PlayerSetupFlow.cpp

Go to the documentation of this file.

#include "PlayerSetupFlow.hpp"
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <string>
#include <string_view>
#include <utility>
 
namespace monopoly::ui::playersetup
{
    namespace
    {
        using rules::GameState;
        using rules::MaxPlayerColours;
        using rules::MaxTokens;
 
 
        struct ButtonRect
        {
            Button button =
                Button::None;
 
            Rect rect{};
        };
 
 
        // ----------------------------------------------------
        // Coordonnées exactes du UDPsel.cpp 800x600.
        // ----------------------------------------------------
 
        constexpr Rect EnterNameNextRect{
            341,
            434,
            468,
            470
        };
 
 
        constexpr std::array<ButtonRect, 10> SelectPlayerButtons{{
            { Button::SelectPlayerNew,   { 547, 241, 676, 388 } },
            { Button::SelectPlayerMore,  { 506, 400, 726, 462 } },
            { Button::SelectPlayerCard1, { 35, 253, 132, 363 } },
            { Button::SelectPlayerCard2, { 141, 253, 238, 363 } },
            { Button::SelectPlayerCard3, { 241, 253, 338, 363 } },
            { Button::SelectPlayerCard4, { 344, 253, 441, 363 } },
            { Button::SelectPlayerCard5, { 36, 370, 133, 480 } },
            { Button::SelectPlayerCard6, { 141, 371, 238, 481 } },
            { Button::SelectPlayerCard7, { 242, 371, 339, 481 } },
            { Button::SelectPlayerCard8, { 345, 372, 442, 482 } }
        }};
 
 
        constexpr std::array<
            ButtonRect,
            12
        > TokenButtons{{
            {
                Button::TokenGun,
                { 77, 252, 177, 293 }
            },
 
            {
                Button::TokenIron,
                { 225, 252, 325, 293 }
            },
 
            {
                Button::TokenThimble,
                { 376, 252, 476, 293 }
            },
 
            {
                Button::TokenCar,
                { 77, 311, 177, 352 }
            },
 
            {
                Button::TokenHorse,
                { 225, 311, 325, 352 }
            },
 
            {
                Button::TokenBarrow,
                { 376, 311, 476, 352 }
            },
 
            {
                Button::TokenDog,
                { 77, 371, 177, 412 }
            },
 
            {
                Button::TokenShip,
                { 225, 371, 325, 412 }
            },
 
            {
                Button::TokenMoneyBag,
                { 376, 371, 476, 412 }
            },
 
            {
                Button::TokenHat,
                { 77, 432, 177, 473 }
            },
 
            {
                Button::TokenShoe,
                { 225, 432, 325, 473 }
            },
 
            {
                Button::TokenNext,
                { 362, 434, 489, 470 }
            }
        }};
 
 
        constexpr std::array<
            ButtonRect,
            4
        > StartButtons{{
            {
                Button::AddHuman,
                { 40, 254, 260, 316 }
            },
 
            {
                Button::AddComputer,
                { 545, 255, 765, 317 }
            },
 
            {
                Button::RemovePlayer,
                { 290, 255, 510, 317 }
            },
 
            {
                Button::StartGame,
                { 290, 328, 510, 390 }
            }
        }};
 
 
        constexpr Rect RemoveCancelRect{
            291,
            401,
            511,
            463
        };
 
 
        constexpr std::array<
            ButtonRect,
            3
        > AIButtons{{
            {
                Button::AIEasy,
                { 52, 254, 272, 316 }
            },
 
            {
                Button::AIMedium,
                { 291, 254, 511, 316 }
            },
 
            {
                Button::AIHard,
                { 532, 254, 752, 316 }
            }
        }};
 
 
        inline constexpr int UsaCityCount = 11;
        inline constexpr int EuropeCountryCount = 12;
 
        constexpr std::array<
            ButtonRect,
            5
        > CityButtons{{
            { Button::CityClassic,   { 73, 214, 293, 276 } },
            { Button::CityLoadBoard, { 507, 214, 727, 276 } },
            { Button::CityLeft,      { 320, 408, 343, 421 } },
            { Button::CityRight,   { 458, 408, 481, 421 } },
            { Button::CityNext,    { 341, 434, 468, 470 } }
        }};
 
