Want to play 1 of 3 tracks depending on current level

Question

I want to play a gameplay music track depending on what the current level is.

E.g.

1 - Play track 1

2 - Play track 1

3 - Play track 2

4 - Play track 2

5 - Play track 3

repeat...

6 - Play track 1

7 - Play track 1

8 - Play track 2

9 - Play track 2

10 - Play track 3

This is what I have, but problem is track 2 will be used at level 6 when it should be track 1.

public static function playGameplayMusic(waveId:Int):Void
{
    var gamePlayTrackId:Int;

    if (waveId % 5 == 0) {
        gamePlayTrackId = 3;
    } else if (waveId % 3 == 0 || waveId % 4 == 0) {
        gamePlayTrackId = 2;
    } else {
        gamePlayTrackId = 1;
    }

    trace('playing gameplay track: ' + gamePlayTrackId);

    SoundPlayer.playMusicByName('gameplay/' + gamePlayTrackId, false);
}

Update:

Went with this. Thanks for all your contributions!

public static function playGameplayMusic(waveId:Int):Void
{
    var gamePlayTrackId:Int = Math.ceil(((waveId - 1) % 5 + 1) / 2);

    SoundPlayer.playMusicByName('gameplay/' + gamePlayTrackId, false);
}

Answer 1

You need to combine a modulo (for the wrap-around) and a division (for the duplication of tracks). With some testing I got to:

static function track(level:Int):Int
{
    return Math.ceil(((level - 1) % 5 + 1) / 2);
}

(live example on Try Haxe)

The idea is to divide a wrap-around, adjusting for no zeros. There might be a way to simplify this though.

Answer 2

This question would probably be better suited at StackOverflow.

That being said: You are using the wrong modulo. Pseudocode:

n = waveID % 5;
n == 0 => Track3
n == 1 || n == 2 => Track1
n == 3 || n == 4 => Track2

If you use modulo you always have to use the size of you collection/repeating pattern (in this case 5). Furthermore I would recommend enumerating the levels beginning at 0, which shifts the above code around to:

n = waveID % 5;
n == 0 || n == 1 => Track1
n == 2 || n == 3 => Track2
n == 4 => Track3

The cleanest way to do this part is probably (Edit: adjusted to HAXE and removed case drop, thanks to jonasmalacofilho):

var n = waveID % 5;
switch(n){
case 0:
  gamePlayTrackId = 1;
case 1:
  gamePlayTrackId = 1;
case 2:
  gamePlayTrackId = 2;
case 3:
  gamePlayTrackId = 2;
case 4:
  gamePlayTrackId = 3;
default:
  //throw exception
}

Answer 3

I don't know enough haxe to make this code better, but I would probably just do

var tracklist = [3, 1, 1, 2, 2];
gamePlayTrackId = tracklist[waveId % 5];

You can probably improve this by making tracklist static or any number of ways.
I'm still learning though, so look at the comments before you implement anything.

Answer 4

You're getting problems with higher numbers being multiples of more than one of the numbers you check. 6 is not just going to trip the last else, it will also trip the % 3 == 0 one. I might do it this way:

StartGame()
{
    m_musicLevel = 1;
    m_track = playGameplayMusic(1);
}

NextLevel()
{
    m_musicLevel++;
    if(m_musicLevel > 5)
    {
        m_musicLevel = 1;
    }
    m_track = playGameplayMusic(m_musicLevel);
}

This means your playGameplayMusic function will only ever see levels 1-5. It's not super-elegant, but it's easy to understand and it will work.

Answer 5

If your levels are procedural / infinite, then the using the chosen method is good.

If you have a limited set of levels (i.e., only 10), then just associate the track choice with the level, hard-coded or preferably stored in the data that is loaded per level.