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

738 lines
17 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>
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#include <physfsrwops.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"
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
#include "FileSystemUtils.h"
Factor fade amount calculation to separate function This makes it so to reuse this code, we don't have to copy-paste it. Additionally, I added a check for the milliseconds being 0, to avoid a division by zero. Logically and mathematically, if the fade amount is 0 milliseconds, then that means the fade should happen instantly - however, dividing by zero is undefined (both in math and in C/C++), so this check needs to be added.
2021-04-02 21:02:01 +02:00
#include "Game.h"
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
#include "Graphics.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"
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
#include "Script.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"
Replace all print calls with vlog calls This is pretty straight-forward to do.
2021-02-24 00:21:29 +01:00
#include "Vlogging.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
/* Begin SDL_mixer wrapper */
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
#include <SDL_mixer.h>
#include <vector>
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
#define VVV_MAX_VOLUME MIX_MAX_VOLUME
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
class SoundTrack
{
public:
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack(const char* fileName)
{
Point to SDL_LoadWAV for SoundTrack FAudio suggestion
2022-01-15 07:02:24 +01:00
/* SDL_LoadWAV, convert spec to FAudioBuffer */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
unsigned char *mem;
size_t length;
FILESYSTEM_loadAssetToMemory(fileName, &mem, &length, false);
if (mem == NULL)
{
m_sound = NULL;
vlog_error("Unable to load WAV file %s", fileName);
SDL_assert(0 && "WAV file missing!");
return;
}
SDL_RWops *fileIn = SDL_RWFromConstMem(mem, length);
m_sound = Mix_LoadWAV_RW(fileIn, 1);
FILESYSTEM_freeMemory(&mem);
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
if (m_sound == NULL)
{
vlog_error("Unable to load WAV file: %s", Mix_GetError());
}
}
void Dispose()
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Point to SDL_LoadWAV for SoundTrack FAudio suggestion
2022-01-15 07:02:24 +01:00
/* Destroy all track voices, SDL_free buffer from LoadWAV */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
Mix_FreeChunk(m_sound);
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
void Play()
{
Add notes for FAudio implementation
2022-01-14 23:11:16 +01:00
/* Fire-and-forget from a per-track FAudioSourceVoice pool */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
if (Mix_PlayChannel(-1, m_sound, 0) == -1)
{
vlog_error("Unable to play WAV file: %s", Mix_GetError());
}
}
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
Move the Mix_OpenAudio call to SoundTrack, from MusicTrack. In hindsight, the FAudio pointer will likely be in SoundTrack since we will want to keep the mastering voice closer to the sounds and their source voice arrays, while the MusicTrack will likely just be one source voice that gets PCM from different streams.
2022-01-14 22:52:52 +01:00
static void Init(int audio_rate, int audio_channels)
{
const Uint16 audio_format = AUDIO_S16SYS;
const int audio_buffers = 1024;
Add notes for FAudio implementation
2022-01-14 23:11:16 +01:00
/* FAudioCreate, FAudio_CreateMasteringVoice */
Move the Mix_OpenAudio call to SoundTrack, from MusicTrack. In hindsight, the FAudio pointer will likely be in SoundTrack since we will want to keep the mastering voice closer to the sounds and their source voice arrays, while the MusicTrack will likely just be one source voice that gets PCM from different streams.
2022-01-14 22:52:52 +01:00
if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) != 0)
{
vlog_error("Unable to initialize audio: %s", Mix_GetError());
SDL_assert(0 && "Unable to initialize audio!");
}
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
static void Pause()
{
Add notes for FAudio implementation
2022-01-14 23:11:16 +01:00
/* FAudio_StopEngine */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
Mix_Pause(-1);
}
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
static void Resume()
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Add notes for FAudio implementation
2022-01-14 23:11:16 +01:00
/* FAudio_StartEngine */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
Mix_Resume(-1);
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
static void SetVolume(int soundVolume)
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Add notes for FAudio implementation
2022-01-14 23:11:16 +01:00
/* FAudioVoice_SetVolume on all sounds. Yeah, all of them :/
* If we get desperate we can use a submix and set volume on that, but
* the submix is an extra mix stage so just loop all sounds manually...
*/
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
Mix_Volume(-1, soundVolume);
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
private:
Mix_Chunk *m_sound;
};
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
class MusicTrack
{
public:
MusicTrack(SDL_RWops *rw)
{
/* Open an stb_vorbis handle */
m_music = Mix_LoadMUS_RW(rw, 1);
if (m_music == NULL)
{
vlog_error("Unable to load Magic Binary Music file: %s", Mix_GetError());
}
}
void Dispose()
{
/* Free stb_vorbis */
Mix_FreeMusic(m_music);
}
bool Play(bool loop)
{
/* Create/Validate static FAudioSourceVoice, begin streaming */
if (Mix_PlayMusic(m_music, loop ? -1 : 0) == -1)
{
vlog_error("Mix_PlayMusic: %s", Mix_GetError());
return false;
}
return true;
}
static void Halt()
{
/* FAudioVoice_Destroy */
Mix_HaltMusic();
}
static bool IsHalted()
{
/* return musicVoice == NULL; */
return Mix_PausedMusic() == 1;
}
static void Pause()
{
/* FAudioSourceVoice_Pause */
Mix_PauseMusic();
}
static void Resume()
{
/* FAudioSourceVoice_Resume */
Mix_ResumeMusic();
}
static void SetVolume(int musicVolume)
{
/* FAudioSourceVoice_SetVolume */
Mix_VolumeMusic(musicVolume);
}
private:
Mix_Music *m_music;
};
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
static std::vector<SoundTrack> soundTracks;
Move MusicTrack below SoundTrack. It's very likely that MusicTrack will be pulling from the SoundTrack FAudio context, so make it so forward declarations are unnecessary.
2022-01-14 23:24:22 +01:00
static std::vector<MusicTrack> musicTracks;
SDL_mixer is now entirely contained in Music.cpp. This meant making the track vectors static, but that's kind of what we do with musicclass anyway? In any case, this will make the transition to FAudio MUCH less invasive.
2021-12-26 14:57:38 +01:00
Inline SoundSystem into musicclass constructor
2021-12-26 14:41:01 +01:00
/* End SDL_mixer wrapper */
musicclass::musicclass(void)
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
{
Move the Mix_OpenAudio call to SoundTrack, from MusicTrack. In hindsight, the FAudio pointer will likely be in SoundTrack since we will want to keep the mastering voice closer to the sounds and their source voice arrays, while the MusicTrack will likely just be one source voice that gets PCM from different streams.
2022-01-14 22:52:52 +01:00
SoundTrack::Init(44100, 2);
Consolidate SoundSystem into Music. It's just some small wrappers, and SoundSystem can be inlined trivially.
2021-12-26 14:38:16 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
safeToProcessMusic= false;
m_doFadeInVol = false;
m_doFadeOutVol = false;
musicVolume = 0;
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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
user_music_volume = USER_VOLUME_MAX;
user_sound_volume = USER_VOLUME_MAX;
Add music and sound volume config options This adds <musicvolume> and <soundvolume> tags to unlock.vvv and settings.vvv, so users' volume preferences will be persistent across game sessions. This does not add the user interface to change them from in-game; the next commit will do that.
2021-04-12 02:41:46 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
currentsong = 0;
nicechange = -1;
nicefade = false;
quick_fade = true;
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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
usingmmmmmm = false;
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
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::init(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
binaryBlob musicWriteBlob;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#define FOREACH_TRACK(blob, track_name) blob.AddFileToBinaryBlob("data/" track_name);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(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
#undef FOREACH_TRACK
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
musicWriteBlob.writeBinaryBlob("data/BinaryMusic.vvv");
musicWriteBlob.clear();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#endif
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
num_mmmmmm_tracks = 0;
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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!mmmmmm_blob.unPackBinary("mmmmmm.vvv"))
{
if (pppppp_blob.unPackBinary("vvvvvvmusic.vvv"))
{
vlog_info("Loading music from PPPPPP blob...");
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
mmmmmm = false;
usingmmmmmm=false;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int index;
SDL_RWops* rw;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#define FOREACH_TRACK(blob, track_name) \
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
index = blob.getIndex("data/" track_name); \
rw = SDL_RWFromMem(blob.getAddress(index), blob.getSize(index)); \
musicTracks.push_back(MusicTrack( rw ));
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(pppppp_blob)
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#undef FOREACH_TRACK
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
else
{
vlog_info("Loading music from loose files...");
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_RWops* rw;
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#define FOREACH_TRACK(_, track_name) \
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
rw = PHYSFSRWOPS_openRead(track_name); \
musicTracks.push_back(MusicTrack( rw ));
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
TRACK_NAMES(_)
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
#undef FOREACH_TRACK
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else
{
vlog_info("Loading PPPPPP and MMMMMM blobs...");
Remove data/ from track name list, refactor music loading, and support loose ogg music (these should be separate commits but they're annoying to split after the fact, oh well)
2020-07-30 23:06:07 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
mmmmmm = true;
int index;
SDL_RWops *rw;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Refactor TRACK_NAMES to take in a blob parameter I'm going to introduce another binaryBlob object in to the mix, and I want to be able to re-use an existing FOREACH_TRACK #define without having to copy-paste it again. So, TRACK_NAMES now takes in a blob parameter, which will be passed to the temporary FOREACH_TRACK #define.
2021-02-16 01:38:10 +01:00
#define FOREACH_TRACK(blob, track_name) \
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
index = blob.getIndex("data/" track_name); \
if (index >= 0 && index < blob.max_headers) \
{ \
rw = SDL_RWFromConstMem(blob.getAddress(index), blob.getSize(index)); \
if (rw == NULL) \
{ \
vlog_error("Unable to read music file header: %s", SDL_GetError()); \
} \
else \
{ \
musicTracks.push_back(MusicTrack( rw )); \
} \
}
TRACK_NAMES(mmmmmm_blob)
num_mmmmmm_tracks += musicTracks.size();
size_t index_ = 0;
while (mmmmmm_blob.nextExtra(&index_))
{
rw = SDL_RWFromConstMem(mmmmmm_blob.getAddress(index_), mmmmmm_blob.getSize(index_));
musicTracks.push_back(MusicTrack( rw ));
num_mmmmmm_tracks++;
index_++;
}
bool ohCrap = pppppp_blob.unPackBinary("vvvvvvmusic.vvv");
SDL_assert(ohCrap && "Music not found!");
TRACK_NAMES(pppppp_blob)
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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_RWops* rw;
size_t index_ = 0;
while (pppppp_blob.nextExtra(&index_))
{
rw = SDL_RWFromConstMem(pppppp_blob.getAddress(index_), pppppp_blob.getSize(index_));
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
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
num_pppppp_tracks++;
index_++;
}
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
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::destroy(void)
Move musicclass cleanup to separate function musicclass::destroy() This removes the music cleanup code from musicclass::init(), and requires that we also call destroy() in Graphics::reloadresources(). This is because we'll need to re-use the musicclass cleanup code elsewhere, and we don't want to copy-paste the cleanup code. Or at least, I don't (but I'm not a game dev, game devs copy-paste all the friggin' time).
2021-02-16 01:24:21 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
for (size_t i = 0; i < soundTracks.size(); ++i)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
soundTracks[i].Dispose();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
soundTracks.clear();
// 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
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::Halt();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
for (size_t i = 0; i < musicTracks.size(); ++i)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
musicTracks[i].Dispose();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
musicTracks.clear();
pppppp_blob.clear();
mmmmmm_blob.clear();
Move musicclass cleanup to separate function musicclass::destroy() This removes the music cleanup code from musicclass::init(), and requires that we also call destroy() in Graphics::reloadresources(). This is because we'll need to re-use the musicclass cleanup code elsewhere, and we don't want to copy-paste the cleanup code. Or at least, I don't (but I'm not a game dev, game devs copy-paste all the friggin' time).
2021-02-16 01:24:21 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::play(int t)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (mmmmmm && usingmmmmmm)
{
// Don't conjoin this if-statement with the above one...
if (num_mmmmmm_tracks > 0)
{
t %= num_mmmmmm_tracks;
}
}
else if (num_pppppp_tracks > 0)
{
t %= num_pppppp_tracks;
}
if (mmmmmm && !usingmmmmmm)
{
t += num_mmmmmm_tracks;
}
safeToProcessMusic = true;
if (currentsong == t && !m_doFadeOutVol)
{
return;
}
currentsong = t;
if (t == -1)
{
return;
}
if (!INBOUNDS_VEC(t, musicTracks))
{
vlog_error("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
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
if (musicTracks[t].Play(false))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
m_doFadeInVol = false;
m_doFadeOutVol = false;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
musicVolume = VVV_MAX_VOLUME;
MusicTrack::SetVolume(musicVolume);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
}
else
{
if (m_doFadeOutVol)
{
// We're already fading out
nicechange = t;
nicefade = true;
currentsong = -1;
if (quick_fade)
{
fadeMusicVolumeOut(500); // fade out quicker
}
else
{
quick_fade = true;
}
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
else if (musicTracks[t].Play(true))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
m_doFadeInVol = false;
m_doFadeOutVol = false;
fadeMusicVolumeIn(3000);
}
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::resume()
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
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::Resume();
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +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
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::resumefade(const int fadein_ms)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
resume();
fadeMusicVolumeIn(fadein_ms);
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
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::fadein(void)
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
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
resumefade(3000); // 3000 ms fadein
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
}
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
void musicclass::pause(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::Pause();
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::haltdasmusik(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* Just pauses music. This is intended. */
pause();
currentsong = -1;
m_doFadeInVol = false;
m_doFadeOutVol = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::silencedasmusik(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
musicVolume = 0;
Reset fade booleans when silencing music This fixes a bug where the music would keep playing when a collection prompt appeared if the music was still fading in at that time.
2021-09-11 02:02:24 +02:00
m_doFadeInVol = false;
m_doFadeOutVol = false;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
struct FadeState
Factor fade amount calculation to separate function This makes it so to reuse this code, we don't have to copy-paste it. Additionally, I added a check for the milliseconds being 0, to avoid a division by zero. Logically and mathematically, if the fade amount is 0 milliseconds, then that means the fade should happen instantly - however, dividing by zero is undefined (both in math and in C/C++), so this check needs to be added.
2021-04-02 21:02:01 +02:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int start_volume;
int end_volume;
int duration_ms;
int step_ms;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
};
static struct FadeState fade;
enum FadeCode
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
Fade_continue,
Fade_finished
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
};
static enum FadeCode processmusicfade(struct FadeState* state, int* volume)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int range;
int new_volume;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (state->duration_ms == 0 /* Fast path. */
|| state->start_volume == state->end_volume /* Fast path. */
|| state->step_ms >= state->duration_ms /* We're finished. */)
{
*volume = state->end_volume;
state->step_ms = 0;
return Fade_finished;
}
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
range = state->end_volume - state->start_volume;
new_volume = range * state->step_ms / state->duration_ms;
new_volume += state->start_volume;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
*volume = new_volume;
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
state->step_ms += game.get_timestep();
Fix fade volume durations being incorrect The previous fade system used only one variable, the amount of volume to fade per frame. However, this variable was an integer, meaning any decimal portion would be truncated, and would lead to a longer fade duration than intended. The fade per volume is calculated by doing MIX_MAX_VOLUME / (fade_ms / game.get_timestep()). MIX_MAX_VOLUME is 128, and game.get_timestep() is usually 34, so a 3000 millisecond fade would be calculated as 128 / (3000 / 34). 3000 / 34 is 88.235..., but that gets truncated to 88, and then 128 / 88 becomes 1.454545..., which then gets truncated to 1. This essentially means 1 is added to or subtracted from the volume every frame, and given that the max volume is 128, this means that the fade lasts for 128 frames. Now, instead of the fade duration lasting 3 seconds, the fade now lasts for 128 frames, which is 128 * 34 / 1000 = 4.352 seconds long. This could be fixed using floats, but when you introduce floats, you now have 1.9999998 problems. For instance, I'm concerned about floating-point determinism issues. What I've done instead is switch the system to use four different variables instead: the start volume, the end volume, the total duration, and the duration completed so far (called the "step"). For every frame, the game interpolates which value should be used based on the step, the total duration, and the start and end volumes, and then adds the timestep to the step. This way, fades will be correctly timed, and we don't have potential determinism issues. Doing this also fixes inaccuracies with the game timestep changing during the fade, since the timestep is only used in the calculation once at the beginning in the previous system.
2021-04-28 01:37:16 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
return Fade_continue;
Factor fade amount calculation to separate function This makes it so to reuse this code, we don't have to copy-paste it. Additionally, I added a check for the milliseconds being 0, to avoid a division by zero. Logically and mathematically, if the fade amount is 0 milliseconds, then that means the fade should happen instantly - however, dividing by zero is undefined (both in math and in C/C++), so this check needs to be added.
2021-04-02 21:02:01 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
void musicclass::fadeMusicVolumeIn(int ms)
{
Music: Do not do fades if not playing This fixes a regression where entering playtesting while a track was fading out (by exiting out of playtesting with a track playing and then immediately entering back in with the level start music set) would result in no music. The cause is the game doing fades even though nothing is playing, which puts it in a confusing state.
2021-09-11 04:37:33 +02:00
if (halted())
{
return;
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
m_doFadeInVol = true;
m_doFadeOutVol = false;
Ensure all fade-ins start from zero This fixes a bug where fading music in but not going through the music.play() path wouldn't start the fade volume from zero. If this happened, then the previous volume would persist, and if the previous volume was the max volume, then that essentially canceled out the fade-in and prevented it from happening at all. But now all paths to fadeMusicVolumeIn() set the volume to zero first, instead of only the caller of music.play().
2021-04-12 19:38:44 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* Ensure it starts at 0 */
musicVolume = 0;
Ensure all fade-ins start from zero This fixes a bug where fading music in but not going through the music.play() path wouldn't start the fade volume from zero. If this happened, then the previous volume would persist, and if the previous volume was the max volume, then that essentially canceled out the fade-in and prevented it from happening at all. But now all paths to fadeMusicVolumeIn() set the volume to zero first, instead of only the caller of music.play().
2021-04-12 19:38:44 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* Fix 1-frame glitch */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(0);
Fix 1-frame glitch when fading in from zero The problem here is that even though we start playing the music when the volume is set to zero, mixer's state doesn't have volume zero, so whatever it plays next will be the very first quanta of the track but at the previous volume (in this case, the maximum volume). To fix this, just update mixer when we update the volume here - it's okay to not account for user volume because it ends up being zero anyway. Fixes #710.
2021-04-12 19:41:44 +02:00
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
fade.step_ms = 0;
fade.duration_ms = ms;
fade.start_volume = 0;
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
fade.end_volume = VVV_MAX_VOLUME;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::fadeMusicVolumeOut(const int fadeout_ms)
{
Music: Do not do fades if not playing This fixes a regression where entering playtesting while a track was fading out (by exiting out of playtesting with a track playing and then immediately entering back in with the level start music set) would result in no music. The cause is the game doing fades even though nothing is playing, which puts it in a confusing state.
2021-09-11 04:37:33 +02:00
if (halted())
{
return;
}
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
m_doFadeInVol = false;
m_doFadeOutVol = true;
fade.step_ms = 0;
/* Duration is proportional to current volume. */
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
fade.duration_ms = fadeout_ms * musicVolume / VVV_MAX_VOLUME;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
fade.start_volume = musicVolume;
fade.end_volume = 0;
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02: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
void musicclass::fadeout(const bool quick_fade_ /*= true*/)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
fadeMusicVolumeOut(quick_fade_ ? 500 : 2000);
quick_fade = quick_fade_;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::processmusicfadein(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
enum FadeCode fade_code = processmusicfade(&fade, &musicVolume);
if (fade_code == Fade_finished)
{
m_doFadeInVol = false;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
void musicclass::processmusicfadeout(void)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
enum FadeCode fade_code = processmusicfade(&fade, &musicVolume);
if (fade_code == Fade_finished)
{
musicVolume = 0;
m_doFadeOutVol = false;
haltdasmusik();
}
Re-fix resumemusic/musicfadein once again So it looks like facb079b3597b380f876537523cd351a0e637b62 (PR #316) had a few issues. The SDL performance counter doesn't really work that well. Testing reveals that unfocusing and focusing the game again results in the resumemusic() script command resuming the track at the wrong time. Even when not unfocusing the game at all, stopping a track and resuming it resumes it at the wrong time. (Only disabling the unfocus pause fixes this.) Furthermore, there's also the fact that the SDL performance counter keeps incrementing when the game is paused under GDB. So... yeah. Instead of dealing with the SDL performance counter, I'm just going to pause and resume the music directly (so the stopmusic() script command just pauses the music instead). As a result, we no longer can keep constantly calling Mix_PauseMusic() or Mix_ResumeMusic() when focused or unfocused, so I've moved those calls to happen directly when the relevant SDL events are received (the constant calls were originally in VCE, and whoever added them (I'm pretty sure it was Leo) was not the sharpest tool in the shed...). And we are going to switch over to using our own fade system instead of the SDL mixer fade system. In fact, we were already using our own fade system for fadeins after collecting a trinket or a custom level crewmate, but we were still using the mixer system for the rest. This is an inconsistency that I am glad to correct, so we're also doing our own fadeouts now. There is, however, an issue with the fade system where the length it goes for is inaccurate, because it's based on a volume-per-frame second calculation that gets truncated. But that's an issue to fix later - at least what I'm doing right now makes resumemusic() and musicfadein() work better than before.
2021-04-02 21:56:25 +02:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void musicclass::processmusic(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if(!safeToProcessMusic)
{
return;
}
if(m_doFadeInVol)
{
processmusicfadein();
}
if (m_doFadeOutVol)
{
processmusicfadeout();
}
/* This needs to come after processing fades */
Move `Mix_PausedMusic()` call into wrapper function This wrapper function is for (a) future-proofing (b) proactive prevention of future copy-pasting (c) to clarify that we never actually halt music in the SDL_mixer sense, we only pause it, so to check if the music is halted we actually check if the music is paused instead. This is important because Mix_PlayingMusic() does not check if the music is paused and Mix_PausedMusic() does not check if the music is halted.
2021-09-11 04:35:29 +02:00
if (nicefade && halted())
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
play(nicechange);
nicechange = -1;
nicefade = false;
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
void musicclass::niceplay(int t)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
/* important: do nothing if the correct song is playing! */
if ((!mmmmmm && currentsong != t)
|| (mmmmmm && usingmmmmmm && currentsong != t)
|| (mmmmmm && !usingmmmmmm && currentsong != t + num_mmmmmm_tracks))
{
if (currentsong != -1)
{
fadeout(false);
}
nicefade = true;
}
nicechange = t;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
static const int areamap[] = {
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
4, 3, 3, 3, 3, 3, 3, 3, 4,-2, 4, 4, 4,12,12,12,12,12,12,12,
4, 3, 3, 3, 3, 3, 3, 4, 4,-2, 4, 4, 4, 4,12,12,12,12,12,12,
4, 4, 4, 4, 3, 4, 4, 4, 4,-2, 4, 4, 4, 4,12,12,12,12,12,12,
4, 4, 4, 4, 3, 4, 4, 4, 4,-2, 4, 4, 1, 1, 1, 1,12,12,12,12,
4, 4, 3, 3, 3, 4, 4, 4, 4,-2,-2,-2, 1, 1, 1, 1, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 1, 1, 1, 1, 1, 1,11,11,-1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 1, 1, 1, 1, 1, 1, 1,11,11,11,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 1, 1, 1, 1, 1, 1, 1, 1, 1,11,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4, 4, 4, 1, 1, 1, 1, 1, 1, 3,
4, 4, 4, 4, 4, 4, 4, 4,-2,-2, 4, 4, 4, 1, 1, 1, 1, 1, 1, 4,
4, 4,-1,-1,-1, 4, 4, 4, 4,-2, 4, 4, 4, 1, 1, 1, 1, 1, 1, 4,
4, 4,-1,-1,-1, 4, 4, 4, 4,-2, 4, 1, 1, 1, 1, 1, 1, 1, 1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4, 1, 1, 1, 1, 1, 1, 4, 1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4, 1, 1, 1, 1, 1, 1, 4, 1, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4,-2, 4,-1,-3, 4, 4, 4, 4, 4, 1, 4,
4, 4, 4, 4, 4, 3, 3, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 3, 3, 3, 3, 3, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 3, 3, 3, 3, 3, 3, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3, 3, 3, 3, 3, 4, 4, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3, 3, 3, 3, 3, 4, 4, 3, 4,-2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
Replace main game music with music area map The main game used a set of copy-pasted code to set the music of each area. There WAS some redundancy built-in, but only three rooms in each direction from the entrance of a zone. Given this, it's completely possible for players to mismatch the music of the area and level. In fact, it's easy to do it even on accident, especially since 2.3 now lets you quicksave and quit during cutscenes. Just play a cutscene that has Pause music, then quicksave, quit, and reload. Also some other accidental ways that I've forgotten about. To fix this, I've done what mapclass has and made an areamap. Except for music. This map is the map of the track number of every single room, except for three special cases: -1 for do nothing and don't change music (usually because multiple different tracks can be played in this room), -2 for Tower music (needs to be track 2 or 9 depending on Flip Mode), and -3 for the start of Space Station 2 (track 1 in time trials, track 4 otherwise). I've thoroughly tested this areamap by playing through the game and entering every single room. Additionally I've also thoroughly tested all special cases (entering the Ship through the teleporter or main entrance, using the Ship's jukebox, the Tower in Flip Mode and regular mode, and the start of Space Station 2 in time trial and in regular mode). Closes #449.
2021-05-12 04:59:02 +02:00
};
SDL_COMPILE_TIME_ASSERT(areamap, SDL_arraysize(areamap) == 20 * 20);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
void musicclass::changemusicarea(int x, int y)
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
int room;
int track;
if (script.running)
{
return;
}
room = musicroom(x, y);
if (!INBOUNDS_ARR(room, areamap))
{
SDL_assert(0 && "Music map index out-of-bounds!");
return;
}
track = areamap[room];
switch (track)
{
case -1:
/* Don't change music. */
return;
case -2:
/* Special case: Tower music, changes with Flip Mode. */
if (graphics.setflipmode)
{
track = 9; /* ecroF evitisoP */
}
else
{
track = 2; /* Positive Force */
}
break;
case -3:
/* Special case: start of Space Station 2. */
if (game.intimetrial)
{
track = 1; /* Pushing Onwards */
}
else
{
track = 4; /* Passion for Exploring */
}
break;
}
niceplay(track);
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
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
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!INBOUNDS_VEC(t, soundTracks))
{
return;
}
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
soundTracks[t].Play();
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
void musicclass::pauseef(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack::Pause();
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
}
void musicclass::resumeef(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack::Resume();
Add pause(), pauseef(), and resumeef() to musicclass musicclass already had a resume() function for music. These are just wrappers around the appropriate SDL_mixer functions, to avoid direct function calls to the mixer API. So if we ever need to do something with all callers of pausing and resuming in the future, or we switch to a different audio backend, the work is already done for us. Also it just looks cleaner to be calling our musicclass function instead of doing a direct API call to the mixer.
2021-04-02 21:07:19 +02:00
}
Move `Mix_PausedMusic()` call into wrapper function This wrapper function is for (a) future-proofing (b) proactive prevention of future copy-pasting (c) to clarify that we never actually halt music in the SDL_mixer sense, we only pause it, so to check if the music is halted we actually check if the music is paused instead. This is important because Mix_PlayingMusic() does not check if the music is paused and Mix_PausedMusic() does not check if the music is halted.
2021-09-11 04:35:29 +02:00
bool musicclass::halted(void)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
return MusicTrack::IsHalted();
Move `Mix_PausedMusic()` call into wrapper function This wrapper function is for (a) future-proofing (b) proactive prevention of future copy-pasting (c) to clarify that we never actually halt music in the SDL_mixer sense, we only pause it, so to check if the music is halted we actually check if the music is paused instead. This is important because Mix_PlayingMusic() does not check if the music is paused and Mix_PausedMusic() does not check if the music is halted.
2021-09-11 04:35:29 +02:00
}
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
void musicclass::updatemutestate(void)
{
if (game.muted)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(0);
SoundTrack::SetVolume(0);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
}
else
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
SoundTrack::SetVolume(VVV_MAX_VOLUME * user_sound_volume / USER_VOLUME_MAX);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
if (game.musicmuted)
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(0);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
}
else
{
Isolate all SDL_mixer references to SoundTrack/MusicTrack. This looks redundant but will actually help in the transition to FAudio; we mostly want to keep the game logic the same while reimplementing the current mixer, weirdness and all. Once that's done and confirmed to be stable and consistent we can start cutting out the workarounds and quirks.
2022-01-14 22:46:04 +01:00
MusicTrack::SetVolume(musicVolume * user_music_volume / USER_VOLUME_MAX);
Move the mute logic to musicclass. This moves the last of the SDL_mixer calls to Music.cpp.
2021-12-26 14:48:23 +01:00
}
}
}