C4SoundSystem: Fix 'global' script sounds not being constrained to a section and differentiate between section-local and global sounds

Author: Fulgen301

src/C4Control.cpp

@@ -1246,9 +1246,9 @@ void C4ControlMessage::Execute(const std::shared_ptr<spdlog::logger> &) const
 		if (auto *client = Game.Clients.getClientByID(iByClient); client && client->TryAllowSound())
 		{
 			if (client->isMuted()
-				|| StartSoundEffect(szMessage, false, 100, nullptr)
-				|| StartSoundEffect((szMessage + std::string{".ogg"}).c_str(), false, 100, nullptr)
-				|| StartSoundEffect((szMessage + std::string{".mp3"}).c_str(), false, 100, nullptr))
+				|| StartSoundEffect(szMessage, false, 100, C4SoundSystem::GlobalSound)
+				|| StartSoundEffect((szMessage + std::string{".ogg"}).c_str(), false, 100, C4SoundSystem::GlobalSound)
+				|| StartSoundEffect((szMessage + std::string{".mp3"}).c_str(), false, 100, C4SoundSystem::GlobalSound))
 			{
 				if (pLobby) pLobby->OnClientSound(Game.Clients.getClientByID(iByClient));
 			}

src/C4GameLobby.cpp

@@ -350,7 +350,7 @@ void MainDlg::SetCountdownState(CountdownState eToState, int32_t iTimer)
 	// changing away from countdown?
 	if (eCountdownState == CDS_Countdown)
 	{
-		StopSoundEffect("Elevator", nullptr);
+		StopSoundEffect("Elevator", C4SoundSystem::GlobalSound);
 		if (eToState != CDS_Start) StartSoundEffect("Pshshsh");
 	}
 	// change to game start?

src/C4GraphicsSystem.cpp

@@ -776,6 +776,11 @@ int32_t C4GraphicsSystem::GetAudibility(C4Section &section, int32_t iX, int32_t
 	return iAudible;
 }
 
+bool C4GraphicsSystem::IsSectionAudible(C4Section &section) const
+{
+	return std::ranges::any_of(Viewports, [&section](const auto &cvp) { return &cvp->GetViewSection() == &section; });
+}
+
 void C4GraphicsSystem::SetGamma(uint32_t dwClr1, uint32_t dwClr2, uint32_t dwClr3, int32_t iRampIndex)
 {
 	// No gamma effects

src/C4GraphicsSystem.h

@@ -75,6 +75,7 @@ class C4GraphicsSystem
 	bool CreateViewport(int32_t iPlayer, bool fSilent);
 	bool CloseViewport(int32_t iPlayer, bool fSilent);
 	int32_t GetAudibility(C4Section &section, int32_t iX, int32_t iY, int32_t *iPan, int32_t iAudibilityRadius = 0);
+	bool IsSectionAudible(C4Section &section) const;
 	int32_t GetViewportCount();
 	C4Viewport *GetViewport(int32_t iPlayer);
 	const std::vector<std::unique_ptr<C4Viewport>> &GetViewports() { return Viewports; }

src/C4Script.cpp

@@ -2456,10 +2456,19 @@ static bool FnSound(C4AulContext *cthr, C4String *szSound, bool fGlobal, C4Objec
 	if (iLoop >= 0 && !fMultiple && IsSoundPlaying(FnStringPar(szSound), pObj))
 		return true;
 	// try to play effect
+	C4SoundSystem::TargetVariant target;
+	if (fGlobal)
+	{
+		target.emplace<C4Section *>(&cthr->GetSection());
+	}
+	else
+	{
+		target.emplace<C4Object *>(pObj);
+	}
 	if (iLoop >= 0)
-		StartSoundEffect(FnStringPar(szSound), !!iLoop, iLevel, pObj, iCustomFalloffDistance);
+		StartSoundEffect(FnStringPar(szSound), !!iLoop, iLevel, target, iCustomFalloffDistance);
 	else
-		StopSoundEffect(FnStringPar(szSound), pObj);
+		StopSoundEffect(FnStringPar(szSound), target);
 	// always return true (network safety!)
 	return true;
 }

src/C4SoundSystem.cpp

@@ -30,43 +30,43 @@
 #include <utility>
 #include <vector>
 
-bool IsSoundPlaying(const char *const name, const C4Object *const obj)
+bool IsSoundPlaying(const char *const name, const C4SoundSystem::TargetVariant target)
 {
-	return Application.SoundSystem->FindInst(name, obj).has_value();
+	return Application.SoundSystem->FindInst(name, target).has_value();
 }
 
-void SoundLevel(const char *const name, C4Object *const obj, const std::int32_t level)
+void SoundLevel(const char *const name, const C4SoundSystem::TargetVariant target, const std::int32_t level)
 {
 	// Sound level zero? Stop
-	if (level <= 0) { StopSoundEffect(name, obj); return; }
+	if (level <= 0) { StopSoundEffect(name, target); return; }
 	// Set volume of existing instance or create new instance
-	const auto it = Application.SoundSystem->FindInst(name, obj);
+	const auto it = Application.SoundSystem->FindInst(name, target);
 	if (it)
 	{
 		(**it).volume = level;
 	}
 	else
 	{
-		StartSoundEffect(name, true, level, obj);
+		StartSoundEffect(name, true, level, target);
 	}
 }
 
 bool StartSoundEffect(const char *const name, const bool loop, const std::int32_t volume,
-	C4Object *const obj, const std::int32_t falloffDistance)
+	const C4SoundSystem::TargetVariant target, const std::int32_t falloffDistance)
 {
-	return Application.SoundSystem->NewInstance(name, loop, volume, 0, obj, falloffDistance) != nullptr;
+	return Application.SoundSystem->NewInstance(name, loop, volume, 0, target, falloffDistance) != nullptr;
 }
 
 void StartSoundEffectAt(const char *const name, C4Section &section, const std::int32_t x, const std::int32_t y)
 {
 	std::int32_t volume, pan;
 	Application.SoundSystem->GetVolumeByPos(section, x, y, volume, pan);
-	Application.SoundSystem->NewInstance(name, false, volume, pan, nullptr, 0);
+	Application.SoundSystem->NewInstance(name, false, volume, pan, C4SoundSystem::Position{&section, x, y}, 0);
 }
 
