Populate hero names in tutorial game ClientTextStore

The tutorial game creation was not calling withPopulatedPregeneratedTexts(), causing hero names to show as "Hero" instead of their actual names because the name text IDs couldn't be resolved. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Remove default value from GameState.gameType parameter
2026-07-28 21:35:42 +00:00 · 2026-02-18 12:30:13 -08:00 · 2026-02-18 12:26:05 -08:00 · 2026-02-18 09:22:27 -08:00 · 2026-02-18 09:15:59 -08:00
126 changed files with 529 additions and 201 deletions
@@ -175,6 +175,19 @@ proto_library(
    ],
 )

+scala_proto_library(
+    name = "game_type_scala_proto",
+    deps = [":game_type_proto"],
+)
+
+proto_library(
+    name = "game_type_proto",
+    srcs = ["game_type.proto"],
+    visibility = [
+        "//src/main/protobuf/net/eagle0:__subpackages__",
+    ],
+)
+
 scala_proto_library(
    name = "gender_scala_proto",
    deps = [":gender_proto"],
@@ -356,6 +369,7 @@ csharp_proto_compile(
        ":date_proto",
        ":diplomacy_offer_proto",
        ":diplomacy_offer_status_proto",
+        ":game_type_proto",
        ":gender_proto",
        ":improvement_type_proto",
        ":profession_proto",
@@ -383,6 +397,7 @@ go_proto_library(
        ":date_proto",
        ":diplomacy_offer_proto",
        ":diplomacy_offer_status_proto",
+        ":game_type_proto",
        ":gender_proto",
        ":improvement_type_proto",
        ":profession_proto",
@@ -0,0 +1,18 @@
+//
+// Copyright 2019 Dan Crosby
+//
+
+syntax = "proto3";
+
+package net.eagle0.eagle.common;
+
+option java_multiple_files = true;
+option java_package = "net.eagle0.eagle.common";
+option java_outer_classname = "GameType";
+option objc_class_prefix = "E0G";
+
+enum GameType {
+    UNKNOWN_GAME_TYPE = 0;
+    NORMAL = 1;
+    TUTORIAL = 2;
+}
@@ -34,6 +34,7 @@ proto_library(
        "//src/main/protobuf/net/eagle0/eagle/common:chronicle_entry_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:command_type_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:date_proto",
+        "//src/main/protobuf/net/eagle0/eagle/common:game_type_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_proto",
        "@com_google_protobuf//:wrappers_proto",
    ],
@@ -324,6 +325,7 @@ proto_library(
        "//src/main/protobuf/net/eagle0/eagle/common:battalion_type_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:chronicle_entry_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:date_proto",
+        "//src/main/protobuf/net/eagle0/eagle/common:game_type_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_proto",
        "@com_google_protobuf//:wrappers_proto",
    ],
@@ -14,6 +14,7 @@ import "src/main/protobuf/net/eagle0/eagle/common/battalion_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/chronicle_entry.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/command_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/date.proto";
+import "src/main/protobuf/net/eagle0/eagle/common/game_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/round_phase.proto";
 import "src/main/protobuf/net/eagle0/eagle/internal/battalion.proto";
 import "src/main/protobuf/net/eagle0/eagle/internal/changed_faction.proto";
@@ -89,4 +90,6 @@ message ActionResult {
    .google.protobuf.Int64Value new_random_seed = 33;

    .net.eagle0.eagle.common.ChronicleEntry new_chronicle_entry = 42;
+
+    .net.eagle0.eagle.common.GameType new_game_type = 44;
 }
@@ -12,6 +12,7 @@ import "src/main/protobuf/net/eagle0/eagle/common/action_result_notification_det
 import "src/main/protobuf/net/eagle0/eagle/common/battalion_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/chronicle_entry.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/date.proto";
+import "src/main/protobuf/net/eagle0/eagle/common/game_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/round_phase.proto";
 import "src/main/protobuf/net/eagle0/eagle/internal/battalion.proto";
 import "src/main/protobuf/net/eagle0/eagle/internal/faction.proto";
@@ -55,4 +56,6 @@ message GameState {
    int64 random_seed = 16;

    repeated .net.eagle0.eagle.common.ChronicleEntry chronicle_entries = 21;
+
+    .net.eagle0.eagle.common.GameType game_type = 23;
 }
@@ -135,6 +135,7 @@ proto_library(
        "//src/main/protobuf/net/eagle0/eagle/common:battalion_type_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:chronicle_entry_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:date_proto",
+        "//src/main/protobuf/net/eagle0/eagle/common:game_type_proto",
        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_proto",
        "@com_google_protobuf//:wrappers_proto",
    ],
@@ -11,6 +11,7 @@ import "google/protobuf/wrappers.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/battalion_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/chronicle_entry.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/date.proto";
+import "src/main/protobuf/net/eagle0/eagle/common/game_type.proto";
 import "src/main/protobuf/net/eagle0/eagle/common/round_phase.proto";
 import "src/main/protobuf/net/eagle0/eagle/views/faction_view.proto";
 import "src/main/protobuf/net/eagle0/eagle/views/hero_view.proto";
@@ -43,6 +44,8 @@ message GameStateView {
    repeated .net.eagle0.eagle.common.BattalionType battalion_types = 12;

    repeated .net.eagle0.eagle.common.ChronicleEntry chronicle_entries = 14;
+
+    .net.eagle0.eagle.common.GameType game_type = 15;
 }

 message GameStateViewDiff {
@@ -72,4 +75,6 @@ message GameStateViewDiff {
    repeated .net.eagle0.eagle.common.BattalionType new_battalion_types = 19;

    repeated .net.eagle0.eagle.common.ChronicleEntry updated_chronicle_entries = 20;
+
+    .net.eagle0.eagle.common.GameType new_game_type = 21;
 }
@@ -158,6 +158,10 @@ class ActionResultApplierImpl(validator: Option[Validator]) extends ActionResult
      .map(factionId => afterRunStatus.copy(victor = Some(factionId)))
      .getOrElse(afterRunStatus)

-    afterVictor.copy(actionResultCount = afterVictor.actionResultCount + 1)
+    val afterGameType = result.newGameType
+      .map(gameType => afterVictor.copy(gameType = gameType))
+      .getOrElse(afterVictor)
+
+    afterGameType.copy(actionResultCount = afterGameType.actionResultCount + 1)
  }
 }
@@ -134,6 +134,7 @@ scala_library(
    ],
    deps = [
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
@@ -39,7 +39,8 @@ object GameStateViewDiffer {
            .flatMap(b => b.shardokGameId)
            .diff(after.outstandingBattles.flatMap(b => b.shardokGameId)),
          newBattalionTypes = newValues(before.battalionTypes, after.battalionTypes),
-          updatedChronicleEntries = after.chronicleEntries.filterNot(before.chronicleEntries.contains)
+          updatedChronicleEntries = after.chronicleEntries.filterNot(before.chronicleEntries.contains),
+          newGameType = optionalDiff(before.gameType, after.gameType)
        )
      )
      .filterNot(_ == emptyDiff)
@@ -52,7 +52,8 @@ object GameStateViewFilter {
      running = false,
      victor = gs.victor,
      battalionTypes = gs.battalionTypes,
-      chronicleEntries = gs.chronicleEntries
+      chronicleEntries = gs.chronicleEntries,
+      gameType = gs.gameType
    )
  }
 }
