Use prefabs for remaining Handle Riot panels

* Stop resizing March recommended button

* Preserve March recommended button prefab height

.bazelrc

@@ -14,6 +14,7 @@ common --worker_sandboxing
 common --local_test_jobs=64
 common --jobs=64
 
+# Keep these C++ standard flags in sync with tools/copts.bzl and scripts/shardok_cpp_config.sh.
 common --cxxopt="--std=c++23"
 common --cxxopt="-Wno-deprecated-non-prototype"
 common --per_file_copt=src/test/cpp/.*@-Wno-character-conversion
@@ -37,6 +38,8 @@ build:ubsan --strip=never
 build:ubsan --copt=-fno-omit-frame-pointer
 build:ubsan --copt=-Wno-macro-redefined
 build:ubsan --copt=-fsanitize=undefined
+# Protobuf's arena implementation trips UBSan alignment checks in external code on macOS.
+build:ubsan --copt=-fno-sanitize=alignment
 build:ubsan --linkopt=-fsanitize=undefined
 test:ubsan --test_env=UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1
 

.clang-tidy

@@ -2,25 +2,17 @@ Checks: >
   -*,
   bugprone-*,
   performance-*,
-  readability-*,
-  modernize-*,
-  cppcoreguidelines-*,
+  modernize-use-nullptr,
+  modernize-use-override,
+  modernize-use-auto,
+  modernize-use-nodiscard,
+  readability-braces-around-statements,
+  readability-qualified-auto,
+  readability-redundant-member-init,
+  cppcoreguidelines-pro-type-cstyle-cast,
   -bugprone-easily-swappable-parameters,
-  -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-macro-usage,
-  -cppcoreguidelines-owning-memory,
-  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-  -cppcoreguidelines-pro-bounds-constant-array-index,
-  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-  -cppcoreguidelines-pro-type-const-cast,
-  -cppcoreguidelines-pro-type-reinterpret-cast,
-  -cppcoreguidelines-pro-type-union-access,
-  -cppcoreguidelines-pro-type-vararg,
-  -modernize-use-trailing-return-type,
-  -readability-convert-member-functions-to-static,
-  -readability-function-cognitive-complexity,
-  -readability-identifier-length,
-  -readability-magic-numbers
+  -bugprone-branch-clone,
+  -bugprone-signed-char-misuse
 WarningsAsErrors: ''
 HeaderFilterRegex: 'src/(main|test)/cpp/net/eagle0/(shardok|common)/.*'
 FormatStyle: file

.github/workflows/bazel_test.yml

@@ -12,6 +12,9 @@ on:
       - '.bazelrc'
       - 'ci/github_actions/ensure_bazel_installed.sh'
       - 'ci/github_actions/summarize_bazel_bep.py'
+      - '.clang-tidy'
+      - 'scripts/run-clang-tidy.sh'
+      - 'scripts/check_shardok_clang_tidy.sh'
       - '.github/actions/setup-bazel/**'
       - '.github/workflows/bazel_test.yml'
       - '!src/main/csharp/**'
@@ -26,6 +29,9 @@ on:
       - '.bazelrc'
       - 'ci/github_actions/ensure_bazel_installed.sh'
       - 'ci/github_actions/summarize_bazel_bep.py'
+      - '.clang-tidy'
+      - 'scripts/run-clang-tidy.sh'
+      - 'scripts/check_shardok_clang_tidy.sh'
       - '.github/actions/setup-bazel/**'
       - '.github/workflows/bazel_test.yml'
       - '!src/main/csharp/**'
@@ -78,6 +84,8 @@ jobs:
         node-version: 'lts/*'
     - name: Check JavaScript syntax
       run: node --check src/main/go/net/eagle0/admin_server/static/map_editor.js
+    - name: Check Shardok clang-tidy gate
+      run: ./scripts/check_shardok_clang_tidy.sh
 
   test:
     runs-on: [self-hosted, bazel]

.github/workflows/shardok_sanitizer_test.yml

@@ -0,0 +1,92 @@
+name: Shardok Sanitizer Test
+
+on:
+  push:
+    branches: ["main"]
+    paths:
+      - "src/main/cpp/net/eagle0/shardok/**"
+      - "src/test/cpp/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/common/**"
+      - "WORKSPACE"
+      - "MODULE.bazel"
+      - "MODULE.bazel.lock"
+      - "BUILD.bazel"
+      - ".bazelrc"
+      - ".github/actions/setup-bazel/**"
+      - ".github/workflows/shardok_sanitizer_test.yml"
+      - "ci/github_actions/ensure_bazel_installed.sh"
+      - "ci/github_actions/summarize_bazel_bep.py"
+  pull_request:
+    paths:
+      - "src/main/cpp/net/eagle0/shardok/**"
+      - "src/test/cpp/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/common/**"
+      - "WORKSPACE"
+      - "MODULE.bazel"
+      - "MODULE.bazel.lock"
+      - "BUILD.bazel"
+      - ".bazelrc"
+      - ".github/actions/setup-bazel/**"
+      - ".github/workflows/shardok_sanitizer_test.yml"
+      - "ci/github_actions/ensure_bazel_installed.sh"
+      - "ci/github_actions/summarize_bazel_bep.py"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  shardok-sanitizer-test:
+    name: Shardok ${{ matrix.name }}
+    runs-on: [self-hosted, bazel]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: ASan
+            config: asan
+          - name: UBSan
+            config: ubsan
+
+    steps:
+      - name: Ensure Git LFS available for checkout
+        run: |
+          COMMON_PATHS=(/opt/homebrew/bin /usr/local/bin)
+          for path in "${COMMON_PATHS[@]}"; do
+            if [ -d "$path" ]; then
+              echo "$path" >> "$GITHUB_PATH"
+              export PATH="$path:$PATH"
+            fi
+          done
+
+          if command -v git-lfs >/dev/null 2>&1; then
+            git-lfs version
+            exit 0
+          fi
+
+          brew install git-lfs
+          git-lfs version
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+          lfs: false
+      - name: Setup Bazel
+        uses: ./.github/actions/setup-bazel
+      - name: Run Shardok sanitizer tests
+        run: bazel test --config=${{ matrix.config }} --build_event_json_file=${{ matrix.config }}.json //src/test/cpp/net/eagle0/shardok/...
+      - name: Summarize Bazel build metrics
+        if: always()
+        run: python3 ci/github_actions/summarize_bazel_bep.py ${{ matrix.config }}.json
+      - name: Archive sanitizer test results
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: shardok-${{ matrix.config }}.json
+          path: ${{ matrix.config }}.json
+          retention-days: 3

AGENTS.md

@@ -11,6 +11,11 @@
 **NEVER kill Unity without asking the user first.** The user might be actively using the Unity Editor. Do not kill,
 force-quit, terminate, or otherwise stop Unity processes unless the user explicitly approves that specific action.
 
+**NEVER change Unity's default/open scene as part of running checks.** Unity batchmode or editor validation may write
+scene-selection churn such as `ProjectSettings/EditorBuildSettings.asset`, `ProjectSettings/SceneTemplateSettings.json`,
+or scene files simply because a different scene was open or loaded. Treat those as unintended local environment changes:
+do not stage them, and restore them before committing unless the user explicitly asked to change scenes/build settings.
+
 ## CRITICAL GIT RULES (NEVER VIOLATE)
 
 **NEVER use `git -C`.** Just run `git` directly from the cwd — it finds the repo via `.git` discovery. Do not `cd` to the repo root either (see the no-`cd` bash rule above).

docs/LLM_MODEL_COMPARISON.md

@@ -71,7 +71,7 @@ LLM settings can be changed at runtime via the admin console:
 1. Navigate to Admin Console → Settings
 2. Change `LlmProvider` to select vendor (gemini, openai, claude)
 3. Change the corresponding model name setting:
-   - `GeminiModelName` (default: gemini-3.1-flash-lite-preview)
+   - `GeminiModelName` (default: gemini-3.1-flash-lite)
    - `OpenAiModelName` (default: gpt-4.1-mini)
    - `ClaudeModelName` (default: claude-3-5-haiku-20241022)
 

scripts/check_shardok_clang_tidy.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Runs the curated Shardok clang-tidy gate used by CI.
+#
+# This intentionally checks representative files instead of the whole C++ tree.
+# Keep this list low-noise; expand it as cleanup PRs make more areas tidy-clean.
+
+set -euo pipefail
+
+repo_root="$(git rev-parse --show-toplevel)"
+source "$repo_root/scripts/shardok_cpp_config.sh"
+
+files=(
+    "src/main/cpp/net/eagle0/shardok/library/ActionCost.hpp"
+    "src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp"
+)
+
+compiler_args=(
+    "-I$repo_root"
+    "$SHARDOK_CXX_STANDARD_ARG"
+)
+
+if command -v xcrun >/dev/null 2>&1; then
+    sdk_path="$(xcrun --show-sdk-path)"
+    compiler_args+=("-isysroot" "$sdk_path")
+fi
+
+"$repo_root/scripts/run-clang-tidy.sh" --verify-config
+
+"$repo_root/scripts/run-clang-tidy.sh" --quiet --warnings-as-errors="*" "${files[@]}" -- "${compiler_args[@]}"

scripts/notarize_submit.sh

@@ -32,23 +32,33 @@ echo "=== Creating ZIP for notarization: $ZIP_PATH ===" >&2
 ditto -c -k --keepParent "$APP_PATH" "$ZIP_PATH"
 
 echo "=== Submitting to Apple for notarization ===" >&2
+set +e
 SUBMIT_OUTPUT=$(xcrun notarytool submit "$ZIP_PATH" \
     --apple-id "$APPLE_ID" \
     --password "$APP_SPECIFIC_PASSWORD" \
     --team-id "$TEAM_ID" 2>&1)
+SUBMIT_STATUS=$?
+set -e
 
 echo "$SUBMIT_OUTPUT" >&2
 
+if [ "$SUBMIT_STATUS" -ne 0 ]; then
+    rm -f "$ZIP_PATH"
+    echo "ERROR: notarytool submit failed with exit code $SUBMIT_STATUS" >&2
+    exit "$SUBMIT_STATUS"
+fi
+
 # Extract submission ID
-SUBMISSION_ID=$(echo "$SUBMIT_OUTPUT" | grep "id:" | head -1 | awk '{print $2}')
+SUBMISSION_ID=$(echo "$SUBMIT_OUTPUT" | awk '/^[[:space:]]*id:/ {print $2; exit}')
 
 if [ -z "$SUBMISSION_ID" ]; then
+    rm -f "$ZIP_PATH"
     echo "ERROR: Failed to get submission ID" >&2
     exit 1
 fi
 
 # Clean up the zip
-rm "$ZIP_PATH"
+rm -f "$ZIP_PATH"
 
 echo "Submission ID: $SUBMISSION_ID" >&2
 

scripts/run-clang-tidy.sh

@@ -10,13 +10,14 @@ set -e
 export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
 
 repo_root="$(git rev-parse --show-toplevel)"
+source "$repo_root/scripts/shardok_cpp_config.sh"
 
 if [ "$#" -eq 0 ]; then
     echo "Usage: scripts/run-clang-tidy.sh [clang-tidy args] <files> [-- <compiler args>]"
     echo ""
     echo "Examples:"
     echo "  scripts/run-clang-tidy.sh --verify-config"
-    echo "  scripts/run-clang-tidy.sh src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp -- -I$repo_root -std=c++23"
+    echo "  scripts/run-clang-tidy.sh src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp -- -I$repo_root $SHARDOK_CXX_STANDARD_ARG"
     exit 2
 fi
 

scripts/shardok_cpp_config.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Shared C++ settings for shell scripts that invoke Shardok tooling outside Bazel.
+
+SHARDOK_CXX_STANDARD="c++23"
+SHARDOK_CXX_STANDARD_ARG="-std=${SHARDOK_CXX_STANDARD}"

src/main/cpp/net/eagle0/common/ByteHasher.hpp

