mpo
/
VVVVVV
mirror of https://github.com/TerryCavanagh/VVVVVV.git
1
0
Fork 0
Code Issues Releases Wiki Activity
VVVVVV/desktop_version/src/Music.cpp

378 lines
8.1 KiB
C++
Raw Normal View History

Clean up and prevent unnecessary qualifiers to self By "unnecessary qualifiers to self", I mean something like using the 'game.' qualifier for a variable on the Game class when you're inside a function on the Game class itself. This patch is to enforce consistency as most of the code doesn't have these unnecessary qualifiers. To prevent further unnecessary qualifiers to self, I made it so the extern in each header file can be omitted by using a define. That way, if someone writes something referring to 'game.' on a Game function, there will be a compile error. However, if you really need to have a reference to the global name, and you're within the same .cpp file as the implementation of that object, you can just do the extern at the function-level. A good example of this is editorinput()/editorrender()/editorlogic() in editor.cpp. In my opinion, they should probably be split off into their own separate file because editor.cpp is getting way too big, but this will do for now.
2020-09-28 04:15:06 +02:00
#define MUSIC_DEFINITION
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
#include "Music.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include <SDL.h>
#include <stdio.h>
Separate includes into sections and alphabetize them Okay, so basically here's the include layout that this game now consistently uses: [The "main" header file, if any (e.g. Graphics.h for Graphics.cpp)] [blank line] [All system includes, such as tinyxml2/physfs/utfcpp/SDL] [blank line] [All project includes, such as Game.h/Entity.h/etc.] And if applicable, another blank line, and then some special-case include screwy stuff (take a look at editor.cpp or FileSystemUtils.cpp, for example, they have ifdefs and defines with their includes).
2020-07-19 21:43:29 +02:00
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include "BinaryBlob.h"
Un-fix using-PPPPPP-while-MMMMMM-present for custom levels As discussed earlier, some custom levels have taken advantage of the fact that songs 0 and 7 loop and also fade in when using PPPPPP while having an mmmmmm.vvv file present.
2020-04-04 00:37:59 +02:00
#include "Map.h"
Remove unnecessary includes from header files Including a header file inside another header file means a bunch of files are going to be unnecessarily recompiled whenever that inner header file is changed. So I minimized the amount of header files included in a header file, and only included the ones that were necessary (system includes don't count, I'm only talking about includes from within this project). Then the includes are only in the .cpp files themselves. This also minimizes problems such as a NO_CUSTOM_LEVELS build failing because some file depended on an include that got included in editor.h, which is another benefit of removing unnecessary includes from header files.
2020-07-19 21:05:41 +02:00
#include "UtilityClass.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
void songend();
Don't reset entire musicclass when mounting and unmounting assets musicclass::init() re-initializes every attribute of musicclass unnecessarily, when initialization should be put in a constructor instead. This is bad, because music.init() gets called whenever we enter and exit a custom level that has assets. Otherwise, this would result in a bug where music.usingmmmmmm would be reset, causing you to revert to PPPPPP on the title screen whenever you enter a level with MMMMMM selected and exit it. This also causes a confusing desync between game.usingmmmmmm and music.usingmmmmmm since the values of the two variables are now different (these duplicate variables should probably be removed, too, and a lot of other duplicate variables like these exist, too, which are a real headache). Which means despite MMMMMM playing on the title screen, exiting the game and re-launching it will play PPPPPP instead. What's even more is that going to game options and switching to PPPPPP will play PPPPPP, but afterwards launching and re-entering will play MMMMMM. Again, having duplicate variables is very bad, and should probably be fixed, but that's a separate patch.
2020-11-13 00:55:58 +01:00
musicclass::musicclass()
{
safeToProcessMusic= false;
m_doFadeInVol = false;
musicVolume = MIX_MAX_VOLUME;
FadeVolAmountPerFrame = 0;
currentsong = 0;
nicechange = -1;
nicefade = false;
resumesong = 0;
quick_fade = true;
songStart = 0;
songEnd = 0;
Mix_HookMusicFinished(&songend);
usingmmmmmm = false;
}
Allow using help/graphics/music/game/key/map/obj everywhere This commit makes `help`, `graphics`, `music`, `game`, `key`, `map`, and `obj` essentially static global objects that can be used everywhere. This is useful in case we ever need to add a new function in the future, so we don't have to bother with passing a new argument in which means we have to pass a new argument in to the function that calls that function which means having to pass a new argument into the function that calls THAT function, etc. which is a real headache when working on fan mods of the source code. Note that this changes NONE of the existing function signatures, it merely just makes those variables accessible everywhere in the same way `script` and `ed` are. Also note that some classes had to be initialized after the filesystem was initialized, but C++ would keep initializing them before the filesystem got initialized, because I *had* to put them at the top of `main.cpp`, or else they wouldn't be global variables. The only way to work around this was to use entityclass's initialization style (which I'm pretty sure entityclass of all things doesn't need to be initialized this way), where you actually initialize the class in an `init()` function, and so then you do `graphics.init()` after the filesystem initialization, AFTER doing `Graphics graphics` up at the top. I've had to do this for `graphics` (but only because its child GraphicsResources `grphx` needs to be initialized this way), `music`, and `game`. I don't think this will affect anything. Other than that, `help`, `key`, and `map` are still using the C++-intended method of having ClassName::ClassName() functions.
2020-01-29 08:35:03 +01:00
void musicclass::init()
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix no-draw frames when exiting a level with custom assets When exiting a level, music.init() gets called again, and every time it gets called after the first time it gets called, it will free all music tracks. To do so, it calls Mix_FreeMusic(). Unfortunately, if there is music fading, Mix_FreeMusic() will call SDL_Delay(), which will result in annoying no-draw frames. Meaning, the screen freezes and doesn't draw anything, and has to wait a bit before continuing. Here's the relevant piece of code from SDL2_mixer's music.c: if (music == music_playing) { /* Wait for any fade out to finish */ while (music->fading == MIX_FADING_OUT) { Mix_UnlockAudio(); SDL_Delay(100); Mix_LockAudio(); } if (music == music_playing) { music_internal_halt(); } } This is especially annoying if you're a TASer, because no-draw frames in a libTAS movie aren't guaranteed to last for a consistent number of frames when you change your inputs around. After this patch, as long as your computer can unmount and re-mount assets fast enough (it doesn't seem like mine can, unfortunately), then you won't get any freezes when exiting a level that has custom assets. (This freeze didn't happen when loading a level because the title screen music fadeout upon pressing ACTION had enough time to fully complete before the level got loaded.)
2020-12-28 21:33:54 +01:00
for (size_t i = 0; i < soundTracks.size(); ++i)
{
Don't leak sounds/music
2020-06-07 22:11:48 +02:00
Mix_FreeChunk(soundTracks[i].sound);
}
Clear soundTracks and musicTracks on musicclass::init
2020-01-30 15:50:19 +01:00
soundTracks.clear();
Fix no-draw frames when exiting a level with custom assets When exiting a level, music.init() gets called again, and every time it gets called after the first time it gets called, it will free all music tracks. To do so, it calls Mix_FreeMusic(). Unfortunately, if there is music fading, Mix_FreeMusic() will call SDL_Delay(), which will result in annoying no-draw frames. Meaning, the screen freezes and doesn't draw anything, and has to wait a bit before continuing. Here's the relevant piece of code from SDL2_mixer's music.c: if (music == music_playing) { /* Wait for any fade out to finish */ while (music->fading == MIX_FADING_OUT) { Mix_UnlockAudio(); SDL_Delay(100); Mix_LockAudio(); } if (music == music_playing) { music_internal_halt(); } } This is especially annoying if you're a TASer, because no-draw frames in a libTAS movie aren't guaranteed to last for a consistent number of frames when you change your inputs around. After this patch, as long as your computer can unmount and re-mount assets fast enough (it doesn't seem like mine can, unfortunately), then you won't get any freezes when exiting a level that has custom assets. (This freeze didn't happen when loading a level because the title screen music fadeout upon pressing ACTION had enough time to fully complete before the level got loaded.)
2020-12-28 21:33:54 +01:00
// Before we free all the music: stop playing music, else SDL2_mixer
// will call SDL_Delay() if we are fading, resulting in no-draw frames
Mix_HaltMusic();
for (size_t i = 0; i < musicTracks.size(); ++i)
{
Don't leak sounds/music
2020-06-07 22:11:48 +02:00
Mix_FreeMusic(musicTracks[i].m_music);
}
Clear soundTracks and musicTracks on musicclass::init
2020-01-30 15:50:19 +01:00
musicTracks.clear();
Don't leak binaryBlob
2020-06-07 22:11:35 +02:00
musicReadBlob.clear();
Revert "Add destructor for SoundTrack/MusicTrack (and explicitly define move constructor to prevent double-free)" This reverts commit 2f760af4394b3279716e78ee17d8414f860b295e.
2020-06-07 21:49:18 +02:00
soundTracks.push_back(SoundTrack( "sounds/jump.wav" ));
soundTracks.push_back(SoundTrack( "sounds/jump2.wav" ));
soundTracks.push_back(SoundTrack( "sounds/hurt.wav" ));
soundTracks.push_back(SoundTrack( "sounds/souleyeminijingle.wav" ));
soundTracks.push_back(SoundTrack( "sounds/coin.wav" ));
soundTracks.push_back(SoundTrack( "sounds/save.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crumble.wav" ));
soundTracks.push_back(SoundTrack( "sounds/vanish.wav" ));
soundTracks.push_back(SoundTrack( "sounds/blip.wav" ));
soundTracks.push_back(SoundTrack( "sounds/preteleport.wav" ));
soundTracks.push_back(SoundTrack( "sounds/teleport.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew1.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew2.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew3.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew4.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew5.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crew6.wav" ));
soundTracks.push_back(SoundTrack( "sounds/terminal.wav" ));
soundTracks.push_back(SoundTrack( "sounds/gamesaved.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crashing.wav" ));
soundTracks.push_back(SoundTrack( "sounds/blip2.wav" ));
soundTracks.push_back(SoundTrack( "sounds/countdown.wav" ));
soundTracks.push_back(SoundTrack( "sounds/go.wav" ));
soundTracks.push_back(SoundTrack( "sounds/crash.wav" ));
soundTracks.push_back(SoundTrack( "sounds/combine.wav" ));
soundTracks.push_back(SoundTrack( "sounds/newrecord.wav" ));
soundTracks.push_back(SoundTrack( "sounds/trophy.wav" ));
soundTracks.push_back(SoundTrack( "sounds/rescue.wav" ));
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#ifdef VVV_COMPILEMUSIC
binaryBlob musicWriteBlob;
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
#define FOREACH_TRACK(track_name) musicWriteBlob.AddFileToBinaryBlob(track_name);
TRACK_NAMES
#undef FOREACH_TRACK
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
musicWriteBlob.writeBinaryBlob("data/BinaryMusic.vvv");
#endif
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
num_mmmmmm_tracks = 0;
num_pppppp_tracks = 0;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
if (!musicReadBlob.unPackBinary("mmmmmm.vvv"))
{
mmmmmm = false;
usingmmmmmm=false;
bool ohCrap = musicReadBlob.unPackBinary("vvvvvvmusic.vvv");
SDL_assert(ohCrap && "Music not found!");
}
else
{
mmmmmm = true;
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
int index;
SDL_RWops *rw;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
#define FOREACH_TRACK(track_name) \
index = musicReadBlob.getIndex(track_name); \
Check index of tracks in musicclass::init() It's possible that musicReadBlob.getIndex() could return the sentinel value of -1 in case the header with that name is invalid, in which case we should simply not do anything. Otherwise it'll lead to segfaults. I opted to do the full bounds check just to be safe, too. For further safety, I hardcoded the max number of headers, 128, less, so 128 is copy-pasted less and in the future if it needs to be changed it'll only have to be changed in one place.
2020-08-14 11:02:16 +02:00
if (index >= 0 && index < musicReadBlob.max_headers) \
{ \
rw = SDL_RWFromMem(musicReadBlob.getAddress(index), musicReadBlob.getSize(index)); \
Check `rw` in musicclass::init() It's possible that SDL_RWFromMem could return NULL, and if this is the case, then we really shouldn't be passing it to MusicTrack().
2020-08-14 11:23:41 +02:00
if (rw == NULL) \
{ \
printf("Unable to read music file header: %s\n", SDL_GetError()); \
} \
else \
{ \
musicTracks.push_back(MusicTrack( rw )); \
} \
Check index of tracks in musicclass::init() It's possible that musicReadBlob.getIndex() could return the sentinel value of -1 in case the header with that name is invalid, in which case we should simply not do anything. Otherwise it'll lead to segfaults. I opted to do the full bounds check just to be safe, too. For further safety, I hardcoded the max number of headers, 128, less, so 128 is copy-pasted less and in the future if it needs to be changed it'll only have to be changed in one place.
2020-08-14 11:02:16 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
TRACK_NAMES
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Check index of tracks in musicclass::init() It's possible that musicReadBlob.getIndex() could return the sentinel value of -1 in case the header with that name is invalid, in which case we should simply not do anything. Otherwise it'll lead to segfaults. I opted to do the full bounds check just to be safe, too. For further safety, I hardcoded the max number of headers, 128, less, so 128 is copy-pasted less and in the future if it needs to be changed it'll only have to be changed in one place.
2020-08-14 11:02:16 +02:00
num_mmmmmm_tracks += musicTracks.size();
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
Parse extra headers from binary blob Not just the ones that contain specific names.
2020-07-01 00:35:50 +02:00
const std::vector<int> extra = musicReadBlob.getExtra();
for (size_t i = 0; i < extra.size(); i++)
{
Fix variables shadowing other variables In C++, when you have two variables in different scopes with the same name, the inner scope wins. Except you have to be really careful because sometimes they're not (#507). So it's better to just always have unique variable names and make sure to never clash a name with a variable in an outer scope - after all, the C++ compiler and standard might be fine with it, but that doesn't mean humans can't make mistakes reading or writing it. Usually I just renamed the inner variables, but for tx/ty in editor.cpp, I just got rid of the ridiculous overcomplicated modulo calculations and replaced them with actual simple modulo calculations, because the existing ones were just ridiculous. Actually, somebody ought to find every instance of the overcomplicated modulos and replace them with the actual good ones, because it's really stupid, quite frankly...
2020-11-04 09:37:46 +01:00
const int& index_ = extra[i];
rw = SDL_RWFromMem(musicReadBlob.getAddress(index_), musicReadBlob.getSize(index_));
Parse extra headers from binary blob Not just the ones that contain specific names.
2020-07-01 00:35:50 +02:00
musicTracks.push_back(MusicTrack( rw ));
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
num_mmmmmm_tracks++;
Parse extra headers from binary blob Not just the ones that contain specific names.
2020-07-01 00:35:50 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
bool ohCrap = musicReadBlob.unPackBinary("vvvvvvmusic.vvv");
SDL_assert(ohCrap && "Music not found!");
}
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
int index;
SDL_RWops *rw;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
TRACK_NAMES
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
De-duplicate track names Instead of copy-pasting the entire list three times over, why not put it in an easy to use "X" macro?
2020-07-01 00:17:02 +02:00
#undef FOREACH_TRACK
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Check index of tracks in musicclass::init() It's possible that musicReadBlob.getIndex() could return the sentinel value of -1 in case the header with that name is invalid, in which case we should simply not do anything. Otherwise it'll lead to segfaults. I opted to do the full bounds check just to be safe, too. For further safety, I hardcoded the max number of headers, 128, less, so 128 is copy-pasted less and in the future if it needs to be changed it'll only have to be changed in one place.
2020-08-14 11:02:16 +02:00
num_pppppp_tracks += musicTracks.size() - num_mmmmmm_tracks;
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
Parse extra headers from binary blob Not just the ones that contain specific names.
2020-07-01 00:35:50 +02:00
const std::vector<int> extra = musicReadBlob.getExtra();
for (size_t i = 0; i < extra.size(); i++)
{
Fix variables shadowing other variables In C++, when you have two variables in different scopes with the same name, the inner scope wins. Except you have to be really careful because sometimes they're not (#507). So it's better to just always have unique variable names and make sure to never clash a name with a variable in an outer scope - after all, the C++ compiler and standard might be fine with it, but that doesn't mean humans can't make mistakes reading or writing it. Usually I just renamed the inner variables, but for tx/ty in editor.cpp, I just got rid of the ridiculous overcomplicated modulo calculations and replaced them with actual simple modulo calculations, because the existing ones were just ridiculous. Actually, somebody ought to find every instance of the overcomplicated modulos and replace them with the actual good ones, because it's really stupid, quite frankly...
2020-11-04 09:37:46 +01:00
const int& index_ = extra[i];
rw = SDL_RWFromMem(musicReadBlob.getAddress(index_), musicReadBlob.getSize(index_));
Parse extra headers from binary blob Not just the ones that contain specific names.
2020-07-01 00:35:50 +02:00
musicTracks.push_back(MusicTrack( rw ));
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
num_pppppp_tracks++;
Parse extra headers from binary blob Not just the ones that contain specific names.
2020-07-01 00:35:50 +02:00
}
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
}
void songend()
{
Clean up and prevent unnecessary qualifiers to self By "unnecessary qualifiers to self", I mean something like using the 'game.' qualifier for a variable on the Game class when you're inside a function on the Game class itself. This patch is to enforce consistency as most of the code doesn't have these unnecessary qualifiers. To prevent further unnecessary qualifiers to self, I made it so the extern in each header file can be omitted by using a define. That way, if someone writes something referring to 'game.' on a Game function, there will be a compile error. However, if you really need to have a reference to the global name, and you're within the same .cpp file as the implementation of that object, you can just do the extern at the function-level. A good example of this is editorinput()/editorrender()/editorlogic() in editor.cpp. In my opinion, they should probably be split off into their own separate file because editor.cpp is getting way too big, but this will do for now.
2020-09-28 04:15:06 +02:00
extern musicclass music;
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
music.songEnd = SDL_GetPerformanceCounter();
music.currentsong = -1;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
void musicclass::play(int t, const double position_sec /*= 0.0*/, const int fadein_ms /*= 3000*/)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
if (mmmmmm && usingmmmmmm)
{
Check divisor in musicclass::play() Previously, it was assuming that the number of PPPPPP/MMMMMM tracks would always be 16, since if that wasn't the case... then the game would rudely and abruptly segfault when attempting to load the file. Huh. But now that the game properly deals with invalid headers, it's possible for the number of tracks to be 0. So I'll need to remove this assumption.
2020-08-14 11:15:09 +02:00
// Don't conjoin this if-statement with the above one...
if (num_mmmmmm_tracks > 0)
{
t %= num_mmmmmm_tracks;
}
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
}
Check divisor in musicclass::play() Previously, it was assuming that the number of PPPPPP/MMMMMM tracks would always be 16, since if that wasn't the case... then the game would rudely and abruptly segfault when attempting to load the file. Huh. But now that the game properly deals with invalid headers, it's possible for the number of tracks to be 0. So I'll need to remove this assumption.
2020-08-14 11:15:09 +02:00
else if (num_pppppp_tracks > 0)
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
{
t %= num_pppppp_tracks;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Fix whitespace inconsistency in musicclass::play() Spaces are used around operators and keywords accordingly, and blank lines are used to visually separate lines of code from each other.
2021-01-04 08:20:35 +01:00
if (mmmmmm && !usingmmmmmm)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Account for extra tracks in musicclass::play() Since each soundtrack is no longer guaranteed to be 16, we'll have to account for their different lengths when playing music.
2020-07-01 02:08:37 +02:00
t += num_mmmmmm_tracks;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix whitespace inconsistency in musicclass::play() Spaces are used around operators and keywords accordingly, and blank lines are used to visually separate lines of code from each other.
2021-01-04 08:20:35 +01:00
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
safeToProcessMusic = true;
Clean up music handling to one place Previously, setting the actual volume of the music was all over the place. Which isn't bad, but when I added being able to press N to mute the music specifically, I should've made it so that there would be a volume variable somewhere that the game looks at if the music is unmuted, and otherwise sets the actual volume to 0 if the game is muted. This resulted in things like #400 and #505 and having to add a bunch of special-cased checks like game.musicmuted and game.completestop. But instead of adding a bunch of special-case code, just make it so there's a central place where Mix_VolumeMusic() actually gets called, and if some piece of code wants to set the music volume, they can set music.musicVolume. But the music handling logic in main.cpp gets the final say on whether to listen to music.musicVolume, or to mute the game entirely. This is how the music handling code should have been from the start (when pressing N to mute the music was added). Fixes #505.
2020-10-11 08:42:02 +02:00
musicVolume = MIX_MAX_VOLUME;
Fix whitespace inconsistency in musicclass::play() Spaces are used around operators and keywords accordingly, and blank lines are used to visually separate lines of code from each other.
2021-01-04 08:20:35 +01:00
Fix regression with playing the same track after it fades out With commit 48313169b68f8ef8e6f83f29830b789061219ffd (PR #453), AllyTally added a single-case patch for a regression, instead of fixing it at its root cause. In fact, that commit only fixes the music if Presenting VVVVVV is playing while exiting to the menu, not if you enter a level that plays Presenting VVVVVV - so it only fixes it going one way, and not going the other way around; neither fixing also all the other cases this could happen. It doesn't, say, fix the case where you are exited to the menu automatically after collecting the last crewmate in the level (or if the level calls gamestate 1013 itself), which is what happens in my MIRA-VIU TAS video at the end, and which I noted in the description of that video ( https://www.youtube.com/watch?v=OYQO4ePbYW4&t=111 ). So, the problem here is that when musicclass::play() is called, it sees that currentsong is the same as its input, and decides that since the music is already playing, it shouldn't play the music again. Thus, the music fades out, and we get silence instead of the music playing again. But I said this was a regression. Why didn't this happen in 2.2? Well, it's because of the fact that 2.2 sets currentsong to -1 (no music playing at all) immediately when starting a fadeout, and not when the fadeout completes (commit facb079b3597b380f876537523cd351a0e637b62, PR #316). As you can imagine, this discrepancy could lead to bugs, given that the game would think that music wasn't playing when in actuality it was, but fixing this bug could also break code that expected this wrong behavior. And in this case, it has. So to properly fix the root cause of this, instead of naïvely single-case patching out every case that comes up randomly, in musicclass::play(), the function will now ignore if the input given is the same as currentsong if the music is currently fading out.
2021-01-04 08:04:20 +01:00
if (currentsong == t && Mix_PlayingMusic() != MIX_FADING_OUT)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Invert currentsong check and un-nest rest of function This removes an indentation level, and makes it easier to reason about the function since you essentially now view it as the function returning right there.
2021-01-04 08:22:00 +01:00
return;
}
Invert t comparison with -1 and un-nest rest of function This is also another conditional where the rest of the function is nested. Furthermore, in order to not repeat ourselves, I've also decided to unconditionally assign currentsong to t, because if t is -1 currentsong gets assigned to -1 anyway - so it's the same thing, but it's much easier to see and think about.
2021-01-04 08:23:46 +01:00
currentsong = t;
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
if (t == -1)
{
return;
}
if (!INBOUNDS_VEC(t, musicTracks))
{
puts("play() out-of-bounds!");
currentsong = -1;
return;
}
if (currentsong == 0 || currentsong == 7 || (!map.custommode && (currentsong == 0+num_mmmmmm_tracks || currentsong == 7+num_mmmmmm_tracks)))
{
// Level Complete theme, no fade in or repeat
if (Mix_FadeInMusicPos(musicTracks[t].m_music, 0, 0, position_sec) == -1)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
printf("Mix_FadeInMusicPos: %s\n", Mix_GetError());
Invert t comparison with -1 and un-nest rest of function This is also another conditional where the rest of the function is nested. Furthermore, in order to not repeat ourselves, I've also decided to unconditionally assign currentsong to t, because if t is -1 currentsong gets assigned to -1 anyway - so it's the same thing, but it's much easier to see and think about.
2021-01-04 08:23:46 +01:00
}
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
}
else
{
if (Mix_FadingMusic() == MIX_FADING_OUT)
{
// We're already fading out
nicechange = t;
nicefade = true;
currentsong = -1;
Fix whitespace inconsistency in musicclass::play() Spaces are used around operators and keywords accordingly, and blank lines are used to visually separate lines of code from each other.
2021-01-04 08:20:35 +01:00
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
if (quick_fade)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
Mix_FadeOutMusic(500); // fade out quicker
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
quick_fade = true;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
}
else if (Mix_FadeInMusicPos(musicTracks[t].m_music, -1, fadein_ms, position_sec) == -1)
{
printf("Mix_FadeInMusicPos: %s\n", Mix_GetError());
}
}
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
Unindent musicclass::play() from previous two commits As always, the actual unindenting happens in a separate commit in order to minimize diff noise.
2021-01-04 08:26:05 +01:00
songStart = SDL_GetPerformanceCounter();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
void musicclass::resume(const int fadein_ms /*= 0*/)
{
const double offset = static_cast<double>(songEnd - songStart);
const double frequency = static_cast<double>(SDL_GetPerformanceFrequency());
const double position_sec = offset / frequency;
play(resumesong, position_sec, fadein_ms);
}
void musicclass::fadein()
{
resume(3000); // 3000 ms fadein
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
void musicclass::haltdasmusik()
{
Mix_HaltMusic();
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
resumesong = currentsong;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
void musicclass::silencedasmusik()
{
musicVolume = 0;
}
void musicclass::fadeMusicVolumeIn(int ms)
{
m_doFadeInVol = true;
FadeVolAmountPerFrame = MIX_MAX_VOLUME / (ms / 33);
}
Clean up don't-quick-fade signaling First, the variable has been inverted, because it's bad practice to have booleans with negative names. Secondly, instead of magically setting a signaling variable when calling fadeout(), fadeout() now has a parameter to set the quick_fade attribute, which is much cleaner than doing the magical assignment that could potentially look unrelated.
2020-11-06 09:51:04 +01:00
void musicclass::fadeout(const bool quick_fade_ /*= true*/)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Mix_FadeOutMusic(2000);
Fix resumemusic/musicfadein not working It seems like they were unfinished. This commit makes them properly work. When a track is stopped with stopmusic() or musicfadeout(), resumemusic() will resume from where the track stopped. musicfadein() does the same but does it with a gradual fade instead of suddenly playing it at full volume. I changed several interfaces around for this. First, setting currentsong to -1 when music is stopped is handled in the hook callback that gets called by SDL_mixer whenever the music stops. Otherwise, it'd be problematic if currentsong was set to -1 when the song starts fading out instead of when the song actually ends. Also, music.play() has a few optional arguments now, to reduce the copying-and-pasting of music code. Lastly, we have to roll our own tracker of music length by using SDL_GetPerformanceCounter(), because there's no way to get the music position if a song fades out. (We could implicitly keep the music position if we abruptly stopped the song using Mix_PauseMusic(), and resume it using Mix_ResumeMusic(), but ignoring the fact that those two functions are also used on the unfocus-pause (which, as it turns out, is basically a non-issue because the unfocus-pause can use some other functions), there's no equivalent for fading out, i.e. there's no "fade out and pause when it fully fades out" function in SDL_mixer.) And then we have to account for the unfocus-pause in our manual tracker. Other than that, these commands are now fully functional.
2020-06-27 10:31:09 +02:00
resumesong = currentsong;
Clean up don't-quick-fade signaling First, the variable has been inverted, because it's bad practice to have booleans with negative names. Secondly, instead of magically setting a signaling variable when calling fadeout(), fadeout() now has a parameter to set the quick_fade attribute, which is much cleaner than doing the magical assignment that could potentially look unrelated.
2020-11-06 09:51:04 +01:00
quick_fade = quick_fade_;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
void musicclass::processmusicfadein()
{
musicVolume += FadeVolAmountPerFrame;
if (musicVolume >= MIX_MAX_VOLUME)
{
m_doFadeInVol = false;
}
}
void musicclass::processmusic()
{
if(!safeToProcessMusic)
{
return;
}
Change nicefade to bool instead of int If it's treated like a bool, why shouldn't it be one?
2020-11-06 09:20:58 +01:00
if (nicefade && Mix_PlayingMusic() == 0)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
play(nicechange);
Change nicefade to bool instead of int If it's treated like a bool, why shouldn't it be one?
2020-11-06 09:20:58 +01:00
nicechange = -1;
nicefade = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
if(m_doFadeInVol)
{
processmusicfadein();
}
}
void musicclass::niceplay(int t)
{
// important: do nothing if the correct song is playing!
Fix niceplay() check having hardcoded number of MMMMMM tracks The number of MMMMMM tracks is no longer guaranteed to be 16 anymore, and instead it should use num_mmmmmm_tracks.
2020-11-06 09:04:57 +01:00
if((!mmmmmm && currentsong!=t) || (mmmmmm && usingmmmmmm && currentsong!=t) || (mmmmmm && !usingmmmmmm && currentsong!=t+num_mmmmmm_tracks))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Don't quick fade when using niceplay() Earlier in 53950e14de65a54d9369c5183a16337782d3dc4e, I made playing a song while a song was already fading quickly fade out the current song, but then added an exception for if the fade came from the musicfadeout() command. This commit adds another exception for if the fade came from niceplay(), since otherwise the music transitions between areas in the game would go too quick.
2020-01-23 01:26:29 +01:00
if(currentsong!=-1)
{
Clean up don't-quick-fade signaling First, the variable has been inverted, because it's bad practice to have booleans with negative names. Secondly, instead of magically setting a signaling variable when calling fadeout(), fadeout() now has a parameter to set the quick_fade attribute, which is much cleaner than doing the magical assignment that could potentially look unrelated.
2020-11-06 09:51:04 +01:00
fadeout(false);
Don't quick fade when using niceplay() Earlier in 53950e14de65a54d9369c5183a16337782d3dc4e, I made playing a song while a song was already fading quickly fade out the current song, but then added an exception for if the fade came from the musicfadeout() command. This commit adds another exception for if the fade came from niceplay(), since otherwise the music transitions between areas in the game would go too quick.
2020-01-23 01:26:29 +01:00
}
Change nicefade to bool instead of int If it's treated like a bool, why shouldn't it be one?
2020-11-06 09:20:58 +01:00
nicefade = true;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
nicechange = t;
}
}
void musicclass::changemusicarea(int x, int y)
{
switch(musicroom(x, y))
{
case musicroom(11, 4):
niceplay(2);
break;
case musicroom(2, 4):
case musicroom(7, 15):
niceplay(3);
break;
case musicroom(18, 1):
case musicroom(15, 0):
niceplay(12);
break;
case musicroom(0, 0):
case musicroom(0, 16):
case musicroom(2, 11):
case musicroom(7, 9):
case musicroom(8, 11):
case musicroom(13, 2):
case musicroom(17, 12):
case musicroom(14, 19):
case musicroom(17, 17):
niceplay(4);
break;
default:
niceplay(1);
break;
}
}
Remove unused argument from musicclass::playef() Apparently the 'offset' argument did something in the 1.x Flash versions, but now it does nothing.
2020-04-02 01:36:35 +02:00
void musicclass::playef(int t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Don't manually write out INBOUNDS_VEC() checks This is because if they are manually written out, they are more likely to contain mistakes. In fact, after further review, there are several functions with incorrect manually-written bounds checks: * entityclass::entitycollide() * entityclass::removeentity() * entityclass::removeblock() * entityclass::copylinecross() * entityclass::revertlinecross() All of those functions forgot to do 'greater than or equal to' instead of 'greater than' when comparing against the size of the vector. So they were erroneous. But they are now fixed.
2020-09-10 06:58:59 +02:00
if (!INBOUNDS_VEC(t, soundTracks))
Add bounds checks to script commands that didn't have them Continuing from #280, another potential source of out-of-bounds indexing (and thus, Undefined Behavior badness) comes from script commands. A majority of them don't do any input validation at all, which means the potential for out-of-bounds indexing and segfaulting in custom levels. So it's always good to add bounds checks to them. Interesting note, the only existing command that has bounds checks is the flag() command. That means you can't turn out-of-bounds flags on or off. But there's no bounds checks for ifflag(), or customifflag(), which means you CAN index out-of-bounds with those commands! That's a bit bad to do, so. Also, I decided to add the bounds checks for playef() at the musicclass::playef() level, instead of just the level of the playef() command. I don't know of any other cases outside of the command where musicclass::playef() will index out of bounds, but musicclass is the one containing the indexed vector anyway, I wanted to cover more cases, and it's better to be safe than sorry.
2020-06-13 06:55:41 +02:00
{
return;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
int channel;
channel = Mix_PlayChannel(-1, soundTracks[t].sound, 0);
if(channel == -1)
{
fprintf(stderr, "Unable to play WAV file: %s\n", Mix_GetError());
}
}