-void StopSoundEffect(const char *const name, const C4Object *const obj)
+void StopSoundEffect(const char *const name, const C4SoundSystem::TargetVariant target)
 {
-	if (const auto it = Application.SoundSystem->FindInst(name, obj))
+	if (const auto it = Application.SoundSystem->FindInst(name, target))
 	{
 		(**it).sample.instances.erase(*it);
 	}
@@ -156,7 +156,7 @@ bool C4SoundSystem::Instance::DetachObj()
 	if (loop) return false;
 	// Otherwise: set volume by last position
 	const auto detachedObj = GetObj();
-	obj.emplace<const ObjPos>(*detachedObj);
+	target.emplace<Position>(detachedObj->Section, detachedObj->x, detachedObj->y);
 	GetVolumeByPos(*detachedObj->Section, detachedObj->x, detachedObj->y, volume, pan);
 
 	// Do not stop instance
@@ -200,6 +200,10 @@ bool C4SoundSystem::Instance::Execute(const bool justStarted)
 		vol *= audibility / 100.0f;
 		pan += obj->GetAudiblePan() / 100.0f;
 	}
+	else if (C4Section *const *const section{std::get_if<C4Section *>(&target)}; section && !Game.GraphicsSystem.IsSectionAudible(**section))
+	{
+		vol = 0.0f;
+	}
 
 	// Sound off? Release channel to make it available for other instances.
 	if (vol <= 0.0f)
@@ -237,7 +241,7 @@ bool C4SoundSystem::Instance::Execute(const bool justStarted)
 
 C4Object *C4SoundSystem::Instance::GetObj() const
 {
-	const auto ptr = std::get_if<C4Object *>(&obj);
+	const auto ptr = std::get_if<C4Object *>(&target);
 	return ptr ? *ptr : nullptr;
 }
 
@@ -252,10 +256,10 @@ std::uint32_t C4SoundSystem::Instance::GetPlaybackPosition() const
 bool C4SoundSystem::Instance::IsNear(const C4Object &obj2) const
 {
 	// Attached to object?
-	if (const auto objAsObject = std::get_if<C4Object *>(&obj); objAsObject && *objAsObject)
+	if (const auto targetAsObject = std::get_if<C4Object *>(&target); targetAsObject && *targetAsObject)
 	{
-		const auto x = (**objAsObject).x;
-		const auto y = (**objAsObject).y;
+		const auto x = (**targetAsObject).x;
+		const auto y = (**targetAsObject).y;
 		return (x - obj2.x) * (x - obj2.x) + (y - obj2.y) * (y - obj2.y) <=
 		NearSoundRadius * NearSoundRadius;
 	}
@@ -267,7 +271,7 @@ bool C4SoundSystem::Instance::IsNear(const C4Object &obj2) const
 	return false;
 }
 
