UDSoundRuntime.cpp

Go to the documentation of this file.

#include "UDSoundRuntime.hpp"
 
#include <algorithm>
 
namespace monopoly::udsound
{
    namespace
    {
        [[nodiscard]] constexpr data::DataId mainData(data::DataTag tag) noexcept
        { return data::packDataId(data::LegacyGroupId::Main, tag); }
        [[nodiscard]] constexpr data::DataId threeDData(data::DataTag tag) noexcept
        { return data::packDataId(data::LegacyGroupId::ThreeD, tag); }
        [[nodiscard]] constexpr audio::PlaybackKey tokenVoiceKey(std::uint8_t token) noexcept
        { return {audio::PlaybackDomain::Voice, static_cast<std::uint64_t>(token) + 1u}; }
 
        inline constexpr audio::PlaybackKey PennybagsKey{
            audio::PlaybackDomain::Voice, TokenVoiceTokenCount + 1u};
        inline constexpr audio::PlaybackKey WarningKey{audio::PlaybackDomain::Interface, 1};
        inline constexpr audio::PlaybackKey ClickKey{audio::PlaybackDomain::Interface, 2};
        inline constexpr audio::PlaybackKey CashUpKey{audio::PlaybackDomain::Interface, 3};
        inline constexpr audio::PlaybackKey CashDownKey{audio::PlaybackDomain::Interface, 4};
        inline constexpr audio::PlaybackKey BuildKey{audio::PlaybackDomain::Interface, 5};
        inline constexpr audio::PlaybackKey UnbuildKey{audio::PlaybackDomain::Interface, 6};
        inline constexpr audio::PlaybackKey SirenKey{audio::PlaybackDomain::Interface, 7};
        inline constexpr audio::PlaybackKey SaveFailureKey{audio::PlaybackDomain::Interface, 8};
        inline constexpr audio::PlaybackKey MusicKey{audio::PlaybackDomain::Music, 1};
        // C_ArtLib.h:525 initializes sounds without SetVolume at 32 percent.
        // These direct audio helpers bypass that sequencer initialization, so
        // carry the same per-sound gain into SDL (no global volume adjustment).
        inline constexpr float DefaultEffectGain = 0.32F;
        inline constexpr float PennybagsGain = 0.70F;
    }
    std::expected<void, std::string> Runtime::warning(audio::Runtime& audio)
    { return audio.play(WarningKey, mainData(WarningTag), DefaultEffectGain); }
    std::expected<void, std::string> Runtime::click(audio::Runtime& audio)
    { return audio.play(ClickKey, mainData(ClickTag), 0.25F); }
    std::expected<void, std::string> Runtime::build(audio::Runtime& audio)
    { return audio.play(BuildKey, mainData(BuildTag), DefaultEffectGain); }
    std::expected<void, std::string> Runtime::unbuild(audio::Runtime& audio)
    { return audio.play(UnbuildKey, mainData(UnbuildTag), DefaultEffectGain); }
    std::expected<void, std::string> Runtime::saveFailure(audio::Runtime& audio)
    { return audio.play(SaveFailureKey, mainData(SaveFailureTag), DefaultEffectGain); }
    std::expected<void, std::string> Runtime::siren(
        audio::Runtime& audio, std::uint8_t variant)
    {
        if (variant >= SirenCount)
            return std::unexpected("Paddywagon siren variant is outside retail 0..1 range");
        return audio.play(SirenKey, threeDData(static_cast<data::DataTag>(
            SirenBaseTag + variant)), 0.74F);
    }
    std::expected<void, std::string> Runtime::cashUp(audio::Runtime& audio)
    { return audio.play(CashUpKey, mainData(CashUpTag), DefaultEffectGain); }
    std::expected<void, std::string> Runtime::cashDown(audio::Runtime& audio)
    { return audio.play(CashDownKey, mainData(CashDownTag), DefaultEffectGain); }
 
    std::expected<void, std::string> Runtime::syncCash(
        audio::Runtime& audio, ibar::ScoreCashChange change)
    {
        if (change == ibar::ScoreCashChange::Up) return cashUp(audio);
        if (change == ibar::ScoreCashChange::Down) return cashDown(audio);
        return {};
    }
 
