IBar.cpp

Go to the documentation of this file.

#include "IBar.hpp"
 
#include "IBarCameraButtonPlayback.hpp"
#include "CardTypes.hpp"
 
#include "Display.hpp"
#include "LocalPlayers.hpp"
#include "Messaging.hpp"
#include "PlayerSelection.hpp"
#include "RuntimeState.hpp"
#include "Timers.hpp"
#include "UserInterface.hpp"
#include "UISound.hpp"
 
#include <SDL3/SDL_scancode.h>
 
#include <algorithm>
#include <cstddef>
 
namespace monopoly::ibar
{
    namespace
    {
        State globalState;
        inline constexpr std::uint64_t EscapeMenuTimeoutTicks =
            static_cast<std::uint64_t>(timers::BasicClockRateHz) * 10u;
 
        void openEscapeMenu(bool newGame, bool exit) noexcept
        {
            globalState.userRequestedNewGame = newGame;
            globalState.userRequestedExit = exit;
            globalState.escapeMenuUp = true;
            globalState.escapeMenuOpenedTick = timers::tickCount();
        }
 
        void closeEscapeMenu(bool restoreOptions, bool playClick) noexcept
        {
            if (playClick) engine::playClickSound();
            globalState.escapeMenuUp = false;
            globalState.userRequestedExit = false;
            globalState.userRequestedNewGame = false;
            if (restoreOptions && !globalState.userChoseToExit &&
                display::stateReadOnly().desired2DView == display::Screen2D::Options)
            {
                display::setBackdrop(userinterface::optionsStateReadOnly().previousView);
            }
        }
 
        void sendRetailNewGame() noexcept
        {
            const auto localPlayer = ui::localplayers::anyLocalPlayer(
                userinterface::ruleStateReadOnly());
            if (localPlayer < rules::MaxPlayers)
                (void)messaging::sendAction(actions::Type::NewGame,
                    localPlayer, rules::BankPlayer, 0);
        }
 
        void enterExitCredits() noexcept
        {
            globalState.userChoseToExit = true;
            auto& options = userinterface::optionsState();
            options.currentScreen = optionsui::Screen::Credits;
            options.active = true;
            display::setBackdrop(display::Screen2D::Options);
        }
 
        void acceptEscapeMenu() noexcept
        {
            engine::playClickSound();
            if (globalState.userRequestedNewGame)
            {
                sendRetailNewGame();
            }
            else if ((display::isIBarVisible(display::stateReadOnly().desired2DView) ||
                      runtime::state().gameInProgress) &&
                     !globalState.userRequestedExit)
            {
                sendRetailNewGame();
            }
            else
            {
                enterExitCredits();
            }
            // Retail routes Yes through the same hitN teardown, including its
            // second Click SFX and request-flag reset.
            closeEscapeMenu(true, true);
        }
 
        void finishExitCredits() noexcept
        {
            globalState.userChoseToExit = false;
            optionsui::reset(userinterface::optionsState());
            display::setBackdrop(display::Screen2D::Black);
            runtime::state().gameQuitRequested = true;
        }
 
