Create isXPhase method and add properties to each phase

2025-07-04 07:22:19 +02:00 · 2025-05-22 18:46:41 -05:00 · 2025-05-22 18:46:41 -05:00 · aef619a699
commit aef619a699
parent b872ac6595
89 changed files with 342 additions and 112 deletions
--- a/src/@types/phase-types.ts
+++ b/src/@types/phase-types.ts
@ -1,11 +1,19 @@
+import type { MoveAnim } from "#app/data/battle-anims";
+import type { AddEnemyBuffModifierPhase } from "#app/phases/add-enemy-buff-modifier-phase";
+import type { AttemptCapturePhase } from "#app/phases/attempt-capture-phase";
 import type { AttemptRunPhase } from "#app/phases/attempt-run-phase";
 import type { BattleEndPhase } from "#app/phases/battle-end-phase";
 import type { BerryPhase } from "#app/phases/berry-phase";
+import type { CheckStatusEffectPhase } from "#app/phases/check-status-effect-phase";
 import type { CheckSwitchPhase } from "#app/phases/check-switch-phase";
 import type { CommandPhase } from "#app/phases/command-phase";
+import type { CommonAnimPhase } from "#app/phases/common-anim-phase";
 import type { DamageAnimPhase } from "#app/phases/damage-anim-phase";
+import type { EggHatchPhase } from "#app/phases/egg-hatch-phase";
 import type { EggLapsePhase } from "#app/phases/egg-lapse-phase";
+import type { EggSummaryPhase } from "#app/phases/egg-summary-phase";
 import type { EncounterPhase } from "#app/phases/encounter-phase";
+import type { EndCardPhase } from "#app/phases/end-card-phase";
 import type { EndEvolutionPhase } from "#app/phases/end-evolution-phase";
 import type { EnemyCommandPhase } from "#app/phases/enemy-command-phase";
 import type { EvolutionPhase } from "#app/phases/evolution-phase";
@ -14,13 +22,21 @@ import type { FaintPhase } from "#app/phases/faint-phase";
 import type { FormChangePhase } from "#app/phases/form-change-phase";
 import type { GameOverModifierRewardPhase } from "#app/phases/game-over-modifier-reward-phase";
 import type { GameOverPhase } from "#app/phases/game-over-phase";
+import type { HideAbilityPhase } from "#app/phases/hide-ability-phase";
+import type { HidePartyExpBarPhase } from "#app/phases/hide-party-exp-bar-phase";
 import type { LearnMovePhase } from "#app/phases/learn-move-phase";
 import type { LevelCapPhase } from "#app/phases/level-cap-phase";
+import type { LevelUpPhase } from "#app/phases/level-up-phase";
+import type { LoadMoveAnimPhase } from "#app/phases/load-move-anim-phase";
 import type { LoginPhase } from "#app/phases/login-phase";
 import type { MessagePhase } from "#app/phases/message-phase";
 import type { ModifierRewardPhase } from "#app/phases/modifier-reward-phase";
+import type { MoneyRewardPhase } from "#app/phases/money-reward-phase";
+import type { MoveAnimPhase } from "#app/phases/move-anim-phase";
+import type { MoveChargePhase } from "#app/phases/move-charge-phase";
 import type { MoveEffectPhase } from "#app/phases/move-effect-phase";
 import type { MoveEndPhase } from "#app/phases/move-end-phase";