    std::expected<void, std::string> Runtime::syncMusic(
        audio::Runtime& audio, bool gameInProgress,
        bool musicOn, std::uint8_t tuneIndex, bool creditsActive)
    {
        data::DataId desired{};
        bool loop = true;
 
        if (creditsActive)
        {
            const auto credits = mainData(CreditsTag);
            const auto creditsLoop = mainData(MusicBaseTag);
            if (creditsMusicStatus_ == 0)
                creditsMusicStatus_ = 1;
            else if (creditsMusicStatus_ == 1 &&
                currentMusic_ == credits && !audio.active(MusicKey))
                creditsMusicStatus_ = 2;
 
            desired = creditsMusicStatus_ == 2 ? creditsLoop : credits;
            loop = creditsMusicStatus_ == 2;
        }
        else
        {
            creditsMusicStatus_ = 0;
            if (!gameInProgress || !musicOn)
            {
                if (currentMusic_) audio.stop(MusicKey);
                currentMusic_.reset();
                return {};
            }
            const auto safeTune = std::min<std::uint8_t>(
                tuneIndex, MusicTuneCount - 1);
            desired = mainData(static_cast<data::DataTag>(
                MusicBaseTag + safeTune));
        }
 
        if (currentMusic_ == desired && audio.active(MusicKey)) return {};
        if (currentMusic_ && *currentMusic_ != desired)
            audio.stop(MusicKey);
        const auto played = audio.play(MusicKey, desired, 0.20F, loop);
        if (!played) return played;
        currentMusic_ = desired;
        return {};
    }
 
    bool Runtime::tokenVoiceActive(
        const audio::Runtime& audio, std::uint8_t token) const noexcept
    {
        return token < TokenVoiceTokenCount && audio.active(tokenVoiceKey(token));
    }
 
    bool Runtime::anyTalking(const audio::Runtime& audio) const noexcept
    {
        if (audio.active(PennybagsKey)) return true;
        for (std::uint8_t token = 0; token < TokenVoiceTokenCount; ++token)
            if (tokenVoiceActive(audio, token)) return true;
        return false;
    }
 
    void Runtime::stopTalking(audio::Runtime& audio) noexcept
    {
        audio.stop(PennybagsKey);
        for (std::uint8_t token = 0; token < TokenVoiceTokenCount; ++token)
            audio.stop(tokenVoiceKey(token));
        watchedTokenVoices_.fill(false);
        watchedPennybags_ = false;
        pendingTalkingVoice_.reset();
    }
 
    void Runtime::watchTalking(const audio::Runtime& audio) noexcept
    {
        if (audio.active(PennybagsKey)) watchedPennybags_ = true;
        for (std::uint8_t token = 0; token < TokenVoiceTokenCount; ++token)
            if (tokenVoiceActive(audio, token)) watchedTokenVoices_[token] = true;
    }
 
    std::expected<void, std::string> Runtime::startTalkingVoice(
        audio::Runtime& audio, const PendingTalkingVoice& voice)
    {
        if (voice.token)
        {
            if (*voice.token >= TokenVoiceTokenCount)
                return std::unexpected("token voice token is out of range");
            return audio.play(tokenVoiceKey(*voice.token), voice.wave, voice.gain, false);
        }
        return audio.play(PennybagsKey, voice.wave, voice.gain, false);
    }
 
    std::expected<TokenVoicePlayResult, std::string> Runtime::playTalkingVoice(
        audio::Runtime& audio, PendingTalkingVoice voice,
        TokenVoiceClipPolicy policy)
    {
        TokenVoicePlayResult result{};
        const bool talking = anyTalking(audio);
        switch (policy)
        {
        case TokenVoiceClipPolicy::ClipOldSoundIfPlaying:
        case TokenVoiceClipPolicy::ClipOldSoundIfPlayingWithLock:
            stopTalking(audio);
            break;
        case TokenVoiceClipPolicy::SkipIfOldSoundPlaying:
            if (talking || pendingTalkingVoice_)
            {
                result.skipped = true;
                return result;
            }
            break;
        case TokenVoiceClipPolicy::WaitForAnyOldSoundThenPlay:
        case TokenVoiceClipPolicy::WaitForAnyOldSoundThenPlayWithLock:
            if (talking || pendingTalkingVoice_)
            {
                watchTalking(audio);
                pendingTalkingVoice_ = voice;
                result.queued = true;
                return result;
            }
            break;
        }
 
        const auto started = startTalkingVoice(audio, voice);
        if (!started) return std::unexpected(started.error());
        result.started = true;
        const bool lockNew =
            policy == TokenVoiceClipPolicy::ClipOldSoundIfPlayingWithLock ||
            policy == TokenVoiceClipPolicy::WaitForAnyOldSoundThenPlayWithLock;
        if (lockNew)
        {
            if (voice.token) watchedTokenVoices_[*voice.token] = true;
            else watchedPennybags_ = true;
        }
        return result;
    }
 