-auto C4SoundSystem::FindInst(const char *wildcard, const C4Object *const obj) ->
+auto C4SoundSystem::FindInst(const char *wildcard, const TargetVariant target) ->
 	std::optional<decltype(Sample::instances)::iterator>
 {
 	const auto wildcardStr = PrepareFilename(wildcard);
@@ -279,7 +283,7 @@ auto C4SoundSystem::FindInst(const char *wildcard, const C4Object *const obj) ->
 		if (!WildcardMatch(wildcard, sample.name.c_str())) continue;
 		// Try to find an instance that is bound to obj
 		auto it = std::find_if(sample.instances.begin(), sample.instances.end(),
-			[&](const auto &inst) { return inst.GetObj() == obj; });
+			[&](const auto &inst) { return inst.target == target; });
 		if (it != sample.instances.end()) return it;
 	}
 
@@ -299,7 +303,7 @@ void C4SoundSystem::GetVolumeByPos(C4Section &section, std::int32_t x, std::int3
 }
 
 auto C4SoundSystem::NewInstance(const char *filename, const bool loop,
-	const std::int32_t volume, const std::int32_t pan, C4Object *const obj,
+	const std::int32_t volume, const std::int32_t pan, const TargetVariant target,
 	const std::int32_t falloffDistance) -> Instance *
 {
 	if (!Application.AudioSystem) return nullptr;
@@ -340,15 +344,13 @@ auto C4SoundSystem::NewInstance(const char *filename, const bool loop,
 	if (!loop && sample->instances.size() >= MaxSoundInstances) return nullptr;
 
 	// Already playing near?
-	const auto nearIt = obj ?
-		std::find_if(sample->instances.cbegin(), sample->instances.cend(),
-			[&](const auto &inst) { return inst.IsNear(*obj); }) :
-		std::find_if(sample->instances.cbegin(), sample->instances.cend(),
-			[](const auto &inst) { return !inst.GetObj(); });
+	const auto nearIt = std::holds_alternative<C4Object *>(target)
+						? std::find_if(sample->instances.cbegin(), sample->instances.cend(), [&](const auto &inst) { return inst.IsNear(*std::get<C4Object *>(target)); })
+						: std::find_if(sample->instances.cbegin(), sample->instances.cend(), [&](const auto &inst) { return inst.target == target; });
 	if (nearIt != sample->instances.cend()) return nullptr;
 
 	// Create instance
-	auto &inst = sample->instances.emplace_back(*sample, loop, volume, obj, falloffDistance);
+	auto &inst = sample->instances.emplace_back(*sample, loop, volume, target, falloffDistance);
 	if (!inst.Execute(true))
 	{
 		sample->instances.pop_back();

src/C4SoundSystem.h

@@ -31,15 +31,27 @@
 
 class C4Section;
 
-bool IsSoundPlaying(const char *name, const C4Object *obj);
-void SoundLevel(const char *name, C4Object *obj, std::int32_t iLevel);
-bool StartSoundEffect(const char *name, bool loop = false, std::int32_t volume = 100,
-	C4Object *obj = nullptr, std::int32_t falloffDistance = 0);
-void StartSoundEffectAt(const char *name, C4Section &section, std::int32_t x, std::int32_t y);
-void StopSoundEffect(const char *name, const C4Object *obj);
-
 class C4SoundSystem
 {
+public:
+	struct Position
+	{
+		C4Section *const Section;
+		const int32_t X;
+		const int32_t Y;
+
+		constexpr bool operator==(const Position &other) const = default;
+	};
+
+	struct GlobalSoundMarker
+	{
+		constexpr bool operator==(GlobalSoundMarker) const noexcept { return true; }
+	};
+
+	static inline constexpr GlobalSoundMarker GlobalSound{};
+
+	using TargetVariant = std::variant<C4Object *, Position, C4Section *, GlobalSoundMarker>;
+
 public:
 	static constexpr std::int32_t AudibilityRadius = 700;
 	static constexpr std::int32_t NearSoundRadius = 50;
@@ -81,24 +93,10 @@ class C4SoundSystem
 
 	struct Instance
 	{
-		struct ObjPos
-		{
-			const int32_t x;
-			const int32_t y;
-
-			ObjPos() = delete;
-			ObjPos(const C4Object &obj) : x{obj.x}, y{obj.y} {}
-			ObjPos(const ObjPos &) = delete;
-			ObjPos(ObjPos &&) = delete;
-			~ObjPos() = default;
-			ObjPos &operator=(const ObjPos &) = delete;
-			ObjPos &operator=(ObjPos &&) = delete;
-		};
-
 		Instance(Sample &sample, bool loop, std::int32_t volume,
-			C4Object *obj, std::int32_t falloffDistance)
+			TargetVariant target, std::int32_t falloffDistance)
 			: sample{sample}, loop{loop}, volume{volume},
-			obj{obj}, falloffDistance{falloffDistance},
+			target{target}, falloffDistance{falloffDistance},
 			startTime{std::chrono::steady_clock::now()} {}
 		Instance(const Instance &) = delete;
 		Instance(Instance &&) = delete;
@@ -110,7 +108,7 @@ class C4SoundSystem
 		std::unique_ptr<C4AudioSystem::SoundChannel> channel;
 		const bool loop;
 		std::int32_t volume, pan{0};
-		std::variant<C4Object *, const ObjPos> obj;
+		TargetVariant target;
 		const std::int32_t falloffDistance;
 		const std::chrono::time_point<std::chrono::steady_clock> startTime;
 
@@ -129,19 +127,26 @@ class C4SoundSystem
 
 	// Returns a sound instance that matches the specified name and object.
 	std::optional<decltype(Sample::instances)::iterator> FindInst(
-		const char *wildcard, const C4Object *obj);
+		const char *wildcard, TargetVariant target);
 	// Returns a reference to the "sound enabled" config entry of the current game mode
 	static bool &GetCfgSoundEnabled();
 	static void GetVolumeByPos(C4Section &section, std::int32_t x, std::int32_t y,
 							   std::int32_t &volume, std::int32_t &pan);
 	Instance *NewInstance(const char *filename, bool loop,
-		std::int32_t volume, std::int32_t pan, C4Object *obj, std::int32_t falloffDistance);
+		std::int32_t volume, std::int32_t pan, TargetVariant target, std::int32_t falloffDistance);
 	// Adds default file extension if missing and replaces "*" with "?"
 	static std::string PrepareFilename(const char *filename);
 
-	friend bool IsSoundPlaying(const char *, const C4Object *);
-	friend void SoundLevel(const char *, C4Object *, std::int32_t);
-	friend bool StartSoundEffect(const char *, bool, std::int32_t, C4Object *, std::int32_t);
+	friend bool IsSoundPlaying(const char *, TargetVariant);
+	friend void SoundLevel(const char *, TargetVariant, std::int32_t);
+	friend bool StartSoundEffect(const char *, bool, std::int32_t, C4SoundSystem::TargetVariant, std::int32_t);
 	friend void StartSoundEffectAt(const char *, C4Section &, std::int32_t, std::int32_t);
-	friend void StopSoundEffect(const char *, const C4Object *);
+	friend void StopSoundEffect(const char *, TargetVariant);
 };
+
+bool IsSoundPlaying(const char *name, C4SoundSystem::TargetVariant target);
+void SoundLevel(const char *name, C4SoundSystem::TargetVariant target, std::int32_t iLevel);
+bool StartSoundEffect(const char *name, bool loop = false, std::int32_t volume = 100,
+	C4SoundSystem::TargetVariant target = C4SoundSystem::GlobalSound, std::int32_t falloffDistance = 0);
+void StartSoundEffectAt(const char *name, C4Section &section, std::int32_t x, std::int32_t y);
+void StopSoundEffect(const char *name, C4SoundSystem::TargetVariant target);

src/C4StartupOptionsDlg.cpp

@@ -1365,7 +1365,7 @@ void C4StartupOptionsDlg::OnSoundVolumeSliderChange(int32_t iNewVal)
 	// sound system reads this value directly
 	Config.Sound.SoundVolume = iNewVal;
 	// test sound
-	StartSoundEffect("ArrowHit", false, 100, nullptr);
+	StartSoundEffect("ArrowHit", false, 100, C4SoundSystem::GlobalSound);
 }
 
 bool C4StartupOptionsDlg::KeyMusicToggle()

src/C4Weather.cpp

@@ -102,7 +102,7 @@ void C4Weather::Execute()
 			section.C4S.Weather.Wind.Min,
 			section.C4S.Weather.Wind.Max);
 	if (!Tick10)
-		SoundLevel("Wind", nullptr, (std::max)(Abs(Wind) - 30, 0) * 2);
+		SoundLevel("Wind", &section, (std::max)(Abs(Wind) - 30, 0) * 2);
 	// Disaster launch
 	if (!Tick10)
 	{