Merge branch 'beta' into WorkingDiscardFunction

src/@types/battler-tags.ts

@@ -0,0 +1,119 @@
+// biome-ignore-start lint/correctness/noUnusedImports: Used in a TSDoc comment
+import type { AbilityBattlerTag, BattlerTagTypeMap, SerializableBattlerTag, TypeBoostTag } from "#data/battler-tags";
+import type { AbilityId } from "#enums/ability-id";
+// biome-ignore-end lint/correctness/noUnusedImports: end
+import type { BattlerTagType } from "#enums/battler-tag-type";
+
+/**
+ * Subset of {@linkcode BattlerTagType}s that restrict the use of moves.
+ */
+export type MoveRestrictionBattlerTagType =
+  | BattlerTagType.THROAT_CHOPPED
+  | BattlerTagType.TORMENT
+  | BattlerTagType.TAUNT
+  | BattlerTagType.IMPRISON
+  | BattlerTagType.HEAL_BLOCK
+  | BattlerTagType.ENCORE
+  | BattlerTagType.DISABLED
+  | BattlerTagType.GORILLA_TACTICS;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s that block damage from moves.
+ */
+export type FormBlockDamageBattlerTagType = BattlerTagType.ICE_FACE | BattlerTagType.DISGUISE;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s that are related to trapping effects.
+ */
+export type TrappingBattlerTagType =
+  | BattlerTagType.BIND
+  | BattlerTagType.WRAP
+  | BattlerTagType.FIRE_SPIN
+  | BattlerTagType.WHIRLPOOL
+  | BattlerTagType.CLAMP
+  | BattlerTagType.SAND_TOMB
+  | BattlerTagType.MAGMA_STORM
+  | BattlerTagType.SNAP_TRAP
+  | BattlerTagType.THUNDER_CAGE
+  | BattlerTagType.INFESTATION
+  | BattlerTagType.INGRAIN
+  | BattlerTagType.OCTOLOCK
+  | BattlerTagType.NO_RETREAT;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s that are related to protection effects.
+ */
+export type ProtectionBattlerTagType = BattlerTagType.PROTECTED | BattlerTagType.SPIKY_SHIELD | DamageProtectedTagType;
+/**
+ * Subset of {@linkcode BattlerTagType}s related to protection effects that block damage but not status moves.
+ */
+export type DamageProtectedTagType = ContactSetStatusProtectedTagType | ContactStatStageChangeProtectedTagType;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s related to protection effects that set a status effect on the attacker.
+ */
+export type ContactSetStatusProtectedTagType = BattlerTagType.BANEFUL_BUNKER | BattlerTagType.BURNING_BULWARK;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s related to protection effects that change stat stages of the attacker.
+ */
+export type ContactStatStageChangeProtectedTagType =
+  | BattlerTagType.KINGS_SHIELD
+  | BattlerTagType.SILK_TRAP
+  | BattlerTagType.OBSTRUCT;
+
+/** Subset of {@linkcode BattlerTagType}s that provide the Endure effect */
+export type EndureTagType = BattlerTagType.ENDURE_TOKEN | BattlerTagType.ENDURING;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s that are related to semi-invulnerable states.
+ */
+export type SemiInvulnerableTagType =
+  | BattlerTagType.FLYING
+  | BattlerTagType.UNDERGROUND
+  | BattlerTagType.UNDERWATER
+  | BattlerTagType.HIDDEN;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s corresponding to {@linkcode AbilityBattlerTag}s
+ *
+ * @remarks
+ * ⚠️ {@linkcode AbilityId.FLASH_FIRE | Flash Fire}'s {@linkcode BattlerTagType.FIRE_BOOST} is not included as it
+ * subclasses {@linkcode TypeBoostTag} and not `AbilityBattlerTag`.
+ */
+export type AbilityBattlerTagType =
+  | BattlerTagType.PROTOSYNTHESIS
+  | BattlerTagType.QUARK_DRIVE
+  | BattlerTagType.UNBURDEN
+  | BattlerTagType.SLOW_START
+  | BattlerTagType.TRUANT;
+
+/**
+ * Subset of {@linkcode BattlerTagType}s related to abilities that boost the highest stat.
+ */
+export type HighestStatBoostTagType =
+  | BattlerTagType.QUARK_DRIVE // formatting
+  | BattlerTagType.PROTOSYNTHESIS;
+/**
+ * Subset of {@linkcode BattlerTagType}s that are able to persist between turns and should therefore be serialized
+ */
+export type SerializableBattlerTagType = keyof {
+  [K in keyof BattlerTagTypeMap as BattlerTagTypeMap[K] extends SerializableBattlerTag
+    ? K
+    : never]: BattlerTagTypeMap[K];
+};
+
+/**
+ * Subset of {@linkcode BattlerTagType}s that are not able to persist across waves and should therefore not be serialized
+ */
+export type NonSerializableBattlerTagType = Exclude<BattlerTagType, SerializableBattlerTagType>;
+
+/**
+ * Dummy, typescript-only declaration to ensure that
+ * {@linkcode BattlerTagTypeMap} has an entry for all `BattlerTagType`s.
+ *
+ * If a battler tag is missing from the map, Typescript will throw an error on this statement.
+ *
+ * ⚠️ Does not actually exist at runtime, so it must not be used!
+ */
+declare const EnsureAllBattlerTagTypesAreMapped: BattlerTagTypeMap[BattlerTagType] & never;