    std::expected<TokenVoicePlayResult, std::string> Runtime::tokenVoice(
        audio::Runtime& audio, bool voicesOn, std::uint8_t token,
        TokenVoiceLine line, TokenVoiceClipPolicy policy,
        std::uint32_t randomValue)
    {
        TokenVoicePlayResult result{};
        if (!voicesOn) return result;
        const auto wave = chooseTokenVoice(audio.boardEdition(), line, token, randomValue);
        if (!wave)
        {
            result.skipped = true;
            return result;
        }
        return playTalkingVoice(audio, PendingTalkingVoice{token, *wave, 1.0F}, policy);
    }
    std::expected<TokenVoicePlayResult, std::string> Runtime::pennybagsVoice(
        audio::Runtime& audio, bool hostCommentsOn, PennybagsVoice voice,
        TokenVoiceClipPolicy policy, std::uint32_t randomValue)
    {
        TokenVoicePlayResult result{};
        if (!hostCommentsOn) return result;
        const auto wave = choosePennybagsVoice(audio.boardEdition(), voice, randomValue);
        if (!wave)
        {
            result.skipped = true;
            return result;
        }
        return playTalkingVoice(audio,
            PendingTalkingVoice{std::nullopt, *wave, PennybagsGain}, policy);
    }
 
    std::expected<TokenVoicePlayResult, std::string> Runtime::pennybagsSpecific(
        audio::Runtime& audio, bool hostCommentsOn, data::DataId wave,
        TokenVoiceClipPolicy policy)
    {
        TokenVoicePlayResult result{};
        if (!hostCommentsOn || wave == data::EmptyDataId) return result;
        return playTalkingVoice(audio,
            PendingTalkingVoice{std::nullopt, wave, PennybagsGain}, policy);
    }
 
    std::expected<bool, std::string> Runtime::syncTokenVoices(audio::Runtime& audio)
    {
        for (std::uint8_t token = 0; token < TokenVoiceTokenCount; ++token)
            if (watchedTokenVoices_[token] && !tokenVoiceActive(audio, token))
                watchedTokenVoices_[token] = false;
        if (watchedPennybags_ && !audio.active(PennybagsKey))
            watchedPennybags_ = false;
 
        if (pendingTalkingVoice_ && !anyTalking(audio))
        {
            const auto pending = *pendingTalkingVoice_;
            pendingTalkingVoice_.reset();
            const auto started = startTalkingVoice(audio, pending);
            if (!started) return std::unexpected(started.error());
            // Retail releases the previous lock before starting SoundToPlayPostLock;
            // the posted voice is therefore not automatically watched again.
        }
 
        const bool watchedToken = std::any_of(watchedTokenVoices_.begin(),
            watchedTokenVoices_.end(), [](bool value) { return value; });
        return watchedToken || watchedPennybags_;
    }
 
    bool Runtime::talkingQueueIdle(const audio::Runtime& audio) const noexcept
    {
        return !anyTalking(audio) && !pendingTalkingVoice_;
    }
 
    void Runtime::watchTokenVoice(audio::Runtime& audio, std::uint8_t token) noexcept
    {
        if (token < TokenVoiceTokenCount && tokenVoiceActive(audio, token))
            watchedTokenVoices_[token] = true;
    }
 
    void Runtime::watchPennybags(audio::Runtime& audio) noexcept
    {
        if (audio.active(PennybagsKey)) watchedPennybags_ = true;
    }
    void Runtime::reset(audio::Runtime* audio) noexcept
    {
        if (audio != nullptr)
        {
            audio->stop(WarningKey); audio->stop(ClickKey);
            audio->stop(CashUpKey); audio->stop(CashDownKey);
            audio->stop(MusicKey); audio->stop(PennybagsKey);
            for (std::uint8_t token = 0; token < TokenVoiceTokenCount; ++token)
                audio->stop(tokenVoiceKey(token));
        }
        currentMusic_.reset();
        creditsMusicStatus_ = 0;
        pendingTalkingVoice_.reset();
        watchedTokenVoices_.fill(false);
        watchedPennybags_ = false;
    }
}