        constexpr std::array<ButtonRect, 7> EuropeCityButtons{{
            { Button::CityClassic,   { 73, 214, 293, 276 } },
            { Button::CityLoadBoard, { 507, 214, 727, 276 } },
            { Button::CountryLeft,   { 145, 442, 168, 455 } },
            { Button::CountryRight,  { 281, 442, 305, 455 } },
            { Button::CurrencyLeft,  { 485, 442, 508, 455 } },
            { Button::CurrencyRight, { 663, 442, 687, 455 } },
            { Button::CityNext,      { 341, 434, 468, 470 } }
        }};
 
        constexpr std::array<
            ButtonRect,
            2
        > RulesChoiceButtons{{
            { Button::RulesStandard, { 75, 254, 295, 316 } },
            { Button::RulesCustom,   { 507, 254, 727, 316 } }
        }};
 
        // Fixed retail rectangle. The remaining CustomizeRules controls are
        // positioned from localized font metrics and stay abstract until that
        // backend exists.
        constexpr Rect RulesOkayRect{ 337, 450, 464, 486 };
 
 
        int languageCountry(data::LanguageId language) noexcept
        {
            const int raw = static_cast<int>(language);
            return raw >= 2 && raw <= 10 ? raw - 2 : 0;
        }
 
        void validateEuropeCurrencies(State& state) noexcept
        {
            state.currencySelection[0] = state.citySelected;
            state.currencySelection[1] = languageCountry(state.language);
            state.currencySelection[2] = MonetarySystemEuro;
        }
 
        void cycleEuropeCurrency(State& state, int direction) noexcept
        {
            const int previous = state.currencySelection[state.currencySelectionIndex];
            do
            {
                state.currencySelectionIndex =
                    (state.currencySelectionIndex + direction + 3) % 3;
            }
            while (previous == state.currencySelection[state.currencySelectionIndex]);
        }
 
