Use preincrement in production loops

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

@@ -443,7 +443,7 @@ void ShardokEngine::PostPlacementCommands(
             reinforcementPositions);
 
     // first make sure they're all valid and there are no duplicates
-    for (size_t i = 0; i < placementInfos.size(); i++) {
+    for (size_t i = 0; i < placementInfos.size(); ++i) {
         const UnitPlacementInfo &pi = placementInfos[i];
 
         const auto it = std::ranges::find_if(*placementCommands, [pi](const CommandSPtr &cmd) {

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

@@ -77,7 +77,7 @@ static auto CreateIceClearedMap(const HexMap* map) -> fb::HexMapW {
     auto* mutableMap = mapCopy.Get();
     auto* terrainVec = mutableMap->mutable_terrain();
 
-    for (size_t i = 0; i < terrainVec->size(); i++) {
+    for (size_t i = 0; i < terrainVec->size(); ++i) {
         // Only process tiles with ice
         // const_cast is safe here because we own the mutable buffer (mapCopy)
         if (auto* terrain = const_cast<Terrain*>(terrainVec->GetMutableObject(i));

src/main/cpp/net/eagle0/shardok/library/commands/EndTurnCommand.cpp

@@ -75,7 +75,7 @@ auto EndTurnCommand::InternalExecute(
     // Any heroes in fire get burninated
     // Decrement stun counters, increment cast state
     const auto beforeFireUnitsCount = runningGameState->units()->size();
-    for (size_t i = 0; i < beforeFireUnitsCount; i++) {
+    for (size_t i = 0; i < beforeFireUnitsCount; ++i) {
         const auto *beforeUnit = runningGameState->units()->Get(static_cast<unsigned int>(i));
         if (beforeUnit->status() != net::eagle0::shardok::storage::fb::UnitStatus_NORMAL_UNIT)
             continue;
@@ -114,7 +114,7 @@ auto EndTurnCommand::InternalExecute(
     endTurnResult.mutable_next_player()->set_value(NextPlayerId(currentState, GetPlayerId()));
 
     const auto unitsAtEndOfRoundCount = runningGameState->units()->size();
-    for (size_t i = 0; i < unitsAtEndOfRoundCount; i++) {
+    for (size_t i = 0; i < unitsAtEndOfRoundCount; ++i) {
         //  Grab the unit fresh because it might have been modified by a previous iteration of the
         //  loop
         const auto *eorUnit = runningGameState->units()->Get(static_cast<unsigned int>(i));

src/main/cpp/net/eagle0/shardok/server/ShardokGamesManager.cpp

@@ -206,7 +206,7 @@ auto SetUpController(
     if (tutorialConfig.enabled()) {
         std::vector<PlayerId> allPlayerIds;
         allPlayerIds.reserve(playerInfos.size());
-        for (size_t i = 0; i < playerInfos.size(); i++) {
+        for (size_t i = 0; i < playerInfos.size(); ++i) {
             allPlayerIds.push_back(static_cast<PlayerId>(i));
         }
 

src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplierImpl.scala

@@ -279,7 +279,7 @@ class ActionResultApplierImpl(validator: Option[Validator]) extends ActionResult
       .getOrElse(afterVictor)
 
     val afterEagleMap = result.newEagleMap
-      .map(em => afterGameType.copy(eagleMap = em))
+      .map(em => afterGameType.copy(eagleMap = Some(em)))
       .getOrElse(afterGameType)
 
     afterEagleMap.copy(actionResultCount = afterEagleMap.actionResultCount + 1)

src/main/scala/net/eagle0/eagle/library/util/view_filters/GameStateViewFilter.scala

@@ -54,7 +54,7 @@ object GameStateViewFilter {
       battalionTypes = gs.battalionTypes,
       chronicleEntries = gs.chronicleEntries,
       gameType = gs.gameType,
-      eagleMap = Some(gs.eagleMap)
+      eagleMap = gs.eagleMap
     )
   }
 }

src/main/scala/net/eagle0/eagle/model/proto_converters/EagleMapInfoConverter.scala

@@ -4,9 +4,6 @@ import net.eagle0.eagle.common.eagle_map_info.EagleMapInfo as EagleMapInfoProto
 import net.eagle0.eagle.model.state.game_state.EagleMapInfo
 
 object EagleMapInfoConverter {
-  private def isSet(proto: EagleMapInfoProto): Boolean =
-    proto.mapWidth != 0 || proto.mapHeight != 0 || proto.sha256.nonEmpty
-
   def toProto(eagleMapInfo: EagleMapInfo): EagleMapInfoProto =
     EagleMapInfoProto(
       mapWidth = eagleMapInfo.mapWidth,
@@ -23,14 +20,8 @@ object EagleMapInfoConverter {
       centroidsSha256 = proto.centroidsSha256
     )
 
-  def fromRequiredProto(proto: Option[EagleMapInfoProto]): EagleMapInfo = {
-    val eagleMapInfo = proto
-      .getOrElse(throw new IllegalArgumentException("EagleMapInfo proto is required"))
-    fromProto(eagleMapInfo)
-  }
-
   def fromProtoOption(proto: Option[EagleMapInfoProto]): Option[EagleMapInfo] =
     proto
-      .filter(isSet)
+      .filter(p => p.mapWidth != 0 || p.mapHeight != 0 || p.sha256.nonEmpty)
       .map(fromProto)
 }

src/main/scala/net/eagle0/eagle/model/proto_converters/game_state/GameStateConverter.scala

@@ -71,7 +71,7 @@ object GameStateConverter {
           randomSeed: Long,
           chronicleEntries: Vector[ChronicleEntry],
           gameType: GameType,
-          eagleMap: net.eagle0.eagle.model.state.game_state.EagleMapInfo
+          eagleMap: Option[net.eagle0.eagle.model.state.game_state.EagleMapInfo]
         ) =>
       GameStateProto(
         gameId = gameId,
@@ -97,7 +97,7 @@ object GameStateConverter {
         chronicleEntries = chronicleEntries.map(ChronicleEntryConverter.toProto),
         gameType = GameTypeConverter.toProto(gameType)._1,
         tutorialPhase = GameTypeConverter.toProto(gameType)._2,
-        eagleMap = Some(EagleMapInfoConverter.toProto(eagleMap))
+        eagleMap = eagleMap.map(EagleMapInfoConverter.toProto)
       )
   }
 
@@ -161,7 +161,7 @@ object GameStateConverter {
           gameType =
             if gameType == GameTypeProto.UNKNOWN_GAME_TYPE then GameType.Normal
             else GameTypeConverter.fromProto(gameType, tutorialPhase),
-          eagleMap = EagleMapInfoConverter.fromRequiredProto(eagleMap)
+          eagleMap = EagleMapInfoConverter.fromProtoOption(eagleMap)
         )
     }
 }

src/main/scala/net/eagle0/eagle/model/state/game_state/GameState.scala

@@ -37,5 +37,5 @@ case class GameState(
     randomSeed: Long,
     chronicleEntries: Vector[ChronicleEntry],
     gameType: GameType,
-    eagleMap: EagleMapInfo
+    eagleMap: Option[EagleMapInfo] = None
 )

src/main/scala/net/eagle0/eagle/service/InMemoryHistory.scala

@@ -54,13 +54,7 @@ object InMemoryHistory {
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = net.eagle0.eagle.model.state.GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = net.eagle0.eagle.model.state.GameType.Normal
   )
 }
 

src/main/scala/net/eagle0/eagle/service/SqliteHistory.scala

@@ -2017,13 +2017,7 @@ object SqliteHistory {
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   /**

src/main/scala/net/eagle0/eagle/service/new_game_creation/NewGameCreation.scala

@@ -493,12 +493,14 @@ object FixedNewGameCreation extends NewGameCreation {
   }
 
   private def genericStartGameResult(gameId: GameId, gameParameters: GameParameters): ActionResultC = {
-    val eagleMapProto = gameParameters.getEagleMap
-    val eagleMap      = EagleMapInfo(
-      mapWidth = eagleMapProto.mapWidth,
-      mapHeight = eagleMapProto.mapHeight,
-      sha256 = eagleMapProto.sha256,
-      centroidsSha256 = eagleMapProto.centroidsSha256
+    val eagleMapProto = gameParameters.eagleMap
+    val eagleMap      = eagleMapProto.map(em =>
+      EagleMapInfo(
+        mapWidth = em.mapWidth,
+        mapHeight = em.mapHeight,
+        sha256 = em.sha256,
+        centroidsSha256 = em.centroidsSha256
+      )
     )
     ActionResultC(
       actionResultType = ActionResultType.GameStart,
@@ -512,7 +514,7 @@ object FixedNewGameCreation extends NewGameCreation {
         )
       ),
       newRandomSeed = Some(gameId),
-      newEagleMap = Some(eagleMap)
+      newEagleMap = eagleMap
     )
   }
 

src/main/scala/net/eagle0/eagle/service/new_game_creation/TutorialGameCreation.scala

@@ -110,12 +110,13 @@ object TutorialGameCreation {
 
     // Start with base ActionResultC
     // Start at BattleRequest phase so battle begins immediately
-    val eagleMapProto = tutorialParams.getEagleMap
-    val eagleMap      = EagleMapInfo(
-      mapWidth = eagleMapProto.mapWidth,
-      mapHeight = eagleMapProto.mapHeight,
-      sha256 = eagleMapProto.sha256,
-      centroidsSha256 = eagleMapProto.centroidsSha256
+    val eagleMap = tutorialParams.eagleMap.map(em =>
+      EagleMapInfo(
+        mapWidth = em.mapWidth,
+        mapHeight = em.mapHeight,
+        sha256 = em.sha256,
+        centroidsSha256 = em.centroidsSha256
+      )
     )
 
     val baseResult = ActionResultC(
@@ -126,7 +127,7 @@ object TutorialGameCreation {
       newRandomSeed = Some(gameId),
       newProvinces = provinces,
       newGameType = Some(GameType.Tutorial(TutorialPhase.OpeningBattle)),
-      newEagleMap = Some(eagleMap)
+      newEagleMap = eagleMap
     )
 
     // Build factions, heroes, and battalions from tutorial parameters

src/test/cpp/net/eagle0/shardok/library/commands/ExtinguishFireCommand_test.cpp

@@ -34,7 +34,7 @@ class ExtinguishFireCommandTests : public ::testing::Test {
         fbb.ForceDefaults(true);
         auto actorOff = AddGenericUnit(0, 0, Coords(3, 2));
 
-        vector<Unit> unitsVec{actorOff};
+        auto unitsVec = vector<Unit>{actorOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         auto mapOff = AddHexMap(fbb, BASIC_MAP_FB);

src/test/cpp/net/eagle0/shardok/library/commands/FearCommand_test.cpp

@@ -26,7 +26,7 @@ class FearCommandTest : public ::testing::Test {
         auto actorOff = AddGenericUnit(5, 0, position);
         auto victimOff = AddGenericUnit(4, 1, target);
 
-        vector<Unit> unitsVec{actorOff, victimOff};
+        auto unitsVec = vector<Unit>{actorOff, victimOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         auto mapOff = AddBasicMap(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/FortifyCommand_test.cpp

@@ -19,7 +19,7 @@ class FortifyCommandTest : public ::testing::Test {
         fbb.ForceDefaults(true);
 
         auto engOff = AddGenericUnit(5, 0, Coords(2, 2));
-        vector<Unit> unitsVec{engOff};
+        auto unitsVec = vector<Unit>{engOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         GameStateBuilder gsb(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/FreezeWaterCommand_test.cpp

@@ -35,7 +35,7 @@ class FreezeWaterCommandTest : public ::testing::Test {
 
         auto undeadOff = AddGenericUndead(4, 1, target);
 
-        vector<Unit> unitsVec{mageOff, undeadOff};
+        auto unitsVec = vector<Unit>{mageOff, undeadOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         GameStateBuilder gsb(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/HideCommand_test.cpp

@@ -28,7 +28,7 @@ class HideCommandTests : public ::testing::Test {
 
         auto rangerOff = AddGenericUnit(rangerPid, 0, position);
         auto anotherOff = AddGenericUnit(anotherPid, 1, Coords(5, 5));
-        vector<Unit> unitsVec{rangerOff, anotherOff};
+        auto unitsVec = vector<Unit>{rangerOff, anotherOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         GameStateBuilder gsb(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/MeteorCancelCommand_test.cpp

@@ -20,7 +20,7 @@ class MeteorCancelCommandTest : public ::testing::Test {
         fbb.ForceDefaults(true);
 
         auto casterOff = AddGenericUnit(5, 0, Coords(5, 5));
-        vector<Unit> unitsVec{casterOff};
+        auto unitsVec = vector<Unit>{casterOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         GameStateBuilder gsb(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/MeteorStartCommand_test.cpp

@@ -22,7 +22,7 @@ class MeteorStartCommandTest : public ::testing::Test {
         fbb.ForceDefaults(true);
 
         auto casterOff = AddGenericUnit(5, 0, Coords(5, 5));
-        vector<Unit> unitsVec{casterOff};
+        auto unitsVec = vector<Unit>{casterOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         GameStateBuilder gsb(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/MeteorTargetCommand_test.cpp

@@ -23,7 +23,7 @@ class MeteorTargetCommandTest : public ::testing::Test {
 
         auto casterOff = AddGenericUnit(5, 0, Coords(5, 5));
 
-        vector<Unit> unitsVec{casterOff};
+        auto unitsVec = vector<Unit>{casterOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         GameStateBuilder gsb(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/RepairCommand_test.cpp

@@ -26,7 +26,7 @@ class RepairCommandTest : public ::testing::Test {
 
         auto engOff = AddGenericUnit(1, 0, Coords(2, 2));
 
-        vector<Unit> unitsVec{engOff};
+        auto unitsVec = vector<Unit>{engOff};
         auto unitsOff = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         auto mapOff = AddBasicMap(fbb);

src/test/cpp/net/eagle0/shardok/library/commands/StartFireCommand_test.cpp

@@ -29,7 +29,7 @@ class StartFireCommandTests : public ::testing::Test {
         fbb.ForceDefaults(true);
 
         actor = AddGenericUnit(0, 0, Coords(2, 3));
-        std::vector<Unit> unitsVec{actor};
+        auto unitsVec = std::vector<Unit>{actor};
         auto unitsOffset = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
         auto hexMap = AddHexMap(fbb, BASIC_MAP_FB);

src/test/scala/net/eagle0/eagle/ai/FactionLeaderProvinceRankerTest.scala

@@ -75,13 +75,7 @@ class FactionLeaderProvinceRankerTest extends AnyFlatSpec with Matchers with Bef
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   "rankedProvinceIds" should "order by hostile, then hostile + neutral" in {

src/test/scala/net/eagle0/eagle/ai/FixLeaderAloneCommandSelectorTest.scala

@@ -79,13 +79,7 @@ class FixLeaderAloneCommandSelectorTest extends AnyFlatSpec with Matchers with B
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def makeMarchAvailable(

src/test/scala/net/eagle0/eagle/ai/InvitationCommandSelectorTest.scala

@@ -84,13 +84,7 @@ class InvitationCommandSelectorTest extends AnyFlatSpec with Matchers with Befor
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val actingFaction: FactionC = makeFaction(

src/test/scala/net/eagle0/eagle/ai/MidGameAIClientTest.scala

@@ -98,13 +98,7 @@ class MidGameAIClientTest extends AnyFlatSpec with Matchers with BeforeAndAfterE
       battalionTypes = battalionTypes,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def makeFaction(

src/test/scala/net/eagle0/eagle/ai/MoveLeaderToBetterProvinceCommandChooserTest.scala

@@ -110,13 +110,7 @@ class MoveLeaderToBetterProvinceCommandChooserTest extends AnyFlatSpec with Matc
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val faction: FactionC = makeFaction(

src/test/scala/net/eagle0/eagle/ai/ResolveDiplomacyCommandSelectorTest.scala

@@ -351,13 +351,7 @@ class ResolveDiplomacyCommandSelectorTest extends AnyFlatSpec with Matchers with
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val acceptRejectAndImprison =

src/test/scala/net/eagle0/eagle/ai/SeekMoreLeadersCommandChooserTest.scala

@@ -146,13 +146,7 @@ class SeekMoreLeadersCommandChooserTest extends AnyFlatSpec with Matchers with B
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def makeMarchAvailable(

src/test/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplierImplTest.scala

@@ -67,13 +67,7 @@ class ActionResultApplierImplTest extends AnyFlatSpec with Matchers with BeforeA
     battalionTypes = Vector.empty,
     randomSeed = 1L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   // ============ Basic State Updates ============

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableAlmsCommandFactoryTest.scala

@@ -70,13 +70,7 @@ class AvailableAlmsCommandFactoryTest extends AnyFlatSpec with Matchers with Bef
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val extraProvinceVassal1 = HeroC(

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableApprehendOutlawCommandFactoryTest.scala

@@ -86,13 +86,7 @@ class AvailableApprehendOutlawCommandFactoryTest extends AnyFlatSpec with Matche
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableArmTroopsCommandFactoryTest.scala

@@ -97,13 +97,7 @@ class AvailableArmTroopsCommandFactoryTest extends AnyFlatSpec with Matchers wit
     battalionTypes = battalionTypes,
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "availableCommands" should "return nothing if there are no battalions" in {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableAttackDecisionCommandFactoryTest.scala

@@ -184,13 +184,7 @@ class AvailableAttackDecisionCommandFactoryTest extends AnyFlatSpec with Matcher
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def getAttackDecisionCommand(gs: GameState): AttackDecisionAvailable =

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableCommandsFactoryTest.scala

@@ -62,13 +62,7 @@ class AvailableCommandsFactoryTest extends AnyFlatSpec with Matchers with MockFa
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val baseProvince = ProvinceC(

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableControlWeatherCommandsFactoryTest.scala

@@ -70,13 +70,7 @@ class AvailableControlWeatherCommandsFactoryTest extends AnyFlatSpec with Before
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableDeclineQuestCommandsFactoryTest.scala

@@ -78,13 +78,7 @@ class AvailableDeclineQuestCommandsFactoryTest extends AnyFlatSpec with Matchers
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "availableCommand" should "return None when the province is not ruled by the faction leader" in {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableDefendCommandsFactoryTest.scala

@@ -147,13 +147,7 @@ class AvailableDefendCommandsFactoryTest extends AnyFlatSpec with BeforeAndAfter
     battalionTypes = battalionTypes,
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val defendingProvince = ProvinceC(

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableDiplomacyCommandsFactoryTest.scala

@@ -153,13 +153,7 @@ class AvailableDiplomacyCommandsFactoryTest extends AnyFlatSpec with Matchers wi
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def gameState: GameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableDivineCommandsFactoryTest.scala

@@ -87,13 +87,7 @@ class AvailableDivineCommandsFactoryTest extends AnyFlatSpec with Matchers with
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "availableCommand" should "return None when the province is not ruled by the faction leader" in {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableExileVassalCommandFactoryTest.scala

@@ -58,13 +58,7 @@ class AvailableExileVassalCommandFactoryTest extends AnyFlatSpec with Matchers {
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "availableCommand" should "include non-leader vassals" in {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableFeastCommandFactoryTest.scala

@@ -53,13 +53,7 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector(),
       randomSeed = 0,
       chronicleEntries = Vector(),
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
     AvailableFeastCommandFactory.availableCommand(
@@ -105,13 +99,7 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector(),
       randomSeed = 0,
       chronicleEntries = Vector(),
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
     inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -156,13 +144,7 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector(),
       randomSeed = 0,
       chronicleEntries = Vector(),
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
     inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -211,13 +193,7 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector(),
       randomSeed = 0,
       chronicleEntries = Vector(),
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
     inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -266,13 +242,7 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector(),
       randomSeed = 0,
       chronicleEntries = Vector(),
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
     inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableHandleCapturedHeroCommandFactoryTest.scala

@@ -97,13 +97,7 @@ class AvailableHandleCapturedHeroCommandFactoryTest
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameStateWithOne: GameState = inside(gameStateWithTwo.provinces(provinceId)) {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableHandleRiotCrackDownCommandFactoryTest.scala

@@ -67,13 +67,7 @@ class AvailableHandleRiotCrackDownCommandFactoryTest extends AnyFlatSpec with Be
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit =

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableHandleRiotDoNothingCommandFactoryTest.scala

@@ -61,13 +61,7 @@ class AvailableHandleRiotDoNothingCommandFactoryTest extends AnyFlatSpec with Be
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {}

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableHandleRiotGiveCommandFactoryTest.scala

@@ -53,13 +53,7 @@ class AvailableHandleRiotGiveCommandFactoryTest extends AnyFlatSpec with BeforeA
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableHeroGiftCommandFactoryTest.scala

@@ -84,13 +84,7 @@ class AvailableHeroGiftCommandFactoryTest extends AnyFlatSpec with Matchers with
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val brother1             = HeroC(

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableImproveCommandsFactoryTest.scala

@@ -88,13 +88,7 @@ class AvailableImproveCommandsFactoryTest extends AnyFlatSpec with Matchers with
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableIssueOrdersCommandFactoryTest.scala

@@ -116,13 +116,7 @@ class AvailableIssueOrdersCommandFactoryTest extends AnyFlatSpec with Matchers {
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "availableCommands" should "return nothing if the province leader is not a faction leader" in {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableManagePrisonerCommandsFactoryTest.scala

@@ -112,13 +112,7 @@ class AvailableManagePrisonerCommandsFactoryTest extends AnyFlatSpec with Before
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def getManagePrisonersCommand(gs: GameState): ManagePrisonersAvailable =

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableMarchCommandFactoryTest.scala

@@ -56,13 +56,7 @@ class AvailableMarchCommandFactoryTest extends AnyFlatSpec with BeforeAndAfterEa
       battalionTypes = battalionTypes,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def getMarchCommand(

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableOrganizeTroopsCommandsFactoryTest.scala

@@ -93,13 +93,7 @@ class AvailableOrganizeTroopsCommandsFactoryTest extends AnyFlatSpec with Before
     battalionTypes = battalionTypes,
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "availableCommand" should "include all battalions, below cap or not, if stats are high enough" in {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailablePleaseRecruitMeCommandFactoryTest.scala

@@ -84,13 +84,7 @@ class AvailablePleaseRecruitMeCommandFactoryTest extends AnyFlatSpec with Before
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val baseProvinces: Map[Int, ProvinceC] = Map(actingProvince.id -> actingProvince)

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableReconCommandFactoryTest.scala

@@ -68,13 +68,7 @@ class AvailableReconCommandFactoryTest extends AnyFlatSpec with BeforeAndAfterEa
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableRecruitHeroesCommandFactoryTest.scala

@@ -90,13 +90,7 @@ class AvailableRecruitHeroesCommandFactoryTest extends AnyFlatSpec with Matchers
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableResolveBreakAllianceCommandFactoryTest.scala

@@ -82,13 +82,7 @@ class AvailableResolveBreakAllianceCommandFactoryTest extends AnyFlatSpec with M
     battalionTypes = Vector.empty,
     randomSeed = 12345L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {}

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableResolveRansomOfferCommandFactoryTest.scala

@@ -135,13 +135,7 @@ class AvailableResolveRansomOfferCommandFactoryTest extends AnyFlatSpec with Mat
     battalionTypes = Vector(),
     randomSeed = 1L,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableResolveTributeCommandsFactoryTest.scala

@@ -68,13 +68,7 @@ class AvailableResolveTributeCommandsFactoryTest extends AnyFlatSpec with Matche
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def makeHostileArmyGroup(

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableRestCommandsFactoryTest.scala

@@ -32,13 +32,7 @@ class AvailableRestCommandsFactoryTest extends AnyFlatSpec with Matchers {
       battalionTypes = Vector(),
       randomSeed = 0,
       chronicleEntries = Vector(),
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
     val command = AvailableRestCommandsFactory.availableCommand(gameState, 12, 6)

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableReturnCommandsFactoryTest.scala

@@ -50,13 +50,7 @@ class AvailableReturnCommandsFactoryTest extends AnyFlatSpec with Matchers {
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableSendSuppliesCommandFactoryTest.scala

@@ -72,13 +72,7 @@ class AvailableSendSuppliesCommandFactoryTest extends AnyFlatSpec with BeforeAnd
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState: GameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableStartEpidemicCommandFactoryTest.scala

@@ -100,13 +100,7 @@ class AvailableStartEpidemicCommandFactoryTest extends AnyFlatSpec with BeforeAn
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableSwearBrotherhoodCommandFactoryTest.scala

@@ -95,13 +95,7 @@ class AvailableSwearBrotherhoodCommandFactoryTest extends AnyFlatSpec with Match
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableTradeCommandFactoryTest.scala

@@ -52,13 +52,7 @@ class AvailableTradeCommandFactoryTest extends AnyFlatSpec with Matchers with Be
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableTrainCommandsFactoryTest.scala

@@ -94,13 +94,7 @@ class AvailableTrainCommandsFactoryTest extends AnyFlatSpec with BeforeAndAfterE
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit =

src/test/scala/net/eagle0/eagle/library/actions/availability/AvailableTravelCommandsFactoryTest.scala

@@ -56,13 +56,7 @@ class AvailableTravelCommandsFactoryTest extends AnyFlatSpec with Matchers with
     battalionTypes = Vector(),
     randomSeed = 0,
     chronicleEntries = Vector(),
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/impl/action/EndBattleAftermathPhaseActionTest.scala

@@ -99,13 +99,7 @@ class EndBattleAftermathPhaseActionTest extends AnyFlatSpec with Matchers with B
       battalionTypes = Vector.empty,
       randomSeed = randomSeed,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   behavior of "EndBattleAftermathPhaseActionTest"

src/test/scala/net/eagle0/eagle/library/actions/impl/action/EndDefenseDecisionPhaseActionTest.scala

@@ -118,13 +118,7 @@ class EndDefenseDecisionPhaseActionTest extends AnyFlatSpec with Matchers {
     victor = None,
     battalionTypes = Vector.empty,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "execute" should "end the phase and proceed to TRUCE_TURN_BACK" in {

src/test/scala/net/eagle0/eagle/library/actions/impl/action/EndDiplomacyResolutionPhaseActionTest.scala

@@ -39,13 +39,7 @@ class EndDiplomacyResolutionPhaseActionTest extends AnyFlatSpec with Matchers wi
     battalionTypes = Vector.empty,
     randomSeed = 12345L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val applier          = ActionResultApplierImpl(Some(RuntimeValidator))

src/test/scala/net/eagle0/eagle/library/actions/impl/action/EndHandleRiotsPhaseActionTest.scala

@@ -73,13 +73,7 @@ class EndHandleRiotsPhaseActionTest extends AnyFlatSpec with BeforeAndAfterEach
     battalionTypes = Vector.empty,
     randomSeed = 1L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {

src/test/scala/net/eagle0/eagle/library/actions/impl/action/EndPlayerCommandsPhaseActionTest.scala

@@ -144,13 +144,7 @@ class EndPlayerCommandsPhaseActionTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector.empty,
       randomSeed = randomSeed,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def gameState: GameState = makeGameState()

src/test/scala/net/eagle0/eagle/library/actions/impl/action/EndVassalCommandsPhaseActionTest.scala

@@ -49,13 +49,7 @@ class EndVassalCommandsPhaseActionTest extends AnyFlatSpec with Matchers {
       battalionTypes = Vector.empty,
       randomSeed = 0xfeedfaceL,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private def endVassalResult(results: Vector[?]): ActionResultC =

src/test/scala/net/eagle0/eagle/library/actions/impl/action/FreeHeroBackstoryVisibilityRecoveryTest.scala

@@ -62,13 +62,7 @@ class FreeHeroBackstoryVisibilityRecoveryTest extends AnyFlatSpec with MockFacto
       battalionTypes = Vector.empty,
       randomSeed = 12345L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val heroWithBackstory: Map[Int, HeroT] = Map(

src/test/scala/net/eagle0/eagle/library/actions/impl/action/NewRoundActionTest.scala

@@ -106,13 +106,7 @@ class NewRoundActionTest
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   // Helper to run NewRoundAction and return Scala ActionResults

src/test/scala/net/eagle0/eagle/library/actions/impl/action/NewYearActionTest.scala

@@ -131,13 +131,7 @@ class NewYearActionTest extends AnyFlatSpec with Matchers with BeforeAndAfterEac
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def gs: GameState = baseGameState

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformFoodConsumptionPhaseActionTest.scala

@@ -89,13 +89,7 @@ class PerformFoodConsumptionPhaseActionTest extends AnyFlatSpec with Matchers wi
     battalionTypes = battalionTypes,
     randomSeed = 1L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {}

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformForcedTurnBackActionTest.scala

@@ -75,13 +75,7 @@ class PerformForcedTurnBackActionTest extends AnyFlatSpec with Matchers with Bef
     victor = None,
     battalionTypes = Vector.empty,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val gsWithoutBlizzard = gsWithBlizzard.copy(

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformHeroDeparturesActionTest.scala

@@ -73,13 +73,7 @@ class PerformHeroDeparturesActionTest extends AnyFlatSpec with Matchers with Bef
     victor = None,
     battalionTypes = Vector.empty,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformHostileArmySetupActionTest.scala

@@ -63,13 +63,7 @@ class PerformHostileArmySetupActionTest extends AnyFlatSpec with Matchers {
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "any setup" should "move to the next round phase" in {

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformProvinceEventsActionTest.scala

@@ -161,13 +161,7 @@ class PerformProvinceEventsActionTest extends AnyFlatSpec with BeforeAndAfterEac
     battalionTypes = Vector.empty,
     randomSeed = randomSeed,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "changedProvince" should "remove beasts if we're past their end date" in {

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformProvinceMoveResolutionActionTest.scala

@@ -115,13 +115,7 @@ class PerformProvinceMoveResolutionActionTest extends AnyFlatSpec with Matchers
     victor = None,
     battalionTypes = Vector.empty,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def getResults(gs: GameState) =

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformReconResolutionActionTest.scala

@@ -65,13 +65,7 @@ class PerformReconResolutionActionTest extends AnyFlatSpec with BeforeAndAfterEa
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val baseProvinces: Map[Int, ProvinceC] = Map(

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformUnaffiliatedHeroesActionTest.scala

@@ -79,13 +79,7 @@ class PerformUnaffiliatedHeroesActionTest extends AnyFlatSpec with Matchers with
     battalionTypes = Vector.empty,
     randomSeed = 12345L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   override def beforeEach(): Unit = {

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PerformVassalCommandsPhaseActionTest.scala

@@ -266,13 +266,7 @@ class PerformVassalCommandsPhaseActionTest extends AnyFlatSpec with Matchers wit
       battalionTypes = battalionTypes,
       randomSeed = 1L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val marchGameState = baseGameState(

src/test/scala/net/eagle0/eagle/library/actions/impl/action/PrisonerExchangeActionTest.scala

@@ -43,13 +43,7 @@ class PrisonerExchangeActionTest extends AnyFlatSpec with Matchers {
     victor = None,
     battalionTypes = Vector.empty,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def prisoner(heroId: Int, lastFactionId: Int): UnaffiliatedHeroC =

src/test/scala/net/eagle0/eagle/library/actions/impl/action/ProvinceConqueredActionTest.scala

@@ -205,13 +205,7 @@ class ProvinceConqueredActionTest extends AnyFlatSpec with Matchers {
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val currentDate = Date(year = 2024, month = Date.Month.July)

src/test/scala/net/eagle0/eagle/library/actions/impl/action/ResolveBattleActionTest.scala

@@ -503,13 +503,7 @@ class ResolveBattleActionTest extends AnyFlatSpec with MockFactory with Matchers
     victor = None,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val startingGameStateWithAllies = startingGameState.copy(

src/test/scala/net/eagle0/eagle/library/actions/impl/action/TruceTurnBackPhaseActionTest.scala

@@ -114,13 +114,7 @@ class TruceTurnBackPhaseActionTest extends AnyFlatSpec with Matchers {
     battalionTypes = Vector.empty,
     randomSeed = 1L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "results" should "advance to the next phase" in {

src/test/scala/net/eagle0/eagle/library/actions/llm_prompt_generators/CapturedHeroMessagePromptGeneratorTest.scala

@@ -109,13 +109,7 @@ class CapturedHeroMessagePromptGeneratorTest extends AnyFlatSpec with Matchers w
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "execute message prompt" should "return an appropriate execute message" in {

src/test/scala/net/eagle0/eagle/library/actions/llm_prompt_generators/ChronicleUpdatePromptGeneratorTest.scala

@@ -82,13 +82,7 @@ class ChronicleUpdatePromptGeneratorTest extends AnyFlatSpec with BeforeAndAfter
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val mockClientTextStore = mock[ClientTextStore]

src/test/scala/net/eagle0/eagle/library/actions/llm_prompt_generators/DivineMessagePromptGeneratorTest.scala

@@ -101,13 +101,7 @@ class DivineMessagePromptGeneratorTest extends AnyFlatSpec with Matchers with Mo
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "generate" should "tell the LLM not to describe exile prisoner quests as releases" in {

src/test/scala/net/eagle0/eagle/library/actions/llm_prompt_generators/GeneratorUtilitiesTest.scala

@@ -58,13 +58,7 @@ class GeneratorUtilitiesTest extends AnyFlatSpec with Matchers with BeforeAndAft
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
     val clientTextStore = mock[ClientTextStore]
     GeneratorUtilities

src/test/scala/net/eagle0/eagle/library/actions/llm_prompt_generators/QuestEndedGeneratorUtilitiesTest.scala

@@ -113,13 +113,7 @@ class QuestEndedGeneratorUtilitiesTest extends AnyFlatSpec with Matchers with Mo
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private def mockTextStore: ClientTextStore = {

src/test/scala/net/eagle0/eagle/library/util/GameStateViewFilterTest.scala

@@ -226,13 +226,7 @@ class GameStateViewFilterTest extends AnyFlatSpec with BeforeAndAfterEach with M
     battalionTypes = Vector.empty,
     randomSeed = 0L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   "filteredGameState" should "return all provinces when there is no factionId" in {

src/test/scala/net/eagle0/eagle/library/util/ProvinceUtilsTest.scala

@@ -438,13 +438,7 @@ class ProvinceUtilsTest extends AnyFlatSpec with Matchers with BeforeAndAfterEac
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   "isFocusProvince" should "return true when the ruling faction has this province as its focus" in {

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/AllianceOfferCommandSelectorTest.scala

@@ -61,13 +61,7 @@ class AllianceOfferCommandSelectorTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = Vector.empty,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
   }
 

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/AlmsCommandSelectorTest.scala

@@ -89,13 +89,7 @@ class AlmsCommandSelectorTest extends AnyFlatSpec with Matchers with BeforeAndAf
       battalionTypes = battalionTypes,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   "chosenAlmsCommand" should "give 1000 food if we need 10 support in December" in {

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/AttackCommandChooserTest.scala

@@ -181,13 +181,7 @@ class AttackCommandChooserTest extends AnyFlatSpec with Matchers with BeforeAndA
     victor = None,
     randomSeed = 12345L,
     chronicleEntries = Vector.empty,
-    gameType = GameType.Normal,
-    eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-      mapWidth = 0,
-      mapHeight = 0,
-      sha256 = "",
-      centroidsSha256 = ""
-    )
+    gameType = GameType.Normal
   )
 
   private val availableBattalionTypes = Vector(

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/AttackDecisionCommandChooserTest.scala

@@ -97,13 +97,7 @@ class AttackDecisionCommandChooserTest extends AnyFlatSpec with Matchers with Be
       battalionTypes = battalionTypes,
       randomSeed = 0L,
       chronicleEntries = Vector.empty,
-      gameType = GameType.Normal,
-      eagleMap = net.eagle0.eagle.model.state.game_state.EagleMapInfo(
-        mapWidth = 0,
-        mapHeight = 0,
-        sha256 = "",
-        centroidsSha256 = ""
-      )
+      gameType = GameType.Normal
     )
 
   private val defaultSupplies = Supplies(gold = 0, food = 0)