        [[nodiscard]] bool processEscapeInput(const uimsg::Message& message) noexcept
        {
            if (globalState.userChoseToExit &&
                (message.type == uimsg::Type::MouseLeftDown ||
                 message.type == uimsg::Type::KeyboardPressed))
            {
                finishExitCredits();
                return true;
            }
 
            if (message.type == uimsg::Type::KeyboardPressed)
            {
                const auto key = static_cast<SDL_Scancode>(message.numberA);
                if (key == SDL_SCANCODE_ESCAPE)
                {
                    globalState.escapeMenuUp = !globalState.escapeMenuUp;
                    if (globalState.escapeMenuUp)
                        globalState.escapeMenuOpenedTick = timers::tickCount();
                    return true;
                }
                if (globalState.escapeMenuUp && key == SDL_SCANCODE_Y)
                {
                    acceptEscapeMenu();
                    return true;
                }
                if (globalState.escapeMenuUp && key == SDL_SCANCODE_N)
                {
                    closeEscapeMenu(true, true);
                    return true;
                }
            }
 
            if (globalState.escapeMenuUp && message.type == uimsg::Type::MouseLeftDown)
            {
                const int x = static_cast<int>(message.numberA);
                const int y = static_cast<int>(message.numberB);
                if (x >= 299 && x <= 381 && y >= 183 && y <= 219)
                {
                    acceptEscapeMenu();
                    return true;
                }
                if (x >= 419 && x <= 501 && y >= 183 && y <= 219)
                {
                    closeEscapeMenu(true, true);
                    return true;
                }
            }
            return false;
        }
 
 
        [[nodiscard]] bool clearsBuyAuctionPopup(actions::Type action) noexcept
        {
            switch (action)
            {
            case actions::Type::NotifyNamePlayer:
            case actions::Type::NotifyAddLocalPlayer:
            case actions::Type::NotifyPlayerDeleted:
            case actions::Type::NotifyPleaseAddPlayers:
            case actions::Type::NotifyNumberOfPlayers:
            case actions::Type::NotifyProposedConfiguration:
            case actions::Type::NotifyAuctionGoing:
            case actions::Type::NotifyNewHighBid:
            case actions::Type::NotifyPleaseRollDice:
            case actions::Type::NotifyEndTurn:
            case actions::Type::NotifyStartTurn:
            case actions::Type::NotifyDiceRolled:
            case actions::Type::NotifyBuyOrAuctionDecision:
            case actions::Type::NotifyMoveForwards:
            case actions::Type::NotifyMoveBackwards:
            case actions::Type::NotifyJumpToSquare:
            case actions::Type::NotifyCashAmount:
            case actions::Type::NotifyPassedGo:
            case actions::Type::NotifyPleasePay:
            case actions::Type::NotifyJailExitChoice:
            case actions::Type::NotifyPickedUpCard:
            case actions::Type::NotifyPutAwayCard:
            case actions::Type::NotifySquareOwnership:
            case actions::Type::NotifySquareMortgage:
            case actions::Type::NotifyFreeUnmortgaging:
            case actions::Type::NotifySquareHouses:
            case actions::Type::NotifyJailCardOwnership:
            case actions::Type::NotifyHousingShortage:
            case actions::Type::NotifyFlatOrFractionTaxDecision:
            case actions::Type::NotifyPlaceBuilding:
            case actions::Type::NotifyDecomposeSale:
            case actions::Type::NotifyPlayerBuySellMort:
            case actions::Type::NotifyImmunityCount:
            case actions::Type::NotifyFutureRentCount:
            case actions::Type::NotifyFreeParkingPot:
            case actions::Type::NotifyCashAnimation:
            case actions::Type::NotifyTradeFinished:
            case actions::Type::NotifyTradeStarted:
            case actions::Type::NotifyTradeEditor:
            case actions::Type::NotifyTradeAcceptanceDecision:
            case actions::Type::NotifyTradeItem:
                return true;
            default:
                return false;
            }
        }
 
 
        bool playerSelectVisible()
        {
            const auto view =
                display::stateReadOnly()
                    .desired2DView;
 
 
            return
                view ==
                    display::Screen2D::
                        PlayerSelect ||
                view ==
                    display::Screen2D::
                        PlayerSelectRules;
        }
 
 
        bool playerBarVisible()
        {
            const auto view =
                display::stateReadOnly()
                    .desired2DView;
 
 
            // DISPLAY_IsIBarVisible + les deux ecrans de setup.
            return
                playerSelectVisible() ||
                view == display::Screen2D::Portfolio ||
                view == display::Screen2D::Main ||
                view == display::Screen2D::Trade;
        }
 
 
        int playerHit(
            int x,
            int y)
        {
            for (
                int player = 0;
                player <
                    static_cast<int>(
                        rules::MaxPlayers
                    );
                ++player)
            {
                const PlayerDisplay& slot =
                    globalState.players[
                        static_cast<std::size_t>(
                            player
                        )
                    ];
 
 
                if (
                    slot.visible &&
                    slot.rect.contains(
                        x,
                        y
                    ))
                {
                    return player;
                }
            }
 
 
            return -1;
        }
 
 
        int playerOrBankHit(int x, int y)
        {
            const int player = playerHit(x, y);
            if (player >= 0) return player;
            if (layout::bankHitRect().contains(x, y))
                return static_cast<int>(rules::BankPlayer);
            return -1;
        }
 
 
        std::optional<layout::ActionButtonSlot> actionHit(
            int x,
            int y) noexcept
        {
            const auto ruleButton = layout::actionButtonHit(
                x,
                y,
                globalState.actionButtonLayout,
                globalState.activeActionButtonSlots);
            if (ruleButton)
                return ruleButton;
 
            if (display::isIBarVisible(display::stateReadOnly().desired2DView))
            {
                if (layout::actionButtonRect(
                        layout::ActionButtonSlot::Camera,
                        globalState.actionButtonLayout).contains(x, y))
                {
                    return layout::ActionButtonSlot::Camera;
                }
 
                // IBAR_Status is a global view button, independent of the
                // projected RULE action mask.  Its art changes between Status
                // and Main, but the physical hit rectangle is shared.
                if (runtime::state().gameInProgress &&
                    layout::actionButtonRect(
                        layout::ActionButtonSlot::Status,
                        globalState.actionButtonLayout).contains(x, y))
                {
                    const auto view = display::stateReadOnly().desired2DView;
                    if (view == display::Screen2D::Main ||
                        view == display::Screen2D::Portfolio ||
                        view == display::Screen2D::Trade)
                    {
                        return layout::ActionButtonSlot::Status;
                    }
                }
            }
            return std::nullopt;
        }
 
 
        bool sendRuleAction(
            actions::Type action,
            std::int64_t numberA = 0,
            std::int64_t numberB = 0,
            std::int64_t numberC = 0,
            std::int64_t numberD = 0)
        {
            if (globalState.actionRemote ||
                globalState.actionPlayer >= rules::MaxPlayers)
            {
                return false;
            }
 
            return messaging::sendAction(
                action,
                globalState.actionPlayer,
                rules::BankPlayer,
                numberA,
                numberB,
                numberC,
                numberD);
        }
 
