different async

defer another get() (#4338 )
More wait (#4335 )
2026-07-29 01:19:44 +00:00 · 2025-08-15 06:43:19 -07:00 · 2025-08-15 06:42:18 -07:00 · 2025-08-14 21:02:20 -07:00 · 2025-08-14 20:25:25 -07:00 · 2025-08-14 19:36:30 -07:00
219 changed files with 4137 additions and 2306 deletions
@@ -4,14 +4,14 @@ bazel_dep(name = "apple_support", repo_name = "build_bazel_apple_support", versi
 # bazel-toolchain
 #

-bazel_dep(name = "toolchains_llvm", version = "1.2.0")
+bazel_dep(name = "toolchains_llvm", version = "1.4.0")

 # Configure and register the toolchain.
 llvm = use_extension("@toolchains_llvm//toolchain/extensions:llvm.bzl", "llvm")

 llvm.toolchain(
    name = "llvm_toolchain",
-    llvm_version = "19.1.0",
+    llvm_version = "20.1.2",
 )

 use_repo(llvm, "llvm_toolchain")
@@ -22,14 +22,14 @@ register_toolchains(
    dev_dependency = True,
 )

-bazel_dep(name = "rules_pkg", version = "1.0.1")
-bazel_dep(name = "bazel_skylib", version = "1.7.1")
+bazel_dep(name = "rules_pkg", version = "1.1.0")
+bazel_dep(name = "bazel_skylib", version = "1.8.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")
+bazel_dep(name = "googletest", version = "1.17.0")
+bazel_dep(name = "rules_go", repo_name = "io_bazel_rules_go", version = "0.56.1")
+bazel_dep(name = "gazelle", repo_name = "bazel_gazelle", version = "0.45.0")

 go_sdk = use_extension("@io_bazel_rules_go//go:extensions.bzl", "go_sdk")

@@ -13,7 +13,8 @@
    "https://bcr.bazel.build/modules/abseil-cpp/20240116.1/MODULE.bazel": "37bcdb4440fbb61df6a1c296ae01b327f19e9bb521f9b8e26ec854b6f97309ed",
    "https://bcr.bazel.build/modules/abseil-cpp/20240116.2/MODULE.bazel": "73939767a4686cd9a520d16af5ab440071ed75cec1a876bf2fcfaf1f71987a16",
    "https://bcr.bazel.build/modules/abseil-cpp/20240722.0/MODULE.bazel": "88668a07647adbdc14cb3a7cd116fb23c9dda37a90a1681590b6c9d8339a5b84",
-    "https://bcr.bazel.build/modules/abseil-cpp/20240722.0/source.json": "59af9f8a8a4817092624e21263fe1fb7d7951a3b06f0570c610c7e5a9caf5f29",
+    "https://bcr.bazel.build/modules/abseil-cpp/20250127.1/MODULE.bazel": "c4a89e7ceb9bf1e25cf84a9f830ff6b817b72874088bf5141b314726e46a57c1",
+    "https://bcr.bazel.build/modules/abseil-cpp/20250127.1/source.json": "03c90ee57977264436d3231676dcddae116c4769a5d02b6fc16c2c9e019b583a",
    "https://bcr.bazel.build/modules/apple_support/1.11.1/MODULE.bazel": "1843d7cd8a58369a444fc6000e7304425fba600ff641592161d9f15b179fb896",
    "https://bcr.bazel.build/modules/apple_support/1.15.1/MODULE.bazel": "a0556fefca0b1bb2de8567b8827518f94db6a6e7e7d632b4c48dc5f865bc7c85",
    "https://bcr.bazel.build/modules/apple_support/1.17.1/MODULE.bazel": "655c922ab1209978a94ef6ca7d9d43e940cd97d9c172fb55f94d91ac53f8610b",
@@ -40,6 +41,7 @@
    "https://bcr.bazel.build/modules/bazel_features/1.17.0/MODULE.bazel": "039de32d21b816b47bd42c778e0454217e9c9caac4a3cf8e15c7231ee3ddee4d",
    "https://bcr.bazel.build/modules/bazel_features/1.18.0/MODULE.bazel": "1be0ae2557ab3a72a57aeb31b29be347bcdc5d2b1eb1e70f39e3851a7e97041a",
    "https://bcr.bazel.build/modules/bazel_features/1.19.0/MODULE.bazel": "59adcdf28230d220f0067b1f435b8537dd033bfff8db21335ef9217919c7fb58",
+    "https://bcr.bazel.build/modules/bazel_features/1.21.0/MODULE.bazel": "675642261665d8eea09989aa3b8afb5c37627f1be178382c320d1b46afba5e3b",
    "https://bcr.bazel.build/modules/bazel_features/1.27.0/MODULE.bazel": "621eeee06c4458a9121d1f104efb80f39d34deff4984e778359c60eaf1a8cb65",
    "https://bcr.bazel.build/modules/bazel_features/1.27.0/source.json": "ed8cf0ef05c858dce3661689d0a2b110ff398e63994e178e4f1f7555a8067fed",
    "https://bcr.bazel.build/modules/bazel_features/1.3.0/MODULE.bazel": "cdcafe83ec318cda34e02948e81d790aab8df7a929cec6f6969f13a489ccecd9",
@@ -57,7 +59,8 @@
    "https://bcr.bazel.build/modules/bazel_skylib/1.6.1/MODULE.bazel": "8fdee2dbaace6c252131c00e1de4b165dc65af02ea278476187765e1a617b917",
    "https://bcr.bazel.build/modules/bazel_skylib/1.7.0/MODULE.bazel": "0db596f4563de7938de764cc8deeabec291f55e8ec15299718b93c4423e9796d",
    "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/MODULE.bazel": "3120d80c5861aa616222ec015332e5f8d3171e062e3e804a2a0253e1be26e59b",
-    "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/source.json": "f121b43eeefc7c29efbd51b83d08631e2347297c95aac9764a701f2a6a2bb953",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.8.1/MODULE.bazel": "88ade7293becda963e0e3ea33e7d54d3425127e0a326e0d17da085a5f1f03ff6",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.8.1/source.json": "7ebaefba0b03efe59cac88ed5bbc67bcf59a3eff33af937345ede2a38b2d368a",
    "https://bcr.bazel.build/modules/boringssl/0.0.0-20211025-d4f1ab9/MODULE.bazel": "6ee6353f8b1a701fe2178e1d925034294971350b6d3ac37e67e5a7d463267834",
    "https://bcr.bazel.build/modules/boringssl/0.0.0-20230215-5c22014/MODULE.bazel": "4b03dc0d04375fa0271174badcd202ed249870c8e895b26664fd7298abea7282",
    "https://bcr.bazel.build/modules/boringssl/0.0.0-20240530-2db0eb3/MODULE.bazel": "d0405b762c5e87cd445b7015f2b8da5400ef9a8dbca0bfefa6c1cea79d528a97",
@@ -91,8 +94,8 @@
    "https://bcr.bazel.build/modules/gazelle/0.34.0/MODULE.bazel": "abdd8ce4d70978933209db92e436deb3a8b737859e9354fb5fd11fb5c2004c8a",
    "https://bcr.bazel.build/modules/gazelle/0.36.0/MODULE.bazel": "e375d5d6e9a6ca59b0cb38b0540bc9a05b6aa926d322f2de268ad267a2ee74c0",
    "https://bcr.bazel.build/modules/gazelle/0.37.0/MODULE.bazel": "d1327ba0907d0275ed5103bfbbb13518f6c04955b402213319d0d6c0ce9839d4",
-    "https://bcr.bazel.build/modules/gazelle/0.40.0/MODULE.bazel": "42ba5378ebe845fca43989a53186ab436d956db498acde790685fe0e8f9c6146",
-    "https://bcr.bazel.build/modules/gazelle/0.40.0/source.json": "1e5ef6e4d8b9b6836d93273c781e78ff829ea2e077afef7a57298040fa4f010a",
+    "https://bcr.bazel.build/modules/gazelle/0.45.0/MODULE.bazel": "ecd19ebe9f8e024e1ccffb6d997cc893a974bcc581f1ae08f386bdd448b10687",
+    "https://bcr.bazel.build/modules/gazelle/0.45.0/source.json": "111d182facc5f5e80f0b823d5f077b74128f40c3fd2eccc89a06f34191bd3392",
    "https://bcr.bazel.build/modules/google_benchmark/1.8.2/MODULE.bazel": "a70cf1bba851000ba93b58ae2f6d76490a9feb74192e57ab8e8ff13c34ec50cb",
    "https://bcr.bazel.build/modules/google_benchmark/1.8.4/MODULE.bazel": "c6d54a11dcf64ee63545f42561eda3fd94c1b5f5ebe1357011de63ae33739d5e",
    "https://bcr.bazel.build/modules/google_benchmark/1.8.5/MODULE.bazel": "9ba9b31b984022828a950e3300410977eda2e35df35584c6b0b2d0c2e52766b7",
@@ -104,7 +107,8 @@
    "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/MODULE.bazel": "22c31a561553727960057361aa33bf20fb2e98584bc4fec007906e27053f80c6",
    "https://bcr.bazel.build/modules/googletest/1.14.0/MODULE.bazel": "cfbcbf3e6eac06ef9d85900f64424708cc08687d1b527f0ef65aa7517af8118f",
    "https://bcr.bazel.build/modules/googletest/1.15.2/MODULE.bazel": "6de1edc1d26cafb0ea1a6ab3f4d4192d91a312fd2d360b63adaa213cd00b2108",
-    "https://bcr.bazel.build/modules/googletest/1.15.2/source.json": "dbdda654dcb3a0d7a8bc5d0ac5fc7e150b58c2a986025ae5bc634bb2cb61f470",
+    "https://bcr.bazel.build/modules/googletest/1.17.0/MODULE.bazel": "dbec758171594a705933a29fcf69293d2468c49ec1f2ebca65c36f504d72df46",
+    "https://bcr.bazel.build/modules/googletest/1.17.0/source.json": "38e4454b25fc30f15439c0378e57909ab1fd0a443158aa35aec685da727cd713",
    "https://bcr.bazel.build/modules/grpc-java/1.62.2/MODULE.bazel": "99b8771e8c7cacb130170fed2a10c9e8fed26334a93e73b42d2953250885a158",
    "https://bcr.bazel.build/modules/grpc-java/1.66.0/MODULE.bazel": "86ff26209fac846adb89db11f3714b3dc0090fb2fb81575673cc74880cda4e7e",
    "https://bcr.bazel.build/modules/grpc-java/1.69.0/MODULE.bazel": "53887af6a00b3b406d70175d3d07e84ea9362016ff55ea90b9185f0227bfaf98",
@@ -146,14 +150,18 @@
    "https://bcr.bazel.build/modules/opentelemetry-proto/1.5.0/source.json": "046b721ce203e88cdaad44d7dd17a86b7200eab9388b663b234e72e13ff7b143",
    "https://bcr.bazel.build/modules/opentracing-cpp/1.6.0/MODULE.bazel": "b3925269f63561b8b880ae7cf62ccf81f6ece55b62cd791eda9925147ae116ec",
    "https://bcr.bazel.build/modules/opentracing-cpp/1.6.0/source.json": "da1cb1add160f5e5074b7272e9db6fd8f1b3336c15032cd0a653af9d2f484aed",
+    "https://bcr.bazel.build/modules/package_metadata/0.0.5/MODULE.bazel": "ef4f9439e3270fdd6b9fd4dbc3d2f29d13888e44c529a1b243f7a31dfbc2e8e4",
+    "https://bcr.bazel.build/modules/package_metadata/0.0.5/source.json": "2326db2f6592578177751c3e1f74786b79382cd6008834c9d01ec865b9126a85",
    "https://bcr.bazel.build/modules/platforms/0.0.10/MODULE.bazel": "8cb8efaf200bdeb2150d93e162c40f388529a25852b332cec879373771e48ed5",
-    "https://bcr.bazel.build/modules/platforms/0.0.10/source.json": "f22828ff4cf021a6b577f1bf6341cb9dcd7965092a439f64fc1bb3b7a5ae4bd5",
+    "https://bcr.bazel.build/modules/platforms/0.0.11/MODULE.bazel": "0daefc49732e227caa8bfa834d65dc52e8cc18a2faf80df25e8caea151a9413f",
    "https://bcr.bazel.build/modules/platforms/0.0.4/MODULE.bazel": "9b328e31ee156f53f3c416a64f8491f7eb731742655a47c9eec4703a71644aee",
    "https://bcr.bazel.build/modules/platforms/0.0.5/MODULE.bazel": "5733b54ea419d5eaf7997054bb55f6a1d0b5ff8aedf0176fef9eea44f3acda37",
    "https://bcr.bazel.build/modules/platforms/0.0.6/MODULE.bazel": "ad6eeef431dc52aefd2d77ed20a4b353f8ebf0f4ecdd26a807d2da5aa8cd0615",
    "https://bcr.bazel.build/modules/platforms/0.0.7/MODULE.bazel": "72fd4a0ede9ee5c021f6a8dd92b503e089f46c227ba2813ff183b71616034814",
    "https://bcr.bazel.build/modules/platforms/0.0.8/MODULE.bazel": "9f142c03e348f6d263719f5074b21ef3adf0b139ee4c5133e2aa35664da9eb2d",
    "https://bcr.bazel.build/modules/platforms/0.0.9/MODULE.bazel": "4a87a60c927b56ddd67db50c89acaa62f4ce2a1d2149ccb63ffd871d5ce29ebc",
+    "https://bcr.bazel.build/modules/platforms/1.0.0/MODULE.bazel": "f05feb42b48f1b3c225e4ccf351f367be0371411a803198ec34a389fb22aa580",
+    "https://bcr.bazel.build/modules/platforms/1.0.0/source.json": "f4ff1fd412e0246fd38c82328eb209130ead81d62dcd5a9e40910f867f733d96",
    "https://bcr.bazel.build/modules/prometheus-cpp/1.2.4/MODULE.bazel": "0fbe5dcff66311947a3f6b86ebc6a6d9328e31a28413ca864debc4a043f371e5",
    "https://bcr.bazel.build/modules/prometheus-cpp/1.3.0/MODULE.bazel": "ce82e086bbc0b60267e970f6a54b2ca6d0f22d3eb6633e00e2cc2899c700f3d8",
    "https://bcr.bazel.build/modules/prometheus-cpp/1.3.0/source.json": "8cb66b4e535afc718e9d104a3db96ccb71a42ee816a100e50fd0d5ac843c0606",
@@ -166,7 +174,9 @@
    "https://bcr.bazel.build/modules/protobuf/27.0-rc2/MODULE.bazel": "b2b0dbafd57b6bec0ca9b251da02e628c357dab53a097570aa7d79d020f107cf",
    "https://bcr.bazel.build/modules/protobuf/27.0/MODULE.bazel": "7873b60be88844a0a1d8f80b9d5d20cfbd8495a689b8763e76c6372998d3f64c",
    "https://bcr.bazel.build/modules/protobuf/27.1/MODULE.bazel": "703a7b614728bb06647f965264967a8ef1c39e09e8f167b3ca0bb1fd80449c0d",
+    "https://bcr.bazel.build/modules/protobuf/29.0-rc2.bcr.1/MODULE.bazel": "52f4126f63a2f0bbf36b99c2a87648f08467a4eaf92ba726bc7d6a500bbf770c",
    "https://bcr.bazel.build/modules/protobuf/29.0-rc2/MODULE.bazel": "6241d35983510143049943fc0d57937937122baf1b287862f9dc8590fc4c37df",
+    "https://bcr.bazel.build/modules/protobuf/29.0-rc3/MODULE.bazel": "33c2dfa286578573afc55a7acaea3cada4122b9631007c594bf0729f41c8de92",
    "https://bcr.bazel.build/modules/protobuf/29.0/MODULE.bazel": "319dc8bf4c679ff87e71b1ccfb5a6e90a6dbc4693501d471f48662ac46d04e4e",
    "https://bcr.bazel.build/modules/protobuf/29.2/MODULE.bazel": "5435497c190d86f79b0568698c45044df7c8d97692886cda9fe9cf9053aea712",
    "https://bcr.bazel.build/modules/protobuf/29.2/source.json": "fe7090cc34072609b26d9beafb122916dabc1d47ba61b242c26c4b06c51384ab",
@@ -185,8 +195,9 @@
    "https://bcr.bazel.build/modules/re2/2021-09-01/MODULE.bazel": "bcb6b96f3b071e6fe2d8bed9cc8ada137a105f9d2c5912e91d27528b3d123833",
    "https://bcr.bazel.build/modules/re2/2023-09-01/MODULE.bazel": "cb3d511531b16cfc78a225a9e2136007a48cf8a677e4264baeab57fe78a80206",
    "https://bcr.bazel.build/modules/re2/2024-05-01/MODULE.bazel": "55a3f059538f381107824e7d00df5df6d061ba1fb80e874e4909c0f0549e8f3e",
+    "https://bcr.bazel.build/modules/re2/2024-07-02.bcr.1/MODULE.bazel": "b4963dda9b31080be1905ef085ecd7dd6cd47c05c79b9cdf83ade83ab2ab271a",
+    "https://bcr.bazel.build/modules/re2/2024-07-02.bcr.1/source.json": "2ff292be6ef3340325ce8a045ecc326e92cbfab47c7cbab4bd85d28971b97ac4",
    "https://bcr.bazel.build/modules/re2/2024-07-02/MODULE.bazel": "0eadc4395959969297cbcf31a249ff457f2f1d456228c67719480205aa306daa",
-    "https://bcr.bazel.build/modules/re2/2024-07-02/source.json": "547d0111a9d4f362db32196fef805abbf3676e8d6afbe44d395d87816c1130ca",
    "https://bcr.bazel.build/modules/rules_android/0.1.1/MODULE.bazel": "48809ab0091b07ad0182defb787c4c5328bd3a278938415c00a7b69b50c4d3a8",
    "https://bcr.bazel.build/modules/rules_android/0.1.1/source.json": "e6986b41626ee10bdc864937ffb6d6bf275bb5b9c65120e6137d56e6331f089e",
    "https://bcr.bazel.build/modules/rules_apple/3.16.0/MODULE.bazel": "0d1caf0b8375942ce98ea944be754a18874041e4e0459401d925577624d3a54a",
@@ -220,7 +231,9 @@
    "https://bcr.bazel.build/modules/rules_go/0.46.0/MODULE.bazel": "3477df8bdcc49e698b9d25f734c4f3a9f5931ff34ee48a2c662be168f5f2d3fd",
    "https://bcr.bazel.build/modules/rules_go/0.48.0/MODULE.bazel": "d00ebcae0908ee3f5e6d53f68677a303d6d59a77beef879598700049c3980a03",
    "https://bcr.bazel.build/modules/rules_go/0.50.1/MODULE.bazel": "b91a308dc5782bb0a8021ad4330c81fea5bda77f96b9e4c117b9b9c8f6665ee0",
-    "https://bcr.bazel.build/modules/rules_go/0.50.1/source.json": "205765fd30216c70321f84c9a967267684bdc74350af3f3c46c857d9f80a4fa2",
+    "https://bcr.bazel.build/modules/rules_go/0.53.0/MODULE.bazel": "a4ed760d3ac0dbc0d7b967631a9a3fd9100d28f7d9fcf214b4df87d4bfff5f9a",
+    "https://bcr.bazel.build/modules/rules_go/0.56.1/MODULE.bazel": "d5b835c548ac917345f1780cd2da52edc1130a908fe091c92096895303ae78a0",
+    "https://bcr.bazel.build/modules/rules_go/0.56.1/source.json": "0c902f7272e8d4e47e459af97be472bc19dadbbe6023a0719d1adce8483ac75a",
    "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74",
    "https://bcr.bazel.build/modules/rules_java/5.1.0/MODULE.bazel": "324b6478b0343a3ce7a9add8586ad75d24076d6d43d2f622990b9c1cfd8a1b15",
    "https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86",
@@ -232,12 +245,14 @@
    "https://bcr.bazel.build/modules/rules_java/7.1.0/MODULE.bazel": "30d9135a2b6561c761bd67bd4990da591e6bdc128790ce3e7afd6a3558b2fb64",
    "https://bcr.bazel.build/modules/rules_java/7.10.0/MODULE.bazel": "530c3beb3067e870561739f1144329a21c851ff771cd752a49e06e3dc9c2e71a",
    "https://bcr.bazel.build/modules/rules_java/7.12.2/MODULE.bazel": "579c505165ee757a4280ef83cda0150eea193eed3bef50b1004ba88b99da6de6",
-    "https://bcr.bazel.build/modules/rules_java/7.12.2/source.json": "b0890f9cda8ff1b8e691a3ac6037b5c14b7fd4134765a3946b89f31ea02e5884",
    "https://bcr.bazel.build/modules/rules_java/7.2.0/MODULE.bazel": "06c0334c9be61e6cef2c8c84a7800cef502063269a5af25ceb100b192453d4ab",
    "https://bcr.bazel.build/modules/rules_java/7.3.2/MODULE.bazel": "50dece891cfdf1741ea230d001aa9c14398062f2b7c066470accace78e412bc2",
    "https://bcr.bazel.build/modules/rules_java/7.4.0/MODULE.bazel": "a592852f8a3dd539e82ee6542013bf2cadfc4c6946be8941e189d224500a8934",
    "https://bcr.bazel.build/modules/rules_java/7.6.1/MODULE.bazel": "2f14b7e8a1aa2f67ae92bc69d1ec0fa8d9f827c4e17ff5e5f02e91caa3b2d0fe",
    "https://bcr.bazel.build/modules/rules_java/7.6.5/MODULE.bazel": "481164be5e02e4cab6e77a36927683263be56b7e36fef918b458d7a8a1ebadb1",
+    "https://bcr.bazel.build/modules/rules_java/8.3.2/MODULE.bazel": "7336d5511ad5af0b8615fdc7477535a2e4e723a357b6713af439fe8cf0195017",
+    "https://bcr.bazel.build/modules/rules_java/8.5.1/MODULE.bazel": "d8a9e38cc5228881f7055a6079f6f7821a073df3744d441978e7a43e20226939",
+    "https://bcr.bazel.build/modules/rules_java/8.5.1/source.json": "db1a77d81b059e0f84985db67a22f3f579a529a86b7997605be3d214a0abe38e",
    "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/MODULE.bazel": "a56b85e418c83eb1839819f0b515c431010160383306d13ec21959ac412d2fe7",
    "https://bcr.bazel.build/modules/rules_jvm_external/5.1/MODULE.bazel": "33f6f999e03183f7d088c9be518a63467dfd0be94a11d0055fe2d210f89aa909",
    "https://bcr.bazel.build/modules/rules_jvm_external/5.2/MODULE.bazel": "d9351ba35217ad0de03816ef3ed63f89d411349353077348a45348b096615036",
@@ -259,7 +274,8 @@
    "https://bcr.bazel.build/modules/rules_nodejs/6.3.3/source.json": "45bd343155bdfed2543f0e39b80ff3f6840efc31975da4b5795797f4c94147ad",
    "https://bcr.bazel.build/modules/rules_pkg/0.7.0/MODULE.bazel": "df99f03fc7934a4737122518bb87e667e62d780b610910f0447665a7e2be62dc",
    "https://bcr.bazel.build/modules/rules_pkg/1.0.1/MODULE.bazel": "5b1df97dbc29623bccdf2b0dcd0f5cb08e2f2c9050aab1092fd39a41e82686ff",
-    "https://bcr.bazel.build/modules/rules_pkg/1.0.1/source.json": "bd82e5d7b9ce2d31e380dd9f50c111d678c3bdaca190cb76b0e1c71b05e1ba8a",
+    "https://bcr.bazel.build/modules/rules_pkg/1.1.0/MODULE.bazel": "9db8031e71b6ef32d1846106e10dd0ee2deac042bd9a2de22b4761b0c3036453",
+    "https://bcr.bazel.build/modules/rules_pkg/1.1.0/source.json": "fef768df13a92ce6067e1cd0cdc47560dace01354f1d921cfb1d632511f7d608",
    "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06",
    "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7",
    "https://bcr.bazel.build/modules/rules_proto/6.0.0-rc1/MODULE.bazel": "1e5b502e2e1a9e825eef74476a5a1ee524a92297085015a052510b09a1a09483",
@@ -281,7 +297,8 @@
    "https://bcr.bazel.build/modules/rules_python/0.37.1/MODULE.bazel": "3faeb2d9fa0a81f8980643ee33f212308f4d93eea4b9ce6f36d0b742e71e9500",
    "https://bcr.bazel.build/modules/rules_python/0.4.0/MODULE.bazel": "9208ee05fd48bf09ac60ed269791cf17fb343db56c8226a720fbb1cdf467166c",
    "https://bcr.bazel.build/modules/rules_python/0.40.0/MODULE.bazel": "9d1a3cd88ed7d8e39583d9ffe56ae8a244f67783ae89b60caafc9f5cf318ada7",
-    "https://bcr.bazel.build/modules/rules_python/0.40.0/source.json": "939d4bd2e3110f27bfb360292986bb79fd8dcefb874358ccd6cdaa7bda029320",
+    "https://bcr.bazel.build/modules/rules_python/1.0.0/MODULE.bazel": "898a3d999c22caa585eb062b600f88654bf92efb204fa346fb55f6f8edffca43",
+    "https://bcr.bazel.build/modules/rules_python/1.0.0/source.json": "b0162a65c6312e45e7912e39abd1a7f8856c2c7e41ecc9b6dc688a6f6400a917",
    "https://bcr.bazel.build/modules/rules_shell/0.2.0/MODULE.bazel": "fda8a652ab3c7d8fee214de05e7a9916d8b28082234e8d2c0094505c5268ed3c",
    "https://bcr.bazel.build/modules/rules_shell/0.3.0/MODULE.bazel": "de4402cd12f4cc8fda2354fce179fdb068c0b9ca1ec2d2b17b3e21b24c1a937b",
    "https://bcr.bazel.build/modules/rules_shell/0.3.0/source.json": "c55ed591aa5009401ddf80ded9762ac32c358d2517ee7820be981e2de9756cf3",
@@ -297,11 +314,12 @@
    "https://bcr.bazel.build/modules/stardoc/0.6.2/MODULE.bazel": "7060193196395f5dd668eda046ccbeacebfd98efc77fed418dbe2b82ffaa39fd",
    "https://bcr.bazel.build/modules/stardoc/0.7.0/MODULE.bazel": "05e3d6d30c099b6770e97da986c53bd31844d7f13d41412480ea265ac9e8079c",
    "https://bcr.bazel.build/modules/stardoc/0.7.1/MODULE.bazel": "3548faea4ee5dda5580f9af150e79d0f6aea934fc60c1cc50f4efdd9420759e7",
-    "https://bcr.bazel.build/modules/stardoc/0.7.1/source.json": "b6500ffcd7b48cd72c29bb67bcac781e12701cc0d6d55d266a652583cfcdab01",
+    "https://bcr.bazel.build/modules/stardoc/0.7.2/MODULE.bazel": "fc152419aa2ea0f51c29583fab1e8c99ddefd5b3778421845606ee628629e0e5",
+    "https://bcr.bazel.build/modules/stardoc/0.7.2/source.json": "58b029e5e901d6802967754adf0a9056747e8176f017cfe3607c0851f4d42216",
    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.1/MODULE.bazel": "5e463fbfba7b1701d957555ed45097d7f984211330106ccd1352c6e0af0dcf91",
    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.1/source.json": "32bd87e5f4d7acc57c5b2ff7c325ae3061d5e242c0c4c214ae87e0f1c13e54cb",
-    "https://bcr.bazel.build/modules/toolchains_llvm/1.2.0/MODULE.bazel": "7b271b71e50de47fa47159a7f58165e80fcebe1196c014a14af0a08a867d1635",
-    "https://bcr.bazel.build/modules/toolchains_llvm/1.2.0/source.json": "0328cfc67075d6a016980be4011bbc1dcfba933e357568002542dff22abdd3a1",
+    "https://bcr.bazel.build/modules/toolchains_llvm/1.4.0/MODULE.bazel": "05239402b7374293359c2f22806f420b75aa5d6f4b15a2eaa809a2c214d58b31",
+    "https://bcr.bazel.build/modules/toolchains_llvm/1.4.0/source.json": "229a516d282b17a82be54c6e3ae220a1b750fb55a8495567e5c7a9d09423f3e2",
    "https://bcr.bazel.build/modules/upb/0.0.0-20211020-160625a/MODULE.bazel": "6cced416be2dc5b9c05efd5b997049ba795e5e4e6fafbe1624f4587767638928",
    "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/MODULE.bazel": "7298990c00040a0e2f121f6c32544bab27d4452f80d9ce51349b1a28f3005c43",
    "https://bcr.bazel.build/modules/upb/0.0.0-20230516-61a97ef/MODULE.bazel": "c0df5e35ad55e264160417fd0875932ee3c9dda63d9fccace35ac62f45e1b6f9",
@@ -663,23 +681,6 @@
        "recordedRepoMappingEntries": []
      }
    },
-    "@@platforms//host:extension.bzl%host_platform": {
-      "general": {
-        "bzlTransitiveDigest": "xelQcPZH8+tmuOHVjL9vDxMnnQNMlwj0SlvgoqBkm4U=",
-        "usagesDigest": "ibwLwKXW2CiKpWzexj5KO6SHidEgCwJvu+ebsPxirn4=",
-        "recordedFileInputs": {},
-        "recordedDirentsInputs": {},
-        "envVariables": {},
-        "generatedRepoSpecs": {
-          "host_platform": {
-            "bzlFile": "@@platforms//host:extension.bzl",
-            "ruleClassName": "host_platform_repo",
-            "attributes": {}
-          }
-        },
-        "recordedRepoMappingEntries": []
-      }
-    },
    "@@rules_foreign_cc~//foreign_cc:extensions.bzl%tools": {
      "general": {
        "bzlTransitiveDigest": "a7qnESofmIRYId6wwGNPJ9kvExU80KrkxL281P3+lBE=",
@@ -1020,6 +1021,29 @@
        ]
      }
    },