src/data/moves/move.ts

@@ -10800,7 +10800,7 @@ export function initMoves() {
     new SelfStatusMove(MoveId.NO_RETREAT, PokemonType.FIGHTING, -1, 5, -1, 0, 8)
       .attr(StatStageChangeAttr, [ Stat.ATK, Stat.DEF, Stat.SPATK, Stat.SPDEF, Stat.SPD ], 1, true)
       .attr(AddBattlerTagAttr, BattlerTagType.NO_RETREAT, true, false)
-      .condition((user, target, move) => user.getTag(TrappedTag)?.sourceMove !== MoveId.NO_RETREAT), // fails if the user is currently trapped by No Retreat
+      .condition((user, target, move) => user.getTag(TrappedTag)?.tagType !== BattlerTagType.NO_RETREAT), // fails if the user is currently trapped by No Retreat
     new StatusMove(MoveId.TAR_SHOT, PokemonType.ROCK, 100, 15, -1, 0, 8)
       .attr(StatStageChangeAttr, [ Stat.SPD ], -1)
       .attr(AddBattlerTagAttr, BattlerTagType.TAR_SHOT, false)

src/data/pokemon/pokemon-data.ts

@@ -1,4 +1,5 @@
-import { type BattlerTag, loadBattlerTag } from "#data/battler-tags";
+import type { BattlerTag } from "#data/battler-tags";
+import { loadBattlerTag, SerializableBattlerTag } from "#data/battler-tags";
 import { allSpecies } from "#data/data-lists";
 import type { Gender } from "#data/gender";
 import { PokemonMove } from "#data/moves/pokemon-move";
@@ -187,9 +188,11 @@ export class PokemonSummonData {
         continue;
       }
 
-      if (key === "tags") {
-        // load battler tags
-        this.tags = value.map((t: BattlerTag) => loadBattlerTag(t));
+      if (key === "tags" && Array.isArray(value)) {
+        // load battler tags, discarding any that are not serializable
+        this.tags = value
+          .map((t: SerializableBattlerTag) => loadBattlerTag(t))
+          .filter((t): t is SerializableBattlerTag => t instanceof SerializableBattlerTag);
         continue;
       }
       this[key] = value;

src/enums/battler-tag-type.ts

@@ -1,5 +1,4 @@
 export enum BattlerTagType {
-  NONE = "NONE",
   RECHARGING = "RECHARGING",
   FLINCHED = "FLINCHED",
   INTERRUPTED = "INTERRUPTED",

src/phase-manager.ts

@@ -9,6 +9,7 @@ import { AttemptCapturePhase } from "#phases/attempt-capture-phase";
 import { AttemptRunPhase } from "#phases/attempt-run-phase";
 import { BattleEndPhase } from "#phases/battle-end-phase";
 import { BerryPhase } from "#phases/berry-phase";
+import { CheckInterludePhase } from "#phases/check-interlude-phase";
 import { CheckStatusEffectPhase } from "#phases/check-status-effect-phase";
 import { CheckSwitchPhase } from "#phases/check-switch-phase";
 import { CommandPhase } from "#phases/command-phase";
@@ -121,6 +122,7 @@ const PHASES = Object.freeze({
   AttemptRunPhase,
   BattleEndPhase,
   BerryPhase,
+  CheckInterludePhase,
   CheckStatusEffectPhase,
   CheckSwitchPhase,
   CommandPhase,
@@ -665,4 +667,15 @@ export class PhaseManager {
   ): void {
     this.startDynamicPhase(this.create(phase, ...args));
   }
+
+  /** Prevents end of turn effects from triggering when transitioning to a new biome on a X0 wave */
+  public onInterlude(): void {
+    const phasesToRemove = ["WeatherEffectPhase", "BerryPhase", "CheckStatusEffectPhase"];
+    this.phaseQueue = this.phaseQueue.filter(p => !phasesToRemove.includes(p.phaseName));
+
+    const turnEndPhase = this.findPhase<TurnEndPhase>(p => p.phaseName === "TurnEndPhase");
+    if (turnEndPhase) {
+      turnEndPhase.upcomingInterlude = true;
+    }
+  }
 }

src/phases/check-interlude-phase.ts

@@ -0,0 +1,18 @@
+import { globalScene } from "#app/global-scene";
+import { Phase } from "#app/phase";
+
+export class CheckInterludePhase extends Phase {
+  public override readonly phaseName = "CheckInterludePhase";
+
+  public override start(): void {
+    super.start();
+    const { phaseManager } = globalScene;
+    const { waveIndex } = globalScene.currentBattle;
+
+    if (waveIndex % 10 === 0 && globalScene.getEnemyParty().every(p => p.isFainted())) {
+      phaseManager.onInterlude();
+    }
+
+    this.end();
+  }
+}

src/phases/turn-end-phase.ts

@@ -18,6 +18,8 @@ import i18next from "i18next";
 
 export class TurnEndPhase extends FieldPhase {
   public readonly phaseName = "TurnEndPhase";
+  public upcomingInterlude = false;
+
   start() {
     super.start();
 
@@ -59,9 +61,11 @@ export class TurnEndPhase extends FieldPhase {
       pokemon.tempSummonData.waveTurnCount++;
     };
 
-    this.executeForAll(handlePokemon);
+    if (!this.upcomingInterlude) {
+      this.executeForAll(handlePokemon);
 
-    globalScene.arena.lapseTags();
+      globalScene.arena.lapseTags();
+    }
 
     if (globalScene.arena.weather && !globalScene.arena.weather.lapse()) {
       globalScene.arena.trySetWeather(WeatherType.NONE);

src/phases/turn-start-phase.ts

@@ -218,6 +218,7 @@ export class TurnStartPhase extends FieldPhase {
           break;
       }
     }
+    phaseManager.pushNew("CheckInterludePhase");
 
     phaseManager.pushNew("WeatherEffectPhase");
     phaseManager.pushNew("BerryPhase");
@@ -227,10 +228,10 @@ export class TurnStartPhase extends FieldPhase {
 
     phaseManager.pushNew("TurnEndPhase");
 
-    /**
-     * this.end() will call shiftPhase(), which dumps everything from PrependQueue (aka everything that is unshifted()) to the front
-     * of the queue and dequeues to start the next phase
-     * this is important since stuff like SwitchSummon, AttemptRun, AttemptCapture Phases break the "flow" and should take precedence
+    /*
+     * `this.end()` will call `PhaseManager#shiftPhase()`, which dumps everything from `phaseQueuePrepend`
+     * (aka everything that is queued via `unshift()`) to the front of the queue and dequeues to start the next phase.
+     * This is important since stuff like `SwitchSummonPhase`, `AttemptRunPhase`, and `AttemptCapturePhase` break the "flow" and should take precedence
      */
     this.end();
   }

test/phases/check-interlude-phase.test.ts

@@ -0,0 +1,63 @@
+import { AbilityId } from "#enums/ability-id";
+import { BerryType } from "#enums/berry-type";
+import { MoveId } from "#enums/move-id";
+import { SpeciesId } from "#enums/species-id";
+import { WeatherType } from "#enums/weather-type";
+import { GameManager } from "#test/test-utils/game-manager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Check Biome End Phase", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+
+  beforeAll(() => {
+    phaserGame = new Phaser.Game({
+      type: Phaser.HEADLESS,
+    });
+  });
+
+  afterEach(() => {
+    game.phaseInterceptor.restoreOg();
+  });
+
+  beforeEach(() => {
+    game = new GameManager(phaserGame);
+    game.override
+      .enemySpecies(SpeciesId.MAGIKARP)
+      .enemyMoveset(MoveId.SPLASH)
+      .enemyAbility(AbilityId.BALL_FETCH)
+      .ability(AbilityId.BALL_FETCH)
+      .startingLevel(100)
+      .battleStyle("single");
+  });
+
+  it("should not trigger end of turn effects when defeating the final pokemon of a biome in classic", async () => {
+    game.override
+      .startingWave(10)
+      .weather(WeatherType.SANDSTORM)
+      .startingHeldItems([{ name: "BERRY", type: BerryType.SITRUS }]);
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    const player = game.field.getPlayerPokemon();
+
+    player.hp = 1;
+
+    game.move.use(MoveId.EXTREME_SPEED);
+    await game.toEndOfTurn();
+
+    expect(player.hp).toBe(1);
+  });
+
+  it("should not prevent end of turn effects when transitioning waves within a biome", async () => {
+    game.override.weather(WeatherType.SANDSTORM);
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    const player = game.field.getPlayerPokemon();
+
+    game.move.use(MoveId.EXTREME_SPEED);
+    await game.toEndOfTurn();
+
+    expect(player.hp).toBeLessThan(player.getMaxHp());
+  });
+});