        bool handleGlobalAction(
            layout::ActionButtonSlot slot,
            const uimsg::Message& message) noexcept
        {
            const auto& uiState = userinterface::ruleStateReadOnly();
            if (slot == layout::ActionButtonSlot::Status)
            {
                const auto view = display::stateReadOnly().desired2DView;
                if (view == display::Screen2D::Main)
                {
                    display::setBackdrop(display::Screen2D::Portfolio);
                    globalState.pendingPressedButton = StatusButtonIndex;
                    return true;
                }
                if (view == display::Screen2D::Portfolio ||
                    view == display::Screen2D::Trade)
                {
                    display::setBackdrop(display::Screen2D::Main);
                    globalState.pendingPressedButton = MainButtonIndex;
                    return true;
                }
                return false;
            }
 
            if (slot == layout::ActionButtonSlot::Options)
            {
                if (!userinterface::beginOptionsFromIBar())
                    return false;
                globalState.pendingPressedButton = OptionsButtonIndex;
                return true;
            }
 
            if (slot == layout::ActionButtonSlot::Trade)
            {
                auto tradePlayer = resolveRulePlayer(globalState.projectedRulePlayer);
                const auto validTradePlayer = [&](rules::PlayerNumber player) noexcept {
                    return player < rules::MaxPlayers &&
                        player < uiState.numberOfPlayers;
                };
                if (!validTradePlayer(tradePlayer))
                    tradePlayer = globalState.projectedRulePlayer;
                if (!validTradePlayer(tradePlayer))
                    tradePlayer = uiState.currentPlayer;
                if (!validTradePlayer(tradePlayer) ||
                    !userinterface::beginTradeFromIBar(tradePlayer))
                {
                    return false;
                }
                globalState.pendingPressedButton = TradeButtonIndex;
                return true;
            }
 
            if (slot != layout::ActionButtonSlot::Camera)
                return false;
 
            auto cameraPlayer = resolveRulePlayer(globalState.projectedRulePlayer);
            const auto validPlayer = [&](rules::PlayerNumber player) noexcept {
                return player < rules::MaxPlayers &&
                    player < uiState.numberOfPlayers;
            };
            if (!validPlayer(cameraPlayer))
                cameraPlayer = globalState.projectedRulePlayer;
            if (!validPlayer(cameraPlayer))
                cameraPlayer = uiState.currentPlayer;
 
            const std::int32_t currentSquare = validPlayer(cameraPlayer)
                ? static_cast<std::int32_t>(uiState.players[cameraPlayer].currentSquare)
                : 0;
            const bool sequential = display::stateReadOnly().mouseRightPressed ||
                (message.numberE & uimsg::MouseModifierControl) != 0;
 
            display::cycleIBarCamera(currentSquare, sequential);
            globalState.pendingPressedButton = CameraButtonIndex;
            return true;
        }
 
 
        void leaveLocalRuleMode() noexcept
        {
            globalState.localRuleModeActive = false;
            globalState.localRuleMode = RuleMode::Nothing;
            globalState.localRulePlayer = rules::NobodyPlayer;
            globalState.selectedDeed.reset();
        }
 
 
        [[nodiscard]] RuleMode otherPlayerMode(rules::PlayerNumber player) noexcept
        {
            if (player == rules::BankPlayer ||
                (player < rules::MaxPlayers &&
                 ui::localplayers::slotIsLocalHumanPlayer(player)))
            {
                return RuleMode::OtherPlayer;
            }
            return RuleMode::OtherPlayerRemote;
        }
 
 
        void enterLocalRuleMode(
            RuleMode mode,
            rules::PlayerNumber player = rules::NobodyPlayer) noexcept
        {
            if (player <= rules::BankPlayer)
            {
                globalState.localRulePlayer = player;
            }
            else if (!globalState.localRuleModeActive)
            {
                globalState.localRulePlayer = globalState.actionPlayer;
            }
 
            globalState.localRuleModeActive = true;
            globalState.localRuleMode = mode;
            if (mode != RuleMode::DeedActive)
                globalState.selectedDeed.reset();
        }
 
 
        void returnFromLocalDetail() noexcept
        {
            if (globalState.localRulePlayer == globalState.projectedRulePlayer)
            {
                leaveLocalRuleMode();
                return;
            }
 
            globalState.localRuleModeActive = true;
            globalState.localRuleMode = otherPlayerMode(globalState.localRulePlayer);
            globalState.selectedDeed.reset();
        }
 
 
        bool handlePlayerOrBankClick(int hit) noexcept
        {
            if (hit < 0 || hit > static_cast<int>(rules::BankPlayer))
                return false;
 
            const auto selected = static_cast<rules::PlayerNumber>(hit);
            if (selected == globalState.projectedRulePlayer)
            {
                leaveLocalRuleMode();
                return true;
            }
 
            enterLocalRuleMode(otherPlayerMode(selected), selected);
            return true;
        }
 
 
        bool dispatchDirectRuleAction(
            layout::ActionButtonSlot slot)
        {
            using Slot = layout::ActionButtonSlot;
            switch (globalState.actionRuleMode)
            {
            case RuleMode::StartTurn:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::RollDice);
                break;
 
            case RuleMode::DoneTurn:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::EndTurn);
                break;
 
