Changed lambdas to use capture variables so they're nice and clean

Changed SetGlobalPitch to default to only setting it for mobile sounds, since the rest is dumb, and fiddled with the logic of its arguments a little so they're flags for including things, that default to false
Changed c-style casts to static_casts for userData and a reinterpret_cast for FMOD::Channel (cause static_cast wouldn't work)
Made it so multiplayer set global pitch will only affect mobile sounds, until I redo sound passing to be more robust

Author: garethyr

Entities/SoundContainer.cpp

@@ -114,30 +114,27 @@ namespace RTE {
 		SoundData soundData;
 
 		/// <summary>
-		/// This lambda exists to have some easy, private reused code.
-		/// It loads an audio file by path in as a ContentFile, which in turn loads it into FMOD, then returns SoundData for it in the outParam outSoundData.
+		/// Internal lambda function to load an audio file by path in as a ContentFile, which in turn loads it into FMOD, then returns SoundData for it in the outParam outSoundData.
 		/// </summary>
 		/// <param name="soundPath">The path to the sound file.</param>
-		/// <param name="parentReader">The reader being used when calling this. Used to report errors if loading the sound fails.</param>
-		/// <param name="outSoundData">The outParam for the SoundData struct produced by reading the given sound.</param>
-		auto readSound = [](const std::string &soundPath, Reader &parentReader, SoundData *outSoundData) {
+		auto readSound = [&soundData, &reader](const std::string &soundPath) {
 			ContentFile soundFile(soundPath.c_str());
 			FMOD::Sound *soundObject = soundFile.GetAsSample();
-			if (g_AudioMan.IsAudioEnabled() && !soundObject) { parentReader.ReportError(std::string("Failed to load the sound from the file")); }
+			if (g_AudioMan.IsAudioEnabled() && !soundObject) { reader.ReportError(std::string("Failed to load the sound from the file")); }
 
-			outSoundData->SoundFile = soundFile;
-			outSoundData->SoundObject = soundObject;
+			soundData.SoundFile = soundFile;
+			soundData.SoundObject = soundObject;
 		};
 
 		if (propValue != "Sound" && propValue != "ContentFile") {
-			readSound(propValue, reader, &soundData);
+			readSound(propValue);
 			return soundData;
 		}
 
 		while (reader.NextProperty()) {
 			std::string soundSubPropertyName = reader.ReadPropName();
 			if (soundSubPropertyName == "FilePath" || soundSubPropertyName == "Path") {
-				readSound(reader.ReadPropValue(), reader, &soundData);
+				readSound(reader.ReadPropValue());
 			} else if (soundSubPropertyName == "Offset") {
 				reader >> soundData.Offset;
 			} else if (soundSubPropertyName == "MinimumAudibleDistance") {
@@ -205,17 +202,20 @@ namespace RTE {
 				m_SelectedSoundSet = (m_SelectedSoundSet + 1) % 2;
 				break;
 			default:
-				auto selectRandomSound = [](int soundSetSize, size_t *outSelectedSoundSet) {
-					size_t soundToSelect = std::floorf(static_cast<float>(soundSetSize) * PosRand());
-					while (soundToSelect == *outSelectedSoundSet) {
-						soundToSelect = std::floorf(static_cast<float>(soundSetSize) * PosRand());
+				/// <summary>
+				/// Internal lambda function to pick a random sound that's not the previously played sound. Done to avoid scoping issues inside the switch below.
+				/// </summary>
+				auto selectRandomSound = [&soundSetCount, this]() {
+					size_t soundToSelect = std::floorf(static_cast<float>(soundSetCount) * PosRand());
+					while (soundToSelect == m_SelectedSoundSet) {
+						soundToSelect = std::floorf(static_cast<float>(soundSetCount) * PosRand());
 					}
-					*outSelectedSoundSet = soundToSelect;
+					m_SelectedSoundSet = soundToSelect;
 				};
 
 				switch (m_SoundSelectionCycleMode) {
 					case MODE_RANDOM:
-						selectRandomSound(soundSetCount, &m_SelectedSoundSet);
+						selectRandomSound();
 						break;
 					case MODE_FORWARDS:
 						m_SelectedSoundSet = (m_SelectedSoundSet + 1) % soundSetCount;

Managers/AudioMan.cpp

@@ -58,7 +58,7 @@ namespace RTE {
 			return -1;
 		}
 
-		SetGlobalPitch(m_GlobalPitch);
+		SetGlobalPitch(m_GlobalPitch, false, false);
 		SetSoundsVolume(m_SoundsVolume);
 		SetMusicVolume(m_MusicVolume);
 
@@ -117,17 +117,17 @@ namespace RTE {
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	void AudioMan::SetGlobalPitch(double pitch, bool excludeImmobileSounds, bool excludeMusic) {
+	void AudioMan::SetGlobalPitch(double pitch, bool includeImmobileSounds, bool includeMusic) {
 		if (!m_AudioEnabled) {
 			return;
 		}
-		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_GLOBAL_PITCH, NULL, NULL, Vector(), 0, pitch, excludeMusic); }
+		if (m_IsInMultiplayerMode) { RegisterSoundEvent(-1, SOUND_SET_GLOBAL_PITCH, NULL, NULL, Vector(), 0, pitch); }
 
 		// Limit pitch change to 8 octaves up or down
 		m_GlobalPitch = Limit(pitch, 8, 0.125); 
-		if (!excludeMusic) { m_MusicChannelGroup->setPitch(m_GlobalPitch); }
+		if (includeMusic) { m_MusicChannelGroup->setPitch(m_GlobalPitch); }
 
-		FMOD::ChannelGroup *channelGroupToUse = excludeImmobileSounds ? m_MobileSoundChannelGroup : m_SoundChannelGroup;
+		FMOD::ChannelGroup *channelGroupToUse = includeImmobileSounds ? m_SoundChannelGroup : m_MobileSoundChannelGroup;
 
 		int numChannels;
 		FMOD_RESULT result = channelGroupToUse->getNumChannels(&numChannels);
@@ -145,7 +145,7 @@ namespace RTE {
 			if (result == FMOD_OK && isPlaying) {
 				void *userData;
 				result == FMOD_OK ? soundChannel->getUserData(&userData) : result;
-				const SoundContainer *channelSoundContainer = (SoundContainer *)userData;
+				const SoundContainer *channelSoundContainer = static_cast<SoundContainer *>(userData);
 
 				if (channelSoundContainer->IsAffectedByGlobalPitch()) { soundChannel->setPitch(pitch); }
 			}
@@ -641,14 +641,14 @@ namespace RTE {
 
 	FMOD_RESULT F_CALLBACK AudioMan::SoundChannelEndedCallback(FMOD_CHANNELCONTROL *channelControl, FMOD_CHANNELCONTROL_TYPE channelControlType, FMOD_CHANNELCONTROL_CALLBACK_TYPE callbackType, void *unusedCommandData1, void *unusedCommandData2) {
 		if (channelControlType == FMOD_CHANNELCONTROL_CHANNEL && callbackType == FMOD_CHANNELCONTROL_CALLBACK_END) {
-			FMOD::Channel *channel = (FMOD::Channel *) channelControl;
+			FMOD::Channel *channel = reinterpret_cast<FMOD::Channel *>(channelControl);
 			int channelIndex;
 			FMOD_RESULT result = channel->getIndex(&channelIndex);
 
 			// Remove this playing sound index from the SoundContainer if it has any playing sounds, i.e. it hasn't been reset before this callback happened.
 			void *userData;
 			result = (result == FMOD_OK) ? channel->getUserData(&userData) : result;
-			SoundContainer *channelSoundContainer = (SoundContainer *)userData;
+			SoundContainer *channelSoundContainer = static_cast<SoundContainer *>(userData);
 			if (channelSoundContainer->IsBeingPlayed()) { channelSoundContainer->RemovePlayingChannel(channelIndex); }
 			result = (result == FMOD_OK) ? channel->setUserData(NULL) : result;
 

Managers/AudioMan.h

@@ -139,12 +139,12 @@ namespace RTE {
 		double GetGlobalPitch() const { return m_GlobalPitch; }
 
 		/// <summary>
-		/// Sets the global pitch multiplier for all sounds, optionally the music too.
+		/// Sets the global pitch multiplier for mobile sounds, optionally setting it for immobile sounds and music.
 		/// </summary>
-		/// <param name="pitch">New global pitch, limited to 8 octaves up or down (i.e. 0.125 - 8).</param>
-		/// <param name="excludeImmobileSounds">Whether to exclude immobile sounds (normally used for GUI and so on) from pitch modification.</param>
-		/// <param name="excludeMusic">Whether to exclude the music from pitch modification.</param>
-		void SetGlobalPitch(double pitch = 1.0, bool excludeImmobileSounds = false, bool excludeMusic = false);
+		/// <param name="pitch">New global pitch, limited to 8 octaves up or down (i.e. 0.125 - 8). Defaults to 1.</param>
+		/// <param name="includeImmobileSounds">Whether to include immobile sounds (normally used for GUI and so on) in global pitch modification. Defaults to false.</param>
+		/// <param name="includeMusic">Whether to include the music in global pitch modification. Defaults to false.</param>
+		void SetGlobalPitch(double pitch = 1.0, bool includeImmobileSounds = false, bool includeMusic = false);
 #pragma endregion
 
 #pragma region Music Getters and Setters

Managers/FrameMan.cpp

@@ -1970,7 +1970,7 @@ void FrameMan::Update()
 // TODO: Don't hardcode this coefficient - although it's a good defualt
         float pitch = m_SimSpeed + (1.0f - m_SimSpeed) * 0.35;
         // Set the pitch for all other applicable sounds other than music
-        g_AudioMan.SetGlobalPitch(pitch, true);
+        g_AudioMan.SetGlobalPitch(pitch);
 // MUSIC PITCHING IS SUCK.. ruins the songs
         // Only affect the music if it's really slow, so it doesn't sound funny and fluctuating
 // TODO: Don't hardcode this threshold - although it's a good defualt

Managers/NetworkClient.cpp

@@ -672,7 +672,7 @@ namespace RTE
 
 		for (int msgIndex = 0; msgIndex < msg->SoundEventsCount; msgIndex++) {
 			if (sndDataPtr->State == AudioMan::SOUND_SET_GLOBAL_PITCH) {
-				g_AudioMan.SetGlobalPitch(sndDataPtr->Pitch, sndDataPtr->AffectedByGlobalPitch); //Note AffectedByGlobalPitch is hackily used to determine whether this affects music
+				g_AudioMan.SetGlobalPitch(sndDataPtr->Pitch);
 			} else {
 				// The set of SoundContainers that have already been handled for this event, used to hopefully avoid repeating actions when iterating over provided sound channel indices
 				std::unordered_set<SoundContainer *> alreadyHandledSoundContainers;