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.2 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
if (currentsong != t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
if (t != -1)
{
currentsong = t;
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
Rename INBOUNDS() macro to INBOUNDS_VEC() Since there's an INBOUNDS_ARR() macro, it's much better to specify the macro for the vector is a macro for the vector, to avoid confusion. All usages of this macro have been renamed accordingly.
2020-09-08 09:31:44 +02:00
if (!INBOUNDS_VEC(t, musicTracks))
Add bounds check to musicclass::play() If the song number (after we've processed it) is out-of-bounds, then just return and log the error.
2020-07-01 02:17:29 +02:00
{
puts("play() out-of-bounds!");
currentsong = -1;
return;
}
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 song 0/7 check using num_pppppp_tracks instead of num_mmmmmm_tracks Just looked over this and had to do a double-take. It should be num_mmmmmm_tracks, not num_pppppp_tracks, because MMMMMM comes first in the vector of music tracks.
2020-11-06 09:34:53 +01:00
if (currentsong == 0 || currentsong == 7 || (!map.custommode && (currentsong == 0+num_mmmmmm_tracks || currentsong == 7+num_mmmmmm_tracks)))
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
// Level Complete theme, no fade in or repeat
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 (Mix_FadeInMusicPos(musicTracks[t].m_music, 0, 0, position_sec) == -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
printf("Mix_FadeInMusicPos: %s\n", Mix_GetError());
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
}
else
{
Merge fadeoutqueuesong into nicechange fadeoutqueuesong basically does the same thing as nicechange - they both queue a song to be played when the current track is done fading out. Except, for some reason, I decided to add fadeoutqueuesong instead of using the existing nicechange/nicefade system. This has consequences where fadeoutqueuesong would step on the toes of nicechange. In the case of #390, nicechange would say "let's play Potential for Anything" when entering the Super Gravitron, but fadeoutqueuesong had previously said "let's play Pipe Dream" because of the player having just exited the Super Gravitron. fadeoutqueuesong took priority because it came first in musicclass::processfade(), and when it called play(), the Mix_PlayingMusic() in the nicechange check afterwards would say music would already be playing at that point, so the nicechange wouldn't take effect. In the end, the solution is to just merge the new system into the already-existing system. Fixes #390.
2020-11-06 09:36:25 +01:00
if (Mix_FadingMusic() == MIX_FADING_OUT)
{
Stop the game from freezing if we play a song during a fadeout (#61)
2020-01-13 04:33:58 +01:00
// We're already fading out
Merge fadeoutqueuesong into nicechange fadeoutqueuesong basically does the same thing as nicechange - they both queue a song to be played when the current track is done fading out. Except, for some reason, I decided to add fadeoutqueuesong instead of using the existing nicechange/nicefade system. This has consequences where fadeoutqueuesong would step on the toes of nicechange. In the case of #390, nicechange would say "let's play Potential for Anything" when entering the Super Gravitron, but fadeoutqueuesong had previously said "let's play Pipe Dream" because of the player having just exited the Super Gravitron. fadeoutqueuesong took priority because it came first in musicclass::processfade(), and when it called play(), the Mix_PlayingMusic() in the nicechange check afterwards would say music would already be playing at that point, so the nicechange wouldn't take effect. In the end, the solution is to just merge the new system into the already-existing system. Fixes #390.
2020-11-06 09:36:25 +01:00
nicechange = t;
nicefade = true;
Stop the game from freezing if we play a song during a fadeout (#61)
2020-01-13 04:33:58 +01:00
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
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
if (quick_fade)
Merge fadeoutqueuesong into nicechange fadeoutqueuesong basically does the same thing as nicechange - they both queue a song to be played when the current track is done fading out. Except, for some reason, I decided to add fadeoutqueuesong instead of using the existing nicechange/nicefade system. This has consequences where fadeoutqueuesong would step on the toes of nicechange. In the case of #390, nicechange would say "let's play Potential for Anything" when entering the Super Gravitron, but fadeoutqueuesong had previously said "let's play Pipe Dream" because of the player having just exited the Super Gravitron. fadeoutqueuesong took priority because it came first in musicclass::processfade(), and when it called play(), the Mix_PlayingMusic() in the nicechange check afterwards would say music would already be playing at that point, so the nicechange wouldn't take effect. In the end, the solution is to just merge the new system into the already-existing system. Fixes #390.
2020-11-06 09:36:25 +01:00
{
Stop the game from freezing if we play a song during a fadeout (#61)
2020-01-13 04:33:58 +01:00
Mix_FadeOutMusic(500); // fade out quicker
Merge fadeoutqueuesong into nicechange fadeoutqueuesong basically does the same thing as nicechange - they both queue a song to be played when the current track is done fading out. Except, for some reason, I decided to add fadeoutqueuesong instead of using the existing nicechange/nicefade system. This has consequences where fadeoutqueuesong would step on the toes of nicechange. In the case of #390, nicechange would say "let's play Potential for Anything" when entering the Super Gravitron, but fadeoutqueuesong had previously said "let's play Pipe Dream" because of the player having just exited the Super Gravitron. fadeoutqueuesong took priority because it came first in musicclass::processfade(), and when it called play(), the Mix_PlayingMusic() in the nicechange check afterwards would say music would already be playing at that point, so the nicechange wouldn't take effect. In the end, the solution is to just merge the new system into the already-existing system. Fixes #390.
2020-11-06 09:36:25 +01:00
}
Stop the game from freezing if we play a song during a fadeout (#61)
2020-01-13 04:33:58 +01:00
else
Merge fadeoutqueuesong into nicechange fadeoutqueuesong basically does the same thing as nicechange - they both queue a song to be played when the current track is done fading out. Except, for some reason, I decided to add fadeoutqueuesong instead of using the existing nicechange/nicefade system. This has consequences where fadeoutqueuesong would step on the toes of nicechange. In the case of #390, nicechange would say "let's play Potential for Anything" when entering the Super Gravitron, but fadeoutqueuesong had previously said "let's play Pipe Dream" because of the player having just exited the Super Gravitron. fadeoutqueuesong took priority because it came first in musicclass::processfade(), and when it called play(), the Mix_PlayingMusic() in the nicechange check afterwards would say music would already be playing at that point, so the nicechange wouldn't take effect. In the end, the solution is to just merge the new system into the already-existing system. Fixes #390.
2020-11-06 09:36:25 +01:00
{
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 = true;
Merge fadeoutqueuesong into nicechange fadeoutqueuesong basically does the same thing as nicechange - they both queue a song to be played when the current track is done fading out. Except, for some reason, I decided to add fadeoutqueuesong instead of using the existing nicechange/nicefade system. This has consequences where fadeoutqueuesong would step on the toes of nicechange. In the case of #390, nicechange would say "let's play Potential for Anything" when entering the Super Gravitron, but fadeoutqueuesong had previously said "let's play Pipe Dream" because of the player having just exited the Super Gravitron. fadeoutqueuesong took priority because it came first in musicclass::processfade(), and when it called play(), the Mix_PlayingMusic() in the nicechange check afterwards would say music would already be playing at that point, so the nicechange wouldn't take effect. In the end, the solution is to just merge the new system into the already-existing system. Fixes #390.
2020-11-06 09:36:25 +01:00
}
Stop the game from freezing if we play a song during a fadeout (#61)
2020-01-13 04:33:58 +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
else if (Mix_FadeInMusicPos(musicTracks[t].m_music, -1, fadein_ms, position_sec) == -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
printf("Mix_FadeInMusicPos: %s\n", Mix_GetError());
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
songStart = SDL_GetPerformanceCounter();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
else
{
currentsong = -1;
}
}
}
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());
}
}