@@ -13,6 +13,7 @@ import net.eagle0.eagle.model.state.hero.HeroT
 import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.shardok_battle.ShardokBattle
 import net.eagle0.eagle.model.state.BattalionType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.RoundPhase

 object ActionResultT {
@@ -64,6 +65,8 @@ trait ActionResultT {

  def newRandomSeed: Option[Long]

+  def newGameType: Option[GameType]
+
  def affectedFactionIds: Vector[FactionId]

  def copy(
@@ -99,6 +102,7 @@ trait ActionResultT {
      newVictorFactionId: Option[FactionId] = newVictorFactionId,
      gameEnded: Option[Boolean] = gameEnded,
      newRandomSeed: Option[Long] = newRandomSeed,
+      newGameType: Option[GameType] = newGameType,
      affectedFactionIds: Vector[FactionId] = affectedFactionIds
  ): ActionResultT

@@ -37,6 +37,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
@@ -59,6 +60,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
@@ -21,6 +21,7 @@ import net.eagle0.eagle.model.state.hero.HeroT
 import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.shardok_battle.ShardokBattle
 import net.eagle0.eagle.model.state.BattalionType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.RoundPhase

 object ActionResultC {
@@ -59,6 +60,7 @@ case class ActionResultC(
    newVictorFactionId: Option[FactionId] = None,
    gameEnded: Option[Boolean] = None,
    newRandomSeed: Option[Long] = None,
+    newGameType: Option[GameType] = None,
    affectedFactionIds: Vector[FactionId] = Vector.empty
 ) extends ActionResultT {
  def update(updater: ActionResultC.ActionResultCUpdater): ActionResultC =
@@ -96,6 +98,7 @@ case class ActionResultC(
      newVictorFactionId: Option[FactionId] = newVictorFactionId,
      gameEnded: Option[Boolean] = gameEnded,
      newRandomSeed: Option[Long] = newRandomSeed,
+      newGameType: Option[GameType] = newGameType,
      affectedFactionIds: Vector[FactionId] = affectedFactionIds
  ): ActionResultC =
    ActionResultC(
@@ -129,6 +132,7 @@ case class ActionResultC(
      newVictorFactionId = newVictorFactionId,
      gameEnded = gameEnded,
      newRandomSeed = newRandomSeed,
+      newGameType = newGameType,
      affectedFactionIds = affectedFactionIds
    )
 }
@@ -44,6 +44,7 @@ import net.eagle0.eagle.model.state.hero.HeroT
 import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.shardok_battle.ShardokBattle
 import net.eagle0.eagle.model.state.BattalionType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.RoundPhase

 object ActionResultProtoConverter {
@@ -83,6 +84,7 @@ object ActionResultProtoConverter {
            newVictorFactionId: Option[FactionId],
            gameEnded: Option[Boolean],
            newRandomSeed: Option[Long],
+            newGameType: Option[GameType],
            affectedFactionIds: Vector[FactionId]
          ) =>
        val arInit = ActionResultProto(
@@ -155,6 +157,11 @@ object ActionResultProtoConverter {
          newVictor = newVictorFactionId,
          gameEnded = gameEnded,
          newRandomSeed = newRandomSeed,
+          newGameType = newGameType
+            .map(GameTypeConverter.toProto)
+            .getOrElse(
+              net.eagle0.eagle.common.game_type.GameType.UNKNOWN_GAME_TYPE
+            ),
          affectedPlayers = affectedFactionIds
        )

@@ -233,6 +240,7 @@ object ActionResultProtoConverter {
      newVictorFactionId = proto.newVictor,
      gameEnded = proto.gameEnded,
      newRandomSeed = proto.newRandomSeed,
+      newGameType = GameTypeConverter.fromProtoOption(proto.newGameType),
      affectedFactionIds = proto.affectedPlayers.toVector
    )
  }
@@ -27,6 +27,7 @@ scala_library(
        ":changed_hero_converter",
        ":changed_province_converter",
        ":command_type_converter",
+        ":game_type_converter",
        ":notification_converter",
        ":round_phase_converter",
        "//src/main/protobuf/net/eagle0/eagle/api:selected_command_scala_proto",
@@ -51,6 +52,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/llm_request",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/shardok_battle:shardok_battle_converter",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
@@ -62,6 +64,22 @@ scala_library(
    ],
 )

+scala_library(
+    name = "game_type_converter",
+    srcs = ["GameTypeConverter.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/game_state:__pkg__",
+        "//src/test/scala/net/eagle0/eagle/model/proto_converters:__pkg__",
+    ],
+    deps = [
+        ":proto_conversion_exception",
+        "//src/main/protobuf/net/eagle0/eagle/common:game_type_scala_proto",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
+    ],
+)
+
 scala_library(
    name = "generated_text_request_converter",
    srcs = ["GeneratedTextRequestConverter.scala"],
@@ -0,0 +1,37 @@
+package net.eagle0.eagle.model.proto_converters
+
+import net.eagle0.eagle.common.game_type.GameType as GameTypeProto
+import net.eagle0.eagle.model.proto_converters.ProtoConversionException
+import net.eagle0.eagle.model.state.GameType
+
+object GameTypeConverter {
+  def toProto(gameType: GameType): GameTypeProto = gameType match {
+    case GameType.Normal   => GameTypeProto.NORMAL
+    case GameType.Tutorial => GameTypeProto.TUTORIAL
+  }
+
+  def fromProto(gameTypeProto: GameTypeProto): GameType =
+    gameTypeProto match {
+      case GameTypeProto.NORMAL                          => GameType.Normal
+      case GameTypeProto.TUTORIAL                        => GameType.Tutorial
+      case GameTypeProto.UNKNOWN_GAME_TYPE               =>
+        throw new ProtoConversionException(
+          "UNKNOWN_GAME_TYPE is not a valid GameType"
+        )
+      case GameTypeProto.Unrecognized(unrecognizedValue) =>
+        throw new ProtoConversionException(
+          s"Unrecognized GameType $unrecognizedValue"
+        )
+    }
+
+  def fromProtoOption(gameTypeProto: GameTypeProto): Option[GameType] =
+    gameTypeProto match {
+      case GameTypeProto.NORMAL                          => Some(GameType.Normal)
+      case GameTypeProto.TUTORIAL                        => Some(GameType.Tutorial)
+      case GameTypeProto.UNKNOWN_GAME_TYPE               => None
+      case GameTypeProto.Unrecognized(unrecognizedValue) =>
+        throw new ProtoConversionException(
+          s"Unrecognized GameType $unrecognizedValue"
+        )
+    }
+}
@@ -30,6 +30,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_type_converter",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:game_type_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:notification_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:proto_conversion_exception",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:round_phase_converter",
@@ -4,6 +4,7 @@ import net.eagle0.eagle.{BattalionId, FactionId, GameId, HeroId, ProvinceId, Rou
 import net.eagle0.eagle.common.action_result_notification_details.Notification as NotificationProto
 import net.eagle0.eagle.common.battalion_type.BattalionType as BattalionTypeProto
 import net.eagle0.eagle.common.date.Date as DateProto
+import net.eagle0.eagle.common.game_type.GameType as GameTypeProto
 import net.eagle0.eagle.common.round_phase.RoundPhase as RoundPhaseProto
 import net.eagle0.eagle.internal.battalion.Battalion as BattalionProto
 import net.eagle0.eagle.internal.chronicle_entry.ChronicleEntry as ChronicleEntryProto
@@ -17,6 +18,7 @@ import net.eagle0.eagle.model.action_result.NotificationT
 import net.eagle0.eagle.model.proto_converters.{
  BattalionConverter,
  BattalionTypeConverter,
+  GameTypeConverter,
  NotificationConverter,
  RoundPhaseConverter
 }
@@ -37,6 +39,7 @@ import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.shardok_battle.ShardokBattle
 import net.eagle0.eagle.model.state.BattalionType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.RoundPhase

 object GameStateConverter {
@@ -63,7 +66,8 @@ object GameStateConverter {
          victor: Option[FactionId],
          battalionTypes: Vector[BattalionType],
          randomSeed: Long,
-          chronicleEntries: Vector[ChronicleEntry]
+          chronicleEntries: Vector[ChronicleEntry],
+          gameType: GameType
        ) =>
      GameStateProto(
        gameId = gameId,
@@ -86,7 +90,8 @@ object GameStateConverter {
        victor = victor,
        battalionTypes = battalionTypes.map(BattalionTypeConverter.toProto),
        randomSeed = randomSeed,
-        chronicleEntries = chronicleEntries.map(ChronicleEntryConverter.toProto)
+        chronicleEntries = chronicleEntries.map(ChronicleEntryConverter.toProto),
+        gameType = GameTypeConverter.toProto(gameType)
      )
  }

@@ -114,6 +119,7 @@ object GameStateConverter {
            battalionTypes: Seq[BattalionTypeProto],
            randomSeed: Long,
            chronicleEntries: Seq[ChronicleEntryProto],
+            gameType: GameTypeProto,
            _
          ) =>
        GameState(
@@ -145,7 +151,10 @@ object GameStateConverter {
          victor = victor,
          battalionTypes = battalionTypes.map(BattalionTypeConverter.fromProto).toVector,
          randomSeed = randomSeed,
-          chronicleEntries = chronicleEntries.map(ChronicleEntryConverter.fromProto).toVector
+          chronicleEntries = chronicleEntries.map(ChronicleEntryConverter.fromProto).toVector,
+          gameType =
+            if gameType == GameTypeProto.UNKNOWN_GAME_TYPE then GameType.Normal
+            else GameTypeConverter.fromProto(gameType)
        )
    }
 }
@@ -12,6 +12,7 @@ scala_library(
        "//src/main/protobuf/net/eagle0/eagle/views:game_state_view_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_type_converter",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:game_type_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:round_phase_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/chronicle_entry:chronicle_entry_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
@@ -19,6 +20,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/faction:faction_view_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/hero:hero_view_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/province:province_view",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
        "//src/main/scala/net/eagle0/eagle/model/view/battle:shardok_battle_view",
@@ -41,6 +43,7 @@ scala_library(
        "//src/main/protobuf/net/eagle0/eagle/views:game_state_view_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_type_converter",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:game_type_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:round_phase_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/chronicle_entry:chronicle_entry_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
@@ -51,6 +54,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/hero:hero_view_diff_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/province:province_view",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/province:province_view_diff_converter",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
        "//src/main/scala/net/eagle0/eagle/model/view/battle:shardok_battle_view",
@@ -1,6 +1,6 @@
 package net.eagle0.eagle.model.proto_converters.view.game_state

-import net.eagle0.eagle.model.proto_converters.{BattalionTypeConverter, RoundPhaseConverter}
+import net.eagle0.eagle.model.proto_converters.{BattalionTypeConverter, GameTypeConverter, RoundPhaseConverter}
 import net.eagle0.eagle.model.proto_converters.chronicle_entry.ChronicleEntryConverter
 import net.eagle0.eagle.model.proto_converters.date.DateConverter
 import net.eagle0.eagle.model.proto_converters.view.battle.ShardokBattleViewConverter
@@ -38,6 +38,7 @@ object GameStateViewConverter {
      running = view.running,
      victor = view.victor,
      battalionTypes = view.battalionTypes.map(BattalionTypeConverter.toProto),
-      chronicleEntries = view.chronicleEntries.map(ChronicleEntryConverter.toProto)
+      chronicleEntries = view.chronicleEntries.map(ChronicleEntryConverter.toProto),
+      gameType = GameTypeConverter.toProto(view.gameType)
    )
 }
@@ -1,7 +1,8 @@
 package net.eagle0.eagle.model.proto_converters.view.game_state

+import net.eagle0.eagle.common.game_type.GameType as GameTypeProto
 import net.eagle0.eagle.common.round_phase.NewRoundPhase
-import net.eagle0.eagle.model.proto_converters.{BattalionTypeConverter, RoundPhaseConverter}
+import net.eagle0.eagle.model.proto_converters.{BattalionTypeConverter, GameTypeConverter, RoundPhaseConverter}
 import net.eagle0.eagle.model.proto_converters.chronicle_entry.ChronicleEntryConverter
 import net.eagle0.eagle.model.proto_converters.date.DateConverter
 import net.eagle0.eagle.model.proto_converters.view.battle.ShardokBattleViewConverter
@@ -31,6 +32,9 @@ object GameStateViewDiffConverter {
      newRunning = diff.newRunning,
      newVictor = diff.newVictor,
      newBattalionTypes = diff.newBattalionTypes.map(BattalionTypeConverter.toProto),
-      updatedChronicleEntries = diff.updatedChronicleEntries.map(ChronicleEntryConverter.toProto)
+      updatedChronicleEntries = diff.updatedChronicleEntries.map(ChronicleEntryConverter.toProto),
+      newGameType = diff.newGameType
+        .map(GameTypeConverter.toProto)
+        .getOrElse(GameTypeProto.UNKNOWN_GAME_TYPE)
    )
 }
@@ -127,6 +127,25 @@ scala_library(
    ],
 )

+scala_library(
+    name = "game_type",
+    srcs = ["GameType.scala"],
+    visibility = [
+        ":__subpackages__",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/library/util:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/view/game_state:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/model/view/game_state:__pkg__",
+        "//src/main/scala/net/eagle0/eagle/service/new_game_creation:__pkg__",
+        "//src/test/scala/net/eagle0/eagle/service:__subpackages__",
+    ],
+    deps = [],
+)
+
 scala_library(
    name = "improvement_type",
    srcs = ["ImprovementType.scala"],
@@ -0,0 +1,9 @@
+package net.eagle0.eagle.model.state
+
+sealed trait GameType { def value: Int }
+object GameType       {
+  case object Normal   extends GameType { val value = 1 }
+  case object Tutorial extends GameType { val value = 2 }
+
+  val allValues: Vector[GameType] = Vector(Normal, Tutorial)
+}
@@ -6,6 +6,7 @@ scala_library(
    visibility = ["//visibility:public"],
    exports = [
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
@@ -22,6 +23,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
@@ -11,6 +11,7 @@ import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.shardok_battle.ShardokBattle
 import net.eagle0.eagle.model.state.BattalionType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.RoundPhase

 case class GameState(
@@ -34,5 +35,6 @@ case class GameState(
    victor: Option[FactionId],
    battalionTypes: Vector[BattalionType],
    randomSeed: Long,
-    chronicleEntries: Vector[ChronicleEntry]
+    chronicleEntries: Vector[ChronicleEntry],
+    gameType: GameType
 )
@@ -7,6 +7,7 @@ scala_library(
    deps = [
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
@@ -24,6 +25,7 @@ scala_library(
    deps = [
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
@@ -1,7 +1,7 @@
 package net.eagle0.eagle.model.view.game_state

 import net.eagle0.eagle.{BattalionId, FactionId, HeroId, ProvinceId, RoundId}
-import net.eagle0.eagle.model.state.{BattalionType, RoundPhase}
+import net.eagle0.eagle.model.state.{BattalionType, GameType, RoundPhase}
 import net.eagle0.eagle.model.state.chronicle_entry.ChronicleEntry
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.view.battle.ShardokBattleView
@@ -23,5 +23,6 @@ case class GameStateView(
    running: Boolean,
    victor: Option[FactionId],
    battalionTypes: Vector[BattalionType],
-    chronicleEntries: Vector[ChronicleEntry]
+    chronicleEntries: Vector[ChronicleEntry],
+    gameType: GameType
 )
@@ -1,7 +1,7 @@
 package net.eagle0.eagle.model.view.game_state

 import net.eagle0.eagle.{BattalionId, FactionId, HeroId}
-import net.eagle0.eagle.model.state.{BattalionType, RoundPhase}
+import net.eagle0.eagle.model.state.{BattalionType, GameType, RoundPhase}
 import net.eagle0.eagle.model.state.chronicle_entry.ChronicleEntry
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.view.battle.ShardokBattleView
@@ -27,5 +27,6 @@ case class GameStateViewDiff(
    newRunning: Option[Boolean] = None,
    newVictor: Option[FactionId] = None,
    newBattalionTypes: Vector[BattalionType] = Vector.empty,
-    updatedChronicleEntries: Vector[ChronicleEntry] = Vector.empty
+    updatedChronicleEntries: Vector[ChronicleEntry] = Vector.empty,
+    newGameType: Option[GameType] = None
 )
@@ -1371,7 +1371,7 @@ class GamesManager(

    tutorialBattleConfigs = tutorialBattleConfigs + (gameId -> tutorialConfig)

-    val textStore = ClientTextStoreImpl(
+    val initialTextStore = ClientTextStoreImpl(
      pregenerated = pregeneratedClientText,
      persister = gamePersisterCreation.persisterForGame(gameId),
      completeTexts = Map.empty,
@@ -1383,6 +1383,13 @@ class GamesManager(
      accessibleToIsSaved = true
    )

+    // Copy pregenerated texts (hero names, backstories) into the game's text store
+    val populatedTextStore = GamesManager.withPopulatedPregeneratedTexts(
+      clientTextStore = initialTextStore,
+      heroes = engineAndResults.engine.currentState.heroes.values,
+      factionIds = engineAndResults.engine.factionIds
+    )
+
    val userToFid = Map(userId -> 1)

    val withAiCommands = GameController.performAiCommands(
@@ -1391,7 +1398,7 @@ class GamesManager(
        fullHistory = GamesManager.extractFullHistory(engineAndResults.engine),
        userIdToFactionId = userToFid,
        aiFids = Vector(2),
-        clientTextStore = textStore
+        clientTextStore = populatedTextStore
      )
    )

@@ -74,7 +74,8 @@ object InMemoryHistory {
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = net.eagle0.eagle.model.state.GameType.Normal
  )
 }

@@ -182,6 +182,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/state:army",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
        "//src/main/scala/net/eagle0/eagle/model/state:combat_unit",
+        "//src/main/scala/net/eagle0/eagle/model/state:game_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state:supplies",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
@@ -44,7 +44,8 @@ object TutorialGameCreation {
      newRoundPhase = Some(RoundPhase.BattleRequest),
      newDate = Some(StartDate.startDate),
      newRandomSeed = Some(gameId),
-      newProvinces = provinces
+      newProvinces = provinces,
+      newGameType = Some(GameType.Tutorial)
    )

    // Build factions, heroes, and battalions from tutorial parameters
@@ -1,13 +1,13 @@
 package net.eagle0.eagle.ai

 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.faction.FactionT
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceT}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -73,7 +73,8 @@ class FactionLeaderProvinceRankerTest extends AnyFlatSpec with Matchers with Bef
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  "rankedProvinceIds" should "order by hostile, then hostile + neutral" in {
@@ -4,6 +4,7 @@ import scala.util.Random

 import net.eagle0.common.SeededRandom
 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{
  AvailableDestinationProvince,
@@ -17,7 +18,6 @@ import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceT}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -77,7 +77,8 @@ class FixLeaderAloneCommandSelectorTest extends AnyFlatSpec with Matchers with B
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private def makeMarchAvailable(
@@ -10,6 +10,7 @@ import net.eagle0.eagle.library.settings.{
  MinimumTrustToInvite,
  PrestigePerSupportedProvince
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{DiplomacyAvailable, DiplomacyOption}
 import net.eagle0.eagle.model.state.command.common.DiplomacyOptionType
@@ -22,7 +23,6 @@ import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -82,7 +82,8 @@ class InvitationCommandSelectorTest extends AnyFlatSpec with Matchers with Befor
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private val actingFaction: FactionC = makeFaction(
@@ -3,6 +3,7 @@ package net.eagle0.eagle.ai
 import net.eagle0.eagle.{BattalionId, FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.{GoldPerHeroHeldBack, MonthsReconConsideredRecent}
 import net.eagle0.eagle.model.state.{Army, BattalionType, MovingArmy, Supplies}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.battalion.BattalionT
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
@@ -25,7 +26,6 @@ import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceT}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionTypeId as ScalaBattalionTypeId
-import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.model.view.province.ProvinceView
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -88,7 +88,8 @@ class MidGameAIClientTest extends AnyFlatSpec with Matchers with BeforeAndAfterE
      victor = None,
      battalionTypes = battalionTypes,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private def makeFaction(
@@ -2,6 +2,7 @@ package net.eagle0.eagle.ai

 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.GoldPerHeroHeldBack
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{
  AvailableDestinationProvince,
  MarchAvailable,
@@ -16,7 +17,6 @@ import net.eagle0.eagle.model.state.hero.HeroT
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceT}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -108,7 +108,8 @@ class MoveLeaderToBetterProvinceCommandChooserTest extends AnyFlatSpec with Matc
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private val faction: FactionC = makeFaction(
@@ -7,6 +7,7 @@ import net.eagle0.eagle.library.settings.{
  LoyaltyGainFromFeast,
  MinimumLoyaltyForSwearBrotherhood
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{
  AvailableDestinationProvince,
@@ -35,7 +36,6 @@ import net.eagle0.eagle.model.state.hero.HeroT
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceT}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -144,7 +144,8 @@ class SeekMoreLeadersCommandChooserTest extends AnyFlatSpec with Matchers with B
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private def makeMarchAvailable(
@@ -13,6 +13,7 @@ import net.eagle0.eagle.model.action_result.concrete.{
 }
 import net.eagle0.eagle.model.action_result.types.ActionResultType
 import net.eagle0.eagle.model.action_result.NotificationDetails
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.date.Date.Month
@@ -26,7 +27,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.shardok_battle.{BattleType, ShardokBattle}
 import net.eagle0.eagle.model.state.BattalionTypeId
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -61,7 +61,8 @@ class ActionResultApplierImplTest extends AnyFlatSpec with Matchers with BeforeA
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 1L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  // ============ Basic State Updates ============
@@ -1,6 +1,7 @@
 package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.library.settings.{MaxAlmsFood, MinVigorForAlms}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.AlmsAvailable
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -8,7 +9,6 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.hero.Profession
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -68,7 +68,8 @@ class AvailableAlmsCommandFactoryTest extends AnyFlatSpec with Matchers with Bef
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val extraProvinceVassal1 = HeroC(
@@ -1,6 +1,7 @@
 package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.library.settings.MinVigorForApprehendOutlaw
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{ApprehendOutlawAvailable, ResidentOutlaw}
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
@@ -8,7 +9,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -84,7 +84,8 @@ class AvailableApprehendOutlawCommandFactoryTest extends AnyFlatSpec with Matche
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -5,6 +5,7 @@ import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{ArmTroopsAvailable, ArmamentCost}
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -94,7 +95,8 @@ class AvailableArmTroopsCommandFactoryTest extends AnyFlatSpec with Matchers wit
    victor = None,
    battalionTypes = battalionTypes,
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  "availableCommands" should "return nothing if there are no battalions" in {
@@ -8,6 +8,7 @@ import net.eagle0.eagle.library.settings.{
 }
 import net.eagle0.eagle.library.EagleInternalException
 import net.eagle0.eagle.model.state.{Army, CombatUnit, HostileArmyGroup, HostileArmyGroupStatus, MovingArmy, Supplies}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{
  ArmyStats,
@@ -26,7 +27,6 @@ import net.eagle0.eagle.model.state.province.Neighbor
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionTypeId
 import net.eagle0.eagle.model.state.Hostility
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -182,7 +182,8 @@ class AvailableAttackDecisionCommandFactoryTest extends AnyFlatSpec with Matcher
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private def getAttackDecisionCommand(gs: GameState): AttackDecisionAvailable =
@@ -13,6 +13,7 @@ import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceEvent
 import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.GameType
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -60,7 +61,8 @@ class AvailableCommandsFactoryTest extends AnyFlatSpec with Matchers with MockFa
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private val baseProvince = ProvinceC(
@@ -2,6 +2,7 @@ package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.{FactionId, ProvinceId}
 import net.eagle0.eagle.library.settings.MinVigorForControlWeather
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{ControlWeatherAvailable, TargetProvinceOptions}
 import net.eagle0.eagle.model.state.command.common.ControlWeatherType
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -11,7 +12,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.Neighbor
 import net.eagle0.eagle.model.state.province.ProvinceEvent.{BlizzardEvent, DroughtEvent}
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -68,7 +68,8 @@ class AvailableControlWeatherCommandsFactoryTest extends AnyFlatSpec with Before
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -10,6 +10,7 @@ import net.eagle0.eagle.model.state.quest.DefeatFactionQuest
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.RecruitmentInfo
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType.Traveler
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.Inside.inside
@@ -76,7 +77,8 @@ class AvailableDeclineQuestCommandsFactoryTest extends AnyFlatSpec with Matchers
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  "availableCommand" should "return None when the province is not ruled by the faction leader" in {
@@ -19,6 +19,7 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.Neighbor
 import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.HostileArmyGroupStatus.Attacking
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -143,7 +144,8 @@ class AvailableDefendCommandsFactoryTest extends AnyFlatSpec with BeforeAndAfter
    victor = None,
    battalionTypes = battalionTypes,
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val defendingProvince = ProvinceC(
@@ -11,6 +11,7 @@ import net.eagle0.eagle.library.settings.{
  PrestigePerSupportedProvince,
  TruceGoldCost
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
 import net.eagle0.eagle.model.state.command.common.DiplomacyOptionType
 import net.eagle0.eagle.model.state.date.Date
@@ -26,7 +27,6 @@ import net.eagle0.eagle.model.state.province.Neighbor
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -151,7 +151,8 @@ class AvailableDiplomacyCommandsFactoryTest extends AnyFlatSpec with Matchers wi
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private def gameState: GameState = makeGameState()
@@ -10,6 +10,7 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.RecruitmentInfo
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType.Resident
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -85,7 +86,8 @@ class AvailableDivineCommandsFactoryTest extends AnyFlatSpec with Matchers with
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  "availableCommand" should "return None when the province is not ruled by the faction leader" in {
@@ -1,12 +1,12 @@
 package net.eagle0.eagle
 package library.actions.availability

+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.ExileVassalAvailable
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.Inside.inside
@@ -56,7 +56,8 @@ class AvailableExileVassalCommandFactoryTest extends AnyFlatSpec with Matchers {
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  "availableCommand" should "include non-leader vassals" in {
@@ -5,6 +5,7 @@ import net.eagle0.eagle.model.state.command.available.AvailableCommand.FeastAvai
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -50,7 +51,8 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
      victor = None,
      battalionTypes = Vector(),
      randomSeed = 0,
-      chronicleEntries = Vector()
+      chronicleEntries = Vector(),
+      gameType = GameType.Normal
    )

    AvailableFeastCommandFactory.availableCommand(
@@ -94,7 +96,8 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
      victor = None,
      battalionTypes = Vector(),
      randomSeed = 0,
-      chronicleEntries = Vector()
+      chronicleEntries = Vector(),
+      gameType = GameType.Normal
    )

    inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -137,7 +140,8 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
      victor = None,
      battalionTypes = Vector(),
      randomSeed = 0,
-      chronicleEntries = Vector()
+      chronicleEntries = Vector(),
+      gameType = GameType.Normal
    )

    inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -184,7 +188,8 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
      victor = None,
      battalionTypes = Vector(),
      randomSeed = 0,
-      chronicleEntries = Vector()
+      chronicleEntries = Vector(),
+      gameType = GameType.Normal
    )

    inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -231,7 +236,8 @@ class AvailableFeastCommandFactoryTest extends AnyFlatSpec with Matchers with Be
      victor = None,
      battalionTypes = Vector(),
      randomSeed = 0,
-      chronicleEntries = Vector()
+      chronicleEntries = Vector(),
+      gameType = GameType.Normal
    )

    inside(AvailableFeastCommandFactory.availableCommand(gameState, 9, 5).get) {
@@ -7,6 +7,7 @@ import net.eagle0.eagle.library.settings.{
  MinimumWisdomForStartFire
 }
 import net.eagle0.eagle.model.state.{Army, CombatUnit, HostileArmyGroup, HostileArmyGroupStatus, MovingArmy, Supplies}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{
  ArmyStats,
@@ -23,7 +24,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionTypeId
 import net.eagle0.eagle.model.state.Hostility
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.{BeforeAndAfterEach, Inside}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -135,7 +135,8 @@ class AvailableFreeForAllDecisionCommandFactoryTest
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private def getFreeForAllCommand(gs: GameState): FreeForAllDecisionAvailable =
@@ -6,6 +6,7 @@ import net.eagle0.eagle.library.settings.{
  MinimumAgilityForStartFire,
  MinimumWisdomForStartFire
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.HandleCapturedHeroAvailable
 import net.eagle0.eagle.model.state.command.common.CapturedHeroOption
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
@@ -14,7 +15,6 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.CapturedHero
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.{BeforeAndAfterEach, Inside}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -95,7 +95,8 @@ class AvailableHandleCapturedHeroCommandFactoryTest
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameStateWithOne: GameState = gameStateWithTwo.copy(
@@ -5,12 +5,13 @@ import net.eagle0.eagle.library.settings.MinVigorForCrackDown
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.HandleRiotCrackDownAvailable
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
-import net.eagle0.eagle.model.state.province.ProvinceEvent.ImminentRiotEvent
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
-import org.scalatest.BeforeAndAfterEach
-import org.scalatest.Inside.inside
+import net.eagle0.eagle.model.state.province.ProvinceEvent.ImminentRiotEvent
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
+import org.scalatest.BeforeAndAfterEach
+import org.scalatest.Inside.inside

 class AvailableHandleRiotCrackDownCommandFactoryTest extends AnyFlatSpec with BeforeAndAfterEach with Matchers {
  private val fid: FactionId       = 17
@@ -64,7 +65,8 @@ class AvailableHandleRiotCrackDownCommandFactoryTest extends AnyFlatSpec with Be
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit =
@@ -74,10 +76,11 @@ class AvailableHandleRiotCrackDownCommandFactoryTest extends AnyFlatSpec with Be
    val result = AvailableHandleRiotCrackDownCommandFactory
      .availableCommand(makeGameState(), fid, pid)

-    inside(result.get) { case cmd: HandleRiotCrackDownAvailable =>
-      cmd.actingProvinceId shouldBe pid
-      cmd.availableHeroIds shouldBe rulingFactionHeroIds
-      cmd.battalionIdsAvailable shouldBe battalionIds
+    inside(result.get) {
+      case cmd: HandleRiotCrackDownAvailable =>
+        cmd.actingProvinceId shouldBe pid
+        cmd.availableHeroIds shouldBe rulingFactionHeroIds
+        cmd.battalionIdsAvailable shouldBe battalionIds
    }
  }

@@ -99,8 +102,9 @@ class AvailableHandleRiotCrackDownCommandFactoryTest extends AnyFlatSpec with Be
    val result = AvailableHandleRiotCrackDownCommandFactory
      .availableCommand(makeGameState(heroVigorOverrides = Map(10 -> 12.0)), fid, pid)

-    inside(result.get) { case cmd: HandleRiotCrackDownAvailable =>
-      cmd.availableHeroIds shouldBe Vector(20, 30)
+    inside(result.get) {
+      case cmd: HandleRiotCrackDownAvailable =>
+        cmd.availableHeroIds shouldBe Vector(20, 30)
    }
  }

@@ -6,6 +6,7 @@ import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceEvent.ImminentRiotEvent
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -58,7 +59,8 @@ class AvailableHandleRiotDoNothingCommandFactoryTest extends AnyFlatSpec with Be
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {}
@@ -6,6 +6,7 @@ import net.eagle0.eagle.model.state.command.available.AvailableCommand.HandleRio
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceEvent
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -50,7 +51,8 @@ class AvailableHandleRiotGiveCommandFactoryTest extends AnyFlatSpec with BeforeA
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {
@@ -2,13 +2,13 @@ package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.MaxGiftGold
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{EligibleGift, HeroGiftAvailable}
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -82,7 +82,8 @@ class AvailableHeroGiftCommandFactoryTest extends AnyFlatSpec with Matchers with
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val brother1             = HeroC(
@@ -3,6 +3,7 @@ package net.eagle0.eagle.library.actions.availability
 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.MinVigorForImprove
 import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.ImproveAvailable
 import net.eagle0.eagle.model.state.command.common.ImprovementType
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -10,7 +11,6 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.hero.Profession
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -86,7 +86,8 @@ class AvailableImproveCommandsFactoryTest extends AnyFlatSpec with Matchers with
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -7,6 +7,7 @@ import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceOrderType as StateProvinceOrderType
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.Inside.inside
@@ -113,7 +114,8 @@ class AvailableIssueOrdersCommandFactoryTest extends AnyFlatSpec with Matchers {
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  "availableCommands" should "return nothing if the province leader is not a faction leader" in {
@@ -2,6 +2,7 @@ package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.{MinimumAgilityForArchery, MinimumAgilityForStartFire}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.ManagePrisonersAvailable
 import net.eagle0.eagle.model.state.command.common.PrisonerManagementOption
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
@@ -12,7 +13,6 @@ import net.eagle0.eagle.model.state.province.Neighbor
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.{BeforeAndAfterEach, Inside}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -110,7 +110,8 @@ class AvailableManagePrisonerCommandsFactoryTest extends AnyFlatSpec with Before
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private def getManagePrisonersCommand(gs: GameState): ManagePrisonersAvailable =
@@ -2,6 +2,7 @@ package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.library.settings.{MaxCombatUnitCountPerSide, MaxFoodTribute, MaxGoldTribute, MinVigorForMarch}
 import net.eagle0.eagle.library.util.ShardokMapInfo
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.battalion.BattalionT
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
@@ -14,7 +15,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionType
 import net.eagle0.eagle.model.state.BattalionTypeId.{HeavyInfantry, LightInfantry}
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -54,7 +54,8 @@ class AvailableMarchCommandFactoryTest extends AnyFlatSpec with BeforeAndAfterEa
      victor = None,
      battalionTypes = battalionTypes,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private def getMarchCommand(
@@ -5,6 +5,7 @@ import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{OrganizeTroopsAvailable, TroopCost}
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -90,7 +91,8 @@ class AvailableOrganizeTroopsCommandsFactoryTest extends AnyFlatSpec with Before
    victor = None,
    battalionTypes = battalionTypes,
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  "availableCommand" should "include all battalions, below cap or not, if stats are high enough" in {
@@ -17,6 +17,7 @@ import net.eagle0.eagle.library.settings.{
  RecruitmentPowerFactor,
  RecruitmentPrestigeFactor
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -25,7 +26,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -83,7 +83,8 @@ class AvailablePleaseRecruitMeCommandFactoryTest extends AnyFlatSpec with Before
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private val baseProvinces: Map[Int, ProvinceC] = Map(actingProvince.id -> actingProvince)
@@ -1,6 +1,7 @@
 package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.library.settings.MinVigorForRecon
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.ReconAvailable
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -9,7 +10,6 @@ import net.eagle0.eagle.model.state.hero.Profession
 import net.eagle0.eagle.model.state.province.{IncomingEndTurnAction, IncomingRecon}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.FactionId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -66,7 +66,8 @@ class AvailableReconCommandFactoryTest extends AnyFlatSpec with BeforeAndAfterEa
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -27,6 +27,7 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.RecruitmentInfo
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType.{Resident, Traveler}
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -88,7 +89,8 @@ class AvailableRecruitHeroesCommandFactoryTest extends AnyFlatSpec with Matchers
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {
@@ -1,5 +1,6 @@
 package net.eagle0.eagle.library.actions.availability

+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.DiplomacyOfferInfo
 import net.eagle0.eagle.model.state.date.Date
@@ -9,7 +10,6 @@ import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -81,7 +81,8 @@ class AvailableResolveBreakAllianceCommandFactoryTest extends AnyFlatSpec with M
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 12345L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {}
@@ -19,6 +19,7 @@ import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.RecruitmentInfo
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType.{Prisoner, Traveler}
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.RoundPhase.PlayerCommands
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -133,7 +134,8 @@ class AvailableResolveRansomOfferCommandFactoryTest extends AnyFlatSpec with Mat
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 1L,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -16,6 +16,7 @@ import net.eagle0.eagle.model.state.command.available.AvailableCommand.{ResolveT
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.model.state.HostileArmyGroupStatus.TributeDemanded
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -64,7 +65,8 @@ class AvailableResolveTributeCommandsFactoryTest extends AnyFlatSpec with Matche
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private def makeHostileArmyGroup(
@@ -1,9 +1,9 @@
 package net.eagle0.eagle.library.actions.availability

+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.RestAvailable
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers

@@ -30,7 +30,8 @@ class AvailableRestCommandsFactoryTest extends AnyFlatSpec with Matchers {
      victor = None,
      battalionTypes = Vector(),
      randomSeed = 0,
-      chronicleEntries = Vector()
+      chronicleEntries = Vector(),
+      gameType = GameType.Normal
    )

    val command = AvailableRestCommandsFactory.availableCommand(gameState, 12, 6)
@@ -1,11 +1,11 @@
 package net.eagle0.eagle.library.actions.availability

+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.ReturnAvailable
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.Inside.inside
@@ -48,7 +48,8 @@ class AvailableReturnCommandsFactoryTest extends AnyFlatSpec with Matchers {
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -1,6 +1,7 @@
 package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.library.settings.MinVigorForSendSupplies
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.SendSuppliesAvailable
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -8,7 +9,6 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceEvent}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.ProvinceId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -70,7 +70,8 @@ class AvailableSendSuppliesCommandFactoryTest extends AnyFlatSpec with BeforeAnd
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState: GameState = makeGameState()
@@ -2,6 +2,7 @@ package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.MinVigorForStartEpidemic
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{StartEpidemicAvailable, StartEpidemicOptions}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -10,7 +11,6 @@ import net.eagle0.eagle.model.state.hero.Profession
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceEvent}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -98,7 +98,8 @@ class AvailableStartEpidemicCommandFactoryTest extends AnyFlatSpec with BeforeAn
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -2,6 +2,7 @@ package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
 import net.eagle0.eagle.library.settings.{MaximumFactionLeaders, MinimumLoyaltyForSwearBrotherhood}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.{HeroAndBackstory, SwearBrotherhoodAvailable}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
@@ -10,7 +11,6 @@ import net.eagle0.eagle.model.state.hero.backstory_version.BackstoryVersion
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -93,7 +93,8 @@ class AvailableSwearBrotherhoodCommandFactoryTest extends AnyFlatSpec with Match
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -5,6 +5,7 @@ import net.eagle0.eagle.model.state.command.available.AvailableCommand.TradeAvai
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -49,7 +50,8 @@ class AvailableTradeCommandFactoryTest extends AnyFlatSpec with Matchers with Be
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {
@@ -9,6 +9,7 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.hero.Profession
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -91,7 +92,8 @@ class AvailableTrainCommandsFactoryTest extends AnyFlatSpec with BeforeAndAfterE
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit =
@@ -1,6 +1,7 @@
 package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.library.settings.MinVigorForTravel
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.TravelAvailable
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -8,7 +9,6 @@ import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceEvent.BlizzardEvent
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -54,7 +54,8 @@ class AvailableTravelCommandsFactoryTest extends AnyFlatSpec with Matchers with
    victor = None,
    battalionTypes = Vector(),
    randomSeed = 0,
-    chronicleEntries = Vector()
+    chronicleEntries = Vector(),
+    gameType = GameType.Normal
  )

  private val gameState = makeGameState()
@@ -42,6 +42,7 @@ import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.RecruitmentInfo
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType.{Outlaw, Prisoner}
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -92,7 +93,8 @@ class EndBattleAftermathPhaseActionTest extends AnyFlatSpec with Matchers with B
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = randomSeed,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  behavior of "EndBattleAftermathPhaseActionTest"
@@ -18,6 +18,7 @@ import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers

@@ -115,7 +116,8 @@ class EndDefenseDecisionPhaseActionTest extends AnyFlatSpec with Matchers {
    runStatus = RunStatus.Running,
    victor = None,
    battalionTypes = Vector.empty,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  "execute" should "end the phase and proceed to TRUCE_TURN_BACK" in {
@@ -4,10 +4,10 @@ import net.eagle0.common.SeededRandom
 import net.eagle0.eagle.library.actions.applier.ActionResultApplierImpl
 import net.eagle0.eagle.library.util.validations.RuntimeValidator
 import net.eagle0.eagle.model.action_result.types.ActionResultType.EndDiplomacyResolutionPhase
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -38,7 +38,8 @@ class EndDiplomacyResolutionPhaseActionTest extends AnyFlatSpec with Matchers wi
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 12345L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private val applier          = ActionResultApplierImpl(Some(RuntimeValidator))
@@ -17,6 +17,7 @@ import net.eagle0.eagle.model.action_result.types.ActionResultType.{
  RiotAversionFailed,
  RiotOccurred
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.command.available.AvailableCommand.HandleRiotDoNothingAvailable
 import net.eagle0.eagle.model.state.command.available.OneProvinceAvailableCommands
 import net.eagle0.eagle.model.state.date.Date
@@ -27,7 +28,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceEvent.ImminentRiotEvent
 import net.eagle0.eagle.model.state.province.ProvinceOrderType
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -71,7 +71,8 @@ class EndHandleRiotsPhaseActionTest extends AnyFlatSpec with BeforeAndAfterEach
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 1L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {
@@ -12,6 +12,7 @@ import net.eagle0.eagle.model.action_result.types.ActionResultType.{
  PrisonerMoveTookEffect,
  WeatherTookEffect
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -23,7 +24,6 @@ import net.eagle0.eagle.model.state.province.ProvinceEvent.{BlizzardEvent, Droug
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroT, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.FactionId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -143,7 +143,8 @@ class EndPlayerCommandsPhaseActionTest extends AnyFlatSpec with Matchers with Be
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = randomSeed,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private def gameState: GameState = makeGameState()
@@ -44,6 +44,7 @@ import net.eagle0.eagle.model.state.province.ProvinceOrderType
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
+import net.eagle0.eagle.model.state.GameType
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.{BeforeAndAfterEach, OneInstancePerTest}
 import org.scalatest.flatspec.AnyFlatSpec
@@ -94,7 +95,8 @@ class NewRoundActionTest
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  // Helper to run NewRoundAction and return Scala ActionResults
@@ -14,6 +14,7 @@ import net.eagle0.eagle.library.settings.{
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.{ChangedBattalionC, ChangedHeroC, StatDelta}
 import net.eagle0.eagle.model.action_result.types.ActionResultType
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -23,7 +24,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionTypeId
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -128,7 +128,8 @@ class NewYearActionTest extends AnyFlatSpec with Matchers with BeforeAndAfterEac
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private def gs: GameState = baseGameState
@@ -14,6 +14,7 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionType
 import net.eagle0.eagle.model.state.BattalionTypeId
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -85,7 +86,8 @@ class PerformFoodConsumptionPhaseActionTest extends AnyFlatSpec with Matchers wi
    victor = None,
    battalionTypes = battalionTypes,
    randomSeed = 1L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {}
@@ -18,6 +18,7 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceEvent.BlizzardEvent
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.ProvinceId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -72,7 +73,8 @@ class PerformForcedTurnBackActionTest extends AnyFlatSpec with Matchers with Bef
    runStatus = RunStatus.Running,
    victor = None,
    battalionTypes = Vector.empty,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private val gsWithoutBlizzard = gsWithBlizzard.copy(
@@ -5,6 +5,7 @@ import net.eagle0.eagle.library.settings.{FactionBiasFromDeparture, LoyaltyThres
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.ChangedHeroC
 import net.eagle0.eagle.model.action_result.types.ActionResultType.{EndHeroDeparturePhase, HeroesDeparted}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.date.Date.Month
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
@@ -16,7 +17,6 @@ import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -72,7 +72,8 @@ class PerformHeroDeparturesActionTest extends AnyFlatSpec with Matchers with Bef
    runStatus = RunStatus.Running,
    victor = None,
    battalionTypes = Vector.empty,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {
@@ -8,6 +8,7 @@ import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.{Neighbor, ProvinceT}
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.GameType
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.Inside.inside
@@ -60,7 +61,8 @@ class PerformHostileArmySetupActionTest extends AnyFlatSpec with Matchers {
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  "any setup" should "move to the next round phase" in {
@@ -78,23 +80,24 @@ class PerformHostileArmySetupActionTest extends AnyFlatSpec with Matchers {
    result.actionResultType shouldBe SetUpHostileArmies
    result.changedProvinces should have size 1

-    inside(result.changedProvinces.head) { case c: ChangedProvinceC =>
-      c.provinceId shouldBe 98
-      c.removedIncomingArmyIds shouldBe Vector(22)
-      c.newHostileArmies should have size 1
-  
-      val hag = c.newHostileArmies.head
-      hag.factionId shouldBe anotherFactionId
-      hag.status shouldBe HostileArmyGroupStatus.AwaitingDecision
-      hag.armies should have size 1
-  
-      // Verify the full army structure is preserved
-      val army = hag.armies.head
-      army.id shouldBe 22
-      army.originProvinceId shouldBe neighborProvinceId
-      army.arrivalRound shouldBe currentRoundId
-      army.startingPositionIndex shouldBe Some(3)
-      army.army.factionId shouldBe anotherFactionId
+    inside(result.changedProvinces.head) {
+      case c: ChangedProvinceC =>
+        c.provinceId shouldBe 98
+        c.removedIncomingArmyIds shouldBe Vector(22)
+        c.newHostileArmies should have size 1
+
+        val hag = c.newHostileArmies.head
+        hag.factionId shouldBe anotherFactionId
+        hag.status shouldBe HostileArmyGroupStatus.AwaitingDecision
+        hag.armies should have size 1
+
+        // Verify the full army structure is preserved
+        val army = hag.armies.head
+        army.id shouldBe 22
+        army.originProvinceId shouldBe neighborProvinceId
+        army.arrivalRound shouldBe currentRoundId
+        army.startingPositionIndex shouldBe Some(3)
+        army.army.factionId shouldBe anotherFactionId
    }
  }

@@ -46,6 +46,7 @@ import net.eagle0.eagle.model.action_result.concrete.{
 }
 import net.eagle0.eagle.model.action_result.types.ActionResultType.ProvinceEventsChanged
 import net.eagle0.eagle.model.state.{Army, MovingArmy, Supplies}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
@@ -67,7 +68,6 @@ import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType
 import net.eagle0.eagle.model.state.BattalionTypeId
-import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.FactionId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -159,7 +159,8 @@ class PerformProvinceEventsActionTest extends AnyFlatSpec with BeforeAndAfterEac
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = randomSeed,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  "changedProvince" should "remove beasts if we're past their end date" in {
@@ -12,6 +12,7 @@ import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.province.ProvinceOrderType
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.HeroId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -111,7 +112,8 @@ class PerformProvinceMoveResolutionActionTest extends AnyFlatSpec with Matchers
    runStatus = net.eagle0.eagle.model.state.run_status.RunStatus.Running,
    victor = None,
    battalionTypes = Vector.empty,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private def getResults(gs: GameState) =
@@ -8,6 +8,7 @@ import net.eagle0.eagle.library.settings.{BaseResourceLimit, PerDevelopmentResou
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.{ActionResultC, ChangedFactionC, ClientTextVisibilityExtensionC}
 import net.eagle0.eagle.model.action_result.types.ActionResultType.{EndReconResolutionPhase, ReconSucceeded}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
@@ -19,7 +20,6 @@ import net.eagle0.eagle.model.state.quest.{ReconProvincesQuest, ReconSpecificPro
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -64,7 +64,8 @@ class PerformReconResolutionActionTest extends AnyFlatSpec with BeforeAndAfterEa
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private val baseProvinces: Map[Int, ProvinceC] = Map(
@@ -34,6 +34,7 @@ import net.eagle0.eagle.model.action_result.types.ActionResultType.{
  HeroMoved,
  HeroRejoined
 }
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.faction.FactionT
@@ -47,7 +48,6 @@ import net.eagle0.eagle.model.state.province.ProvinceEvent.BlizzardEvent
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatest.BeforeAndAfterEach
@@ -77,7 +77,8 @@ class PerformUnaffiliatedHeroesActionTest extends AnyFlatSpec with Matchers with
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 12345L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  override def beforeEach(): Unit = {
@@ -48,6 +48,7 @@ import net.eagle0.eagle.model.state.province.Neighbor
 import net.eagle0.eagle.model.state.province.ProvinceOrderType.{Develop, Expand}
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.BattalionTypeId.{HeavyCavalry, HeavyInfantry, LightInfantry}
+import net.eagle0.eagle.model.state.GameType
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -264,7 +265,8 @@ class PerformVassalCommandsPhaseActionTest extends AnyFlatSpec with Matchers wit
      victor = None,
      battalionTypes = battalionTypes,
      randomSeed = 1L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )

  private val marchGameState = baseGameState(
@@ -5,13 +5,13 @@ import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedPro
 import net.eagle0.eagle.model.action_result.concrete.ChangedHeroC
 import net.eagle0.eagle.model.action_result.types.ActionResultType.{EndPrisonerExchangePhase, PrisonersExchanged}
 import net.eagle0.eagle.model.action_result.NotificationDetails
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
-import net.eagle0.eagle.model.state.RoundPhase
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers

@@ -40,7 +40,8 @@ class PrisonerExchangeActionTest extends AnyFlatSpec with Matchers {
    runStatus = RunStatus.Running,
    victor = None,
    battalionTypes = Vector.empty,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private def prisoner(heroId: Int, lastFactionId: Int): UnaffiliatedHeroC =
@@ -40,6 +40,7 @@ import net.eagle0.eagle.model.state.run_status.RunStatus
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unit_status.UnitStatus
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.shardok_interface.{EagleUnit, ResolvedEagleUnit}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -203,7 +204,8 @@ class ProvinceConqueredActionTest extends AnyFlatSpec with Matchers {
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private val currentDate = Date(year = 2024, month = Date.Month.July)
@@ -48,6 +48,7 @@ import net.eagle0.eagle.model.state.shardok_battle.{DrawType, EndGameCondition}
 import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
 import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
 import net.eagle0.eagle.model.state.unit_status.UnitStatus
+import net.eagle0.eagle.model.state.GameType
 import net.eagle0.eagle.shardok_interface.{BattleResolution, EagleUnit, ResolvedEagleUnit, ResolvedShardokPlayer}
 import net.eagle0.eagle.FactionId
 import org.scalamock.scalatest.MockFactory
@@ -496,7 +497,8 @@ class ResolveBattleActionTest extends AnyFlatSpec with MockFactory with Matchers
    runStatus = RunStatus.Running,
    victor = None,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private val startingGameStateWithAllies = startingGameState.copy(
@@ -6,6 +6,7 @@ import net.eagle0.eagle.model.action_result.changed_province.concrete.{ChangedPr
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.ActionResultType.{EndTruceTurnBackPhase, WithdrawalForTruce}
 import net.eagle0.eagle.model.state.{Army, HostileArmyGroup, HostileArmyGroupStatus, MovingArmy, Supplies}
+import net.eagle0.eagle.model.state.{GameType, RoundPhase}
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.concrete.FactionC
 import net.eagle0.eagle.model.state.faction.FactionRelationship
@@ -13,7 +14,6 @@ import net.eagle0.eagle.model.state.faction.FactionRelationship.RelationshipLeve
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
 import net.eagle0.eagle.model.state.run_status.RunStatus
-import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.FactionId
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -113,7 +113,8 @@ class TruceTurnBackPhaseActionTest extends AnyFlatSpec with Matchers {
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 1L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  "results" should "advance to the next phase" in {
@@ -10,6 +10,7 @@ import net.eagle0.eagle.model.state.hero.{Gender, Profession}
 import net.eagle0.eagle.model.state.hero.backstory_version.BackstoryVersion
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.GameType
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -107,7 +108,8 @@ class CapturedHeroMessagePromptGeneratorTest extends AnyFlatSpec with Matchers w
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  "execute message prompt" should "return an appropriate execute message" in {
@@ -14,6 +14,7 @@ import net.eagle0.eagle.model.state.hero.backstory_version.BackstoryVersion
 import net.eagle0.eagle.model.state.hero.concrete.HeroC
 import net.eagle0.eagle.model.state.hero.Gender
 import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.GameType
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -80,7 +81,8 @@ class ChronicleUpdatePromptGeneratorTest extends AnyFlatSpec with BeforeAndAfter
    victor = None,
    battalionTypes = Vector.empty,
    randomSeed = 0L,
-    chronicleEntries = Vector.empty
+    chronicleEntries = Vector.empty,
+    gameType = GameType.Normal
  )

  private val mockClientTextStore = mock[ClientTextStore]
@@ -3,6 +3,7 @@ package net.eagle0.eagle.library.actions.llm_prompt_generators
 import net.eagle0.eagle.client_text.ClientTextStore
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.GameType
 import org.scalamock.scalatest.MockFactory
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
@@ -56,7 +57,8 @@ class GeneratorUtilitiesTest extends AnyFlatSpec with Matchers with BeforeAndAft
      victor = None,
      battalionTypes = Vector.empty,
      randomSeed = 0L,
-      chronicleEntries = Vector.empty
+      chronicleEntries = Vector.empty,
+      gameType = GameType.Normal
    )
    val clientTextStore = mock[ClientTextStore]
    GeneratorUtilities
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
adminandClaude Opus 4.5	9cf6e9cc3f	Populate hero names in tutorial game ClientTextStore The tutorial game creation was not calling withPopulatedPregeneratedTexts(), causing hero names to show as "Hero" instead of their actual names because the name text IDs couldn't be resolved. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-02-18 12:30:13 -08:00
adminandClaude Opus 4.5	aa62cbdae5	Remove default value from GameState.gameType parameter Force callers to explicitly specify gameType when constructing GameState, making the type requirement more explicit and preventing accidental defaults. Updates all test files and InMemoryHistory to explicitly pass GameType.Normal. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-02-18 12:26:05 -08:00
adminandClaude Opus 4.5	b5ce58a448	Add newGameType field to GameStateViewDiff Ensures game type changes are sent to clients via diffs, not just the full GameStateView. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-02-18 09:22:27 -08:00
adminandClaude Opus 4.5	561babd7bc	Add GameType enum to track tutorial vs normal games - Add GameType enum (NORMAL, TUTORIAL) in common proto and Scala model - Store gameType in GameState and pass to GameStateView for client - Add newGameType field to ActionResult for setting game type on creation - Mark tutorial games as TUTORIAL in TutorialGameCreation Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-02-18 09:15:59 -08:00