            case RuleMode::ViewingCard:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::CardSeen);
                break;
 
            case RuleMode::FreeUnmortgage:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::FreeUnmortgageDone);
                break;
 
            case RuleMode::BuyAuction:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::BuyOrAuctionDecision, 1);
                if (slot == Slot::General3)
                    return sendRuleAction(actions::Type::BuyOrAuctionDecision, 0);
                break;
 
            case RuleMode::TaxDecision:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::TaxDecision, 0);
                if (slot == Slot::General3)
                    return sendRuleAction(actions::Type::TaxDecision, 1);
                break;
 
            case RuleMode::JailExitPCR:
            case RuleMode::JailExitPXR:
            case RuleMode::JailExitPCX:
            case RuleMode::JailExitPXX:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::ExitJailDecision, 0);
                if (slot == Slot::General2)
                    return sendRuleAction(actions::Type::ExitJailDecision, 1);
                if (slot == Slot::General3)
                    return sendRuleAction(actions::Type::ExitJailDecision, 2);
                break;
 
            case RuleMode::Trading:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::TradeAccept, 0, 0);
                if (slot == Slot::General2)
                    return sendRuleAction(actions::Type::TradeAccept, 0, -1);
                if (slot == Slot::General3)
                    return sendRuleAction(actions::Type::TradeAccept, 1, 1);
                break;
 
            case RuleMode::RaiseMoney:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::GoBankrupt);
                break;
 
            case RuleMode::HousingShort:
            case RuleMode::HotelShort:
                if (slot == Slot::Main)
                    return sendRuleAction(actions::Type::StartHousingAuction);
                break;
 
            default:
                break;
            }
 
            return false;
        }
 
 
        bool handleLocalRuleAction(layout::ActionButtonSlot slot)
        {
            using Slot = layout::ActionButtonSlot;
            const auto enterBssm = [&](RuleMode mode, std::uint8_t buttonIndex)
            {
                globalState.pendingPressedButton = buttonIndex;
                enterLocalRuleMode(mode);
                udsound::PennybagsVoice voice = udsound::PennybagsVoice::PlayerClicks_BuyHouseHotel;
                switch (mode)
                {
                case RuleMode::Sell: voice = udsound::PennybagsVoice::PlayerClicks_SellHouseHotel; break;
                case RuleMode::Mortgage: voice = udsound::PennybagsVoice::PlayerClicks_Mortgage; break;
                case RuleMode::UnMortgage: voice = udsound::PennybagsVoice::PlayerClicks_UnMortgage; break;
                default: break;
                }
                engine::playPennybagsVoice(voice,
                    udsound::TokenVoiceClipPolicy::SkipIfOldSoundPlaying, false);
                return true;
            };
 
            switch (globalState.actionRuleMode)
            {
            case RuleMode::StartTurn:
            case RuleMode::DoneTurn:
            case RuleMode::FreeUnmortgage:
                if (slot == Slot::General1) return enterBssm(RuleMode::Build, BuildButtonIndex);
                if (slot == Slot::General2) return enterBssm(RuleMode::Sell, SellButtonIndex);
                if (slot == Slot::General3) return enterBssm(RuleMode::Mortgage, MortgageButtonIndex);
                if (slot == Slot::General4) return enterBssm(RuleMode::UnMortgage, UnmortButtonIndex);
                break;
 
            case RuleMode::OtherPlayer:
                if (slot == Slot::General1) return enterBssm(RuleMode::Build, BuildButtonIndex);
                if (slot == Slot::General2) return enterBssm(RuleMode::Sell, SellButtonIndex);
                if (slot == Slot::General3) return enterBssm(RuleMode::Mortgage, MortgageButtonIndex);
                if (slot == Slot::General4) return enterBssm(RuleMode::UnMortgage, UnmortButtonIndex);
                if (slot == Slot::Main)
                {
                    globalState.pendingPressedButton = DoneButtonIndex;
                    leaveLocalRuleMode();
                    return true;
                }
                break;
 
            case RuleMode::OtherPlayerRemote:
                if (slot == Slot::Main)
                {
                    globalState.pendingPressedButton = DoneButtonIndex;
                    leaveLocalRuleMode();
                    return true;
                }
                break;
 
            case RuleMode::RaiseMoney:
                if (slot == Slot::General2) return enterBssm(RuleMode::Sell, SellButtonIndex);
                if (slot == Slot::General3) return enterBssm(RuleMode::Mortgage, MortgageButtonIndex);
                break;
 
            case RuleMode::GameOver:
                if (slot == Slot::General2)
                {
                    const auto localPlayer = ui::localplayers::anyLocalPlayer(
                        userinterface::ruleStateReadOnly());
                    if (localPlayer >= rules::MaxPlayers ||
                        !messaging::sendAction(actions::Type::NewGame, localPlayer,
                            rules::BankPlayer, 0))
                    {
                        return false;
                    }
                    globalState.pendingPressedButton = NewGameButtonIndex;
                    return true;
                }
                if (slot == Slot::Main)
                {
                    // Retail sets g_UserRequestedExit then feeds an Escape key
                    // back through UDIBAR_ProcessMessage.
                    globalState.pendingPressedButton = ExitButtonIndex;
                    openEscapeMenu(false, true);
                    return true;
                }
                break;
 
            case RuleMode::Build:
            case RuleMode::Sell:
            case RuleMode::Mortgage:
            case RuleMode::UnMortgage:
                if (slot == Slot::Main)
                {
                    globalState.pendingPressedButton = DoneButtonIndex;
                    returnFromLocalDetail();
                    return true;
                }
                break;
 
            case RuleMode::DeedActive:
                if (slot == Slot::Main)
                {
                    globalState.pendingPressedButton = DoneButtonIndex;
                    returnFromLocalDetail();
                    return true;
                }
                if (!globalState.selectedDeed) break;
                if (slot == Slot::General1)
                    return sendRuleAction(actions::Type::BuyHouse,
                        *globalState.selectedDeed, 0, 0, 1);
                if (slot == Slot::General2)
                    return sendRuleAction(actions::Type::SellBuildings,
                        *globalState.selectedDeed, 0, 0, 1);
                if (slot == Slot::General3 || slot == Slot::General4)
                    return sendRuleAction(actions::Type::Mortgaging,
                        *globalState.selectedDeed, 0, 0, 1);
                break;
 
            default:
                break;
            }
 
            return false;
        }
 
 
        bool handlePropertyClick(int square)
        {
            switch (globalState.actionRuleMode)
            {
            case RuleMode::StartTurn:
            case RuleMode::OtherPlayer:
            case RuleMode::DoneTurn:
            case RuleMode::JailExitPCR:
            case RuleMode::JailExitPXR:
            case RuleMode::JailExitPCX:
            case RuleMode::JailExitPXX:
            case RuleMode::BuyAuction:
            case RuleMode::RaiseMoney:
                if (square >= 0 && square < static_cast<int>(rules::SquareCount) &&
                    userinterface::ruleStateReadOnly().squares[
                        static_cast<std::size_t>(square)].owner == globalState.actionPlayer)
                {
                    globalState.selectedDeed = static_cast<std::uint8_t>(square);
                    enterLocalRuleMode(RuleMode::DeedActive);
                    return true;
                }
                break;
 
            case RuleMode::FreeUnmortgage:
                return sendRuleAction(actions::Type::Mortgaging, square);
 
            case RuleMode::Mortgage:
            case RuleMode::UnMortgage:
                return sendRuleAction(actions::Type::Mortgaging, square, 0, 0, 1);
 
            case RuleMode::Build:
                return sendRuleAction(actions::Type::BuyHouse, square, 0, 0, 1);
 
            case RuleMode::Sell:
            case RuleMode::HotelDecomposition:
                return sendRuleAction(actions::Type::SellBuildings, square, 0, 0, 1);
 
            case RuleMode::PlaceHouse:
            case RuleMode::PlaceHotel:
                return sendRuleAction(actions::Type::BuyHouse, square);
 
            default:
                break;
            }
 
            return false;
        }
    }
 
 
 
    bool initialize()
    {
        // DISPLAY_UDIBAR_Initialize().
 
        globalState = {};
 
        globalState.playerLastMouseOver =
            -1;
 
        globalState.playerCurrentMouseOver =
            -1;
 
        globalState.initialized =
            true;
 
 
        return true;
    }
 
 
    void shutdown()
    {
        // DISPLAY_UDIBAR_Destroy().
 
        globalState = {};
    }
 
 
    void tickActions(
        std::uint64_t numberOfTicks)
    {
        (void)numberOfTicks;
        if (globalState.escapeMenuUp &&
            globalState.escapeMenuOpenedTick + EscapeMenuTimeoutTicks < timers::tickCount())
        {
            closeEscapeMenu(true, true);
        }
    }
 
 
    bool requestNewGameConfirmation() noexcept
    {
        if (!globalState.initialized || globalState.userChoseToExit) return false;
        openEscapeMenu(true, false);
        return true;
    }
 
    bool requestExitConfirmation() noexcept
    {
        if (!globalState.initialized || globalState.userChoseToExit) return false;
        openEscapeMenu(false, true);
        return true;
    }
 
 
    void show()
    {
        if (!globalState.initialized)
        {
            return;
        }
 
 
        const rules::GameState& uiState =
            userinterface::ruleStateReadOnly();
 
 
        const display::State& displayState =
            display::stateReadOnly();
 
 
        const int numberOfPlayers =
            std::clamp(
                static_cast<int>(
                    uiState.numberOfPlayers
                ),
                0,
                static_cast<int>(
                    rules::MaxPlayers
                )
            );
 
 
        const bool showPlayerBar =
            playerBarVisible();
 
 
        for (
            int player = 0;
            player <
                static_cast<int>(
                    rules::MaxPlayers
                );
            ++player)
        {
            PlayerDisplay& result =
                globalState.players[
                    static_cast<std::size_t>(
                        player
                    )
                ];
 
 
            result = {};
 
 
            if (
                !showPlayerBar ||
                player >= numberOfPlayers)
            {
                continue;
            }
 
 
            const auto playerNo =
                static_cast<
                    rules::PlayerNumber
                >(player);
 
 
            result.local =
                ui::localplayers::
                    slotIsLocalPlayer(
                        playerNo
                    );
 
 
            result.localHuman =
                ui::localplayers::
                    slotIsLocalHumanPlayer(
                        playerNo
                    );
 
 
            result.localAI =
                ui::localplayers::
                    slotIsLocalAIPlayer(
                        playerNo
                    );
 
 
            // ------------------------------------------------
            // DISPLAY_UDIBAR_Show() original :
            //
            // if ShowOnlyLocalPlayers && !local -> invisible
            //
            // else if ShowOnlyLocalAIPlayers && !localAI
            //     -> invisible
            //
            // else visible.
            // ------------------------------------------------
 
            if (
                displayState
                    .showOnlyLocalPlayersOnIBar &&
                !result.local)
            {
                continue;
            }
 
 
            if (
                displayState
                    .showOnlyLocalAIPlayersOnIBar &&
                !result.localAI)
            {
                continue;
            }
 
 
            result.visible = true;
 
 
            result.rect =
                layout::playerSetupHitRect(
                    player,
                    numberOfPlayers
                );
        }
 
 
        // Si le joueur sous la souris vient d'être masqué,
        // retirer le hover.
        if (globalState.playerCurrentMouseOver ==
                static_cast<int>(rules::BankPlayer) &&
            !display::isIBarVisible(displayState.desired2DView))
        {
            globalState.playerCurrentMouseOver = -1;
        }
        else if (
            globalState.playerCurrentMouseOver >= 0 &&
            globalState.playerCurrentMouseOver != static_cast<int>(rules::BankPlayer))
        {
            const auto index =
                static_cast<std::size_t>(
                    globalState
                        .playerCurrentMouseOver
                );
 
 
            if (
                index >=
                    globalState.players.size() ||
                !globalState.players[
                    index
                ].visible)
            {
                globalState
                    .playerCurrentMouseOver =
                    -1;
            }
        }
    }
 
 
    void processLibraryMessage(
        const uimsg::Message& message)
    {
        if (!globalState.initialized)
        {
            return;
        }
 
        // Escape confirmation is global in the retail IBar and must run even
        // while Options or player setup hides the ordinary bar.
        if (processEscapeInput(message)) return;
 
        if (playerSelectVisible())
        {
            if (message.type == uimsg::Type::MouseMoved)
            {
                globalState.playerLastMouseOver =
                    globalState.playerCurrentMouseOver;
                globalState.playerCurrentMouseOver = playerHit(
                    static_cast<int>(message.numberA),
                    static_cast<int>(message.numberB));
                return;
            }
 
            if (message.type != uimsg::Type::MouseLeftDown ||
                message.numberB < 413)
            {
                return;
            }
 
            const int player = playerHit(
                static_cast<int>(message.numberA),
                static_cast<int>(message.numberB));
            if (player < 0)
            {
                return;
            }
 
            playerselection::playerButtonClicked(
                static_cast<rules::PlayerNumber>(player));
            return;
        }
 
        if (!playerBarVisible())
        {
            return;
        }
 
        if (message.type == uimsg::Type::MouseMoved)
        {
            globalState.playerLastMouseOver =
                globalState.playerCurrentMouseOver;
            globalState.playerCurrentMouseOver = playerOrBankHit(
                static_cast<int>(message.numberA),
                static_cast<int>(message.numberB));
 
            globalState.actionButtonLastMouseOver =
                globalState.actionButtonCurrentMouseOver;
            const auto action = actionHit(
                static_cast<int>(message.numberA),
                static_cast<int>(message.numberB));
            globalState.actionButtonCurrentMouseOver = action
                ? static_cast<int>(*action)
                : -1;
 
            globalState.propertyLastMouseOver =
                globalState.propertyCurrentMouseOver;
            const auto property = layout::propertyHit(
                static_cast<int>(message.numberA),
                static_cast<int>(message.numberB),
                globalState.visiblePropertySlots);
            globalState.propertyCurrentMouseOver = property ? *property : -1;
            return;
        }
 
        const bool mainShortcut = message.type == uimsg::Type::KeyboardPressed &&
            message.numberA == SDL_SCANCODE_SPACE;
        if (message.type != uimsg::Type::MouseLeftDown && !mainShortcut)
        {
            return;
        }
 
        // UDIBar.cpp maps Space to the Main rectangle for the current layout.
        // Use the same hit test so disabled and remote actions keep their guards.
        const auto mainRect = layout::actionButtonRect(
            layout::ActionButtonSlot::Main, globalState.actionButtonLayout);
        const int hitX = mainShortcut ? mainRect.left : static_cast<int>(message.numberA);
        const int hitY = mainShortcut ? mainRect.top : static_cast<int>(message.numberB);
        const auto action = actionHit(hitX, hitY);
        if (action)
        {
            globalState.actionButtonCurrentMouseOver =
                static_cast<int>(*action);
            if (handleGlobalAction(*action, message)) return;
            if (handleLocalRuleAction(*action)) return;
            (void)dispatchDirectRuleAction(*action);
            return;
        }
 
        const auto property = layout::propertyHit(
            hitX, hitY, globalState.visiblePropertySlots);
        if (property)
        {
            globalState.propertyCurrentMouseOver = *property;
            (void)handlePropertyClick(*property);
            return;
        }
 
        const int playerOrBank = playerOrBankHit(hitX, hitY);
        if (playerOrBank >= 0)
            (void)handlePlayerOrBankClick(playerOrBank);
    }
 
 
    void processRuleMessage(
        const actions::Message& message,
        RuleMode projectedMode,
        std::uint64_t tick) noexcept
    {
        if (clearsBuyAuctionPopup(message.action))
            globalState.desiredBuyAuctionSquare.reset();
 
        if (message.action == actions::Type::NotifyDecomposeSale)
        {
            globalState.cashAnimationAmount.reset();
            globalState.decompositionHousesToSell = -message.numberB;
            globalState.buttonBarForceUpdate = true;
        }
 
        if (message.action == actions::Type::NotifyCashAnimation)
        {
            if (projectedMode != RuleMode::HotelDecomposition &&
                projectedMode != RuleMode::RaiseMoney)
            {
                globalState.decompositionHousesToSell.reset();
                globalState.cashAnimationAmount = message.numberC;
                globalState.cashAnimationTick = tick;
                ++globalState.cashAnimationSerial;
                globalState.buttonBarForceUpdate = true;
            }
            return;
        }
 
        if (message.action == actions::Type::NotifyBuyOrAuctionDecision)
        {
            const int square = static_cast<int>(message.numberB);
            if (square >= 0 && square < static_cast<int>(rules::SquareCount) &&
                layout::propertyIndex(square) >= 0)
            {
                globalState.desiredBuyAuctionSquare =
                    static_cast<std::uint8_t>(square);
            }
            return;
        }
 
        if (message.action == actions::Type::NotifyPickedUpCard)
        {
            const auto deck = message.numberB;
            const auto card = message.numberC;
            if (deck == static_cast<std::int64_t>(rules::DeckType::Chance) &&
                card >= rules::ChanceFirst && card < rules::ChanceFirst + rules::ChanceCount)
            {
                globalState.desiredCardIndex = static_cast<std::uint8_t>(
                    card - rules::ChanceFirst);
            }
            else if (deck == static_cast<std::int64_t>(rules::DeckType::Community) &&
                card >= rules::CommunityFirst && card < rules::CommunityFirst + rules::CommunityCount)
            {
                globalState.desiredCardIndex = static_cast<std::uint8_t>(
                    16 + card - rules::CommunityFirst);
            }
            return;
        }
 
        if (message.action == actions::Type::NotifyPutAwayCard)
        {
            globalState.desiredCardIndex.reset();
            return;
        }
 
        if (message.action != actions::Type::NotifyActionCompleted ||
            message.numberB == 0 ||
            message.numberA < 0 ||
            message.numberA > static_cast<std::int64_t>(
                actions::Type::ClearTradedImmunitiesOrFutures))
        {
            return;
        }
 
        const auto action = static_cast<actions::Type>(message.numberA);
        if (action == actions::Type::CardSeen)
            globalState.desiredCardIndex.reset();
 
        std::optional<std::uint8_t> pressed;
        switch (action)
        {
        case actions::Type::EndTurn:
        case actions::Type::CardSeen:
        case actions::Type::FreeUnmortgageDone:
            pressed = DoneButtonIndex;
            break;
        case actions::Type::RollDice:
            pressed = RollDiceButtonIndex;
            break;
        case actions::Type::ExitJailDecision:
            if (message.numberD == 0) pressed = RollDiceButtonIndex;
            else if (message.numberD == 1) pressed = PayButtonIndex;
            else if (message.numberD == 2) pressed = UseCardButtonIndex;
            break;
        case actions::Type::GoBankrupt:
            pressed = BankruptButtonIndex;
            break;
        case actions::Type::BuyOrAuctionDecision:
            pressed = message.numberD != 0 ? BuyButtonIndex : AuctionButtonIndex;
            break;
        case actions::Type::TaxDecision:
            if (message.numberD == 0) pressed = FlatTaxButtonIndex;
            else if (message.numberD == 1) pressed = PercentageButtonIndex;
            break;
        case actions::Type::StartHousingAuction:
            if (projectedMode == RuleMode::HousingShort)
                pressed = AuctionHouseButtonIndex;
            else if (projectedMode == RuleMode::HotelShort)
                pressed = AuctionHotelButtonIndex;
            break;
        default:
            break;
        }
 
        if (pressed)
            globalState.pendingPressedButton = *pressed;
    }
 
 
    void clearPendingPressedButton(std::uint8_t buttonIndex) noexcept
    {
        if (globalState.pendingPressedButton == buttonIndex)
            globalState.pendingPressedButton.reset();
    }
 
    void restoreRuleTracking() noexcept
    {
        leaveLocalRuleMode();
    }
 
    void inspectPlayer(rules::PlayerNumber player) noexcept
    {
        if (player > rules::BankPlayer)
        {
            leaveLocalRuleMode();
            return;
        }
        enterLocalRuleMode(otherPlayerMode(player), player);
    }
 
    RuleMode resolveRuleMode(
        RuleMode projectedMode,
        rules::PlayerNumber projectedPlayer) noexcept
    {
        globalState.projectedRuleMode = projectedMode;
        globalState.projectedRulePlayer = projectedPlayer;
 
        return globalState.localRuleModeActive
            ? globalState.localRuleMode
            : projectedMode;
    }
 
 
    rules::PlayerNumber resolveRulePlayer(
        rules::PlayerNumber projectedPlayer) noexcept
    {
        return globalState.localRuleModeActive &&
               globalState.localRulePlayer <= rules::BankPlayer
            ? globalState.localRulePlayer
            : projectedPlayer;
    }
 
 
    void setRuleActionHitState(
        layout::ActionButtonLayout buttonLayout,
        layout::ActionButtonMask activeSlots,
        RuleMode mode,
        rules::PlayerNumber player,
        bool remote) noexcept
    {
        if (globalState.actionButtonLayout != buttonLayout ||
            globalState.activeActionButtonSlots != activeSlots)
        {
            globalState.actionButtonLastMouseOver =
                globalState.actionButtonCurrentMouseOver;
            globalState.actionButtonCurrentMouseOver = -1;
        }
 
        globalState.actionButtonLayout = buttonLayout;
        globalState.activeActionButtonSlots = activeSlots;
        globalState.actionRuleMode = mode;
        globalState.actionPlayer = player;
        globalState.actionRemote = remote;
    }
 
 
    void setPropertyHitState(
        layout::PropertyMask visibleProperties) noexcept
    {
        globalState.visiblePropertySlots = visibleProperties;
        if (globalState.propertyCurrentMouseOver >= 0 &&
            (layout::propertyBit(globalState.propertyCurrentMouseOver) &
             visibleProperties) == 0)
        {
            globalState.propertyLastMouseOver =
                globalState.propertyCurrentMouseOver;
            globalState.propertyCurrentMouseOver = -1;
        }
    }
 
 
    bool activateProperty(int square)
    {
        if (!globalState.initialized || square < 0 ||
            square >= static_cast<int>(rules::SquareCount))
            return false;
        globalState.propertyCurrentMouseOver = square;
        return handlePropertyClick(square);
    }
 
    State& state()
    {
        return globalState;
    }
 
 
    const State& stateReadOnly()
    {
        return globalState;
    }
}