        std::uint8_t tokenForButton(
            Button button)
        {
            switch (button)
            {
                case Button::TokenGun:
                    return TokenGun;
 
                case Button::TokenCar:
                    return TokenCar;
 
                case Button::TokenDog:
                    return TokenDog;
 
                case Button::TokenHat:
                    return TokenHat;
 
                case Button::TokenIron:
                    return TokenIron;
 
                case Button::TokenHorse:
                    return TokenHorse;
 
                case Button::TokenShip:
                    return TokenShip;
 
                case Button::TokenShoe:
                    return TokenShoe;
 
                case Button::TokenThimble:
                    return TokenThimble;
 
                case Button::TokenBarrow:
                    return TokenBarrow;
 
                case Button::TokenMoneyBag:
                    return TokenMoneyBag;
 
                default:
                    return 0;
            }
        }
 
 
        bool isTokenButton(
            Button button)
        {
            return
                button >= Button::TokenGun &&
                button <= Button::TokenShoe;
        }
 
 
        bool selectPlayerCardSlot(
            Button button,
            std::size_t& slot)
        {
            if (button < Button::SelectPlayerCard1 ||
                button > Button::SelectPlayerCard8)
            {
                return false;
            }
 
            slot = static_cast<std::size_t>(
                static_cast<std::uint8_t>(button) -
                static_cast<std::uint8_t>(Button::SelectPlayerCard1));
            return true;
        }
 
 
        void startPhase(
            State& state,
            const GameState& uiState,
            Phase phase)
        {
            // udpsel_StartPhase().
 
            state.phase =
                phase;
 
 
            switch (phase)
            {
                case Phase::EnterName:
                {
                    state.aiLevel = 0;
 
                    // Le jeu affichait immédiatement "_"
                    // pour permettre de taper sans attendre
                    // la fin des animations.
                    state.name = L"_";
 
                    break;
                }
 
 
                case Phase::SelectCity:
                {
                    if (state.boardEdition == data::BoardEdition::Europe)
                    {
                        state.citySelected = languageCountry(state.language);
                        validateEuropeCurrencies(state);
                        state.currencySelectionIndex = 0;
                    }
                    break;
                }
 
                case Phase::SelectToken:
                {
                    if (state.aiLevel > 0)
                    {
                        state.token =
                            nextAvailableToken(
                                uiState,
                                state.token
                            );
                    }
                    else
                    {
                        state.token =
                            tokenFromName(
                                state,
                                uiState,
                                state.name
                            );
                    }
 
                    break;
                }
 
 
                default:
                    break;
            }
        }
 
 
        std::wstring cleanedEnteredName(
            std::wstring name)
        {
            if (
                !name.empty() &&
                name.back() == L'_')
            {
                name.pop_back();
            }
 
            return name;
        }
 
 
        std::wstring aiTokenName(
            const State& state)
        {
            if (state.token >=
                state.tokenNames.size())
            {
                return {};
            }
 
 
            std::wstring result =
                state.tokenNames[
                    state.token
                ];
 
 
            // UDPsel.cpp :
            // 10 caractères normalement.
            // Le dé à coudre dispose de 11 caractères
            // pour sa traduction française.
            const std::size_t maximum =
                state.token ==
                    TokenThimble
                    ? MaximumEnteredNameLength + 1
                    : MaximumEnteredNameLength;
 
 
            if (result.size() > maximum)
            {
                result.resize(maximum);
            }
 
 
            return result;
        }
    }
 
 
    void initialize(
        State& state,
        bool serverMode)
    {
        state = {};
 
        state.phase =
            Phase::None;
 
        state.desiredPhase =
            Phase::None;
 
        state.name =
            L"_";
 
        state.token =
            TokenGun;
 
        state.aiLevel = 0;
 
        state.serverMode =
            serverMode;
    }
 
 
    void setTokenName(
        State& state,
        std::uint8_t token,
        std::wstring_view name)
    {
        if (token >=
            state.tokenNames.size())
        {
            return;
        }
 
 
        state.tokenNames[token] =
            name;
    }
 
 
    void setPlayerLogAvailable(
        State& state,
        bool available)
    {
        state.hasPlayerLogEntries = available;
 
        if (!available)
        {
            state.playerLogCount = 0;
            state.playerLogPageStart = 0;
            state.playerLog = {};
        }
    }
 
 
    void setPlayerLogEntries(
        State& state,
        const rules::GameState& uiState,
        std::span<const std::wstring> entries)
    {
        state.playerLog = {};
        state.playerLogCount = 0;
        state.playerLogPageStart = 0;
 
        for (const auto& sourceName : entries)
        {
            if (sourceName.empty() ||
                state.playerLogCount >= state.playerLog.size())
            {
                continue;
            }
 
            std::wstring candidate = sourceName;
            if (candidate.size() > MaximumEnteredNameLength)
                candidate.resize(MaximumEnteredNameLength);
 
            bool alreadySelected = false;
            for (rules::PlayerNumber player = 0;
                 player < uiState.numberOfPlayers;
                 ++player)
            {
                if (uiState.players[player].name == candidate)
                {
                    alreadySelected = true;
                    break;
                }
            }
 
            if (!alreadySelected)
                state.playerLog[state.playerLogCount++] = std::move(candidate);
        }
 
        state.hasPlayerLogEntries = state.playerLogCount != 0;
    }
 
 
    void setEnteredName(
        State& state,
        std::wstring_view name)
    {
        std::wstring result(name);
 
 
        if (
            result.size() >
            MaximumEnteredNameLength)
        {
            result.resize(
                MaximumEnteredNameLength
            );
        }
 
 
        state.name =
            std::move(result);
    }
 
 
    void requestPhase(
        State& state,
        const GameState& uiState,
        Phase requested)
    {
        // UDPSEL_SwitchPhase().
 
        if (requested == state.phase)
        {
            return;
        }
 
 
        Phase actual =
            requested;
 
 
        switch (requested)
        {
            case Phase::SelectPlayer:
            {
                // Si aucun historique n'existe, le jeu
                // passe directement à ENTERNAME.
                if (!state.hasPlayerLogEntries)
                {
                    actual =
                        Phase::EnterName;
                }
 
                break;
            }
 
 
            default:
                break;
        }
 
 
        state.desiredPhase =
            actual;
 
 
        // Le moteur moderne n'a pas encore les anim-outs
        // LED/Sequencer : le passage logique peut donc être
        // commité immédiatement.
        startPhase(
            state,
            uiState,
            actual
        );
    }
 
 
    bool tokenAvailable(
        const GameState& uiState,
        std::uint8_t token)
    {
        for (
            rules::PlayerNumber player = 0;
            player < uiState.numberOfPlayers;
            ++player)
        {
            if (
                uiState.players[player].token ==
                token)
            {
                return false;
            }
        }
 
 
        return true;
    }
 
 
    std::uint8_t nextAvailableToken(
        const GameState& uiState,
        std::uint8_t currentToken)
    {
        // udpsel_DetermineNextAvailableToken() exact.
 
        const std::uint8_t original =
            static_cast<std::uint8_t>(
                currentToken %
                MaxTokens
            );
 
 
        std::uint8_t token =
            static_cast<std::uint8_t>(
                (
                    original + 1
                ) %
                MaxTokens
            );
 
 
        // Comportement original :
        // aucun joueur => renvoyer immédiatement
        // le token SUIVANT.
        if (uiState.numberOfPlayers == 0)
        {
            return token;
        }
 
 
        while (true)
        {
            if (
                tokenAvailable(
                    uiState,
                    token
                ))
            {
                return token;
            }
 
 
            token =
                static_cast<std::uint8_t>(
                    (
                        token + 1
                    ) %
                    MaxTokens
                );
 
 
            if (token == original)
            {
                return original;
            }
        }
    }
 
 
    std::uint8_t tokenFromName(
        const State& state,
        const GameState& uiState,
        std::wstring_view name)
    {
        // udpsel_GetTokenByName().
 
        for (
            std::uint8_t token = 0;
            token < MaxTokens;
            ++token)
        {
            if (
                !state.tokenNames[token].empty() &&
                state.tokenNames[token] == name)
            {
                return token;
            }
        }
 
 
        return
            nextAvailableToken(
                uiState,
                TokenGun
            );
    }
 
 
    std::uint8_t nextAvailableColour(
        const GameState& uiState,
        std::uint8_t currentColour)
    {
        // udpsel_DetermineNextAvailableColour() exact.
 
        const std::uint8_t original =
            static_cast<std::uint8_t>(
                currentColour %
                MaxPlayerColours
            );
 
 
        std::uint8_t colour =
            original;
 
 
        if (uiState.numberOfPlayers == 0)
        {
            return colour;
        }
 
 
        while (true)
        {
            bool available = true;
 
 
            for (
                rules::PlayerNumber player = 0;
                player < uiState.numberOfPlayers;
                ++player)
            {
                if (
                    uiState.players[player].colour ==
                    colour)
                {
                    available = false;
                    break;
                }
            }
 
 
            if (available)
            {
                return colour;
            }
 
 
            colour =
                static_cast<std::uint8_t>(
                    (
                        colour + 1
                    ) %
                    MaxPlayerColours
                );
 
 
            if (colour == original)
            {
                return original;
            }
        }
    }
 
 
    Button buttonAt(
        Phase phase,
        int x,
        int y,
        data::BoardEdition edition)
    {
        switch (phase)
        {
            case Phase::SelectPlayer:
            {
                for (const auto& entry : SelectPlayerButtons)
                {
                    if (entry.rect.contains(x, y))
                        return entry.button;
                }
                break;
            }
 
 
            case Phase::EnterName:
            {
                if (
                    EnterNameNextRect.contains(
                        x,
                        y
                    ))
                {
                    return
                        Button::EnterNameNext;
                }
 
                break;
            }
 
 
            case Phase::SelectToken:
            {
                for (
                    const auto& entry :
                    TokenButtons)
                {
                    if (
                        entry.rect.contains(
                            x,
                            y
                        ))
                    {
                        return entry.button;
                    }
                }
 
                break;
            }
 
 
            case Phase::StartAddRemove:
            {
                for (
                    const auto& entry :
                    StartButtons)
                {
                    if (
                        entry.rect.contains(
                            x,
                            y
                        ))
                    {
                        return entry.button;
                    }
                }
 
                break;
            }
 
 
            case Phase::RemovePlayer:
            {
                if (
                    RemoveCancelRect.contains(
                        x,
                        y
                    ))
                {
                    return
                        Button::RemoveCancel;
                }
 
                break;
            }
 
 
            case Phase::SelectAIStrength:
            {
                for (
                    const auto& entry :
                    AIButtons)
                {
                    if (
                        entry.rect.contains(
                            x,
                            y
                        ))
                    {
                        return entry.button;
                    }
                }
 
                break;
            }
 
 
            case Phase::SelectCity:
            {
                if (edition == data::BoardEdition::Europe)
                {
                    for (const auto& entry : EuropeCityButtons)
                        if (entry.rect.contains(x, y)) return entry.button;
                }
                else
                {
                    for (const auto& entry : CityButtons)
                        if (entry.rect.contains(x, y)) return entry.button;
                }
                break;
            }
 
 
            case Phase::StandardOrCustomRules:
            {
                for (const auto& entry : RulesChoiceButtons)
                {
                    if (entry.rect.contains(x, y))
                        return entry.button;
                }
                break;
            }
 
 
            case Phase::CustomizeRules:
            {
                if (RulesOkayRect.contains(x, y))
                    return Button::RulesOkay;
                break;
            }
 
 
            default:
                break;
        }
 
 
        return Button::None;
    }
 
 
    Command clickButton(
        State& state,
        const GameState& uiState,
        Button button)
    {
        Command command{};
 
 
        if (button == Button::None)
        {
            return command;
        }
 
 
        // ----------------------------------------------------
        // SELECT PLAYER
        // ----------------------------------------------------
 
        if (state.phase == Phase::SelectPlayer)
        {
            if (button == Button::SelectPlayerNew)
            {
                state.aiLevel = 0;
                requestPhase(state, uiState, Phase::EnterName);
                return command;
            }
 
            if (button == Button::SelectPlayerMore)
            {
                if (state.playerLogCount > PlayerHistoryPageSize)
                {
                    state.playerLogPageStart += PlayerHistoryPageSize;
                    if (state.playerLogPageStart >= state.playerLogCount)
                        state.playerLogPageStart = 0;
                }
                return command;
            }
 
            std::size_t slot = 0;
            if (selectPlayerCardSlot(button, slot))
            {
                const std::size_t entry = state.playerLogPageStart + slot;
                if (entry < state.playerLogCount)
                {
                    state.name = state.playerLog[entry];
                    state.aiLevel = 0;
                    requestPhase(state, uiState, Phase::SelectToken);
                }
                return command;
            }
 
            return command;
        }
 
 
        // ----------------------------------------------------
        // ENTER NAME
        // ----------------------------------------------------
 
        if (
            state.phase ==
            Phase::EnterName)
        {
            if (
                button ==
                Button::EnterNameNext)
            {
                requestPhase(
                    state,
                    uiState,
                    Phase::SelectToken
                );
            }
 
 
            return command;
        }
 
 
        // ----------------------------------------------------
        // PICK TOKEN
        // ----------------------------------------------------
 
        if (
            state.phase ==
            Phase::SelectToken)
        {
            if (isTokenButton(button))
            {
                state.token =
                    tokenForButton(
                        button
                    );
 
                return command;
            }
 
 
            if (
                button ==
                Button::TokenNext)
            {
                std::wstring finalName;
 
 
                if (state.aiLevel > 0)
                {
                    finalName =
                        aiTokenName(
                            state
                        );
                }
                else
                {
                    finalName =
                        cleanedEnteredName(
                            state.name
                        );
                }
 
 
                if (finalName.empty())
                {
                    return command;
                }
 
 
                command.type =
                    CommandType::
                        AddLocalPlayer;
 
 
                command.name =
                    finalName;
 
 
                command.token =
                    state.token;
 
 
                // PC_RED = 0.
                command.colour =
                    nextAvailableColour(
                        uiState,
                        0
                    );
 
 
                command.aiLevel =
                    state.aiLevel;
 
 
                requestPhase(
                    state,
                    uiState,
                    Phase::StartAddRemove
                );
 
 
                // Original :
                // reset du nom après l'ajout.
                state.name =
                    L"_";
 
 
                return command;
            }
 
 
            return command;
        }
 
 
        // ----------------------------------------------------
        // START / ADD / REMOVE
        // ----------------------------------------------------
 
        if (
            state.phase ==
            Phase::StartAddRemove)
        {
            switch (button)
            {
                case Button::AddHuman:
                {
                    state.aiLevel = 0;
 
 
                    requestPhase(
                        state,
                        uiState,
                        Phase::SelectPlayer
                    );
 
                    return command;
                }
 
 
                case Button::AddComputer:
                {
                    requestPhase(
                        state,
                        uiState,
                        Phase::SelectAIStrength
                    );
 
                    return command;
                }
 
 
                case Button::RemovePlayer:
                {
                    requestPhase(
                        state,
                        uiState,
                        Phase::RemovePlayer
                    );
 
                    return command;
                }
 
 
                case Button::StartGame:
                {
                    state.startButtonPressed =
                        true;
 
 
                    command.type =
                        CommandType::StartGame;
 
 
                    if (state.serverMode)
                    {
                        requestPhase(
                            state,
                            uiState,
                            Phase::SelectCity
                        );
                    }
                    else
                    {
                        requestPhase(
                            state,
                            uiState,
                            Phase::CustomizeRules
                        );
                    }
 
 
                    return command;
                }
 
 
                default:
                    return command;
            }
        }
 
 
        // ----------------------------------------------------
        // REMOVE PLAYER
        // ----------------------------------------------------
 
        if (
            state.phase ==
            Phase::RemovePlayer)
        {
            if (
                button ==
                Button::RemoveCancel)
            {
                requestPhase(
                    state,
                    uiState,
                    Phase::StartAddRemove
                );
            }
 
 
            return command;
        }
 
 
        // ----------------------------------------------------
        // AI STRENGTH
        // ----------------------------------------------------
 
        if (
            state.phase ==
            Phase::SelectAIStrength)
        {
            switch (button)
            {
                case Button::AIEasy:
                    state.aiLevel = 1;
                    break;
 
                case Button::AIMedium:
                    state.aiLevel = 2;
                    break;
 
                case Button::AIHard:
                    state.aiLevel = 3;
                    break;
 
                default:
                    return command;
            }
 
 
            requestPhase(
                state,
                uiState,
                Phase::SelectToken
            );
 
 
            return command;
        }
 
 
        if (
            state.phase ==
            Phase::SelectCity)
        {
            if (state.boardEdition == data::BoardEdition::Europe)
            {
                switch (button)
                {
                    case Button::CityLoadBoard:
                        command.type = CommandType::RequestCustomBoard;
                        return command;
 
                    case Button::CountryLeft:
                        state.citySelected = state.citySelected > 0
                            ? state.citySelected - 1 : EuropeCountryCount - 1;
                        validateEuropeCurrencies(state);
                        return command;
 
                    case Button::CountryRight:
                        state.citySelected = state.citySelected < EuropeCountryCount - 1
                            ? state.citySelected + 1 : 0;
                        validateEuropeCurrencies(state);
                        return command;
 
                    case Button::CurrencyLeft:
                        cycleEuropeCurrency(state, -1);
                        return command;
 
                    case Button::CurrencyRight:
                        cycleEuropeCurrency(state, 1);
                        return command;
 
                    case Button::CityClassic:
                        state.citySelected = languageCountry(state.language);
                        validateEuropeCurrencies(state);
                        command.type = CommandType::CommitCity;
                        command.city = state.citySelected;
                        command.system = state.currencySelection[state.currencySelectionIndex];
                        requestPhase(state, uiState, Phase::StandardOrCustomRules);
                        return command;
 
                    case Button::CityNext:
                        command.type = CommandType::CommitCity;
                        command.city = state.citySelected;
                        command.system = state.currencySelection[state.currencySelectionIndex];
                        requestPhase(state, uiState, Phase::StandardOrCustomRules);
                        return command;
 
                    default:
                        return command;
                }
            }
 
            switch (button)
            {
                case Button::CityLoadBoard:
                    command.type = CommandType::RequestCustomBoard;
                    return command;
 
                case Button::CityLeft:
                    state.citySelected = state.citySelected > 0
                        ? state.citySelected - 1 : UsaCityCount - 1;
                    return command;
 
                case Button::CityRight:
                    state.citySelected = state.citySelected < UsaCityCount - 1
                        ? state.citySelected + 1 : 0;
                    return command;
 
                case Button::CityClassic:
                    state.citySelected = 0;
                    command.type = CommandType::CommitCity;
                    command.city = 0;
                    command.system = MonetarySystemUs;
                    requestPhase(state, uiState, Phase::StandardOrCustomRules);
                    return command;
 
                case Button::CityNext:
                    command.type = CommandType::CommitCity;
                    command.city = state.citySelected;
                    command.system = MonetarySystemUs;
                    requestPhase(state, uiState, Phase::StandardOrCustomRules);
                    return command;
 
                default:
                    return command;
            }
        }
 
 
        if (state.phase == Phase::StandardOrCustomRules)
        {
            switch (button)
            {
                case Button::RulesCustom:
                    state.customRulesDesired = true;
                    requestPhase(state, uiState, Phase::CustomizeRules);
                    return command;
 
                case Button::RulesStandard:
                    state.customRulesDesired = false;
                    command.type = CommandType::AcceptStandardRules;
                    return command;
 
                default:
                    return command;
            }
        }
 
 
        if (state.phase == Phase::CustomizeRules)
        {
            switch (button)
            {
                case Button::RulesOkay:
                    if (state.serverMode)
                        command.type = CommandType::AcceptCustomRules;
                    return command;
 
                case Button::RulesRestoreStandard:
                    command.type = CommandType::RestoreStandardRules;
                    return command;
 
                case Button::RulesShortGame:
                    command.type = CommandType::ApplyShortGameRules;
                    return command;
 
                default:
                    return command;
            }
        }
 
 
        return command;
    }
 
 
    Command clickAt(
        State& state,
        const GameState& uiState,
        int x,
        int y)
    {
        return
            clickButton(
                state,
                uiState,
                buttonAt(
                    state.phase,
                    x,
                    y,
                    state.boardEdition
                )
            );
    }
 
 
    Command customRuleChoice(
        State& state,
        const GameState&,
        rules::options::SetupRule rule,
        std::uint8_t choice)
    {
        Command command{};
 
        if (state.phase != Phase::CustomizeRules || !state.serverMode)
            return command;
 
        if (choice >= rules::options::setupRuleChoiceCount(rule))
            return command;
 
        command.type = CommandType::ApplyCustomRule;
        command.setupRule = rule;
        command.ruleChoice = choice;
        return command;
    }
 
 
    Command playerBarClicked(
        State& state,
        rules::PlayerNumber player)
    {
        // UDPSEL_PlayerButtonClicked().
 
        Command command{};
 
 
        if (
            state.phase !=
            Phase::RemovePlayer)
        {
            return command;
        }
 
 
        if (player >=
            rules::MaxPlayers)
        {
            return command;
        }
 
 
        command.type =
            CommandType::
                RemoveLocalPlayer;
 
 
        command.player =
            player;
 
 
        state.phase =
            Phase::StartAddRemove;
 
 
        state.desiredPhase =
            Phase::StartAddRemove;
 
 
        return command;
    }
}