AIDecisionUtility.cpp

Go to the documentation of this file.

#include "AIDecisionUtility.hpp"
#include "AITradeUtility.hpp"
 
#include <algorithm>
#include <cmath>
#include <limits>
 
namespace monopoly::ai::decision
{
    namespace
    {
        [[nodiscard]] std::int64_t reserveForHighestDevelopedRent(
            const rules::GameState& state,
            rules::PlayerNumber player) noexcept
        {
            const auto highest = ai::highestRentSquare(state, player);
            if (highest.square == rules::board::SquareType::Go ||
                ai::housesOnMonopoly(state, highest.square) == 0)
                return 0;
            return highest.rent;
        }
 
        [[nodiscard]] double monopolyFrequency(
            rules::board::SquareType representative) noexcept
        {
            const auto group = rules::board::definition(representative).group;
            const auto index = static_cast<std::size_t>(group);
            return index < MonopolyAverageLandingFrequency.size()
                ? MonopolyAverageLandingFrequency[index] : 0.0;
        }
 
        inline constexpr std::array<rules::board::SquareType, 28> MortgageOrder{
            rules::board::SquareType::MediterraneanAvenue,
            rules::board::SquareType::OrientalAvenue,
            rules::board::SquareType::VermontAvenue,
            rules::board::SquareType::BalticAvenue,
            rules::board::SquareType::ConnecticutAvenue,
            rules::board::SquareType::StCharlesPlace,
            rules::board::SquareType::StatesAvenue,
            rules::board::SquareType::VirginiaAvenue,
            rules::board::SquareType::StJamesPlace,
            rules::board::SquareType::TennesseeAvenue,
            rules::board::SquareType::NewYorkAvenue,
            rules::board::SquareType::KentuckyAvenue,
            rules::board::SquareType::IndianaAvenue,
            rules::board::SquareType::IllinoisAvenue,
            rules::board::SquareType::AtlanticAvenue,
            rules::board::SquareType::VentnorAvenue,
            rules::board::SquareType::MarvinGardens,
            rules::board::SquareType::PacificAvenue,
            rules::board::SquareType::NorthCarolinaAvenue,
            rules::board::SquareType::PennsylvaniaAvenue,
            rules::board::SquareType::ParkPlace,
            rules::board::SquareType::Boardwalk,
            rules::board::SquareType::ShortLineRailroad,
            rules::board::SquareType::BAndORailroad,
            rules::board::SquareType::PennsylvaniaRailroad,
            rules::board::SquareType::ReadingRailroad,
            rules::board::SquareType::ElectricCompany,
            rules::board::SquareType::WaterWorks};
    }
 
