Use preincrement in test loops

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/ai/AITimeBudget_test.cpp

@@ -66,7 +66,7 @@ protected:
                 net::eagle0::shardok::storage::fb::DrawType_UNKNOWN_DRAW_TYPE);
         endGameCondition.mutate_victory_details(
                 net::eagle0::shardok::storage::fb::VictoryCondition_UNKNOWN_VICTORY_CONDITION);
-        std::vector<PlayerId> winningIdsVec{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
+        auto winningIdsVec = std::vector<PlayerId>{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
         auto winningIdsOff = fbb.CreateVector(winningIdsVec);
         auto statusB = net::eagle0::shardok::storage::fb::GameStatusBuilder(fbb);
         statusB.add_state(net::eagle0::shardok::storage::fb::GameStatus_::State_GAME_RUNNING);

src/test/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator_test.cpp

@@ -75,7 +75,7 @@ protected:
                 net::eagle0::shardok::storage::fb::GameStatus_::State_GAME_RUNNING);
         const auto mapOffset = AddHexMap(fbb, hexMap);
 
-        const vector<int8_t> attackerVC{
+        const auto attackerVC = vector<int8_t>{
                 net::eagle0::shardok::storage::fb::
                         VictoryCondition_VICTORY_CONDITION_LAST_PLAYER_STANDING,
                 net::eagle0::shardok::storage::fb::
@@ -87,7 +87,7 @@ protected:
                 1000,
                 &attackerVC);
 
-        const vector<int8_t> defenderVC{
+        const auto defenderVC = vector<int8_t>{
                 net::eagle0::shardok::storage::fb::
                         VictoryCondition_VICTORY_CONDITION_WIN_AFTER_MAX_ROUNDS,
                 net::eagle0::shardok::storage::fb::

src/test/cpp/net/eagle0/shardok/ai/score/AIVictoryConditionScoreCalculator_test.cpp

@@ -33,7 +33,7 @@ protected:
                 defenderPlayer};
         const auto playersOffset = fbb.CreateVectorOfSortedTables(&playersVec);
 
-        std::vector<Unit> units{
+        auto units = std::vector<Unit>{
                 AddGenericUnit(0, 0, attackerLocation),
                 AddGenericUnit(1, 1, defenderLocation)};
         if (secondAttacker) { units.push_back(AddGenericUnit(0, 2, attacker2Location)); }

src/test/cpp/net/eagle0/shardok/library/GtestExtensions.hpp

@@ -67,7 +67,7 @@ void EXPECT_CONTAINS(const VecT& vec, const T& obj) {
 
 template<class VecT, class F>
 auto CHECK_NOCONTAINS_WHERE(const VecT& vec, F where) -> bool {
-    for (size_t i = 0; i < vec.size(); i++) {
+    for (size_t i = 0; i < vec.size(); ++i) {
         if (where(vec[i])) {
             std::cout << "Found at index " << i << '\n';
             return false;

src/test/cpp/net/eagle0/shardok/library/PercentileRollDifficulty_test.cpp

@@ -18,7 +18,7 @@ TEST(PercentileRollOddsTests, singleStat_returnsExpected) {
     const std::vector<double> expectedBonuses =
             {-25.0, -12.8, -3.125, -0.2, 0.0, 0.2, 3.125, 12.8, 25.0, 28.1216};
 
-    for (size_t i = 0; i < stats.size(); i++) {
+    for (size_t i = 0; i < stats.size(); ++i) {
         EXPECT_DOUBLE_EQ(expectedBonuses[i], BonusFromStat(stats[i]));
     }
 }

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

@@ -88,7 +88,7 @@ class MoveCommandTest : public ::testing::Test {
                 net::eagle0::shardok::storage::fb::BattalionTypeId_UNDEAD);
         undeadUnit.mutable_battalion().mutate_size(500);
         undeadUnit.mutable_location() = startLocation;
-        for (uint32_t i = 0; i < undeadUnit.opponent_knowledge()->size(); i++) {
+        for (uint32_t i = 0; i < undeadUnit.opponent_knowledge()->size(); ++i) {
             undeadUnit.mutable_opponent_knowledge()->Mutate(i, 0);
         }
         undeadUnit.mutate_remaining_action_points(12);
@@ -210,7 +210,7 @@ TEST_F(MoveCommandTest, Execute_movesActor) {
                                  zocCoords)
                                  .Execute(gameState, randomGenerator);
 
-    for (size_t i = 0; i < interimTargets.size(); i++) {
+    for (size_t i = 0; i < interimTargets.size(); ++i) {
         EXPECT_EQ(interimTargets[i], ChangedUnit(results[i], 0)->location());
     }
 }

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)

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

@@ -184,13 +184,7 @@ class CommandChoiceHelpersTest extends AnyFlatSpec with Matchers with BeforeAndA
       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
     )
 
   behavior of "CommandChoiceHelpersTest"

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

@@ -126,13 +126,7 @@ class ExpandCommandSelectorTest extends AnyFlatSpec with Matchers with BeforeAnd
       battalionTypes = battalionTypesVector,
       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
     )
 
   "heroIdsToMarch" should "never send a faction leader by themselves" in

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

@@ -83,13 +83,7 @@ class FulfillQuestsCommandSelectorTest 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
     )
 
   private val gameState = makeGameState(

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

@@ -69,13 +69,7 @@ class ImproveCommandSelectorTest extends AnyFlatSpec with Matchers with BeforeAn
       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 improveCommand = ImproveAvailable(

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

@@ -61,13 +61,7 @@ class TruceOfferCommandSelectorTest 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
     )
   }
 

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/quest_command_selectors/AllianceQuestCommandChooserTest.scala

@@ -93,13 +93,7 @@ class AllianceQuestCommandChooserTest extends AnyFlatSpec 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
     )
   }
 

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/quest_command_selectors/AlmsAcrossRealmQuestCommandChooserTest.scala

@@ -101,13 +101,7 @@ class AlmsAcrossRealmQuestCommandChooserTest extends AnyFlatSpec with BeforeAndA
       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
     )
   }
 

src/test/scala/net/eagle0/eagle/library/util/command_choice_helpers/quest_command_selectors/AlmsToProvinceQuestCommandChooserTest.scala

@@ -81,13 +81,7 @@ class AlmsToProvinceQuestCommandChooserTest extends AnyFlatSpec with BeforeAndAf
       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
     )
   }