Note that this Wiki is a work in progress, items may not be updated or may disappear entirely as the pages are updated.

From SpacialAudio

{ CUSTOM SONG SCORING SCRIPT BY TOBY SHEETS (tobasco@riograndemud.com) FOR SAM USERS

Edited 2/28/03

Overview:

This script overrides SAM's 'balance' field values to provide a more robust and accurate song scoring system. It has so far only been tested using the category-based rotation logic. Here's how it works:

Every time a song plays, this script runs. The very first thing it does is set all song balances to zero. Then it applies a series of rules to each song based on various parameters. Every time a rule is broken, the balance value of the song is incremented by a set value. Once the script has completed its check of rules, the songs all have a final balance. The lower the balance of a song, the better choice that song is for next play because it has broken the fewest rules to the least degree.

When using category based rotation to control your station you typically use a line like:

Cat.QueueBottom('My_Category',smWeighted, prNoRules);

The parameter 'smWeighted' means SAM will choose the song with the lowest balance from the category you specify. Because WE are now controlling the balances of songs we are forcing SAM to make better decisions when selecting songs. You should see much better song selection using this PAL script.

The beauty of this script is that it can be added on to quite easily. I will be creating more rules and adding them to this script as time goes by with suggestions from you all.

Happy broadcasting!

PAL.Loop := True;

// Set some global variables to be used throughout the script

  var
   D, D2, D3 : TDataSet;

  var
   scale, points, increments,
   highest_point, songID, count : Integer;
  var
   lowest_point, point_increment, balance, penalty : Float;
   
  var
   date : DateTime;

  // SET ALL SONG balanceS TO ZERO

  ExecSQL('UPDATE songlist SET balance = 0',[]);

{*******************************************************************************
              START OF RULE 1
*******************************************************************************}

  var current_time :  DateTime = now;
  var three_hours_ago :  DateTime = T['-03:00:00'];

{******************************************************************************
RULE 1: NO SONG REPEATS WITHIN 3 HOURS
This rule applies severe penalties to songs played in the last three hours.
The most recently played tune receives the heaviest penalty. A song played
2 1/2 hours ago receives a lighter penalty. For every second closer to NOW that
a song played, its penalty increases by about 9.25 points.
******************************************************************************}
  Pal.LockExecution;

// SET PENALTY VARIABLES

scale := 100;
points := 100;
increments := 10800;      // the number of sec's in 3 hours
lowest_point := points - ((points / 100) * scale);
highest_point := points;
point_increment := (highest_point - lowest_point) / increments;

D:=Query('SELECT ID, date_played FROM songlist WHERE date_played > :now', [three_hours_ago], True);
D.First;

While Not D.EOF Do
Begin
 // SET NEW balanceS FOR ALL SONGS PLAYED WITHIN LAST 3 HOURS
 date := D['date_played'];
 penalty := ((((date * 86400) - (three_hours_ago * 86400)) * point_increment) + lowest_point);
 ExecSQL('UPDATE songlist SET balance = balance + :penalty WHERE ID = :ID', [penalty, D['ID']]);
 D.Next;
End;

D.Free;
Pal.UnlockExecution;
WriteLn('Rule 1 complete.');

{*******************************************************************************
              END OF RULE 1
*******************************************************************************}

{*******************************************************************************
              START OF RULE 2
*******************************************************************************}

  var lastgenre : String;

{*******************************************************************************
RULE NUMBER 2: DIFFERENT GENRE FOR EACH PLAY
Checks genre of the currently playing song and penalizes all songs that are
from the same genre. This just adds a little variety, especially if you are
running a Top 40 station. For instance it will make sure you don't have two
rap songs back to back, or two pop songs. For this to really work well you 
should take the time to go through all of your songs and fine tune the genre 
tags. Instead of using the "Rock" genre for all of your fast guitar songs, 
sort them into "Hard Rock", "Metal", "Death Metal" etc. Sort your "Rap" genres
into "Hip Hop", "Freestyle", "Gangsta", etc.

Also, this rule only works if you leave SAM on "Ghost Queue" mode, instead
of keeping more than one track in the queue. This rule only applies to the 
currently playing song therefore, if you're adding the 5th song to the queue, 
only the 5th song will be of a different genre from the one currently playing. 
*******************************************************************************}
  Pal.LockExecution;

  penalty := 20;

  // GET GENRE OF LAST SONG PLAYED

  D := Query('SELECT genre FROM songlist ORDER BY date_played DESC LIMIT 1', [], True);
    lastgenre := (D['genre']);
  D.Free;

  // PENALIZE ALL SONGS WITH MATCHING GENRE
  ExecSQL('UPDATE songlist SET balance = balance + :penalty WHERE genre = :lastgenre',[penalty, lastgenre]);

  PAL.UnlockExecution;
  WriteLn('Rule 2 complete.');
{*******************************************************************************
              END OF RULE 2
*******************************************************************************}

{*******************************************************************************
              START OF RULE 3
********************************************************************************
********************************************************************************
RULE 3: NO ARTIST REPEATS WITHIN AN HOUR
All artists that have played in the last 60 minutes will be penalized. Currently
a blanket value of 100 points is assigned to all artists played in the last hour.

(This rule could be made better by checking exactly how long ago that artist was
played and penalizing it differently for each second closer to NOW that the 
artist was played - much like the way RULE 1 penalizes songs.I'll probably play
with this a bit after some coffee.)
*******************************************************************************}

Pal.LockExecution;

penalty := 100;

//GRAB ALL ARTISTS FROM LAST HOUR

D := Query('SELECT DISTINCT artist FROM historylist WHERE date_played > :now ORDER BY date_played DESC',[T['-01:00:00']],True);

D.First;
while not D.EOF do
begin
  ExecSQL('UPDATE songlist SET balance = balance + :penalty WHERE artist = :artist',[penalty, D['artist']]);
  D.Next;
end;

D.Free;

PAL.UnlockExecution;
WriteLn('Rule 3 complete.');

{*******************************************************************************
                 END OF RULE 3
********************************************************************************

{*******************************************************************************
              START OF RULE 4
********************************************************************************
********************************************************************************
RULE 4: CHECK QUEUE LIST
This rule double checks the queue list. Any songs that are already queued will 
be assigned some penalty points (currently set at 100). 
*******************************************************************************}
  Pal.LockExecution;
  penalty := 100;

  //GRAB ALL SONGS FROM QUEUE LIST
  D := Query('SELECT songID FROM queuelist',[],True);
  D.First;
   while not D.EOF do
   begin
     D3 := Query('SELECT artist from songlist WHERE ID = :songID', [D['songID']], True);
     ExecSQL('UPDATE songlist SET balance = balance + :penalty WHERE artist = :artist',[penalty, D3['artist']]);
     D3.Free;
     D.Next;
   end;
  D.Free;

  PAL.UnlockExecution;
  WriteLn('Rule 4 complete.');
{*******************************************************************************
              END OF RULE 4
 ********************************************************************************}

{*******************************************************************************
              START OF RULE 5
********************************************************************************}

var x : Integer;

{*******************************************************************************
RULE 5: Check number of plays
This rule checks how many times each song has played. The more a song has been
played the higher the penalty will be. If a song has never played it will end up
with a lower balance than the one that has played the most.
********************************************************************************}

PAL.LockExecution;

scale := 100;
points := 100;

// Get highest number of song plays
D := Query('SELECT DISTINCT count_played from songlist ORDER BY count_played DESC LIMIT 1', [], True);

increments := D['count_played'];
D.Free;
lowest_point := points - ((points / 100) * scale);
highest_point := points;
point_increment := (highest_point - lowest_point) / increments;

ExecSQL('UPDATE songlist SET balance = balance + (count_played * :point_increment) ', [point_increment]);

PAL.UnlockExecution;
WriteLn('Rule 5 complete.');

{*******************************************************************************
              END OF RULE 5
********************************************************************************}

{*******************************************************************************
              START CHOOSE BEST SONG
********************************************************************************
********************************************************************************
This section grabs the song with the lowest balance. If more than one song 
shares the lowest balance, a random one will be chosen with that score.

This section is currently disabled. If you do not have a complex script set up
for category based rotation, you can enable this section to do the song
selection for you. You will be amazed at the consistent results! To enable this
section, just put a closed bracket at the end of the line below this text, just
after the long series of asterisks.
*******************************************************************************}

  WriteLn('Choosing best song...');
  Pal.LockExecution;

 // GRAB LOWEST FINAL balance

  D := Query('SELECT balance FROM songlist ORDER BY balance ASC', [], True);
    balance := D['balance'];
  D.Free;

  // Count number of songs with this balance
  D:= Query('SELECT filename, balance FROM songlist WHERE balance = :balance ORDER BY RAND() LIMIT 1', [balance], True);

  // Que up selected song 

  Queue.AddFile(D['filename'],ipBottom);
  WriteLn('Adding: ' + D['filename'] + ' to queue.');

  D.Free;
  PAL.UnlockExecution;

{*******************************************************************************
              END CHOOSE BEST SONG
*******************************************************************************}

  // Wait for song to play before running again from the top
  PAL.WaitForPlayCount(1);