mirror of
https://github.com/nolen777/eagle0.git
synced 2026-07-29 09:15:42 +00:00
Compare commits
9
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 admin
|
72ba7949f6 | ||
|
admin
|
8d37c07f24 | ||
|
admin
|
44b3467306 | ||
|
admin
|
5d66603e1b | ||
|
admin
|
96798a6ad5 | ||
|
admin
|
9273fb0134 | ||
|
admin
|
a874e973e2 | ||
|
admin
|
46a88d17c1 | ||
|
admin
|
c391ce0a4b |
@@ -1,8 +1,5 @@
|
||||
bazel-1.0.0.bazelrc
|
||||
|
||||
# for now: filter out annoying TASTY warnings
|
||||
common --ui_event_filters=-INFO
|
||||
|
||||
common --enable_bzlmod
|
||||
|
||||
# Don't use toolchains_llvm for the swift app build
|
||||
@@ -19,9 +16,9 @@ common --worker_sandboxing
|
||||
common --local_test_jobs=64
|
||||
common --jobs=64
|
||||
|
||||
common --cxxopt="--std=c++23"
|
||||
common --cxxopt="--std=c++20"
|
||||
common --cxxopt="-Wno-deprecated-non-prototype"
|
||||
common --host_cxxopt="--std=c++23"
|
||||
common --host_cxxopt="--std=c++20"
|
||||
|
||||
common --javacopt="-Xlint:-options"
|
||||
|
||||
@@ -29,9 +26,6 @@ common --javacopt="-Xlint:-options"
|
||||
common --linkopt=-Wl
|
||||
common:macos --linkopt=-Wl,-no_warn_duplicate_libraries
|
||||
|
||||
# Fix Xcode version caching issue - avoids need for `bazel clean --expunge` after Xcode updates
|
||||
common:macos --repo_env=DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
|
||||
|
||||
common --java_language_version=17
|
||||
common --java_runtime_version=remotejdk_17
|
||||
common --tool_java_language_version=17
|
||||
|
||||
@@ -6,7 +6,4 @@
|
||||
*.bytes filter=lfs diff=lfs merge=lfs -text
|
||||
*.psd filter=lfs diff=lfs merge=lfs -text
|
||||
*.ttf filter=lfs diff=lfs merge=lfs -text
|
||||
# Exclude pre-existing font files that were committed as blobs (not LFS pointers)
|
||||
src/main/csharp/**/GUI[[:space:]]Pro[[:space:]]Kit*/**/*.ttf !filter !diff !merge
|
||||
src/main/csharp/**/Modern[[:space:]]UI[[:space:]]Pack/**/*.ttf !filter !diff !merge
|
||||
*.herodata filter=lfs diff=lfs merge=lfs -text
|
||||
|
||||
@@ -34,54 +34,10 @@ jobs:
|
||||
with:
|
||||
lfs: false
|
||||
- name: Run tests
|
||||
id: test
|
||||
continue-on-error: true
|
||||
run: bazel test --build_event_json_file=test.json //src/test/... //src/main/go/...
|
||||
- name: Collect failed test logs
|
||||
if: always()
|
||||
run: |
|
||||
# Remove any existing failed_test_logs directory and create fresh
|
||||
rm -rf failed_test_logs
|
||||
mkdir -p failed_test_logs
|
||||
# Extract failed test targets from test.json and copy their logs
|
||||
# The test.json is in JSONL format - one JSON object per line
|
||||
# We look for lines with testResult that have a status other than PASSED
|
||||
if [ -f test.json ]; then
|
||||
grep '"testResult"' test.json | \
|
||||
grep '"status"' | \
|
||||
grep -v '"status":"PASSED"' | \
|
||||
grep -o '"label":"[^"]*"' | \
|
||||
cut -d'"' -f4 | \
|
||||
sort -u | \
|
||||
while read target; do
|
||||
# Convert target like //src/test/cpp/...:test_name to path
|
||||
log_path=$(echo "$target" | sed 's|^//||' | sed 's|:|/|')
|
||||
if [ -f "bazel-testlogs/$log_path/test.log" ]; then
|
||||
log_name=$(echo "$log_path" | tr '/' '_')
|
||||
if cp "bazel-testlogs/$log_path/test.log" "failed_test_logs/${log_name}.log"; then
|
||||
echo "Collected log for failed test: $target"
|
||||
else
|
||||
echo "Error: Failed to copy log for $target"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
# List what we collected
|
||||
echo "Collected logs:"
|
||||
ls -lh failed_test_logs/ 2>/dev/null || echo "No logs collected"
|
||||
- name: Archive test results
|
||||
if: always()
|
||||
if: success() || failure()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: test.json
|
||||
path: test.json
|
||||
- name: Archive failed test logs
|
||||
if: always()
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: failed-test-logs
|
||||
path: failed_test_logs/
|
||||
if-no-files-found: ignore
|
||||
- name: Fail if tests failed
|
||||
if: steps.test.outcome == 'failure'
|
||||
run: exit 1
|
||||
|
||||
@@ -1,63 +0,0 @@
|
||||
name: Build Linux Sysroot
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
version:
|
||||
description: 'Sysroot version (e.g., v2, v3)'
|
||||
required: true
|
||||
default: 'v2'
|
||||
type: string
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
build-sysroot:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Build sysroot
|
||||
run: ./tools/sysroot/build_sysroot.sh
|
||||
|
||||
- name: Upload sysroot artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: ubuntu-noble-sysroot
|
||||
path: tools/sysroot/output/
|
||||
|
||||
- name: Install AWS CLI
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y awscli
|
||||
|
||||
- name: Upload to DigitalOcean Spaces
|
||||
env:
|
||||
AWS_ACCESS_KEY_ID: ${{ secrets.ACCESS_KEY_ID }}
|
||||
AWS_SECRET_ACCESS_KEY: ${{ secrets.SECRET_KEY }}
|
||||
run: |
|
||||
# Upload sysroot tarball to DO Spaces
|
||||
aws s3 cp tools/sysroot/output/ubuntu_noble_amd64_sysroot.tar.xz \
|
||||
s3://eagle0/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.tar.xz \
|
||||
--endpoint-url https://sfo3.digitaloceanspaces.com \
|
||||
--acl public-read
|
||||
|
||||
# Upload sha256 file
|
||||
aws s3 cp tools/sysroot/output/ubuntu_noble_amd64_sysroot.sha256 \
|
||||
s3://eagle0/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.sha256 \
|
||||
--endpoint-url https://sfo3.digitaloceanspaces.com \
|
||||
--acl public-read
|
||||
|
||||
echo ""
|
||||
echo "=== Sysroot uploaded ==="
|
||||
echo "URL: https://eagle0.sfo3.digitaloceanspaces.com/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.tar.xz"
|
||||
echo "SHA256: $(cat tools/sysroot/output/ubuntu_noble_amd64_sysroot.sha256)"
|
||||
echo ""
|
||||
echo "Update MODULE.bazel with:"
|
||||
echo "sysroot("
|
||||
echo " name = \"linux_sysroot\","
|
||||
echo " sha256 = \"$(cat tools/sysroot/output/ubuntu_noble_amd64_sysroot.sha256)\","
|
||||
echo " urls = [\"https://eagle0.sfo3.digitaloceanspaces.com/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.tar.xz\"],"
|
||||
echo ")"
|
||||
@@ -1,72 +0,0 @@
|
||||
name: Docker Build and Push
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ "main" ]
|
||||
paths:
|
||||
- 'src/main/cpp/**'
|
||||
- 'src/main/scala/**'
|
||||
- 'src/main/protobuf/**'
|
||||
- 'src/main/resources/**'
|
||||
- 'ci/BUILD.bazel'
|
||||
- 'MODULE.bazel'
|
||||
- '.github/workflows/docker_build.yml'
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
push_images:
|
||||
description: 'Push images to container registry'
|
||||
required: true
|
||||
default: 'false'
|
||||
type: boolean
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
build-eagle:
|
||||
runs-on: self-hosted
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
lfs: false
|
||||
|
||||
- name: Build Eagle Docker image
|
||||
run: bazel build //ci:eagle_server_image
|
||||
|
||||
- name: Login to DigitalOcean Container Registry
|
||||
if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
|
||||
env:
|
||||
DO_TOKEN: ${{ secrets.DO_REGISTRY_TOKEN }}
|
||||
run: |
|
||||
mkdir -p ~/.docker
|
||||
AUTH=$(echo -n "${DO_TOKEN}:${DO_TOKEN}" | base64)
|
||||
echo "{\"auths\":{\"registry.digitalocean.com\":{\"auth\":\"${AUTH}\"}}}" > ~/.docker/config.json
|
||||
|
||||
- name: Push Eagle image to DO registry
|
||||
if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
|
||||
run: bazel run //ci:eagle_server_push
|
||||
|
||||
build-shardok:
|
||||
runs-on: self-hosted
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v4
|
||||
with:
|
||||
lfs: false
|
||||
|
||||
- name: Build Shardok Docker image (cross-compile for Linux)
|
||||
run: bazel build --platforms=//:linux_x86_64 //ci:shardok_server_image
|
||||
|
||||
- name: Login to DigitalOcean Container Registry
|
||||
if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
|
||||
env:
|
||||
DO_TOKEN: ${{ secrets.DO_REGISTRY_TOKEN }}
|
||||
run: |
|
||||
mkdir -p ~/.docker
|
||||
AUTH=$(echo -n "${DO_TOKEN}:${DO_TOKEN}" | base64)
|
||||
echo "{\"auths\":{\"registry.digitalocean.com\":{\"auth\":\"${AUTH}\"}}}" > ~/.docker/config.json
|
||||
|
||||
- name: Push Shardok image to DO registry
|
||||
if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
|
||||
run: bazel run --platforms=//:linux_x86_64 //ci:shardok_server_push
|
||||
+2
-2
@@ -20,7 +20,7 @@ project/boot/
|
||||
project/plugins/project/
|
||||
project/target/
|
||||
bazel-bin
|
||||
bazel-eagle0*
|
||||
bazel-eagle0
|
||||
bazel-out
|
||||
bazel-testlogs
|
||||
.ijwb
|
||||
@@ -32,9 +32,9 @@ buildWin.sh
|
||||
__pycache__/
|
||||
scripts/refresh_name_layers/vendor/
|
||||
scripts/refresh_name_layers/refresh_name_layers.zip
|
||||
.pre-commit-config.yaml
|
||||
.bazelbsp
|
||||
.bsp
|
||||
.metals
|
||||
api_keys.txt
|
||||
|
||||
src/main/csharp/net/eagle0/clients/unity/eagle0/ProjectSettings/Packages/com.unity.dedicated-server/
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
# See https://pre-commit.com for more information
|
||||
# See https://pre-commit.com/hooks.html for more hooks
|
||||
repos:
|
||||
- repo: https://github.com/pre-commit/pre-commit-hooks
|
||||
rev: v4.3.0
|
||||
hooks:
|
||||
- id: check-added-large-files
|
||||
- id: no-commit-to-branch
|
||||
args: [--branch, main]
|
||||
- repo: https://github.com/pocc/pre-commit-hooks
|
||||
rev: v1.3.5
|
||||
hooks:
|
||||
- id: clang-format
|
||||
args: [-i, --no-diff]
|
||||
types_or: ["c++", "c#"]
|
||||
exclude: ^src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins
|
||||
- repo: https://github.com/yoheimuta/protolint
|
||||
rev: v0.42.2
|
||||
hooks:
|
||||
- id: protolint
|
||||
args: [-fix]
|
||||
exclude: ^src/main/protobuf/scalapb/
|
||||
- repo: local
|
||||
hooks:
|
||||
- id: scalafmt
|
||||
name: scalafmt
|
||||
language: system
|
||||
entry: scalafmt -i -f
|
||||
types_or: ["scala"]
|
||||
- repo: local
|
||||
hooks:
|
||||
- id: gazelle
|
||||
name: gazelle
|
||||
language: system
|
||||
entry: ./scripts/pre-commit-gazelle.sh
|
||||
files: '(\.go|\.proto|BUILD\.bazel|BUILD|WORKSPACE|WORKSPACE\.bazel|\.bzl)$'
|
||||
pass_filenames: false
|
||||
- repo: local
|
||||
hooks:
|
||||
- id: update-action-result-types
|
||||
name: update-action-result-types
|
||||
language: system
|
||||
entry: ./scripts/updateActionResultTypes.sh
|
||||
files: 'src/main/protobuf/net/eagle0/eagle/common/action_result_type.proto'
|
||||
+2
-47
@@ -1,47 +1,2 @@
|
||||
version = "3.9.9"
|
||||
runner.dialect = scala3
|
||||
rewrite.scala3.convertToNewSyntax = true
|
||||
# Keep braces, don't use significant indentation
|
||||
# rewrite.scala3.removeOptionalBraces = yes
|
||||
rewrite.scala3.insertEndMarkerMinLines = 15
|
||||
rewrite.scala3.removeEndMarkerMaxLines = 14
|
||||
|
||||
# Strip margin settings
|
||||
assumeStandardLibraryStripMargin = false
|
||||
align.stripMargin = true
|
||||
|
||||
# Code Style & Formatting
|
||||
align.preset = more
|
||||
align.multiline = true
|
||||
align.arrowEnumeratorGenerator = true
|
||||
spaces.inImportCurlyBraces = false
|
||||
spaces.beforeContextBoundColon = Never
|
||||
maxColumn = 120
|
||||
docstrings.style = Asterisk
|
||||
docstrings.wrap = yes
|
||||
|
||||
# Method chaining
|
||||
newlines.beforeCurlyLambdaParams = multilineWithCaseOnly
|
||||
optIn.breakChainOnFirstMethodDot = true
|
||||
includeCurlyBraceInSelectChains = false
|
||||
|
||||
# Advanced Scala 3 Features
|
||||
rewrite.scala3.countEndMarkerLines = all
|
||||
rewrite.redundantBraces.stringInterpolation = true
|
||||
rewrite.redundantBraces.parensForOneLineApply = true
|
||||
|
||||
# Project-Specific Considerations
|
||||
optIn.annotationNewlines = true
|
||||
runner.optimizer.forceConfigStyleMinArgCount = 3
|
||||
|
||||
# Import sorting configuration
|
||||
rewrite.rules = [SortImports, RedundantBraces, RedundantParens]
|
||||
rewrite.imports.sort = scalastyle
|
||||
rewrite.imports.groups = [
|
||||
["java\\..*"],
|
||||
["javax\\..*"],
|
||||
["scala\\..*"],
|
||||
[".*"]
|
||||
]
|
||||
rewrite.imports.contiguousGroups = only
|
||||
rewrite.trailingCommas.style = never
|
||||
version = "3.6.1"
|
||||
runner.dialect = scala213
|
||||
|
||||
@@ -3,15 +3,6 @@ load("@io_bazel_rules_go//go:def.bzl", "nogo")
|
||||
|
||||
package(default_visibility = ["//visibility:public"])
|
||||
|
||||
# Platform for cross-compiling to Linux x86_64
|
||||
platform(
|
||||
name = "linux_x86_64",
|
||||
constraint_values = [
|
||||
"@platforms//os:linux",
|
||||
"@platforms//cpu:x86_64",
|
||||
],
|
||||
)
|
||||
|
||||
gazelle(name = "gazelle")
|
||||
|
||||
# gazelle:proto file
|
||||
|
||||
@@ -4,32 +4,26 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
|
||||
|
||||
## Project Overview
|
||||
|
||||
Eagle0 is a multi-language gaming system combining strategic turn-based gameplay (Eagle) with tactical hex-based
|
||||
combat (Shardok). The system integrates LLM-based narrative generation and supports both human and AI players.
|
||||
Eagle0 is a multi-language gaming system combining strategic turn-based gameplay (Eagle) with tactical hex-based combat (Shardok). The system integrates LLM-based narrative generation and supports both human and AI players.
|
||||
|
||||
## Architecture
|
||||
|
||||
**Three-Tier Game System:**
|
||||
|
||||
- **Unity Client (C#)**: Real-time strategy game client with integrated tactical combat UI
|
||||
- **Eagle (Scala)**: Strategic layer managing turn-based gameplay, diplomacy, hero progression, and province control
|
||||
- **Shardok (C++)**: Tactical layer handling real-time hex-based combat simulation with performance-critical battle
|
||||
resolution
|
||||
- **Shardok (C++)**: Tactical layer handling real-time hex-based combat simulation with performance-critical battle resolution
|
||||
|
||||
**Communication Flow:**
|
||||
|
||||
```
|
||||
Unity Client ↔ Eagle (gRPC streaming) ↔ Shardok (internal gRPC)
|
||||
```
|
||||
|
||||
**Key Entry Points:**
|
||||
|
||||
- `/src/main/csharp/net/eagle0/clients/unity/eagle0/` - Unity C# game client
|
||||
- `/src/main/scala/net/eagle0/eagle/Main.scala` - Eagle strategic game server
|
||||
- `/src/main/cpp/net/eagle0/shardok/shardok_server_main.cpp` - Shardok tactical server
|
||||
|
||||
**Protocol Buffer Architecture:**
|
||||
|
||||
- Extensive use of protobuf for type-safe communication
|
||||
- Separate packages: `api/` (client-facing), `internal/` (server state), `views/` (client projections)
|
||||
- Event sourcing pattern with immutable action history
|
||||
@@ -37,17 +31,13 @@ Unity Client ↔ Eagle (gRPC streaming) ↔ Shardok (internal gRPC)
|
||||
## Essential Commands
|
||||
|
||||
### Building
|
||||
|
||||
```bash
|
||||
# Build Eagle server (Scala strategic layer)
|
||||
bazel build //src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar
|
||||
|
||||
# Build Shardok server (C++ tactical layer)
|
||||
# Build Shardok server (C++ tactical layer)
|
||||
bazel build -c opt //src/main/cpp/net/eagle0/shardok:shardok-server
|
||||
|
||||
# Shardok server includes both AI algorithms
|
||||
bazel build //src/main/cpp/net/eagle0/shardok:shardok-server
|
||||
|
||||
# Build Unity/C# client
|
||||
./scripts/build_protos.sh # Protocol buffer generation for Unity
|
||||
./scripts/build_plugins.sh # Native plugins for all platforms
|
||||
@@ -56,7 +46,6 @@ bazel build //src/main/cpp/net/eagle0/shardok:shardok-server
|
||||
```
|
||||
|
||||
### Running Services
|
||||
|
||||
```bash
|
||||
# Eagle server (port 40032)
|
||||
bazel run //src/main/scala/net/eagle0/eagle:eagle_server -- --eagle-grpc-port 40032
|
||||
@@ -68,7 +57,6 @@ bazel run //src/main/cpp/net/eagle0/shardok:shardok-server --compilation_mode=op
|
||||
```
|
||||
|
||||
### Testing
|
||||
|
||||
```bash
|
||||
# Run all tests
|
||||
bazel test //src/test/... //src/main/go/...
|
||||
@@ -79,24 +67,12 @@ bazel test //src/test/cpp/... # C++ Shardok tests
|
||||
```
|
||||
|
||||
### Code Generation
|
||||
|
||||
```bash
|
||||
bazel run gazelle # Update Go build files
|
||||
./scripts/updateActionResultTypes.sh # Update protocol buffer mappings
|
||||
```
|
||||
|
||||
### Pre-Commit Checklist
|
||||
|
||||
**MANDATORY: Before running `git commit`, verify:**
|
||||
|
||||
1. **If you modified any BUILD.bazel file:** Run `bazel run gazelle` and stage any changes it makes
|
||||
2. **If you modified C++ or C# files:** Run `clang-format -i` on the modified files
|
||||
3. **If you modified Scala files:** scalafmt will run automatically via pre-commit hook
|
||||
|
||||
The pre-commit hook runs gazelle but only checks if it succeeds - it does NOT verify the BUILD files are in canonical format. The `gazelle_test` will fail if deps are not alphabetically sorted. **Always run gazelle manually after BUILD file changes.**
|
||||
|
||||
### Code Formatting
|
||||
|
||||
```bash
|
||||
# ALWAYS run clang-format after making any C++ or C# code changes
|
||||
clang-format -i <modified_files>
|
||||
@@ -108,95 +84,26 @@ find . -name "*.cpp" -o -name "*.hpp" | xargs clang-format -i
|
||||
find . -name "*.cs" | xargs clang-format -i
|
||||
```
|
||||
|
||||
### Static Analysis
|
||||
|
||||
```bash
|
||||
# Run clang-tidy static analysis on C++ files
|
||||
# Note: This may show some header include errors but will still analyze the main file
|
||||
bazel run @llvm_toolchain//:clang-tidy -- --checks='readability-*,bugprone-*,clang-analyzer-*' <file_path> -- -I/Users/dancrosby/CodingProjects/github/eagle0 -std=c++23
|
||||
|
||||
# Example for AI files:
|
||||
bazel run @llvm_toolchain//:clang-tidy -- --checks='readability-*,bugprone-*,clang-analyzer-*' /Users/dancrosby/CodingProjects/github/eagle0/src/main/cpp/net/eagle0/shardok/ai/AIUnitScoreCalculator.cpp -- -I/Users/dancrosby/CodingProjects/github/eagle0 -std=c++23
|
||||
```
|
||||
|
||||
## AI Algorithm Selection
|
||||
|
||||
Eagle0 supports two AI algorithms for tactical combat decision-making:
|
||||
|
||||
### Iterative Deepening AI (Default)
|
||||
|
||||
The original minimax-based AI with sophisticated randomness handling:
|
||||
|
||||
- **Advantages**: Proven, sophisticated randomness evaluation, comprehensive lookahead
|
||||
- **Use cases**: Production builds, scenarios requiring precise evaluation
|
||||
- **Performance**: Single-threaded, thorough evaluation
|
||||
|
||||
### Monte Carlo Tree Search AI (MCTS)
|
||||
|
||||
Modern MCTS-based AI with multithreading support:
|
||||
|
||||
- **Advantages**: Multithreaded, better performance on modern CPUs, anytime algorithm
|
||||
- **Use cases**: Performance testing, scenarios requiring fast decisions
|
||||
- **Performance**: Multithreaded, adaptive depth based on time budget
|
||||
|
||||
### Switching Between Algorithms
|
||||
|
||||
The algorithm is selected at **runtime** via the ShardokAIClient constructor:
|
||||
|
||||
```cpp
|
||||
// Using Iterative Deepening AI (default)
|
||||
ShardokAIClient client(playerId, isDefender, hexMap, settings);
|
||||
// OR explicitly:
|
||||
ShardokAIClient client(playerId, isDefender, hexMap, settings, AIAlgorithmType::ITERATIVE_DEEPENING);
|
||||
|
||||
// Using MCTS AI
|
||||
ShardokAIClient client(playerId, isDefender, hexMap, settings, AIAlgorithmType::MCTS);
|
||||
```
|
||||
|
||||
```bash
|
||||
# Build the server (includes both AI algorithms)
|
||||
bazel build //src/main/cpp/net/eagle0/shardok:shardok-server
|
||||
|
||||
# Test both algorithms
|
||||
bazel test //src/test/cpp/net/eagle0/shardok/ai:ai_iterative_deepening_test
|
||||
bazel test //src/test/cpp/net/eagle0/shardok/ai:ai_mcts_test # If available
|
||||
|
||||
# Performance tests
|
||||
./scripts/ai_perf_test.sh # Uses whatever algorithm the server is configured to use
|
||||
```
|
||||
|
||||
Both implementations are compatible with all existing interfaces and produce the same `SearchResult` structure.
|
||||
|
||||
**Note**: Both implementations are documented in `src/main/cpp/net/eagle0/shardok/ai/AI_SCORING_SYSTEM.md`, including
|
||||
recommendations for improving MCTS randomness handling.
|
||||
|
||||
The AI algorithm selection is made at runtime when creating ShardokAIClient instances, allowing different AI strategies
|
||||
to be used for different players or game situations within the same server process.
|
||||
|
||||
## Language-Specific Patterns
|
||||
|
||||
**Scala (Strategic Layer):**
|
||||
|
||||
- Use `EngineImpl.scala` for core game logic modifications
|
||||
- Follow event sourcing pattern - all changes through immutable actions
|
||||
- gRPC streaming for real-time client updates via `EagleServiceImpl.scala`
|
||||
- LLM integration in `/common/llm_integration/` for narrative generation
|
||||
|
||||
**C++ (Tactical Layer):**
|
||||
|
||||
- Performance-critical combat in `ShardokEngine.hpp/.cpp`
|
||||
- FlatBuffers for efficient serialization in `/flatbuffer/` directory
|
||||
- AI systems in `/ai/` subdirectory with pluggable strategy selectors
|
||||
- Extensive unit testing with Google Test framework
|
||||
|
||||
**Protocol Buffers:**
|
||||
|
||||
- Three-layer structure: `api/` (client), `internal/` (server), `views/` (projections)
|
||||
- Use `shardok_internal_interface.proto` for Eagle-Shardok communication
|
||||
- Maintain backward compatibility when modifying existing messages
|
||||
|
||||
**C# (Unity Client):**
|
||||
|
||||
- Located in `/src/main/csharp/net/eagle0/clients/unity/eagle0/`
|
||||
- Uses Unity 6 (6000.0.32f1) with comprehensive protobuf integration (100+ .proto files)
|
||||
- Key components: `EagleConnection.cs` (gRPC client), `EagleGameController.cs` (main game logic)
|
||||
@@ -205,7 +112,6 @@ to be used for different players or game situations within the same server proce
|
||||
- Seamless transition between strategic gameplay and hex-based tactical combat
|
||||
|
||||
**Go (Build Tools):**
|
||||
|
||||
- Build automation and code generation utilities
|
||||
- AWS S3 integration for deployment artifacts
|
||||
|
||||
@@ -216,31 +122,6 @@ to be used for different players or game situations within the same server proce
|
||||
- Map validation tests ensure game content integrity
|
||||
- Use `GameSettings_test_utils.cpp` and `ShardokEngineBasedTestData.cpp` for C++ test helpers
|
||||
|
||||
### Scala Testing Patterns
|
||||
|
||||
**Use `inside()` instead of `asInstanceOf` for type matching in tests:**
|
||||
|
||||
Never use `asInstanceOf` in tests. Instead, use ScalaTest's `inside()` pattern for safe type matching:
|
||||
|
||||
```scala
|
||||
// BAD - don't do this
|
||||
val changedHero = result.changedHeroes.head.asInstanceOf[ChangedHeroC]
|
||||
changedHero.heroId shouldBe 19
|
||||
|
||||
// GOOD - use inside() pattern
|
||||
import org.scalatest.Inside.inside
|
||||
|
||||
inside(result.changedHeroes.head) { case changedHero: ChangedHeroC =>
|
||||
changedHero.heroId shouldBe 19
|
||||
changedHero.vigorChange shouldBe StatDelta(17.2)
|
||||
}
|
||||
```
|
||||
|
||||
The `inside()` pattern:
|
||||
- Provides better error messages when the type doesn't match
|
||||
- Is idiomatic ScalaTest
|
||||
- Works with pattern matching for more complex assertions
|
||||
|
||||
## Performance Testing
|
||||
|
||||
When making performance-related changes to the AI or engine:
|
||||
@@ -272,38 +153,10 @@ done
|
||||
```
|
||||
|
||||
**Important notes:**
|
||||
|
||||
- Run tests multiple times (3-5) to account for performance variance
|
||||
- Focus on commands evaluated at each depth rather than total commands
|
||||
- Commands at different depths aren't directly comparable (depth 3 is more valuable than depth 2)
|
||||
- **Always test performance changes** - what seems like an optimization may sometimes have unexpected overhead or
|
||||
behavior changes.
|
||||
|
||||
## Troubleshooting Scala Build Errors
|
||||
|
||||
### MissingType Errors
|
||||
|
||||
When you see errors like:
|
||||
```
|
||||
dotty.tools.dotc.core.MissingType: Cannot resolve reference to type net.eagle0.eagle.internal.game_state.type.GameState
|
||||
```
|
||||
|
||||
**This is NOT a Scala compiler crash.** This is a missing dependency in BUILD.bazel.
|
||||
|
||||
**How to fix:**
|
||||
1. Identify the missing type from the error message (e.g., `game_state.GameState`)
|
||||
2. Find the Bazel target that provides this type (e.g., `//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto`)
|
||||
3. Add it to the `deps` of the failing target
|
||||
4. If the type appears in a public method signature, also add it to `exports` so downstream targets can see it
|
||||
|
||||
**Common pattern:** When adding a method to a class that takes or returns a proto type, the proto dependency often needs to be added to both `deps` AND `exports`.
|
||||
|
||||
### Bazel Clean
|
||||
|
||||
**NEVER run `bazel clean` without asking first.** It rarely fixes actual issues and wastes significant rebuild time. The issues that seem like they need `bazel clean` are usually:
|
||||
- Missing imports in Scala code
|
||||
- Missing dependencies in BUILD.bazel
|
||||
- Missing exports for types used in public signatures
|
||||
- **Always test performance changes** - what seems like an optimization may sometimes have unexpected overhead or behavior changes.
|
||||
|
||||
## Game Content
|
||||
|
||||
@@ -315,6 +168,4 @@ dotty.tools.dotc.core.MissingType: Cannot resolve reference to type net.eagle0.e
|
||||
|
||||
- Bazel handles multi-language builds and dependencies
|
||||
- CI/CD via GitHub Actions with platform-specific build scripts in `/ci/github_actions/`
|
||||
- Docker containerization available via `ci/eagle_run.Dockerfile`
|
||||
- Always run "bazel run //:gazelle" after editing any BUILD.bazel files
|
||||
- *ALWAYS ALWAYS* run "bazel run gazelle" after any change that modifies a BUILD.bazel file
|
||||
- Docker containerization available via `ci/eagle_run.Dockerfile`
|
||||
+103
-199
@@ -1,269 +1,173 @@
|
||||
module(name = "net_eagle0")
|
||||
|
||||
# Version constants
|
||||
SCALA_VERSION = "3.7.2"
|
||||
|
||||
NETTY_VERSION = "4.1.110.Final"
|
||||
|
||||
SCALAPB_VERSION = "1.0.0-alpha.1"
|
||||
|
||||
AWS_SDK_VERSION = "2.28.1"
|
||||
bazel_dep(name = "apple_support", repo_name = "build_bazel_apple_support", version = "1.21.1")
|
||||
|
||||
#
|
||||
# Core Build Tools
|
||||
# bazel-toolchain
|
||||
#
|
||||
|
||||
bazel_dep(name = "bazel_skylib", version = "1.8.1")
|
||||
bazel_dep(name = "rules_pkg", version = "1.1.0")
|
||||
|
||||
#
|
||||
# Language Support - Scala
|
||||
#
|
||||
|
||||
bazel_dep(name = "rules_scala", version = "7.1.1")
|
||||
|
||||
scala_config = use_extension(
|
||||
"@rules_scala//scala/extensions:config.bzl",
|
||||
"scala_config",
|
||||
)
|
||||
scala_config.settings(scala_version = SCALA_VERSION)
|
||||
|
||||
scala_deps = use_extension(
|
||||
"@rules_scala//scala/extensions:deps.bzl",
|
||||
"scala_deps",
|
||||
)
|
||||
scala_deps.scala()
|
||||
scala_deps.scalatest()
|
||||
scala_deps.scala_proto()
|
||||
|
||||
#
|
||||
# Language Support - C++
|
||||
#
|
||||
|
||||
bazel_dep(name = "toolchains_llvm", version = "1.6.0")
|
||||
bazel_dep(name = "toolchains_llvm", version = "1.2.0")
|
||||
|
||||
# Configure and register the toolchain.
|
||||
llvm = use_extension("@toolchains_llvm//toolchain/extensions:llvm.bzl", "llvm")
|
||||
|
||||
# Native toolchain (macOS -> macOS, Linux -> Linux)
|
||||
llvm.toolchain(
|
||||
name = "llvm_toolchain",
|
||||
llvm_version = "20.1.2",
|
||||
llvm_version = "19.1.0",
|
||||
)
|
||||
|
||||
# Cross-compilation toolchain (macOS -> Linux x86_64)
|
||||
# Uses the same LLVM distribution but with a Linux sysroot
|
||||
llvm.toolchain(
|
||||
name = "llvm_toolchain_linux",
|
||||
llvm_version = "20.1.2",
|
||||
use_repo(llvm, "llvm_toolchain")
|
||||
|
||||
# Set dev_dependency so we can turn this off for swift MacOS builds
|
||||
register_toolchains(
|
||||
"@llvm_toolchain//:all",
|
||||
dev_dependency = True,
|
||||
)
|
||||
|
||||
# Linux sysroot for cross-compilation (Chromium's Debian sysroot)
|
||||
llvm.sysroot(
|
||||
name = "llvm_toolchain_linux",
|
||||
label = "@linux_sysroot//sysroot",
|
||||
targets = ["linux-x86_64"],
|
||||
)
|
||||
|
||||
use_repo(llvm, "llvm_toolchain", "llvm_toolchain_linux")
|
||||
|
||||
# Download the Linux sysroot (Ubuntu 24.04 Noble for C++23 support)
|
||||
# Built by: .github/workflows/build_sysroot.yml
|
||||
# To rebuild: Run the "Build Linux Sysroot" workflow with a new version, then update sha256 and URL
|
||||
sysroot = use_repo_rule("@toolchains_llvm//toolchain:sysroot.bzl", "sysroot")
|
||||
sysroot(
|
||||
name = "linux_sysroot",
|
||||
# TODO: Update sha256 after running sysroot build workflow with version v2
|
||||
sha256 = "PLACEHOLDER_RUN_SYSROOT_WORKFLOW_FIRST",
|
||||
urls = ["https://eagle0.sfo3.digitaloceanspaces.com/sysroot/v2/ubuntu_noble_amd64_sysroot.tar.xz"],
|
||||
)
|
||||
|
||||
#
|
||||
# Language Support - Go
|
||||
#
|
||||
|
||||
bazel_dep(name = "rules_go", version = "0.56.1", repo_name = "io_bazel_rules_go")
|
||||
bazel_dep(name = "gazelle", version = "0.45.0", repo_name = "bazel_gazelle")
|
||||
bazel_dep(name = "rules_pkg", version = "1.0.1")
|
||||
bazel_dep(name = "bazel_skylib", version = "1.7.1")
|
||||
bazel_dep(name = "protobuf", repo_name = "com_google_protobuf", version = "29.2")
|
||||
bazel_dep(name = "grpc", version = "1.71.0")
|
||||
bazel_dep(name = "grpc-java", version = "1.71.0")
|
||||
bazel_dep(name = "googletest", version = "1.15.2")
|
||||
bazel_dep(name = "rules_go", repo_name = "io_bazel_rules_go", version = "0.50.1")
|
||||
bazel_dep(name = "gazelle", repo_name = "bazel_gazelle", version = "0.40.0")
|
||||
|
||||
go_sdk = use_extension("@io_bazel_rules_go//go:extensions.bzl", "go_sdk")
|
||||
|
||||
go_sdk.download(version = "1.23.3")
|
||||
|
||||
go_deps = use_extension("@bazel_gazelle//:extensions.bzl", "go_deps")
|
||||
|
||||
go_deps.from_file(go_mod = "//:go.mod")
|
||||
|
||||
use_repo(
|
||||
go_deps,
|
||||
"com_github_aws_aws_sdk_go_v2",
|
||||
"com_github_aws_aws_sdk_go_v2_config",
|
||||
"com_github_aws_aws_sdk_go_v2_credentials",
|
||||
"com_github_aws_aws_sdk_go_v2_service_s3",
|
||||
"org_golang_google_grpc",
|
||||
"org_golang_google_protobuf",
|
||||
"org_golang_x_text",
|
||||
"com_github_google_go_cmp",
|
||||
)
|
||||
|
||||
#
|
||||
# Platform Support - Apple/iOS
|
||||
#
|
||||
|
||||
bazel_dep(name = "apple_support", version = "1.21.1", repo_name = "build_bazel_apple_support")
|
||||
bazel_dep(name = "rules_apple", version = "3.16.1", repo_name = "build_bazel_rules_apple")
|
||||
bazel_dep(name = "rules_swift", version = "2.3.1", repo_name = "build_bazel_rules_swift")
|
||||
#go_sdk.nogo(
|
||||
# nogo = "//:my_nogo",
|
||||
#)
|
||||
|
||||
#
|
||||
# Protocol Buffers & RPC
|
||||
# rules_jvm_external
|
||||
#
|
||||
|
||||
bazel_dep(name = "protobuf", version = "29.2", repo_name = "com_google_protobuf")
|
||||
bazel_dep(name = "grpc", version = "1.71.0")
|
||||
bazel_dep(name = "grpc-java", version = "1.71.0")
|
||||
bazel_dep(name = "flatbuffers", version = "25.2.10")
|
||||
scala_version = "2.13.14"
|
||||
|
||||
#
|
||||
# Testing
|
||||
#
|
||||
|
||||
bazel_dep(name = "googletest", version = "1.17.0")
|
||||
|
||||
#
|
||||
# Container Images (OCI)
|
||||
#
|
||||
|
||||
bazel_dep(name = "rules_oci", version = "2.2.6")
|
||||
bazel_dep(name = "aspect_bazel_lib", version = "2.16.0")
|
||||
|
||||
oci = use_extension("@rules_oci//oci:extensions.bzl", "oci")
|
||||
|
||||
# Base image for Eagle (Java 17)
|
||||
oci.pull(
|
||||
name = "eclipse_temurin_17",
|
||||
digest = "sha256:d286b5352d98777bbf727f54038b04f0145cd9b76ca83f38a67aa111d4303748",
|
||||
image = "docker.io/library/eclipse-temurin",
|
||||
platforms = ["linux/amd64"],
|
||||
bazel_dep(
|
||||
name = "rules_jvm_external",
|
||||
version = "6.3",
|
||||
)
|
||||
|
||||
# Base image for Shardok (Ubuntu 24.04 for C++ runtime)
|
||||
oci.pull(
|
||||
name = "ubuntu_24_04",
|
||||
image = "docker.io/library/ubuntu",
|
||||
platforms = ["linux/amd64"],
|
||||
tag = "24.04",
|
||||
)
|
||||
use_repo(oci, "eclipse_temurin_17", "eclipse_temurin_17_linux_amd64", "ubuntu_24_04", "ubuntu_24_04_linux_amd64")
|
||||
|
||||
#
|
||||
# Java/Scala Dependencies
|
||||
#
|
||||
|
||||
bazel_dep(name = "rules_jvm_external", version = "6.3")
|
||||
|
||||
maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
|
||||
|
||||
maven.install(
|
||||
artifacts = [
|
||||
# Netty
|
||||
"io.netty:netty-codec:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-codec-http:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-codec-socks:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-codec-http2:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-handler:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-buffer:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-transport:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-resolver:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-common:%s" % NETTY_VERSION,
|
||||
"io.netty:netty-handler-proxy:%s" % NETTY_VERSION,
|
||||
|
||||
# ScalaPB
|
||||
"com.thesamet.scalapb:lenses_3:%s" % SCALAPB_VERSION,
|
||||
"com.thesamet.scalapb:scalapb-json4s_3:%s" % SCALAPB_VERSION,
|
||||
"com.thesamet.scalapb:scalapb-runtime_3:%s" % SCALAPB_VERSION,
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_3:%s" % SCALAPB_VERSION,
|
||||
"com.thesamet.scalapb:compilerplugin_3:%s" % SCALAPB_VERSION,
|
||||
"com.thesamet.scalapb:protoc-bridge_3:0.9.9",
|
||||
|
||||
# JSON
|
||||
"org.json4s:json4s-ast_3:4.1.0-M8",
|
||||
"org.json4s:json4s-core_3:4.1.0-M8",
|
||||
"org.json4s:json4s-native_3:4.1.0-M8",
|
||||
|
||||
# Testing
|
||||
"org.scalamock:scalamock_3:7.4.1",
|
||||
|
||||
# AWS SDK
|
||||
"software.amazon.awssdk:s3-transfer-manager:%s" % AWS_SDK_VERSION,
|
||||
"software.amazon.awssdk:s3:%s" % AWS_SDK_VERSION,
|
||||
"software.amazon.awssdk:regions:%s" % AWS_SDK_VERSION,
|
||||
"software.amazon.awssdk:aws-core:%s" % AWS_SDK_VERSION,
|
||||
"software.amazon.awssdk:sdk-core:%s" % AWS_SDK_VERSION,
|
||||
"software.amazon.awssdk:utils:%s" % AWS_SDK_VERSION,
|
||||
"software.amazon.awssdk:http-client-spi:%s" % AWS_SDK_VERSION,
|
||||
|
||||
# AWS Lambda
|
||||
"com.amazonaws:aws-lambda-java-core:1.2.3",
|
||||
"com.amazonaws:aws-lambda-java-events:3.13.0",
|
||||
|
||||
# Logging
|
||||
"org.scala-lang:scala-library:%s" % scala_version,
|
||||
"io.netty:netty-codec:4.1.110.Final",
|
||||
"io.netty:netty-codec-http:4.1.110.Final",
|
||||
"io.netty:netty-codec-socks:4.1.110.Final",
|
||||
"io.netty:netty-codec-http2:4.1.110.Final",
|
||||
"io.netty:netty-handler:4.1.110.Final",
|
||||
"io.netty:netty-buffer:4.1.110.Final",
|
||||
"io.netty:netty-transport:4.1.110.Final",
|
||||
"io.netty:netty-resolver:4.1.110.Final",
|
||||
"io.netty:netty-common:4.1.110.Final",
|
||||
"io.netty:netty-handler-proxy:4.1.110.Final",
|
||||
"com.thesamet.scalapb:lenses_2.13:1.0.0-alpha.1",
|
||||
"com.thesamet.scalapb:scalapb-json4s_2.13:1.0.0-alpha.1",
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13:1.0.0-alpha.1",
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_2.13:1.0.0-alpha.1",
|
||||
"com.thesamet.scalapb:compilerplugin_2.13:1.0.0-alpha.1",
|
||||
"com.thesamet.scalapb:protoc-bridge_2.13:0.9.8",
|
||||
"org.json4s:json4s-ast_2.13:4.0.7",
|
||||
"org.json4s:json4s-core_2.13:4.0.7",
|
||||
"org.json4s:json4s-native_2.13:4.0.7",
|
||||
"org.scalamock:scalamock_2.13:6.0.0",
|
||||
"software.amazon.awssdk:s3-transfer-manager:2.28.1",
|
||||
"software.amazon.awssdk:s3:2.28.1",
|
||||
"software.amazon.awssdk:regions:2.28.1",
|
||||
"software.amazon.awssdk:aws-core:2.28.1",
|
||||
"software.amazon.awssdk:sdk-core:2.28.1",
|
||||
"org.slf4j:slf4j-api:2.0.16",
|
||||
"org.slf4j:slf4j-simple:2.0.16",
|
||||
|
||||
# Other
|
||||
#"software.amazon.awssdk:sns:2.28.1",
|
||||
"software.amazon.awssdk:utils:2.28.1",
|
||||
"software.amazon.awssdk:http-client-spi:2.28.1",
|
||||
"org.reactivestreams:reactive-streams:1.0.4",
|
||||
"com.amazonaws:aws-lambda-java-core:1.2.3",
|
||||
"com.amazonaws:aws-lambda-java-events:3.13.0",
|
||||
"javax.xml.bind:jaxb-api:2.3.1",
|
||||
|
||||
# OkHttp (for SSE with read timeout support)
|
||||
"com.squareup.okhttp3:okhttp:4.12.0",
|
||||
"com.squareup.okhttp3:okhttp-sse:4.12.0",
|
||||
],
|
||||
duplicate_version_warning = "error",
|
||||
fail_if_repin_required = True,
|
||||
lock_file = "//:maven_install.json",
|
||||
lock_file = "//:maven_install.json", #
|
||||
repositories = [
|
||||
"https://repo1.maven.org/maven2",
|
||||
],
|
||||
)
|
||||
|
||||
use_repo(maven, "maven", "unpinned_maven")
|
||||
|
||||
#
|
||||
# External Libraries
|
||||
# rules_apple
|
||||
#
|
||||
|
||||
bazel_dep(
|
||||
name = "rules_apple",
|
||||
repo_name = "build_bazel_rules_apple",
|
||||
version = "3.16.1",
|
||||
)
|
||||
bazel_dep(
|
||||
name = "rules_swift",
|
||||
repo_name = "build_bazel_rules_swift",
|
||||
version = "2.3.1",
|
||||
)
|
||||
|
||||
#
|
||||
# Unbazelified imports
|
||||
#
|
||||
http_archive = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
|
||||
|
||||
# GTL (for parallel_hashmap)
|
||||
GTL_VERSION = "1.2.0"
|
||||
#
|
||||
# flatbuffers
|
||||
#
|
||||
bazel_dep(name = "flatbuffers", version = "25.2.10")
|
||||
|
||||
GTL_SHA = "1969c45dd76eac0dd87e9e2b65cffe358617f4fe1bcd203f72f427742537913a"
|
||||
#
|
||||
# gtl (for parallel_hashmap)
|
||||
#
|
||||
|
||||
gtl_version = "1.2.0"
|
||||
|
||||
gtl_sha = "1969c45dd76eac0dd87e9e2b65cffe358617f4fe1bcd203f72f427742537913a"
|
||||
|
||||
http_archive(
|
||||
name = "gtl",
|
||||
build_file = "@//external:BUILD.gtl",
|
||||
sha256 = GTL_SHA,
|
||||
strip_prefix = "gtl-%s" % GTL_VERSION,
|
||||
url = "https://github.com/greg7mdp/gtl/archive/refs/tags/v%s.zip" % GTL_VERSION,
|
||||
sha256 = gtl_sha,
|
||||
strip_prefix = "gtl-%s" % gtl_version,
|
||||
url = "https://github.com/greg7mdp/gtl/archive/refs/tags/v%s.zip" % gtl_version,
|
||||
)
|
||||
|
||||
# Unity GoDice Plugin
|
||||
UNITY_GODICE_COMMIT = "18d6823991592e4d45fcc0f22692db849dea9063"
|
||||
#
|
||||
# Plugins for the native code for interacting with GoDice
|
||||
#
|
||||
unity_godice_commit = "18d6823991592e4d45fcc0f22692db849dea9063"
|
||||
|
||||
UNITY_GODICE_SHA = "04e6ae4155965aab3372592e04061eba1256bb6ea7ccffd0d83f27574e5b3349"
|
||||
unity_godice_sha = "04e6ae4155965aab3372592e04061eba1256bb6ea7ccffd0d83f27574e5b3349"
|
||||
|
||||
http_archive(
|
||||
name = "net_eagle0_unity_godice",
|
||||
sha256 = UNITY_GODICE_SHA,
|
||||
strip_prefix = "godice-framework-%s" % UNITY_GODICE_COMMIT,
|
||||
sha256 = unity_godice_sha,
|
||||
strip_prefix = "godice-framework-%s" % unity_godice_commit,
|
||||
urls = [
|
||||
"https://github.com/nolen777/godice-framework/archive/%s.zip" % UNITY_GODICE_COMMIT,
|
||||
"https://github.com/nolen777/godice-framework/archive/%s.zip" % unity_godice_commit,
|
||||
],
|
||||
)
|
||||
|
||||
#
|
||||
# Toolchain Registration
|
||||
#
|
||||
|
||||
register_toolchains(
|
||||
"//tools:unused_dependency_checker_error_and_opts_toolchain",
|
||||
"@rules_scala//testing:scalatest_toolchain",
|
||||
)
|
||||
|
||||
# Set dev_dependency so we can turn this off for swift MacOS builds
|
||||
register_toolchains(
|
||||
"@llvm_toolchain//:all",
|
||||
"@llvm_toolchain_linux//:all",
|
||||
dev_dependency = True,
|
||||
)
|
||||
|
||||
Generated
+113
-3820
File diff suppressed because it is too large
Load Diff
@@ -1,2 +1,51 @@
|
||||
# This file marks the root of the Bazel workspace.
|
||||
# See MODULE.bazel for external dependencies and setup.
|
||||
workspace(name = "net_eagle0")
|
||||
|
||||
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
|
||||
|
||||
#
|
||||
# Scala support
|
||||
#
|
||||
|
||||
scala_version = "2.13.14"
|
||||
|
||||
#rules_scala_version = "6.6.0"
|
||||
|
||||
#rules_scala_sha = "e734eef95cf26c0171566bdc24d83bd82bdaf8ca7873bec6ce9b0d524bdaf05d"
|
||||
|
||||
#http_archive(
|
||||
# name = "io_bazel_rules_scala",
|
||||
# sha256 = rules_scala_sha,
|
||||
# strip_prefix = "rules_scala-%s" % rules_scala_version,
|
||||
# url = "https://github.com/bazelbuild/rules_scala/releases/download/v%s/rules_scala-v%s.tar.gz" % (rules_scala_version, rules_scala_version),
|
||||
#)
|
||||
|
||||
# Using a commit from master to get 2.13.14 support. Restore the commented-out lines above with a new
|
||||
# release version when one is cut.
|
||||
rules_scala_commit = "e53a43bf48f10a5906b3e91c21798281cec1b334"
|
||||
|
||||
rules_scala_sha = "b4fd903724d084d9d9f45e17fc22391bda745bf0574f8934d38a9c1c2fc18834"
|
||||
|
||||
http_archive(
|
||||
name = "io_bazel_rules_scala",
|
||||
sha256 = rules_scala_sha,
|
||||
strip_prefix = "rules_scala-%s" % rules_scala_commit,
|
||||
url = "https://github.com/bazelbuild/rules_scala/archive/%s.zip" % rules_scala_commit,
|
||||
)
|
||||
|
||||
load("@io_bazel_rules_scala//:scala_config.bzl", "scala_config")
|
||||
|
||||
scala_config(scala_version = scala_version)
|
||||
|
||||
load("//tools:toolchains.bzl", "scala_register_toolchains")
|
||||
|
||||
scala_register_toolchains()
|
||||
|
||||
load("@io_bazel_rules_scala//scala:scala.bzl", "scala_repositories")
|
||||
|
||||
scala_repositories()
|
||||
|
||||
load("@io_bazel_rules_scala//testing:scalatest.bzl", "scalatest_repositories", "scalatest_toolchain")
|
||||
|
||||
scalatest_repositories()
|
||||
|
||||
scalatest_toolchain()
|
||||
|
||||
-128
@@ -1,128 +0,0 @@
|
||||
load("@rules_oci//oci:defs.bzl", "oci_image", "oci_load", "oci_push")
|
||||
load("@rules_pkg//pkg:tar.bzl", "pkg_tar")
|
||||
|
||||
#
|
||||
# Eagle Server Docker Image
|
||||
#
|
||||
# Build: bazel build //ci:eagle_server_image
|
||||
# Load: bazel run //ci:eagle_server_load
|
||||
# Push: bazel run //ci:eagle_server_push
|
||||
#
|
||||
|
||||
# Package the deploy JAR
|
||||
pkg_tar(
|
||||
name = "eagle_server_jar_layer",
|
||||
srcs = ["//src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar"],
|
||||
package_dir = "/app",
|
||||
)
|
||||
|
||||
# Package the game resources needed at runtime
|
||||
pkg_tar(
|
||||
name = "eagle_resources_layer",
|
||||
srcs = [
|
||||
"//src/main/resources/net/eagle0/eagle:beasts",
|
||||
"//src/main/resources/net/eagle0/eagle:game_parameters",
|
||||
"//src/main/resources/net/eagle0/eagle:headshots",
|
||||
"//src/main/resources/net/eagle0/eagle:heroes",
|
||||
"//src/main/resources/net/eagle0/eagle:province_map",
|
||||
"//src/main/resources/net/eagle0/eagle:settings",
|
||||
],
|
||||
package_dir = "/app/resources",
|
||||
)
|
||||
|
||||
oci_image(
|
||||
name = "eagle_server_image",
|
||||
base = "@eclipse_temurin_17_linux_amd64",
|
||||
entrypoint = [
|
||||
"java",
|
||||
"-Xmx4g",
|
||||
"-XX:+UseG1GC",
|
||||
"-jar",
|
||||
"/app/eagle_server_deploy.jar",
|
||||
],
|
||||
env = {
|
||||
"JAVA_OPTS": "-Xmx4g -XX:+UseG1GC",
|
||||
},
|
||||
exposed_ports = ["40032/tcp"],
|
||||
tars = [
|
||||
":eagle_server_jar_layer",
|
||||
":eagle_resources_layer",
|
||||
],
|
||||
workdir = "/app",
|
||||
)
|
||||
|
||||
# Load into Docker locally: bazel run //ci:eagle_server_load
|
||||
oci_load(
|
||||
name = "eagle_server_load",
|
||||
image = ":eagle_server_image",
|
||||
repo_tags = ["eagle0/eagle-server:latest"],
|
||||
)
|
||||
|
||||
# Push to DigitalOcean Container Registry
|
||||
oci_push(
|
||||
name = "eagle_server_push",
|
||||
image = ":eagle_server_image",
|
||||
repository = "registry.digitalocean.com/eagle0/eagle-server",
|
||||
)
|
||||
|
||||
#
|
||||
# Shardok Server Docker Image
|
||||
#
|
||||
# Build: bazel build //ci:shardok_server_image
|
||||
# Load: bazel run //ci:shardok_server_load
|
||||
# Push: bazel run //ci:shardok_server_push
|
||||
#
|
||||
|
||||
# Package the Shardok binary
|
||||
pkg_tar(
|
||||
name = "shardok_binary_layer",
|
||||
srcs = ["//src/main/cpp/net/eagle0/shardok:shardok-server"],
|
||||
package_dir = "/app",
|
||||
)
|
||||
|
||||
# Package the Shardok resources (battalion types, settings)
|
||||
pkg_tar(
|
||||
name = "shardok_resources_layer",
|
||||
srcs = [
|
||||
"//src/main/resources/net/eagle0/shardok:battalion_types",
|
||||
"//src/main/resources/net/eagle0/shardok:settings",
|
||||
],
|
||||
package_dir = "/app/resources",
|
||||
)
|
||||
|
||||
# Package the converted maps
|
||||
pkg_tar(
|
||||
name = "shardok_maps_layer",
|
||||
srcs = ["//src/main/resources/net/eagle0/shardok/maps"],
|
||||
package_dir = "/app/resources/maps",
|
||||
)
|
||||
|
||||
oci_image(
|
||||
name = "shardok_server_image",
|
||||
base = "@ubuntu_24_04_linux_amd64",
|
||||
entrypoint = ["/app/shardok-server"],
|
||||
exposed_ports = [
|
||||
"40042/tcp",
|
||||
"40052/tcp",
|
||||
],
|
||||
tars = [
|
||||
":shardok_binary_layer",
|
||||
":shardok_resources_layer",
|
||||
":shardok_maps_layer",
|
||||
],
|
||||
workdir = "/app",
|
||||
)
|
||||
|
||||
# Load into Docker locally: bazel run //ci:shardok_server_load
|
||||
oci_load(
|
||||
name = "shardok_server_load",
|
||||
image = ":shardok_server_image",
|
||||
repo_tags = ["eagle0/shardok-server:latest"],
|
||||
)
|
||||
|
||||
# Push to DigitalOcean Container Registry
|
||||
oci_push(
|
||||
name = "shardok_server_push",
|
||||
image = ":shardok_server_image",
|
||||
repository = "registry.digitalocean.com/eagle0/shardok-server",
|
||||
)
|
||||
+2
-1
@@ -1 +1,2 @@
|
||||
UNITY_VERSION='6000.3.0f1'
|
||||
|
||||
UNITY_VERSION='6000.1.11f1'
|
||||
@@ -1,47 +0,0 @@
|
||||
# Docker Compose for local testing of production images
|
||||
# Build images: bazel run //ci:eagle_server_load && bazel run //ci:shardok_server_load
|
||||
# Run: docker compose -f docker-compose.prod.yml up
|
||||
|
||||
services:
|
||||
eagle:
|
||||
image: eagle0/eagle-server:latest
|
||||
container_name: eagle-server
|
||||
ports:
|
||||
- "40032:40032"
|
||||
environment:
|
||||
# Eagle server configuration
|
||||
EAGLE_GRPC_PORT: "40032"
|
||||
SHARDOK_HOST: "shardok"
|
||||
SHARDOK_PORT: "40042"
|
||||
# Resource paths (relative to /app in container)
|
||||
EAGLE_RESOURCES_PATH: "/app/resources"
|
||||
volumes:
|
||||
# Mount saves directory for persistence
|
||||
- ./saves:/app/saves
|
||||
depends_on:
|
||||
- shardok
|
||||
restart: unless-stopped
|
||||
healthcheck:
|
||||
test: ["CMD", "nc", "-z", "localhost", "40032"]
|
||||
interval: 30s
|
||||
timeout: 10s
|
||||
retries: 3
|
||||
start_period: 30s
|
||||
|
||||
shardok:
|
||||
image: eagle0/shardok-server:latest
|
||||
container_name: shardok-server
|
||||
ports:
|
||||
- "40042:40042"
|
||||
- "40052:40052"
|
||||
environment:
|
||||
# Shardok server configuration
|
||||
SHARDOK_RESOURCES_PATH: "/app/resources"
|
||||
SHARDOK_MAPS_PATH: "/app/resources/maps"
|
||||
restart: unless-stopped
|
||||
healthcheck:
|
||||
test: ["CMD", "nc", "-z", "localhost", "40042"]
|
||||
interval: 30s
|
||||
timeout: 10s
|
||||
retries: 3
|
||||
start_period: 10s
|
||||
@@ -1,280 +0,0 @@
|
||||
# CommandProto Usage Analysis in shardok/ai
|
||||
|
||||
This document analyzes all remaining usages of `CommandProto` (protocol buffer representation) in the AI code and identifies opportunities to eliminate proto conversion by using `ShardokCommand` directly.
|
||||
|
||||
## Summary
|
||||
|
||||
**Total CommandProto usages found:** 42 locations across 9 files
|
||||
|
||||
**Eliminated:** 6 usages (14%) - ✅ **Phase 1 Complete**
|
||||
**Can be eliminated:** ~14 usages (33%)
|
||||
**Must keep (for now):** ~22 usages (53%)
|
||||
|
||||
---
|
||||
|
||||
## Files with CommandProto Usage
|
||||
|
||||
### 1. AICommandFilter.cpp (6 usages) - ✅ **COMPLETED** (PR #4505)
|
||||
**Location:** Lines 146, 189, 252, 356, 387, 428
|
||||
|
||||
**Original usage:**
|
||||
```cpp
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
if (!cmdProto.has_target()) { ... }
|
||||
const auto& targetCoords = cmdProto.target();
|
||||
if (!cmdProto.has_actor()) { ... }
|
||||
const auto unitId = cmdProto.actor().value();
|
||||
```
|
||||
|
||||
**Replaced with:**
|
||||
```cpp
|
||||
const int targetRow = cmd.GetTargetRow();
|
||||
const int targetCol = cmd.GetTargetColumn();
|
||||
if (targetRow < 0 || targetCol < 0) {
|
||||
throw ShardokInternalErrorException("Command missing required target");
|
||||
}
|
||||
const Coords targetCoords(targetRow, targetCol);
|
||||
|
||||
const int actorId = cmd.GetActorUnitId();
|
||||
if (actorId < 0) {
|
||||
throw ShardokInternalErrorException("Command missing required actor");
|
||||
}
|
||||
```
|
||||
|
||||
**Status:** ✅ **ELIMINATED** - Replaced with direct accessors + exception handling
|
||||
**Impact:** Eliminated 6 proto conversions in hot path (command filtering)
|
||||
**Completed:** Phase 1, PR #4505
|
||||
|
||||
---
|
||||
|
||||
### 2. ShardokAIClient.cpp (8 usages)
|
||||
**Location:** Lines 83, 86, 87, 102, 105, 237, 261, 311, 356
|
||||
|
||||
**Usage breakdown:**
|
||||
|
||||
#### a) Command validation (lines 83-87)
|
||||
```cpp
|
||||
void CheckCommand(const CommandProto &realDescriptor, const CommandProto &guessedDescriptor) {
|
||||
differencer.IgnoreField(CommandProto::descriptor()->FindFieldByNumber(
|
||||
CommandProto::kFollowUpCommandTypesFieldNumber));
|
||||
```
|
||||
**Status:** ❌ **MUST KEEP** - Uses protobuf reflection for comparison
|
||||
**Reason:** Comparing proto messages for correctness checking requires proto API
|
||||
|
||||
#### b) GetAvailableCommandProtos calls (lines 105, 356)
|
||||
```cpp
|
||||
const auto guessedCommands = guessedEngine.GetAvailableCommandProtos(playerId, false);
|
||||
if (const auto &availableCommands = engine.GetAvailableCommandProtos(playerId, false);
|
||||
```
|
||||
**Status:** ✅ **CAN REPLACE** - Should use `GetAvailableCommandsForAIPlayer()` instead
|
||||
**Impact:** This is a major conversion point - converts entire command list to protos
|
||||
**Priority:** HIGH (converts all commands to proto unnecessarily)
|
||||
|
||||
#### c) Strategy selector methods (lines 102, 237, 261, 311)
|
||||
```cpp
|
||||
const vector<CommandProto> &realAvailableCommands) const -> CommandChoiceResults
|
||||
```
|
||||
**Status:** ✅ **CAN REPLACE** - Depends on fixing strategy selector signatures
|
||||
**Priority:** MEDIUM (depends on other refactors)
|
||||
|
||||
---
|
||||
|
||||
### 3. IterativeDeepeningAI.cpp/hpp (4 usages)
|
||||
**Location:** Lines 41, 272 (cpp), 73, 96 (hpp)
|
||||
|
||||
**Current usage:**
|
||||
```cpp
|
||||
const std::vector<CommandProto>& commands,
|
||||
```
|
||||
|
||||
**Status:** ✅ **CAN REPLACE** - These methods should accept `CommandListSPtr` instead
|
||||
**Impact:** Major - this is the main AI search algorithm
|
||||
**Priority:** HIGH (core AI algorithm)
|
||||
|
||||
**Note:** IterativeDeepeningAI already receives commands as proto vectors. The conversion happens upstream at the entry point. Need to trace back to find where `GetAvailableCommandProtos` is called.
|
||||
|
||||
---
|
||||
|
||||
### 4. AIFleeDecisionCalculator.cpp/hpp (6 usages)
|
||||
**Location:** Lines 17, 38, 39, 62, 63 (hpp), 18, 19, 137, 138 (cpp)
|
||||
|
||||
**Current usage:**
|
||||
```cpp
|
||||
const vector<CommandProto>& availableCommands,
|
||||
const vector<CommandProto>::const_iterator& fleeCommand,
|
||||
```
|
||||
|
||||
**Status:** ✅ **CAN REPLACE** - Should use `CommandListSPtr` and indices instead
|
||||
**Impact:** Flee decision logic could avoid proto conversion
|
||||
**Priority:** MEDIUM
|
||||
|
||||
---
|
||||
|
||||
### 5. AIAttackerStrategySelector.cpp/hpp (2 usages)
|
||||
**Location:** Line 30 in both files
|
||||
|
||||
**Current usage:**
|
||||
```cpp
|
||||
const vector<CommandProto>& availableCommands) -> AIStrategy
|
||||
```
|
||||
|
||||
**Status:** ⚠️ **PARTIALLY REPLACEABLE** - Currently doesn't use the commands parameter
|
||||
**Current implementation:**
|
||||
```cpp
|
||||
const vector<CommandProto>& /*availableCommands*/) -> AIStrategy {
|
||||
// Parameter is commented out - not used!
|
||||
return AIStrategy::DEFAULT;
|
||||
}
|
||||
```
|
||||
**Priority:** LOW (parameter unused, but signature should be consistent)
|
||||
|
||||
---
|
||||
|
||||
### 6. AICommandEvaluator.hpp (1 usage)
|
||||
**Location:** Line 27
|
||||
|
||||
**Current usage:**
|
||||
```cpp
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
```
|
||||
|
||||
**Status:** ⚠️ **CHECK USAGE** - Type alias, need to check if used
|
||||
**Priority:** LOW (just a type alias)
|
||||
|
||||
---
|
||||
|
||||
### 7. AIScoreCalculator.hpp (1 usage)
|
||||
**Location:** Line 24
|
||||
|
||||
**Current usage:**
|
||||
```cpp
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
```
|
||||
|
||||
**Status:** ⚠️ **CHECK USAGE** - Type alias, need to check if used
|
||||
**Priority:** LOW (just a type alias)
|
||||
|
||||
---
|
||||
|
||||
### 8. AIWaterCrossingCommandChooser.hpp (1 usage)
|
||||
**Location:** Line 20
|
||||
|
||||
**Current usage:**
|
||||
```cpp
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
```
|
||||
|
||||
**Status:** ⚠️ **CHECK USAGE** - Type alias, need to check if used
|
||||
**Priority:** LOW (just a type alias)
|
||||
|
||||
---
|
||||
|
||||
## Key Conversion Points (Entry Points)
|
||||
|
||||
### ShardokEngine::GetAvailableCommandProtos()
|
||||
This method converts the entire command list from `CommandListSPtr` to `vector<CommandProto>`.
|
||||
|
||||
**Current flow:**
|
||||
```
|
||||
ShardokEngine::GetAvailableCommandsForAIPlayer() → CommandListSPtr
|
||||
↓ (conversion)
|
||||
ShardokEngine::GetAvailableCommandProtos() → vector<CommandProto>
|
||||
↓
|
||||
AI algorithms (IterativeDeepeningAI, etc.)
|
||||
```
|
||||
|
||||
**Desired flow:**
|
||||
```
|
||||
ShardokEngine::GetAvailableCommandsForAIPlayer() → CommandListSPtr
|
||||
↓ (no conversion!)
|
||||
AI algorithms use CommandSPtr directly
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Recommendations by Priority
|
||||
|
||||
### HIGH Priority (Performance-critical hot paths)
|
||||
|
||||
1. **AICommandFilter.cpp (6 usages)**
|
||||
- Replace `cmd.GetCommandProto()` with direct accessor methods
|
||||
- Use `GetActorUnitId()`, `GetTargetRow()`, `GetTargetColumn()`
|
||||
- Impact: Eliminates 6 proto conversions per filtered command
|
||||
|
||||
2. **ShardokAIClient.cpp - GetAvailableCommandProtos calls**
|
||||
- Replace calls to `GetAvailableCommandProtos()` with `GetAvailableCommandsForAIPlayer()`
|
||||
- Impact: Eliminates conversion of entire command list
|
||||
|
||||
3. **IterativeDeepeningAI**
|
||||
- Change signature from `vector<CommandProto>` to `CommandListSPtr`
|
||||
- Impact: Main AI search algorithm avoids proto conversion
|
||||
|
||||
### MEDIUM Priority
|
||||
|
||||
4. **AIFleeDecisionCalculator**
|
||||
- Change to use `CommandListSPtr` and indices
|
||||
- Impact: Flee decision logic avoids proto
|
||||
|
||||
5. **ShardokAIClient strategy methods**
|
||||
- Update signatures to use `CommandListSPtr`
|
||||
- Cascades to strategy selectors
|
||||
|
||||
### LOW Priority
|
||||
|
||||
6. **Type aliases**
|
||||
- Remove unused `using CommandProto` declarations
|
||||
- Clean up imports
|
||||
|
||||
---
|
||||
|
||||
## Migration Strategy
|
||||
|
||||
### Phase 1: Low-hanging fruit (AICommandFilter) - ✅ **COMPLETED** (PR #4505)
|
||||
- ✅ Replaced 6 proto conversions with direct accessor calls
|
||||
- ✅ Added exception handling for missing actor/target data
|
||||
- ✅ No signature changes needed
|
||||
- ✅ Immediate performance benefit
|
||||
- **PR:** #4505
|
||||
|
||||
### Phase 2: Entry point (ShardokAIClient)
|
||||
- Replace `GetAvailableCommandProtos()` calls with `GetAvailableCommandsForAIPlayer()`
|
||||
- Update method signatures in ShardokAIClient
|
||||
|
||||
### Phase 3: Core AI (IterativeDeepeningAI)
|
||||
- Change IterativeDeepeningAI to accept `CommandListSPtr`
|
||||
- This is the biggest change but has highest impact
|
||||
|
||||
### Phase 4: Supporting systems
|
||||
- Update AIFleeDecisionCalculator
|
||||
- Update strategy selectors
|
||||
- Clean up type aliases
|
||||
|
||||
### Phase 5: Validation code
|
||||
- Keep proto-based validation as-is (uses reflection)
|
||||
- Consider if validation is still needed in production
|
||||
|
||||
---
|
||||
|
||||
## Notes
|
||||
|
||||
- **MCTS already converted**: The MCTS code path already uses `CommandListSPtr` directly
|
||||
- **Proto still needed**: For serialization/network communication (not in AI hot path)
|
||||
- **Validation**: Proto comparison in CheckCommand() should remain (uses proto reflection)
|
||||
|
||||
---
|
||||
|
||||
## Estimated Impact
|
||||
|
||||
**Proto conversions eliminated:** ~20-25 per command choice
|
||||
**Performance gain:** Eliminates hundreds of allocations per AI decision
|
||||
**Code simplification:** Removes proto conversion layer from AI
|
||||
|
||||
**Before:**
|
||||
```
|
||||
Command → Proto → AI Decision
|
||||
```
|
||||
|
||||
**After:**
|
||||
```
|
||||
Command → AI Decision (direct)
|
||||
```
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,334 +0,0 @@
|
||||
# Deproto Migration Plan
|
||||
|
||||
## Vision
|
||||
|
||||
**Protocol buffers should only be used at the edges** — for network serialization (gRPC) and disk persistence. Inside the Eagle game engine, all logic should operate on native Scala models.
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
│ GRPC BOUNDARY │
|
||||
│ EagleServiceImpl.scala ←→ Proto Messages ←→ Unity Client │
|
||||
└─────────────────────────────────────────────────────────────────────┘
|
||||
↓
|
||||
GameStateConverter
|
||||
↓
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
│ SCALA ENGINE │
|
||||
│ │
|
||||
│ GameStateC ───→ Actions ───→ ActionResultT ───→ New GameStateC │
|
||||
│ ↑ │ │
|
||||
│ │ (Pure Scala models) │ │
|
||||
│ └───────────────────────────────────────────────────┘ │
|
||||
│ │
|
||||
│ HeroC, FactionC, ProvinceC, BattalionC, ArmyC, etc. │
|
||||
└─────────────────────────────────────────────────────────────────────┘
|
||||
↓
|
||||
GameStateConverter
|
||||
↓
|
||||
┌─────────────────────────────────────────────────────────────────────┐
|
||||
│ PERSISTENCE BOUNDARY │
|
||||
│ GameHistory.scala ←→ Proto Messages ←→ File/Database │
|
||||
└─────────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Current State
|
||||
|
||||
### Completed Phases
|
||||
|
||||
| Phase | Status | Summary |
|
||||
|-------|--------|---------|
|
||||
| Phase 1: GameStateC | **Complete** | Scala `GameState` model with 22 fields |
|
||||
| Phase 2: EngineImpl | **Complete** | Holds Scala `GameState` internally |
|
||||
| Phase 3: GameHistory | **Complete** | `stateAfter` returns Scala GameState |
|
||||
| Phase 4: ActionResultT | **Complete** | All 59 actions return `ActionResultT` |
|
||||
| Phase 5: Action Base Classes | **Complete** | All `RandomSequentialResultsAction` and `DeterministicSingleResultAction` converted to T-type base classes |
|
||||
| Phase 5b: Base Class Cleanup | **Complete** | `RandomSequentialResultsAction` and `DeterministicSingleResultAction` deleted |
|
||||
| Phase 5c: RoundPhaseAdvancer Actions | **Complete** | All actions called by RoundPhaseAdvancer accept Scala GameState |
|
||||
| Phase 5d: RoundPhaseAdvancer Itself | **Complete** | RoundPhaseAdvancer.checkForPhaseAdvancement takes Scala GameState |
|
||||
|
||||
### Phase 5c/5d Progress (Complete)
|
||||
|
||||
`RoundPhaseAdvancer.checkForPhaseAdvancement` now accepts Scala `GameState` and `ActionResultApplier` directly (PR #4677).
|
||||
|
||||
| Action | PR | Status |
|
||||
|--------|-----|--------|
|
||||
| `PrisonerExchangeAction` | #4670 | ✅ Merged |
|
||||
| `PerformForcedTurnBackAction` | #4671 | ✅ Merged |
|
||||
| `PerformHeroDeparturesAction` | #4672 | ✅ Merged |
|
||||
| `RequestFreeForAllBattlesAction` | #4673 | ✅ Merged |
|
||||
| `EndPlayerCommandsPhaseAction` | #4674 | ✅ Merged |
|
||||
| `EndDiplomacyResolutionPhaseAction` | #4675 | ✅ Merged |
|
||||
| `RoundPhaseAdvancer` itself | #4677 | ✅ Merged |
|
||||
|
||||
### EngineImpl Progress
|
||||
|
||||
| Change | PR | Status |
|
||||
|--------|-----|--------|
|
||||
| `recursiveTransform` deleted | #4677 | ✅ Merged |
|
||||
| `recursiveTransformT` uses `RandomStateTSequencer` | #4677 | ✅ Merged |
|
||||
|
||||
### Current Architecture
|
||||
|
||||
**ActionResultT Production (100% Complete):**
|
||||
- All actions produce `ActionResultT`
|
||||
- Conversion to `ActionResultProto` happens via `ActionResultProtoConverter.toProto()`
|
||||
- No direct `ActionResultProto` construction outside the converter
|
||||
|
||||
**ActionResultProto Consumption (Next Target):**
|
||||
- `ActionResultProtoApplierImpl` - applies proto results to proto GameState
|
||||
- `RoundPhaseAdvancer` - calls converter, passes protos to applier
|
||||
- `InMemoryHistory` / `PersistedHistory` - stores proto results
|
||||
- Service layer (`GameController`, `GamesManager`, etc.) - uses proto for client communication
|
||||
|
||||
---
|
||||
|
||||
## Phase 6: Migrate to ActionResultT Consumers
|
||||
|
||||
### Objective
|
||||
|
||||
Eliminate internal consumption of `ActionResultProto`. Everything inside the engine should work with `ActionResultT`.
|
||||
|
||||
### Current Flow (Proto-Heavy)
|
||||
```
|
||||
Action.execute()
|
||||
→ ActionResultT
|
||||
→ ActionResultProtoConverter.toProto()
|
||||
→ ActionResultProto
|
||||
→ ActionResultProtoApplierImpl.applyActionResults()
|
||||
→ GameStateProto
|
||||
→ GameStateConverter.fromProto()
|
||||
→ GameStateC
|
||||
```
|
||||
|
||||
### Target Flow (T-Types Throughout)
|
||||
```
|
||||
Action.execute()
|
||||
→ ActionResultT
|
||||
→ ActionResultApplier.applyActionResults()
|
||||
→ GameStateC
|
||||
|
||||
(Proto conversion only at boundaries)
|
||||
```
|
||||
|
||||
### Key Files to Convert
|
||||
|
||||
**Tier 1 - Core Applier:** ✅ **Complete**
|
||||
```
|
||||
src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplierImpl.scala
|
||||
```
|
||||
`ActionResultApplier` applies `ActionResultT` directly to Scala `GameState`. The legacy `ActionResultTApplierImpl` wraps it and converts to/from proto for callers that still need proto types.
|
||||
|
||||
**Tier 2 - RoundPhaseAdvancer:** ✅ **Complete**
|
||||
```
|
||||
src/main/scala/net/eagle0/eagle/library/RoundPhaseAdvancer.scala
|
||||
```
|
||||
Now accepts Scala `GameState` and `ActionResultApplier`. Only converts to proto lazily for `AvailableCommandsFactory` calls.
|
||||
|
||||
**Tier 3 - Sequencers:**
|
||||
```
|
||||
src/main/scala/net/eagle0/eagle/library/actions/impl/common/RandomStateTSequencer.scala
|
||||
src/main/scala/net/eagle0/eagle/library/actions/impl/common/RandomStateProtoSequencer.scala
|
||||
```
|
||||
Modify `RandomStateTSequencer` to thread Scala `GameState` throughout (currently converts to proto internally). Then evaluate whether `RandomStateProtoSequencer` is still needed at all.
|
||||
|
||||
**Current State**: `RandomStateTSequencer` accepts Scala `GameState` via its `apply()` method but internally converts to proto. All callback methods (`withRandomActionResult`, `withActionResults`, etc.) pass `GameStateProto` to callers, forcing actions that use the sequencer to work with proto types internally.
|
||||
|
||||
**Target State**: Create a fully protoless sequencer where:
|
||||
1. `lastState` returns Scala `GameState` (not `lastStateProto`)
|
||||
2. All callback methods pass Scala `GameState` to callers
|
||||
3. Actions using the sequencer can be fully protoless
|
||||
|
||||
**Migration Path**:
|
||||
1. Add `lastState: GameState` method alongside `lastStateProto` (non-breaking)
|
||||
2. Add parallel callback methods that pass Scala GameState (e.g., `withScalaActionResult`)
|
||||
3. Migrate actions one by one to use the new Scala-based callbacks
|
||||
4. Once all actions migrated, deprecate/remove proto-based callbacks
|
||||
5. Remove `lastStateProto` once no longer used
|
||||
|
||||
**RandomStateSequencer Migration Progress** (PR #4679 introduced protoless `RandomStateSequencer`):
|
||||
|
||||
| Action | Status |
|
||||
|--------|--------|
|
||||
| `TruceTurnBackPhaseAction` | ✅ Migrated (PR #4680) |
|
||||
| `EndHandleRiotsPhaseAction` | ✅ Migrated (PR #4684) |
|
||||
| `PerformVassalCommandsPhaseAction` | ✅ Migrated |
|
||||
| `PerformVassalDefenseDecisionsAction` | ✅ Migrated |
|
||||
| `EndVassalCommandsPhaseAction` | ✅ Migrated |
|
||||
| `PerformReconResolutionAction` | ✅ Migrated |
|
||||
| `NewRoundAction` | ✅ Migrated (PR #4698) |
|
||||
| `EndBattleAftermathPhaseAction` | ✅ Migrated (PR #4699) |
|
||||
| `EndDiplomacyResolutionPhaseAction` | ✅ Migrated |
|
||||
| `PerformUnaffiliatedHeroesAction` | ✅ Migrated |
|
||||
| `EngineImpl.recursiveTransformT` | ✅ Migrated (PR #4704) |
|
||||
| `ProtolessSequentialResultsActionWrapper` | ✅ Migrated (PR #4705) |
|
||||
| `LegacyRandomStateTSequencer` | ✅ **Deleted** (PR #4705) |
|
||||
|
||||
**TCommandFactory Extraction** (PR #4684):
|
||||
|
||||
To enable lightweight mocking of command creation in tests, `TCommandFactory` trait was extracted from `CommandFactory`. This allows tests to mock just the `makeTCommand` method without pulling in all 40+ command dependencies that `CommandFactory` requires.
|
||||
|
||||
- `TCommandFactory` - lightweight trait with just `makeTCommand`
|
||||
- `CommandFactory extends TCommandFactory` - maintains backward compatibility
|
||||
- Actions accepting command factories now use `TCommandFactory` type for better testability
|
||||
|
||||
**Tier 4 - History APIs:**
|
||||
```
|
||||
src/main/scala/net/eagle0/eagle/service/InMemoryHistory.scala
|
||||
src/main/scala/net/eagle0/eagle/service/PersistedHistory.scala
|
||||
```
|
||||
Change APIs to vend Scala `GameState` and `ActionResultT` instead of proto versions. `PersistedHistory` converts to proto internally for disk persistence; `InMemoryHistory` doesn't need proto at all.
|
||||
|
||||
### ActionResultProto Consumer Inventory
|
||||
|
||||
| File | Usage | Status |
|
||||
|------|-------|--------|
|
||||
| `ActionResultApplierImpl.scala` | Applies ActionResultT to Scala GameState | ✅ **Complete** |
|
||||
| `ActionResultTApplierImpl.scala` | Legacy wrapper - converts to/from proto | Keep until all callers migrated |
|
||||
| `RoundPhaseAdvancer.scala` | Uses Scala GameState | ✅ **Complete** |
|
||||
| `RandomStateSequencer.scala` | Threads Scala GameState | ✅ **Complete** |
|
||||
| `VigorXPApplier.scala` | Has both proto and Scala methods | Scala method exists, delete proto method when unused |
|
||||
| `PerformForcedTurnBackAction.scala` | Fully protoless | ✅ **Complete** |
|
||||
| `ResolveBattleAction.scala` | Heavy proto usage | Blocked by proto dependencies |
|
||||
| `InMemoryHistory.scala` | Stores proto results | Pending - vend Scala types |
|
||||
| `PersistedHistory.scala` | Stores proto results | Pending - vend Scala types, convert for disk |
|
||||
| `GameController.scala` | Uses proto for client communication | Keep proto (gRPC boundary) |
|
||||
|
||||
### Remaining Proto Usage in Actions
|
||||
|
||||
**Progress: 46 of 52 action files (88%) are fully protoless.**
|
||||
|
||||
The following 6 actions still have proto usage:
|
||||
|
||||
| Action | Proto Usages | Blocker | Effort |
|
||||
|--------|--------------|---------|--------|
|
||||
| `ResolveBattleAction` | 24 | Shardok interface, complex battle logic | High |
|
||||
| `PerformVassalCommandsPhaseAction` | 3 | `CommandChoiceHelpers` takes proto GameState | Medium |
|
||||
| `EndHandleRiotsPhaseAction` | 2 | `CommandChoiceHelpers` takes proto GameState | Medium |
|
||||
| `PerformVassalDefenseDecisionsAction` | 2 | `CommandChoiceHelpers` takes proto GameState | Medium |
|
||||
| `EndVassalCommandsPhaseAction` | 1 | `CommandChoiceHelpers` takes proto GameState | Medium |
|
||||
| `NewRoundAction` | 1 | `ChronicleEventGenerator` returns proto | Medium |
|
||||
|
||||
**Deleted Dead Code:**
|
||||
- `UnaffiliatedHeroMovedAction` - Was never called; `PerformUnaffiliatedHeroesAction.heroMovedResult` constructs `ActionResultC` directly
|
||||
- `HeroBackstoryUpdateActionGenerator.fromGameState` - Dead method that converted proto to Scala; only `apply(GameState)` is used
|
||||
|
||||
**Note**: `PerformReconResolutionAction` and `EndBattleAftermathPhaseAction` are now fully protoless after:
|
||||
1. Migrating `FactionT.reconnedProvinces` and `ChangedFactionC.updatedReconnedProvinces` to use Scala `ProvinceView`
|
||||
2. Adding Scala overload of `ProvinceViewFilter.withdrawnFromProvinceView`
|
||||
|
||||
### Estimated Effort (Remaining)
|
||||
|
||||
| Component | Lines | Complexity | Blocks |
|
||||
|-----------|-------|------------|--------|
|
||||
| `CommandChoiceHelpers` to Scala | ~2000 | High | 4 vassal actions |
|
||||
| `ResolveBattleAction` refactor | ~500 | High | 1 action (complex) |
|
||||
| `ChronicleEventGenerator` to Scala | ~400 | Medium | 1 action |
|
||||
| History API updates | ~100 | Low | - |
|
||||
| **Total Remaining** | **~3000** | | |
|
||||
|
||||
### Progress Summary
|
||||
|
||||
| Metric | Value |
|
||||
|--------|-------|
|
||||
| Action files fully protoless | 46 / 52 (88%) |
|
||||
| Proto usages in remaining actions | 33 total |
|
||||
| Biggest blocker | `ResolveBattleAction` (24 usages) |
|
||||
| Second biggest blocker | `CommandChoiceHelpers` (blocks 4 actions) |
|
||||
|
||||
### Validation
|
||||
- [x] `ActionResultApplier` created and tested
|
||||
- [x] `RandomStateSequencer` threads Scala GameState throughout
|
||||
- [x] `RoundPhaseAdvancer` uses T-types internally
|
||||
- [x] `ProvinceViewFilter` has Scala overload for server-side use (PR #4752)
|
||||
- [x] `FactionT.reconnedProvinces` and `ChangedFactionC.updatedReconnedProvinces` use Scala `ProvinceView`
|
||||
- [x] `ProvinceViewFilter.withdrawnFromProvinceView` has Scala overload
|
||||
- [ ] `ProvinceViewFilter` faction-filtered views use Scala types
|
||||
- [ ] `CommandChoiceHelpers` uses Scala types
|
||||
- [ ] History APIs vend Scala types
|
||||
- [ ] No `ActionResultProtoConverter.toProto()` calls except at persistence/gRPC boundaries
|
||||
- [ ] All tests pass
|
||||
|
||||
---
|
||||
|
||||
## Phase 7: Clean Up Legacy Utilities
|
||||
|
||||
### Objective
|
||||
Remove remaining direct proto imports from utility classes.
|
||||
|
||||
### Files to Modify
|
||||
|
||||
| File | Status |
|
||||
|------|--------|
|
||||
| `CommandChoiceHelpers.scala` | Accepts proto `GameState`; blocks full deproto of `PerformVassalCommandsPhaseAction` and `PerformVassalDefenseDecisionsAction` |
|
||||
| `LegacyProvinceUtils.scala` | Replace with `ProvinceUtils.scala` - `hasImminentRiot` added (PR #4683) |
|
||||
| `LegacyFactionUtils.scala` | Replace proto imports with `FactionT` |
|
||||
| `LegacyUnaffiliatedHeroUtils.scala` | Replace proto imports with Scala models |
|
||||
| `BattalionTypeLoader.scala` | Keep proto for file loading, convert immediately after |
|
||||
| `BeastUtils.scala` | **Complete** - now uses Scala `BeastInfo` only |
|
||||
|
||||
### View Filters (Partially Complete)
|
||||
|
||||
The view filter utilities now have Scala overloads for server-side use:
|
||||
|
||||
| File | Status | Notes |
|
||||
|------|--------|-------|
|
||||
| `ProvinceViewFilter.scala` | **Partial** | `filteredProvinceView(ProvinceT, ScalaGameState)` added (PR #4752) |
|
||||
| `ArmyFilter.scala` | **Partial** | `filterArmy(ScalaArmy, Map[BattalionId, BattalionT], Option[FactionId])` added |
|
||||
| `BattalionViewFilter.scala` | **Complete** | Uses Scala `BattalionT` throughout |
|
||||
| `GameStateViewFilter.scala` | Pending | Uses proto types throughout |
|
||||
| `GameStateViewDiffer.scala` | Pending | Works with view protos |
|
||||
|
||||
**Unblocked Actions** (PR #4752):
|
||||
- `EndBattleAftermathPhaseAction` - can now use `filteredProvinceView(province, scalaGameState)`
|
||||
- `PerformReconResolutionAction` - can now use Scala overload
|
||||
- `GameStateFactionExtensions` - can now use `updatedReconnedProvinces` with Scala types
|
||||
|
||||
**Remaining Work**:
|
||||
- Faction-filtered `filteredProvinceView(Province, GameState, FactionId)` still uses proto types
|
||||
- `withdrawnFromProvinceView` still uses proto types
|
||||
- These are needed for client-facing views with visibility restrictions
|
||||
|
||||
---
|
||||
|
||||
## Phase 8: Verify Boundaries
|
||||
|
||||
### Objective
|
||||
Confirm protos are used correctly at boundaries — and ONLY there.
|
||||
|
||||
### Expected Proto Usage (Keep)
|
||||
- `EagleServiceImpl.scala` - gRPC boundary
|
||||
- `InMemoryHistory.scala` / `PersistedHistory.scala` - Persistence boundary
|
||||
- `*Converter.scala` - Explicit conversion utilities
|
||||
- `*Loader.scala` - File loading utilities
|
||||
|
||||
### Expected No Proto Usage (Verify)
|
||||
- `/library/actions/impl/` - Pure Scala models
|
||||
- `/library/util/` - Pure Scala models (except loaders)
|
||||
- `/model/state/` - Pure Scala models
|
||||
|
||||
---
|
||||
|
||||
## Open Questions
|
||||
|
||||
1. **Persistence Format**: Currently game state is persisted as proto. Should we keep proto for persistence (good for schema evolution) or switch to a different format?
|
||||
|
||||
2. **Shardok Integration**: `ResolveBattleAction` communicates with Shardok. Should the Shardok interface use protos (external service) or Scala models?
|
||||
|
||||
3. **View Generation**: `GameStateViewDiffer` works with view protos for client updates. Views need Scala models (`ProvinceViewT`, etc.) to allow actions like `EndBattleAftermathPhaseAction` to be fully protoless. The Scala views would be converted to proto only at the gRPC boundary when sending updates to clients.
|
||||
|
||||
---
|
||||
|
||||
## Success Criteria
|
||||
|
||||
### Code Quality
|
||||
- [ ] Zero proto imports in `/library/actions/` (except boundaries)
|
||||
- [ ] Zero proto imports in `/library/` utilities (except loaders)
|
||||
- [ ] `GameStateT` used throughout engine internals
|
||||
- [ ] Proto usage limited to: `EagleServiceImpl`, loaders, converters, persistence
|
||||
|
||||
### Architecture
|
||||
- [ ] Clear separation: Scala models (internal) vs Proto (boundaries)
|
||||
- [ ] Converters as the only bridge between domains
|
||||
- [ ] No "proto creep" into business logic
|
||||
@@ -1,940 +0,0 @@
|
||||
# Eagle0 Productionization Plan
|
||||
|
||||
## Executive Summary
|
||||
|
||||
This document outlines a plan to move Eagle0's Eagle and Shardok servers from a home Mac to cloud infrastructure while maintaining a QA environment on the Mac. The architecture uses DigitalOcean (already integrated via Spaces) with containerized deployments and GitHub Actions CI/CD.
|
||||
|
||||
## Current Architecture
|
||||
|
||||
```
|
||||
Unity Client
|
||||
│
|
||||
│ gRPC/TLS (eagle0.net:443)
|
||||
▼
|
||||
nginx (home Mac, via router port forward)
|
||||
│
|
||||
├─► Eagle Server (Scala/JVM, port 40032)
|
||||
│ │
|
||||
│ │ internal gRPC (port 40042)
|
||||
│ ▼
|
||||
└─► Shardok Server (C++, port 40042/40052)
|
||||
|
||||
Storage: DigitalOcean Spaces (sfo3.digitaloceanspaces.com)
|
||||
DNS: eagle0.net → home IP
|
||||
```
|
||||
|
||||
**Key observations:**
|
||||
- Already using DigitalOcean Spaces for S3-compatible storage
|
||||
- Eagle server is a deployable JAR (`eagle_server_deploy.jar`)
|
||||
- Shardok server is a native C++ binary
|
||||
- nginx handles TLS termination and gRPC routing
|
||||
- Self-hosted GitHub Actions runner on Mac
|
||||
|
||||
---
|
||||
|
||||
## Target Architecture
|
||||
|
||||
### Production Environment (DigitalOcean)
|
||||
|
||||
```
|
||||
Unity Client
|
||||
│
|
||||
├─► eagle0.net (Production)
|
||||
│ │
|
||||
│ ▼
|
||||
│ DigitalOcean Load Balancer (TLS termination)
|
||||
│ │
|
||||
│ ▼
|
||||
│ ┌─────────────────────────────────────┐
|
||||
│ │ DigitalOcean Droplet(s) │
|
||||
│ │ ┌─────────────┬─────────────────┐ │
|
||||
│ │ │ Eagle │ Shardok │ │
|
||||
│ │ │ (Docker) │ (Docker) │ │
|
||||
│ │ │ :40032 │ :40042 │ │
|
||||
│ │ └─────────────┴─────────────────┘ │
|
||||
│ └─────────────────────────────────────┘
|
||||
│
|
||||
└─► qa.eagle0.net (QA - home Mac, unchanged)
|
||||
│
|
||||
▼
|
||||
nginx → Eagle/Shardok (current setup)
|
||||
```
|
||||
|
||||
### Environment Switching
|
||||
|
||||
The Unity client already supports configurable server URLs via the connection screen:
|
||||
- **Production:** `eagle0.net` (default)
|
||||
- **QA:** `qa.eagle0.net`
|
||||
|
||||
No client code changes needed - users can simply type the desired URL.
|
||||
|
||||
---
|
||||
|
||||
## Cloud Provider: DigitalOcean
|
||||
|
||||
### Why DigitalOcean
|
||||
|
||||
1. **Already integrated** - S3 Spaces storage at `sfo3.digitaloceanspaces.com` with credentials configured
|
||||
2. **Simple pricing** - Predictable monthly costs, no surprise bills
|
||||
3. **Good performance** - SFO3 datacenter is geographically close
|
||||
4. **Managed services** - Load balancers, managed databases if needed later
|
||||
5. **Not AWS/GCP** - Per your requirements
|
||||
|
||||
### Alternative Considered: Hetzner
|
||||
|
||||
- Cheaper for compute ($3.29/mo for 2 vCPU/4GB vs DO's $24/mo)
|
||||
- Good EU presence but less US coverage
|
||||
- No managed load balancer (need to run HAProxy/nginx yourself)
|
||||
- **Recommendation:** Start with DigitalOcean for simplicity; migrate to Hetzner later if cost becomes a concern
|
||||
|
||||
---
|
||||
|
||||
## Infrastructure Components
|
||||
|
||||
### 1. Compute: DigitalOcean Droplets
|
||||
|
||||
#### Resource Characteristics
|
||||
|
||||
- **Eagle server:** CPU-light, possibly RAM-heavy (JVM). Should be always available.
|
||||
- **Shardok server:** Very CPU-heavy (AI algorithms). Only needed during tactical battles. Startup time <1 second.
|
||||
|
||||
#### Recommended: On-Demand Shardok (Same Droplet)
|
||||
|
||||
For current low player count, optimize for cost while maintaining availability:
|
||||
|
||||
| Component | Config | Monthly Cost |
|
||||
|-----------|--------|--------------|
|
||||
| Droplet | s-2vcpu-4gb | $24/mo |
|
||||
| Eagle | Always running | - |
|
||||
| Shardok | Started on-demand by Eagle, stopped after idle | - |
|
||||
|
||||
**How it works:**
|
||||
1. Eagle server runs 24/7 - game is always available
|
||||
2. When battle starts, Eagle launches Shardok container/process (<1s startup)
|
||||
3. After battle ends, idle timer starts (e.g., 5 minutes)
|
||||
4. On timeout, Eagle stops Shardok to free CPU
|
||||
5. If new battle starts during idle period, Shardok is already warm
|
||||
|
||||
**Shardok lifecycle management** (implement in Eagle):
|
||||
```scala
|
||||
// Pseudocode for Eagle's Shardok management
|
||||
object ShardokManager {
|
||||
private var process: Option[Process] = None
|
||||
private var idleTimer: Option[Timer] = None
|
||||
|
||||
def ensureRunning(): Unit = {
|
||||
cancelIdleTimer()
|
||||
if (process.isEmpty) {
|
||||
process = Some(startShardokProcess())
|
||||
waitForHealthCheck()
|
||||
}
|
||||
}
|
||||
|
||||
def onBattleEnd(): Unit = {
|
||||
idleTimer = Some(scheduleShutdown(5.minutes))
|
||||
}
|
||||
|
||||
private def shutdown(): Unit = {
|
||||
process.foreach(_.destroy())
|
||||
process = None
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Future Scaling Options
|
||||
|
||||
As player count grows and Shardok needs more CPU:
|
||||
|
||||
**Option A: Upgrade Droplet (Simplest)**
|
||||
|
||||
| Droplet | vCPU | RAM | Cost | Use Case |
|
||||
|---------|------|-----|------|----------|
|
||||
| s-2vcpu-4gb | 2 shared | 4 GB | $24/mo | Current (few players) |
|
||||
| s-4vcpu-8gb | 4 shared | 8 GB | $48/mo | Moderate usage |
|
||||
| c-4 | 4 dedicated | 8 GB | $84/mo | CPU-intensive battles |
|
||||
| c-8 | 8 dedicated | 16 GB | $168/mo | Multiple concurrent battles |
|
||||
|
||||
**Option B: Separate Shardok Droplet (API-driven)**
|
||||
|
||||
For heavy Shardok usage with cost optimization:
|
||||
|
||||
- **Eagle droplet:** s-1vcpu-2gb ($12/mo) - always on
|
||||
- **Shardok droplet:** Created on-demand via DigitalOcean API
|
||||
- c-4 CPU-optimized: $0.125/hour
|
||||
- c-8 CPU-optimized: $0.25/hour
|
||||
- Created when battle starts, destroyed after idle
|
||||
- 30-60s droplet creation time (acceptable if battles are requested in advance)
|
||||
|
||||
**Option C: Fly.io for Shardok (Scale-to-Zero)**
|
||||
|
||||
For true pay-per-use with fast cold starts:
|
||||
|
||||
- **Eagle:** DigitalOcean or Fly.io (~$10/mo)
|
||||
- **Shardok:** Fly.io with auto-scaling
|
||||
- Performance VMs: ~$0.0000022/second when running
|
||||
- Cold start: 2-5 seconds
|
||||
- Scales to zero when idle
|
||||
|
||||
Requires learning Fly.io but offers best cost efficiency for sporadic usage.
|
||||
|
||||
**Option D: Multiple Shardok Instances (High Scale)**
|
||||
|
||||
For many concurrent battles:
|
||||
|
||||
- **Eagle:** Dedicated droplet with more RAM
|
||||
- **Shardok pool:** Multiple Shardok containers/droplets
|
||||
- Eagle routes battles to available Shardok instances
|
||||
- Could use Kubernetes or Docker Swarm for orchestration
|
||||
|
||||
This is overkill for now but documented for future reference.
|
||||
|
||||
### 2. Load Balancer
|
||||
|
||||
**DigitalOcean Load Balancer:** $12/mo
|
||||
|
||||
- TLS termination with Let's Encrypt
|
||||
- Health checks
|
||||
- Sticky sessions (if needed)
|
||||
- Can add more droplets later for HA
|
||||
|
||||
**Alternative:** Run nginx on the droplet for $0 extra, but lose automatic failover.
|
||||
|
||||
### 3. Storage
|
||||
|
||||
**Already configured:** DigitalOcean Spaces
|
||||
- Bucket: `eagle0`
|
||||
- Region: `sfo3`
|
||||
- Used for game saves and assets
|
||||
- Cost: $5/mo base + $0.02/GB storage + $0.01/GB transfer
|
||||
|
||||
### 4. DNS
|
||||
|
||||
**Option A: DigitalOcean DNS (Recommended)**
|
||||
- Free with droplets
|
||||
- Easy integration
|
||||
- API for automated updates
|
||||
|
||||
**Option B: Keep current DNS provider**
|
||||
- Update A records manually or via script
|
||||
|
||||
**DNS Records:**
|
||||
```
|
||||
eagle0.net A <DO Load Balancer IP>
|
||||
qa.eagle0.net A <Home IP> (unchanged)
|
||||
*.eagle0.net A <DO Load Balancer IP> (wildcard for future)
|
||||
```
|
||||
|
||||
### 5. Firewall
|
||||
|
||||
**DigitalOcean Cloud Firewall:** Free
|
||||
|
||||
```
|
||||
Inbound Rules:
|
||||
- TCP 443 (HTTPS/gRPC) from anywhere → Load Balancer
|
||||
- TCP 22 (SSH) from your IP only → Droplets
|
||||
- TCP 40032 (Eagle) from Load Balancer only
|
||||
- TCP 40042 (Shardok) from Load Balancer only
|
||||
|
||||
Outbound Rules:
|
||||
- All traffic allowed (for external APIs, Spaces, etc.)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Container Strategy
|
||||
|
||||
### Dockerfiles
|
||||
|
||||
**Eagle Server** (`ci/eagle_run.Dockerfile` - already exists, needs enhancement):
|
||||
|
||||
```dockerfile
|
||||
FROM eclipse-temurin:17-jre-alpine
|
||||
|
||||
# Add non-root user
|
||||
RUN addgroup -S eagle && adduser -S eagle -G eagle
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Copy the deploy JAR
|
||||
COPY --chown=eagle:eagle deploy/eagle_server_deploy.jar ./
|
||||
|
||||
# Copy game resources
|
||||
COPY --chown=eagle:eagle src/main/resources/net/eagle0/eagle/ ./resources/
|
||||
|
||||
USER eagle
|
||||
|
||||
# Health check
|
||||
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
|
||||
CMD wget -q --spider http://localhost:40032/health || exit 1
|
||||
|
||||
EXPOSE 40032
|
||||
|
||||
ENTRYPOINT ["java", "-Xmx4g", "-jar", "eagle_server_deploy.jar"]
|
||||
CMD ["--eagle-grpc-port", "40032", "--shardok-interface-remote-address", "shardok:40042", "--gpt-model-name", "gpt-4"]
|
||||
```
|
||||
|
||||
**Shardok Server** (new: `ci/shardok_run.Dockerfile`):
|
||||
|
||||
```dockerfile
|
||||
FROM ubuntu:22.04
|
||||
|
||||
# Install runtime dependencies
|
||||
RUN apt-get update && apt-get install -y \
|
||||
libstdc++6 \
|
||||
ca-certificates \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Add non-root user
|
||||
RUN useradd -r -s /bin/false shardok
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Copy the Shardok binary and dependencies
|
||||
COPY --chown=shardok:shardok bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server ./
|
||||
COPY --chown=shardok:shardok src/main/resources/net/eagle0/shardok/maps/ ./maps/
|
||||
|
||||
USER shardok
|
||||
|
||||
# Health check (need to implement gRPC health endpoint)
|
||||
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
|
||||
CMD ./shardok-server --health-check || exit 1
|
||||
|
||||
EXPOSE 40042 40052
|
||||
|
||||
ENTRYPOINT ["./shardok-server"]
|
||||
```
|
||||
|
||||
**Docker Compose** (new: `docker-compose.prod.yml`):
|
||||
|
||||
```yaml
|
||||
version: '3.8'
|
||||
|
||||
services:
|
||||
eagle:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: ci/eagle_run.Dockerfile
|
||||
image: eagle0/eagle-server:${VERSION:-latest}
|
||||
ports:
|
||||
- "40032:40032"
|
||||
environment:
|
||||
- SHARDOK_ADDRESS=shardok:40042
|
||||
- GPT_MODEL_NAME=${GPT_MODEL_NAME:-gpt-4}
|
||||
- JAVA_OPTS=-Xmx4g -XX:+UseG1GC
|
||||
depends_on:
|
||||
- shardok
|
||||
restart: unless-stopped
|
||||
logging:
|
||||
driver: "json-file"
|
||||
options:
|
||||
max-size: "100m"
|
||||
max-file: "5"
|
||||
|
||||
shardok:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: ci/shardok_run.Dockerfile
|
||||
image: eagle0/shardok-server:${VERSION:-latest}
|
||||
ports:
|
||||
- "40042:40042"
|
||||
- "40052:40052"
|
||||
restart: unless-stopped
|
||||
logging:
|
||||
driver: "json-file"
|
||||
options:
|
||||
max-size: "100m"
|
||||
max-file: "5"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Build Pipeline
|
||||
|
||||
### Build Artifacts
|
||||
|
||||
The build process produces:
|
||||
1. **Eagle JAR:** `bazel-bin/src/main/scala/net/eagle0/eagle/eagle_server_deploy.jar`
|
||||
2. **Shardok binary:** `bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server`
|
||||
|
||||
### Cross-Compilation for Linux
|
||||
|
||||
Current builds target macOS (self-hosted runner). For production Linux deployment:
|
||||
|
||||
**Option A: Build in Docker (Recommended)**
|
||||
```bash
|
||||
# Build Eagle (JVM - platform independent)
|
||||
bazel build //src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar
|
||||
|
||||
# Build Shardok in Linux container
|
||||
docker run --rm -v $(pwd):/workspace -w /workspace \
|
||||
ubuntu:22.04 \
|
||||
bash -c "apt-get update && apt-get install -y build-essential && bazel build -c opt //src/main/cpp/net/eagle0/shardok:shardok-server"
|
||||
```
|
||||
|
||||
**Option B: Use GitHub-hosted Linux runner**
|
||||
- Add `runs-on: ubuntu-latest` workflow
|
||||
- Builds directly on Linux
|
||||
- May need to cache Bazel to avoid long build times
|
||||
|
||||
**Option C: Cross-compile on Mac**
|
||||
- Configure Bazel for Linux cross-compilation
|
||||
- More complex setup but faster iteration
|
||||
|
||||
**Recommendation:** Option A (Docker build) for Shardok, since Eagle's JAR is platform-independent.
|
||||
|
||||
---
|
||||
|
||||
## CI/CD Pipeline
|
||||
|
||||
### GitHub Actions Workflows
|
||||
|
||||
**New workflow:** `.github/workflows/deploy_production.yml`
|
||||
|
||||
```yaml
|
||||
name: Deploy to Production
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
paths:
|
||||
- 'src/main/scala/**'
|
||||
- 'src/main/cpp/**'
|
||||
- 'src/main/protobuf/**'
|
||||
- 'ci/*.Dockerfile'
|
||||
- 'docker-compose.prod.yml'
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
environment:
|
||||
description: 'Deployment environment'
|
||||
required: true
|
||||
default: 'production'
|
||||
type: choice
|
||||
options:
|
||||
- production
|
||||
- staging
|
||||
|
||||
env:
|
||||
REGISTRY: registry.digitalocean.com
|
||||
EAGLE_IMAGE: eagle0/eagle-server
|
||||
SHARDOK_IMAGE: eagle0/shardok-server
|
||||
|
||||
jobs:
|
||||
build-eagle:
|
||||
runs-on: self-hosted
|
||||
outputs:
|
||||
version: ${{ steps.version.outputs.version }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
lfs: false
|
||||
|
||||
- name: Set version
|
||||
id: version
|
||||
run: echo "version=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Build Eagle server JAR
|
||||
run: bazel build //src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar
|
||||
|
||||
- name: Copy artifacts
|
||||
run: |
|
||||
mkdir -p deploy
|
||||
cp bazel-bin/src/main/scala/net/eagle0/eagle/eagle_server_deploy.jar deploy/
|
||||
|
||||
- name: Build Docker image
|
||||
run: |
|
||||
docker build -f ci/eagle_run.Dockerfile -t ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:${{ steps.version.outputs.version }} .
|
||||
docker tag ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:${{ steps.version.outputs.version }} ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:latest
|
||||
|
||||
- name: Push to registry
|
||||
run: |
|
||||
echo "${{ secrets.DO_REGISTRY_TOKEN }}" | docker login ${{ env.REGISTRY }} -u ${{ secrets.DO_REGISTRY_TOKEN }} --password-stdin
|
||||
docker push ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:${{ steps.version.outputs.version }}
|
||||
docker push ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:latest
|
||||
|
||||
build-shardok:
|
||||
runs-on: ubuntu-latest
|
||||
needs: []
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
lfs: false
|
||||
|
||||
- name: Set version
|
||||
id: version
|
||||
run: echo "version=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
|
||||
|
||||
- name: Set up Bazel
|
||||
uses: bazelbuild/setup-bazelisk@v2
|
||||
|
||||
- name: Cache Bazel
|
||||
uses: actions/cache@v3
|
||||
with:
|
||||
path: ~/.cache/bazel
|
||||
key: bazel-linux-${{ hashFiles('MODULE.bazel', 'WORKSPACE') }}
|
||||
|
||||
- name: Build Shardok server
|
||||
run: bazel build -c opt //src/main/cpp/net/eagle0/shardok:shardok-server
|
||||
|
||||
- name: Build Docker image
|
||||
run: |
|
||||
mkdir -p bazel-bin/src/main/cpp/net/eagle0/shardok/
|
||||
cp bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server bazel-bin/src/main/cpp/net/eagle0/shardok/
|
||||
docker build -f ci/shardok_run.Dockerfile -t ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:${{ steps.version.outputs.version }} .
|
||||
docker tag ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:${{ steps.version.outputs.version }} ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:latest
|
||||
|
||||
- name: Push to registry
|
||||
run: |
|
||||
echo "${{ secrets.DO_REGISTRY_TOKEN }}" | docker login ${{ env.REGISTRY }} -u ${{ secrets.DO_REGISTRY_TOKEN }} --password-stdin
|
||||
docker push ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:${{ steps.version.outputs.version }}
|
||||
docker push ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:latest
|
||||
|
||||
deploy:
|
||||
runs-on: ubuntu-latest
|
||||
needs: [build-eagle, build-shardok]
|
||||
environment: production
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Deploy to DigitalOcean
|
||||
uses: appleboy/ssh-action@v1.0.0
|
||||
with:
|
||||
host: ${{ secrets.DO_DROPLET_IP }}
|
||||
username: deploy
|
||||
key: ${{ secrets.DO_SSH_KEY }}
|
||||
script: |
|
||||
cd /opt/eagle0
|
||||
|
||||
# Pull latest images
|
||||
docker-compose -f docker-compose.prod.yml pull
|
||||
|
||||
# Rolling restart (zero-downtime if load balancer configured)
|
||||
docker-compose -f docker-compose.prod.yml up -d --remove-orphans
|
||||
|
||||
# Wait for health checks
|
||||
sleep 30
|
||||
docker-compose -f docker-compose.prod.yml ps
|
||||
|
||||
# Cleanup old images
|
||||
docker image prune -f
|
||||
|
||||
- name: Verify deployment
|
||||
run: |
|
||||
# Health check endpoint
|
||||
curl -f https://eagle0.net/health || exit 1
|
||||
|
||||
- name: Notify on failure
|
||||
if: failure()
|
||||
run: |
|
||||
# Add Slack/Discord notification here
|
||||
echo "Deployment failed!"
|
||||
```
|
||||
|
||||
### Deployment Steps
|
||||
|
||||
1. **On push to main:**
|
||||
- Build Eagle JAR (self-hosted Mac runner - for consistency)
|
||||
- Build Shardok binary (GitHub-hosted Ubuntu runner)
|
||||
- Build Docker images
|
||||
- Push to DigitalOcean Container Registry
|
||||
|
||||
2. **Deploy to droplet:**
|
||||
- SSH to production server
|
||||
- Pull new images
|
||||
- `docker-compose up -d` (rolling update)
|
||||
- Verify health checks
|
||||
|
||||
3. **Rollback:**
|
||||
```bash
|
||||
# On server
|
||||
docker-compose -f docker-compose.prod.yml down
|
||||
docker-compose -f docker-compose.prod.yml pull eagle0/eagle-server:<previous-version>
|
||||
docker-compose -f docker-compose.prod.yml up -d
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Server Setup
|
||||
|
||||
### Initial Droplet Setup
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# Run on fresh DigitalOcean droplet (Ubuntu 22.04)
|
||||
|
||||
# Update system
|
||||
apt-get update && apt-get upgrade -y
|
||||
|
||||
# Install Docker
|
||||
curl -fsSL https://get.docker.com | sh
|
||||
systemctl enable docker
|
||||
systemctl start docker
|
||||
|
||||
# Install Docker Compose
|
||||
apt-get install -y docker-compose-plugin
|
||||
|
||||
# Create deploy user
|
||||
useradd -m -s /bin/bash -G docker deploy
|
||||
mkdir -p /home/deploy/.ssh
|
||||
# Add your SSH public key to /home/deploy/.ssh/authorized_keys
|
||||
|
||||
# Create app directory
|
||||
mkdir -p /opt/eagle0
|
||||
chown deploy:deploy /opt/eagle0
|
||||
|
||||
# Configure Docker to use DigitalOcean Container Registry
|
||||
docker login registry.digitalocean.com
|
||||
|
||||
# Create systemd service for auto-start
|
||||
cat > /etc/systemd/system/eagle0.service << 'EOF'
|
||||
[Unit]
|
||||
Description=Eagle0 Game Servers
|
||||
Requires=docker.service
|
||||
After=docker.service
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
RemainAfterExit=yes
|
||||
WorkingDirectory=/opt/eagle0
|
||||
ExecStart=/usr/bin/docker compose -f docker-compose.prod.yml up -d
|
||||
ExecStop=/usr/bin/docker compose -f docker-compose.prod.yml down
|
||||
User=deploy
|
||||
Group=deploy
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
EOF
|
||||
|
||||
systemctl enable eagle0
|
||||
```
|
||||
|
||||
### Load Balancer Configuration
|
||||
|
||||
**DigitalOcean Load Balancer settings:**
|
||||
|
||||
- **Forwarding Rules:**
|
||||
- HTTPS 443 → HTTP 40032 (Eagle)
|
||||
- gRPC is HTTP/2, handled automatically
|
||||
|
||||
- **Health Checks:**
|
||||
- Protocol: HTTP
|
||||
- Port: 40032
|
||||
- Path: `/health` (need to implement)
|
||||
|
||||
- **SSL:**
|
||||
- Let's Encrypt certificate for `eagle0.net`
|
||||
|
||||
- **Settings:**
|
||||
- Sticky sessions: Disabled (gRPC streams handle this)
|
||||
- Proxy protocol: Disabled
|
||||
|
||||
### nginx on Droplet (Alternative to LB)
|
||||
|
||||
If using nginx instead of managed LB:
|
||||
|
||||
```nginx
|
||||
# /etc/nginx/sites-available/eagle0
|
||||
upstream eagle_backend {
|
||||
server 127.0.0.1:40032;
|
||||
keepalive 100;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 443 ssl http2;
|
||||
server_name eagle0.net;
|
||||
|
||||
ssl_certificate /etc/letsencrypt/live/eagle0.net/fullchain.pem;
|
||||
ssl_certificate_key /etc/letsencrypt/live/eagle0.net/privkey.pem;
|
||||
|
||||
# gRPC settings
|
||||
location /net.eagle0.eagle.api.Eagle {
|
||||
grpc_pass grpc://eagle_backend;
|
||||
grpc_read_timeout 1200s;
|
||||
grpc_send_timeout 1200s;
|
||||
grpc_socket_keepalive on;
|
||||
|
||||
# Rate limiting
|
||||
limit_req zone=eagle burst=50 nodelay;
|
||||
}
|
||||
|
||||
# Health check endpoint
|
||||
location /health {
|
||||
proxy_pass http://127.0.0.1:40032/health;
|
||||
}
|
||||
}
|
||||
|
||||
# Rate limit zone
|
||||
limit_req_zone $binary_remote_addr zone=eagle:10m rate=100r/s;
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Environment Configuration
|
||||
|
||||
### Secrets Management
|
||||
|
||||
**GitHub Secrets (for CI/CD):**
|
||||
- `DO_REGISTRY_TOKEN` - DigitalOcean Container Registry token
|
||||
- `DO_DROPLET_IP` - Production server IP
|
||||
- `DO_SSH_KEY` - SSH private key for deployment
|
||||
- `OPENAI_API_KEY` - For LLM integration (if used in production)
|
||||
- `DO_SPACES_KEY` - Already exists for S3
|
||||
|
||||
**On Server (environment variables):**
|
||||
```bash
|
||||
# /opt/eagle0/.env
|
||||
GPT_MODEL_NAME=gpt-4
|
||||
OPENAI_API_KEY=sk-...
|
||||
DO_SPACES_KEY=...
|
||||
DO_SPACES_SECRET=...
|
||||
JAVA_OPTS=-Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200
|
||||
```
|
||||
|
||||
### Configuration Files
|
||||
|
||||
**Production config** (`/opt/eagle0/config/eagle0.conf`):
|
||||
```
|
||||
monteCarloIterations = 150000
|
||||
monteCarloThreads = 4
|
||||
grpcAddress = 0.0.0.0:40042
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Monitoring & Observability
|
||||
|
||||
### Logging
|
||||
|
||||
**Docker logging driver:** json-file with rotation
|
||||
- Logs stored in `/var/lib/docker/containers/<id>/`
|
||||
- Max 5 files of 100MB each
|
||||
|
||||
**Log aggregation options:**
|
||||
1. **DigitalOcean Logs** - $0 for basic, integrates with Droplets
|
||||
2. **Papertrail** - $7/mo for 1GB, good search
|
||||
3. **Self-hosted Loki** - Free, more complex
|
||||
|
||||
### Metrics
|
||||
|
||||
**Prometheus + Grafana** (optional, for advanced monitoring):
|
||||
```yaml
|
||||
# Add to docker-compose.prod.yml
|
||||
prometheus:
|
||||
image: prom/prometheus
|
||||
volumes:
|
||||
- ./prometheus.yml:/etc/prometheus/prometheus.yml
|
||||
ports:
|
||||
- "9090:9090"
|
||||
|
||||
grafana:
|
||||
image: grafana/grafana
|
||||
ports:
|
||||
- "3000:3000"
|
||||
environment:
|
||||
- GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
|
||||
```
|
||||
|
||||
**Key metrics to track:**
|
||||
- Connection count
|
||||
- Request latency (p50, p95, p99)
|
||||
- Error rate
|
||||
- CPU/memory usage
|
||||
- Shardok AI search depth/time
|
||||
|
||||
### Alerting
|
||||
|
||||
**DigitalOcean Monitoring Alerts:**
|
||||
- CPU > 80% for 5 minutes
|
||||
- Memory > 90%
|
||||
- Disk > 85%
|
||||
- Droplet unreachable
|
||||
|
||||
**Uptime monitoring:**
|
||||
- Use UptimeRobot (free tier) or Better Uptime
|
||||
- Check `https://eagle0.net/health` every minute
|
||||
|
||||
---
|
||||
|
||||
## Cost Estimate
|
||||
|
||||
### Recommended Starting Configuration
|
||||
|
||||
| Component | Monthly Cost | Notes |
|
||||
|-----------|-------------|-------|
|
||||
| Droplet (s-2vcpu-4gb) | $24 | Eagle always-on, Shardok on-demand |
|
||||
| Spaces | ~$5 | Already paying |
|
||||
| Container Registry | $5 | For Docker images |
|
||||
| DNS | $0 | Included |
|
||||
| Bandwidth | ~$0 | 1TB free, then $0.01/GB |
|
||||
| **Total** | **~$34/mo** | |
|
||||
|
||||
### Optional Add-ons
|
||||
|
||||
| Component | Monthly Cost | Notes |
|
||||
|-----------|-------------|-------|
|
||||
| Load Balancer | +$12 | Only if need HA/failover |
|
||||
| Monitoring (Papertrail) | +$7 | Better log search |
|
||||
|
||||
### Scaling Costs
|
||||
|
||||
| Scenario | Droplet | Monthly Cost |
|
||||
|----------|---------|--------------|
|
||||
| Current (few players) | s-2vcpu-4gb | $24 |
|
||||
| Growing usage | s-4vcpu-8gb | $48 |
|
||||
| CPU-intensive battles | c-4 (dedicated) | $84 |
|
||||
| High concurrency | c-8 (dedicated) | $168 |
|
||||
| Separate Shardok (on-demand) | s-1vcpu-2gb + c-4 hourly | $12 + usage |
|
||||
|
||||
---
|
||||
|
||||
## Migration Plan
|
||||
|
||||
### Phase 1: Infrastructure Setup (Day 1)
|
||||
|
||||
1. Create DigitalOcean resources:
|
||||
- Droplet in SFO3 region
|
||||
- Container Registry
|
||||
- (Optional) Load Balancer
|
||||
|
||||
2. Configure DNS:
|
||||
- Point `eagle0.net` to new infrastructure
|
||||
- Keep `qa.eagle0.net` pointing to home IP
|
||||
|
||||
3. Set up server:
|
||||
- Run initial setup script
|
||||
- Configure Docker and docker-compose
|
||||
- Test SSH access
|
||||
|
||||
### Phase 2: Build Pipeline (Day 2)
|
||||
|
||||
1. Create Dockerfiles:
|
||||
- Enhance `ci/eagle_run.Dockerfile`
|
||||
- Create `ci/shardok_run.Dockerfile`
|
||||
|
||||
2. Create `docker-compose.prod.yml`
|
||||
|
||||
3. Set up GitHub Actions:
|
||||
- Add deployment workflow
|
||||
- Configure secrets
|
||||
- Test build pipeline
|
||||
|
||||
### Phase 3: Deployment (Day 3)
|
||||
|
||||
1. Deploy to production:
|
||||
- Push first images
|
||||
- Start containers
|
||||
- Verify health checks
|
||||
|
||||
2. Configure TLS:
|
||||
- Set up Let's Encrypt
|
||||
- Update nginx/LB configuration
|
||||
|
||||
3. Update DNS:
|
||||
- Switch `eagle0.net` to production
|
||||
- Verify client can connect
|
||||
|
||||
### Phase 4: Validation (Day 4)
|
||||
|
||||
1. Test gameplay:
|
||||
- Connect from Unity client
|
||||
- Play through Eagle gameplay
|
||||
- Test Shardok combat
|
||||
|
||||
2. Monitor:
|
||||
- Check logs for errors
|
||||
- Verify resource usage
|
||||
- Test reconnection behavior
|
||||
|
||||
3. Document:
|
||||
- Update runbooks
|
||||
- Document rollback procedures
|
||||
|
||||
### Phase 5: QA Environment (Day 5)
|
||||
|
||||
1. Configure `qa.eagle0.net`:
|
||||
- Keep pointing to home Mac
|
||||
- Ensure nginx routes correctly
|
||||
|
||||
2. Test environment switching:
|
||||
- Connect to production
|
||||
- Switch to QA
|
||||
- Verify different game states
|
||||
|
||||
---
|
||||
|
||||
## Rollback Procedure
|
||||
|
||||
### Quick Rollback (< 5 minutes)
|
||||
|
||||
```bash
|
||||
# SSH to production server
|
||||
ssh deploy@<droplet-ip>
|
||||
|
||||
# Roll back to previous version
|
||||
cd /opt/eagle0
|
||||
docker-compose -f docker-compose.prod.yml down
|
||||
docker pull registry.digitalocean.com/eagle0/eagle-server:<previous-tag>
|
||||
docker pull registry.digitalocean.com/eagle0/shardok-server:<previous-tag>
|
||||
VERSION=<previous-tag> docker-compose -f docker-compose.prod.yml up -d
|
||||
```
|
||||
|
||||
### Full Rollback to Home Mac
|
||||
|
||||
1. Update DNS: Point `eagle0.net` back to home IP
|
||||
2. Ensure home Mac servers are running
|
||||
3. Wait for DNS propagation (5-30 minutes)
|
||||
|
||||
---
|
||||
|
||||
## Security Checklist
|
||||
|
||||
- [ ] SSH key authentication only (disable password)
|
||||
- [ ] Firewall configured (only 443, 22 from trusted IPs)
|
||||
- [ ] TLS 1.3 enforced
|
||||
- [ ] Secrets in environment variables, not in code
|
||||
- [ ] Container runs as non-root user
|
||||
- [ ] Rate limiting on gRPC endpoints
|
||||
- [ ] Regular security updates (`unattended-upgrades`)
|
||||
- [ ] Remove Shardok internal interface from public nginx (per CONNECTION_ARCHITECTURE.md)
|
||||
|
||||
---
|
||||
|
||||
## Resolved Questions
|
||||
|
||||
1. **Game state migration:** No migration needed. Saves are currently local only. The codebase has a `Persister` pattern (with existing AWS support) that could be adapted to save to DO Spaces in the future.
|
||||
|
||||
2. **LLM API keys:** Yes, OpenAI API keys are needed on the Eagle server. Add `OPENAI_API_KEY` to the `.env` file on the production droplet.
|
||||
|
||||
3. **Multiple regions:** Not needed for now. Single SFO3 region is sufficient.
|
||||
|
||||
## Remaining Open Questions
|
||||
|
||||
1. **Backup strategy:** Should we add automated backups for local persistence, or migrate to DO Spaces persistence first?
|
||||
|
||||
2. **Autoscaling:** Is traffic predictable enough to use fixed instance, or need autoscaling later?
|
||||
|
||||
---
|
||||
|
||||
## Next Steps
|
||||
|
||||
### Phase 1: Infrastructure
|
||||
1. **Approve this plan** - Review and discuss any changes
|
||||
2. **Create DigitalOcean resources** - Droplet (s-2vcpu-4gb), Container Registry
|
||||
3. **Set up droplet** - Docker, deploy user, firewall, nginx with TLS
|
||||
|
||||
### Phase 2: Containerization
|
||||
4. **Implement Dockerfiles** - Eagle and Shardok containers
|
||||
5. **Implement Shardok lifecycle management** - Eagle starts/stops Shardok on-demand
|
||||
- Add `ShardokProcessManager` to Eagle server
|
||||
- Start Shardok when battle requested
|
||||
- Stop after idle timeout (5 min)
|
||||
- Health check before routing traffic
|
||||
|
||||
### Phase 3: CI/CD
|
||||
6. **Set up GitHub Actions** - Build and push Docker images
|
||||
7. **Add deployment workflow** - SSH deploy to droplet
|
||||
|
||||
### Phase 4: Migration
|
||||
8. **Deploy to production** - Push images, start services
|
||||
9. **Update DNS** - Point eagle0.net to droplet
|
||||
10. **Validate** - Test gameplay, monitor logs
|
||||
11. **Configure QA** - Ensure qa.eagle0.net still works (home Mac)
|
||||
@@ -1,205 +0,0 @@
|
||||
# Scala 3 Modernization Guide
|
||||
|
||||
## Overview
|
||||
This document outlines opportunities to modernize the Eagle0 codebase to use Scala 3 best practices and features. The migration to Scala 3 is complete, but the code still uses many Scala 2 patterns that can be improved.
|
||||
|
||||
## Modernization Opportunities
|
||||
|
||||
### 1. **Convert Sealed Traits to Enums** 🎯 HIGH IMPACT
|
||||
**Benefits**: Better performance, more concise syntax, improved exhaustiveness checking
|
||||
|
||||
**Current pattern** (`ExternalTextGenerationCaller.scala:23-31`):
|
||||
```scala
|
||||
sealed trait ExternalTextGenerationError extends Error {
|
||||
def message: String
|
||||
}
|
||||
case class ExternalTextGenerationRateLimitError(code: Int, message: String)
|
||||
extends ExternalTextGenerationError
|
||||
case class ExternalTextGenerationHttpError(code: Int, message: String)
|
||||
extends ExternalTextGenerationError
|
||||
case class ExternalTextGenerationTimeoutError(message: String)
|
||||
extends ExternalTextGenerationError
|
||||
```
|
||||
|
||||
**Scala 3 improvement**:
|
||||
```scala
|
||||
enum ExternalTextGenerationError extends Error:
|
||||
case RateLimit(code: Int, message: String)
|
||||
case Http(code: Int, message: String)
|
||||
case Timeout(message: String)
|
||||
|
||||
def message: String = this match
|
||||
case RateLimit(_, msg) => msg
|
||||
case Http(_, msg) => msg
|
||||
case Timeout(msg) => msg
|
||||
```
|
||||
|
||||
**Files to check**:
|
||||
- `/src/main/scala/net/eagle0/common/llm_integration/ExternalTextGenerationCaller.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request/GeneratedTextRequestT.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/model/state/quest/concrete/QuestC.scala`
|
||||
|
||||
### 2. **Convert Implicit Classes to Extension Methods** 🎯 HIGH IMPACT
|
||||
**Benefits**: Modern syntax, better IDE support, cleaner imports
|
||||
|
||||
**Current pattern** (`MoreSeq.scala:23-26`):
|
||||
```scala
|
||||
implicit def SeqCollect[A, Repr[_]](coll: Repr[A])(implicit
|
||||
itr: IsIterable[Repr[A]]
|
||||
): SeqCollect[A, Repr, itr.type] =
|
||||
new SeqCollect[A, Repr, itr.type](coll, itr)
|
||||
```
|
||||
|
||||
**Scala 3 improvement**:
|
||||
```scala
|
||||
extension [A, Repr[_]](coll: Repr[A])(using itr: IsIterable[Repr[A]])
|
||||
def flatCollect[B](pf: PartialFunction[itr.A, Option[B]])(using Factory[B, Repr[B]]): Repr[B] =
|
||||
Factory[B, Repr[B]].fromSpecific(itr(coll).collect(pf).flatten)
|
||||
|
||||
def flatCollectFirst[B](pf: PartialFunction[itr.A, Option[B]]): Option[B] =
|
||||
itr(coll).collect(pf).flatten.headOption
|
||||
```
|
||||
|
||||
**Files to check**:
|
||||
- `/src/main/scala/net/eagle0/common/MoreSeq.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers/CommandChooser.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/service/new_game_creation/NewGameCreation.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultProtoApplierImpl.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/service/new_game_creation/StartGameActionResultUtils.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/model/state/date/Date.scala`
|
||||
|
||||
### 3. **Convert Implicit Parameters to Using Clauses** 🎯 MEDIUM IMPACT
|
||||
**Benefits**: Cleaner syntax, better tooling support, clearer intent
|
||||
|
||||
**Current pattern**:
|
||||
```scala
|
||||
def method[T](value: T)(implicit ec: ExecutionContext): Future[T]
|
||||
def process[A](items: Seq[A])(implicit ord: Ordering[A]): Seq[A]
|
||||
```
|
||||
|
||||
**Scala 3 improvement**:
|
||||
```scala
|
||||
def method[T](value: T)(using ExecutionContext): Future[T]
|
||||
def process[A](items: Seq[A])(using Ordering[A]): Seq[A]
|
||||
```
|
||||
|
||||
**Files to check**:
|
||||
- `/src/main/scala/net/eagle0/common/MoreSeq.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/library/util/hero_name_fetcher/HeroNameFetcher.scala`
|
||||
- `/src/main/scala/net/eagle0/eagle/library/util/ShardokMapInfo.scala`
|
||||
- `/src/main/scala/net/eagle0/common/llm_integration/OpenAIChatCompletionsServiceImpl.scala`
|
||||
- `/src/main/scala/net/eagle0/common/llm_integration/ClaudeServiceImpl.scala`
|
||||
|
||||
### 4. **Opaque Types for Type Safety** 🎯 MEDIUM IMPACT
|
||||
**Benefits**: Zero runtime cost, compile-time type safety, prevents mixing up similar types
|
||||
|
||||
**Pattern to look for**: Type aliases that represent distinct concepts
|
||||
```scala
|
||||
// Instead of: type UserId = String, type GameId = String
|
||||
opaque type UserId = String
|
||||
object UserId:
|
||||
def apply(s: String): UserId = s
|
||||
extension (id: UserId)
|
||||
def value: String = id
|
||||
def isValid: Boolean = id.nonEmpty && id.length > 3
|
||||
|
||||
opaque type GameId = Long
|
||||
object GameId:
|
||||
def apply(l: Long): GameId = l
|
||||
extension (id: GameId) def value: Long = id
|
||||
```
|
||||
|
||||
**Candidates**: Look for simple type aliases and ID types throughout the codebase.
|
||||
|
||||
### 5. **Inline Methods for Performance** 🎯 LOW IMPACT
|
||||
**Benefits**: Compile-time optimization, better performance for hot paths
|
||||
|
||||
**Pattern**: Mark small, frequently-called methods as `inline`
|
||||
```scala
|
||||
inline def isValidId(id: String): Boolean =
|
||||
id.nonEmpty && id.length > 3
|
||||
|
||||
inline def calculateScore(base: Int, multiplier: Double): Double =
|
||||
base * multiplier
|
||||
```
|
||||
|
||||
**Candidates**: Small utility methods in performance-critical paths (AI calculations, game state updates).
|
||||
|
||||
### 6. **Union Types Instead of Complex Hierarchies** 🎯 LOW IMPACT
|
||||
**Benefits**: Simpler type definitions for either/or scenarios
|
||||
|
||||
**Pattern**: Simple sealed traits with only case classes
|
||||
```scala
|
||||
// Instead of:
|
||||
sealed trait Result
|
||||
case class Success(value: String) extends Result
|
||||
case class Error(message: String) extends Result
|
||||
|
||||
// Consider:
|
||||
type Result = Success | Error
|
||||
case class Success(value: String)
|
||||
case class Error(message: String)
|
||||
```
|
||||
|
||||
### 7. **Context Functions for Cleaner APIs** 🎯 LOW IMPACT
|
||||
**Benefits**: Cleaner API design, implicit context passing
|
||||
|
||||
**Pattern**: Replace implicit function parameters
|
||||
```scala
|
||||
// Old
|
||||
type Handler = GameState => Unit
|
||||
def withGameState(gs: GameState)(handler: Handler): Unit = handler(gs)
|
||||
|
||||
// New
|
||||
type Handler = GameState ?=> Unit
|
||||
def withGameState(gs: GameState)(handler: Handler): Unit =
|
||||
given GameState = gs
|
||||
handler
|
||||
```
|
||||
|
||||
## Implementation Priority
|
||||
|
||||
### Phase 1: Quick Wins (High Impact, Low Risk)
|
||||
1. **Convert Extension Methods** in `MoreSeq.scala` - immediate readability improvement
|
||||
2. **Update Using Clauses** - simple find/replace operation
|
||||
3. **Convert Simple Sealed Traits to Enums** - start with error types
|
||||
|
||||
### Phase 2: Type Safety Improvements
|
||||
4. **Add Opaque Types** for IDs and measurements - improves type safety
|
||||
5. **Inline Performance-Critical Methods** - measure before/after impact
|
||||
|
||||
### Phase 3: Advanced Features (Lower Priority)
|
||||
6. **Union Types** where appropriate - only for simple either/or cases
|
||||
7. **Context Functions** for complex API improvements
|
||||
|
||||
## Implementation Guidelines
|
||||
|
||||
### Style Consistency
|
||||
- **Keep curly braces**: Continue using Scala 2 style `{}` instead of indentation-based syntax
|
||||
- **Gradual adoption**: Modernize files as they're touched for other reasons
|
||||
- **Test thoroughly**: Each modernization should include verification that behavior is unchanged
|
||||
|
||||
### Performance Considerations
|
||||
- **Measure enum performance**: Verify that enum conversion actually improves performance in hot paths
|
||||
- **Benchmark inline methods**: Use profiling to confirm performance gains
|
||||
- **Consider compilation time**: Some features may increase compile time
|
||||
|
||||
### Migration Strategy
|
||||
- **File-by-file approach**: Complete modernization of one file at a time
|
||||
- **Separate PRs**: Each modernization type should be its own PR for easier review
|
||||
- **Documentation**: Update this document as patterns are modernized
|
||||
|
||||
## Success Criteria
|
||||
- [ ] All extension methods converted from implicit classes
|
||||
- [ ] All implicit parameters converted to using clauses
|
||||
- [ ] Key sealed traits converted to enums where appropriate
|
||||
- [ ] Opaque types introduced for important ID types
|
||||
- [ ] Performance-critical methods marked as inline (with benchmarks)
|
||||
- [ ] No regression in functionality or performance
|
||||
- [ ] Code remains readable and maintainable
|
||||
|
||||
## Notes
|
||||
- Focus on high-impact, low-risk improvements first
|
||||
- Each change should be driven by clear benefits (performance, readability, type safety)
|
||||
- Maintain backward compatibility where possible
|
||||
- Document any breaking changes clearly
|
||||
@@ -1,305 +0,0 @@
|
||||
# Actions and Commands Model Usage Analysis
|
||||
|
||||
This document analyzes all actions and commands in `src/main/scala/net/eagle0/eagle/library/actions/impl` to determine which use Scala models vs protobuf models, based on BUILD.bazel dependencies.
|
||||
|
||||
**Legend:**
|
||||
- ✅ **Scala Models Only** - Uses only `//src/main/scala/net/eagle0/eagle/model` dependencies
|
||||
- ❌ **Uses Protobuf** - Has dependencies on `//src/main/protobuf` targets
|
||||
- 🔄 **Partial Conversion** - Conversion attempted but blocked by dependencies
|
||||
|
||||
## Summary
|
||||
|
||||
Based on BUILD.bazel dependency analysis (2025-09-16, updated 2025-09-17):
|
||||
- **Total Commands Analyzed:** 41
|
||||
- **Commands Fully Migrated (No Protobuf):** 41 (100%) ✅
|
||||
- **Commands Still Using Protobuf:** 0 (0%) ✅
|
||||
- **Total Actions Analyzed:** 48
|
||||
- **Actions Fully Migrated (No Protobuf):** 5 (10.4%)
|
||||
- **Actions Partially Migrated:** 19 (39.6%)
|
||||
- **Actions Still Using Protobuf:** 24 (50%)
|
||||
- **Base Classes:** 8 protoless variants available, 6 still use protobuf
|
||||
- **Shared Components:** `ResolvedEagleUnit` migrated to use `Option[BattalionT]` for proper null handling
|
||||
|
||||
## Conversion Insights
|
||||
|
||||
Based on conversion attempt of `ResolveTruceOfferCommand` (see [PR #4379](https://github.com/nolen777/eagle0/pull/4379)):
|
||||
|
||||
### Key Challenges Discovered
|
||||
|
||||
1. **LLM Integration Dependencies**: Commands that use `DiplomacyResolutionLlmRequestGenerator` face challenges because the LLM system still expects protobuf enum types, not Scala model enums.
|
||||
|
||||
2. **Inconsistent Package Naming**: Some files have inconsistent package declarations vs BUILD file locations (e.g., `generated_text_request_generators` in package vs `llm_request_generators` in BUILD).
|
||||
|
||||
3. **Model Constructor Differences**: Scala model constructors (e.g., `TruceOffer`) have different required parameters than their protobuf counterparts, requiring more complex data mapping.
|
||||
|
||||
4. **Type System Complexity**: Union types and type constraints become more complex when mixing protobuf and Scala model types during transition.
|
||||
|
||||
5. **Cascading Dependency Issues**: Converting to `ActionResultC` requires extensive trait dependencies (`ChangedBattalionT`, `ChangedHeroT`, `GeneratedTextRequestT`, etc.) that create complex BUILD dependency graphs, unlike simple protobuf `ActionResult`.
|
||||
|
||||
6. **BUILD Complexity**: Each Scala model conversion requires significantly more BUILD dependencies than protobuf equivalents, making incremental conversion difficult.
|
||||
|
||||
7. **Build Verification Critical**: Any conversion must maintain working build state - even simple commands like `DefendCommand` can break main server build due to dependency cascades.
|
||||
### Successful Conversion Elements
|
||||
|
||||
- ✅ Base class conversion (`SimpleAction` → `ProtolessSimpleAction`)
|
||||
- ✅ Import updates for most Scala model types
|
||||
- ✅ BUILD.bazel dependency updates for core action result types
|
||||
- ✅ Basic type conversions for simple cases
|
||||
|
||||
### Recommended Conversion Strategy
|
||||
|
||||
1. **Architecture-First Approach**: Convert base infrastructure (LLM generators, action result builders) before individual commands
|
||||
2. **Wrapper Pattern**: Use existing `Protoless*ActionWrapper` classes as templates for gradual transition
|
||||
3. **Dependency Analysis**: Map full dependency trees before attempting conversions to avoid cascading build failures
|
||||
4. **Batch Conversions**: Convert related commands together to minimize dependency conflicts
|
||||
5. **Build Verification**: **ALWAYS** verify `//src/main/scala/net/eagle0/eagle:eagle_server` and test suite build before creating PRs
|
||||
|
||||
### Conversion Requirements
|
||||
|
||||
**Before creating any PR:**
|
||||
- ✅ `bazel build //src/main/scala/net/eagle0/eagle:eagle_server` succeeds
|
||||
- ✅ `bazel test //src/test/scala/... --keep_going` passes (or doesn't introduce new failures)
|
||||
- ✅ All BUILD dependencies are correctly specified
|
||||
- ✅ Scalafmt and other linters pass
|
||||
|
||||
---
|
||||
|
||||
## Common Base Classes
|
||||
|
||||
| File | Type | Model Usage | Notes |
|
||||
|------|------|-------------|-------|
|
||||
| Action.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto`, `game_state_scala_proto` |
|
||||
| ActionWithResultingState.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto`, `game_state_scala_proto` |
|
||||
| DeterministicSingleResultAction.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto`, `game_state_scala_proto` |
|
||||
| DeterministicSequentialResultsAction.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto`, `game_state_scala_proto` |
|
||||
| ProtolessRandomSequentialResultsAction.scala | Base Class | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model/action_result` |
|
||||
| ProtolessRandomSimpleAction.scala | Base Class | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model/action_result` |
|
||||
| ProtolessSequentialResultsAction.scala | Base Class | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model/action_result` |
|
||||
| ProtolessSimpleAction.scala | Base Class | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model/action_result` |
|
||||
| RandomSequentialResultsAction.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto`, `game_state_scala_proto` |
|
||||
| RandomSimpleAction.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto` |
|
||||
| RandomStateProtoSequencer.scala | Sequencer | ❌ Uses Protobuf | Bridge class, depends on both protobuf and Scala models |
|
||||
| RandomStateTSequencer.scala | Sequencer | ❌ Uses Protobuf | Bridge class, depends on both protobuf and Scala models |
|
||||
| SimpleAction.scala | Base Class | ❌ Uses Protobuf | Depends on `action_result_scala_proto` |
|
||||
| VigorXPApplier.scala | Utility | ❌ Uses Protobuf | Depends on `action_result_scala_proto` |
|
||||
|
||||
---
|
||||
|
||||
## Actions
|
||||
|
||||
### ✅ Fully Migrated Actions (No Protobuf Dependencies)
|
||||
|
||||
These actions have been successfully migrated to use Scala models only:
|
||||
|
||||
| File | Base Class | Notes |
|
||||
|------|------------|-------|
|
||||
| HeroBackstoryUpdateAction.scala | ProtolessSequentialResultsAction | Processes hero backstory updates with LLM integration |
|
||||
| ProvinceConqueredAction.scala | ProtolessSimpleAction | Uses component-based design (gameId, currentRoundId, currentDate, Scala models) |
|
||||
| ProvinceHeldAction.scala | ProtolessSimpleAction | Uses specific components (gameId, currentRoundId, defendingProvince, etc.) instead of full GameState |
|
||||
| UnaffiliatedHeroAppearedAction.scala | ProtolessSimpleAction | Handles unaffiliated hero appearance with name generation |
|
||||
| WithdrawnArmiesReturnHomeAction.scala | ProtolessSequentialResultsAction | Manages army withdrawal and return mechanics |
|
||||
|
||||
### 🔄 Actions Partially Migrated (Using Protoless Base Classes)
|
||||
|
||||
These actions use protoless base classes but still have some protobuf dependencies:
|
||||
|
||||
| File | Model Usage | Notes |
|
||||
|------|-------------|-------|
|
||||
| CheckForFactionChangesAction.scala | ProtolessSequentialResultsAction | Still has some protobuf dependencies |
|
||||
| CheckForFailedQuestsAction.scala | ProtolessSequentialResultsAction | Depends on `unaffiliated_hero_quest_scala_proto` |
|
||||
| CheckForFulfilledQuestsAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| EndAttackDecisionPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| EndBattleAftermathPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| EndFreeForAllDecisionPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| EndPlayerCommandsPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| EndUnaffiliatedHeroActionsPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| EndVassalCommandsPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| FreeForAllDrawAction.scala | ProtolessSimpleAction | Depends on multiple protobuf targets |
|
||||
| FriendlyMoveAction.scala | ProtolessSimpleAction | Depends on multiple protobuf targets |
|
||||
| PerformUncontestedConquestAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| ProvinceConqueredAction.scala | ProtolessSimpleAction | **CONVERTED** - Uses specific components (gameId, currentRoundId, currentDate, Scala models) |
|
||||
| SafePassageArmiesProceedAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| ShipmentArrivedAction.scala | ProtolessSimpleAction | Depends on multiple protobuf targets |
|
||||
| TruceTurnBackPhaseAction.scala | ProtolessSequentialResultsAction | Depends on multiple protobuf targets |
|
||||
| UnaffiliatedHeroRejoinedAction.scala | ProtolessSimpleAction | Depends on multiple protobuf targets |
|
||||
| WonFreeForAllAction.scala | ProtolessSimpleAction | Depends on multiple protobuf targets |
|
||||
|
||||
### ❌ Actions Still Using Protobuf (Not Yet Using Protoless Base Classes)
|
||||
|
||||
| File | Notes |
|
||||
|------|-------|
|
||||
| ChronicleEventGenerator.scala | Depends on multiple protobuf targets |
|
||||
| EndBattleRequestPhaseAction.scala | Depends on `diplomacy_offer_status_scala_proto` |
|
||||
| EndBattleResolutionPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndDefenseDecisionPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndDiplomacyResolutionPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndFreeForAllBattleRequestPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndFreeForAllBattleResolutionPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndHandleRiotsPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndPleaseRecruitMePhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| EndProvinceMoveResolutionPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| NewRoundAction.scala | Depends on multiple protobuf targets |
|
||||
| NewYearAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformFoodConsumptionPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformForcedTurnBackAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformHeroDeparturesAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformHostileArmySetupAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformProvinceEventsAction.scala | Depends on `province_event_scala_proto` |
|
||||
| PerformProvinceMoveResolutionAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformReconResolutionAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformUnaffiliatedHeroesAction.scala | Depends on `unaffiliated_hero_quest_scala_proto` |
|
||||
| PerformVassalCommandsPhaseAction.scala | Depends on multiple protobuf targets |
|
||||
| PerformVassalDefenseDecisionsAction.scala | Depends on multiple protobuf targets |
|
||||
| PrisonerEscapeAction.scala | Depends on `game_state_scala_proto` |
|
||||
| PrisonerExchangeAction.scala | Depends on multiple protobuf targets |
|
||||
| RequestBattlesAction.scala | Depends on multiple protobuf targets |
|
||||
| RequestFreeForAllBattlesAction.scala | Depends on multiple protobuf targets |
|
||||
| ResolveBattleAction.scala | Depends on `shardok_internal_interface_scala_grpc` |
|
||||
| UnaffiliatedHeroMovedAction.scala | Depends on multiple protobuf targets |
|
||||
| UnaffiliatedHeroesChangedAction.scala | Depends on multiple protobuf targets |
|
||||
|
||||
---
|
||||
|
||||
## Commands
|
||||
|
||||
✅ **ALL COMMANDS FULLY MIGRATED** (100% - 41/41 commands)
|
||||
|
||||
All 41 commands in the codebase have been successfully migrated to use Scala models only, with no protobuf dependencies. This includes:
|
||||
|
||||
- **Simple Actions**: Use `ProtolessSimpleAction` base class
|
||||
- **Random Actions**: Use `ProtolessRandomSimpleAction` base class
|
||||
- **Complex Domain Models**: Successfully integrated with LLM systems, diplomacy, quest fulfillment, and state management
|
||||
- **Complete Type Safety**: All commands now use type-safe Scala domain models
|
||||
|
||||
**Key Migration Achievements:**
|
||||
- ✅ All military commands (ArmTroops, Train, Organize, etc.)
|
||||
- ✅ All diplomacy commands (Resolve Alliance/Truce/Ransom offers, etc.)
|
||||
- ✅ All LLM-integrated commands (backstory generation, diplomacy resolution)
|
||||
- ✅ All quest and event commands
|
||||
- ✅ Final remaining command (FreeForAllDecisionCommand) migrated
|
||||
|
||||
---
|
||||
|
||||
## Diplomacy Helpers
|
||||
|
||||
All diplomacy helpers use **Scala models only**:
|
||||
|
||||
| File | Model Usage | Notes |
|
||||
|------|-------------|-------|
|
||||
| AllianceResolutionHelpers.scala | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model` only |
|
||||
| BreakAllianceResolutionHelpers.scala | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model` only |
|
||||
| InvitationResolutionHelpers.scala | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model` only |
|
||||
| RansomResolutionHelpers.scala | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model` only |
|
||||
| TruceResolutionHelpers.scala | ✅ Scala Models Only | Uses `//src/main/scala/net/eagle0/eagle/model` only |
|
||||
|
||||
---
|
||||
|
||||
## Migration Priority Analysis
|
||||
|
||||
Based on the BUILD.bazel dependency analysis, here are the key findings and recommendations:
|
||||
|
||||
### 🎯 High Impact Migration Targets
|
||||
|
||||
**Core Dependencies Blocking Multiple Commands:**
|
||||
|
||||
1. **`action_result_scala_proto`** - Used by 12+ commands
|
||||
- Blocks: `DefendCommand`, `FreeForAllDecisionCommand`, diplomacy resolvers
|
||||
- Impact: Would unlock many command migrations
|
||||
|
||||
2. **`available_command_scala_proto` / `selected_command_scala_proto`** - Used by 10+ commands
|
||||
- Blocks: All UI-interactive commands
|
||||
- Impact: Would enable client-server interaction model migration
|
||||
|
||||
3. **`game_state_scala_proto`** - Used by 8+ commands
|
||||
- Blocks: Complex state-dependent commands
|
||||
- Impact: Core state representation migration
|
||||
|
||||
### 📊 Migration Tiers by Complexity
|
||||
|
||||
**Tier 1 - Quick Wins (2 commands):**
|
||||
- `ArmTroopsCommand` - Only `battalion_type` dependency
|
||||
- `TrainCommand` - Only `battalion_type` dependency
|
||||
- **Effort:** Low, **Impact:** Demonstrates battalion model usage
|
||||
|
||||
**Tier 2 - API Layer (5 commands):**
|
||||
- Commands blocked by `available_command`/`selected_command`
|
||||
- **Effort:** Medium, **Impact:** High (enables UI interaction models)
|
||||
|
||||
**Tier 3 - Diplomacy Suite (6 commands):**
|
||||
- All `Resolve*Command` diplomacy commands
|
||||
- **Effort:** High, **Impact:** High (complete diplomacy model migration)
|
||||
- **Strategy:** Migrate as a group after diplomacy models are ready
|
||||
|
||||
### 🏆 Success Metrics
|
||||
|
||||
**Current Status:**
|
||||
- ✅ **100% of commands fully migrated** (41/41) 🎉
|
||||
- ✅ **All diplomacy helpers use Scala models**
|
||||
- ✅ **All protoless base classes available**
|
||||
- ✅ **ALL command migration completed**
|
||||
|
||||
**Completed Milestones:**
|
||||
- ✅ **70% target:** Migrate Tier 1 + some Tier 2 commands **COMPLETED**
|
||||
- ✅ **80% target:** Continue with remaining non-diplomacy commands **COMPLETED**
|
||||
- ✅ **85% target:** Complete API layer migration **COMPLETED**
|
||||
- ✅ **95% target:** Complete diplomacy migration **COMPLETED**
|
||||
- ✅ **100% target:** Migrate final remaining command (FreeForAllDecisionCommand) **COMPLETED**
|
||||
|
||||
### 🎯 Action Migration Progress
|
||||
|
||||
**Migration Statistics:**
|
||||
- 5/48 Actions fully migrated (10.4%)
|
||||
- 20/48 Actions using protoless base classes but with protobuf dependencies (41.7%)
|
||||
- 24/48 Actions still fully on protobuf (50%)
|
||||
|
||||
**Successfully Migrated Actions:**
|
||||
1. **HeroBackstoryUpdateAction** - LLM integration for hero backstories
|
||||
2. **ProvinceConqueredAction** - Component-based design with prisoner handling and province conquest
|
||||
3. **ProvinceHeldAction** - Component-based design pattern (gameId, currentRoundId, specific models)
|
||||
4. **UnaffiliatedHeroAppearedAction** - Hero appearance with name generation
|
||||
5. **WithdrawnArmiesReturnHomeAction** - Army withdrawal mechanics
|
||||
|
||||
**Recent Migration Updates (2025-09-17):**
|
||||
- **ResolvedEagleUnit** - Changed `battalion: BattalionT` to `battalion: Option[BattalionT]`
|
||||
- Properly handles units without battalions (battalion ID -1)
|
||||
- Updated `ShardokInterfaceGrpcClient` to check for `defaultBattalionId` and use `None`
|
||||
- Updated `ResolveBattleAction`, `ProvinceConqueredAction`, `RequestBattlesAction`
|
||||
- All tests updated to handle optional battalions
|
||||
|
||||
**Key Migration Patterns:**
|
||||
- ✅ Use specific components instead of full GameState (see ProvinceHeldAction, ProvinceConqueredAction)
|
||||
- ✅ Convert protobuf models to Scala models at Action boundaries
|
||||
- ✅ Update BUILD.bazel to remove protobuf dependencies
|
||||
- ✅ Update all call sites and tests
|
||||
- ✅ Use `Option[T]` for optional fields instead of special sentinel values (e.g., battalion ID -1)
|
||||
|
||||
**Next Migration Candidates (Simple Actions with Protoless Base):**
|
||||
1. **FreeForAllDrawAction** - Already uses ProtolessSimpleAction
|
||||
2. **FriendlyMoveAction** - Already uses ProtolessSimpleAction
|
||||
3. **ShipmentArrivedAction** - Already uses ProtolessSimpleAction
|
||||
4. **WonFreeForAllAction** - Already uses ProtolessSimpleAction
|
||||
5. **ProvinceConqueredAction** - Already uses ProtolessSimpleAction, only needs `common_unit` migration
|
||||
|
||||
### 🔄 Conversion Strategy Updates
|
||||
|
||||
**Revised Approach Based on Analysis:**
|
||||
|
||||
1. **Focus on Core Dependencies First**
|
||||
- Migrate `battalion_type` model (unlocks 2 commands immediately)
|
||||
- Migrate `action_result` model (unlocks 12+ commands)
|
||||
- Migrate `available_command`/`selected_command` (unlocks UI layer)
|
||||
|
||||
2. **Leverage Existing Success**
|
||||
- 77.5% of commands already fully migrated
|
||||
- Use migrated commands as reference implementations
|
||||
- Diplomacy helpers prove complex business logic can work with Scala models
|
||||
|
||||
3. **Group Related Migrations**
|
||||
- Military commands: `ArmTroopsCommand`, `TrainCommand`, `OrganizeTroopsCommand`
|
||||
- UI commands: All using `available_command`/`selected_command`
|
||||
- Diplomacy commands: All `Resolve*Command` variants
|
||||
|
||||
---
|
||||
|
||||
*Updated on 2025-09-17 - Analysis based on BUILD.bazel dependencies and code review*
|
||||
*Latest update: ResolvedEagleUnit migrated to use Option[BattalionT] for proper battalion handling*
|
||||
@@ -1,310 +0,0 @@
|
||||
# Scala 3 Migration: Reflection Issues Found
|
||||
|
||||
This document catalogs all reflection-related problems discovered during the Scala 2.13.16 → Scala 3.7.2 migration of the Eagle0 codebase.
|
||||
|
||||
## Summary
|
||||
|
||||
The migration revealed several categories of reflection issues that needed to be addressed for Scala 3 compatibility:
|
||||
|
||||
1. **Scala 2 Runtime Reflection API** - No longer available in Scala 3
|
||||
2. **Settings System Reflection** - Custom reflection for loading settings singletons
|
||||
3. **json4s Automatic Case Class Extraction** - Uses reflection that fails with Scala 3 metaprogramming classes
|
||||
4. **ScalaTest Exception Handling** - Syntax changes affecting exception variable binding
|
||||
|
||||
## 1. Scala 2 Runtime Reflection (FIXED)
|
||||
|
||||
### Issue
|
||||
Tests using `scala.reflect.runtime.universe` fail because this reflection API doesn't exist in Scala 3.
|
||||
|
||||
### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/test/scala/net/eagle0/eagle/library/actions/types/ActionResultTypesTest.scala`
|
||||
|
||||
### Error
|
||||
```scala
|
||||
import scala.reflect.runtime.universe // Not available in Scala 3
|
||||
```
|
||||
|
||||
### Solution Applied
|
||||
**Deleted the test entirely** as it was redundant. The test was verifying that auto-generated Scala objects (created by Bazel from proto enum values) matched their source proto values - something already guaranteed by the build system. Since the objects are generated directly from the proto definitions, this test provided no value.
|
||||
|
||||
**Files deleted:**
|
||||
- `src/test/scala/net/eagle0/eagle/library/actions/types/ActionResultTypesTest.scala`
|
||||
|
||||
## 2. Settings System Reflection (FIXED)
|
||||
|
||||
### Issue
|
||||
Custom `SettingsLoader` class used reflection to access Scala object singletons, but the reflection pattern changed between Scala 2 and Scala 3.
|
||||
|
||||
### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/main/scala/net/eagle0/eagle/library/settings/loaders/SettingsLoader.scala`
|
||||
|
||||
### Error
|
||||
```
|
||||
java.lang.NoSuchMethodException: net.eagle0.eagle.library.settings.ApprehendOutlawVigorCost$.MODULE$
|
||||
```
|
||||
|
||||
### Root Cause
|
||||
In Scala 2, singleton objects are accessed via `ClassName$.MODULE$()`, but in Scala 3, they're accessed directly via `ClassName$` field. Additionally, `scala.reflect.runtime.universe` is not available in Scala 3.
|
||||
|
||||
### Solution Applied
|
||||
**Completely eliminated reflection** by auto-generating the entire `SettingsLoader.scala` file from BUILD.bazel definitions:
|
||||
|
||||
1. **Created generator**: `src/main/go/net/eagle0/build/settings_loader_generator/settings_loader_generator.go` - parses BUILD.bazel and generates complete SettingsLoader.scala with pattern matching for all 272 settings
|
||||
|
||||
2. **Added genrule**: In `src/main/scala/net/eagle0/eagle/library/settings/loaders/BUILD.bazel`:
|
||||
```python
|
||||
genrule(
|
||||
name = "settings_loader_src",
|
||||
srcs = ["//src/main/scala/net/eagle0/eagle/library/settings:BUILD.bazel"],
|
||||
outs = ["SettingsLoader.scala"],
|
||||
cmd = "$(location //src/main/go/net/eagle0/build/settings_loader_generator) $(location //src/main/scala/net/eagle0/eagle/library/settings:BUILD.bazel) > $@",
|
||||
tools = ["//src/main/go/net/eagle0/build/settings_loader_generator"],
|
||||
)
|
||||
```
|
||||
|
||||
3. **Result**: SettingsLoader now uses compile-time pattern matching instead of reflection:
|
||||
```scala
|
||||
private def settingObjectForKey(key: String): Any = key match {
|
||||
case "ActionVigorCost" => ActionVigorCost
|
||||
case "BaseFoodBuyPrice" => BaseFoodBuyPrice
|
||||
// ... all 272 settings auto-generated
|
||||
case _ => throw NoSuchSettingException(key)
|
||||
}
|
||||
```
|
||||
|
||||
### Benefits
|
||||
- **No reflection** - Completely Scala 3 compatible
|
||||
- **Maintainable** - New settings automatically included when added to BUILD.bazel
|
||||
- **Performance** - Pattern matching is faster than reflection
|
||||
- **Type-safe** - Compile-time checking of all settings
|
||||
|
||||
## 3. json4s Reflection Issues (MULTIPLE LOCATIONS)
|
||||
|
||||
### 3.1 EagleServiceImpl JSON Serialization (FIXED)
|
||||
|
||||
#### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/main/scala/net/eagle0/eagle/service/EagleServiceImpl.scala`
|
||||
|
||||
#### Error
|
||||
```
|
||||
java.lang.NoClassDefFoundError: scala/quoted/staging/package$
|
||||
```
|
||||
|
||||
#### Root Cause
|
||||
json4s automatic case class serialization uses reflection that tries to access Scala 3 metaprogramming classes (`scala.quoted.staging.package$`) which aren't available at runtime.
|
||||
|
||||
#### Solution Applied
|
||||
Replaced automatic json4s serialization with ScalaPB's built-in JSON support:
|
||||
|
||||
```scala
|
||||
// Old (reflection-based):
|
||||
// implicit val formats: DefaultFormats.type = DefaultFormats
|
||||
// write(actionResultView)
|
||||
|
||||
// New (ScalaPB JSON support):
|
||||
import scalapb.json4s.JsonFormat
|
||||
JsonFormat.toJsonString(actionResultView.toProto)
|
||||
```
|
||||
|
||||
### 3.2 ShardokMapInfo JSON Parsing (FIXED)
|
||||
|
||||
#### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/main/scala/net/eagle0/eagle/library/util/ShardokMapInfo.scala` (Line 44)
|
||||
|
||||
#### Error
|
||||
```
|
||||
java.lang.NoClassDefFoundError: scala/quoted/staging/package$
|
||||
at org.json4s.reflect.ScalaSigReader$.readConstructor(ScalaSigReader.scala:42)
|
||||
```
|
||||
|
||||
#### Root Cause
|
||||
The line `val extracted = parsedJson.extract[List[ShardokMapInfo]]` uses json4s automatic case class extraction which relies on reflection.
|
||||
|
||||
#### Solution Applied
|
||||
Replaced automatic extraction with manual JSON parsing:
|
||||
|
||||
```scala
|
||||
// OLD (reflection-based):
|
||||
val extracted = parsedJson.extract[List[ShardokMapInfo]]
|
||||
|
||||
// NEW (manual parsing, no reflection):
|
||||
val extracted = parsedJson match {
|
||||
case JArray(items) => items.map { item =>
|
||||
val name = (item \ "name").extract[String]
|
||||
val castleCount = (item \ "castleCount").extract[Int]
|
||||
val positions = (item \ "positions").extract[Map[Int, Int]]
|
||||
ShardokMapInfo(name, castleCount, positions)
|
||||
}
|
||||
case _ => throw new Exception("Expected JSON array for map info")
|
||||
}
|
||||
```
|
||||
|
||||
#### Testing
|
||||
The fix was verified - `attack_command_chooser_test` now passes successfully.
|
||||
|
||||
### 3.3 HeroNameFetcher JSON Parsing (FIXED)
|
||||
|
||||
#### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/main/scala/net/eagle0/eagle/library/util/hero_name_fetcher/HeroNameFetcher.scala`
|
||||
|
||||
#### Issue
|
||||
Case class extraction `parsedJson.extract[ResponseBody]` uses reflection that may fail in Scala 3.
|
||||
|
||||
#### Solution Applied
|
||||
Replaced automatic case class extraction with manual JSON parsing:
|
||||
|
||||
```scala
|
||||
// OLD (reflection-based):
|
||||
val parsedJson = json.parse(src.getLines().mkString)
|
||||
parsedJson.extract[ResponseBody]
|
||||
|
||||
// NEW (manual parsing, no reflection):
|
||||
parsedJson \ "names" match {
|
||||
case JArray(nameArray) =>
|
||||
nameArray.map { nameObj =>
|
||||
val id = (nameObj \ "id").extract[String]
|
||||
val name = (nameObj \ "name").extract[String]
|
||||
NameResponse(id, name)
|
||||
}.toVector
|
||||
case _ => throw new Exception("Expected 'names' array in response")
|
||||
}
|
||||
```
|
||||
|
||||
#### Testing
|
||||
The fix was verified - HeroNameFetcher now builds successfully without reflection.
|
||||
|
||||
### 3.4 Other json4s Usage Analysis
|
||||
|
||||
#### Files with json4s extraction:
|
||||
- **✅ SAFE**: OpenAI/Claude Services - Only extract simple types (`String`, `Int`) - no reflection
|
||||
- **✅ FIXED**: `HeroNameFetcher.scala` - Replaced `extract[ResponseBody]` with manual parsing (no reflection)
|
||||
- **⚠️ POTENTIAL ISSUES** (not currently causing failures but should be monitored):
|
||||
- `JsonUtils.scala`: `extract[Map[String, Vector[String]]]` - complex type extraction
|
||||
- `HexMapJsonUtils.scala`: `extract[List[JObject]]` - may be problematic
|
||||
|
||||
#### Recommendation
|
||||
Apply the same manual parsing pattern to remaining case class extractions if they cause runtime failures during Scala 3 migration.
|
||||
|
||||
## 4. ScalaTest Exception Handling Syntax (FIXED)
|
||||
|
||||
### Issue
|
||||
Scala 3 changed how exception variables are bound in ScalaTest's `the[Exception] thrownBy {...}` construct.
|
||||
|
||||
### Files Affected
|
||||
**70+ test files** across the codebase using exception testing patterns.
|
||||
|
||||
### Error Pattern
|
||||
```
|
||||
Not found: ex
|
||||
```
|
||||
|
||||
### Root Cause
|
||||
In Scala 2: `the[Exception] thrownBy { ... }` automatically creates an `ex` variable.
|
||||
In Scala 3: The exception variable must be explicitly bound.
|
||||
|
||||
### Solution Applied
|
||||
Added explicit variable binding across all affected test files:
|
||||
|
||||
```scala
|
||||
// Old Scala 2 syntax:
|
||||
the[EagleCommandException] thrownBy {
|
||||
// test code
|
||||
}
|
||||
ex.getMessage shouldBe "expected message"
|
||||
|
||||
// New Scala 3 syntax:
|
||||
val ex = the[EagleCommandException] thrownBy {
|
||||
// test code
|
||||
}
|
||||
ex.getMessage shouldBe "expected message"
|
||||
```
|
||||
|
||||
### Script Used
|
||||
Created and ran a systematic fix script that processed 70+ files:
|
||||
|
||||
```bash
|
||||
# Pattern to find and fix exception handling
|
||||
find . -name "*.scala" -exec sed -i '' 's/the\[\([^]]*\)\] thrownBy {/val ex = the[\1] thrownBy {/g' {} \;
|
||||
```
|
||||
|
||||
## 5. ScalaTest Import Changes (FIXED)
|
||||
|
||||
### Issue
|
||||
Scala 3 requires different imports for ScalaTest matchers.
|
||||
|
||||
### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/test/scala/net/eagle0/eagle/library/actions/impl/command/DeclineQuestCommandTest.scala`
|
||||
|
||||
### Error
|
||||
```
|
||||
value convertToAnyShouldWrapper is not a member of object org.scalatest.matchers.should.Matchers
|
||||
```
|
||||
|
||||
### Solution Applied
|
||||
Changed from specific imports to wildcard import:
|
||||
|
||||
```scala
|
||||
// Old:
|
||||
import org.scalatest.matchers.should.Matchers.{convertToAnyShouldWrapper, the}
|
||||
|
||||
// New:
|
||||
import org.scalatest.matchers.should.Matchers.*
|
||||
```
|
||||
|
||||
## 6. Mock Framework Issues (FIXED)
|
||||
|
||||
### Issue
|
||||
ScalaMock had type inference issues with Scala 3 for classes with constructor parameters.
|
||||
|
||||
### Files Affected
|
||||
- `/Users/dancrosby/CodingProjects/github/eagle0/src/test/scala/net/eagle0/eagle/library/EngineImplTest.scala`
|
||||
|
||||
### Error
|
||||
```
|
||||
Found: Vector
|
||||
Required: Vector[net.eagle0.eagle.library.util.hero_generator.hero_with_name.HeroWithName]
|
||||
```
|
||||
|
||||
### Root Cause
|
||||
Mock framework couldn't properly infer types for `mock[HeroGenerator]` where `HeroGenerator` has constructor parameters.
|
||||
|
||||
### Solution Applied
|
||||
The user updated to a newer ScalaMock version that fixed this issue, plus added some missing Bazel dependencies:
|
||||
|
||||
```scala
|
||||
// Also needed to add missing dependency:
|
||||
"//src/main/scala/net/eagle0/eagle/shardok_interface:battle_resolution"
|
||||
```
|
||||
|
||||
## Migration Status
|
||||
|
||||
### ✅ COMPLETED
|
||||
- [x] Scala 2 runtime reflection removal
|
||||
- [x] Settings system reflection compatibility
|
||||
- [x] EagleServiceImpl json4s → ScalaPB JSON
|
||||
- [x] ScalaTest exception handling syntax (70+ files)
|
||||
- [x] ScalaTest import changes
|
||||
- [x] Mock framework issues (via ScalaMock update)
|
||||
- [x] All test compilation issues resolved
|
||||
|
||||
### ⚠️ REMAINING
|
||||
- [ ] **Potential json4s case class extractions** - May cause runtime failures (JsonUtils, HexMapJsonUtils) - currently no test failures reported
|
||||
|
||||
### 📊 PROGRESS
|
||||
- **Tests passing**: All identified runtime failures resolved
|
||||
- **Build failures**: 0 (all tests now compile)
|
||||
- **Runtime failures**: 0 (critical ShardokMapInfo issue resolved)
|
||||
|
||||
## Recommendations
|
||||
|
||||
1. **✅ COMPLETED**: ShardokMapInfo json4s reflection issue resolved with manual parsing
|
||||
2. **Monitor remaining json4s usage**: Watch for runtime failures in HeroNameFetcher, JsonUtils, and HexMapJsonUtils during full Scala 3 migration
|
||||
3. **Consider ScalaPB for new JSON needs**: For new functionality, prefer ScalaPB's JSON support to avoid reflection entirely
|
||||
4. **Apply manual parsing pattern**: If other json4s case class extractions cause runtime failures, use the same manual parsing approach demonstrated in ShardokMapInfo
|
||||
|
||||
## Key Learnings
|
||||
|
||||
- **Scala 3 reflection changes**: Major differences in singleton object access patterns
|
||||
- **json4s compatibility**: Automatic case class extraction doesn't work well with Scala 3 metaprogramming
|
||||
- **ScalaPB advantage**: Using ScalaPB's JSON support avoids reflection issues entirely
|
||||
- **Systematic approach**: Many issues followed patterns that could be fixed with scripts across multiple files
|
||||
Binary file not shown.
@@ -9,7 +9,6 @@ require (
|
||||
github.com/aws/aws-sdk-go-v2/config v1.28.10
|
||||
github.com/aws/aws-sdk-go-v2/credentials v1.17.51
|
||||
github.com/aws/aws-sdk-go-v2/service/s3 v1.72.2
|
||||
google.golang.org/grpc v1.68.0
|
||||
google.golang.org/protobuf v1.36.3
|
||||
)
|
||||
|
||||
|
||||
@@ -40,8 +40,6 @@ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
|
||||
golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
|
||||
golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
|
||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0=
|
||||
google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA=
|
||||
google.golang.org/protobuf v1.26.0-rc.1 h1:7QnIQpGRHE5RnLKnESfDoxm2dTapTZua5a0kS0A+VXQ=
|
||||
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
|
||||
google.golang.org/protobuf v1.36.3 h1:82DV7MYdb8anAVi3qge1wSnMDrnKK7ebr+I0hHRN1BU=
|
||||
|
||||
+167
-251
@@ -1,10 +1,9 @@
|
||||
{
|
||||
"__AUTOGENERATED_FILE_DO_NOT_MODIFY_THIS_FILE_MANUALLY": "THERE_IS_NO_DATA_ONLY_ZUUL",
|
||||
"__INPUT_ARTIFACTS_HASH": 289080209,
|
||||
"__RESOLVED_ARTIFACTS_HASH": -131178107,
|
||||
"__INPUT_ARTIFACTS_HASH": 644967262,
|
||||
"__RESOLVED_ARTIFACTS_HASH": -595552834,
|
||||
"conflict_resolution": {
|
||||
"com.google.guava:failureaccess:1.0.1": "com.google.guava:failureaccess:1.0.2",
|
||||
"com.squareup.okio:okio:2.10.0": "com.squareup.okio:okio:3.6.0",
|
||||
"io.netty:netty-buffer:4.1.110.Final": "io.netty:netty-buffer:4.1.112.Final",
|
||||
"io.netty:netty-codec-http2:4.1.110.Final": "io.netty:netty-codec-http2:4.1.112.Final",
|
||||
"io.netty:netty-codec-http:4.1.110.Final": "io.netty:netty-codec-http:4.1.112.Final",
|
||||
@@ -15,7 +14,8 @@
|
||||
"io.netty:netty-transport-native-unix-common:4.1.110.Final": "io.netty:netty-transport-native-unix-common:4.1.112.Final",
|
||||
"io.netty:netty-transport:4.1.110.Final": "io.netty:netty-transport:4.1.112.Final",
|
||||
"io.opencensus:opencensus-api:0.31.0": "io.opencensus:opencensus-api:0.31.1",
|
||||
"org.checkerframework:checker-qual:3.12.0": "org.checkerframework:checker-qual:3.43.0"
|
||||
"org.checkerframework:checker-qual:3.12.0": "org.checkerframework:checker-qual:3.43.0",
|
||||
"org.scala-lang:scala-library:2.13.14": "org.scala-lang:scala-library:2.13.15"
|
||||
},
|
||||
"artifacts": {
|
||||
"com.amazonaws:aws-lambda-java-core": {
|
||||
@@ -156,18 +156,6 @@
|
||||
},
|
||||
"version": "1.4.2"
|
||||
},
|
||||
"com.squareup.okhttp3:okhttp": {
|
||||
"shasums": {
|
||||
"jar": "b1050081b14bb7a3a7e55a4d3ef01b5dcfabc453b4573a4fc019767191d5f4e0"
|
||||
},
|
||||
"version": "4.12.0"
|
||||
},
|
||||
"com.squareup.okhttp3:okhttp-sse": {
|
||||
"shasums": {
|
||||
"jar": "bff4fbcaef7aac2d910d4ff46dafaa4e6d15da127df6bac97216da46943a7d4c"
|
||||
},
|
||||
"version": "4.12.0"
|
||||
},
|
||||
"com.squareup.okhttp:okhttp": {
|
||||
"shasums": {
|
||||
"jar": "88ac9fd1bb51f82bcc664cc1eb9c225c90dc4389d660231b4cc737bebfe7d0aa"
|
||||
@@ -176,39 +164,27 @@
|
||||
},
|
||||
"com.squareup.okio:okio": {
|
||||
"shasums": {
|
||||
"jar": "8e63292e5c53bb93c4a6b0c213e79f15990fed250c1340f1c343880e1c9c39b5"
|
||||
"jar": "a27f091d34aa452e37227e2cfa85809f29012a8ef2501a9b5a125a978e4fcbc1"
|
||||
},
|
||||
"version": "3.6.0"
|
||||
"version": "2.10.0"
|
||||
},
|
||||
"com.squareup.okio:okio-jvm": {
|
||||
"com.thesamet.scalapb:compilerplugin_2.13": {
|
||||
"shasums": {
|
||||
"jar": "67543f0736fc422ae927ed0e504b98bc5e269fda0d3500579337cb713da28412"
|
||||
},
|
||||
"version": "3.6.0"
|
||||
},
|
||||
"com.thesamet.scalapb:compilerplugin_3": {
|
||||
"shasums": {
|
||||
"jar": "e7d7156269fc23cbb539eea60f07c3230aa05a726434fc942b040495567f0a2d"
|
||||
"jar": "218640423ba8156f994d6d700ef960d65025f79a5918070c0898213f4384df1f"
|
||||
},
|
||||
"version": "1.0.0-alpha.1"
|
||||
},
|
||||
"com.thesamet.scalapb:lenses_3": {
|
||||
"com.thesamet.scalapb:lenses_2.13": {
|
||||
"shasums": {
|
||||
"jar": "63fdffc573947402c526c49cf6ee92990ede88d55eb56af5123dfd247b365185"
|
||||
"jar": "46902feb0fd848fce92e234514254dc43b3cde5f6e10e88ae6eec52f4c016fbc"
|
||||
},
|
||||
"version": "1.0.0-alpha.1"
|
||||
},
|
||||
"com.thesamet.scalapb:protoc-bridge_2.13": {
|
||||
"shasums": {
|
||||
"jar": "403f0e7223c8fd052cff0fbf977f3696c387a696a3a12d7b031d95660c7552f5"
|
||||
"jar": "0b3827da2cd9bca867d6963c2a821e7eaff41f5ac3babf671c4c00408bd14a9b"
|
||||
},
|
||||
"version": "0.9.7"
|
||||
},
|
||||
"com.thesamet.scalapb:protoc-bridge_3": {
|
||||
"shasums": {
|
||||
"jar": "e7e2f1862f54076b6870bd034a7c16aae7b88cfee3d00b69dbb6b1175108560c"
|
||||
},
|
||||
"version": "0.9.9"
|
||||
"version": "0.9.8"
|
||||
},
|
||||
"com.thesamet.scalapb:protoc-gen_2.13": {
|
||||
"shasums": {
|
||||
@@ -216,24 +192,30 @@
|
||||
},
|
||||
"version": "0.9.7"
|
||||
},
|
||||
"com.thesamet.scalapb:scalapb-json4s_3": {
|
||||
"com.thesamet.scalapb:scalapb-json4s_2.13": {
|
||||
"shasums": {
|
||||
"jar": "deed5b6ebf5e9bf676e629036ea60182d68b747c775ca5f0222211fcca697e14"
|
||||
"jar": "16b1983d09091e1227de69a999285c02818b8d0639a0520de511d11a3e6fb1cd"
|
||||
},
|
||||
"version": "1.0.0-alpha.1"
|
||||
},
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_3": {
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_2.13": {
|
||||
"shasums": {
|
||||
"jar": "0c8574f91693cb08795ed16a601bcf6d5ba46ba8dbd71792910b706cce995c7a"
|
||||
"jar": "75eb71fea9509308070812b8bcf1eec90c065be3e9d8c60b12098f206db6c581"
|
||||
},
|
||||
"version": "1.0.0-alpha.1"
|
||||
},
|
||||
"com.thesamet.scalapb:scalapb-runtime_3": {
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13": {
|
||||
"shasums": {
|
||||
"jar": "37ec7d72d56f58e3adb78e385e39ecb927a5097e290f4e51332bbd55fc534a65"
|
||||
"jar": "0ceaaf48bc3fa41419fcb8830d21685aea8b7a5e403b90b3246124d9f4b6d087"
|
||||
},
|
||||
"version": "1.0.0-alpha.1"
|
||||
},
|
||||
"com.thoughtworks.paranamer:paranamer": {
|
||||
"shasums": {
|
||||
"jar": "688cb118a6021d819138e855208c956031688be4b47a24bb615becc63acedf07"
|
||||
},
|
||||
"version": "2.8"
|
||||
},
|
||||
"commons-codec:commons-codec": {
|
||||
"shasums": {
|
||||
"jar": "f9f6cb103f2ddc3c99a9d80ada2ae7bf0685111fd6bffccb72033d1da4e6ff23"
|
||||
@@ -463,27 +445,15 @@
|
||||
},
|
||||
"org.jetbrains.kotlin:kotlin-stdlib": {
|
||||
"shasums": {
|
||||
"jar": "55e989c512b80907799f854309f3bc7782c5b3d13932442d0379d5c472711504"
|
||||
"jar": "b8ab1da5cdc89cb084d41e1f28f20a42bd431538642a5741c52bbfae3fa3e656"
|
||||
},
|
||||
"version": "1.9.10"
|
||||
"version": "1.4.20"
|
||||
},
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-common": {
|
||||
"shasums": {
|
||||
"jar": "cde3341ba18a2ba262b0b7cf6c55b20c90e8d434e42c9a13e6a3f770db965a88"
|
||||
"jar": "a7112c9b3cefee418286c9c9372f7af992bd1e6e030691d52f60cb36dbec8320"
|
||||
},
|
||||
"version": "1.9.10"
|
||||
},
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk7": {
|
||||
"shasums": {
|
||||
"jar": "ac6361bf9ad1ed382c2103d9712c47cdec166232b4903ed596e8876b0681c9b7"
|
||||
},
|
||||
"version": "1.9.10"
|
||||
},
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk8": {
|
||||
"shasums": {
|
||||
"jar": "a4c74d94d64ce1abe53760fe0389dd941f6fc558d0dab35e47c085a11ec80f28"
|
||||
},
|
||||
"version": "1.9.10"
|
||||
"version": "1.4.20"
|
||||
},
|
||||
"org.jetbrains:annotations": {
|
||||
"shasums": {
|
||||
@@ -491,35 +461,41 @@
|
||||
},
|
||||
"version": "13.0"
|
||||
},
|
||||
"org.json4s:json4s-ast_3": {
|
||||
"org.json4s:json4s-ast_2.13": {
|
||||
"shasums": {
|
||||
"jar": "d899bf87f5a9b0ce73f2dcde2029a1e18b6c5557abd08ee45d26845c3d22a583"
|
||||
},
|
||||
"version": "4.1.0-M8"
|
||||
},
|
||||
"org.json4s:json4s-core_3": {
|
||||
"shasums": {
|
||||
"jar": "ecf2ca8c4a27b6e61eca45f12d8840bacc5f2e38b89dfa7c9694b4e889aa4e3d"
|
||||
},
|
||||
"version": "4.1.0-M8"
|
||||
},
|
||||
"org.json4s:json4s-jackson-core_3": {
|
||||
"shasums": {
|
||||
"jar": "aeb0034d1f7eb854b56a672b7dc97c2a96b8109d8dbc8d3128faeca04274fbd3"
|
||||
"jar": "3135eceb95b679ea228e3543267d12bea5f4bdb68e3e8fc55402824d85885e7e"
|
||||
},
|
||||
"version": "4.0.7"
|
||||
},
|
||||
"org.json4s:json4s-native-core_3": {
|
||||
"org.json4s:json4s-core_2.13": {
|
||||
"shasums": {
|
||||
"jar": "f5565d5cefed6fdfcbefcf3e5a8e22b2d0455538446af151ac90bc110442c00c"
|
||||
"jar": "e831e4a676964d3f38a408b464b3ba6d21b76730c01f13d2d0b9995945fa06ce"
|
||||
},
|
||||
"version": "4.1.0-M8"
|
||||
"version": "4.0.7"
|
||||
},
|
||||
"org.json4s:json4s-native_3": {
|
||||
"org.json4s:json4s-jackson-core_2.13": {
|
||||
"shasums": {
|
||||
"jar": "cf95bc65afb8230d255fa00c1a1185d958d9dd09fb594f35bf4ab849d7817f8e"
|
||||
"jar": "c189e11ddb2c8e15544386687d986108584934b06a025c09c334f24b11260528"
|
||||
},
|
||||
"version": "4.1.0-M8"
|
||||
"version": "4.0.7"
|
||||
},
|
||||
"org.json4s:json4s-native-core_2.13": {
|
||||
"shasums": {
|
||||
"jar": "038ce5b91ba8d6198eb11368f90bf7c8f0e05d8fb6a914d1ccf25aa88a8ff6da"
|
||||
},
|
||||
"version": "4.0.7"
|
||||
},
|
||||
"org.json4s:json4s-native_2.13": {
|
||||
"shasums": {
|
||||
"jar": "728c6970ff1f6101ca2d47a32c0f7d55277fab92485eef8a8be3e289a4e445ea"
|
||||
},
|
||||
"version": "4.0.7"
|
||||
},
|
||||
"org.json4s:json4s-scalap_2.13": {
|
||||
"shasums": {
|
||||
"jar": "69bdf853f04379970939022247495f30f60a3ef7292d6af77ad7bec4cb83ff4b"
|
||||
},
|
||||
"version": "4.0.7"
|
||||
},
|
||||
"org.ow2.asm:asm": {
|
||||
"shasums": {
|
||||
@@ -533,29 +509,29 @@
|
||||
},
|
||||
"version": "1.0.4"
|
||||
},
|
||||
"org.scala-lang.modules:scala-collection-compat_3": {
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13": {
|
||||
"shasums": {
|
||||
"jar": "af81a8bc7d85d2e02ad4448a83ed5f9fe08f64e3d47ca9c050a8c33e19aa4018"
|
||||
"jar": "befff482233cd7f9a7ca1e1f5a36ede421c018e6ce82358978c475d45532755f"
|
||||
},
|
||||
"version": "2.12.0"
|
||||
},
|
||||
"org.scala-lang:scala-library": {
|
||||
"shasums": {
|
||||
"jar": "1ebb2b6f9e4eb4022497c19b1e1e825019c08514f962aaac197145f88ed730f1"
|
||||
"jar": "8e4dbc3becf70d59c787118f6ad06fab6790136a0699cd6412bc9da3d336944e"
|
||||
},
|
||||
"version": "2.13.16"
|
||||
"version": "2.13.15"
|
||||
},
|
||||
"org.scala-lang:scala3-library_3": {
|
||||
"org.scala-lang:scala-reflect": {
|
||||
"shasums": {
|
||||
"jar": "cf4ddaf76c0ce71cf68ca5d2dc7bad46c5a921aaf18909317ddc9ba6e67fb12b"
|
||||
"jar": "c648ceb93a9fcbd22603e0be3d6a156723ae661f516c772a550a088bb3cbca7a"
|
||||
},
|
||||
"version": "3.3.6"
|
||||
"version": "2.13.12"
|
||||
},
|
||||
"org.scalamock:scalamock_3": {
|
||||
"org.scalamock:scalamock_2.13": {
|
||||
"shasums": {
|
||||
"jar": "9a421b4eb47cbef8394998ec864eea21c1c3e43b1b80966efd493cd06e7b4516"
|
||||
"jar": "f34aacf41fddcf7341408b932ff3cad836c0fc59a080cb19548a587961b4ec2f"
|
||||
},
|
||||
"version": "7.4.1"
|
||||
"version": "6.0.0"
|
||||
},
|
||||
"org.slf4j:slf4j-api": {
|
||||
"shasums": {
|
||||
@@ -810,63 +786,48 @@
|
||||
"org.checkerframework:checker-qual",
|
||||
"org.ow2.asm:asm"
|
||||
],
|
||||
"com.squareup.okhttp3:okhttp": [
|
||||
"com.squareup.okio:okio",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
],
|
||||
"com.squareup.okhttp3:okhttp-sse": [
|
||||
"com.squareup.okhttp3:okhttp",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
],
|
||||
"com.squareup.okhttp:okhttp": [
|
||||
"com.squareup.okio:okio"
|
||||
],
|
||||
"com.squareup.okio:okio": [
|
||||
"com.squareup.okio:okio-jvm"
|
||||
"org.jetbrains.kotlin:kotlin-stdlib",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-common"
|
||||
],
|
||||
"com.squareup.okio:okio-jvm": [
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-common",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk8"
|
||||
],
|
||||
"com.thesamet.scalapb:compilerplugin_3": [
|
||||
"com.thesamet.scalapb:compilerplugin_2.13": [
|
||||
"com.google.protobuf:protobuf-java",
|
||||
"com.thesamet.scalapb:protoc-gen_2.13",
|
||||
"org.scala-lang.modules:scala-collection-compat_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"com.thesamet.scalapb:lenses_3": [
|
||||
"org.scala-lang.modules:scala-collection-compat_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
"com.thesamet.scalapb:lenses_2.13": [
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"com.thesamet.scalapb:protoc-bridge_2.13": [
|
||||
"dev.dirs:directories",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"com.thesamet.scalapb:protoc-bridge_3": [
|
||||
"dev.dirs:directories",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"com.thesamet.scalapb:protoc-gen_2.13": [
|
||||
"com.thesamet.scalapb:protoc-bridge_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"com.thesamet.scalapb:scalapb-json4s_3": [
|
||||
"com.thesamet.scalapb:scalapb-runtime_3",
|
||||
"org.json4s:json4s-jackson-core_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
"com.thesamet.scalapb:scalapb-json4s_2.13": [
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13",
|
||||
"org.json4s:json4s-jackson-core_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_3": [
|
||||
"com.thesamet.scalapb:scalapb-runtime_3",
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_2.13": [
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13",
|
||||
"io.grpc:grpc-protobuf",
|
||||
"io.grpc:grpc-stub",
|
||||
"org.scala-lang.modules:scala-collection-compat_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"com.thesamet.scalapb:scalapb-runtime_3": [
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13": [
|
||||
"com.google.protobuf:protobuf-java",
|
||||
"com.thesamet.scalapb:lenses_3",
|
||||
"org.scala-lang.modules:scala-collection-compat_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
"com.thesamet.scalapb:lenses_2.13",
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"io.grpc:grpc-api": [
|
||||
"com.google.code.findbugs:jsr305",
|
||||
@@ -1034,42 +995,41 @@
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-common",
|
||||
"org.jetbrains:annotations"
|
||||
],
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk7": [
|
||||
"org.jetbrains.kotlin:kotlin-stdlib"
|
||||
],
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk8": [
|
||||
"org.jetbrains.kotlin:kotlin-stdlib",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk7"
|
||||
],
|
||||
"org.json4s:json4s-ast_3": [
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"org.json4s:json4s-core_3": [
|
||||
"org.json4s:json4s-ast_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"org.json4s:json4s-jackson-core_3": [
|
||||
"com.fasterxml.jackson.core:jackson-databind",
|
||||
"org.json4s:json4s-ast_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"org.json4s:json4s-native-core_3": [
|
||||
"org.json4s:json4s-ast_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"org.json4s:json4s-native_3": [
|
||||
"org.json4s:json4s-core_3",
|
||||
"org.json4s:json4s-native-core_3",
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"org.scala-lang.modules:scala-collection-compat_3": [
|
||||
"org.scala-lang:scala3-library_3"
|
||||
],
|
||||
"org.scala-lang:scala3-library_3": [
|
||||
"org.json4s:json4s-ast_2.13": [
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.scalamock:scalamock_3": [
|
||||
"org.scala-lang:scala3-library_3"
|
||||
"org.json4s:json4s-core_2.13": [
|
||||
"com.thoughtworks.paranamer:paranamer",
|
||||
"org.json4s:json4s-ast_2.13",
|
||||
"org.json4s:json4s-scalap_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.json4s:json4s-jackson-core_2.13": [
|
||||
"com.fasterxml.jackson.core:jackson-databind",
|
||||
"org.json4s:json4s-ast_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.json4s:json4s-native-core_2.13": [
|
||||
"org.json4s:json4s-ast_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.json4s:json4s-native_2.13": [
|
||||
"org.json4s:json4s-core_2.13",
|
||||
"org.json4s:json4s-native-core_2.13",
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.json4s:json4s-scalap_2.13": [
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13": [
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.scala-lang:scala-reflect": [
|
||||
"org.scala-lang:scala-library"
|
||||
],
|
||||
"org.scalamock:scalamock_2.13": [
|
||||
"org.scala-lang:scala-library",
|
||||
"org.scala-lang:scala-reflect"
|
||||
],
|
||||
"org.slf4j:slf4j-simple": [
|
||||
"org.slf4j:slf4j-api"
|
||||
@@ -1500,29 +1460,6 @@
|
||||
"com.google.truth:truth": [
|
||||
"com.google.common.truth"
|
||||
],
|
||||
"com.squareup.okhttp3:okhttp": [
|
||||
"okhttp3",
|
||||
"okhttp3.internal",
|
||||
"okhttp3.internal.authenticator",
|
||||
"okhttp3.internal.cache",
|
||||
"okhttp3.internal.cache2",
|
||||
"okhttp3.internal.concurrent",
|
||||
"okhttp3.internal.connection",
|
||||
"okhttp3.internal.http",
|
||||
"okhttp3.internal.http1",
|
||||
"okhttp3.internal.http2",
|
||||
"okhttp3.internal.io",
|
||||
"okhttp3.internal.platform",
|
||||
"okhttp3.internal.platform.android",
|
||||
"okhttp3.internal.proxy",
|
||||
"okhttp3.internal.publicsuffix",
|
||||
"okhttp3.internal.tls",
|
||||
"okhttp3.internal.ws"
|
||||
],
|
||||
"com.squareup.okhttp3:okhttp-sse": [
|
||||
"okhttp3.internal.sse",
|
||||
"okhttp3.sse"
|
||||
],
|
||||
"com.squareup.okhttp:okhttp": [
|
||||
"com.squareup.okhttp",
|
||||
"com.squareup.okhttp.internal",
|
||||
@@ -1531,18 +1468,18 @@
|
||||
"com.squareup.okhttp.internal.io",
|
||||
"com.squareup.okhttp.internal.tls"
|
||||
],
|
||||
"com.squareup.okio:okio-jvm": [
|
||||
"com.squareup.okio:okio": [
|
||||
"okio",
|
||||
"okio.internal"
|
||||
],
|
||||
"com.thesamet.scalapb:compilerplugin_3": [
|
||||
"com.thesamet.scalapb:compilerplugin_2.13": [
|
||||
"scalapb",
|
||||
"scalapb.compiler",
|
||||
"scalapb.internal",
|
||||
"scalapb.options",
|
||||
"scalapb.options.compiler"
|
||||
],
|
||||
"com.thesamet.scalapb:lenses_3": [
|
||||
"com.thesamet.scalapb:lenses_2.13": [
|
||||
"scalapb.lenses"
|
||||
],
|
||||
"com.thesamet.scalapb:protoc-bridge_2.13": [
|
||||
@@ -1550,21 +1487,16 @@
|
||||
"protocbridge.codegen",
|
||||
"protocbridge.frontend"
|
||||
],
|
||||
"com.thesamet.scalapb:protoc-bridge_3": [
|
||||
"protocbridge",
|
||||
"protocbridge.codegen",
|
||||
"protocbridge.frontend"
|
||||
],
|
||||
"com.thesamet.scalapb:protoc-gen_2.13": [
|
||||
"protocgen"
|
||||
],
|
||||
"com.thesamet.scalapb:scalapb-json4s_3": [
|
||||
"com.thesamet.scalapb:scalapb-json4s_2.13": [
|
||||
"scalapb.json4s"
|
||||
],
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_3": [
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_2.13": [
|
||||
"scalapb.grpc"
|
||||
],
|
||||
"com.thesamet.scalapb:scalapb-runtime_3": [
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13": [
|
||||
"com.google.protobuf.any",
|
||||
"com.google.protobuf.api",
|
||||
"com.google.protobuf.compiler.plugin",
|
||||
@@ -1583,6 +1515,9 @@
|
||||
"scalapb.options",
|
||||
"scalapb.textformat"
|
||||
],
|
||||
"com.thoughtworks.paranamer:paranamer": [
|
||||
"com.thoughtworks.paranamer"
|
||||
],
|
||||
"commons-codec:commons-codec": [
|
||||
"org.apache.commons.codec",
|
||||
"org.apache.commons.codec.binary",
|
||||
@@ -1886,7 +1821,6 @@
|
||||
"kotlin.annotation",
|
||||
"kotlin.collections",
|
||||
"kotlin.collections.builders",
|
||||
"kotlin.collections.jdk8",
|
||||
"kotlin.collections.unsigned",
|
||||
"kotlin.comparisons",
|
||||
"kotlin.concurrent",
|
||||
@@ -1895,59 +1829,51 @@
|
||||
"kotlin.coroutines.cancellation",
|
||||
"kotlin.coroutines.intrinsics",
|
||||
"kotlin.coroutines.jvm.internal",
|
||||
"kotlin.enums",
|
||||
"kotlin.experimental",
|
||||
"kotlin.internal",
|
||||
"kotlin.internal.jdk7",
|
||||
"kotlin.internal.jdk8",
|
||||
"kotlin.io",
|
||||
"kotlin.io.encoding",
|
||||
"kotlin.io.path",
|
||||
"kotlin.jdk7",
|
||||
"kotlin.js",
|
||||
"kotlin.jvm",
|
||||
"kotlin.jvm.functions",
|
||||
"kotlin.jvm.internal",
|
||||
"kotlin.jvm.internal.markers",
|
||||
"kotlin.jvm.internal.unsafe",
|
||||
"kotlin.jvm.jdk8",
|
||||
"kotlin.jvm.optionals",
|
||||
"kotlin.math",
|
||||
"kotlin.properties",
|
||||
"kotlin.random",
|
||||
"kotlin.random.jdk8",
|
||||
"kotlin.ranges",
|
||||
"kotlin.reflect",
|
||||
"kotlin.sequences",
|
||||
"kotlin.streams.jdk8",
|
||||
"kotlin.system",
|
||||
"kotlin.text",
|
||||
"kotlin.text.jdk8",
|
||||
"kotlin.time",
|
||||
"kotlin.time.jdk8"
|
||||
"kotlin.time"
|
||||
],
|
||||
"org.jetbrains:annotations": [
|
||||
"org.intellij.lang.annotations",
|
||||
"org.jetbrains.annotations"
|
||||
],
|
||||
"org.json4s:json4s-ast_3": [
|
||||
"org.json4s:json4s-ast_2.13": [
|
||||
"org.json4s",
|
||||
"org.json4s.prefs"
|
||||
],
|
||||
"org.json4s:json4s-core_3": [
|
||||
"org.json4s:json4s-core_2.13": [
|
||||
"org.json4s",
|
||||
"org.json4s.prefs",
|
||||
"org.json4s.reflect"
|
||||
],
|
||||
"org.json4s:json4s-jackson-core_3": [
|
||||
"org.json4s:json4s-jackson-core_2.13": [
|
||||
"org.json4s.jackson"
|
||||
],
|
||||
"org.json4s:json4s-native-core_3": [
|
||||
"org.json4s:json4s-native-core_2.13": [
|
||||
"org.json4s.native"
|
||||
],
|
||||
"org.json4s:json4s-native_3": [
|
||||
"org.json4s:json4s-native_2.13": [
|
||||
"org.json4s.native"
|
||||
],
|
||||
"org.json4s:json4s-scalap_2.13": [
|
||||
"org.json4s.scalap",
|
||||
"org.json4s.scalap.scalasig"
|
||||
],
|
||||
"org.ow2.asm:asm": [
|
||||
"org.objectweb.asm",
|
||||
"org.objectweb.asm.signature"
|
||||
@@ -1955,7 +1881,7 @@
|
||||
"org.reactivestreams:reactive-streams": [
|
||||
"org.reactivestreams"
|
||||
],
|
||||
"org.scala-lang.modules:scala-collection-compat_3": [
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13": [
|
||||
"scala.collection.compat",
|
||||
"scala.collection.compat.immutable",
|
||||
"scala.util.control.compat",
|
||||
@@ -1994,26 +1920,22 @@
|
||||
"scala.util.hashing",
|
||||
"scala.util.matching"
|
||||
],
|
||||
"org.scala-lang:scala3-library_3": [
|
||||
"scala",
|
||||
"scala.annotation",
|
||||
"scala.annotation.internal",
|
||||
"scala.annotation.unchecked",
|
||||
"scala.compiletime",
|
||||
"scala.compiletime.ops",
|
||||
"scala.compiletime.testing",
|
||||
"scala.deriving",
|
||||
"scala.quoted",
|
||||
"scala.quoted.runtime",
|
||||
"scala.reflect",
|
||||
"scala.runtime",
|
||||
"scala.runtime.coverage",
|
||||
"scala.runtime.function",
|
||||
"scala.runtime.stdLibPatches",
|
||||
"scala.util",
|
||||
"scala.util.control"
|
||||
"org.scala-lang:scala-reflect": [
|
||||
"scala.reflect.api",
|
||||
"scala.reflect.internal",
|
||||
"scala.reflect.internal.annotations",
|
||||
"scala.reflect.internal.pickling",
|
||||
"scala.reflect.internal.settings",
|
||||
"scala.reflect.internal.tpe",
|
||||
"scala.reflect.internal.transform",
|
||||
"scala.reflect.internal.util",
|
||||
"scala.reflect.io",
|
||||
"scala.reflect.macros",
|
||||
"scala.reflect.macros.blackbox",
|
||||
"scala.reflect.macros.whitebox",
|
||||
"scala.reflect.runtime"
|
||||
],
|
||||
"org.scalamock:scalamock_3": [
|
||||
"org.scalamock:scalamock_2.13": [
|
||||
"org.scalamock",
|
||||
"org.scalamock.clazz",
|
||||
"org.scalamock.context",
|
||||
@@ -2024,8 +1946,6 @@
|
||||
"org.scalamock.scalatest",
|
||||
"org.scalamock.scalatest.proxy",
|
||||
"org.scalamock.specs2",
|
||||
"org.scalamock.stubs",
|
||||
"org.scalamock.stubs.internal",
|
||||
"org.scalamock.util"
|
||||
],
|
||||
"org.slf4j:slf4j-api": [
|
||||
@@ -2355,19 +2275,16 @@
|
||||
"com.google.protobuf:protobuf-java",
|
||||
"com.google.re2j:re2j",
|
||||
"com.google.truth:truth",
|
||||
"com.squareup.okhttp3:okhttp",
|
||||
"com.squareup.okhttp3:okhttp-sse",
|
||||
"com.squareup.okhttp:okhttp",
|
||||
"com.squareup.okio:okio",
|
||||
"com.squareup.okio:okio-jvm",
|
||||
"com.thesamet.scalapb:compilerplugin_3",
|
||||
"com.thesamet.scalapb:lenses_3",
|
||||
"com.thesamet.scalapb:compilerplugin_2.13",
|
||||
"com.thesamet.scalapb:lenses_2.13",
|
||||
"com.thesamet.scalapb:protoc-bridge_2.13",
|
||||
"com.thesamet.scalapb:protoc-bridge_3",
|
||||
"com.thesamet.scalapb:protoc-gen_2.13",
|
||||
"com.thesamet.scalapb:scalapb-json4s_3",
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_3",
|
||||
"com.thesamet.scalapb:scalapb-runtime_3",
|
||||
"com.thesamet.scalapb:scalapb-json4s_2.13",
|
||||
"com.thesamet.scalapb:scalapb-runtime-grpc_2.13",
|
||||
"com.thesamet.scalapb:scalapb-runtime_2.13",
|
||||
"com.thoughtworks.paranamer:paranamer",
|
||||
"commons-codec:commons-codec",
|
||||
"commons-logging:commons-logging",
|
||||
"dev.dirs:directories",
|
||||
@@ -2412,20 +2329,19 @@
|
||||
"org.hamcrest:hamcrest-core",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-common",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk7",
|
||||
"org.jetbrains.kotlin:kotlin-stdlib-jdk8",
|
||||
"org.jetbrains:annotations",
|
||||
"org.json4s:json4s-ast_3",
|
||||
"org.json4s:json4s-core_3",
|
||||
"org.json4s:json4s-jackson-core_3",
|
||||
"org.json4s:json4s-native-core_3",
|
||||
"org.json4s:json4s-native_3",
|
||||
"org.json4s:json4s-ast_2.13",
|
||||
"org.json4s:json4s-core_2.13",
|
||||
"org.json4s:json4s-jackson-core_2.13",
|
||||
"org.json4s:json4s-native-core_2.13",
|
||||
"org.json4s:json4s-native_2.13",
|
||||
"org.json4s:json4s-scalap_2.13",
|
||||
"org.ow2.asm:asm",
|
||||
"org.reactivestreams:reactive-streams",
|
||||
"org.scala-lang.modules:scala-collection-compat_3",
|
||||
"org.scala-lang.modules:scala-collection-compat_2.13",
|
||||
"org.scala-lang:scala-library",
|
||||
"org.scala-lang:scala3-library_3",
|
||||
"org.scalamock:scalamock_3",
|
||||
"org.scala-lang:scala-reflect",
|
||||
"org.scalamock:scalamock_2.13",
|
||||
"org.slf4j:slf4j-api",
|
||||
"org.slf4j:slf4j-simple",
|
||||
"software.amazon.awssdk:annotations",
|
||||
|
||||
@@ -3,8 +3,7 @@
|
||||
set -euxo pipefail
|
||||
|
||||
/bin/echo "building darwin bundle"
|
||||
bazel build --config=mactools @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
|
||||
ZIP_LOCATION=$(bazel cquery --config=mactools --output=files @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle 2>/dev/null)
|
||||
/usr/bin/unzip -o $ZIP_LOCATION -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
|
||||
bazel build --noincompatible_enable_cc_toolchain_resolution @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
|
||||
/usr/bin/unzip -o bazel-bin/external/net_eagle0_unity_godice/darwin/framework/DarwinGodiceBundle.zip -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
|
||||
|
||||
/usr/bin/plutil -convert xml1 src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/DarwinGodiceBundle.bundle/Contents/Info.plist
|
||||
|
||||
@@ -5,9 +5,8 @@ set -euxo pipefail
|
||||
/bin/echo "build plugins"
|
||||
|
||||
/bin/echo "building darwin bundle"
|
||||
bazel build --config=mactools @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
|
||||
ZIP_LOCATION=$(bazel cquery --config=mactools --output=files @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle 2>/dev/null)
|
||||
/usr/bin/unzip -o $ZIP_LOCATION -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
|
||||
bazel build --noincompatible_enable_cc_toolchain_resolution @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
|
||||
/usr/bin/unzip -o bazel-bin/external/net_eagle0_unity_godice/darwin/framework/DarwinGodiceBundle.zip -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
|
||||
|
||||
/usr/bin/plutil -convert xml1 src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/DarwinGodiceBundle.bundle/Contents/Info.plist
|
||||
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1pv-WMXReccddPwev_YG9IXEGznuGHrYjNNEZ0Rb-ZhM/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/shardok/settings.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1p6I5nUMcoAPHIcqikVgbBCFVnqN9dpOEVClbS_wOI7M/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/eagle/settings.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1pv-WMXReccddPwev_YG9IXEGznuGHrYjNNEZ0Rb-ZhM/export?gid=0&format=tsv" > src/main/resources/net/eagle0/shardok/settings.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1p6I5nUMcoAPHIcqikVgbBCFVnqN9dpOEVClbS_wOI7M/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/settings.tsv
|
||||
|
||||
bazel run //src/main/go/net/eagle0/build/settings_generator:settings_generator -- \
|
||||
${PWD}/src/main/resources/net/eagle0/eagle/settings.tsv \
|
||||
${PWD}/src/main/scala/net/eagle0/eagle/library/settings/
|
||||
bazel run gazelle
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1DHEsiv4cY4gE6AX3sVH82K__mpBD1aznIYCQwQxA_F0/export?gid=0&format=tsv" | tr -d '\r' > /tmp/names.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1DHEsiv4cY4gE6AX3sVH82K__mpBD1aznIYCQwQxA_F0/export?gid=0&format=tsv" > /tmp/names.tsv
|
||||
bazel run //src/main/scala/net/eagle0/util:name_list_checker -- /tmp/names.tsv > src/main/resources/net/eagle0/names.tsv
|
||||
bazel run //src/main/scala/net/eagle0/util:name_list_json_maker -- /tmp/names.tsv > src/main/resources/net/eagle0/names.json
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1NhvG73HKyVE36yGpkV2oJiSIXoNqQOYTr5ArLnucYL0/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/shardok/battalionTypes.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1pNWiyxIks2wJ1v7jRLFD24zrKHG2AfhC-nkWmQKQGN4/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/eagle/heroes.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1RUguq5eAQprsZwOOqiCc-1dg4Urc_6iJ6awZsFU4MeI/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/eagle/beasts.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1NhvG73HKyVE36yGpkV2oJiSIXoNqQOYTr5ArLnucYL0/export?gid=0&format=tsv" > src/main/resources/net/eagle0/shardok/battalionTypes.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1pNWiyxIks2wJ1v7jRLFD24zrKHG2AfhC-nkWmQKQGN4/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/heroes.tsv
|
||||
curl -L "https://docs.google.com/spreadsheets/d/1RUguq5eAQprsZwOOqiCc-1dg4Urc_6iJ6awZsFU4MeI/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/beasts.tsv
|
||||
#curl -L "https://docs.google.com/spreadsheets/d/1Z-60cJ_N1IasvqpVb5awKEkIYznEeR2IZSdli47oW88/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/province_map.tsv
|
||||
|
||||
${PWD}/scripts/dlSettings.sh
|
||||
|
||||
@@ -1,235 +0,0 @@
|
||||
#!/bin/bash
|
||||
#
|
||||
# generate_changelog.sh
|
||||
#
|
||||
# Generates a weekly changelog from merged PRs, uses Claude to create a synopsis,
|
||||
# and opens an email draft in Mac Mail.
|
||||
#
|
||||
# Usage: ./scripts/generate_changelog.sh [--dry-run]
|
||||
#
|
||||
# The script tracks its last run using a git tag 'changelog-last-run'.
|
||||
# On first run (no tag), it defaults to the previous Friday at 4pm.
|
||||
|
||||
set -euo pipefail
|
||||
|
||||
# Ensure homebrew binaries are in PATH
|
||||
export PATH="/opt/homebrew/bin:$PATH"
|
||||
|
||||
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
||||
REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
|
||||
TAG_NAME="changelog-last-run"
|
||||
DRY_RUN=false
|
||||
|
||||
# Parse arguments
|
||||
while [[ $# -gt 0 ]]; do
|
||||
case $1 in
|
||||
--dry-run)
|
||||
DRY_RUN=true
|
||||
shift
|
||||
;;
|
||||
*)
|
||||
echo "Unknown option: $1"
|
||||
echo "Usage: $0 [--dry-run]"
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
cd "$REPO_ROOT"
|
||||
|
||||
# Get the cutoff date - either from tag or previous Friday 4pm
|
||||
get_cutoff_date() {
|
||||
# Try to get the date from the tag
|
||||
if git rev-parse "$TAG_NAME" >/dev/null 2>&1; then
|
||||
# Get the commit date of the tagged commit
|
||||
git log -1 --format="%aI" "$TAG_NAME"
|
||||
else
|
||||
# Calculate previous Friday at 4pm
|
||||
# Get current day of week (1=Monday, 7=Sunday)
|
||||
local dow=$(date +%u)
|
||||
local days_since_friday
|
||||
|
||||
if [[ $dow -ge 5 ]]; then
|
||||
# Friday (5), Saturday (6), or Sunday (7)
|
||||
days_since_friday=$((dow - 5))
|
||||
else
|
||||
# Monday (1) through Thursday (4)
|
||||
days_since_friday=$((dow + 2))
|
||||
fi
|
||||
|
||||
# Get previous Friday at 4pm in ISO format
|
||||
if [[ "$(uname)" == "Darwin" ]]; then
|
||||
date -v-"${days_since_friday}d" -v16H -v0M -v0S +"%Y-%m-%dT%H:%M:%S%z"
|
||||
else
|
||||
date -d "$days_since_friday days ago 16:00:00" --iso-8601=seconds
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
# Fetch merged PRs since the cutoff date
|
||||
fetch_merged_prs() {
|
||||
local since_date="$1"
|
||||
local output_file="$2"
|
||||
|
||||
echo "Fetching PRs merged since: $since_date"
|
||||
|
||||
# Use gh to search for merged PRs
|
||||
gh pr list \
|
||||
--state merged \
|
||||
--base main \
|
||||
--json number,title,body,mergedAt,author \
|
||||
--jq ".[] | select(.mergedAt >= \"$since_date\")" \
|
||||
> "$output_file.json"
|
||||
|
||||
# Format the output nicely
|
||||
echo "# Merged PRs since $since_date" > "$output_file"
|
||||
echo "" >> "$output_file"
|
||||
|
||||
# Process each PR
|
||||
jq -r '
|
||||
"## PR #\(.number): \(.title)\n" +
|
||||
"Author: \(.author.login)\n" +
|
||||
"Merged: \(.mergedAt)\n\n" +
|
||||
"### Description\n" +
|
||||
(.body // "(No description)") +
|
||||
"\n\n---\n"
|
||||
' "$output_file.json" >> "$output_file"
|
||||
|
||||
# Count PRs
|
||||
local pr_count=$(jq -s 'length' "$output_file.json")
|
||||
echo "Found $pr_count merged PRs"
|
||||
|
||||
rm -f "$output_file.json"
|
||||
|
||||
if [[ $pr_count -eq 0 ]]; then
|
||||
echo "No PRs found since $since_date"
|
||||
return 1
|
||||
fi
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
# Generate synopsis using Claude
|
||||
generate_synopsis() {
|
||||
local input_file="$1"
|
||||
local output_file="$2"
|
||||
|
||||
echo "Generating synopsis with Claude..."
|
||||
|
||||
# Create a prompt file to avoid shell escaping issues
|
||||
local prompt_file="/tmp/eagle0_prompt_$$.txt"
|
||||
cat > "$prompt_file" <<'PROMPT_HEADER'
|
||||
You are summarizing changes for a weekly engineering update email.
|
||||
|
||||
Read the following list of merged PRs and create a concise synopsis grouped by theme/feature/area of the codebase.
|
||||
|
||||
Guidelines:
|
||||
- Group related changes together under clear headings (ALL CAPS with a blank line before)
|
||||
- Use "- " bullet points for individual changes
|
||||
- Highlight any significant new features, breaking changes, or important fixes
|
||||
- Keep the tone professional but accessible
|
||||
- Aim for a summary that takes 1-2 minutes to read
|
||||
- Don't include PR numbers in the summary - focus on what changed and why it matters
|
||||
|
||||
IMPORTANT: Output plain text only. No markdown, no HTML. Use simple formatting:
|
||||
- ALL CAPS for section headers
|
||||
- Dashes (-) for bullet points
|
||||
- Blank lines between sections
|
||||
|
||||
Here are the merged PRs:
|
||||
|
||||
PROMPT_HEADER
|
||||
|
||||
cat "$input_file" >> "$prompt_file"
|
||||
echo "" >> "$prompt_file"
|
||||
echo "Generate the synopsis now:" >> "$prompt_file"
|
||||
|
||||
# Use Claude CLI to generate the synopsis (read from stdin)
|
||||
cat "$prompt_file" | claude --print > "$output_file"
|
||||
|
||||
rm -f "$prompt_file"
|
||||
echo "Synopsis generated at: $output_file"
|
||||
}
|
||||
|
||||
# Create email in Mac Mail
|
||||
create_email() {
|
||||
local synopsis_file="$1"
|
||||
local since_date="$2"
|
||||
|
||||
local subject="Eagle0 Weekly Changelog - $(date +%Y-%m-%d)"
|
||||
|
||||
echo "Creating email draft in Mac Mail..."
|
||||
|
||||
osascript <<EOF
|
||||
set textContent to read POSIX file "$synopsis_file" as «class utf8»
|
||||
|
||||
tell application "Mail"
|
||||
set newMessage to make new outgoing message with properties {subject:"$subject", content:textContent, visible:true}
|
||||
activate
|
||||
end tell
|
||||
EOF
|
||||
|
||||
echo "Email draft created"
|
||||
}
|
||||
|
||||
# Update the tag to mark this run
|
||||
update_tag() {
|
||||
echo "Updating $TAG_NAME tag..."
|
||||
|
||||
# Delete existing tag if present
|
||||
git tag -d "$TAG_NAME" 2>/dev/null || true
|
||||
git push origin --delete "$TAG_NAME" 2>/dev/null || true
|
||||
|
||||
# Create new tag at HEAD
|
||||
git tag "$TAG_NAME"
|
||||
git push origin "$TAG_NAME"
|
||||
|
||||
echo "Tag updated to current HEAD"
|
||||
}
|
||||
|
||||
# Main
|
||||
main() {
|
||||
echo "=== Eagle0 Weekly Changelog Generator ==="
|
||||
echo ""
|
||||
|
||||
# Get cutoff date
|
||||
local cutoff_date=$(get_cutoff_date)
|
||||
echo "Cutoff date: $cutoff_date"
|
||||
|
||||
# Create temp files
|
||||
local pr_file="/tmp/eagle0_prs_$(date +%s).md"
|
||||
local synopsis_file="/tmp/eagle0_synopsis_$(date +%s).txt"
|
||||
|
||||
# Fetch PRs
|
||||
if ! fetch_merged_prs "$cutoff_date" "$pr_file"; then
|
||||
echo "No changes to report. Exiting."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "PR details saved to: $pr_file"
|
||||
|
||||
# Generate synopsis
|
||||
generate_synopsis "$pr_file" "$synopsis_file"
|
||||
|
||||
if [[ "$DRY_RUN" == "true" ]]; then
|
||||
echo ""
|
||||
echo "=== DRY RUN - Synopsis content ==="
|
||||
cat "$synopsis_file"
|
||||
echo ""
|
||||
echo "=== DRY RUN - Skipping email creation and tag update ==="
|
||||
else
|
||||
# Create email
|
||||
create_email "$synopsis_file" "$cutoff_date"
|
||||
|
||||
# Update tag for next run
|
||||
update_tag
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "Done!"
|
||||
echo "PR details: $pr_file"
|
||||
echo "Synopsis: $synopsis_file"
|
||||
}
|
||||
|
||||
main
|
||||
@@ -1,19 +0,0 @@
|
||||
#!/bin/bash
|
||||
# Pre-commit hook wrapper for gazelle that fails if files are modified.
|
||||
# This ensures BUILD files are in canonical format before committing.
|
||||
|
||||
set -e
|
||||
|
||||
# Run gazelle
|
||||
bazel run //:gazelle 2>/dev/null
|
||||
|
||||
# Check if any BUILD files were modified
|
||||
if ! git diff --quiet -- '*.bazel' '**/BUILD' 'WORKSPACE*'; then
|
||||
echo ""
|
||||
echo "ERROR: gazelle modified BUILD files. Please stage the changes and retry:"
|
||||
echo ""
|
||||
git diff --name-only -- '*.bazel' '**/BUILD' 'WORKSPACE*'
|
||||
echo ""
|
||||
echo "Run: git add -u && git commit"
|
||||
exit 1
|
||||
fi
|
||||
@@ -22,6 +22,13 @@ cc_library(
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "container_utils",
|
||||
hdrs = ["ContainerUtils.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "filesystem_utils",
|
||||
srcs = ["FilesystemUtils.cpp"],
|
||||
@@ -88,13 +95,6 @@ cc_library(
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "thread_pool",
|
||||
hdrs = ["ThreadPool.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "time_utils",
|
||||
hdrs = ["TimeUtils.hpp"],
|
||||
|
||||
@@ -7,43 +7,12 @@
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
// FNV-1a 64-bit constants
|
||||
constexpr uint64_t FNV_PRIME = 0x00000100000001B3ULL;
|
||||
constexpr uint64_t FNV_OFFSET_BASIS = 0xcbf29ce484222325ULL;
|
||||
constexpr uint64_t FNV_PRIME = 0x100000001b3;
|
||||
constexpr uint64_t FNV_OFFSET_BASIS = 0xcbf29ce484222325;
|
||||
|
||||
// FNV-1a algorithm: XOR first, then multiply
|
||||
static inline auto MixIn(uint64_t& hash, const uint8_t byte) {
|
||||
hash ^= byte;
|
||||
hash *= FNV_PRIME;
|
||||
}
|
||||
|
||||
// Hash an entire buffer using FNV-1a
|
||||
// Fast word-at-a-time implementation - processes 8 bytes at once for better performance
|
||||
// while maintaining good distribution properties for hash table use
|
||||
static inline auto HashBuffer(const uint8_t* data, size_t size) -> uint64_t {
|
||||
if (data == nullptr) { return FNV_OFFSET_BASIS; }
|
||||
|
||||
uint64_t hash = FNV_OFFSET_BASIS;
|
||||
const uint8_t* end = data + size;
|
||||
|
||||
// Process 8 bytes at a time
|
||||
while (data + 8 <= end) {
|
||||
uint64_t word;
|
||||
// Use memcpy to avoid alignment issues and let compiler optimize
|
||||
__builtin_memcpy(&word, data, sizeof(word));
|
||||
hash ^= word;
|
||||
hash *= FNV_PRIME;
|
||||
data += 8;
|
||||
}
|
||||
|
||||
// Process remaining bytes
|
||||
while (data < end) {
|
||||
hash ^= static_cast<uint64_t>(*data);
|
||||
hash *= FNV_PRIME;
|
||||
data++;
|
||||
}
|
||||
|
||||
return hash;
|
||||
hash = hash * FNV_PRIME;
|
||||
hash = hash ^ byte;
|
||||
}
|
||||
|
||||
#endif // EAGLE0_BYTEHASHER_HPP
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
//
|
||||
// Created by Dan Crosby on 12/25/20.
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_CONTAINERUTILS_HPP
|
||||
#define EAGLE0_CONTAINERUTILS_HPP
|
||||
|
||||
#include <algorithm>
|
||||
#include <functional>
|
||||
#include <optional>
|
||||
|
||||
namespace common {
|
||||
|
||||
using std::allocator;
|
||||
using std::back_inserter;
|
||||
using std::begin;
|
||||
using std::copy_if;
|
||||
using std::count_if;
|
||||
using std::end;
|
||||
using std::find;
|
||||
using std::find_if;
|
||||
using std::function;
|
||||
using std::optional;
|
||||
using std::remove_if;
|
||||
using std::vector;
|
||||
|
||||
template<class T, class Container>
|
||||
auto Contains(const Container& container, const T& elt) -> bool {
|
||||
return find(begin(container), end(container), elt) != end(container);
|
||||
}
|
||||
|
||||
template<class Container, class Func>
|
||||
auto CountIf(const Container& container, Func fn) -> size_t {
|
||||
Container result{};
|
||||
return count_if(begin(container), end(container), fn);
|
||||
}
|
||||
|
||||
template<class Container, class Func>
|
||||
void FilterInPlace(Container& container, Func fn) {
|
||||
container.erase(
|
||||
remove_if(begin(container), end(container), [fn](const auto& elt) { return !fn(elt); }),
|
||||
end(container));
|
||||
}
|
||||
|
||||
template<class Container, class Func>
|
||||
auto Filtered(const Container& container, Func fn) -> Container {
|
||||
Container result{};
|
||||
copy_if(begin(container), end(container), back_inserter(result), fn);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<class Container, class Func>
|
||||
auto FilteredToVector(const Container& container, Func fn) -> decltype(auto) {
|
||||
typedef typename Container::value_type value_type;
|
||||
vector<value_type> result{};
|
||||
copy_if(begin(container), end(container), back_inserter(result), fn);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename Container, typename Func>
|
||||
auto FindIf(const Container& container, Func fn) -> optional<typename Container::value_type> {
|
||||
const auto& t = find_if(begin(container), end(container), fn);
|
||||
|
||||
if (t == end(container)) {
|
||||
return {};
|
||||
} else {
|
||||
return optional<typename Container::value_type>(*t);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Container, typename Func>
|
||||
auto ContainsWhere(const Container& container, Func fn) -> bool {
|
||||
return find_if(begin(container), end(container), fn) != end(container);
|
||||
}
|
||||
|
||||
template<
|
||||
template<typename, typename>
|
||||
class TwoTypeContainer,
|
||||
typename T,
|
||||
typename Allocator = allocator<T>,
|
||||
typename Func>
|
||||
auto Map(const TwoTypeContainer<T, Allocator>& input, Func fn) -> decltype(auto) {
|
||||
typedef typename decltype(function(fn))::result_type result_type;
|
||||
|
||||
TwoTypeContainer<result_type, allocator<result_type>> result{};
|
||||
result.reserve(input.size());
|
||||
|
||||
transform(begin(input), end(input), back_inserter(result), fn);
|
||||
return result;
|
||||
}
|
||||
|
||||
template<template<typename> class OneTypeContainer, typename T, typename Func>
|
||||
auto Map(const OneTypeContainer<T>& input, Func fn) -> decltype(auto) {
|
||||
typedef typename decltype(function(fn))::result_type result_type;
|
||||
|
||||
OneTypeContainer<result_type> result{};
|
||||
result.reserve(input.size());
|
||||
|
||||
transform(begin(input), end(input), back_inserter(result), fn);
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename Container, typename Func>
|
||||
auto MapToVector(const Container& input, Func fn) -> decltype(auto) {
|
||||
typedef typename decltype(function(fn))::result_type result_type;
|
||||
|
||||
vector<result_type> result{};
|
||||
|
||||
transform(begin(input), end(input), back_inserter(result), fn);
|
||||
return result;
|
||||
}
|
||||
|
||||
template<
|
||||
template<typename, typename>
|
||||
class TwoTypeContainer,
|
||||
typename T,
|
||||
typename Allocator = allocator<T>,
|
||||
typename Func>
|
||||
auto FlatMap(const TwoTypeContainer<T, Allocator>& input, Func fn) -> decltype(auto) {
|
||||
typedef typename decltype(function(fn))::result_type::value_type result_value_type;
|
||||
|
||||
TwoTypeContainer<result_value_type, allocator<result_value_type>> result{};
|
||||
|
||||
for (const auto& elt : input) {
|
||||
const auto& outContainer = fn(elt);
|
||||
for (const auto& outElt : outContainer) { result.push_back(outElt); }
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template<template<typename> class OneTypeContainer, typename T, typename Func>
|
||||
auto FlatMap(const OneTypeContainer<T>& input, Func fn) -> decltype(auto) {
|
||||
typedef typename decltype(function(fn))::result_type::value_type result_value_type;
|
||||
|
||||
OneTypeContainer<result_value_type> result{};
|
||||
|
||||
for (const auto& elt : input) {
|
||||
const auto& outContainer = fn(elt);
|
||||
for (const auto& outElt : outContainer) { result.push_back(outElt); }
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename Container, typename Func>
|
||||
auto FlatMapToVector(const Container& input, Func fn) -> decltype(auto) {
|
||||
typedef typename decltype(function(fn))::result_type::value_type value_type;
|
||||
|
||||
vector<value_type> result{};
|
||||
|
||||
for (const auto& elt : input) {
|
||||
const auto& outContainer = fn(elt);
|
||||
for (const auto& outElt : outContainer) { result.push_back(outElt); }
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename Container>
|
||||
auto ToVector(const Container& input) -> decltype(auto) {
|
||||
typedef typename Container::value_type value_type;
|
||||
return vector<value_type>(begin(input), end(input));
|
||||
}
|
||||
|
||||
template<typename C1, typename C2>
|
||||
auto Append(C1& recipient, const C2& newItems) -> C1& {
|
||||
recipient.insert(end(recipient), begin(newItems), end(newItems));
|
||||
return recipient;
|
||||
}
|
||||
|
||||
} // namespace common
|
||||
|
||||
#endif // EAGLE0_CONTAINERUTILS_HPP
|
||||
@@ -30,7 +30,7 @@ auto rloc(const string& execPath) -> string {
|
||||
const std::unique_ptr<Runfiles> runfiles(Runfiles::Create(execPath, &error));
|
||||
|
||||
if (runfiles == nullptr) {
|
||||
fprintf(stderr, "Error! %s\n", error.c_str());
|
||||
printf("Error! %s\n", error.c_str());
|
||||
abort();
|
||||
// error handling
|
||||
}
|
||||
@@ -67,9 +67,9 @@ auto FilesystemUtils::MapFilesDirectory() -> string {
|
||||
|
||||
void FilesystemUtils::MakeDirectoryIfNecessary(const string& directoryPath) {
|
||||
if (fs::create_directories(directoryPath))
|
||||
fprintf(stderr, "Directory %s created\n", directoryPath.c_str());
|
||||
printf("Directory %s created\n", directoryPath.c_str());
|
||||
else
|
||||
fprintf(stderr, "No new directory created for %s\n", directoryPath.c_str());
|
||||
printf("No new directory created for %s\n", directoryPath.c_str());
|
||||
}
|
||||
|
||||
auto FilesystemUtils::SaveFilesDirectory() -> string {
|
||||
@@ -129,11 +129,11 @@ auto FilesystemUtils::AtomicallySaveToPath(const string& path, const byte_vector
|
||||
if (ostr.good()) {
|
||||
const int err = rename(tempPath.c_str(), path.c_str());
|
||||
if (err == -1) {
|
||||
fprintf(stderr, "Failed to move file to %s! Errno %d\n", path.c_str(), errno);
|
||||
printf("Failed to move file to %s! Errno %d\n", path.c_str(), errno);
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
fprintf(stderr, "Failed writing to %s!\n", tempPath.c_str());
|
||||
printf("Failed writing to %s!\n", tempPath.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -145,7 +145,7 @@ auto FilesystemUtils::LoadFromPath(const string& path) -> byte_vector {
|
||||
const std::streamsize size = inputFileStream.tellg();
|
||||
inputFileStream.seekg(0, std::ios::beg);
|
||||
|
||||
auto bv = byte_vector(static_cast<size_t>(size));
|
||||
auto bv = byte_vector(size);
|
||||
inputFileStream.read((char*)bv.data(), size);
|
||||
|
||||
return bv;
|
||||
|
||||
@@ -84,9 +84,7 @@ auto RandomGenerator::ChanceOpenEndedPercentileAtOrAbove(const double value) ->
|
||||
|
||||
auto StdLibraryGenerator::DoubleZeroToOne() -> double { return unifDouble(engine); }
|
||||
|
||||
StdLibraryGenerator::StdLibraryGenerator() : RandomGenerator() {
|
||||
engine.seed(static_cast<std::mt19937_64::result_type>(std::time(nullptr)));
|
||||
}
|
||||
StdLibraryGenerator::StdLibraryGenerator() : RandomGenerator() { engine.seed(std::time(nullptr)); }
|
||||
|
||||
auto StdLibraryGenerator::IntBetween(const int min, const int max) -> int {
|
||||
std::uniform_int_distribution<int> unifInt(min, max - 1);
|
||||
|
||||
@@ -14,14 +14,6 @@
|
||||
|
||||
#include "src/main/cpp/net/eagle0/common/RandomGenerator.hpp"
|
||||
|
||||
// A deterministic random generator that returns values from a fixed sequence.
|
||||
// Used for testing and MCTS simulation where we want specific, predictable outcomes.
|
||||
//
|
||||
// Values in the sequence are treated as [0, 1] probabilities that are returned
|
||||
// by DoubleZeroToOne(). The normal percentile methods (including open-ended
|
||||
// variants) work as usual, so callers must provide appropriate sequences.
|
||||
// For example, to get an open-ended low result of -50, provide [0.02, 0.52]
|
||||
// which produces: initial=2 (triggers open-ended), accumulated=52, final=2-52=-50
|
||||
class SequenceRandomGenerator : public ::RandomGenerator {
|
||||
private:
|
||||
const std::vector<double> sequence;
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
//
|
||||
// ThreadPool.cpp - Implementation of priority-based thread pool
|
||||
//
|
||||
|
||||
#include "ThreadPool.hpp"
|
||||
|
||||
namespace eagle0 {
|
||||
namespace common {
|
||||
|
||||
// Implementation is header-only to support templates
|
||||
// This file exists for potential future non-template implementations
|
||||
|
||||
} // namespace common
|
||||
} // namespace eagle0
|
||||
@@ -1,200 +0,0 @@
|
||||
//
|
||||
// ThreadPool.hpp - Priority-based thread pool with deadline support
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_THREADPOOL_HPP
|
||||
#define EAGLE0_THREADPOOL_HPP
|
||||
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <condition_variable>
|
||||
#include <functional>
|
||||
#include <future>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <queue>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
namespace eagle0::common {
|
||||
|
||||
enum class TaskStatus { SUCCESS = 0, DEADLINE_EXCEEDED = 1, CANCELLED = 2 };
|
||||
|
||||
template<typename T>
|
||||
struct TaskResult {
|
||||
T value;
|
||||
TaskStatus status;
|
||||
|
||||
TaskResult() : value{}, status(TaskStatus::SUCCESS) {}
|
||||
TaskResult(T val) : value(std::move(val)), status(TaskStatus::SUCCESS) {}
|
||||
TaskResult(T val, TaskStatus stat) : value(std::move(val)), status(stat) {}
|
||||
|
||||
// NO implicit conversion - this was causing infinite recursion
|
||||
// Use .value or .get() instead
|
||||
T get() const { return value; }
|
||||
|
||||
bool succeeded() const { return status == TaskStatus::SUCCESS; }
|
||||
bool deadlineExceeded() const { return status == TaskStatus::DEADLINE_EXCEEDED; }
|
||||
};
|
||||
|
||||
class ThreadPool {
|
||||
public:
|
||||
using Clock = std::chrono::steady_clock;
|
||||
using TimePoint = Clock::time_point;
|
||||
|
||||
private:
|
||||
struct Task {
|
||||
std::function<void()> function;
|
||||
int priority;
|
||||
TimePoint deadline;
|
||||
bool has_deadline;
|
||||
|
||||
Task(std::function<void()> f, int p, TimePoint d, bool has_d)
|
||||
: function(std::move(f)),
|
||||
priority(p),
|
||||
deadline(d),
|
||||
has_deadline(has_d) {}
|
||||
|
||||
// Higher priority values and earlier deadlines have higher priority
|
||||
bool operator<(const Task& other) const {
|
||||
if (priority != other.priority) {
|
||||
return priority < other.priority; // Lower priority values have lower priority in
|
||||
// priority_queue
|
||||
}
|
||||
if (has_deadline && other.has_deadline) {
|
||||
return deadline > other.deadline; // Later deadlines have lower priority
|
||||
}
|
||||
if (has_deadline && !other.has_deadline) {
|
||||
return false; // Tasks with deadlines have higher priority
|
||||
}
|
||||
if (!has_deadline && other.has_deadline) {
|
||||
return true; // Tasks without deadlines have lower priority
|
||||
}
|
||||
return false; // Equal priority, no preference
|
||||
}
|
||||
};
|
||||
|
||||
std::vector<std::thread> workers;
|
||||
std::priority_queue<Task> tasks;
|
||||
std::mutex queue_mutex;
|
||||
std::condition_variable condition;
|
||||
std::atomic<bool> stop{false};
|
||||
|
||||
public:
|
||||
explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency()) {
|
||||
for (size_t i = 0; i < num_threads; ++i) {
|
||||
workers.emplace_back([this] {
|
||||
while (true) {
|
||||
Task task{nullptr, 0, TimePoint{}, false};
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(queue_mutex);
|
||||
condition.wait(lock, [this] { return stop.load() || !tasks.empty(); });
|
||||
|
||||
if (stop.load() && tasks.empty()) { return; }
|
||||
|
||||
if (!tasks.empty()) {
|
||||
task = std::move(const_cast<Task&>(tasks.top()));
|
||||
tasks.pop();
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// Execute the task (deadline checking is now handled inside the task)
|
||||
if (task.function) { task.function(); }
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Enqueue a task with priority only
|
||||
template<class F, class... Args>
|
||||
auto enqueue(F&& f, Args&&... args, int priority = 0)
|
||||
-> std::future<TaskResult<std::invoke_result_t<F, Args...>>> {
|
||||
using return_type = std::invoke_result_t<F, Args...>;
|
||||
using result_type = TaskResult<return_type>;
|
||||
|
||||
auto actualTask = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
|
||||
|
||||
auto task = std::make_shared<std::packaged_task<result_type()>>(
|
||||
[actualTask = std::move(actualTask)]() mutable -> result_type {
|
||||
return result_type(actualTask());
|
||||
});
|
||||
|
||||
std::future<result_type> result = task->get_future();
|
||||
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(queue_mutex);
|
||||
if (stop.load()) { throw std::runtime_error("enqueue on stopped ThreadPool"); }
|
||||
tasks.emplace([task]() { (*task)(); }, priority, TimePoint{}, false);
|
||||
}
|
||||
|
||||
condition.notify_one();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Enqueue a task with priority and deadline
|
||||
template<class F, class... Args>
|
||||
auto enqueue_with_deadline(F&& f, Args&&... args, int priority, TimePoint deadline)
|
||||
-> std::future<TaskResult<std::invoke_result_t<F, Args...>>> {
|
||||
using return_type = std::invoke_result_t<F, Args...>;
|
||||
using result_type = TaskResult<return_type>;
|
||||
|
||||
auto actualTask = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
|
||||
|
||||
auto task = std::make_shared<std::packaged_task<result_type()>>(
|
||||
[actualTask = std::move(actualTask), deadline]() mutable -> result_type {
|
||||
if (Clock::now() > deadline) {
|
||||
return result_type(return_type{}, TaskStatus::DEADLINE_EXCEEDED);
|
||||
}
|
||||
return result_type(actualTask());
|
||||
});
|
||||
|
||||
std::future<result_type> result = task->get_future();
|
||||
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(queue_mutex);
|
||||
if (stop.load()) { throw std::runtime_error("enqueue on stopped ThreadPool"); }
|
||||
tasks.emplace([task]() { (*task)(); }, priority, deadline, true);
|
||||
}
|
||||
|
||||
condition.notify_one();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Get current queue size (approximate, for monitoring)
|
||||
size_t queue_size() const {
|
||||
std::unique_lock<std::mutex> lock(const_cast<std::mutex&>(queue_mutex));
|
||||
return tasks.size();
|
||||
}
|
||||
|
||||
// Get detailed queue information for debugging
|
||||
void debug_queue_state() const {
|
||||
std::unique_lock<std::mutex> lock(const_cast<std::mutex&>(queue_mutex));
|
||||
printf("ThreadPool: Queue size: %zu\n", tasks.size());
|
||||
if (!tasks.empty()) {
|
||||
// Create a copy to inspect priorities without modifying queue
|
||||
auto queue_copy = tasks;
|
||||
std::vector<int> priorities;
|
||||
while (!queue_copy.empty()) {
|
||||
priorities.push_back(queue_copy.top().priority);
|
||||
queue_copy.pop();
|
||||
}
|
||||
printf("ThreadPool: Priorities in queue: ");
|
||||
for (int p : priorities) { printf("%d ", p); }
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
||||
~ThreadPool() {
|
||||
stop.store(true);
|
||||
condition.notify_all();
|
||||
for (std::thread& worker : workers) {
|
||||
if (worker.joinable()) { worker.join(); }
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace eagle0::common
|
||||
|
||||
#endif // EAGLE0_THREADPOOL_HPP
|
||||
@@ -8,8 +8,6 @@ namespace shardok {
|
||||
|
||||
using Coords = net::eagle0::shardok::storage::fb::Coords;
|
||||
|
||||
constexpr double kDefaultMorale = 50.0;
|
||||
|
||||
auto ConvertBattalion(const net::eagle0::common::CommonBattalion &battalion) -> Battalion {
|
||||
Battalion shardokBattalion{};
|
||||
|
||||
@@ -17,9 +15,9 @@ auto ConvertBattalion(const net::eagle0::common::CommonBattalion &battalion) ->
|
||||
shardokBattalion.mutate_size(battalion.size());
|
||||
shardokBattalion.mutate_type(
|
||||
static_cast<net::eagle0::shardok::storage::fb::BattalionTypeId>(battalion.type()));
|
||||
shardokBattalion.mutate_morale(kDefaultMorale);
|
||||
shardokBattalion.mutate_armament(static_cast<float>(battalion.armament()));
|
||||
shardokBattalion.mutate_training(static_cast<float>(battalion.training()));
|
||||
shardokBattalion.mutate_morale(battalion.morale());
|
||||
shardokBattalion.mutate_armament(battalion.armament());
|
||||
shardokBattalion.mutate_training(battalion.training());
|
||||
|
||||
return shardokBattalion;
|
||||
}
|
||||
@@ -39,28 +37,28 @@ auto ConvertHero(const net::eagle0::common::CommonHero &hero) -> Hero {
|
||||
shardokHero.mutable_control_info().mutate_controlled_unit_id(-1);
|
||||
shardokHero.mutable_control_info().mutate_controlled_this_round(false);
|
||||
|
||||
shardokHero.mutate_strength(static_cast<int8_t>(hero.strength()));
|
||||
shardokHero.mutate_strength_xp(static_cast<int16_t>(hero.strength_xp()));
|
||||
shardokHero.mutate_strength(hero.strength());
|
||||
shardokHero.mutate_strength_xp(hero.strength_xp());
|
||||
|
||||
shardokHero.mutate_agility(static_cast<int8_t>(hero.agility()));
|
||||
shardokHero.mutate_agility_xp(static_cast<int16_t>(hero.agility_xp()));
|
||||
shardokHero.mutate_agility(hero.agility());
|
||||
shardokHero.mutate_agility_xp(hero.agility_xp());
|
||||
|
||||
shardokHero.mutate_constitution(static_cast<int8_t>(hero.constitution()));
|
||||
shardokHero.mutate_constitution_xp(static_cast<int16_t>(hero.constitution_xp()));
|
||||
shardokHero.mutate_constitution(hero.constitution());
|
||||
shardokHero.mutate_constitution_xp(hero.constitution_xp());
|
||||
|
||||
shardokHero.mutate_charisma(static_cast<int8_t>(hero.charisma()));
|
||||
shardokHero.mutate_charisma_xp(static_cast<int16_t>(hero.charisma_xp()));
|
||||
shardokHero.mutate_charisma(hero.charisma());
|
||||
shardokHero.mutate_charisma_xp(hero.charisma_xp());
|
||||
|
||||
shardokHero.mutate_wisdom(static_cast<int8_t>(hero.wisdom()));
|
||||
shardokHero.mutate_wisdom_xp(static_cast<int16_t>(hero.wisdom_xp()));
|
||||
shardokHero.mutate_wisdom(hero.wisdom());
|
||||
shardokHero.mutate_wisdom_xp(hero.wisdom_xp());
|
||||
|
||||
shardokHero.mutate_integrity(static_cast<int8_t>(hero.integrity()));
|
||||
shardokHero.mutate_ambition(static_cast<int8_t>(hero.ambition()));
|
||||
shardokHero.mutate_gregariousness(static_cast<int8_t>(hero.gregariousness()));
|
||||
shardokHero.mutate_bravery(static_cast<int8_t>(hero.bravery()));
|
||||
shardokHero.mutate_integrity(hero.integrity());
|
||||
shardokHero.mutate_ambition(hero.ambition());
|
||||
shardokHero.mutate_gregariousness(hero.gregariousness());
|
||||
shardokHero.mutate_bravery(hero.bravery());
|
||||
|
||||
shardokHero.mutate_vigor(static_cast<float>(hero.vigor()));
|
||||
shardokHero.mutate_starting_vigor(static_cast<float>(hero.vigor()));
|
||||
shardokHero.mutate_vigor(hero.vigor());
|
||||
shardokHero.mutate_starting_vigor(hero.vigor());
|
||||
|
||||
return shardokHero;
|
||||
}
|
||||
@@ -95,22 +93,19 @@ auto ConvertUnit(
|
||||
shardokUnit.mutate_stun_rounds_remaining(0);
|
||||
|
||||
for (const PlayerId pid : allPlayerIds) {
|
||||
shardokUnit.mutable_opponent_knowledge()->Mutate(
|
||||
static_cast<flatbuffers::uoffset_t>(pid),
|
||||
0);
|
||||
shardokUnit.mutable_opponent_knowledge()->Mutate(pid, 0);
|
||||
}
|
||||
|
||||
shardokUnit.mutate_has_moved_in_zoc(false);
|
||||
shardokUnit.mutate_targeted_unit(-1);
|
||||
shardokUnit.mutate_volleys_remaining(0);
|
||||
shardokUnit.mutate_food_remaining(static_cast<float>(unit.food()));
|
||||
shardokUnit.mutate_food_remaining(unit.food());
|
||||
shardokUnit.mutate_can_flee(unit.can_flee());
|
||||
shardokUnit.mutate_can_archery(unit.can_archery());
|
||||
shardokUnit.mutate_can_start_fire(unit.can_start_fire());
|
||||
|
||||
if (unit.has_starting_position_index()) {
|
||||
shardokUnit.mutate_starting_position_index(
|
||||
static_cast<int8_t>(unit.starting_position_index().value()));
|
||||
shardokUnit.mutate_starting_position_index(unit.starting_position_index().value());
|
||||
} else {
|
||||
shardokUnit.mutate_starting_position_index(-1);
|
||||
}
|
||||
|
||||
@@ -9,10 +9,7 @@
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCTypes.h"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/unit.hpp"
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
|
||||
#include "src/main/protobuf/net/eagle0/common/common_unit.pb.h"
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
namespace shardok {
|
||||
|
||||
|
||||
@@ -1,139 +0,0 @@
|
||||
# MCTS (Monte Carlo Tree Search) Framework
|
||||
|
||||
This directory contains a game-agnostic Monte Carlo Tree Search implementation that can be used with any turn-based game. The framework separates the MCTS algorithm from game-specific logic through abstract interfaces.
|
||||
|
||||
## Core Abstract Classes
|
||||
|
||||
### `MCTSAction` (abstract/MCTSAction.hpp)
|
||||
Abstract interface for representing game actions/moves.
|
||||
|
||||
**Key Methods:**
|
||||
- `getIndex()` - Returns the action's unique identifier
|
||||
- `getDescription()` - Human-readable description for debugging/logging
|
||||
- `clone()` - Creates a deep copy of the action
|
||||
- `equals()` - Compares actions for equality
|
||||
|
||||
### `MCTSGameState` (abstract/MCTSGameState.hpp)
|
||||
Abstract interface for representing game states.
|
||||
|
||||
**Key Methods:**
|
||||
- `hash()` - Returns a hash for transposition table lookups
|
||||
- `score(playerId)` - Evaluates the state's value for a given player
|
||||
- `currentPlayerId()` - Returns whose turn it is
|
||||
- `isTerminal()` - Checks if the game has ended
|
||||
- `getWinner()` - Returns the winning player (if terminal)
|
||||
- `clone()` - Creates a deep copy of the state
|
||||
- `equals()` - Compares states for equality
|
||||
|
||||
### `MCTSGameEngine` (abstract/MCTSGameEngine.hpp)
|
||||
Abstract interface for game rule enforcement and state transitions. Many methods have efficient default implementations.
|
||||
|
||||
**Must Override (Pure Virtual):**
|
||||
- `applyAction(state, action)` - Applies an action to create a new state
|
||||
- `getLegalActions(state)` - Returns all valid moves from a state
|
||||
- `isTerminal(state)` - Checks if a state is game-ending
|
||||
- `evaluateState(state, playerId)` - Scores a state for a player
|
||||
|
||||
**Optional Overrides (Have Default Implementations):**
|
||||
- `applyActionMutable(state, action)` - Apply action in-place for efficiency (default: calls applyAction)
|
||||
- `filterActions(actions, state)` - Applies heuristic filtering (default: no filtering)
|
||||
- `simulateRandomPlayout(state, playerId, maxDepth, policy)` - Runs simulation (default: efficient mutable implementation)
|
||||
- `getActionScore(state, action, playerId)` - Scores an action (default: apply and evaluate)
|
||||
- `shouldStopSearch(state, iterations, startTime)` - Early termination (default: no early stop)
|
||||
|
||||
**Performance Features:**
|
||||
- The default `simulateRandomPlayout` clones the state once and mutates it throughout simulation for efficiency
|
||||
- Games can override `applyActionMutable` to provide even more efficient in-place updates
|
||||
- Games can override `simulateRandomPlayout` for custom optimizations (e.g., using internal engine state)
|
||||
|
||||
## MCTS Algorithm Implementation
|
||||
|
||||
### `AbstractMCTSAI` (abstract/AbstractMCTSAI.hpp)
|
||||
The main MCTS algorithm implementation that works with any game implementing the abstract interfaces.
|
||||
|
||||
**Key Features:**
|
||||
- **Selection**: Uses UCB1 (Upper Confidence Bound) for node selection
|
||||
- **Expansion**: Adds new nodes to the search tree
|
||||
- **Simulation**: Runs random playouts to estimate node values
|
||||
- **Backpropagation**: Updates node statistics with simulation results
|
||||
- **Multithreading**: Supports parallel MCTS with configurable thread count
|
||||
- **Path Compression**: Optimizes move sequences for better performance
|
||||
|
||||
**Configuration Options:**
|
||||
- `explorationConstant` - UCB1 exploration parameter (default: √2)
|
||||
- `maxSimulationDepth` - Maximum depth for random playouts
|
||||
- `maxTreeDepth` - Maximum tree depth to prevent stack overflow
|
||||
- `useMultithreading` - Enable parallel search
|
||||
- `numThreads` - Number of worker threads
|
||||
- `simulationPolicy` - Strategy for action selection during simulation
|
||||
|
||||
### `MCTSNode` (abstract/MCTSNode.hpp)
|
||||
Represents nodes in the MCTS search tree.
|
||||
|
||||
**Core Data:**
|
||||
- `action` - The action that led to this node
|
||||
- `actionIndex` - Index in the original actions array
|
||||
- `gameState` - The game state at this node
|
||||
- `visitCount` - Number of times this node was visited
|
||||
- `totalReward` - Sum of simulation rewards
|
||||
- `averageReward` - Average reward (totalReward / visitCount)
|
||||
- `children` - Child nodes in the search tree
|
||||
- `parent` - Parent node reference
|
||||
|
||||
**Key Methods:**
|
||||
- `CanExpand()` - Checks if node has untried actions
|
||||
- `GetBestChild(explorationConstant)` - UCB1-based child selection
|
||||
- `GetBestFinalChild()` - Most-visited child (for final move selection)
|
||||
- `CalculateUCB1(explorationConstant)` - Computes UCB1 value
|
||||
|
||||
## Simulation Policies
|
||||
|
||||
The framework supports multiple strategies for action selection during random playouts:
|
||||
|
||||
- **RANDOM** - Uniform random selection
|
||||
- **FILTERED_RANDOM** - Random selection from filtered action set
|
||||
- **BEST_IMMEDIATE** - Always choose the highest-scoring immediate action
|
||||
- **WEIGHTED_BEST_IMMEDIATE** - Weighted random selection based on action scores
|
||||
|
||||
## Type Definitions
|
||||
|
||||
### `MCTSTypes` (abstract/MCTSTypes.hpp)
|
||||
- `MCTSPlayerId` - Player identifier type (int)
|
||||
- `MCTSSimulationPolicy` - Enumeration of simulation strategies
|
||||
- `MCTSConfig` - Configuration structure for MCTS parameters
|
||||
|
||||
## Usage Pattern
|
||||
|
||||
To use this framework with your game:
|
||||
|
||||
1. **Implement the abstract interfaces** for your game:
|
||||
```cpp
|
||||
class MyGameAction : public MCTSAction { /* ... */ };
|
||||
class MyGameState : public MCTSGameState { /* ... */ };
|
||||
class MyGameEngine : public MCTSGameEngine { /* ... */ };
|
||||
```
|
||||
|
||||
2. **Create and configure the AI**:
|
||||
```cpp
|
||||
MCTSConfig config;
|
||||
config.explorationConstant = 1.414;
|
||||
config.maxSimulationDepth = 100;
|
||||
AbstractMCTSAI ai(playerId, config);
|
||||
```
|
||||
|
||||
3. **Run the search**:
|
||||
```cpp
|
||||
auto actions = engine.getLegalActions(currentState);
|
||||
auto result = ai.Search(engine, currentState, actions, timeLimit);
|
||||
auto bestAction = actions[result.bestActionIndex];
|
||||
```
|
||||
|
||||
## Testing
|
||||
|
||||
The framework includes comprehensive tests using a Tic-Tac-Toe implementation:
|
||||
- `MockTicTacToe.hpp` - Example implementation of all abstract interfaces
|
||||
- `AbstractMCTSAI_test.cpp` - Unit tests for the core algorithm
|
||||
- `MCTSIntegration_test.cpp` - Integration tests with complete games
|
||||
- `MCTSNode_test.cpp` - Tests for the node data structure
|
||||
|
||||
This demonstrates how to implement the interfaces and validates that the MCTS algorithm works correctly with any turn-based game.
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,106 +0,0 @@
|
||||
//
|
||||
// Abstract MCTS AI implementation - game agnostic
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_ABSTRACT_MCTSAI_HPP
|
||||
#define EAGLE0_ABSTRACT_MCTSAI_HPP
|
||||
|
||||
#include <chrono>
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
#include "MCTSAction.hpp"
|
||||
#include "MCTSGameEngine.hpp"
|
||||
#include "MCTSGameState.hpp"
|
||||
#include "MCTSNode.hpp"
|
||||
#include "MCTSTypes.hpp"
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
class AbstractMCTSAI {
|
||||
public:
|
||||
// Search result structure
|
||||
struct SearchResult {
|
||||
size_t bestActionIndex = 0;
|
||||
double bestScore = 0.0;
|
||||
int searchDepth = 0;
|
||||
int nodesEvaluated = 0;
|
||||
std::chrono::milliseconds searchTime{0};
|
||||
bool foundWinningMove = false;
|
||||
};
|
||||
|
||||
explicit AbstractMCTSAI(MCTSPlayerId playerId, MCTSConfig config = MCTSConfig{});
|
||||
|
||||
// Main search interface
|
||||
[[nodiscard]] auto Search(
|
||||
const MCTSGameEngine& engine,
|
||||
const MCTSGameState& initialState,
|
||||
std::chrono::milliseconds timeLimit) const -> SearchResult;
|
||||
|
||||
// Configuration
|
||||
[[nodiscard]] auto GetConfig() const -> const MCTSConfig& { return config_; }
|
||||
void SetConfig(const MCTSConfig& newConfig) { config_ = newConfig; }
|
||||
|
||||
[[nodiscard]] auto FindNodeAtDepthWithHash(
|
||||
const MCTSNode* root,
|
||||
int maxDepth,
|
||||
uint64_t targetHash) -> const MCTSNode*;
|
||||
|
||||
private:
|
||||
MCTSPlayerId playerId_;
|
||||
MCTSConfig config_;
|
||||
|
||||
// Transposition table: maps state hash -> minimum depth at which state was reached
|
||||
// Used to detect and penalize longer paths to the same game state
|
||||
// Cleared at the start of each Search() call
|
||||
mutable std::unordered_map<uint64_t, int> transpositionTable_;
|
||||
|
||||
// Core MCTS algorithm
|
||||
[[nodiscard]] auto BuildMCTSTree(
|
||||
const MCTSGameEngine& engine,
|
||||
const MCTSGameState& initialState,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::unique_ptr<MCTSNode>;
|
||||
|
||||
// MCTS phases
|
||||
[[nodiscard]] auto MCTSSelection(MCTSNode* root) const -> MCTSNode*;
|
||||
|
||||
[[nodiscard]] auto MCTSExpansion(MCTSNode* node, const MCTSGameEngine& engine) const
|
||||
-> MCTSNode*;
|
||||
|
||||
[[nodiscard]] auto MCTSSimulation(
|
||||
const MCTSGameEngine& engine,
|
||||
const MCTSGameState& state,
|
||||
MCTSPlayerId startingPlayer,
|
||||
int startingPlayerFlips = 0) const -> double;
|
||||
|
||||
auto MCTSBackpropagation(MCTSNode* node, double reward, MCTSBackpropagationPolicy policy) const
|
||||
-> void;
|
||||
|
||||
// Helper functions
|
||||
[[nodiscard]] auto SelectSimulationAction(
|
||||
const MCTSGameEngine& engine,
|
||||
const MCTSGameState& state,
|
||||
const std::vector<std::unique_ptr<MCTSAction>>& actions,
|
||||
bool isMaximizing) const -> size_t;
|
||||
|
||||
// Logging
|
||||
static auto LogSearchResults(
|
||||
const MCTSNode* rootNode,
|
||||
const MCTSNode* bestChild,
|
||||
const SearchResult& result) -> void;
|
||||
|
||||
// Debug tree dumping
|
||||
static auto DumpTreeToFile(const MCTSNode* root, const std::string& filepath) -> void;
|
||||
|
||||
private:
|
||||
static auto
|
||||
DumpNodeRecursive(const MCTSNode* node, std::ostream& out, int indentLevel, bool isLastChild)
|
||||
-> void;
|
||||
};
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_ABSTRACT_MCTSAI_HPP
|
||||
@@ -1,94 +0,0 @@
|
||||
load("//tools:copts.bzl", "COPTS")
|
||||
|
||||
cc_library(
|
||||
name = "mcts_types",
|
||||
hdrs = ["MCTSTypes.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/common/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "mcts_action",
|
||||
hdrs = ["MCTSAction.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/common/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "mcts_game_state",
|
||||
hdrs = ["MCTSGameState.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/common/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":mcts_types",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "mcts_game_engine",
|
||||
srcs = ["MCTSGameEngine.cpp"],
|
||||
hdrs = ["MCTSGameEngine.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/common/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":mcts_action",
|
||||
":mcts_game_state",
|
||||
":mcts_types",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "mcts_node",
|
||||
hdrs = ["MCTSNode.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/common/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":mcts_action",
|
||||
":mcts_game_state",
|
||||
":mcts_types",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "abstract_mcts_ai",
|
||||
srcs = ["AbstractMCTSAI.cpp"],
|
||||
hdrs = ["AbstractMCTSAI.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/common/mcts:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai/mcts:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":mcts_action",
|
||||
":mcts_game_engine",
|
||||
":mcts_game_state",
|
||||
":mcts_node",
|
||||
":mcts_types",
|
||||
"//src/main/cpp/net/eagle0/common/mcts/util:tree_indent_util",
|
||||
],
|
||||
)
|
||||
|
||||
# Individual targets are exposed above - no need for a catch-all target
|
||||
# Each component should be imported explicitly by its consumers
|
||||
@@ -1,40 +0,0 @@
|
||||
//
|
||||
// Abstract action interface for MCTS
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_MCTS_ACTION_HPP
|
||||
#define EAGLE0_MCTS_ACTION_HPP
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
// Abstract interface for game actions
|
||||
class MCTSAction {
|
||||
public:
|
||||
virtual ~MCTSAction() = default;
|
||||
|
||||
// Get a unique index for this action (used for command indexing)
|
||||
[[nodiscard]] virtual size_t getIndex() const = 0;
|
||||
|
||||
// Get a human-readable description for debugging/logging
|
||||
[[nodiscard]] virtual std::string getDescription() const = 0;
|
||||
|
||||
// Create a deep copy of this action
|
||||
[[nodiscard]] virtual std::unique_ptr<MCTSAction> clone() const = 0;
|
||||
|
||||
// Check if two actions are equivalent
|
||||
[[nodiscard]] virtual bool equals(const MCTSAction& other) const = 0;
|
||||
|
||||
// Check if this action requires a chance node (binary success/failure outcome)
|
||||
// Examples: START_FIRE, RAISE_DEAD, EXTINGUISH_FIRE
|
||||
// If true, the game engine should provide outcome probabilities
|
||||
[[nodiscard]] virtual bool requiresChanceNode() const = 0;
|
||||
};
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_MCTS_ACTION_HPP
|
||||
@@ -1,148 +0,0 @@
|
||||
//
|
||||
// Default implementations for MCTSGameEngine
|
||||
//
|
||||
|
||||
#include "MCTSGameEngine.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
#include <random>
|
||||
#include <vector>
|
||||
|
||||
#include "MCTSTypes.hpp" // For MCTSInternalError
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
double MCTSGameEngine::simulateRandomPlayout(
|
||||
const MCTSGameState& state,
|
||||
MCTSPlayerId playerId,
|
||||
int maxDepth,
|
||||
MCTSSimulationPolicy policy) const {
|
||||
// Clone state once and mutate it throughout simulation for efficiency
|
||||
auto currentState = state.clone();
|
||||
int depth = 0;
|
||||
|
||||
// Use thread-local random generator for thread safety
|
||||
static thread_local std::mt19937 gen(std::random_device{}());
|
||||
|
||||
// Simulate until terminal or max depth
|
||||
while (!currentState->isTerminal() && depth < maxDepth) {
|
||||
auto actions = getLegalActions(*currentState, playerId, 0, 0);
|
||||
if (actions.empty()) { break; }
|
||||
|
||||
size_t selectedIndex = 0;
|
||||
|
||||
// Select action based on policy
|
||||
switch (policy) {
|
||||
case MCTSSimulationPolicy::RANDOM: {
|
||||
std::uniform_int_distribution<> dis(0, actions.size() - 1);
|
||||
selectedIndex = dis(gen);
|
||||
break;
|
||||
}
|
||||
|
||||
case MCTSSimulationPolicy::FILTERED_RANDOM: {
|
||||
auto filteredIndices = filterActions(actions, *currentState);
|
||||
if (!filteredIndices.empty()) {
|
||||
std::uniform_int_distribution<> dis(0, filteredIndices.size() - 1);
|
||||
selectedIndex = filteredIndices[dis(gen)];
|
||||
} else {
|
||||
// Fall back to random if no actions pass filter
|
||||
std::uniform_int_distribution<> dis(0, actions.size() - 1);
|
||||
selectedIndex = dis(gen);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case MCTSSimulationPolicy::BEST_IMMEDIATE: {
|
||||
double bestScore = -std::numeric_limits<double>::infinity();
|
||||
for (size_t i = 0; i < actions.size(); ++i) {
|
||||
double score = getActionScore(
|
||||
*currentState,
|
||||
*actions[i],
|
||||
currentState->currentPlayerId());
|
||||
if (score > bestScore) {
|
||||
bestScore = score;
|
||||
selectedIndex = i;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case MCTSSimulationPolicy::WEIGHTED_BEST_IMMEDIATE: {
|
||||
// Score all actions and weight by ranking
|
||||
std::vector<std::pair<size_t, double>> scores;
|
||||
scores.reserve(actions.size());
|
||||
|
||||
for (size_t i = 0; i < actions.size(); ++i) {
|
||||
double score = getActionScore(
|
||||
*currentState,
|
||||
*actions[i],
|
||||
currentState->currentPlayerId());
|
||||
scores.emplace_back(i, score);
|
||||
}
|
||||
|
||||
// Sort by score (descending)
|
||||
std::sort(scores.begin(), scores.end(), [](const auto& a, const auto& b) {
|
||||
return a.second > b.second;
|
||||
});
|
||||
|
||||
// Create weights based on ranking (1/rank)
|
||||
std::vector<double> weights;
|
||||
weights.reserve(scores.size());
|
||||
for (size_t i = 0; i < scores.size(); ++i) { weights.push_back(1.0 / (i + 1.0)); }
|
||||
|
||||
// Select based on weights
|
||||
std::discrete_distribution<> dis(weights.begin(), weights.end());
|
||||
selectedIndex = scores[dis(gen)].first;
|
||||
break;
|
||||
}
|
||||
|
||||
case MCTSSimulationPolicy::WEIGHTED_HEURISTIC: {
|
||||
// Get heuristic weights (fast O(1) per action)
|
||||
const auto weights = getActionWeights(actions, *currentState);
|
||||
|
||||
// Filter out zero-weight actions
|
||||
std::vector<size_t> validIndices;
|
||||
std::vector<double> validWeights;
|
||||
validIndices.reserve(actions.size());
|
||||
validWeights.reserve(actions.size());
|
||||
|
||||
for (size_t i = 0; i < weights.size() && i < actions.size(); ++i) {
|
||||
if (weights[i] > 0.0) {
|
||||
validIndices.push_back(i);
|
||||
validWeights.push_back(weights[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// If all actions filtered out, this is a bug in the weighting logic
|
||||
if (validWeights.empty()) {
|
||||
throw MCTSInternalError(
|
||||
"MCTS simulation (playout): All actions have zero weight in "
|
||||
"WEIGHTED_HEURISTIC policy (action count: " +
|
||||
std::to_string(actions.size()) +
|
||||
") - this indicates incorrect weighting");
|
||||
}
|
||||
|
||||
// Select based on heuristic weights
|
||||
std::discrete_distribution<> dis(validWeights.begin(), validWeights.end());
|
||||
selectedIndex = validIndices[dis(gen)];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Apply selected action using mutable version for efficiency
|
||||
applyActionMutable(currentState, *actions[selectedIndex]);
|
||||
if (!currentState) {
|
||||
break; // Failed to apply action
|
||||
}
|
||||
|
||||
depth++;
|
||||
}
|
||||
|
||||
// Return evaluation from original player's perspective
|
||||
return evaluateState(*currentState, playerId);
|
||||
}
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
@@ -1,161 +0,0 @@
|
||||
//
|
||||
// Abstract game engine interface for MCTS
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_MCTS_GAME_ENGINE_HPP
|
||||
#define EAGLE0_MCTS_GAME_ENGINE_HPP
|
||||
|
||||
#include <chrono>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "MCTSAction.hpp"
|
||||
#include "MCTSGameState.hpp"
|
||||
#include "MCTSTypes.hpp"
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
// Information about chance outcomes (supports both binary and multi-outcome)
|
||||
struct ChanceOutcomeInfo {
|
||||
std::vector<double> probabilities; // Probability of each outcome (must sum to 1.0)
|
||||
std::vector<double> rolls; // Roll values for each outcome
|
||||
|
||||
// Factory for binary success/failure outcomes (e.g., START_FIRE)
|
||||
[[nodiscard]] static ChanceOutcomeInfo binary(double successProbability) {
|
||||
// -100: triggers open-ended low sequence, succeeds against any threshold
|
||||
// 150: triggers open-ended high sequence, fails against any threshold
|
||||
return {{successProbability, 1.0 - successProbability}, {-100.0, 150.0}};
|
||||
}
|
||||
|
||||
// Factory for multi-outcome with fixed seeds (e.g., END_TURN)
|
||||
// Uses uniformly distributed roll values to sample different random outcomes
|
||||
[[nodiscard]] static ChanceOutcomeInfo multiOutcome(int numOutcomes) {
|
||||
std::vector<double> probs(numOutcomes, 1.0 / numOutcomes);
|
||||
std::vector<double> rollValues;
|
||||
rollValues.reserve(numOutcomes);
|
||||
// Spread rolls across the percentile range: 10, 30, 50, 70, 90 for 5 outcomes
|
||||
for (int i = 0; i < numOutcomes; ++i) {
|
||||
rollValues.push_back(10.0 + (80.0 * i) / (numOutcomes - 1));
|
||||
}
|
||||
return {probs, rollValues};
|
||||
}
|
||||
|
||||
[[nodiscard]] const std::vector<double>& getRepresentativeRolls() const { return rolls; }
|
||||
|
||||
[[nodiscard]] const std::vector<double>& getProbabilities() const { return probabilities; }
|
||||
};
|
||||
|
||||
// Backward compatibility alias
|
||||
using BinaryOutcomeInfo = ChanceOutcomeInfo;
|
||||
|
||||
// Abstract interface for game engines
|
||||
class MCTSGameEngine {
|
||||
public:
|
||||
virtual ~MCTSGameEngine() = default;
|
||||
|
||||
// Apply an action to a state and return the resulting state
|
||||
// If deterministicRoll is provided (0.0-100.0), use that for any random outcomes
|
||||
[[nodiscard]] virtual std::unique_ptr<MCTSGameState> applyAction(
|
||||
const MCTSGameState& state,
|
||||
const MCTSAction& action,
|
||||
double deterministicRoll = -1.0) const = 0;
|
||||
|
||||
// Apply an action to a mutable state in-place (for efficient simulation)
|
||||
// Default: clone, apply, and move the result back
|
||||
// Override this for better performance
|
||||
virtual void applyActionMutable(std::unique_ptr<MCTSGameState>& state, const MCTSAction& action)
|
||||
const {
|
||||
state = applyAction(*state, action);
|
||||
}
|
||||
|
||||
// Get all legal actions for the current state with player flip tracking
|
||||
// Default implementation ignores flip tracking and calls base version
|
||||
[[nodiscard]] virtual std::vector<std::unique_ptr<MCTSAction>> getLegalActions(
|
||||
const MCTSGameState& state,
|
||||
MCTSPlayerId /*rootPlayerId*/,
|
||||
int /*currentPlayerFlips*/,
|
||||
int /*maxPlayerFlips*/) const = 0;
|
||||
|
||||
// Check if a state is terminal
|
||||
[[nodiscard]] virtual bool isTerminal(const MCTSGameState& state) const = 0;
|
||||
|
||||
// Evaluate a state from the perspective of a player
|
||||
[[nodiscard]] virtual double evaluateState(const MCTSGameState& state, MCTSPlayerId playerId)
|
||||
const = 0;
|
||||
|
||||
// Filter actions based on game-specific heuristics
|
||||
// Returns indices of actions to keep
|
||||
// Default: no filtering (return all indices)
|
||||
[[nodiscard]] virtual std::vector<size_t> filterActions(
|
||||
const std::vector<std::unique_ptr<MCTSAction>>& actions,
|
||||
const MCTSGameState& /*state*/) const {
|
||||
std::vector<size_t> indices;
|
||||
indices.reserve(actions.size());
|
||||
for (size_t i = 0; i < actions.size(); ++i) { indices.push_back(i); }
|
||||
return indices;
|
||||
}
|
||||
|
||||
// Get heuristic weights for actions (used by WEIGHTED_HEURISTIC simulation policy)
|
||||
// Returns weights corresponding to each action (same size as actions vector)
|
||||
// Weight of 0.0 = never select, higher = more likely to select
|
||||
// Default: uniform weights (all actions equally likely)
|
||||
[[nodiscard]] virtual std::vector<double> getActionWeights(
|
||||
const std::vector<std::unique_ptr<MCTSAction>>& actions,
|
||||
const MCTSGameState& /*state*/) const {
|
||||
// Default: uniform weights
|
||||
return std::vector<double>(actions.size(), 1.0);
|
||||
}
|
||||
|
||||
// Simulate a random playout from the given state
|
||||
// Default implementation uses policy to select actions
|
||||
[[nodiscard]] virtual double simulateRandomPlayout(
|
||||
const MCTSGameState& state,
|
||||
MCTSPlayerId playerId,
|
||||
int maxDepth,
|
||||
MCTSSimulationPolicy policy) const;
|
||||
|
||||
// Get the immediate score of applying an action
|
||||
// Default: apply the action and evaluate the resulting state
|
||||
[[nodiscard]] virtual double getActionScore(
|
||||
const MCTSGameState& state,
|
||||
const MCTSAction& action,
|
||||
MCTSPlayerId playerId) const {
|
||||
auto newState = applyAction(state, action);
|
||||
if (!newState) { return 0.0; }
|
||||
return evaluateState(*newState, playerId);
|
||||
}
|
||||
|
||||
// Check if we should stop searching (e.g., time limit, found winning move)
|
||||
[[nodiscard]] virtual bool shouldStopSearch(
|
||||
const MCTSGameState& /*state*/,
|
||||
int /*iterations*/,
|
||||
std::chrono::steady_clock::time_point /*startTime*/) const {
|
||||
// Default: no early stopping
|
||||
return false;
|
||||
}
|
||||
|
||||
// Map a filtered action index back to the original unfiltered index
|
||||
// This is needed when getLegalActions() applies filtering - the returned actions
|
||||
// may be a subset of all available actions, and this maps back to the original index.
|
||||
// Default implementation: no filtering, so filtered index = original index
|
||||
[[nodiscard]] virtual size_t mapFilteredIndexToOriginal(
|
||||
size_t filteredIndex,
|
||||
const MCTSGameState& state) const {
|
||||
// Default: no filtering, index stays the same
|
||||
(void)state; // Suppress unused parameter warning
|
||||
return filteredIndex;
|
||||
}
|
||||
|
||||
// Get binary outcome information for an action that requires a chance node
|
||||
// Only called for actions where action.requiresChanceNode() returns true
|
||||
// Returns success probability for binary success/failure actions
|
||||
[[nodiscard]] virtual BinaryOutcomeInfo getBinaryOutcomeInfo(
|
||||
const MCTSGameState& state,
|
||||
const MCTSAction& action) const = 0;
|
||||
};
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_MCTS_GAME_ENGINE_HPP
|
||||
@@ -1,50 +0,0 @@
|
||||
//
|
||||
// Abstract game state interface for MCTS
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_MCTS_GAME_STATE_HPP
|
||||
#define EAGLE0_MCTS_GAME_STATE_HPP
|
||||
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "MCTSTypes.hpp"
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
// Abstract interface for game states
|
||||
class MCTSGameState {
|
||||
public:
|
||||
virtual ~MCTSGameState() = default;
|
||||
|
||||
// Compute hash for transposition table
|
||||
[[nodiscard]] virtual uint64_t hash() const = 0;
|
||||
|
||||
// Evaluate the state from the perspective of the given player
|
||||
[[nodiscard]] virtual double score(MCTSPlayerId playerId) const = 0;
|
||||
|
||||
// Get the player whose turn it is
|
||||
[[nodiscard]] virtual MCTSPlayerId currentPlayerId() const = 0;
|
||||
|
||||
// Check if the game has ended
|
||||
[[nodiscard]] virtual bool isTerminal() const = 0;
|
||||
|
||||
// Create a deep copy of the state
|
||||
[[nodiscard]] virtual std::unique_ptr<MCTSGameState> clone() const = 0;
|
||||
|
||||
// Check if two states are equivalent
|
||||
[[nodiscard]] virtual bool equals(const MCTSGameState& other) const = 0;
|
||||
|
||||
// Get winner if terminal, or -1 if not terminal or draw
|
||||
[[nodiscard]] virtual MCTSPlayerId getWinner() const = 0;
|
||||
|
||||
// Optional: Get a string representation for debugging
|
||||
[[nodiscard]] virtual std::string toString() const { return "MCTSGameState"; }
|
||||
};
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_MCTS_GAME_STATE_HPP
|
||||
@@ -1,277 +0,0 @@
|
||||
//
|
||||
// Abstract MCTS Node structure for game-agnostic implementation
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_ABSTRACT_MCTSNODE_HPP
|
||||
#define EAGLE0_ABSTRACT_MCTSNODE_HPP
|
||||
|
||||
#include <cmath>
|
||||
#include <limits>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "MCTSAction.hpp"
|
||||
#include "MCTSGameState.hpp"
|
||||
#include "MCTSTypes.hpp"
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
// Node type for MCTS tree
|
||||
enum class NodeType {
|
||||
DECISION, // Player chooses an action (standard MCTS node)
|
||||
CHANCE // Nature determines outcome (for probabilistic actions)
|
||||
};
|
||||
|
||||
// Abstract MCTS Node structure
|
||||
struct MCTSNode {
|
||||
// Node type
|
||||
NodeType nodeType = NodeType::DECISION;
|
||||
// Action information
|
||||
std::unique_ptr<MCTSAction> action; // The action that led to this node (null for root)
|
||||
size_t actionIndex = SIZE_MAX; // Index in the original actions array (SIZE_MAX for root)
|
||||
|
||||
// Score information
|
||||
double immediateScore = 0.0;
|
||||
double lookaheadScore = 0.0;
|
||||
|
||||
// Game state after this action
|
||||
std::unique_ptr<MCTSGameState> gameState;
|
||||
|
||||
// MCTS statistics
|
||||
int visitCount = 0;
|
||||
double totalReward = 0.0;
|
||||
double averageReward = 0.0;
|
||||
mutable double ucb1Value = 0.0;
|
||||
double actionWeight = 1.0; // Prior probability/weight for this action (from heuristics)
|
||||
|
||||
// Tree structure
|
||||
std::vector<std::unique_ptr<MCTSNode>> children;
|
||||
size_t nextUntriedActionIndex = 0; // Next action to expand
|
||||
size_t totalActions = 0; // Total number of available actions
|
||||
MCTSNode* parent = nullptr;
|
||||
|
||||
// Chance node specific fields (only used when nodeType == CHANCE)
|
||||
std::vector<double> outcomeProbabilities; // Probability of each outcome
|
||||
std::vector<double> outcomeRolls; // Representative roll for each outcome
|
||||
|
||||
// Game context
|
||||
MCTSPlayerId playerId;
|
||||
int depth = 0;
|
||||
bool isTerminal = false;
|
||||
int playerFlips = 0; // Number of times the active player has changed from root player
|
||||
bool isMaximizingPlayer = true; // True if this node is maximizing for root player
|
||||
|
||||
// Transposition detection
|
||||
uint64_t stateHash = 0;
|
||||
bool isRedundant = false; // True if this node represents a duplicate state
|
||||
|
||||
// Constructor for root node
|
||||
MCTSNode(std::unique_ptr<MCTSGameState> state, MCTSPlayerId pid, int d)
|
||||
: gameState(std::move(state)),
|
||||
playerId(pid),
|
||||
depth(d),
|
||||
playerFlips(0),
|
||||
isMaximizingPlayer(true) {
|
||||
if (gameState) {
|
||||
stateHash = gameState->hash();
|
||||
isTerminal = gameState->isTerminal();
|
||||
}
|
||||
}
|
||||
|
||||
// Constructor for child node
|
||||
MCTSNode(
|
||||
std::unique_ptr<MCTSAction> act,
|
||||
std::unique_ptr<MCTSGameState> state,
|
||||
MCTSPlayerId pid,
|
||||
int d,
|
||||
size_t actIdx = SIZE_MAX,
|
||||
int flips = 0,
|
||||
bool isMaximizing = true,
|
||||
double weight = 1.0)
|
||||
: action(std::move(act)),
|
||||
actionIndex(actIdx),
|
||||
gameState(std::move(state)),
|
||||
actionWeight(weight),
|
||||
playerId(pid),
|
||||
depth(d),
|
||||
playerFlips(flips),
|
||||
isMaximizingPlayer(isMaximizing) {
|
||||
if (gameState) {
|
||||
stateHash = gameState->hash();
|
||||
isTerminal = gameState->isTerminal();
|
||||
}
|
||||
}
|
||||
|
||||
// Iterative destructor to avoid stack overflow with deep trees
|
||||
~MCTSNode() {
|
||||
std::vector<std::unique_ptr<MCTSNode>> nodesToDestroy;
|
||||
nodesToDestroy.swap(children);
|
||||
|
||||
while (!nodesToDestroy.empty()) {
|
||||
std::vector<std::unique_ptr<MCTSNode>> currentBatch;
|
||||
currentBatch.swap(nodesToDestroy);
|
||||
|
||||
for (const auto& node : currentBatch) {
|
||||
if (node && !node->children.empty()) {
|
||||
for (auto& child : node->children) {
|
||||
nodesToDestroy.push_back(std::move(child));
|
||||
}
|
||||
node->children.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Calculate UCB1 value for this node from parent's perspective
|
||||
// Uses prior-weighted formula similar to AlphaGo:
|
||||
// UCB = Q + c * P * sqrt(N_parent) / (1 + N_child)
|
||||
// Where P is the action weight (prior probability from heuristics)
|
||||
[[nodiscard]] double CalculateUCB1(
|
||||
const double explorationConstant,
|
||||
const int parentVisitCount,
|
||||
const bool parentIsMaximizing) const {
|
||||
// Exploitation: use lookahead score (minimax value)
|
||||
// For minimizing nodes, negate the score to prefer low child values
|
||||
const double exploitationValue = parentIsMaximizing ? lookaheadScore : -lookaheadScore;
|
||||
|
||||
// Exploration: prior-weighted formula (AlphaGo-style)
|
||||
// Actions with weight 0.0 (like FLEE_COMMAND) get no exploration bonus
|
||||
// Unvisited nodes get: c * weight * sqrt(N_parent)
|
||||
// This prevents bad actions from dominating exploration due to infinite UCB
|
||||
const double explorationValue = explorationConstant * actionWeight *
|
||||
std::sqrt(parentVisitCount) / (1.0 + visitCount);
|
||||
|
||||
return exploitationValue + explorationValue;
|
||||
}
|
||||
|
||||
// Check if this node can be expanded
|
||||
[[nodiscard]] bool CanExpand() const { return nextUntriedActionIndex < totalActions; }
|
||||
|
||||
// Check if this is a chance node
|
||||
[[nodiscard]] bool IsChanceNode() const { return nodeType == NodeType::CHANCE; }
|
||||
|
||||
// Check if this is a decision node
|
||||
[[nodiscard]] bool IsDecisionNode() const { return nodeType == NodeType::DECISION; }
|
||||
|
||||
// Get best child from chance node (probability-weighted selection)
|
||||
// For chance nodes, we want to explore outcomes proportionally to their probability
|
||||
[[nodiscard]] MCTSNode* GetBestChanceChild() const {
|
||||
if (children.empty() || !IsChanceNode()) return nullptr;
|
||||
|
||||
// Find the outcome that is most under-explored relative to its probability
|
||||
// Expected visits for outcome i: total_visits * probability[i]
|
||||
// Actual visits: child[i]->visitCount
|
||||
// Deficit: expected - actual
|
||||
size_t bestIndex = 0;
|
||||
double bestDeficit = -std::numeric_limits<double>::max();
|
||||
|
||||
for (size_t i = 0; i < children.size(); i++) {
|
||||
if (!children[i] || children[i]->isRedundant) continue;
|
||||
|
||||
const double expectedVisits = visitCount * outcomeProbabilities[i];
|
||||
const double actualVisits = static_cast<double>(children[i]->visitCount);
|
||||
const double deficit = expectedVisits - actualVisits;
|
||||
|
||||
if (deficit > bestDeficit) {
|
||||
bestDeficit = deficit;
|
||||
bestIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
return children[bestIndex].get();
|
||||
}
|
||||
|
||||
// Get best child based on UCB1
|
||||
[[nodiscard]] MCTSNode* GetBestChild(const double explorationConstant) const {
|
||||
if (children.empty()) return nullptr;
|
||||
|
||||
MCTSNode* bestChild = nullptr;
|
||||
double bestValue = -std::numeric_limits<double>::max();
|
||||
|
||||
for (auto& child : children) {
|
||||
// Skip redundant nodes
|
||||
if (child->isRedundant) continue;
|
||||
|
||||
// Calculate UCB1 value using the helper function
|
||||
const double value =
|
||||
child->CalculateUCB1(explorationConstant, visitCount, isMaximizingPlayer);
|
||||
|
||||
// Debug logging for UCB selection
|
||||
static bool enableUCBDebug = false;
|
||||
if (enableUCBDebug && child->visitCount > 0) {
|
||||
const double exploitationValue =
|
||||
isMaximizingPlayer ? child->lookaheadScore : -child->lookaheadScore;
|
||||
const double explorationValue =
|
||||
explorationConstant * std::sqrt(std::log(visitCount) / child->visitCount);
|
||||
printf(" UCB: %s lookahead=%.2f expl=%.2f (+%.2f) = %.2f [%s]\n",
|
||||
isMaximizingPlayer ? "MAX" : "MIN",
|
||||
child->lookaheadScore,
|
||||
exploitationValue,
|
||||
explorationValue,
|
||||
value,
|
||||
child->action ? child->action->getDescription().c_str() : "root");
|
||||
}
|
||||
|
||||
if (value > bestValue) {
|
||||
bestValue = value;
|
||||
bestChild = child.get();
|
||||
}
|
||||
}
|
||||
|
||||
return bestChild;
|
||||
}
|
||||
|
||||
// Get best child based on visit count (for final selection)
|
||||
[[nodiscard]] MCTSNode* GetBestFinalChild() const {
|
||||
if (children.empty()) return nullptr;
|
||||
|
||||
MCTSNode* bestChild = nullptr;
|
||||
int bestVisits = 0;
|
||||
double bestScore = isMaximizingPlayer ? -std::numeric_limits<double>::max()
|
||||
: std::numeric_limits<double>::max();
|
||||
|
||||
for (const auto& child : children) {
|
||||
// Skip redundant nodes
|
||||
if (child->isRedundant) continue;
|
||||
|
||||
// Prefer most-visited node (robust child selection)
|
||||
if (child->visitCount > bestVisits) {
|
||||
bestVisits = child->visitCount;
|
||||
bestScore = child->lookaheadScore;
|
||||
bestChild = child.get();
|
||||
} else if (child->visitCount == bestVisits) {
|
||||
// Tie-break on lookahead score (minimax value, not poisoned average)
|
||||
// Maximizing: prefer higher score (better for root player)
|
||||
// Minimizing: prefer lower score (worse for root player)
|
||||
const bool shouldReplace = isMaximizingPlayer ? (child->lookaheadScore > bestScore)
|
||||
: (child->lookaheadScore < bestScore);
|
||||
if (shouldReplace) {
|
||||
bestScore = child->lookaheadScore;
|
||||
bestChild = child.get();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If no child was visited, fall back to lookahead score
|
||||
if (!bestChild && !children.empty()) {
|
||||
for (const auto& child : children) {
|
||||
if (child->isRedundant) continue;
|
||||
|
||||
const bool shouldReplace = isMaximizingPlayer ? (child->lookaheadScore > bestScore)
|
||||
: (child->lookaheadScore < bestScore);
|
||||
if (shouldReplace) {
|
||||
bestScore = child->lookaheadScore;
|
||||
bestChild = child.get();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return bestChild;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_ABSTRACT_MCTSNODE_HPP
|
||||
@@ -1,60 +0,0 @@
|
||||
//
|
||||
// Core types for abstract MCTS implementation
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_MCTS_TYPES_HPP
|
||||
#define EAGLE0_MCTS_TYPES_HPP
|
||||
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
namespace shardok {
|
||||
namespace mcts {
|
||||
|
||||
// Exception thrown when MCTS encounters an internal error that indicates a bug
|
||||
class MCTSInternalError : public std::logic_error {
|
||||
public:
|
||||
explicit MCTSInternalError(const std::string& message) : std::logic_error(message) {}
|
||||
};
|
||||
|
||||
// Abstract player identifier type
|
||||
using MCTSPlayerId = int;
|
||||
|
||||
// Simulation policy for MCTS rollouts
|
||||
enum class MCTSSimulationPolicy {
|
||||
RANDOM, // Pure random selection
|
||||
FILTERED_RANDOM, // Random from filtered actions
|
||||
BEST_IMMEDIATE, // Choose best immediate score
|
||||
WEIGHTED_BEST_IMMEDIATE, // Random weighted by score ranking
|
||||
WEIGHTED_HEURISTIC // Random weighted by fast heuristics (no score evaluation)
|
||||
};
|
||||
|
||||
// Backpropagation policy for MCTS tree updates
|
||||
enum class MCTSBackpropagationPolicy {
|
||||
AVERAGING, // Traditional MCTS averaging (for stochastic/single-player games)
|
||||
MINIMAX // Minimax backup (for deterministic adversarial games)
|
||||
};
|
||||
|
||||
// Configuration for MCTS algorithm
|
||||
struct MCTSConfig {
|
||||
double explorationConstant = 1.414; // UCB1 constant (sqrt(2) by default)
|
||||
int maxSimulationDepth = 1000; // Maximum depth for rollout
|
||||
int maxTreeDepth = 2000; // Maximum tree depth to prevent stack overflow
|
||||
bool useMultithreading = true; // Enable parallel MCTS
|
||||
int numThreads = 16; // Number of threads for parallel MCTS
|
||||
MCTSSimulationPolicy simulationPolicy = MCTSSimulationPolicy::BEST_IMMEDIATE;
|
||||
MCTSBackpropagationPolicy backpropagationPolicy = MCTSBackpropagationPolicy::AVERAGING;
|
||||
int maxPlayerFlips = 0; // Maximum number of player changes for tree expansion
|
||||
// (0 = expand through current player's turn only,
|
||||
// 1 = expand through opponent's first response, etc.)
|
||||
int maxSimulationFlips = 0; // Maximum player flips for leaf evaluation
|
||||
// When evaluating a leaf at playerFlips < maxSimulationFlips,
|
||||
// simulate forward to this phase for fair comparison
|
||||
// (default 0 = evaluate leaves as-is, backward compatible)
|
||||
std::string debugDumpPath = ""; // If non-empty, dump MCTS tree to this file path
|
||||
};
|
||||
|
||||
} // namespace mcts
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_MCTS_TYPES_HPP
|
||||
@@ -1,8 +0,0 @@
|
||||
load("@rules_cc//cc:defs.bzl", "cc_library")
|
||||
|
||||
cc_library(
|
||||
name = "tree_indent_util",
|
||||
srcs = ["TreeIndentUtil.cpp"],
|
||||
hdrs = ["TreeIndentUtil.hpp"],
|
||||
visibility = ["//visibility:public"],
|
||||
)
|
||||
@@ -1,53 +0,0 @@
|
||||
//
|
||||
// Utility functions for processing tree indentation with UTF-8 box drawing characters
|
||||
//
|
||||
|
||||
#include "TreeIndentUtil.hpp"
|
||||
|
||||
namespace mcts::util {
|
||||
|
||||
namespace {
|
||||
// Box drawing characters for tree visualization
|
||||
constexpr const char* kBranch = "\xE2\x94\x9C"; // ├
|
||||
constexpr const char* kCorner = "\xE2\x94\x94"; // └
|
||||
constexpr const char* kVertical = "\xE2\x94\x82"; // │
|
||||
constexpr const char* kHorizontal = "\xE2\x94\x80"; // ─
|
||||
} // namespace
|
||||
|
||||
std::string BuildTreeIndent(int indentLevel, bool isLastChild) {
|
||||
std::string indent;
|
||||
|
||||
for (int i = 0; i < indentLevel; ++i) {
|
||||
if (i == indentLevel - 1) {
|
||||
indent += isLastChild ? kCorner : kBranch;
|
||||
indent += kHorizontal;
|
||||
indent += " ";
|
||||
} else {
|
||||
indent += " ";
|
||||
}
|
||||
}
|
||||
|
||||
return indent;
|
||||
}
|
||||
|
||||
std::string ConvertBranchToContinuation(const std::string& indent) {
|
||||
std::string result = indent;
|
||||
|
||||
const std::string replacement = std::string(kVertical) + " ";
|
||||
|
||||
// Replace ├ and └ with │
|
||||
size_t pos = 0;
|
||||
while ((pos = result.find(kBranch, pos)) != std::string::npos) {
|
||||
result.replace(pos, 3, replacement); // UTF-8 chars are 3 bytes
|
||||
pos += replacement.size();
|
||||
}
|
||||
pos = 0;
|
||||
while ((pos = result.find(kCorner, pos)) != std::string::npos) {
|
||||
result.replace(pos, 3, replacement);
|
||||
pos += replacement.size();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
} // namespace mcts::util
|
||||
@@ -1,22 +0,0 @@
|
||||
//
|
||||
// Utility functions for processing tree indentation with UTF-8 box drawing characters
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_TREE_INDENT_UTIL_HPP
|
||||
#define EAGLE0_TREE_INDENT_UTIL_HPP
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace mcts::util {
|
||||
|
||||
// Builds tree indentation string for a node at a given depth
|
||||
// Returns string like " ├─ " or " └─ " with proper spacing
|
||||
std::string BuildTreeIndent(int indentLevel, bool isLastChild);
|
||||
|
||||
// Converts tree branch characters (├ and └) to continuation lines (│) for sub-content
|
||||
// This preserves the tree structure when displaying additional info below a node
|
||||
std::string ConvertBranchToContinuation(const std::string& indent);
|
||||
|
||||
} // namespace mcts::util
|
||||
|
||||
#endif // EAGLE0_TREE_INDENT_UTIL_HPP
|
||||
@@ -36,7 +36,7 @@ auto CalculateMap(
|
||||
.name = mapName,
|
||||
.positionsRequiringCrossing = {}};
|
||||
|
||||
for (unsigned int i = 0; i < hexMap->attacker_starting_positions()->size(); i++) {
|
||||
for (int i = 0; i < hexMap->attacker_starting_positions()->size(); i++) {
|
||||
const auto* positionList = hexMap->attacker_starting_positions()->Get(i);
|
||||
if (positionList->positions()->size() < 1) continue;
|
||||
if (positionList->positions()->size() != 10) {
|
||||
|
||||
@@ -5,9 +5,7 @@
|
||||
#ifndef EAGLE0_MAPINFOCALCULATOR_HPP
|
||||
#define EAGLE0_MAPINFOCALCULATOR_HPP
|
||||
|
||||
#include <cstdint>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
//
|
||||
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
|
||||
#include "MapInfoCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
|
||||
@@ -53,7 +52,7 @@ auto main(const int argc, char** argv) -> int {
|
||||
outputStream << " \"positions\": {";
|
||||
|
||||
bool firstPosition = true;
|
||||
for (const auto& [position, count] : mapInfo.positionsRequiringCrossing) {
|
||||
for (const auto& kv : mapInfo.positionsRequiringCrossing) {
|
||||
if (firstPosition) {
|
||||
outputStream << endl;
|
||||
firstPosition = false;
|
||||
@@ -61,7 +60,7 @@ auto main(const int argc, char** argv) -> int {
|
||||
outputStream << "," << endl;
|
||||
}
|
||||
|
||||
outputStream << " \"" << position << "\": " << count;
|
||||
outputStream << " \"" << kv.first << "\": " << kv.second;
|
||||
}
|
||||
outputStream << endl << " }" << endl << " }";
|
||||
}
|
||||
|
||||
@@ -4,11 +4,9 @@
|
||||
|
||||
#include "AIAttackGroups.hpp"
|
||||
|
||||
#include <cstdlib>
|
||||
#include <iterator>
|
||||
#include <ranges>
|
||||
#include <unordered_map>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
|
||||
namespace shardok {
|
||||
@@ -75,28 +73,30 @@ auto MinDistanceIncludingBraving(
|
||||
auto EffectiveDistance(
|
||||
const Unit* unit,
|
||||
const HexMap* map,
|
||||
const AttackLocations& attackLocations,
|
||||
const MapId& mapId,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> DIST_T {
|
||||
const AttackLocations& attackLocations,
|
||||
const SettingsGetter& settings,
|
||||
const int braveWaterCost) -> DIST_T {
|
||||
return EffectiveDistance(
|
||||
unit,
|
||||
map,
|
||||
attackLocations.LocationsWithEnemyInRange(unit),
|
||||
mapId,
|
||||
apdCache,
|
||||
battalionTypeGetter,
|
||||
attackLocations.LocationsWithEnemyInRange(unit),
|
||||
settings,
|
||||
braveWaterCost);
|
||||
}
|
||||
|
||||
auto EffectiveDistance(
|
||||
const Unit* unit,
|
||||
const HexMap* map,
|
||||
const CoordsSet& locations,
|
||||
const MapId& mapId,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> DIST_T {
|
||||
const auto mapId = ActionPointDistancesCache::GetMapId(map);
|
||||
const auto& battType = battalionTypeGetter(unit->battalion().type());
|
||||
const CoordsSet& locations,
|
||||
const SettingsGetter& settings,
|
||||
const int braveWaterCost) -> DIST_T {
|
||||
const auto& battType = settings.GetBattalionType(unit->battalion().type());
|
||||
const auto* notBravingApd = apdCache->GetRaw(map, mapId, battType, false);
|
||||
const ActionPointDistances* bravingApd = nullptr;
|
||||
if (battType->allowsBraveWater) {
|
||||
@@ -129,12 +129,12 @@ auto GenerateTargetPriorities(
|
||||
const vector<const Unit*>& remainingUnits,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const MapId& mapId,
|
||||
const SettingsGetter& settings,
|
||||
const bool isLateGame) -> vector<TargetPriorityList> {
|
||||
auto cc = map->column_count();
|
||||
|
||||
const auto mapId = ActionPointDistancesCache::GetMapId(map);
|
||||
const auto braveWaterCost = settings.Backing().brave_water_action_point_cost();
|
||||
|
||||
vector<TargetPriorityList> allTargetsUnitsAndDistances{};
|
||||
allTargetsUnitsAndDistances.reserve(remainingUnits.size());
|
||||
@@ -158,7 +158,7 @@ auto GenerateTargetPriorities(
|
||||
vector<TargetAndDistance> targetsWithDistance;
|
||||
|
||||
// Get APDs directly from cache (now with built-in thread-local optimization)
|
||||
const auto& battType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto& battType = settings.GetBattalionType(unit->battalion().type());
|
||||
const auto* notBravingApd = apdCache->GetRaw(map, mapId, battType, false);
|
||||
const ActionPointDistances* bravingApd = nullptr;
|
||||
if (battType->allowsBraveWater) {
|
||||
@@ -221,15 +221,11 @@ auto GenerateTargetPriorities(
|
||||
Power(unit);
|
||||
}
|
||||
|
||||
tpl.priorityOrder.reserve(targetsWithDistance.size());
|
||||
std::ranges::transform(
|
||||
targetsWithDistance,
|
||||
std::back_inserter(tpl.priorityOrder),
|
||||
[](const TargetAndDistance& tad) {
|
||||
return TargetAndAttackLocations{
|
||||
.target = tad.target,
|
||||
.attackLocations = tad.attackLocations};
|
||||
});
|
||||
tpl.priorityOrder = common::Map(targetsWithDistance, [](const TargetAndDistance& tad) {
|
||||
return TargetAndAttackLocations{
|
||||
.target = tad.target,
|
||||
.attackLocations = tad.attackLocations};
|
||||
});
|
||||
}
|
||||
|
||||
return allTargetsUnitsAndDistances;
|
||||
|
||||
@@ -5,12 +5,12 @@
|
||||
#ifndef EAGLE0_AIATTACKGROUPS_HPP
|
||||
#define EAGLE0_AIATTACKGROUPS_HPP
|
||||
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.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"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/player_info.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/unit.hpp"
|
||||
@@ -22,8 +22,6 @@ using Unit = net::eagle0::shardok::storage::fb::Unit;
|
||||
using net::eagle0::shardok::storage::fb::PlayerInfo;
|
||||
using std::vector;
|
||||
|
||||
using BattalionTypeGetter = std::function<BattalionTypeSPtr(BattalionTypeId)>;
|
||||
|
||||
struct TargetAndAttackLocations {
|
||||
Coords target;
|
||||
CoordsSet attackLocations;
|
||||
@@ -43,18 +41,20 @@ struct TargetPriorityList {
|
||||
auto EffectiveDistance(
|
||||
const Unit* unit,
|
||||
const HexMap* map,
|
||||
const AttackLocations& attackLocations,
|
||||
const MapId& mapId,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> DIST_T;
|
||||
const AttackLocations& attackLocations,
|
||||
const SettingsGetter& settings,
|
||||
int braveWaterCost) -> DIST_T;
|
||||
|
||||
auto EffectiveDistance(
|
||||
const Unit* unit,
|
||||
const HexMap* map,
|
||||
const CoordsSet& locations,
|
||||
const MapId& mapId,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> DIST_T;
|
||||
const CoordsSet& locations,
|
||||
const SettingsGetter& settings,
|
||||
int braveWaterCost) -> DIST_T;
|
||||
|
||||
auto EffectiveDistance(
|
||||
const Unit* unit,
|
||||
@@ -71,8 +71,8 @@ auto GenerateTargetPriorities(
|
||||
const vector<const Unit*>& remainingUnits,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const MapId& mapId,
|
||||
const SettingsGetter& settings,
|
||||
bool isLateGame = false) -> vector<TargetPriorityList>;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -4,8 +4,6 @@
|
||||
|
||||
#include "AIAttackerStrategySelector.hpp"
|
||||
|
||||
#include "AIAttackGroups.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIFleeDecisionCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
|
||||
@@ -13,23 +11,21 @@ namespace shardok {
|
||||
|
||||
using Unit = net::eagle0::shardok::storage::fb::Unit;
|
||||
|
||||
// Combat success threshold below which we should consider fleeing
|
||||
// This replaces the simple troop ratio check with sophisticated probability estimation
|
||||
constexpr double FLEE_CONSIDERATION_THRESHOLD = 0.25;
|
||||
constexpr double MAXIMUM_RATIO_FOR_ATTACKER_TO_FLEE = 0.50;
|
||||
|
||||
auto AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
const PlayerId attackerPid,
|
||||
const GameStateW& gameState,
|
||||
const net::eagle0::shardok::storage::fb::GameState* gameState,
|
||||
const CoordsSet& criticalTileCoords,
|
||||
int maxRounds,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter& settings,
|
||||
const AIWaterCrossingCommandChooser& waterCrossingCommandChooser,
|
||||
const CommandListSPtr& /*availableCommands*/) -> AIStrategy {
|
||||
const vector<CommandProto>& availableCommands) -> AIStrategy {
|
||||
uint32_t attackerUnitCount = 0;
|
||||
int defenderOccupiedCriticalTileCount = 0;
|
||||
int attackerTroops = 0;
|
||||
int defenderTroops = 0;
|
||||
bool canFlee = false;
|
||||
|
||||
vector<const Unit*> attackerUnits{};
|
||||
@@ -44,6 +40,8 @@ auto AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
if (pi != nullptr) {
|
||||
if (pi->is_defender()) {
|
||||
if (unit->location().row() >= 0) {
|
||||
defenderTroops += unit->battalion().size();
|
||||
|
||||
if (criticalTileCoords.Contains(unit->location())) {
|
||||
++defenderOccupiedCriticalTileCount;
|
||||
}
|
||||
@@ -52,6 +50,7 @@ auto AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
}
|
||||
} else if (unit->player_id() == attackerPid) {
|
||||
++attackerUnitCount;
|
||||
attackerTroops += unit->battalion().size();
|
||||
if (unit->can_flee()) canFlee = true;
|
||||
attackerUnits.push_back(unit);
|
||||
} else {
|
||||
@@ -61,19 +60,11 @@ auto AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
}
|
||||
|
||||
AIStrategy chosenStrategy;
|
||||
|
||||
// Use sophisticated combat success estimation instead of simple troop ratio
|
||||
if (canFlee && AIFleeDecisionCalculator::ShouldConsiderFleeing(
|
||||
attackerPid,
|
||||
gameState,
|
||||
maxRounds,
|
||||
FLEE_CONSIDERATION_THRESHOLD)) {
|
||||
if (canFlee && attackerTroops < MAXIMUM_RATIO_FOR_ATTACKER_TO_FLEE * defenderTroops) {
|
||||
chosenStrategy = FleeStrategy;
|
||||
} else if (const CoordsSet startCrossingLocations =
|
||||
waterCrossingCommandChooser.StartCrossingFrom(
|
||||
battalionTypeGetter,
|
||||
gameState,
|
||||
criticalTileCoords);
|
||||
waterCrossingCommandChooser
|
||||
.StartCrossingFrom(settings, gameState, criticalTileCoords);
|
||||
!startCrossingLocations.empty()) {
|
||||
chosenStrategy = CrossRiversStrategy(startCrossingLocations);
|
||||
} else if (attackerUnitCount < criticalTileCoords.size()) {
|
||||
@@ -88,8 +79,8 @@ auto AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
attackerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost));
|
||||
ActionPointDistancesCache::GetMapId(gameState->hex_map()),
|
||||
settings));
|
||||
}
|
||||
// If any critical tile is occupied by the defender, attack the castles.
|
||||
// Otherwise, try to hold the castles.
|
||||
@@ -105,8 +96,8 @@ auto AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
attackerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost));
|
||||
ActionPointDistancesCache::GetMapId(gameState->hex_map()),
|
||||
settings));
|
||||
} else {
|
||||
chosenStrategy = HoldCastlesStrategy;
|
||||
}
|
||||
|
||||
@@ -6,29 +6,26 @@
|
||||
#define EAGLE0_AIATTACKERSTRATEGYSELECTOR_HPP
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCommandChooser.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCommand.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/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
using GameState = net::eagle0::shardok::storage::fb::GameState;
|
||||
|
||||
class AIAttackerStrategySelector {
|
||||
public:
|
||||
static auto BestAttackerStrategy(
|
||||
PlayerId attackerPid,
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
const CoordsSet& criticalTileCoords,
|
||||
int maxRounds,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter& settings,
|
||||
const AIWaterCrossingCommandChooser& waterCrossingCommandChooser,
|
||||
const CommandListSPtr& availableCommands) -> AIStrategy;
|
||||
const vector<CommandProto>& availableCommands) -> AIStrategy;
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -1,560 +0,0 @@
|
||||
//
|
||||
// Command evaluator for AI lookahead search.
|
||||
// Extracted from AIScoreCalculator to separate concerns.
|
||||
//
|
||||
|
||||
#include "AICommandEvaluator.hpp"
|
||||
|
||||
#include <chrono>
|
||||
#include <cmath>
|
||||
#include <future>
|
||||
#include <limits>
|
||||
|
||||
#include "AICommandFilter.hpp"
|
||||
#include "TranspositionTable.hpp"
|
||||
#include "src/main/cpp/net/eagle0/common/SequenceRandomGenerator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexCubeUtils.hpp"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
// No need to forward declare internal functions - use the public interface instead
|
||||
|
||||
// Helper constants and static variables
|
||||
static const std::vector<double> _averageSequence = {0.5};
|
||||
static const auto _averageGenerator = std::make_shared<SequenceRandomGenerator>(_averageSequence);
|
||||
|
||||
#define MULTITHREAD true
|
||||
#define LOGGING_ 0
|
||||
|
||||
// Helper function to determine if a command type is deterministic
|
||||
static auto IsDeterministic(const CommandType type) -> bool {
|
||||
switch (type) {
|
||||
case net::eagle0::shardok::common::MOVE_COMMAND:
|
||||
case net::eagle0::shardok::common::CONTROL_COMMAND:
|
||||
case net::eagle0::shardok::common::METEOR_START_COMMAND:
|
||||
case net::eagle0::shardok::common::METEOR_TARGET_COMMAND:
|
||||
case net::eagle0::shardok::common::METEOR_CANCEL_COMMAND:
|
||||
case net::eagle0::shardok::common::END_TURN_COMMAND:
|
||||
case net::eagle0::shardok::common::PLACE_UNIT_COMMAND:
|
||||
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::REPAIR_COMMAND: return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Helper function to sort commands by score
|
||||
static auto CommandSorter(
|
||||
const AICommandEvaluator::IndexAndScore& l,
|
||||
const AICommandEvaluator::IndexAndScore& r) -> bool {
|
||||
if (l.lookaheadScore < r.lookaheadScore) return true;
|
||||
if (l.lookaheadScore > r.lookaheadScore) return false;
|
||||
|
||||
// At this point the scores are tied
|
||||
if (l.immediateScore < r.immediateScore) return true;
|
||||
if (l.immediateScore > r.immediateScore) return false;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
AICommandEvaluator::AICommandEvaluator(
|
||||
const AIScoreCalculator& scorer,
|
||||
const APDCache& apdCache,
|
||||
BattalionTypeGetter battalionTypeGetter)
|
||||
: scorer_(scorer),
|
||||
apdCache_(apdCache),
|
||||
battalionTypeGetter_(std::move(battalionTypeGetter)) {} // Move the function object
|
||||
|
||||
auto AICommandEvaluator::PerformLookahead(
|
||||
const PlayerId pid,
|
||||
const bool isDefender,
|
||||
const int remainingLookahead,
|
||||
const int maxRepeatCount,
|
||||
const std::shared_ptr<ShardokEngine>& innerEngine,
|
||||
const ScoreValue currentUtility,
|
||||
const AIStrategy& attackerStrategy,
|
||||
const CoordsSet& allCastleCoords,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::future<ScoreValue> {
|
||||
// Check transposition table before expensive computation
|
||||
auto cachedScore =
|
||||
g_transpositionTable.probe(innerEngine->GetCurrentGameState(), remainingLookahead, pid);
|
||||
|
||||
if (cachedScore.has_value()) {
|
||||
// Return cached result immediately
|
||||
std::promise<ScoreValue> p;
|
||||
p.set_value(*cachedScore);
|
||||
return p.get_future();
|
||||
}
|
||||
const auto nextUtility = currentUtility;
|
||||
|
||||
// Check if we've reached the depth limit before making recursive calls
|
||||
if (remainingLookahead <= 0) {
|
||||
// Store the current utility in the transposition table and return it
|
||||
// Note: Store with depth 1 since depth 0 indicates an empty entry in the transposition
|
||||
// table
|
||||
g_transpositionTable.store(innerEngine->GetCurrentGameState(), 1, pid, nextUtility);
|
||||
|
||||
std::promise<ScoreValue> p;
|
||||
p.set_value(nextUtility);
|
||||
return p.get_future();
|
||||
}
|
||||
|
||||
if (const CommandListSPtr nextCommands = innerEngine->GetAvailableCommandsForAIPlayer(pid);
|
||||
nextCommands && !nextCommands->empty()) {
|
||||
// Get the future from FindBestCommand without calling .get()
|
||||
auto bestCommandFuture = FindBestCommand(
|
||||
pid,
|
||||
isDefender,
|
||||
remainingLookahead - 1,
|
||||
maxRepeatCount,
|
||||
*innerEngine,
|
||||
attackerStrategy,
|
||||
nextUtility,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
// Return a future that chains the best command evaluation
|
||||
return std::async(
|
||||
std::launch::deferred,
|
||||
[bestCommandFuture = std::move(bestCommandFuture),
|
||||
innerEngine,
|
||||
pid,
|
||||
nextUtility,
|
||||
remainingLookahead]() mutable -> ScoreValue {
|
||||
const auto [index, type, lookaheadScore, immediateScore] =
|
||||
bestCommandFuture.get();
|
||||
|
||||
ScoreValue resultScore;
|
||||
if (auto& nextCommand =
|
||||
innerEngine->GetAvailableCommandsForAIPlayer(pid)->at(index);
|
||||
nextCommand->GetCommandType() !=
|
||||
net::eagle0::shardok::common::END_TURN_COMMAND) {
|
||||
resultScore = immediateScore;
|
||||
} else {
|
||||
resultScore = nextUtility;
|
||||
}
|
||||
|
||||
// Store in transposition table before returning
|
||||
g_transpositionTable.store(
|
||||
innerEngine->GetCurrentGameState(),
|
||||
remainingLookahead,
|
||||
pid,
|
||||
resultScore);
|
||||
|
||||
return resultScore;
|
||||
});
|
||||
}
|
||||
|
||||
// No commands available, store and return the current utility as a future
|
||||
g_transpositionTable
|
||||
.store(innerEngine->GetCurrentGameState(), remainingLookahead, pid, nextUtility);
|
||||
|
||||
std::promise<ScoreValue> p;
|
||||
p.set_value(nextUtility);
|
||||
return p.get_future();
|
||||
}
|
||||
|
||||
auto AICommandEvaluator::EvaluateWithRandomness(
|
||||
const PlayerId pid,
|
||||
const bool isDefender,
|
||||
const uint32_t commandIndex,
|
||||
const int remainingLookahead,
|
||||
const int maxRepeatCount,
|
||||
const std::shared_ptr<RandomGenerator>& randomGenerator,
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIStrategy& attackerStrategy,
|
||||
const CoordsSet& allCastleCoords,
|
||||
std::chrono::steady_clock::time_point deadline) const -> ImmediateAndLookaheadScore {
|
||||
ImmediateAndLookaheadScore returnValue{};
|
||||
|
||||
// Check if we've exceeded the deadline
|
||||
if (std::chrono::steady_clock::now() > deadline) {
|
||||
// Return with a default score and an empty future that resolves immediately
|
||||
std::promise<ScoreValue> p;
|
||||
p.set_value(0.0); // Default timeout score
|
||||
returnValue.immediateScore = 0.0;
|
||||
returnValue.lookaheadScore = p.get_future();
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
auto innerEngine = std::make_shared<ShardokEngine>(guessedEngine, false);
|
||||
innerEngine->PostCommand(pid, commandIndex, randomGenerator);
|
||||
|
||||
auto innerUtility = scorer_.GuessedStateScore(
|
||||
isDefender,
|
||||
innerEngine->GetCurrentGameState(),
|
||||
attackerStrategy,
|
||||
allCastleCoords);
|
||||
|
||||
returnValue.immediateScore = innerUtility;
|
||||
|
||||
if (remainingLookahead <= 0) {
|
||||
std::promise<ScoreValue> p;
|
||||
returnValue.lookaheadScore = p.get_future();
|
||||
p.set_value(innerUtility);
|
||||
} else {
|
||||
auto lookaheadLambda = [this,
|
||||
pid,
|
||||
isDefender,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
innerEngine,
|
||||
attackerStrategy,
|
||||
innerUtility,
|
||||
&allCastleCoords,
|
||||
deadline]() -> ScoreValue {
|
||||
auto lookaheadFuture = PerformLookahead(
|
||||
pid,
|
||||
isDefender,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
innerEngine,
|
||||
innerUtility,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
return lookaheadFuture.get();
|
||||
};
|
||||
|
||||
#if MULTITHREAD
|
||||
auto launchPolicy = remainingLookahead == 1 ? std::launch::async : std::launch::deferred;
|
||||
returnValue.lookaheadScore = std::async(launchPolicy, lookaheadLambda);
|
||||
#else
|
||||
std::promise<ScoreValue> p;
|
||||
returnValue.lookaheadScore = p.get_future();
|
||||
auto lambdaResult = lookaheadLambda();
|
||||
p.set_value(lambdaResult);
|
||||
#endif
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
}
|
||||
|
||||
auto AICommandEvaluator::FindBestCommand(
|
||||
const PlayerId pid,
|
||||
const bool isDefender,
|
||||
const int remainingLookahead,
|
||||
const int maxRepeatCount,
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIStrategy& attackerStrategy,
|
||||
const ScoreValue currentUtility,
|
||||
const CoordsSet& allCastleCoords,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::future<IndexAndScore> {
|
||||
const CommandListSPtr guessedDescriptors = guessedEngine.GetAvailableCommandsForAIPlayer(pid);
|
||||
|
||||
// Filter out obviously bad commands to reduce search space
|
||||
const std::vector<size_t> filteredIndices = AICommandFilter::FilterCommands(
|
||||
guessedDescriptors,
|
||||
pid,
|
||||
isDefender,
|
||||
guessedEngine.GetCurrentGameState(),
|
||||
apdCache_,
|
||||
battalionTypeGetter_);
|
||||
|
||||
const auto& gameState = guessedEngine.GetCurrentGameState();
|
||||
// Calculate minimum hex distance to enemies for this player
|
||||
double minDistToEnemies = std::numeric_limits<double>::max();
|
||||
const auto* units = gameState->units();
|
||||
|
||||
for (size_t i = 0; i < units->size(); ++i) {
|
||||
if (const auto* playerUnit = units->Get(static_cast<unsigned int>(i));
|
||||
playerUnit->player_id() == pid) {
|
||||
const auto& playerCoords = playerUnit->location();
|
||||
|
||||
for (size_t j = 0; j < units->size(); ++j) {
|
||||
if (const auto* enemyUnit = units->Get(static_cast<unsigned int>(j));
|
||||
enemyUnit->player_id() != pid) {
|
||||
const auto& enemyCoords = enemyUnit->location();
|
||||
|
||||
// Proper hex distance calculation using cube coordinates
|
||||
const Cube playerCube = OffsetToCube(playerCoords);
|
||||
const Cube enemyCube = OffsetToCube(enemyCoords);
|
||||
const int hexDistance = CubeDistance(playerCube, enemyCube);
|
||||
|
||||
minDistToEnemies = std::min(minDistToEnemies, static_cast<double>(hexDistance));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (minDistToEnemies == std::numeric_limits<double>::max()) {
|
||||
minDistToEnemies = 0.0; // No enemies found
|
||||
}
|
||||
|
||||
#if LOGGING_
|
||||
// Log command count and distance metrics for performance analysis
|
||||
const auto allCommandCount = guessedDescriptors->size();
|
||||
const auto filteredCommandCount = filteredIndices.size();
|
||||
const int currentRound = gameState->current_round();
|
||||
|
||||
printf("AI_COMMAND_COUNT: Round %d, Player %d, Defender %d, MinDist %.1f, Commands %zu -> %zu "
|
||||
"(%.1f%% filtered)\n",
|
||||
currentRound,
|
||||
static_cast<int>(pid),
|
||||
isDefender ? 1 : 0,
|
||||
minDistToEnemies,
|
||||
allCommandCount,
|
||||
filteredCommandCount,
|
||||
100.0 * (allCommandCount - filteredCommandCount) / allCommandCount);
|
||||
#endif
|
||||
|
||||
const auto commandCount = filteredIndices.size();
|
||||
|
||||
// Structure to hold all command evaluation data
|
||||
struct CommandEvaluation {
|
||||
size_t index;
|
||||
CommandType type;
|
||||
ScoreValue immediateScore;
|
||||
std::vector<std::future<ScoreValue>> lookaheadFutures;
|
||||
};
|
||||
|
||||
std::vector<CommandEvaluation> commandEvaluations(commandCount);
|
||||
|
||||
for (uint32_t index = 0; index < commandCount; index++) {
|
||||
const auto originalIndex = filteredIndices[index];
|
||||
const auto& guessedDescriptor = guessedDescriptors->at(originalIndex);
|
||||
const auto guessedCommandType = guessedDescriptor->GetCommandType();
|
||||
|
||||
commandEvaluations[index].index = originalIndex;
|
||||
commandEvaluations[index].type = guessedCommandType;
|
||||
|
||||
if (guessedCommandType == net::eagle0::shardok::common::END_TURN_COMMAND) {
|
||||
std::promise<ScoreValue> p;
|
||||
commandEvaluations[index].lookaheadFutures.push_back(p.get_future());
|
||||
p.set_value(currentUtility);
|
||||
commandEvaluations[index].immediateScore = currentUtility;
|
||||
} else if (IsDeterministic(guessedCommandType)) {
|
||||
auto [immediateScore, lookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
originalIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
_averageGenerator,
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
commandEvaluations[index].immediateScore = immediateScore;
|
||||
commandEvaluations[index].lookaheadFutures.push_back(std::move(lookaheadScore));
|
||||
} else if (guessedDescriptor->HasOdds()) {
|
||||
const auto successChancePercentile = guessedDescriptor->GetOddsPercentile();
|
||||
const double successChance = static_cast<double>(successChancePercentile) / 100.0;
|
||||
|
||||
// Success attempt uses 1.0 - (successChance / 2) as the roll
|
||||
auto [successImmediateScore, successLookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
originalIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
std::make_shared<SequenceRandomGenerator>(
|
||||
std::vector{1.0 - successChance / 2.0}),
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
// Failure attempt uses the average of (1 - successChance) and 0 as the roll
|
||||
auto [failureImmediateScore, failureLookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
originalIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
std::make_shared<SequenceRandomGenerator>(
|
||||
std::vector{(1.0 - successChance) / 2.0}),
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
commandEvaluations[index].immediateScore =
|
||||
std::lerp(failureImmediateScore, successImmediateScore, successChance);
|
||||
|
||||
auto successSF = successLookaheadScore.share();
|
||||
auto failureSF = failureLookaheadScore.share();
|
||||
commandEvaluations[index].lookaheadFutures.push_back(std::async(
|
||||
std::launch::deferred,
|
||||
[successSF, failureSF, successChance]() -> double {
|
||||
return std::lerp(failureSF.get(), successSF.get(), successChance);
|
||||
}));
|
||||
} else {
|
||||
ScoreValue sum = 0.0;
|
||||
for (int repeatIteration = 0; repeatIteration < maxRepeatCount; repeatIteration++) {
|
||||
// In each iteration, use a double from [0, 1] as the random roll
|
||||
auto sequence = std::vector{
|
||||
static_cast<double>(repeatIteration) /
|
||||
static_cast<double>(maxRepeatCount - 1)};
|
||||
auto [immediateScore, lookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
originalIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
std::make_shared<SequenceRandomGenerator>(sequence),
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
sum += immediateScore;
|
||||
commandEvaluations[index].lookaheadFutures.push_back(std::move(lookaheadScore));
|
||||
}
|
||||
commandEvaluations[index].immediateScore = sum / maxRepeatCount;
|
||||
}
|
||||
}
|
||||
|
||||
// Return a future that will wait for all evaluations and find the best one
|
||||
return std::async(
|
||||
std::launch::deferred,
|
||||
[evals = std::move(commandEvaluations)]() mutable -> IndexAndScore {
|
||||
std::vector<IndexAndScore> allResults;
|
||||
allResults.reserve(evals.size());
|
||||
|
||||
// Wait for all futures and compute final scores
|
||||
for (auto& eval : evals) {
|
||||
ScoreValue totalLookaheadScore = 0.0;
|
||||
for (auto& future : eval.lookaheadFutures) {
|
||||
totalLookaheadScore += future.get();
|
||||
}
|
||||
ScoreValue avgLookaheadScore =
|
||||
eval.lookaheadFutures.empty()
|
||||
? eval.immediateScore
|
||||
: totalLookaheadScore / eval.lookaheadFutures.size();
|
||||
|
||||
allResults.push_back(IndexAndScore{
|
||||
.index = eval.index,
|
||||
.type = eval.type,
|
||||
.lookaheadScore = avgLookaheadScore,
|
||||
.immediateScore = eval.immediateScore});
|
||||
}
|
||||
// Find the best command using the existing sorter
|
||||
auto bestIt = std::ranges::max_element(allResults, CommandSorter);
|
||||
return *bestIt;
|
||||
});
|
||||
}
|
||||
|
||||
auto AICommandEvaluator::EvaluateCommand(
|
||||
const PlayerId pid,
|
||||
const bool isDefender,
|
||||
const int remainingLookahead,
|
||||
const int maxRepeatCount,
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIStrategy& attackerStrategy,
|
||||
const ScoreValue currentUtility,
|
||||
const CoordsSet& allCastleCoords,
|
||||
const size_t commandIndex,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::future<ScoreValue> {
|
||||
const CommandListSPtr guessedDescriptors = guessedEngine.GetAvailableCommandsForAIPlayer(pid);
|
||||
|
||||
if (commandIndex >= guessedDescriptors->size()) {
|
||||
std::promise<ScoreValue> p;
|
||||
p.set_value(currentUtility);
|
||||
return p.get_future();
|
||||
}
|
||||
|
||||
const auto& guessedDescriptor = guessedDescriptors->at(commandIndex);
|
||||
|
||||
if (const auto guessedCommandType = guessedDescriptor->GetCommandType();
|
||||
guessedCommandType == net::eagle0::shardok::common::END_TURN_COMMAND) {
|
||||
std::promise<ScoreValue> p;
|
||||
p.set_value(currentUtility);
|
||||
return p.get_future();
|
||||
} else if (IsDeterministic(guessedCommandType)) {
|
||||
auto [immediateScore, lookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
commandIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
_averageGenerator,
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
return std::move(lookaheadScore);
|
||||
} else if (guessedDescriptor->HasOdds()) {
|
||||
const auto successChancePercentile = guessedDescriptor->GetOddsPercentile();
|
||||
const double successChance = static_cast<double>(successChancePercentile) / 100.0;
|
||||
|
||||
// Success attempt
|
||||
auto [successImmediateScore, successLookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
commandIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
std::make_shared<SequenceRandomGenerator>(std::vector{1.0 - successChance / 2.0}),
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
// Failure attempt
|
||||
auto [failureImmediateScore, failureLookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
commandIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
std::make_shared<SequenceRandomGenerator>(std::vector{(1.0 - successChance) / 2.0}),
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
// Return weighted average of success and failure
|
||||
auto successSF = successLookaheadScore.share();
|
||||
auto failureSF = failureLookaheadScore.share();
|
||||
return std::async(std::launch::deferred, [successSF, failureSF, successChance]() -> double {
|
||||
return std::lerp(failureSF.get(), successSF.get(), successChance);
|
||||
});
|
||||
} else {
|
||||
// For non-deterministic commands without odds, use multiple attempts
|
||||
std::vector<std::future<ScoreValue>> lookaheadFutures;
|
||||
lookaheadFutures.reserve(maxRepeatCount);
|
||||
|
||||
for (int repeatIteration = 0; repeatIteration < maxRepeatCount; repeatIteration++) {
|
||||
auto sequence = std::vector{
|
||||
static_cast<double>(repeatIteration) / static_cast<double>(maxRepeatCount - 1)};
|
||||
auto [immediateScore, lookaheadScore] = EvaluateWithRandomness(
|
||||
pid,
|
||||
isDefender,
|
||||
commandIndex,
|
||||
remainingLookahead,
|
||||
maxRepeatCount,
|
||||
std::make_shared<SequenceRandomGenerator>(sequence),
|
||||
guessedEngine,
|
||||
attackerStrategy,
|
||||
allCastleCoords,
|
||||
deadline);
|
||||
|
||||
lookaheadFutures.push_back(std::move(lookaheadScore));
|
||||
}
|
||||
|
||||
// Return a future that computes the average when needed
|
||||
return std::async(
|
||||
std::launch::deferred,
|
||||
[lookaheadFutures = std::move(lookaheadFutures),
|
||||
maxRepeatCount]() mutable -> double {
|
||||
ScoreValue total = 0.0;
|
||||
for (auto& future : lookaheadFutures) { total += future.get(); }
|
||||
return total / maxRepeatCount;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace shardok
|
||||
@@ -1,110 +0,0 @@
|
||||
//
|
||||
// Command evaluator for AI lookahead search.
|
||||
// Separated from AIScoreCalculator to isolate pure state scoring from lookahead logic.
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_AICOMMANDEVALUATOR_HPP
|
||||
#define EAGLE0_AICOMMANDEVALUATOR_HPP
|
||||
|
||||
#include <chrono>
|
||||
#include <future>
|
||||
|
||||
#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/ShardokCTypes.h"
|
||||
#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/protobuf/net/eagle0/shardok/common/command_type.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
// Forward declarations
|
||||
class AIScoreCalculator;
|
||||
class ShardokEngine;
|
||||
|
||||
using ScoreValue = double;
|
||||
using CommandType = net::eagle0::shardok::common::CommandType;
|
||||
using BattalionTypeGetter = std::function<BattalionTypeSPtr(BattalionTypeId)>;
|
||||
|
||||
/// Evaluates commands with lookahead using minimax-style search.
|
||||
/// Uses AIScoreCalculator for pure state evaluation, adds recursive lookahead logic.
|
||||
class AICommandEvaluator {
|
||||
public:
|
||||
/// Construct evaluator with a scorer for state evaluation and dependencies for command
|
||||
/// filtering
|
||||
AICommandEvaluator(
|
||||
const AIScoreCalculator& scorer,
|
||||
const APDCache& apdCache,
|
||||
BattalionTypeGetter battalionTypeGetter); // Pass by value
|
||||
|
||||
/// Evaluates the score for a particular command index with lookahead.
|
||||
[[nodiscard]] auto EvaluateCommand(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIStrategy& attackerStrategy,
|
||||
ScoreValue currentUtility,
|
||||
const CoordsSet& allCastleCoords,
|
||||
size_t commandIndex,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::future<ScoreValue>;
|
||||
|
||||
/// Find the best command among all available commands at the given depth.
|
||||
struct IndexAndScore {
|
||||
size_t index;
|
||||
CommandType type;
|
||||
ScoreValue lookaheadScore;
|
||||
ScoreValue immediateScore;
|
||||
};
|
||||
|
||||
[[nodiscard]] auto FindBestCommand(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIStrategy& attackerStrategy,
|
||||
ScoreValue currentUtility,
|
||||
const CoordsSet& allCastleCoords,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::future<IndexAndScore>;
|
||||
|
||||
private:
|
||||
const AIScoreCalculator& scorer_;
|
||||
const APDCache& apdCache_;
|
||||
BattalionTypeGetter battalionTypeGetter_; // Store by value
|
||||
|
||||
struct ImmediateAndLookaheadScore {
|
||||
ScoreValue immediateScore;
|
||||
std::future<ScoreValue> lookaheadScore;
|
||||
};
|
||||
|
||||
/// Recursive lookahead calculator
|
||||
[[nodiscard]] auto PerformLookahead(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const std::shared_ptr<ShardokEngine>& innerEngine,
|
||||
ScoreValue currentUtility,
|
||||
const AIStrategy& attackerStrategy,
|
||||
const CoordsSet& allCastleCoords,
|
||||
std::chrono::steady_clock::time_point deadline) const -> std::future<ScoreValue>;
|
||||
|
||||
/// Evaluate single command execution with randomness handling
|
||||
[[nodiscard]] auto EvaluateWithRandomness(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
uint32_t commandIndex,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const std::shared_ptr<class RandomGenerator>& randomGenerator,
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIStrategy& attackerStrategy,
|
||||
const CoordsSet& allCastleCoords,
|
||||
std::chrono::steady_clock::time_point deadline) const -> ImmediateAndLookaheadScore;
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_AICOMMANDEVALUATOR_HPP
|
||||
@@ -7,7 +7,6 @@
|
||||
#include <algorithm>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/BattalionType.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokException.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexCubeUtils.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/common/command_type.pb.h"
|
||||
@@ -21,8 +20,8 @@ CoordsSet AICommandFilter::BuildEnemyLocations(const GameStateW& gameState, Play
|
||||
CoordsSet enemyLocations(gameState->hex_map());
|
||||
const auto* units = gameState->units();
|
||||
|
||||
for (size_t i = 0; i < units->size(); ++i) {
|
||||
const auto* unit = units->Get(static_cast<unsigned int>(i));
|
||||
for (int i = 0; i < units->size(); ++i) {
|
||||
const auto* unit = units->Get(i);
|
||||
if (unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
|
||||
unit->player_id() != pid && !unit->hidden() && unit->location().column() != -1) {
|
||||
enemyLocations.Add(unit->location());
|
||||
@@ -37,8 +36,8 @@ std::vector<size_t> AICommandFilter::FilterCommands(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter) {
|
||||
const SettingsGetter& settings,
|
||||
const APDCache& apdCache) {
|
||||
std::vector<size_t> filteredIndices;
|
||||
filteredIndices.reserve(commands->size());
|
||||
|
||||
@@ -67,8 +66,8 @@ std::vector<size_t> AICommandFilter::FilterCommands(
|
||||
pid,
|
||||
isDefender,
|
||||
gameState,
|
||||
settings,
|
||||
apdCache,
|
||||
battalionTypeGetter,
|
||||
enemyLocations,
|
||||
castleLocations,
|
||||
minDistToEnemies)) {
|
||||
@@ -81,22 +80,16 @@ std::vector<size_t> AICommandFilter::FilterCommands(
|
||||
pid,
|
||||
isDefender,
|
||||
gameState,
|
||||
settings,
|
||||
apdCache,
|
||||
battalionTypeGetter,
|
||||
enemyLocations,
|
||||
minDistToEnemies)) {
|
||||
shouldFilter = true;
|
||||
}
|
||||
|
||||
// Check strategic blunders
|
||||
if (!shouldFilter && IsStrategicBlunder(
|
||||
*cmd,
|
||||
pid,
|
||||
isDefender,
|
||||
gameState,
|
||||
apdCache,
|
||||
battalionTypeGetter,
|
||||
minDistToEnemies)) {
|
||||
if (!shouldFilter &&
|
||||
IsStrategicBlunder(*cmd, pid, isDefender, gameState, settings, minDistToEnemies)) {
|
||||
shouldFilter = true;
|
||||
}
|
||||
|
||||
@@ -111,8 +104,8 @@ bool AICommandFilter::IsWastefulAction(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const SettingsGetter& settings,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
const CoordsSet& enemyLocations,
|
||||
const CoordsSet& castleLocations,
|
||||
double minDistToEnemies) {
|
||||
@@ -144,16 +137,15 @@ bool AICommandFilter::IsWastefulAction(
|
||||
|
||||
if (!isDefender) {
|
||||
// Attackers: Only allow fire if the target location is on or adjacent to an enemy
|
||||
const int targetRow = cmd.GetTargetRow();
|
||||
const int targetCol = cmd.GetTargetColumn();
|
||||
if (targetRow < 0 || targetCol < 0) {
|
||||
throw ShardokInternalErrorException(
|
||||
"START_FIRE_COMMAND missing required target information");
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
if (!cmdProto.has_target()) {
|
||||
return true; // Can't analyze without target info
|
||||
}
|
||||
|
||||
const Coords fireLocation(
|
||||
static_cast<int8_t>(targetRow),
|
||||
static_cast<int8_t>(targetCol));
|
||||
const auto& targetCoords = cmdProto.target();
|
||||
const Coords fireLocation{
|
||||
static_cast<int8_t>(targetCoords.row()),
|
||||
static_cast<int8_t>(targetCoords.column())};
|
||||
|
||||
// Check if any enemy is on the fire location or adjacent to it
|
||||
bool enemyNearFireLocation = false;
|
||||
@@ -188,12 +180,13 @@ bool AICommandFilter::IsWastefulAction(
|
||||
|
||||
if (!isDefender) {
|
||||
// Attackers: Only allow fortify if within 3 hexes of enemies or castles
|
||||
const int unitId = cmd.GetActorUnitId();
|
||||
if (unitId < 0) {
|
||||
throw ShardokInternalErrorException(
|
||||
"FORTIFY_COMMAND missing required actor information");
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
if (!cmdProto.has_actor()) {
|
||||
return true; // Can't analyze without actor info
|
||||
}
|
||||
|
||||
const auto unitId = cmdProto.actor().value();
|
||||
|
||||
// Get the acting unit directly by ID
|
||||
const Unit* actingUnit = gameState->units()->Get(unitId);
|
||||
// verify the unit is still active
|
||||
@@ -250,18 +243,16 @@ bool AICommandFilter::IsWastefulAction(
|
||||
// These actions can fail, so we need high confidence of benefit (8+ action points
|
||||
// saved)
|
||||
|
||||
const int unitId = cmd.GetActorUnitId();
|
||||
const int targetRow = cmd.GetTargetRow();
|
||||
const int targetCol = cmd.GetTargetColumn();
|
||||
if (unitId < 0 || targetRow < 0 || targetCol < 0) {
|
||||
throw ShardokInternalErrorException(
|
||||
"BUILD_BRIDGE/FREEZE_WATER_COMMAND missing required actor or target "
|
||||
"information");
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
if (!cmdProto.has_actor() || !cmdProto.has_target()) {
|
||||
return true; // Can't analyze without full command info
|
||||
}
|
||||
|
||||
const Coords waterLocation(
|
||||
static_cast<int8_t>(targetRow),
|
||||
static_cast<int8_t>(targetCol));
|
||||
const auto unitId = cmdProto.actor().value();
|
||||
const auto& targetCoords = cmdProto.target();
|
||||
const Coords waterLocation{
|
||||
static_cast<int8_t>(targetCoords.row()),
|
||||
static_cast<int8_t>(targetCoords.column())};
|
||||
|
||||
// Get the acting unit directly by ID
|
||||
const Unit* actingUnit = gameState->units()->Get(unitId);
|
||||
@@ -278,7 +269,7 @@ bool AICommandFilter::IsWastefulAction(
|
||||
}
|
||||
|
||||
// Get action point distances for this unit's battalion type
|
||||
const auto& battType = battalionTypeGetter(actingUnit->battalion().type());
|
||||
const auto& battType = settings.GetBattalionType(actingUnit->battalion().type());
|
||||
const auto* apd = apdCache->GetRaw(
|
||||
gameState->hex_map(),
|
||||
ActionPointDistancesCache::GetMapId(gameState->hex_map()),
|
||||
@@ -356,16 +347,15 @@ bool AICommandFilter::IsWastefulAction(
|
||||
case CommandType::REPAIR_COMMAND: {
|
||||
// Repair filtering - filter repairs with high integrity targets
|
||||
// Note: RepairCommandFactory already filters enemy-occupied targets
|
||||
const int targetRow = cmd.GetTargetRow();
|
||||
const int targetCol = cmd.GetTargetColumn();
|
||||
if (targetRow < 0 || targetCol < 0) {
|
||||
throw ShardokInternalErrorException(
|
||||
"REPAIR_COMMAND missing required target information");
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
if (!cmdProto.has_target()) {
|
||||
return true; // Can't analyze without target info
|
||||
}
|
||||
|
||||
const Coords repairLocation(
|
||||
static_cast<int8_t>(targetRow),
|
||||
static_cast<int8_t>(targetCol));
|
||||
const auto& targetCoords = cmdProto.target();
|
||||
const Coords repairLocation{
|
||||
static_cast<int8_t>(targetCoords.row()),
|
||||
static_cast<int8_t>(targetCoords.column())};
|
||||
|
||||
// Check terrain modifiers at target location
|
||||
const auto* terrain = GetTerrain(gameState->hex_map(), repairLocation);
|
||||
@@ -388,16 +378,15 @@ bool AICommandFilter::IsWastefulAction(
|
||||
|
||||
case CommandType::EXTINGUISH_FIRE_COMMAND: {
|
||||
// Extinguish fire filtering - don't extinguish fires on enemy-occupied tiles
|
||||
const int targetRow = cmd.GetTargetRow();
|
||||
const int targetCol = cmd.GetTargetColumn();
|
||||
if (targetRow < 0 || targetCol < 0) {
|
||||
throw ShardokInternalErrorException(
|
||||
"EXTINGUISH_FIRE_COMMAND missing required target information");
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
if (!cmdProto.has_target()) {
|
||||
return true; // Can't analyze without target info
|
||||
}
|
||||
|
||||
const Coords fireLocation(
|
||||
static_cast<int8_t>(targetRow),
|
||||
static_cast<int8_t>(targetCol));
|
||||
const auto& targetCoords = cmdProto.target();
|
||||
const Coords fireLocation{
|
||||
static_cast<int8_t>(targetCoords.row()),
|
||||
static_cast<int8_t>(targetCoords.column())};
|
||||
|
||||
// Check if any enemy occupies the fire location - let them burn!
|
||||
std::vector<PlayerId> allyPids; // Empty for now - assume 2-player game
|
||||
@@ -418,8 +407,8 @@ bool AICommandFilter::IsWastefulMovement(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const SettingsGetter& settings,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
const CoordsSet& enemyLocations,
|
||||
double minDistToEnemies) {
|
||||
if (cmd.GetCommandType() != CommandType::MOVE_COMMAND) { return false; }
|
||||
@@ -429,17 +418,17 @@ bool AICommandFilter::IsWastefulMovement(
|
||||
return false; // Don't filter defender movement or when close to enemies
|
||||
}
|
||||
|
||||
// Get unit and target information directly from command
|
||||
const int unitId = cmd.GetActorUnitId();
|
||||
const int targetRow = cmd.GetTargetRow();
|
||||
const int targetCol = cmd.GetTargetColumn();
|
||||
// Get the command proto to access unit and target information
|
||||
const auto cmdProto = cmd.GetCommandProto();
|
||||
|
||||
// Check if we have the required information
|
||||
if (unitId < 0 || targetRow < 0 || targetCol < 0) {
|
||||
throw ShardokInternalErrorException(
|
||||
"MOVE_COMMAND missing required actor or target information");
|
||||
if (!cmdProto.has_actor() || !cmdProto.has_target()) {
|
||||
return false; // Can't analyze without unit and target info
|
||||
}
|
||||
|
||||
const auto unitId = cmdProto.actor().value();
|
||||
const auto& targetCoords = cmdProto.target();
|
||||
|
||||
// Get the acting unit directly by ID
|
||||
const Unit* actingUnit = gameState->units()->Get(unitId);
|
||||
// Verify the unit is still active
|
||||
@@ -455,10 +444,12 @@ bool AICommandFilter::IsWastefulMovement(
|
||||
}
|
||||
|
||||
const auto& currentCoords = actingUnit->location();
|
||||
const Coords targetCoordsFlat(static_cast<int8_t>(targetRow), static_cast<int8_t>(targetCol));
|
||||
const Coords targetCoordsFlat{
|
||||
static_cast<int8_t>(targetCoords.row()),
|
||||
static_cast<int8_t>(targetCoords.column())};
|
||||
|
||||
// Get action point distances for this unit's battalion type
|
||||
const auto& battType = battalionTypeGetter(actingUnit->battalion().type());
|
||||
const auto& battType = settings.GetBattalionType(actingUnit->battalion().type());
|
||||
const auto* apd = apdCache->GetRaw(
|
||||
gameState->hex_map(),
|
||||
ActionPointDistancesCache::GetMapId(gameState->hex_map()),
|
||||
@@ -495,13 +486,12 @@ bool AICommandFilter::IsWastefulMovement(
|
||||
}
|
||||
|
||||
bool AICommandFilter::IsStrategicBlunder(
|
||||
const ShardokCommand& /*cmd*/,
|
||||
PlayerId /*pid*/,
|
||||
bool /*isDefender*/,
|
||||
const GameStateW& /*gameState*/,
|
||||
const APDCache& /*apdCache*/,
|
||||
const BattalionTypeGetter& /*battalionTypeGetter*/,
|
||||
double /*minDistToEnemies*/) {
|
||||
const ShardokCommand& cmd,
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const SettingsGetter& settings,
|
||||
double minDistToEnemies) {
|
||||
// Simplified strategic blunder detection for now
|
||||
// TODO: Implement proper castle abandonment detection
|
||||
// TODO: Use minDistToEnemies for strategic blunder logic
|
||||
@@ -516,8 +506,8 @@ double AICommandFilter::MinDistanceToEnemyUnits(
|
||||
double minDistance = std::numeric_limits<double>::max();
|
||||
const auto* units = gameState->units();
|
||||
|
||||
for (size_t i = 0; i < units->size(); ++i) {
|
||||
const auto* playerUnit = units->Get(static_cast<unsigned int>(i));
|
||||
for (int i = 0; i < units->size(); ++i) {
|
||||
const auto* playerUnit = units->Get(i);
|
||||
if (playerUnit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
|
||||
playerUnit->player_id() == pid) {
|
||||
const auto& playerCoords = playerUnit->location();
|
||||
@@ -547,8 +537,8 @@ double AICommandFilter::MinDistanceToCastles(
|
||||
}
|
||||
|
||||
// Find minimum hex distance from any player unit to any castle
|
||||
for (size_t i = 0; i < units->size(); ++i) {
|
||||
const auto* unit = units->Get(static_cast<unsigned int>(i));
|
||||
for (int i = 0; i < units->size(); ++i) {
|
||||
const auto* unit = units->Get(i);
|
||||
if (unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
|
||||
unit->player_id() == pid) {
|
||||
const auto& unitCoords = unit->location();
|
||||
@@ -582,8 +572,8 @@ int AICommandFilter::CountPlayerUnits(const GameStateW& gameState, PlayerId pid)
|
||||
int count = 0;
|
||||
const auto* units = gameState->units();
|
||||
|
||||
for (size_t i = 0; i < units->size(); ++i) {
|
||||
const auto* unit = units->Get(static_cast<unsigned int>(i));
|
||||
for (int i = 0; i < units->size(); ++i) {
|
||||
const auto* unit = units->Get(i);
|
||||
if (unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
|
||||
unit->player_id() == pid) {
|
||||
count++;
|
||||
@@ -594,9 +584,9 @@ int AICommandFilter::CountPlayerUnits(const GameStateW& gameState, PlayerId pid)
|
||||
}
|
||||
|
||||
bool AICommandFilter::WouldAbandonCriticalCastle(
|
||||
const ShardokCommand& /*cmd*/,
|
||||
PlayerId /*pid*/,
|
||||
const GameStateW& /*gameState*/) {
|
||||
const ShardokCommand& cmd,
|
||||
PlayerId pid,
|
||||
const GameStateW& gameState) {
|
||||
// Simplified implementation - return false for now
|
||||
// TODO: Implement proper castle abandonment detection when API is available
|
||||
return false;
|
||||
|
||||
@@ -8,12 +8,12 @@
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.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"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/command_descriptor.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
@@ -32,8 +32,8 @@ public:
|
||||
* @param pid Player ID making the move
|
||||
* @param isDefender True if this player is the defender
|
||||
* @param gameState Current game state
|
||||
* @param settings Game settings for parameter lookup
|
||||
* @param apdCache Action point distance cache for distance calculations
|
||||
* @param battalionTypeLookup Function to look up battalion types by ID
|
||||
* @return Filtered list of commands worth evaluating
|
||||
*/
|
||||
static std::vector<size_t> FilterCommands(
|
||||
@@ -41,8 +41,8 @@ public:
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeLookup);
|
||||
const SettingsGetter& settings,
|
||||
const APDCache& apdCache);
|
||||
|
||||
private:
|
||||
// Helper to build enemy locations once for efficiency
|
||||
@@ -54,8 +54,8 @@ private:
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const SettingsGetter& settings,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeLookup,
|
||||
const CoordsSet& enemyLocations,
|
||||
const CoordsSet& castleLocations,
|
||||
double minDistToEnemies);
|
||||
@@ -66,8 +66,8 @@ private:
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const SettingsGetter& settings,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeLookup,
|
||||
const CoordsSet& enemyLocations,
|
||||
double minDistToEnemies);
|
||||
|
||||
@@ -77,8 +77,7 @@ private:
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
const GameStateW& gameState,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeLookup,
|
||||
const SettingsGetter& settings,
|
||||
double minDistToEnemies);
|
||||
|
||||
// Helper functions for distance and position analysis
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
//
|
||||
// AICommonTypes.hpp
|
||||
// Common type definitions used across AI utility functions
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_AICOMMONTYPES_HPP
|
||||
#define EAGLE0_AICOMMONTYPES_HPP
|
||||
|
||||
#include <functional>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/BattalionType.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCTypes.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
// Function type for looking up battalion types by ID
|
||||
// Used across AI utilities to get battalion type information without
|
||||
// needing to pass the entire scorer object
|
||||
using BattalionTypeGetter = std::function<BattalionTypeSPtr(BattalionTypeId)>;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_AICOMMONTYPES_HPP
|
||||
@@ -1,25 +0,0 @@
|
||||
//
|
||||
// AI System Types and Configuration
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_AI_CONFIG_HPP
|
||||
#define EAGLE0_AI_CONFIG_HPP
|
||||
|
||||
namespace shardok {
|
||||
|
||||
// Enum for AI algorithm selection
|
||||
enum class AIAlgorithmType {
|
||||
ITERATIVE_DEEPENING, // Default: Minimax with sophisticated randomness
|
||||
MCTS // Monte Carlo Tree Search with multithreading
|
||||
};
|
||||
|
||||
// Enum for scoring calculator selection
|
||||
enum class ScoringCalculatorType {
|
||||
STANDARD, // Default: Unbounded raw scores
|
||||
NORMALIZED, // Normalized scores in [0, 1] range for ML training
|
||||
MCTS_OPTIMIZED // Bounded linear scores tuned for MCTS
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_AI_CONFIG_HPP
|
||||
@@ -4,13 +4,8 @@
|
||||
|
||||
#include "AIDefenderStrategySelector.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <ranges>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackGroups.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
|
||||
namespace shardok {
|
||||
@@ -19,11 +14,10 @@ constexpr double MAXIMUM_RATIO_FOR_DEFENDER_TO_FLEE = 0.15;
|
||||
constexpr double MINIMUM_RATIO_FOR_DEFENDER_TO_HOLD = 0.60;
|
||||
|
||||
auto AIDefenderStrategySelector::BestDefenderStrategy(
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
const CoordsSet& criticalTileCoords,
|
||||
int maxRounds,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter) -> AIStrategy {
|
||||
const SettingsGetter& settings) -> AIStrategy {
|
||||
uint32_t attackerNonUndeadUnitCount = 0;
|
||||
uint32_t attackerNonUndeadUnitNotRequiringWaterCrossingCount = 0;
|
||||
int attackerTroops = 0;
|
||||
@@ -39,7 +33,7 @@ auto AIDefenderStrategySelector::BestDefenderStrategy(
|
||||
player->player_id(),
|
||||
criticalTileCoords,
|
||||
apdCache,
|
||||
battalionTypeGetter);
|
||||
settings);
|
||||
attackerUnitIdsRequiringWaterCrossing.insert(
|
||||
attackerUnitIdsRequiringWaterCrossing.end(),
|
||||
unitIdsRequiringWaterCrossing.begin(),
|
||||
@@ -63,9 +57,7 @@ auto AIDefenderStrategySelector::BestDefenderStrategy(
|
||||
net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD) {
|
||||
++attackerNonUndeadUnitCount;
|
||||
|
||||
if (!std::ranges::contains(
|
||||
attackerUnitIdsRequiringWaterCrossing,
|
||||
unit->unit_id())) {
|
||||
if (!common::Contains(attackerUnitIdsRequiringWaterCrossing, unit->unit_id())) {
|
||||
++attackerNonUndeadUnitNotRequiringWaterCrossingCount;
|
||||
}
|
||||
}
|
||||
@@ -74,7 +66,7 @@ auto AIDefenderStrategySelector::BestDefenderStrategy(
|
||||
}
|
||||
}
|
||||
|
||||
const int roundsRemaining = maxRounds - gameState->current_round();
|
||||
const int roundsRemaining = 32 - gameState->current_round();
|
||||
AIStrategy chosenStrategy;
|
||||
|
||||
// Defender will flee if
|
||||
|
||||
@@ -6,23 +6,20 @@
|
||||
#define EAGLE0_AIDEFENDERSTRATEGYSELECTOR_HPP
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.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/action_point_distances/ActionPointDistancesCache.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
class AIDefenderStrategySelector {
|
||||
using GameState = net::eagle0::shardok::storage::fb::GameState;
|
||||
|
||||
public:
|
||||
static auto BestDefenderStrategy(
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
const CoordsSet& criticalTileCoords,
|
||||
int maxRounds,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter) -> AIStrategy;
|
||||
const SettingsGetter& settings) -> AIStrategy;
|
||||
};
|
||||
} // namespace shardok
|
||||
|
||||
|
||||
@@ -49,8 +49,8 @@ auto DefenderDistanceBuf(
|
||||
const vector<const Unit *> &attackerUnits,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache,
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter &settings,
|
||||
const int braveWaterActionPointCost,
|
||||
const bool lateGame,
|
||||
const bool includeUndead) -> double {
|
||||
const auto &locationsToAttackMe = alCache->CachedLocations(defenderLocation, lateGame);
|
||||
@@ -73,14 +73,14 @@ auto DefenderDistanceBuf(
|
||||
notBravingDistances[typeInt] = apdCache->GetRaw(
|
||||
hexMap,
|
||||
mapId,
|
||||
battalionTypeGetter(attacker->battalion().type()),
|
||||
settings.GetBattalionType(attacker->battalion().type()),
|
||||
false);
|
||||
bravingDistances[typeInt] = apdCache->GetRaw(
|
||||
hexMap,
|
||||
mapId,
|
||||
battalionTypeGetter(attacker->battalion().type()),
|
||||
settings.GetBattalionType(attacker->battalion().type()),
|
||||
true,
|
||||
braveWaterCost);
|
||||
braveWaterActionPointCost);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -6,10 +6,10 @@
|
||||
#define EAGLE0_AIDISTANCEDEBUF_HPP
|
||||
|
||||
#include "AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistances.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"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
@@ -23,8 +23,8 @@ auto DefenderDistanceBuf(
|
||||
const vector<const Unit *> &attackerUnits,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache,
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter &settings,
|
||||
int braveWaterActionPointCost,
|
||||
bool lateGame,
|
||||
bool includeUndead) -> double;
|
||||
|
||||
|
||||
@@ -9,31 +9,23 @@
|
||||
#include "AIFleeDecisionCalculator.hpp"
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIUnitScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
auto AIFleeDecisionCalculator::GetFleeCommandIndex(
|
||||
const CommandList::const_iterator& fleeCommand,
|
||||
const CommandListSPtr& availableCommands) -> size_t {
|
||||
return static_cast<size_t>(std::distance(availableCommands->begin(), fleeCommand));
|
||||
const vector<CommandProto>::const_iterator& fleeCommand,
|
||||
const vector<CommandProto>& availableCommands) -> size_t {
|
||||
return static_cast<size_t>(std::distance(availableCommands.begin(), fleeCommand));
|
||||
}
|
||||
|
||||
auto AIFleeDecisionCalculator::EstimateCombatSuccess(
|
||||
PlayerId attackerPlayerId,
|
||||
const GameStateW& gameState,
|
||||
int maxRounds) -> double {
|
||||
if (gameState->status() == nullptr ||
|
||||
gameState->status()->state() !=
|
||||
net::eagle0::shardok::storage::fb::GameStatus_::State_GAME_RUNNING) {
|
||||
return 1.0; // we're still in set_up so we can't really evaluate
|
||||
}
|
||||
const GameStateW& guessedState,
|
||||
const GameSettingsSPtr& settings) -> double {
|
||||
// Combat success estimation based on troops, heroes, and capture dynamics
|
||||
|
||||
// Combat success estimation based on unit power, heroes, and capture dynamics
|
||||
double attackerPower = 0.0;
|
||||
double defenderPower = 0.0;
|
||||
int attackerTroops = 0; // Still track raw troops for special cases
|
||||
int attackerTroops = 0;
|
||||
int defenderTroops = 0;
|
||||
int attackerUnits = 0;
|
||||
int defenderUnits = 0;
|
||||
@@ -41,19 +33,17 @@ auto AIFleeDecisionCalculator::EstimateCombatSuccess(
|
||||
int defenderHeroes = 0;
|
||||
bool defenderHasVips = false;
|
||||
|
||||
// Calculate total power and count units/heroes for each side
|
||||
for (const auto* unit : *gameState->units()) {
|
||||
// Count troops, units, and heroes for each side
|
||||
for (const auto* unit : *guessedState->units()) {
|
||||
if (unit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT) continue;
|
||||
|
||||
const auto* pi = PlayerInfoForPid(gameState, unit->player_id());
|
||||
const auto* pi = PlayerInfoForPid(guessedState, unit->player_id());
|
||||
if (pi == nullptr) continue;
|
||||
|
||||
const int unitTroops = unit->battalion().size();
|
||||
const bool hasHero = unit->has_attached_hero();
|
||||
const double unitPower = ContextFreeUnitValue(unit);
|
||||
|
||||
if (pi->is_defender()) {
|
||||
defenderPower += unitPower;
|
||||
defenderTroops += unitTroops;
|
||||
defenderUnits++;
|
||||
if (hasHero) {
|
||||
@@ -61,50 +51,46 @@ auto AIFleeDecisionCalculator::EstimateCombatSuccess(
|
||||
if (unit->attached_hero().is_vip()) { defenderHasVips = true; }
|
||||
}
|
||||
} else if (unit->player_id() == attackerPlayerId) {
|
||||
attackerPower += unitPower;
|
||||
attackerTroops += unitTroops;
|
||||
attackerUnits++;
|
||||
if (hasHero) { attackerHeroes++; }
|
||||
}
|
||||
}
|
||||
|
||||
const int roundsRemaining = maxRounds - gameState->current_round();
|
||||
const int roundsRemaining =
|
||||
settings->GetGetter().Backing().max_rounds() - guessedState->current_round();
|
||||
|
||||
// Special case: Attacker has no heroes - automatic loss
|
||||
if (attackerHeroes == 0) {
|
||||
return 0.0; // Cannot win without heroes
|
||||
}
|
||||
|
||||
// Special case: Defender has no heroes - automatic win for attacker
|
||||
if (defenderHeroes == 0) {
|
||||
return 1.0; // Guaranteed win
|
||||
}
|
||||
|
||||
// Special case: Attacker has no troops (but has heroes)
|
||||
// Special case: Attacker has no troops
|
||||
if (attackerTroops == 0) {
|
||||
// Very difficult to win with heroes alone
|
||||
return 0.05; // Extremely low chance
|
||||
// Even with heroes, attacker is extremely unlikely to win without troops
|
||||
return 0.01; // Near zero, but not absolute zero
|
||||
}
|
||||
|
||||
// Special case: Defender has no troops but has heroes
|
||||
if (defenderTroops == 0) {
|
||||
// Defenders with only heroes are vulnerable to capture
|
||||
// Only truly difficult if time is extremely limited
|
||||
if (roundsRemaining <= 1) {
|
||||
// Last round - very hard to capture all heroes
|
||||
return 0.3; // Low but not impossible
|
||||
} else if (roundsRemaining <= 2) {
|
||||
return 0.6; // Still achievable
|
||||
if (defenderTroops == 0 && defenderHeroes > 0) {
|
||||
// Defender can win by running out the clock if attacker can't capture heroes
|
||||
// Success depends heavily on remaining time and attacker's ability to capture
|
||||
if (roundsRemaining <= 3) {
|
||||
// Very hard for attacker to capture all heroes in time
|
||||
return 0.15; // Low chance
|
||||
} else if (roundsRemaining <= 5) {
|
||||
return 0.25; // Still difficult
|
||||
} else {
|
||||
// With 3+ rounds, capturing defenseless heroes is quite feasible
|
||||
return 0.85; // High probability of success
|
||||
// More time available, but still challenging
|
||||
return 0.35;
|
||||
}
|
||||
}
|
||||
|
||||
// Special case: Defender has neither troops nor heroes
|
||||
if (defenderTroops == 0 && defenderHeroes == 0) {
|
||||
return 0.95; // Nearly guaranteed win
|
||||
}
|
||||
|
||||
// Normal case: Both sides have troops
|
||||
// Base probability from power ratio (accounts for unit quality, not just quantity)
|
||||
const double powerRatio = attackerPower / std::max(1.0, defenderPower);
|
||||
double baseProbability = std::min(0.95, std::max(0.05, powerRatio * 0.5));
|
||||
// Base probability from troop ratio
|
||||
const double troopRatio =
|
||||
static_cast<double>(attackerTroops) / static_cast<double>(defenderTroops);
|
||||
double baseProbability = std::min(0.95, std::max(0.05, troopRatio * 0.5));
|
||||
|
||||
// Adjust for time pressure - attackers need to win before time runs out
|
||||
if (roundsRemaining <= 1) {
|
||||
@@ -133,15 +119,18 @@ auto AIFleeDecisionCalculator::EstimateCombatSuccess(
|
||||
|
||||
auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
|
||||
PlayerId playerId,
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& guessedState,
|
||||
const CommandListSPtr& availableCommands,
|
||||
const CommandList::const_iterator& fleeCommand,
|
||||
int maxRounds,
|
||||
int minimumFleeOddsThreshold,
|
||||
int desperateFleeThreshold,
|
||||
const vector<CommandProto>& availableCommands,
|
||||
const vector<CommandProto>::const_iterator& fleeCommand,
|
||||
bool enableDebugLogging) -> FleeDecision {
|
||||
// Get flee success odds
|
||||
const int fleeSuccessChance = (*fleeCommand)->GetOddsPercentile();
|
||||
const int fleeSuccessChance = fleeCommand->odds().success_chance();
|
||||
|
||||
// Get thresholds from settings
|
||||
const auto settingsGetter = settings->GetGetter();
|
||||
const int minimumFleeOddsThreshold = settingsGetter.Backing().ai_minimum_flee_odds_threshold();
|
||||
const int desperateFleeThreshold = settingsGetter.Backing().ai_desperate_flee_threshold();
|
||||
|
||||
if (enableDebugLogging) {
|
||||
printf("AI FinalRound: Evaluating flee (odds=%d%%)...\n", fleeSuccessChance);
|
||||
@@ -161,10 +150,10 @@ auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
|
||||
}
|
||||
|
||||
// Low flee odds - evaluate if fighting might be better
|
||||
const double combatWinChance = EstimateCombatSuccess(playerId, guessedState, maxRounds);
|
||||
const double combatWinChance = EstimateCombatSuccess(playerId, guessedState, settings);
|
||||
|
||||
// If combat situation is hopeless, even bad flee odds are better than certain death
|
||||
if (combatWinChance <= 0.05 && fleeSuccessChance >= desperateFleeThreshold) {
|
||||
if (combatWinChance < 0.05 && fleeSuccessChance >= desperateFleeThreshold) {
|
||||
if (enableDebugLogging) {
|
||||
printf("AI FinalRound: Combat hopeless (%.1f%%), desperate flee attempt (%d%%)\n",
|
||||
combatWinChance * 100,
|
||||
@@ -210,17 +199,4 @@ auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
|
||||
}
|
||||
}
|
||||
|
||||
auto AIFleeDecisionCalculator::ShouldConsiderFleeing(
|
||||
PlayerId attackerPlayerId,
|
||||
const GameStateW& guessedState,
|
||||
int maxRounds,
|
||||
double fleeConsiderationThreshold) -> bool {
|
||||
// Get combat success probability
|
||||
const double combatSuccessChance =
|
||||
EstimateCombatSuccess(attackerPlayerId, guessedState, maxRounds);
|
||||
|
||||
// Consider fleeing if combat success chance is below threshold
|
||||
return combatSuccessChance < fleeConsiderationThreshold;
|
||||
}
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -9,11 +9,14 @@
|
||||
#ifndef AIFleeDecisionCalculator_hpp
|
||||
#define AIFleeDecisionCalculator_hpp
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCommand.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/command_descriptor.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
|
||||
class AIFleeDecisionCalculator {
|
||||
public:
|
||||
// Configuration for flee decision thresholds
|
||||
@@ -32,33 +35,23 @@ public:
|
||||
// Evaluate whether to flee or fight in the final round
|
||||
[[nodiscard]] static auto EvaluateFleeVsFight(
|
||||
PlayerId playerId,
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& guessedState,
|
||||
const CommandListSPtr& availableCommands,
|
||||
const CommandList::const_iterator& fleeCommand,
|
||||
int maxRounds,
|
||||
int minimumFleeOddsThreshold,
|
||||
int desperateFleeThreshold,
|
||||
const vector<CommandProto>& availableCommands,
|
||||
const vector<CommandProto>::const_iterator& fleeCommand,
|
||||
bool enableDebugLogging = false) -> FleeDecision;
|
||||
|
||||
// Estimate probability of combat success for the attacker
|
||||
[[nodiscard]] static auto EstimateCombatSuccess(
|
||||
PlayerId attackerPlayerId,
|
||||
const GameStateW& guessedState,
|
||||
int maxRounds) -> double;
|
||||
|
||||
// Determine if the attacker should consider fleeing based on combat odds
|
||||
// Returns true if fleeing should be considered as an option
|
||||
[[nodiscard]] static auto ShouldConsiderFleeing(
|
||||
PlayerId attackerPlayerId,
|
||||
const GameStateW& guessedState,
|
||||
int maxRounds,
|
||||
double fleeConsiderationThreshold = 0.5) -> bool;
|
||||
const GameSettingsSPtr& settings) -> double;
|
||||
|
||||
private:
|
||||
// Helper to get flee command index
|
||||
[[nodiscard]] static auto GetFleeCommandIndex(
|
||||
const CommandList::const_iterator& fleeCommand,
|
||||
const CommandListSPtr& availableCommands) -> size_t;
|
||||
const vector<CommandProto>::const_iterator& fleeCommand,
|
||||
const vector<CommandProto>& availableCommands) -> size_t;
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -1,251 +0,0 @@
|
||||
//
|
||||
// Fast heuristic weighting implementation with context-aware logic
|
||||
//
|
||||
|
||||
#include "AIHeuristicWeighting.hpp"
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokException.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistances.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
using CommandType = net::eagle0::shardok::common::CommandType;
|
||||
using Coords = net::eagle0::shardok::storage::fb::Coords;
|
||||
using ProtoCoords = net::eagle0::shardok::common::Coords;
|
||||
|
||||
double AIHeuristicWeighting::GetCommandWeight(
|
||||
const CommandType commandType,
|
||||
const UnitId actorUnitId,
|
||||
const PlayerId actorPlayerId,
|
||||
const Coords& targetCoords,
|
||||
const GameStateW& state,
|
||||
const CoordsSet& castleCoords,
|
||||
const APDCache* apdCache,
|
||||
bool isDefender,
|
||||
std::function<BattalionTypeSPtr(BattalionTypeId)> getBattalionType) {
|
||||
// Fast O(1) heuristic weights based on command type and game context
|
||||
// Higher weight = more likely to select in simulation
|
||||
// 0.0 = never select (filtered out)
|
||||
|
||||
const auto* hexMap = state->hex_map();
|
||||
const auto* units = state->units();
|
||||
const bool hasTarget = (targetCoords.row() >= 0 && targetCoords.column() >= 0);
|
||||
|
||||
switch (commandType) {
|
||||
// === HIGH VALUE OFFENSIVE (10.0) ===
|
||||
// Ranged attacks - very valuable, typically available when in range
|
||||
case CommandType::ARCHERY_COMMAND: return 20.0;
|
||||
case CommandType::LIGHTNING_BOLT_COMMAND: return 10.0;
|
||||
case CommandType::FEAR_COMMAND: return 10.0;
|
||||
|
||||
// Area/tactical spells - high impact
|
||||
case CommandType::METEOR_START_COMMAND: {
|
||||
// METEOR_START doesn't have a target - it's based on actor location
|
||||
if (hasTarget) {
|
||||
throw ShardokInternalErrorException(
|
||||
"METEOR_START_COMMAND should not have target coordinates");
|
||||
}
|
||||
|
||||
// Get actor's location
|
||||
const auto* actorUnit = units->Get(actorUnitId);
|
||||
if (!actorUnit) {
|
||||
throw ShardokInternalErrorException(
|
||||
"METEOR_START_COMMAND actor unit not found in game state");
|
||||
}
|
||||
|
||||
const Coords& actorLocation = actorUnit->location();
|
||||
int enemyCount = 0;
|
||||
|
||||
// Count enemies within meteor range (3 hexes) of actor location
|
||||
constexpr int METEOR_RANGE = 3;
|
||||
const auto tilesInRange = TilesWithinDistance(hexMap, actorLocation, METEOR_RANGE);
|
||||
for (const auto& tileCoords : tilesInRange) {
|
||||
if (const auto* unit = Occupant(units, tileCoords)) {
|
||||
if (unit->player_id() != actorPlayerId) { enemyCount++; }
|
||||
}
|
||||
}
|
||||
|
||||
return 1.0 + (enemyCount * 15.0); // Base 1 + 15 per enemy in range
|
||||
}
|
||||
|
||||
case CommandType::METEOR_TARGET_COMMAND: {
|
||||
// High weight per enemy unit at or adjacent to target
|
||||
if (!hasTarget) {
|
||||
throw ShardokInternalErrorException(
|
||||
"METEOR_TARGET_COMMAND requires target coordinates for heuristic "
|
||||
"weighting");
|
||||
}
|
||||
|
||||
int enemyCount = 0;
|
||||
|
||||
// Count enemies at target
|
||||
if (const auto* targetUnit = Occupant(units, targetCoords)) {
|
||||
if (targetUnit->player_id() != actorPlayerId) { enemyCount++; }
|
||||
}
|
||||
|
||||
// Count enemies adjacent to target
|
||||
for (const auto& neighbor : HexMapUtils::GetAdjacentTiles(hexMap, targetCoords)) {
|
||||
if (const auto* unit = Occupant(units, neighbor.coords)) {
|
||||
if (unit->player_id() != actorPlayerId) { enemyCount++; }
|
||||
}
|
||||
}
|
||||
|
||||
return 1.0 + (enemyCount * 15.0); // Base 1 + 15 per enemy in range
|
||||
}
|
||||
|
||||
case CommandType::RAISE_DEAD_COMMAND: return 10.0;
|
||||
case CommandType::HOLY_WAVE_COMMAND: return 8.0;
|
||||
|
||||
// Fire on enemy (context-dependent)
|
||||
case CommandType::START_FIRE_COMMAND: {
|
||||
// High if enemy at target, low otherwise
|
||||
if (!hasTarget) {
|
||||
throw ShardokInternalErrorException(
|
||||
"START_FIRE_COMMAND requires target coordinates for heuristic weighting");
|
||||
}
|
||||
|
||||
if (const auto* targetUnit = Occupant(units, targetCoords)) {
|
||||
if (targetUnit->player_id() != actorPlayerId) {
|
||||
return 10.0; // Enemy at target - high value
|
||||
}
|
||||
}
|
||||
return 1.0; // No enemy - low value but still valid
|
||||
}
|
||||
|
||||
// === MEDIUM-HIGH OFFENSIVE (5.0-7.0) ===
|
||||
// Direct damage melee
|
||||
case CommandType::MELEE_COMMAND: return 7.0;
|
||||
case CommandType::CHARGE_COMMAND: return 7.0; // Damage + movement
|
||||
case CommandType::CHALLENGE_DUEL_COMMAND: return 5.0;
|
||||
|
||||
// Control and tactical magic
|
||||
case CommandType::CONTROL_COMMAND: return 6.0;
|
||||
case CommandType::METEOR_CAST_COMMAND: return 6.0; // Finish meteor
|
||||
|
||||
case CommandType::REDUCE_COMMAND: {
|
||||
// High if enemy at target, zero otherwise
|
||||
if (!hasTarget) return 0.0;
|
||||
|
||||
if (const auto* targetUnit = Occupant(units, targetCoords)) {
|
||||
if (targetUnit->player_id() != actorPlayerId) {
|
||||
return 10.0; // Enemy at target - very high value
|
||||
}
|
||||
}
|
||||
return 0.0; // No enemy - don't use
|
||||
}
|
||||
|
||||
// === MOVEMENT - Context-dependent ===
|
||||
case CommandType::MOVE_COMMAND: {
|
||||
if (isDefender) {
|
||||
return 0.0; // Defenders don't move
|
||||
}
|
||||
|
||||
// Attackers: weight based on distance improvement towards castle
|
||||
if (!hasTarget) {
|
||||
throw ShardokInternalErrorException(
|
||||
"MOVE_COMMAND requires target coordinates for heuristic weighting");
|
||||
}
|
||||
|
||||
// Get actor unit to determine battalion type and start position
|
||||
const auto* actorUnit = units->Get(actorUnitId);
|
||||
if (!actorUnit) return 4.0; // Default if can't find actor
|
||||
|
||||
// Get battalion type for distance calculation
|
||||
const auto battalionTypeId = actorUnit->battalion().type();
|
||||
const auto battalionTypePtr = getBattalionType(battalionTypeId);
|
||||
if (!battalionTypePtr) return 4.0; // Default if can't get battalion type
|
||||
|
||||
// Get ActionPointDistances for this battalion type
|
||||
const auto mapId = ActionPointDistancesCache::GetMapId(hexMap);
|
||||
const auto* apd = (*apdCache)->GetRaw(hexMap, mapId, battalionTypePtr, false, -1);
|
||||
if (!apd) return 4.0; // Default if can't get distances
|
||||
|
||||
// Calculate minimum distance from start to any castle
|
||||
const Coords startCoords = actorUnit->location();
|
||||
auto minStartDistance = ActionPointDistances::IMPOSSIBLE;
|
||||
for (const auto& castleCoord : castleCoords) {
|
||||
const auto dist = apd->Distance(startCoords, castleCoord);
|
||||
if (dist < minStartDistance) { minStartDistance = dist; }
|
||||
}
|
||||
|
||||
// Calculate minimum distance from end to any castle
|
||||
const Coords& endCoords = targetCoords;
|
||||
auto minEndDistance = ActionPointDistances::IMPOSSIBLE;
|
||||
for (const auto& castleCoord : castleCoords) {
|
||||
const auto dist = apd->Distance(endCoords, castleCoord);
|
||||
if (dist < minEndDistance) { minEndDistance = dist; }
|
||||
}
|
||||
|
||||
// Return weight based on distance improvement
|
||||
// Higher weight if we're moving closer to castle
|
||||
if (minStartDistance == ActionPointDistances::IMPOSSIBLE ||
|
||||
minEndDistance == ActionPointDistances::IMPOSSIBLE) {
|
||||
return 4.0; // Default if distances are impossible
|
||||
}
|
||||
|
||||
const auto improvement = static_cast<double>(minStartDistance - minEndDistance);
|
||||
return std::max(0.0, improvement);
|
||||
}
|
||||
|
||||
case CommandType::BRAVE_WATER_COMMAND: return 3.0; // Tactical movement
|
||||
case CommandType::SCOUT_COMMAND:
|
||||
return 2.0; // Information gathering
|
||||
|
||||
// Terrain manipulation
|
||||
case CommandType::FREEZE_WATER_COMMAND: return 3.0;
|
||||
case CommandType::BUILD_BRIDGE_COMMAND: return 3.0;
|
||||
|
||||
// === LOW VALUE DEFENSIVE/UTILITY (1.0-2.0) ===
|
||||
case CommandType::EXTINGUISH_FIRE_COMMAND: {
|
||||
// High if friendly at target, low otherwise
|
||||
if (!hasTarget) {
|
||||
throw ShardokInternalErrorException(
|
||||
"EXTINGUISH_FIRE_COMMAND requires target coordinates for heuristic "
|
||||
"weighting");
|
||||
}
|
||||
|
||||
if (const auto* targetUnit = Occupant(units, targetCoords)) {
|
||||
if (targetUnit->player_id() == actorPlayerId) {
|
||||
return 8.0; // Friendly at target - high value
|
||||
}
|
||||
}
|
||||
return 1.0; // No friendly - low value but still valid
|
||||
}
|
||||
|
||||
case CommandType::UNIT_REST_COMMAND: return 1.5;
|
||||
case CommandType::FORTIFY_COMMAND: return 2.0;
|
||||
|
||||
// Zero weight - don't use in simulation
|
||||
case CommandType::REPAIR_COMMAND: return 0.0;
|
||||
case CommandType::HIDE_COMMAND: return 0.0;
|
||||
case CommandType::RELEASE_UNIT_COMMAND: return 0.0;
|
||||
|
||||
case CommandType::REINFORCE_COMMAND: return 10.0;
|
||||
case CommandType::MANAGE_PRISONER: return 1.0;
|
||||
|
||||
// === ZERO WEIGHT - NEVER SELECT (0.0) ===
|
||||
// Explicitly bad actions
|
||||
case CommandType::FLEE_COMMAND: return 0.0; // Never flee in simulation
|
||||
case CommandType::RETREAT_COMMAND: return 0.0;
|
||||
case CommandType::BECOME_OUTLAW_COMMAND: return 0.0; // Never become outlaw
|
||||
case CommandType::DISMISS_UNIT_COMMAND:
|
||||
return 0.0; // Never dismiss in combat
|
||||
|
||||
// Actions that are fine as a fallback
|
||||
case CommandType::END_TURN_COMMAND: return 1.0;
|
||||
case CommandType::UNIT_STOP_COMMAND: return 1.0;
|
||||
case CommandType::METEOR_CANCEL_COMMAND: return 1.0;
|
||||
|
||||
// Setup commands (shouldn't appear in combat, but filter anyway)
|
||||
case CommandType::PLACE_UNIT_COMMAND: return 10.0;
|
||||
case CommandType::PLACE_HIDDEN_UNIT_COMMAND: return 1.0;
|
||||
case CommandType::END_PLAYER_SETUP_COMMAND: return 1.0;
|
||||
|
||||
// Unknown/unhandled
|
||||
case CommandType::UNKNOWN_COMMAND:
|
||||
default: return 0.0; // Don't select unknown commands
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace shardok
|
||||
@@ -1,40 +0,0 @@
|
||||
//
|
||||
// Fast heuristic weighting for MCTS simulations
|
||||
// Provides O(1) weights based on command type and context
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_AI_HEURISTIC_WEIGHTING_HPP
|
||||
#define EAGLE0_AI_HEURISTIC_WEIGHTING_HPP
|
||||
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/common/command_type.pb.h"
|
||||
#pragma clang diagnostic pop
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.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"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
// Fast heuristic-based command weighting for MCTS simulation policy
|
||||
// Avoids expensive score calculation while maintaining intelligent bias
|
||||
class AIHeuristicWeighting {
|
||||
public:
|
||||
// Get weight for a command using fast heuristics with game context
|
||||
// Returns weight >= 0.0, where 0.0 means "never select" and higher is more likely
|
||||
static double GetCommandWeight(
|
||||
net::eagle0::shardok::common::CommandType commandType,
|
||||
UnitId actorUnitId,
|
||||
PlayerId actorPlayerId,
|
||||
const Coords& targetCoords,
|
||||
const GameStateW& state,
|
||||
const CoordsSet& castleCoords,
|
||||
const APDCache* apdCache,
|
||||
bool isDefender,
|
||||
std::function<BattalionTypeSPtr(BattalionTypeId)> getBattalionType);
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_AI_HEURISTIC_WEIGHTING_HPP
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,169 @@
|
||||
//
|
||||
// Created by dancrosby on 3/4/20.
|
||||
//
|
||||
|
||||
#ifndef EAGLE0_AISCORECALCULATOR_HPP
|
||||
#define EAGLE0_AISCORECALCULATOR_HPP
|
||||
|
||||
#include <future>
|
||||
|
||||
#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/library/ShardokCTypes.h"
|
||||
#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/settings/GameSettings.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/command_descriptor.pb.h"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/game_state_view.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
using net::eagle0::shardok::api::GameStateView;
|
||||
using GameState = fb::GameState;
|
||||
using shardok::PlayerId;
|
||||
using std::future;
|
||||
using std::vector;
|
||||
|
||||
using ScoreValue = double;
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
|
||||
class AIScoreCalculator {
|
||||
public:
|
||||
struct IndexAndScore {
|
||||
size_t index;
|
||||
CommandType type;
|
||||
ScoreValue lookaheadScore;
|
||||
ScoreValue immediateScore;
|
||||
};
|
||||
|
||||
private:
|
||||
[[nodiscard]] static auto DefenderScatterStrategyScoreForState(
|
||||
const GameStateW &gameState,
|
||||
int roundsRemaining,
|
||||
const SettingsGetter &settings,
|
||||
const ALCache &alCache,
|
||||
const APDCache &apdCache) -> ScoreValue;
|
||||
|
||||
[[nodiscard]] static auto DefenderHoldCastlesStrategyScoreForState(
|
||||
const GameStateW &gameState,
|
||||
const CoordsSet &castleCoords,
|
||||
int roundsRemaining,
|
||||
const SettingsGetter &settings,
|
||||
const ALCache &alCache,
|
||||
const APDCache &apdCache) -> ScoreValue;
|
||||
|
||||
[[nodiscard]] static auto FleeStrategyScoreForState(
|
||||
const GameStateW &gameState,
|
||||
PlayerId playerId) -> ScoreValue;
|
||||
|
||||
[[nodiscard]] static auto DefenderScoreForState(
|
||||
const GameStateW &gameState,
|
||||
const AIStrategy &defenderStrategy,
|
||||
const CoordsSet &castleCoords,
|
||||
int roundsRemaining,
|
||||
const SettingsGetter &settings,
|
||||
const ALCache &alCache,
|
||||
const APDCache &apdCache) -> ScoreValue;
|
||||
|
||||
[[nodiscard]] static auto AttackerScoreForState(
|
||||
const GameStateW &gameState,
|
||||
const AIStrategy &attackerStrategy,
|
||||
const CoordsSet &castleCoords,
|
||||
int roundsRemaining,
|
||||
const SettingsGetter &settings,
|
||||
const ALCache &alCache,
|
||||
const APDCache &apdCache) -> ScoreValue;
|
||||
|
||||
struct ImmediateAndLookaheadScore {
|
||||
ScoreValue immediateScore;
|
||||
future<ScoreValue> lookaheadScore;
|
||||
};
|
||||
|
||||
static auto BasicLookaheadCalculator(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const shared_ptr<ShardokEngine> &innerEngine,
|
||||
ScoreValue currentUtility,
|
||||
const AIStrategy &attackerStrategy,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const CoordsSet &allCastleCoords,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache) -> ScoreValue;
|
||||
|
||||
static auto CalcOne(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
uint32_t commandIndex,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const std::shared_ptr<RandomGenerator> &randomGenerator,
|
||||
const ShardokEngine &guessedEngine,
|
||||
const AIStrategy &attackerStrategy,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const CoordsSet &allCastleCoords,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache) -> ImmediateAndLookaheadScore;
|
||||
|
||||
struct CommandEvaluationResult {
|
||||
ScoreValue immediateScore;
|
||||
ScoreValue lookaheadScore;
|
||||
};
|
||||
|
||||
static auto EvaluateCommand(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
uint32_t commandIndex,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const ShardokEngine &guessedEngine,
|
||||
const AIStrategy &attackerStrategy,
|
||||
ScoreValue currentUtility,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const CoordsSet &allCastleCoords,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache) -> CommandEvaluationResult;
|
||||
|
||||
public:
|
||||
[[nodiscard]] static auto GuessedStateScore(
|
||||
bool isDefender,
|
||||
const GameStateW &state,
|
||||
const AIStrategy &aiStrategy,
|
||||
const CoordsSet &allCastleCoords,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache) -> ScoreValue;
|
||||
|
||||
[[nodiscard]] static auto BestCommandIndex(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const ShardokEngine &guessedEngine,
|
||||
const AIStrategy &attackerStrategy,
|
||||
ScoreValue currentUtility,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const CoordsSet &allCastleCoords,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache) -> IndexAndScore;
|
||||
|
||||
[[nodiscard]] static auto CommandScore(
|
||||
PlayerId pid,
|
||||
bool isDefender,
|
||||
int remainingLookahead,
|
||||
int maxRepeatCount,
|
||||
const ShardokEngine &guessedEngine,
|
||||
const AIStrategy &attackerStrategy,
|
||||
ScoreValue currentUtility,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const CoordsSet &allCastleCoords,
|
||||
const APDCache &apdCache,
|
||||
const ALCache &alCache,
|
||||
size_t commandIndex) -> ScoreValue;
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
#endif // EAGLE0_AISCORECALCULATOR_HPP
|
||||
@@ -16,7 +16,7 @@ auto HasAttachedHeroWithProfession(
|
||||
unit->attached_hero().profession_info().profession() == profession;
|
||||
}
|
||||
|
||||
auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int {
|
||||
auto CastleClaimCapableAttackerUnitCount(const GameState *gameState) -> int {
|
||||
int count = 0;
|
||||
|
||||
for (const auto *unit : *gameState->units()) {
|
||||
@@ -32,7 +32,7 @@ auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int {
|
||||
return count;
|
||||
}
|
||||
|
||||
auto PlayerInfoForPid(const GameStateW &gs, const PlayerId pid) -> const PlayerInfo * {
|
||||
auto PlayerInfoForPid(const GameState *gs, const PlayerId pid) -> const PlayerInfo * {
|
||||
if (gs->player_infos()) {
|
||||
for (const auto &pi : *gs->player_infos()) {
|
||||
if (pi->player_id() == pid) return pi;
|
||||
|
||||
@@ -7,7 +7,6 @@
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCTypes.h"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/unit.hpp"
|
||||
@@ -26,8 +25,8 @@ 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 *;
|
||||
auto CastleClaimCapableAttackerUnitCount(const GameState *gameState) -> int;
|
||||
auto PlayerInfoForPid(const GameState *gs, PlayerId pid) -> const PlayerInfo *;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
|
||||
@@ -3,7 +3,6 @@
|
||||
//
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
|
||||
|
||||
namespace shardok {
|
||||
AIStrategy FleeStrategy = AIStrategy{AIStrategy::STRATEGY_FLEE};
|
||||
AIStrategy HoldCastlesStrategy = AIStrategy{AIStrategy::STRATEGY_HOLD_CASTLES};
|
||||
|
||||
@@ -24,46 +24,16 @@ int AIEvaluationCounter::GetCurrentCount() { return activeCount.load(); }
|
||||
auto CalculateTimeBudget(
|
||||
const PlayerId playerId,
|
||||
const GameSettingsSPtr &settings,
|
||||
const GameStateW &state,
|
||||
const size_t numCommands) -> AITimeBudget {
|
||||
const GameStateW &state) -> AITimeBudget {
|
||||
const auto settingsGetter = settings->GetGetter();
|
||||
const auto castleCoords = AllCastleCoords(state->hex_map());
|
||||
|
||||
// Check if we're in setup phase
|
||||
const bool isSetupPhase = state->status()->state() ==
|
||||
net::eagle0::shardok::storage::fb::GameStatus_::State_SET_UP;
|
||||
|
||||
// Get maximum budget cap from settings (in seconds)
|
||||
const double maxBudgetSeconds =
|
||||
settingsGetter.Backing().lookahead_time_budget_maximum_seconds();
|
||||
const double maxBudgetMs = maxBudgetSeconds * 1000.0;
|
||||
|
||||
// During setup, use the setup-specific time budget
|
||||
if (isSetupPhase) {
|
||||
// Dynamic budget: msPerCommand × numCommands
|
||||
const double msPerCommand =
|
||||
settingsGetter.Backing().lookahead_time_budget_per_command_setup_ms();
|
||||
const double budgetMs = msPerCommand * static_cast<double>(numCommands);
|
||||
|
||||
// Clamp to reasonable bounds: 200ms minimum, maxBudgetMs maximum
|
||||
const auto clampedBudgetMs = std::clamp(budgetMs, 200.0, maxBudgetMs);
|
||||
const auto remainingBudget =
|
||||
std::chrono::milliseconds(static_cast<int64_t>(clampedBudgetMs));
|
||||
|
||||
const size_t minDepth = settingsGetter.Backing().min_lookahead_turns();
|
||||
|
||||
return AITimeBudget{
|
||||
.remainingBudget = remainingBudget,
|
||||
.minDepthRequired = minDepth,
|
||||
.isCloseToEnemy = false}; // Not relevant during setup
|
||||
}
|
||||
|
||||
// Determine proximity (≤4 hex distance) - applies to both attackers and defenders
|
||||
bool isClose = false;
|
||||
const auto *units = state->units();
|
||||
|
||||
for (size_t i = 0; i < units->size() && !isClose; ++i) {
|
||||
const auto *myUnit = units->Get(static_cast<unsigned int>(i));
|
||||
for (int i = 0; i < units->size() && !isClose; ++i) {
|
||||
const auto *myUnit = units->Get(i);
|
||||
if (myUnit->player_id() != playerId) continue;
|
||||
|
||||
const auto &myCoords = myUnit->location();
|
||||
@@ -73,8 +43,8 @@ auto CalculateTimeBudget(
|
||||
const Cube myCube = OffsetToCube(myCoords);
|
||||
|
||||
// Check distance to enemy units
|
||||
for (size_t j = 0; j < units->size(); ++j) {
|
||||
const auto *enemyUnit = units->Get(static_cast<unsigned int>(j));
|
||||
for (int j = 0; j < units->size(); ++j) {
|
||||
const auto *enemyUnit = units->Get(j);
|
||||
if (enemyUnit->player_id() == playerId) continue;
|
||||
|
||||
const auto &enemyCoords = enemyUnit->location();
|
||||
@@ -102,28 +72,15 @@ auto CalculateTimeBudget(
|
||||
}
|
||||
}
|
||||
|
||||
// Get time budget from settings - dynamic based on number of commands
|
||||
// Dynamic budget: msPerCommand × numCommands
|
||||
const double msPerCommand =
|
||||
isClose ? settingsGetter.Backing().lookahead_time_budget_per_command_close_ms()
|
||||
: settingsGetter.Backing().lookahead_time_budget_per_command_far_ms();
|
||||
const double budgetMs = msPerCommand * static_cast<double>(numCommands);
|
||||
// Get time budget from settings
|
||||
const auto budget = std::chrono::duration<double>(
|
||||
isClose ? settingsGetter.Backing().lookahead_time_budget_close_in_seconds()
|
||||
: settingsGetter.Backing().lookahead_time_budget_far_in_seconds());
|
||||
|
||||
// Clamp to reasonable bounds: 200ms minimum, maxBudgetMs maximum
|
||||
const auto clampedBudgetMs = std::clamp(budgetMs, 200.0, maxBudgetMs);
|
||||
const auto remainingBudget = std::chrono::milliseconds(static_cast<int64_t>(clampedBudgetMs));
|
||||
|
||||
// TEMPORARY DEBUG OUTPUT
|
||||
printf("[DEBUG CalculateTimeBudget] numCommands=%zu, msPerCommand=%.2f, budgetMs=%.2f, "
|
||||
"clampedBudgetMs=%.2f, isClose=%d\n",
|
||||
numCommands,
|
||||
msPerCommand,
|
||||
budgetMs,
|
||||
clampedBudgetMs,
|
||||
isClose);
|
||||
const auto remainingBudget = std::chrono::duration_cast<std::chrono::milliseconds>(budget);
|
||||
|
||||
// Get minimum depth requirement
|
||||
const size_t minDepth = settingsGetter.Backing().min_lookahead_turns();
|
||||
const int minDepth = settingsGetter.Backing().min_lookahead_turns();
|
||||
|
||||
return AITimeBudget{
|
||||
.remainingBudget = remainingBudget,
|
||||
|
||||
@@ -31,18 +31,15 @@ public:
|
||||
// Configuration structure for iterative deepening time budget
|
||||
struct AITimeBudget {
|
||||
std::chrono::milliseconds remainingBudget; // Time budget remaining (decremented as used)
|
||||
size_t minDepthRequired; // Minimum depth from minLookaheadTurns
|
||||
int minDepthRequired; // Minimum depth from minLookaheadTurns
|
||||
bool isCloseToEnemy; // Proximity flag for budget selection
|
||||
};
|
||||
|
||||
// Calculate time budget based on proximity to enemies and castles
|
||||
// Time budget is calculated dynamically based on number of available commands:
|
||||
// budget = msPerCommand × numCommands (clamped to 200-5000ms)
|
||||
auto CalculateTimeBudget(
|
||||
PlayerId playerId,
|
||||
const GameSettingsSPtr &settings,
|
||||
const GameStateW &state,
|
||||
size_t numCommands) -> AITimeBudget;
|
||||
const GameStateW &state) -> AITimeBudget;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
|
||||
@@ -5,7 +5,6 @@
|
||||
#include "AIUnitScoreCalculator.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdlib>
|
||||
|
||||
#include "AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
@@ -17,10 +16,9 @@ using std::end;
|
||||
using std::shared_ptr;
|
||||
|
||||
constexpr double kProfessionValue = 200;
|
||||
constexpr double kVigorScoreMultiplier = 5.0;
|
||||
constexpr double kCastleMultiplierBonus = 1.0;
|
||||
constexpr double kOnFireMultiplier = 0.25;
|
||||
constexpr double kAdjacentFireMultiplier = 0.80;
|
||||
constexpr double kAdjacentFireMultiplier = 0.99;
|
||||
constexpr double kOnIceMultiplier = 0.25;
|
||||
constexpr double kMeteorStartInRangeValue = 50;
|
||||
constexpr double kMeteorDirectTargetingEnemy = 2;
|
||||
@@ -64,8 +62,7 @@ auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue {
|
||||
4.0;
|
||||
}
|
||||
|
||||
const double vigorValue =
|
||||
unit->has_attached_hero() ? unit->attached_hero().vigor() * kVigorScoreMultiplier : 0.0;
|
||||
const double vigorValue = unit->has_attached_hero() ? unit->attached_hero().vigor() : 0.0;
|
||||
|
||||
double battalionTypeMultiplier = 1.0;
|
||||
switch (unit->battalion().type()) {
|
||||
@@ -91,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 * (0.5 + armament / 100.0) *
|
||||
(0.5 + training / 100.0) * (0.5 + morale / 100.0) *
|
||||
unit->battalion().size();
|
||||
|
||||
const double heroValue =
|
||||
@@ -101,7 +98,7 @@ auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue {
|
||||
return battalionValue + heroValue;
|
||||
}
|
||||
|
||||
auto archeryValue(const Unit * /*unit*/) -> double {
|
||||
auto archeryValue(const Unit *unit) -> double {
|
||||
// TODO: make this depend on the value of the targets
|
||||
return kArcheryPossibleValue;
|
||||
}
|
||||
@@ -116,7 +113,7 @@ auto reduceValue(const Unit *unit, const Terrain *unitTerrain) -> double {
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
auto fearValue(const Unit * /*unit*/) -> double {
|
||||
auto fearValue(const Unit *unit) -> double {
|
||||
// TODO: make this depend on the value of the targets
|
||||
return kFearPossibleValue;
|
||||
}
|
||||
@@ -337,8 +334,7 @@ auto UnitValue(
|
||||
const AttackLocations &locationsThisSideCanAttackFrom,
|
||||
const CoordsSet &locationsInDangerFromEnemy,
|
||||
const ActionPointDistances *distances,
|
||||
int meteorRange,
|
||||
double meteorCastVigorCost) -> ScoreValue {
|
||||
const SettingsGetter &settings) -> ScoreValue {
|
||||
const auto &location = unit->location();
|
||||
if (location.row() < 0) return 0; // unplaced unit
|
||||
|
||||
@@ -346,8 +342,7 @@ auto UnitValue(
|
||||
unit->battalion().type() == net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD;
|
||||
|
||||
const int coordsIndex = location.row() * map->column_count() + location.column();
|
||||
const auto *terrain = map->terrain()->Get(coordsIndex);
|
||||
|
||||
const auto &terrain = map->terrain()->Get(coordsIndex);
|
||||
double castleMultiplier = 1.0;
|
||||
// Only give a multiplier for being in a castle if the castle is useful, and the unit is not
|
||||
// undead
|
||||
@@ -357,12 +352,14 @@ auto UnitValue(
|
||||
kCastleMultiplierBonus * (terrain->modifier().castle().integrity() + 25) / 100.0;
|
||||
}
|
||||
double onFireMultiplier = 1.0;
|
||||
if (terrain->modifier().fire().present()) { onFireMultiplier *= kOnFireMultiplier; }
|
||||
if (terrain->modifier().fire().present() && (isAttacker || attackerWantsCastles)) {
|
||||
onFireMultiplier *= kOnFireMultiplier;
|
||||
}
|
||||
{
|
||||
for (const auto adjacentCoords = HexMapUtils::GetAdjacentCoords(map, location);
|
||||
const auto &c : adjacentCoords) {
|
||||
if (const auto *adjTerrain = GetTerrain(map, c);
|
||||
adjTerrain && adjTerrain->modifier().fire().present()) {
|
||||
if (const auto &adjTerrain = GetTerrain(map, c);
|
||||
adjTerrain->modifier().fire().present()) {
|
||||
onFireMultiplier *= kAdjacentFireMultiplier;
|
||||
}
|
||||
}
|
||||
@@ -381,8 +378,8 @@ auto UnitValue(
|
||||
roundsRemaining,
|
||||
attackerUnits,
|
||||
defenderUnits,
|
||||
meteorRange,
|
||||
meteorCastVigorCost);
|
||||
settings.Backing().meteor_range(),
|
||||
settings.Backing().meteor_cast_vigor_cost());
|
||||
|
||||
// scouting values
|
||||
// attack range
|
||||
@@ -417,7 +414,7 @@ auto UnitValue(
|
||||
if (const auto commandingUnitId = unit->commanding_unit_id(); commandingUnitId != -1) {
|
||||
const Unit *commandingUnit = nullptr;
|
||||
for (const Unit *attackerUnit : attackerUnits) {
|
||||
if (attackerUnit && attackerUnit->unit_id() == commandingUnitId) {
|
||||
if (attackerUnit->unit_id() == commandingUnitId) {
|
||||
commandingUnit = attackerUnit;
|
||||
break;
|
||||
}
|
||||
@@ -425,7 +422,7 @@ auto UnitValue(
|
||||
|
||||
if (commandingUnit == nullptr) {
|
||||
for (const Unit *defenderUnit : defenderUnits) {
|
||||
if (defenderUnit && defenderUnit->unit_id() == commandingUnitId) {
|
||||
if (defenderUnit->unit_id() == commandingUnitId) {
|
||||
commandingUnit = defenderUnit;
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -46,8 +46,7 @@ auto UnitValue(
|
||||
const AttackLocations &locationsThisSideCanAttackFrom,
|
||||
const CoordsSet &locationsInDangerFromEnemy,
|
||||
const ActionPointDistances *distances,
|
||||
int meteorRange,
|
||||
double meteorCastVigorCost) -> ScoreValue;
|
||||
const SettingsGetter &settings) -> ScoreValue;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
|
||||
+36
-36
@@ -4,12 +4,10 @@
|
||||
|
||||
#include "AIVictoryConditionScoreCalculator.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <ranges>
|
||||
|
||||
#include "AIAttackLocations.hpp"
|
||||
#include "AIDistanceDebuf.hpp"
|
||||
#include "src/main/cpp/net/eagle0/common/ContainerUtils.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackGroups.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIDistanceDebuf.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/victory_condition.hpp"
|
||||
|
||||
@@ -43,8 +41,8 @@ auto AttackerDebufForOnFireCriticalTile(
|
||||
const vector<const Unit*>& extinguishingUnits,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter& settings,
|
||||
const int braveWaterActionPointCost,
|
||||
const bool lateGame) -> double {
|
||||
double minDebuf = 99999.9;
|
||||
|
||||
@@ -60,8 +58,8 @@ auto AttackerDebufForOnFireCriticalTile(
|
||||
extinguishingUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
lateGame,
|
||||
/* includeUndead = */ false);
|
||||
if (newDebuf < minDebuf) minDebuf = newDebuf;
|
||||
@@ -77,8 +75,8 @@ auto AttackerDebufForUnoccupiedCriticalTile(
|
||||
const vector<const Unit*>& claimableUnits,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter& settings,
|
||||
const int braveWaterActionPointCost,
|
||||
const bool lateGame) -> double {
|
||||
return UNHELD_VALUE * DefenderDistanceBuf(
|
||||
criticalTileLocation,
|
||||
@@ -87,8 +85,8 @@ auto AttackerDebufForUnoccupiedCriticalTile(
|
||||
claimableUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
lateGame,
|
||||
/* includeUndead = */ false);
|
||||
}
|
||||
@@ -100,8 +98,8 @@ auto AttackerDebufForDefenderOccupiedCriticalTile(
|
||||
const vector<const Unit*>& attackerUnits,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost,
|
||||
const SettingsGetter& settings,
|
||||
const int braveWaterActionPointCost,
|
||||
const bool lateGame) {
|
||||
const double baseUnitValue =
|
||||
defenderUnit->battalion().size() +
|
||||
@@ -117,16 +115,19 @@ auto AttackerDebufForDefenderOccupiedCriticalTile(
|
||||
attackerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
lateGame,
|
||||
/* includeUndead = */ false);
|
||||
}
|
||||
|
||||
auto DefenderHoldsCriticalTilesVictoryScore(
|
||||
const GameStateW& gameState,
|
||||
const net::eagle0::shardok::storage::fb::GameState* gameState,
|
||||
const CoordsSet& criticalTileLocations,
|
||||
const PlayerInfo* player) -> ScoreValue {
|
||||
const PlayerInfo* player,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const SettingsGetter& settings) -> ScoreValue {
|
||||
ScoreValue total = 0.0;
|
||||
|
||||
const auto rc = gameState->hex_map()->row_count();
|
||||
@@ -151,13 +152,12 @@ auto DefenderHoldsCriticalTilesVictoryScore(
|
||||
}
|
||||
|
||||
auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
const GameStateW& gameState,
|
||||
const net::eagle0::shardok::storage::fb::GameState* gameState,
|
||||
const CoordsSet& criticalTileLocations,
|
||||
const PlayerInfo* player,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> ScoreValue {
|
||||
const SettingsGetter& settings) -> ScoreValue {
|
||||
vector<const Unit*> playerUnits{};
|
||||
vector<const Unit*> claimablePlayerUnits{};
|
||||
for (const Unit* unit : *gameState->units()) {
|
||||
@@ -173,6 +173,7 @@ auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
return criticalTileLocations.size() * MAX_DEFENDER_HELD_VALUE;
|
||||
}
|
||||
|
||||
const int braveWaterActionPointCost = settings.Backing().brave_water_action_point_cost();
|
||||
const MapId mapId = apdCache->GetMapId(gameState->hex_map());
|
||||
|
||||
ScoreValue total = 0.0;
|
||||
@@ -199,8 +200,8 @@ auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
claimablePlayerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
IsLateGame(gameState));
|
||||
total += BADLY_HELD_VALUE;
|
||||
}
|
||||
@@ -212,8 +213,8 @@ auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
playerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
IsLateGame(gameState));
|
||||
}
|
||||
} else if (terrain->modifier().fire().present()) {
|
||||
@@ -224,8 +225,8 @@ auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
claimablePlayerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
IsLateGame(gameState));
|
||||
} else {
|
||||
total -= AttackerDebufForUnoccupiedCriticalTile(
|
||||
@@ -235,8 +236,8 @@ auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
claimablePlayerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
braveWaterActionPointCost,
|
||||
IsLateGame(gameState));
|
||||
}
|
||||
}
|
||||
@@ -245,13 +246,12 @@ auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
}
|
||||
|
||||
auto LastPlayerStandingVictoryScore(
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
const PlayerInfo* player,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> ScoreValue {
|
||||
if (!std::ranges::contains(
|
||||
const SettingsGetter& settings) -> ScoreValue {
|
||||
if (!common::Contains(
|
||||
*player->victory_conditions(),
|
||||
net::eagle0::shardok::storage::fb::
|
||||
VictoryCondition_VICTORY_CONDITION_LAST_PLAYER_STANDING)) {
|
||||
@@ -283,8 +283,8 @@ auto LastPlayerStandingVictoryScore(
|
||||
playerUnits,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settings,
|
||||
5,
|
||||
IsLateGame(gameState),
|
||||
/* includeUndead = */ true);
|
||||
}
|
||||
+11
-12
@@ -9,8 +9,6 @@
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackGroups.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.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"
|
||||
@@ -25,26 +23,27 @@ using std::vector;
|
||||
using ScoreValue = double;
|
||||
|
||||
auto AttackerHoldsCriticalTilesVictoryScore(
|
||||
const GameStateW& gameState,
|
||||
const net::eagle0::shardok::storage::fb::GameState* gameState,
|
||||
const CoordsSet& criticalTileLocations,
|
||||
const PlayerInfo* player,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> ScoreValue;
|
||||
const SettingsGetter& settings) -> ScoreValue;
|
||||
|
||||
auto DefenderHoldsCriticalTilesVictoryScore(
|
||||
const GameStateW& gameState,
|
||||
const net::eagle0::shardok::storage::fb::GameState* gameState,
|
||||
const CoordsSet& criticalTileLocations,
|
||||
const PlayerInfo* player) -> ScoreValue;
|
||||
|
||||
auto LastPlayerStandingVictoryScore(
|
||||
const GameStateW& gameState,
|
||||
const PlayerInfo* player,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
ActionPoints braveWaterCost) -> ScoreValue;
|
||||
const SettingsGetter& settings) -> ScoreValue;
|
||||
|
||||
auto LastPlayerStandingVictoryScore(
|
||||
const GameState* gameState,
|
||||
const PlayerInfo* player,
|
||||
const APDCache& apdCache,
|
||||
const ALCache& alCache,
|
||||
const SettingsGetter& settings) -> ScoreValue;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -11,11 +11,11 @@
|
||||
namespace shardok {
|
||||
|
||||
auto UnitIdsRequiringWaterCrossing(
|
||||
const GameStateW &gameState,
|
||||
const GameState *gameState,
|
||||
const PlayerId pid,
|
||||
const CoordsSet &destinations,
|
||||
const APDCache &apdCache,
|
||||
const BattalionTypeGetter &battalionTypeGetter) -> vector<UnitId> {
|
||||
const SettingsGetter &settings) -> 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++) {
|
||||
@@ -36,7 +36,7 @@ auto UnitIdsRequiringWaterCrossing(
|
||||
for (const auto *unit : *gameState->units()) {
|
||||
if (unit->player_id() != pid) continue;
|
||||
|
||||
const auto &battType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto &battType = settings.GetBattalionType(unit->battalion().type());
|
||||
|
||||
if (unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT) {
|
||||
for (const Coords &destination : destinations) {
|
||||
@@ -74,9 +74,10 @@ auto UnitIdsRequiringWaterCrossing(
|
||||
}
|
||||
|
||||
auto UnitIdsToCreateWaterCrossing(
|
||||
const GameStateW &gameState,
|
||||
const GameState *gameState,
|
||||
const PlayerId pid,
|
||||
const BattalionTypeGetter &battalionTypeGetter) -> vector<UnitId> {
|
||||
const APDCache &apdCache,
|
||||
const SettingsGetter &settings) -> vector<UnitId> {
|
||||
vector<UnitId> unitIds{};
|
||||
|
||||
for (const auto *unit : *gameState->units()) {
|
||||
@@ -87,7 +88,7 @@ auto UnitIdsToCreateWaterCrossing(
|
||||
if (!unit->has_attached_hero()) continue;
|
||||
|
||||
const auto profession = unit->attached_hero().profession_info().profession();
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto &battalionType = settings.GetBattalionType(unit->battalion().type());
|
||||
|
||||
if (profession == net::eagle0::shardok::storage::fb::Profession_ENGINEER ||
|
||||
(profession == net::eagle0::shardok::storage::fb::Profession_MAGE &&
|
||||
@@ -195,17 +196,17 @@ auto WaterCrossingTiles(
|
||||
|
||||
// Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
|
||||
auto IntendedCrossingStarts(
|
||||
const GameStateW &gameState,
|
||||
const GameState *gameState,
|
||||
const vector<UnitId> &unitIdsCreatingCrossing,
|
||||
const CoordsSet &tilesToStartCrossingFrom,
|
||||
const MapId &mapId,
|
||||
const APDCache &apdCache,
|
||||
const BattalionTypeGetter &battalionTypeGetter) -> CoordsSet {
|
||||
const SettingsGetter &settings) -> CoordsSet {
|
||||
CoordsSet intendedCrossingStarts(gameState->hex_map());
|
||||
const MapId mapId = apdCache->GetMapId(gameState->hex_map());
|
||||
for (const UnitId uid : unitIdsCreatingCrossing) {
|
||||
const Unit *unit = gameState->units()->Get(uid);
|
||||
const Coords &location = unit->location();
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto &battalionType = settings.GetBattalionType(unit->battalion().type());
|
||||
const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
|
||||
|
||||
if (location.row() >= 0) {
|
||||
@@ -218,111 +219,4 @@ auto IntendedCrossingStarts(
|
||||
return 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,
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
const GameStateW &gameState,
|
||||
const CoordsSet &castleCoords,
|
||||
const CoordsSet &startCrossingFrom,
|
||||
const APDCache &apdCache) -> double {
|
||||
uint32_t castleClaimCount = 0;
|
||||
for (const auto *unit : *gameState->units()) {
|
||||
if (unit->player_id() != playerId) continue;
|
||||
const auto status = unit->status();
|
||||
if (status != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
|
||||
status != net::eagle0::shardok::storage::fb::UnitStatus_RESERVE_UNIT)
|
||||
continue;
|
||||
if (!unit->has_attached_hero()) continue;
|
||||
|
||||
++castleClaimCount;
|
||||
}
|
||||
|
||||
CoordsSet destinations = castleCoords;
|
||||
if (castleClaimCount < castleCoords.size()) {
|
||||
destinations = CoordsSet(gameState->hex_map());
|
||||
for (const auto *enemyUnit : *gameState->units()) {
|
||||
if (enemyUnit->player_id() == playerId) continue;
|
||||
const auto status = enemyUnit->status();
|
||||
if (status != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT) continue;
|
||||
AssertValid(enemyUnit->location(), gameState->hex_map());
|
||||
destinations.Add(enemyUnit->location());
|
||||
}
|
||||
}
|
||||
|
||||
const auto unitIdsRequiringCrossing = UnitIdsRequiringWaterCrossing(
|
||||
gameState,
|
||||
playerId,
|
||||
castleCoords,
|
||||
apdCache,
|
||||
battalionTypeGetter);
|
||||
if (unitIdsRequiringCrossing.empty()) return kNoRequiredCrossingScore;
|
||||
|
||||
const auto unitIdsCreatingCrossing =
|
||||
UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
|
||||
if (unitIdsCreatingCrossing.empty()) return kNoCrossingCreatorsScore;
|
||||
|
||||
double totalScore = 0;
|
||||
|
||||
const auto mapId = ActionPointDistancesCache::GetMapId(gameState->hex_map());
|
||||
|
||||
// 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);
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
Coords location = unit->location();
|
||||
|
||||
int thisDistance;
|
||||
if (location.row() < 0) thisDistance = 1000;
|
||||
else {
|
||||
const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
|
||||
|
||||
thisDistance = MinimumDistance(apd, location, startCrossingFrom);
|
||||
}
|
||||
|
||||
totalScore -= thisDistance * 100.0;
|
||||
}
|
||||
|
||||
// Now a smaller penalty for distance for units that need to cross, except if they block -- then
|
||||
// a large penalty
|
||||
for (const UnitId uid : unitIdsRequiringCrossing) {
|
||||
// If this unit ID can also create a crossing, we already handled it
|
||||
if (std::ranges::contains(unitIdsCreatingCrossing, uid)) continue;
|
||||
|
||||
const Unit *unit = gameState->units()->Get(uid);
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
Coords location = unit->location();
|
||||
const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
|
||||
|
||||
int thisDistance;
|
||||
if (location.row() < 0) thisDistance = 1000;
|
||||
else { thisDistance = MinimumDistance(apd, location, startCrossingFrom); }
|
||||
|
||||
bool targetBlocks = false;
|
||||
// If we're not capable of creating a crossing, don't get in the way of somebody that is.
|
||||
for (const UnitId crossingUid : unitIdsCreatingCrossing) {
|
||||
const auto *crossingCapableUnit = gameState->units()->Get(crossingUid);
|
||||
|
||||
// Don't check for units that aren't yet placed
|
||||
if (crossingCapableUnit->location().row() < 0) continue;
|
||||
AssertValid(crossingCapableUnit->location(), gameState->hex_map());
|
||||
|
||||
if (thisDistance <
|
||||
MinimumDistance(apd, crossingCapableUnit->location(), startCrossingFrom)) {
|
||||
targetBlocks = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (targetBlocks) continue;
|
||||
|
||||
totalScore -= thisDistance;
|
||||
}
|
||||
|
||||
return totalScore;
|
||||
}
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -5,8 +5,6 @@
|
||||
#ifndef EAGLE0_AIWATERCROSSINGCALCULATOR_HPP
|
||||
#define EAGLE0_AIWATERCROSSINGCALCULATOR_HPP
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.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"
|
||||
@@ -31,17 +29,18 @@ 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(
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
PlayerId pid,
|
||||
const CoordsSet& destinations,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;
|
||||
const SettingsGetter& settings) -> vector<UnitId>;
|
||||
|
||||
// Units belonging to the player that are capable of creating water crossings
|
||||
auto UnitIdsToCreateWaterCrossing(
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
PlayerId pid,
|
||||
const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;
|
||||
const APDCache& apdCache,
|
||||
const SettingsGetter& settings) -> vector<UnitId>;
|
||||
|
||||
// Whether a unit of the given type can reach destination from origin, given the current state
|
||||
// of the map
|
||||
@@ -68,20 +67,12 @@ auto WaterCrossingTiles(
|
||||
|
||||
// Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
|
||||
auto IntendedCrossingStarts(
|
||||
const GameStateW& gameState,
|
||||
const GameState* gameState,
|
||||
const vector<UnitId>& unitIdsCreatingCrossing,
|
||||
const CoordsSet& tilesToStartCrossingFrom,
|
||||
const MapId& mapId,
|
||||
const APDCache& apdCache,
|
||||
const BattalionTypeGetter& battalionTypeGetter) -> CoordsSet;
|
||||
|
||||
// Calculate score based on water crossing strategy
|
||||
auto WaterCrossingScore(
|
||||
PlayerId playerId,
|
||||
const BattalionTypeGetter& battalionTypeGetter,
|
||||
const GameStateW& gameState,
|
||||
const CoordsSet& castleCoords,
|
||||
const CoordsSet& startCrossingFrom,
|
||||
const APDCache& apdCache) -> double;
|
||||
const SettingsGetter& settings) -> CoordsSet;
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
|
||||
@@ -4,10 +4,8 @@
|
||||
|
||||
#include "AIWaterCrossingCommandChooser.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <ranges>
|
||||
|
||||
#include "AIMinimumDistanceAndTarget.hpp"
|
||||
#include "src/main/cpp/net/eagle0/common/ContainerUtils.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCalculator.hpp"
|
||||
|
||||
namespace shardok {
|
||||
@@ -18,11 +16,11 @@ constexpr ScoreValue kNoRequiredCrossingScore = std::numeric_limits<ScoreValue>:
|
||||
constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>::min();
|
||||
|
||||
[[nodiscard]] auto AIWaterCrossingCommandChooser::WaterCrossingScore(
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
const GameStateW &gameState,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const GameState *gameState,
|
||||
const CoordsSet &castleCoords,
|
||||
const CoordsSet &startCrossingFrom) const -> ScoreValue {
|
||||
uint32_t castleClaimCount = 0;
|
||||
int castleClaimCount = 0;
|
||||
for (const auto *unit : *gameState->units()) {
|
||||
if (unit->player_id() != playerId) continue;
|
||||
const auto status = unit->status();
|
||||
@@ -51,13 +49,15 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:
|
||||
playerId,
|
||||
castleCoords,
|
||||
apdCache,
|
||||
battalionTypeGetter);
|
||||
settingsGetter);
|
||||
if (unitIdsRequiringCrossing.empty()) return kNoRequiredCrossingScore;
|
||||
|
||||
const auto unitIdsCreatingCrossing =
|
||||
UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
|
||||
UnitIdsToCreateWaterCrossing(gameState, playerId, apdCache, settingsGetter);
|
||||
if (unitIdsCreatingCrossing.empty()) return kNoCrossingCreatorsScore;
|
||||
|
||||
fprintf(stderr, "%lu units require a water crossing\n", unitIdsRequiringCrossing.size());
|
||||
|
||||
ScoreValue totalScore = 0;
|
||||
|
||||
const auto mapId = ActionPointDistancesCache::GetMapId(gameState->hex_map());
|
||||
@@ -65,7 +65,7 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:
|
||||
// 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);
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto &battalionType = settingsGetter.GetBattalionType(unit->battalion().type());
|
||||
Coords location = unit->location();
|
||||
|
||||
int thisDistance;
|
||||
@@ -83,10 +83,10 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:
|
||||
// a large penalty
|
||||
for (const UnitId uid : unitIdsRequiringCrossing) {
|
||||
// If this unit ID can also create a crossing, we already handled it
|
||||
if (std::ranges::contains(unitIdsCreatingCrossing, uid)) continue;
|
||||
if (common::Contains(unitIdsCreatingCrossing, uid)) continue;
|
||||
|
||||
const Unit *unit = gameState->units()->Get(uid);
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto &battalionType = settingsGetter.GetBattalionType(unit->battalion().type());
|
||||
Coords location = unit->location();
|
||||
const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
|
||||
|
||||
@@ -118,12 +118,12 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:
|
||||
}
|
||||
|
||||
auto AIWaterCrossingCommandChooser::StartCrossingFrom(
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
const GameStateW &gameState,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const GameState *gameState,
|
||||
const CoordsSet &castleCoords) const -> CoordsSet {
|
||||
CoordsSet startCrossingFrom(gameState->hex_map());
|
||||
|
||||
uint32_t castleClaimCount = 0;
|
||||
int castleClaimCount = 0;
|
||||
for (const auto *unit : *gameState->units()) {
|
||||
if (unit->player_id() != playerId) continue;
|
||||
const auto status = unit->status();
|
||||
@@ -152,16 +152,16 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
|
||||
playerId,
|
||||
castleCoords,
|
||||
apdCache,
|
||||
battalionTypeGetter);
|
||||
settingsGetter);
|
||||
if (unitIdsRequiringCrossing.empty()) return startCrossingFrom;
|
||||
|
||||
const auto unitIdsCreatingCrossing =
|
||||
UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
|
||||
UnitIdsToCreateWaterCrossing(gameState, playerId, apdCache, settingsGetter);
|
||||
if (unitIdsCreatingCrossing.empty()) return startCrossingFrom;
|
||||
|
||||
for (const UnitId uid : unitIdsRequiringCrossing) {
|
||||
const Unit *unit = gameState->units()->Get(uid);
|
||||
const auto &battalionType = battalionTypeGetter(unit->battalion().type());
|
||||
const auto &battalionType = settingsGetter.GetBattalionType(unit->battalion().type());
|
||||
Coords origin = unit->location();
|
||||
|
||||
// FIXME: this is just grabbing the first starting position, ideally we'd try them all
|
||||
|
||||
@@ -6,16 +6,18 @@
|
||||
#define EAGLE0_AIWATERCROSSINGCOMMANDCHOOSER_HPP
|
||||
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AICommonTypes.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/fb_helpers/FlatbufferWrapper.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
|
||||
#include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/command_descriptor.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
using GameState = net::eagle0::shardok::storage::fb::GameState;
|
||||
using Unit = net::eagle0::shardok::storage::fb::Unit;
|
||||
using ScoreValue = double;
|
||||
@@ -30,14 +32,14 @@ public:
|
||||
: playerId(pid),
|
||||
apdCache(std::move(apdCache)) {}
|
||||
|
||||
[[nodiscard]] auto StartCrossingFrom(
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
const GameStateW &gameState,
|
||||
auto StartCrossingFrom(
|
||||
const SettingsGetter &settingsGetter,
|
||||
const GameState *gameState,
|
||||
const CoordsSet &castleCoords) const -> CoordsSet;
|
||||
|
||||
[[nodiscard]] auto WaterCrossingScore(
|
||||
const BattalionTypeGetter &battalionTypeGetter,
|
||||
const GameStateW &gameState,
|
||||
const SettingsGetter &settingsGetter,
|
||||
const GameState *gameState,
|
||||
const CoordsSet &castleCoords,
|
||||
const CoordsSet &startCrossingFrom) const -> ScoreValue;
|
||||
};
|
||||
|
||||
@@ -210,556 +210,4 @@ Where:
|
||||
- **Magnitude**: Indicates confidence/importance of the evaluation
|
||||
- **Relative scoring**: Only score differences matter, not absolute values
|
||||
|
||||
This scoring system provides a robust framework for tactical AI decision-making, balancing immediate tactical gains with strategic objectives while handling the uncertainty inherent in combat outcomes.
|
||||
|
||||
## AIScoreCalculator Function Reference
|
||||
|
||||
### Public Interface Functions
|
||||
|
||||
#### `GuessedStateScore`
|
||||
**Purpose**: Evaluates the score of a game state from the perspective of the current AI strategy without performing any commands.
|
||||
|
||||
**Parameters**:
|
||||
- `isDefender`: Whether the AI is playing as defender
|
||||
- `state`: Current game state to evaluate
|
||||
- `aiStrategy`: Strategy being used (attack castles, hold castles, scatter, etc.)
|
||||
- `allCastleCoords`: Set of all castle coordinates on the map
|
||||
- `settingsGetter`: Game configuration and rules
|
||||
- `apdCache`: Cached action point distances for movement calculations
|
||||
- `alCache`: Cached attack locations for combat calculations
|
||||
|
||||
**Returns**: Score value representing how favorable the state is for the evaluating player (positive = good, negative = bad)
|
||||
|
||||
#### `CommandScore`
|
||||
**Purpose**: Evaluates the score for a specific command using lookahead search to consider future consequences.
|
||||
|
||||
**Parameters**:
|
||||
- `pid`: Player ID executing the command
|
||||
- `isDefender`: Whether the player is a defender
|
||||
- `remainingLookahead`: Depth of recursive search remaining
|
||||
- `maxRepeatCount`: Number of random simulations for non-deterministic commands
|
||||
- `guessedEngine`: Current game engine state
|
||||
- `attackerStrategy`: Strategy being used by attackers
|
||||
- `currentUtility`: Current game state score before command execution
|
||||
- `settingsGetter`: Game configuration
|
||||
- `allCastleCoords`: Castle locations
|
||||
- `apdCache` & `alCache`: Cached distance/attack calculations
|
||||
- `commandIndex`: Index of command to evaluate
|
||||
- `deadline`: Time limit for computation
|
||||
|
||||
**Returns**: Future containing the final score after lookahead evaluation
|
||||
|
||||
### Internal Core Functions
|
||||
|
||||
#### `BuildDecisionTree` (NEW)
|
||||
**Purpose**: Builds a complete decision tree containing all evaluated command paths up to the specified depth.
|
||||
|
||||
**Process**:
|
||||
1. Filters commands using `AICommandFilter` to reduce search space
|
||||
2. For each command, calls `ExecuteCommandForTree` to build complete subtrees
|
||||
3. Returns full tree with all possible moves and their consequences
|
||||
4. Identifies best command within the complete tree structure
|
||||
|
||||
**Returns**: `std::future<CommandDecisionTree>` containing the complete decision tree
|
||||
|
||||
#### `BestCommandIndex` (Legacy - Wrapper)
|
||||
**Purpose**: Backward compatibility wrapper that uses `BuildDecisionTree` but returns traditional `IndexAndScore`.
|
||||
|
||||
**Process**:
|
||||
1. Calls `BuildDecisionTree` to get complete tree
|
||||
2. Extracts best command information for compatibility
|
||||
3. Returns only the optimal command details in legacy format
|
||||
|
||||
#### `ExecuteCommandForTree` (NEW)
|
||||
**Purpose**: Executes a command and creates a tree node with the resulting game state and scores.
|
||||
|
||||
**Process**:
|
||||
1. Creates engine copy and executes the command with given random seed
|
||||
2. Creates `CommandTreeNode` with command results and game state
|
||||
3. Calculates immediate score using `GuessedStateScore`
|
||||
4. Calls `RecursiveTreeBuilder` to populate child nodes if depth allows
|
||||
5. Calculates lookahead score from children (or uses immediate score)
|
||||
|
||||
**Returns**: `std::unique_ptr<CommandTreeNode>` containing the command execution results and subtree
|
||||
|
||||
#### `RecursiveTreeBuilder` (NEW)
|
||||
**Purpose**: Recursively populates child nodes of a tree node by building subtrees for subsequent moves.
|
||||
|
||||
**Process**:
|
||||
1. Gets available commands for the next player
|
||||
2. Filters commands to reduce search space
|
||||
3. For each command, calls `ExecuteCommandForTree` to create child nodes
|
||||
4. Handles different command types (deterministic, odds-based, random)
|
||||
5. Populates the parent node's children vector with complete subtrees
|
||||
|
||||
#### `CalcOne` (Legacy)
|
||||
**Purpose**: Executes a single command simulation with specified randomness and returns both immediate and lookahead scores.
|
||||
|
||||
**Process**:
|
||||
1. Creates engine copy and executes the command with given random seed
|
||||
2. Calculates immediate score using `GuessedStateScore`
|
||||
3. Initiates recursive lookahead calculation if depth remains
|
||||
4. Handles timeouts gracefully by returning default scores
|
||||
|
||||
#### `EvaluateCommand`
|
||||
**Purpose**: Lower-level command evaluation that handles different command types appropriately.
|
||||
|
||||
**Command Type Handling**:
|
||||
- **Deterministic**: Single evaluation with average randomness (0.5)
|
||||
- **Odds-based**: Two evaluations (success/failure) weighted by success probability
|
||||
- **Non-deterministic**: Multiple evaluations with distributed random values, averaged
|
||||
|
||||
#### `BasicLookaheadCalculator`
|
||||
**Purpose**: Recursive lookahead search that finds the best future command sequence and propagates scores backward.
|
||||
|
||||
**Features**:
|
||||
- Uses transposition table to cache previously computed positions
|
||||
- Handles depth limits and terminal states
|
||||
- Returns futures for asynchronous computation
|
||||
- Stores results in transposition table for reuse
|
||||
|
||||
### Strategy-Specific Scoring Functions
|
||||
|
||||
#### `AttackerScoreForState`
|
||||
**Purpose**: Calculates state score from attacker perspective based on strategy type.
|
||||
|
||||
**Strategy Support**:
|
||||
- `STRATEGY_ATTACK_CASTLES`: Prioritizes capturing castle positions
|
||||
- `STRATEGY_ATTACK_UNITS`: Focuses on eliminating defender units
|
||||
- `STRATEGY_HOLD_CASTLES`: Maintains control of captured castles
|
||||
- `STRATEGY_CROSS_RIVERS`: Special water crossing objectives
|
||||
- `STRATEGY_FLEE`: Escape-focused scoring
|
||||
|
||||
#### `DefenderScoreForState`
|
||||
**Purpose**: Calculates state score from defender perspective.
|
||||
|
||||
**Strategy Support**:
|
||||
- `STRATEGY_HOLD_CASTLES`: Defend critical castle positions
|
||||
- `STRATEGY_SCATTER`: Spread units to avoid elimination
|
||||
- `STRATEGY_FLEE`: Escape-focused scoring
|
||||
|
||||
#### `AttackerUnitsScore`
|
||||
**Purpose**: Core unit valuation function that calculates total value of all units on the board with contextual modifiers.
|
||||
|
||||
**Features**:
|
||||
- Uses `UnitValue` for individual unit calculations
|
||||
- Applies distance multipliers based on proximity to objectives
|
||||
- Handles special cases like undead, VIP units, and scattered defenders
|
||||
- Incorporates castle bonuses and environmental penalties
|
||||
|
||||
### Specialized Strategy Functions
|
||||
|
||||
#### `DefenderScatterStrategyScoreForState`
|
||||
**Purpose**: Implements scatter strategy scoring that rewards defensive units for staying far from enemies and friendlies.
|
||||
|
||||
#### `DefenderHoldCastlesStrategyScoreForState`
|
||||
**Purpose**: Implements castle defense strategy with victory condition scoring.
|
||||
|
||||
#### `FleeStrategyScoreForState`
|
||||
**Purpose**: Implements flee strategy that heavily penalizes remaining on the battlefield.
|
||||
|
||||
### Utility Functions
|
||||
|
||||
#### `AttackerMultiplierForTargetDistance`
|
||||
**Purpose**: Calculates distance-based scoring multipliers for attackers based on proximity to priority targets.
|
||||
|
||||
**Features**:
|
||||
- Uses recursive priority list evaluation
|
||||
- Accounts for occupied vs. unoccupied targets
|
||||
- Incorporates brave water crossing capabilities
|
||||
- Uses cached action point distances for efficiency
|
||||
|
||||
#### `CommandSorter`
|
||||
**Purpose**: Comparison function for ranking commands by lookahead score (primary) and immediate score (tiebreaker).
|
||||
|
||||
#### `IsDeterministic`
|
||||
**Purpose**: Determines if a command type has predictable outcomes or requires random simulation.
|
||||
|
||||
### Performance and Caching
|
||||
|
||||
#### `EffectiveDistanceCache`
|
||||
**Purpose**: Memoization cache for expensive distance calculations between units and targets.
|
||||
|
||||
#### `AttackerScorePerformanceLogger`
|
||||
**Purpose**: Performance monitoring system that tracks call frequency and timing for `AttackerScoreForState`.
|
||||
|
||||
The function architecture supports parallel evaluation, caching, and recursive lookahead while maintaining separation between strategy-specific logic and core evaluation mechanics.
|
||||
|
||||
## Decision Tree Data Structures (NEW)
|
||||
|
||||
### CommandTreeNode
|
||||
**Purpose**: Represents a single command execution and its consequences in the decision tree.
|
||||
|
||||
**Key Fields**:
|
||||
- `commandIndex`: Index of the command in the original command list
|
||||
- `commandType`: Type of command (MOVE, MELEE, END_TURN, etc.)
|
||||
- `immediateScore`: Score of the game state immediately after this command
|
||||
- `lookaheadScore`: Best achievable score considering future moves
|
||||
- `resultingGameState`: Game state after command execution
|
||||
- `children`: Vector of child nodes representing subsequent possible moves
|
||||
- `playerId`, `depth`, `isDefender`: Metadata about the command context
|
||||
|
||||
**Features**:
|
||||
- Stores complete game state for each decision point
|
||||
- Maintains parent-child relationships for tree traversal
|
||||
- Supports both immediate and lookahead scoring
|
||||
- Contains metadata for debugging and analysis
|
||||
|
||||
### CommandDecisionTree
|
||||
**Purpose**: Complete decision tree containing all evaluated command paths from a given position.
|
||||
|
||||
**Key Fields**:
|
||||
- `rootNodes`: All possible first moves from the starting position
|
||||
- `bestCommand`: Pointer to the optimal root command
|
||||
- `maxDepth`: Maximum lookahead depth of the tree
|
||||
- `totalNodes`: Total number of nodes in the tree (for statistics)
|
||||
|
||||
**Features**:
|
||||
- Provides complete visibility into AI decision-making process
|
||||
- Enables analysis of alternative moves and their consequences
|
||||
- Supports tree statistics and debugging information
|
||||
- Maintains backward compatibility through `GetBestCommandIndex()`
|
||||
|
||||
**Memory Management**:
|
||||
- Uses `std::unique_ptr` for automatic memory cleanup
|
||||
- `GameStateW` objects are stored directly (not shared pointers for simplicity)
|
||||
- Tree structure ensures proper cleanup when nodes go out of scope
|
||||
|
||||
### Tree vs. Legacy Approach Comparison
|
||||
|
||||
| Aspect | Legacy (Single Best) | Tree-Based (Complete) |
|
||||
|--------|---------------------|----------------------|
|
||||
| **Output** | Best command only | Complete decision tree |
|
||||
| **Memory** | Minimal | Higher (stores all paths) |
|
||||
| **Analysis** | Limited visibility | Full decision transparency |
|
||||
| **Debugging** | Single command info | Complete move sequences |
|
||||
| **Performance** | Slightly faster | Comparable (same calculations) |
|
||||
| **Compatibility** | Direct usage | Wrapper maintains compatibility |
|
||||
|
||||
### Usage Patterns
|
||||
|
||||
**For AI Decision Making**:
|
||||
```cpp
|
||||
auto treeFuture = BuildDecisionTree(pid, isDefender, depth, maxRepeat,
|
||||
engine, strategy, utility, settings,
|
||||
castles, apdCache, alCache, deadline);
|
||||
CommandDecisionTree tree = treeFuture.get();
|
||||
size_t bestCommand = tree.bestCommand->commandIndex;
|
||||
```
|
||||
|
||||
**For Analysis and Debugging**:
|
||||
```cpp
|
||||
CommandDecisionTree tree = treeFuture.get();
|
||||
// Examine all possible moves
|
||||
for (const auto& rootNode : tree.rootNodes) {
|
||||
std::cout << "Command " << rootNode->commandIndex
|
||||
<< " Score: " << rootNode->lookaheadScore << std::endl;
|
||||
// Traverse children to see consequences
|
||||
for (const auto& child : rootNode->children) {
|
||||
// ... analyze child moves
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Legacy Compatibility**:
|
||||
```cpp
|
||||
// Existing code continues to work unchanged
|
||||
auto indexScoreFuture = BestCommandIndex(pid, isDefender, ...);
|
||||
IndexAndScore result = indexScoreFuture.get();
|
||||
size_t bestCommand = result.index;
|
||||
```
|
||||
|
||||
The tree-based approach provides complete decision transparency while maintaining full backward compatibility with existing AI code.
|
||||
|
||||
## MCTS Alternative: Randomness Handling Recommendations
|
||||
|
||||
The new MCTS-based AI system is available in `MCTSAI.hpp/.cpp` and provides an alternative to the iterative deepening approach. However, the current MCTS implementation uses simplified randomness handling compared to the sophisticated approach in the original system.
|
||||
|
||||
### Current MCTS Limitations
|
||||
|
||||
1. **Expansion Phase**: Uses average rolls (0.5) for all commands during tree expansion
|
||||
2. **Simulation Phase**: Uses random command selection with average rolls
|
||||
3. **Missing**: No explicit chance nodes for commands with `HasOdds()`
|
||||
4. **Missing**: No multi-sample evaluation for stochastic commands
|
||||
|
||||
### Recommended Improvements: Chance Node Integration
|
||||
|
||||
#### 1. **Explicit Chance Nodes** (Highest Priority)
|
||||
|
||||
For commands with `HasOdds()`, create explicit chance nodes in the MCTS tree:
|
||||
|
||||
```cpp
|
||||
// During MCTSExpansion
|
||||
if (descriptor->HasOdds()) {
|
||||
// Create TWO child nodes: success and failure
|
||||
auto successNode = CreateMCTSNode(commandIndex, SUCCESS_VARIANT);
|
||||
auto failureNode = CreateMCTSNode(commandIndex, FAILURE_VARIANT);
|
||||
|
||||
// Execute with deterministic rolls (matching original system)
|
||||
ExecuteWithRoll(successNode, 1.0 - successChance/2.0); // High roll
|
||||
ExecuteWithRoll(failureNode, (1.0 - successChance)/2.0); // Low roll
|
||||
|
||||
// Set probability weights for selection
|
||||
successNode->probabilityWeight = successChance;
|
||||
failureNode->probabilityWeight = 1.0 - successChance;
|
||||
}
|
||||
```
|
||||
|
||||
#### 2. **Weighted Selection for Chance Nodes**
|
||||
|
||||
Modify `MCTSSelection` to handle chance nodes:
|
||||
|
||||
```cpp
|
||||
if (node->isChanceNode) {
|
||||
// Select based on probability distribution, not UCB1
|
||||
return SelectByProbability(node->children);
|
||||
} else {
|
||||
// Normal UCB1 selection for decision nodes
|
||||
return node->GetBestChild(explorationConstant);
|
||||
}
|
||||
```
|
||||
|
||||
#### 3. **Probability-Weighted Backpropagation**
|
||||
|
||||
Update backpropagation to account for chance node probabilities:
|
||||
|
||||
```cpp
|
||||
void MCTSBackpropagation(MCTSNode* node, double reward) {
|
||||
while (node) {
|
||||
node->visitCount++;
|
||||
|
||||
// Weight reward by probability for chance nodes
|
||||
double weightedReward = reward;
|
||||
if (node->parent && node->parent->isChanceNode) {
|
||||
weightedReward *= node->probabilityWeight;
|
||||
}
|
||||
|
||||
node->totalReward += weightedReward;
|
||||
node->averageReward = node->totalReward / node->visitCount;
|
||||
node = node->parent;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### 4. **Multi-Sample Commands**
|
||||
|
||||
For commands without explicit odds but with randomness, use stratified sampling:
|
||||
|
||||
```cpp
|
||||
// During expansion, create multiple child nodes with different rolls
|
||||
for (int sample = 0; sample < numSamples; ++sample) {
|
||||
double roll = static_cast<double>(sample) / (numSamples - 1);
|
||||
auto sampleNode = CreateMCTSNodeWithRoll(commandIndex, roll);
|
||||
sampleNode->probabilityWeight = 1.0 / numSamples;
|
||||
}
|
||||
```
|
||||
|
||||
### Benefits of Chance Node Integration
|
||||
|
||||
1. **Accurate Evaluation**: Preserves the sophisticated randomness handling from the original system
|
||||
2. **Better Convergence**: MCTS can properly explore both success/failure outcomes
|
||||
3. **Realistic Simulations**: Tree accurately represents game's probability distributions
|
||||
4. **Comparable Results**: Makes MCTS results directly comparable to iterative deepening
|
||||
|
||||
### Implementation Priority
|
||||
|
||||
1. **Phase 1**: Add explicit chance nodes for `HasOdds()` commands
|
||||
2. **Phase 2**: Implement probability-weighted selection and backpropagation
|
||||
3. **Phase 3**: Add multi-sample support for general stochastic commands
|
||||
4. **Phase 4**: Optimize performance with lazy expansion of chance nodes
|
||||
|
||||
### Alternative: Determinization Approach
|
||||
|
||||
If explicit chance nodes prove too complex, consider **determinization**:
|
||||
|
||||
- Run multiple MCTS trees with different fixed random seeds
|
||||
- Aggregate results across all determinizations
|
||||
- Simpler to implement but potentially less accurate than explicit chance nodes
|
||||
|
||||
### Switching Between AI Systems
|
||||
|
||||
Both AI systems (`IterativeDeepeningAI` and `MCTSAI`) implement compatible interfaces. The algorithm is selected at **runtime** via the ShardokAIClient constructor:
|
||||
|
||||
```cpp
|
||||
// Using Iterative Deepening (default)
|
||||
ShardokAIClient client(playerId, isDefender, hexMap, settings);
|
||||
// Or explicitly:
|
||||
ShardokAIClient client(playerId, isDefender, hexMap, settings,
|
||||
AIAlgorithmType::ITERATIVE_DEEPENING);
|
||||
|
||||
// Using MCTS
|
||||
ShardokAIClient client(playerId, isDefender, hexMap, settings,
|
||||
AIAlgorithmType::MCTS);
|
||||
|
||||
// Note: MCTS configuration can be customized via MCTSConfig:
|
||||
// - maxIterations: 10000 (max MCTS iterations per move)
|
||||
// - maxSimulationDepth: 10 (depth for rollout phase)
|
||||
// - maxTreeDepth: 20 (max tree depth to prevent stack overflow)
|
||||
// - explorationConstant: 1.414 (UCB1 exploration vs exploitation)
|
||||
// - useMultithreading: true (APD cache is thread-safe with TLS + mutex protection)
|
||||
// - numThreads: 4
|
||||
```
|
||||
|
||||
The selection is made per AI client instance, allowing different algorithms for different players or game situations within the same server process.
|
||||
|
||||
#### Direct AI Usage (Lower Level)
|
||||
|
||||
Both AI systems can also be used directly:
|
||||
|
||||
```cpp
|
||||
// Using Iterative Deepening directly
|
||||
auto iterativeAI = IterativeDeepeningAI(playerId, isDefender, strategy,
|
||||
castleCoords, apdCache, alCache);
|
||||
auto result = iterativeAI.IterativeSearch(settings, state, commands, budget);
|
||||
|
||||
// Using MCTS directly
|
||||
auto mctsAI = MCTSAI(playerId, isDefender, strategy,
|
||||
castleCoords, apdCache, alCache);
|
||||
auto result = mctsAI.Search(settings, state, commands, budget);
|
||||
```
|
||||
|
||||
#### Algorithm Comparison
|
||||
|
||||
| Feature | Iterative Deepening | MCTS |
|
||||
|---------|-------------------|------|
|
||||
| **Randomness Handling** | Sophisticated (chance nodes, multi-sample) | Simplified (average rolls) |
|
||||
| **Performance** | Single-threaded | Multithreaded |
|
||||
| **Search Type** | Fixed depth with iterative deepening | Adaptive with time budget |
|
||||
| **Memory Usage** | Lower | Higher (maintains tree) |
|
||||
| **Max Tree Depth** | Limited by lookahead setting | Limited by `maxTreeDepth` config (default: 20) |
|
||||
| **Tree Destruction** | Not applicable | Iterative (avoids stack overflow) |
|
||||
| **Best For** | Precise evaluation, production | Performance testing, fast decisions |
|
||||
|
||||
The MCTS implementation provides a solid foundation. Known limitations:
|
||||
1. **Randomness Handling**: Simplified compared to iterative deepening (no explicit chance nodes)
|
||||
2. **Simulation Quality**: Uses random rollouts instead of sophisticated evaluation
|
||||
|
||||
Note: The APD cache is fully thread-safe using thread-local storage and mutex-protected shared cache.
|
||||
|
||||
Adding chance node handling and ensuring thread safety would make it a superior replacement for the iterative deepening approach while maintaining the sophisticated randomness evaluation that makes the current system effective.
|
||||
|
||||
## MCTS Configuration Options
|
||||
|
||||
The MCTS AI system provides extensive configuration through the `MCTSConfig` structure:
|
||||
|
||||
### Core MCTS Parameters
|
||||
|
||||
```cpp
|
||||
struct MCTSConfig {
|
||||
double explorationConstant = 1.414; // UCB1 constant (sqrt(2) by default)
|
||||
int maxSimulationDepth = 1000; // Maximum depth for rollout
|
||||
int maxTreeDepth = 2000; // Maximum tree depth to prevent stack overflow
|
||||
bool useMultithreading = true; // Enable parallel MCTS
|
||||
int numThreads = 16; // Number of threads for parallel MCTS (when enabled)
|
||||
MCTSSimulationPolicy simulationPolicy = MCTSSimulationPolicy::BEST_IMMEDIATE;
|
||||
bool enableTranspositionDetection = true; // Enable pruning of duplicate states
|
||||
double immediateScoreTieBreakThreshold = 5.0; // When avg rewards differ by less than this, prefer higher immediate score
|
||||
double visitCountTolerance = 0.05; // Treat visit counts as equal if within this % of best count
|
||||
bool enableImmediateScoreInUCB1 = true; // Apply immediate score tie-breaking in UCB1 selection too
|
||||
};
|
||||
```
|
||||
|
||||
### Exploration vs Exploitation
|
||||
|
||||
- **`explorationConstant`**: Controls the exploration vs exploitation balance in UCB1 selection
|
||||
- Higher values (>1.414): More exploration of unvisited nodes
|
||||
- Lower values (<1.414): More exploitation of known good moves
|
||||
- Default: 1.414 (√2, theoretical optimum for UCB1)
|
||||
|
||||
### Tree Structure Limits
|
||||
|
||||
- **`maxTreeDepth`**: Prevents stack overflow in deep game trees
|
||||
- Default: 2000 (very high limit for most tactical scenarios)
|
||||
- Terminal detection stops expansion when this depth is reached
|
||||
|
||||
- **`maxSimulationDepth`**: Controls rollout length during simulation phase
|
||||
- Default: 1000 (sufficient for most tactical scenarios)
|
||||
- Longer simulations provide more accurate estimates but use more time
|
||||
|
||||
### Multithreading Configuration
|
||||
|
||||
- **`useMultithreading`**: Enable/disable parallel MCTS execution
|
||||
- Default: true (takes advantage of modern multi-core CPUs)
|
||||
- Requires thread-safe game engine and scoring components
|
||||
|
||||
- **`numThreads`**: Number of worker threads for parallel tree building
|
||||
- Default: 16 (adjust based on available CPU cores)
|
||||
- More threads can improve search speed but with diminishing returns
|
||||
|
||||
### Simulation Policies
|
||||
|
||||
The `MCTSSimulationPolicy` enum controls how commands are selected during the rollout phase:
|
||||
|
||||
- **`RANDOM`**: Pure random selection from all available commands
|
||||
- Fastest but least informed simulations
|
||||
- Good baseline for testing MCTS convergence
|
||||
|
||||
- **`FILTERED_RANDOM`**: Random selection from AICommandFilter-approved commands
|
||||
- Eliminates obviously bad moves (moving away from objectives, etc.)
|
||||
- Better simulation quality with minimal overhead
|
||||
|
||||
- **`BEST_IMMEDIATE`**: Always choose command with highest immediate score
|
||||
- Most informed simulations
|
||||
- Slower but higher quality rollouts
|
||||
- Default setting for production use
|
||||
|
||||
- **`WEIGHTED_BEST_IMMEDIATE`**: Random selection weighted by immediate score ranking
|
||||
- Balances exploration with informed choice
|
||||
- Alternative to pure greedy selection
|
||||
|
||||
### Transposition Detection
|
||||
|
||||
- **`enableTranspositionDetection`**: Enable pruning of duplicate game states
|
||||
- Default: true (improves search efficiency)
|
||||
- Uses hash-based state identification
|
||||
- Prevents wasted computation on equivalent positions reached via different move sequences
|
||||
|
||||
### Immediate Score Tie-Breaking
|
||||
|
||||
These settings address MCTS's tendency to choose indirect paths when direct paths lead to the same outcome:
|
||||
|
||||
- **`immediateScoreTieBreakThreshold`**: Score difference threshold for tie-breaking
|
||||
- Default: 5.0 (when backpropagated rewards differ by less than this, prefer immediate score)
|
||||
- Helps AI choose direct moves over equivalent indirect sequences
|
||||
- Improves user experience by reducing unnecessary intermediate moves
|
||||
|
||||
- **`visitCountTolerance`**: Visit count equality threshold for tie-breaking
|
||||
- Default: 0.05 (5% tolerance - visit counts within this percentage are considered equal)
|
||||
- Prevents minor visit count differences from overriding immediate score preferences
|
||||
|
||||
- **`enableImmediateScoreInUCB1`**: Apply immediate score tie-breaking during exploration
|
||||
- Default: true (consistent tie-breaking in both exploration and final selection)
|
||||
- When UCB1 values are very close, prefer nodes with higher immediate scores
|
||||
- Improves convergence on direct paths to objectives
|
||||
|
||||
### Usage Example
|
||||
|
||||
```cpp
|
||||
// Custom MCTS configuration for performance testing
|
||||
MCTSConfig config;
|
||||
config.explorationConstant = 2.0; // More exploration
|
||||
config.simulationPolicy = MCTSSimulationPolicy::FILTERED_RANDOM; // Faster rollouts
|
||||
config.numThreads = 8; // Reduce threads for testing environment
|
||||
config.immediateScoreTieBreakThreshold = 10.0; // More aggressive tie-breaking
|
||||
|
||||
MCTSAI ai(playerId, isDefender, strategy, castleCoords, apdCache, alCache, config);
|
||||
```
|
||||
|
||||
### Configuration Recommendations
|
||||
|
||||
**For Production Use:**
|
||||
- Use default settings for balanced performance and quality
|
||||
- Consider reducing `numThreads` on systems with limited CPU cores
|
||||
- `BEST_IMMEDIATE` simulation policy provides highest quality decisions
|
||||
|
||||
**For Performance Testing:**
|
||||
- `FILTERED_RANDOM` or `RANDOM` simulation policies for faster rollouts
|
||||
- Lower `explorationConstant` (1.0) for more exploitation
|
||||
- Disable transposition detection for baseline comparison
|
||||
|
||||
**For Analysis/Debugging:**
|
||||
- Single-threaded execution (`useMultithreading = false`) for deterministic results
|
||||
- Higher `immediateScoreTieBreakThreshold` to emphasize direct paths
|
||||
- `BEST_IMMEDIATE` simulation for most predictable behavior
|
||||
|
||||
The configuration system allows fine-tuning MCTS behavior for different scenarios while maintaining compatibility with the existing AI infrastructure.
|
||||
This scoring system provides a robust framework for tactical AI decision-making, balancing immediate tactical gains with strategic objectives while handling the uncertainty inherent in combat outcomes.
|
||||
@@ -1,16 +1,5 @@
|
||||
load("//tools:copts.bzl", "COPTS")
|
||||
|
||||
cc_library(
|
||||
name = "ai_common_types",
|
||||
hdrs = ["AICommonTypes.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = ["//visibility:public"],
|
||||
deps = [
|
||||
"//src/main/cpp/net/eagle0/shardok/library:battalion_type",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:shardok_c_types",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_attacker_strategy_selector",
|
||||
srcs = ["AIAttackerStrategySelector.cpp"],
|
||||
@@ -22,7 +11,6 @@ cc_library(
|
||||
],
|
||||
deps = [
|
||||
":ai_attack_locations",
|
||||
":ai_flee_decision_calculator",
|
||||
":ai_score_utilities",
|
||||
":ai_strategy",
|
||||
":ai_water_crossing_command_chooser",
|
||||
@@ -39,15 +27,14 @@ cc_library(
|
||||
hdrs = ["AIAttackGroups.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
":ai_attack_locations",
|
||||
":ai_common_types",
|
||||
":ai_score_utilities",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/settings:game_settings",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:hex_map_cc_fbs",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:unit_cc_fbs",
|
||||
@@ -59,10 +46,6 @@ cc_library(
|
||||
srcs = ["AIAttackLocations.cpp"],
|
||||
hdrs = ["AIAttackLocations.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":ai_score_utilities",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/map:terrain",
|
||||
@@ -87,7 +70,6 @@ cc_library(
|
||||
":ai_score_utilities",
|
||||
":ai_strategy",
|
||||
":ai_water_crossing_calculator",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/map:coords_set",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
|
||||
@@ -101,14 +83,11 @@ cc_library(
|
||||
hdrs = ["AIDistanceDebuf.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":ai_attack_locations",
|
||||
":ai_common_types",
|
||||
":ai_score_utilities",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
@@ -137,110 +116,53 @@ cc_library(
|
||||
hdrs = ["AIScoreUtilities.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:shardok_c_types",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:unit_cc_fbs",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_flee_decision_calculator",
|
||||
srcs = ["AIFleeDecisionCalculator.cpp"],
|
||||
hdrs = ["AIFleeDecisionCalculator.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
":ai_score_utilities",
|
||||
":ai_unit_score_calculator",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:engine",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_heuristic_weighting",
|
||||
srcs = ["AIHeuristicWeighting.cpp"],
|
||||
hdrs = ["AIHeuristicWeighting.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts/adapters:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/map:coords_set",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
"//src/main/protobuf/net/eagle0/shardok/common:command_type_cc_proto",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_command_evaluator",
|
||||
srcs = ["AICommandEvaluator.cpp"],
|
||||
hdrs = ["AICommandEvaluator.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
":ai_command_filter",
|
||||
":ai_strategy",
|
||||
":transposition_table",
|
||||
"//src/main/cpp/net/eagle0/common:sequence_random_generator",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:ai_score_calculator_interface",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:engine",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/map:coords_set",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_cube_utils",
|
||||
"//src/main/protobuf/net/eagle0/shardok/common:command_type_cc_proto",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_command_filter",
|
||||
srcs = ["AICommandFilter.cpp"],
|
||||
hdrs = ["AICommandFilter.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__pkg__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts/adapters:__pkg__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
":ai_common_types",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:engine",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/settings:game_settings",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
|
||||
"//src/main/protobuf/net/eagle0/shardok/api:command_descriptor_cc_proto",
|
||||
"//src/main/protobuf/net/eagle0/shardok/common:command_type_cc_proto",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "transposition_table",
|
||||
srcs = ["TranspositionTable.cpp"],
|
||||
hdrs = ["TranspositionTable.hpp"],
|
||||
name = "ai_score_calculator",
|
||||
srcs = ["AIScoreCalculator.cpp"],
|
||||
hdrs = ["AIScoreCalculator.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
":ai_attacker_strategy_selector",
|
||||
":ai_command_filter",
|
||||
":ai_unit_score_calculator",
|
||||
":ai_victory_condition_score_calculator",
|
||||
"//src/main/cpp/net/eagle0/common:sequence_random_generator",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:engine",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/view_filters:game_state_guesser",
|
||||
],
|
||||
)
|
||||
|
||||
@@ -250,13 +172,11 @@ cc_library(
|
||||
hdrs = ["AIStrategy.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":ai_attack_groups",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/map:coords_set",
|
||||
],
|
||||
)
|
||||
|
||||
@@ -266,7 +186,6 @@ cc_library(
|
||||
hdrs = ["AIUnitScoreCalculator.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
@@ -277,6 +196,26 @@ cc_library(
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_victory_condition_score_calculator",
|
||||
srcs = ["AIVictoryConditionScoreCalculator.cpp"],
|
||||
hdrs = ["AIVictoryConditionScoreCalculator.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":ai_attack_groups",
|
||||
":ai_attack_locations",
|
||||
":ai_distance_debuf",
|
||||
":ai_score_utilities",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_water_crossing_calculator",
|
||||
srcs = ["AIWaterCrossingCalculator.cpp"],
|
||||
@@ -284,14 +223,10 @@ cc_library(
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok:__pkg__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__subpackages__",
|
||||
],
|
||||
deps = [
|
||||
":ai_common_types",
|
||||
":ai_minimum_distance_and_target",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:ai_score_calculator_interface",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/fb_helpers:hex_map_helpers",
|
||||
@@ -312,6 +247,7 @@ cc_library(
|
||||
"//src/main/cpp/net/eagle0/shardok/library:game_state_w",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/protobuf/net/eagle0/shardok/api:command_descriptor_cc_proto",
|
||||
],
|
||||
)
|
||||
|
||||
@@ -321,7 +257,6 @@ cc_library(
|
||||
hdrs = ["AITimeBudget.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__pkg__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
@@ -340,31 +275,38 @@ cc_library(
|
||||
hdrs = ["IterativeDeepeningAI.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:__pkg__",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
":ai_attacker_strategy_selector",
|
||||
":ai_command_evaluator",
|
||||
":ai_defender_strategy_selector",
|
||||
":ai_score_calculator",
|
||||
":ai_time_budget",
|
||||
":ai_water_crossing_command_chooser",
|
||||
"//src/main/cpp/net/eagle0/common:time_utils",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:ai_score_calculator_interface",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:engine",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
"//src/main/protobuf/net/eagle0/shardok/api:command_descriptor_cc_proto",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
name = "ai_config",
|
||||
hdrs = ["AIConfig.hpp"],
|
||||
name = "ai_flee_decision_calculator",
|
||||
srcs = ["AIFleeDecisionCalculator.cpp"],
|
||||
hdrs = ["AIFleeDecisionCalculator.hpp"],
|
||||
copts = COPTS,
|
||||
visibility = [
|
||||
"//src/main/cpp/net/eagle0/shardok/ai_performance_runner:__pkg__",
|
||||
"//src/test/cpp/net/eagle0/shardok/ai:__pkg__",
|
||||
],
|
||||
deps = [
|
||||
":ai_score_utilities",
|
||||
"//src/main/cpp/net/eagle0/shardok/library:engine",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/settings:game_settings",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
|
||||
"//src/main/protobuf/net/eagle0/shardok/api:command_descriptor_cc_proto",
|
||||
],
|
||||
)
|
||||
|
||||
cc_library(
|
||||
@@ -375,21 +317,15 @@ cc_library(
|
||||
visibility = ["//visibility:public"],
|
||||
deps = [
|
||||
":ai_attacker_strategy_selector",
|
||||
":ai_config",
|
||||
":ai_defender_strategy_selector",
|
||||
":ai_flee_decision_calculator",
|
||||
":ai_iterative_deepening", # Direct dependency for runtime selection
|
||||
":ai_iterative_deepening",
|
||||
":ai_score_calculator",
|
||||
":ai_time_budget",
|
||||
":ai_water_crossing_command_chooser",
|
||||
"//src/main/cpp/net/eagle0/common:time_utils",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/mcts:shardok_mcts_ai", # MCTS with abstraction layer
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:ai_score_calculator_interface",
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:mcts_optimized_ai_score_calculator", # Bounded linear scorer for MCTS
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:normalized_ai_score_calculator", # Normalized [0,1] scorer for ML training
|
||||
"//src/main/cpp/net/eagle0/shardok/ai/score:standard_ai_score_calculator", # Standard unbounded scorer (default)
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/action_point_distances:action_point_distances_cache",
|
||||
"//src/main/cpp/net/eagle0/shardok/library/util:game_state_dumper",
|
||||
"@com_google_protobuf//:protobuf",
|
||||
],
|
||||
)
|
||||
|
||||
@@ -10,9 +10,8 @@
|
||||
#include <utility>
|
||||
|
||||
#include "AIAttackerStrategySelector.hpp"
|
||||
#include "AICommandEvaluator.hpp"
|
||||
#include "TranspositionTable.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator.hpp"
|
||||
#include "AIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/common/TimeUtils.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
|
||||
|
||||
namespace shardok {
|
||||
@@ -24,21 +23,19 @@ IterativeDeepeningAI::IterativeDeepeningAI(
|
||||
const bool isDefender,
|
||||
AIStrategy strategy,
|
||||
const CoordsSet& castleCoords,
|
||||
const AIScoreCalculator& scorer,
|
||||
const APDCache& apdCache,
|
||||
BattalionTypeGetter battalionTypeGetter)
|
||||
const ALCache& alCache)
|
||||
: playerId(playerId),
|
||||
isDefender(isDefender),
|
||||
strategy(std::move(strategy)),
|
||||
castleCoords(castleCoords),
|
||||
scorer(scorer),
|
||||
apdCache(apdCache),
|
||||
battalionTypeGetter(std::move(battalionTypeGetter)) {} // Move the function object
|
||||
alCache(alCache) {}
|
||||
|
||||
auto IterativeDeepeningAI::IterativeSearch(
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& state,
|
||||
const CommandListSPtr& commands,
|
||||
const std::vector<CommandProto>& commands,
|
||||
const AITimeBudget& initialBudget) const -> SearchResult {
|
||||
// Make a mutable copy of the time budget to track remaining time
|
||||
AITimeBudget timeBudget = initialBudget;
|
||||
@@ -46,12 +43,7 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
const auto initialBudgetMs = initialBudget.remainingBudget;
|
||||
SearchResult result;
|
||||
|
||||
// Increment TT age for replacement strategy (new search)
|
||||
g_transpositionTable.incrementAge();
|
||||
|
||||
// DEBUG: Clear TT to see if that's causing the suspicious depth reaching
|
||||
// g_transpositionTable.clear(); // Uncomment to test without cross-search caching
|
||||
if (commands->empty()) {
|
||||
if (commands.empty()) {
|
||||
#if DEBUG_ITERATIVE_DEEPENING_TIMINGS
|
||||
printf("ID AI: Commands are empty, returning early\n");
|
||||
#endif
|
||||
@@ -59,30 +51,35 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
return result;
|
||||
}
|
||||
|
||||
// Check if we're in SET_UP phase and enforce maximum depth limit
|
||||
// Check if we're in SET_UP phase
|
||||
bool isSetupPhase =
|
||||
(state->status()->state() ==
|
||||
net::eagle0::shardok::storage::fb::GameStatus_::State_SET_UP);
|
||||
// Limit depth to prevent thread pool exhaustion and keep search reasonable
|
||||
size_t maxDepth = isSetupPhase ? 2 : 8;
|
||||
int maxDepth = isSetupPhase ? 2 : std::numeric_limits<int>::max();
|
||||
|
||||
// Calculate current utility and create engine once for all command evaluations
|
||||
const auto& settingsGetter = settings->GetGetter();
|
||||
const auto guessedEngine = ShardokEngine(settings, state);
|
||||
const auto maxRepeatCount = settingsGetter.Backing().ai_utility_repeat_count();
|
||||
const ScoreValue currentUtility =
|
||||
scorer.GuessedStateScore(isDefender, state, strategy, castleCoords);
|
||||
const ScoreValue currentUtility = AIScoreCalculator::GuessedStateScore(
|
||||
isDefender,
|
||||
state,
|
||||
strategy,
|
||||
castleCoords,
|
||||
settingsGetter,
|
||||
apdCache,
|
||||
alCache);
|
||||
|
||||
// Initialize data structures for tracking scores at each depth
|
||||
scoresByDepth.clear();
|
||||
scoresByDepth.resize(commands->size());
|
||||
scoresByDepth.resize(commands.size());
|
||||
highestDepthCompleted.clear();
|
||||
highestDepthCompleted.resize(commands->size(), 0);
|
||||
highestDepthCompleted.resize(commands.size(), 0);
|
||||
|
||||
size_t currentDepth = 1;
|
||||
int currentDepth = 1;
|
||||
size_t previousBestCommand = 0; // Track best command from previous depth
|
||||
size_t evaluatedCountAtHighestDepth = 0;
|
||||
auto completionReason = EvaluationCompletionReason::RAN_OUT_OF_TIME;
|
||||
EvaluationCompletionReason completionReason = EvaluationCompletionReason::RAN_OUT_OF_TIME;
|
||||
|
||||
// Main iterative deepening loop
|
||||
while ((currentDepth == 1 || !IsTimeExpired(timeBudget)) && currentDepth <= maxDepth) {
|
||||
@@ -92,37 +89,27 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
scoresByDepth,
|
||||
highestDepthCompleted);
|
||||
|
||||
size_t evaluatedCount = 0;
|
||||
int evaluatedCount = 0;
|
||||
bool allEvaluated = true;
|
||||
bool allEndTurnCommands = true; // Track if all commands are END_TURN
|
||||
|
||||
// Start all command evaluations for this depth
|
||||
std::vector<std::pair<size_t, std::future<SearchResult>>> futures;
|
||||
futures.reserve(sortedIndices.size());
|
||||
|
||||
// Try to evaluate all commands at this depth, within budget constraints
|
||||
for (size_t cmdIndex : sortedIndices) {
|
||||
if (currentDepth > 1 && IsTimeExpired(timeBudget)) {
|
||||
allEvaluated = false;
|
||||
break;
|
||||
}
|
||||
|
||||
auto future = SearchCommandAtDepthWithEngine(
|
||||
auto cmdResult = SearchCommandAtDepthWithEngine(
|
||||
guessedEngine,
|
||||
scorer,
|
||||
settingsGetter,
|
||||
maxRepeatCount,
|
||||
commands,
|
||||
cmdIndex,
|
||||
currentDepth, // Pass current iteration depth as desired search depth
|
||||
currentDepth,
|
||||
currentUtility,
|
||||
timeBudget);
|
||||
|
||||
futures.emplace_back(cmdIndex, std::move(future));
|
||||
}
|
||||
|
||||
// Now wait for all futures and collect results
|
||||
for (auto& [cmdIndex, future] : futures) {
|
||||
auto cmdResult = future.get();
|
||||
|
||||
// Ensure scoresByDepth[cmdIndex] has enough space
|
||||
if (scoresByDepth[cmdIndex].size() <= currentDepth) {
|
||||
scoresByDepth[cmdIndex].resize(currentDepth + 1);
|
||||
@@ -132,8 +119,7 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
evaluatedCount++;
|
||||
|
||||
// Check if this command is not END_TURN_COMMAND
|
||||
if ((*commands)[cmdIndex]->GetCommandType() !=
|
||||
net::eagle0::shardok::common::END_TURN_COMMAND) {
|
||||
if (commands[cmdIndex].type() != net::eagle0::shardok::common::END_TURN_COMMAND) {
|
||||
allEndTurnCommands = false;
|
||||
}
|
||||
}
|
||||
@@ -144,7 +130,7 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
size_t currentBestCommand = 0;
|
||||
ScoreValue currentBestScore = -std::numeric_limits<ScoreValue>::infinity();
|
||||
|
||||
for (size_t i = 0; i < commands->size(); ++i) {
|
||||
for (size_t i = 0; i < commands.size(); ++i) {
|
||||
if (highestDepthCompleted[i] >= currentDepth) {
|
||||
if (scoresByDepth[i][currentDepth] > currentBestScore) {
|
||||
currentBestScore = scoresByDepth[i][currentDepth];
|
||||
@@ -156,21 +142,17 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
// Log if best command changed from previous depth
|
||||
if (currentDepth > 1 && currentBestCommand != previousBestCommand) {
|
||||
#if DEBUG_ITERATIVE_DEEPENING_TIMINGS
|
||||
printf("ID AI: Best command changed at depth %lu:\n", currentDepth);
|
||||
printf(" Depth %lu best: command %zu (score %.2f) - type: %s\n",
|
||||
printf("ID AI: Best command changed at depth %d:\n", currentDepth);
|
||||
printf(" Depth %d best: command %zu (score %.2f) - %s\n",
|
||||
currentDepth - 1,
|
||||
previousBestCommand,
|
||||
scoresByDepth[previousBestCommand][currentDepth - 1],
|
||||
net::eagle0::shardok::common::CommandType_Name(
|
||||
(*commands)[previousBestCommand]->GetCommandType())
|
||||
.c_str());
|
||||
printf(" Depth %lu best: command %zu (score %.2f) - type: %s\n",
|
||||
commands[previousBestCommand].DebugString().c_str());
|
||||
printf(" Depth %d best: command %zu (score %.2f) - %s\n",
|
||||
currentDepth,
|
||||
currentBestCommand,
|
||||
currentBestScore,
|
||||
net::eagle0::shardok::common::CommandType_Name(
|
||||
(*commands)[currentBestCommand]->GetCommandType())
|
||||
.c_str());
|
||||
commands[currentBestCommand].DebugString().c_str());
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -193,12 +175,12 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
// This indicates we've hit END_TURN in the lookahead
|
||||
if (currentDepth > 1 && evaluatedCount > 0) {
|
||||
bool scoresUnchanged = true;
|
||||
size_t unchangedCount = 0;
|
||||
int unchangedCount = 0;
|
||||
|
||||
for (size_t i = 0; i < sortedIndices.size() && i < evaluatedCount; ++i) {
|
||||
size_t cmdIndex = sortedIndices[i];
|
||||
// This command was evaluated at both current and previous depth
|
||||
if (size_t cmdIndex = sortedIndices[i];
|
||||
scoresByDepth[cmdIndex].size() > currentDepth &&
|
||||
if (scoresByDepth[cmdIndex].size() > currentDepth &&
|
||||
scoresByDepth[cmdIndex].size() > currentDepth - 1) {
|
||||
// Check if score changed between depth N-1 and depth N
|
||||
if (std::abs(
|
||||
@@ -222,11 +204,10 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
// Check if we've used more than 50% of total budget
|
||||
auto totalElapsed = std::chrono::steady_clock::now() - startTime;
|
||||
auto totalElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(totalElapsed);
|
||||
double budgetUsedPercent = static_cast<double>(totalElapsedMs.count()) /
|
||||
static_cast<double>(initialBudgetMs.count());
|
||||
double budgetUsedPercent = (double)totalElapsedMs.count() / initialBudgetMs.count();
|
||||
|
||||
if (budgetUsedPercent > 0.5) {
|
||||
printf("ID AI: Stopping after depth %lu - used %.1f%% of time budget\n",
|
||||
printf("ID AI: Stopping after depth %d - used %.1f%% of time budget\n",
|
||||
currentDepth,
|
||||
budgetUsedPercent * 100);
|
||||
completionReason = EvaluationCompletionReason::NOT_ENOUGH_TIME_TO_CONTINUE;
|
||||
@@ -249,7 +230,7 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
result.searchCompleted = result.minimumDepthCompleted;
|
||||
result.timeUsed = std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||
std::chrono::steady_clock::now() - startTime);
|
||||
result.availableCommandCount = commands->size();
|
||||
result.availableCommandCount = commands.size();
|
||||
result.commandCountEvaluated = evaluatedCountAtHighestDepth;
|
||||
result.completionReason = completionReason;
|
||||
|
||||
@@ -261,8 +242,6 @@ auto IterativeDeepeningAI::IterativeSearch(
|
||||
result.availableCommandCount);
|
||||
}
|
||||
|
||||
// Print TranspositionTable statistics
|
||||
g_transpositionTable.printStats();
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -272,79 +251,72 @@ bool IterativeDeepeningAI::IsTimeExpired(const AITimeBudget& budget) {
|
||||
|
||||
auto IterativeDeepeningAI::SearchCommandAtDepthWithEngine(
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIScoreCalculator& scorer,
|
||||
const GameSettings::Getter& settingsGetter,
|
||||
const int maxRepeatCount,
|
||||
const CommandListSPtr& commands,
|
||||
const std::vector<CommandProto>& commands,
|
||||
const size_t commandIndex,
|
||||
const int desiredDepth,
|
||||
const int depth,
|
||||
const ScoreValue currentUtility,
|
||||
AITimeBudget& timeBudget) const -> std::future<SearchResult> {
|
||||
AITimeBudget& timeBudget) const -> SearchResult {
|
||||
SearchResult result;
|
||||
result.bestCommandIndex = commandIndex;
|
||||
result.depthAchieved = desiredDepth;
|
||||
result.depthAchieved = depth;
|
||||
result.searchCompleted = true;
|
||||
result.minimumDepthCompleted = true;
|
||||
result.availableCommandCount = commands->size();
|
||||
result.availableCommandCount = commands.size();
|
||||
result.commandCountEvaluated = 1; // We're evaluating just this command
|
||||
|
||||
if (commandIndex >= commands->size()) {
|
||||
if (commandIndex >= commands.size()) {
|
||||
result.bestScore = 0.0;
|
||||
std::promise<SearchResult> p;
|
||||
p.set_value(result);
|
||||
return p.get_future();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Track concurrent evaluations and adjust time accounting
|
||||
AIEvaluationCounter counter;
|
||||
const auto startTime = std::chrono::steady_clock::now();
|
||||
try {
|
||||
// Track concurrent evaluations and adjust time accounting
|
||||
AIEvaluationCounter counter;
|
||||
const auto startTime = std::chrono::steady_clock::now();
|
||||
|
||||
// Calculate deadline from remaining time budget
|
||||
const auto deadline = startTime + timeBudget.remainingBudget;
|
||||
// Use CommandScore to evaluate the specific command at the given depth
|
||||
const auto commandScore = AIScoreCalculator::CommandScore(
|
||||
playerId,
|
||||
isDefender,
|
||||
depth,
|
||||
maxRepeatCount,
|
||||
guessedEngine,
|
||||
strategy,
|
||||
currentUtility,
|
||||
settingsGetter,
|
||||
castleCoords,
|
||||
apdCache,
|
||||
alCache,
|
||||
commandIndex);
|
||||
|
||||
// Create command evaluator for lookahead search
|
||||
AICommandEvaluator evaluator(scorer, apdCache, battalionTypeGetter);
|
||||
// Calculate time used and adjust based on concurrent evaluations
|
||||
const auto elapsed = std::chrono::steady_clock::now() - startTime;
|
||||
const int concurrentCount = counter.GetCurrentCount();
|
||||
const auto adjustedElapsed = elapsed / std::max(1, concurrentCount);
|
||||
const auto adjustedElapsedMs =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(adjustedElapsed);
|
||||
|
||||
// Get the future from EvaluateCommand - don't wait yet
|
||||
// Note: EvaluateCommand expects remainingLookahead, not desiredDepth
|
||||
// desiredDepth 1 = evaluate immediate (remainingLookahead 0)
|
||||
// desiredDepth 2 = look 1 move ahead (remainingLookahead 1)
|
||||
// desiredDepth N = look N-1 moves ahead (remainingLookahead N-1)
|
||||
auto commandScoreFuture = evaluator.EvaluateCommand(
|
||||
playerId,
|
||||
isDefender,
|
||||
desiredDepth - 1, // Convert desiredDepth to remainingLookahead
|
||||
maxRepeatCount,
|
||||
guessedEngine,
|
||||
strategy,
|
||||
currentUtility,
|
||||
castleCoords,
|
||||
commandIndex,
|
||||
deadline);
|
||||
// Deduct adjusted time from remaining budget
|
||||
timeBudget.remainingBudget -= adjustedElapsedMs;
|
||||
|
||||
// Calculate time and adjust budget before waiting
|
||||
// This is needed because we need to update timeBudget synchronously
|
||||
const auto commandScore = commandScoreFuture.get();
|
||||
result.bestScore = commandScore;
|
||||
} catch (const std::exception& e) {
|
||||
// If evaluation fails, return a neutral score rather than crashing
|
||||
#if DEBUG_ITERATIVE_DEEPENING_TIMINGS
|
||||
printf("SearchCommandAtDepthWithEngine: evaluation failed with exception: %s\n", e.what());
|
||||
#endif
|
||||
result.bestScore = 0.0;
|
||||
}
|
||||
|
||||
const auto elapsed = std::chrono::steady_clock::now() - startTime;
|
||||
const int concurrentCount = AIEvaluationCounter::GetCurrentCount();
|
||||
const auto adjustedElapsed = elapsed / std::max(1, concurrentCount);
|
||||
const auto adjustedElapsedMs =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(adjustedElapsed);
|
||||
|
||||
// Deduct adjusted time from remaining budget
|
||||
timeBudget.remainingBudget -= adjustedElapsedMs;
|
||||
|
||||
result.bestScore = commandScore;
|
||||
|
||||
std::promise<SearchResult> p;
|
||||
p.set_value(result);
|
||||
return p.get_future();
|
||||
return result;
|
||||
}
|
||||
|
||||
auto IterativeDeepeningAI::GetCommandsSortedByPreviousDepth(
|
||||
const size_t currentDepth,
|
||||
int currentDepth,
|
||||
const std::vector<std::vector<ScoreValue>>& scoresByDepth,
|
||||
const std::vector<size_t>& highestDepthCompleted) -> std::vector<size_t> {
|
||||
const std::vector<int>& highestDepthCompleted) const -> std::vector<size_t> {
|
||||
std::vector<size_t> indices(scoresByDepth.size());
|
||||
std::iota(indices.begin(), indices.end(), 0);
|
||||
|
||||
@@ -354,21 +326,11 @@ auto IterativeDeepeningAI::GetCommandsSortedByPreviousDepth(
|
||||
}
|
||||
|
||||
// Sort by score at previous depth
|
||||
const size_t prevDepth = currentDepth - 1;
|
||||
std::ranges::sort(indices, [&](const size_t a, const size_t b) {
|
||||
// Bounds check - if indices are out of range, or inner vectors are too small, treat as not
|
||||
// evaluated
|
||||
if (a >= scoresByDepth.size() || b >= scoresByDepth.size() ||
|
||||
a >= highestDepthCompleted.size() || b >= highestDepthCompleted.size()) {
|
||||
return a < b; // Maintain stable order for out-of-bounds indices
|
||||
}
|
||||
|
||||
// Check if the scores for previous depth exist
|
||||
int prevDepth = currentDepth - 1;
|
||||
std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b) {
|
||||
// Only consider commands that were evaluated at previous depth
|
||||
if (highestDepthCompleted[a] >= prevDepth && highestDepthCompleted[b] >= prevDepth) {
|
||||
// Additional safety check for inner vector size
|
||||
if (scoresByDepth[a].size() > prevDepth && scoresByDepth[b].size() > prevDepth) {
|
||||
return scoresByDepth[a][prevDepth] > scoresByDepth[b][prevDepth];
|
||||
}
|
||||
return scoresByDepth[a][prevDepth] > scoresByDepth[b][prevDepth];
|
||||
}
|
||||
// Commands not evaluated at prev depth go to the end
|
||||
return highestDepthCompleted[a] >= prevDepth;
|
||||
@@ -379,7 +341,7 @@ auto IterativeDeepeningAI::GetCommandsSortedByPreviousDepth(
|
||||
|
||||
auto IterativeDeepeningAI::SelectBestResult(
|
||||
const std::vector<std::vector<ScoreValue>>& scoresByDepth,
|
||||
const std::vector<size_t>& highestDepthCompleted) -> SearchResult {
|
||||
const std::vector<int>& highestDepthCompleted) const -> SearchResult {
|
||||
SearchResult result;
|
||||
result.bestScore = -std::numeric_limits<ScoreValue>::infinity();
|
||||
result.searchCompleted = false;
|
||||
@@ -387,8 +349,9 @@ auto IterativeDeepeningAI::SelectBestResult(
|
||||
// Find the command with best score at its highest evaluated depth
|
||||
for (size_t i = 0; i < scoresByDepth.size(); ++i) {
|
||||
if (highestDepthCompleted[i] > 0) {
|
||||
const size_t depth = highestDepthCompleted[i];
|
||||
if (ScoreValue score = scoresByDepth[i][depth]; score > result.bestScore) {
|
||||
int depth = highestDepthCompleted[i];
|
||||
ScoreValue score = scoresByDepth[i][depth];
|
||||
if (score > result.bestScore) {
|
||||
result.bestScore = score;
|
||||
result.bestCommandIndex = i;
|
||||
result.depthAchieved = depth;
|
||||
|
||||
@@ -6,24 +6,22 @@
|
||||
#define EAGLE0_ITERATIVEDEEPENINGAI_HPP
|
||||
|
||||
#include <chrono>
|
||||
#include <future>
|
||||
#include <vector>
|
||||
|
||||
#include "AIStrategy.hpp"
|
||||
#include "AITimeBudget.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCTypes.h"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCommand.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/command_descriptor.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
|
||||
// Forward declarations
|
||||
class ShardokEngine;
|
||||
using ScoreValue = double;
|
||||
using BattalionTypeGetter = std::function<BattalionTypeSPtr(BattalionTypeId)>;
|
||||
using CommandProto = net::eagle0::shardok::api::CommandDescriptor;
|
||||
|
||||
/// Reason why AI evaluation completed at the achieved depth.
|
||||
enum class EvaluationCompletionReason {
|
||||
@@ -37,7 +35,7 @@ public:
|
||||
struct SearchResult {
|
||||
size_t bestCommandIndex;
|
||||
ScoreValue bestScore;
|
||||
size_t depthAchieved;
|
||||
int depthAchieved;
|
||||
std::chrono::milliseconds timeUsed;
|
||||
bool minimumDepthCompleted;
|
||||
bool searchCompleted;
|
||||
@@ -62,50 +60,48 @@ public:
|
||||
bool isDefender,
|
||||
AIStrategy strategy,
|
||||
const CoordsSet& castleCoords,
|
||||
const AIScoreCalculator& scorer,
|
||||
const APDCache& apdCache,
|
||||
BattalionTypeGetter battalionTypeGetter); // Pass by value
|
||||
const ALCache& alCache);
|
||||
|
||||
[[nodiscard]] SearchResult IterativeSearch(
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& state,
|
||||
const CommandListSPtr& commands,
|
||||
const AITimeBudget& initialBudget) const;
|
||||
const std::vector<CommandProto>& commands,
|
||||
const AITimeBudget& timeBudget) const;
|
||||
|
||||
private:
|
||||
PlayerId playerId;
|
||||
bool isDefender;
|
||||
AIStrategy strategy;
|
||||
CoordsSet castleCoords;
|
||||
const AIScoreCalculator& scorer;
|
||||
const APDCache& apdCache;
|
||||
BattalionTypeGetter battalionTypeGetter; // Store by value, not reference!
|
||||
const ALCache& alCache;
|
||||
|
||||
// Reusable vectors to reduce memory allocations
|
||||
mutable std::vector<std::vector<ScoreValue>> scoresByDepth;
|
||||
mutable std::vector<size_t> highestDepthCompleted;
|
||||
mutable std::vector<int> highestDepthCompleted;
|
||||
mutable std::vector<size_t> reusableSortedIndices;
|
||||
|
||||
[[nodiscard]] static bool IsTimeExpired(const AITimeBudget& budget);
|
||||
|
||||
[[nodiscard]] std::future<SearchResult> SearchCommandAtDepthWithEngine(
|
||||
[[nodiscard]] SearchResult SearchCommandAtDepthWithEngine(
|
||||
const ShardokEngine& guessedEngine,
|
||||
const AIScoreCalculator& scorer,
|
||||
const GameSettings::Getter& settingsGetter,
|
||||
int maxRepeatCount,
|
||||
const CommandListSPtr& commands,
|
||||
const std::vector<CommandProto>& commands,
|
||||
size_t commandIndex,
|
||||
int desiredDepth,
|
||||
int depth,
|
||||
ScoreValue currentUtility,
|
||||
AITimeBudget& timeBudget) const;
|
||||
|
||||
[[nodiscard]] static std::vector<size_t> GetCommandsSortedByPreviousDepth(
|
||||
size_t currentDepth,
|
||||
[[nodiscard]] std::vector<size_t> GetCommandsSortedByPreviousDepth(
|
||||
int currentDepth,
|
||||
const std::vector<std::vector<ScoreValue>>& scoresByDepth,
|
||||
const std::vector<size_t>& highestDepthCompleted);
|
||||
const std::vector<int>& highestDepthCompleted) const;
|
||||
|
||||
[[nodiscard]] static SearchResult SelectBestResult(
|
||||
[[nodiscard]] SearchResult SelectBestResult(
|
||||
const std::vector<std::vector<ScoreValue>>& scoresByDepth,
|
||||
const std::vector<size_t>& highestDepthCompleted);
|
||||
const std::vector<int>& highestDepthCompleted) const;
|
||||
};
|
||||
|
||||
} // namespace shardok
|
||||
|
||||
@@ -10,27 +10,15 @@
|
||||
|
||||
#define DEBUG_FLEE_DECISIONS
|
||||
|
||||
// Enable to dump game state and debug tree to /tmp for debugging
|
||||
// #define ENABLE_MCTS_DEBUG_DUMP
|
||||
|
||||
#ifdef ENABLE_MCTS_DEBUG_DUMP
|
||||
#include <chrono>
|
||||
#include <fstream>
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#endif
|
||||
#include <google/protobuf/util/message_differencer.h>
|
||||
|
||||
#include "AIAttackerStrategySelector.hpp"
|
||||
#include "AIConfig.hpp"
|
||||
#include "AIDefenderStrategySelector.hpp"
|
||||
#include "AIFleeDecisionCalculator.hpp"
|
||||
#include "AIScoreUtilities.hpp"
|
||||
#include "AITimeBudget.hpp"
|
||||
#include "IterativeDeepeningAI.hpp"
|
||||
#include "mcts/ShardokMCTSAI.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/MCTSOptimizedAIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/NormalizedAIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/StandardAIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/common/TimeUtils.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/view_filters/GameStateGuesser.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/action_result_view.pb.h"
|
||||
@@ -42,7 +30,7 @@ using net::eagle0::shardok::api::GameStateView;
|
||||
|
||||
static constexpr bool kPerformanceLogging = true;
|
||||
|
||||
void ApplyUpdate(GameStateView & /*currentView*/, const ActionResultView & /*update*/) {}
|
||||
void ApplyUpdate(GameStateView ¤tView, const ActionResultView &update) {}
|
||||
|
||||
auto RoundsRemaining(const GameSettingsSPtr &settings, const GameStateView &gsv) -> int {
|
||||
const int maxRounds = settings->GetGetter().Backing().max_rounds();
|
||||
@@ -54,17 +42,11 @@ ShardokAIClient::ShardokAIClient(
|
||||
const PlayerId playerId,
|
||||
const bool isDefender,
|
||||
const HexMap *hexMap,
|
||||
const SettingsGetter &settings,
|
||||
const AIAlgorithmType aiAlgorithmType,
|
||||
const ScoringCalculatorType scoringCalculatorType,
|
||||
const mcts::MCTSConfig &mctsConfig)
|
||||
const SettingsGetter &settings)
|
||||
: playerId(playerId),
|
||||
isDefender(isDefender),
|
||||
aiAlgorithmType(aiAlgorithmType),
|
||||
scoringCalculatorType(scoringCalculatorType),
|
||||
alCache(std::make_unique<AttackLocationsCache>(hexMap, settings)),
|
||||
waterCrossingCommandChooser(playerId, apdCache),
|
||||
mctsConfig(mctsConfig) {
|
||||
waterCrossingCommandChooser(playerId, apdCache) {
|
||||
// Pre-generate the most common cache entries for better performance
|
||||
const auto mapId = ActionPointDistancesCache::GetMapId(hexMap);
|
||||
|
||||
@@ -88,110 +70,38 @@ ShardokAIClient::ShardokAIClient(
|
||||
apdCache->ConsolidateThreadLocalCache_Racy();
|
||||
}
|
||||
|
||||
void CheckCommand(const CommandSPtr &realCommand, const CommandSPtr &guessedCommand) {
|
||||
// Verify that the AI's guessed state produces the same available commands as the real state.
|
||||
// We only compare fields that uniquely identify a command - metadata fields like action_points,
|
||||
// will_unhide, next_round_target_info are not part of command identity.
|
||||
void CheckCommand(const CommandProto &realDescriptor, const CommandProto &guessedDescriptor) {
|
||||
string diff;
|
||||
auto differencer = google::protobuf::util::MessageDifferencer();
|
||||
differencer.IgnoreField(CommandProto::descriptor()->FindFieldByNumber(
|
||||
CommandProto::kFollowUpCommandTypesFieldNumber));
|
||||
differencer.ReportDifferencesToString(&diff);
|
||||
if (!differencer.Compare(realDescriptor, guessedDescriptor)) {
|
||||
printf("diff: %s\n\n", diff.c_str());
|
||||
|
||||
if (realCommand->GetCommandType() != guessedCommand->GetCommandType()) {
|
||||
throw ShardokInternalErrorException("Command type mismatch between real and guessed state");
|
||||
}
|
||||
|
||||
if (realCommand->GetPlayerId() != guessedCommand->GetPlayerId()) {
|
||||
throw ShardokInternalErrorException("Player ID mismatch between real and guessed state");
|
||||
}
|
||||
|
||||
if (realCommand->GetActorUnitId() != guessedCommand->GetActorUnitId()) {
|
||||
throw ShardokInternalErrorException("Actor unit mismatch between real and guessed state");
|
||||
}
|
||||
|
||||
if (realCommand->GetTargetRow() != guessedCommand->GetTargetRow() ||
|
||||
realCommand->GetTargetColumn() != guessedCommand->GetTargetColumn()) {
|
||||
throw ShardokInternalErrorException(
|
||||
"Target coordinates mismatch between real and guessed state");
|
||||
}
|
||||
|
||||
// For commands with odds (like FLEE), verify the odds match
|
||||
if (realCommand->HasOdds() != guessedCommand->HasOdds()) {
|
||||
throw ShardokInternalErrorException(
|
||||
"Odds presence mismatch between real and guessed state");
|
||||
}
|
||||
|
||||
if (realCommand->HasOdds() && guessedCommand->HasOdds()) {
|
||||
if (realCommand->GetOddsPercentile() != guessedCommand->GetOddsPercentile()) {
|
||||
throw ShardokInternalErrorException(
|
||||
"Odds percentile mismatch between real and guessed state");
|
||||
}
|
||||
printf("Selected command descriptor\n%s\ndoes not match guessed\n%s\n\n",
|
||||
realDescriptor.DebugString().c_str(),
|
||||
guessedDescriptor.DebugString().c_str());
|
||||
throw ShardokInternalErrorException("Illegal state for AI client");
|
||||
}
|
||||
}
|
||||
|
||||
auto ShardokAIClient::StandardChooseCommandIndex(
|
||||
const GameSettingsSPtr &settings,
|
||||
const GameStateW &guessedState,
|
||||
const CommandListSPtr &realAvailableCommands) const -> CommandChoiceResults {
|
||||
const vector<CommandProto> &realAvailableCommands) const -> CommandChoiceResults {
|
||||
const auto settingsGetter = settings->GetGetter();
|
||||
const auto guessedEngine = ShardokEngine(settings, guessedState);
|
||||
const auto guessedCommands = guessedEngine.GetAvailableCommandsForAIPlayer(playerId);
|
||||
const auto commandCount = guessedCommands->size();
|
||||
|
||||
// Calculate time budget based on game situation using new dynamic per-command settings
|
||||
const auto timeBudget = CalculateTimeBudget(playerId, settings, guessedState, commandCount);
|
||||
// Calculate time budget based on game situation using new settings
|
||||
const auto timeBudget = CalculateTimeBudget(playerId, settings, guessedState);
|
||||
|
||||
// Configure MCTS based on proximity to enemy
|
||||
// When far from enemy: use AVERAGING with maxPlayerFlips=0 (single-player lookahead)
|
||||
// - AVERAGING naturally penalizes longer paths through variance
|
||||
// - No opponent nodes, so no one-bad-child problem
|
||||
// When close to enemy: use MINIMAX with maxPlayerFlips=1 (adversarial lookahead)
|
||||
// - MINIMAX correctly models opponent choosing best response
|
||||
// - Explores through one opponent turn for tactical accuracy
|
||||
auto adjustedMCTSConfig = mctsConfig;
|
||||
const auto guessedCommands = guessedEngine.GetAvailableCommandProtos(playerId, false);
|
||||
const auto commandCount = guessedCommands.size();
|
||||
|
||||
// For fair evaluation: simulate leaves to opponent's turn start (maxSimulationFlips=1)
|
||||
// This ensures all leaves are scored at the same game phase:
|
||||
// - Leaves at playerFlips=0 (still my turn): simulate through END_TURN to playerFlips=1
|
||||
// - Leaves at playerFlips=1 (opponent's turn): evaluate immediately
|
||||
// Result: consistent comparison of "what happens after I end my turn"
|
||||
// adjustedMCTSConfig.maxSimulatfixionFlips = 1;
|
||||
|
||||
// adjustedMCTSConfig.maxPlayerFlips = 0;
|
||||
// if (timeBudget.isCloseToEnemy) {
|
||||
// adjustedMCTSConfig.maxPlayerFlips = 1;
|
||||
// adjustedMCTSConfig.backpropagationPolicy = mcts::MCTSBackpropagationPolicy::MINIMAX;
|
||||
// if constexpr (kPerformanceLogging) {
|
||||
// printf("MCTS Config: Close to enemy - using maxPlayerFlips=1, MINIMAX backprop\n");
|
||||
// }
|
||||
// } else {
|
||||
// adjustedMCTSConfig.maxPlayerFlips = 0;
|
||||
// adjustedMCTSConfig.backpropagationPolicy = mcts::MCTSBackpropagationPolicy::AVERAGING;
|
||||
// if constexpr (kPerformanceLogging) {
|
||||
// printf("MCTS Config: Far from enemy - using maxPlayerFlips=0, AVERAGING backprop\n");
|
||||
// }
|
||||
// }
|
||||
|
||||
assert(commandCount == realAvailableCommands->size());
|
||||
// Verify that the AI's guessed state produces the same available commands as reality
|
||||
for (size_t i = 0; i < commandCount; i++) {
|
||||
CheckCommand((*realAvailableCommands)[i], (*guessedCommands)[i]);
|
||||
}
|
||||
|
||||
// Extract values directly from settings for strategy selection
|
||||
const auto maxRounds = settingsGetter.Backing().max_rounds();
|
||||
const auto braveWaterCost = settingsGetter.Backing().brave_water_action_point_cost();
|
||||
const auto battalionTypeGetter = [&settingsGetter](BattalionTypeId typeId) {
|
||||
return settingsGetter.GetBattalionType(typeId);
|
||||
};
|
||||
|
||||
// Create scorer for actual scoring during search - type selected at construction
|
||||
std::unique_ptr<AIScoreCalculator> scorer;
|
||||
switch (scoringCalculatorType) {
|
||||
case ScoringCalculatorType::NORMALIZED:
|
||||
scorer = MakeNormalizedAIScoreCalculator(settingsGetter, apdCache, alCache);
|
||||
break;
|
||||
case ScoringCalculatorType::MCTS_OPTIMIZED:
|
||||
scorer = MakeMCTSOptimizedAIScoreCalculator(settingsGetter, apdCache, alCache);
|
||||
break;
|
||||
case ScoringCalculatorType::STANDARD:
|
||||
default: scorer = MakeStandardAIScoreCalculator(settingsGetter, apdCache, alCache); break;
|
||||
assert(commandCount == realAvailableCommands.size());
|
||||
for (int i = 0; i < commandCount; i++) {
|
||||
CheckCommand(realAvailableCommands[i], guessedCommands[i]);
|
||||
}
|
||||
|
||||
// Determine strategy once for consistent scoring throughout iterative deepening
|
||||
@@ -199,80 +109,23 @@ auto ShardokAIClient::StandardChooseCommandIndex(
|
||||
const AIStrategy strategy = isDefender ? AIDefenderStrategySelector::BestDefenderStrategy(
|
||||
guessedState,
|
||||
castleCoords,
|
||||
maxRounds,
|
||||
apdCache,
|
||||
battalionTypeGetter)
|
||||
settingsGetter)
|
||||
: AIAttackerStrategySelector::BestAttackerStrategy(
|
||||
playerId,
|
||||
guessedState,
|
||||
castleCoords,
|
||||
maxRounds,
|
||||
apdCache,
|
||||
alCache,
|
||||
battalionTypeGetter,
|
||||
braveWaterCost,
|
||||
settingsGetter,
|
||||
waterCrossingCommandChooser,
|
||||
realAvailableCommands);
|
||||
|
||||
// AI implementation chosen at runtime via constructor parameter
|
||||
IterativeDeepeningAI::SearchResult search_result;
|
||||
|
||||
if (aiAlgorithmType == AIAlgorithmType::MCTS) {
|
||||
#ifdef ENABLE_MCTS_DEBUG_DUMP
|
||||
// Set unique debug dump path for each action using timestamp
|
||||
const auto now = std::chrono::system_clock::now();
|
||||
const auto nowTime = std::chrono::system_clock::to_time_t(now);
|
||||
const auto nowMs =
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) %
|
||||
1000;
|
||||
|
||||
std::ostringstream pathStream;
|
||||
pathStream << "/tmp/shardok_debug_"
|
||||
<< std::put_time(std::localtime(&nowTime), "%Y%m%d_%H%M%S") << "_"
|
||||
<< std::setfill('0') << std::setw(3) << nowMs.count() << "_p"
|
||||
<< static_cast<int>(playerId) << ".txt";
|
||||
adjustedMCTSConfig.debugDumpPath = pathStream.str();
|
||||
|
||||
// Also dump the game state to a file for reproduction
|
||||
std::ostringstream statePathStream;
|
||||
statePathStream << "/tmp/shardok_state_"
|
||||
<< std::put_time(std::localtime(&nowTime), "%Y%m%d_%H%M%S") << "_"
|
||||
<< std::setfill('0') << std::setw(3) << nowMs.count() << "_p"
|
||||
<< static_cast<int>(playerId) << ".bin";
|
||||
const std::string statePath = statePathStream.str();
|
||||
|
||||
// Write the flatbuffer game state to file using SaveTo method
|
||||
if (guessedState.SaveTo(statePath)) {
|
||||
printf("Game state dumped to: %s\n", statePath.c_str());
|
||||
} else {
|
||||
printf("Failed to dump game state to: %s\n", statePath.c_str());
|
||||
}
|
||||
#endif // ENABLE_MCTS_DEBUG_DUMP
|
||||
|
||||
// Using Monte Carlo Tree Search AI (with abstraction layer)
|
||||
ShardokMCTSAI ai(
|
||||
playerId,
|
||||
isDefender,
|
||||
strategy,
|
||||
castleCoords,
|
||||
*scorer,
|
||||
apdCache,
|
||||
alCache,
|
||||
adjustedMCTSConfig);
|
||||
search_result = ai.Search(settings, guessedState, timeBudget);
|
||||
} else {
|
||||
// Using Iterative Deepening AI (default)
|
||||
IterativeDeepeningAI ai(
|
||||
playerId,
|
||||
isDefender,
|
||||
strategy,
|
||||
castleCoords,
|
||||
*scorer,
|
||||
apdCache,
|
||||
battalionTypeGetter);
|
||||
search_result =
|
||||
ai.IterativeSearch(settings, guessedState, realAvailableCommands, timeBudget);
|
||||
}
|
||||
// Use iterative deepening AI for Phase 2 implementation
|
||||
IterativeDeepeningAI
|
||||
iterativeAI(playerId, isDefender, strategy, castleCoords, apdCache, alCache);
|
||||
auto search_result =
|
||||
iterativeAI.IterativeSearch(settings, guessedState, realAvailableCommands, timeBudget);
|
||||
|
||||
CommandChoiceResults result{};
|
||||
result.chosenIndex = search_result.bestCommandIndex;
|
||||
@@ -288,12 +141,9 @@ auto ShardokAIClient::StandardChooseCommandIndex(
|
||||
result.commandCountEvaluated,
|
||||
result.availableCommandCount);
|
||||
}
|
||||
const auto chosenCommandType =
|
||||
(*realAvailableCommands)[result.chosenIndex]->GetCommandType();
|
||||
printf("ID AI: Search complete - achieved depth %d for best command %zu (%s)\n",
|
||||
printf("ID AI: Search complete - achieved depth %d for best command %zu\n",
|
||||
result.depthAchieved,
|
||||
result.chosenIndex,
|
||||
net::eagle0::shardok::common::CommandType_Name(chosenCommandType).c_str());
|
||||
result.chosenIndex);
|
||||
|
||||
fflush(stdout);
|
||||
}
|
||||
@@ -304,20 +154,19 @@ auto ShardokAIClient::StandardChooseCommandIndex(
|
||||
auto ShardokAIClient::LateRoundAttackerChooseCommandIndex(
|
||||
const GameSettingsSPtr &settings,
|
||||
const GameStateW &guessedState,
|
||||
const CommandListSPtr &realAvailableCommands) const -> CommandChoiceResults {
|
||||
const vector<CommandProto> &realAvailableCommands) const -> CommandChoiceResults {
|
||||
if (const auto dismissCommand = std::ranges::find_if(
|
||||
*realAvailableCommands,
|
||||
[](const CommandSPtr &cmd) {
|
||||
return cmd->GetCommandType() ==
|
||||
net::eagle0::shardok::common::DISMISS_UNIT_COMMAND;
|
||||
realAvailableCommands,
|
||||
[](const net::eagle0::shardok::api::CommandDescriptor &cmd) {
|
||||
return cmd.type() == net::eagle0::shardok::common::DISMISS_UNIT_COMMAND;
|
||||
});
|
||||
dismissCommand == realAvailableCommands->end()) {
|
||||
dismissCommand == realAvailableCommands.end()) {
|
||||
return StandardChooseCommandIndex(settings, guessedState, realAvailableCommands);
|
||||
} else {
|
||||
CommandChoiceResults results{};
|
||||
results.chosenIndex =
|
||||
static_cast<size_t>(std::distance(realAvailableCommands->begin(), dismissCommand));
|
||||
results.availableCommandCount = realAvailableCommands->size();
|
||||
static_cast<size_t>(std::distance(realAvailableCommands.begin(), dismissCommand));
|
||||
results.availableCommandCount = realAvailableCommands.size();
|
||||
results.depthAchieved = 1; // Simple heuristic choice
|
||||
results.commandCountEvaluated = 1; // Only evaluated one command type
|
||||
results.completionReason =
|
||||
@@ -329,31 +178,24 @@ auto ShardokAIClient::LateRoundAttackerChooseCommandIndex(
|
||||
auto ShardokAIClient::FinalRoundAttackerChooseCommandIndex(
|
||||
const GameSettingsSPtr &settings,
|
||||
const GameStateW &guessedState,
|
||||
const CommandListSPtr &realAvailableCommands) const -> CommandChoiceResults {
|
||||
const auto fleeCommand =
|
||||
std::ranges::find_if(*realAvailableCommands, [](const CommandSPtr &cmd) {
|
||||
return cmd->GetCommandType() == net::eagle0::shardok::common::FLEE_COMMAND;
|
||||
const vector<CommandProto> &realAvailableCommands) const -> CommandChoiceResults {
|
||||
const auto fleeCommand = std::ranges::find_if(
|
||||
realAvailableCommands,
|
||||
[](const net::eagle0::shardok::api::CommandDescriptor &cmd) {
|
||||
return cmd.type() == net::eagle0::shardok::common::FLEE_COMMAND;
|
||||
});
|
||||
|
||||
if (fleeCommand == realAvailableCommands->end()) {
|
||||
if (fleeCommand == realAvailableCommands.end()) {
|
||||
return LateRoundAttackerChooseCommandIndex(settings, guessedState, realAvailableCommands);
|
||||
}
|
||||
|
||||
// Extract values directly from settings for flee decision evaluation
|
||||
const auto settingsGetter = settings->GetGetter();
|
||||
const auto maxRounds = settingsGetter.Backing().max_rounds();
|
||||
const auto minimumFleeOddsThreshold = settingsGetter.Backing().ai_minimum_flee_odds_threshold();
|
||||
const auto desperateFleeThreshold = settingsGetter.Backing().ai_desperate_flee_threshold();
|
||||
|
||||
// Use the flee decision calculator
|
||||
const auto fleeDecision = AIFleeDecisionCalculator::EvaluateFleeVsFight(
|
||||
playerId,
|
||||
settings,
|
||||
guessedState,
|
||||
realAvailableCommands,
|
||||
fleeCommand,
|
||||
maxRounds,
|
||||
minimumFleeOddsThreshold,
|
||||
desperateFleeThreshold,
|
||||
#ifdef DEBUG_FLEE_DECISIONS
|
||||
true // Enable debug logging
|
||||
#else
|
||||
@@ -364,7 +206,7 @@ auto ShardokAIClient::FinalRoundAttackerChooseCommandIndex(
|
||||
if (fleeDecision.shouldFlee) {
|
||||
CommandChoiceResults results{};
|
||||
results.chosenIndex = fleeDecision.commandIndex;
|
||||
results.availableCommandCount = realAvailableCommands->size();
|
||||
results.availableCommandCount = realAvailableCommands.size();
|
||||
results.depthAchieved = 1; // Heuristic choice
|
||||
results.commandCountEvaluated = 1; // Only evaluated one command type
|
||||
results.completionReason = EvaluationCompletionReason::RAN_OUT_OF_COMMANDS;
|
||||
@@ -378,7 +220,7 @@ auto ShardokAIClient::FinalRoundAttackerChooseCommandIndex(
|
||||
auto ShardokAIClient::ChooseCommandIndex(
|
||||
const GameSettingsSPtr &settings,
|
||||
const GameStateView &gsv,
|
||||
const CommandListSPtr &realAvailableCommands) const -> CommandChoiceResults {
|
||||
const vector<CommandProto> &realAvailableCommands) const -> CommandChoiceResults {
|
||||
static int typeChosenCount[net::eagle0::shardok::common::CommandType_MAX + 1];
|
||||
static int totalChoices = 0;
|
||||
|
||||
@@ -397,7 +239,7 @@ auto ShardokAIClient::ChooseCommandIndex(
|
||||
results = StandardChooseCommandIndex(settings, guessedState, realAvailableCommands);
|
||||
}
|
||||
|
||||
const auto chosenType = (*realAvailableCommands)[results.chosenIndex]->GetCommandType();
|
||||
const auto chosenType = realAvailableCommands[results.chosenIndex].type();
|
||||
typeChosenCount[static_cast<int>(chosenType)]++;
|
||||
totalChoices++;
|
||||
|
||||
@@ -423,8 +265,8 @@ auto ShardokAIClient::ChooseCommandIndex(
|
||||
|
||||
auto ShardokAIClient::ChooseCommandIndex(const ShardokEngine &engine) const
|
||||
-> CommandChoiceResults {
|
||||
if (const auto &availableCommands = engine.GetAvailableCommandsForAIPlayer(playerId);
|
||||
availableCommands->empty()) {
|
||||
if (const auto &availableCommands = engine.GetAvailableCommandProtos(playerId, false);
|
||||
availableCommands.empty()) {
|
||||
printf("no commands for player %d\n", playerId);
|
||||
throw ShardokInternalErrorException(
|
||||
"Asked to choose a command, but there are none available");
|
||||
|
||||
@@ -12,13 +12,10 @@
|
||||
#include <vector>
|
||||
|
||||
#include "src/main/cpp/net/eagle0/common/RandomGenerator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSTypes.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIConfig.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AITimeBudget.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCommandChooser.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/IterativeDeepeningAI.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator.hpp"
|
||||
#include "src/main/cpp/net/eagle0/shardok/library/ShardokCommand.hpp"
|
||||
#include "src/main/protobuf/net/eagle0/shardok/api/game_state_view.pb.h"
|
||||
|
||||
namespace shardok {
|
||||
@@ -41,55 +38,42 @@ class ShardokAIClient {
|
||||
private:
|
||||
const PlayerId playerId;
|
||||
const bool isDefender;
|
||||
const AIAlgorithmType aiAlgorithmType;
|
||||
const ScoringCalculatorType scoringCalculatorType;
|
||||
|
||||
APDCache apdCache = std::make_shared<ActionPointDistancesCache>();
|
||||
ALCache alCache;
|
||||
|
||||
const AIWaterCrossingCommandChooser waterCrossingCommandChooser;
|
||||
|
||||
// MCTS configuration (only used when aiAlgorithmType == MCTS)
|
||||
mcts::MCTSConfig mctsConfig;
|
||||
|
||||
[[nodiscard]] auto StandardChooseCommandIndex(
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& guessedState,
|
||||
const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;
|
||||
const vector<CommandProto>& realAvailableCommands) const -> CommandChoiceResults;
|
||||
[[nodiscard]] auto LateRoundAttackerChooseCommandIndex(
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& guessedState,
|
||||
const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;
|
||||
const vector<CommandProto>& realAvailableCommands) const -> CommandChoiceResults;
|
||||
[[nodiscard]] auto FinalRoundAttackerChooseCommandIndex(
|
||||
const GameSettingsSPtr& settings,
|
||||
const GameStateW& guessedState,
|
||||
const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;
|
||||
const vector<CommandProto>& realAvailableCommands) const -> CommandChoiceResults;
|
||||
|
||||
[[nodiscard]] auto ChooseCommandIndex(
|
||||
const GameSettingsSPtr& settings,
|
||||
const net::eagle0::shardok::api::GameStateView& gsv,
|
||||
const vector<CommandProto>& realAvailableCommands) const -> CommandChoiceResults;
|
||||
|
||||
public:
|
||||
explicit ShardokAIClient(
|
||||
PlayerId playerId,
|
||||
bool isDefender,
|
||||
const HexMap* hexMap,
|
||||
const SettingsGetter& settings,
|
||||
AIAlgorithmType aiAlgorithmType,
|
||||
ScoringCalculatorType scoringCalculatorType,
|
||||
const mcts::MCTSConfig& mctsConfig);
|
||||
const SettingsGetter& settings);
|
||||
~ShardokAIClient() = default;
|
||||
|
||||
[[nodiscard]] auto GetPlayerId() const -> PlayerId { return playerId; }
|
||||
|
||||
[[nodiscard]] auto ChooseCommandIndex(const ShardokEngine& engine) const
|
||||
-> CommandChoiceResults;
|
||||
|
||||
// Overload that works on copies of state - allows caller to release lock during AI thinking
|
||||
[[nodiscard]] auto ChooseCommandIndex(
|
||||
const GameSettingsSPtr& settings,
|
||||
const net::eagle0::shardok::api::GameStateView& gsv,
|
||||
const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;
|
||||
|
||||
// MCTS configuration methods (only relevant when using MCTS algorithm)
|
||||
[[nodiscard]] auto GetMCTSConfig() const -> const mcts::MCTSConfig& { return mctsConfig; }
|
||||
void SetMCTSConfig(const mcts::MCTSConfig& config) { mctsConfig = config; }
|
||||
};
|
||||
} // namespace shardok
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user