In so many games, music speedup is a great way to get the message to the player that they need to hurry up and get things done.
It’d be great if you could simply set a new tempo with a simple GML function, and have the current background music adjust on the fly. Something like audio_sound_set_speed(sound, speed) would be lovely. But it’s not as simple as that in GameMaker, as I found out recently.
Here’s how I implemented a speedup for my GMLTetris project:
First, I created two music tracks, one at normal speed, and one at double speed, and added them to the game project as sound assets.
Everything else is just programming:
if <condition> {stop slow_music; start fast_music;}
This is easy enough, the trickiest part is probably getting the condition right to switch tracks, but depending on the game, that condition could be very simple, too. The only real complication is that if you’re checking the condition repeatedly, as you normally would every Step, you only want to trigger the changeover once. So to do that, set up a variable to track whether the switch has happened already, and check it, too, even if the condition that triggers the changeover continues to remain true on successive steps.
if <condition> && !music_switched {stop slow_music; start fast_music; music_switched = true;}
The music speedup that happens in a game like Super Mario Bros., where the music speedup occurs when the level timer hits 100, is a typical example of such a technique. If you only need to do a single, one-way switch, this is all you need.
If your game needs to switch back and forth between slow and fast music, your conditional needs to be more sophisticated.
if <condition>
{
if !<fast_music_already_playing>
{stop slow_music; start fast_music;}
}
else
{
if !<slow_music_already_playing>
{stop fast_music; start slow_music;}
}Here, because the game can switch multiple times, when the condition check happens, we can’t get away with a music_switched variable that changes one time. What we need to do is check to see if the music we need to switch to is already playing, and if not, stop the current music and switch to the other music.
One thing to keep in mind, this basic technique will start the fast music from the beginning of the track. This might be what you want, but it would also be good if you could start the fast music at the position where the slow music was, for a seamless transition.
GML has the functions to do this: audio_sound_get_track_position() and audio_sound_set_track_position(). But in order to make use of them, we need to do a bit more work.
First, since the gml functions return the absolute time position of the track, and since two tracks play at different speeds, we need to adjust the position proportionately when we switch tracks, so that the position is at the same position percentage-wise. This is actually easy, as long as we know the tempo change, which we do. Since the fast track is double speed, we can easily calculate the equivalent position in the other track by multiplying or dividing by 2.
Slow to fast: position *= 0.5;
Fast to slow: position *= 2;
Where I ran into trouble was, I needed to be able to switch both ways. It seemed like it should be simple — just check whether the desired track is already playing, and if not, get the position of the current track, adjust it proportionately, start the desired track, set the position. Easy, right?
Let’s look at it in pseudocode first:
if <condition to switch to fast music>
{
if audio_is_playing(slow_music)
{get position; stop slow music; start fast music; set position;}
}
else
{
if audio_is_playing(fast_music)
{get position; stop fast music; start slow music; set position;}
}This was when I discovered that audio_play_sound() returns a handle for identifying the specific instance of the sound that is playing. This is necessary to use to set the track position of the playing sound. You can’t just set the position for the sound_index; you have to set it for the specific handle of the currently playing instance of the sound. If you set the track position for the sound_index, any time that sound resource is played in the future, it will start from that position.
///Create Event:bgm = audio_play_sound(slow_music, 10, true);
///Step Event:if <condition>{if audio_is_playing(slow_music){var pos = audio_sound_get_track_position(bgm);audio_stop_sound(bgm);bgm = audio_play_sound(fast_music, 10, true);audio_sound_set_track_position(bgm, pos * 0.5);}}else{if audio_is_playing(fast_music){var pos = audio_sound_get_track_position(bgm);audio_stop_sound(bgm);bgm = audio_play_sound(slow_music, 10, true);audio_sound_set_track_position(bgm, pos * 2);}}
I also discovered that detecting which track is playing with audio_is_playing() does not work for this purpose. I still don’t have a clear understanding of what was happening in my code, but some debugging showed that my track position calculations were being distorted by being called multiple times. This doesn’t make sense to me because the song should no longer be playing after the first step when the switch condition is met. But my theory is that since the audio is played in another process from the main program, there’s some messaging going between the two processes asynchronously, and as a result audio_sound_is_playing() can still return true a step later, even after the message is sent to stop the track playing.
By trying to set the track point multiple times in quick succession, weird and unexpected results happened, and the tracks switched but did not set to the correct position.
So I had to come up with a surer method of knowing which music is playing.
Debugging was tricky, since I couldn’t tell from listening where the audio position was. To aid debugging, I drew the position of the playing track to the screen, and then I was able to see that the position was not being set correctly as expected. Somehow, switching from slow to fast would drop the track back from about 10 seconds to 2 seconds, and then switching from fast to slow would jump from 2 seconds to 38 seconds. It wasn’t consistently the same timing, but depending on when the switch was triggered, it would jump around, seemingly at random, but within a range of a second or so around these positions.
I couldn’t figure out why that was happening, so I tried using show_debug_message() and watched the output console, and saw that the track position would update 2 or 3 times when the tracks switched; I was expecting it to only update once.
This is what clued me in to what I believe was happening due to the multiple processes communicating asynchronously.
The solution I used in the end was easy and simple: instead of checking which track was currently playing using the audio functions to directly check whether it was playing, and then switching from slow to fast or vice versa based on the currently-playing audio asset, I just added a new variable, condition_previous, and compared condition to condition_previous, and made the switch happen only when the current condition didn’t match condition_previous. This only happens in one step, when the condition changes from false to true, or vice versa, and so the track position is set once, when the bgm switches tracks and syncs up the new track to where the old track left off.
switch_previous = switch;
switch = <condition to check for switching to the fast music>;
if switch && !switch_previous
{
var pos = audio_sound_get_track_position(bgm);
audio_stop_sound(bgm);
bgm = audio_play_sound(fast_music, 10, true);
audio_sound_set_track_position(bgm, pos * 0.5)
}
else
{
if !switch && switch_previous
{
var pos = audio_sound_get_track_position(bgm);
audio_stop_sound(bgm);
bgm = audio_play_sound(slow_music, 10, true);
audio_sound_set_track_position(bgm, pos * 2);
}
}This works, because it guarantees that the condition checks will be accurate, as they do not depend on checking the status of the audio playing in another thread.