Use direct roll vector declarations

2026-07-29 13:52:08 +00:00 · 2026-06-23 12:50:28 -07:00
395 changed files with 2487 additions and 2667 deletions
@@ -37,7 +37,7 @@ int main(const int argc, char** argv) {

 void ModifyMap(HexMapProto& map) {
    const int terrainCount = map.terrain_size();
-    for (int i = 0; i < terrainCount; ++i) {
+    for (int i = 0; i < terrainCount; i++) {
        const auto existingTerrainType = map.terrain(i).type();
        const auto newTerrain =
                static_cast<net::eagle0::shardok::common::Terrain_Type>(existingTerrainType + 2);
@@ -37,7 +37,7 @@ auto CalculateMap(
            .name = mapName,
            .positionsRequiringCrossing = {}};

-    for (std::size_t i = 0; i < hexMap->attacker_starting_positions()->size(); ++i) {
+    for (std::size_t i = 0; i < hexMap->attacker_starting_positions()->size(); i++) {
        const auto* positionList = hexMap->attacker_starting_positions()->Get(i);
        const auto* positions = positionList->positions();
        if (positions->empty()) continue;
@@ -54,7 +54,7 @@ void runBattle(const std::vector<shardok::Unit>& units) {
    const auto p1UnitCount = randInt(1, static_cast<int>(maxP1UnitCount));
    std::vector<shardok::Unit> p1Units{};
    p1Units.reserve(p1UnitCount);
-    for (int i = 0; i < p1UnitCount; ++i) {
+    for (int i = 0; i < p1UnitCount; i++) {
        auto unit = units[i];
        unit.mutate_player_id(0);
        p1Units.push_back(std::move(unit));
@@ -64,7 +64,7 @@ void runBattle(const std::vector<shardok::Unit>& units) {
    const auto p2UnitCount = randInt(1, static_cast<int>(maxP2UnitCount));
    std::vector<shardok::Unit> p2Units{};
    p2Units.reserve(p2UnitCount);
-    for (int i = p1UnitCount; i < p1UnitCount + p2UnitCount; ++i) {
+    for (int i = p1UnitCount; i < p1UnitCount + p2UnitCount; i++) {
        auto unit = units[i];
        unit.mutate_player_id(1);
        p2Units.push_back(std::move(unit));
@@ -158,7 +158,7 @@ auto main(int /*argc*/, char** argv) -> int {

    std::array<std::thread, THREAD_COUNT> threads;

-    for (int i = 0; i < THREAD_COUNT; ++i) {
+    for (int i = 0; i < THREAD_COUNT; i++) {
        threads[i] = std::thread(runBattlesThread, randomUnits);
    }

@@ -27,7 +27,7 @@ struct TargetAndAttackLocations {
    Coords target;
    CoordsSet attackLocations;

-    [[nodiscard]] auto operator==(const TargetAndAttackLocations& rhs) const -> bool = default;
+    auto operator==(const TargetAndAttackLocations& rhs) const -> bool = default;
 };

 struct TargetPriorityList {
@@ -39,7 +39,7 @@ struct TargetPriorityList {
          priorityOrder(po) {}
 };

-[[nodiscard]] auto EffectiveDistance(
+auto EffectiveDistance(
        const Unit* unit,
        const HexMap* map,
        const AttackLocations& attackLocations,
@@ -47,7 +47,7 @@ struct TargetPriorityList {
        const BattalionTypeGetter& battalionTypeGetter,
        ActionPoints braveWaterCost) -> DIST_T;

-[[nodiscard]] auto EffectiveDistance(
+auto EffectiveDistance(
        const Unit* unit,
        const HexMap* map,
        const CoordsSet& locations,
@@ -55,14 +55,14 @@ struct TargetPriorityList {
        const BattalionTypeGetter& battalionTypeGetter,
        ActionPoints braveWaterCost) -> DIST_T;

-[[nodiscard]] auto EffectiveDistance(
+auto EffectiveDistance(
        const Unit* unit,
        const ActionPointDistances* notBravingApd,
        const ActionPointDistances* bravingApd,
        const CoordsSet& locations) -> DIST_T;

 // Chooses a list of targets in priority order for each unit.
-[[nodiscard]] auto GenerateTargetPriorities(
+auto GenerateTargetPriorities(
        const std::vector<const Unit*>& occupants,
        const HexMap* map,
        const CoordsSet& targets,
@@ -53,8 +53,8 @@ AttackLocationsCache::AttackLocationsCache(const HexMap *hexMap, const SettingsG

    auto emptySet = CoordsSet(columnCount, rowCount);

-    for (MapIndex r = 0; r < hexMap->row_count(); ++r) {
-        for (MapIndex c = 0; c < hexMap->column_count(); ++c) {
+    for (MapIndex r = 0; r < hexMap->row_count(); r++) {
+        for (MapIndex c = 0; c < hexMap->column_count(); c++) {
            auto location = Coords(r, c);
            const auto terrain = GetTerrain(hexMap, location);

@@ -21,12 +21,16 @@

 namespace shardok {

+// No need to forward declare internal functions - use the public interface instead
+
+// Helper constants and static variables
 static const std::vector<double> kAverageSequence = {0.5};
 static const auto kAverageGenerator = std::make_shared<SequenceRandomGenerator>(kAverageSequence);

 constexpr bool kMultithread = true;
 constexpr bool kLogging = false;

+// Helper function to determine if a command type is deterministic
 static auto IsDeterministic(const CommandType type) -> bool {
    switch (type) {
        case net::eagle0::shardok::common::MOVE_COMMAND:
@@ -59,6 +63,7 @@ static auto RandomnessSampleForRepeat(const int repeatIteration, const int maxRe
    return static_cast<double>(repeatIteration) / static_cast<double>(maxRepeatCount - 1);
 }

+// Helper function to sort commands by score
 static auto CommandSorter(
        const AICommandEvaluator::IndexAndScore& l,
        const AICommandEvaluator::IndexAndScore& r) -> bool {
@@ -78,7 +83,7 @@ AICommandEvaluator::AICommandEvaluator(
        BattalionTypeGetter battalionTypeGetter)
    : scorer_(scorer),
      apdCache_(apdCache),
-      battalionTypeGetter_(std::move(battalionTypeGetter)) {}
+      battalionTypeGetter_(std::move(battalionTypeGetter)) {}  // Move the function object

 auto AICommandEvaluator::PerformLookahead(
        const PlayerId pid,
@@ -331,7 +336,7 @@ auto AICommandEvaluator::FindBestCommand(

    std::vector<CommandEvaluation> commandEvaluations(commandCount);

-    for (uint32_t index = 0; index < commandCount; ++index) {
+    for (uint32_t index = 0; index < commandCount; index++) {
        const auto originalIndex = filteredIndices[index];
        const auto& guessedDescriptor = guessedDescriptors->at(originalIndex);
        const auto guessedCommandType = guessedDescriptor->GetCommandType();
@@ -418,7 +423,7 @@ auto AICommandEvaluator::FindBestCommand(
            ScoreValue sum = 0.0;
            const int sampleCount = std::max(1, maxRepeatCount);
            commandEvaluations[index].lookaheadFutures.reserve(sampleCount);
-            for (int repeatIteration = 0; repeatIteration < sampleCount; ++repeatIteration) {
+            for (int repeatIteration = 0; repeatIteration < sampleCount; repeatIteration++) {
                // In each iteration, use a double from [0, 1] as the random roll
                auto sequence =
                        std::vector{RandomnessSampleForRepeat(repeatIteration, sampleCount)};
@@ -582,7 +587,7 @@ auto AICommandEvaluator::EvaluateCommand(
    const int sampleCount = std::max(1, maxRepeatCount);
    lookaheadFutures.reserve(sampleCount);

-    for (int repeatIteration = 0; repeatIteration < sampleCount; ++repeatIteration) {
+    for (int repeatIteration = 0; repeatIteration < sampleCount; repeatIteration++) {
        auto sequence = std::vector{RandomnessSampleForRepeat(repeatIteration, sampleCount)};
        auto evaluation = EvaluateWithRandomness(
                pid,
@@ -78,7 +78,7 @@ public:
 private:
    const AIScoreCalculator& scorer_;
    const APDCache& apdCache_;
-    BattalionTypeGetter battalionTypeGetter_;
+    BattalionTypeGetter battalionTypeGetter_;  // Store by value

    struct ImmediateAndLookaheadScore {
        ScoreValue immediateScore{};
@@ -104,14 +104,17 @@ auto DefenderDistanceBuf(
                pointCostToDesiredTargetWithBraving);
    }

-    std::ranges::sort(pointCosts, [](const WithoutAndWith &left, const WithoutAndWith &right) {
-        return left.without == right.without ? left.with < right.with
-                                             : left.without < right.without;
-    });
+    std::sort(
+            begin(pointCosts),
+            end(pointCosts),
+            [](const WithoutAndWith &left, const WithoutAndWith &right) {
+                return left.without == right.without ? left.with < right.with
+                                                     : left.without < right.without;
+            });

    // experiment: add dummy values to the end with very high cost, so there's never an advantage
    // to leaving a defender unit alive in a castle.
-    for (size_t i = attackerUnits.size(); i < 20; ++i) { pointCosts.emplace_back(999, 999); }
+    for (size_t i = attackerUnits.size(); i < 20; i++) { pointCosts.emplace_back(999, 999); }

    double sum = 0.0;
    double decr = kPerUnitDebufDecay;
@@ -13,7 +13,7 @@

 namespace shardok {

-[[nodiscard]] auto DefenderDistanceBuf(
+auto DefenderDistanceBuf(
        const Coords &defenderLocation,
        const HexMap *hexMap,
        const MapId &mapId,
@@ -12,7 +12,7 @@

 namespace shardok {

-[[nodiscard]] inline auto CurrentAIExperimentId() -> int {
+inline auto CurrentAIExperimentId() -> int {
    const char* rawValue = std::getenv("SHARDOK_SCORING_EXPERIMENT_ID");
    if (rawValue == nullptr) { return 0; }

@@ -28,9 +28,7 @@ namespace shardok {
    return experimentId;
 }

-[[nodiscard]] inline auto IsAIExperiment(const int id) -> bool {
-    return CurrentAIExperimentId() == id;
-}
+inline auto IsAIExperiment(const int id) -> bool { return CurrentAIExperimentId() == id; }

 }  // namespace shardok

@@ -18,12 +18,12 @@ struct CoordsAndDistance {
    int distance;
 };

-[[nodiscard]] auto MinimumDistanceAndTarget(
+auto MinimumDistanceAndTarget(
        const ActionPointDistances *apd,
        const Coords &origin,
        const CoordsSet &destinations) -> CoordsAndDistance;

-[[nodiscard]] auto MinimumDistance(
+auto MinimumDistance(
        const ActionPointDistances *apd,
        const Coords &origin,
        const CoordsSet &destinations) -> int;
@@ -20,12 +20,12 @@ using GameState = net::eagle0::shardok::storage::fb::GameState;
 using PlayerInfo = net::eagle0::shardok::storage::fb::PlayerInfo;
 using Unit = net::eagle0::shardok::storage::fb::Unit;

-[[nodiscard]] auto HasAttachedHeroWithProfession(
+auto HasAttachedHeroWithProfession(
        const Unit *unit,
        net::eagle0::shardok::storage::fb::Profession profession) -> bool;

-[[nodiscard]] auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
-[[nodiscard]] auto PlayerInfoForPid(const GameStateW &, PlayerId pid) -> const PlayerInfo *;
+auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
+auto PlayerInfoForPid(const GameStateW &, PlayerId pid) -> const PlayerInfo *;

 }  // namespace shardok

@@ -26,13 +26,11 @@ struct AIStrategy {
 };

 extern AIStrategy FleeStrategy;
-[[nodiscard]] auto AttackUnitsStrategy(const vector<TargetPriorityList>& targetPriorities)
-        -> AIStrategy;
-[[nodiscard]] auto AttackCastlesStrategy(const vector<TargetPriorityList>& targetPriorities)
-        -> AIStrategy;
+auto AttackUnitsStrategy(const vector<TargetPriorityList>& targetPriorities) -> AIStrategy;
+auto AttackCastlesStrategy(const vector<TargetPriorityList>& targetPriorities) -> AIStrategy;
 extern AIStrategy HoldCastlesStrategy;
 extern AIStrategy ScatterStrategy;
-[[nodiscard]] auto CrossRiversStrategy(const CoordsSet& targetLocations) -> AIStrategy;
+auto CrossRiversStrategy(const CoordsSet& targetLocations) -> AIStrategy;

 }  // namespace shardok

@@ -30,7 +30,7 @@ public:
    AIEvaluationCounter(AIEvaluationCounter&&) = delete;
    auto operator=(AIEvaluationCounter&&) -> AIEvaluationCounter& = delete;

-    [[nodiscard]] static int GetCurrentCount();
+    static int GetCurrentCount();
 };

 // Configuration structure for iterative deepening time budget
@@ -44,7 +44,7 @@ struct AITimeBudget {
 // Time budget is calculated dynamically based on number of available commands:
 //   budget = msPerCommand × numCommands (clamped to 200-5000ms)
 // If isAllAiBattle is true, uses allAiBattleTimeBudgetMaximum instead of the normal maximum.
-[[nodiscard]] auto CalculateTimeBudget(
+auto CalculateTimeBudget(
        PlayerId playerId,
        const GameSettingsSPtr& settings,
        const GameStateW& state,
@@ -17,9 +17,9 @@ using net::eagle0::shardok::storage::fb::Unit;
 using ScoreValue = double;
 class AttackLocations;

-[[nodiscard]] auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue;
+auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue;

-[[nodiscard]] auto GetRangedAttackBonus(
+auto GetRangedAttackBonus(
        const Unit *unit,
        bool isAttacker,
        const HexMap *map,
@@ -32,7 +32,7 @@ class AttackLocations;
        double minVigorToCast,
        ActionPoints archeryActionPointCost = 0) -> double;

-[[nodiscard]] auto UnitValue(
+auto UnitValue(
        const Unit *unit,
        bool isAttacker,
        const std::vector<const Unit *> &attackerUnits,
@@ -18,7 +18,7 @@ auto UnitIdsRequiringWaterCrossing(
        const BattalionTypeGetter &battalionTypeGetter) -> vector<UnitId> {
    // Put out all the fires, except on bridges
    fb::HexMapW mapCopy = fb::CopyHexMap(gameState->hex_map());
-    for (uint32_t index = 0; index < mapCopy->terrain()->size(); ++index) {
+    for (uint32_t index = 0; index < mapCopy->terrain()->size(); index++) {
        if (IsWater(mapCopy->terrain()->Get(index)->type())) continue;
        // const_cast is safe because we own the mutable buffer (mapCopy)
        const_cast<net::eagle0::shardok::storage::fb::Terrain *>(
@@ -155,7 +155,7 @@ auto WaterCrossingTiles(
    //  1) the tile is water
    //  2) the tile does not already have a bridge (that is not on fire)
    //  3) the tile is not already frozen
-    for (int index = 0; index < mapSize; ++index) {
+    for (int index = 0; index < mapSize; index++) {
        const auto startTerrain = *hexMap->terrain()->Get(index);

        if (!IsWater(startTerrain.type())) continue;
@@ -31,7 +31,7 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {
 }

 // Units that need a water crossing to reach at least one of the destinations
-[[nodiscard]] auto UnitIdsRequiringWaterCrossing(
+auto UnitIdsRequiringWaterCrossing(
        const GameStateW& gameState,
        PlayerId pid,
        const CoordsSet& destinations,
@@ -39,14 +39,14 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {
        const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;

 // Units belonging to the player that are capable of creating water crossings
-[[nodiscard]] auto UnitIdsToCreateWaterCrossing(
+auto UnitIdsToCreateWaterCrossing(
        const GameStateW& gameState,
        PlayerId pid,
        const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;

 // Whether a unit of the given type can reach destination from origin, given the current state
 // of the map
-[[nodiscard]] auto CanReach(
+auto CanReach(
        const Coords& origin,
        const Coords& destination,
        const HexMap* hexMap,
@@ -56,12 +56,11 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {

 // Returns the *non*-water tiles from which you could bridge/freeze water to allow a unit to cross
 // from origin to destination
-[[nodiscard]] auto CrossingStartLocations(const HexMap* hexMap, const CoordsSet& waterCrossingTiles)
-        -> CoordsSet;
+auto CrossingStartLocations(const HexMap* hexMap, const CoordsSet& waterCrossingTiles) -> CoordsSet;

 // Returns the water tiles that, if they were bridged/frozen, would allow a unit to cross from
 // origin to destination
-[[nodiscard]] auto WaterCrossingTiles(
+auto WaterCrossingTiles(
        const Coords& origin,
        const Coords& destination,
        const HexMap* hexMap,
@@ -69,7 +68,7 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {
        const BattalionTypeSPtr& battalionType) -> CoordsSet;

 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
-[[nodiscard]] auto IntendedCrossingStarts(
+auto IntendedCrossingStarts(
        const GameStateW& gameState,
        const vector<UnitId>& unitIdsCreatingCrossing,
        const CoordsSet& tilesToStartCrossingFrom,
@@ -77,7 +76,7 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {
        const BattalionTypeGetter& battalionTypeGetter) -> CoordsSet;

 // Calculate score based on water crossing strategy
-[[nodiscard]] auto WaterCrossingScore(
+auto WaterCrossingScore(
        PlayerId playerId,
        const BattalionTypeGetter& battalionTypeGetter,
        const GameStateW& gameState,
@@ -51,7 +51,7 @@ IterativeDeepeningAI::IterativeDeepeningAI(
      castleCoords(castleCoords),
      scorer(scorer),
      apdCache(apdCache),
-      battalionTypeGetter(std::move(battalionTypeGetter)) {}
+      battalionTypeGetter(std::move(battalionTypeGetter)) {}  // Move the function object

 auto IterativeDeepeningAI::IterativeSearch(
        const GameSettingsSPtr& settings,
@@ -79,7 +79,7 @@ private:
    CoordsSet castleCoords;
    const AIScoreCalculator& scorer;
    const APDCache& apdCache;
-    BattalionTypeGetter battalionTypeGetter;
+    BattalionTypeGetter battalionTypeGetter;  // Store by value, not reference!

    // Reusable vectors to reduce memory allocations
    mutable std::vector<std::vector<ScoreValue>> scoresByDepth;
@@ -182,7 +182,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(
                  << " round=" << guessedState->current_round() << "\n";

        const auto maxDump = std::max(commandCount, realAvailableCommands->size());
-        for (size_t i = 0; i < maxDump; ++i) {
+        for (size_t i = 0; i < maxDump; i++) {
            const auto realName = i < realAvailableCommands->size()
                                          ? net::eagle0::shardok::common::CommandType_Name(
                                                    (*realAvailableCommands)[i]->GetCommandType())
@@ -214,13 +214,13 @@ auto ShardokAIClient::StandardChooseCommandIndex(
        // Group by unit to find the missing position per unit
        std::unordered_map<int, std::set<std::pair<int, int>>> realPositions;
        std::unordered_map<int, std::set<std::pair<int, int>>> guessedPositions;
-        for (size_t i = 0; i < realAvailableCommands->size(); ++i) {
+        for (size_t i = 0; i < realAvailableCommands->size(); i++) {
            const auto &cmd = (*realAvailableCommands)[i];
            realPositions[cmd->GetActorUnitId()].emplace(
                    cmd->GetTargetRow(),
                    cmd->GetTargetColumn());
        }
-        for (size_t i = 0; i < commandCount; ++i) {
+        for (size_t i = 0; i < commandCount; i++) {
            const auto &cmd = (*guessedCommands)[i];
            guessedPositions[cmd->GetActorUnitId()].emplace(
                    cmd->GetTargetRow(),
@@ -250,7 +250,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(

        // Dump all guessed state units for full picture
        std::cerr << "  Guessed state units (" << guessedState->units()->size() << " total):\n";
-        for (size_t i = 0; i < guessedState->units()->size(); ++i) {
+        for (size_t i = 0; i < guessedState->units()->size(); i++) {
            const auto *u = guessedState->units()->Get(static_cast<unsigned int>(i));
            std::cerr << "    unit_id=" << u->unit_id() << " player=" << u->player_id()
                      << " status=" << static_cast<int>(u->status()) << " loc=("
@@ -263,7 +263,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(
                "AI command count mismatch: guessed=" + std::to_string(commandCount) +
                " real=" + std::to_string(realAvailableCommands->size()));
    }
-    for (size_t i = 0; i < commandCount; ++i) {
+    for (size_t i = 0; i < commandCount; i++) {
        CheckCommand((*realAvailableCommands)[i], (*guessedCommands)[i]);
    }

@@ -490,7 +490,7 @@ auto ShardokAIClient::ChooseCommandIndex(
    if (totalChoices % 1000 == 0) {
        std::cout << "TYPES CHOSEN:\n";
        vector<std::pair<int, CommandType>> choices{};
-        for (int i = 0; i <= net::eagle0::shardok::common::CommandType_MAX; ++i) {
+        for (int i = 0; i <= net::eagle0::shardok::common::CommandType_MAX; i++) {
            if (typeChosenCount[i] != 0) {
                choices.emplace_back(typeChosenCount[i], static_cast<CommandType>(i));
            }
@@ -43,7 +43,7 @@ auto SortActionsByWeight(
    std::vector<size_t> sortedIndices(actions.size());
    std::iota(sortedIndices.begin(), sortedIndices.end(), 0);

-    std::ranges::sort(sortedIndices, [&weights](size_t a, size_t b) {
+    std::sort(sortedIndices.begin(), sortedIndices.end(), [&weights](size_t a, size_t b) {
        return weights[a] > weights[b];
    });

@@ -398,8 +398,9 @@ std::vector<size_t> ShardokGameEngine::filterActions(
        const MCTSGameState& /*state*/) const {
    // All filtering is already done in getLegalActions() using AICommandFilter
    // This method is used by simulation policies and doesn't need additional filtering
-    std::vector<size_t> indices(actions.size());
-    std::iota(indices.begin(), indices.end(), 0);
+    std::vector<size_t> indices;
+    indices.reserve(actions.size());
+    for (size_t i = 0; i < actions.size(); ++i) { indices.push_back(i); }
    return indices;
 }

@@ -23,7 +23,7 @@ using net::eagle0::shardok::storage::fb::PlayerInfo;

 using ScoreValue = double;

-[[nodiscard]] auto AttackerHoldsCriticalTilesVictoryScore(
+auto AttackerHoldsCriticalTilesVictoryScore(
        const GameStateW& gameState,
        const CoordsSet& criticalTileLocations,
        const PlayerInfo* player,
@@ -32,12 +32,12 @@ using ScoreValue = double;
        const BattalionTypeGetter& battalionTypeGetter,
        ActionPoints braveWaterCost) -> ScoreValue;

-[[nodiscard]] auto DefenderHoldsCriticalTilesVictoryScore(
+auto DefenderHoldsCriticalTilesVictoryScore(
        const GameStateW& gameState,
        const CoordsSet& criticalTileLocations,
        const PlayerInfo* player) -> ScoreValue;

-[[nodiscard]] auto LastPlayerStandingVictoryScore(
+auto LastPlayerStandingVictoryScore(
        const GameStateW& gameState,
        const PlayerInfo* player,
        const APDCache& apdCache,
@@ -230,7 +230,7 @@ auto MakeMCTSOptimizedAIScoreCalculator(
    std::vector<BattalionTypeSPtr> battalionTypes(BattalionTypeId::BattalionTypeId_MAX + 1);
    for (int typeId = BattalionTypeId::BattalionTypeId_MIN;
         typeId <= BattalionTypeId::BattalionTypeId_MAX;
-         ++typeId) {
+         typeId++) {
        auto battalionTypeId = static_cast<BattalionTypeId>(typeId);
        battalionTypes[battalionTypeId] = settingsGetter.GetBattalionType(battalionTypeId);
    }
@@ -356,7 +356,7 @@ auto MakeStandardAIScoreCalculatorWithExperiment(
    std::vector<BattalionTypeSPtr> battalionTypes(BattalionTypeId::BattalionTypeId_MAX + 1);
    for (int typeId = BattalionTypeId::BattalionTypeId_MIN;
         typeId <= BattalionTypeId::BattalionTypeId_MAX;
-         ++typeId) {
+         typeId++) {
        auto battalionTypeId = static_cast<BattalionTypeId>(typeId);
        battalionTypes[battalionTypeId] = settingsGetter.GetBattalionType(battalionTypeId);
    }
@@ -7,7 +7,8 @@
 #include "src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"

-namespace shardok::score_calculator_internal {
+namespace shardok {
+namespace score_calculator_internal {

 auto EffectiveDistanceCache::GetOrCompute(
        const Unit* unit,
@@ -124,4 +125,5 @@ auto AttackerMultiplierForTargetDistance(
            isLateGame);
 }

-}  // namespace shardok::score_calculator_internal
+}  // namespace score_calculator_internal
+}  // namespace shardok
@@ -24,7 +24,8 @@
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/hex_map_generated.h"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/unit_generated.h"

-namespace shardok::score_calculator_internal {
+namespace shardok {
+namespace score_calculator_internal {

 using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 using Unit = net::eagle0::shardok::storage::fb::Unit;
@@ -50,13 +51,13 @@ struct EffectiveDistanceCache {
    struct CacheKey {
        UnitId unitId;
        Coords target;
-        [[nodiscard]] bool operator==(const CacheKey& other) const {
+        bool operator==(const CacheKey& other) const {
            return unitId == other.unitId && target == other.target;
        }
    };

    struct CacheKeyHash {
-        [[nodiscard]] size_t operator()(const CacheKey& key) const {
+        size_t operator()(const CacheKey& key) const {
            return std::hash<UnitId>{}(key.unitId) ^ (std::hash<int>{}(key.target.row()) << 1) ^
                   (std::hash<int>{}(key.target.column()) << 2);
        }
@@ -64,7 +65,7 @@ struct EffectiveDistanceCache {

    mutable gtl::flat_hash_map<CacheKey, DIST_T, CacheKeyHash> cache;

-    [[nodiscard]] DIST_T GetOrCompute(
+    DIST_T GetOrCompute(
            const Unit* unit,
            const Coords& target,
            const ActionPointDistances* notBravingApd,
@@ -74,12 +75,11 @@ struct EffectiveDistanceCache {

 /// Calculate score for FLEE strategy
 /// Returns negative score based on fleeing units
-[[nodiscard]] auto FleeStrategyScoreForState(const GameStateW& gameState, PlayerId playerId)
-        -> ScoreValue;
+auto FleeStrategyScoreForState(const GameStateW& gameState, PlayerId playerId) -> ScoreValue;

 /// Calculate attacker multiplier based on distance to priority targets
 /// This is used to weight attacker units by their proximity to objectives
-[[nodiscard]] auto AttackerMultiplierForTargetDistance(
+auto AttackerMultiplierForTargetDistance(
        const Unit* attackingUnit,
        const std::vector<TargetAndAttackLocations>& priorityList,
        const std::vector<const Unit*>& occupants,
@@ -89,6 +89,7 @@ struct EffectiveDistanceCache {
        const ActionPointDistances* bravingApd,
        bool isLateGame) -> double;

-}  // namespace shardok::score_calculator_internal
+}  // namespace score_calculator_internal
+}  // namespace shardok

 #endif  // EAGLE0_SHARDOK_AI_SCORE_PRIVATE_AI_SCORE_CALCULATOR_SHARED_UTILITIES_HPP
@@ -10,7 +10,8 @@
 #include <iostream>
 #include <sstream>

-namespace shardok::ai_battle_simulator {
+namespace shardok {
+namespace ai_battle_simulator {

 using net::eagle0::shardok::ai_battle_simulator::AIAlgorithmType;
 using net::eagle0::shardok::ai_battle_simulator::PlayerConfig;
@@ -109,4 +110,5 @@ std::string AiBattleConfigLoader::ToJsonString(const BattleConfigProto& config)
    return jsonString;
 }

-}  // namespace shardok::ai_battle_simulator
+}  // namespace ai_battle_simulator
+}  // namespace shardok
@@ -13,7 +13,8 @@
 #include "src/main/protobuf/net/eagle0/shardok/ai_battle_simulator/ai_battle_config.pb.h"
 #pragma clang diagnostic pop

-namespace shardok::ai_battle_simulator {
+namespace shardok {
+namespace ai_battle_simulator {

 using BattleConfigProto = net::eagle0::shardok::ai_battle_simulator::BattleConfig;

@@ -40,6 +41,7 @@ public:
    [[nodiscard]] static std::string ToJsonString(const BattleConfigProto& config);
 };

-}  // namespace shardok::ai_battle_simulator
+}  // namespace ai_battle_simulator
+}  // namespace shardok

 #endif  // EAGLE0_SHARDOK_AI_BATTLE_SIMULATOR_AI_BATTLE_CONFIG_HPP
@@ -28,7 +28,8 @@
 #include "src/main/protobuf/net/eagle0/shardok/common/player_info.pb.h"
 #pragma clang diagnostic pop

-namespace shardok::ai_battle_simulator {
+namespace shardok {
+namespace ai_battle_simulator {

 namespace {

@@ -330,6 +331,10 @@ GameStateW AiBattleSimulator::CreateInitialGameState() const {
    // Load map
    auto hexMapProto = LoadMap(config_.map_name());

+    // Create player info protos
+    std::vector<net::eagle0::shardok::common::PlayerInfo> playerInfoProtos;
+    playerInfoProtos.reserve(2);
+
    // Attacker info
    net::eagle0::shardok::common::PlayerInfo attackerInfo;
    attackerInfo.set_player_id(ATTACKER_ID);
@@ -339,6 +344,7 @@ GameStateW AiBattleSimulator::CreateInitialGameState() const {
            net::eagle0::shardok::common::VICTORY_CONDITION_LAST_PLAYER_STANDING);
    attackerInfo.add_victory_conditions(
            net::eagle0::shardok::common::VICTORY_CONDITION_HOLDS_CRITICAL_TILES);
+    playerInfoProtos.push_back(std::move(attackerInfo));

    // Defender info
    net::eagle0::shardok::common::PlayerInfo defenderInfo;
@@ -349,10 +355,7 @@ GameStateW AiBattleSimulator::CreateInitialGameState() const {
            net::eagle0::shardok::common::VICTORY_CONDITION_LAST_PLAYER_STANDING);
    defenderInfo.add_victory_conditions(
            net::eagle0::shardok::common::VICTORY_CONDITION_WIN_AFTER_MAX_ROUNDS);
-
-    std::vector<net::eagle0::shardok::common::PlayerInfo> playerInfoProtos{
-            std::move(attackerInfo),
-            std::move(defenderInfo)};
+    playerInfoProtos.push_back(std::move(defenderInfo));

    // Create units from config
    std::vector<net::eagle0::shardok::storage::fb::Unit> units;
@@ -958,4 +961,5 @@ BattleResult AiBattleSimulator::CreateResultFromGameState(
    return result;
 }

-}  // namespace shardok::ai_battle_simulator
+}  // namespace ai_battle_simulator
+}  // namespace shardok
@@ -30,9 +30,7 @@ class ShardokEngine;
 // Type alias for hex map
 using HexMap = net::eagle0::shardok::storage::fb::HexMap;

-}  // namespace shardok
-
-namespace shardok::ai_battle_simulator {
+namespace ai_battle_simulator {

 using BattleConfigProto = net::eagle0::shardok::ai_battle_simulator::BattleConfig;

@@ -148,6 +146,7 @@ private:
    CreateResultFromGameState(const GameStateW& state, int totalRounds, int totalCommands) const;
 };

-}  // namespace shardok::ai_battle_simulator
+}  // namespace ai_battle_simulator
+}  // namespace shardok

 #endif  // EAGLE0_SHARDOK_AI_BATTLE_SIMULATOR_AI_BATTLE_SIMULATOR_HPP
@@ -191,8 +191,7 @@ int main(int argc, char *argv[]) {
            }
            std::cout << "],\"has_game_status\":" << (hasGameStatus ? "true" : "false") << "}\n";
            return 0;
-        }
-        if (!resultPath.empty()) {
+        } else if (!resultPath.empty()) {
            ActionResult result;
            if (!result.ParseFromString(ReadFile(resultPath))) {
                throw std::runtime_error("Failed to parse Shardok action result proto");
@@ -7,7 +7,8 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSTypes.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/ShardokAIClient.hpp"

-namespace shardok::ai_testing_common {
+namespace shardok {
+namespace ai_testing_common {

 auto AIClientFactory::Create(
        PlayerId playerId,
@@ -29,4 +30,5 @@ auto AIClientFactory::Create(
            mctsConfig);
 }

-}  // namespace shardok::ai_testing_common
+}  // namespace ai_testing_common
+}  // namespace shardok
@@ -8,7 +8,8 @@
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"

-namespace shardok::ai_testing_common {
+namespace shardok {
+namespace ai_testing_common {

 auto GamePhaseRunner::RunSetupPhase(
        ShardokEngine& engine,
@@ -57,4 +58,5 @@ auto GamePhaseRunner::RunSingleTurn(ShardokEngine& engine, PlayerId playerId, Sh
    return true;
 }

-}  // namespace shardok::ai_testing_common
+}  // namespace ai_testing_common
+}  // namespace shardok
@@ -9,7 +9,8 @@
 #include "src/main/cpp/net/eagle0/common/byte_vector.hpp"
 #include "src/main/cpp/net/eagle0/shardok/util/BattalionTypeRegistrar.hpp"

-namespace shardok::ai_testing_common {
+namespace shardok {
+namespace ai_testing_common {

 auto GameSettingsFactory::CreateDefault() -> GameSettingsSPtr {
    auto settings = std::make_shared<GameSettings>();
@@ -30,4 +31,5 @@ auto GameSettingsFactory::CreateDefault() -> GameSettingsSPtr {
    return settings;
 }

-}  // namespace shardok::ai_testing_common
+}  // namespace ai_testing_common
+}  // namespace shardok
@@ -10,7 +10,8 @@

 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"

-namespace shardok::ai_testing_common {
+namespace shardok {
+namespace ai_testing_common {

 /**
 * Factory class for creating GameSettings instances with standard configuration.
@@ -32,6 +33,7 @@ public:
    static auto CreateDefault() -> GameSettingsSPtr;
 };

-}  // namespace shardok::ai_testing_common
+}  // namespace ai_testing_common
+}  // namespace shardok

 #endif  // EAGLE0_SHARDOK_AI_TESTING_COMMON_GAME_SETTINGS_FACTORY_HPP
@@ -32,8 +32,9 @@ private:
    static auto CannotBecomeOutlaw(const GameStateW &gameState, PlayerId pid) -> bool {
        if (pid == UNCONTROLLED_PLAYER_ID) return false;

-        const auto &player = std::ranges::find_if(
-                *gameState->player_infos(),
+        const auto &player = std::find_if(
+                std::begin(*gameState->player_infos()),
+                std::end(*gameState->player_infos()),
                [pid](const PlayerInfoFb *pi) { return pi->player_id() == pid; });

        return (player != std::end(*gameState->player_infos()) && player->cannot_become_outlaw());
@@ -42,8 +43,9 @@ private:
    static auto IsAttacker(const GameStateW &gameState, PlayerId pid) -> bool {
        if (pid == UNCONTROLLED_PLAYER_ID) return false;

-        const auto &player = std::ranges::find_if(
-                *gameState->player_infos(),
+        const auto &player = std::find_if(
+                std::begin(*gameState->player_infos()),
+                std::end(*gameState->player_infos()),
                [pid](const PlayerInfoFb *pi) { return pi->player_id() == pid; });

        return (player == std::end(*gameState->player_infos()) || !player->is_defender());
@@ -189,12 +189,12 @@ struct BattalionType {
    }

    [[nodiscard]] auto GetCostToEnterTerrain(const TerrainProto &terrain) const -> ActionCost {
-        if (HasBridge(terrain.modifier())) {
-            return {ActionCost::standard,
+        if (HasBridge(terrain.modifier()))
+            return ActionCost(
+                    ActionCost::standard,
                    ActionPoints(std::ceil(
                            100.0 * minimumCostToEnterBridge /
-                            terrain.modifier().bridge().integrity().value()))};
-        }
+                            terrain.modifier().bridge().integrity().value())));
        if (IsFrozen(terrain.modifier())) return costToEnterIce;

        auto terrainCost = GetCostToEnterTerrainType(terrain.type());
@@ -208,11 +208,11 @@ struct BattalionType {
    [[nodiscard]] auto GetCostToEnterTerrain(
            const net::eagle0::shardok::storage::fb::Terrain_::Type terrainType,
            const net::eagle0::shardok::storage::fb::TileModifier &tm) const -> ActionCost {
-        if (tm.bridge().present()) {
-            return {ActionCost::standard,
+        if (tm.bridge().present())
+            return ActionCost(
+                    ActionCost::standard,
                    ActionPoints(
-                            std::ceil(100.0 * minimumCostToEnterBridge / tm.bridge().integrity()))};
-        }
+                            std::ceil(100.0 * minimumCostToEnterBridge / tm.bridge().integrity())));
        if (tm.ice().present()) return costToEnterIce;

        auto terrainCost = GetCostToEnterTerrainType(terrainType);
@@ -44,7 +44,7 @@ inline constexpr DamageType DamageType_aessence = DamageType::DamageType_aessenc
 inline constexpr DamageType DamageType_impact = DamageType::DamageType_impact;
 inline constexpr int NUM_DAMAGE_TYPES = static_cast<int>(DamageType::NUM_DAMAGE_TYPES);

-[[nodiscard]] static inline bool DamageTypeGetsTerrainDefense(const DamageType type) {
+static inline bool DamageTypeGetsTerrainDefense(const DamageType type) {
    switch (type) {
        case DamageType_slashing:
        case DamageType_puncturing:
@@ -132,13 +132,11 @@ public:
        return damageByType.at(PenetratingIndex(type));
    };

-    [[nodiscard]] bool operator==(const CombatDamage& cmpr) const {
-        return damageByType == cmpr.damageByType;
-    }
+    bool operator==(const CombatDamage& cmpr) const { return damageByType == cmpr.damageByType; }

-    [[nodiscard]] bool operator!=(const CombatDamage& cmpr) const { return !(*this == cmpr); }
+    bool operator!=(const CombatDamage& cmpr) const { return !(*this == cmpr); }

-    [[nodiscard]] bool operator<=(const CombatDamage& cmpr) const {
+    bool operator<=(const CombatDamage& cmpr) const {
        return std::ranges::equal(
                damageByType,
                cmpr.damageByType,
@@ -147,7 +145,7 @@ public:
                });
    }

-    [[nodiscard]] bool operator>=(const CombatDamage& cmpr) const {
+    bool operator>=(const CombatDamage& cmpr) const {
        return std::ranges::equal(
                damageByType,
                cmpr.damageByType,
@@ -156,15 +154,11 @@ public:
                });
    }

-    [[nodiscard]] bool operator>(const CombatDamage& cmpr) const {
-        return ((*this >= cmpr) && !(*this == cmpr));
-    }
+    bool operator>(const CombatDamage& cmpr) const { return ((*this >= cmpr) && !(*this == cmpr)); }

-    [[nodiscard]] bool operator<(const CombatDamage& cmpr) const {
-        return ((*this <= cmpr) && !(*this == cmpr));
-    }
+    bool operator<(const CombatDamage& cmpr) const { return ((*this <= cmpr) && !(*this == cmpr)); }

-    [[nodiscard]] CombatDamage operator+(const CombatDamage& add) const {
+    CombatDamage operator+(const CombatDamage& add) const {
        return Builder()
                .SetSlashing(
                        GetNormalDamageOfType(DamageType_slashing) +
@@ -225,7 +219,7 @@ public:
                .Build();
    }

-    [[nodiscard]] CombatDamage operator*(const double factor) const {
+    CombatDamage operator*(const double factor) const {
        return Builder()
                .SetSlashing(GetNormalDamageOfType(DamageType_slashing) * factor)
                .SetPuncturing(GetNormalDamageOfType(DamageType_puncturing) * factor)
@@ -448,7 +442,7 @@ public:

    [[nodiscard]] auto ToBuilder() const -> Builder {
        Builder builder = Builder();
-        for (int i = 0; i < static_cast<int>(NUM_DAMAGE_TYPES); ++i) {
+        for (int i = 0; i < static_cast<int>(NUM_DAMAGE_TYPES); i++) {
            const auto type = static_cast<DamageType>(i);
            builder.SetDamageByType(type, false, this->GetNormalDamageOfType(type));
            builder.SetDamageByType(type, true, this->GetPenetratingDamageOfType(type));
@@ -457,9 +451,7 @@ public:
    }
 };

-[[nodiscard]] inline CombatDamage operator*(const double factor, const CombatDamage& dmg) {
-    return dmg * factor;
-}
+inline CombatDamage operator*(const double factor, const CombatDamage& dmg) { return dmg * factor; }
 }  // namespace shardok

 #endif  // EAGLE0_SHARDOK_LIBRARY_COMBAT_DAMAGE_HPP
@@ -21,23 +21,19 @@ using WeatherFb = net::eagle0::shardok::storage::fb::Weather;
 using TerrainProto = net::eagle0::shardok::common::Terrain;
 using Terrain = net::eagle0::shardok::storage::fb::Terrain;

-[[nodiscard]] auto PropensityByTerrain(const Terrain *terrain, const SettingsGetter &settings)
-        -> int;
+auto PropensityByTerrain(const Terrain *terrain, const SettingsGetter &settings) -> int;

-[[nodiscard]] auto PropensityByTerrain(const TerrainProto &terrain, const SettingsGetter &settings)
-        -> int;
+auto PropensityByTerrain(const TerrainProto &terrain, const SettingsGetter &settings) -> int;

-[[nodiscard]] auto PropensityByTerrain(
+auto PropensityByTerrain(
        const TerrainType &terrainType,
        const TileModifierProto &modifier,
        const SettingsGetter &settings) -> int;

-[[nodiscard]] auto GetFireDamage(
-        int troops,
-        double openEndedPercentileRoll1,
-        double openEndedPercentileRoll2) -> CombatDamage;
+auto GetFireDamage(int troops, double openEndedPercentileRoll1, double openEndedPercentileRoll2)
+        -> CombatDamage;

-[[nodiscard]] auto GetExtinguishOdds(
+auto GetExtinguishOdds(
        const SettingsGetter &settings,
        const Terrain *terrain,
        const WeatherFb *currentWeather,
@@ -45,7 +41,7 @@ using Terrain = net::eagle0::shardok::storage::fb::Terrain;
        double intelligence,
        bool ownTile) -> PercentileRollOdds;

-[[nodiscard]] auto GetStartFireOdds(
+auto GetStartFireOdds(
        const SettingsGetter &settings,
        const Terrain &terrain,
        const WeatherFb &currentWeather,
@@ -36,19 +36,25 @@ public:
    using BaseType::BaseType;

    // Default constructor
-    GameStateW() = default;
+    GameStateW() : BaseType() {}

    // Copy constructor
-    GameStateW(const GameStateW& other) = default;
+    GameStateW(const GameStateW& other) : BaseType(other) {}

    // Move constructor
-    GameStateW(GameStateW&& other) noexcept = default;
+    GameStateW(GameStateW&& other) noexcept : BaseType(std::move(other)) {}

    // Copy assignment
-    GameStateW& operator=(const GameStateW& other) = default;
+    GameStateW& operator=(const GameStateW& other) {
+        BaseType::operator=(other);
+        return *this;
+    }

    // Move assignment
-    GameStateW& operator=(GameStateW&& other) noexcept = default;
+    GameStateW& operator=(GameStateW&& other) noexcept {
+        BaseType::operator=(std::move(other));
+        return *this;
+    }

    // Constructor from base type
    GameStateW(const BaseType& base) : BaseType(base) {}
@@ -42,7 +42,7 @@ private:
    [[nodiscard]] virtual auto InternalExecute(
            const GameStateW& currentState,
            const std::shared_ptr<RandomGenerator>& generator) const -> std::vector<ActionResult> {
-        return InternalExecuteWithRoll(currentState, generator, std::nullopt);
+        return InternalExecuteWithRoll(currentState, generator, std::optional<int32_t>());
    }

    [[nodiscard]] virtual auto InternalExecuteWithRoll(
@@ -443,7 +443,7 @@ void ShardokEngine::PostPlacementCommands(
            reinforcementPositions);

    // first make sure they're all valid and there are no duplicates
-    for (size_t i = 0; i < placementInfos.size(); ++i) {
+    for (size_t i = 0; i < placementInfos.size(); i++) {
        const UnitPlacementInfo &pi = placementInfos[i];

        const auto it = std::ranges::find_if(*placementCommands, [pi](const CommandSPtr &cmd) {
@@ -455,7 +455,7 @@ void ShardokEngine::PostPlacementCommands(
        }

        // check that we're not double-filling any location or double-placing any unit
-        for (size_t j = i + 1; j < placementInfos.size(); ++j) {
+        for (size_t j = i + 1; j < placementInfos.size(); j++) {
            const UnitPlacementInfo &other = placementInfos[j];

            if (pi.unitId == other.unitId)
@@ -31,7 +31,7 @@ auto ActionPointDistances::BraveWaterPossibleCoords(const HexMap* hexMap) const
    const int indexCount = hexMap->row_count() * hexMap->column_count();
    info->details.reserve(indexCount);
    const auto indexToCoords = CreateIndexToCoords(hexMap);
-    for (int i = 0; i < indexCount; ++i) {
+    for (int i = 0; i < indexCount; i++) {
        if (const Terrain* terrain = hexMap->terrain()->Get(i);
            IsWater(terrain->type()) && !terrain->modifier().bridge().present() &&
            !terrain->modifier().ice().present()) {
@@ -71,7 +71,7 @@ auto ActionPointDistances::CreateIndexToCoords(const HexMap* hexMap) -> std::vec
    const int indexCount = hexMap->row_count() * columnCount;
    std::vector<Coords> indexToCoords;
    indexToCoords.reserve(indexCount);
-    for (int i = 0; i < indexCount; ++i) {
+    for (int i = 0; i < indexCount; i++) {
        indexToCoords.emplace_back(
                static_cast<int8_t>(i / columnCount),
                static_cast<int8_t>(i % columnCount));
@@ -85,7 +85,7 @@ auto ActionPointDistances::CreateAdjacencyTable(const HexMap* hexMap)
    const int indexCount = hexMap->row_count() * columnCount;
    std::vector<std::array<int, 6>> adjacencyTable;
    adjacencyTable.reserve(indexCount);
-    for (int i = 0; i < indexCount; ++i) {
+    for (int i = 0; i < indexCount; i++) {
        const Coords coords(
                static_cast<int8_t>(i / columnCount),
                static_cast<int8_t>(i % columnCount));
@@ -119,7 +119,7 @@ void ActionPointDistances::PopulateOne(

    // Find starting index (the one with distance 0)
    const int distanceCount = static_cast<int>(ds.size());
-    for (int i = 0; i < distanceCount; ++i) {
+    for (int i = 0; i < distanceCount; i++) {
        if (ds[i] == 0) {
            pq.emplace(0, i);
            break;
@@ -141,7 +141,7 @@ void ActionPointDistances::PopulateOne(

        // Prefetch terrain data for all neighbors to reduce memory stalls
        const std::array<int, 6>& neighbors = adjacencyTable[currentIndex];
-        for (int i = 0; i < 6 && neighbors[i] != -1; ++i) {
+        for (int i = 0; i < 6 && neighbors[i] != -1; i++) {
            __builtin_prefetch(hexMap->terrain()->Get(neighbors[i]), 0, 3);
        }

@@ -243,7 +243,7 @@ OnDemandActionPointDistances::OnDemandActionPointDistances(

    auto braveWaterPossibleCoords = includeBravingWater ? BraveWaterPossibleCoords(map) : nullptr;

-    for (int fromIndex = 0; fromIndex < indexCount; ++fromIndex) {
+    for (int fromIndex = 0; fromIndex < indexCount; fromIndex++) {
        distances[fromIndex] = std::async(
                                       std::launch::deferred,
                                       &OnDemandActionPointDistances::GenerateDistances,
@@ -43,7 +43,7 @@ protected:
            const std::shared_ptr<BraveableTileInfo> &braveWaterPossibleCoords,
            const std::vector<Coords> &indexToCoords,
            const std::vector<std::array<int, 6>> &adjacencyTable);
-    [[nodiscard]] static auto GenerateDistances(
+    static auto GenerateDistances(
            int fromIndex,
            const HexMap *hexMap,
            bool includeBravingWater,
@@ -51,15 +51,13 @@ protected:
            const BattalionTypeSPtr &battalionType,
            const std::shared_ptr<BraveableTileInfo> &braveWaterPossibleCoords)
            -> std::vector<DIST_T>;
-    [[nodiscard]] auto BraveWaterPossibleCoords(const HexMap *hexMap) const
-            -> std::shared_ptr<BraveableTileInfo>;
+    auto BraveWaterPossibleCoords(const HexMap *hexMap) const -> std::shared_ptr<BraveableTileInfo>;

    // Create coordinate lookup table for efficient index->coords conversion
-    [[nodiscard]] static auto CreateIndexToCoords(const HexMap *hexMap) -> std::vector<Coords>;
+    static auto CreateIndexToCoords(const HexMap *hexMap) -> std::vector<Coords>;

    // Create adjacency lookup table for efficient neighbor access
-    [[nodiscard]] static auto CreateAdjacencyTable(const HexMap *hexMap)
-            -> std::vector<std::array<int, 6>>;
+    static auto CreateAdjacencyTable(const HexMap *hexMap) -> std::vector<std::array<int, 6>>;

    [[nodiscard]] auto ToIndex(const Coords &coords) const -> int {
        return coords.row() * column_count + coords.column();
@@ -72,9 +70,9 @@ public:

    virtual ~ActionPointDistances() = default;

-    [[nodiscard]] virtual auto Distance(int fromIndex, int toIndex) const -> DIST_T = 0;
+    virtual auto Distance(int fromIndex, int toIndex) const -> DIST_T = 0;

-    [[nodiscard]] virtual auto Distance(const Coords &from, const Coords &to) const -> DIST_T = 0;
+    virtual auto Distance(const Coords &from, const Coords &to) const -> DIST_T = 0;
 };

 class OnDemandActionPointDistances final : public ActionPointDistances {
@@ -93,11 +91,11 @@ public:

    ~OnDemandActionPointDistances() override = default;

-    [[nodiscard]] auto Distance(const int fromIndex, const int toIndex) const -> int16_t override {
+    auto Distance(const int fromIndex, const int toIndex) const -> int16_t override {
        return distances[fromIndex].get()[toIndex];
    }

-    [[nodiscard]] auto Distance(const Coords &from, const Coords &to) const -> int16_t override {
+    auto Distance(const Coords &from, const Coords &to) const -> int16_t override {
        return Distance(ToIndex(from), ToIndex(to));
    }
 };
@@ -77,7 +77,7 @@ static auto CreateIceClearedMap(const HexMap* map) -> fb::HexMapW {
    auto* mutableMap = mapCopy.Get();
    auto* terrainVec = mutableMap->mutable_terrain();

-    for (size_t i = 0; i < terrainVec->size(); ++i) {
+    for (size_t i = 0; i < terrainVec->size(); i++) {
        // Only process tiles with ice
        // const_cast is safe here because we own the mutable buffer (mapCopy)
        if (auto* terrain = const_cast<Terrain*>(terrainVec->GetMutableObject(i));
@@ -22,7 +22,7 @@ struct MapId {
    uint64_t terrainTypesId;
    uint64_t modifierId;

-    [[nodiscard]] auto operator==(const MapId& other) const -> bool {
+    auto operator==(const MapId& other) const -> bool {
        return terrainTypesId == other.terrainTypesId && modifierId == other.modifierId;
    }
 };
@@ -34,7 +34,7 @@ struct FullCacheKey {
    bool includeBravingWater;
    int braveWaterCost;

-    [[nodiscard]] bool operator==(const FullCacheKey& other) const {
+    bool operator==(const FullCacheKey& other) const {
        return mapId == other.mapId && battalionTypeId == other.battalionTypeId &&
               includeBravingWater == other.includeBravingWater &&
               braveWaterCost == other.braveWaterCost;
@@ -43,7 +43,7 @@ struct FullCacheKey {

 // Hash function for FullCacheKey
 struct FullCacheKeyHash {
-    [[nodiscard]] size_t operator()(const FullCacheKey& key) const {
+    size_t operator()(const FullCacheKey& key) const {
        // Pack small fields into a single 64-bit value
        uint64_t packed = (static_cast<uint64_t>(key.battalionTypeId) << 32) |
                          (static_cast<uint64_t>(key.braveWaterCost) << 1) |
@@ -85,7 +85,7 @@ private:
    // Epoch system removed - TLS cache uses size-based eviction instead

    // Helper to build cache key
-    [[nodiscard]] static auto MakeCacheKey(
+    static auto MakeCacheKey(
            const MapId& mapId,
            const BattalionTypeSPtr& battalionType,
            bool includeBravingWater,
@@ -107,7 +107,7 @@ public:
            bool includeBravingWater,
            int braveWaterActionPointCost = -1) -> const ActionPointDistances*;

-    [[nodiscard]] static auto GetMapId(const HexMap* map) -> MapId;
+    static auto GetMapId(const HexMap* map) -> MapId;

    // Consolidate the thread-safe cache into the persistent cache and clear
    // the current thread's local cache. This is only safe if we know reads
@@ -116,7 +116,7 @@ public:

    // Cache management methods
    static void ClearThreadLocalCache();
-    [[nodiscard]] static size_t GetThreadLocalCacheSize();
+    static size_t GetThreadLocalCacheSize();
 };

 using APDCache = std::shared_ptr<ActionPointDistancesCache>;
@@ -42,13 +42,13 @@ auto FixedActionPointDistances::Create(

    int chunkSize = (indexCount + ASYNC_COUNT - 1) / ASYNC_COUNT;
    // Break into chunks for async
-    for (int chunkIdx = 0; chunkIdx < ASYNC_COUNT; ++chunkIdx) {
+    for (int chunkIdx = 0; chunkIdx < ASYNC_COUNT; chunkIdx++) {
        futures[chunkIdx] = std::async(std::launch::async, [=]() -> vector<vector<DIST_T>> {
            vector<vector<DIST_T>> chunkVec;
            chunkVec.reserve(chunkSize);
            const int chunkStartIndex = chunkIdx * chunkSize;

-            for (int i = 0; i < chunkSize; ++i) {
+            for (int i = 0; i < chunkSize; i++) {
                const auto fromIndex = chunkStartIndex + i;
                if (fromIndex >= indexCount) { continue; }
                chunkVec.push_back(ActionPointDistances::GenerateDistances(
@@ -65,7 +65,7 @@ auto FixedActionPointDistances::Create(

    apd->distances.reserve(indexCount);

-    for (int chunkIdx = 0; chunkIdx < ASYNC_COUNT; ++chunkIdx) {
+    for (int chunkIdx = 0; chunkIdx < ASYNC_COUNT; chunkIdx++) {
        auto resultsVec = futures[chunkIdx].get();
        apd->distances.insert(apd->distances.end(), resultsVec.begin(), resultsVec.end());
    }
@@ -24,7 +24,7 @@ private:

 public:
    // Factory method to create FixedActionPointDistances
-    [[nodiscard]] static auto Create(
+    static auto Create(
            const HexMap *map,
            const BattalionTypeSPtr &battalionType,
            bool includeBravingWater,
@@ -68,7 +68,7 @@ void ApplyResolvedUnit(
    // If a VIP was captured, alter the morale of all this player's units
    if (status == net::eagle0::shardok::storage::fb::UnitStatus_CAPTURED_UNIT &&
        unit.has_attached_hero() && unit.attached_hero().is_vip()) {
-        for (uint32_t i = 0; i < inoutState->units()->size(); ++i) {
+        for (uint32_t i = 0; i < inoutState->units()->size(); i++) {
            auto *playerUnit = GetMutableUnit(inoutState, i);
            if (playerUnit->player_id() != unit.player_id()) continue;
            if (playerUnit->unit_id() == unit.unit_id()) continue;
@@ -248,12 +248,12 @@ void MutatingApplyResult(
                static_cast<net::eagle0::shardok::storage::fb::GameStatus_::State>(
                        result.game_status().state())));
        const int winningShardokIdCount = result.game_status().winning_shardok_ids_size();
-        for (int i = 0; i < winningShardokIdCount; ++i) {
+        for (int i = 0; i < winningShardokIdCount; i++) {
            mutatingGameState->mutable_status()->mutable_winning_shardok_ids()->Mutate(
                    i,
                    result.game_status().winning_shardok_ids(i));
        }
-        for (int i = winningShardokIdCount; i < 10; ++i) {
+        for (int i = winningShardokIdCount; i < 10; i++) {
            mutatingGameState->mutable_status()->mutable_winning_shardok_ids()->Mutate(i, -1);
        }

@@ -385,10 +385,10 @@ void MutatingApplyResult(
        internalAssert(mutatingGameState->mutate_eligible_charger_id(-1));
    }
    const int possibleChargeeCount = result.possible_chargees_size();
-    for (int i = 0; i < possibleChargeeCount; ++i) {
+    for (int i = 0; i < possibleChargeeCount; i++) {
        mutatingGameState->mutable_possible_chargee_ids()->Mutate(i, result.possible_chargees(i));
    }
-    for (int i = possibleChargeeCount; i < 6; ++i) {
+    for (int i = possibleChargeeCount; i < 6; i++) {
        mutatingGameState->mutable_possible_chargee_ids()->Mutate(i, -1);
    }

@@ -23,11 +23,11 @@ void MutatingApplyResult(
        GameStateW& mutatingGameState,
        const ActionResultProto& actionResult,
        const SettingsGetter& settings);
-[[nodiscard]] auto ApplyResult(
+auto ApplyResult(
        GameStateW startingState,
        const ActionResultProto& actionResult,
        const SettingsGetter& settings) -> GameStateW;
-[[nodiscard]] auto ApplyResults(
+auto ApplyResults(
        const GameStateW& startingState,
        const std::vector<ActionResultProto>& actionResults,
        const SettingsGetter& settings) -> GameStateW;
@@ -19,7 +19,7 @@ auto CopyWithExtraUnits(const GameStateW& original, int additionalCount) -> Game

    // Add the requested units plus some extra slack for future use
    int extraSlack = std::max(5, additionalCount * 2);
-    for (int i = 0; i < additionalCount + extraSlack; ++i) {
+    for (int i = 0; i < additionalCount + extraSlack; i++) {
        Unit unit;
        unit.mutate_unit_id(static_cast<int16_t>(endGST.units.size()));
        if (i < additionalCount) {
@@ -9,8 +9,7 @@

 namespace shardok {

-[[nodiscard]] auto CopyWithExtraUnits(const GameStateW& original, int additionalCount)
-        -> GameStateW;
+auto CopyWithExtraUnits(const GameStateW& original, int additionalCount) -> GameStateW;

 }  // namespace shardok

@@ -90,7 +90,7 @@ auto BurnStructuresResult(const GameStateW &gameState, const SettingsGetter &set
        *result.mutable_changed_tile_modifiers() = {burnedTmcs.begin(), burnedTmcs.end()};
        return result;
    } else {
-        return std::nullopt;
+        return std::optional<ActionResultProto>();
    }
 }

@@ -25,9 +25,10 @@ static inline auto GameIsOver(const GameStatusFb* status) -> bool {
 }

 auto UpdateGameStatusAction::GetPlayerInfo(int playerId) const -> const PlayerInfoFb* {
-    return *std::ranges::find_if(*gameState->player_infos(), [playerId](const PlayerInfoFb* pi) {
-        return pi->player_id() == playerId;
-    });
+    return *std::find_if(
+            std::begin(*gameState->player_infos()),
+            std::end(*gameState->player_infos()),
+            [playerId](const PlayerInfoFb* pi) { return pi->player_id() == playerId; });
 }

 static inline auto HasVictoryCondition(const PlayerInfoFb* pi, const VictoryCondition condition)
@@ -29,7 +29,7 @@ auto UpdateOpponentKnowledgeAction::InternalExecute(

        auto unitAfter = *unit;

-        for (PlayerId pid = 0; pid < 10; ++pid) {
+        for (PlayerId pid = 0; pid < 10; pid++) {
            if (pid == unitPid) continue;
            if (static_cast<unsigned int>(pid) >= playerCount) continue;
            int bump = PlayerIsDefender(currentState, pid) ? defenderKnowledgeGain
@@ -126,7 +126,7 @@ void BraveWaterCommandFactory::AddAvailableBraveWaterCommands(
            }

            for (const auto &target : braveWaterTargets) {
-                std::optional<UnitId> ambusher = std::nullopt;
+                std::optional<UnitId> ambusher = std::optional<UnitId>();
                const auto &targetOccupant = Occupant(units, target);
                if (targetOccupant) { ambusher = targetOccupant->unit_id(); }
                commands.push_back(BraveWaterCommandFactory(settings)
@@ -19,7 +19,7 @@ private:
 public:
    explicit CommandFactoriesList(const SettingsGetter& settings);

-    [[nodiscard]] auto GetFactories() const -> std::vector<std::shared_ptr<const CommandFactory>>;
+    auto GetFactories() const -> std::vector<std::shared_ptr<const CommandFactory>>;
 };
 }  // namespace shardok

@@ -41,7 +41,7 @@ public:

    virtual void AddAvailableCommands(CommandList& commands, const CommandParams& params) const = 0;

-    [[nodiscard]] virtual auto IncludeInFollowUps() const -> bool { return true; }
+    virtual auto IncludeInFollowUps() const -> bool { return true; }
 };
 }  // namespace shardok

@@ -27,7 +27,7 @@ void FearCommandFactory::AddAvailableFearCommands(

        if (costForFear.IsPossible(remainingActionPoints)) {
            const int range = settings.Backing().fear_range();
-            for (int distance = 1; distance <= range; ++distance) {
+            for (int distance = 1; distance <= range; distance++) {
                const auto coordsSet = TilesWithExactDistance(hexMap, position, distance);

                for (const Coords &fearCoords : coordsSet) {
@@ -46,7 +46,7 @@ auto LightningBoltCommandFactory::AddAvailableLightningBoltCommands(
            ActionCost::UsesAllActionCost(settings.Backing().lightning_action_point_cost());
    const int lightningRange = settings.Backing().lightning_range();
    if (costForLightning.IsPossible(remainingActionPoints)) {
-        for (int distance = 1; distance <= lightningRange; ++distance) {
+        for (int distance = 1; distance <= lightningRange; distance++) {
            CoordsSet coords = TilesWithExactDistance(hexMap, position, distance);

            for (const Coords &lightningCoords : coords) {
@@ -41,7 +41,7 @@ void RaiseDeadCommandFactory::AddAvailableRaiseDeadCommands(
            const BattalionTypeSPtr &undeadType = settings.GetBattalionType(
                    net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD);

-            for (int distance = 1; distance <= range; ++distance) {
+            for (int distance = 1; distance <= range; distance++) {
                const CoordsSet coordsSet = TilesWithExactDistance(hexMap, position, distance);

                for (const Coords &raiseDeadCoords : coordsSet) {
@@ -34,7 +34,7 @@ void ScoutCommandFactory::AddAvailableScoutCommands(
        const Coords unitLocation = unit->location();

        if (costForScout.IsPossible(remainingActionPoints)) {
-            for (int distance = 1; distance <= scoutRange; ++distance) {
+            for (int distance = 1; distance <= scoutRange; distance++) {
                CoordsSet coordsSet = TilesWithExactDistance(hexMap, unitLocation, distance);

                for (const Coords& scoutCoords : coordsSet) {
@@ -46,13 +46,13 @@ public:

    ~ArcheryCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::ARCHERY_COMMAND;
    }

    auto CanUseClientRoll() const -> bool override { return true; }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] int GetActorUnitId() const override { return attackerId; }
    [[nodiscard]] MapIndex GetTargetRow() const override { return defenderLocation.row(); }
@@ -32,11 +32,11 @@ public:

    ~ControlCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::CONTROL_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;
    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return false; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWhileStunned() const -> bool override { return false; }
@@ -41,11 +41,11 @@ public:
    [[nodiscard]] auto ExecuteWithRoll(const GameStateW& currentState, double roll) const
            -> vector<ActionResult>;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::DISMISS_UNIT_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;
    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return false; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWhileStunned() const -> bool override { return false; }
@@ -75,7 +75,7 @@ auto EndTurnCommand::InternalExecute(
    // Any heroes in fire get burninated
    // Decrement stun counters, increment cast state
    const auto beforeFireUnitsCount = runningGameState->units()->size();
-    for (size_t i = 0; i < beforeFireUnitsCount; ++i) {
+    for (size_t i = 0; i < beforeFireUnitsCount; i++) {
        const auto *beforeUnit = runningGameState->units()->Get(static_cast<unsigned int>(i));
        if (beforeUnit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT)
            continue;
@@ -114,7 +114,7 @@ auto EndTurnCommand::InternalExecute(
    endTurnResult.mutable_next_player()->set_value(NextPlayerId(currentState, GetPlayerId()));

    const auto unitsAtEndOfRoundCount = runningGameState->units()->size();
-    for (size_t i = 0; i < unitsAtEndOfRoundCount; ++i) {
+    for (size_t i = 0; i < unitsAtEndOfRoundCount; i++) {
        //  Grab the unit fresh because it might have been modified by a previous iteration of the
        //  loop
        const auto *eorUnit = runningGameState->units()->Get(static_cast<unsigned int>(i));
@@ -85,7 +85,7 @@ auto FearCommand::GetFearOdds(
        double attackerWisdom,
        const double defenderCharisma) -> PercentileRollOdds {
    const std::array otherFactors = {
-            MakeOtherFactor(static_cast<int>(50.0 - defenderCharisma), opponentCharismaString)};
+            MakeOtherFactor(int(50.0 - defenderCharisma), opponentCharismaString)};
    return MakeOdds(
            fearBaseOdds,
            0,
@@ -31,11 +31,11 @@ public:
            int agilityXp,
            int professionKnowledgeBump);

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::FORTIFY_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] int GetActorUnitId() const override { return fortifyingUnitId; }
 };
@@ -37,7 +37,7 @@ public:
        return net::eagle0::shardok::common::HIDE_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] int GetActorUnitId() const override { return actorId; }
    [[nodiscard]] MapIndex GetTargetRow() const override { return target.row(); }
@@ -143,9 +143,8 @@ auto HolyWaveInspireAction::InternalExecute(

    resultProto.set_type(net::eagle0::shardok::common::INSPIRED_TROOPS);

-    float newMorale = moraleBefore + static_cast<float>(inspireBuf);
-    float moraleCap =
-            inspiredUnit->battalion().base_morale() + static_cast<float>(maxInspireOverBase);
+    float newMorale = moraleBefore + float(inspireBuf);
+    float moraleCap = inspiredUnit->battalion().base_morale() + float(maxInspireOverBase);
    if (moraleCap < newMorale) newMorale = moraleCap;
    if (newMorale > 100) newMorale = 100;

@@ -51,11 +51,11 @@ public:

    ~MeleeCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::MELEE_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    auto CanUseClientRoll() const -> bool override { return true; }

@@ -33,11 +33,11 @@ public:

    ~MeteorCancelCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::METEOR_CANCEL_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;
    [[nodiscard]] auto IsRequiredToEndTurn() const -> bool override { return requiredToEndTurn; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWithLowVigor() const -> bool override { return true; }
@@ -33,11 +33,11 @@ public:
            const CoordsSet& nextRoundTargets);
    ~MeteorStartCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::METEOR_START_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] int GetActorUnitId() const override { return casterId; }
 };
@@ -38,11 +38,11 @@ public:

    ~MeteorTargetCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::METEOR_TARGET_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;
    [[nodiscard]] auto IsRequiredToEndTurn() const -> bool override { return requiredToEndTurn; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWithLowVigor() const -> bool override { return true; }
@@ -135,8 +135,9 @@ auto shardok::MoveCommand::InternalExecute(
                        KnownAdjacentEnemies(player, allUnits, map, allyPids, destination);

                for (const Unit* possibleChargee : newAdjacentEnemies) {
-                    if (std::ranges::find_if(
-                                knownAdjacentEnemies,
+                    if (std::find_if(
+                                knownAdjacentEnemies.begin(),
+                                knownAdjacentEnemies.end(),
                                [possibleChargee](const Unit* adj) {
                                    return adj->unit_id() == possibleChargee->unit_id();
                                }) == knownAdjacentEnemies.end()) {
@@ -109,7 +109,7 @@ auto GetNewUnit(
    unit.mutate_player_id(playerId);
    unit.mutate_commanding_unit_id(commandingUnitId);

-    for (uint32_t i = 0; i < unit.opponent_knowledge()->size(); ++i) {
+    for (uint32_t i = 0; i < unit.opponent_knowledge()->size(); i++) {
        unit.mutable_opponent_knowledge()->Mutate(i, 0);
    }

@@ -46,11 +46,11 @@ public:

    ~ReinforceCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::REINFORCE_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] auto IsRequiredToEndTurn() const -> bool override { return false; }
    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return true; }
@@ -34,7 +34,7 @@ public:
        return net::eagle0::shardok::common::RELEASE_UNIT_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;
    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return false; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWhileStunned() const -> bool override { return false; }
@@ -57,7 +57,7 @@ public:
        return net::eagle0::shardok::common::REPAIR_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] auto IsRequiredToEndTurn() const -> bool override { return false; }
    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return true; }
@@ -55,11 +55,11 @@ public:
    [[nodiscard]] auto ExecuteWithRoll(const GameStateW& currentState, double roll) const
            -> vector<ActionResult>;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::SCOUT_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return false; }
@@ -43,11 +43,11 @@ public:

    ~StartFireCommand() override = default;

-    [[nodiscard]] auto GetCommandType() const -> CommandType override {
+    auto GetCommandType() const -> CommandType override {
        return net::eagle0::shardok::common::START_FIRE_COMMAND;
    }

-    [[nodiscard]] auto GetCommandProto() const -> CommandProto override;
+    auto GetCommandProto() const -> CommandProto override;

    [[nodiscard]] auto CanBeFollowUp() const -> bool override { return true; }
    [[nodiscard]] auto CanDoWithLowMorale() const -> bool override { return false; }
@@ -47,7 +47,7 @@ auto GetAcceptOdds(

    double baseDeadliness = settings.Backing().base_deadliness();

-    for (int i = 0; i < NUM_RUNS; ++i) {
+    for (int i = 0; i < NUM_RUNS; i++) {
        double defenderRoll;
        if (statsKnown) {
            defenderRoll = i * 100.0 / (NUM_RUNS - 1);
@@ -114,7 +114,7 @@ auto GetAcceptOdds(

    Hero defendingHero = defender->attached_hero();
    defenderWins = 0;
-    for (int i = 0; i < NUM_RUNS; ++i) {
+    for (int i = 0; i < NUM_RUNS; i++) {
        double defenderRoll;
        if (heroStatsKnown) {
            defenderRoll = i * 100.0 / (NUM_RUNS - 1);
@@ -141,7 +141,7 @@ public:
            return Wrapper();  // Return empty wrapper for invalid data
        }

-        size_t offset = 0;
+        size_t offset;
        std::memcpy(&offset, str.data(), sizeof(size_t));

        size_t size = str.size() - sizeof(size_t);
@@ -159,7 +159,7 @@ public:
            return Wrapper();  // Return empty wrapper for invalid data
        }

-        size_t offset = 0;
+        size_t offset;
        std::memcpy(&offset, bv.data(), sizeof(size_t));

        size_t size = bv.size() - sizeof(size_t);
@@ -46,15 +46,15 @@ auto ConvertVictoryCondition(const net::eagle0::shardok::common::VictoryConditio

 auto FromPlayerInfoProto(flatbuffers::FlatBufferBuilder& fbb, const PlayerInfoProto& piProto)
        -> flatbuffers::Offset<net::eagle0::shardok::storage::fb::PlayerInfo> {
-    std::vector<AlliedPlayer> alliesVec;
+    auto alliesVec = std::vector<AlliedPlayer>();
    alliesVec.reserve(piProto.allies_size());
    for (const auto& apProto : piProto.allies()) { alliesVec.emplace_back(apProto.player_id()); }
    const auto alliesOffset = fbb.CreateVectorOfStructs(alliesVec);

-    std::vector<int8_t> vcVec;
+    auto vcVec = std::vector<int8_t>();
    const int victoryConditionCount = piProto.victory_conditions_size();
    vcVec.reserve(victoryConditionCount);
-    for (int i = 0; i < victoryConditionCount; ++i) {
+    for (int i = 0; i < victoryConditionCount; i++) {
        vcVec.push_back(ConvertVictoryCondition(piProto.victory_conditions(i)));
    }
    const auto vcOffset = fbb.CreateVector(vcVec);
@@ -142,7 +142,7 @@ auto SetupInitialGameState(
            &endGameCondition);
    auto gameIdOffset = fbb.CreateString(gameId);

-    std::vector<Offset<PlayerInfo>> playerInfoVec;
+    auto playerInfoVec = std::vector<Offset<PlayerInfo>>();
    playerInfoVec.reserve(playerInfoProtos.size());
    for (const auto& piProto : playerInfoProtos) {
        playerInfoVec.push_back(FromPlayerInfoProto(fbb, piProto));
@@ -162,7 +162,7 @@ auto SetupInitialGameState(
    // Add slack units: 3 per necromancer, minimum 5 for general use
    const int slackUnits = std::max(5, necromancerCount * 3);

-    std::vector<Unit> unitsVec;
+    auto unitsVec = std::vector<Unit>();
    unitsVec.reserve(units.size() + slackUnits);
    for (const auto& unit : units) {
        Unit modifiedUnit = unit;
@@ -191,7 +191,7 @@ auto SetupInitialGameState(
    }

    // Add slack units for future expansion (e.g., necromancer raise dead)
-    for (int i = 0; i < slackUnits; ++i) {
+    for (int i = 0; i < slackUnits; i++) {
        Unit slackUnit;
        slackUnit.mutate_unit_id(static_cast<int16_t>(units.size() + i));
        slackUnit.mutate_status(net::eagle0::shardok::storage::fb::UnitStatus_RESERVED_SLOT);
@@ -28,7 +28,7 @@ using net::eagle0::shardok::storage::fb::Unit;
 using Weather = net::eagle0::shardok::storage::fb::Weather;
 using GameStatusProto = net::eagle0::shardok::common::GameStatus;

-[[nodiscard]] auto SetupInitialGameState(
+auto SetupInitialGameState(
        const GameId& gameId,
        const HexMapProto& hexMapProto,
        const std::vector<PlayerInfoProto>& playerInfoProtos,
@@ -37,14 +37,14 @@ using GameStatusProto = net::eagle0::shardok::common::GameStatus;
        bool isWinter,
        const SettingsGetter& settings) -> GameStateW;

-[[nodiscard]] auto FromPlayerInfoProto(
+auto FromPlayerInfoProto(
        flatbuffers::FlatBufferBuilder& fbb,
        const PlayerInfoProto& playerInfoProto)
        -> flatbuffers::Offset<net::eagle0::shardok::storage::fb::PlayerInfo>;

-[[nodiscard]] auto ToPlayerInfoProto(const PlayerInfo* fbPI) -> PlayerInfoProto;
-[[nodiscard]] auto ToWeatherProto(const Weather* fbW) -> net::eagle0::shardok::common::Weather;
-[[nodiscard]] auto ToProto(const GameStatus* fbStatus) -> GameStatusProto;
+auto ToPlayerInfoProto(const PlayerInfo* fbPI) -> PlayerInfoProto;
+auto ToWeatherProto(const Weather* fbW) -> net::eagle0::shardok::common::Weather;
+auto ToProto(const GameStatus* fbStatus) -> GameStatusProto;

 }  // namespace shardok::fb

@@ -22,15 +22,15 @@ using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 using HexMapW = Wrapper<HexMap>;
 using HexMapProto = net::eagle0::shardok::common::HexMap;

-[[nodiscard]] auto ConvertHexMapProto(
+auto ConvertHexMapProto(
        FlatBufferBuilder& fbb,
        const net::eagle0::shardok::common::HexMap& mapProto,
        bool isWinter = false,
        float initialWinterIceIntegrity = 0.0f) -> Offset<HexMap>;

-[[nodiscard]] auto ToProto(const HexMap* hexMap) -> HexMapProto;
+auto ToProto(const HexMap* hexMap) -> HexMapProto;

-[[nodiscard]] auto CopyHexMap(const HexMap* hexMap) -> HexMapW;
+auto CopyHexMap(const HexMap* hexMap) -> HexMapW;

 }  // namespace shardok::fb

@@ -16,7 +16,7 @@ namespace shardok::fb {
 using Terrain = net::eagle0::shardok::storage::fb::Terrain;
 using TerrainProto = net::eagle0::shardok::common::Terrain;

-[[nodiscard]] auto ToTerrainProto(const Terrain* terrain) -> TerrainProto;
+auto ToTerrainProto(const Terrain* terrain) -> TerrainProto;

 }  // namespace shardok::fb

@@ -16,7 +16,7 @@ namespace shardok::fb {
 using TileModifier = net::eagle0::shardok::storage::fb::TileModifier;
 using TileModifierProto = net::eagle0::shardok::common::TileModifier;

-[[nodiscard]] auto ToTileModifierProto(const TileModifier& tileModifier) -> TileModifierProto;
+auto ToTileModifierProto(const TileModifier& tileModifier) -> TileModifierProto;

 }  // namespace shardok::fb

@@ -23,12 +23,10 @@ namespace shardok {
 using Coords = net::eagle0::shardok::storage::fb::Coords;
 using CoordsProto = net::eagle0::shardok::common::Coords;

-[[nodiscard]] auto MakeCoordsProto(int row, int column) -> net::eagle0::shardok::common::Coords;
+auto MakeCoordsProto(int row, int column) -> net::eagle0::shardok::common::Coords;

-[[nodiscard]] static inline auto IsUnplaced(const Coords &c) -> bool {
-    return c.row() < 0 || c.column() < 0;
-}
-[[nodiscard]] static inline auto IsUnplaced(const CoordsProto &c) -> bool {
+static inline auto IsUnplaced(const Coords &c) -> bool { return c.row() < 0 || c.column() < 0; }
+static inline auto IsUnplaced(const CoordsProto &c) -> bool {
    return c.row() < 0 || c.column() < 0;
 }

@@ -43,15 +41,14 @@ using CoordsProto = net::eagle0::shardok::common::Coords;
 }  // namespace shardok

 namespace net::eagle0::shardok::storage::fb {
-[[nodiscard]] auto operator==(const Coords &lhs, const net::eagle0::shardok::common::Coords &rhs)
-        -> bool;
+auto operator==(const Coords &lhs, const net::eagle0::shardok::common::Coords &rhs) -> bool;
 }

 namespace net::eagle0::shardok::common {
-[[nodiscard]] auto operator==(
+auto operator==(
        const net::eagle0::shardok::common::Coords &lhs,
        const net::eagle0::shardok::common::Coords &rhs) -> bool;
-[[nodiscard]] auto operator==(
+auto operator==(
        const net::eagle0::shardok::common::Coords &lhs,
        const net::eagle0::shardok::storage::fb::Coords &rhs) -> bool;
 }  // namespace net::eagle0::shardok::common
@@ -59,7 +56,7 @@ namespace net::eagle0::shardok::common {
 namespace std {
 template<>
 struct hash<net::eagle0::shardok::common::Coords> {
-    [[nodiscard]] auto operator()(const net::eagle0::shardok::common::Coords &c) const -> size_t {
+    auto operator()(const net::eagle0::shardok::common::Coords &c) const -> size_t {
        return size_t(c.row() << 16 | c.column());
    }
 };
@@ -19,7 +19,7 @@ namespace shardok {

 constexpr bool kCoordsSetIndexChecks = false;

-constexpr size_t STANDARD_SIZE = size_t{12} * 14;
+constexpr size_t STANDARD_SIZE = 12 * 14;

 using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 using BackingBitset = common::IterableBitset<168>;
@@ -34,7 +34,7 @@ private:
    uint32_t indexCount;

    [[nodiscard]] auto Index(const int row, const int column) const -> int {
-        return (row * mapWidth) + column;
+        return row * mapWidth + column;
    }

    [[nodiscard]] auto Index(const Coords& c) const -> int { return Index(c.row(), c.column()); }
@@ -137,7 +137,7 @@ public:
    }

    void Filter(const std::function<bool(int, int)>& f) {
-        for (uint32_t i = 0; i < indexCount; ++i) {
+        for (uint32_t i = 0; i < indexCount; i++) {
            if (Contains(i) && !f(i / mapWidth, i % mapWidth)) { Remove(i); }
        }
    }
@@ -41,11 +41,11 @@ inline HexMapDirection& operator++(HexMapDirection& dir) {
 }

 struct HexMapDirectionsTo {
-    HexMapDirection main{};
-    HexMapDirection secondary{};  // Only valid if exactly on the line
-    bool usesSecondary{};
+    HexMapDirection main;
+    HexMapDirection secondary;  // Only valid if exactly on the line
+    bool usesSecondary;

-    bool Matches(const HexMapDirection dir) const {
+    bool Matches(const HexMapDirection dir) {
        return dir == main || (usesSecondary && dir == secondary);
    }
 };
@@ -13,13 +13,13 @@
 namespace shardok {
 using HexMap = net::eagle0::shardok::storage::fb::HexMap;

-[[nodiscard]] auto GetModifierHash(const HexMap* map) -> uint64_t;
+auto GetModifierHash(const HexMap* map) -> uint64_t;

 // Helper function to compute modifier byte for consistent hashing
 // Excludes ice from hash since AI pathfinding should ignore ice
 // Compact bit layout: bridge=bit0, fire=bit1, snow=bit2
 template<typename TileModifier>
-[[nodiscard]] auto ComputeModifierByte(const TileModifier& modifier) -> int8_t {
+auto ComputeModifierByte(const TileModifier& modifier) -> int8_t {
    return static_cast<int8_t>(
            modifier.bridge().present() | modifier.fire().present() << 1 |
            modifier.snow().present() << 2);
@@ -27,7 +27,7 @@ template<typename TileModifier>

 // Overload for protobuf modifier
 template<typename ProtoModifier>
-[[nodiscard]] auto ComputeModifierByteProto(const ProtoModifier& modifier) -> int8_t {
+auto ComputeModifierByteProto(const ProtoModifier& modifier) -> int8_t {
    return static_cast<int8_t>(
            modifier.has_bridge() | modifier.has_fire() << 1 | modifier.has_snow() << 2);
 }
@@ -34,25 +34,23 @@ using TerrainType::Terrain_Type_UNKNOWN;

 constexpr int kTerrainTypeCount = net::eagle0::shardok::common::Terrain_Type_Type_ARRAYSIZE;

-[[nodiscard]] auto AllowsHiding(const Terrain* terrain) -> bool;
-[[nodiscard]] auto AllowsHiding(net::eagle0::shardok::storage::fb::Terrain_::Type type) -> bool;
-[[nodiscard]] auto AllowsHiding(const net::eagle0::shardok::storage::fb::TileModifier& modifier)
-        -> bool;
+auto AllowsHiding(const Terrain* terrain) -> bool;
+auto AllowsHiding(net::eagle0::shardok::storage::fb::Terrain_::Type type) -> bool;
+auto AllowsHiding(const net::eagle0::shardok::storage::fb::TileModifier& modifier) -> bool;

-[[nodiscard]] auto AllowsHiding(const TerrainProto& terrain) -> bool;
-[[nodiscard]] auto AllowsHiding(TerrainType type) -> bool;
-[[nodiscard]] auto AllowsHiding(const TileModifierProto& modifier) -> bool;
+auto AllowsHiding(const TerrainProto& terrain) -> bool;
+auto AllowsHiding(TerrainType type) -> bool;
+auto AllowsHiding(const TileModifierProto& modifier) -> bool;

-[[nodiscard]] auto AllowsFortification(const Terrain* terrain) -> bool;
+auto AllowsFortification(const Terrain* terrain) -> bool;

-[[nodiscard]] auto IsWater(net::eagle0::shardok::storage::fb::Terrain_::Type type) -> bool;
-[[nodiscard]] auto IsWater(TerrainType type) -> bool;
+auto IsWater(net::eagle0::shardok::storage::fb::Terrain_::Type type) -> bool;
+auto IsWater(TerrainType type) -> bool;

-[[nodiscard]] auto IsTraversible(const net::eagle0::shardok::storage::fb::Terrain& terrain) -> bool;
+auto IsTraversible(const net::eagle0::shardok::storage::fb::Terrain& terrain) -> bool;

-[[nodiscard]] auto MakeHexMapTerrain(TerrainType tp, TileModifierProto mod = TileModifierProto())
-        -> TerrainProto;
-[[nodiscard]] auto MakeHexMapTerrain(
+auto MakeHexMapTerrain(TerrainType tp, TileModifierProto mod = TileModifierProto()) -> TerrainProto;
+auto MakeHexMapTerrain(
        net::eagle0::shardok::storage::fb::Terrain_::Type tp,
        const net::eagle0::shardok::storage::fb::TileModifier& mod =
                net::eagle0::shardok::storage::fb::TileModifier()) -> Terrain;
@@ -23,9 +23,9 @@ namespace shardok {
 using SingleModifier = net::eagle0::shardok::common::TileModifier_SingleModifier;
 using TileModifierProto = net::eagle0::shardok::common::TileModifier;

-SingleModifier MakeSingleModifier(const std::optional<double>& integ = std::nullopt);
+SingleModifier MakeSingleModifier(const std::optional<double>& integ = std::optional<double>());

-[[nodiscard]] bool operator==(const SingleModifier& lhs, const SingleModifier& rhs);
+bool operator==(const SingleModifier& lhs, const SingleModifier& rhs);

 TileModifierProto MakeTileModifier(bool onFire = false);

@@ -12,10 +12,10 @@
 namespace shardok {
 using TileModifierWithCoords = net::eagle0::shardok::common::TileModifierWithCoords;

-[[nodiscard]] auto MakeTmc(const Coords &coordinates, const TileModifierProto &modifier)
+auto MakeTmc(const Coords &coordinates, const TileModifierProto &modifier)
        -> TileModifierWithCoords;

-[[nodiscard]] auto MakeTmc(
+auto MakeTmc(
        const Coords &coordinates,
        const net::eagle0::shardok::storage::fb::TileModifier &modifier) -> TileModifierWithCoords;

@@ -76,7 +76,7 @@ public:
            return settings.backingStruct;
        }

-        [[nodiscard]] auto GetRandomGenerator() const -> std::shared_ptr<RandomGenerator> {
+        [[nodiscard]] auto GetRandomGenerator() const -> const std::shared_ptr<RandomGenerator> {
            return settings.randomGenerator;
        }

@@ -130,7 +130,7 @@ int32_t MutatingInternalTakeDamage(

    double takenDamage = 0.0;

-    for (int i = 0; i < NUM_DAMAGE_TYPES; ++i) {
+    for (int i = 0; i < NUM_DAMAGE_TYPES; i++) {
        const auto damageType = static_cast<DamageType>(i);
        const double armamentAdjustment =
                1.0 - ((type->baseResistanceByType[i] +
@@ -52,7 +52,7 @@ auto MutatingTakeDamage(
    const CombatDamage heroDamage = heroDamageRatio * damage;

    double vigorHit = 0.0;
-    for (int i = 0; i < NUM_DAMAGE_TYPES; ++i) {
+    for (int i = 0; i < NUM_DAMAGE_TYPES; i++) {
        vigorHit += heroDamage.GetNormalDamageOfType(DamageType(i)) * kHeroMortalityFactor;
        vigorHit += heroDamage.GetPenetratingDamageOfType(DamageType(i)) * kHeroMortalityFactor;
        // TODO: hero should have adjustments for damage types too
@@ -45,7 +45,7 @@ auto OpponentKnowledge(const Unit &unit, const PlayerId toPlayer) -> int {
    if (toPlayer == -1) {
        // handle observer, with pid -1
        int8_t max = 0;
-        for (uint32_t i = 0; i < unit.opponent_knowledge()->size(); ++i) {
+        for (uint32_t i = 0; i < unit.opponent_knowledge()->size(); i++) {
            max = std::max(max, unit.opponent_knowledge()->Get(i));
        }
        return max;
@@ -59,7 +59,7 @@ auto OpponentKnowledge(const Unit *unit, const PlayerId toPlayer) -> int {
    if (toPlayer == -1) {
        // handle observer, with pid -1
        int8_t max = 0;
-        for (uint32_t i = 0; i < unit->opponent_knowledge()->size(); ++i) {
+        for (uint32_t i = 0; i < unit->opponent_knowledge()->size(); i++) {
            max = std::max(max, unit->opponent_knowledge()->Get(i));
        }
        return max;
@@ -190,7 +190,7 @@ void MutatingBumpOpponentKnowledge(Unit *unit, const PlayerId pid, const int bum

 void MutatingBumpAllKnowledgeToMinimum(Unit *unit, const int minimum) {
    const auto current = unit->opponent_knowledge();
-    for (uint32_t i = 0; i < current->size(); ++i) {
+    for (uint32_t i = 0; i < current->size(); i++) {
        if (current->Get(i) < minimum) { unit->mutable_opponent_knowledge()->Mutate(i, minimum); }
    }
 }
@@ -220,7 +220,7 @@ auto InternalTakeDamageFb(
        CombatDamage heroDamage = heroDamageRatio * totalDamage;

        double vigorHit = 0.0;
-        for (int i = 0; i < NUM_DAMAGE_TYPES; ++i) {
+        for (int i = 0; i < NUM_DAMAGE_TYPES; i++) {
            const auto damageType = static_cast<DamageType>(i);
            vigorHit += heroDamage.GetNormalDamageOfType(damageType) * heroMortalityFactor;
            vigorHit += heroDamage.GetPenetratingDamageOfType(damageType) * heroMortalityFactor;
@@ -237,7 +237,7 @@ auto InternalTakeDamageFb(
    double takenDamage = 0.0;
    double terrainAdjustment = battalionType->GetDamageTakenMultiplierForTerrain(&terrain);

-    for (int i = 0; i < NUM_DAMAGE_TYPES; ++i) {
+    for (int i = 0; i < NUM_DAMAGE_TYPES; i++) {
        const auto damageType = static_cast<DamageType>(i);
        double armamentAdjustment = 1.0 - (battalionType->baseResistanceByType[i] +
                                           (battalion.armament() / 100.0) *
@@ -22,12 +22,12 @@ namespace shardok {
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 using Units = flatbuffers::Vector<const Unit *>;

-[[nodiscard]] auto IsDestroyed(const Unit &unit) -> bool;
+auto IsDestroyed(const Unit &unit) -> bool;

-[[nodiscard]] auto MaxActionPoints(const Unit &unit) -> ActionPoints;
+auto MaxActionPoints(const Unit &unit) -> ActionPoints;

-[[nodiscard]] auto OpponentKnowledge(const Unit &unit, PlayerId toPlayer) -> int;
-[[nodiscard]] auto OpponentKnowledge(const Unit *unit, PlayerId toPlayer) -> int;
+auto OpponentKnowledge(const Unit &unit, PlayerId toPlayer) -> int;
+auto OpponentKnowledge(const Unit *unit, PlayerId toPlayer) -> int;

 // Returns the casualty count.
 auto MutatingApplyDamageFrom(
@@ -50,7 +50,7 @@ auto MutatingApplyEnvironmentalDamage(
        double baseDeadliness,
        const BattalionTypeSPtr &type) -> int32_t;

-[[nodiscard]] auto WithTakenDamageFb(
+auto WithTakenDamageFb(
        const Unit *victim,
        const CombatDamage &amount,
        const Terrain &terrain,
@@ -71,10 +71,8 @@ void MutatingBumpCharismaXp(Unit *unit, int newXp);
 void MutatingBumpOpponentKnowledge(Unit *unit, PlayerId pid, int bump);
 void MutatingBumpAllKnowledgeToMinimum(Unit *unit, int bump);

-[[nodiscard]] auto ReserveUnitsForPlayer(const Units *units, PlayerId pid)
-        -> std::map<UnitId, const Unit *>;
-[[nodiscard]] auto PlacedUnitsForPlayer(const Units *units, PlayerId pid)
-        -> std::map<UnitId, const Unit *>;
+auto ReserveUnitsForPlayer(const Units *units, PlayerId pid) -> std::map<UnitId, const Unit *>;
+auto PlacedUnitsForPlayer(const Units *units, PlayerId pid) -> std::map<UnitId, const Unit *>;

 }  // namespace shardok

--- a/Show More
+++ b/Show More