+    "@@rules_java~//java:rules_java_deps.bzl%compatibility_proxy": {
+      "general": {
+        "bzlTransitiveDigest": "KIX40nDfygEWbU+rq3nYpt3tVgTK/iO8PKh5VMBlN7M=",
+        "usagesDigest": "pwHZ+26iLgQdwvdZeA5wnAjKnNI3y6XO2VbhOTeo5h8=",
+        "recordedFileInputs": {},
+        "recordedDirentsInputs": {},
+        "envVariables": {},
+        "generatedRepoSpecs": {
+          "compatibility_proxy": {
+            "bzlFile": "@@rules_java~//java:rules_java_deps.bzl",
+            "ruleClassName": "_compatibility_proxy_repo_rule",
+            "attributes": {}
+          }
+        },
+        "recordedRepoMappingEntries": [
+          [
+            "rules_java~",
+            "bazel_tools",
+            "bazel_tools"
+          ]
+        ]
+      }
+    },
    "@@rules_kotlin~//src/main/starlark/core/repositories:bzlmod_setup.bzl%rules_kotlin_extensions": {
      "general": {
        "bzlTransitiveDigest": "fus14IFJ/1LGWWGKPH/U18VnJCoMjfDt1ckahqCnM0A=",
@@ -1389,8 +1413,8 @@
    },
    "@@toolchains_llvm~//toolchain/extensions:llvm.bzl%llvm": {
      "general": {
-        "bzlTransitiveDigest": "dZkcElkfice3BvKPXtFwrvPABm8ac+SwfynSinwK4dQ=",
-        "usagesDigest": "Phpqeo3bkW3l2tD5aOSKApubwu0KPfl0KuPgjY6+ueM=",
+        "bzlTransitiveDigest": "afRF0aFOIUrkYl3o040WQ606ep1qciEXzjnAxT3Kek8=",
+        "usagesDigest": "wl2njI0HdPm89XuKGMWIa1gyCAQ5gvOs+ksjFd4QbZs=",
        "recordedFileInputs": {},
        "recordedDirentsInputs": {},
        "envVariables": {},
@@ -1404,8 +1428,9 @@
              "distribution": "auto",
              "exec_arch": "",
              "exec_os": "",
+              "libclang_rt": {},
              "llvm_mirror": "",
-              "llvm_version": "19.1.0",
+              "llvm_version": "20.1.2",
              "llvm_versions": {},
              "netrc": "",
              "sha256": {},
@@ -1420,6 +1445,7 @@
              "absolute_paths": false,
              "archive_flags": {},
              "compile_flags": {},
+              "conly_flags": {},
              "coverage_compile_flags": {},
              "coverage_link_flags": {},
              "cxx_builtin_include_directories": {},
@@ -1433,7 +1459,7 @@
              "link_flags": {},
              "link_libs": {},
              "llvm_versions": {
-                "": "19.1.0"
+                "": "20.1.2"
              },
              "opt_compile_flags": {},
              "opt_link_flags": {},
@@ -22,13 +22,6 @@ 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"],
@@ -1,173 +0,0 @@
-//
-// 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
@@ -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(size);
+    auto bv = byte_vector(static_cast<size_t>(size));
    inputFileStream.read((char*)bv.data(), size);

    return bv;
@@ -84,7 +84,9 @@ auto RandomGenerator::ChanceOpenEndedPercentileAtOrAbove(const double value) ->

 auto StdLibraryGenerator::DoubleZeroToOne() -> double { return unifDouble(engine); }

-StdLibraryGenerator::StdLibraryGenerator() : RandomGenerator() { engine.seed(std::time(nullptr)); }
+StdLibraryGenerator::StdLibraryGenerator() : RandomGenerator() {
+    engine.seed(static_cast<std::mt19937_64::result_type>(std::time(nullptr)));
+}

 auto StdLibraryGenerator::IntBetween(const int min, const int max) -> int {
    std::uniform_int_distribution<int> unifInt(min, max - 1);
@@ -8,6 +8,8 @@ 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{};

@@ -15,9 +17,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(battalion.morale());
-    shardokBattalion.mutate_armament(battalion.armament());
-    shardokBattalion.mutate_training(battalion.training());
+    shardokBattalion.mutate_morale(kDefaultMorale);
+    shardokBattalion.mutate_armament(static_cast<float>(battalion.armament()));
+    shardokBattalion.mutate_training(static_cast<float>(battalion.training()));

    return shardokBattalion;
 }
@@ -37,28 +39,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(hero.strength());
-    shardokHero.mutate_strength_xp(hero.strength_xp());
+    shardokHero.mutate_strength(static_cast<int8_t>(hero.strength()));
+    shardokHero.mutate_strength_xp(static_cast<int16_t>(hero.strength_xp()));

-    shardokHero.mutate_agility(hero.agility());
-    shardokHero.mutate_agility_xp(hero.agility_xp());
+    shardokHero.mutate_agility(static_cast<int8_t>(hero.agility()));
+    shardokHero.mutate_agility_xp(static_cast<int16_t>(hero.agility_xp()));

-    shardokHero.mutate_constitution(hero.constitution());
-    shardokHero.mutate_constitution_xp(hero.constitution_xp());
+    shardokHero.mutate_constitution(static_cast<int8_t>(hero.constitution()));
+    shardokHero.mutate_constitution_xp(static_cast<int16_t>(hero.constitution_xp()));

-    shardokHero.mutate_charisma(hero.charisma());
-    shardokHero.mutate_charisma_xp(hero.charisma_xp());
+    shardokHero.mutate_charisma(static_cast<int8_t>(hero.charisma()));
+    shardokHero.mutate_charisma_xp(static_cast<int16_t>(hero.charisma_xp()));

-    shardokHero.mutate_wisdom(hero.wisdom());
-    shardokHero.mutate_wisdom_xp(hero.wisdom_xp());
+    shardokHero.mutate_wisdom(static_cast<int8_t>(hero.wisdom()));
+    shardokHero.mutate_wisdom_xp(static_cast<int16_t>(hero.wisdom_xp()));

-    shardokHero.mutate_integrity(hero.integrity());
-    shardokHero.mutate_ambition(hero.ambition());
-    shardokHero.mutate_gregariousness(hero.gregariousness());
-    shardokHero.mutate_bravery(hero.bravery());
+    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_vigor(hero.vigor());
-    shardokHero.mutate_starting_vigor(hero.vigor());
+    shardokHero.mutate_vigor(static_cast<float>(hero.vigor()));
+    shardokHero.mutate_starting_vigor(static_cast<float>(hero.vigor()));

    return shardokHero;
 }
@@ -93,19 +95,22 @@ auto ConvertUnit(
    shardokUnit.mutate_stun_rounds_remaining(0);

    for (const PlayerId pid : allPlayerIds) {
-        shardokUnit.mutable_opponent_knowledge()->Mutate(pid, 0);
+        shardokUnit.mutable_opponent_knowledge()->Mutate(
+                static_cast<flatbuffers::uoffset_t>(pid),
+                0);
    }

    shardokUnit.mutate_has_moved_in_zoc(false);
    shardokUnit.mutate_targeted_unit(-1);
    shardokUnit.mutate_volleys_remaining(0);
-    shardokUnit.mutate_food_remaining(unit.food());
+    shardokUnit.mutate_food_remaining(static_cast<float>(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(unit.starting_position_index().value());
+        shardokUnit.mutate_starting_position_index(
+                static_cast<int8_t>(unit.starting_position_index().value()));
    } else {
        shardokUnit.mutate_starting_position_index(-1);
    }
@@ -9,7 +9,10 @@

 #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 {

@@ -36,7 +36,7 @@ auto CalculateMap(
            .name = mapName,
            .positionsRequiringCrossing = {}};

-    for (int i = 0; i < hexMap->attacker_starting_positions()->size(); i++) {
+    for (unsigned 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,7 +5,9 @@
 #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,6 +3,7 @@
 //

 #include <iostream>
+#include <memory>

 #include "MapInfoCalculator.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
@@ -52,7 +53,7 @@ auto main(const int argc, char** argv) -> int {
        outputStream << "    \"positions\": {";

        bool firstPosition = true;
-        for (const auto& kv : mapInfo.positionsRequiringCrossing) {
+        for (const auto& [position, count] : mapInfo.positionsRequiringCrossing) {
            if (firstPosition) {
                outputStream << endl;
                firstPosition = false;
@@ -60,7 +61,7 @@ auto main(const int argc, char** argv) -> int {
                outputStream << "," << endl;
            }

-            outputStream << "      \"" << kv.first << "\": " << kv.second;
+            outputStream << "      \"" << position << "\": " << count;
        }
        outputStream << endl << "    }" << endl << "  }";
    }
@@ -4,6 +4,8 @@

 #include "AIAttackGroups.hpp"

+#include <iterator>
+#include <ranges>
 #include <unordered_map>

 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
@@ -221,11 +223,15 @@ auto GenerateTargetPriorities(
                    Power(unit);
        }

-        tpl.priorityOrder = common::Map(targetsWithDistance, [](const TargetAndDistance& tad) {
-            return TargetAndAttackLocations{
-                    .target = tad.target,
-                    .attackLocations = tad.attackLocations};
-        });
+        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};
+                });
    }

    return allTargetsUnitsAndDistances;
@@ -4,6 +4,7 @@

 #include "AIAttackerStrategySelector.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"

@@ -11,21 +12,21 @@ namespace shardok {

 using Unit = net::eagle0::shardok::storage::fb::Unit;

-constexpr double MAXIMUM_RATIO_FOR_ATTACKER_TO_FLEE = 0.50;
+// 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;

 auto AIAttackerStrategySelector::BestAttackerStrategy(
        const PlayerId attackerPid,
-        const net::eagle0::shardok::storage::fb::GameState* gameState,
+        const GameStateW& gameState,
        const CoordsSet& criticalTileCoords,
        const APDCache& apdCache,
        const ALCache& alCache,
        const SettingsGetter& settings,
        const AIWaterCrossingCommandChooser& waterCrossingCommandChooser,
-        const vector<CommandProto>& 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{};
@@ -40,8 +41,6 @@ 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;
                    }
@@ -50,7 +49,6 @@ 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 {
@@ -60,7 +58,13 @@ auto AIAttackerStrategySelector::BestAttackerStrategy(
    }

    AIStrategy chosenStrategy;
-    if (canFlee && attackerTroops < MAXIMUM_RATIO_FOR_ATTACKER_TO_FLEE * defenderTroops) {
+
+    // Use sophisticated combat success estimation instead of simple troop ratio
+    if (canFlee && AIFleeDecisionCalculator::ShouldConsiderFleeing(
+                           attackerPid,
+                           gameState,
+                           settings,
+                           FLEE_CONSIDERATION_THRESHOLD)) {
        chosenStrategy = FleeStrategy;
    } else if (const CoordsSet startCrossingLocations =
                       waterCrossingCommandChooser
@@ -8,18 +8,16 @@
 #include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIWaterCrossingCommandChooser.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.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 GameState* gameState,
+            const GameStateW& gameState,
            const CoordsSet& criticalTileCoords,
            const APDCache& apdCache,
            const ALCache& alCache,
@@ -20,8 +20,8 @@ CoordsSet AICommandFilter::BuildEnemyLocations(const GameStateW& gameState, Play
    CoordsSet enemyLocations(gameState->hex_map());
    const auto* units = gameState->units();

-    for (int i = 0; i < units->size(); ++i) {
-        const auto* unit = units->Get(i);
+    for (size_t i = 0; i < units->size(); ++i) {
+        const auto* unit = units->Get(static_cast<unsigned int>(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());
@@ -486,12 +486,12 @@ bool AICommandFilter::IsWastefulMovement(
 }

 bool AICommandFilter::IsStrategicBlunder(
-        const ShardokCommand& cmd,
-        PlayerId pid,
-        bool isDefender,
-        const GameStateW& gameState,
-        const SettingsGetter& settings,
-        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
@@ -506,8 +506,8 @@ double AICommandFilter::MinDistanceToEnemyUnits(
    double minDistance = std::numeric_limits<double>::max();
    const auto* units = gameState->units();

-    for (int i = 0; i < units->size(); ++i) {
-        const auto* playerUnit = units->Get(i);
+    for (size_t i = 0; i < units->size(); ++i) {
+        const auto* playerUnit = units->Get(static_cast<unsigned int>(i));
        if (playerUnit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
            playerUnit->player_id() == pid) {
            const auto& playerCoords = playerUnit->location();
@@ -537,8 +537,8 @@ double AICommandFilter::MinDistanceToCastles(
    }

    // Find minimum hex distance from any player unit to any castle
-    for (int i = 0; i < units->size(); ++i) {
-        const auto* unit = units->Get(i);
+    for (size_t i = 0; i < units->size(); ++i) {
+        const auto* unit = units->Get(static_cast<unsigned int>(i));
        if (unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
            unit->player_id() == pid) {
            const auto& unitCoords = unit->location();
@@ -572,8 +572,8 @@ int AICommandFilter::CountPlayerUnits(const GameStateW& gameState, PlayerId pid)
    int count = 0;
    const auto* units = gameState->units();

-    for (int i = 0; i < units->size(); ++i) {
-        const auto* unit = units->Get(i);
+    for (size_t i = 0; i < units->size(); ++i) {
+        const auto* unit = units->Get(static_cast<unsigned int>(i));
        if (unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
            unit->player_id() == pid) {
            count++;
@@ -584,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;
@@ -4,6 +4,9 @@

 #include "AIDefenderStrategySelector.hpp"

+#include <algorithm>
+#include <ranges>
+
 #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/library/util/HexMapUtils.hpp"
@@ -14,7 +17,7 @@ constexpr double MAXIMUM_RATIO_FOR_DEFENDER_TO_FLEE = 0.15;
 constexpr double MINIMUM_RATIO_FOR_DEFENDER_TO_HOLD = 0.60;

 auto AIDefenderStrategySelector::BestDefenderStrategy(
-        const GameState* gameState,
+        const GameStateW& gameState,
        const CoordsSet& criticalTileCoords,
        const APDCache& apdCache,
        const SettingsGetter& settings) -> AIStrategy {
@@ -57,7 +60,9 @@ auto AIDefenderStrategySelector::BestDefenderStrategy(
                    net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD) {
                    ++attackerNonUndeadUnitCount;

-                    if (!common::Contains(attackerUnitIdsRequiringWaterCrossing, unit->unit_id())) {
+                    if (!std::ranges::contains(
+                                attackerUnitIdsRequiringWaterCrossing,
+                                unit->unit_id())) {
                        ++attackerNonUndeadUnitNotRequiringWaterCrossingCount;
                    }
                }
@@ -7,16 +7,15 @@

 #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/GameStateW.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 GameState* gameState,
+            const GameStateW& gameState,
            const CoordsSet& criticalTileCoords,
            const APDCache& apdCache,
            const SettingsGetter& settings) -> AIStrategy;
@@ -0,0 +1,228 @@
+//
+//  AIFleeDecisionCalculator.cpp
+//  eagle0
+//
+//  Handles AI flee decision logic including combat success estimation
+//  and flee vs fight evaluation for final round scenarios
+//
+
+#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 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,
+        const SettingsGetter& settings) -> 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
+    }
+
+    // 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 defenderTroops = 0;
+    int attackerUnits = 0;
+    int defenderUnits = 0;
+    int attackerHeroes = 0;
+    int defenderHeroes = 0;
+    bool defenderHasVips = false;
+
+    // Calculate total power and count units/heroes for each side
+    for (const auto* unit : *gameState->units()) {
+        if (unit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT) continue;
+
+        const auto* pi = PlayerInfoForPid(gameState, 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) {
+                defenderHeroes++;
+                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 = settings.Backing().max_rounds() - gameState->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)
+    if (attackerTroops == 0) {
+        // Very difficult to win with heroes alone
+        return 0.05;  // Extremely low chance
+    }
+
+    // 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
+        } else {
+            // With 3+ rounds, capturing defenseless heroes is quite feasible
+            return 0.85;  // High probability of success
+        }
+    }
+
+    // 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));
+
+    // Adjust for time pressure - attackers need to win before time runs out
+    if (roundsRemaining <= 1) {
+        baseProbability *= 0.6;  // Severe penalty for last round
+    } else if (roundsRemaining <= 3) {
+        baseProbability *= 0.8;  // Moderate penalty
+    }
+
+    // Adjust for unit count (more units = better tactical flexibility)
+    const double unitRatio =
+            static_cast<double>(attackerUnits) / std::max(1.0, static_cast<double>(defenderUnits));
+    if (unitRatio < 0.5) {
+        baseProbability *= 0.8;
+    } else if (unitRatio > 1.5) {
+        baseProbability *= 1.15;
+    }
+
+    // Adjust for hero presence
+    if (defenderHeroes > attackerHeroes && defenderHasVips) {
+        // Defender has more heroes including VIPs - harder to capture
+        baseProbability *= 0.85;
+    }
+
+    return std::min(0.95, std::max(0.05, baseProbability));
+}
+
+auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
+        PlayerId playerId,
+        const SettingsGetter& settingsGetter,
+        const GameStateW& guessedState,
+        const vector<CommandProto>& availableCommands,
+        const vector<CommandProto>::const_iterator& fleeCommand,
+        bool enableDebugLogging) -> FleeDecision {
+    // Get flee success odds
+    const int fleeSuccessChance = fleeCommand->odds().success_chance();
+
+    // Get thresholds from settings
+    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);
+    }
+
+    // Check if flee odds are good enough to attempt
+    if (fleeSuccessChance >= minimumFleeOddsThreshold) {
+        if (enableDebugLogging) {
+            printf("AI FinalRound: Good flee odds (%d%% >= %d%%), choosing flee\n",
+                   fleeSuccessChance,
+                   minimumFleeOddsThreshold);
+        }
+        return FleeDecision{
+                true,
+                GetFleeCommandIndex(fleeCommand, availableCommands),
+                "Good flee odds"};
+    }
+
+    // Low flee odds - evaluate if fighting might be better
+    const double combatWinChance = EstimateCombatSuccess(playerId, guessedState, settingsGetter);
+
+    // If combat situation is hopeless, even bad flee odds are better than certain death
+    if (combatWinChance <= 0.05 && fleeSuccessChance >= desperateFleeThreshold) {
+        if (enableDebugLogging) {
+            printf("AI FinalRound: Combat hopeless (%.1f%%), desperate flee attempt (%d%%)\n",
+                   combatWinChance * 100,
+                   fleeSuccessChance);
+        }
+        return FleeDecision{
+                true,
+                GetFleeCommandIndex(fleeCommand, availableCommands),
+                "Combat hopeless, desperate flee"};
+    }
+
+    // Detailed flee vs fight comparison
+    const double fleeChance = static_cast<double>(fleeSuccessChance) / 100.0;
+
+    // Compare expected outcomes:
+    // - Flee: fleeChance of survival (not victory, but avoiding loss)
+    // - Fight: combatWinChance of victory (better than survival)
+
+    constexpr double FLEE_VS_COMBAT_MARGIN =
+            0.8;  // Require 80% of combat chance to prefer fighting
+    const double adjustedCombatThreshold = combatWinChance * FLEE_VS_COMBAT_MARGIN;
+
+    if (enableDebugLogging) {
+        printf("AI FinalRound: Flee=%d%%, Combat=%.1f%%, Threshold=%.1f%% -> ",
+               fleeSuccessChance,
+               combatWinChance * 100,
+               adjustedCombatThreshold * 100);
+    }
+
+    if (fleeChance > adjustedCombatThreshold) {
+        if (enableDebugLogging) { printf("FLEE (better odds)\n"); }
+        return FleeDecision{
+                true,
+                GetFleeCommandIndex(fleeCommand, availableCommands),
+                "Flee has better expected outcome"};
+    } else {
+        if (enableDebugLogging) { printf("FIGHT (better expected outcome)\n"); }
+        // Return 0 to indicate we should use standard command selection
+        return FleeDecision{
+                false,
+                0,  // Will be replaced by StandardChooseCommandIndex
+                "Fighting has better expected outcome"};
+    }
+}
+
+auto AIFleeDecisionCalculator::ShouldConsiderFleeing(
+        PlayerId attackerPlayerId,
+        const GameStateW& guessedState,
+        const SettingsGetter& settings,
+        double fleeConsiderationThreshold) -> bool {
+    // Get combat success probability
+    const double combatSuccessChance =
+            EstimateCombatSuccess(attackerPlayerId, guessedState, settings);
+
+    // Consider fleeing if combat success chance is below threshold
+    return combatSuccessChance < fleeConsiderationThreshold;
+}
+
+}  // namespace shardok
@@ -0,0 +1,67 @@
+//
+//  AIFleeDecisionCalculator.hpp
+//  eagle0
+//
+//  Handles AI flee decision logic including combat success estimation
+//  and flee vs fight evaluation for final round scenarios
+//
+
+#ifndef AIFleeDecisionCalculator_hpp
+#define AIFleeDecisionCalculator_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
+    struct FleeThresholds {
+        int minimumFleeOddsThreshold;  // Minimum flee success odds to consider fleeing
+        int desperateFleeThreshold;    // Flee threshold when combat is hopeless
+    };
+
+    // Result of flee vs fight evaluation
+    struct FleeDecision {
+        bool shouldFlee;
+        size_t commandIndex;    // Index of command to execute (flee or fight)
+        const char* reasoning;  // Debug explanation of decision
+    };
+
+    // Evaluate whether to flee or fight in the final round
+    [[nodiscard]] static auto EvaluateFleeVsFight(
+            PlayerId playerId,
+            const SettingsGetter& settings,
+            const GameStateW& guessedState,
+            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,
+            const SettingsGetter& settings) -> 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,
+            const SettingsGetter& settings,
+            double fleeConsiderationThreshold = 0.5) -> bool;
+
+private:
+    // Helper to get flee command index
+    [[nodiscard]] static auto GetFleeCommandIndex(
+            const vector<CommandProto>::const_iterator& fleeCommand,
+            const vector<CommandProto>& availableCommands) -> size_t;
+};
+
+}  // namespace shardok
+
+#endif /* AIFleeDecisionCalculator_hpp */
@@ -25,6 +25,113 @@

 namespace shardok {

+struct IndexAndScore {
+    size_t index;
+    CommandType type;
+    ScoreValue lookaheadScore;
+    ScoreValue immediateScore;
+};
+
+struct ImmediateAndLookaheadScore {
+    ScoreValue immediateScore;
+    future<ScoreValue> lookaheadScore;
+};
+
+[[nodiscard]] 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) -> std::future<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) -> std::future<IndexAndScore>;
+
+[[nodiscard]] 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;
+
+[[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 CommandEvaluationResult {
+    ScoreValue immediateScore;
+    future<ScoreValue> lookaheadScore;
+};
+
+[[nodiscard]] 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;
+
 #define LOGGING_ 0
 #define PERFORMANCE_LOGGING_ 0

@@ -137,9 +244,7 @@ using Unit = fb::Unit;
 static const std::vector _averageSequence = {0.5};
 static const auto _averageGenerator = std::make_shared<SequenceRandomGenerator>(_averageSequence);

-static auto CommandSorter(
-        const AIScoreCalculator::IndexAndScore &l,
-        const AIScoreCalculator::IndexAndScore &r) -> bool {
+static auto CommandSorter(const IndexAndScore &l, const IndexAndScore &r) -> bool {
    if (l.lookaheadScore < r.lookaheadScore) return true;
    if (l.lookaheadScore > r.lookaheadScore) return false;

@@ -261,12 +366,12 @@ auto AttackerUnitsScore(
        const APDCache &apdCache,
        const MapId &mapId) -> ScoreValue {
    // Cache frequently accessed FlatBuffer fields to avoid repeated offset calculations
-    const auto *cachedGameState = gameState.Get();
-    const auto *cachedUnits = cachedGameState->units();
-    const auto *cachedHexMap = cachedGameState->hex_map();
+    const auto *gameStateRawPtr = gameState.Get();
+    const auto *cachedUnits = gameStateRawPtr->units();
+    const auto *cachedHexMap = gameStateRawPtr->hex_map();
    const int16_t cachedRowCount = cachedHexMap->row_count();
    const int16_t cachedColumnCount = cachedHexMap->column_count();
-    const int cachedCurrentRound = cachedGameState->current_round();
+    const int cachedCurrentRound = gameStateRawPtr->current_round();

    bool isLateGame = cachedCurrentRound > 18;  // Inline IsLateGame for efficiency

@@ -289,7 +394,7 @@ auto AttackerUnitsScore(
    auto occupants = Occupants(*cachedUnits, cachedRowCount, cachedColumnCount);

    for (const Unit *unit : *cachedUnits) {
-        const auto *pi = PlayerInfoForPid(cachedGameState, unit->player_id());
+        const auto *pi = PlayerInfoForPid(gameState, unit->player_id());
        if (pi == nullptr) continue;

        switch (unit->status()) {
@@ -458,9 +563,7 @@ auto AttackerUnitsScore(

            // If the best we can do puts us very close to the enemy, and the unit is almost
            // destroyed, return a negative value; better to flee
-            if (unit->can_flee() && closestDistanceToEnemy < 5 &&
-                closestDistanceToEnemy != ActionPointDistances::IMPOSSIBLE &&
-                unit->battalion().size() < 10) {
+            if (unit->can_flee() && closestDistanceToEnemy < 5 && unit->battalion().size() < 10) {
                distanceMultiplier = -1;
            } else {
                DIST_T closestDistanceToFriendly = 1;
@@ -510,9 +613,7 @@ auto AttackerUnitsScore(
    return attackerUnitsValue - defenderUnitsValue;
 }

-auto AIScoreCalculator::FleeStrategyScoreForState(
-        const GameStateW &gameState,
-        const PlayerId playerId) -> ScoreValue {
+auto FleeStrategyScoreForState(const GameStateW &gameState, const PlayerId playerId) -> ScoreValue {
    ScoreValue scoreValue = 0.0;

    for (const auto *unit : *gameState->units()) {
@@ -532,7 +633,7 @@ auto AIScoreCalculator::FleeStrategyScoreForState(
    return scoreValue;
 }

-auto AIScoreCalculator::DefenderScatterStrategyScoreForState(
+auto DefenderScatterStrategyScoreForState(
        const GameStateW &gameState,
        const int roundsRemaining,
        const SettingsGetter &settings,
@@ -568,7 +669,7 @@ auto AIScoreCalculator::DefenderScatterStrategyScoreForState(
    return unitsTotal;
 }

-auto AIScoreCalculator::DefenderHoldCastlesStrategyScoreForState(
+auto DefenderHoldCastlesStrategyScoreForState(
        const GameStateW &gameState,
        const CoordsSet &castleCoords,
        const int roundsRemaining,
@@ -608,7 +709,7 @@ auto AIScoreCalculator::DefenderHoldCastlesStrategyScoreForState(
    return UNITS_BASE_MULTIPLIER * unitsMultiplier * unitsTotal + victoryConditionTotal;
 }

-auto AIScoreCalculator::DefenderScoreForState(
+auto DefenderScoreForState(
        const GameStateW &gameState,
        const AIStrategy &defenderStrategy,
        const CoordsSet &castleCoords,
@@ -664,7 +765,7 @@ auto AIScoreCalculator::DefenderScoreForState(
    throw ShardokInternalErrorException("Escaped AIStrategy switch");
 }

-auto AIScoreCalculator::AttackerScoreForState(
+auto AttackerScoreForState(
        const GameStateW &gameState,
        const AIStrategy &attackerStrategy,
        const CoordsSet &castleCoords,
@@ -792,7 +893,7 @@ void PrintCommand(
    printf("u%f\n", utility);
 }

-auto AIScoreCalculator::BasicLookaheadCalculator(
+auto BasicLookaheadCalculator(
        const PlayerId pid,
        const bool isDefender,
        const int remainingLookahead,
@@ -803,12 +904,13 @@ auto AIScoreCalculator::BasicLookaheadCalculator(
        const SettingsGetter &settingsGetter,
        const CoordsSet &allCastleCoords,
        const APDCache &apdCache,
-        const ALCache &alCache) -> ScoreValue {
+        const ALCache &alCache) -> std::future<ScoreValue> {
    const auto nextUtility = currentUtility;

    if (const CommandListSPtr nextCommands = innerEngine->GetAvailableCommandsForAIPlayer(pid);
        nextCommands && !nextCommands->empty()) {
-        const auto [index, type, lookaheadScore, immediateScore] = BestCommandIndex(
+        // Get the future from BestCommandIndex without calling .get()
+        auto bestCommandFuture = BestCommandIndex(
                pid,
                isDefender,
                remainingLookahead - 1,
@@ -821,16 +923,34 @@ auto AIScoreCalculator::BasicLookaheadCalculator(
                apdCache,
                alCache);

-        if (auto &nextCommand = innerEngine->GetAvailableCommandsForAIPlayer(pid)->at(index);
-            nextCommand->GetCommandType() != net::eagle0::shardok::common::END_TURN_COMMAND) {
-            return immediateScore;
-        }
+        // Return a future that chains the best command evaluation
+        return std::async(
+                std::launch::deferred,
+                [bestCommandFuture = std::move(bestCommandFuture),
+                 innerEngine,
+                 pid,
+                 nextUtility]() mutable -> ScoreValue {
+                    const auto [index, type, lookaheadScore, immediateScore] =
+                            bestCommandFuture.get();
+
+                    if (auto &nextCommand =
+                                innerEngine->GetAvailableCommandsForAIPlayer(pid)->at(index);
+                        nextCommand->GetCommandType() !=
+                        net::eagle0::shardok::common::END_TURN_COMMAND) {
+                        return immediateScore;
+                    }
+
+                    return nextUtility;
+                });
    }

-    return nextUtility;
+    // No commands available, return the current utility as a future
+    std::promise<ScoreValue> p;
+    p.set_value(nextUtility);
+    return p.get_future();
 }

-auto AIScoreCalculator::CalcOne(
+auto CalcOne(
        PlayerId pid,
        bool isDefender,
        uint32_t commandIndex,
@@ -848,7 +968,7 @@ auto AIScoreCalculator::CalcOne(
    auto innerEngine = std::make_shared<ShardokEngine>(guessedEngine, false);
    innerEngine->PostCommand(pid, commandIndex, randomGenerator);

-    auto innerUtility = GuessedStateScore(
+    auto innerUtility = AIScoreCalculator::GuessedStateScore(
            isDefender,
            innerEngine->GetCurrentGameState(),
            attackerStrategy,
@@ -874,7 +994,7 @@ auto AIScoreCalculator::CalcOne(
                                &settingsGetter,
                                &allCastleCoords,
                                &apdCache,
-                                &alCache]() -> ScoreValue {
+                                &alCache]() -> std::future<ScoreValue> {
            return BasicLookaheadCalculator(
                    pid,
                    isDefender,
@@ -890,19 +1010,24 @@ auto AIScoreCalculator::CalcOne(
        };

 #if MULTITHREAD
-        returnValue.lookaheadScore = std::async(std::launch::async, lookaheadLambda);
+        // Use async to run the lambda in parallel, then chain the resulting future
+        auto futureOfFuture = std::async(std::launch::async, lookaheadLambda);
+        returnValue.lookaheadScore = std::async(
+                std::launch::deferred,
+                [futureOfFuture = std::move(futureOfFuture)]() mutable -> ScoreValue {
+                    auto innerFuture = futureOfFuture.get();
+                    return innerFuture.get();
+                });
 #else
-        std::promise<ScoreValue> p;
-        returnValue.lookaheadScore = p.get_future();
-        auto lambdaResult = lookaheadLambda();
-        p.set_value(lambdaResult);
+        // In single-threaded mode, just call the lambda directly
+        returnValue.lookaheadScore = lookaheadLambda();
 #endif
    }

    return returnValue;
 }

-[[nodiscard]] auto AIScoreCalculator::BestCommandIndex(
+[[nodiscard]] auto BestCommandIndex(
        const PlayerId pid,
        const bool isDefender,
        const int remainingLookahead,
@@ -913,7 +1038,7 @@ auto AIScoreCalculator::CalcOne(
        const SettingsGetter &settingsGetter,
        const CoordsSet &allCastleCoords,
        const APDCache &apdCache,
-        const ALCache &alCache) -> IndexAndScore {
+        const ALCache &alCache) -> std::future<IndexAndScore> {
    const CommandListSPtr guessedDescriptors = guessedEngine.GetAvailableCommandsForAIPlayer(pid);

    // Filter out obviously bad commands to reduce search space
@@ -930,12 +1055,14 @@ auto AIScoreCalculator::CalcOne(
    double minDistToEnemies = std::numeric_limits<double>::max();
    const auto *units = gameState->units();

-    for (int i = 0; i < units->size(); ++i) {
-        if (const auto *playerUnit = units->Get(i); playerUnit->player_id() == pid) {
+    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 (int j = 0; j < units->size(); ++j) {
-                if (const auto *enemyUnit = units->Get(j); enemyUnit->player_id() != pid) {
+            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
@@ -972,24 +1099,29 @@ auto AIScoreCalculator::CalcOne(

    const auto commandCount = filteredIndices.size();

-    vector<IndexAndScore> allIndices(commandCount);
+    // Structure to hold all command evaluation data
+    struct CommandEvaluation {
+        size_t index;
+        CommandType type;
+        ScoreValue immediateScore;
+        std::vector<std::future<ScoreValue>> lookaheadFutures;
+    };

-    // Primary index is the command index; vector may contain repeated attempts
-    vector<vector<future<ScoreValue>>> scoreFutures(commandCount);
+    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();

-        allIndices[index].index = originalIndex;
-        allIndices[index].type = guessedCommandType;
+        commandEvaluations[index].index = originalIndex;
+        commandEvaluations[index].type = guessedCommandType;

        if (guessedCommandType == net::eagle0::shardok::common::END_TURN_COMMAND) {
            std::promise<ScoreValue> p;
-            scoreFutures[index].push_back(p.get_future());
+            commandEvaluations[index].lookaheadFutures.push_back(p.get_future());
            p.set_value(currentUtility);
-            allIndices[index].immediateScore = currentUtility;
+            commandEvaluations[index].immediateScore = currentUtility;
        } else if (IsDeterministic(guessedCommandType)) {
            auto [immediateScore, lookaheadScore] =
                    CalcOne(pid,
@@ -1005,8 +1137,8 @@ auto AIScoreCalculator::CalcOne(
                            apdCache,
                            alCache);

-            allIndices[index].immediateScore = immediateScore;
-            scoreFutures[index].push_back(std::move(lookaheadScore));
+            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;
@@ -1045,12 +1177,12 @@ auto AIScoreCalculator::CalcOne(
                            apdCache,
                            alCache);

-            allIndices[index].immediateScore =
+            commandEvaluations[index].immediateScore =
                    std::lerp(failureImmediateScore, successImmediateScore, successChance);

            auto successSF = successLookaheadScore.share();
            auto failureSF = failureLookaheadScore.share();
-            scoreFutures[index].push_back(std::async(
+            commandEvaluations[index].lookaheadFutures.push_back(std::async(
                    std::launch::deferred,
                    [successSF, failureSF, successChance]() -> double {
                        return std::lerp(failureSF.get(), successSF.get(), successChance);
@@ -1077,23 +1209,43 @@ auto AIScoreCalculator::CalcOne(
                                alCache);

                sum += immediateScore;
-                scoreFutures[index].push_back(std::move(lookaheadScore));
+                commandEvaluations[index].lookaheadFutures.push_back(std::move(lookaheadScore));
            }
-            allIndices[index].immediateScore = sum / maxRepeatCount;
+            commandEvaluations[index].immediateScore = sum / maxRepeatCount;
        }
    }

-    for (uint32_t i = 0; i < commandCount; i++) {
-        const auto count = static_cast<ScoreValue>(scoreFutures[i].size());
-        ScoreValue total = 0.0;
-        for (auto &oneFuture : scoreFutures[i]) { total += oneFuture.get(); }
-        allIndices[i].lookaheadScore = total / count;
-    }
+    // Return a future that will wait for all evaluations and find the best one
+    return std::async(
+            std::launch::deferred,
+            [commandEvaluations = std::move(commandEvaluations)]() mutable -> IndexAndScore {
+                std::vector<IndexAndScore> allResults;
+                allResults.reserve(commandEvaluations.size());

-    return *std::ranges::max_element(allIndices, CommandSorter);
+                // Wait for all futures and compute final scores
+                for (auto &eval : commandEvaluations) {
+                    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 AIScoreCalculator::EvaluateCommand(
+auto EvaluateCommand(
        const PlayerId pid,
        const bool isDefender,
        const uint32_t commandIndex,
@@ -1108,13 +1260,19 @@ auto AIScoreCalculator::EvaluateCommand(
        const ALCache &alCache) -> CommandEvaluationResult {
    const CommandListSPtr guessedDescriptors = guessedEngine.GetAvailableCommandsForAIPlayer(pid);

-    if (commandIndex >= guessedDescriptors->size()) { return {currentUtility, currentUtility}; }
+    if (commandIndex >= guessedDescriptors->size()) {
+        std::promise<ScoreValue> p;
+        p.set_value(currentUtility);
+        return {currentUtility, p.get_future()};
+    }

    const auto &guessedDescriptor = guessedDescriptors->at(commandIndex);

    if (const auto guessedCommandType = guessedDescriptor->GetCommandType();
        guessedCommandType == net::eagle0::shardok::common::END_TURN_COMMAND) {
-        return {currentUtility, currentUtility};
+        std::promise<ScoreValue> p;
+        p.set_value(currentUtility);
+        return {currentUtility, p.get_future()};
    } else if (IsDeterministic(guessedCommandType)) {
        auto [immediateScore, lookaheadScore] =
                CalcOne(pid,
@@ -1129,7 +1287,7 @@ auto AIScoreCalculator::EvaluateCommand(
                        allCastleCoords,
                        apdCache,
                        alCache);
-        return {immediateScore, lookaheadScore.get()};
+        return {immediateScore, std::move(lookaheadScore)};
    } else if (guessedDescriptor->HasOdds()) {
        const auto successChancePercentile = guessedDescriptor->GetOddsPercentile();
        const double successChance = static_cast<double>(successChancePercentile) / 100.0;
@@ -1165,12 +1323,20 @@ auto AIScoreCalculator::EvaluateCommand(
                alCache);

        // Return weighted average of success and failure
+        auto successSF = successLookaheadScore.share();
+        auto failureSF = failureLookaheadScore.share();
        return {std::lerp(failureImmediateScore, successImmediateScore, successChance),
-                std::lerp(failureLookaheadScore.get(), successLookaheadScore.get(), successChance)};
+                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
        ScoreValue totalImmediateScore = 0.0;
-        ScoreValue totalLookaheadScore = 0.0;
+        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)};
@@ -1189,9 +1355,19 @@ auto AIScoreCalculator::EvaluateCommand(
                            alCache);

            totalImmediateScore += immediateScore;
-            totalLookaheadScore += lookaheadScore.get();
+            lookaheadFutures.push_back(std::move(lookaheadScore));
        }
-        return {totalImmediateScore / maxRepeatCount, totalLookaheadScore / maxRepeatCount};
+
+        // Return a future that computes the average when needed
+        return {totalImmediateScore / maxRepeatCount,
+                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;
+                        })};
    }
 }

@@ -1207,8 +1383,8 @@ auto AIScoreCalculator::EvaluateCommand(
        const CoordsSet &allCastleCoords,
        const APDCache &apdCache,
        const ALCache &alCache,
-        const size_t commandIndex) -> ScoreValue {
-    const auto result = EvaluateCommand(
+        const size_t commandIndex) -> std::future<ScoreValue> {
+    auto result = EvaluateCommand(
            pid,
            isDefender,
            commandIndex,
@@ -1221,7 +1397,7 @@ auto AIScoreCalculator::EvaluateCommand(
            allCastleCoords,
            apdCache,
            alCache);
-    return result.lookaheadScore;
+    return std::move(result.lookaheadScore);
 }

 }  // namespace shardok
@@ -30,103 +30,8 @@ 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:
+    // Evaluate the score of a guessed game state based on the current AI strategy. DOES NOT perform
+    // or evaluate any commands.
    [[nodiscard]] static auto GuessedStateScore(
            bool isDefender,
            const GameStateW &state,
@@ -136,19 +41,7 @@ public:
            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;
-
+    // Evaluates the score for a particular command index for the given player, using lookahead.
    [[nodiscard]] static auto CommandScore(
            PlayerId pid,
            bool isDefender,
@@ -161,7 +54,7 @@ public:
            const CoordsSet &allCastleCoords,
            const APDCache &apdCache,
            const ALCache &alCache,
-            size_t commandIndex) -> ScoreValue;
+            size_t commandIndex) -> std::future<ScoreValue>;
 };

 }  // namespace shardok
@@ -16,7 +16,7 @@ auto HasAttachedHeroWithProfession(
           unit->attached_hero().profession_info().profession() == profession;
 }

-auto CastleClaimCapableAttackerUnitCount(const GameState *gameState) -> int {
+auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int {
    int count = 0;

    for (const auto *unit : *gameState->units()) {
@@ -32,7 +32,7 @@ auto CastleClaimCapableAttackerUnitCount(const GameState *gameState) -> int {
    return count;
 }

-auto PlayerInfoForPid(const GameState *gs, const PlayerId pid) -> const PlayerInfo * {
+auto PlayerInfoForPid(const GameStateW &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,6 +7,7 @@

 #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"
@@ -25,8 +26,8 @@ auto HasAttachedHeroWithProfession(
        const Unit *unit,
        net::eagle0::shardok::storage::fb::Profession profession) -> bool;

-auto CastleClaimCapableAttackerUnitCount(const GameState *gameState) -> int;
-auto PlayerInfoForPid(const GameState *gs, PlayerId pid) -> const PlayerInfo *;
+auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
+auto PlayerInfoForPid(const GameStateW &, PlayerId pid) -> const PlayerInfo *;

 }  // namespace shardok

@@ -32,8 +32,8 @@ auto CalculateTimeBudget(
    bool isClose = false;
    const auto *units = state->units();

-    for (int i = 0; i < units->size() && !isClose; ++i) {
-        const auto *myUnit = units->Get(i);
+    for (size_t i = 0; i < units->size() && !isClose; ++i) {
+        const auto *myUnit = units->Get(static_cast<unsigned int>(i));
        if (myUnit->player_id() != playerId) continue;

        const auto &myCoords = myUnit->location();
@@ -43,8 +43,8 @@ auto CalculateTimeBudget(
        const Cube myCube = OffsetToCube(myCoords);

        // Check distance to enemy units
-        for (int j = 0; j < units->size(); ++j) {
-            const auto *enemyUnit = units->Get(j);
+        for (size_t j = 0; j < units->size(); ++j) {
+            const auto *enemyUnit = units->Get(static_cast<unsigned int>(j));
            if (enemyUnit->player_id() == playerId) continue;

            const auto &enemyCoords = enemyUnit->location();
@@ -80,7 +80,7 @@ auto CalculateTimeBudget(
    const auto remainingBudget = std::chrono::duration_cast<std::chrono::milliseconds>(budget);

    // Get minimum depth requirement
-    const int minDepth = settingsGetter.Backing().min_lookahead_turns();
+    const size_t minDepth = settingsGetter.Backing().min_lookahead_turns();

    return AITimeBudget{
            .remainingBudget = remainingBudget,
@@ -31,7 +31,7 @@ public:
 // Configuration structure for iterative deepening time budget
 struct AITimeBudget {
    std::chrono::milliseconds remainingBudget;  // Time budget remaining (decremented as used)
-    int minDepthRequired;                       // Minimum depth from minLookaheadTurns
+    size_t minDepthRequired;                    // Minimum depth from minLookaheadTurns
    bool isCloseToEnemy;                        // Proximity flag for budget selection
 };

@@ -98,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;
 }
@@ -113,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;
 }
@@ -4,9 +4,11 @@

 #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/library/util/HexMapUtils.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/victory_condition.hpp"
@@ -122,12 +124,12 @@ auto AttackerDebufForDefenderOccupiedCriticalTile(
 }

 auto DefenderHoldsCriticalTilesVictoryScore(
-        const net::eagle0::shardok::storage::fb::GameState* gameState,
+        const GameStateW& gameState,
        const CoordsSet& criticalTileLocations,
        const PlayerInfo* player,
-        const APDCache& apdCache,
-        const ALCache& alCache,
-        const SettingsGetter& settings) -> ScoreValue {
+        const APDCache& /*apdCache*/,
+        const ALCache& /*alCache*/,
+        const SettingsGetter& /*settings*/) -> ScoreValue {
    ScoreValue total = 0.0;

    const auto rc = gameState->hex_map()->row_count();
@@ -152,7 +154,7 @@ auto DefenderHoldsCriticalTilesVictoryScore(
 }

 auto AttackerHoldsCriticalTilesVictoryScore(
-        const net::eagle0::shardok::storage::fb::GameState* gameState,
+        const GameStateW& gameState,
        const CoordsSet& criticalTileLocations,
        const PlayerInfo* player,
        const APDCache& apdCache,
@@ -246,12 +248,12 @@ auto AttackerHoldsCriticalTilesVictoryScore(
 }

 auto LastPlayerStandingVictoryScore(
-        const GameState* gameState,
+        const GameStateW& gameState,
        const PlayerInfo* player,
        const APDCache& apdCache,
        const ALCache& alCache,
        const SettingsGetter& settings) -> ScoreValue {
-    if (!common::Contains(
+    if (!std::ranges::contains(
                *player->victory_conditions(),
                net::eagle0::shardok::storage::fb::
                        VictoryCondition_VICTORY_CONDITION_LAST_PLAYER_STANDING)) {
@@ -9,6 +9,7 @@

 #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/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"
@@ -23,7 +24,7 @@ using std::vector;
 using ScoreValue = double;

 auto AttackerHoldsCriticalTilesVictoryScore(
-        const net::eagle0::shardok::storage::fb::GameState* gameState,
+        const GameStateW& gameState,
        const CoordsSet& criticalTileLocations,
        const PlayerInfo* player,
        const APDCache& apdCache,
@@ -31,7 +32,7 @@ auto AttackerHoldsCriticalTilesVictoryScore(
        const SettingsGetter& settings) -> ScoreValue;

 auto DefenderHoldsCriticalTilesVictoryScore(
-        const net::eagle0::shardok::storage::fb::GameState* gameState,
+        const GameStateW& gameState,
        const CoordsSet& criticalTileLocations,
        const PlayerInfo* player,
        const APDCache& apdCache,
@@ -39,7 +40,7 @@ auto DefenderHoldsCriticalTilesVictoryScore(
        const SettingsGetter& settings) -> ScoreValue;

 auto LastPlayerStandingVictoryScore(
-        const GameState* gameState,
+        const GameStateW& gameState,
        const PlayerInfo* player,
        const APDCache& apdCache,
        const ALCache& alCache,
@@ -11,7 +11,7 @@
 namespace shardok {

 auto UnitIdsRequiringWaterCrossing(
-        const GameState *gameState,
+        const GameStateW &gameState,
        const PlayerId pid,
        const CoordsSet &destinations,
        const APDCache &apdCache,
@@ -74,9 +74,9 @@ auto UnitIdsRequiringWaterCrossing(
 }

 auto UnitIdsToCreateWaterCrossing(
-        const GameState *gameState,
+        const GameStateW &gameState,
        const PlayerId pid,
-        const APDCache &apdCache,
+        const APDCache & /*apdCache*/,
        const SettingsGetter &settings) -> vector<UnitId> {
    vector<UnitId> unitIds{};

@@ -196,7 +196,7 @@ auto WaterCrossingTiles(

 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
 auto IntendedCrossingStarts(
-        const GameState *gameState,
+        const GameStateW &gameState,
        const vector<UnitId> &unitIdsCreatingCrossing,
        const CoordsSet &tilesToStartCrossingFrom,
        const MapId &mapId,
@@ -5,6 +5,7 @@
 #ifndef EAGLE0_AIWATERCROSSINGCALCULATOR_HPP
 #define EAGLE0_AIWATERCROSSINGCALCULATOR_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"
@@ -29,7 +30,7 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {

 // Units that need a water crossing to reach at least one of the destinations
 auto UnitIdsRequiringWaterCrossing(
-        const GameState* gameState,
+        const GameStateW& gameState,
        PlayerId pid,
        const CoordsSet& destinations,
        const APDCache& apdCache,
@@ -37,7 +38,7 @@ auto UnitIdsRequiringWaterCrossing(

 // Units belonging to the player that are capable of creating water crossings
 auto UnitIdsToCreateWaterCrossing(
-        const GameState* gameState,
+        const GameStateW& gameState,
        PlayerId pid,
        const APDCache& apdCache,
        const SettingsGetter& settings) -> vector<UnitId>;
@@ -67,7 +68,7 @@ auto WaterCrossingTiles(

 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
 auto IntendedCrossingStarts(
-        const GameState* gameState,
+        const GameStateW& gameState,
        const vector<UnitId>& unitIdsCreatingCrossing,
        const CoordsSet& tilesToStartCrossingFrom,
        const MapId& mapId,
@@ -4,8 +4,10 @@

 #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 {
@@ -17,10 +19,10 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:

 [[nodiscard]] auto AIWaterCrossingCommandChooser::WaterCrossingScore(
        const SettingsGetter &settingsGetter,
-        const GameState *gameState,
+        const GameStateW &gameState,
        const CoordsSet &castleCoords,
        const CoordsSet &startCrossingFrom) const -> ScoreValue {
-    int castleClaimCount = 0;
+    uint32_t castleClaimCount = 0;
    for (const auto *unit : *gameState->units()) {
        if (unit->player_id() != playerId) continue;
        const auto status = unit->status();
@@ -83,7 +85,7 @@ 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 (common::Contains(unitIdsCreatingCrossing, uid)) continue;
+        if (std::ranges::contains(unitIdsCreatingCrossing, uid)) continue;

        const Unit *unit = gameState->units()->Get(uid);
        const auto &battalionType = settingsGetter.GetBattalionType(unit->battalion().type());
@@ -119,11 +121,11 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:

 auto AIWaterCrossingCommandChooser::StartCrossingFrom(
        const SettingsGetter &settingsGetter,
-        const GameState *gameState,
+        const GameStateW &gameState,
        const CoordsSet &castleCoords) const -> CoordsSet {
    CoordsSet startCrossingFrom(gameState->hex_map());

-    int castleClaimCount = 0;
+    uint32_t castleClaimCount = 0;
    for (const auto *unit : *gameState->units()) {
        if (unit->player_id() != playerId) continue;
        const auto status = unit->status();
@@ -8,6 +8,7 @@
 #include <utility>
 #include <vector>

+#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"
@@ -34,12 +35,12 @@ public:

    auto StartCrossingFrom(
            const SettingsGetter &settingsGetter,
-            const GameState *gameState,
+            const GameStateW &gameState,
            const CoordsSet &castleCoords) const -> CoordsSet;

    [[nodiscard]] auto WaterCrossingScore(
            const SettingsGetter &settingsGetter,
-            const GameState *gameState,
+            const GameStateW &gameState,
            const CoordsSet &castleCoords,
            const CoordsSet &startCrossingFrom) const -> ScoreValue;
 };
@@ -11,6 +11,7 @@ cc_library(
    ],
    deps = [
        ":ai_attack_locations",
+        ":ai_flee_decision_calculator",
        ":ai_score_utilities",
        ":ai_strategy",
        ":ai_water_crossing_command_chooser",
@@ -70,6 +71,7 @@ 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",
@@ -120,12 +122,32 @@ cc_library(
        "//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: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/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(
    name = "ai_command_filter",
    srcs = ["AICommandFilter.cpp"],
@@ -210,6 +232,7 @@ cc_library(
        ":ai_attack_locations",
        ":ai_distance_debuf",
        ":ai_score_utilities",
+        "//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/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
@@ -227,6 +250,7 @@ cc_library(
    ],
    deps = [
        ":ai_minimum_distance_and_target",
+        "//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",
@@ -244,6 +268,7 @@ cc_library(
    deps = [
        ":ai_minimum_distance_and_target",
        ":ai_water_crossing_calculator",
+        "//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",
@@ -299,6 +324,7 @@ cc_library(
    deps = [
        ":ai_attacker_strategy_selector",
        ":ai_defender_strategy_selector",
+        ":ai_flee_decision_calculator",
        ":ai_iterative_deepening",
        ":ai_score_calculator",
        ":ai_time_budget",
@@ -55,7 +55,7 @@ auto IterativeDeepeningAI::IterativeSearch(
    bool isSetupPhase =
            (state->status()->state() ==
             net::eagle0::shardok::storage::fb::GameStatus_::State_SET_UP);
-    int maxDepth = isSetupPhase ? 2 : std::numeric_limits<int>::max();
+    size_t maxDepth = isSetupPhase ? 2 : std::numeric_limits<int>::max();

    // Calculate current utility and create engine once for all command evaluations
    const auto& settingsGetter = settings->GetGetter();
@@ -76,10 +76,10 @@ auto IterativeDeepeningAI::IterativeSearch(
    highestDepthCompleted.clear();
    highestDepthCompleted.resize(commands.size(), 0);

-    int currentDepth = 1;
+    size_t currentDepth = 1;
    size_t previousBestCommand = 0;  // Track best command from previous depth
    size_t evaluatedCountAtHighestDepth = 0;
-    EvaluationCompletionReason completionReason = EvaluationCompletionReason::RAN_OUT_OF_TIME;
+    auto completionReason = EvaluationCompletionReason::RAN_OUT_OF_TIME;

    // Main iterative deepening loop
    while ((currentDepth == 1 || !IsTimeExpired(timeBudget)) && currentDepth <= maxDepth) {
@@ -89,18 +89,21 @@ auto IterativeDeepeningAI::IterativeSearch(
                scoresByDepth,
                highestDepthCompleted);

-        int evaluatedCount = 0;
+        size_t evaluatedCount = 0;
        bool allEvaluated = true;
        bool allEndTurnCommands = true;  // Track if all commands are END_TURN

-        // Try to evaluate all commands at this depth, within budget constraints
+        // Start all command evaluations for this depth
+        std::vector<std::pair<size_t, std::future<SearchResult>>> futures;
+        futures.reserve(sortedIndices.size());
+
        for (size_t cmdIndex : sortedIndices) {
            if (currentDepth > 1 && IsTimeExpired(timeBudget)) {
                allEvaluated = false;
                break;
            }

-            auto cmdResult = SearchCommandAtDepthWithEngine(
+            auto future = SearchCommandAtDepthWithEngine(
                    guessedEngine,
                    settingsGetter,
                    maxRepeatCount,
@@ -110,6 +113,13 @@ auto IterativeDeepeningAI::IterativeSearch(
                    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);
@@ -142,13 +152,13 @@ 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 %d:\n", currentDepth);
-                printf("  Depth %d best: command %zu (score %.2f) - %s\n",
+                printf("ID AI: Best command changed at depth %lu:\n", currentDepth);
+                printf("  Depth %lu best: command %zu (score %.2f) - %s\n",
                       currentDepth - 1,
                       previousBestCommand,
                       scoresByDepth[previousBestCommand][currentDepth - 1],
                       commands[previousBestCommand].DebugString().c_str());
-                printf("  Depth %d best: command %zu (score %.2f) - %s\n",
+                printf("  Depth %lu best: command %zu (score %.2f) - %s\n",
                       currentDepth,
                       currentBestCommand,
                       currentBestScore,
@@ -175,12 +185,12 @@ auto IterativeDeepeningAI::IterativeSearch(
        // This indicates we've hit END_TURN in the lookahead
        if (currentDepth > 1 && evaluatedCount > 0) {
            bool scoresUnchanged = true;
-            int unchangedCount = 0;
+            size_t 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 (scoresByDepth[cmdIndex].size() > currentDepth &&
+                if (size_t cmdIndex = sortedIndices[i];
+                    scoresByDepth[cmdIndex].size() > currentDepth &&
                    scoresByDepth[cmdIndex].size() > currentDepth - 1) {
                    // Check if score changed between depth N-1 and depth N
                    if (std::abs(
@@ -204,10 +214,11 @@ 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 = (double)totalElapsedMs.count() / initialBudgetMs.count();
+        double budgetUsedPercent = static_cast<double>(totalElapsedMs.count()) /
+                                   static_cast<double>(initialBudgetMs.count());

        if (budgetUsedPercent > 0.5) {
-            printf("ID AI: Stopping after depth %d - used %.1f%% of time budget\n",
+            printf("ID AI: Stopping after depth %lu - used %.1f%% of time budget\n",
                   currentDepth,
                   budgetUsedPercent * 100);
            completionReason = EvaluationCompletionReason::NOT_ENOUGH_TIME_TO_CONTINUE;
@@ -257,7 +268,7 @@ auto IterativeDeepeningAI::SearchCommandAtDepthWithEngine(
        const size_t commandIndex,
        const int depth,
        const ScoreValue currentUtility,
-        AITimeBudget& timeBudget) const -> SearchResult {
+        AITimeBudget& timeBudget) const -> std::future<SearchResult> {
    SearchResult result;
    result.bestCommandIndex = commandIndex;
    result.depthAchieved = depth;
@@ -268,7 +279,9 @@ auto IterativeDeepeningAI::SearchCommandAtDepthWithEngine(

    if (commandIndex >= commands.size()) {
        result.bestScore = 0.0;
-        return result;
+        std::promise<SearchResult> p;
+        p.set_value(result);
+        return p.get_future();
    }

    try {
@@ -276,8 +289,8 @@ auto IterativeDeepeningAI::SearchCommandAtDepthWithEngine(
        AIEvaluationCounter counter;
        const auto startTime = std::chrono::steady_clock::now();

-        // Use CommandScore to evaluate the specific command at the given depth
-        const auto commandScore = AIScoreCalculator::CommandScore(
+        // Get the future from CommandScore - don't wait yet
+        auto commandScoreFuture = AIScoreCalculator::CommandScore(
                playerId,
                isDefender,
                depth,
@@ -291,9 +304,12 @@ auto IterativeDeepeningAI::SearchCommandAtDepthWithEngine(
                alCache,
                commandIndex);

-        // Calculate time used and adjust based on concurrent evaluations
+        // Calculate time and adjust budget before waiting
+        // This is needed because we need to update timeBudget synchronously
+        const auto commandScore = commandScoreFuture.get();
+
        const auto elapsed = std::chrono::steady_clock::now() - startTime;
-        const int concurrentCount = counter.GetCurrentCount();
+        const int concurrentCount = AIEvaluationCounter::GetCurrentCount();
        const auto adjustedElapsed = elapsed / std::max(1, concurrentCount);
        const auto adjustedElapsedMs =
                std::chrono::duration_cast<std::chrono::milliseconds>(adjustedElapsed);
@@ -310,13 +326,15 @@ auto IterativeDeepeningAI::SearchCommandAtDepthWithEngine(
        result.bestScore = 0.0;
    }

-    return result;
+    std::promise<SearchResult> p;
+    p.set_value(result);
+    return p.get_future();
 }

 auto IterativeDeepeningAI::GetCommandsSortedByPreviousDepth(
-        int currentDepth,
+        const size_t currentDepth,
        const std::vector<std::vector<ScoreValue>>& scoresByDepth,
-        const std::vector<int>& highestDepthCompleted) const -> std::vector<size_t> {
+        const std::vector<size_t>& highestDepthCompleted) -> std::vector<size_t> {
    std::vector<size_t> indices(scoresByDepth.size());
    std::iota(indices.begin(), indices.end(), 0);

@@ -326,8 +344,8 @@ auto IterativeDeepeningAI::GetCommandsSortedByPreviousDepth(
    }

    // Sort by score at previous depth
-    int prevDepth = currentDepth - 1;
-    std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b) {
+    const size_t prevDepth = currentDepth - 1;
+    std::ranges::sort(indices, [&](const size_t a, const size_t b) {
        // Only consider commands that were evaluated at previous depth
        if (highestDepthCompleted[a] >= prevDepth && highestDepthCompleted[b] >= prevDepth) {
            return scoresByDepth[a][prevDepth] > scoresByDepth[b][prevDepth];
@@ -341,7 +359,7 @@ auto IterativeDeepeningAI::GetCommandsSortedByPreviousDepth(

 auto IterativeDeepeningAI::SelectBestResult(
        const std::vector<std::vector<ScoreValue>>& scoresByDepth,
-        const std::vector<int>& highestDepthCompleted) const -> SearchResult {
+        const std::vector<size_t>& highestDepthCompleted) -> SearchResult {
    SearchResult result;
    result.bestScore = -std::numeric_limits<ScoreValue>::infinity();
    result.searchCompleted = false;
@@ -349,9 +367,8 @@ 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) {
-            int depth = highestDepthCompleted[i];
-            ScoreValue score = scoresByDepth[i][depth];
-            if (score > result.bestScore) {
+            const size_t depth = highestDepthCompleted[i];
+            if (ScoreValue score = scoresByDepth[i][depth]; score > result.bestScore) {
                result.bestScore = score;
                result.bestCommandIndex = i;
                result.depthAchieved = depth;
@@ -6,6 +6,7 @@
 #define EAGLE0_ITERATIVEDEEPENINGAI_HPP

 #include <chrono>
+#include <future>
 #include <vector>

 #include "AIStrategy.hpp"
@@ -35,7 +36,7 @@ public:
    struct SearchResult {
        size_t bestCommandIndex;
        ScoreValue bestScore;
-        int depthAchieved;
+        size_t depthAchieved;
        std::chrono::milliseconds timeUsed;
        bool minimumDepthCompleted;
        bool searchCompleted;
@@ -67,7 +68,7 @@ public:
            const GameSettingsSPtr& settings,
            const GameStateW& state,
            const std::vector<CommandProto>& commands,
-            const AITimeBudget& timeBudget) const;
+            const AITimeBudget& initialBudget) const;

 private:
    PlayerId playerId;
@@ -79,12 +80,12 @@ private:

    // Reusable vectors to reduce memory allocations
    mutable std::vector<std::vector<ScoreValue>> scoresByDepth;
-    mutable std::vector<int> highestDepthCompleted;
+    mutable std::vector<size_t> highestDepthCompleted;
    mutable std::vector<size_t> reusableSortedIndices;

    [[nodiscard]] static bool IsTimeExpired(const AITimeBudget& budget);

-    [[nodiscard]] SearchResult SearchCommandAtDepthWithEngine(
+    [[nodiscard]] std::future<SearchResult> SearchCommandAtDepthWithEngine(
            const ShardokEngine& guessedEngine,
            const GameSettings::Getter& settingsGetter,
            int maxRepeatCount,
@@ -94,14 +95,14 @@ private:
            ScoreValue currentUtility,
            AITimeBudget& timeBudget) const;

-    [[nodiscard]] std::vector<size_t> GetCommandsSortedByPreviousDepth(
-            int currentDepth,
+    [[nodiscard]] static std::vector<size_t> GetCommandsSortedByPreviousDepth(
+            size_t currentDepth,
            const std::vector<std::vector<ScoreValue>>& scoresByDepth,
-            const std::vector<int>& highestDepthCompleted) const;
+            const std::vector<size_t>& highestDepthCompleted);

-    [[nodiscard]] SearchResult SelectBestResult(
+    [[nodiscard]] static SearchResult SelectBestResult(
            const std::vector<std::vector<ScoreValue>>& scoresByDepth,
-            const std::vector<int>& highestDepthCompleted) const;
+            const std::vector<size_t>& highestDepthCompleted);
 };

 }  // namespace shardok
@@ -8,10 +8,14 @@

 #include "ShardokAIClient.hpp"

+#define DEBUG_FLEE_DECISIONS
+
 #include <google/protobuf/util/message_differencer.h>

 #include "AIAttackerStrategySelector.hpp"
 #include "AIDefenderStrategySelector.hpp"
+#include "AIFleeDecisionCalculator.hpp"
+#include "AIScoreUtilities.hpp"
 #include "AITimeBudget.hpp"
 #include "IterativeDeepeningAI.hpp"
 #include "src/main/cpp/net/eagle0/common/TimeUtils.hpp"
@@ -26,7 +30,7 @@ using net::eagle0::shardok::api::GameStateView;

 static constexpr bool kPerformanceLogging = true;

-void ApplyUpdate(GameStateView &currentView, const ActionResultView &update) {}
+void ApplyUpdate(GameStateView & /*currentView*/, const ActionResultView & /*update*/) {}

 auto RoundsRemaining(const GameSettingsSPtr &settings, const GameStateView &gsv) -> int {
    const int maxRounds = settings->GetGetter().Backing().max_rounds();
@@ -96,7 +100,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(
    const auto commandCount = guessedCommands.size();

    assert(commandCount == realAvailableCommands.size());
-    for (int i = 0; i < commandCount; i++) {
+    for (size_t i = 0; i < commandCount; i++) {
        CheckCommand(realAvailableCommands[i], guessedCommands[i]);
    }

@@ -175,23 +179,41 @@ auto ShardokAIClient::FinalRoundAttackerChooseCommandIndex(
        const GameSettingsSPtr &settings,
        const GameStateW &guessedState,
        const vector<CommandProto> &realAvailableCommands) const -> CommandChoiceResults {
-    if (const auto fleeCommand = std::ranges::find_if(
-                realAvailableCommands,
-                [](const net::eagle0::shardok::api::CommandDescriptor &cmd) {
-                    return cmd.type() == net::eagle0::shardok::common::FLEE_COMMAND;
-                });
-        fleeCommand == realAvailableCommands.end()) {
+    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()) {
        return LateRoundAttackerChooseCommandIndex(settings, guessedState, realAvailableCommands);
-    } else {
+    }
+
+    // Use the flee decision calculator
+    const auto fleeDecision = AIFleeDecisionCalculator::EvaluateFleeVsFight(
+            playerId,
+            settings->GetGetter(),
+            guessedState,
+            realAvailableCommands,
+            fleeCommand,
+#ifdef DEBUG_FLEE_DECISIONS
+            true  // Enable debug logging
+#else
+            false
+#endif
+    );
+
+    if (fleeDecision.shouldFlee) {
        CommandChoiceResults results{};
-        results.chosenIndex =
-                static_cast<size_t>(std::distance(realAvailableCommands.begin(), fleeCommand));
+        results.chosenIndex = fleeDecision.commandIndex;
        results.availableCommandCount = realAvailableCommands.size();
-        results.depthAchieved = 1;          // Simple heuristic choice
+        results.depthAchieved = 1;          // Heuristic choice
        results.commandCountEvaluated = 1;  // Only evaluated one command type
-        results.completionReason =
-                EvaluationCompletionReason::RAN_OUT_OF_COMMANDS;  // Heuristic choice
+        results.completionReason = EvaluationCompletionReason::RAN_OUT_OF_COMMANDS;
        return results;
+    } else {
+        // Fight instead of flee
+        return StandardChooseCommandIndex(settings, guessedState, realAvailableCommands);
    }
 }

@@ -56,6 +56,7 @@ private:
            const GameSettingsSPtr& settings,
            const GameStateW& guessedState,
            const vector<CommandProto>& realAvailableCommands) const -> CommandChoiceResults;
+
    [[nodiscard]] auto ChooseCommandIndex(
            const GameSettingsSPtr& settings,
            const net::eagle0::shardok::api::GameStateView& gsv,
@@ -5,7 +5,10 @@
 #ifndef EAGLE0_GAMEUPDATERECEIVER_HPP
 #define EAGLE0_GAMEUPDATERECEIVER_HPP

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/api/action_result_view.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok {
 using std::vector;
@@ -8,9 +8,11 @@

 #include "ShardokGameController.hpp"

+#include <algorithm>
+#include <iterator>
+#include <ranges>
 #include <thread>

-#include "src/main/cpp/net/eagle0/common/ContainerUtils.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/ShardokAIClient.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/protobuf/net/eagle0/shardok/api/game_state_view.pb.h"
@@ -85,10 +87,10 @@ void ShardokGameController::LockedNotifyClients() const { updateCondition.notify

 auto ShardokGameController::LockedAIClientForPid(PlayerId pid) const
        -> shared_ptr<ShardokAIClient> {
-    return common::FindIf(
-                   aiClients,
-                   [pid](const auto &client) { return client->GetPlayerId() == pid; })
-            .value_or(nullptr);
+    const auto it = std::ranges::find_if(aiClients, [pid](const auto &client) {
+        return client->GetPlayerId() == pid;
+    });
+    return (it != aiClients.end()) ? *it : nullptr;
 }

 void ShardokGameController::DoAIThread() {
@@ -165,7 +167,7 @@ void ShardokGameController::PostCommand(

    CheckFactionId(engine, shardokPlayerId, eagleFactionId);

-    const auto expectedToken = engine->GetUnfilteredHistoryCount();
+    const auto expectedToken = static_cast<int64_t>(engine->GetUnfilteredHistoryCount());
    if (token < expectedToken) {
        printf("Double token in postCommand\n");
        // The client is missing some updates; probably it's a double-submit
@@ -193,7 +195,7 @@ void ShardokGameController::PostPlacementCommands(

        CheckFactionId(engine, shardokPlayerId, eagleFactionId);

-        const auto expectedToken = engine->GetUnfilteredHistoryCount();
+        const auto expectedToken = static_cast<int64_t>(engine->GetUnfilteredHistoryCount());
        if (token < expectedToken) {
            printf("Double token in postPlacementCommands\n");
            // The client is missing some updates; probably it's a double-submit
@@ -240,9 +242,11 @@ auto ShardokGameController::GetUpdates(const int64_t startingActionId) -> AllUpd
            incomingRegistrations--;
        }

-        updates.mainResults = common::Map(awrs, [](const ShardokActionWithResultingState &a) {
-            return a.action_result();
-        });
+        updates.mainResults.reserve(awrs.size());
+        std::ranges::transform(
+                awrs,
+                std::back_inserter(updates.mainResults),
+                [](const ShardokActionWithResultingState &a) { return a.action_result(); });

        const auto playerInfos = engine->GetPlayerInfos();
        updates.filteredResults.reserve(playerInfos.size() + 1);
@@ -8,6 +8,9 @@

 #include "AvailableCommandsFactory.hpp"

+#include <algorithm>
+#include <ranges>
+
 #include "src/main/cpp/net/eagle0/shardok/library/FireUtils.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_factories/PlayerSetupCommandFactory.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_result_applier/ActionResultApplier.hpp"
@@ -132,30 +135,30 @@ void AvailableCommandsFactoryImpl::AddAvailableCommandsForOneUnit(
    }
    if (battType->adjustsMorale &&
        unit->battalion().morale() < settings.Backing().minimum_morale_to_act()) {
-        common::FilterInPlace(oneUnitCommands, [](const CommandSPtr &cmd) {
-            return cmd->CanDoWithLowMorale();
+        std::erase_if(oneUnitCommands, [](const CommandSPtr &cmd) {
+            return !cmd->CanDoWithLowMorale();
        });
    }
    if (unit->stun_rounds_remaining() > 0) {
-        common::FilterInPlace(oneUnitCommands, [](const CommandSPtr &cmd) {
-            return cmd->CanDoWhileStunned();
+        std::erase_if(oneUnitCommands, [](const CommandSPtr &cmd) {
+            return !cmd->CanDoWhileStunned();
        });
    }
    if (hasHero && unit->attached_hero().vigor() < settings.Backing().minimum_vigor_to_act()) {
-        common::FilterInPlace(oneUnitCommands, [](const CommandSPtr &cmd) {
-            return cmd->CanDoWithLowVigor();
+        std::erase_if(oneUnitCommands, [](const CommandSPtr &cmd) {
+            return !cmd->CanDoWithLowVigor();
        });
    }
    if (unitMovedIntoZoc) {
-        common::FilterInPlace(oneUnitCommands, [](const CommandSPtr &cmd) {
-            return cmd->CanDoAfterMovingIntoZoc();
+        std::erase_if(oneUnitCommands, [](const CommandSPtr &cmd) {
+            return !cmd->CanDoAfterMovingIntoZoc();
        });
    }
-    if (common::ContainsWhere(oneUnitCommands, [](const CommandSPtr &cmd) {
+    if (std::ranges::any_of(oneUnitCommands, [](const CommandSPtr &cmd) {
            return cmd->IsRequiredToEndTurn();
        })) {
-        common::FilterInPlace(oneUnitCommands, [](const CommandSPtr &cmd) {
-            return cmd->IsRequiredToEndTurn();
+        std::erase_if(oneUnitCommands, [](const CommandSPtr &cmd) {
+            return !cmd->IsRequiredToEndTurn();
        });
    }

@@ -183,7 +186,7 @@ auto AvailableCommandsFactoryImpl::GetAvailableCommands(
                /* onlyFollowUps=*/false);
    }

-    if (!common::ContainsWhere(commands, [](const CommandSPtr &command) {
+    if (!std::ranges::any_of(commands, [](const CommandSPtr &command) {
            return command->IsRequiredToEndTurn();
        })) {
        commands.push_back(std::make_shared<EndTurnCommand>(playerId, gameState, settings));
@@ -8,7 +8,6 @@ cc_library(
    visibility = ["//visibility:public"],
    deps = [
        ":shardok_c_types",
-        "//src/main/cpp/net/eagle0/common:container_utils",
        "//src/main/cpp/net/eagle0/shardok/library/fb_helpers:flatbuffer_wrapper",
        "//src/main/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
        "//src/main/flatbuffer/net/eagle0/shardok/storage:unit_cc_fbs",
@@ -4,7 +4,8 @@

 #include "GameStateW.hpp"

-#include "src/main/cpp/net/eagle0/common/ContainerUtils.hpp"
+#include <algorithm>
+#include <ranges>

 namespace shardok {

@@ -24,13 +25,17 @@ auto GameStateW::GetOccupant(const net::eagle0::shardok::storage::fb::Coords& co

    // Fast path: use bitfield cache if available
    if (state->occupied_tiles() && !state->occupied_tiles()->empty()) {
-        const size_t tileIndex = coords.row() * columnCount + coords.column();
-        const size_t expectedBitfieldSize = (rowCount * columnCount + 7) / 8;  // Ceiling division
+        const size_t tileIndex =
+                static_cast<size_t>(coords.row()) * static_cast<size_t>(columnCount) +
+                static_cast<size_t>(coords.column());
+        const size_t expectedBitfieldSize =
+                (static_cast<size_t>(rowCount) * static_cast<size_t>(columnCount) + 7) /
+                8;  // Ceiling division

        if (state->occupied_tiles()->size() == expectedBitfieldSize) {
            const size_t byteIndex = tileIndex / 8;
            const size_t bitOffset = tileIndex % 8;
-            const uint8_t byte = state->occupied_tiles()->Get(byteIndex);
+            const uint8_t byte = state->occupied_tiles()->Get(static_cast<unsigned int>(byteIndex));
            const bool isOccupied = (byte & (1 << bitOffset)) != 0;

            if (!isOccupied) {
@@ -43,8 +48,8 @@ auto GameStateW::GetOccupant(const net::eagle0::shardok::storage::fb::Coords& co
    // Used when bitfield not available OR when bitfield indicates occupation
    if (!state->units()) { return nullptr; }

-    for (int i = 0; i < state->units()->size(); ++i) {
-        const auto* unit = state->units()->Get(i);
+    for (size_t i = 0; i < state->units()->size(); ++i) {
+        const auto* unit = state->units()->Get(static_cast<unsigned int>(i));
        if (unit && unit->status() == net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT &&
            unit->location().row() == coords.row() &&
            unit->location().column() == coords.column()) {
@@ -62,7 +67,7 @@ auto GameStateW::GetKnownEnemyOccupant(
    const auto* occupant = GetOccupant(coords);
    if (occupant) {
        if (!occupant->hidden() && occupant->player_id() != playerId &&
-            !common::Contains(allyPids, occupant->player_id())) {
+            !std::ranges::contains(allyPids, occupant->player_id())) {
            return occupant;
        }
    }
@@ -82,26 +87,30 @@ void GameStateW::UpdateOccupiedTile(
    // Clear old position in bitfield
    if (oldCoords.row() >= 0 && oldCoords.row() < rowCount && oldCoords.column() >= 0 &&
        oldCoords.column() < columnCount) {
-        const size_t tileIndex = oldCoords.row() * columnCount + oldCoords.column();
+        const size_t tileIndex =
+                static_cast<size_t>(oldCoords.row()) * static_cast<size_t>(columnCount) +
+                static_cast<size_t>(oldCoords.column());
        const size_t byteIndex = tileIndex / 8;
        const size_t bitOffset = tileIndex % 8;
        if (byteIndex < mutableOccupiedTiles->size()) {
-            uint8_t byte = mutableOccupiedTiles->Get(byteIndex);
+            uint8_t byte = mutableOccupiedTiles->Get(static_cast<unsigned int>(byteIndex));
            byte &= ~(1 << bitOffset);  // Clear the bit
-            mutableOccupiedTiles->Mutate(byteIndex, byte);
+            mutableOccupiedTiles->Mutate(static_cast<unsigned int>(byteIndex), byte);
        }
    }

    // Set new position in bitfield
    if (newCoords.row() >= 0 && newCoords.row() < rowCount && newCoords.column() >= 0 &&
        newCoords.column() < columnCount) {
-        const size_t tileIndex = newCoords.row() * columnCount + newCoords.column();
+        const size_t tileIndex =
+                static_cast<size_t>(newCoords.row()) * static_cast<size_t>(columnCount) +
+                static_cast<size_t>(newCoords.column());
        const size_t byteIndex = tileIndex / 8;
        const size_t bitOffset = tileIndex % 8;
        if (byteIndex < mutableOccupiedTiles->size()) {
-            uint8_t byte = mutableOccupiedTiles->Get(byteIndex);
+            uint8_t byte = mutableOccupiedTiles->Get(static_cast<unsigned int>(byteIndex));
            byte |= (1 << bitOffset);  // Set the bit
-            mutableOccupiedTiles->Mutate(byteIndex, byte);
+            mutableOccupiedTiles->Mutate(static_cast<unsigned int>(byteIndex), byte);
        }
    }
 }
@@ -115,7 +124,8 @@ auto GameStateW::GetOccupiedTilesBitfield() const -> const flatbuffers::Vector<u
    // Verify the bitfield size matches expected map size
    const int16_t rowCount = state->hex_map()->row_count();
    const int16_t columnCount = state->hex_map()->column_count();
-    const size_t expectedBitfieldSize = (rowCount * columnCount + 7) / 8;
+    const size_t expectedBitfieldSize =
+            (static_cast<size_t>(rowCount) * static_cast<size_t>(columnCount) + 7) / 8;

    if (state->occupied_tiles()->size() != expectedBitfieldSize) { return nullptr; }

@@ -5,6 +5,8 @@
 #ifndef EAGLE0_GAMESTATEW_HPP
 #define EAGLE0_GAMESTATEW_HPP

+#include <cstdint>
+
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokCTypes.h"
 #include "src/main/cpp/net/eagle0/shardok/library/fb_helpers/FlatbufferWrapper.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
@@ -12,7 +12,10 @@
 #include <string>
 #include <vector>

+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/storage/odds.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok {
 typedef net::eagle0::shardok::storage::Odds PercentileRollOdds;
@@ -14,7 +14,10 @@
 #include "ShardokException.hpp"
 #include "src/main/cpp/net/eagle0/common/RandomGenerator.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/storage/action_result.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok {

@@ -42,9 +45,9 @@ private:
    }

    [[nodiscard]] virtual auto InternalExecuteWithRoll(
-            const GameStateW& currentState,
-            const std::shared_ptr<RandomGenerator>& generator,
-            std::optional<int32_t> roll) const -> std::vector<ActionResult> {
+            const GameStateW& /*currentState*/,
+            const std::shared_ptr<RandomGenerator>& /*generator*/,
+            std::optional<int32_t> /*roll*/) const -> std::vector<ActionResult> {
        throw ShardokClientErrorException("Roll not supported");
    }

@@ -46,7 +46,7 @@ public:
    [[nodiscard]] virtual auto HasOdds() const -> bool { return false; }
    [[nodiscard]] virtual auto GetOddsPercentile() const -> int32_t { return 0; }

-    virtual void AddFollowUpCommandTypes(const std::unordered_set<CommandType>& newTypes) {
+    virtual void AddFollowUpCommandTypes(const std::unordered_set<CommandType>& /*newTypes*/) {
        throw ShardokInternalErrorException("Can't add follow up commands to this type");
    }
 };
@@ -9,6 +9,8 @@
 #include "ShardokEngine.hpp"

 #include <algorithm>
+#include <optional>
+#include <ranges>
 #include <utility>
 #include <vector>

@@ -310,21 +312,19 @@ void ShardokEngine::PostPlacementCommands(
            availableCommandsFactory->GetPlayerSetupCommands(gameState, player);

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

-        if (auto command = common::FindIf(
-                    *placementCommands,
-                    [pi](const CommandSPtr &cmd) {
-                        return cmd->GetCommandProto().actor().value() == pi.unitId &&
-                               cmd->GetCommandProto().target() == pi.location;
-                    });
-            !command.has_value()) {
+        const auto it = std::ranges::find_if(*placementCommands, [pi](const CommandSPtr &cmd) {
+            return cmd->GetCommandProto().actor().value() == pi.unitId &&
+                   cmd->GetCommandProto().target() == pi.location;
+        });
+        if (it == placementCommands->end()) {
            throw ShardokClientErrorException("No such placement info found");
        }

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

            if (pi.unitId == other.unitId)
@@ -339,12 +339,11 @@ void ShardokEngine::PostPlacementCommands(

    // now execute
    for (const auto &pi : placementInfos) {
-        auto command = common::FindIf(*placementCommands, [pi](const CommandSPtr &cmd) {
+        const auto it = std::ranges::find_if(*placementCommands, [pi](const CommandSPtr &cmd) {
            return cmd->GetCommandProto().actor().value() == pi.unitId &&
                   cmd->GetCommandProto().target() == pi.location;
        });
-        for (vector<ActionResult> onePlacementResults =
-                     (*command)->Execute(gameState, randomGenerator);
+        for (vector<ActionResult> onePlacementResults = (*it)->Execute(gameState, randomGenerator);
             const ActionResultProto &oneResult : onePlacementResults) {
            HandleActionResult(oneResult, randomGenerator);
        }
@@ -376,17 +375,17 @@ void ShardokEngine::PostFinishedPlacementCommand(
    const auto placementCommands =
            availableCommandsFactory->GetPlayerSetupCommands(gameState, player);

-    const auto command = common::FindIf(*placementCommands, [](const CommandSPtr &cmd) {
+    const auto it = std::ranges::find_if(*placementCommands, [](const CommandSPtr &cmd) {
        return cmd->GetCommandProto().type() ==
               net::eagle0::shardok::common::END_PLAYER_SETUP_COMMAND;
    });

-    if (!command.has_value()) {
+    if (it == placementCommands->end()) {
        throw ShardokClientErrorException("No finish placement command found");
    }
    cachedAvailableCommands = nullptr;

-    PostActionUnchecked(command.value(), randomGenerator, std::nullopt);
+    PostActionUnchecked(*it, randomGenerator, std::nullopt);
 }

 void ShardokEngine::PostCommand(
@@ -87,11 +87,11 @@ auto PlayerSetupCommandFactory::AddAvailablePlayerSetupCommands(
    if (placedUnits.size() >= 10) return;
    if (unplacedUnits.empty()) return;

-    for (const auto &kv : unplacedUnits) {
+    for (const auto &[unitId, unit] : unplacedUnits) {
        AddAvailablePlaceAndHideUnitCommandsForOneUnit(
                existingCommands,
                isDefender,
-                kv.second,
+                unit,
                gameState);
    }
 }
@@ -135,14 +135,14 @@ auto ActionPointDistancesCache::GetRaw(
            MakeCacheKey(mapId, battalionType, includeBravingWater, braveWaterActionPointCost);

    // Check the persistent map first
-    if (auto persistentIt = persistentCache.find(cacheKey); persistentIt != persistentCache.end()) {
+    if (persistentCache.contains(cacheKey)) {
 #if CACHE_STATS_LOGGING_
        cacheStats.persistentHits++;
        MaybePrintCacheStats();
 #endif
        // Return directly from persistent cache without TLS insertion
        // This avoids the overhead of thread-local storage operations on hot path
-        return persistentIt->second.rawPtr;
+        return persistentCache.at(cacheKey).rawPtr;
    }

 #if CACHE_STATS_LOGGING_
@@ -150,12 +150,12 @@ auto ActionPointDistancesCache::GetRaw(
 #endif

    // Check thread-local cache first (no locks needed!)
-    if (auto localIt = tlsCache.find(cacheKey); localIt != tlsCache.end()) {
+    if (tlsCache.contains(cacheKey)) {
 #if CACHE_STATS_LOGGING_
        cacheStats.localHits++;
        MaybePrintCacheStats();
 #endif
-        return localIt->second.rawPtr;  // Raw pointer - zero overhead access!
+        return tlsCache.at(cacheKey).rawPtr;  // Raw pointer - zero overhead access!
    }

 #if CACHE_STATS_LOGGING_
@@ -184,10 +184,13 @@ auto ActionPointDistancesCache::GetRaw(
    // Declaring here to keep the copied map in scope
    const HexMap* mapToUse = map;

+    // ReSharper disable once CppTooWideScope
+    // ReSharper disable once CppJoinDeclarationAndAssignment
+    fb::HexMapW iceClearedMap;
    if (hasIce) {
        // Create ice-cleared map for pathfinding
        // This prevents AI from considering ice as a valid path toward enemies
-        fb::HexMapW iceClearedMap = CreateIceClearedMap(map);
+        iceClearedMap = CreateIceClearedMap(map);
        mapToUse = iceClearedMap.Get();
    }

@@ -214,7 +217,7 @@ auto ActionPointDistancesCache::GetRaw(
    // Store in shared cache
    sharedDistances.lazy_emplace_l(
            cacheKey,
-            [](const auto& kv) { /* already checked above */ },
+            [](const auto& /*kv*/) { /* already checked above */ },
            [=](const auto& ctor) { ctor(cacheKey, result); });

    // Cache result locally for future lookups by this thread
@@ -26,7 +26,7 @@ void FixedActionPointDistances::SetCacheDirectory(const string& newDir) {

 static thread_local byte_vector _scratch;

-FixedActionPointDistances::FixedActionPointDistances(const HexMap* map, int columnCount)
+FixedActionPointDistances::FixedActionPointDistances(const HexMap* /*map*/, int columnCount)
    : ActionPointDistances(columnCount) {}

 auto FixedActionPointDistances::Create(
@@ -130,8 +130,8 @@ void ApplyResolvedUnit(
        }
    }

-    common::FilterInPlace(inoutState.units, [unitId](const auto &unit) {
-        return unit.unit_id() != unitId;
+    std::erase_if(inoutState.units, [unitId](const auto &unit) {
+        return unit.unit_id() == unitId;
    });
    inoutState.units[unitId] = *((Unit *)resolvedUnit.unit_bytes().data());
    inoutState.units[unitId].mutate_status(
@@ -161,7 +161,7 @@ void MutatingAddUnits(GameStateW &mutatingState, const ActionResultProto &result
        const auto *unit = (Unit *)unitBytes.data();
        maxChangedUnitId = std::max(maxChangedUnitId, unit->unit_id());

-        if (unit->unit_id() >= mutatingState->units()->size()) {
+        if (static_cast<unsigned int>(unit->unit_id()) >= mutatingState->units()->size()) {
            // Unit ID beyond vector size - must expand
            needsVectorExpansion = true;
            break;  // No point checking further
@@ -48,7 +48,7 @@ auto CopyWithExtraUnits(const GameStateW& original, int additionalCount) -> Game
        // Fallback: create new bitfield only if original doesn't have one
        const int16_t rowCount = endGST.hex_map->row_count;
        const int16_t columnCount = endGST.hex_map->column_count;
-        const size_t mapSize = rowCount * columnCount;
+        const size_t mapSize = static_cast<size_t>(rowCount) * static_cast<size_t>(columnCount);
        const size_t bitfieldSize = (mapSize + 7) / 8;  // Ceiling division
        endGST.occupied_tiles.resize(bitfieldSize, 0);  // Initialize all bits to 0 (empty)

@@ -58,7 +58,9 @@ auto CopyWithExtraUnits(const GameStateW& original, int additionalCount) -> Game
                const auto& location = unit.location();
                if (location.row() >= 0 && location.row() < rowCount && location.column() >= 0 &&
                    location.column() < columnCount) {
-                    const size_t tileIndex = location.row() * columnCount + location.column();
+                    const size_t tileIndex =
+                            static_cast<size_t>(location.row()) * static_cast<size_t>(columnCount) +
+                            static_cast<size_t>(location.column());
                    const size_t byteIndex = tileIndex / 8;
                    const size_t bitOffset = tileIndex % 8;
                    endGST.occupied_tiles[byteIndex] |= (1 << bitOffset);  // Set the bit
@@ -11,7 +11,7 @@
 namespace shardok {
 auto DefensiveAmbushAction::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    const auto results = CombatUtils::InternalPerformMelee(
            ActionCost(ActionCost::standard, 0),
            currentState->units()->Get(ambusherId),
@@ -23,7 +23,7 @@ FireOutAction::FireOutAction(
      fireOutOdds(std::move(odds)) {}

 auto FireOutAction::InternalExecute(
-        const GameStateW& currentState,
+        const GameStateW& /*currentState*/,
        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
    const auto fireOutRoll = generator->Percentile();

@@ -23,7 +23,7 @@ FireSpreadAction::FireSpreadAction(
      fireSpreadOdds(std::move(odds)) {}

 auto FireSpreadAction::InternalExecute(
-        const GameStateW& currentState,
+        const GameStateW& /*currentState*/,
        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
    const auto fireSpreadRoll = generator->Percentile();

@@ -71,8 +71,8 @@ public:
 };

 auto MeteorUnitDamageAction::InternalExecute(
-        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
+        const GameStateW & /*currentState*/,
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResultProto> {
    CombatDamage attackerDamage =
            CombatDamage::Builder()
                    .SetFire(attackerIntelligence * baseDamage * damageMultiplier)
@@ -131,8 +131,8 @@ public:
 };

 auto MeteorTileDamageAction::InternalExecute(
-        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
+        const GameStateW & /*currentState*/,
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResultProto> {
    auto tm = fb::ToTileModifierProto(terrain->modifier());

    MutatingAdjustBridgeIntegrity(&tm, integrityAdjustment);
@@ -154,7 +154,7 @@ auto MeteorTileDamageAction::InternalExecute(
 }

 auto MeteorCastAction::InternalExecute(
-        const GameStateW &currentState,
+        const GameStateW & /*currentState*/,
        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
    vector<ActionResultProto> allResults{};
    auto runningGameState = startingGameState;
@@ -97,7 +97,7 @@ auto BurnStructuresResult(const GameStateW &gameState, const SettingsGetter &set
 auto NewWeather(
        const net::eagle0::shardok::storage::fb::MonthlyWeather &monthlyWeather,
        const WeatherFb &oldWeather,
-        const SettingsGetter &settings,
+        const SettingsGetter & /*settings*/,
        const std::shared_ptr<RandomGenerator> &randomGenerator) -> Weather {
    const Weather::Conditions newConditions =
            ConditionsByMonth(monthlyWeather, randomGenerator->Percentile());
@@ -21,7 +21,7 @@ auto ChooseUndeadCommand(
        const std::shared_ptr<RandomGenerator> &randomGenerator) -> CommandSPtr;

 auto PerformUndeadCommandsAction::InternalExecute(
-        const GameStateW &currentState,
+        const GameStateW & /*currentState*/,
        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
    GameStateW runningGameState = startingGameState;
    vector<ActionResultProto> allResults{};
@@ -14,7 +14,7 @@ using net::eagle0::shardok::common::GameStatus;

 [[nodiscard]] auto PlaceHiddenUnitCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    auto actorAfter = *currentState->units()->Get(actorId);
    actorAfter.mutable_location() = target;
    actorAfter.mutate_hidden(true);
@@ -12,8 +12,8 @@ using net::eagle0::shardok::common::ActionType;
 using net::eagle0::shardok::common::GameStatus;

 auto PlaceUnitCommand::InternalExecute(
-        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const GameStateW& /*currentState*/,
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    auto actorAfter = *actor;
    actorAfter.mutable_location() = target;

@@ -78,7 +78,7 @@ auto effectiveSnow(const TerrainProto& terr) -> double {
 }

 auto SnowAdjustmentAction::InternalExecute(
-        const GameStateW& currentState,
+        const GameStateW& /*currentState*/,
        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
    vector<ActionResult> results{};

@@ -17,8 +17,8 @@ static auto RequiredDailyFood(const Unit& unit, const SettingsGetter& settingsGe
 }

 auto StartPlayerTurnAction::InternalExecute(
-        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const GameStateW& /*currentState*/,
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    ActionResult result{};
    result.set_type(net::eagle0::shardok::common::ActionType::PLAYER_TURN_START);
    result.mutable_next_player()->set_value(newFactionId);
@@ -12,7 +12,7 @@ namespace shardok {

 auto UndeadChangeAction::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    if (undeadUnitIds.empty()) return {};

    const int maxGrowthPer = (int)(reinforceRate * bodyCount / (double)undeadUnitIds.size());
@@ -9,8 +9,8 @@
 namespace shardok {

 auto UndeadFrozenAction::InternalExecute(
-        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const GameStateW& /*currentState*/,
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    if (occupant->battalion().type() != net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD)
        return {};

@@ -4,6 +4,9 @@

 #include "UpdateGameStatusAction.hpp"

+#include <algorithm>
+#include <ranges>
+
 #include "src/main/cpp/net/eagle0/shardok/library/util/ActionResultFlatbufferHelpers.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/game_status.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/player_info.hpp"
@@ -65,7 +68,7 @@ void UpdateGameStatusAction::ResolveHiddenLosers(ActionResult& actionResult) con
    for (const auto* unit : *gameState->units()) {
        if (unit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT) continue;

-        if (!common::Contains(winningIds, unit->player_id()) && unit->hidden() &&
+        if (!std::ranges::contains(winningIds, unit->player_id()) && unit->hidden() &&
            unit->can_flee() && unit->has_attached_hero() &&
            unit->attached_hero().vigor() >= settingsGetter.Backing().minimum_vigor_to_act()) {
            net::eagle0::shardok::storage::ResolvedUnit* fledRanger =
@@ -80,7 +83,7 @@ void UpdateGameStatusAction::ResolveHiddenLosers(ActionResult& actionResult) con

 auto UpdateGameStatusAction::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    vector<ActionResult> results{};

    // If the game has already ended, just return that state
@@ -148,7 +151,7 @@ auto UpdateGameStatusAction::InternalExecute(

            for (const PlayerId pid2 : survivors) {
                if (pid1 == pid2) continue;
-                if (!common::ContainsWhere(
+                if (!std::ranges::any_of(
                            *p1Info->allies(),
                            [pid2](const net::eagle0::shardok::storage::fb::AlliedPlayer*
                                           alliedPlayer) {
@@ -12,7 +12,7 @@ namespace shardok {

 auto UpdateOpponentKnowledgeAction::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    ActionResult result{};
    result.set_type(net::eagle0::shardok::common::ActionType::KNOWLEDGE_UPDATED);

@@ -31,7 +31,7 @@ auto UpdateOpponentKnowledgeAction::InternalExecute(

        for (PlayerId pid = 0; pid < 10; pid++) {
            if (pid == unitPid) continue;
-            if (pid >= playerCount) continue;
+            if (static_cast<unsigned int>(pid) >= playerCount) continue;
            int bump = PlayerIsDefender(currentState, pid) ? defenderKnowledgeGain
                                                           : attackerKnowledgeGain;
            MutatingBumpOpponentKnowledge(&unitAfter, pid, bump);
@@ -8,6 +8,9 @@

 #include "FleeCommandFactory.hpp"

+#include <algorithm>
+#include <ranges>
+
 #include "src/main/cpp/net/eagle0/shardok/library/commands/BecomeOutlawCommand.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/commands/FleeCommand.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
@@ -41,7 +44,7 @@ void FleeCommandFactory::AddAvailableFleeCommands(
        for (const auto &adjTile : HexMapUtils::GetAdjacentTiles(map, unit->location())) {
            const auto *occupant = Occupant(allUnits, adjTile.coords);
            if (occupant && !occupant->hidden()) {
-                if (common::Contains(allyPids, occupant->player_id())) {
+                if (std::ranges::contains(allyPids, occupant->player_id())) {
                    adjacentFriendliesMod += perAdjacentFriendly;
                } else {
                    adjacentEnemiesMod += perAdjacentEnemy;
@@ -55,7 +58,7 @@ void FleeCommandFactory::AddAvailableFleeCommands(
        for (const auto &twoAwayCoords : TilesWithExactDistance(map, unit->location(), 2)) {
            const auto *occupant = Occupant(allUnits, twoAwayCoords);
            if (occupant && !occupant->hidden()) {
-                if (common::Contains(allyPids, occupant->player_id())) {
+                if (std::ranges::contains(allyPids, occupant->player_id())) {
                    adjacentFriendliesMod += int32_t(perAdjacentFriendly * adjustmentForTwoAway);
                } else {
                    adjacentEnemiesMod += int32_t(perAdjacentEnemy * adjustmentForTwoAway);
@@ -4,6 +4,9 @@

 #include "HideCommandFactory.hpp"

+#include <algorithm>
+#include <ranges>
+
 #include "src/main/cpp/net/eagle0/shardok/library/commands/HideCommand.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/ZoneOfControlCalculator.hpp"
@@ -26,7 +29,7 @@ auto HideCommandFactory::MakeHideCommand(const Unit *actor, const Coords &target

 auto HideCommandFactory::PositionIsHideable(
        const Unit *actor,
-        CommandList &existingCommands,
+        CommandList & /*existingCommands*/,
        const HexMap *hexMap,
        const Coords &target,
        const Units *units,
@@ -36,7 +39,7 @@ auto HideCommandFactory::PositionIsHideable(
    const auto occupant = Occupant(units, target);
    if (occupant) {
        if (occupant->player_id() == actor->player_id()) return false;
-        if (common::Contains(allyPids, occupant->player_id())) return false;
+        if (std::ranges::contains(allyPids, occupant->player_id())) return false;
        if (!occupant->hidden()) return false;
    }

@@ -8,7 +8,6 @@

 #include "HolyWaveCommandFactory.hpp"

-#include "src/main/cpp/net/eagle0/common/ContainerUtils.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/commands/HolyWaveCommand.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"

@@ -46,7 +45,7 @@ void HolyWaveCommandFactory::AddAvailableCommands(
    AddAvailableHolyWaveCommands(commands, params.unit, params.remainingActionPoints);
 }

-auto CanHolyWave(const SettingsGetter &settings, const Unit *unit) -> bool {
+auto CanHolyWave(const SettingsGetter & /*settings*/, const Unit *unit) -> bool {
    if (!unit->has_attached_hero()) return false;

    return unit->attached_hero().profession_info().profession() ==
@@ -21,9 +21,9 @@ void ScoutCommandFactory::AddAvailableScoutCommands(
        CommandList& commands,
        const Unit* unit,
        const ActionPoints remainingActionPoints,
-        const Coords& position,
+        const Coords& /*position*/,
        const HexMap* hexMap,
-        const Units* units) const {
+        const Units* /*units*/) const {
    if (CanScout(settings, unit)) {
        const auto& hero = unit->attached_hero();

@@ -13,7 +13,7 @@ using net::eagle0::shardok::common::ActionType;

 auto ControlCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    const Unit* actor = currentState->units()->Get(actorId);
    if (!actor->has_attached_hero() ||
        actor->attached_hero().control_info().controlled_unit_id() == -1) {
@@ -38,7 +38,7 @@ auto ApplyAndAdd(
 }

 auto EndTurnCommand::InternalExecute(
-        const GameStateW &currentState,
+        const GameStateW & /*currentState*/,
        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
    if (GetPlayerId() != gameState->current_player()) {
        throw ShardokInternalErrorException(
@@ -73,8 +73,8 @@ auto EndTurnCommand::InternalExecute(
    // Any heroes in fire get burninated
    // Decrement stun counters, increment cast state
    const auto beforeFireUnitsCount = runningGameState->units()->size();
-    for (int i = 0; i < beforeFireUnitsCount; i++) {
-        const auto *beforeUnit = runningGameState->units()->Get(i);
+    for (size_t i = 0; i < beforeFireUnitsCount; i++) {
+        const auto *beforeUnit = runningGameState->units()->Get(static_cast<unsigned int>(i));
        if (beforeUnit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT)
            continue;
        if (beforeUnit->player_id() != GetPlayerId()) continue;
@@ -112,10 +112,10 @@ auto EndTurnCommand::InternalExecute(
    endTurnResult.mutable_next_player()->set_value(NextPlayerId(gameState, GetPlayerId()));

    const auto unitsAtEndOfRoundCount = runningGameState->units()->size();
-    for (int i = 0; i < unitsAtEndOfRoundCount; i++) {
+    for (size_t i = 0; i < unitsAtEndOfRoundCount; i++) {
        //  Grab the unit fresh because it might have been modified by a previous iteration of the
        //  loop
-        const auto *eorUnit = runningGameState->units()->Get(i);
+        const auto *eorUnit = runningGameState->units()->Get(static_cast<unsigned int>(i));
        if (eorUnit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT)
            continue;
        if (eorUnit->player_id() != GetPlayerId()) continue;
@@ -11,7 +11,7 @@ namespace shardok {

 auto FortifyCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    ActionResult fortifyResult{};
    fortifyResult.set_type(net::eagle0::shardok::common::FORTIFIED);
    fortifyResult.mutable_player()->set_value(GetPlayerId());
@@ -4,6 +4,8 @@

 #include "HideCommand.hpp"

+#include <algorithm>
+#include <ranges>
 #include <utility>

 #include "src/main/cpp/net/eagle0/shardok/library/unit/Unit.hpp"
@@ -29,7 +31,7 @@ HideCommand::HideCommand(

 auto HideCommand::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    auto actorAfter = *currentState->units()->Get(actorId);
    MutatingSpendActionPoints(&actorAfter, cost);

@@ -60,7 +62,7 @@ auto HideCommand::InternalExecute(
            if (!oneOverOccupant) continue;
            PlayerId occupantPid = oneOverOccupant->player_id();
            if (occupantPid == GetPlayerId()) continue;
-            if (common::Contains(alliedPids, occupantPid)) continue;
+            if (std::ranges::contains(alliedPids, occupantPid)) continue;

            if (!oneOverOccupant->has_attached_hero()) continue;
            if (oneOverOccupant->attached_hero().profession_info().profession() ==
@@ -9,6 +9,7 @@
 #include "HolyWaveCommand.hpp"

 #include <algorithm>
+#include <ranges>
 #include <utility>

 #include "src/main/cpp/net/eagle0/shardok/library/action_result_applier/ActionResultApplier.hpp"
@@ -50,7 +51,7 @@ public:

 auto HolyWaveDamageAction::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    ActionResult resultProto;
    resultProto.mutable_player()->set_value(playerId);
    resultProto.mutable_actor()->set_value(actingUnitId);
@@ -131,7 +132,7 @@ public:

 auto HolyWaveInspireAction::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    ActionResult resultProto;
    resultProto.mutable_player()->set_value(playerId);
    resultProto.mutable_actor()->set_value(actingUnitId);
@@ -197,7 +198,7 @@ HolyWaveCommand::HolyWaveCommand(

 auto HolyWaveCommand::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    vector<ActionResult> results;

    const Unit *actorBefore = currentState->units()->Get(actorId);
@@ -237,7 +238,7 @@ auto HolyWaveCommand::InternalExecute(
                undeadIds.push_back(occupant->unit_id());
            } else if (
                    occupant->player_id() == GetPlayerId() ||
-                    common::Contains(allyPids, GetPlayerId())) {
+                    std::ranges::contains(allyPids, GetPlayerId())) {
                allFriendlyUnitIds.push_back(occupant->unit_id());
            }
        }
@@ -34,7 +34,7 @@ auto LightningBoltCommand::InternalExecute(
    return ExecuteWithRoll(currentState, attackerRoll);
 }

-auto LightningBoltCommand::ExecuteWithRoll(const GameStateW& currentState, double attackerRoll)
+auto LightningBoltCommand::ExecuteWithRoll(const GameStateW& currentState, double /*attackerRoll*/)
        const -> vector<ActionResult> {
    const Unit* attackerBefore = currentState->units()->Get(attackerId);
    if (!attackerBefore->has_attached_hero()) {
@@ -24,7 +24,7 @@ MeteorCancelCommand::MeteorCancelCommand(

 auto MeteorCancelCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    const Unit* caster = currentState->units()->Get(casterId);
    auto casterAfter = *caster;

@@ -39,7 +39,7 @@ auto MeteorStartCommand::GetCommandProto() const -> CommandProto {

 auto MeteorStartCommand::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    const auto *caster = currentState->units()->Get(casterId);

    auto casterAfter = *caster;
@@ -14,7 +14,7 @@ namespace shardok {

 auto shardok::MeteorTargetCommand::InternalExecute(
        const GameStateW &currentState,
-        const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator> & /*generator*/) const -> vector<ActionResult> {
    const Unit *caster = currentState->units()->Get(casterId);
    auto casterAfter = *caster;

@@ -4,6 +4,8 @@

 #include "MoveCommand.hpp"

+#include <algorithm>
+#include <ranges>
 #include <utility>

 #include "src/main/cpp/net/eagle0/shardok/library/action_result_applier/ActionResultApplier.hpp"
@@ -97,7 +99,7 @@ auto shardok::MoveCommand::InternalExecute(
                    const auto* occupant = currentState.GetOccupant(adj);
                    if (!occupant) continue;
                    if (occupant->player_id() == mover.player_id()) continue;
-                    if (common::Contains(allyPids, occupant->player_id())) continue;
+                    if (std::ranges::contains(allyPids, occupant->player_id())) continue;
                    if (!occupant->has_attached_hero()) continue;
                    if (occupant->attached_hero().profession_info().profession() ==
                        net::eagle0::shardok::storage::fb::Profession_RANGER) {
@@ -113,7 +115,7 @@ auto shardok::MoveCommand::InternalExecute(
                    auto occupant = currentState.GetOccupant(adj);
                    if (!occupant) continue;
                    if (occupant->player_id() == mover.player_id()) continue;
-                    if (common::Contains(allyPids, occupant->player_id())) continue;
+                    if (std::ranges::contains(allyPids, occupant->player_id())) continue;
                    if (occupant->hidden()) {
                        auto occupantAfter = *occupant;
                        occupantAfter.mutate_hidden(false);
@@ -17,7 +17,7 @@ using net::eagle0::shardok::common::ActionType;

 auto ReinforceCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    const Unit* actingUnit = currentState->units()->Get(actingUnitId);
    auto actorAfter = *actingUnit;
    MutatingSpendActionPoints(&actorAfter, cost);
@@ -21,7 +21,7 @@ auto ReleaseUnitCommand::GetCommandProto() const -> CommandProto {

 auto ReleaseUnitCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    auto controllingUnitAfter = *currentState->units()->Get(actingUnitId);
    controllingUnitAfter.mutate_remaining_action_points(0);
    controllingUnitAfter.mutable_attached_hero().mutable_control_info().mutate_controlled_unit_id(
@@ -18,7 +18,7 @@ using net::eagle0::shardok::common::ActionType::REPAIR_FAILED;

 auto RepairCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    const auto* actor = currentState->units()->Get(actorId);

    if (!actor->has_attached_hero()) { throw ActionRequiresHeroException("repair"); }
@@ -13,7 +13,7 @@
 namespace shardok {
 auto RetreatCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    ActionResult result{};
    result.set_type(net::eagle0::shardok::common::ActionType::RETREATED);
    result.mutable_player()->set_value(GetPlayerId());
@@ -26,7 +26,7 @@ StartFireCommand::StartFireCommand(
      odds(std::move(odds)){};

 auto StartFireCommand::InternalExecute(
-        const GameStateW& currentState,
+        const GameStateW& /*currentState*/,
        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
    return ExecuteWithRoll(generator->Percentile());
 }
@@ -11,7 +11,7 @@ namespace shardok {

 auto UnitRestCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    auto actorAfter = *currentState->units()->Get(actorId);

    if (actorAfter.has_attached_hero()) {
@@ -10,7 +10,7 @@ namespace shardok {

 auto UnitStopCommand::InternalExecute(
        const GameStateW& currentState,
-        const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+        const std::shared_ptr<RandomGenerator>& /*generator*/) const -> vector<ActionResult> {
    ActionResult result{};
    result.set_type(net::eagle0::shardok::common::ActionType::UNIT_STOP);
    result.mutable_player()->set_value(GetPlayerId());
@@ -7,6 +7,8 @@
 #include <sys/mman.h>
 #include <unistd.h>

+#include <mutex>
+
 namespace shardok {

 // Uses mmap and munmap to directly allocate pages
@@ -44,7 +46,7 @@ public:
        }
        return b;
    }
-    auto deallocate(uint8_t* buf, const size_t size) -> void override { free(buf); }
+    auto deallocate(uint8_t* buf, const size_t /*size*/) -> void override { free(buf); }

    ~MallocAllocator() override = default;
 };
@@ -54,9 +56,9 @@ class ReusingAllocator final : public WrapperAllocator {
 private:
    std::unique_ptr<WrapperAllocator> fallbackAllocator;

-    const size_t pageSize = getpagesize();
+    const size_t pageSize = static_cast<size_t>(getpagesize());

-    auto RoundUpToPage(const size_t size) const -> size_t {
+    [[nodiscard]] auto RoundUpToPage(const size_t size) const -> size_t {
        return (size + pageSize - 1) & ~(pageSize - 1);
    }

@@ -9,7 +9,10 @@

 #include "FlatbufferWrapper.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/hex_map.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/common/hex_map.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok::fb {

@@ -6,7 +6,10 @@
 #define EAGLE0_TERRAINHELPERS_HPP

 #include "src/main/flatbuffer/net/eagle0/shardok/storage/terrain.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/common/terrain.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok::fb {

@@ -6,7 +6,10 @@
 #define EAGLE0_TILEMODIFIERHELPERS_HPP

 #include "src/main/flatbuffer/net/eagle0/shardok/storage/tile_modifier.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/common/tile_modifier.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok::fb {

@@ -13,7 +13,10 @@

 #include "src/main/cpp/net/eagle0/shardok/library/ShardokCTypes.h"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/coords.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/common/coords.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok {

@@ -23,9 +23,9 @@ auto GetModifierHash(const HexMap* map) -> uint64_t {
    uint64_t modifierId = FNV_OFFSET_BASIS;
    for (const auto& t : *map->terrain()) {
        const auto modByte = shardok::ComputeModifierByte(t->modifier());
-        MixIn(modifierId, modByte);
+        MixIn(modifierId, static_cast<uint8_t>(modByte));
        if (t->modifier().snow().present()) {
-            MixIn(modifierId, static_cast<char>(t->modifier().snow().integrity()));
+            MixIn(modifierId, static_cast<uint8_t>(t->modifier().snow().integrity()));
        }
        MixIn(modifierId, '/');
    }
@@ -13,7 +13,10 @@
 #include <optional>

 #include "src/main/flatbuffer/net/eagle0/shardok/storage/tile_modifier.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/common/tile_modifier.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok {

@@ -47,10 +47,8 @@ auto SettingsGetter::GetFirePropensityByWeatherConditions(
 void GameSettings::Setter::SetFromTypesAndValues(
        const std::unordered_map<string, string>& types,
        const std::unordered_map<string, string>& values) {
-    for (const auto& kv : values) {
-        const string& settingName = kv.first;
+    for (const auto& [settingName, valueString] : values) {
        const string& typeString = types.at(settingName);
-        const string& valueString = kv.second;

        if (typeString.starts_with("int")) {
            SetInt(settingName, std::stoi(valueString));
@@ -62,6 +62,12 @@ public:
    public:
        explicit Getter(const GameSettings &settings) : settings(settings) {}

+        // Rule of 5 to fix deprecated copy constructor warning
+        Getter(const Getter &) = default;
+        Getter &operator=(const Getter &) = delete;  // Can't assign due to reference member
+        Getter(Getter &&) = default;
+        Getter &operator=(Getter &&) = delete;  // Can't assign due to reference member
+
        virtual ~Getter() = default;

        [[nodiscard]] auto ActionCostFor(int pointValue) const -> ActionCost;
@@ -4,6 +4,8 @@

 #include "SettingsLoader.hpp"

+#include <memory>
+
 #include "src/main/cpp/net/eagle0/common/FilesystemUtils.hpp"
 #include "src/main/cpp/net/eagle0/common/TsvParser.hpp"
 #include "src/main/cpp/net/eagle0/shardok/util/BattalionTypeRegistrar.hpp"
@@ -17,7 +17,10 @@
 #include "src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokException.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/hero.hpp"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
 #include "src/main/protobuf/net/eagle0/shardok/common/terrain.pb.h"
+#pragma GCC diagnostic pop

 namespace shardok {
 using std::string;
@@ -39,7 +39,6 @@ cc_library(
    ],
    deps = [
        ":hex_cube_utils",
-        "//src/main/cpp/net/eagle0/common:container_utils",
        "//src/main/cpp/net/eagle0/common:filesystem_utils",
        "//src/main/cpp/net/eagle0/shardok/library/map:coordinates",
        "//src/main/cpp/net/eagle0/shardok/library/map:coords_set",
@@ -43,7 +43,8 @@ void Validate(const GameStateW &inState, const GameStateW &outState) {
            inStatus != net::eagle0::shardok::storage::fb::UnitStatus_OUTLAWED_UNIT)
            continue;

-        const auto outStatus = outState->units()->Get(inUnit->unit_id())->status();
+        const auto outStatus =
+                outState->units()->Get(static_cast<unsigned int>(inUnit->unit_id()))->status();
        internalAssert(
                outStatus == inStatus,
                "Can't come back from fled/destroyed/captured status");
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
admin	6b9afab26d	different async	2025-08-15 06:43:19 -07:00
adminandGitHub	1bc8fa418e	defer another get() (#4338 )	2025-08-15 06:42:18 -07:00
adminandGitHub	3da5b576a0	More wait (#4335 ) * add comments * return a future from the AIScoreCalculator api * is this a deadlock * avoid the deadlock	2025-08-14 21:02:20 -07:00
adminandGitHub	51e41219ac	wait on a future (#4334 ) * wait on a future * move the private static functions into the implementation file	2025-08-14 20:25:25 -07:00
admin GitHub Claude	d6fe2f415d	Modernize remaining container utils (#4333 ) * Remove unused container utility functions from ContainerUtils.hpp Removed the following unused template functions: - CountIf (no usages found) - Filtered and FilteredToVector (no usages found) - Map and MapToVector (no usages found) - FlatMap and FlatMapToVector (no usages found) - ToVector (no usages found) - Append (no usages found) Kept FilterInPlace as it's still used in several files but marked it as deprecated with a comment to use std::erase_if instead. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Replace FilterInPlace with std::erase_if and remove from ContainerUtils - Replaced all FilterInPlace usages with std::erase_if in: * AvailableCommandsFactory.cpp (5 usages) * ActionResultApplier.cpp (1 usage) - Removed FilterInPlace function from ContainerUtils.hpp entirely - Simplified ContainerUtils_test.cpp by removing all tests for removed functions - Note: FilterInPlace for CoordsSet remains in CoordsSet.hpp as it's for custom type 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * remove ContainerUtils and ContainerUtils_test * Restore Map, MapToVector, and FlatMapToVector functions for remaining usages - Recreated ContainerUtils.hpp with only the functions still in use: * Map (used in AIAttackGroups.cpp and ShardokGameController.cpp) * MapToVector (used in EagleInterfaceGrpcServer.cpp) * FlatMapToVector (used in EagleInterfaceGrpcServer.cpp) - Added missing #includes and BUILD dependencies to all files using these functions - All functions marked as deprecated with comments suggesting C++20/23 alternatives - Used C++20 concepts for conditional reserve() calls 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Replace all common::Map function calls with std::ranges::transform - Replaced common::Map in AIAttackGroups.cpp with std::ranges::transform + back_inserter - Replaced common::Map in ShardokGameController.cpp with std::ranges::transform + back_inserter - Replaced 3 common::MapToVector calls in EagleInterfaceGrpcServer.cpp with std::ranges::transform + back_inserter - Replaced common::FlatMapToVector with nested std::ranges::any_of for more idiomatic ranges code - Added proper reserve() calls for performance - Removed all Map functions from ContainerUtils.hpp - Updated includes to use <iterator> and <ranges> instead of ContainerUtils.hpp - Removed container_utils dependencies from BUILD files All custom container utility functions have now been fully replaced with C++20/23 standard library equivalents. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Remove ContainerUtils.hpp file and BUILD target - Deleted src/main/cpp/net/eagle0/common/ContainerUtils.hpp (now empty) - Removed container_utils BUILD target from common/BUILD.bazel - All container utility functions have been fully replaced with C++20/23 standard library equivalents The modernization is now complete - no custom container utilities remain in the codebase. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * typo * gazelle --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-08-14 19:36:30 -07:00
admin GitHub Claude	dab304b595	Replace custom container utilities with C++20/23 standard library equivalents (#4332 ) * Replace custom container utilities with C++20/23 standard library equivalents - Replace common::Contains with std::ranges::contains (C++23) - Replace common::ContainsWhere with std::ranges::any_of (C++20) - Replace common::FindIf with std::ranges::find_if (C++20) - Mark deprecated custom helper functions in ContainerUtils.hpp - Add #include <ranges> and <algorithm> to affected files This modernizes the codebase to use standard library algorithms instead of custom implementations, improving maintainability and leveraging optimized standard library implementations. The custom functions remain for compatibility but are marked as deprecated to encourage migration to standard equivalents. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * Complete replacement of all remaining common::Contains usages - UpdateGameStatusAction.cpp: Replace common::Contains with std::ranges::contains - AvailableCommands_test.cpp: Replace usage in test and add ranges include - GtestExtensions.hpp: Update test helper function to use std::ranges::contains - HideCommandFactory.cpp: Replace common::Contains in hide command logic - MoveCommand.cpp: Replace all usages in move command ally checking - HideCommand.cpp: Replace usage in allied player checking - HolyWaveCommand.cpp: Replace usage in holy wave targeting - ShardokEngine.cpp: Fix iterator dereference after FindIf conversion All custom common::Contains usages have been eliminated in favor of C++23 std::ranges::contains for better performance and standards compliance. * remove those functions * fix GtestExtensions.hpp * Fix test template to handle both standard containers and custom types Use C++20 concepts with if constexpr to detect whether a type has a Contains member function (like CoordsSet) or should use std::ranges::contains for standard containers. This allows the test helper to work correctly with both standard library containers and custom container-like classes. All 105 C++ tests now pass successfully. * Use const auto for iterator in ShardokGameController Make iterator constness explicit since it's in a const member function and the iterator is never modified. This improves code clarity about intent. * Use const auto for all iterator variables in ShardokEngine Make iterator constness explicit in all find_if operations since these iterators are never modified after creation. This improves code clarity and const correctness throughout the engine placement logic. * more deprecated removal --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-08-14 16:36:45 -07:00
admin GitHub Claude	44044eb981	Modernize range-based loops with C++17 structured bindings (#4331 ) Replace traditional key-value pair iteration patterns with structured bindings: - HexMapUtils.hpp: Modernize template functions with [unitId, unit] bindings - GameSettings.cpp: Use [settingName, valueString] destructuring - PlayerSetupCommandFactory.cpp: Replace kv.second with unit binding - MapInfoCalculatorRunner.cpp: Use [position, count] for JSON output This improves code readability by eliminating repetitive .first/.second member access and makes the intent more explicit. Structured bindings were introduced in C++17 and provide cleaner, more expressive iteration. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-14 06:33:09 -07:00
admin GitHub Claude	0016fc86bc	Modernize map operations using C++20 contains() method (#4330 ) Replace find() \!= end() patterns with more readable contains() + at() approach: - ActionPointDistancesCache.cpp: Update cache lookup logic - GameStateGuesser.cpp: Modernize player averages lookup This improves code readability while maintaining identical performance characteristics. The contains() method was introduced in C++20 and provides a cleaner, more expressive way to check map membership. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-14 06:33:01 -07:00
adminandGitHub	06538f3493	update to C++23 (#4329 )	2025-08-13 22:03:08 -07:00
admin GitHub Claude	45c5183ecb	Update LLVM version from 19.1.0 to 20.1.2 (#4328 ) - Updates to latest supported LLVM version in toolchains_llvm 1.4.0 - All C++ builds and tests pass successfully with Clang/LLVM 20.1.2 - Shardok server builds successfully in optimized mode 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 21:41:42 -07:00
admin GitHub Claude	3f304fe57e	Update toolchains_llvm from 1.2.0 to 1.4.0 (#4327 ) - Updates LLVM toolchain to latest stable version from Bazel Central Registry - All builds and tests pass successfully with new version 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 17:02:16 -07:00
admin GitHub Claude	35cb38be65	Update rules_go from 0.50.1 to 0.56.1 (#4325 ) - Updated rules_go to latest stable version (0.56.1) - Verified Go builds complete successfully - Confirmed Go tests continue to pass 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 17:01:26 -07:00
admin GitHub Claude	b7f86a2029	Update gazelle from 0.40.0 to 0.45.0 (#4326 ) * Update gazelle from 0.40.0 to 0.45.0 - Updated gazelle to latest stable version (0.45.0) - Verified Go builds complete successfully - Confirmed Go tests continue to pass 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com> * run gazelle --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 14:02:30 -07:00
admin GitHub Claude	57ff4c14fe	Update bazel_skylib from 1.7.1 to 1.8.1 (#4323 ) - Updated bazel_skylib to latest stable version (1.8.1) - Verified Eagle server builds successfully - Confirmed tests continue to pass 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 13:15:14 -07:00
admin GitHub Claude	9a5ce10600	Update googletest from 1.15.2 to 1.17.0 (#4324 ) - Updated googletest to latest stable version (1.17.0) - Verified Shardok C++ tests pass successfully - Confirmed no breaking changes in test framework 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 12:54:28 -07:00
admin GitHub Claude	3f8c999446	Update rules_pkg from 1.0.1 to 1.1.0 (#4322 ) - Updated rules_pkg to latest stable version (1.1.0) - Verified Eagle server builds successfully - Confirmed tests continue to pass 🤖 Generated with [Claude Code](https://claude.ai/code) Co-authored-by: Claude <noreply@anthropic.com>	2025-08-13 09:44:04 -07:00
adminandGitHub	3c8bd1d804	Re-enable another warning (#4321 ) * re-enable another warning * more fixes * more fixes	2025-08-13 09:40:06 -07:00
adminandGitHub	63e7c04276	ReturnCommand goes protoless (#4320 )	2025-08-13 09:14:43 -07:00
adminandGitHub	c27f1ec93f	rest command goes protoless (#4319 ) * rest command goes protoless * cleanup * fix the tests too * missing one * moar	2025-08-13 08:33:46 -07:00
adminandGitHub	21c11c9afb	Yet more warnings (#4318 ) * unused parameters * more * moar * moar * fix some test warnings * fix some test warnings * another * another	2025-08-13 08:01:12 -07:00
adminandGitHub	b12a7584a5	fix some warnings and add more copts (#4317 ) * fix some warnings and add more copts * more fixes * fix more deprecations * remove that * cleanup * cleanup * a bit more	2025-08-13 07:08:12 -07:00
adminandGitHub	d1b752bd56	SuppressBeastsCommand goes protoless (#4316 ) * partially working * legacy * it builds * fix existing tests * and the call site * moar * restore the tests * fix the tests * build file fix * cleanup	2025-08-13 06:46:41 -07:00
adminandGitHub	bfb78c2b85	No eagle morale (#4315 ) * remove all morale references * remove from CommonUnit too * and fix unit conversions * cleanup	2025-08-11 20:13:01 -07:00
adminandGitHub	bc3c14bde7	Fix attack decision (#4313 ) * fix the attack decision * better * implement the tests * include tests * closer on tests * one more	2025-08-11 19:46:16 -07:00
adminandGitHub	353fb08592	cleanup (#4314 )	2025-08-10 10:48:01 -07:00
adminandGitHub	74c8ca80bc	fix a crasher in SuppressBeastsCommandSelector (#4311 )	2025-08-09 18:58:01 -07:00
adminandGitHub	f668328983	make a lower assumption about stats until we have some data about the… (#4312 ) * make a lower assumption about stats until we have some data about the player's other units * add tests	2025-08-08 11:13:34 -07:00
adminandGitHub	9fa948d63f	Fleeing way too often (#4307 ) * what did you do * kinda messed up * let's try this way * fix tests * put back the check and start fixing the test * tidies * fix one test * more passing * fix tests	2025-08-07 22:15:08 -07:00
adminandGitHub	86a0212062	more gpt-5 defaulting (#4310 )	2025-08-07 20:22:09 -07:00
adminandGitHub	f910661c32	change AIScoreUtilities to take a GameStateW& (#4309 )	2025-08-07 20:16:16 -07:00
adminandGitHub	cd28e2dfcf	Use gpt-5 (#4308 ) * hmm * make gpt-5 the default	2025-08-07 19:36:35 -07:00
adminandGitHub	9bccccc3fb	only get return prisoner quests for faction leaders (#4306 )	2025-08-05 20:49:42 -07:00
adminandGitHub	5603d57e76	No raw GameState pointers in shardok/ai/ (#4305 ) * more * AIWaterCrossing too * fix build	2025-08-05 19:46:28 -07:00
adminandGitHub	359eceff97	use new flee logic when deciding to flee early (#4304 ) * use new flee logic when deciding to flee early * fix tests * not so hopeless * use unit power * dupes * fix the overload removals	2025-08-05 19:17:56 -07:00
adminandGitHub	acf1af5fcc	much simpler (#4303 )	2025-08-01 06:45:33 -07:00
adminandGitHub	f4e35bf4f0	less likely to flee if odds are lower (#4300 ) * less likely to flee if odds are lower * into settings * move to another file * tests * fix the remaining tests	2025-07-31 21:27:31 -07:00
adminandGitHub	a3383f8871	fix a crasher from a bad CLion suggestion (#4302 ) * fix a crasher from a bad CLion suggestion * disable bad advice	2025-07-31 21:23:06 -07:00
adminandGitHub	366d4790cd	don't bring more battalions than heroes from a particular province (#4298 ) * don't bring more battalions than heroes from a particular province * unit tests * gazelle * more idiomatic * update tests	2025-07-30 07:48:12 -07:00
adminandGitHub	0dc8b75906	fix a battalion power bug (#4299 )	2025-07-30 07:46:30 -07:00