@@ -28,7 +28,7 @@ static inline auto HashBuffer(const uint8_t* data, size_t size) -> uint64_t {
 
     // Process 8 bytes at a time
     while (data + 8 <= end) {
-        uint64_t word;
+        uint64_t word = 0;
         // Use memcpy to avoid alignment issues and let compiler optimize
         __builtin_memcpy(&word, data, sizeof(word));
         hash ^= word;

src/main/cpp/net/eagle0/common/IterableBitset.hpp

@@ -9,6 +9,7 @@
 #include <bit>
 #include <cstdint>
 #include <cstdlib>
+#include <iterator>
 
 #define ITERABLE_BITSET_INDEX_CHECKS false
 
@@ -104,9 +105,11 @@ public:
 
     class Iter {
     public:
+        using iterator_category = std::forward_iterator_tag;
+        using difference_type = std::ptrdiff_t;
         using value_type = size_t;
-        using pointer = size_t*;
-        using reference = size_t&;
+        using pointer = void;
+        using reference = size_t;
 
     private:
         size_t storeIndex;
@@ -142,13 +145,20 @@ public:
         auto operator!=(const Iter& rhs) const -> bool {
             return storeIndex != rhs.storeIndex || bitIndex != rhs.bitIndex;
         }
-        void operator++() {
+        auto operator++() -> Iter& {
             bitIndex++;
             if (bitIndex >= STORE_BITS) {
                 storeIndex++;
                 bitIndex = 0;
             }
             ToNext();
+            return *this;
+        }
+
+        auto operator++(int) -> Iter {
+            Iter previous = *this;
+            ++(*this);
+            return previous;
         }
 
         auto operator*() const -> size_t { return (storeIndex << BIT_SHIFT) + bitIndex; }

src/main/cpp/net/eagle0/common/RandomGenerator.cpp

@@ -8,7 +8,9 @@
 
 #include "RandomGenerator.hpp"
 
+#include <algorithm>
 #include <ctime>
+#include <stdexcept>
 
 constexpr double kOpenEndedHighThreshold = 95.0;
 constexpr double kOpenEndedLowThreshold = 5.0;
@@ -67,7 +69,8 @@ auto RandomGenerator::ReverseOpenEndedPercentile() -> double {
 }
 
 auto RandomGenerator::IntBetween(const int min, const int max) -> int {
-    return int(DoubleZeroToOne() * (max - min)) + min;
+    if (min >= max) { throw std::invalid_argument("random integer range must be non-empty"); }
+    return std::min(int(DoubleZeroToOne() * (max - min)) + min, max - 1);
 }
 
 auto RandomGenerator::IntBelow(const int max) -> int { return IntBetween(0, max); }
@@ -94,6 +97,7 @@ StdLibraryGenerator::StdLibraryGenerator(const std::mt19937_64::result_type seed
 }
 
 auto StdLibraryGenerator::IntBetween(const int min, const int max) -> int {
+    if (min >= max) { throw std::invalid_argument("random integer range must be non-empty"); }
     std::uniform_int_distribution<int> unifInt(min, max - 1);
     return unifInt(engine);
 }

src/main/cpp/net/eagle0/common/RandomGenerator.hpp

@@ -12,6 +12,7 @@
 #include <cstddef>
 #include <memory>
 #include <random>
+#include <stdexcept>
 #include <vector>
 
 class RandomGenerator;
@@ -41,6 +42,7 @@ public:
 
     template<class T>
     auto RandomElement(const std::vector<T>& vec) -> T {
+        if (vec.empty()) { throw std::invalid_argument("cannot choose from an empty vector"); }
         return vec.at(static_cast<std::size_t>(IntBelow(static_cast<int>(vec.size()))));
     }
 

src/main/cpp/net/eagle0/common/SequenceRandomGenerator.hpp

@@ -9,7 +9,9 @@
 #ifndef EAGLE0_COMMON_SEQUENCE_RANDOM_GENERATOR_HPP
 #define EAGLE0_COMMON_SEQUENCE_RANDOM_GENERATOR_HPP
 
+#include <cmath>
 #include <memory>
+#include <stdexcept>
 #include <utility>
 #include <vector>
 
@@ -29,14 +31,24 @@ private:
     size_t position = 0;
 
     auto DoubleZeroToOne() -> double override {
+        if (position >= sequence.size()) { position = 0; }
         const double nextVal = sequence.at(position);
         position++;
-        if (position >= sequence.size()) { position = 0; }
         return nextVal;
     }
 
 public:
-    explicit SequenceRandomGenerator(std::vector<double> s) : sequence(std::move(s)) {}
+    explicit SequenceRandomGenerator(std::vector<double> s) : sequence(std::move(s)) {
+        if (sequence.empty()) {
+            throw std::invalid_argument("sequence random generator requires at least one value");
+        }
+        for (const double value : sequence) {
+            if (!std::isfinite(value) || value < 0.0 || value > 1.0) {
+                throw std::invalid_argument(
+                        "sequence random generator values must be between 0 and 1");
+            }
+        }
+    }
     static auto WithSequence(const std::vector<double>& s)
             -> std::shared_ptr<SequenceRandomGenerator> {
         return std::make_shared<SequenceRandomGenerator>(s);

src/main/cpp/net/eagle0/common/UnitConversions.cpp

@@ -9,6 +9,7 @@ namespace shardok {
 using Coords = net::eagle0::shardok::storage::fb::Coords;
 
 constexpr double kDefaultMorale = 50.0;
+constexpr float kExplicitMoraleSentinel = -1.0f;
 
 auto ConvertBattalion(const net::eagle0::common::CommonBattalion &battalion) -> Battalion {
     Battalion shardokBattalion{};
@@ -18,6 +19,10 @@ auto ConvertBattalion(const net::eagle0::common::CommonBattalion &battalion) ->
     shardokBattalion.mutate_type(
             static_cast<net::eagle0::shardok::storage::fb::BattalionTypeId>(battalion.type()));
     shardokBattalion.mutate_morale(kDefaultMorale);
+    if (battalion.has_morale()) {
+        shardokBattalion.mutate_morale(static_cast<float>(battalion.morale()));
+        shardokBattalion.mutate_base_morale(kExplicitMoraleSentinel);
+    }
     shardokBattalion.mutate_armament(static_cast<float>(battalion.armament()));
     shardokBattalion.mutate_training(static_cast<float>(battalion.training()));
 
@@ -125,4 +130,4 @@ auto ConvertUnit(
     return shardokUnit;
 }
 
-}  // namespace shardok
+}  // namespace shardok

src/main/cpp/net/eagle0/common/byte_vector.hpp

@@ -9,18 +9,24 @@
 #ifndef EAGLE0_COMMON_BYTE_VECTOR_HPP
 #define EAGLE0_COMMON_BYTE_VECTOR_HPP
 
+#include <charconv>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
-#include <sstream>
+#include <initializer_list>
 #include <stdexcept>
 #include <string>
+#include <string_view>
+#include <utility>
 #include <vector>
 
 using std::string;
 using std::vector;
 
-class byte_vector : public vector<uint8_t> {
+class byte_vector {
+private:
+    std::vector<uint8_t> bytes_;
+
 public:
     class HexException : public std::exception {
         const std::string description;
@@ -35,60 +41,78 @@ public:
     };
 
 private:
-    static auto HexNibbleToValue(const char nibble) -> uint8_t {
-        if (nibble >= '0' && nibble <= '9') {
-            return uint8_t(nibble - '0');
-        } else if (nibble >= 'A' && nibble <= 'F') {
-            return uint8_t(nibble - 'A' + 10);
-        } else if (nibble >= 'a' && nibble <= 'f') {
-            return uint8_t(nibble - 'a' + 10);
+    static auto HexCharsToByte(const std::string_view digits) -> uint8_t {
+        unsigned int parsedByte = 0;
+        const auto [ptr, ec] =
+                std::from_chars(digits.data(), digits.data() + digits.size(), parsedByte, 16);
+        if (ec != std::errc() || ptr != digits.data() + digits.size()) {
+            throw HexException(ptr == digits.data() + digits.size() ? digits.back() : *ptr);
         }
-        throw HexException(nibble);
-    }
-
-    static auto HexCharsToByte(std::istringstream& str) -> uint8_t {
-        uint8_t b = 0;
-        char c = 0;
-        str >> c;
-        b |= (HexNibbleToValue(c) << 4u);
-        str >> c;
-        b |= HexNibbleToValue(c);
-        return b;
+        return static_cast<uint8_t>(parsedByte);
     }
 
 public:
     byte_vector() = default;
-    byte_vector(const std::initializer_list<uint8_t> list) : vector<uint8_t>(list) {}
+    byte_vector(const std::initializer_list<uint8_t> list) : bytes_(list) {}
     template<class InputIt>
-    byte_vector(InputIt begin, InputIt end) : vector<uint8_t>(begin, end) {}
+    byte_vector(InputIt begin, InputIt end) : bytes_(begin, end) {}
     byte_vector(const byte_vector& rhs) = default;
-    explicit byte_vector(const std::string& s) : byte_vector(s.begin(), s.end()) {}
-    explicit byte_vector(const size_t size) : vector<uint8_t>(size) {}
-    explicit byte_vector(void* data, const size_t size) : vector<uint8_t>(size) {
-        this->assign((uint8_t*)data, (uint8_t*)data + size);
+    byte_vector(byte_vector&& rhs) noexcept = default;
+    explicit byte_vector(const std::string& s) : bytes_(s.begin(), s.end()) {}
+    explicit byte_vector(std::vector<uint8_t> bytes) : bytes_(std::move(bytes)) {}
+    explicit byte_vector(const size_t size) : bytes_(size) {}
+    explicit byte_vector(const void* data, const size_t size) {
+        auto* bytes = static_cast<const uint8_t*>(data);
+        bytes_.assign(bytes, bytes + size);
     }
 
-    auto operator==(const vector<uint8_t>& vec) -> bool {
-        if (this->size() != vec.size()) return false;
-        for (size_t i = 0; i < size(); i++) {
-            if ((*this)[i] != vec[i]) return false;
-        }
-        return true;
+    auto operator=(const byte_vector& rhs) -> byte_vector& = default;
+    auto operator=(byte_vector&& rhs) noexcept -> byte_vector& = default;
+
+    [[nodiscard]] auto operator==(const std::vector<uint8_t>& vec) const -> bool {
+        return bytes_ == vec;
     }
+    [[nodiscard]] auto operator==(const byte_vector& vec) const -> bool {
+        return bytes_ == vec.bytes_;
+    }
+
+    [[nodiscard]] auto data() -> uint8_t* { return bytes_.data(); }
+    [[nodiscard]] auto data() const -> const uint8_t* { return bytes_.data(); }
+    [[nodiscard]] auto size() const -> size_t { return bytes_.size(); }
+    [[nodiscard]] auto empty() const -> bool { return bytes_.empty(); }
+    void reserve(const size_t count) { bytes_.reserve(count); }
+    void resize(const size_t count) { bytes_.resize(count); }
+    void swap(byte_vector& other) noexcept { bytes_.swap(other.bytes_); }
+
+    [[nodiscard]] auto begin() -> std::vector<uint8_t>::iterator { return bytes_.begin(); }
+    [[nodiscard]] auto begin() const -> std::vector<uint8_t>::const_iterator {
+        return bytes_.begin();
+    }
+    [[nodiscard]] auto end() -> std::vector<uint8_t>::iterator { return bytes_.end(); }
+    [[nodiscard]] auto end() const -> std::vector<uint8_t>::const_iterator { return bytes_.end(); }
+    [[nodiscard]] auto cbegin() const -> std::vector<uint8_t>::const_iterator {
+        return bytes_.cbegin();
+    }
+    [[nodiscard]] auto cend() const -> std::vector<uint8_t>::const_iterator {
+        return bytes_.cend();
+    }
+
+    [[nodiscard]] auto operator[](const size_t index) -> uint8_t& { return bytes_[index]; }
+    [[nodiscard]] auto operator[](const size_t index) const -> uint8_t { return bytes_[index]; }
 
     auto append(const char* bytes, const size_t length) {
-        const auto previousSize = this->size();
-        this->resize(previousSize + length);
-        std::memcpy(this->data() + previousSize, bytes, length);
+        const auto previousSize = size();
+        resize(previousSize + length);
+        std::memcpy(data() + previousSize, bytes, length);
     }
 
     template<class T>
     auto append(const T* elts, const size_t count) {
-        append((char*)elts, count * sizeof(T));
+        append(reinterpret_cast<const char*>(elts), count * sizeof(T));
     }
 
     template<class T>
-    auto append(const vector<T> elts) {
+    auto append(const vector<T>& elts) {
         append(elts.data(), elts.size());
     }
 
@@ -98,7 +122,7 @@ public:
     }
 
     auto operator+=(const uint8_t c) -> byte_vector& {
-        this->insert(end(), c);
+        bytes_.push_back(c);
         return *this;
     }
 
@@ -111,7 +135,7 @@ public:
 
     template<class Iterable>
     auto operator+=(const Iterable& rhs) -> byte_vector& {
-        this->insert(end(), rhs.cbegin(), rhs.cend());
+        bytes_.insert(end(), rhs.cbegin(), rhs.cend());
         return *this;
     }
 
@@ -119,7 +143,7 @@ public:
         if (size() < 8) {
             uint64_t total = 0;
             for (size_t i = 0; i < size(); i++) {
-                total <<= 8u;
+                total <<= 8U;
                 total += (*this)[i];
             }
             return total;
@@ -128,9 +152,9 @@ public:
         uint64_t firstBytes = 0;
         uint64_t lastBytes = 0;
         for (unsigned i = 0; i < 8; i++) {
-            firstBytes <<= 8u;
+            firstBytes <<= 8U;
             firstBytes += (*this)[i];
-            lastBytes <<= 8u;
+            lastBytes <<= 8U;
             lastBytes += (*this)[i];
         }
 
@@ -141,8 +165,8 @@ public:
         std::ifstream inputFileStream(path, std::ios::binary | std::ios::ate);
         const std::streamsize size = inputFileStream.tellg();
         inputFileStream.seekg(0, std::ios::beg);
-        this->resize((size_t(size)));
-        inputFileStream.read((char*)this->data(), size);
+        this->resize(static_cast<size_t>(size));
+        inputFileStream.read(reinterpret_cast<char*>(this->data()), size);
         return *this;
     }
 
@@ -153,34 +177,41 @@ public:
         }
         const std::streamsize size = inputFileStream.tellg();
         inputFileStream.seekg(0, std::ios::beg);
-        byte_vector serializedGame((size_t(size)));
-        inputFileStream.read((char*)serializedGame.data(), size);
+        byte_vector serializedGame(static_cast<size_t>(size));
+        inputFileStream.read(reinterpret_cast<char*>(serializedGame.data()), size);
         return serializedGame;
     }
 
     static auto FromHex(const char* hexString) -> byte_vector { return FromHex(string(hexString)); }
 
-    static auto FromHex(string hexString) -> byte_vector {
-        if (hexString[0] == '0' && (hexString[1] == 'x' || hexString[1] == 'X')) {
-            hexString = string(hexString.begin() + 1, hexString.end());
+    static auto FromHex(const string& hexString) -> byte_vector {
+        std::string_view digits(hexString);
+        if (digits.starts_with("0x") || digits.starts_with("0X")) {
+            digits.remove_prefix(2);
+        } else if (digits.starts_with("x") || digits.starts_with("X")) {
+            digits.remove_prefix(1);
         }
-        if (hexString[0] == 'x' || hexString[0] == 'X') {
-            hexString = string(hexString.begin() + 1, hexString.end());
-        }
-        byte_vector vec;
-        const size_t len = hexString.size();
-        vec.reserve(len / 2);
-        std::istringstream hexStream(hexString);
 
-        while (size_t(hexStream.tellg()) < len) { vec += HexCharsToByte(hexStream); }
+        if (digits.size() % 2 != 0) { throw HexException(digits.empty() ? '\0' : digits.back()); }
+
+        byte_vector vec;
+        vec.reserve(digits.size() / 2);
+
+        for (size_t index = 0; index < digits.size(); index += 2) {
+            vec += HexCharsToByte(digits.substr(index, 2));
+        }
         return vec;
     }
 
     explicit operator std::string() const { return std::string(begin(), end()); }
 };
 
-inline auto operator<<(std::ostream& ostr, byte_vector vec) -> std::ostream& {
-    ostr.write((char*)vec.data(), (std::streamsize)vec.size());
+inline auto operator==(const std::vector<uint8_t>& lhs, const byte_vector& rhs) -> bool {
+    return rhs == lhs;
+}
+
+inline auto operator<<(std::ostream& ostr, const byte_vector& vec) -> std::ostream& {
+    ostr.write(reinterpret_cast<const char*>(vec.data()), static_cast<std::streamsize>(vec.size()));
     return ostr;
 }
 

src/main/cpp/net/eagle0/common/mcts/abstract/AbstractMCTSAI.cpp

@@ -209,8 +209,8 @@ auto AbstractMCTSAI::BuildMCTSTree(
             }));
         }
 
-        // Wait for all threads to complete
-        for (auto& future : futures) { future.wait(); }
+        // Wait for all threads to complete and propagate worker exceptions.
+        for (auto& future : futures) { future.get(); }
     } else {
         // Single-threaded MCTS
         while (std::chrono::steady_clock::now() < deadline) {

src/main/cpp/net/eagle0/shardok/HexMapMigrator.cpp

@@ -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);

src/main/cpp/net/eagle0/shardok/MapInfoCalculator.cpp

@@ -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;

src/main/cpp/net/eagle0/shardok/MapInfoCalculator.hpp

@@ -18,7 +18,7 @@ struct alignas(64) OneMapInfo {
     std::map<int, int> positionsRequiringCrossing;
 };
 
-auto CalculateMap(
+[[nodiscard]] auto CalculateMap(
         const std::string& mapName,
         const std::shared_ptr<shardok::ActionPointDistancesCache>& apdCache,
         const shardok::BattalionTypeSPtr& battalionType) -> OneMapInfo;

src/main/cpp/net/eagle0/shardok/RandomBattleRunner.cpp

@@ -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);
     }
 

src/main/cpp/net/eagle0/shardok/ai/AIAttackGroups.cpp

@@ -25,25 +25,44 @@ DIST_T NormalizedCostWhenBraving(const DIST_T cost) {
 
 struct TargetAndDistance {
     Coords target;
+    size_t targetIndex;
     CoordsSet attackLocations;
     double targetPower;
     DIST_T distance;
 
-    TargetAndDistance(const Coords& t, const CoordsSet& al, const double tp, const DIST_T d)
+    TargetAndDistance(
+            const Coords& t,
+            const size_t ti,
+            const CoordsSet& al,
+            const double tp,
+            const DIST_T d)
         : target(t),
+          targetIndex(ti),
           attackLocations(al),
           targetPower(tp),
           distance(d) {}
 };
 
+auto CoordsIndex(const Coords& coords, const int columnCount) {
+    return coords.row() * columnCount + coords.column();
+}
+
+auto CoordsFromIndex(const size_t index, const int columnCount) -> Coords {
+    return Coords(
+            static_cast<int8_t>(index / static_cast<size_t>(columnCount)),
+            static_cast<int8_t>(index % static_cast<size_t>(columnCount)));
+}
+
 auto MinDistance(
         const Coords& start,
         const CoordsSet& destinations,
         const ActionPointDistances* apd) -> DIST_T {
     DIST_T minDistance = ActionPointDistances::IMPOSSIBLE;
+    const int startIndex = CoordsIndex(start, destinations.ColumnCount());
 
-    for (const Coords& dest : destinations) {
-        if (const DIST_T distance = apd->Distance(start, dest); distance < minDistance) {
+    for (const auto destIndex : destinations.indexIterator()) {
+        if (const DIST_T distance = apd->Distance(startIndex, static_cast<int>(destIndex));
+            distance < minDistance) {
             minDistance = distance;
         }
     }
@@ -113,10 +132,6 @@ auto EffectiveDistance(
 
 auto Power(const Unit* unit) -> double { return unit->battalion().size(); }
 
-auto CoordsIndex(const Coords& coords, const int columnCount) {
-    return coords.row() * columnCount + coords.column();
-}
-
 // Chooses a list of targets in priority order for each unit.
 auto GenerateTargetPriorities(
         const vector<const Unit*>& occupants,
@@ -163,10 +178,10 @@ auto GenerateTargetPriorities(
             bravingApd = apdCache->GetRaw(map, mapId, battType, true, braveWaterCost);
         }
 
-        for (const Coords& targetLocation : targets) {
-            const auto coordsIndex = CoordsIndex(targetLocation, cc);
-            const auto& occupant = occupants[coordsIndex];
+        for (const auto targetIndex : targets.indexIterator()) {
+            const auto& occupant = occupants[targetIndex];
 
+            const Coords targetLocation = CoordsFromIndex(targetIndex, cc);
             const auto& attackLocations = alCache->CachedLocations(targetLocation, isLateGame);
 
             if (occupant && occupant->player_id() != attackerId) {
@@ -179,12 +194,14 @@ auto GenerateTargetPriorities(
 
                     targetsWithDistance.emplace_back(
                             targetLocation,
+                            targetIndex,
                             attackLocsForUnit,
                             occupantPower,
                             distance);
                 } else {
                     targetsWithDistance.emplace_back(
                             targetLocation,
+                            targetIndex,
                             attackLocations.LocationsWithEnemyInRange(unit),
                             occupantPower,
                             ActionPointDistances::IMPOSSIBLE);
@@ -195,13 +212,11 @@ auto GenerateTargetPriorities(
         // Sort by distance
         std::ranges::sort(
                 targetsWithDistance,
-                [&powerAttackingEachTarget,
-                 cc](const TargetAndDistance& left, const TargetAndDistance& right) {
-                    const auto leftIndex = CoordsIndex(left.target, cc);
-                    const auto rightIndex = CoordsIndex(right.target, cc);
-
-                    const double powerAttackingLeft = powerAttackingEachTarget[leftIndex];
-                    const double powerAttackingRight = powerAttackingEachTarget[rightIndex];
+                [&powerAttackingEachTarget](
+                        const TargetAndDistance& left,
+                        const TargetAndDistance& right) {
+                    const double powerAttackingLeft = powerAttackingEachTarget[left.targetIndex];
+                    const double powerAttackingRight = powerAttackingEachTarget[right.targetIndex];
 
                     const bool leftAlreadyOverwhelmed =
                             powerAttackingLeft >= kOverpowerRatio * left.targetPower;
@@ -215,8 +230,7 @@ auto GenerateTargetPriorities(
                 });
 
         if (!targetsWithDistance.empty()) {
-            powerAttackingEachTarget[CoordsIndex(targetsWithDistance.front().target, cc)] +=
-                    Power(unit);
+            powerAttackingEachTarget[targetsWithDistance.front().targetIndex] += Power(unit);
         }
 
         tpl.priorityOrder.reserve(targetsWithDistance.size());

src/main/cpp/net/eagle0/shardok/ai/AIAttackGroups.hpp

@@ -27,7 +27,7 @@ struct TargetAndAttackLocations {
     Coords target;
     CoordsSet attackLocations;
 
-    auto operator==(const TargetAndAttackLocations& rhs) const -> bool = default;
+    [[nodiscard]] auto operator==(const TargetAndAttackLocations& rhs) const -> bool = default;
 };
 
 struct TargetPriorityList {
@@ -39,7 +39,7 @@ struct TargetPriorityList {
           priorityOrder(po) {}
 };
 
-auto EffectiveDistance(
+[[nodiscard]] auto EffectiveDistance(
         const Unit* unit,
         const HexMap* map,
         const AttackLocations& attackLocations,
@@ -47,7 +47,7 @@ auto EffectiveDistance(
         const BattalionTypeGetter& battalionTypeGetter,
         ActionPoints braveWaterCost) -> DIST_T;
 
-auto EffectiveDistance(
+[[nodiscard]] auto EffectiveDistance(
         const Unit* unit,
         const HexMap* map,
         const CoordsSet& locations,
@@ -55,14 +55,14 @@ auto EffectiveDistance(
         const BattalionTypeGetter& battalionTypeGetter,
         ActionPoints braveWaterCost) -> DIST_T;
 
-auto EffectiveDistance(
+[[nodiscard]] 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.
-auto GenerateTargetPriorities(
+[[nodiscard]] auto GenerateTargetPriorities(
         const std::vector<const Unit*>& occupants,
         const HexMap* map,
         const CoordsSet& targets,

src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.cpp

@@ -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);
 
@@ -114,8 +114,7 @@ auto AttackLocationsCache::CachedLocations(const CoordsSet &targets, const bool
         -> AttackLocations {
     AttackLocations al(rowCount, columnCount);
 
-    for (const auto &target : targets) {
-        const int index = target.row() * columnCount + target.column();
+    for (const auto index : targets.indexIterator()) {
         if (lateGame) {
             al += lateGameLocations[index];
         } else {
@@ -137,4 +136,4 @@ auto AttackLocationsCache::CachedLocations(const vector<const Unit *> &enemies,
     return CachedLocations(targets, lateGame);
 }
 
-}  // namespace shardok
+}  // namespace shardok

src/main/cpp/net/eagle0/shardok/ai/AICommandEvaluator.cpp

@@ -11,6 +11,8 @@
 #include <iomanip>
 #include <iostream>
 #include <limits>
+#include <sstream>
+#include <stdexcept>
 
 #include "AICommandFilter.hpp"
 #include "TranspositionTable.hpp"
@@ -21,16 +23,49 @@
 
 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
+[[nodiscard]] static auto AverageGenerator() -> std::shared_ptr<SequenceRandomGenerator> {
+    return std::make_shared<SequenceRandomGenerator>(std::vector{0.5});
+}
+
+[[nodiscard]] static auto DescribeCommandForLog(const CommandSPtr& command) -> std::string {
+    if (!command) { return "<null command>"; }
+
+    std::ostringstream out;
+    out << "type=" << command->GetCommandType()
+        << " player=" << static_cast<int>(command->GetPlayerId())
+        << " actor=" << command->GetActorUnitId() << " target=("
+        << static_cast<int>(command->GetTargetRow()) << ','
+        << static_cast<int>(command->GetTargetColumn()) << ')';
+
+    if (command->HasOdds()) { out << " odds_percentile=" << command->GetOddsPercentile(); }
+
+    return out.str();
+}
+
+[[nodiscard]] static auto DescribeCommandAt(
+        const CommandListSPtr& commands,
+        const size_t commandIndex) -> std::string {
+    if (!commands) { return "command=<null command list>"; }
+    if (commandIndex >= commands->size()) {
+        std::ostringstream out;
+        out << "command=<index " << commandIndex << " out of " << commands->size() << ">";
+        return out.str();
+    }
+
+    std::ostringstream out;
+    out << "command={" << DescribeCommandForLog(commands->at(commandIndex)) << '}';
+    return out.str();
+}
+
+[[nodiscard]] static auto WithExceptionContext(
+        const std::string& context,
+        const std::exception& exception) -> std::runtime_error {
+    return std::runtime_error(context + ": " + exception.what());
+}
+
 static auto IsDeterministic(const CommandType type) -> bool {
     switch (type) {
         case net::eagle0::shardok::common::MOVE_COMMAND:
@@ -43,13 +78,11 @@ static auto IsDeterministic(const CommandType type) -> bool {
         case net::eagle0::shardok::common::PLACE_HIDDEN_UNIT_COMMAND:
         case net::eagle0::shardok::common::UNIT_STOP_COMMAND:
         case net::eagle0::shardok::common::UNIT_REST_COMMAND:
-        case net::eagle0::shardok::common::FLEE_COMMAND:
         case net::eagle0::shardok::common::REINFORCE_COMMAND:
         case net::eagle0::shardok::common::RETREAT_COMMAND:
         case net::eagle0::shardok::common::END_PLAYER_SETUP_COMMAND:
         case net::eagle0::shardok::common::HIDE_COMMAND:
         case net::eagle0::shardok::common::FORTIFY_COMMAND:
-        case net::eagle0::shardok::common::BECOME_OUTLAW_COMMAND:
         case net::eagle0::shardok::common::HOLY_WAVE_COMMAND:
         case net::eagle0::shardok::common::EVACUATE_PRISONERS_COMMAND:
         case net::eagle0::shardok::common::REPAIR_COMMAND: return true;
@@ -63,7 +96,14 @@ 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 SuccessSampleForOdds(const double successChance) -> double {
+    return successChance / 2.0;
+}
+
+static auto FailureSampleForOdds(const double successChance) -> double {
+    return successChance + ((1.0 - successChance) / 2.0);
+}
+
 static auto CommandSorter(
         const AICommandEvaluator::IndexAndScore& l,
         const AICommandEvaluator::IndexAndScore& r) -> bool {
@@ -83,7 +123,7 @@ AICommandEvaluator::AICommandEvaluator(
         BattalionTypeGetter battalionTypeGetter)
     : scorer_(scorer),
       apdCache_(apdCache),
-      battalionTypeGetter_(std::move(battalionTypeGetter)) {}  // Move the function object
+      battalionTypeGetter_(std::move(battalionTypeGetter)) {}
 
 auto AICommandEvaluator::PerformLookahead(
         const PlayerId pid,
@@ -138,17 +178,34 @@ auto AICommandEvaluator::PerformLookahead(
                 std::launch::deferred,
                 [bestCommandFuture = std::move(bestCommandFuture),
                  innerEngine,
+                 nextCommands,
                  pid,
                  nextUtility,
                  remainingLookahead]() mutable -> EvaluationResult {
-                    const auto bestCommand = bestCommandFuture.get();
+                    IndexAndScore bestCommand;
+                    try {
+                        bestCommand = bestCommandFuture.get();
+                    } catch (const std::exception& e) {
+                        std::ostringstream context;
+                        context << "AI PerformLookahead failed while resolving best command"
+                                << " player=" << static_cast<int>(pid)
+                                << " remaining_lookahead=" << remainingLookahead
+                                << " next_command_count=" << nextCommands->size();
+                        throw WithExceptionContext(context.str(), e);
+                    }
                     if (!bestCommand.completed) {
                         return EvaluationResult{.score = nextUtility, .completed = false};
                     }
+                    if (bestCommand.index >= nextCommands->size()) {
+                        std::cerr << "AI lookahead produced command index " << bestCommand.index
+                                  << " with only " << nextCommands->size()
+                                  << " available commands for player " << static_cast<int>(pid)
+                                  << " at remaining lookahead " << remainingLookahead << "\n";
+                        return EvaluationResult{.score = nextUtility, .completed = false};
+                    }
 
                     ScoreValue resultScore;
-                    if (auto& nextCommand = innerEngine->GetAvailableCommandsForAIPlayer(pid)->at(
-                                bestCommand.index);
+                    if (const auto& nextCommand = nextCommands->at(bestCommand.index);
                         nextCommand->GetCommandType() !=
                         net::eagle0::shardok::common::END_TURN_COMMAND) {
                         resultScore = bestCommand.immediateScore;
@@ -199,14 +256,36 @@ auto AICommandEvaluator::EvaluateWithRandomness(
         return returnValue;
     }
 
+    const auto guessedCommands = guessedEngine.GetAvailableCommandsForAIPlayer(pid);
     auto innerEngine = std::make_shared<ShardokEngine>(guessedEngine, false);
-    innerEngine->PostCommand(pid, commandIndex, randomGenerator);
+    try {
+        innerEngine->PostCommand(pid, commandIndex, randomGenerator);
+    } catch (const std::exception& e) {
+        std::ostringstream context;
+        context << "AI EvaluateWithRandomness failed while posting simulated command"
+                << " player=" << static_cast<int>(pid) << " command_index=" << commandIndex
+                << " guessed_command_count=" << guessedCommands->size()
+                << " remaining_lookahead=" << remainingLookahead << ' '
+                << DescribeCommandAt(guessedCommands, commandIndex);
+        throw WithExceptionContext(context.str(), e);
+    }
 
-    auto innerUtility = scorer_.GuessedStateScore(
-            isDefender,
-            innerEngine->GetCurrentGameState(),
-            attackerStrategy,
-            allCastleCoords);
+    ScoreValue innerUtility;
+    try {
+        innerUtility = scorer_.GuessedStateScore(
+                isDefender,
+                innerEngine->GetCurrentGameState(),
+                attackerStrategy,
+                allCastleCoords);
+    } catch (const std::exception& e) {
+        std::ostringstream context;
+        context << "AI EvaluateWithRandomness failed while scoring simulated state"
+                << " player=" << static_cast<int>(pid) << " command_index=" << commandIndex
+                << " guessed_command_count=" << guessedCommands->size()
+                << " remaining_lookahead=" << remainingLookahead << ' '
+                << DescribeCommandAt(guessedCommands, commandIndex);
+        throw WithExceptionContext(context.str(), e);
+    }
 
     returnValue.immediateScore = innerUtility;
     returnValue.completed = true;
@@ -221,22 +300,33 @@ auto AICommandEvaluator::EvaluateWithRandomness(
                                 isDefender,
                                 remainingLookahead,
                                 maxRepeatCount,
+                                commandIndex,
                                 innerEngine,
                                 attackerStrategy,
                                 innerUtility,
-                                &allCastleCoords,
+                                guessedCommands,
+                                allCastleCoords,
                                 deadline]() -> EvaluationResult {
-            auto lookaheadFuture = PerformLookahead(
-                    pid,
-                    isDefender,
-                    remainingLookahead,
-                    maxRepeatCount,
-                    innerEngine,
-                    innerUtility,
-                    attackerStrategy,
-                    allCastleCoords,
-                    deadline);
-            return lookaheadFuture.get();
+            try {
+                auto lookaheadFuture = PerformLookahead(
+                        pid,
+                        isDefender,
+                        remainingLookahead,
+                        maxRepeatCount,
+                        innerEngine,
+                        innerUtility,
+                        attackerStrategy,
+                        allCastleCoords,
+                        deadline);
+                return lookaheadFuture.get();
+            } catch (const std::exception& e) {
+                std::ostringstream context;
+                context << "AI EvaluateWithRandomness failed during recursive lookahead"
+                        << " player=" << static_cast<int>(pid) << " command_index=" << commandIndex
+                        << " remaining_lookahead=" << remainingLookahead << ' '
+                        << DescribeCommandAt(guessedCommands, commandIndex);
+                throw WithExceptionContext(context.str(), e);
+            }
         };
 
         if constexpr (kMultithread) {
@@ -336,9 +426,21 @@ 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 CommandSPtr guessedDescriptor = [&] {
+            try {
+                return guessedDescriptors->at(originalIndex);
+            } catch (const std::exception& e) {
+                std::ostringstream context;
+                context << "AI FindBestCommand failed while reading filtered command"
+                        << " player=" << static_cast<int>(pid) << " filtered_index=" << index
+                        << " original_index=" << originalIndex
+                        << " guessed_command_count=" << guessedDescriptors->size()
+                        << " filtered_command_count=" << filteredIndices.size();
+                throw WithExceptionContext(context.str(), e);
+            }
+        }();
         const auto guessedCommandType = guessedDescriptor->GetCommandType();
 
         commandEvaluations[index].index = originalIndex;
@@ -356,7 +458,7 @@ auto AICommandEvaluator::FindBestCommand(
                     originalIndex,
                     remainingLookahead,
                     maxRepeatCount,
-                    kAverageGenerator,
+                    AverageGenerator(),
                     guessedEngine,
                     attackerStrategy,
                     allCastleCoords,
@@ -370,7 +472,7 @@ auto AICommandEvaluator::FindBestCommand(
             const auto successChancePercentile = guessedDescriptor->GetOddsPercentile();
             const double successChance = static_cast<double>(successChancePercentile) / 100.0;
 
-            // Success attempt uses 1.0 - (successChance / 2) as the roll
+            // Success attempt uses the midpoint of the successful percentile range.
             auto successEvaluation = EvaluateWithRandomness(
                     pid,
                     isDefender,
@@ -378,13 +480,13 @@ auto AICommandEvaluator::FindBestCommand(
                     remainingLookahead,
                     maxRepeatCount,
                     std::make_shared<SequenceRandomGenerator>(
-                            std::vector{1.0 - successChance / 2.0}),
+                            std::vector{SuccessSampleForOdds(successChance)}),
                     guessedEngine,
                     attackerStrategy,
                     allCastleCoords,
                     deadline);
 
-            // Failure attempt uses the average of (1 - successChance) and 0 as the roll
+            // Failure attempt uses the midpoint of the failing percentile range.
             auto failureEvaluation = EvaluateWithRandomness(
                     pid,
                     isDefender,
@@ -392,7 +494,7 @@ auto AICommandEvaluator::FindBestCommand(
                     remainingLookahead,
                     maxRepeatCount,
                     std::make_shared<SequenceRandomGenerator>(
-                            std::vector{(1.0 - successChance) / 2.0}),
+                            std::vector{FailureSampleForOdds(successChance)}),
                     guessedEngine,
                     attackerStrategy,
                     allCastleCoords,
@@ -423,7 +525,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)};
@@ -460,7 +562,17 @@ auto AICommandEvaluator::FindBestCommand(
                     ScoreValue totalLookaheadScore = 0.0;
                     bool completed = eval.immediateCompleted;
                     for (auto& future : eval.lookaheadFutures) {
-                        const auto lookahead = future.get();
+                        EvaluationResult lookahead;
+                        try {
+                            lookahead = future.get();
+                        } catch (const std::exception& e) {
+                            std::ostringstream context;
+                            context << "AI FindBestCommand failed while resolving lookahead future"
+                                    << " command_index=" << eval.index
+                                    << " command_type=" << eval.type
+                                    << " lookahead_future_count=" << eval.lookaheadFutures.size();
+                            throw WithExceptionContext(context.str(), e);
+                        }
                         if (!lookahead.completed) { completed = false; }
                         totalLookaheadScore += lookahead.score;
                     }
@@ -527,7 +639,7 @@ auto AICommandEvaluator::EvaluateCommand(
                 commandIndex,
                 remainingLookahead,
                 maxRepeatCount,
-                kAverageGenerator,
+                AverageGenerator(),
                 guessedEngine,
                 attackerStrategy,
                 allCastleCoords,
@@ -546,7 +658,8 @@ auto AICommandEvaluator::EvaluateCommand(
                 commandIndex,
                 remainingLookahead,
                 maxRepeatCount,
-                std::make_shared<SequenceRandomGenerator>(std::vector{1.0 - successChance / 2.0}),
+                std::make_shared<SequenceRandomGenerator>(
+                        std::vector{SuccessSampleForOdds(successChance)}),
                 guessedEngine,
                 attackerStrategy,
                 allCastleCoords,
@@ -559,7 +672,8 @@ auto AICommandEvaluator::EvaluateCommand(
                 commandIndex,
                 remainingLookahead,
                 maxRepeatCount,
-                std::make_shared<SequenceRandomGenerator>(std::vector{(1.0 - successChance) / 2.0}),
+                std::make_shared<SequenceRandomGenerator>(
+                        std::vector{FailureSampleForOdds(successChance)}),
                 guessedEngine,
                 attackerStrategy,
                 allCastleCoords,
@@ -587,7 +701,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,

src/main/cpp/net/eagle0/shardok/ai/AICommandEvaluator.hpp

@@ -78,7 +78,7 @@ public:
 private:
     const AIScoreCalculator& scorer_;
     const APDCache& apdCache_;
-    BattalionTypeGetter battalionTypeGetter_;  // Store by value
+    BattalionTypeGetter battalionTypeGetter_;
 
     struct ImmediateAndLookaheadScore {
         ScoreValue immediateScore{};

src/main/cpp/net/eagle0/shardok/ai/AIDistanceDebuf.cpp

@@ -104,23 +104,21 @@ auto DefenderDistanceBuf(
                 pointCostToDesiredTargetWithBraving);
     }
 
-    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;
-            });
+    std::ranges::sort(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;
     for (const WithoutAndWith &pointCost : pointCosts) {
-        const int effectiveCost =
-                (pointCost.without == 999) ? int(1.2 * pointCost.with) : pointCost.without;
+        const int effectiveCost = (pointCost.without == 999)
+                                          ? static_cast<int>(1.2 * pointCost.with)
+                                          : pointCost.without;
         sum += decr / (effectiveCost + 1);
         decr *= kPerUnitDebufDecay;
     }

src/main/cpp/net/eagle0/shardok/ai/AIDistanceDebuf.hpp

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

src/main/cpp/net/eagle0/shardok/ai/AIExperimentConfig.hpp

@@ -12,7 +12,7 @@
 
 namespace shardok {
 
-inline auto CurrentAIExperimentId() -> int {
+[[nodiscard]] inline auto CurrentAIExperimentId() -> int {
     const char* rawValue = std::getenv("SHARDOK_SCORING_EXPERIMENT_ID");
     if (rawValue == nullptr) { return 0; }
 
@@ -28,7 +28,9 @@ inline auto CurrentAIExperimentId() -> int {
     return experimentId;
 }
 
-inline auto IsAIExperiment(const int id) -> bool { return CurrentAIExperimentId() == id; }
+[[nodiscard]] inline auto IsAIExperiment(const int id) -> bool {
+    return CurrentAIExperimentId() == id;
+}
 
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/ai/AIFleeDecisionCalculator.cpp

@@ -19,6 +19,8 @@ namespace shardok {
 
 namespace {
 
+constexpr double kCertainCombatWinChance = 0.95;
+
 void WritePercent(std::ostream& output, const double value) {
     const auto flags = output.flags();
     const auto precision = output.precision();
@@ -154,8 +156,8 @@ auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
         const CommandListSPtr& availableCommands,
         const CommandList::const_iterator& fleeCommand,
         int maxRounds,
-        int minimumFleeOddsThreshold,
-        int desperateFleeThreshold,
+        int /*minimumFleeOddsThreshold*/,
+        int /*desperateFleeThreshold*/,
         bool enableDebugLogging) -> FleeDecision {
     // Get flee success odds
     const int fleeSuccessChance = (*fleeCommand)->GetOddsPercentile();
@@ -164,67 +166,31 @@ auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
         std::cout << "AI FinalRound: Evaluating flee (odds=" << fleeSuccessChance << "%)...\n";
     }
 
-    // Check if flee odds are good enough to attempt
-    if (fleeSuccessChance >= minimumFleeOddsThreshold) {
-        if (enableDebugLogging) {
-            std::cout << "AI FinalRound: Good flee odds (" << fleeSuccessChance
-                      << "% >= " << minimumFleeOddsThreshold << "%), choosing flee\n";
-        }
-        return FleeDecision{
-                true,
-                GetFleeCommandIndex(fleeCommand, availableCommands),
-                "Good flee odds"};
-    }
-
-    // Low flee odds - evaluate if fighting might be better
     const double combatWinChance = EstimateCombatSuccess(playerId, guessedState, maxRounds);
 
-    // If combat situation is hopeless, even bad flee odds are better than certain death
-    if (combatWinChance <= 0.05 && fleeSuccessChance >= desperateFleeThreshold) {
+    if (combatWinChance < kCertainCombatWinChance) {
         if (enableDebugLogging) {
-            std::cout << "AI FinalRound: Combat hopeless (";
+            std::cout << "AI FinalRound: Combat not certain (";
             WritePercent(std::cout, combatWinChance * 100);
-            std::cout << "%), desperate flee attempt (" << fleeSuccessChance << "%)\n";
+            std::cout << "% < ";
+            WritePercent(std::cout, kCertainCombatWinChance * 100);
+            std::cout << "%), choosing flee\n";
         }
         return FleeDecision{
                 true,
                 GetFleeCommandIndex(fleeCommand, availableCommands),
-                "Combat hopeless, desperate flee"};
+                "Last round combat not certain"};
     }
 
-    // Detailed flee vs fight comparison
-    const double fleeChance = static_cast<double>(fleeSuccessChance) / 100.0;
-
-    // Compare expected outcomes:
-    // - Flee: fleeChance of survival (not victory, but avoiding loss)
-    // - Fight: combatWinChance of victory (better than survival)
-
-    constexpr double FLEE_VS_COMBAT_MARGIN =
-            0.8;  // Require 80% of combat chance to prefer fighting
-    const double adjustedCombatThreshold = combatWinChance * FLEE_VS_COMBAT_MARGIN;
-
     if (enableDebugLogging) {
-        std::cout << "AI FinalRound: Flee=" << fleeSuccessChance << "%, Combat=";
+        std::cout << "AI FinalRound: Combat effectively certain (";
         WritePercent(std::cout, combatWinChance * 100);
-        std::cout << "%, Threshold=";
-        WritePercent(std::cout, adjustedCombatThreshold * 100);
-        std::cout << "% -> ";
-    }
-
-    if (fleeChance > adjustedCombatThreshold) {
-        if (enableDebugLogging) { std::cout << "FLEE (better odds)\n"; }
-        return FleeDecision{
-                true,
-                GetFleeCommandIndex(fleeCommand, availableCommands),
-                "Flee has better expected outcome"};
-    } else {
-        if (enableDebugLogging) { std::cout << "FIGHT (better expected outcome)\n"; }
-        // Return 0 to indicate we should use standard command selection
-        return FleeDecision{
-                false,
-                0,  // Will be replaced by StandardChooseCommandIndex
-                "Fighting has better expected outcome"};
+        std::cout << "%), fighting\n";
     }
+    return FleeDecision{
+            false,
+            0,  // Will be replaced by StandardChooseCommandIndex
+            "Combat effectively certain"};
 }
 
 auto AIFleeDecisionCalculator::ShouldConsiderFleeing(

src/main/cpp/net/eagle0/shardok/ai/AIMinimumDistanceAndTarget.cpp

@@ -5,15 +5,34 @@
 #include "AIMinimumDistanceAndTarget.hpp"
 
 namespace shardok {
+namespace {
+
+auto CoordsIndex(const Coords &coords, const int columnCount) -> int {
+    return coords.row() * columnCount + coords.column();
+}
+
+auto CoordsFromIndex(const size_t index, const int columnCount) -> Coords {
+    return Coords(
+            static_cast<int8_t>(index / static_cast<size_t>(columnCount)),
+            static_cast<int8_t>(index % static_cast<size_t>(columnCount)));
+}
+
+}  // namespace
+
 auto MinimumDistanceAndTarget(
         const ActionPointDistances *apd,
         const Coords &origin,
         const CoordsSet &destinations) -> CoordsAndDistance {
     CoordsAndDistance min{Coords(-1, -1), ActionPointDistances::IMPOSSIBLE};
-    for (const auto &dest : destinations) {
-        const DIST_T dist = apd->Distance(origin, dest);
+    const int columnCount = destinations.ColumnCount();
+    const int originIndex = CoordsIndex(origin, columnCount);
+
+    for (const auto destIndex : destinations.indexIterator()) {
+        const DIST_T dist = apd->Distance(originIndex, static_cast<int>(destIndex));
         if (dist == ActionPointDistances::IMPOSSIBLE) continue;
-        if (dist < min.distance) min = CoordsAndDistance{dest, dist};
+        if (dist < min.distance) {
+            min = CoordsAndDistance{CoordsFromIndex(destIndex, columnCount), dist};
+        }
     }
 
     return min;
@@ -25,4 +44,4 @@ auto MinimumDistance(
         const CoordsSet &destinations) -> int {
     return MinimumDistanceAndTarget(apd, origin, destinations).distance;
 }
-}  // namespace shardok
+}  // namespace shardok

src/main/cpp/net/eagle0/shardok/ai/AIMinimumDistanceAndTarget.hpp

@@ -18,12 +18,12 @@ struct CoordsAndDistance {
     int distance;
 };
 
-auto MinimumDistanceAndTarget(
+[[nodiscard]] auto MinimumDistanceAndTarget(
         const ActionPointDistances *apd,
         const Coords &origin,
         const CoordsSet &destinations) -> CoordsAndDistance;
 
-auto MinimumDistance(
+[[nodiscard]] auto MinimumDistance(
         const ActionPointDistances *apd,
         const Coords &origin,
         const CoordsSet &destinations) -> int;

src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp

@@ -20,12 +20,13 @@ using GameState = net::eagle0::shardok::storage::fb::GameState;
 using PlayerInfo = net::eagle0::shardok::storage::fb::PlayerInfo;
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 
-auto HasAttachedHeroWithProfession(
+[[nodiscard]] auto HasAttachedHeroWithProfession(
         const Unit *unit,
         net::eagle0::shardok::storage::fb::Profession profession) -> bool;
 
-auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
-auto PlayerInfoForPid(const GameStateW &, PlayerId pid) -> const PlayerInfo *;
+[[nodiscard]] auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
+[[nodiscard]] auto PlayerInfoForPid(const GameStateW &gameState, PlayerId pid)
+        -> const PlayerInfo *;
 
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp

@@ -26,11 +26,13 @@ struct AIStrategy {
 };
 
 extern AIStrategy FleeStrategy;
-auto AttackUnitsStrategy(const vector<TargetPriorityList>& targetPriorities) -> AIStrategy;
-auto AttackCastlesStrategy(const vector<TargetPriorityList>& targetPriorities) -> AIStrategy;
+[[nodiscard]] auto AttackUnitsStrategy(const vector<TargetPriorityList>& targetPriorities)
+        -> AIStrategy;
+[[nodiscard]] auto AttackCastlesStrategy(const vector<TargetPriorityList>& targetPriorities)
+        -> AIStrategy;
 extern AIStrategy HoldCastlesStrategy;
 extern AIStrategy ScatterStrategy;
-auto CrossRiversStrategy(const CoordsSet& targetLocations) -> AIStrategy;
+[[nodiscard]] auto CrossRiversStrategy(const CoordsSet& targetLocations) -> AIStrategy;
 
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/ai/AITimeBudget.hpp

@@ -30,7 +30,7 @@ public:
     AIEvaluationCounter(AIEvaluationCounter&&) = delete;
     auto operator=(AIEvaluationCounter&&) -> AIEvaluationCounter& = delete;
 
-    static int GetCurrentCount();
+    [[nodiscard]] 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.
-auto CalculateTimeBudget(
+[[nodiscard]] auto CalculateTimeBudget(
         PlayerId playerId,
         const GameSettingsSPtr& settings,
         const GameStateW& state,

src/main/cpp/net/eagle0/shardok/ai/AIUnitScoreCalculator.cpp

@@ -88,8 +88,8 @@ auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue {
             break;
     }
 
-    const double battalionValue = battalionTypeMultiplier * (1.0 + armament / 100.0) *
-                                  (1.0 + training / 100.0) * (0.5 + morale / 100.0) *
+    const double battalionValue = battalionTypeMultiplier * (1.0 + (armament / 100.0)) *
+                                  (1.0 + (training / 100.0)) * (0.5 + (morale / 100.0)) *
                                   unit->battalion().size();
 
     const double heroValue =
@@ -120,15 +120,16 @@ auto archeryValue(const vector<const Unit *> &enemyUnits, const bool canShootNow
 
 auto reduceValue(const Unit *unit, const Terrain *unitTerrain) -> double {
     // TODO: make this depend on value of reducing castle too
-    if (unit->fortified() || unitTerrain->modifier().castle().present())
+    if (unit->fortified() || unitTerrain->modifier().castle().present()) {
         return kReduceFortifiedPossibleValue;
-    else if (AllowsFortification(unitTerrain))
-        return kReduceUnfortifiedPossibleValue;
-    else
-        return 0.0;
+    }
+    if (AllowsFortification(unitTerrain)) { return kReduceUnfortifiedPossibleValue; }
+    return 0.0;
 }
 
-auto fearValue(const vector<const Unit *> &) -> double { return kFearPossibleValue; }
+auto fearValue([[maybe_unused]] const vector<const Unit *> &enemyUnits) -> double {
+    return kFearPossibleValue;
+}
 
 auto lightningValue(const Unit *unit) -> double {
     // TODO: make this depend on the value of the targets
@@ -235,9 +236,8 @@ auto meteorValue(
                     multiplier = kMeteorNoneRoundMultiplier * vigorFactor;
                 }
                 return maxValue * multiplier;
-            } else {
-                return 0.0;
             }
+            return 0.0;
         }
 
         case net::eagle0::shardok::storage::fb::MultiroundMagicState_TARGET:
@@ -247,9 +247,8 @@ auto meteorValue(
                         map,
                         enemyOccupants,
                         friendlyOccupants);
-            } else {
-                return bestTargetValue(unit, map, enemyOccupants, friendlyOccupants, meteorRange);
             }
+            return bestTargetValue(unit, map, enemyOccupants, friendlyOccupants, meteorRange);
         case net::eagle0::shardok::storage::fb::MultiroundMagicState_CAST:
             return kMeteorCastRoundMultiplier *
                    meteorDropRawValue(

src/main/cpp/net/eagle0/shardok/ai/AIUnitScoreCalculator.hpp

@@ -17,9 +17,9 @@ using net::eagle0::shardok::storage::fb::Unit;
 using ScoreValue = double;
 class AttackLocations;
 
-auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue;
+[[nodiscard]] auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue;
 
-auto GetRangedAttackBonus(
+[[nodiscard]] auto GetRangedAttackBonus(
         const Unit *unit,
         bool isAttacker,
         const HexMap *map,
@@ -32,7 +32,7 @@ auto GetRangedAttackBonus(
         double minVigorToCast,
         ActionPoints archeryActionPointCost = 0) -> double;
 
-auto UnitValue(
+[[nodiscard]] auto UnitValue(
         const Unit *unit,
         bool isAttacker,
         const std::vector<const Unit *> &attackerUnits,

src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCalculator.cpp

@@ -6,9 +6,18 @@
 
 #include "AIMinimumDistanceAndTarget.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/fb_helpers/HexMapHelpers.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/map/HexMapHasher.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
 
 namespace shardok {
+namespace {
+
+auto RecomputeModifierHash(HexMap *hexMap) -> MapId {
+    hexMap->mutate_modifier_hash(GetModifierHash(hexMap));
+    return ActionPointDistancesCache::GetMapId(hexMap);
+}
+
+}  // namespace
 
 auto UnitIdsRequiringWaterCrossing(
         const GameStateW &gameState,
@@ -18,7 +27,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 +164,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;
@@ -169,6 +178,7 @@ auto WaterCrossingTiles(
         auto *terr = const_cast<net::eagle0::shardok::storage::fb::Terrain *>(
                 mapCopy->mutable_terrain()->GetMutableObject(index));
         terr->mutable_modifier().mutable_bridge().mutate_present(true);
+        terr->mutable_modifier().mutable_bridge().mutate_integrity(100.0);
         terr->mutable_modifier().mutable_fire().mutate_present(false);
 
         auto hash = ActionPointDistancesCache::GetMapId(mapCopy);
@@ -185,6 +195,50 @@ auto WaterCrossingTiles(
     return returnCoords;
 }
 
+// Returns currently frozen water tiles that can act as an existing crossing from origin to
+// destination. The shared APD cache deliberately ignores ice, so this probes frozen tiles by
+// temporarily treating one as bridged for the water-crossing strategy only.
+auto FrozenWaterCrossingTiles(
+        const Coords &origin,
+        const Coords &destination,
+        const HexMap *hexMap,
+        const APDCache &apdCache,
+        const BattalionTypeSPtr &battalionType) -> CoordsSet {
+    AssertValid(origin, hexMap);
+    AssertValid(destination, hexMap);
+    auto returnCoords = CoordsSet(hexMap);
+
+    fb::HexMapW mapCopy = fb::CopyHexMap(hexMap);
+    const int mapSize = hexMap->row_count() * hexMap->column_count();
+
+    for (int index = 0; index < mapSize; ++index) {
+        const auto startTerrain = *hexMap->terrain()->Get(index);
+
+        if (!IsWater(startTerrain.type())) continue;
+
+        const auto modifier = startTerrain.modifier();
+        if (!modifier.ice().present() || modifier.fire().present()) continue;
+
+        auto *terr = const_cast<net::eagle0::shardok::storage::fb::Terrain *>(
+                mapCopy->mutable_terrain()->GetMutableObject(index));
+        terr->mutable_modifier().mutable_bridge().mutate_present(true);
+        terr->mutable_modifier().mutable_bridge().mutate_integrity(100.0);
+        terr->mutable_modifier().mutable_fire().mutate_present(false);
+
+        const MapId mapId = RecomputeModifierHash(mapCopy.Get());
+
+        if (const auto *distances = apdCache->GetRaw(mapCopy, mapId, battalionType, false);
+            distances->Distance(origin, destination) != ActionPointDistances::IMPOSSIBLE) {
+            returnCoords.Add(index / hexMap->column_count(), index % hexMap->column_count());
+        }
+
+        terr->mutable_modifier().mutable_bridge().mutate_present(false);
+        terr->mutable_modifier().mutable_bridge().mutate_integrity(0.0);
+    }
+
+    return returnCoords;
+}
+
 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
 auto IntendedCrossingStarts(
         const GameStateW &gameState,
@@ -213,7 +267,6 @@ auto IntendedCrossingStarts(
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 
 constexpr double kNoRequiredCrossingScore = std::numeric_limits<double>::max();
-constexpr double kNoCrossingCreatorsScore = std::numeric_limits<double>::min();
 
 auto WaterCrossingScore(
         const PlayerId playerId,
@@ -256,12 +309,26 @@ auto WaterCrossingScore(
 
     const auto unitIdsCreatingCrossing =
             UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
-    if (unitIdsCreatingCrossing.empty()) return kNoCrossingCreatorsScore;
 
     double totalScore = 0;
 
     const auto mapId = ActionPointDistancesCache::GetMapId(gameState->hex_map());
 
+    if (unitIdsCreatingCrossing.empty()) {
+        for (const UnitId uid : unitIdsRequiringCrossing) {
+            const Unit *unit = gameState->units()->Get(uid);
+            const auto &battalionType = battalionTypeGetter(unit->battalion().type());
+            const Coords location = unit->location();
+            const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
+
+            const int thisDistance =
+                    location.row() < 0 ? 1000 : MinimumDistance(apd, location, startCrossingFrom);
+            totalScore -= thisDistance;
+        }
+
+        return totalScore;
+    }
+
     // First put a big penalty on the distance for units that can create a crossing
     for (const UnitId uid : unitIdsCreatingCrossing) {
         const Unit *unit = gameState->units()->Get(uid);

src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCalculator.hpp

@@ -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
-auto UnitIdsRequiringWaterCrossing(
+[[nodiscard]] auto UnitIdsRequiringWaterCrossing(
         const GameStateW& gameState,
         PlayerId pid,
         const CoordsSet& destinations,
@@ -39,14 +39,14 @@ auto UnitIdsRequiringWaterCrossing(
         const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;
 
 // Units belonging to the player that are capable of creating water crossings
-auto UnitIdsToCreateWaterCrossing(
+[[nodiscard]] 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
-auto CanReach(
+[[nodiscard]] auto CanReach(
         const Coords& origin,
         const Coords& destination,
         const HexMap* hexMap,
@@ -56,11 +56,21 @@ auto CanReach(
 
 // Returns the *non*-water tiles from which you could bridge/freeze water to allow a unit to cross
 // from origin to destination
-auto CrossingStartLocations(const HexMap* hexMap, const CoordsSet& waterCrossingTiles) -> CoordsSet;
+[[nodiscard]] 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
-auto WaterCrossingTiles(
+[[nodiscard]] auto WaterCrossingTiles(
+        const Coords& origin,
+        const Coords& destination,
+        const HexMap* hexMap,
+        const APDCache& apdCache,
+        const BattalionTypeSPtr& battalionType) -> CoordsSet;
+
+// Returns currently frozen water tiles that can act as an existing crossing from origin to
+// destination.
+[[nodiscard]] auto FrozenWaterCrossingTiles(
         const Coords& origin,
         const Coords& destination,
         const HexMap* hexMap,
@@ -68,7 +78,7 @@ auto WaterCrossingTiles(
         const BattalionTypeSPtr& battalionType) -> CoordsSet;
 
 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
-auto IntendedCrossingStarts(
+[[nodiscard]] auto IntendedCrossingStarts(
         const GameStateW& gameState,
         const vector<UnitId>& unitIdsCreatingCrossing,
         const CoordsSet& tilesToStartCrossingFrom,
@@ -76,7 +86,7 @@ auto IntendedCrossingStarts(
         const BattalionTypeGetter& battalionTypeGetter) -> CoordsSet;
 
 // Calculate score based on water crossing strategy
-auto WaterCrossingScore(
+[[nodiscard]] auto WaterCrossingScore(
         PlayerId playerId,
         const BattalionTypeGetter& battalionTypeGetter,
         const GameStateW& gameState,

src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCommandChooser.cpp

@@ -15,7 +15,6 @@ namespace shardok {
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 
 constexpr ScoreValue kNoRequiredCrossingScore = std::numeric_limits<ScoreValue>::max();
-constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>::min();
 
 [[nodiscard]] auto AIWaterCrossingCommandChooser::WaterCrossingScore(
         const BattalionTypeGetter &battalionTypeGetter,
@@ -56,12 +55,26 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:
 
     const auto unitIdsCreatingCrossing =
             UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
-    if (unitIdsCreatingCrossing.empty()) return kNoCrossingCreatorsScore;
 
     ScoreValue totalScore = 0;
 
     const auto mapId = ActionPointDistancesCache::GetMapId(gameState->hex_map());
 
+    if (unitIdsCreatingCrossing.empty()) {
+        for (const UnitId uid : unitIdsRequiringCrossing) {
+            const Unit *unit = gameState->units()->Get(uid);
+            const auto &battalionType = battalionTypeGetter(unit->battalion().type());
+            const Coords location = unit->location();
+            const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
+
+            const int thisDistance =
+                    location.row() < 0 ? 1000 : MinimumDistance(apd, location, startCrossingFrom);
+            totalScore -= thisDistance;
+        }
+
+        return totalScore;
+    }
+
     // First put a big penalty on the distance for units that can create a crossing
     for (const UnitId uid : unitIdsCreatingCrossing) {
         const Unit *unit = gameState->units()->Get(uid);
@@ -157,7 +170,6 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
 
     const auto unitIdsCreatingCrossing =
             UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
-    if (unitIdsCreatingCrossing.empty()) return startCrossingFrom;
 
     for (const UnitId uid : unitIdsRequiringCrossing) {
         const Unit *unit = gameState->units()->Get(uid);
@@ -177,6 +189,17 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
             Coords destination = *destinations.begin();
             AssertValid(destination, gameState->hex_map());
 
+            auto frozenWaterCrossingTiles = FrozenWaterCrossingTiles(
+                    origin,
+                    destination,
+                    gameState->hex_map(),
+                    apdCache,
+                    battalionType);
+            startCrossingFrom +=
+                    CrossingStartLocations(gameState->hex_map(), frozenWaterCrossingTiles);
+
+            if (unitIdsCreatingCrossing.empty()) continue;
+
             auto waterCrossingTiles = WaterCrossingTiles(
                     origin,
                     destination,
@@ -192,4 +215,4 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
     return startCrossingFrom;
 }
 
-}  // namespace shardok
+}  // namespace shardok

src/main/cpp/net/eagle0/shardok/ai/IterativeDeepeningAI.cpp

@@ -51,7 +51,7 @@ IterativeDeepeningAI::IterativeDeepeningAI(
       castleCoords(castleCoords),
       scorer(scorer),
       apdCache(apdCache),
-      battalionTypeGetter(std::move(battalionTypeGetter)) {}  // Move the function object
+      battalionTypeGetter(std::move(battalionTypeGetter)) {}
 
 auto IterativeDeepeningAI::IterativeSearch(
         const GameSettingsSPtr& settings,

src/main/cpp/net/eagle0/shardok/ai/IterativeDeepeningAI.hpp

@@ -79,7 +79,7 @@ private:
     CoordsSet castleCoords;
     const AIScoreCalculator& scorer;
     const APDCache& apdCache;
-    BattalionTypeGetter battalionTypeGetter;  // Store by value, not reference!
+    BattalionTypeGetter battalionTypeGetter;
 
     // Reusable vectors to reduce memory allocations
     mutable std::vector<std::vector<ScoreValue>> scoresByDepth;

src/main/cpp/net/eagle0/shardok/ai/ShardokAIClient.cpp

@@ -19,8 +19,11 @@
 #include <sstream>
 #endif
 
+#include <array>
+#include <atomic>
 #include <iomanip>
 #include <iostream>
+#include <mutex>
 #include <set>
 #include <unordered_map>
 
@@ -182,7 +185,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 +217,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 +253,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 +266,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]);
     }
 
@@ -465,8 +468,10 @@ auto ShardokAIClient::ChooseCommandIndex(
         const GameSettingsSPtr &settings,
         const GameStateView &gsv,
         const CommandListSPtr &realAvailableCommands) const -> CommandChoiceResults {
-    static int typeChosenCount[net::eagle0::shardok::common::CommandType_MAX + 1];
-    static int totalChoices = 0;
+    static std::array<std::atomic<int>, net::eagle0::shardok::common::CommandType_MAX + 1>
+            typeChosenCount;
+    static std::atomic<int> totalChoices = 0;
+    static std::mutex reportMutex;
 
     CommandChoiceResults results{};
 
@@ -484,15 +489,18 @@ auto ShardokAIClient::ChooseCommandIndex(
     }
 
     const auto chosenType = (*realAvailableCommands)[results.chosenIndex]->GetCommandType();
-    typeChosenCount[static_cast<int>(chosenType)]++;
-    totalChoices++;
+    typeChosenCount[static_cast<size_t>(chosenType)].fetch_add(1, std::memory_order_relaxed);
+    const int updatedTotal = totalChoices.fetch_add(1, std::memory_order_relaxed) + 1;
 
-    if (totalChoices % 1000 == 0) {
+    if (updatedTotal % 1000 == 0) {
+        std::lock_guard lock(reportMutex);
         std::cout << "TYPES CHOSEN:\n";
         vector<std::pair<int, CommandType>> choices{};
-        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));
+        for (int i = 0; i <= net::eagle0::shardok::common::CommandType_MAX; ++i) {
+            if (const int count =
+                        typeChosenCount[static_cast<size_t>(i)].load(std::memory_order_relaxed);
+                count != 0) {
+                choices.emplace_back(count, static_cast<CommandType>(i));
             }
         }
 

src/main/cpp/net/eagle0/shardok/ai/TranspositionTable.cpp

@@ -38,8 +38,10 @@ TranspositionTable::probe(const GameStateW& state, int depth, PlayerId player) {
     uint64_t stored_hash = entry.hash_full.load(std::memory_order_relaxed);
     uint8_t stored_depth = entry.depth.load(std::memory_order_relaxed);
     uint8_t stored_player = entry.player_id.load(std::memory_order_relaxed);
+    uint16_t stored_age = entry.age.load(std::memory_order_relaxed);
 
-    if (stored_hash == hash && stored_depth >= depth && stored_player == player) {
+    if (stored_hash == hash && stored_depth >= depth && stored_player == player &&
+        stored_age == current_age.load(std::memory_order_relaxed)) {
         stats.hits++;
         float score = entry.score.load(std::memory_order_relaxed);
         return static_cast<ScoreValue>(score);

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokAction.hpp

@@ -44,6 +44,7 @@ public:
     [[nodiscard]] PlayerId getPlayer() const { return player_; }
     [[nodiscard]] int getActorId() const { return actorId_; }
     [[nodiscard]] std::pair<int, int> getTarget() const { return {targetRow_, targetCol_}; }
+    [[nodiscard]] bool hasOdds() const { return hasOdds_; }
 
 private:
     // Store only essential fields (~25 bytes, all POD, cache-friendly)

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameEngine.cpp

@@ -6,8 +6,10 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cstdint>
 #include <iomanip>
 #include <iostream>
+#include <mutex>
 #include <numeric>
 
 #include "ShardokAction.hpp"
@@ -32,9 +34,30 @@ auto IsDefenderPlayer(const GameStateW& gameState, const PlayerId playerId) -> b
     return false;
 }
 
-auto LegalActionsCacheKey(const uint64_t stateHash, const bool rootIsDefender) -> uint64_t {
+auto MixCacheKey(uint64_t seed, const uint64_t value) -> uint64_t {
+    constexpr uint64_t kHashCombineConstant = 0x9e3779b97f4a7c15ULL;
+    seed ^= value + kHashCombineConstant + (seed << 6) + (seed >> 2);
+    return seed;
+}
+
+auto PointerIdentityHash(const void* ptr) -> uint64_t {
+    return static_cast<uint64_t>(reinterpret_cast<std::uintptr_t>(ptr));
+}
+
+auto LegalActionsCacheKey(
+        const uint64_t stateHash,
+        const bool rootIsDefender,
+        const GameSettings* gameSettings,
+        const APDCache* apdCache) -> uint64_t {
     constexpr uint64_t kDefenderRoleHash = 0x9e3779b97f4a7c15ULL;
-    return rootIsDefender ? stateHash ^ kDefenderRoleHash : stateHash;
+    uint64_t key = rootIsDefender ? stateHash ^ kDefenderRoleHash : stateHash;
+
+    // The cached action set is the output of AICommandFilter, not just the raw command list.
+    // Include the context objects that can affect filtering so a process-wide cache entry from
+    // one search cannot be reused by a different settings/APD context with the same state hash.
+    key = MixCacheKey(key, PointerIdentityHash(gameSettings));
+    key = MixCacheKey(key, PointerIdentityHash(apdCache != nullptr ? apdCache->get() : nullptr));
+    return key;
 }
 
 auto SortActionsByWeight(
@@ -43,7 +66,7 @@ auto SortActionsByWeight(
     std::vector<size_t> sortedIndices(actions.size());
     std::iota(sortedIndices.begin(), sortedIndices.end(), 0);
 
-    std::sort(sortedIndices.begin(), sortedIndices.end(), [&weights](size_t a, size_t b) {
+    std::ranges::sort(sortedIndices, [&weights](size_t a, size_t b) {
         return weights[a] > weights[b];
     });
 
@@ -72,6 +95,10 @@ std::atomic<uint64_t> ShardokGameEngine::cacheMisses_{0};
 std::atomic<uint64_t> ShardokGameEngine::timeInHashComputation_{0};
 std::atomic<uint64_t> ShardokGameEngine::timeInLegalActionsComputation_{0};
 
+namespace {
+std::once_flag legalActionsCacheReserveOnce;
+}  // namespace
+
 ShardokGameEngine::ShardokGameEngine(
         [[maybe_unused]] const ShardokEngine* engine,
         const AIScoreCalculator* scoreCalculator,
@@ -92,7 +119,9 @@ ShardokGameEngine::ShardokGameEngine(
       criticalTileCoords_(criticalTileCoords) {
     // Thread-local cache is automatically initialized per thread
     // Reserve space to reduce rehashing (based on profiling: ~30-50K unique states per search)
-    legalActionsCache_.reserve(100000);
+    std::call_once(legalActionsCacheReserveOnce, [] {
+        ShardokGameEngine::legalActionsCache_.reserve(100000);
+    });
 }
 
 std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
@@ -106,27 +135,15 @@ std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
 
     const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
 
-    // Use cached engine if available (avoids recomputing GetAvailableCommands for same state)
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        // Clone the cached engine to preserve command cache
-        engine = std::make_shared<ShardokEngine>(*cachedEngine);
-    } else {
-        // Create fresh engine and populate command cache
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_,
-                0,
-                false);
-        // Populate command cache (result intentionally unused, just populating cache)
-        [[maybe_unused]] const auto commands =
-                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-        // Cache the engine for future use with this state
-        shardokState->setCachedEngine(engine);
-        // Clone it for applying the action (don't mutate the cached engine)
-        engine = std::make_shared<ShardokEngine>(*engine);
-    }
+    auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_,
+            0,
+            false);
+    // Populate the AI command list before posting so the MCTS action index maps to the
+    // no-follow-up command ordering used by getLegalActions().
+    [[maybe_unused]] const auto commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
     // Create deterministic random generator if a specific roll is requested
     // deterministicRoll of -1.0 (default) means use random generator
@@ -187,11 +204,6 @@ std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
             *alCache_,
             criticalTileCoords_);
 
-    // Cache the engine on the new state so score() can use it for END_TURN normalization
-    // The engine's command list may be stale after the action was applied, but that's OK -
-    // we'll refresh it when we call GetAvailableCommandsForAIPlayer() in score()
-    newState->setCachedEngine(engine);
-
     // Don't pre-compute hash - let it be computed lazily on first use
     // Many states (especially in simulation) never need their hash computed
     return newState;
@@ -211,28 +223,18 @@ void ShardokGameEngine::applyActionMutable(
 
     const auto currentPlayer = static_cast<PlayerId>(state->currentPlayerId());
 
-    // Use cached engine if available
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        engine = std::make_shared<ShardokEngine>(*cachedEngine);
-    } else {
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_,
-                0,
-                false);
-        // Populate command cache (result intentionally unused, just populating cache)
-        [[maybe_unused]] const auto commands =
-                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-        shardokState->setCachedEngine(engine);
-        engine = std::make_shared<ShardokEngine>(*engine);
-    }
+    auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_,
+            0,
+            false);
+    // Populate the AI command list before posting so the MCTS action index maps to the
+    // no-follow-up command ordering used by getLegalActions().
+    [[maybe_unused]] const auto commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
     engine->PostCommand(currentPlayer, shardokAction->getIndex(), nullptr);
     shardokState->getMutableShardokState() = engine->GetCurrentGameState();
-    // Clear the cached engine and hash since the state has been mutated
-    shardokState->setCachedEngine(nullptr);
     shardokState->invalidateHashCache();
 }
 
@@ -258,7 +260,8 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
     // Time hash computation
     const auto hashStart = std::chrono::high_resolution_clock::now();
     const uint64_t stateHash = shardokState->hash();
-    const uint64_t cacheKey = LegalActionsCacheKey(stateHash, isDefender_);
+    const uint64_t cacheKey =
+            LegalActionsCacheKey(stateHash, isDefender_, gameSettings_.get(), apdCache_);
     const auto hashEnd = std::chrono::high_resolution_clock::now();
     timeInHashComputation_.fetch_add(
             std::chrono::duration_cast<std::chrono::microseconds>(hashEnd - hashStart).count(),
@@ -266,40 +269,49 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
 
     // Check transposition table for cached legal actions
     if (auto it = legalActionsCache_.find(cacheKey); it != legalActionsCache_.end()) {
-        cacheHits_.fetch_add(1, std::memory_order_relaxed);
+        const auto engine = std::make_shared<ShardokEngine>(
+                gameSettings_,
+                shardokState->getShardokState(),
+                criticalTileCoords_);
 
-        // Use cached engine
-        shardokState->setCachedEngine(it->second.engine);
+        const CommandListSPtr commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
-        // Get commands from the cached engine (Engine already caches these internally)
-        const CommandListSPtr commands =
-                it->second.engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-
-        if (!commands || commands->empty()) { return {}; }
-
-        // Convert to MCTSActions using stored filtered indices
-        std::vector<std::unique_ptr<MCTSAction>> actions;
-        actions.reserve(it->second.filteredIndices.size());
-
-        for (const size_t origIdx : it->second.filteredIndices) {
-            if (origIdx < commands->size()) {
-                const auto& cmd = commands->at(origIdx);
-
-                // Extract essential fields directly from command (no proto conversion!)
-                actions.push_back(std::make_unique<ShardokAction>(
-                        origIdx,
-                        cmd->GetCommandType(),
-                        cmd->GetPlayerId(),
-                        cmd->GetActorUnitId(),
-                        cmd->GetTargetRow(),
-                        cmd->GetTargetColumn(),
-                        cmd->HasOdds()));
+        bool cacheEntryMatches = commands != nullptr && commands->size() == it->second.commandCount;
+        for (const auto& cachedAction : it->second.actions) {
+            const size_t commandIndex = cachedAction.getIndex();
+            if (!cacheEntryMatches || commandIndex >= commands->size()) {
+                cacheEntryMatches = false;
+                break;
             }
+
+            const auto& command = commands->at(commandIndex);
+            const auto [targetRow, targetColumn] = cachedAction.getTarget();
+            cacheEntryMatches = command->GetCommandType() ==
+                                        static_cast<net::eagle0::shardok::common::CommandType>(
+                                                cachedAction.getType()) &&
+                                command->GetPlayerId() == cachedAction.getPlayer() &&
+                                command->GetActorUnitId() == cachedAction.getActorId() &&
+                                command->GetTargetRow() == targetRow &&
+                                command->GetTargetColumn() == targetColumn &&
+                                command->HasOdds() == cachedAction.hasOdds();
+            if (!cacheEntryMatches) { break; }
         }
 
-        // Sort actions by weight (descending) to ensure MCTS explores high-value actions first
-        const std::vector<double> weights = getActionWeights(actions, state);
-        return SortActionsByWeight(std::move(actions), weights);
+        if (cacheEntryMatches) {
+            cacheHits_.fetch_add(1, std::memory_order_relaxed);
+
+            // Convert immutable cached action snapshots to MCTS action instances.
+            std::vector<std::unique_ptr<MCTSAction>> actions;
+            actions.reserve(it->second.actions.size());
+
+            for (const auto& cachedAction : it->second.actions) {
+                actions.push_back(cachedAction.clone());
+            }
+
+            // Sort actions by weight (descending) to ensure MCTS explores high-value actions first
+            const std::vector<double> weights = getActionWeights(actions, state);
+            return SortActionsByWeight(std::move(actions), weights);
+        }
     }
 
     cacheMisses_.fetch_add(1, std::memory_order_relaxed);
@@ -307,17 +319,10 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
     // Time legal actions computation
     const auto actionsStart = std::chrono::high_resolution_clock::now();
 
-    // Use cached engine if available, otherwise create and cache it
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        engine = cachedEngine;
-    } else {
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_);
-        shardokState->setCachedEngine(engine);
-    }
+    const auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_);
 
     const CommandListSPtr commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
@@ -338,20 +343,24 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
     // Convert only filtered commands to MCTSActions
     std::vector<std::unique_ptr<MCTSAction>> actions;
     actions.reserve(filteredIndices.size());
+    std::vector<ShardokAction> cachedActions;
+    cachedActions.reserve(filteredIndices.size());
 
     for (const size_t idx : filteredIndices) {
         if (idx < commands->size()) {
             const auto& cmd = commands->at(idx);
 
             // Extract essential fields directly from command (no proto conversion!)
-            actions.push_back(std::make_unique<ShardokAction>(
+            ShardokAction action(
                     idx,
                     cmd->GetCommandType(),
                     cmd->GetPlayerId(),
                     cmd->GetActorUnitId(),
                     cmd->GetTargetRow(),
                     cmd->GetTargetColumn(),
-                    cmd->HasOdds()));
+                    cmd->HasOdds());
+            actions.push_back(action.clone());
+            cachedActions.push_back(action);
         }
     }
 
@@ -368,20 +377,20 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
                     .count(),
             std::memory_order_relaxed);
 
-    // Store in transposition table for future lookups
-    // Note: We only store filtered indices and the engine (which caches commands internally)
-    // This avoids duplicating heavy protocol buffer objects
+    // Store immutable action snapshots in the transposition table for future lookups.
+    // Do not store ShardokEngine here: its command cache is mutable and not safe to share
+    // across MCTS worker threads.
     // Use lazy_emplace_l to ensure thread-safe insertion (locks the bucket during construction)
     legalActionsCache_.lazy_emplace_l(
             cacheKey,
             [&](typename decltype(legalActionsCache_)::value_type& v) {
                 // Update existing entry
-                v.second.filteredIndices = filteredIndices;
-                v.second.engine = engine;
+                v.second.commandCount = commands->size();
+                v.second.actions = cachedActions;
             },
             [&](const typename decltype(legalActionsCache_)::constructor& ctor) {
                 // Create new entry
-                ctor(cacheKey, LegalActionsCache{filteredIndices, engine});
+                ctor(cacheKey, LegalActionsCache{commands->size(), cachedActions});
             });
 
     return actions;
@@ -398,9 +407,8 @@ 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;
-    indices.reserve(actions.size());
-    for (size_t i = 0; i < actions.size(); ++i) { indices.push_back(i); }
+    std::vector<size_t> indices(actions.size());
+    std::iota(indices.begin(), indices.end(), 0);
     return indices;
 }
 
@@ -415,15 +423,7 @@ std::vector<double> ShardokGameEngine::getActionWeights(
                 "indicates a type mismatch in the MCTS adapter layer");
     }
 
-    // Get cached engine and command list for looking up command protos
-    auto cachedEngine = shardokState->getCachedEngine();
-    if (!cachedEngine) {
-        throw MCTSInternalError(
-                "ShardokGameEngine::getActionWeights called with state that has no cached engine");
-    }
-
     const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
-    const CommandListSPtr commands = cachedEngine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
     // Determine if current player is defender (not root player!)
     // During simulation we need to use the correct perspective for action weighting
@@ -442,20 +442,13 @@ std::vector<double> ShardokGameEngine::getActionWeights(
                     "indicates a type mismatch in the MCTS adapter layer");
         }
 
-        // Look up command proto from cached engine using action's index
-        const size_t cmdIndex = shardokAction->getIndex();
-        if (cmdIndex >= commands->size()) {
-            throw MCTSInternalError(
-                    "ShardokGameEngine::getActionWeights: action index out of bounds");
-        }
-
-        const auto& cmd = commands->at(cmdIndex);
+        const auto [targetRow, targetColumn] = shardokAction->getTarget();
 
         weights.push_back(AIHeuristicWeighting::GetCommandWeight(
-                cmd->GetCommandType(),
-                cmd->GetActorUnitId(),
-                cmd->GetPlayerId(),
-                Coords{cmd->GetTargetRow(), cmd->GetTargetColumn()},
+                static_cast<net::eagle0::shardok::common::CommandType>(shardokAction->getType()),
+                shardokAction->getActorId(),
+                shardokAction->getPlayer(),
+                Coords{static_cast<int8_t>(targetRow), static_cast<int8_t>(targetColumn)},
                 gameState,
                 castleCoords_,
                 apdCache_,
@@ -489,7 +482,7 @@ bool ShardokGameEngine::shouldStopSearch(
 size_t ShardokGameEngine::mapFilteredIndexToOriginal(
         size_t filteredIndex,
         const MCTSGameState& state) const {
-    // Get the filtered actions (uses cached engine)
+    // Get the filtered actions.
     auto actions = getLegalActions(state, state.currentPlayerId(), 0, 0);
 
     // Check bounds
@@ -591,22 +584,12 @@ ChanceOutcomeInfo ShardokGameEngine::getBinaryOutcomeInfo(
 
     const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
 
-    // Get or create the engine for this state
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        engine = cachedEngine;
-    } else {
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_,
-                0,
-                false);
-        // Populate command cache
-        [[maybe_unused]] const auto commands =
-                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-        shardokState->setCachedEngine(engine);
-    }
+    const auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_,
+            0,
+            false);
 
     // Get command descriptors
     const auto descriptors = engine->GetAvailableCommandsForAIPlayer(currentPlayer);

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameEngine.hpp

@@ -15,6 +15,7 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSGameEngine.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
+#include "src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokAction.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
@@ -99,11 +100,12 @@ public:
     void resetCacheStatistics();
 
 private:
-    // Transposition table entry for caching legal actions
-    // Note: We don't store command protos since the Engine already caches them
+    // Transposition table entry for caching legal actions.
+    // Store immutable action snapshots only; ShardokEngine owns mutable command caches and
+    // must remain per-state/per-thread.
     struct LegalActionsCache {
-        std::vector<size_t> filteredIndices;
-        std::shared_ptr<ShardokEngine> engine;  // Engine with populated command cache
+        size_t commandCount;
+        std::vector<ShardokAction> actions;
     };
 
     const AIScoreCalculator* scoreCalculator_;

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameState.cpp

@@ -98,7 +98,6 @@ std::unique_ptr<MCTSGameState> ShardokGameState::clone() const {
             apdCache_,
             alCache_,
             criticalTileCoords_);
-    // Don't copy the cached engine - each state needs its own
     return cloned;
 }
 

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameState.hpp

@@ -10,7 +10,6 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSGameState.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
-#include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
@@ -52,10 +51,6 @@ public:
     [[nodiscard]] const GameSettings* getSettings() const { return settings_; }
     [[nodiscard]] const CoordsSet& getCriticalTileCoords() const { return criticalTileCoords_; }
 
-    // Engine caching for performance (avoids recomputing available commands)
-    void setCachedEngine(std::shared_ptr<ShardokEngine> engine) const { cachedEngine_ = engine; }
-    [[nodiscard]] std::shared_ptr<ShardokEngine> getCachedEngine() const { return cachedEngine_; }
-
     // Invalidate hash cache when state is mutated
     void invalidateHashCache() const {
         hashCached_ = false;
@@ -74,7 +69,6 @@ private:
     mutable uint64_t cachedHash_ = 0;
     mutable bool hashCached_ = false;
     const CoordsSet criticalTileCoords_;  // Own the data to avoid dangling references
-    mutable std::shared_ptr<ShardokEngine> cachedEngine_;  // Engine with cached available commands
 };
 
 }  // namespace mcts

src/main/cpp/net/eagle0/shardok/ai/score/AIVictoryConditionScoreCalculator.cpp

@@ -133,8 +133,7 @@ auto DefenderHoldsCriticalTilesVictoryScore(
     const auto cc = gameState->hex_map()->column_count();
     const auto occupants = Occupants(*gameState->units(), rc, cc);
 
-    for (const Coords& criticalTileLocation : criticalTileLocations) {
-        const auto index = criticalTileLocation.row() * cc + criticalTileLocation.column();
+    for (const auto index : criticalTileLocations.indexIterator()) {
         const auto& occupant = occupants[index];
 
         if (occupant && occupant->battalion().type() !=

src/main/cpp/net/eagle0/shardok/ai/score/AIVictoryConditionScoreCalculator.hpp

@@ -23,7 +23,7 @@ using net::eagle0::shardok::storage::fb::PlayerInfo;
 
 using ScoreValue = double;
 
-auto AttackerHoldsCriticalTilesVictoryScore(
+[[nodiscard]] auto AttackerHoldsCriticalTilesVictoryScore(
         const GameStateW& gameState,
         const CoordsSet& criticalTileLocations,
         const PlayerInfo* player,
@@ -32,12 +32,12 @@ auto AttackerHoldsCriticalTilesVictoryScore(
         const BattalionTypeGetter& battalionTypeGetter,
         ActionPoints braveWaterCost) -> ScoreValue;
 
-auto DefenderHoldsCriticalTilesVictoryScore(
+[[nodiscard]] auto DefenderHoldsCriticalTilesVictoryScore(
         const GameStateW& gameState,
         const CoordsSet& criticalTileLocations,
         const PlayerInfo* player) -> ScoreValue;
 
-auto LastPlayerStandingVictoryScore(
+[[nodiscard]] auto LastPlayerStandingVictoryScore(
         const GameStateW& gameState,
         const PlayerInfo* player,
         const APDCache& apdCache,

src/main/cpp/net/eagle0/shardok/ai/score/MCTSOptimizedAIScoreCalculator.cpp

@@ -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);
     }

src/main/cpp/net/eagle0/shardok/ai/score/StandardAIScoreCalculator.cpp

@@ -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);
     }

src/main/cpp/net/eagle0/shardok/ai/score/private/AIScoreCalculatorSharedUtilities.cpp

@@ -7,8 +7,7 @@
 #include "src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
 
-namespace shardok {
-namespace score_calculator_internal {
+namespace shardok::score_calculator_internal {
 
 auto EffectiveDistanceCache::GetOrCompute(
         const Unit* unit,
@@ -125,5 +124,4 @@ auto AttackerMultiplierForTargetDistance(
             isLateGame);
 }
 
-}  // namespace score_calculator_internal
-}  // namespace shardok
+}  // namespace shardok::score_calculator_internal

src/main/cpp/net/eagle0/shardok/ai/score/private/AIScoreCalculatorSharedUtilities.hpp

@@ -24,8 +24,7 @@
 #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 {
-namespace score_calculator_internal {
+namespace shardok::score_calculator_internal {
 
 using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 using Unit = net::eagle0::shardok::storage::fb::Unit;
@@ -51,13 +50,13 @@ struct EffectiveDistanceCache {
     struct CacheKey {
         UnitId unitId;
         Coords target;
-        bool operator==(const CacheKey& other) const {
+        [[nodiscard]] bool operator==(const CacheKey& other) const {
             return unitId == other.unitId && target == other.target;
         }
     };
 
     struct CacheKeyHash {
-        size_t operator()(const CacheKey& key) const {
+        [[nodiscard]] 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);
         }
@@ -65,7 +64,7 @@ struct EffectiveDistanceCache {
 
     mutable gtl::flat_hash_map<CacheKey, DIST_T, CacheKeyHash> cache;
 
-    DIST_T GetOrCompute(
+    [[nodiscard]] DIST_T GetOrCompute(
             const Unit* unit,
             const Coords& target,
             const ActionPointDistances* notBravingApd,
@@ -75,11 +74,12 @@ struct EffectiveDistanceCache {
 
 /// Calculate score for FLEE strategy
 /// Returns negative score based on fleeing units
-auto FleeStrategyScoreForState(const GameStateW& gameState, PlayerId playerId) -> ScoreValue;
+[[nodiscard]] 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
-auto AttackerMultiplierForTargetDistance(
+[[nodiscard]] auto AttackerMultiplierForTargetDistance(
         const Unit* attackingUnit,
         const std::vector<TargetAndAttackLocations>& priorityList,
         const std::vector<const Unit*>& occupants,
@@ -89,7 +89,6 @@ auto AttackerMultiplierForTargetDistance(
         const ActionPointDistances* bravingApd,
         bool isLateGame) -> double;
 
-}  // namespace score_calculator_internal
-}  // namespace shardok
+}  // namespace shardok::score_calculator_internal
 
 #endif  // EAGLE0_SHARDOK_AI_SCORE_PRIVATE_AI_SCORE_CALCULATOR_SHARED_UTILITIES_HPP

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleConfig.cpp

@@ -10,8 +10,7 @@
 #include <iostream>
 #include <sstream>
 
-namespace shardok {
-namespace ai_battle_simulator {
+namespace shardok::ai_battle_simulator {
 
 using net::eagle0::shardok::ai_battle_simulator::AIAlgorithmType;
 using net::eagle0::shardok::ai_battle_simulator::PlayerConfig;
@@ -110,5 +109,4 @@ std::string AiBattleConfigLoader::ToJsonString(const BattleConfigProto& config)
     return jsonString;
 }
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleConfig.hpp

@@ -13,8 +13,7 @@
 #include "src/main/protobuf/net/eagle0/shardok/ai_battle_simulator/ai_battle_config.pb.h"
 #pragma clang diagnostic pop
 
-namespace shardok {
-namespace ai_battle_simulator {
+namespace shardok::ai_battle_simulator {
 
 using BattleConfigProto = net::eagle0::shardok::ai_battle_simulator::BattleConfig;
 
@@ -41,7 +40,6 @@ public:
     [[nodiscard]] static std::string ToJsonString(const BattleConfigProto& config);
 };
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator
 
 #endif  // EAGLE0_SHARDOK_AI_BATTLE_SIMULATOR_AI_BATTLE_CONFIG_HPP

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleSimulator.cpp

@@ -28,8 +28,7 @@
 #include "src/main/protobuf/net/eagle0/shardok/common/player_info.pb.h"
 #pragma clang diagnostic pop
 
-namespace shardok {
-namespace ai_battle_simulator {
+namespace shardok::ai_battle_simulator {
 
 namespace {
 
@@ -331,10 +330,6 @@ 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);
@@ -344,7 +339,6 @@ 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;
@@ -355,7 +349,10 @@ 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);
-    playerInfoProtos.push_back(std::move(defenderInfo));
+
+    std::vector<net::eagle0::shardok::common::PlayerInfo> playerInfoProtos{
+            std::move(attackerInfo),
+            std::move(defenderInfo)};
 
     // Create units from config
     std::vector<net::eagle0::shardok::storage::fb::Unit> units;
@@ -961,5 +958,4 @@ BattleResult AiBattleSimulator::CreateResultFromGameState(
     return result;
 }
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleSimulator.hpp

@@ -30,7 +30,9 @@ class ShardokEngine;
 // Type alias for hex map
 using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 
-namespace ai_battle_simulator {
+}  // namespace shardok
+
+namespace shardok::ai_battle_simulator {
 
 using BattleConfigProto = net::eagle0::shardok::ai_battle_simulator::BattleConfig;
 
@@ -146,7 +148,6 @@ private:
     CreateResultFromGameState(const GameStateW& state, int totalRounds, int totalCommands) const;
 };
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator
 
 #endif  // EAGLE0_SHARDOK_AI_BATTLE_SIMULATOR_AI_BATTLE_SIMULATOR_HPP

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/real_battle_smoke_metadata_main.cpp

@@ -191,7 +191,8 @@ int main(int argc, char *argv[]) {
             }
             std::cout << "],\"has_game_status\":" << (hasGameStatus ? "true" : "false") << "}\n";
             return 0;
-        } else if (!resultPath.empty()) {
+        }
+        if (!resultPath.empty()) {
             ActionResult result;
             if (!result.ParseFromString(ReadFile(resultPath))) {
                 throw std::runtime_error("Failed to parse Shardok action result proto");

src/main/cpp/net/eagle0/shardok/ai_performance_runner/PerformanceTestGameStateBuilder.hpp

@@ -32,7 +32,7 @@ public:
      * Initialize game settings from the default configuration files.
      * Must be called before creating game states.
      */
-    static auto InitializeGameSettings() -> GameSettingsSPtr;
+    [[nodiscard]] static auto InitializeGameSettings() -> GameSettingsSPtr;
 
     /**
      * Create the standard "Perf" test configuration:
@@ -44,7 +44,7 @@ public:
      * @param defenderToggle If true, AI is defender; if false, AI is attacker
      * @return A GameStateW with the configured battle
      */
-    static auto CreatePerfTestGameState(
+    [[nodiscard]] static auto CreatePerfTestGameState(
             const GameSettingsSPtr& settings,
             bool defenderToggle = false) -> GameStateW;
 
@@ -58,7 +58,7 @@ public:
      * @param defenderToggle If true, AI is defender; if false, AI is attacker
      * @return A GameStateW with the configured battle
      */
-    static auto CreateCustomTestGameState(
+    [[nodiscard]] static auto CreateCustomTestGameState(
             const GameSettingsSPtr& settings,
             const std::string& mapName,
             int aiUnitCount,
@@ -67,11 +67,11 @@ public:
 
 private:
     // Helper functions for building game state components
-    static auto
+    [[nodiscard]] static auto
     AddPlayerInfo(flatbuffers::FlatBufferBuilder& fbb, int playerId, bool isDefender, int food)
             -> flatbuffers::Offset<net::eagle0::shardok::storage::fb::PlayerInfo>;
 
-    static auto AddGenericUnit(
+    [[nodiscard]] static auto AddGenericUnit(
             PlayerId playerId,
             UnitId unitId,
             const net::eagle0::shardok::storage::fb::Coords& location,

src/main/cpp/net/eagle0/shardok/ai_testing_common/AIClientFactory.cpp

@@ -7,8 +7,7 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSTypes.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/ShardokAIClient.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 auto AIClientFactory::Create(
         PlayerId playerId,
@@ -30,5 +29,4 @@ auto AIClientFactory::Create(
             mctsConfig);
 }
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common

src/main/cpp/net/eagle0/shardok/ai_testing_common/AIClientFactory.hpp

@@ -54,7 +54,7 @@ public:
      * @param mctsConfig MCTS settings, used only when algorithmType is MCTS
      * @return Unique pointer to created ShardokAIClient
      */
-    static auto Create(
+    [[nodiscard]] static auto Create(
             PlayerId playerId,
             bool isDefender,
             const net::eagle0::shardok::storage::fb::HexMap* hexMap,

src/main/cpp/net/eagle0/shardok/ai_testing_common/GamePhaseRunner.cpp

@@ -8,8 +8,7 @@
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 auto GamePhaseRunner::RunSetupPhase(
         ShardokEngine& engine,
@@ -58,5 +57,4 @@ auto GamePhaseRunner::RunSingleTurn(ShardokEngine& engine, PlayerId playerId, Sh
     return true;
 }
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common

src/main/cpp/net/eagle0/shardok/ai_testing_common/GameSettingsFactory.cpp

@@ -9,8 +9,7 @@
 #include "src/main/cpp/net/eagle0/common/byte_vector.hpp"
 #include "src/main/cpp/net/eagle0/shardok/util/BattalionTypeRegistrar.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 auto GameSettingsFactory::CreateDefault() -> GameSettingsSPtr {
     auto settings = std::make_shared<GameSettings>();
@@ -31,5 +30,4 @@ auto GameSettingsFactory::CreateDefault() -> GameSettingsSPtr {
     return settings;
 }
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common

src/main/cpp/net/eagle0/shardok/ai_testing_common/GameSettingsFactory.hpp

@@ -10,8 +10,7 @@
 
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 /**
  * Factory class for creating GameSettings instances with standard configuration.
@@ -30,10 +29,9 @@ public:
      *
      * @return Shared pointer to initialized GameSettings
      */
-    static auto CreateDefault() -> GameSettingsSPtr;
+    [[nodiscard]] static auto CreateDefault() -> GameSettingsSPtr;
 };
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common
 
 #endif  // EAGLE0_SHARDOK_AI_TESTING_COMMON_GAME_SETTINGS_FACTORY_HPP

src/main/cpp/net/eagle0/shardok/controller/ShardokGameController.cpp

@@ -14,6 +14,7 @@
 #include <iostream>
 #include <iterator>
 #include <ranges>
+#include <sstream>
 #include <string>
 #include <thread>
 
@@ -27,6 +28,77 @@ using net::eagle0::common::ScopedShardokLatencyTrace;
 
 using net::eagle0::shardok::common::GameStatus;
 
+namespace {
+
+[[nodiscard]] auto DescribeCommandForLog(const CommandSPtr &command) -> std::string {
+    if (!command) { return "<null command>"; }
+
+    std::ostringstream out;
+    out << "type=" << command->GetCommandType()
+        << " player=" << static_cast<int>(command->GetPlayerId())
+        << " actor=" << command->GetActorUnitId() << " target=("
+        << static_cast<int>(command->GetTargetRow()) << ','
+        << static_cast<int>(command->GetTargetColumn()) << ')';
+
+    if (command->HasOdds()) { out << " odds_percentile=" << command->GetOddsPercentile(); }
+
+    try {
+        out << " proto={" << command->GetCommandProto().ShortDebugString() << '}';
+    } catch (const std::exception &e) { out << " proto_error={" << e.what() << '}'; }
+
+    return out.str();
+}
+
+[[nodiscard]] auto DescribeCommandsForLog(const CommandList &commands) -> std::string {
+    std::ostringstream out;
+    out << "available_command_count=" << commands.size();
+    for (size_t i = 0; i < commands.size(); ++i) {
+        out << "\n  [" << i << "] " << DescribeCommandForLog(commands[i]);
+    }
+    return out.str();
+}
+
+[[nodiscard]] auto DescribeCurrentStateForLog(const ShardokEngine &engine) -> std::string {
+    const auto *state = engine.GetCurrentGameState().Get();
+    if (state == nullptr) { return "state=<null>"; }
+
+    const auto vectorSize = [](const auto *vector) -> size_t {
+        return vector == nullptr ? 0 : vector->size();
+    };
+
+    std::ostringstream out;
+    out << "state={round=" << static_cast<int>(state->current_round())
+        << " current_player=" << static_cast<int>(state->current_player())
+        << " history_count=" << engine.GetUnfilteredHistoryCount();
+
+    if (const auto *status = state->status(); status != nullptr) {
+        out << " status=" << static_cast<int>(status->state()) << " end_condition=";
+        if (const auto *endCondition = status->end_game_condition(); endCondition != nullptr) {
+            out << "{type=" << static_cast<int>(endCondition->victory_type())
+                << " victory_details=" << static_cast<int>(endCondition->victory_details())
+                << " draw_details=" << static_cast<int>(endCondition->draw_details()) << '}';
+        } else {
+            out << "<null>";
+        }
+    } else {
+        out << " status=<null>";
+    }
+
+    out << " units=" << vectorSize(state->units())
+        << " player_infos=" << vectorSize(state->player_infos());
+
+    if (const auto *hexMap = state->hex_map(); hexMap != nullptr) {
+        out << " map=" << hexMap->row_count() << 'x' << hexMap->column_count();
+    } else {
+        out << " map=<null>";
+    }
+
+    out << '}';
+    return out.str();
+}
+
+}  // namespace
+
 class InvalidTokenException : public std::exception {};
 
 class MismatchedPlayerIdException : public std::exception {
@@ -154,6 +226,8 @@ void ShardokGameController::DoAIThread() {
             continue;
         }
 
+        std::string aiPhase = "choosing command";
+        int64_t chosenIndex = -1;
         try {
             // Phase 2: AI thinks (NO LOCK - this is the slow part)
             auto results = [&] {
@@ -165,6 +239,7 @@ void ShardokGameController::DoAIThread() {
                          {"available_command_count", std::to_string(availableCommands->size())}});
                 return aiClient->ChooseCommandIndex(settings, gsv, availableCommands);
             }();
+            chosenIndex = results.chosenIndex;
 
             // Phase 3: Post the command (brief lock)
             {
@@ -183,6 +258,7 @@ void ShardokGameController::DoAIThread() {
                 }
 
                 {
+                    aiPhase = "posting chosen command";
                     ScopedShardokLatencyTrace trace(
                             "ai_engine_post_command",
                             cachedGameId,
@@ -193,6 +269,7 @@ void ShardokGameController::DoAIThread() {
                 }
                 LockedNotifyClients();
                 {
+                    aiPhase = "posting forced follow-up commands";
                     ScopedShardokLatencyTrace trace(
                             "ai_engine_post_forced_commands",
                             cachedGameId,
@@ -204,16 +281,32 @@ void ShardokGameController::DoAIThread() {
                 aiThreadKeepGoing = !engine->GameIsOver();
             }
         } catch (const std::exception &e) {
+            std::ostringstream error;
+            error << "AI error in game " << cachedGameId << ", player " << playerId << ", round "
+                  << gsv.current_round() << ": " << e.what();
+
+            std::ostringstream context;
+            context << "AI failure context: phase=" << aiPhase
+                    << ", expected_history_count=" << expectedHistoryCount
+                    << ", current_history_count=" << engine->GetUnfilteredHistoryCount()
+                    << ", chosen_index=" << chosenIndex
+                    << ", current_player=" << static_cast<int>(engine->GetCurrentPlayerId()) << ", "
+                    << DescribeCurrentStateForLog(*engine);
+
+            const std::string commandsContext = availableCommands
+                                                        ? DescribeCommandsForLog(*availableCommands)
+                                                        : "available_command_count=<cleared>";
+
             std::cerr << "AI thread exception in game " << cachedGameId << ", player " << playerId
                       << ", round " << gsv.current_round() << ": " << e.what() << '\n';
+            std::cerr << context.str() << '\n';
+            std::cerr << commandsContext << '\n';
 
             void *backtraceArray[20];
             const int backtraceSize = backtrace(backtraceArray, 20);
             backtrace_symbols_fd(backtraceArray, backtraceSize, STDERR_FILENO);
 
-            aiThreadErrorMessage = "AI error in game " + cachedGameId + ", player " +
-                                   std::to_string(playerId) + ", round " +
-                                   std::to_string(gsv.current_round()) + ": " + e.what();
+            aiThreadErrorMessage = error.str() + "\n" + context.str() + "\n" + commandsContext;
             aiThreadFailed.store(true);
             updateCondition.notify_all();
             break;

src/main/cpp/net/eagle0/shardok/library/AvailableCommandsFactory.cpp

@@ -32,9 +32,8 @@ private:
     static auto CannotBecomeOutlaw(const GameStateW &gameState, PlayerId pid) -> bool {
         if (pid == UNCONTROLLED_PLAYER_ID) return false;
 
-        const auto &player = std::find_if(
-                std::begin(*gameState->player_infos()),
-                std::end(*gameState->player_infos()),
+        const auto &player = std::ranges::find_if(
+                *gameState->player_infos(),
                 [pid](const PlayerInfoFb *pi) { return pi->player_id() == pid; });
 
         return (player != std::end(*gameState->player_infos()) && player->cannot_become_outlaw());
@@ -43,9 +42,8 @@ private:
     static auto IsAttacker(const GameStateW &gameState, PlayerId pid) -> bool {
         if (pid == UNCONTROLLED_PLAYER_ID) return false;
 
-        const auto &player = std::find_if(
-                std::begin(*gameState->player_infos()),
-                std::end(*gameState->player_infos()),
+        const auto &player = std::ranges::find_if(
+                *gameState->player_infos(),
                 [pid](const PlayerInfoFb *pi) { return pi->player_id() == pid; });
 
         return (player == std::end(*gameState->player_infos()) || !player->is_defender());

src/main/cpp/net/eagle0/shardok/library/BattalionType.hpp

@@ -189,12 +189,13 @@ struct BattalionType {
     }
 
     [[nodiscard]] auto GetCostToEnterTerrain(const TerrainProto &terrain) const -> ActionCost {
-        if (HasBridge(terrain.modifier()))
-            return ActionCost(
-                    ActionCost::standard,
+        if (HasBridge(terrain.modifier()) && terrain.modifier().bridge().has_integrity() &&
+            terrain.modifier().bridge().integrity().value() > 0.0) {
+            return {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 +209,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(
-                    ActionCost::standard,
+        if (tm.bridge().present() && tm.bridge().integrity() > 0.0) {
+            return {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);

src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp

@@ -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);
 
-static inline bool DamageTypeGetsTerrainDefense(const DamageType type) {
+[[nodiscard]] static inline bool DamageTypeGetsTerrainDefense(const DamageType type) {
     switch (type) {
         case DamageType_slashing:
         case DamageType_puncturing:
@@ -132,11 +132,13 @@ public:
         return damageByType.at(PenetratingIndex(type));
     };
 
-    bool operator==(const CombatDamage& cmpr) const { return damageByType == cmpr.damageByType; }
+    [[nodiscard]] bool operator==(const CombatDamage& cmpr) const {
+        return damageByType == cmpr.damageByType;
+    }
 
-    bool operator!=(const CombatDamage& cmpr) const { return !(*this == cmpr); }
+    [[nodiscard]] bool operator!=(const CombatDamage& cmpr) const { return !(*this == cmpr); }
 
-    bool operator<=(const CombatDamage& cmpr) const {
+    [[nodiscard]] bool operator<=(const CombatDamage& cmpr) const {
         return std::ranges::equal(
                 damageByType,
                 cmpr.damageByType,
@@ -145,7 +147,7 @@ public:
                 });
     }
 
-    bool operator>=(const CombatDamage& cmpr) const {
+    [[nodiscard]] bool operator>=(const CombatDamage& cmpr) const {
         return std::ranges::equal(
                 damageByType,
                 cmpr.damageByType,
@@ -154,11 +156,15 @@ public:
                 });
     }
 
-    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]] bool operator<(const CombatDamage& cmpr) const {
+        return ((*this <= cmpr) && !(*this == cmpr));
+    }
 
-    CombatDamage operator+(const CombatDamage& add) const {
+    [[nodiscard]] CombatDamage operator+(const CombatDamage& add) const {
         return Builder()
                 .SetSlashing(
                         GetNormalDamageOfType(DamageType_slashing) +
@@ -219,7 +225,7 @@ public:
                 .Build();
     }
 
-    CombatDamage operator*(const double factor) const {
+    [[nodiscard]] CombatDamage operator*(const double factor) const {
         return Builder()
                 .SetSlashing(GetNormalDamageOfType(DamageType_slashing) * factor)
                 .SetPuncturing(GetNormalDamageOfType(DamageType_puncturing) * factor)
@@ -442,7 +448,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));
@@ -451,7 +457,9 @@ public:
     }
 };
 
-inline CombatDamage operator*(const double factor, const CombatDamage& dmg) { return dmg * factor; }
+[[nodiscard]] inline CombatDamage operator*(const double factor, const CombatDamage& dmg) {
+    return dmg * factor;
+}
 }  // namespace shardok
 
 #endif  // EAGLE0_SHARDOK_LIBRARY_COMBAT_DAMAGE_HPP

src/main/cpp/net/eagle0/shardok/library/FireUtils.hpp

@@ -21,19 +21,23 @@ using WeatherFb = net::eagle0::shardok::storage::fb::Weather;
 using TerrainProto = net::eagle0::shardok::common::Terrain;
 using Terrain = net::eagle0::shardok::storage::fb::Terrain;
 
-auto PropensityByTerrain(const Terrain *terrain, const SettingsGetter &settings) -> int;
+[[nodiscard]] auto PropensityByTerrain(const Terrain *terrain, const SettingsGetter &settings)
+        -> int;
 
-auto PropensityByTerrain(const TerrainProto &terrain, const SettingsGetter &settings) -> int;
+[[nodiscard]] auto PropensityByTerrain(const TerrainProto &terrain, const SettingsGetter &settings)
+        -> int;
 
-auto PropensityByTerrain(
+[[nodiscard]] auto PropensityByTerrain(
         const TerrainType &terrainType,
         const TileModifierProto &modifier,
         const SettingsGetter &settings) -> int;
 
-auto GetFireDamage(int troops, double openEndedPercentileRoll1, double openEndedPercentileRoll2)
-        -> CombatDamage;
+[[nodiscard]] auto GetFireDamage(
+        int troops,
+        double openEndedPercentileRoll1,
+        double openEndedPercentileRoll2) -> CombatDamage;
 
-auto GetExtinguishOdds(
+[[nodiscard]] auto GetExtinguishOdds(
         const SettingsGetter &settings,
         const Terrain *terrain,
         const WeatherFb *currentWeather,
@@ -41,7 +45,7 @@ auto GetExtinguishOdds(
         double intelligence,
         bool ownTile) -> PercentileRollOdds;
 
-auto GetStartFireOdds(
+[[nodiscard]] auto GetStartFireOdds(
         const SettingsGetter &settings,
         const Terrain &terrain,
         const WeatherFb &currentWeather,

src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp

@@ -36,25 +36,19 @@ public:
     using BaseType::BaseType;
 
     // Default constructor
-    GameStateW() : BaseType() {}
+    GameStateW() = default;
 
     // Copy constructor
-    GameStateW(const GameStateW& other) : BaseType(other) {}
+    GameStateW(const GameStateW& other) = default;
 
     // Move constructor
-    GameStateW(GameStateW&& other) noexcept : BaseType(std::move(other)) {}
+    GameStateW(GameStateW&& other) noexcept = default;
 
     // Copy assignment
-    GameStateW& operator=(const GameStateW& other) {
-        BaseType::operator=(other);
-        return *this;
-    }
+    GameStateW& operator=(const GameStateW& other) = default;
 
     // Move assignment
-    GameStateW& operator=(GameStateW&& other) noexcept {
-        BaseType::operator=(std::move(other));
-        return *this;
-    }
+    GameStateW& operator=(GameStateW&& other) noexcept = default;
 
     // Constructor from base type
     GameStateW(const BaseType& base) : BaseType(base) {}

src/main/cpp/net/eagle0/shardok/library/PercentileRollOdds.hpp

@@ -22,13 +22,13 @@ namespace shardok {
 using PercentileRollOdds = net::eagle0::shardok::storage::Odds;
 using OtherFactor = net::eagle0::shardok::storage::Odds_OtherFactor;
 
-double BonusFromStat(double stat);
+[[nodiscard]] double BonusFromStat(double stat);
 
-int16_t AverageBonusFromStats(const std::vector<double> &stats);
+[[nodiscard]] int16_t AverageBonusFromStats(const std::vector<double> &stats);
 
-OtherFactor MakeOtherFactor(int value, const std::string &id);
+[[nodiscard]] OtherFactor MakeOtherFactor(int value, const std::string &id);
 
-PercentileRollOdds MakeOdds(
+[[nodiscard]] PercentileRollOdds MakeOdds(
         int base = 0,
         int terr = 0,
         int weath = 0,
@@ -36,7 +36,7 @@ PercentileRollOdds MakeOdds(
         int statF = 0,
         std::span<const OtherFactor> others = {});
 
-PercentileRollOdds MakeOdds(
+[[nodiscard]] PercentileRollOdds MakeOdds(
         int base,
         int terr,
         int weath,
@@ -44,11 +44,11 @@ PercentileRollOdds MakeOdds(
         const std::vector<double> &stats,
         std::span<const OtherFactor> others = {});
 
-int16_t GetTotalOdds(const PercentileRollOdds &odds);
+[[nodiscard]] int16_t GetTotalOdds(const PercentileRollOdds &odds);
 
-bool PercentileRollSucceeds(const PercentileRollOdds &odds, double roll);
+[[nodiscard]] bool PercentileRollSucceeds(const PercentileRollOdds &odds, double roll);
 
-int16_t GetSuccessChance(const PercentileRollOdds &odds);
+[[nodiscard]] int16_t GetSuccessChance(const PercentileRollOdds &odds);
 }  // namespace shardok
 
 #endif  // EAGLE0_SHARDOK_LIBRARY_PERCENTILE_ROLL_ODDS_HPP

src/main/cpp/net/eagle0/shardok/library/ShardokAction.hpp

@@ -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::optional<int32_t>());
+        return InternalExecuteWithRoll(currentState, generator, std::nullopt);
     }
 
     [[nodiscard]] virtual auto InternalExecuteWithRoll(

src/main/cpp/net/eagle0/shardok/library/ShardokEngine.cpp

@@ -140,7 +140,12 @@ ShardokEngine::ShardokEngine(const ShardokEngine &toCopy, const bool trackHistor
       gameState(toCopy.gameState),
       trackHistory(trackHistory),
       startingHistoryCount(toCopy.startingHistoryCount),
+      startingHistoryState(trackHistory ? toCopy.startingHistoryState : GameStateW{}),
+      actionHistory(
+              trackHistory ? toCopy.actionHistory : std::vector<ShardokActionWithResultingState>{}),
       criticalTileCoords(toCopy.criticalTileCoords),
+      tutorialController_(toCopy.tutorialController_),
+      pendingReinforcementPlacement_(toCopy.pendingReinforcementPlacement_),
       cachedAvailableCommands(toCopy.cachedAvailableCommands) {}
 
 auto ShardokEngine::GetGameStateAtStartOfAction(const ActionId startingActionId) const
@@ -443,7 +448,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 +460,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)
@@ -718,8 +723,8 @@ auto SecuredByPlayerByUnitIdFromHistory(
                 continue;
             }
             if (!resolvedUnit.has_secured_by_player()) { continue; }
-            const auto *unit = reinterpret_cast<const Unit *>(resolvedUnit.unit_bytes().data());
-            securedByPlayerByUnitId[unit->unit_id()] = resolvedUnit.secured_by_player().value();
+            const auto unit = UnitFromBytes(resolvedUnit.unit_bytes());
+            securedByPlayerByUnitId[unit.unit_id()] = resolvedUnit.secured_by_player().value();
         }
     }
     return securedByPlayerByUnitId;

src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistances.cpp

@@ -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,

src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistances.hpp

@@ -43,7 +43,7 @@ protected:
             const std::shared_ptr<BraveableTileInfo> &braveWaterPossibleCoords,
             const std::vector<Coords> &indexToCoords,
             const std::vector<std::array<int, 6>> &adjacencyTable);
-    static auto GenerateDistances(
+    [[nodiscard]] static auto GenerateDistances(
             int fromIndex,
             const HexMap *hexMap,
             bool includeBravingWater,
@@ -51,13 +51,15 @@ protected:
             const BattalionTypeSPtr &battalionType,
             const std::shared_ptr<BraveableTileInfo> &braveWaterPossibleCoords)
             -> std::vector<DIST_T>;
-    auto BraveWaterPossibleCoords(const HexMap *hexMap) const -> std::shared_ptr<BraveableTileInfo>;
+    [[nodiscard]] auto BraveWaterPossibleCoords(const HexMap *hexMap) const
+            -> std::shared_ptr<BraveableTileInfo>;
 
     // Create coordinate lookup table for efficient index->coords conversion
-    static auto CreateIndexToCoords(const HexMap *hexMap) -> std::vector<Coords>;
+    [[nodiscard]] static auto CreateIndexToCoords(const HexMap *hexMap) -> std::vector<Coords>;
 
     // Create adjacency lookup table for efficient neighbor access
-    static auto CreateAdjacencyTable(const HexMap *hexMap) -> std::vector<std::array<int, 6>>;
+    [[nodiscard]] 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();
@@ -70,9 +72,9 @@ public:
 
     virtual ~ActionPointDistances() = default;
 
-    virtual auto Distance(int fromIndex, int toIndex) const -> DIST_T = 0;
+    [[nodiscard]] virtual auto Distance(int fromIndex, int toIndex) const -> DIST_T = 0;
 
-    virtual auto Distance(const Coords &from, const Coords &to) const -> DIST_T = 0;
+    [[nodiscard]] virtual auto Distance(const Coords &from, const Coords &to) const -> DIST_T = 0;
 };
 
 class OnDemandActionPointDistances final : public ActionPointDistances {
@@ -91,11 +93,11 @@ public:
 
     ~OnDemandActionPointDistances() override = default;
 
-    auto Distance(const int fromIndex, const int toIndex) const -> int16_t override {
+    [[nodiscard]] auto Distance(const int fromIndex, const int toIndex) const -> int16_t override {
         return distances[fromIndex].get()[toIndex];
     }
 
-    auto Distance(const Coords &from, const Coords &to) const -> int16_t override {
+    [[nodiscard]] auto Distance(const Coords &from, const Coords &to) const -> int16_t override {
         return Distance(ToIndex(from), ToIndex(to));
     }
 };

src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.cpp

@@ -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));

src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp

@@ -22,7 +22,7 @@ struct MapId {
     uint64_t terrainTypesId;
     uint64_t modifierId;
 
-    auto operator==(const MapId& other) const -> bool {
+    [[nodiscard]] auto operator==(const MapId& other) const -> bool {
         return terrainTypesId == other.terrainTypesId && modifierId == other.modifierId;
     }
 };
@@ -34,7 +34,7 @@ struct FullCacheKey {
     bool includeBravingWater;
     int braveWaterCost;
 
-    bool operator==(const FullCacheKey& other) const {
+    [[nodiscard]] 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 {
-    size_t operator()(const FullCacheKey& key) const {
+    [[nodiscard]] 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
-    static auto MakeCacheKey(
+    [[nodiscard]] static auto MakeCacheKey(
             const MapId& mapId,
             const BattalionTypeSPtr& battalionType,
             bool includeBravingWater,
@@ -107,7 +107,7 @@ public:
             bool includeBravingWater,
             int braveWaterActionPointCost = -1) -> const ActionPointDistances*;
 
-    static auto GetMapId(const HexMap* map) -> MapId;
+    [[nodiscard]] 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();
-    static size_t GetThreadLocalCacheSize();
+    [[nodiscard]] static size_t GetThreadLocalCacheSize();
 };
 
 using APDCache = std::shared_ptr<ActionPointDistancesCache>;

src/main/cpp/net/eagle0/shardok/library/action_point_distances/FixedActionPointDistances.cpp

@@ -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());
     }

src/main/cpp/net/eagle0/shardok/library/action_point_distances/FixedActionPointDistances.hpp

@@ -24,7 +24,7 @@ private:
 
 public:
     // Factory method to create FixedActionPointDistances
-    static auto Create(
+    [[nodiscard]] static auto Create(
             const HexMap *map,
             const BattalionTypeSPtr &battalionType,
             bool includeBravingWater,

src/main/cpp/net/eagle0/shardok/library/action_result_applier/ActionResultApplier.cpp

@@ -14,6 +14,7 @@
 #include "src/main/cpp/net/eagle0/shardok/library/action_result_applier/UnitHelpers.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/HexMapHasher.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/unit/Unit.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/util/ActionResultFlatbufferHelpers.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
 
@@ -30,10 +31,6 @@ inline auto GetMutableUnit(GameState *state, UnitId unitId) -> Unit * {
     return const_cast<Unit *>(state->mutable_units()->GetMutableObject(unitId));
 }
 
-inline auto UnitFromBytes(const std::string &unitBytes) -> const Unit & {
-    return *reinterpret_cast<const Unit *>(unitBytes.data());
-}
-
 using net::eagle0::shardok::storage::fb::VictoryCondition;
 using net::eagle0::shardok::storage::fb::VictoryType;
 
@@ -68,7 +65,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;
@@ -101,7 +98,7 @@ void ApplyResolvedUnit(
         GameStateT &inoutState,
         const ResolvedUnitProto &resolvedUnit,
         const double vipCapturedMoraleAdjustment) {
-    const Unit &unit = UnitFromBytes(resolvedUnit.unit_bytes());
+    const Unit unit = UnitFromBytes(resolvedUnit.unit_bytes());
     UnitId unitId = unit.unit_id();
 
     if (unit.has_attached_hero() &&
@@ -169,15 +166,15 @@ void MutatingAddUnits(GameStateW &mutatingState, const ActionResultProto &result
 
     // First pass: check what kind of modifications we need
     for (const auto &unitBytes : result.changed_units_fb()) {
-        const auto *unit = &UnitFromBytes(unitBytes);
-        maxChangedUnitId = std::max(maxChangedUnitId, unit->unit_id());
+        const auto unit = UnitFromBytes(unitBytes);
+        maxChangedUnitId = std::max(maxChangedUnitId, unit.unit_id());
 
-        if (static_cast<unsigned int>(unit->unit_id()) >= mutatingState->units()->size()) {
+        if (static_cast<unsigned int>(unit.unit_id()) >= mutatingState->units()->size()) {
             // Unit ID beyond vector size - must expand
             needsVectorExpansion = true;
             break;  // No point checking further
         } else if (
-                mutatingState->units()->Get(unit->unit_id())->status() ==
+                mutatingState->units()->Get(unit.unit_id())->status() ==
                 net::eagle0::shardok::storage::fb::UnitStatus_RESERVED_SLOT) {
             // Unit wants to use a reserved slot
             needsReservedSlotConversion = true;
@@ -199,8 +196,8 @@ void MutatingAddUnits(GameStateW &mutatingState, const ActionResultProto &result
         // Convert reserved slots to real units in place
         // We only need to process the units that are being changed
         for (const auto &unitBytes : result.changed_units_fb()) {
-            const auto *unit = &UnitFromBytes(unitBytes);
-            auto *mutableUnit = GetMutableUnit(mutatingState.Get(), unit->unit_id());
+            const auto unit = UnitFromBytes(unitBytes);
+            auto *mutableUnit = GetMutableUnit(mutatingState.Get(), unit.unit_id());
             if (mutableUnit->status() ==
                 net::eagle0::shardok::storage::fb::UnitStatus_RESERVED_SLOT) {
                 // Convert this reserved slot to a real unit
@@ -248,12 +245,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);
         }
 
@@ -299,51 +296,48 @@ void MutatingApplyResult(
     const double vipCapturedMoraleAdjustment = settings.Backing().vip_captured_morale_adjustment();
 
     for (const auto &changedUnitBytes : result.changed_units_fb()) {
-        const Unit *changedUnit = &UnitFromBytes(changedUnitBytes);
+        const Unit changedUnit = UnitFromBytes(changedUnitBytes);
 
         internalAssert(
-                changedUnit->unit_id() < static_cast<int32_t>(mutatingGameState->units()->size()),
+                changedUnit.unit_id() < static_cast<int32_t>(mutatingGameState->units()->size()),
                 "Got a changed unit outside acceptable range");
-        const auto battalionSizeAfter = changedUnit->battalion().size();
+        const auto battalionSizeAfter = changedUnit.battalion().size();
 
         const int battalionSizeBefore =
-                (changedUnit->unit_id() < static_cast<int32_t>(initialUnitCount))
-                        ? mutatingGameState->units()
-                                  ->Get(changedUnit->unit_id())
-                                  ->battalion()
-                                  .size()
-                        : changedUnit->battalion().size();
+                (changedUnit.unit_id() < static_cast<int32_t>(initialUnitCount))
+                        ? mutatingGameState->units()->Get(changedUnit.unit_id())->battalion().size()
+                        : changedUnit.battalion().size();
 
-        auto status = changedUnit->status();
-        if (IsDestroyed(*changedUnit)) {
+        auto status = changedUnit.status();
+        if (IsDestroyed(changedUnit)) {
             status =
-                    changedUnit->has_attached_hero()
+                    changedUnit.has_attached_hero()
                             ? net::eagle0::shardok::storage::fb::UnitStatus_CAPTURED_UNIT
                             : net::eagle0::shardok::storage::fb::UnitStatus_DESTROYED_SUMMONED_UNIT;
 
             ApplyResolvedUnit(
                     mutatingGameState.Get(),
-                    *changedUnit,
+                    changedUnit,
                     status,
                     vipCapturedMoraleAdjustment,
                     settings);
         }
 
         // Capture old position before applying changes
-        auto *mutableUnit = GetMutableUnit(mutatingGameState.Get(), changedUnit->unit_id());
+        auto *mutableUnit = GetMutableUnit(mutatingGameState.Get(), changedUnit.unit_id());
         const auto oldLocation = mutableUnit->location();
 
-        fb::ApplyUnit(mutableUnit, changedUnit, status);
+        fb::ApplyUnit(mutableUnit, &changedUnit, status);
 
         // Update occupied tiles bitfield if position changed
-        const auto &newLocation = changedUnit->location();
+        const auto &newLocation = changedUnit.location();
         if (oldLocation.row() != newLocation.row() ||
             oldLocation.column() != newLocation.column()) {
             mutatingGameState.UpdateOccupiedTile(oldLocation, newLocation);
         }
 
         if (battalionSizeBefore != battalionSizeAfter) {
-            if (changedUnit->battalion().type() ==
+            if (changedUnit.battalion().type() ==
                 net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD) {
                 if (battalionSizeAfter > battalionSizeBefore) {
                     // Undead consumed some bodies
@@ -355,7 +349,7 @@ void MutatingApplyResult(
                 if (battalionSizeAfter > battalionSizeBefore) {
                     std::ostringstream stringStream;
                     stringStream << "Battalion got larger! Was " << battalionSizeBefore << ", now "
-                                 << changedUnit << " result was " << result.DebugString();
+                                 << &changedUnit << " result was " << result.DebugString();
                     throw ShardokInternalErrorException(stringStream.str());
                 }
 
@@ -365,7 +359,7 @@ void MutatingApplyResult(
                 if (newCount != 0) {
                     newArmament =
                             (mutatingGameState->dead_count() * mutatingGameState->dead_armament() +
-                             casualties * changedUnit->battalion().armament()) /
+                             casualties * changedUnit.battalion().armament()) /
                             newCount;
                 }
 
@@ -385,10 +379,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);
     }
 

src/main/cpp/net/eagle0/shardok/library/action_result_applier/ActionResultApplier.hpp

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

src/main/cpp/net/eagle0/shardok/library/action_result_applier/BUILD.bazel

@@ -16,6 +16,7 @@ cc_library(
         "//src/main/cpp/net/eagle0/shardok/library:game_state_w",
         "//src/main/cpp/net/eagle0/shardok/library/map:hex_map_hasher",
         "//src/main/cpp/net/eagle0/shardok/library/unit",
+        "//src/main/cpp/net/eagle0/shardok/library/util:action_result_flatbuffer_helpers",
         "//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
         "//src/main/protobuf/net/eagle0/shardok/storage:action_result_cc_proto",
     ],

src/main/cpp/net/eagle0/shardok/library/action_result_applier/GameStateCopier.cpp

@@ -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) {

src/main/cpp/net/eagle0/shardok/library/action_result_applier/GameStateCopier.hpp

@@ -9,7 +9,8 @@
 
 namespace shardok {
 
-auto CopyWithExtraUnits(const GameStateW& original, int additionalCount) -> GameStateW;
+[[nodiscard]] auto CopyWithExtraUnits(const GameStateW& original, int additionalCount)
+        -> GameStateW;
 
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/library/action_result_applier/UnitHelpers.cpp

@@ -8,7 +8,7 @@
 
 namespace shardok::fb {
 
-using namespace net::eagle0::shardok::storage::fb;
+using net::eagle0::shardok::storage::fb::UnitStatus;
 
 auto ApplyUnit(
         Unit* toUnit,

src/main/cpp/net/eagle0/shardok/library/actions/FallIntoWaterAction.cpp

@@ -17,7 +17,7 @@
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
 
 namespace shardok {
-using namespace net::eagle0::shardok::common;
+using net::eagle0::shardok::common::WATER_DAMAGE;
 
 auto EscapeChance(
         const int base,
@@ -65,7 +65,7 @@ auto EscapeChance(
 }
 
 auto ToVector(const Units &units) -> vector<const Unit *> {
-    auto v = vector<const Unit *>{};
+    vector<const Unit *> v{};
     v.reserve(units.size());
     for (const Unit *u : units) { v.push_back(u); }
     return v;

src/main/cpp/net/eagle0/shardok/library/actions/NewRoundAction.cpp

@@ -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::optional<ActionResultProto>();
+        return std::nullopt;
     }
 }
 

src/main/cpp/net/eagle0/shardok/library/actions/StartPlayerTurnAction.cpp

@@ -60,7 +60,8 @@ auto StartPlayerTurnAction::InternalExecute(
                     ->Get(startingState->month() - 1)
                     ->is_winter() &&
             !inCastle) {
-            effectiveBase += float(settingsGetter.Backing().winter_morale_adjustment());
+            effectiveBase +=
+                    static_cast<float>(settingsGetter.Backing().winter_morale_adjustment());
         }
         float moraleDiff = effectiveBase - updatedUnit.battalion().morale();
         MutatingMaybeAdjustMorale(

src/main/cpp/net/eagle0/shardok/library/actions/UndeadChangeAction.cpp

@@ -34,7 +34,8 @@ auto UndeadChangeAction::InternalExecute(
         int growth = newCount - decayedSize;
 
         float newArmament =
-                float(unit->battalion().armament() * decayedSize + armament * growth) / newCount;
+                static_cast<float>(unit->battalion().armament() * decayedSize + armament * growth) /
+                newCount;
 
         auto newUnit = *unit;
         newUnit.mutable_battalion().mutate_size(newCount);

src/main/cpp/net/eagle0/shardok/library/actions/UpdateGameStatusAction.cpp

@@ -25,10 +25,9 @@ static inline auto GameIsOver(const GameStatusFb* status) -> bool {
 }
 
 auto UpdateGameStatusAction::GetPlayerInfo(int playerId) const -> const PlayerInfoFb* {
-    return *std::find_if(
-            std::begin(*gameState->player_infos()),
-            std::end(*gameState->player_infos()),
-            [playerId](const PlayerInfoFb* pi) { return pi->player_id() == playerId; });
+    return *std::ranges::find_if(*gameState->player_infos(), [playerId](const PlayerInfoFb* pi) {
+        return pi->player_id() == playerId;
+    });
 }
 
 static inline auto HasVictoryCondition(const PlayerInfoFb* pi, const VictoryCondition condition)

src/main/cpp/net/eagle0/shardok/library/actions/UpdateOpponentKnowledgeAction.cpp

@@ -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

src/main/cpp/net/eagle0/shardok/library/command_factories/BraveWaterCommandFactory.cpp

@@ -126,7 +126,7 @@ void BraveWaterCommandFactory::AddAvailableBraveWaterCommands(
             }
 
             for (const auto &target : braveWaterTargets) {
-                std::optional<UnitId> ambusher = std::optional<UnitId>();
+                std::optional<UnitId> ambusher = std::nullopt;
                 const auto &targetOccupant = Occupant(units, target);
                 if (targetOccupant) { ambusher = targetOccupant->unit_id(); }
                 commands.push_back(BraveWaterCommandFactory(settings)

src/main/cpp/net/eagle0/shardok/library/command_factories/CommandFactoriesList.hpp

@@ -19,7 +19,7 @@ private:
 public:
     explicit CommandFactoriesList(const SettingsGetter& settings);
 
-    auto GetFactories() const -> std::vector<std::shared_ptr<const CommandFactory>>;
+    [[nodiscard]] auto GetFactories() const -> std::vector<std::shared_ptr<const CommandFactory>>;
 };
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/library/command_factories/CommandFactory.hpp

@@ -41,7 +41,7 @@ public:
 
     virtual void AddAvailableCommands(CommandList& commands, const CommandParams& params) const = 0;
 
-    virtual auto IncludeInFollowUps() const -> bool { return true; }
+    [[nodiscard]] virtual auto IncludeInFollowUps() const -> bool { return true; }
 };
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/library/command_factories/EvacuatePrisonersCommandFactory.hpp

@@ -11,7 +11,7 @@
 namespace shardok {
 
 class EvacuatePrisonersCommandFactory : public CommandFactory {
-    const SettingsGetter& settings;
+    const SettingsGetter settings;
 
 public:
     explicit EvacuatePrisonersCommandFactory(const SettingsGetter& getter);

src/main/cpp/net/eagle0/shardok/library/command_factories/FearCommandFactory.cpp

@@ -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) {

src/main/cpp/net/eagle0/shardok/library/command_factories/FleeCommandFactory.cpp

@@ -61,9 +61,11 @@ void FleeCommandFactory::AddAvailableFleeCommands(
             const auto *occupant = Occupant(allUnits, twoAwayCoords);
             if (occupant && !occupant->hidden()) {
                 if (std::ranges::contains(allyPids, occupant->player_id())) {
-                    adjacentFriendliesMod += int32_t(perAdjacentFriendly * adjustmentForTwoAway);
+                    adjacentFriendliesMod +=
+                            static_cast<int32_t>(perAdjacentFriendly * adjustmentForTwoAway);
                 } else {
-                    adjacentEnemiesMod += int32_t(perAdjacentEnemy * adjustmentForTwoAway);
+                    adjacentEnemiesMod +=
+                            static_cast<int32_t>(perAdjacentEnemy * adjustmentForTwoAway);
                 }
             }
         }