+import type { MoveHeaderPhase } from "#app/phases/move-header-phase";
 import type { MovePhase } from "#app/phases/move-phase";
 import type {
  MysteryEncounterPhase,
@ -28,153 +44,243 @@ import type {
  MysteryEncounterBattlePhase,
  MysteryEncounterRewardsPhase,
  PostMysteryEncounterPhase,
+  MysteryEncounterBattleStartCleanupPhase,
 } from "#app/phases/mystery-encounter-phases";
 import type { NewBattlePhase } from "#app/phases/new-battle-phase";
 import type { NewBiomeEncounterPhase } from "#app/phases/new-biome-encounter-phase";
 import type { NextEncounterPhase } from "#app/phases/next-encounter-phase";
+import type { ObtainStatusEffectPhase } from "#app/phases/obtain-status-effect-phase";
 import type { PartyExpPhase } from "#app/phases/party-exp-phase";
 import type { PartyHealPhase } from "#app/phases/party-heal-phase";
+import type { PokemonAnimPhase } from "#app/phases/pokemon-anim-phase";
+import type { PokemonHealPhase } from "#app/phases/pokemon-heal-phase";
+import type { PokemonTransformPhase } from "#app/phases/pokemon-transform-phase";
 import type { PostGameOverPhase } from "#app/phases/post-game-over-phase";
 import type { PostSummonPhase } from "#app/phases/post-summon-phase";
+import type { PostTurnStatusEffectPhase } from "#app/phases/post-turn-status-effect-phase";
 import type { QuietFormChangePhase } from "#app/phases/quiet-form-change-phase";
+import type { ReloadSessionPhase } from "#app/phases/reload-session-phase";
+import type { ResetStatusPhase } from "#app/phases/reset-status-phase";
+import type { ReturnPhase } from "#app/phases/return-phase";
 import type { RevivalBlessingPhase } from "#app/phases/revival-blessing-phase";
 import type { RibbonModifierRewardPhase } from "#app/phases/ribbon-modifier-reward-phase";
+import type { ScanIvsPhase } from "#app/phases/scan-ivs-phase";
 import type { SelectBiomePhase } from "#app/phases/select-biome-phase";
+import type { SelectChallengePhase } from "#app/phases/select-challenge-phase";
 import type { SelectGenderPhase } from "#app/phases/select-gender-phase";
 import type { SelectModifierPhase } from "#app/phases/select-modifier-phase";
 import type { SelectStarterPhase } from "#app/phases/select-starter-phase";
 import type { SelectTargetPhase } from "#app/phases/select-target-phase";
 import type { ShinySparklePhase } from "#app/phases/shiny-sparkle-phase";
 import type { ShowAbilityPhase } from "#app/phases/show-ability-phase";
+import type { ShowPartyExpBarPhase } from "#app/phases/show-party-exp-bar-phase";
+import type { ShowTrainerPhase } from "#app/phases/show-trainer-phase";
 import type { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
+import type { SummonMissingPhase } from "#app/phases/summon-missing-phase";
 import type { SummonPhase } from "#app/phases/summon-phase";
+import type { SwitchBiomePhase } from "#app/phases/switch-biome-phase";
 import type { SwitchPhase } from "#app/phases/switch-phase";
 import type { SwitchSummonPhase } from "#app/phases/switch-summon-phase";
+import type { TeraPhase } from "#app/phases/tera-phase";
 import type { TitlePhase } from "#app/phases/title-phase";
 import type { ToggleDoublePositionPhase } from "#app/phases/toggle-double-position-phase";
+import type { TrainerVictoryPhase } from "#app/phases/trainer-victory-phase";
 import type { TurnEndPhase } from "#app/phases/turn-end-phase";
 import type { TurnInitPhase } from "#app/phases/turn-init-phase";
 import type { TurnStartPhase } from "#app/phases/turn-start-phase";
 import type { UnavailablePhase } from "#app/phases/unavailable-phase";
 import type { UnlockPhase } from "#app/phases/unlock-phase";
 import type { VictoryPhase } from "#app/phases/victory-phase";
+import type { WeatherEffectPhase } from "#app/phases/weather-effect-phase";

-export type PhaseKind = "";
 export type PhaseClass =
-  | typeof LoginPhase
-  | typeof TitlePhase
-  | typeof SelectGenderPhase
-  | typeof NewBiomeEncounterPhase
-  | typeof SelectStarterPhase
-  | typeof PostSummonPhase
-  | typeof SummonPhase
-  | typeof ToggleDoublePositionPhase
-  | typeof CheckSwitchPhase
-  | typeof ShowAbilityPhase
-  | typeof MessagePhase
-  | typeof TurnInitPhase
-  | typeof CommandPhase
-  | typeof EnemyCommandPhase
-  | typeof TurnStartPhase
-  | typeof MovePhase
-  | typeof MoveEffectPhase
-  | typeof DamageAnimPhase
-  | typeof FaintPhase
-  | typeof BerryPhase
-  | typeof TurnEndPhase
-  | typeof BattleEndPhase
-  | typeof EggLapsePhase
-  | typeof SelectModifierPhase
-  | typeof NextEncounterPhase
-  | typeof NewBattlePhase
-  | typeof VictoryPhase
-  | typeof LearnMovePhase
-  | typeof MoveEndPhase
-  | typeof StatStageChangePhase
-  | typeof ShinySparklePhase
-  | typeof SelectTargetPhase
-  | typeof UnavailablePhase
-  | typeof QuietFormChangePhase
-  | typeof SwitchPhase
-  | typeof SwitchSummonPhase
-  | typeof PartyHealPhase
-  | typeof FormChangePhase
-  | typeof EvolutionPhase
-  | typeof EndEvolutionPhase
-  | typeof LevelCapPhase
+  | typeof AddEnemyBuffModifierPhase
+  | typeof AttemptCapturePhase
  | typeof AttemptRunPhase
-  | typeof SelectBiomePhase
+  | typeof BattleEndPhase
+  | typeof BerryPhase
+  | typeof CheckStatusEffectPhase
+  | typeof CheckSwitchPhase
+  | typeof CommandPhase
+  | typeof CommonAnimPhase
+  | typeof DamageAnimPhase
+  | typeof EggHatchPhase
+  | typeof EggLapsePhase
+  | typeof EggSummaryPhase
+  | typeof EncounterPhase
+  | typeof EndCardPhase
+  | typeof EndEvolutionPhase
+  | typeof EnemyCommandPhase
+  | typeof EvolutionPhase
+  | typeof FormChangePhase
+  | typeof ExpPhase
+  | typeof FaintPhase
+  | typeof FormChangePhase
+  | typeof GameOverPhase
+  | typeof GameOverModifierRewardPhase
+  | typeof HideAbilityPhase
+  | typeof HidePartyExpBarPhase
+  | typeof LearnMovePhase
+  | typeof LevelUpPhase
+  | typeof LevelCapPhase
+  | typeof LoadMoveAnimPhase
+  | typeof LoginPhase
+  | typeof MessagePhase
+  | typeof ModifierRewardPhase
+  | typeof MoneyRewardPhase
+  | typeof MoveAnimPhase
+  | typeof MoveChargePhase
+  | typeof MoveEffectPhase
+  | typeof MoveEndPhase
+  | typeof MoveHeaderPhase
+  | typeof MovePhase
  | typeof MysteryEncounterPhase
  | typeof MysteryEncounterOptionSelectedPhase
  | typeof MysteryEncounterBattlePhase
  | typeof MysteryEncounterRewardsPhase
+  | typeof MysteryEncounterBattleStartCleanupPhase
+  | typeof MysteryEncounterRewardsPhase
  | typeof PostMysteryEncounterPhase
-  | typeof RibbonModifierRewardPhase
-  | typeof GameOverModifierRewardPhase
-  | typeof ModifierRewardPhase
+  | typeof NewBattlePhase
+  | typeof NewBiomeEncounterPhase
+  | typeof NextEncounterPhase
+  | typeof ObtainStatusEffectPhase
  | typeof PartyExpPhase
-  | typeof ExpPhase
-  | typeof EncounterPhase
-  | typeof GameOverPhase
-  | typeof UnlockPhase
+  | typeof PartyHealPhase
+  | typeof PokemonAnimPhase
+  | typeof PokemonHealPhase
+  | typeof PokemonTransformPhase
  | typeof PostGameOverPhase
-  | typeof RevivalBlessingPhase;
-export type PhaseString =
-  | "LoginPhase"
-  | "TitlePhase"
-  | "SelectGenderPhase"
-  | "NewBiomeEncounterPhase"
-  | "SelectStarterPhase"
-  | "PostSummonPhase"
-  | "SummonPhase"
-  | "ToggleDoublePositionPhase"
-  | "CheckSwitchPhase"
-  | "ShowAbilityPhase"
-  | "MessagePhase"
-  | "TurnInitPhase"
-  | "CommandPhase"
-  | "EnemyCommandPhase"
-  | "TurnStartPhase"
-  | "MovePhase"
-  | "MoveEffectPhase"
-  | "DamageAnimPhase"
-  | "FaintPhase"
-  | "BerryPhase"
-  | "TurnEndPhase"
-  | "BattleEndPhase"
-  | "EggLapsePhase"
-  | "SelectModifierPhase"
-  | "NextEncounterPhase"
-  | "NewBattlePhase"
-  | "VictoryPhase"
-  | "LearnMovePhase"
-  | "MoveEndPhase"
-  | "StatStageChangePhase"
-  | "ShinySparklePhase"
-  | "SelectTargetPhase"
-  | "UnavailablePhase"
-  | "QuietFormChangePhase"
-  | "SwitchPhase"
-  | "SwitchSummonPhase"
-  | "PartyHealPhase"
-  | "FormChangePhase"
-  | "EvolutionPhase"
-  | "EndEvolutionPhase"
-  | "LevelCapPhase"
-  | "AttemptRunPhase"
-  | "SelectBiomePhase"
-  | "MysteryEncounterPhase"
-  | "MysteryEncounterOptionSelectedPhase"
-  | "MysteryEncounterBattlePhase"
-  | "MysteryEncounterRewardsPhase"
-  | "PostMysteryEncounterPhase"
-  | "RibbonModifierRewardPhase"
-  | "GameOverModifierRewardPhase"
-  | "ModifierRewardPhase"
-  | "PartyExpPhase"
-  | "ExpPhase"
-  | "EncounterPhase"
-  | "GameOverPhase"
-  | "UnlockPhase"
-  | "PostGameOverPhase"
-  | "RevivalBlessingPhase";
+  | typeof PostSummonPhase
+  | typeof PostTurnStatusEffectPhase
+  | typeof QuietFormChangePhase
+  | typeof ReloadSessionPhase
+  | typeof ResetStatusPhase
+  | typeof ReturnPhase
+  | typeof RevivalBlessingPhase
+  | typeof RibbonModifierRewardPhase
+  | typeof ScanIvsPhase
+  | typeof SelectBiomePhase
+  | typeof SelectChallengePhase
+  | typeof SelectGenderPhase
+  | typeof SelectModifierPhase
+  | typeof SelectStarterPhase
+  | typeof SelectTargetPhase
+  | typeof ShinySparklePhase
+  | typeof ShowAbilityPhase
+  | typeof ShowTrainerPhase
+  | typeof ShowPartyExpBarPhase
+  | typeof StatStageChangePhase
+  | typeof SummonMissingPhase
+  | typeof SummonPhase
+  | typeof SwitchBiomePhase
+  | typeof SwitchPhase
+  | typeof SwitchSummonPhase
+  | typeof TeraPhase
+  | typeof TitlePhase
+  | typeof ToggleDoublePositionPhase
+  | typeof TrainerVictoryPhase
+  | typeof TurnEndPhase
+  | typeof TurnInitPhase
+  | typeof TurnStartPhase
+  | typeof UnavailablePhase
+  | typeof UnlockPhase
+  | typeof VictoryPhase
+  | typeof WeatherEffectPhase;
+
+/** Typescript map used to map a string phase to the actual phase type */
+export type PhaseMap = {
+  AddEnemyBuffModifierPhase: AddEnemyBuffModifierPhase;
+  AttemptCapturePhase: AttemptCapturePhase;
+  AttemptRunPhase: AttemptRunPhase;
+  BattleEndPhase: BattleEndPhase;
+  BerryPhase: BerryPhase;
+  CheckStatusEffectPhase: CheckStatusEffectPhase;
+  CheckSwitchPhase: CheckSwitchPhase;
+  CommandPhase: CommandPhase;
+  CommonAnimPhase: CommonAnimPhase;
+  DamageAnimPhase: DamageAnimPhase;
+  EggHatchPhase: EggHatchPhase;
+  EggLapsePhase: EggLapsePhase;
+  EggSummaryPhase: EggSummaryPhase;
+  EncounterPhase: EncounterPhase;
+  EndCardPhase: EndCardPhase;
+  EndEvolutionPhase: EndEvolutionPhase;
+  EnemyCommandPhase: EnemyCommandPhase;
+  EvolutionPhase: EvolutionPhase;
+  ExpPhase: ExpPhase;
+  FaintPhase: FaintPhase;
+  FormChangePhase: FormChangePhase;
+  GameOverPhase: GameOverPhase;
+  GameOverModifierRewardPhase: GameOverModifierRewardPhase;
+  HideAbilityPhase: HideAbilityPhase;
+  HidePartyExpBarPhase: HidePartyExpBarPhase;
+  LearnMovePhase: LearnMovePhase;
+  LevelCapPhase: LevelCapPhase;
+  LevelUpPhase: LevelUpPhase;
+  LoadMoveAnimPhase: LoadMoveAnimPhase;
+  LoginPhase: LoginPhase;
+  MessagePhase: MessagePhase;
+  ModifierRewardPhase: ModifierRewardPhase;
+  MoneyRewardPhase: MoneyRewardPhase;
+  MoveAnimPhase: MoveAnimPhase<MoveAnim>;
+  MoveChargePhase: MoveChargePhase;
+  MoveEffectPhase: MoveEffectPhase;
+  MoveEndPhase: MoveEndPhase;
+  MoveHeaderPhase: MoveHeaderPhase;
+  MovePhase: MovePhase;
+  MysteryEncounterPhase: MysteryEncounterPhase;
+  MysteryEncounterOptionSelectedPhase: MysteryEncounterOptionSelectedPhase;
+  MysteryEncounterBattlePhase: MysteryEncounterBattlePhase;
+  MysteryEncounterBattleStartCleanupPhase: MysteryEncounterBattleStartCleanupPhase;
+  MysteryEncounterRewardsPhase: MysteryEncounterRewardsPhase;
+  PostMysteryEncounterPhase: PostMysteryEncounterPhase;
+  NewBattlePhase: NewBattlePhase;
+  NewBiomeEncounterPhase: NewBiomeEncounterPhase;
+  NextEncounterPhase: NextEncounterPhase;
+  ObtainStatusEffectPhase: ObtainStatusEffectPhase;
+  PartyExpPhase: PartyExpPhase;
+  PartyHealPhase: PartyHealPhase;
+  PokemonAnimPhase: PokemonAnimPhase;
+  PokemonHealPhase: PokemonHealPhase;
+  PokemonTransformPhase: PokemonTransformPhase;
+  PostGameOverPhase: PostGameOverPhase;
+  PostSummonPhase: PostSummonPhase;
+  PostTurnStatusEffectPhase: PostTurnStatusEffectPhase;
+  QuietFormChangePhase: QuietFormChangePhase;
+  ReloadSessionPhase: ReloadSessionPhase;
+  ResetStatusPhase: ResetStatusPhase;
+  ReturnPhase: ReturnPhase;
+  RevivalBlessingPhase: RevivalBlessingPhase;
+  RibbonModifierRewardPhase: RibbonModifierRewardPhase;
+  ScanIvsPhase: ScanIvsPhase;
+  SelectBiomePhase: SelectBiomePhase;
+  SelectChallengePhase: SelectChallengePhase;
+  SelectGenderPhase: SelectGenderPhase;
+  SelectModifierPhase: SelectModifierPhase;
+  SelectStarterPhase: SelectStarterPhase;
+  SelectTargetPhase: SelectTargetPhase;
+  ShinySparklePhase: ShinySparklePhase;
+  ShowAbilityPhase: ShowAbilityPhase;
+  ShowPartyExpBarPhase: ShowPartyExpBarPhase;
+  ShowTrainerPhase: ShowTrainerPhase;
+  StatStageChangePhase: StatStageChangePhase;
+  SummonMissingPhase: SummonMissingPhase;
+  SummonPhase: SummonPhase;
+  SwitchBiomePhase: SwitchBiomePhase;
+  SwitchPhase: SwitchPhase;
+  SwitchSummonPhase: SwitchSummonPhase;
+  TeraPhase: TeraPhase;
+  TitlePhase: TitlePhase;
+  ToggleDoublePositionPhase: ToggleDoublePositionPhase;
+  TrainerVictoryPhase: TrainerVictoryPhase;
+  TurnEndPhase: TurnEndPhase;
+  TurnInitPhase: TurnInitPhase;
+  TurnStartPhase: TurnStartPhase;
+  UnavailablePhase: UnavailablePhase;
+  UnlockPhase: UnlockPhase;
+  VictoryPhase: VictoryPhase;
+  WeatherEffectPhase: WeatherEffectPhase;
+};
+
+export type PhaseString = keyof PhaseMap;
--- a/src/phase.ts
+++ b/src/phase.ts
@ -1,9 +1,33 @@
 import { globalScene } from "#app/global-scene";
+import type { PhaseMap, PhaseString } from "./@types/phase-types";

-export class Phase {
+export abstract class Phase {
  start() {}

  end() {
    globalScene.shiftPhase();
  }
+
+  /**
+   * The string name of the phase, used to identify the phase type for {@linkcode isXPhase}
+   *
+   * @privateremarks
+   *
+   * When implementing a phase, you must set the `phaseName` property to the name of the phase.
+   */
+  protected abstract readonly phaseName: PhaseString;
+
+  /**
+   * Check if the phase is of the given type without requiring `instanceof`.
+   *
+   * @param phase - The string name of the phase to check.
+   * @returns `true` if this phase is of the given type, `false` otherwise.
+   *
+   * @remarks
+   * This does not check for subclasses! It only checks if the phase is *exactly* the given type.
+   * This method exists to avoid circular import issues, as using `instanceof` would require importing each phase.
+   */
+  isXPhase<K extends keyof PhaseMap>(phase: K): this is PhaseMap[K] {
+    return this.phaseName === phase;
+  }
 }
--- a/src/phases/add-enemy-buff-modifier-phase.ts
+++ b/src/phases/add-enemy-buff-modifier-phase.ts
@ -9,6 +9,7 @@ import { Phase } from "#app/phase";
 import { globalScene } from "#app/global-scene";

 export class AddEnemyBuffModifierPhase extends Phase {
+  protected readonly phaseName = "AddEnemyBuffModifierPhase";
  start() {
    super.start();

--- a/src/phases/attempt-capture-phase.ts
+++ b/src/phases/attempt-capture-phase.ts
@ -27,6 +27,7 @@ import { globalScene } from "#app/global-scene";
 import { Gender } from "#app/data/gender";

 export class AttemptCapturePhase extends PokemonPhase {
+  protected readonly phaseName = "AttemptCapturePhase";
  private pokeballType: PokeballType;
  private pokeball: Phaser.GameObjects.Sprite;
  private originalY: number;
--- a/src/phases/attempt-run-phase.ts
+++ b/src/phases/attempt-run-phase.ts
@ -17,6 +17,7 @@ import { globalScene } from "#app/global-scene";
 import { SelectBiomePhase } from "./select-biome-phase";

 export class AttemptRunPhase extends PokemonPhase {
+  protected readonly phaseName = "AttemptRunPhase";
  /** For testing purposes: this is to force the pokemon to fail and escape */
  public forceFailEscape = false;

--- a/src/phases/battle-end-phase.ts
+++ b/src/phases/battle-end-phase.ts
@ -5,6 +5,7 @@ import { BattlePhase } from "./battle-phase";
 import { GameOverPhase } from "./game-over-phase";

 export class BattleEndPhase extends BattlePhase {
+  protected readonly phaseName = "BattleEndPhase";
  /** If true, will increment battles won */
  isVictory: boolean;

--- a/src/phases/battle-phase.ts
+++ b/src/phases/battle-phase.ts
@ -2,7 +2,7 @@ import { globalScene } from "#app/global-scene";
 import { TrainerSlot } from "#enums/trainer-slot";
 import { Phase } from "#app/phase";

-export class BattlePhase extends Phase {
+export abstract class BattlePhase extends Phase {
  showEnemyTrainer(trainerSlot: TrainerSlot = TrainerSlot.NONE): void {
    if (!globalScene.currentBattle.trainer) {
      console.warn("Enemy trainer is missing!");
--- a/src/phases/berry-phase.ts
+++ b/src/phases/berry-phase.ts
@ -20,6 +20,7 @@ import type Pokemon from "#app/field/pokemon";
 * Also triggers Cud Chew's "repeat berry use" effects
 */
 export class BerryPhase extends FieldPhase {
+  protected readonly phaseName = "BerryPhase";
  start() {
    super.start();

--- a/src/phases/check-status-effect-phase.ts
+++ b/src/phases/check-status-effect-phase.ts
@ -4,6 +4,7 @@ import type { BattlerIndex } from "#app/battle";
 import { globalScene } from "#app/global-scene";

 export class CheckStatusEffectPhase extends Phase {
+  protected readonly phaseName = "CheckStatusEffectPhase";
  private order: BattlerIndex[];
  constructor(order: BattlerIndex[]) {
    super();
--- a/src/phases/check-switch-phase.ts
+++ b/src/phases/check-switch-phase.ts
@ -10,6 +10,7 @@ import { SwitchPhase } from "./switch-phase";
 import { SwitchType } from "#enums/switch-type";

 export class CheckSwitchPhase extends BattlePhase {
+  protected readonly phaseName = "CheckSwitchPhase";
  protected fieldIndex: number;
  protected useName: boolean;

--- a/src/phases/command-phase.ts
+++ b/src/phases/command-phase.ts
@ -25,6 +25,7 @@ import { ArenaTagSide } from "#app/data/arena-tag";
 import { ArenaTagType } from "#app/enums/arena-tag-type";

 export class CommandPhase extends FieldPhase {
+  protected readonly phaseName = "CommandPhase";
  protected fieldIndex: number;

  constructor(fieldIndex: number) {
--- a/src/phases/common-anim-phase.ts
+++ b/src/phases/common-anim-phase.ts
@ -5,6 +5,9 @@ import { CommonBattleAnim } from "#app/data/battle-anims";
 import { PokemonPhase } from "./pokemon-phase";

 export class CommonAnimPhase extends PokemonPhase {
+  // PokemonHealPhase extends CommonAnimPhase, and to make typescript happy,
+  // we need to allow phaseName to be a union of the two
+  protected readonly phaseName: "CommonAnimPhase" | "PokemonHealPhase" | "WeatherEffectPhase" = "CommonAnimPhase";
  private anim: CommonAnim | null;
  private targetIndex?: BattlerIndex;
  private playOnEmptyField: boolean;
--- a/src/phases/damage-anim-phase.ts
+++ b/src/phases/damage-anim-phase.ts
@ -6,6 +6,7 @@ import { fixedInt } from "#app/utils/common";
 import { PokemonPhase } from "#app/phases/pokemon-phase";

 export class DamageAnimPhase extends PokemonPhase {
+  protected readonly phaseName = "DamageAnimPhase";
  private amount: number;
  private damageResult: DamageResult;
  private critical: boolean;
--- a/src/phases/egg-hatch-phase.ts
+++ b/src/phases/egg-hatch-phase.ts
@ -20,6 +20,7 @@ import { doShinySparkleAnim } from "#app/field/anims";
 * Class that represents egg hatching
 */
 export class EggHatchPhase extends Phase {
+  protected readonly phaseName = "EggHatchPhase";
  /** The egg that is hatching */
  private egg: Egg;
  /** The new EggHatchData for the egg/pokemon that hatches */
--- a/src/phases/egg-lapse-phase.ts
+++ b/src/phases/egg-lapse-phase.ts
@ -16,6 +16,7 @@ import { EggHatchData } from "#app/data/egg-hatch-data";
 * Also handles prompts for skipping animation, and calling the egg summary phase
 */
 export class EggLapsePhase extends Phase {
+  protected readonly phaseName = "EggLapsePhase";
  private eggHatchData: EggHatchData[] = [];
  private readonly minEggsToSkip: number = 2;

--- a/src/phases/egg-summary-phase.ts
+++ b/src/phases/egg-summary-phase.ts
@ -9,6 +9,7 @@ import type { EggHatchData } from "#app/data/egg-hatch-data";
 * Phase is handled mostly by the egg-hatch-scene-handler UI
 */
 export class EggSummaryPhase extends Phase {
+  protected readonly phaseName = "EggSummaryPhase";
  private eggHatchData: EggHatchData[];

  constructor(eggHatchData: EggHatchData[]) {
--- a/src/phases/encounter-phase.ts
+++ b/src/phases/encounter-phase.ts
@ -47,6 +47,7 @@ import { WEIGHT_INCREMENT_ON_SPAWN_MISS } from "#app/data/mystery-encounters/mys
 import { getNatureName } from "#app/data/nature";

 export class EncounterPhase extends BattlePhase {
+  protected readonly phaseName = "EncounterPhase";
  private loaded: boolean;

  constructor(loaded = false) {
--- a/src/phases/end-card-phase.ts
+++ b/src/phases/end-card-phase.ts
@ -5,6 +5,7 @@ import { addTextObject, TextStyle } from "#app/ui/text";
 import i18next from "i18next";

 export class EndCardPhase extends Phase {
+  protected readonly phaseName = "EndCardPhase";
  public endCard: Phaser.GameObjects.Image;
  public text: Phaser.GameObjects.Text;
  start(): void {
--- a/src/phases/end-evolution-phase.ts
+++ b/src/phases/end-evolution-phase.ts
@ -3,6 +3,7 @@ import { Phase } from "#app/phase";
 import { UiMode } from "#enums/ui-mode";

 export class EndEvolutionPhase extends Phase {
+  protected readonly phaseName = "EndEvolutionPhase";
  start() {
    super.start();

--- a/src/phases/enemy-command-phase.ts
+++ b/src/phases/enemy-command-phase.ts
@ -15,6 +15,7 @@ import { BattlerTagType } from "#enums/battler-tag-type";
 * @see {@linkcode EnemyPokemon.getNextMove}
 */
 export class EnemyCommandPhase extends FieldPhase {
+  protected readonly phaseName = "EnemyCommandPhase";
  protected fieldIndex: number;
  protected skipTurn = false;

--- a/src/phases/evolution-phase.ts
+++ b/src/phases/evolution-phase.ts
@ -19,6 +19,9 @@ import { EndEvolutionPhase } from "#app/phases/end-evolution-phase";
 import { EVOLVE_MOVE } from "#app/data/balance/pokemon-level-moves";

 export class EvolutionPhase extends Phase {
+  // FormChangePhase inherits from this, but EvolutionPhase is not abstract.
+  // We have to use the union here
+  protected readonly phaseName: "EvolutionPhase" | "FormChangePhase" = "EvolutionPhase";
  protected pokemon: PlayerPokemon;
  protected lastLevel: number;

--- a/src/phases/exp-phase.ts
+++ b/src/phases/exp-phase.ts
@ -7,6 +7,7 @@ import { PlayerPartyMemberPokemonPhase } from "./player-party-member-pokemon-pha
 import { LevelUpPhase } from "./level-up-phase";

 export class ExpPhase extends PlayerPartyMemberPokemonPhase {
+  protected readonly phaseName = "ExpPhase";
  private expValue: number;

  constructor(partyMemberIndex: number, expValue: number) {
--- a/src/phases/faint-phase.ts
+++ b/src/phases/faint-phase.ts
@ -35,6 +35,7 @@ import { FRIENDSHIP_LOSS_FROM_FAINT } from "#app/data/balance/starters";
 import { BattlerTagType } from "#enums/battler-tag-type";

 export class FaintPhase extends PokemonPhase {
+  protected readonly phaseName = "FaintPhase";
  /**
   * Whether or not instant revive should be prevented
   */
--- a/src/phases/form-change-phase.ts
+++ b/src/phases/form-change-phase.ts
@ -13,6 +13,7 @@ import { BattlerTagType } from "#enums/battler-tag-type";
 import { SpeciesFormKey } from "#enums/species-form-key";

 export class FormChangePhase extends EvolutionPhase {
+  protected readonly phaseName = "FormChangePhase";
  private formChange: SpeciesFormChange;
  private modal: boolean;

--- a/src/phases/game-over-modifier-reward-phase.ts
+++ b/src/phases/game-over-modifier-reward-phase.ts
@ -4,6 +4,7 @@ import i18next from "i18next";
 import { ModifierRewardPhase } from "./modifier-reward-phase";

 export class GameOverModifierRewardPhase extends ModifierRewardPhase {
+  protected readonly phaseName = "GameOverModifierRewardPhase";
  doReward(): Promise<void> {
    return new Promise<void>(resolve => {
      const newModifier = this.modifierType.newModifier();
--- a/src/phases/game-over-phase.ts
+++ b/src/phases/game-over-phase.ts
@ -34,6 +34,7 @@ import { pokerogueApi } from "#app/plugins/api/pokerogue-api";
 import { MessagePhase } from "./message-phase";

 export class GameOverPhase extends BattlePhase {
+  protected readonly phaseName = "GameOverPhase";
  private isVictory: boolean;
  private firstRibbons: PokemonSpecies[] = [];

--- a/src/phases/hide-ability-phase.ts
+++ b/src/phases/hide-ability-phase.ts
@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
 import { Phase } from "#app/phase";

 export class HideAbilityPhase extends Phase {
+  protected readonly phaseName = "HideAbilityPhase";
  start() {
    super.start();

--- a/src/phases/hide-party-exp-bar-phase.ts
+++ b/src/phases/hide-party-exp-bar-phase.ts
@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
 import { BattlePhase } from "./battle-phase";

 export class HidePartyExpBarPhase extends BattlePhase {
+  protected readonly phaseName = "HidePartyExpBarPhase";
  start() {
    super.start();

--- a/src/phases/learn-move-phase.ts
+++ b/src/phases/learn-move-phase.ts
@ -24,6 +24,7 @@ export enum LearnMoveType {
 }

 export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
+  protected readonly phaseName = "LearnMovePhase";
  private moveId: MoveId;
  private messageMode: UiMode;
  private learnMoveType: LearnMoveType;
--- a/src/phases/level-cap-phase.ts
+++ b/src/phases/level-cap-phase.ts
@ -4,6 +4,7 @@ import i18next from "i18next";
 import { FieldPhase } from "./field-phase";

 export class LevelCapPhase extends FieldPhase {
+  protected readonly phaseName = "LevelCapPhase";
  start(): void {
    super.start();

--- a/src/phases/level-up-phase.ts
+++ b/src/phases/level-up-phase.ts
@ -10,6 +10,7 @@ import { NumberHolder } from "#app/utils/common";
 import i18next from "i18next";

 export class LevelUpPhase extends PlayerPartyMemberPokemonPhase {
+  protected readonly phaseName = "LevelUpPhase";
  protected lastLevel: number;
  protected level: number;
  protected pokemon: PlayerPokemon = this.getPlayerPokemon();
--- a/src/phases/load-move-anim-phase.ts
+++ b/src/phases/load-move-anim-phase.ts
@ -8,6 +8,7 @@ import { Phase } from "#app/phase";
 * isn't already loaded (e.g. for Metronome)
 */
 export class LoadMoveAnimPhase extends Phase {
+  protected readonly phaseName = "LoadMoveAnimPhase";
  constructor(protected moveId: MoveId) {
    super();
  }
--- a/src/phases/login-phase.ts
+++ b/src/phases/login-phase.ts
@ -11,6 +11,7 @@ import { SelectGenderPhase } from "./select-gender-phase";
 import { UnavailablePhase } from "./unavailable-phase";

 export class LoginPhase extends Phase {
+  protected readonly phaseName = "LoginPhase";
  private showText: boolean;

  constructor(showText = true) {
--- a/src/phases/message-phase.ts
+++ b/src/phases/message-phase.ts
@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
 import { Phase } from "#app/phase";

 export class MessagePhase extends Phase {
+  protected readonly phaseName = "MessagePhase";
  private text: string;
  private callbackDelay?: number | null;
  private prompt?: boolean | null;
--- a/src/phases/modifier-reward-phase.ts
+++ b/src/phases/modifier-reward-phase.ts
@ -5,6 +5,9 @@ import i18next from "i18next";
 import { BattlePhase } from "./battle-phase";

 export class ModifierRewardPhase extends BattlePhase {
+  // RibbonModifierRewardPhase extends ModifierRewardPhase and to make typescript happy
+  // we need to use a union type here
+  protected readonly phaseName: "ModifierRewardPhase" | "RibbonModifierRewardPhase" = "ModifierRewardPhase";
  protected modifierType: ModifierType;

  constructor(modifierTypeFunc: ModifierTypeFunc) {
--- a/src/phases/money-reward-phase.ts
+++ b/src/phases/money-reward-phase.ts
@ -6,6 +6,7 @@ import { NumberHolder } from "#app/utils/common";
 import { BattlePhase } from "./battle-phase";

 export class MoneyRewardPhase extends BattlePhase {
+  protected readonly phaseName = "MoneyRewardPhase";
  private moneyMultiplier: number;

  constructor(moneyMultiplier: number) {
--- a/src/phases/move-anim-phase.ts
+++ b/src/phases/move-anim-phase.ts
@ -12,6 +12,8 @@ export class MoveAnimPhase<Anim extends MoveAnim> extends Phase {
    super();
  }

+  protected readonly phaseName = "MoveAnimPhase";
+
  public override start(): void {
    super.start();

--- a/src/phases/move-charge-phase.ts
+++ b/src/phases/move-charge-phase.ts
@ -16,6 +16,7 @@ import { MoveEndPhase } from "#app/phases/move-end-phase";
 * @extends {@linkcode PokemonPhase}
 */
 export class MoveChargePhase extends PokemonPhase {
+  protected readonly phaseName = "MoveChargePhase";
  /** The move instance that this phase applies */
  public move: PokemonMove;
  /** The field index targeted by the move (Charging moves assume single target) */
--- a/src/phases/move-effect-phase.ts
+++ b/src/phases/move-effect-phase.ts
@ -82,6 +82,7 @@ import { DamageAchv } from "#app/system/achv";
 type HitCheckEntry = [HitCheckResult, TypeDamageMultiplier];

 export class MoveEffectPhase extends PokemonPhase {
+  protected readonly phaseName = "MoveEffectPhase";
  public move: Move;
  private virtual = false;
  protected targets: BattlerIndex[];
--- a/src/phases/move-end-phase.ts
+++ b/src/phases/move-end-phase.ts
@ -6,6 +6,7 @@ import { applyPostSummonAbAttrs, PostSummonRemoveEffectAbAttr } from "#app/data/
 import type Pokemon from "#app/field/pokemon";

 export class MoveEndPhase extends PokemonPhase {
+  protected readonly phaseName = "MoveEndPhase";
  private wasFollowUp: boolean;

  /** Targets from the preceding MovePhase */
--- a/src/phases/move-header-phase.ts
+++ b/src/phases/move-header-phase.ts
@ -4,6 +4,7 @@ import type Pokemon from "#app/field/pokemon";
 import { BattlePhase } from "./battle-phase";

 export class MoveHeaderPhase extends BattlePhase {
+  protected readonly phaseName = "MoveHeaderPhase";
  public pokemon: Pokemon;
  public move: PokemonMove;

--- a/src/phases/move-phase.ts
+++ b/src/phases/move-phase.ts
@ -52,6 +52,7 @@ import { StatusEffect } from "#enums/status-effect";
 import i18next from "i18next";

 export class MovePhase extends BattlePhase {
+  protected readonly phaseName = "MovePhase";
  protected _pokemon: Pokemon;
  protected _move: PokemonMove;
  protected _targets: BattlerIndex[];
--- a/src/phases/mystery-encounter-phases.ts
+++ b/src/phases/mystery-encounter-phases.ts
@ -39,6 +39,7 @@ import { SelectBiomePhase } from "./select-biome-phase";
 * - Queuing of the {@linkcode MysteryEncounterOptionSelectedPhase}
 */
 export class MysteryEncounterPhase extends Phase {
+  protected readonly phaseName = "MysteryEncounterPhase";
  private readonly FIRST_DIALOGUE_PROMPT_DELAY = 300;
  optionSelectSettings?: OptionSelectSettings;

@ -180,6 +181,7 @@ export class MysteryEncounterPhase extends Phase {
 * Any phase that is meant to follow this one MUST be queued via the onOptionSelect() logic of the selected option
 */
 export class MysteryEncounterOptionSelectedPhase extends Phase {
+  protected readonly phaseName = "MysteryEncounterOptionSelectedPhase";
  onOptionSelect: OptionPhaseCallback;

  constructor() {
@ -221,6 +223,7 @@ export class MysteryEncounterOptionSelectedPhase extends Phase {
 * See {@linkcode TurnEndPhase} for more details
 */
 export class MysteryEncounterBattleStartCleanupPhase extends Phase {
+  protected readonly phaseName = "MysteryEncounterBattleStartCleanupPhase";
  /**
   * Cleans up `TURN_END` tags, any {@linkcode PostTurnStatusEffectPhase}s, checks for Pokemon switches, then continues
   */
@ -284,6 +287,7 @@ export class MysteryEncounterBattleStartCleanupPhase extends Phase {
 * - Queue the {@linkcode SummonPhase}s, {@linkcode PostSummonPhase}s, etc., required to initialize the phase queue for a battle
 */
 export class MysteryEncounterBattlePhase extends Phase {
+  protected readonly phaseName = "MysteryEncounterBattlePhase";
  disableSwitch: boolean;

  constructor(disableSwitch = false) {
@ -513,6 +517,7 @@ export class MysteryEncounterBattlePhase extends Phase {
 * - Queuing of the {@linkcode PostMysteryEncounterPhase}
 */
 export class MysteryEncounterRewardsPhase extends Phase {
+  protected readonly phaseName = "MysteryEncounterRewardsPhase";
  addHealPhase: boolean;

  constructor(addHealPhase = false) {
@ -580,6 +585,7 @@ export class MysteryEncounterRewardsPhase extends Phase {
 * - Queuing of the next wave
 */
 export class PostMysteryEncounterPhase extends Phase {
+  protected readonly phaseName = "PostMysteryEncounterPhase";
  private readonly FIRST_DIALOGUE_PROMPT_DELAY = 750;
  onPostOptionSelect?: OptionPhaseCallback;

--- a/src/phases/new-battle-phase.ts
+++ b/src/phases/new-battle-phase.ts
@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
 import { BattlePhase } from "./battle-phase";

 export class NewBattlePhase extends BattlePhase {
+  protected readonly phaseName = "NewBattlePhase";
  start() {
    super.start();

--- a/src/phases/new-biome-encounter-phase.ts
+++ b/src/phases/new-biome-encounter-phase.ts
@ -4,6 +4,7 @@ import { getRandomWeatherType } from "#app/data/weather";
 import { NextEncounterPhase } from "./next-encounter-phase";

 export class NewBiomeEncounterPhase extends NextEncounterPhase {
+  protected readonly phaseName = "NewBiomeEncounterPhase";
  doEncounter(): void {
    globalScene.playBgm(undefined, true);

--- a/src/phases/next-encounter-phase.ts
+++ b/src/phases/next-encounter-phase.ts
@ -6,6 +6,7 @@ import { EncounterPhase } from "./encounter-phase";
 * Handles generating, loading and preparing for it.
 */
 export class NextEncounterPhase extends EncounterPhase {
+  protected readonly phaseName = "NextEncounterPhase";
  start() {
    super.start();
  }
--- a/src/phases/obtain-status-effect-phase.ts
+++ b/src/phases/obtain-status-effect-phase.ts
@ -11,6 +11,7 @@ import { applyPostSetStatusAbAttrs, PostSetStatusAbAttr } from "#app/data/abilit
 import { isNullOrUndefined } from "#app/utils/common";

 export class ObtainStatusEffectPhase extends PokemonPhase {
+  protected readonly phaseName = "ObtainStatusEffectPhase";
  private statusEffect?: StatusEffect;
  private turnsRemaining?: number;
  private sourceText?: string | null;
--- a/src/phases/party-exp-phase.ts
+++ b/src/phases/party-exp-phase.ts
@ -6,6 +6,7 @@ import { Phase } from "#app/phase";
 * Intended to be used as a more 1-off phase to provide exp to the party (such as during MEs), rather than cleanup a battle entirely
 */
 export class PartyExpPhase extends Phase {
+  protected readonly phaseName = "PartyExpPhase";
  expValue: number;
  useWaveIndexMultiplier?: boolean;
  pokemonParticipantIds?: Set<number>;
--- a/src/phases/party-heal-phase.ts
+++ b/src/phases/party-heal-phase.ts
@ -3,6 +3,7 @@ import { fixedInt } from "#app/utils/common";
 import { BattlePhase } from "./battle-phase";

 export class PartyHealPhase extends BattlePhase {
+  protected readonly phaseName = "PartyHealPhase";
  private resumeBgm: boolean;

  constructor(resumeBgm: boolean) {
--- a/src/phases/pokemon-anim-phase.ts
+++ b/src/phases/pokemon-anim-phase.ts
@ -7,6 +7,7 @@ import { PokemonAnimType } from "#enums/pokemon-anim-type";
 import { SpeciesId } from "#enums/species-id";

 export class PokemonAnimPhase extends BattlePhase {
+  protected readonly phaseName = "PokemonAnimPhase";
  /** The type of animation to play in this phase */
  protected key: PokemonAnimType;
  /** The Pokemon to which this animation applies */
--- a/src/phases/pokemon-heal-phase.ts
+++ b/src/phases/pokemon-heal-phase.ts
@ -14,6 +14,7 @@ import { BattlerTagType } from "#app/enums/battler-tag-type";
 import type { HealBlockTag } from "#app/data/battler-tags";

 export class PokemonHealPhase extends CommonAnimPhase {
+  protected readonly phaseName = "PokemonHealPhase";
  private hpHealed: number;
  private message: string | null;
  private showFullHpMessage: boolean;
--- a/src/phases/pokemon-transform-phase.ts
+++ b/src/phases/pokemon-transform-phase.ts
@ -13,6 +13,7 @@ import i18next from "i18next";
 * Used for Transform (move) and Imposter (ability)
 */
 export class PokemonTransformPhase extends PokemonPhase {
+  protected readonly phaseName = "PokemonTransformPhase";
  protected targetIndex: BattlerIndex;
  private playSound: boolean;

--- a/src/phases/post-game-over-phase.ts
+++ b/src/phases/post-game-over-phase.ts
@ -4,6 +4,7 @@ import type { EndCardPhase } from "./end-card-phase";
 import { TitlePhase } from "./title-phase";

 export class PostGameOverPhase extends Phase {
+  protected readonly phaseName = "PostGameOverPhase";
  private endCardPhase?: EndCardPhase;

  constructor(endCardPhase?: EndCardPhase) {
--- a/src/phases/post-summon-phase.ts
+++ b/src/phases/post-summon-phase.ts
@ -7,6 +7,7 @@ import { MysteryEncounterPostSummonTag } from "#app/data/battler-tags";
 import { BattlerTagType } from "#enums/battler-tag-type";

 export class PostSummonPhase extends PokemonPhase {
+  protected readonly phaseName = "PostSummonPhase";
  start() {
    super.start();

--- a/src/phases/post-turn-status-effect-phase.ts
+++ b/src/phases/post-turn-status-effect-phase.ts
@ -17,6 +17,7 @@ import { BooleanHolder, NumberHolder } from "#app/utils/common";
 import { PokemonPhase } from "./pokemon-phase";

 export class PostTurnStatusEffectPhase extends PokemonPhase {
+  protected readonly phaseName = "PostTurnStatusEffectPhase";
  // biome-ignore lint/complexity/noUselessConstructor: Not unnecessary as it makes battlerIndex required
  constructor(battlerIndex: BattlerIndex) {
    super(battlerIndex);
--- a/src/phases/quiet-form-change-phase.ts
+++ b/src/phases/quiet-form-change-phase.ts
@ -19,6 +19,7 @@ import {
 } from "#app/data/abilities/ability";

 export class QuietFormChangePhase extends BattlePhase {
+  protected readonly phaseName = "QuietFormChangePhase";
  protected pokemon: Pokemon;
  protected formChange: SpeciesFormChange;

--- a/src/phases/reload-session-phase.ts
+++ b/src/phases/reload-session-phase.ts
@ -4,6 +4,7 @@ import { UiMode } from "#enums/ui-mode";
 import { fixedInt } from "#app/utils/common";

 export class ReloadSessionPhase extends Phase {
+  protected readonly phaseName = "ReloadSessionPhase";
  private systemDataStr?: string;

  constructor(systemDataStr?: string) {
--- a/src/phases/reset-status-phase.ts
+++ b/src/phases/reset-status-phase.ts
@ -7,6 +7,7 @@ import { BattlePhase } from "#app/phases/battle-phase";
 * This is necessary to perform in a phase primarly to ensure that the status icon disappears at the correct time in the battle
 */
 export class ResetStatusPhase extends BattlePhase {
+  protected readonly phaseName = "ResetStatusPhase";
  private readonly pokemon: Pokemon;
  private readonly affectConfusion: boolean;
  private readonly reloadAssets: boolean;
--- a/src/phases/return-phase.ts
+++ b/src/phases/return-phase.ts
@ -4,6 +4,7 @@ import { SwitchType } from "#enums/switch-type";
 import { SwitchSummonPhase } from "./switch-summon-phase";

 export class ReturnPhase extends SwitchSummonPhase {
+  protected readonly phaseName = "ReturnPhase";
  constructor(fieldIndex: number) {
    super(SwitchType.SWITCH, fieldIndex, -1, true);
  }
--- a/src/phases/revival-blessing-phase.ts
+++ b/src/phases/revival-blessing-phase.ts
@ -15,6 +15,7 @@ import type { PlayerPokemon } from "#app/field/pokemon";
 * when used by one of the player's Pokemon.
 */
 export class RevivalBlessingPhase extends BattlePhase {
+  protected readonly phaseName = "RevivalBlessingPhase";
  constructor(protected user: PlayerPokemon) {
    super();
  }
--- a/src/phases/ribbon-modifier-reward-phase.ts
+++ b/src/phases/ribbon-modifier-reward-phase.ts
@ -6,6 +6,7 @@ import i18next from "i18next";
 import { ModifierRewardPhase } from "./modifier-reward-phase";

 export class RibbonModifierRewardPhase extends ModifierRewardPhase {
+  protected readonly phaseName = "RibbonModifierRewardPhase";
  private species: PokemonSpecies;

  constructor(modifierTypeFunc: ModifierTypeFunc, species: PokemonSpecies) {
--- a/src/phases/scan-ivs-phase.ts
+++ b/src/phases/scan-ivs-phase.ts
@ -8,6 +8,7 @@ import i18next from "i18next";
 import { PokemonPhase } from "./pokemon-phase";

 export class ScanIvsPhase extends PokemonPhase {
+  protected readonly phaseName = "ScanIvsPhase";
  // biome-ignore lint/complexity/noUselessConstructor: This changes `battlerIndex` to be required
  constructor(battlerIndex: BattlerIndex) {
    super(battlerIndex);
--- a/src/phases/select-biome-phase.ts
+++ b/src/phases/select-biome-phase.ts
@ -10,6 +10,7 @@ import { PartyHealPhase } from "./party-heal-phase";
 import { SwitchBiomePhase } from "./switch-biome-phase";

 export class SelectBiomePhase extends BattlePhase {
+  protected readonly phaseName = "SelectBiomePhase";
  start() {
    super.start();

--- a/src/phases/select-challenge-phase.ts
+++ b/src/phases/select-challenge-phase.ts
@ -3,6 +3,7 @@ import { Phase } from "#app/phase";
 import { UiMode } from "#enums/ui-mode";

 export class SelectChallengePhase extends Phase {
+  protected readonly phaseName = "SelectChallengePhase";
  start() {
    super.start();

--- a/src/phases/select-gender-phase.ts
+++ b/src/phases/select-gender-phase.ts
@ -6,6 +6,7 @@ import { UiMode } from "#enums/ui-mode";
 import i18next from "i18next";

 export class SelectGenderPhase extends Phase {
+  protected readonly phaseName = "SelectGenderPhase";
  start(): void {
    super.start();

--- a/src/phases/select-modifier-phase.ts
+++ b/src/phases/select-modifier-phase.ts
@ -32,6 +32,7 @@ import type { CustomModifierSettings } from "#app/modifier/modifier-type";
 import { isNullOrUndefined, NumberHolder } from "#app/utils/common";

 export class SelectModifierPhase extends BattlePhase {
+  protected readonly phaseName = "SelectModifierPhase";
  private rerollCount: number;
  private modifierTiers?: ModifierTier[];
  private customModifierSettings?: CustomModifierSettings;
--- a/src/phases/select-starter-phase.ts
+++ b/src/phases/select-starter-phase.ts
@ -15,6 +15,7 @@ import SoundFade from "phaser3-rex-plugins/plugins/soundfade";
 import { isNullOrUndefined } from "#app/utils/common";

 export class SelectStarterPhase extends Phase {
+  protected readonly phaseName = "SelectStarterPhase";
  start() {
    super.start();

--- a/src/phases/select-target-phase.ts
+++ b/src/phases/select-target-phase.ts
@ -8,6 +8,7 @@ import i18next from "#app/plugins/i18n";
 import { allMoves } from "#app/data/data-lists";

 export class SelectTargetPhase extends PokemonPhase {
+  protected readonly phaseName = "SelectTargetPhase";
  // biome-ignore lint/complexity/noUselessConstructor: This makes `fieldIndex` required
  constructor(fieldIndex: number) {
    super(fieldIndex);
--- a/src/phases/shiny-sparkle-phase.ts
+++ b/src/phases/shiny-sparkle-phase.ts
@ -3,6 +3,7 @@ import type { BattlerIndex } from "#app/battle";
 import { PokemonPhase } from "./pokemon-phase";

 export class ShinySparklePhase extends PokemonPhase {
+  protected readonly phaseName = "ShinySparklePhase";
  // biome-ignore lint/complexity/noUselessConstructor: This makes `battlerIndex` required
  constructor(battlerIndex: BattlerIndex) {
    super(battlerIndex);
--- a/src/phases/show-ability-phase.ts
+++ b/src/phases/show-ability-phase.ts
@ -5,6 +5,7 @@ import { getPokemonNameWithAffix } from "#app/messages";
 import { HideAbilityPhase } from "#app/phases/hide-ability-phase";

 export class ShowAbilityPhase extends PokemonPhase {
+  protected readonly phaseName = "ShowAbilityPhase";
  private passive: boolean;
  private pokemonName: string;
  private abilityName: string;
--- a/src/phases/show-party-exp-bar-phase.ts
+++ b/src/phases/show-party-exp-bar-phase.ts
@ -8,6 +8,7 @@ import { LevelUpPhase } from "./level-up-phase";
 import { PlayerPartyMemberPokemonPhase } from "./player-party-member-pokemon-phase";

 export class ShowPartyExpBarPhase extends PlayerPartyMemberPokemonPhase {
+  protected readonly phaseName = "ShowPartyExpBarPhase";
  private expValue: number;

  constructor(partyMemberIndex: number, expValue: number) {
--- a/src/phases/show-trainer-phase.ts
+++ b/src/phases/show-trainer-phase.ts
@ -3,6 +3,7 @@ import { PlayerGender } from "#app/enums/player-gender";
 import { BattlePhase } from "./battle-phase";

 export class ShowTrainerPhase extends BattlePhase {
+  protected readonly phaseName = "ShowTrainerPhase";
  start() {
    super.start();

--- a/src/phases/stat-stage-change-phase.ts
+++ b/src/phases/stat-stage-change-phase.ts
@ -31,6 +31,7 @@ export type StatStageChangeCallback = (
 ) => void;

 export class StatStageChangePhase extends PokemonPhase {
+  protected readonly phaseName = "StatStageChangePhase";
  private stats: BattleStat[];
  private selfTarget: boolean;
  private stages: number;
--- a/src/phases/summon-missing-phase.ts
+++ b/src/phases/summon-missing-phase.ts
@ -4,6 +4,7 @@ import { SummonPhase } from "./summon-phase";
 import { globalScene } from "#app/global-scene";

 export class SummonMissingPhase extends SummonPhase {
+  protected readonly phaseName = "SummonMissingPhase";
  preSummon(): void {
    globalScene.ui.showText(
      i18next.t("battle:sendOutPokemon", {
--- a/src/phases/summon-phase.ts
+++ b/src/phases/summon-phase.ts
@ -17,6 +17,9 @@ import { applyPreSummonAbAttrs, PreSummonAbAttr } from "#app/data/abilities/abil
 import { globalScene } from "#app/global-scene";

 export class SummonPhase extends PartyMemberPokemonPhase {
+  // Both SwitchSummonPhase and SummonMissingPhase extend this class and so we must use a
+  // union type to make typescript happy.
+  protected readonly phaseName: "SummonPhase" | "SummonMissingPhase" | "SwitchSummonPhase" = "SummonPhase";
  private loaded: boolean;

  constructor(fieldIndex: number, player = true, loaded = false) {
--- a/src/phases/switch-biome-phase.ts
+++ b/src/phases/switch-biome-phase.ts
@ -4,6 +4,7 @@ import { getBiomeKey } from "#app/field/arena";
 import { BattlePhase } from "./battle-phase";

 export class SwitchBiomePhase extends BattlePhase {
+  protected readonly phaseName = "SwitchBiomePhase";
  private nextBiome: BiomeId;

  constructor(nextBiome: BiomeId) {
--- a/src/phases/switch-phase.ts
+++ b/src/phases/switch-phase.ts
@ -11,6 +11,7 @@ import { SwitchSummonPhase } from "./switch-summon-phase";
 * for the player (if a switch would be valid for the current battle state).
 */
 export class SwitchPhase extends BattlePhase {
+  protected readonly phaseName = "SwitchPhase";
  protected readonly fieldIndex: number;
  private readonly switchType: SwitchType;
  private readonly isModal: boolean;
--- a/src/phases/switch-summon-phase.ts
+++ b/src/phases/switch-summon-phase.ts
@ -22,6 +22,7 @@ import { SubstituteTag } from "#app/data/battler-tags";
 import { SwitchType } from "#enums/switch-type";

 export class SwitchSummonPhase extends SummonPhase {
+  protected readonly phaseName = "SwitchSummonPhase";
  private readonly switchType: SwitchType;
  private readonly slotIndex: number;
  private readonly doReturn: boolean;
--- a/src/phases/tera-phase.ts
+++ b/src/phases/tera-phase.ts
@ -9,6 +9,7 @@ import { SpeciesFormChangeTeraTrigger } from "#app/data/pokemon-forms";
 import { CommonAnim, CommonBattleAnim } from "#app/data/battle-anims";

 export class TeraPhase extends BattlePhase {
+  protected readonly phaseName = "TeraPhase";
  public pokemon: Pokemon;

  constructor(pokemon: Pokemon) {
--- a/src/phases/title-phase.ts
+++ b/src/phases/title-phase.ts
@ -29,6 +29,7 @@ import { globalScene } from "#app/global-scene";
 import Overrides from "#app/overrides";

 export class TitlePhase extends Phase {
+  protected readonly phaseName = "TitlePhase";
  private loaded = false;
  private lastSessionData: SessionSaveData;
  public gameMode: GameModes;
--- a/src/phases/toggle-double-position-phase.ts
+++ b/src/phases/toggle-double-position-phase.ts
@ -3,6 +3,7 @@ import { FieldPosition } from "#app/field/pokemon";
 import { BattlePhase } from "./battle-phase";

 export class ToggleDoublePositionPhase extends BattlePhase {
+  protected readonly phaseName = "ToggleDoublePositionPhase";
  private double: boolean;

  constructor(double: boolean) {
--- a/src/phases/trainer-victory-phase.ts
+++ b/src/phases/trainer-victory-phase.ts
@ -14,6 +14,7 @@ import { achvs } from "#app/system/achv";
 import { timedEventManager } from "#app/global-event-manager";

 export class TrainerVictoryPhase extends BattlePhase {
+  protected readonly phaseName = "TrainerVictoryPhase";
  start() {
    globalScene.disableMenu = true;

--- a/src/phases/turn-end-phase.ts
+++ b/src/phases/turn-end-phase.ts
@ -18,6 +18,7 @@ import { PokemonHealPhase } from "./pokemon-heal-phase";
 import { globalScene } from "#app/global-scene";

 export class TurnEndPhase extends FieldPhase {
+  protected readonly phaseName = "TurnEndPhase";
  start() {
    super.start();

--- a/src/phases/turn-init-phase.ts
+++ b/src/phases/turn-init-phase.ts
@ -15,6 +15,7 @@ import { TurnStartPhase } from "./turn-start-phase";
 import { globalScene } from "#app/global-scene";

 export class TurnInitPhase extends FieldPhase {
+  protected readonly phaseName = "TurnInitPhase";
  start() {
    super.start();

--- a/src/phases/turn-start-phase.ts
+++ b/src/phases/turn-start-phase.ts
@ -25,6 +25,7 @@ import { globalScene } from "#app/global-scene";
 import { TeraPhase } from "./tera-phase";

 export class TurnStartPhase extends FieldPhase {
+  protected readonly phaseName = "TurnStartPhase";
  /**
   * This orders the active Pokemon on the field by speed into an BattlerIndex array and returns that array.
   * It also checks for Trick Room and reverses the array if it is present.
--- a/src/phases/unavailable-phase.ts
+++ b/src/phases/unavailable-phase.ts
@ -4,6 +4,7 @@ import { UiMode } from "#enums/ui-mode";
 import { LoginPhase } from "./login-phase";

 export class UnavailablePhase extends Phase {
+  protected readonly phaseName = "UnavailablePhase";
  start(): void {
    globalScene.ui.setMode(UiMode.UNAVAILABLE, () => {
      globalScene.unshiftPhase(new LoginPhase(true));
--- a/src/phases/unlock-phase.ts
+++ b/src/phases/unlock-phase.ts
@ -6,6 +6,7 @@ import { UiMode } from "#enums/ui-mode";
 import i18next from "i18next";

 export class UnlockPhase extends Phase {
+  protected readonly phaseName = "UnlockPhase";
  private unlockable: Unlockables;

  constructor(unlockable: Unlockables) {
--- a/src/phases/victory-phase.ts
+++ b/src/phases/victory-phase.ts
@ -18,6 +18,7 @@ import { timedEventManager } from "#app/global-event-manager";
 import { SelectBiomePhase } from "./select-biome-phase";

 export class VictoryPhase extends PokemonPhase {
+  protected readonly phaseName = "VictoryPhase";
  /** If true, indicates that the phase is intended for EXP purposes only, and not to continue a battle to next phase */
  isExpOnly: boolean;

--- a/src/phases/weather-effect-phase.ts
+++ b/src/phases/weather-effect-phase.ts
@ -19,6 +19,7 @@ import { BooleanHolder, toDmgValue } from "#app/utils/common";
 import { CommonAnimPhase } from "./common-anim-phase";

 export class WeatherEffectPhase extends CommonAnimPhase {
+  protected readonly phaseName = "WeatherEffectPhase";
  public weather: Weather | null;

  constructor() {