    std::int64_t excessCashAvailable(
        const rules::GameState& state,
        rules::PlayerNumber player,
        bool cashOnly,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::int64_t moneyOwed) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers ||
            strategy >= CashStrategy::Count)
            return 0;
 
        auto liquid = cashOnly
            ? state.players[player].cash
            : ai::liquidAssets(state, player, false, false, moneyOwed);
        std::int64_t payments{};
 
        switch (strategy)
        {
        case CashStrategy::MinimumAmount:
            payments = minCashOnHand;
            break;
        case CashStrategy::ExpectedRentIncludingMonopolies:
            payments = ai::averageRentPaid(state, player, 0, true, 1.0);
            payments = std::max(payments, minCashOnHand);
            break;
        case CashStrategy::ExpectedRentExcludingMonopolies:
            payments = ai::averageRentPaid(state, player, 0, false, 1.0);
            payments = std::max(payments, minCashOnHand);
            break;
        case CashStrategy::HighestRent:
            payments = reserveForHighestDevelopedRent(state, player);
            payments += ai::averageRentPaid(state, player, 0, false, 1.0);
            payments = std::max(payments, minCashOnHand);
            break;
        case CashStrategy::MonopolyDependent:
            if (ai::anyMonopoly(state) &&
                ai::mostExpensivePotentialIncome(state) == player &&
                ai::bestCurrentRent(state) == player)
            {
                payments = reserveForHighestDevelopedRent(state, player);
            }
            payments += ai::averageRentPaid(state, player, 0, false, 1.0);
            payments = std::max(payments, minCashOnHand);
            break;
        case CashStrategy::Count:
            return 0;
        }
 
        return std::max<std::int64_t>(0, liquid - payments);
    }
 
    std::int64_t cashAvailableAfterHousing(
        const rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::int64_t moneyOwed) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count)
            return 0;
 
        auto simulated = state;
        const bool shortage = ai::housingShortage(state, CriticalHousingLevel);
        do
        {
            if (!shortage)
                while (hypotheticalBuyHouse(simulated, player, moneyOwed)) {}
        } while (hypotheticalUnmortgageProperty(
            simulated, player, true, strategy, minCashOnHand, moneyOwed) !=
            rules::board::SquareType::Go);
 
        return excessCashAvailable(
            simulated, player, false, strategy, minCashOnHand, moneyOwed);
    }
 
    bool shouldBuyProperty(
        const rules::GameState& state,
        rules::PlayerNumber player,
        rules::board::SquareType property,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::span<const std::int64_t> moneyOwed) noexcept
    {
        using trade::StrategicPropertyImportance;
        using rules::board::SquareGroup;
        using rules::board::SquareType;
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || property >= SquareType::InJail ||
            strategy >= CashStrategy::Count)
            return false;
 
        const auto& definition = rules::board::definition(property);
        const auto propertyCost = definition.purchaseCost;
        const auto debt = player < moneyOwed.size() ? moneyOwed[player] : 0;
        auto reserve = ai::minimumCalculatedExpenses(state, player);
        if (reserve < 0)
            return false;
        reserve = std::max(reserve, minCashOnHand) - definition.mortgageCost;
 
        const auto liquid = ai::liquidAssets(state, player, false, false, debt);
        const auto withHouses = ai::liquidAssets(state, player, true, true, debt);
        const auto protectBare = ai::liquidAssets(state, player, true, false, debt);
        if (withHouses < propertyCost || withHouses - propertyCost < reserve)
            return false;
 
        // Retail computes both values, but only the all-assets result is consumed.
        (void)ai::mostLiquidAssets(state, player, false, moneyOwed);
        if (ai::mostLiquidAssets(state, player, true, moneyOwed) < propertyCost)
            return false;
 
        const auto importanceOthers = trade::strategicPropertyImportance(
            state, property, player, rules::NobodyPlayer);
        const auto importanceUs = trade::strategicPropertyImportance(
            state, property, rules::NobodyPlayer, player);
 
        if (liquid - propertyCost < reserve)
        {
            if (importanceOthers == StrategicPropertyImportance::GivesDirectMonopoly)
            {
                const auto monopolyPlayer = ai::firstOwnerInMonopoly(state, property);
                if (monopolyPlayer >= state.numberOfPlayers)
                    return false;
                const auto otherDebt = monopolyPlayer < moneyOwed.size() ? moneyOwed[monopolyPlayer] : 0;
                const auto otherLiquid = ai::liquidAssets(
                    state, monopolyPlayer, true, false, otherDebt);
                if (otherLiquid < propertyCost)
                    return definition.group <= SquareGroup::OrientalAvenue;
                return true;
            }
 
            if (importanceUs == StrategicPropertyImportance::GivesDirectMonopoly)
            {
                if (definition.group <= SquareGroup::OrientalAvenue)
                    return true;
                const auto monopolies = ai::monopoliesOwned(state, player, false);
                if (monopolies.count == 0)
                    return false;
                for (std::size_t monopolyIndex = 0; monopolyIndex < monopolies.count; ++monopolyIndex)
                {
                    const auto representative = monopolies.representatives[monopolyIndex];
                    const auto lots = ai::monopolyLots(representative);
                    const auto houses = ai::housesOnMonopoly(state, representative);
                    if (houses < static_cast<std::int64_t>(lots.count * 3))
                        return false;
                }
                const auto shortfall = propertyCost + reserve - liquid;
                const auto last = monopolies.representatives[monopolies.count - 1];
                if (static_cast<double>(shortfall) >
                    static_cast<double>(rules::board::definition(last).housePurchaseCost) * 1.5)
                    return false;
                return true;
            }
 
            if (trade::onlyPlayerHasMonopoly(state, player) &&
                !ai::ownsPropertyFromMonopoly(state, player, property) &&
                !ai::isCashCow(property))
                return true;
            return false;
        }
 
        bool buy = ai::isCashCow(property);
        if (importanceUs == StrategicPropertyImportance::GivesDirectMonopoly)
            return true;
        if (importanceOthers == StrategicPropertyImportance::AllowsTrade ||
            importanceOthers == StrategicPropertyImportance::GivesDirectMonopoly)
            return true;
 
        if (definition.group == SquareGroup::ParkPlace ||
            definition.group == SquareGroup::MediterraneanAvenue ||
            definition.group == SquareGroup::StJamesPlace)
            buy = true;
        if (importanceUs != StrategicPropertyImportance::NotImportant && !buy)
            buy = true;
 
        if (trade::onlyPlayerHasMonopoly(state, player) &&
            !ai::ownsPropertyFromMonopoly(state, player, property) &&
            !ai::isCashCow(property))
            return true;
 
        if (protectBare - propertyCost < reserve && !buy)
            return false;
        if (cashAvailableAfterHousing(
                state, player, strategy, minCashOnHand, debt) < propertyCost)
            return false;
        return true;
    }
 
    bool hypotheticalBuyHouse(
        rules::GameState& state,
        rules::PlayerNumber player,
        std::int64_t moneyOwed) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers)
            return false;
 
        const auto liquid = ai::liquidAssets(
            state, player, false, false, moneyOwed);
        if (liquid == 0)
            return false;
 
        const auto monopolies = ai::monopoliesOwned(state, player, true);
        auto bestSquare = rules::board::SquareType::Go;
        double bestMetric{};
 
        for (std::size_t index = 0; index < monopolies.count; ++index)
        {
            const auto representative = monopolies.representatives[index];
            const auto lots = ai::monopolyLots(representative);
            const auto houses = ai::housesOnMonopoly(state, representative);
            const auto toThree = static_cast<std::int64_t>(lots.count * 3) - houses;
            if (toThree < 1)
                continue;
            const auto& definition = rules::board::definition(representative);
            if (toThree * definition.housePurchaseCost > liquid)
                continue;
            if (bestMetric < static_cast<double>(definition.rent[0]))
            {
                bestMetric = static_cast<double>(definition.rent[0]);
                bestSquare = representative;
            }
        }
 
        if (bestSquare == rules::board::SquareType::Go)
        {
            bestMetric = 0.0;
            for (std::size_t index = 0; index < monopolies.count; ++index)
            {
                const auto representative = monopolies.representatives[index];
                const auto lots = ai::monopolyLots(representative);
                if (ai::housesOnMonopoly(state, representative) >=
                    static_cast<std::int64_t>(lots.count * 3))
                    continue;
                const auto& definition = rules::board::definition(representative);
                if (definition.housePurchaseCost > liquid)
                    continue;
                const auto frequency = monopolyFrequency(representative);
                if (bestMetric < frequency)
                {
                    bestMetric = frequency;
                    bestSquare = representative;
                }
            }
        }
 
        if (bestSquare == rules::board::SquareType::Go)
        {
            bestMetric = 0.0;
            for (std::size_t index = 0; index < monopolies.count; ++index)
            {
                const auto representative = monopolies.representatives[index];
                const auto lots = ai::monopolyLots(representative);
                if (ai::housesOnMonopoly(state, representative) >=
                    static_cast<std::int64_t>(lots.count * state.options.housesPerHotel))
                    continue;
                const auto& definition = rules::board::definition(representative);
                if (definition.housePurchaseCost > liquid)
                    continue;
                const auto frequency = monopolyFrequency(representative);
                if (bestMetric < frequency)
                {
                    bestMetric = frequency;
                    bestSquare = representative;
                }
            }
        }
 
        if (bestSquare == rules::board::SquareType::Go)
            return false;
 
        const auto lots = ai::monopolyLots(bestSquare);
        if (lots.count == 0)
            return false;
        auto topHousesOnLot = state.options.housesPerHotel;
        if (state.options.evenBuildRule)
        {
            const auto balancedTop = static_cast<std::uint8_t>(
                ai::housesOnMonopoly(state, bestSquare) /
                    static_cast<std::int64_t>(lots.count) + 1);
            if (balancedTop < topHousesOnLot)
                topHousesOnLot = balancedTop;
        }
 
        auto chosen = rules::board::SquareType::Go;
        for (std::size_t index = 0; index < lots.count; ++index)
        {
            const auto square = lots.squares[index];
            if (state.squares[static_cast<std::size_t>(square)].houses < topHousesOnLot)
            {
                chosen = square;
                break;
            }
        }
        if (chosen == rules::board::SquareType::Go)
            return false;
 
        ++state.squares[static_cast<std::size_t>(chosen)].houses;
        // Retail subtracts monopolies[0]'s house price here even when another
        // monopoly was selected. Debit the selected monopoly's actual house price.
        state.players[player].cash -=
            rules::board::definition(bestSquare).housePurchaseCost;
        return true;
    }
    rules::board::SquareType hypotheticalUnmortgageMonopolyProperty(
        rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count)
            return SquareType::Go;
 
        const auto owned = ai::propertiesOwnedByPlayer(state, player);
        const auto excess = excessCashAvailable(
            state, player, false, strategy, minCashOnHand, moneyOwed);
 
        const auto tryRange = [&](std::size_t begin, std::size_t endExclusive) {
            for (std::size_t index = begin; index < endExclusive; ++index)
            {
                const auto square = static_cast<SquareType>(index);
                auto& runtime = state.squares[index];
                const auto bit = rules::board::propertyBit(square);
                if (!runtime.mortgaged || bit == 0 || (owned & bit) == 0 ||
                    !ai::testForMonopoly(owned, square))
                    continue;
 
                const auto rawCost = static_cast<double>(
                    rules::board::definition(square).mortgageCost) * 1.1;
                // Preserve the retail comparison against the untruncated double.
                if (static_cast<double>(excess) < rawCost)
                    continue;
 
                runtime.mortgaged = false;
                state.players[player].cash -= static_cast<std::int64_t>(rawCost);
                return square;
            }
            return SquareType::Go;
        };
 
        auto square = tryRange(
            static_cast<std::size_t>(SquareType::OrientalAvenue),
            static_cast<std::size_t>(SquareType::InJail));
        if (square != SquareType::Go)
            return square;
 
        return tryRange(
            static_cast<std::size_t>(SquareType::Go),
            static_cast<std::size_t>(SquareType::BalticAvenue) + 1);
    }
 
    rules::board::SquareType hypotheticalUnmortgageProperty(
        rules::GameState& state,
        rules::PlayerNumber player,
        bool onlyMonopolies,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count)
            return SquareType::Go;
 
        const auto monopoly = hypotheticalUnmortgageMonopolyProperty(
            state, player, strategy, minCashOnHand, moneyOwed);
        if (monopoly != SquareType::Go || onlyMonopolies)
            return monopoly;
 
        const auto owned = ai::propertiesOwnedByPlayer(state, player);
        const auto excessCash = excessCashAvailable(
            state, player, true, strategy, minCashOnHand, moneyOwed);
        const auto square = ai::findHighestRentMortgaged(
            state, player, owned, excessCash);
        if (square == SquareType::Go)
            return SquareType::Go;
 
        const auto rawCost = static_cast<double>(
            rules::board::definition(square).mortgageCost) * 1.1;
        // Retail's hypothetical non-monopoly fallback debits a stale
        // Square_predefined_info pointer. Use the selected property's cost.
        state.squares[static_cast<std::size_t>(square)].mortgaged = false;
        state.players[player].cash -= static_cast<std::int64_t>(rawCost);
        return square;
    }
 
    bool shouldUnmortgageProperty(
        const rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count)
            return false;
 
        auto simulated = state;
        if (!ai::housingShortage(state, CriticalHousingLevel))
        {
            while (hypotheticalBuyHouse(simulated, player, moneyOwed))
            {
            }
        }
 
        const auto owned = ai::propertiesOwnedByPlayer(state, player);
        const auto cashOnly = excessCashAvailable(
            simulated, player, true, strategy, minCashOnHand, moneyOwed);
        const auto mortgageable = excessCashAvailable(
            simulated, player, false, strategy, minCashOnHand, moneyOwed);
 
        for (std::size_t index = 0;
             index < static_cast<std::size_t>(SquareType::InJail); ++index)
        {
            const auto square = static_cast<SquareType>(index);
            const auto bit = rules::board::propertyBit(square);
            if (bit == 0 || (owned & bit) == 0 || !state.squares[index].mortgaged)
                continue;
 
            const auto cost = static_cast<std::int64_t>(
                static_cast<double>(rules::board::definition(square).mortgageCost) * 1.1);
            const auto available = ai::testForMonopoly(owned, square)
                ? mortgageable : cashOnly;
            if (available >= cost)
                return true;
        }
        return false;
    }
 
    HousePurchaseDecision shouldBuyHouse(
        const rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::uint8_t housingPurchaseStrategy,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count ||
            state.options.housesPerHotel == 0)
            return HousePurchaseDecision::No;
 
        const auto excess = excessCashAvailable(
            state, player, false, strategy, minCashOnHand, moneyOwed);
        if (excess == 0)
            return HousePurchaseDecision::No;
 
        const auto monopolies = ai::monopoliesOwned(state, player, false);
        if (monopolies.count == 0)
            return HousePurchaseDecision::No;
 
        const bool shortage = ai::housingShortage(state, CriticalHousingLevel);
        const auto topHousesOnLot = static_cast<std::uint8_t>(
            shortage ? state.options.housesPerHotel - 1 : state.options.housesPerHotel);
        bool foundDeferredMonopoly{};
 
        for (std::size_t index = 0;
             index < static_cast<std::size_t>(SquareType::InJail); ++index)
        {
            const auto square = static_cast<SquareType>(index);
            const auto& definition = rules::board::definition(square);
            bool belongsToMonopoly{};
            for (std::size_t monopolyIndex = 0; monopolyIndex < monopolies.count; ++monopolyIndex)
            {
                if (definition.group == rules::board::definition(
                        monopolies.representatives[monopolyIndex]).group)
                {
                    belongsToMonopoly = true;
                    break;
                }
            }
            if (!belongsToMonopoly || state.squares[index].houses >= topHousesOnLot)
                continue;
 
            if ((housingPurchaseStrategy & HouseBuyWithin12) != 0 && !shortage &&
                !ai::playerCloseToProperty(state, player, square, 2, 12))
            {
                foundDeferredMonopoly = true;
                continue;
            }
 
            std::int64_t buyCount = 1;
            if ((housingPurchaseStrategy & HouseBuyAtLeast3) != 0 && !shortage)
            {
                const auto lots = ai::monopolyLots(square);
                buyCount = static_cast<std::int64_t>(lots.count * 3) -
                    ai::housesOnMonopoly(state, square);
                if (buyCount < 1)
                    buyCount = 1;
            }
 
            const auto unmortgageCost = ai::costUnmortgageMonopoly(state, square);
            if (definition.housePurchaseCost * buyCount <= excess - unmortgageCost)
                return HousePurchaseDecision::Yes;
        }
 
        return foundDeferredMonopoly
            ? HousePurchaseDecision::Later : HousePurchaseDecision::No;
    }
 
    EconomicActionPlan planBuyHouseAction(
        const rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::uint8_t housingPurchaseStrategy,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        EconomicActionPlan none{};
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count ||
            state.options.housesPerHotel == 0)
            return none;
 
        const auto planMortgageWorst = [&]() -> EconomicActionPlan {
            auto simulated = state;
            if (!mortgageWorstProperty(simulated, player, false, false))
                return {};
            for (std::size_t index = 0;
                 index < static_cast<std::size_t>(SquareType::InJail); ++index)
            {
                if (!state.squares[index].mortgaged && simulated.squares[index].mortgaged)
                    return {EconomicActionKind::MortgageProperty,
                        static_cast<SquareType>(index)};
            }
            return {};
        };
 
        const auto excess = excessCashAvailable(
            state, player, false, strategy, minCashOnHand, moneyOwed);
        if (excess == 0)
            return none;
 
        const int freeHouses = ai::freeHouses(state);
        const int freeHotels = ai::freeHotels(state);
        const auto ownedMonopolies = ai::monopoliesOwned(state, player, false);
        if (ownedMonopolies.count == 0)
            return none;
 
        const bool shortage = ai::housingShortage(state, CriticalHousingLevel);
        int topHousesOnLot = shortage
            ? static_cast<int>(state.options.housesPerHotel) - 1
            : static_cast<int>(state.options.housesPerHotel);
 
        std::array<SquareType, 8> monopolies{};
        std::size_t monopolyCount{};
        for (std::size_t index = 0; index < ownedMonopolies.count; ++index)
        {
            const auto representative = ownedMonopolies.representatives[index];
            const auto lots = ai::monopolyLots(representative);
            if ((housingPurchaseStrategy & HouseBuyWithin12) != 0 &&
                !ai::someoneCloseToMonopoly(state, player, lots))
                continue;
            monopolies[monopolyCount++] = representative;
        }
        if (monopolyCount == 0)
            return none;
 
        SquareType bestSquare = SquareType::Go;
        double bestMetric{};
        if (freeHouses > 0)
        {
            for (std::size_t index = 0; index < monopolyCount; ++index)
            {
                const auto representative = monopolies[index];
                const auto lots = ai::monopolyLots(representative);
                auto buyHouses = static_cast<std::int64_t>(lots.count * 3) -
                    ai::housesOnMonopoly(state, representative);
                if (buyHouses < 1)
                    continue;
                const auto unmortgageCost = ai::costUnmortgageMonopoly(state, representative);
                const auto houseCost = rules::board::definition(representative).housePurchaseCost;
                if (buyHouses * houseCost > excess - unmortgageCost)
                    continue;
                const auto baseRent = static_cast<double>(
                    rules::board::definition(representative).rent[0]);
                if (bestMetric < baseRent)
                {
                    bestMetric = baseRent;
                    bestSquare = representative;
                }
            }
 
            if (bestSquare == SquareType::Go)
            {
                for (std::size_t index = 0; index < monopolyCount; ++index)
                {
                    const auto representative = monopolies[index];
                    const auto lots = ai::monopolyLots(representative);
                    if (ai::housesOnMonopoly(state, representative) >=
                        static_cast<int>(lots.count * 3))
                        continue;
                    if (rules::board::definition(representative).housePurchaseCost > excess)
                        continue;
                    const auto frequency = monopolyFrequency(representative);
                    if (bestMetric < frequency)
                    {
                        bestMetric = frequency;
                        bestSquare = representative;
                    }
                }
            }
        }
 
        if (bestSquare == SquareType::Go)
        {
            bestMetric = 0.0;
            for (std::size_t index = 0; index < monopolyCount; ++index)
            {
                const auto representative = monopolies[index];
                const auto lots = ai::monopolyLots(representative);
                const auto houses = ai::housesOnMonopoly(state, representative);
                if (houses >= static_cast<int>(lots.count * topHousesOnLot))
                    continue;
                const auto unmortgageCost = ai::costUnmortgageMonopoly(state, representative);
                const auto houseCost = rules::board::definition(representative).housePurchaseCost;
                if (houseCost > excess - unmortgageCost)
                    continue;
                const auto hotelThreshold =
                    (static_cast<int>(state.options.housesPerHotel) - 1) *
                    static_cast<int>(lots.count);
                if (houses >= hotelThreshold && freeHotels == 0)
                    continue;
                if (houses < hotelThreshold && freeHouses == 0)
                    continue;
                const auto frequency = monopolyFrequency(representative);
                if (bestMetric < frequency)
                {
                    bestMetric = frequency;
                    bestSquare = representative;
                }
            }
        }
 
        if (bestSquare == SquareType::Go)
            return none;
 
        const auto lots = ai::monopolyLots(bestSquare);
        const auto unmortgageCost = ai::costUnmortgageMonopoly(state, bestSquare);
        if (unmortgageCost > excess)
            return none;
        if (state.players[player].cash < unmortgageCost)
            return planMortgageWorst();
        if (unmortgageCost > 0)
        {
            for (std::size_t index = lots.count; index > 0; --index)
            {
                const auto square = lots.squares[index - 1];
                if (state.squares[static_cast<std::size_t>(square)].mortgaged)
                    return {EconomicActionKind::UnmortgageProperty, square};
            }
        }
 
        if (state.options.evenBuildRule)
        {
            const auto balancedTop = ai::housesOnMonopoly(state, bestSquare) /
                static_cast<int>(lots.count) + 1;
            if (balancedTop < topHousesOnLot)
                topHousesOnLot = balancedTop;
        }
 
        std::array<SquareType, 3> buildable{};
        std::size_t buildableCount{};
        for (std::size_t index = 0; index < lots.count; ++index)
        {
            const auto square = lots.squares[index];
            if (state.squares[static_cast<std::size_t>(square)].houses < topHousesOnLot)
                buildable[buildableCount++] = square;
        }
        if (buildableCount == 0)
            return none;
 
        for (std::size_t index = 0; index < buildableCount; ++index)
        {
            const auto square = buildable[index];
            if (!ai::playerCloseToProperty(state, player, square, 7, 7))
                continue;
            if (state.players[player].cash < rules::board::definition(square).housePurchaseCost)
                return planMortgageWorst();
            return {EconomicActionKind::BuyHouse, square};
        }
 
        const auto square = buildable[0];
        if (state.players[player].cash < rules::board::definition(square).housePurchaseCost)
            return planMortgageWorst();
        return {EconomicActionKind::BuyHouse, square};
    }
 
    std::optional<rules::board::SquareType> chooseHousingAuctionSquare(
        const rules::GameState& state,
        rules::PlayerNumber player,
        HousingAuctionBuilding building,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        rules::board::PropertySet legalSquares,
        bool reservedBuilding,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count ||
            state.options.housesPerHotel == 0)
            return std::nullopt;
 
        const auto excess = reservedBuilding ? 0 : excessCashAvailable(
            state, player, false, strategy, minCashOnHand, moneyOwed);
        if (!reservedBuilding && excess == 0)
            return std::nullopt;
 
        const int freeHouses = reservedBuilding && building == HousingAuctionBuilding::House
            ? 1 : ai::freeHouses(state);
        const int freeHotels = reservedBuilding && building == HousingAuctionBuilding::Hotel
            ? 1 : ai::freeHotels(state);
        const auto owned = ai::monopoliesOwned(state, player, false);
        if (owned.count == 0)
            return std::nullopt;
 
        int topHousesOnLot = ai::housingShortage(state, CriticalHousingLevel)
            ? static_cast<int>(state.options.housesPerHotel) - 1
            : static_cast<int>(state.options.housesPerHotel);
        const int hotelThresholdPerLot = static_cast<int>(state.options.housesPerHotel) - 1;
 
        const auto monopolyHasLegalSquare = [&](SquareType representative) {
            if (legalSquares == 0)
                return true;
            const auto lots = ai::monopolyLots(representative);
            for (std::size_t i = 0; i < lots.count; ++i)
            {
                if ((legalSquares & rules::board::propertyBit(lots.squares[i])) != 0)
                    return true;
            }
            return false;
        };
 
        SquareType bestSquare = SquareType::Go;
        double bestMetric{};
        if (building == HousingAuctionBuilding::House && freeHouses > 0)
        {
            for (std::size_t i = 0; i < owned.count; ++i)
            {
                const auto rep = owned.representatives[i];
                const auto lots = ai::monopolyLots(rep);
                if (!monopolyHasLegalSquare(rep) || ai::costUnmortgageMonopoly(state, rep) > 0)
                    continue;
                auto buyHouses = static_cast<std::int64_t>(lots.count * 3) -
                    ai::housesOnMonopoly(state, rep);
                if (buyHouses < 1)
                    continue;
                const auto cost = rules::board::definition(rep).housePurchaseCost;
                if (!reservedBuilding && buyHouses * cost > excess)
                    continue;
                const auto rent = static_cast<double>(rules::board::definition(rep).rent[0]);
                if (bestMetric < rent)
                {
                    bestMetric = rent;
                    bestSquare = rep;
                }
            }
 
            if (bestSquare == SquareType::Go)
            {
                bestMetric = 0.0;
                for (std::size_t i = 0; i < owned.count; ++i)
                {
                    const auto rep = owned.representatives[i];
                    const auto lots = ai::monopolyLots(rep);
                    if (!monopolyHasLegalSquare(rep) || ai::costUnmortgageMonopoly(state, rep) > 0 ||
                        ai::housesOnMonopoly(state, rep) >= static_cast<int>(lots.count * 3))
                        continue;
                    const auto cost = rules::board::definition(rep).housePurchaseCost;
                    if (!reservedBuilding && cost > excess)
                        continue;
                    const auto frequency = monopolyFrequency(rep);
                    if (bestMetric < frequency)
                    {
                        bestMetric = frequency;
                        bestSquare = rep;
                    }
                }
            }
        }
 
        if (bestSquare == SquareType::Go)
        {
            bestMetric = 0.0;
            for (std::size_t i = 0; i < owned.count; ++i)
            {
                const auto rep = owned.representatives[i];
                const auto lots = ai::monopolyLots(rep);
                if (!monopolyHasLegalSquare(rep) || ai::costUnmortgageMonopoly(state, rep) > 0)
                    continue;
                const auto houses = ai::housesOnMonopoly(state, rep);
                if (houses >= static_cast<int>(lots.count * topHousesOnLot))
                    continue;
                const auto cost = rules::board::definition(rep).housePurchaseCost;
                if (!reservedBuilding && cost > excess)
                    continue;
                const auto hotelThreshold = hotelThresholdPerLot * static_cast<int>(lots.count);
                if (building == HousingAuctionBuilding::Hotel)
                {
                    if (houses < hotelThreshold || freeHotels == 0)
                        continue;
                }
                else if (houses >= hotelThreshold || freeHouses == 0)
                    continue;
                const auto frequency = monopolyFrequency(rep);
                if (bestMetric < frequency)
                {
                    bestMetric = frequency;
                    bestSquare = rep;
                }
            }
        }
        if (bestSquare == SquareType::Go)
            return std::nullopt;
 
        const auto lots = ai::monopolyLots(bestSquare);
        if (state.options.evenBuildRule)
        {
            const auto balancedTop = ai::housesOnMonopoly(state, bestSquare) /
                static_cast<int>(lots.count) + 1;
            if (balancedTop < topHousesOnLot)
                topHousesOnLot = balancedTop;
        }
 
        for (std::size_t i = 0; i < lots.count; ++i)
        {
            const auto square = lots.squares[i];
            const auto bit = rules::board::propertyBit(square);
            if (legalSquares != 0 && (legalSquares & bit) == 0)
                continue;
            const auto houses = state.squares[static_cast<std::size_t>(square)].houses;
            if (houses >= topHousesOnLot)
                continue;
            if (building == HousingAuctionBuilding::Hotel && houses < hotelThresholdPerLot)
                continue;
            if (building == HousingAuctionBuilding::House && houses >= hotelThresholdPerLot)
                continue;
            return square;
        }
        return std::nullopt;
    }
 
    EconomicActionPlan planUnmortgagePropertyAction(
        const rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        std::int64_t moneyOwed) noexcept
    {
        using rules::board::SquareType;
        EconomicActionPlan none{};
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count)
            return none;
 
        const auto planMortgageWorst = [&]() -> EconomicActionPlan {
            auto simulated = state;
            if (!mortgageWorstProperty(simulated, player, false, false))
                return {};
            for (std::size_t index = 0;
                 index < static_cast<std::size_t>(SquareType::InJail); ++index)
            {
                if (!state.squares[index].mortgaged && simulated.squares[index].mortgaged)
                    return {EconomicActionKind::MortgageProperty,
                        static_cast<SquareType>(index)};
            }
            return {};
        };
 
        const auto owned = ai::propertiesOwnedByPlayer(state, player);
        const auto cashOnly = excessCashAvailable(
            state, player, true, strategy, minCashOnHand, moneyOwed);
        const auto mortgageable = excessCashAvailable(
            state, player, false, strategy, minCashOnHand, moneyOwed);
        const auto cash = state.players[player].cash;
 
        const auto tryMonopolyRange = [&](std::size_t begin, std::size_t endExclusive)
            -> EconomicActionPlan {
            for (std::size_t index = begin; index < endExclusive; ++index)
            {
                const auto square = static_cast<SquareType>(index);
                const auto bit = rules::board::propertyBit(square);
                if (bit == 0 || (owned & bit) == 0 ||
                    !state.squares[index].mortgaged ||
                    !ai::testForMonopoly(owned, square))
                    continue;
                const auto rawCost = static_cast<double>(
                    rules::board::definition(square).mortgageCost) * 1.1;
                if (static_cast<double>(mortgageable) < rawCost)
                    continue;
                if (static_cast<double>(cash) < rawCost)
                    return planMortgageWorst();
                return {EconomicActionKind::UnmortgageProperty, square};
            }
            return {};
        };
 
        auto plan = tryMonopolyRange(
            static_cast<std::size_t>(SquareType::OrientalAvenue),
            static_cast<std::size_t>(SquareType::InJail));
        if (plan.acted())
            return plan;
        plan = tryMonopolyRange(
            static_cast<std::size_t>(SquareType::Go),
            static_cast<std::size_t>(SquareType::BalticAvenue) + 1);
        if (plan.acted())
            return plan;
 
        const auto square = ai::findHighestRentMortgaged(
            state, player, owned, cashOnly);
        if (square == SquareType::Go)
            return none;
        const auto rawCost = static_cast<double>(
            rules::board::definition(square).mortgageCost) * 1.1;
        if (static_cast<double>(cash) < rawCost)
            return none;
        return {EconomicActionKind::UnmortgageProperty, square};
    }
 
    std::optional<bool> chooseFractionTax(
        const rules::GameState& state,
        rules::PlayerNumber player) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers)
            return std::nullopt;
        const auto percentage =
            ai::totalWorth(state, player) * state.options.taxRate / 100;
        return percentage <= state.options.flatTaxFee;
    }
 
    std::optional<JailExitChoice> chooseJailExitChoice(
        const rules::GameState& state,
        rules::PlayerNumber player,
        bool canRollDoubles,
        bool canPayFee,
        bool canUseCard) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers)
            return std::nullopt;
 
        // Retail receives can_pay_fifty but never consults it.
        (void)canPayFee;
 
        if (canUseCard && state.players[player].turnsInJail == 2)
            return JailExitChoice::Card;
        if (!canRollDoubles)
            return canUseCard ? JailExitChoice::Card : JailExitChoice::Pay;
 
        const auto directMonopoly = [&](SquareType square) noexcept {
            const auto index = static_cast<std::size_t>(square);
            if (state.squares[index].owner != rules::NobodyPlayer)
                return false;
            const auto bit = rules::board::propertyBit(square);
            if (bit == 0)
                return false;
            for (rules::PlayerNumber current = 0;
                 current < state.numberOfPlayers; ++current)
            {
                const auto owned = ai::propertiesOwnedByPlayer(state, current);
                if (ai::testForMonopoly(owned | bit, square))
                    return true;
            }
            return false;
        };
 
        const auto electric = static_cast<std::size_t>(SquareType::ElectricCompany);
        const auto water = static_cast<std::size_t>(SquareType::WaterWorks);
        if (state.squares[electric].owner == rules::NobodyPlayer &&
            state.squares[water].owner == player &&
            ai::propertiesLeftToBuy(state) <= 3)
            return JailExitChoice::Roll;
 
        if (directMonopoly(SquareType::VirginiaAvenue) ||
            directMonopoly(SquareType::TennesseeAvenue) ||
            directMonopoly(SquareType::StJamesPlace))
            return JailExitChoice::Roll;
 
        double averageRent = static_cast<double>(state.options.passingGoAmount) -
            static_cast<double>(ai::averageRentPaid(state, player, 0, true, 1.0));
        averageRent /= 5.0;
        averageRent *= 2.5;
        if (averageRent < static_cast<double>(state.options.getOutOfJailFee))
            return JailExitChoice::Roll;
 
        return canUseCard ? JailExitChoice::Card : JailExitChoice::Pay;
    }
 
    std::int64_t totalWorthWithFactors(
        const rules::GameState& state,
        rules::PlayerNumber player,
        const WorthFactors& factors) noexcept
    {
        using rules::board::SquareGroup;
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers || player >= state.numberOfPlayers)
            return 0;
 
        const auto owned = ai::propertiesOwnedByPlayer(state, player);
        const auto railroadCount = ai::numberRailroadsUtilitiesOwned(
            state, player, SquareGroup::Railroad, false, owned);
        const auto utilityCount = ai::numberRailroadsUtilitiesOwned(
            state, player, SquareGroup::Utility, false, owned);
 
        std::int64_t total{};
        for (std::size_t index = 0;
             index < static_cast<std::size_t>(SquareType::InJail); ++index)
        {
            const auto square = static_cast<SquareType>(index);
            const auto bit = rules::board::propertyBit(square);
            if (bit == 0 || (owned & bit) == 0)
                continue;
 
            const auto& definition = rules::board::definition(square);
            total += definition.housePurchaseCost * state.squares[index].houses;
 
            double factor{};
            if (definition.group == SquareGroup::Railroad && railroadCount > 0)
            {
                const auto factorIndex = static_cast<std::size_t>(railroadCount - 1);
                if (factorIndex < 4)
                    factor = factors.cashCow[factorIndex];
            }
            else if (definition.group == SquareGroup::Utility && utilityCount > 0)
            {
                const auto factorIndex = static_cast<std::size_t>(4 + utilityCount - 1);
                if (factorIndex < factors.cashCow.size())
                    factor = factors.cashCow[factorIndex];
            }
            else
            {
                const auto factorIndex = static_cast<std::size_t>(definition.group);
                if (factorIndex < factors.property.size())
                    factor = factors.property[factorIndex];
            }
            total += static_cast<std::int64_t>(
                static_cast<double>(definition.purchaseCost) * factor);
        }
        return total + state.players[player].cash;
    }
 
    bool mortgageWorstProperty(
        rules::GameState& state,
        rules::PlayerNumber player,
        bool sellHouses,
        bool mortgageMonopoly) noexcept
    {
        using rules::board::SquareGroup;
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers || player >= state.numberOfPlayers)
            return false;
 
        const auto owned = ai::propertiesOwnedByPlayer(state, player);
        auto monopoliless = owned;
        auto housingless = owned;
 
        const auto mortgage = [&](SquareType square) {
            const auto index = static_cast<std::size_t>(square);
            state.players[player].cash += rules::board::definition(square).mortgageCost;
            state.squares[index].mortgaged = true;
        };
 
        for (const auto square : MortgageOrder)
        {
            const auto bit = rules::board::propertyBit(square);
            if (bit == 0 || (owned & bit) == 0)
                continue;
 
            const auto index = static_cast<std::size_t>(square);
            // Retail tests unsigned-char houses >= 0, which is always true and
            // empties the intended "housingless" set. Keep only genuinely
            // undeveloped lots so the documented fallback can actually run.
            if (state.squares[index].houses > 0)
                housingless &= ~bit;
 
            const bool monopoly = ai::ownsMonopoly(
                state, player, square, mortgageMonopoly);
            if (monopoly)
                monopoliless &= ~bit;
 
            if (state.squares[index].mortgaged)
                continue;
 
            const auto group = rules::board::definition(square).group;
            int groupCount{};
            if (group == SquareGroup::Railroad || group == SquareGroup::Utility)
            {
                groupCount = ai::numberRailroadsUtilitiesOwned(
                    state, player, group,
                    state.options.mortgagedCountsInGroupRent, owned);
            }
 
            if (!monopoly && groupCount < 2)
            {
                mortgage(square);
                return true;
            }
        }
 
        SquareType mortgageSquare = SquareType::Go;
        if (!sellHouses && !mortgageMonopoly)
        {
            mortgageSquare = ai::findLowestRentProperty(
                state, player, monopoliless);
        }
        else if (!sellHouses)
        {
            mortgageSquare = ai::findLowestRentProperty(
                state, player, housingless);
        }
        else if (ai::housingShortage(state, CriticalHousingLevel))
        {
            mortgageSquare = ai::findLowestRentProperty(
                state, player, housingless);
            if (mortgageSquare == SquareType::Go)
                mortgageSquare = ai::findLowestRentProperty(state, player, owned);
        }
        else
        {
            mortgageSquare = ai::findLowestRentProperty(state, player, owned);
        }
 
        if (mortgageSquare == SquareType::Go)
            return false;
 
        if (ai::housesOnMonopoly(state, mortgageSquare) > 0)
        {
            const auto lots = ai::monopolyLots(mortgageSquare);
            ai::testSellHouses(state, lots, mortgageSquare);
        }
        else
        {
            mortgage(mortgageSquare);
        }
        return true;
    }
 
    EconomicActionPlan planHouseSaleAction(
        const rules::GameState& state,
        rules::board::SquareType referenceSquare) noexcept
    {
        using rules::board::SquareType;
        const auto raw = static_cast<std::size_t>(referenceSquare);
        if (raw >= static_cast<std::size_t>(SquareType::InJail))
            return {};
 
        const auto lots = ai::monopolyLots(referenceSquare);
        if (lots.count == 0)
            return {};
 
        auto simulated = state;
        ai::testSellHouses(simulated, lots, referenceSquare);
 
        SquareType soldSquare = SquareType::InJail;
        std::uint8_t maxHouses{};
        for (std::size_t index = 0; index < lots.count; ++index)
        {
            const auto square = lots.squares[index];
            const auto squareIndex = static_cast<std::size_t>(square);
            if (simulated.squares[squareIndex].houses >=
                state.squares[squareIndex].houses)
                continue;
            if (soldSquare == SquareType::InJail ||
                state.squares[squareIndex].houses > maxHouses)
            {
                soldSquare = square;
                maxHouses = state.squares[squareIndex].houses;
            }
        }
        if (soldSquare == SquareType::InJail)
            return {};
        return {EconomicActionKind::SellBuilding, soldSquare};
    }
 
    EconomicActionPlan planDebtLiquidationStep(
        const rules::GameState& state,
        rules::PlayerNumber player,
        bool sellHouses) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers)
            return {};
 
        auto simulated = state;
        if (!mortgageWorstProperty(simulated, player, sellHouses, true))
            return {};
 
        for (std::size_t index = 0;
             index < static_cast<std::size_t>(SquareType::InJail); ++index)
        {
            if (!state.squares[index].mortgaged &&
                simulated.squares[index].mortgaged)
                return {EconomicActionKind::MortgageProperty,
                    static_cast<SquareType>(index)};
        }
 
        SquareType soldSquare = SquareType::InJail;
        std::uint8_t maxHouses{};
        for (std::size_t index = 0;
             index < static_cast<std::size_t>(SquareType::InJail); ++index)
        {
            if (simulated.squares[index].houses >= state.squares[index].houses)
                continue;
            if (soldSquare == SquareType::InJail ||
                state.squares[index].houses > maxHouses)
            {
                soldSquare = static_cast<SquareType>(index);
                maxHouses = state.squares[index].houses;
            }
        }
        if (soldSquare != SquareType::InJail)
            return {EconomicActionKind::SellBuilding, soldSquare};
        return {};
    }
 
    void mortgageNegativeCashPlayers(rules::GameState& state) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers)
            return;
        for (rules::PlayerNumber player = 0; player < state.numberOfPlayers; ++player)
        {
            if (state.players[player].currentSquare ==
                static_cast<std::uint8_t>(rules::board::SquareType::OffBoard))
                continue;
            while (state.players[player].cash < 0)
            {
                if (!mortgageWorstProperty(state, player, true, true))
                    break;
            }
        }
    }
 
    double evaluateWinningChances(
        const rules::GameState& state,
        rules::PlayerNumber player,
        const WinningChanceConfig& config,
        std::span<double> savePlayerChances) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers)
            return 0.0;
        const bool saveAll = !savePlayerChances.empty();
        if ((!saveAll && player >= state.numberOfPlayers) ||
            (saveAll && savePlayerChances.size() < state.numberOfPlayers))
            return 0.0;
 
        std::array<double, rules::MaxPlayers> localChances{};
        double* chances = saveAll ? savePlayerChances.data() : localChances.data();
        std::fill(chances, chances + state.numberOfPlayers, 0.0);
        auto simulated = state;
        const bool shortage = ai::housingShortage(state, CriticalHousingLevel);
 
        for (rules::PlayerNumber current = 0; current < simulated.numberOfPlayers; ++current)
        {
            if (state.players[current].currentSquare ==
                static_cast<std::uint8_t>(SquareType::OffBoard))
                continue;
            do
            {
                if (!shortage)
                {
                    while (hypotheticalBuyHouse(
                        simulated, current, config.moneyOwed[current]))
                    {
                    }
                }
            } while (hypotheticalUnmortgageProperty(
                simulated, current, true, config.cashStrategy[current],
                config.minCashOnHand[current], config.moneyOwed[current]) != SquareType::Go);
        }
 
        for (rules::PlayerNumber current = 0; current < simulated.numberOfPlayers; ++current)
        {
            if (state.players[current].currentSquare ==
                static_cast<std::uint8_t>(SquareType::OffBoard))
                continue;
            while (hypotheticalUnmortgageProperty(
                simulated, current, false, config.cashStrategy[current],
                config.minCashOnHand[current], config.moneyOwed[current]) != SquareType::Go)
            {
            }
        }
 
        for (rules::PlayerNumber current = 0; current < simulated.numberOfPlayers; ++current)
        {
            if (state.players[current].currentSquare ==
                static_cast<std::uint8_t>(SquareType::OffBoard))
                continue;
            while (simulated.players[current].cash < 0)
            {
                if (!mortgageWorstProperty(simulated, current, false, false) &&
                    !mortgageWorstProperty(simulated, current, false, true) &&
                    !mortgageWorstProperty(simulated, current, true, true))
                    break;
            }
        }
 
        double totalAbsoluteChance{};
        for (rules::PlayerNumber current = 0; current < simulated.numberOfPlayers; ++current)
        {
            const auto owned = ai::propertiesOwnedByPlayer(state, current);
            chances[current] = ai::averageRentReceived(
                simulated, current, 0, false, 0.07, owned) *
                static_cast<double>(simulated.numberOfPlayers - 1);
            chances[current] -= static_cast<double>(
                ai::averageRentPaid(simulated, current, 0, true, 0.07));
            chances[current] += static_cast<double>(state.options.passingGoAmount);
 
            const auto liquidAssets = ai::liquidAssets(
                simulated, current, false, false, config.moneyOwed[current]);
            switch (ai::monopolyStage(simulated, current))
            {
            case ai::MonopolyStage::Buying:
            case ai::MonopolyStage::NoMonopolies:
            {
                constexpr double MonopolySquareCount = 22.0;
                const double buyingFraction =
                    static_cast<double>(ai::propertiesLeftToBuy(state)) / MonopolySquareCount;
                double multiplier =
                    config.buyingStageCashMultiplier * buyingFraction +
                    config.noMonopolyStageCashMultiplier * (1.0 - buyingFraction);
                const double dependence = config.cashLiquidAssetsDependence > 0.0
                    ? config.cashLiquidAssetsDependence : 1.0;
                double assetScale = 1.0 / std::exp(
                    std::log(dependence) * static_cast<double>(liquidAssets) / 1000.0);
                assetScale = std::clamp(assetScale, 0.25, 1.0);
                multiplier *= assetScale;
                chances[current] += multiplier * static_cast<double>(liquidAssets);
                break;
            }
            case ai::MonopolyStage::MonopoliesNotOwnOne:
                chances[current] += config.monopolyNotOwnedStageCashMultiplier *
                    static_cast<double>(liquidAssets);
                break;
            case ai::MonopolyStage::MonopoliesOwnOne:
                chances[current] += config.monopolyOwnedStageCashMultiplier *
                    static_cast<double>(liquidAssets);
                break;
            }
 
            if (chances[current] > 0.0)
                totalAbsoluteChance += chances[current];
        }
 
        if (totalAbsoluteChance == 0.0)
            totalAbsoluteChance = 1.0;
 
        double normalizeConstant{};
        for (rules::PlayerNumber current = 0; current < simulated.numberOfPlayers; ++current)
        {
            chances[current] /= totalAbsoluteChance;
            chances[current] = std::exp(chances[current]);
            normalizeConstant += chances[current];
        }
        for (rules::PlayerNumber current = 0; current < simulated.numberOfPlayers; ++current)
            chances[current] /= normalizeConstant;
 
        if (saveAll)
            return 0.0;
        return chances[player];
    }
 
    double evaluateTrade(
        const rules::GameState& state,
        rules::PlayerNumber player,
        rules::PlayerNumber strategyPlayer,
        const ai::trade::TradeProposalList& proposals,
        const TradeEvaluationConfig& config) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategyPlayer >= state.numberOfPlayers)
            return -50.0;
 
        auto before = state;
        auto after = state;
        ai::trade::applyTradeToState(after, proposals);
        mortgageNegativeCashPlayers(after);
        if (config.purchasingPlayer < state.numberOfPlayers &&
            config.purchasingProperty < rules::board::SquareType::InJail)
        {
            const auto index = static_cast<std::size_t>(config.purchasingProperty);
            before.squares[index].owner = config.purchasingPlayer;
            after.squares[index].owner = config.purchasingPlayer;
        }
 
        const double chancesBefore = evaluateWinningChances(
            before, player, config.winningChance);
        const double chancesAfter = evaluateWinningChances(
            after, player, config.winningChance);
        if ((chancesBefore - chancesAfter) > config.chancesThreshold)
            return -50.0;
 
        auto worthBefore = totalWorthWithFactors(before, player, config.worthFactors);
        auto worthAfter = totalWorthWithFactors(after, player, config.worthFactors);
        const auto debt = config.winningChance.moneyOwed[player];
        if (ai::liquidAssets(after, player, true, true, debt) <= 0)
            return -50.0;
        for (std::size_t deck = 0;
             deck < static_cast<std::size_t>(rules::DeckType::Count); ++deck)
        {
            if (before.cards[deck].jailOwner == player)
                worthBefore += config.jailCardValue;
            if (after.cards[deck].jailOwner == player)
                worthAfter += config.jailCardValue;
        }
 
        const double propertyImportance = ai::trade::calculateTradePropertyImportance(
            before, after, player, strategyPlayer, proposals, false,
            config.propertyImportance, config.winningChance.moneyOwed);
        return (chancesAfter - chancesBefore) * config.chancesFactor +
            static_cast<double>(worthAfter - worthBefore) * config.cashFactor +
            propertyImportance * config.tradeImportanceFactor;
    }
 
    std::int64_t tradeBidForProperty(
        const rules::GameState& state, rules::PlayerNumber player,
        rules::board::SquareType property, std::int64_t currentBid,
        rules::PlayerNumber currentBidder, const AuctionBidConfig& config) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || property >= SquareType::InJail ||
            currentBid < 0 || currentBidder == player)
            return 0;
 
        constexpr std::int64_t Change = 10;
        auto afterCurrentBid = state;
        auto afterOurBid = state;
        const auto index = static_cast<std::size_t>(property);
        const bool validBidder = currentBidder < state.numberOfPlayers;
        if (validBidder)
        {
            afterCurrentBid.squares[index].owner = currentBidder;
            afterCurrentBid.players[currentBidder].cash -= currentBid;
        }
        afterOurBid.squares[index].owner = player;
        afterOurBid.players[player].cash -= currentBid + Change;
        mortgageNegativeCashPlayers(afterCurrentBid);
        mortgageNegativeCashPlayers(afterOurBid);
 
        const auto mortgageCost = rules::board::definition(property).mortgageCost;
        const auto debtFor = [&](rules::PlayerNumber current) {
            return current < config.evaluation.winningChance.moneyOwed.size()
                ? config.evaluation.winningChance.moneyOwed[current] : 0;
        };
        if (validBidder && ai::liquidAssets(
                afterCurrentBid, currentBidder, true, true, debtFor(currentBidder)) -
                mortgageCost < 0)
            return 0;
        if (ai::liquidAssets(afterOurBid, player, true, true, debtFor(player)) -
            mortgageCost < 0)
            return 0;
 
        const double chancesBefore = evaluateWinningChances(
            afterCurrentBid, player, config.evaluation.winningChance);
        const double chancesAfter = evaluateWinningChances(
            afterOurBid, player, config.evaluation.winningChance);
        if ((chancesBefore - chancesAfter) > config.evaluation.chancesThreshold)
            return 0;
 
        auto worthBefore = totalWorthWithFactors(
            afterCurrentBid, player, config.evaluation.worthFactors);
        auto worthAfter = totalWorthWithFactors(
            afterOurBid, player, config.evaluation.worthFactors);
        for (std::size_t deck = 0;
             deck < static_cast<std::size_t>(rules::DeckType::Count); ++deck)
        {
            if (afterCurrentBid.cards[deck].jailOwner == player)
                worthBefore += config.evaluation.jailCardValue;
            if (afterOurBid.cards[deck].jailOwner == player)
                worthAfter += config.evaluation.jailCardValue;
        }
 
        ai::trade::TradeProposalList proposal{};
        const auto bit = rules::board::propertyBit(property);
        proposal[player].propertiesReceived = bit;
        if (validBidder)
            proposal[currentBidder].propertiesGiven = bit;
        const double propertyImportance = ai::trade::calculateTradePropertyImportance(
            afterCurrentBid, afterOurBid, player, player, proposal, false,
            config.evaluation.propertyImportance,
            config.evaluation.winningChance.moneyOwed);
        const double evaluation =
            (chancesAfter - chancesBefore) * config.evaluation.chancesFactor +
            static_cast<double>(worthAfter - worthBefore) * config.evaluation.cashFactor +
            propertyImportance * config.evaluation.tradeImportanceFactor;
        return evaluation >= 0.0 ? currentBid + Change : 0;
    }
 
    std::int64_t bidForAuctionItem(
        const rules::GameState& state, rules::PlayerNumber player,
        rules::board::SquareType item, std::int64_t currentBid,
        rules::PlayerNumber currentBidder, const AuctionBidConfig& config,
        bool useTenDollarIncrement) noexcept
    {
        using rules::board::SquareType;
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || item >= SquareType::Count ||
            currentBid < 0 || currentBidder == player)
            return 0;
 
        const auto debt = config.evaluation.winningChance.moneyOwed[player];
        const auto strategy = config.evaluation.winningChance.cashStrategy[player];
        const auto minCash = config.evaluation.winningChance.minCashOnHand[player];
        const auto liquid = ai::liquidAssets(state, player, false, false, debt);
        const auto liquidSellingHouses = ai::liquidAssets(state, player, true, false, debt);
        const auto cashAfterHousing = cashAvailableAfterHousing(
            state, player, strategy, minCash, debt);
        const auto excessCash = excessCashAvailable(
            state, player, false, strategy, minCash, debt);
 
        double bid{};
        std::int64_t mortgageCost{};
        std::int64_t purchaseCost{};
        auto importance = ai::trade::StrategicPropertyImportance::NotImportant;
        std::int64_t tradeBid{};
        if (item < SquareType::InJail)
        {
            const auto& definition = rules::board::definition(item);
            mortgageCost = definition.mortgageCost;
            purchaseCost = definition.purchaseCost;
            importance = ai::trade::strategicPropertyImportance(state, item);
            tradeBid = tradeBidForProperty(
                state, player, item, currentBid, currentBidder, config);
        }
        else
        {
            if (shouldBuyHouse(state, player, strategy, minCash,
                    config.housingPurchaseStrategy, debt) == HousePurchaseDecision::No)
                return 0;
            const auto monopolies = ai::monopoliesOwned(state, player, false);
            std::int64_t housesWanted{};
            for (std::size_t index = 0; index < monopolies.count; ++index)
                housesWanted += ai::housesCanBuyOnMonopoly(
                    state, monopolies.representatives[index]);
            housesWanted = std::min<std::int64_t>(housesWanted, ai::freeHouses(state));
            if (housesWanted <= 0)
                return 0;
            bid = static_cast<double>(excessCash) /
                static_cast<double>(housesWanted);
        }
 
        if (item < SquareType::InJail)
        {
            if (importance == ai::trade::StrategicPropertyImportance::GivesDirectMonopoly)
            {
                const auto owner = ai::firstOwnerInMonopoly(state, item);
                if (currentBidder == owner)
                {
                    if (ai::playerOwnsMonopoly(state, player, false))
                    {
                        bid = ai::trade::onlyPlayerHasMonopoly(state, player)
                            ? (static_cast<double>(liquid) +
                               static_cast<double>(liquidSellingHouses) *
                                   config.monopolySuicideFactor) / 2.0
                            : static_cast<double>(excessCash);
                    }
                    else
                    {
                        const double remaining = static_cast<double>(
                            ai::propertiesLeftToBuy(state));
                        bid = static_cast<double>(excessCash) *
                            config.monopolySuicideFactor;
                        bid *= 0.5 + (0.5 - remaining / 22.0 / 2.0);
                        if (ai::trade::hasMonopolyTrade(state, player, owner))
                            bid = static_cast<double>(excessCash) *
                                config.monopolySuicideFactor * 0.5;
                        if (static_cast<double>(tradeBid) > bid)
                            bid = static_cast<double>(tradeBid);
                    }
                }
                else if (owner == player)
                    bid = static_cast<double>(cashAfterHousing);
                else
                    bid = static_cast<double>(tradeBid);
            }
            else
                bid = static_cast<double>(tradeBid);
        }
 
        if (bid > static_cast<double>(excessCash))
            bid = static_cast<double>(excessCash);
 
        if (item < SquareType::InJail && bid < static_cast<double>(mortgageCost))
        {
            const auto floorBid = mortgageCost + static_cast<std::int64_t>(bid) / 2;
            bid = liquid >= floorBid
                ? static_cast<double>(floorBid)
                : static_cast<double>(liquid);
        }
 
        if (item < SquareType::InJail && bid < static_cast<double>(purchaseCost) &&
            ai::trade::onlyPlayerHasMonopoly(state, player) &&
            !ai::ownsPropertyFromMonopoly(state, player, item) &&
            !ai::isCashCow(item) && excessCash >= purchaseCost)
        {
            bid = static_cast<double>(purchaseCost);
        }
 
        const std::int64_t maximumBid = static_cast<std::int64_t>(bid);
        const std::int64_t change = useTenDollarIncrement ? 10 : 5;
        if (maximumBid <= currentBid || currentBid + change > maximumBid)
            return 0;
        return currentBid + change;
    }
 
    void evaluateTradePlayerList(
        const rules::GameState& state,
        std::span<const rules::PlayerNumber> players,
        rules::PlayerNumber strategyPlayer,
        const ai::trade::TradeProposalList& proposals,
        bool givingMonopolyForCash,
        const TradeEvaluationConfig& config,
        std::span<double> evaluations) noexcept
    {
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            strategyPlayer >= state.numberOfPlayers || evaluations.size() < players.size())
            return;
 
        auto before = state;
        auto after = state;
        ai::trade::applyTradeToState(after, proposals);
        mortgageNegativeCashPlayers(after);
        if (config.purchasingPlayer < state.numberOfPlayers &&
            config.purchasingProperty < rules::board::SquareType::InJail)
        {
            const auto index = static_cast<std::size_t>(config.purchasingProperty);
            before.squares[index].owner = config.purchasingPlayer;
            after.squares[index].owner = config.purchasingPlayer;
        }
        std::array<double, rules::MaxPlayers> chancesBefore{};
        std::array<double, rules::MaxPlayers> chancesAfter{};
        (void)evaluateWinningChances(
            before, rules::NobodyPlayer, config.winningChance,
            std::span<double>(chancesBefore.data(), state.numberOfPlayers));
        (void)evaluateWinningChances(
            after, rules::NobodyPlayer, config.winningChance,
            std::span<double>(chancesAfter.data(), state.numberOfPlayers));
 
        for (std::size_t index = 0; index < players.size(); ++index)
        {
            const auto player = players[index];
            if (player >= state.numberOfPlayers)
            {
                evaluations[index] = -50.0;
                continue;
            }
            if ((chancesBefore[player] - chancesAfter[player]) > config.chancesThreshold)
            {
                evaluations[index] = -50.0;
                continue;
            }
 
            auto worthBefore = totalWorthWithFactors(before, player, config.worthFactors);
            auto worthAfter = totalWorthWithFactors(after, player, config.worthFactors);
            const auto debt = config.winningChance.moneyOwed[player];
            if (ai::liquidAssets(after, player, true, true, debt) <= 0)
            {
                evaluations[index] = -50.0;
                continue;
            }
            for (std::size_t deck = 0;
                 deck < static_cast<std::size_t>(rules::DeckType::Count); ++deck)
            {
                if (before.cards[deck].jailOwner == player)
                    worthBefore += config.jailCardValue;
                if (after.cards[deck].jailOwner == player)
                    worthAfter += config.jailCardValue;
            }
 
            const double propertyImportance = ai::trade::calculateTradePropertyImportance(
                before, after, player, strategyPlayer, proposals,
                givingMonopolyForCash, config.propertyImportance,
                config.winningChance.moneyOwed);
            evaluations[index] =
                (chancesAfter[player] - chancesBefore[player]) * config.chancesFactor +
                static_cast<double>(worthAfter - worthBefore) * config.cashFactor +
                propertyImportance * config.tradeImportanceFactor;
        }
    }
 
    bool makeTradeFair(
        const rules::GameState& state,
        rules::PlayerNumber player,
        std::span<const rules::PlayerNumber> partners,
        std::int64_t giveMost,
        bool givingMonopoly,
        ai::trade::TradeProposalList& proposals,
        const FairTradeConfig& config,
        std::span<const ai::trade::FutureImmunityRecord> immunities) noexcept
    {
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || partners.empty() ||
            partners.size() >= rules::MaxPlayers)
            return false;
 
        std::array<rules::PlayerNumber, rules::MaxPlayers> participants{};
        for (std::size_t index = 0; index < partners.size(); ++index)
        {
            if (partners[index] >= state.numberOfPlayers || partners[index] == player)
                return false;
            participants[index] = partners[index];
        }
        participants[partners.size()] = player;
        const auto participantCount = partners.size() + 1;
        std::array<std::int64_t, rules::MaxPlayers> cashGiven{};
        auto change = giveMost / 2;
        if (partners.size() == 1)
        {
            proposals[player].cashReceived = 0;
            proposals[player].cashGiven = 0;
            proposals[partners[0]].cashReceived = 0;
            proposals[partners[0]].cashGiven = 0;
        }
 
        const double minEvaluation = givingMonopoly
            ? config.minGiveMonopolyEvaluation
            : config.minEvaluationThreshold;
        bool doneChangingCash{};
        std::array<double, rules::MaxPlayers> evaluations{};
        while (!doneChangingCash)
        {
            evaluateTradePlayerList(
                state,
                std::span<const rules::PlayerNumber>(participants.data(), participantCount),
                player, proposals, givingMonopoly, config.evaluation,
                std::span<double>(evaluations.data(), participantCount));
 
            auto bestEvaluation = evaluations[0];
            auto worstEvaluation = evaluations[0];
            auto bestPlayer = partners[0];
            auto worstPlayer = partners[0];
            for (std::size_t index = 0; index < partners.size(); ++index)
            {
                const auto current = partners[index];
                if (evaluations[index] > bestEvaluation)
                {
                    bestEvaluation = evaluations[index];
                    bestPlayer = current;
                }
                if (evaluations[index] < worstEvaluation)
                {
                    worstEvaluation = evaluations[index];
                    worstPlayer = current;
                }
            }
 
            if (evaluations[partners.size()] < minEvaluation ||
                worstEvaluation >= evaluations[partners.size()])
            {
                if (change <= 2)
                {
                    change = 5;
                    doneChangingCash = true;
                }
                proposals[player].cashReceived += change;
                proposals[bestPlayer].cashGiven += change;
                cashGiven[bestPlayer] -= change;
            }
            else
            {
                if (change <= 2)
                {
                    doneChangingCash = true;
                    continue;
                }
                proposals[worstPlayer].cashReceived += change;
                proposals[player].cashGiven += change;
                cashGiven[worstPlayer] += change;
            }
            change /= 2;
        }
 
        for (const auto current : partners)
        {
            const double multiplier = ai::trade::cashMultiplier(
                config.playerAttitude[current], config.cashMultipliers);
            if (multiplier <= 0.0)
                return false;
            const double factor = 1.0 / multiplier;
            std::int64_t adjustment{};
            if (cashGiven[current] > 0)
                adjustment = static_cast<std::int64_t>(
                    static_cast<double>(cashGiven[current]) -
                    static_cast<double>(cashGiven[current]) * factor);
            else
                adjustment = static_cast<std::int64_t>(
                    static_cast<double>(cashGiven[current]) -
                    static_cast<double>(cashGiven[current]) / factor);
            proposals[current].cashReceived -= adjustment;
            proposals[player].cashGiven -= adjustment;
        }
        for (std::size_t index = 0; index < participantCount; ++index)
        {
            const auto current = participants[index];
            proposals[current].cashGiven -= proposals[current].cashReceived;
            proposals[current].cashReceived = 0;
            if (proposals[current].cashGiven < 0)
            {
                proposals[current].cashReceived = -proposals[current].cashGiven;
                proposals[current].cashGiven = 0;
            }
 
            auto canPay = -ai::trade::transferTax(
                state, proposals[current].propertiesReceived);
            auto properties = ai::propertiesOwnedByPlayer(state, current);
            properties &= ~proposals[current].propertiesGiven;
            canPay += ai::liquidAssetsForProperties(state, properties, false, false);
            canPay += state.players[current].cash;
            if (config.localAIPlayer[current])
                canPay -= config.evaluation.winningChance.moneyOwed[current];
 
            if (canPay < proposals[current].cashGiven)
            {
                if (!givingMonopoly || canPay < -cashGiven[current])
                    return false;
                change = (canPay - cashGiven[current]) / 2;
                change -= proposals[current].cashGiven;
                proposals[current].cashGiven += change;
                proposals[player].cashReceived += change;
                break;
            }
        }
        return ai::trade::tradeIsProper(state, proposals, immunities);
    }
 
    bool buildMonopolyTrade(
        const rules::GameState& state,
        rules::PlayerNumber player,
        rules::board::SquareGroup group,
        std::span<const rules::PlayerNumber> partners,
        const ai::trade::PropertySets& properties,
        ai::trade::TradeProposalList& proposals,
        const MonopolyProposalConfig& config) noexcept
    {
        const auto groupIndex = static_cast<std::size_t>(group);
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || groupIndex >= ai::ExpensiveMonopolySquares.size() ||
            partners.empty() || partners.size() >= rules::MaxPlayers)
            return false;
        auto combined = properties[player];
        for (const auto partner : partners)
        {
            if (partner >= state.numberOfPlayers || partner == player)
                return false;
            combined |= properties[partner];
        }
        auto next = proposals;
        const auto lots = ai::monopolyLots(ai::ExpensiveMonopolySquares[groupIndex]);
        for (std::size_t index = 0; index < lots.count; ++index)
        {
            const auto square = lots.squares[index];
            const auto owner = state.squares[static_cast<std::size_t>(square)].owner;
            if (owner == player)
                continue;
            if (owner >= state.numberOfPlayers)
                return false;
            const auto bit = rules::board::propertyBit(square);
            next[player].propertiesReceived |= bit;
            next[owner].propertiesGiven |= bit;
        }
        combined &= ~next[player].propertiesReceived;
        auto after = state;
        for (const auto partner : partners)
        {
            // Preserve retail's successive updates of the same simulation.
            ai::trade::applyTradeToState(after, next);
            (void)ai::trade::addTypeProperty(
                state, after, partner, player, combined,
                ai::trade::TradeImportanceItem::Monopoly, next, properties, false,
                config.whatToTrade, config.fairTrade.playerAttitude[partner],
                config.fairTrade.evaluation.winningChance.moneyOwed[partner]);
        }
        if (!makeTradeFair(state, player, partners, 2500, false, next, config.fairTrade))
            return false;
        proposals = next;
        return true;
    }
 
    bool buildMonopolyForCash(
        const rules::GameState& state,
        rules::PlayerNumber player,
        rules::PlayerNumber firstPartner,
        const ai::trade::PropertySets& properties,
        ai::trade::TradeProposalList& proposals,
        const MonopolyProposalConfig& config) noexcept
    {
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || firstPartner >= state.numberOfPlayers)
            return false;
        auto available = properties[player];
        const auto owned = ai::monopoliesOwned(state, player, false);
        for (std::size_t index = 0; index < owned.count; ++index)
            available ^= ai::monopolySet(owned.representatives[index]);
 
        for (std::size_t offset = 0; offset < state.numberOfPlayers; ++offset)
        {
            const auto partner = static_cast<rules::PlayerNumber>(
                (firstPartner + offset) % state.numberOfPlayers);
            if (partner == player ||
                state.players[partner].currentSquare ==
                    static_cast<std::uint8_t>(rules::board::SquareType::OffBoard) ||
                ai::playerOwnsMonopoly(state, partner, false))
                continue;
            ai::trade::TradeProposalList next{};
            auto combined = available | properties[partner];
            if (!ai::trade::addTypeProperty(
                    state, state, partner, player, combined,
                    ai::trade::TradeImportanceItem::Monopoly, next, properties, false,
                    config.whatToTrade, config.fairTrade.playerAttitude[partner],
                    config.fairTrade.evaluation.winningChance.moneyOwed[partner]))
                continue;
            const std::array<rules::PlayerNumber, 1> partners{partner};
            if (makeTradeFair(state, player, partners, 16000, true, next, config.fairTrade) &&
                ai::trade::tradeIsProper(state, next))
            {
                proposals = next;
                return true;
            }
        }
        return false;
    }
 
    bool buildSemiImportantTrade(
        const rules::GameState& state,
        rules::PlayerNumber player,
        std::span<const double> playerAttitudes,
        const ai::trade::PropertySets& properties,
        const SemiImportantTradeInputs& inputs,
        ai::trade::TradeProposalList& proposals,
        const MonopolyProposalConfig& config) noexcept
    {
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || playerAttitudes.size() < state.numberOfPlayers)
            return false;
        for (const auto group : inputs.wantedGroups)
            if (static_cast<std::size_t>(group) >= ai::ExpensiveMonopolySquares.size())
                return false;
        if (!inputs.deriveOfferedGroups)
        {
            for (const auto group : inputs.offeredGroups)
                if (static_cast<std::size_t>(group) >= ai::ExpensiveMonopolySquares.size())
                    return false;
        }
 
        std::array<rules::PlayerNumber, rules::MaxPlayers> candidates{};
        std::size_t candidateCount{};
        double totalWeight{};
        for (rules::PlayerNumber candidate = 0; candidate < state.numberOfPlayers; ++candidate)
        {
            if (candidate == player || candidate == inputs.excludedPlayer ||
                (inputs.requiredTarget != rules::NobodyPlayer &&
                 candidate != inputs.requiredTarget) ||
                state.players[candidate].currentSquare ==
                    static_cast<std::uint8_t>(rules::board::SquareType::OffBoard) ||
                playerAttitudes[candidate] < -1.0)
                continue;
            candidates[candidateCount++] = candidate;
            totalWeight += (playerAttitudes[candidate] + 1.0) / 2.0;
        }
        if (candidateCount == 0 || totalWeight <= 0.0)
            return false;
 
        double choice = inputs.partnerRoll;
        std::size_t start{};
        for (; start < candidateCount; ++start)
        {
            choice -= (playerAttitudes[candidates[start]] + 1.0) / 2.0 / totalWeight;
            if (choice <= 0.0)
                break;
        }
        if (start >= candidateCount)
            start = candidateCount - 1;
 
        const int wantedLimit = static_cast<int>(inputs.wantedPropertyRoll % 3u) + 1;
        const int offeredLimit = wantedLimit + static_cast<int>(inputs.offeredPropertyRoll % 2u) - 1;
        for (std::size_t offset = 0; offset < candidateCount; ++offset)
        {
            const auto target = candidates[(start + offset) % candidateCount];
            ai::trade::TradeProposalList next{};
            int taken{};
            int given{};
 
            if ((inputs.importance & ai::trade::TradeForCash) == 0)
            {
                auto available = properties[target];
                for (std::size_t index = 0; index < 3 && taken < wantedLimit; ++index)
                {
                    const auto representative = ai::ExpensiveMonopolySquares[
                        static_cast<std::size_t>(inputs.wantedGroups[index])];
                    const auto groupSet = ai::monopolySet(representative);
                    auto wanted = available & groupSet;
                    bool blockedOwner{};
                    const auto lots = ai::monopolyLots(representative);
                    for (std::size_t lot = 0; lot < lots.count; ++lot)
                    {
                        const auto owner = state.squares[
                            static_cast<std::size_t>(lots.squares[lot])].owner;
                        if (owner == player || owner >= state.numberOfPlayers)
                            continue;
                        if (playerAttitudes[owner] < -1.0 ||
                            ai::playerOwnsMonopoly(state, owner, true))
                        {
                            blockedOwner = true;
                            break;
                        }
                    }
                    if (wanted == 0 || ai::testForMonopoly(wanted, representative) ||
                        ai::testForMonopoly(properties[player] | wanted, representative) ||
                        blockedOwner)
                        continue;
                    next[target].propertiesGiven |= wanted;
                    next[player].propertiesReceived |= wanted;
                    available &= ~wanted;
                    taken += ai::propertyCount(wanted);
                }
                // Retail's loop breaks after the first railroad/utility square, even
                // when the chosen partner does not own it.
                if (taken == 0)
                {
                    for (std::size_t square = 0;
                         square < static_cast<std::size_t>(rules::board::SquareType::InJail); ++square)
                    {
                        const auto type = static_cast<rules::board::SquareType>(square);
                        const auto group = rules::board::definition(type).group;
                        if (group != rules::board::SquareGroup::Utility &&
                            group != rules::board::SquareGroup::Railroad)
                            continue;
                        const auto bit = rules::board::propertyBit(type);
                        if ((available & bit) != 0)
                        {
                            next[target].propertiesGiven |= bit;
                            next[player].propertiesReceived |= bit;
                            ++taken;
                        }
                        break;
                    }
                    if (taken == 0)
                        continue;
                }
            }
 
            auto available = properties[player];
            auto offeredGroups = inputs.offeredGroups;
            if (inputs.deriveOfferedGroups)
            {
                offeredGroups = ai::trade::orderMonopolyImportance(
                    ai::liquidAssets(
                        state, target, false, false,
                        config.fairTrade.evaluation.winningChance.moneyOwed[target]),
                    ai::trade::MonopolySortOrder::Ascending);
            }
            const std::size_t groupLimit = (inputs.importance & ai::trade::TradeForCash) != 0 ? 8 : 4;
            for (std::size_t index = 0; index < groupLimit; ++index)
            {
                const auto representative = ai::ExpensiveMonopolySquares[
                    static_cast<std::size_t>(offeredGroups[index])];
                const auto groupSet = ai::monopolySet(representative);
                auto offered = available & groupSet;
                if (offered == 0 || ai::testForMonopoly(offered, representative) ||
                    ((inputs.importance & ai::trade::TradeDesperate) == 0 &&
                     ai::testForMonopoly(properties[target] | offered, representative)))
                    continue;
                next[target].propertiesReceived |= offered;
                next[player].propertiesGiven |= offered;
                available &= ~offered;
                given += ai::propertyCount(offered);
                if ((inputs.importance & ai::trade::TradeForCash) != 0)
                    break;
                if (given > offeredLimit)
                {
                    next[target].propertiesReceived ^= offered;
                    next[player].propertiesGiven ^= offered;
                    given -= ai::propertyCount(offered);
                    break;
                }
            }
            if (given == 0 && taken == 0)
                continue;
            const std::array<rules::PlayerNumber, 1> partners{target};
            auto fair = config.fairTrade;
            auto attitude = playerAttitudes[target];
            if (attitude < inputs.minimumNonmonopolyTradeAttitude &&
                (inputs.importance & (ai::trade::TradeDesperate |
                                      ai::trade::TradeSomewhatImportant)) == 0)
                attitude = inputs.minimumNonmonopolyTradeAttitude;
            int attitudeIndex = attitude <= -1.0 ? 0 : static_cast<int>((attitude + 1.0) * 10.0);
            if ((inputs.importance & ai::trade::TradeSomewhatImportant) != 0)
                attitudeIndex -= 2;
            if ((inputs.importance & ai::trade::TradeDesperate) != 0)
                attitudeIndex -= 5;
            attitudeIndex = std::clamp(attitudeIndex, 0,
                static_cast<int>(ai::trade::WhatToTradeEntries) - 1);
            fair.playerAttitude[target] = static_cast<double>(attitudeIndex) / 10.0 - 1.0;
            if (!makeTradeFair(state, player, partners, 2500, false, next, fair))
                continue;
            proposals = next;
            return true;
        }
        return false;
    }
 
    ProactiveTradeResult buildProactiveTrade(
        const rules::GameState& state,
        rules::PlayerNumber player,
        std::span<const double> playerAttitudes,
        const ai::trade::PropertySets& properties,
        const ProactiveTradeInputs& inputs,
        const MonopolyProposalConfig& config) noexcept
    {
        ProactiveTradeResult result{};
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || playerAttitudes.size() < state.numberOfPlayers)
            return result;
        for (const auto group : inputs.monopolyGroups)
            if (static_cast<std::size_t>(group) >= ai::ExpensiveMonopolySquares.size())
                return result;
 
        std::array<rules::PlayerNumber, rules::MaxPlayers> candidates{};
        std::size_t candidateCount{};
        const bool desperate = (inputs.importance & ai::trade::TradeDesperate) != 0;
        for (rules::PlayerNumber candidate = 0; candidate < state.numberOfPlayers; ++candidate)
        {
            if (candidate == player || candidate == inputs.excludedPlayer ||
                state.players[candidate].currentSquare ==
                    static_cast<std::uint8_t>(rules::board::SquareType::OffBoard))
                continue;
            if (!desperate &&
                (ai::playerOwnsMonopoly(state, candidate, false) ||
                 playerAttitudes[candidate] < -1.0))
                continue;
            candidates[candidateCount++] = candidate;
        }
        // Retail exits before the give-away path when no trade partner is eligible.
        if (candidateCount == 0)
            return result;
 
        if (inputs.shouldGiveAwayMonopoly)
        {
            const auto partner = ai::trade::findNonmonopolyPlayer(
                state, player, config.fairTrade.evaluation.winningChance.moneyOwed);
            if (partner != rules::NobodyPlayer)
            {
                ai::trade::TradeProposalList proposal{};
                if (buildMonopolyForCash(
                        state, player, partner, properties, proposal, config))
                {
                    result.kind = ProactiveTradeKind::GiveMonopolyForCash;
                    result.proposal = proposal;
                }
                // Retail returns immediately if a cash-sale target exists but the
                // monopoly-for-cash builder cannot produce a proposal.
                return result;
            }
        }
 
        std::size_t monopolyLimit{};
        switch (ai::trade::shouldTradeForMonopoly(state, player))
        {
        case ai::trade::MonopolyTradeDecision::Maybe:
            monopolyLimit = 2;
            break;
        case ai::trade::MonopolyTradeDecision::Required:
            monopolyLimit = 7; // SG_PARK_PLACE: all but the worst-ranked group.
            break;
        case ai::trade::MonopolyTradeDecision::Avoid:
            monopolyLimit = 0;
            break;
        }
        if ((inputs.importance & ai::trade::TradeForCash) != 0)
            monopolyLimit = 0;
 
        if ((inputs.importance & ai::trade::TradeGiveMonopoly) == 0)
        {
            for (std::size_t rank = 0; rank < monopolyLimit; ++rank)
            {
                const auto group = inputs.monopolyGroups[rank];
                const auto representative = ai::ExpensiveMonopolySquares[
                    static_cast<std::size_t>(group)];
                const auto smallest = ai::trade::findSmallestMonopolyTrade(
                    player, ai::monopolySet(representative),
                    std::span<const rules::PlayerNumber>(candidates.data(), candidateCount),
                    properties);
                // The retail build deliberately restricts this path to exactly
                // two partners despite the recursive helper supporting larger trades.
                if (smallest.count != 2)
                    continue;
 
                ai::trade::TradeProposalList proposal{};
                if (!buildMonopolyTrade(
                        state, player, group,
                        std::span<const rules::PlayerNumber>(
                            smallest.players.data(), smallest.count),
                        properties, proposal, config))
                    continue;
 
                if (inputs.importance == 0 ||
                    inputs.importance == ai::trade::TradeSomewhatImportant)
                {
                    if (evaluateTrade(
                            state, player, player, proposal,
                            config.fairTrade.evaluation) <
                        config.fairTrade.minEvaluationThreshold)
                        continue;
                }
                if (!ai::trade::tradeIsProper(state, proposal))
                    continue;
 
                result.kind = ProactiveTradeKind::AcquireMonopoly;
                result.proposal = proposal;
                return result;
            }
        }
 
        if (!inputs.semiImportant)
        {
            result.kind = ProactiveTradeKind::NeedsSemiImportant;
            return result;
        }
        auto semiInputs = *inputs.semiImportant;
        semiInputs.importance = inputs.importance;
        semiInputs.excludedPlayer = inputs.excludedPlayer;
        ai::trade::TradeProposalList proposal{};
        if (buildSemiImportantTrade(
                state, player, playerAttitudes, properties, semiInputs,
                proposal, config) &&
            ai::trade::tradeIsProper(state, proposal))
        {
            result.kind = ProactiveTradeKind::SemiImportant;
            result.proposal = proposal;
        }
        return result;
    }
 
    CounterProposalPreflightResult counterProposalPreflight(
        const rules::GameState& state,
        rules::PlayerNumber player,
        const ai::trade::TradeProposalList& currentTrade,
        const CounterProposalPreflightInputs& inputs,
        const CounterProposalPreflightConfig& config,
        CounterProposalSession& session,
        std::span<const ai::trade::FutureImmunityRecord> immunities) noexcept
    {
        CounterProposalPreflightResult result{};
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || inputs.proposedPlayer >= state.numberOfPlayers)
            return result;
 
        if (inputs.pendingActions != 0 || !state.tradeInProgress ||
            inputs.playerSendingTrade || inputs.auctionOn)
        {
            result.status = CounterProposalStatus::InvalidTime;
            return result;
        }
        if (!ai::trade::playerInvolvedInTrade(currentTrade[player]))
        {
            result.status = CounterProposalStatus::NotInvolved;
            return result;
        }
        if (ai::trade::playerHasFutureOrImmunity(player, immunities))
        {
            result.status = CounterProposalStatus::FutureOrImmunity;
            return result;
        }
        if (session.timesCounteredTrade >= config.tradeCounterLimit)
        {
            result.status = CounterProposalStatus::TooManyCounters;
            return result;
        }
        if (session.timesCounteredTrade == 0 &&
            ai::trade::propertiesAlreadyTraded(
                session.propertyMemory, inputs.proposedPlayer,
                currentTrade[player], config.numberTimesAllowPropertyTrade) != 0)
        {
            result.status = CounterProposalStatus::RepeatedProperties;
            return result;
        }
        if (session.timesCounteredTrade == 0)
            ai::trade::rememberTradedProperties(
                session.propertyMemory, inputs.proposedPlayer, currentTrade[player]);
 
        if (inputs.counterRoll > config.tradeCounterProbability &&
            inputs.tradeAccept && session.timesCounteredTrade == 0)
        {
            result.status = CounterProposalStatus::ProbabilitySkipped;
            return result;
        }
        result.evaluation = evaluateTrade(
            state, player, player, currentTrade, config.evaluation);
        if (session.timesCounteredTrade != 0 &&
            result.evaluation <= session.lastTradeEvaluation)
        {
            result.status = CounterProposalStatus::NotSeriousTrader;
            return result;
        }
        session.lastTradeEvaluation = result.evaluation;
 
        auto preparedState = state;
        if (config.evaluation.purchasingPlayer < state.numberOfPlayers &&
            config.evaluation.purchasingProperty < rules::board::SquareType::InJail)
            preparedState.squares[static_cast<std::size_t>(
                config.evaluation.purchasingProperty)].owner = config.evaluation.purchasingPlayer;
        result.preparation = ai::trade::createPlayerPropertyAttitudeList(
            preparedState, player, currentTrade, config.playerAttitude);
        if (result.preparation.tradePlayerCount < 1)
        {
            result.status = CounterProposalStatus::NoTradePartners;
            return result;
        }
        if (result.preparation.tradePlayerCount == 1)
        {
            const auto partner = result.preparation.tradePlayers[0];
            if (config.playerAttitude[partner] <= -1.0)
            {
                result.status = CounterProposalStatus::AnnoyedWithTrader;
                return result;
            }
        }
        result.averageAttitude = result.preparation.totalAttitude /
            static_cast<double>(result.preparation.tradePlayerCount);
        if (result.averageAttitude < -1.0)
            result.averageAttitude = -1.0;
        result.status = CounterProposalStatus::Ready;
        return result;
    }
 
    CounterProposalBalanceResult counterProposalBalance(
        const rules::GameState& state,
        rules::PlayerNumber player,
        const CounterProposalPreflightResult& preflight,
        ai::trade::TradeProposalList& proposals,
        const CounterProposalBalanceConfig& config,
        std::span<const ai::trade::FutureImmunityRecord> immunities) noexcept
    {
        CounterProposalBalanceResult result{};
        if (state.numberOfPlayers == 0 || state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers ||
            preflight.status != CounterProposalStatus::Ready ||
            preflight.preparation.tradePlayerCount == 0 ||
            preflight.preparation.tradePlayerCount >= rules::MaxPlayers ||
            config.maxIterations == 0)
            return result;
 
        const auto partnerCount = preflight.preparation.tradePlayerCount;
        for (std::size_t index = 0; index < partnerCount; ++index)
        {
            const auto partner = preflight.preparation.tradePlayers[index];
            if (partner >= state.numberOfPlayers || partner == player)
                return result;
        }
 
        auto oldState = state;
        auto newState = state;
        ai::trade::applyTradeToState(newState, proposals);
        const auto& evaluationConfig = config.fairTrade.evaluation;
        if (evaluationConfig.purchasingPlayer < state.numberOfPlayers &&
            evaluationConfig.purchasingProperty < rules::board::SquareType::InJail)
        {
            const auto square = static_cast<std::size_t>(evaluationConfig.purchasingProperty);
            oldState.squares[square].owner = evaluationConfig.purchasingPlayer;
            newState.squares[square].owner = evaluationConfig.purchasingPlayer;
        }
        auto combinedProperties = rules::board::PropertySet{};
        auto combinedTraded = rules::board::PropertySet{};
        for (std::size_t index = 0; index < partnerCount; ++index)
        {
            const auto partner = preflight.preparation.tradePlayers[index];
            combinedProperties |= preflight.preparation.playerProperties[partner];
            combinedTraded |= proposals[partner].propertiesReceived |
                proposals[partner].propertiesGiven;
        }
        combinedProperties |= preflight.preparation.playerProperties[player];
        combinedProperties &= ~combinedTraded;
 
        result.propertyImportance = 0.0;
        do
        {
            result.evaluation = evaluateTrade(
                oldState, player, player, proposals, evaluationConfig);
            if (result.evaluation >= config.minEvaluationThreshold)
                break;
 
            // Retail repeatedly applies the full trade to new_state here. This
            // intentionally reapplies cash deltas while property ownership stays idempotent.
            ai::trade::applyTradeToState(newState, proposals);
            result.propertyImportance = ai::trade::calculateTradePropertyImportance(
                oldState, newState, player, player, proposals, false,
                evaluationConfig.propertyImportance,
                evaluationConfig.winningChance.moneyOwed);
            const auto importance = ai::trade::createItemImportanceList(
                oldState, player, player, evaluationConfig.propertyImportance,
                0.0, config.fairTrade.cashMultipliers);
            bool added{};
            for (const auto& record : importance)
            {
                if (-result.propertyImportance < record.importance)
                    continue;
                if (ai::trade::addTypeProperty(
                        state, newState, player, player, combinedProperties,
                        record.item, proposals, preflight.preparation.playerProperties,
                        false, config.whatToTrade, 0.0,
                        evaluationConfig.winningChance.moneyOwed[player]))
                {
                    added = true;
                    break;
                }
            }
 
            ++result.iterations;
            if (!added || result.iterations >= config.maxIterations)
                break;
        }
        while (result.propertyImportance < 0.0);
 
        if (result.propertyImportance < config.lowestPropertyImportanceForCounter &&
            result.evaluation < config.minEvaluationThreshold)
        {
            result.status = CounterProposalBalanceStatus::TooPoor;
            return result;
        }
 
        double gaveMonopolyValue{};
        if (partnerCount == 1)
        {
            const auto target = preflight.preparation.tradePlayers[0];
            const auto importance = ai::trade::createItemImportanceList(
                oldState, target, player, evaluationConfig.propertyImportance,
                config.fairTrade.playerAttitude[target],
                config.fairTrade.cashMultipliers);
            for (const auto& record : importance)
            {
                ai::trade::applyTradeToState(newState, proposals);
                result.propertyImportance = ai::trade::calculateTradePropertyImportance(
                    oldState, newState, target, player, proposals, false,
                    evaluationConfig.propertyImportance,
                    evaluationConfig.winningChance.moneyOwed);
                result.propertyImportance += gaveMonopolyValue;
                if (-result.propertyImportance < record.importance)
                    continue;
 
                if (record.item == ai::trade::TradeImportanceItem::Monopoly)
                {
                    proposals[player].propertiesGiven = 0;
                    proposals[target].propertiesReceived = 0;
                    newState = state;
                    ai::trade::applyTradeToState(newState, proposals);
                    result.propertyImportance = ai::trade::calculateTradePropertyImportance(
                        oldState, newState, target, player, proposals, false,
                        evaluationConfig.propertyImportance,
                        evaluationConfig.winningChance.moneyOwed);
                }
 
                const bool added = ai::trade::addTypeProperty(
                    state, newState, target, player, combinedProperties,
                    record.item, proposals, preflight.preparation.playerProperties,
                    true, config.whatToTrade, config.fairTrade.playerAttitude[target],
                    evaluationConfig.winningChance.moneyOwed[target]);
                if (!added && record.item == ai::trade::TradeImportanceItem::Monopoly)
                {
                    result.status = CounterProposalBalanceStatus::CouldNotReturnMonopoly;
                    return result;
                }
                if (added && record.item == ai::trade::TradeImportanceItem::Monopoly)
                {
                    ai::trade::applyTradeToState(newState, proposals);
                    gaveMonopolyValue = ai::trade::calculateTradePropertyImportance(
                        oldState, newState, target, player, proposals, false,
                        evaluationConfig.propertyImportance,
                        evaluationConfig.winningChance.moneyOwed);
                    gaveMonopolyValue -= result.propertyImportance;
                    gaveMonopolyValue = record.importance - gaveMonopolyValue;
                    if (gaveMonopolyValue < 0.0)
                        gaveMonopolyValue = 0.0;
                }
            }
        }
 
        ai::trade::makeTradeProper(state, proposals, immunities);
        const auto partners = std::span<const rules::PlayerNumber>(
            preflight.preparation.tradePlayers.data(), partnerCount);
        if (!makeTradeFair(oldState, player, partners, config.maxGiveInTrade,
                false, proposals, config.fairTrade, immunities))
        {
            result.status = CounterProposalBalanceStatus::Unaffordable;
            return result;
        }
        if (!ai::trade::tradeIsProper(state, proposals, immunities))
        {
            result.status = CounterProposalBalanceStatus::Improper;
            return result;
        }
        result.status = CounterProposalBalanceStatus::Ready;
        return result;
    }
 
    bool shouldGiveAwayMonopoly(
        const rules::GameState& state,
        rules::PlayerNumber player,
        CashStrategy strategy,
        std::int64_t minCashOnHand,
        int maxHousesPerSquareForGiveAway,
        std::span<const std::int64_t> moneyOwed) noexcept
    {
        if (state.numberOfPlayers > rules::MaxPlayers ||
            player >= state.numberOfPlayers || strategy >= CashStrategy::Count)
            return false;
        if (!ai::playerOwnsMonopoly(state, player, false) ||
            ai::housingShortage(state, CriticalHousingLevel) ||
            trade::findNonmonopolyPlayer(state, player, moneyOwed) == rules::NobodyPlayer ||
            trade::onlyPlayerHasMonopoly(state, player))
            return false;
 
        auto simulated = state;
        const auto debt = player < moneyOwed.size() ? moneyOwed[player] : 0;
        while (hypotheticalUnmortgageMonopolyProperty(
            simulated, player, strategy, minCashOnHand, debt) !=
            rules::board::SquareType::Go)
        {
        }
        while (hypotheticalBuyHouse(simulated, player, debt))
        {
        }
 
        const auto monopolies = ai::monopoliesOwned(simulated, player, false);
        for (std::size_t index = 0; index < monopolies.count; ++index)
        {
            const auto representative = monopolies.representatives[index];
            const auto lots = ai::monopolyLots(representative);
            const auto houses = ai::housesOnMonopoly(simulated, representative);
            if (houses <= static_cast<std::int64_t>(lots.count) *
                    maxHousesPerSquareForGiveAway)
                return true;
        }
        return false;
    }
 
}