Merge b57788b908 into b2990aaa15

Rename run name field, don't encrypt before updating

CONTRIBUTING.md

@@ -81,7 +81,7 @@ For example, here is how you could test a scenario where the player Pokemon has
 ```typescript
 const overrides = {
   ABILITY_OVERRIDE: AbilityId.DROUGHT,
-  OPP_MOVESET_OVERRIDE: MoveId.WATER_GUN,
+  ENEMY_MOVESET_OVERRIDE: MoveId.WATER_GUN,
 } satisfies Partial<InstanceType<typeof DefaultOverrides>>;
 ```
 

package.json

@@ -29,6 +29,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.0.0",
     "@ls-lint/ls-lint": "2.3.1",
+    "@types/crypto-js": "^4.2.0",
     "@types/jsdom": "^21.1.7",
     "@types/node": "^22.16.5",
     "@vitest/coverage-istanbul": "^3.2.4",

pnpm-lock.yaml

@@ -48,6 +48,9 @@ importers:
       '@ls-lint/ls-lint':
         specifier: 2.3.1
         version: 2.3.1
+      '@types/crypto-js':
+        specifier: ^4.2.0
+        version: 4.2.2
       '@types/jsdom':
         specifier: ^21.1.7
         version: 21.1.7
@@ -718,6 +721,9 @@ packages:
   '@types/cookie@0.6.0':
     resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==}
 
+  '@types/crypto-js@4.2.2':
+    resolution: {integrity: sha512-sDOLlVbHhXpAUAL0YHDUUwDZf3iN4Bwi4W6a0W0b+QcAezUbRtH4FVb+9J4h+XFPW7l/gQ9F8qC7P+Ec4k8QVQ==}
+
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
@@ -2525,6 +2531,8 @@ snapshots:
 
   '@types/cookie@0.6.0': {}
 
+  '@types/crypto-js@4.2.2': {}
+
   '@types/deep-eql@4.0.2': {}
 
   '@types/estree@1.0.8': {}

public/images/ui/party_slot_main_short.json

@@ -0,0 +1,146 @@
+{
+	"textures": [
+		{
+			"image": "party_slot_main_short.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 110,
+				"h": 294
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "party_slot_main_short",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 110,
+						"h": 41
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					}
+				},
+				{
+					"filename": "party_slot_main_short_sel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 110,
+						"h": 41
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					},
+					"frame": {
+						"x": 0,
+						"y": 41,
+						"w": 110,
+						"h": 41
+					}
+				},
+				{
+					"filename": "party_slot_main_short_fnt",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 110,
+						"h": 41
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					},
+					"frame": {
+						"x": 0,
+						"y": 82,
+						"w": 110,
+						"h": 41
+					}
+				},
+				{
+					"filename": "party_slot_main_short_fnt_sel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 110,
+						"h": 41
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					},
+					"frame": {
+						"x": 0,
+						"y": 123,
+						"w": 110,
+						"h": 41
+					}
+				},
+				{
+					"filename": "party_slot_main_short_swap",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 110,
+						"h": 41
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					},
+					"frame": {
+						"x": 0,
+						"y": 164,
+						"w": 110,
+						"h": 41
+					}
+				},
+				{
+					"filename": "party_slot_main_short_swap_sel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 110,
+						"h": 41
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 110,
+						"h": 41
+					},
+					"frame": {
+						"x": 0,
+						"y": 205,
+						"w": 110,
+						"h": 41
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:29685f2f538901cf5bf7f0ed2ea867c3:a080ea6c8cccd1e03244214053e79796:565f7afc5ca419b6ba8dbce51ea30818$"
+	}
+}

src/@types/dex-data.ts

@@ -1,3 +1,5 @@
+import type { RibbonData } from "#system/ribbons/ribbon-data";
+
 export interface DexData {
   [key: number]: DexEntry;
 }
@@ -10,4 +12,5 @@ export interface DexEntry {
   caughtCount: number;
   hatchedCount: number;
   ivs: number[];
+  ribbons: RibbonData;
 }

src/@types/helpers/type-helpers.ts

@@ -103,3 +103,12 @@ export type CoerceNullPropertiesToUndefined<T extends object> = {
  * @typeParam T - The type to render partial
  */
 export type AtLeastOne<T extends object> = Partial<T> & ObjectValues<{ [K in keyof T]: Pick<Required<T>, K> }>;
+
+/** Type helper that adds a brand to a type, used for nominal typing.
+ *
+ * @remarks
+ * Brands should be either a string or unique symbol. This prevents overlap with other types.
+ */
+export declare class Brander<B> {
+  private __brand: B;
+}

src/account.ts

@@ -17,45 +17,42 @@ export function initLoggedInUser(): void {
   };
 }
 
-export function updateUserInfo(): Promise<[boolean, number]> {
-  return new Promise<[boolean, number]>(resolve => {
-    if (bypassLogin) {
-      loggedInUser = {
-        username: "Guest",
-        lastSessionSlot: -1,
-        discordId: "",
-        googleId: "",
-        hasAdminRole: false,
-      };
-      let lastSessionSlot = -1;
-      for (let s = 0; s < 5; s++) {
-        if (localStorage.getItem(`sessionData${s ? s : ""}_${loggedInUser.username}`)) {
-          lastSessionSlot = s;
-          break;
-        }
+export async function updateUserInfo(): Promise<[boolean, number]> {
+  if (bypassLogin) {
+    loggedInUser = {
+      username: "Guest",
+      lastSessionSlot: -1,
+      discordId: "",
+      googleId: "",
+      hasAdminRole: false,
+    };
+    let lastSessionSlot = -1;
+    for (let s = 0; s < 5; s++) {
+      if (localStorage.getItem(`sessionData${s ? s : ""}_${loggedInUser.username}`)) {
+        lastSessionSlot = s;
+        break;
       }
-      loggedInUser.lastSessionSlot = lastSessionSlot;
-      // Migrate old data from before the username was appended
-      ["data", "sessionData", "sessionData1", "sessionData2", "sessionData3", "sessionData4"].map(d => {
-        const lsItem = localStorage.getItem(d);
-        if (lsItem && !!loggedInUser?.username) {
-          const lsUserItem = localStorage.getItem(`${d}_${loggedInUser.username}`);
-          if (lsUserItem) {
-            localStorage.setItem(`${d}_${loggedInUser.username}_bak`, lsUserItem);
-          }
-          localStorage.setItem(`${d}_${loggedInUser.username}`, lsItem);
-          localStorage.removeItem(d);
-        }
-      });
-      return resolve([true, 200]);
     }
-    pokerogueApi.account.getInfo().then(([accountInfo, status]) => {
-      if (!accountInfo) {
-        resolve([false, status]);
-        return;
+    loggedInUser.lastSessionSlot = lastSessionSlot;
+    // Migrate old data from before the username was appended
+    ["data", "sessionData", "sessionData1", "sessionData2", "sessionData3", "sessionData4"].forEach(d => {
+      const lsItem = localStorage.getItem(d);
+      if (lsItem && !!loggedInUser?.username) {
+        const lsUserItem = localStorage.getItem(`${d}_${loggedInUser.username}`);
+        if (lsUserItem) {
+          localStorage.setItem(`${d}_${loggedInUser.username}_bak`, lsUserItem);
+        }
+        localStorage.setItem(`${d}_${loggedInUser.username}`, lsItem);
+        localStorage.removeItem(d);
       }
-      loggedInUser = accountInfo;
-      resolve([true, 200]);
     });
-  });
+    return [true, 200];
+  }
+
+  const [accountInfo, status] = await pokerogueApi.account.getInfo();
+  if (!accountInfo) {
+    return [false, status];
+  }
+  loggedInUser = accountInfo;
+  return [true, 200];
 }

src/battle-scene.ts

@@ -944,17 +944,17 @@ export class BattleScene extends SceneBase {
     dataSource?: PokemonData,
     postProcess?: (enemyPokemon: EnemyPokemon) => void,
   ): EnemyPokemon {
-    if (Overrides.OPP_LEVEL_OVERRIDE > 0) {
-      level = Overrides.OPP_LEVEL_OVERRIDE;
+    if (Overrides.ENEMY_LEVEL_OVERRIDE > 0) {
+      level = Overrides.ENEMY_LEVEL_OVERRIDE;
     }
-    if (Overrides.OPP_SPECIES_OVERRIDE) {
-      species = getPokemonSpecies(Overrides.OPP_SPECIES_OVERRIDE);
+    if (Overrides.ENEMY_SPECIES_OVERRIDE) {
+      species = getPokemonSpecies(Overrides.ENEMY_SPECIES_OVERRIDE);
       // The fact that a Pokemon is a boss or not can change based on its Species and level
       boss = this.getEncounterBossSegments(this.currentBattle.waveIndex, level, species) > 1;
     }
 
     const pokemon = new EnemyPokemon(species, level, trainerSlot, boss, shinyLock, dataSource);
-    if (Overrides.OPP_FUSION_OVERRIDE) {
+    if (Overrides.ENEMY_FUSION_OVERRIDE) {
       pokemon.generateFusionSpecies();
     }
 
@@ -1766,10 +1766,10 @@ export class BattleScene extends SceneBase {
   }
 
   getEncounterBossSegments(waveIndex: number, level: number, species?: PokemonSpecies, forceBoss = false): number {
-    if (Overrides.OPP_HEALTH_SEGMENTS_OVERRIDE > 1) {
-      return Overrides.OPP_HEALTH_SEGMENTS_OVERRIDE;
+    if (Overrides.ENEMY_HEALTH_SEGMENTS_OVERRIDE > 1) {
+      return Overrides.ENEMY_HEALTH_SEGMENTS_OVERRIDE;
     }
-    if (Overrides.OPP_HEALTH_SEGMENTS_OVERRIDE === 1) {
+    if (Overrides.ENEMY_HEALTH_SEGMENTS_OVERRIDE === 1) {
       // The rest of the code expects to be returned 0 and not 1 if the enemy is not a boss
       return 0;
     }

src/constants.ts

@@ -101,3 +101,9 @@ export const ANTI_VARIANCE_WEIGHT_MODIFIER = 15;
  * Default: `10000` (0.01%)
  */
 export const FAKE_TITLE_LOGO_CHANCE = 10000;
+
+/**
+ * The ceiling on friendship amount that can be reached through the use of rare candies.
+ * Using rare candies will never increase friendship beyond this value.
+ */
+export const RARE_CANDY_FRIENDSHIP_CAP = 200;

src/data/abilities/ability.ts

@@ -1,6 +1,8 @@
 /* biome-ignore-start lint/correctness/noUnusedImports: tsdoc imports */
 import type { BattleScene } from "#app/battle-scene";
 import type { SpeciesFormChangeRevertWeatherFormTrigger } from "#data/form-change-triggers";
+import type { MoveEffectPhase } from "#phases/move-effect-phase";
+import type { MoveEndPhase } from "#phases/move-end-phase";
 /* biome-ignore-end lint/correctness/noUnusedImports: tsdoc imports */
 
 import { applyAbAttrs } from "#abilities/apply-ab-attrs";
@@ -51,7 +53,8 @@ import { BerryModifierType } from "#modifiers/modifier-type";
 import { applyMoveAttrs } from "#moves/apply-attrs";
 import { noAbilityTypeOverrideMoves } from "#moves/invalid-moves";
 import type { Move } from "#moves/move";
-import type { PokemonMove } from "#moves/pokemon-move";
+import { getMoveTargets } from "#moves/move-utils";
+import { PokemonMove } from "#moves/pokemon-move";
 import type { StatStageChangePhase } from "#phases/stat-stage-change-phase";
 import type {
   AbAttrCondition,
@@ -5786,12 +5789,21 @@ export class InfiltratorAbAttr extends AbAttr {
 /**
  * Attribute implementing the effects of {@link https://bulbapedia.bulbagarden.net/wiki/Magic_Bounce_(ability) | Magic Bounce}.
  * Allows the source to bounce back {@linkcode MoveFlags.REFLECTABLE | Reflectable}
- *  moves as if the user had used {@linkcode MoveId.MAGIC_COAT | Magic Coat}.
- * @sealed
- * @todo Make reflection a part of this ability's effects
+ * moves as if the user had used {@linkcode MoveId.MAGIC_COAT | Magic Coat}.
+ * The calling {@linkcode MoveEffectPhase} will "skip" targets with a reflection effect active,
+ * showing the flyout and queueing the reaction during the move's {@linkcode MoveEndPhase}.
  */
-export class ReflectStatusMoveAbAttr extends AbAttr {
-  private declare readonly _: never;
+export class ReflectStatusMoveAbAttr extends PreDefendAbAttr {
+  override apply({ pokemon, opponent, move }: AugmentMoveInteractionAbAttrParams): void {
+    const newTargets = move.isMultiTarget() ? getMoveTargets(pokemon, move.id).targets : [opponent.getBattlerIndex()];
+    globalScene.phaseManager.unshiftNew(
+      "MovePhase",
+      pokemon,
+      newTargets,
+      new PokemonMove(move.id),
+      MoveUseMode.REFLECTED,
+    );
+  }
 }
 
 // TODO: Make these ability attributes be flags instead of dummy attributes
@@ -7248,10 +7260,7 @@ export function initAbilities() {
       .attr(PostIntimidateStatStageChangeAbAttr, [ Stat.SPD ], 1),
     new Ability(AbilityId.MAGIC_BOUNCE, 5)
       .attr(ReflectStatusMoveAbAttr)
-      .ignorable()
-      // Interactions with stomping tantrum, instruct, encore, and probably other moves that
-      // rely on move history
-      .edgeCase(),
+      .ignorable(),
     new Ability(AbilityId.SAP_SIPPER, 5)
       .attr(TypeImmunityStatStageChangeAbAttr, PokemonType.GRASS, Stat.ATK, 1)
       .ignorable(),
@@ -7285,7 +7294,7 @@ export function initAbilities() {
       .attr(PostSummonMessageAbAttr, (pokemon: Pokemon) => i18next.t("abilityTriggers:postSummonTeravolt", { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon) }))
       .attr(MoveAbilityBypassAbAttr),
     new Ability(AbilityId.AROMA_VEIL, 6)
-      .attr(UserFieldBattlerTagImmunityAbAttr, [ BattlerTagType.INFATUATED, BattlerTagType.TAUNT, BattlerTagType.DISABLED, BattlerTagType.TORMENT, BattlerTagType.HEAL_BLOCK ])
+      .attr(UserFieldBattlerTagImmunityAbAttr, [ BattlerTagType.INFATUATED, BattlerTagType.TAUNT, BattlerTagType.DISABLED, BattlerTagType.TORMENT, BattlerTagType.HEAL_BLOCK, BattlerTagType.ENCORE ])
       .ignorable(),
     new Ability(AbilityId.FLOWER_VEIL, 6)
       .attr(ConditionalUserFieldStatusEffectImmunityAbAttr, (target: Pokemon, source: Pokemon | null) => {
@@ -7349,7 +7358,7 @@ export function initAbilities() {
     new Ability(AbilityId.GOOEY, 6)
       .attr(PostDefendStatStageChangeAbAttr, (_target, _user, move) => move.hasFlag(MoveFlags.MAKES_CONTACT), Stat.SPD, -1, false),
     new Ability(AbilityId.AERILATE, 6)
-      .attr(MoveTypeChangeAbAttr, PokemonType.FLYING, 1.2, (_user, _target, move) => move.type === PokemonType.NORMAL),
+    .attr(MoveTypeChangeAbAttr, PokemonType.FLYING, 1.2, (_user, _target, move) => move.type === PokemonType.NORMAL),
     new Ability(AbilityId.PARENTAL_BOND, 6)
       .attr(AddSecondStrikeAbAttr, 0.25),
     new Ability(AbilityId.DARK_AURA, 6)

src/data/battler-tags.ts

@@ -28,6 +28,8 @@ import type { Pokemon } from "#field/pokemon";
 import { applyMoveAttrs } from "#moves/apply-attrs";
 import { invalidEncoreMoves } from "#moves/invalid-moves";
 import type { Move } from "#moves/move";
+import { getMoveTargets } from "#moves/move-utils";
+import { PokemonMove } from "#moves/pokemon-move";
 import type { MoveEffectPhase } from "#phases/move-effect-phase";
 import type { MovePhase } from "#phases/move-phase";
 import type { StatStageChangeCallback } from "#phases/stat-stage-change-phase";
@@ -174,6 +176,7 @@ export class BattlerTag implements BaseBattlerTag {
     return "";
   }
 
+  // TODO: Make this a getter
   isSourceLinked(): boolean {
     return false;
   }
@@ -1238,13 +1241,16 @@ export class FrenzyTag extends SerializableBattlerTag {
  */
 export class EncoreTag extends MoveRestrictionBattlerTag {
   public override readonly tagType = BattlerTagType.ENCORE;
-  /** The ID of the move the user is locked into using */
+  /** The {@linkcode MoveID} the tag holder is locked into */
   public moveId: MoveId;
 
   constructor(sourceId: number) {
+    // Encore ends at the end of the 3rd turn it procs.
+    // If used on turn X when faster, it ends at the end of turn X+2.
+    // If used on turn X when slower, it ends at the end of turn X+3.
     super(
       BattlerTagType.ENCORE,
-      [BattlerTagLapseType.CUSTOM, BattlerTagLapseType.AFTER_MOVE],
+      [BattlerTagLapseType.AFTER_MOVE, BattlerTagLapseType.TURN_END],
       3,
       MoveId.ENCORE,
       sourceId,
@@ -1266,6 +1272,14 @@ export class EncoreTag extends MoveRestrictionBattlerTag {
       return false;
     }
 
+    if (!pokemon.getMoveset().some(m => m.moveId === lastMove.move && !m.isOutOfPp())) {
+      return false;
+    }
+
+    if (pokemon.getTag(BattlerTagType.SHELL_TRAP)) {
+      return false;
+    }
+
     this.moveId = lastMove.move;
 
     return true;
@@ -1278,35 +1292,57 @@ export class EncoreTag extends MoveRestrictionBattlerTag {
       }),
     );
 
-    const movePhase = globalScene.phaseManager.findPhase(m => m.is("MovePhase") && m.pokemon === pokemon);
-    if (movePhase) {
-      const movesetMove = pokemon.getMoveset().find(m => m.moveId === this.moveId);
-      if (movesetMove) {
-        const lastMove = pokemon.getLastXMoves(1)[0];
-        globalScene.phaseManager.tryReplacePhase(
-          m => m.is("MovePhase") && m.pokemon === pokemon,
-          globalScene.phaseManager.create(
-            "MovePhase",
-            pokemon,
-            lastMove.targets ?? [],
-            movesetMove,
-            MoveUseMode.NORMAL,
-          ),
-        );
-      }
+    // If the target has not moved yet,
+    // replace their upcoming move with the encored move against randomized targets
+    const movePhase = globalScene.phaseManager.findPhase(
+      (m): m is MovePhase => m.is("MovePhase") && m.pokemon === pokemon,
+    );
+    if (!movePhase) {
+      return;
     }
+
+    // Use the prior move in the moveset.
+    // Bang is justified as `canAdd` returns false if not found
+    const movesetMove = pokemon.getMoveset().find(m => m.moveId === this.moveId)!;
+
+    const moveTargets = getMoveTargets(pokemon, this.moveId);
+    // Spread moves and ones with only 1 valid target will use their normal targeting.
+    // If not, target a random enemy in our target list
+    const targets =
+      moveTargets.multiple || moveTargets.targets.length === 1
+        ? moveTargets.targets
+        : [moveTargets.targets[pokemon.randBattleSeedInt(moveTargets.targets.length)]];
+
+    globalScene.phaseManager.tryReplacePhase(
+      m => m.is("MovePhase") && m.pokemon === pokemon,
+      globalScene.phaseManager.create(
+        "MovePhase",
+        pokemon,
+        targets,
+        movesetMove,
+        movePhase.useMode,
+        movePhase.isForcedLast(),
+      ),
+    );
   }
 
   /**
-   * If the encored move has run out of PP, Encore ends early. Otherwise, Encore lapses based on the AFTER_MOVE battler tag lapse type.
-   * @returns `true` to persist | `false` to end and be removed
+   * If the encored move has run out of PP or the tag's turn count has elapsed,
+   * Encore ends at the END of the turn.
+   * Otherwise, Encore's duration reduces when the target attempts to use a move.
+   * @returns Whether the tag should remain active.
    */
   override lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {
-    if (lapseType === BattlerTagLapseType.CUSTOM) {
-      const encoredMove = pokemon.getMoveset().find(m => m.moveId === this.moveId);
-      return !isNullOrUndefined(encoredMove) && encoredMove.getPpRatio() > 0;
+    if (lapseType === BattlerTagLapseType.AFTER_MOVE) {
+      this.turnCount--;
+      return true;
     }
-    return super.lapse(pokemon, lapseType);
+
+    const encoredMove = pokemon.getMoveset().find(m => m.moveId === this.moveId);
+    if (isNullOrUndefined(encoredMove) || encoredMove.isOutOfPp()) {
+      return false;
+    }
+    return this.turnCount > 0;
   }
 
   /**
@@ -1489,12 +1525,8 @@ export class MinimizeTag extends SerializableBattlerTag {
 
 export class DrowsyTag extends SerializableBattlerTag {
   public override readonly tagType = BattlerTagType.DROWSY;
-  constructor() {
-    super(BattlerTagType.DROWSY, BattlerTagLapseType.TURN_END, 2, MoveId.YAWN);
-  }
-
-  canAdd(pokemon: Pokemon): boolean {
-    return globalScene.arena.terrain?.terrainType !== TerrainType.ELECTRIC || !pokemon.isGrounded();
+  constructor(sourceId: number) {
+    super(BattlerTagType.DROWSY, BattlerTagLapseType.TURN_END, 2, MoveId.YAWN, sourceId);
   }
 
   onAdd(pokemon: Pokemon): void {
@@ -1509,6 +1541,7 @@ export class DrowsyTag extends SerializableBattlerTag {
 
   lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {
     if (!super.lapse(pokemon, lapseType)) {
+      // TODO: Safeguard should not prevent yawn from setting sleep after tag use
       pokemon.trySetStatus(StatusEffect.SLEEP, true);
       return false;
     }
@@ -3632,6 +3665,23 @@ export class MagicCoatTag extends BattlerTag {
       }),
     );
   }
+
+  /**
+   * Apply the tag to reflect a move.
+   * @param pokemon - The {@linkcode Pokemon} to whom this tag belongs
+   * @param opponent - The {@linkcode Pokemon} having originally used the move
+   * @param move - The {@linkcode Move} being used
+   */
+  public apply(pokemon: Pokemon, opponent: Pokemon, move: Move): void {
+    const newTargets = move.isMultiTarget() ? getMoveTargets(pokemon, move.id).targets : [opponent.getBattlerIndex()];
+    globalScene.phaseManager.unshiftNew(
+      "MovePhase",
+      pokemon,
+      newTargets,
+      new PokemonMove(move.id),
+      MoveUseMode.REFLECTED,
+    );
+  }
 }
 
 /**
@@ -3679,7 +3729,7 @@ export function getBattlerTag(
     case BattlerTagType.AQUA_RING:
       return new AquaRingTag();
     case BattlerTagType.DROWSY:
-      return new DrowsyTag();
+      return new DrowsyTag(sourceId);
     case BattlerTagType.TRAPPED:
       return new TrappedTag(tagType, BattlerTagLapseType.CUSTOM, turnCount, sourceMove, sourceId);
     case BattlerTagType.NO_RETREAT:

src/data/challenge.ts

@@ -20,6 +20,7 @@ import { Trainer } from "#field/trainer";
 import type { ModifierTypeOption } from "#modifiers/modifier-type";
 import { PokemonMove } from "#moves/pokemon-move";
 import type { DexAttrProps, GameData } from "#system/game-data";
+import { RibbonData, type RibbonFlag } from "#system/ribbons/ribbon-data";
 import { type BooleanHolder, isBetween, type NumberHolder, randSeedItem } from "#utils/common";
 import { deepCopy } from "#utils/data";
 import { getPokemonSpecies, getPokemonSpeciesForm } from "#utils/pokemon-utils";
@@ -42,6 +43,15 @@ export abstract class Challenge {
 
   public conditions: ChallengeCondition[];
 
+  /**
+   * The Ribbon awarded on challenge completion, or 0 if the challenge has no ribbon or is not enabled
+   *
+   * @defaultValue 0
+   */
+  public get ribbonAwarded(): RibbonFlag {
+    return 0 as RibbonFlag;
+  }
+
   /**
    * @param id {@link Challenges} The enum value for the challenge
    */
@@ -423,6 +433,12 @@ type ChallengeCondition = (data: GameData) => boolean;
  * Implements a mono generation challenge.
  */
 export class SingleGenerationChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    // NOTE: This logic will not work for the eventual mono gen 10 ribbon, as
+    // as its flag will not be in sequence with the other mono gen ribbons.
+    return this.value ? ((RibbonData.MONO_GEN_1 << (this.value - 1)) as RibbonFlag) : 0;
+  }
+
   constructor() {
     super(Challenges.SINGLE_GENERATION, 9);
   }
@@ -686,6 +702,12 @@ interface monotypeOverride {
  * Implements a mono type challenge.
  */
 export class SingleTypeChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    // `this.value` represents the 1-based index of pokemon type
+    // `RibbonData.MONO_NORMAL` starts the flag position for the types,
+    // and we shift it by 1 for the specific type.
+    return this.value ? ((RibbonData.MONO_NORMAL << (this.value - 1)) as RibbonFlag) : 0;
+  }
   private static TYPE_OVERRIDES: monotypeOverride[] = [
     { species: SpeciesId.CASTFORM, type: PokemonType.NORMAL, fusion: false },
   ];
@@ -755,6 +777,9 @@ export class SingleTypeChallenge extends Challenge {
  * Implements a fresh start challenge.
  */
 export class FreshStartChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    return this.value ? RibbonData.FRESH_START : 0;
+  }
   constructor() {
     super(Challenges.FRESH_START, 2);
   }
@@ -828,6 +853,9 @@ export class FreshStartChallenge extends Challenge {
  * Implements an inverse battle challenge.
  */
 export class InverseBattleChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    return this.value ? RibbonData.INVERSE : 0;
+  }
   constructor() {
     super(Challenges.INVERSE_BATTLE, 1);
   }
@@ -861,6 +889,9 @@ export class InverseBattleChallenge extends Challenge {
  * Implements a flip stat challenge.
  */
 export class FlipStatChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    return this.value ? RibbonData.FLIP_STATS : 0;
+  }
   constructor() {
     super(Challenges.FLIP_STAT, 1);
   }
@@ -941,6 +972,9 @@ export class LowerStarterPointsChallenge extends Challenge {
  * Implements a No Support challenge
  */
 export class LimitedSupportChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    return this.value ? ((RibbonData.NO_HEAL << (this.value - 1)) as RibbonFlag) : 0;
+  }
   constructor() {
     super(Challenges.LIMITED_SUPPORT, 3);
   }
@@ -973,6 +1007,9 @@ export class LimitedSupportChallenge extends Challenge {
  * Implements a Limited Catch challenge
  */
 export class LimitedCatchChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    return this.value ? RibbonData.LIMITED_CATCH : 0;
+  }
   constructor() {
     super(Challenges.LIMITED_CATCH, 1);
   }
@@ -997,6 +1034,9 @@ export class LimitedCatchChallenge extends Challenge {
  * Implements a Permanent Faint challenge
  */
 export class HardcoreChallenge extends Challenge {
+  public override get ribbonAwarded(): RibbonFlag {
+    return this.value ? RibbonData.HARDCORE : 0;
+  }
   constructor() {
     super(Challenges.HARDCORE, 1);
   }

src/data/egg-hatch-data.ts

@@ -47,6 +47,7 @@ export class EggHatchData {
       caughtCount: currDexEntry.caughtCount,
       hatchedCount: currDexEntry.hatchedCount,
       ivs: [...currDexEntry.ivs],
+      ribbons: currDexEntry.ribbons,
     };
     this.starterDataEntryBeforeUpdate = {
       moveset: currStarterDataEntry.moveset,

src/data/moves/invalid-moves.ts

@@ -280,3 +280,68 @@ export const invalidEncoreMoves: ReadonlySet<MoveId> = new Set([
   MoveId.SLEEP_TALK,
   MoveId.ENCORE,
 ]);
+
+export const invalidInstructMoves: ReadonlySet<MoveId> = new Set([
+  // Locking/Continually Executed moves
+  MoveId.OUTRAGE,
+  MoveId.RAGING_FURY,
+  MoveId.ROLLOUT,
+  MoveId.PETAL_DANCE,
+  MoveId.THRASH,
+  MoveId.ICE_BALL,
+  MoveId.UPROAR,
+  // Multi-turn Moves
+  MoveId.BIDE,
+  MoveId.SHELL_TRAP,
+  MoveId.BEAK_BLAST,
+  MoveId.FOCUS_PUNCH,
+  // "First Turn Only" moves
+  MoveId.FAKE_OUT,
+  MoveId.FIRST_IMPRESSION,
+  MoveId.MAT_BLOCK,
+  // Moves with a recharge turn
+  MoveId.HYPER_BEAM,
+  MoveId.ETERNABEAM,
+  MoveId.FRENZY_PLANT,
+  MoveId.BLAST_BURN,
+  MoveId.HYDRO_CANNON,
+  MoveId.GIGA_IMPACT,
+  MoveId.PRISMATIC_LASER,
+  MoveId.ROAR_OF_TIME,
+  MoveId.ROCK_WRECKER,
+  MoveId.METEOR_ASSAULT,
+  // Charging & 2-turn moves
+  MoveId.DIG,
+  MoveId.FLY,
+  MoveId.BOUNCE,
+  MoveId.SHADOW_FORCE,
+  MoveId.PHANTOM_FORCE,
+  MoveId.DIVE,
+  MoveId.ELECTRO_SHOT,
+  MoveId.ICE_BURN,
+  MoveId.GEOMANCY,
+  MoveId.FREEZE_SHOCK,
+  MoveId.SKY_DROP,
+  MoveId.SKY_ATTACK,
+  MoveId.SKULL_BASH,
+  MoveId.SOLAR_BEAM,
+  MoveId.SOLAR_BLADE,
+  MoveId.METEOR_BEAM,
+  // Copying/Move-Calling moves
+  MoveId.ASSIST,
+  MoveId.COPYCAT,
+  MoveId.ME_FIRST,
+  MoveId.METRONOME,
+  MoveId.MIRROR_MOVE,
+  MoveId.NATURE_POWER,
+  MoveId.SLEEP_TALK,
+  MoveId.SNATCH,
+  MoveId.INSTRUCT,
+  // Misc moves
+  MoveId.KINGS_SHIELD,
+  MoveId.SKETCH,
+  MoveId.TRANSFORM,
+  MoveId.MIMIC,
+  MoveId.STRUGGLE,
+  // TODO: Add Max/G-Max/Z-Move blockage if or when they are implemented
+]);

src/data/moves/move.ts

@@ -11,6 +11,7 @@ import { WeakenMoveTypeTag } from "#data/arena-tag";
 import { MoveChargeAnim } from "#data/battle-anims";
 import {
   CommandedTag,
+  DrowsyTag,
   EncoreTag,
   GulpMissileTag,
   HelpingHandTag,
@@ -77,7 +78,7 @@ import {
   PreserveBerryModifier,
 } from "#modifiers/modifier";
 import { applyMoveAttrs } from "#moves/apply-attrs";
-import { invalidAssistMoves, invalidCopycatMoves, invalidMetronomeMoves, invalidMirrorMoveMoves, invalidSketchMoves, invalidSleepTalkMoves } from "#moves/invalid-moves";
+import { invalidAssistMoves, invalidCopycatMoves, invalidInstructMoves, invalidMetronomeMoves, invalidMirrorMoveMoves, invalidSketchMoves, invalidSleepTalkMoves } from "#moves/invalid-moves";
 import { frenzyMissFunc, getMoveTargets } from "#moves/move-utils";
 import { PokemonMove } from "#moves/pokemon-move";
 import { MoveEndPhase } from "#phases/move-end-phase";
@@ -679,20 +680,9 @@ export abstract class Move implements Localizable {
           return true;
         }
         break;
-      case MoveFlags.REFLECTABLE:
-        // If the target is not semi-invulnerable and either has magic coat active or an unignored magic bounce ability
-        if (
-          target?.getTag(SemiInvulnerableTag) ||
-          !(target?.getTag(BattlerTagType.MAGIC_COAT) ||
-            (!this.doesFlagEffectApply({ flag: MoveFlags.IGNORE_ABILITIES, user, target }) &&
-              target?.hasAbilityWithAttr("ReflectStatusMoveAbAttr")))
-        ) {
-          return false;
-        }
-        break;
     }
 
-    return !!(this.flags & flag);
+    return this.hasFlag(flag)
   }
 
   /**
@@ -5705,6 +5695,34 @@ export class AddBattlerTagAttr extends MoveEffectAttr {
   }
 }
 
+/**
+ * Attribute to implement {@linkcode MoveId.YAWN}.
+ * Yawn adds a BattlerTag to its target that puts them to sleep at the end
+ * of the next turn, retaining many of the same checks as normal status setting moves.
+ */
+export class YawnAttr extends AddBattlerTagAttr {
+  constructor() {
+    super(BattlerTagType.DROWSY, false, true)
+  }
+
+  getCondition(): MoveConditionFunc {
+    return (user, target, move) => {
+      if (!super.getCondition()!(user, target, move)) {
+        return false;
+      }
+
+      // Statused opponents or ones with safeguard active use a generic failure message
+      if (target.status || target.isSafeguarded(user)) {
+        return false;
+      }
+
+      // TODO: This does not display the cause of the "but it failed" message,
+      // but fixing it would require a rework of the move failure system
+      return target.canSetStatus(StatusEffect.SLEEP, true, false, user)
+    }
+  }
+}
+
 /**
  * Adds a {@link https://bulbapedia.bulbagarden.net/wiki/Seeding | Seeding} effect to the target
  * as seen with Leech Seed and Sappy Seed.
@@ -7152,7 +7170,6 @@ export class RepeatMoveAttr extends MoveEffectAttr {
     // bangs are justified as Instruct fails if no prior move or moveset move exists
     // TODO: How does instruct work when copying a move called via Copycat that the user itself knows?
     const lastMove = target.getLastNonVirtualMove()!;
-    const movesetMove = target.getMoveset().find(m => m.moveId === lastMove?.move)!
 
     // If the last move used can hit more than one target or has variable targets,
     // re-compute the targets for the attack (mainly for alternating double/single battles)
@@ -7176,12 +7193,18 @@ export class RepeatMoveAttr extends MoveEffectAttr {
       }
     }
 
+    // If the target is currently affected by Encore, increase its duration by 1 (to offset decrease during move use)
+    const targetEncore = target.getTag(BattlerTagType.ENCORE) as EncoreTag | undefined;
+    if (targetEncore) {
+      targetEncore.turnCount++
+    }
+
     globalScene.phaseManager.queueMessage(i18next.t("moveTriggers:instructingMove", {
       userPokemonName: getPokemonNameWithAffix(user),
       targetPokemonName: getPokemonNameWithAffix(target)
     }));
     target.turnData.extraTurns++;
-    globalScene.phaseManager.appendNewToPhase("MoveEndPhase", "MovePhase", target, moveTargets, movesetMove, MoveUseMode.NORMAL);
+    globalScene.phaseManager.appendNewToPhase("MoveEndPhase", "MovePhase", target, moveTargets, this.movesetMove, MoveUseMode.NORMAL);
     return true;
   }
 
@@ -7190,77 +7213,13 @@ export class RepeatMoveAttr extends MoveEffectAttr {
       // TODO: Check instruct behavior with struggle - ignore, fail or success
       const lastMove = target.getLastNonVirtualMove();
       const movesetMove = target.getMoveset().find(m => m.moveId === lastMove?.move);
-      const uninstructableMoves = [
-        // Locking/Continually Executed moves
-        MoveId.OUTRAGE,
-        MoveId.RAGING_FURY,
-        MoveId.ROLLOUT,
-        MoveId.PETAL_DANCE,
-        MoveId.THRASH,
-        MoveId.ICE_BALL,
-        MoveId.UPROAR,
-        // Multi-turn Moves
-        MoveId.BIDE,
-        MoveId.SHELL_TRAP,
-        MoveId.BEAK_BLAST,
-        MoveId.FOCUS_PUNCH,
-        // "First Turn Only" moves
-        MoveId.FAKE_OUT,
-        MoveId.FIRST_IMPRESSION,
-        MoveId.MAT_BLOCK,
-        // Moves with a recharge turn
-        MoveId.HYPER_BEAM,
-        MoveId.ETERNABEAM,
-        MoveId.FRENZY_PLANT,
-        MoveId.BLAST_BURN,
-        MoveId.HYDRO_CANNON,
-        MoveId.GIGA_IMPACT,
-        MoveId.PRISMATIC_LASER,
-        MoveId.ROAR_OF_TIME,
-        MoveId.ROCK_WRECKER,
-        MoveId.METEOR_ASSAULT,
-        // Charging & 2-turn moves
-        MoveId.DIG,
-        MoveId.FLY,
-        MoveId.BOUNCE,
-        MoveId.SHADOW_FORCE,
-        MoveId.PHANTOM_FORCE,
-        MoveId.DIVE,
-        MoveId.ELECTRO_SHOT,
-        MoveId.ICE_BURN,
-        MoveId.GEOMANCY,
-        MoveId.FREEZE_SHOCK,
-        MoveId.SKY_DROP,
-        MoveId.SKY_ATTACK,
-        MoveId.SKULL_BASH,
-        MoveId.SOLAR_BEAM,
-        MoveId.SOLAR_BLADE,
-        MoveId.METEOR_BEAM,
-        // Copying/Move-Calling moves
-        MoveId.ASSIST,
-        MoveId.COPYCAT,
-        MoveId.ME_FIRST,
-        MoveId.METRONOME,
-        MoveId.MIRROR_MOVE,
-        MoveId.NATURE_POWER,
-        MoveId.SLEEP_TALK,
-        MoveId.SNATCH,
-        MoveId.INSTRUCT,
-        // Misc moves
-        MoveId.KINGS_SHIELD,
-        MoveId.SKETCH,
-        MoveId.TRANSFORM,
-        MoveId.MIMIC,
-        MoveId.STRUGGLE,
-        // TODO: Add Max/G-Max/Z-Move blockage if or when they are implemented
-      ];
 
-      if (!lastMove?.move // no move to instruct
+      if (
+        !lastMove?.move // no move to instruct
         || !movesetMove // called move not in target's moveset (forgetting the move, etc.)
-        || movesetMove.ppUsed === movesetMove.getMovePp() // move out of pp
-        // TODO: This next line is likely redundant as all charging moves are in the above list
-        || allMoves[lastMove.move].isChargingMove() // called move is a charging/recharging move
-        || uninstructableMoves.includes(lastMove.move)) { // called move is in the banlist
+        || movesetMove.isOutOfPp() // move out of pp
+        || invalidInstructMoves.has(lastMove.move) // called move is in the banlist
+      ) {
         return false;
       }
       this.movesetMove = movesetMove;
@@ -7974,7 +7933,7 @@ export class AfterYouAttr extends MoveEffectAttr {
     globalScene.phaseManager.queueMessage(i18next.t("moveTriggers:afterYou", { targetName: getPokemonNameWithAffix(target) }));
 
     // Will find next acting phase of the targeted pokémon, delete it and queue it right after us.
-    const targetNextPhase = globalScene.phaseManager.findPhase<MovePhase>(phase => phase.pokemon === target);
+    const targetNextPhase = globalScene.phaseManager.findPhase((phase): phase is MovePhase => phase.is("MovePhase") && phase.pokemon === target);
     if (targetNextPhase && globalScene.phaseManager.tryRemovePhase((phase: MovePhase) => phase.pokemon === target)) {
       globalScene.phaseManager.prependToPhase(targetNextPhase, "MovePhase");
     }
@@ -8002,7 +7961,7 @@ export class ForceLastAttr extends MoveEffectAttr {
     globalScene.phaseManager.queueMessage(i18next.t("moveTriggers:forceLast", { targetPokemonName: getPokemonNameWithAffix(target) }));
 
     // TODO: Refactor this to be more readable and less janky
-    const targetMovePhase = globalScene.phaseManager.findPhase<MovePhase>((phase) => phase.pokemon === target);
+    const targetMovePhase = globalScene.phaseManager.findPhase((phase): phase is MovePhase => phase.is("MovePhase") && phase.pokemon === target);
     if (targetMovePhase && !targetMovePhase.isForcedLast() && globalScene.phaseManager.tryRemovePhase((phase: MovePhase) => phase.pokemon === target)) {
       // Finding the phase to insert the move in front of -
       // Either the end of the turn or in front of another, slower move which has also been forced last
@@ -9186,11 +9145,11 @@ export function initMoves() {
       .hidesUser(),
     new StatusMove(MoveId.ENCORE, PokemonType.NORMAL, 100, 5, -1, 0, 2)
       .attr(AddBattlerTagAttr, BattlerTagType.ENCORE, false, true)
-      .ignoresSubstitute()
       .condition((user, target, move) => new EncoreTag(user.id).canAdd(target))
+      .ignoresSubstitute()
       .reflectable()
-      // Can lock infinitely into struggle; has incorrect interactions with Blood Moon/Gigaton Hammer
-      // Also may or may not incorrectly select targets for replacement move (needs verification)
+      // has incorrect interactions with Blood Moon/Gigaton Hammer
+      // TODO: Verify if Encore's duration decreases during status based move failures
       .edgeCase(),
     new AttackMove(MoveId.PURSUIT, PokemonType.DARK, MoveCategory.PHYSICAL, 40, 100, 20, -1, 0, 2)
       .partial(), // No effect implemented
@@ -9363,9 +9322,7 @@ export function initMoves() {
     new SelfStatusMove(MoveId.MAGIC_COAT, PokemonType.PSYCHIC, -1, 15, -1, 4, 3)
       .attr(AddBattlerTagAttr, BattlerTagType.MAGIC_COAT, true, true, 0)
       .condition(failIfLastCondition)
-      // Interactions with stomping tantrum, instruct, and other moves that
-      // rely on move history
-      // Also will not reflect roar / whirlwind if the target has ForceSwitchOutImmunityAbAttr
+      // Will not reflect roar / whirlwind if the target has ForceSwitchOutImmunityAbAttr
       .edgeCase(),
     new SelfStatusMove(MoveId.RECYCLE, PokemonType.NORMAL, -1, 10, -1, 0, 3)
       .unimplemented(),
@@ -9374,11 +9331,11 @@ export function initMoves() {
     new AttackMove(MoveId.BRICK_BREAK, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 75, 100, 15, -1, 0, 3)
       .attr(RemoveScreensAttr),
     new StatusMove(MoveId.YAWN, PokemonType.NORMAL, -1, 10, -1, 0, 3)
-      .attr(AddBattlerTagAttr, BattlerTagType.DROWSY, false, true)
-      .condition((user, target, move) => !target.status && !target.isSafeguarded(user))
-      .reflectable(),
+      .attr(YawnAttr)
+      .reflectable()
+      .edgeCase(), // Should not be blocked by safeguard once tag is applied
     new AttackMove(MoveId.KNOCK_OFF, PokemonType.DARK, MoveCategory.PHYSICAL, 65, 100, 20, -1, 0, 3)
-      .attr(MovePowerMultiplierAttr, (user, target, move) => target.getHeldItems().filter(i => i.isTransferable).length > 0 ? 1.5 : 1)
+      .attr(MovePowerMultiplierAttr, (_user, target, _move) => target.getHeldItems().some(i => i.isTransferable) ? 1.5 : 1)
       .attr(RemoveHeldItemAttr, false)
       .edgeCase(),
       // Should not be able to remove held item if user faints due to Rough Skin, Iron Barbs, etc.
@@ -10662,11 +10619,10 @@ export function initMoves() {
     new AttackMove(MoveId.TROP_KICK, PokemonType.GRASS, MoveCategory.PHYSICAL, 70, 100, 15, 100, 0, 7)
       .attr(StatStageChangeAttr, [ Stat.ATK ], -1),
     new StatusMove(MoveId.INSTRUCT, PokemonType.PSYCHIC, -1, 15, -1, 0, 7)
-      .ignoresSubstitute()
       .attr(RepeatMoveAttr)
+      .ignoresSubstitute()
       /*
        * Incorrect interactions with Gigaton Hammer, Blood Moon & Torment due to them _failing on use_, not merely being unselectable.
-       * Incorrectly ticks down Encore's fail counter
        * TODO: Verify whether Instruct can repeat Struggle
        * TODO: Verify whether Instruct can fail when using a copied move also in one's own moveset
        */

src/data/moves/pokemon-move.ts

@@ -11,7 +11,7 @@ import { BooleanHolder, toDmgValue } from "#utils/common";
  * These are the moves assigned to a {@linkcode Pokemon} object.
  * It links to {@linkcode Move} class via the move ID.
  * Compared to {@linkcode Move}, this class also tracks things like
- * PP Ups recieved, PP used, etc.
+ * PP Ups received, PP used, etc.
  * @see {@linkcode isUsable} - checks if move is restricted, out of PP, or not implemented.
  * @see {@linkcode getMove} - returns {@linkcode Move} object by looking it up via ID.
  * @see {@linkcode usePp} - removes a point of PP from the move.
@@ -73,6 +73,7 @@ export class PokemonMove {
     this.ppUsed = Math.min(this.ppUsed + count, this.getMovePp());
   }
 
+  // TODO: Rename to `getMaxPP`
   getMovePp(): number {
     return this.maxPpOverride || this.getMove().pp + this.ppUp * toDmgValue(this.getMove().pp / 5);
   }
@@ -81,6 +82,10 @@ export class PokemonMove {
     return 1 - this.ppUsed / this.getMovePp();
   }
 
+  public isOutOfPp(): boolean {
+    return this.ppUsed >= this.getMovePp();
+  }
+
   getName(): string {
     return this.getMove().name;
   }

src/field/pokemon.ts

@@ -1,7 +1,7 @@
 import type { Ability, PreAttackModifyDamageAbAttrParams } from "#abilities/ability";
 import { applyAbAttrs, applyOnGainAbAttrs, applyOnLoseAbAttrs } from "#abilities/apply-ab-attrs";
 import type { AnySound, BattleScene } from "#app/battle-scene";
-import { PLAYER_PARTY_MAX_SIZE } from "#app/constants";
+import { PLAYER_PARTY_MAX_SIZE, RARE_CANDY_FRIENDSHIP_CAP } from "#app/constants";
 import { timedEventManager } from "#app/global-event-manager";
 import { globalScene } from "#app/global-scene";
 import { getPokemonNameWithAffix } from "#app/messages";
@@ -139,6 +139,8 @@ import { populateVariantColors, variantColorCache, variantData } from "#sprites/
 import { achvs } from "#system/achv";
 import type { StarterDataEntry, StarterMoveset } from "#system/game-data";
 import type { PokemonData } from "#system/pokemon-data";
+import { RibbonData } from "#system/ribbons/ribbon-data";
+import { awardRibbonsToSpeciesLine } from "#system/ribbons/ribbon-methods";
 import type { AbAttrMap, AbAttrString, TypeMultiplierAbAttrParams } from "#types/ability-types";
 import type { DamageCalculationResult, DamageResult } from "#types/damage-result";
 import type { IllusionData } from "#types/illusion-data";
@@ -1825,7 +1827,7 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
     // Overrides moveset based on arrays specified in overrides.ts
     let overrideArray: MoveId | Array<MoveId> = this.isPlayer()
       ? Overrides.MOVESET_OVERRIDE
-      : Overrides.OPP_MOVESET_OVERRIDE;
+      : Overrides.ENEMY_MOVESET_OVERRIDE;
     overrideArray = coerceArray(overrideArray);
     if (overrideArray.length > 0) {
       if (!this.isPlayer()) {
@@ -2030,8 +2032,8 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
     if (Overrides.ABILITY_OVERRIDE && this.isPlayer()) {
       return allAbilities[Overrides.ABILITY_OVERRIDE];
     }
-    if (Overrides.OPP_ABILITY_OVERRIDE && this.isEnemy()) {
-      return allAbilities[Overrides.OPP_ABILITY_OVERRIDE];
+    if (Overrides.ENEMY_ABILITY_OVERRIDE && this.isEnemy()) {
+      return allAbilities[Overrides.ENEMY_ABILITY_OVERRIDE];
     }
     if (this.isFusion()) {
       if (!isNullOrUndefined(this.fusionCustomPokemonData?.ability) && this.fusionCustomPokemonData.ability !== -1) {
@@ -2060,8 +2062,8 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
     if (Overrides.PASSIVE_ABILITY_OVERRIDE && this.isPlayer()) {
       return allAbilities[Overrides.PASSIVE_ABILITY_OVERRIDE];
     }
-    if (Overrides.OPP_PASSIVE_ABILITY_OVERRIDE && this.isEnemy()) {
-      return allAbilities[Overrides.OPP_PASSIVE_ABILITY_OVERRIDE];
+    if (Overrides.ENEMY_PASSIVE_ABILITY_OVERRIDE && this.isEnemy()) {
+      return allAbilities[Overrides.ENEMY_PASSIVE_ABILITY_OVERRIDE];
     }
     if (!isNullOrUndefined(this.customPokemonData.passive) && this.customPokemonData.passive !== -1) {
       return allAbilities[this.customPokemonData.passive];
@@ -2128,14 +2130,14 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
     // returns override if valid for current case
     if (
       (Overrides.HAS_PASSIVE_ABILITY_OVERRIDE === false && this.isPlayer()) ||
-      (Overrides.OPP_HAS_PASSIVE_ABILITY_OVERRIDE === false && this.isEnemy())
+      (Overrides.ENEMY_HAS_PASSIVE_ABILITY_OVERRIDE === false && this.isEnemy())
     ) {
       return false;
     }
     if (
       ((Overrides.PASSIVE_ABILITY_OVERRIDE !== AbilityId.NONE || Overrides.HAS_PASSIVE_ABILITY_OVERRIDE) &&
         this.isPlayer()) ||
-      ((Overrides.OPP_PASSIVE_ABILITY_OVERRIDE !== AbilityId.NONE || Overrides.OPP_HAS_PASSIVE_ABILITY_OVERRIDE) &&
+      ((Overrides.ENEMY_PASSIVE_ABILITY_OVERRIDE !== AbilityId.NONE || Overrides.ENEMY_HAS_PASSIVE_ABILITY_OVERRIDE) &&
         this.isEnemy())
     ) {
       return true;
@@ -3001,8 +3003,8 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
 
     if (forStarter && this.isPlayer() && Overrides.STARTER_FUSION_SPECIES_OVERRIDE) {
       fusionOverride = getPokemonSpecies(Overrides.STARTER_FUSION_SPECIES_OVERRIDE);
-    } else if (this.isEnemy() && Overrides.OPP_FUSION_SPECIES_OVERRIDE) {
-      fusionOverride = getPokemonSpecies(Overrides.OPP_FUSION_SPECIES_OVERRIDE);
+    } else if (this.isEnemy() && Overrides.ENEMY_FUSION_SPECIES_OVERRIDE) {
+      fusionOverride = getPokemonSpecies(Overrides.ENEMY_FUSION_SPECIES_OVERRIDE);
     }
 
     this.fusionSpecies =
@@ -4430,14 +4432,19 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
 
   /**
    * Return this Pokemon's move history.
-   * Entries are sorted in order of OLDEST to NEWEST
-   * @returns An array of {@linkcode TurnMove}, as described above.
+   * Entries are sorted in order of OLDEST to NEWEST.
+   * @returns An array of {@linkcode TurnMove}s, as described above.
    * @see {@linkcode getLastXMoves}
    */
   public getMoveHistory(): TurnMove[] {
     return this.summonData.moveHistory;
   }
 
+  /**
+   * Add a move to the end of this {@linkcode Pokemon}'s move history,
+   * used to record its most recently executed actions.
+   * @param turnMove - The {@linkcode TurnMove} to add
+   */
   public pushMoveHistory(turnMove: TurnMove): void {
     if (!this.isOnField()) {
       return;
@@ -5822,45 +5829,59 @@ export class PlayerPokemon extends Pokemon {
       );
     });
   }
-
-  addFriendship(friendship: number): void {
-    if (friendship > 0) {
-      const starterSpeciesId = this.species.getRootSpeciesId();
-      const fusionStarterSpeciesId = this.isFusion() && this.fusionSpecies ? this.fusionSpecies.getRootSpeciesId() : 0;
-      const starterData = [
-        globalScene.gameData.starterData[starterSpeciesId],
-        fusionStarterSpeciesId ? globalScene.gameData.starterData[fusionStarterSpeciesId] : null,
-      ].filter(d => !!d);
-      const amount = new NumberHolder(friendship);
-      globalScene.applyModifier(PokemonFriendshipBoosterModifier, true, this, amount);
-      const candyFriendshipMultiplier = globalScene.gameMode.isClassic
-        ? timedEventManager.getClassicFriendshipMultiplier()
-        : 1;
-      const fusionReduction = fusionStarterSpeciesId
-        ? timedEventManager.areFusionsBoosted()
-          ? 1.5 // Divide candy gain for fusions by 1.5 during events
-          : 2 // 2 for fusions outside events
-        : 1; // 1 for non-fused mons
-      const starterAmount = new NumberHolder(Math.floor((amount.value * candyFriendshipMultiplier) / fusionReduction));
-
-      // Add friendship to this PlayerPokemon
-      this.friendship = Math.min(this.friendship + amount.value, 255);
-      if (this.friendship === 255) {
-        globalScene.validateAchv(achvs.MAX_FRIENDSHIP);
-      }
-      // Add to candy progress for this mon's starter species and its fused species (if it has one)
-      starterData.forEach((sd: StarterDataEntry, i: number) => {
-        const speciesId = !i ? starterSpeciesId : (fusionStarterSpeciesId as SpeciesId);
-        sd.friendship = (sd.friendship || 0) + starterAmount.value;
-        if (sd.friendship >= getStarterValueFriendshipCap(speciesStarterCosts[speciesId])) {
-          globalScene.gameData.addStarterCandy(getPokemonSpecies(speciesId), 1);
-          sd.friendship = 0;
-        }
-      });
-    } else {
-      // Lose friendship upon fainting
+  /**
+   * Add friendship to this Pokemon
+   *
+   * @remarks
+   * This adds friendship to the pokemon's friendship stat (used for evolution, return, etc.) and candy progress.
+   * For fusions, candy progress for each species in the fusion is halved.
+   *
+   * @param friendship - The amount of friendship to add. Negative values will reduce friendship, though not below 0.
+   * @param capped - If true, don't allow the friendship gain to exceed 200. Used to cap friendship gains from rare candies.
+   */
+  addFriendship(friendship: number, capped = false): void {
+    // Short-circuit friendship loss, which doesn't impact candy friendship
+    if (friendship <= 0) {
       this.friendship = Math.max(this.friendship + friendship, 0);
+      return;
     }
+
+    const starterSpeciesId = this.species.getRootSpeciesId();
+    const fusionStarterSpeciesId = this.isFusion() && this.fusionSpecies ? this.fusionSpecies.getRootSpeciesId() : 0;
+    const starterGameData = globalScene.gameData.starterData;
+    const starterData: [StarterDataEntry, SpeciesId][] = [[starterGameData[starterSpeciesId], starterSpeciesId]];
+    if (fusionStarterSpeciesId) {
+      starterData.push([starterGameData[fusionStarterSpeciesId], fusionStarterSpeciesId]);
+    }
+    const amount = new NumberHolder(friendship);
+    globalScene.applyModifier(PokemonFriendshipBoosterModifier, true, this, amount);
+    friendship = amount.value;
+
+    const newFriendship = this.friendship + friendship;
+    // If capped is true, only adjust friendship if the new friendship is less than or equal to 200.
+    if (!capped || newFriendship <= RARE_CANDY_FRIENDSHIP_CAP) {
+      this.friendship = Math.min(newFriendship, 255);
+      if (newFriendship >= 255) {
+        globalScene.validateAchv(achvs.MAX_FRIENDSHIP);
+        awardRibbonsToSpeciesLine(this.species.speciesId, RibbonData.FRIENDSHIP);
+      }
+    }
+
+    let candyFriendshipMultiplier = globalScene.gameMode.isClassic
+      ? timedEventManager.getClassicFriendshipMultiplier()
+      : 1;
+    if (fusionStarterSpeciesId) {
+      candyFriendshipMultiplier /= timedEventManager.areFusionsBoosted() ? 1.5 : 2;
+    }
+    const candyFriendshipAmount = Math.floor(friendship * candyFriendshipMultiplier);
+    // Add to candy progress for this mon's starter species and its fused species (if it has one)
+    starterData.forEach(([sd, id]: [StarterDataEntry, SpeciesId]) => {
+      sd.friendship = (sd.friendship || 0) + candyFriendshipAmount;
+      if (sd.friendship >= getStarterValueFriendshipCap(speciesStarterCosts[id])) {
+        globalScene.gameData.addStarterCandy(getPokemonSpecies(id), 1);
+        sd.friendship = 0;
+      }
+    });
   }
 
   getPossibleEvolution(evolution: SpeciesFormEvolution | null): Promise<Pokemon> {
@@ -6241,22 +6262,22 @@ export class EnemyPokemon extends Pokemon {
       this.setBoss(boss, dataSource?.bossSegments);
     }
 
-    if (Overrides.OPP_STATUS_OVERRIDE) {
-      this.status = new Status(Overrides.OPP_STATUS_OVERRIDE, 0, 4);
+    if (Overrides.ENEMY_STATUS_OVERRIDE) {
+      this.status = new Status(Overrides.ENEMY_STATUS_OVERRIDE, 0, 4);
     }
 
-    if (Overrides.OPP_GENDER_OVERRIDE !== null) {
-      this.gender = Overrides.OPP_GENDER_OVERRIDE;
+    if (Overrides.ENEMY_GENDER_OVERRIDE !== null) {
+      this.gender = Overrides.ENEMY_GENDER_OVERRIDE;
     }
 
     const speciesId = this.species.speciesId;
 
     if (
-      speciesId in Overrides.OPP_FORM_OVERRIDES &&
-      !isNullOrUndefined(Overrides.OPP_FORM_OVERRIDES[speciesId]) &&
-      this.species.forms[Overrides.OPP_FORM_OVERRIDES[speciesId]]
+      speciesId in Overrides.ENEMY_FORM_OVERRIDES &&
+      !isNullOrUndefined(Overrides.ENEMY_FORM_OVERRIDES[speciesId]) &&
+      this.species.forms[Overrides.ENEMY_FORM_OVERRIDES[speciesId]]
     ) {
-      this.formIndex = Overrides.OPP_FORM_OVERRIDES[speciesId];
+      this.formIndex = Overrides.ENEMY_FORM_OVERRIDES[speciesId];
     } else if (globalScene.gameMode.isDaily && globalScene.gameMode.isWaveFinal(globalScene.currentBattle.waveIndex)) {
       const eventBoss = getDailyEventSeedBoss(globalScene.seed);
       if (!isNullOrUndefined(eventBoss)) {
@@ -6266,21 +6287,21 @@ export class EnemyPokemon extends Pokemon {
 
     if (!dataSource) {
       this.generateAndPopulateMoveset();
-      if (shinyLock || Overrides.OPP_SHINY_OVERRIDE === false) {
+      if (shinyLock || Overrides.ENEMY_SHINY_OVERRIDE === false) {
         this.shiny = false;
       } else {
         this.trySetShiny();
       }
 
-      if (!this.shiny && Overrides.OPP_SHINY_OVERRIDE) {
+      if (!this.shiny && Overrides.ENEMY_SHINY_OVERRIDE) {
         this.shiny = true;
         this.initShinySparkle();
       }
 
       if (this.shiny) {
         this.variant = this.generateShinyVariant();
-        if (Overrides.OPP_VARIANT_OVERRIDE !== null) {
-          this.variant = Overrides.OPP_VARIANT_OVERRIDE;
+        if (Overrides.ENEMY_VARIANT_OVERRIDE !== null) {
+          this.variant = Overrides.ENEMY_VARIANT_OVERRIDE;
         }
       }
 

src/loading-scene.ts

@@ -90,6 +90,7 @@ export class LoadingScene extends SceneBase {
     this.loadAtlas("shiny_icons", "ui");
     this.loadImage("ha_capsule", "ui", "ha_capsule.png");
     this.loadImage("champion_ribbon", "ui", "champion_ribbon.png");
+    this.loadImage("champion_ribbon_emerald", "ui", "champion_ribbon_emerald.png");
     this.loadImage("icon_spliced", "ui");
     this.loadImage("icon_lock", "ui", "icon_lock.png");
     this.loadImage("icon_stop", "ui", "icon_stop.png");
@@ -122,6 +123,7 @@ export class LoadingScene extends SceneBase {
     this.loadImage("party_bg_double", "ui");
     this.loadImage("party_bg_double_manage", "ui");
     this.loadAtlas("party_slot_main", "ui");
+    this.loadAtlas("party_slot_main_short", "ui");
     this.loadAtlas("party_slot", "ui");
     this.loadImage("party_slot_overlay_lv", "ui");
     this.loadImage("party_slot_hp_bar", "ui");

src/modifier/modifier.ts

@@ -2304,7 +2304,7 @@ export class PokemonLevelIncrementModifier extends ConsumablePokemonModifier {
       playerPokemon.levelExp = 0;
     }
 
-    playerPokemon.addFriendship(FRIENDSHIP_GAIN_FROM_RARE_CANDY);
+    playerPokemon.addFriendship(FRIENDSHIP_GAIN_FROM_RARE_CANDY, true);
 
     globalScene.phaseManager.unshiftNew(
       "LevelUpPhase",
@@ -3755,7 +3755,7 @@ export class EnemyFusionChanceModifier extends EnemyPersistentModifier {
 export function overrideModifiers(isPlayer = true): void {
   const modifiersOverride: ModifierOverride[] = isPlayer
     ? Overrides.STARTING_MODIFIER_OVERRIDE
-    : Overrides.OPP_MODIFIER_OVERRIDE;
+    : Overrides.ENEMY_MODIFIER_OVERRIDE;
   if (!modifiersOverride || modifiersOverride.length === 0 || !globalScene) {
     return;
   }
@@ -3797,7 +3797,7 @@ export function overrideModifiers(isPlayer = true): void {
 export function overrideHeldItems(pokemon: Pokemon, isPlayer = true): void {
   const heldItemsOverride: ModifierOverride[] = isPlayer
     ? Overrides.STARTING_HELD_ITEMS_OVERRIDE
-    : Overrides.OPP_HELD_ITEMS_OVERRIDE;
+    : Overrides.ENEMY_HELD_ITEMS_OVERRIDE;
   if (!heldItemsOverride || heldItemsOverride.length === 0 || !globalScene) {
     return;
   }

src/overrides.ts

@@ -179,25 +179,24 @@ class DefaultOverrides {
   // --------------------------
   // OPPONENT / ENEMY OVERRIDES
   // --------------------------
-  // TODO: rename `OPP_` to `ENEMY_`
-  readonly OPP_SPECIES_OVERRIDE: SpeciesId | number = 0;
+  readonly ENEMY_SPECIES_OVERRIDE: SpeciesId | number = 0;
   /**
    * This will make all opponents fused Pokemon
    */
-  readonly OPP_FUSION_OVERRIDE: boolean = false;
+  readonly ENEMY_FUSION_OVERRIDE: boolean = false;
   /**
    * This will override the species of the fusion only when the opponent is already a fusion
    */
-  readonly OPP_FUSION_SPECIES_OVERRIDE: SpeciesId | number = 0;
-  readonly OPP_LEVEL_OVERRIDE: number = 0;
-  readonly OPP_ABILITY_OVERRIDE: AbilityId = AbilityId.NONE;
-  readonly OPP_PASSIVE_ABILITY_OVERRIDE: AbilityId = AbilityId.NONE;
-  readonly OPP_HAS_PASSIVE_ABILITY_OVERRIDE: boolean | null = null;
-  readonly OPP_STATUS_OVERRIDE: StatusEffect = StatusEffect.NONE;
-  readonly OPP_GENDER_OVERRIDE: Gender | null = null;
-  readonly OPP_MOVESET_OVERRIDE: MoveId | Array<MoveId> = [];
-  readonly OPP_SHINY_OVERRIDE: boolean | null = null;
-  readonly OPP_VARIANT_OVERRIDE: Variant | null = null;
+  readonly ENEMY_FUSION_SPECIES_OVERRIDE: SpeciesId | number = 0;
+  readonly ENEMY_LEVEL_OVERRIDE: number = 0;
+  readonly ENEMY_ABILITY_OVERRIDE: AbilityId = AbilityId.NONE;
+  readonly ENEMY_PASSIVE_ABILITY_OVERRIDE: AbilityId = AbilityId.NONE;
+  readonly ENEMY_HAS_PASSIVE_ABILITY_OVERRIDE: boolean | null = null;
+  readonly ENEMY_STATUS_OVERRIDE: StatusEffect = StatusEffect.NONE;
+  readonly ENEMY_GENDER_OVERRIDE: Gender | null = null;
+  readonly ENEMY_MOVESET_OVERRIDE: MoveId | Array<MoveId> = [];
+  readonly ENEMY_SHINY_OVERRIDE: boolean | null = null;
+  readonly ENEMY_VARIANT_OVERRIDE: Variant | null = null;
   /**
    * Overrides the IVs of enemy pokemon. Values must never be outside the range `0` to `31`!
    * - If set to a number between `0` and `31`, set all IVs of all enemy pokemon to that number.
@@ -207,7 +206,7 @@ class DefaultOverrides {
   readonly ENEMY_IVS_OVERRIDE: number | number[] | null = null;
   /** Override the nature of all enemy pokemon to the specified nature. Disabled if `null`. */
   readonly ENEMY_NATURE_OVERRIDE: Nature | null = null;
-  readonly OPP_FORM_OVERRIDES: Partial<Record<SpeciesId, number>> = {};
+  readonly ENEMY_FORM_OVERRIDES: Partial<Record<SpeciesId, number>> = {};
   /**
    * Override to give the enemy Pokemon a given amount of health segments
    *
@@ -215,7 +214,7 @@ class DefaultOverrides {
    * 1: the Pokemon will have a single health segment and therefore will not be a boss
    * 2+: the Pokemon will be a boss with the given number of health segments
    */
-  readonly OPP_HEALTH_SEGMENTS_OVERRIDE: number = 0;
+  readonly ENEMY_HEALTH_SEGMENTS_OVERRIDE: number = 0;
 
   // -------------
   // EGG OVERRIDES
@@ -277,12 +276,12 @@ class DefaultOverrides {
    *
    * Note that any previous modifiers are cleared.
    */
-  readonly OPP_MODIFIER_OVERRIDE: ModifierOverride[] = [];
+  readonly ENEMY_MODIFIER_OVERRIDE: ModifierOverride[] = [];
 
   /** Override array of {@linkcode ModifierOverride}s used to provide held items to first party member when starting a new game. */
   readonly STARTING_HELD_ITEMS_OVERRIDE: ModifierOverride[] = [];
   /** Override array of {@linkcode ModifierOverride}s used to provide held items to enemies on spawn. */
-  readonly OPP_HELD_ITEMS_OVERRIDE: ModifierOverride[] = [];
+  readonly ENEMY_HELD_ITEMS_OVERRIDE: ModifierOverride[] = [];
 
   /**
    * Override array of {@linkcode ModifierOverride}s used to replace the generated item rolls after a wave.

src/phase-manager.ts

@@ -44,6 +44,7 @@ import { MoveEffectPhase } from "#phases/move-effect-phase";
 import { MoveEndPhase } from "#phases/move-end-phase";
 import { MoveHeaderPhase } from "#phases/move-header-phase";
 import { MovePhase } from "#phases/move-phase";
+import { MoveReflectPhase } from "#phases/move-reflect-phase";
 import {
   MysteryEncounterBattlePhase,
   MysteryEncounterBattleStartCleanupPhase,
@@ -157,6 +158,7 @@ const PHASES = Object.freeze({
   MoveEffectPhase,
   MoveEndPhase,
   MoveHeaderPhase,
+  MoveReflectPhase,
   MovePhase,
   MysteryEncounterPhase,
   MysteryEncounterOptionSelectedPhase,
@@ -414,6 +416,8 @@ export class PhaseManager {
    * @param phaseFilter filter function to use to find the wanted phase
    * @returns the found phase or undefined if none found
    */
+  findPhase<P extends Phase = Phase>(phaseFilter: (phase: Phase) => phase is P): P | undefined;
+  findPhase<P extends Phase = Phase>(phaseFilter: (phase: P) => boolean): P | undefined;
   findPhase<P extends Phase = Phase>(phaseFilter: (phase: P) => boolean): P | undefined {
     return this.phaseQueue.find(phaseFilter) as P | undefined;
   }

src/phases/command-phase.ts

@@ -178,11 +178,6 @@ export class CommandPhase extends FieldPhase {
 
     this.checkCommander();
 
-    const playerPokemon = this.getPokemon();
-
-    // Note: It is OK to call this if the target is not under the effect of encore; it will simply do nothing.
-    playerPokemon.lapseTag(BattlerTagType.ENCORE);
-
     if (globalScene.currentBattle.turnCommands[this.fieldIndex]?.skip) {
       this.end();
       return;

src/phases/encounter-phase.ts

@@ -229,7 +229,7 @@ export class EncounterPhase extends BattlePhase {
         }),
       );
     } else {
-      const overridedBossSegments = Overrides.OPP_HEALTH_SEGMENTS_OVERRIDE > 1;
+      const overridedBossSegments = Overrides.ENEMY_HEALTH_SEGMENTS_OVERRIDE > 1;
       // for double battles, reduce the health segments for boss Pokemon unless there is an override
       if (!overridedBossSegments && battle.enemyParty.filter(p => p.isBoss()).length > 1) {
         for (const enemyPokemon of battle.enemyParty) {

src/phases/game-over-phase.ts

@@ -19,8 +19,11 @@ import { ChallengeData } from "#system/challenge-data";
 import type { SessionSaveData } from "#system/game-data";
 import { ModifierData as PersistentModifierData } from "#system/modifier-data";
 import { PokemonData } from "#system/pokemon-data";
+import { RibbonData, type RibbonFlag } from "#system/ribbons/ribbon-data";
+import { awardRibbonsToSpeciesLine } from "#system/ribbons/ribbon-methods";
 import { TrainerData } from "#system/trainer-data";
 import { trainerConfigs } from "#trainers/trainer-config";
+import { checkSpeciesValidForChallenge, isNuzlockeChallenge } from "#utils/challenge-utils";
 import { isLocal, isLocalServerConnected } from "#utils/common";
 import { getPokemonSpecies } from "#utils/pokemon-utils";
 import i18next from "i18next";
@@ -111,6 +114,40 @@ export class GameOverPhase extends BattlePhase {
     }
   }
 
+  /**
+   * Submethod of {@linkcode handleGameOver} that awards ribbons to Pokémon in the player's party based on the current
+   * game mode and challenges.
+   */
+  private awardRibbons(): void {
+    let ribbonFlags = 0;
+    if (globalScene.gameMode.isClassic) {
+      ribbonFlags |= RibbonData.CLASSIC;
+    }
+    if (isNuzlockeChallenge()) {
+      ribbonFlags |= RibbonData.NUZLOCKE;
+    }
+    for (const challenge of globalScene.gameMode.challenges) {
+      const ribbon = challenge.ribbonAwarded;
+      if (challenge.value && ribbon) {
+        ribbonFlags |= ribbon;
+      }
+    }
+    // Award ribbons to all Pokémon in the player's party that are considered valid
+    // for the current game mode and challenges.
+    for (const pokemon of globalScene.getPlayerParty()) {
+      const species = pokemon.species;
+      if (
+        checkSpeciesValidForChallenge(
+          species,
+          globalScene.gameData.getSpeciesDexAttrProps(species, pokemon.getDexAttr()),
+          false,
+        )
+      ) {
+        awardRibbonsToSpeciesLine(species.speciesId, ribbonFlags as RibbonFlag);
+      }
+    }
+  }
+
   handleGameOver(): void {
     const doGameOver = (newClear: boolean) => {
       globalScene.disableMenu = true;
@@ -122,12 +159,12 @@ export class GameOverPhase extends BattlePhase {
             globalScene.validateAchv(achvs.UNEVOLVED_CLASSIC_VICTORY);
             globalScene.gameData.gameStats.sessionsWon++;
             for (const pokemon of globalScene.getPlayerParty()) {
-              this.awardRibbon(pokemon);
-
+              this.awardFirstClassicCompletion(pokemon);
               if (pokemon.species.getRootSpeciesId() !== pokemon.species.getRootSpeciesId(true)) {
-                this.awardRibbon(pokemon, true);
+                this.awardFirstClassicCompletion(pokemon, true);
               }
             }
+            this.awardRibbons();
           } else if (globalScene.gameMode.isDaily && newClear) {
             globalScene.gameData.gameStats.dailyRunSessionsWon++;
           }
@@ -263,7 +300,7 @@ export class GameOverPhase extends BattlePhase {
     }
   }
 
-  awardRibbon(pokemon: Pokemon, forStarter = false): void {
+  awardFirstClassicCompletion(pokemon: Pokemon, forStarter = false): void {
     const speciesId = getPokemonSpecies(pokemon.species.speciesId);
     const speciesRibbonCount = globalScene.gameData.incrementRibbonCount(speciesId, forStarter);
     // first time classic win, award voucher

src/phases/move-effect-phase.ts

@@ -1,7 +1,6 @@
 import { applyAbAttrs } from "#abilities/apply-ab-attrs";
 import { globalScene } from "#app/global-scene";
 import { getPokemonNameWithAffix } from "#app/messages";
-import type { Phase } from "#app/phase";
 import { ConditionalProtectTag } from "#data/arena-tag";
 import { MoveAnim } from "#data/battle-anims";
 import { DamageProtectedTag, ProtectedTag, SemiInvulnerableTag, SubstituteTag, TypeBoostTag } from "#data/battler-tags";
@@ -33,8 +32,7 @@ import {
 } from "#modifiers/modifier";
 import { applyFilteredMoveAttrs, applyMoveAttrs } from "#moves/apply-attrs";
 import type { Move, MoveAttr } from "#moves/move";
-import { getMoveTargets, isFieldTargeted } from "#moves/move-utils";
-import { PokemonMove } from "#moves/pokemon-move";
+import { isFieldTargeted } from "#moves/move-utils";
 import { PokemonPhase } from "#phases/pokemon-phase";
 import { DamageAchv } from "#system/achv";
 import type { DamageResult } from "#types/damage-result";
@@ -67,12 +65,6 @@ export class MoveEffectPhase extends PokemonPhase {
   /** Is this the last strike of a move? */
   private lastHit: boolean;
 
-  /**
-   * Phases queued during moves; used to add a new MovePhase for reflected moves after triggering.
-   * TODO: Remove this and move the reflection logic to ability-side
-   */
-  private queuedPhases: Phase[] = [];
-
   /**
    * @param useMode - The {@linkcode MoveUseMode} corresponding to how this move was used.
    */
@@ -95,143 +87,11 @@ export class MoveEffectPhase extends PokemonPhase {
     this.hitChecks = Array(this.targets.length).fill([HitCheckResult.PENDING, 0]);
   }
 
-  /**
-   * Compute targets and the results of hit checks of the invoked move against all targets,
-   * organized by battler index.
-   *
-   * **This is *not* a pure function**; it has the following side effects
-   * - `this.hitChecks` - The results of the hit checks against each target
-   * - `this.moveHistoryEntry` - Sets success or failure based on the hit check results
-   * - user.turnData.hitCount and user.turnData.hitsLeft - Both set to 1 if the
-   *   move was unsuccessful against all targets
-   *
-   * @returns The targets of the invoked move
-   * @see {@linkcode hitCheck}
-   */
-  private conductHitChecks(user: Pokemon, fieldMove: boolean): Pokemon[] {
-    /** All Pokemon targeted by this phase's invoked move */
-    /** Whether any hit check ended in a success */
-    let anySuccess = false;
-    /** Whether the attack missed all of its targets */
-    let allMiss = true;
-
-    let targets = this.getTargets();
-
-    // For field targeted moves, we only look for the first target that may magic bounce
-
-    for (const [i, target] of targets.entries()) {
-      const hitCheck = this.hitCheck(target);
-      // If the move bounced and was a field targeted move,
-      // then immediately stop processing other targets
-      if (fieldMove && hitCheck[0] === HitCheckResult.REFLECTED) {
-        targets = [target];
-        this.hitChecks = [hitCheck];
-        break;
-      }
-      if (hitCheck[0] === HitCheckResult.HIT) {
-        anySuccess = true;
-      } else {
-        allMiss ||= hitCheck[0] === HitCheckResult.MISS;
-      }
-      this.hitChecks[i] = hitCheck;
-    }
-
-    if (anySuccess) {
-      this.moveHistoryEntry.result = MoveResult.SUCCESS;
-    } else {
-      user.turnData.hitCount = 1;
-      user.turnData.hitsLeft = 1;
-      this.moveHistoryEntry.result = allMiss ? MoveResult.MISS : MoveResult.FAIL;
-    }
-
-    return targets;
-  }
-
-  /**
-   * Queue the phaes that should occur when the target reflects the move back to the user
-   * @param user - The {@linkcode Pokemon} using this phase's invoked move
-   * @param target - The {@linkcode Pokemon} that is reflecting the move
-   * TODO: Rework this to use `onApply` of Magic Coat
-   */
-  private queueReflectedMove(user: Pokemon, target: Pokemon): void {
-    const newTargets = this.move.isMultiTarget()
-      ? getMoveTargets(target, this.move.id).targets
-      : [user.getBattlerIndex()];
-    // TODO: ability displays should be handled by the ability
-    if (!target.getTag(BattlerTagType.MAGIC_COAT)) {
-      this.queuedPhases.push(
-        globalScene.phaseManager.create(
-          "ShowAbilityPhase",
-          target.getBattlerIndex(),
-          target.getPassiveAbility().hasAttr("ReflectStatusMoveAbAttr"),
-        ),
-      );
-      this.queuedPhases.push(globalScene.phaseManager.create("HideAbilityPhase"));
-    }
-
-    this.queuedPhases.push(
-      globalScene.phaseManager.create(
-        "MovePhase",
-        target,
-        newTargets,
-        new PokemonMove(this.move.id),
-        MoveUseMode.REFLECTED,
-      ),
-    );
-  }
-
-  /**
-   * Apply the move to each of the resolved targets.
-   * @param targets - The resolved set of targets of the move
-   * @throws Error if there was an unexpected hit check result
-   */
-  private applyToTargets(user: Pokemon, targets: Pokemon[]): void {
-    let firstHit = true;
-    for (const [i, target] of targets.entries()) {
-      const [hitCheckResult, effectiveness] = this.hitChecks[i];
-      switch (hitCheckResult) {
-        case HitCheckResult.HIT:
-          this.applyMoveEffects(target, effectiveness, firstHit);
-          firstHit = false;
-          if (isFieldTargeted(this.move)) {
-            // Stop processing other targets if the move is a field move
-            return;
-          }
-          break;
-        // biome-ignore lint/suspicious/noFallthroughSwitchClause: The fallthrough is intentional
-        case HitCheckResult.NO_EFFECT:
-          globalScene.phaseManager.queueMessage(
-            i18next.t(this.move.id === MoveId.SHEER_COLD ? "battle:hitResultImmune" : "battle:hitResultNoEffect", {
-              pokemonName: getPokemonNameWithAffix(target),
-            }),
-          );
-        case HitCheckResult.NO_EFFECT_NO_MESSAGE:
-        case HitCheckResult.PROTECTED:
-        case HitCheckResult.TARGET_NOT_ON_FIELD:
-          applyMoveAttrs("NoEffectAttr", user, target, this.move);
-          break;
-        case HitCheckResult.MISS:
-          globalScene.phaseManager.queueMessage(
-            i18next.t("battle:attackMissed", { pokemonNameWithAffix: getPokemonNameWithAffix(target) }),
-          );
-          applyMoveAttrs("MissEffectAttr", user, target, this.move);
-          break;
-        case HitCheckResult.REFLECTED:
-          this.queueReflectedMove(user, target);
-          break;
-        case HitCheckResult.PENDING:
-        case HitCheckResult.ERROR:
-          throw new Error("Unexpected hit check result");
-      }
-    }
-  }
-
   public override start(): void {
     super.start();
 
     /** The Pokemon using this phase's invoked move */
     const user = this.getUserPokemon();
-
     if (!user) {
       super.end();
       return;
@@ -326,6 +186,58 @@ export class MoveEffectPhase extends PokemonPhase {
     this.postAnimCallback(user, targets);
   }
 
+  /**
+   * Compute targets and the results of hit checks of the invoked move against all targets,
+   * organized by battler index.
+   *
+   * **This is *not* a pure function**; it has the following side effects
+   * - `this.hitChecks` - The results of the hit checks against each target
+   * - `this.moveHistoryEntry` - Sets success or failure based on the hit check results
+   * - user.turnData.hitCount and user.turnData.hitsLeft - Both set to 1 if the
+   *   move was unsuccessful against all targets
+   *
+   * @returns The targets of the invoked move
+   * @see {@linkcode hitCheck}
+   */
+  private conductHitChecks(user: Pokemon, fieldMove: boolean): Pokemon[] {
+    /** All Pokemon targeted by this phase's invoked move */
+    /** Whether any hit check ended in a success */
+    let anySuccess = false;
+    /** Whether the attack missed all of its targets */
+    let allMiss = true;
+
+    let targets = this.getTargets();
+
+    // For field targeted moves, we only look for the first target that may magic bounce
+
+    for (const [i, target] of targets.entries()) {
+      const hitCheck = this.hitCheck(target);
+      // If the move bounced and was a field targeted move,
+      // then immediately stop processing other targets
+      if (fieldMove && hitCheck[0] === HitCheckResult.REFLECTED) {
+        targets = [target];
+        this.hitChecks = [hitCheck];
+        break;
+      }
+      if (hitCheck[0] === HitCheckResult.HIT) {
+        anySuccess = true;
+      } else {
+        allMiss ||= hitCheck[0] === HitCheckResult.MISS;
+      }
+      this.hitChecks[i] = hitCheck;
+    }
+
+    if (anySuccess) {
+      this.moveHistoryEntry.result = MoveResult.SUCCESS;
+    } else {
+      user.turnData.hitCount = 1;
+      user.turnData.hitsLeft = 1;
+      this.moveHistoryEntry.result = allMiss ? MoveResult.MISS : MoveResult.FAIL;
+    }
+
+    return targets;
+  }
+
   /**
    * Callback to be called after the move animation is played
    */
@@ -344,9 +256,6 @@ export class MoveEffectPhase extends PokemonPhase {
       return;
     }
 
-    if (this.queuedPhases.length) {
-      globalScene.phaseManager.appendToPhase(this.queuedPhases, "MoveEndPhase");
-    }
     const moveType = user.getMoveType(this.move, true);
     if (this.move.category !== MoveCategory.STATUS && !user.stellarTypesBoosted.includes(moveType)) {
       user.stellarTypesBoosted.push(moveType);
@@ -360,121 +269,52 @@ export class MoveEffectPhase extends PokemonPhase {
     this.end();
   }
 
-  public override end(): void {
-    const user = this.getUserPokemon();
-    if (!user) {
-      super.end();
-      return;
-    }
-
-    /**
-     * If this phase isn't for the invoked move's last strike (and we still have something to hit),
-     * unshift another MoveEffectPhase for the next strike before ending this phase.
-     */
-    if (--user.turnData.hitsLeft >= 1 && this.getFirstTarget()) {
-      this.addNextHitPhase();
-      super.end();
-      return;
-    }
-
-    /**
-     * All hits of the move have resolved by now.
-     * Queue message for multi-strike moves before applying Shell Bell heals & proccing Dancer-like effects.
-     */
-    const hitsTotal = user.turnData.hitCount - Math.max(user.turnData.hitsLeft, 0);
-    if (hitsTotal > 1 || user.turnData.hitsLeft > 0) {
-      // Queue message if multiple hits occurred or were slated to occur (such as a Triple Axel miss)
-      globalScene.phaseManager.queueMessage(i18next.t("battle:attackHitsCount", { count: hitsTotal }));
-    }
-
-    globalScene.applyModifiers(HitHealModifier, this.player, user);
-    this.getTargets().forEach(target => {
-      target.turnData.moveEffectiveness = null;
-    });
-    super.end();
-  }
-
   /**
-   * Applies reactive effects that occur when a Pokémon is hit.
-   * (i.e. Effect Spore, Disguise, Liquid Ooze, Beak Blast)
-   * @param user - The {@linkcode Pokemon} using this phase's invoked move
-   * @param target - {@linkcode Pokemon} the current target of this phase's invoked move
-   * @param hitResult - The {@linkcode HitResult} of the attempted move
-   * @param wasCritical - `true` if the move was a critical hit
+   * Apply the move to each of the resolved targets.
+   * @param targets - The resolved set of targets of the move
+   * @throws Error if there was an unexpected hit check result
    */
-  protected applyOnGetHitAbEffects(user: Pokemon, target: Pokemon, hitResult: HitResult, wasCritical = false): void {
-    const params = { pokemon: target, opponent: user, move: this.move, hitResult };
-    applyAbAttrs("PostDefendAbAttr", params);
-
-    if (wasCritical) {
-      applyAbAttrs("PostReceiveCritStatStageChangeAbAttr", params);
-    }
-    target.lapseTags(BattlerTagLapseType.AFTER_HIT);
-  }
-
-  /**
-   * Handles checking for and applying Flinches
-   * @param user - The {@linkcode Pokemon} using this phase's invoked move
-   * @param target - {@linkcode Pokemon} the current target of this phase's invoked move
-   * @param dealsDamage - `true` if the attempted move successfully dealt damage
-   */
-  protected applyHeldItemFlinchCheck(user: Pokemon, target: Pokemon, dealsDamage: boolean): void {
-    if (this.move.hasAttr("FlinchAttr")) {
-      return;
-    }
-
-    if (
-      dealsDamage &&
-      !target.hasAbilityWithAttr("IgnoreMoveEffectsAbAttr") &&
-      !this.move.hitsSubstitute(user, target)
-    ) {
-      const flinched = new BooleanHolder(false);
-      globalScene.applyModifiers(FlinchChanceModifier, user.isPlayer(), user, flinched);
-      if (flinched.value) {
-        target.addTag(BattlerTagType.FLINCHED, undefined, this.move.id, user.id);
+  private applyToTargets(user: Pokemon, targets: Pokemon[]): void {
+    let firstHit = true;
+    for (const [i, target] of targets.entries()) {
+      const [hitCheckResult, effectiveness] = this.hitChecks[i];
+      switch (hitCheckResult) {
+        case HitCheckResult.HIT:
+          this.applyMoveEffects(target, effectiveness, firstHit);
+          firstHit = false;
+          if (isFieldTargeted(this.move)) {
+            // Stop processing other targets if the move is a field move
+            return;
+          }
+          break;
+        // biome-ignore lint/suspicious/noFallthroughSwitchClause: The fallthrough is intentional
+        case HitCheckResult.NO_EFFECT:
+          globalScene.phaseManager.queueMessage(
+            i18next.t(this.move.id === MoveId.SHEER_COLD ? "battle:hitResultImmune" : "battle:hitResultNoEffect", {
+              pokemonName: getPokemonNameWithAffix(target),
+            }),
+          );
+        case HitCheckResult.NO_EFFECT_NO_MESSAGE:
+        case HitCheckResult.PROTECTED:
+        case HitCheckResult.TARGET_NOT_ON_FIELD:
+          applyMoveAttrs("NoEffectAttr", user, target, this.move);
+          break;
+        case HitCheckResult.MISS:
+          globalScene.phaseManager.queueMessage(
+            i18next.t("battle:attackMissed", { pokemonNameWithAffix: getPokemonNameWithAffix(target) }),
+          );
+          applyMoveAttrs("MissEffectAttr", user, target, this.move);
+          break;
+        case HitCheckResult.REFLECTED:
+          globalScene.phaseManager.appendNewToPhase("MoveEndPhase", "MoveReflectPhase", target, user, this.move);
+          break;
+        case HitCheckResult.PENDING:
+        case HitCheckResult.ERROR:
+          throw new Error("Unexpected hit check result");
       }
     }
   }
 
-  /** Return whether the target is protected by protect or a relevant conditional protection
-   * @param user - The {@linkcode Pokemon} using this phase's invoked move
-   * @param target - {@linkcode Pokemon} the target to check for protection
-   * @param move - The {@linkcode Move} being used
-   * @returns Whether the pokemon was protected
-   */
-  private protectedCheck(user: Pokemon, target: Pokemon): boolean {
-    /** The {@linkcode ArenaTagSide} to which the target belongs */
-    const targetSide = target.isPlayer() ? ArenaTagSide.PLAYER : ArenaTagSide.ENEMY;
-    /** Has the invoked move been cancelled by conditional protection (e.g Quick Guard)? */
-    const hasConditionalProtectApplied = new BooleanHolder(false);
-    /** Does the applied conditional protection bypass Protect-ignoring effects? */
-    const bypassIgnoreProtect = new BooleanHolder(false);
-    /** If the move is not targeting a Pokemon on the user's side, try to apply conditional protection effects */
-    if (!this.move.isAllyTarget()) {
-      globalScene.arena.applyTagsForSide(
-        ConditionalProtectTag,
-        targetSide,
-        false,
-        hasConditionalProtectApplied,
-        user,
-        target,
-        this.move.id,
-        bypassIgnoreProtect,
-      );
-    }
-
-    // TODO: Break up this chunky boolean to make it more palatable
-    return (
-      ![MoveTarget.ENEMY_SIDE, MoveTarget.BOTH_SIDES].includes(this.move.moveTarget) &&
-      (bypassIgnoreProtect.value || !this.move.doesFlagEffectApply({ flag: MoveFlags.IGNORE_PROTECT, user, target })) &&
-      (hasConditionalProtectApplied.value ||
-        (!target.findTags(t => t instanceof DamageProtectedTag).length &&
-          target.findTags(t => t instanceof ProtectedTag).some(t => target.lapseTag(t.tagType))) ||
-        (this.move.category !== MoveCategory.STATUS &&
-          target.findTags(t => t instanceof DamageProtectedTag).some(t => target.lapseTag(t.tagType))))
-    );
-  }
-
   /**
    * Conduct the hit check and type effectiveness for this move against the target
    *
@@ -495,10 +335,6 @@ export class MoveEffectPhase extends PokemonPhase {
     const user = this.getUserPokemon();
     const move = this.move;
 
-    if (!user) {
-      return [HitCheckResult.ERROR, 0];
-    }
-
     // Moves targeting the user bypass all checks
     if (move.moveTarget === MoveTarget.USER) {
       return [HitCheckResult.HIT, 1];
@@ -532,7 +368,7 @@ export class MoveEffectPhase extends PokemonPhase {
     }
 
     // Reflected moves cannot be reflected again
-    if (!isReflected(this.useMode) && move.doesFlagEffectApply({ flag: MoveFlags.REFLECTABLE, user, target })) {
+    if (isMoveReflectableBy(this.move, target, this.useMode)) {
       return [HitCheckResult.REFLECTED, 0];
     }
 
@@ -603,9 +439,6 @@ export class MoveEffectPhase extends PokemonPhase {
    */
   public checkBypassAccAndInvuln(target: Pokemon) {
     const user = this.getUserPokemon();
-    if (!user) {
-      return false;
-    }
     if (user.hasAbilityWithAttr("AlwaysHitAbAttr") || target.hasAbilityWithAttr("AlwaysHitAbAttr")) {
       return true;
     }
@@ -637,79 +470,43 @@ export class MoveEffectPhase extends PokemonPhase {
     return move.getAttrs("HitsTagAttr").some(hta => hta.tagType === semiInvulnerableTag.tagType);
   }
 
-  /** @returns The {@linkcode Pokemon} using this phase's invoked move */
-  public getUserPokemon(): Pokemon | null {
-    // TODO: Make this purely a battler index
-    if (this.battlerIndex > BattlerIndex.ENEMY_2) {
-      return globalScene.getPokemonById(this.battlerIndex);
-    }
-    return (this.player ? globalScene.getPlayerField() : globalScene.getEnemyField())[this.fieldIndex];
-  }
-
   /**
-   * @returns An array of {@linkcode Pokemon} that are:
-   * - On-field and active
-   * - Non-fainted
-   * - Targeted by this phase's invoked move
+   * Check whether the target is protected by protect or a relevant conditional protection.
+   * @param user - The {@linkcode Pokemon} using this phase's invoked move
+   * @param target - The target {@linkcode Pokemon} to check for protection
+   * @returns Whether the target was protected
    */
-  public getTargets(): Pokemon[] {
-    return globalScene.getField(true).filter(p => this.targets.indexOf(p.getBattlerIndex()) > -1);
-  }
-
-  /** @returns The first active, non-fainted target of this phase's invoked move. */
-  public getFirstTarget(): Pokemon | undefined {
-    return this.getTargets()[0];
-  }
-
-  /**
-   * Removes the given {@linkcode Pokemon} from this phase's target list
-   * @param target - The {@linkcode Pokemon} to be removed
-   */
-  protected removeTarget(target: Pokemon): void {
-    const targetIndex = this.targets.indexOf(target.getBattlerIndex());
-    if (targetIndex !== -1) {
-      this.targets.splice(this.targets.indexOf(target.getBattlerIndex()), 1);
+  private protectedCheck(user: Pokemon, target: Pokemon): boolean {
+    /** The {@linkcode ArenaTagSide} to which the target belongs */
+    const targetSide = target.isPlayer() ? ArenaTagSide.PLAYER : ArenaTagSide.ENEMY;
+    /** Has the invoked move been cancelled by conditional protection (e.g Quick Guard)? */
+    const hasConditionalProtectApplied = new BooleanHolder(false);
+    /** Does the applied conditional protection bypass Protect-ignoring effects? */
+    const bypassIgnoreProtect = new BooleanHolder(false);
+    /** If the move is not targeting a Pokemon on the user's side, try to apply conditional protection effects */
+    if (!this.move.isAllyTarget()) {
+      globalScene.arena.applyTagsForSide(
+        ConditionalProtectTag,
+        targetSide,
+        false,
+        hasConditionalProtectApplied,
+        user,
+        target,
+        this.move.id,
+        bypassIgnoreProtect,
+      );
     }
-  }
 
-  /**
-   * Prevents subsequent strikes of this phase's invoked move from occurring
-   * @param target - If defined, only stop subsequent strikes against this {@linkcode Pokemon}
-   */
-  public stopMultiHit(target?: Pokemon): void {
-    // If given a specific target, remove the target from subsequent strikes
-    if (target) {
-      this.removeTarget(target);
-    }
-    const user = this.getUserPokemon();
-    if (!user) {
-      return;
-    }
-    // If no target specified, or the specified target was the last of this move's
-    // targets, completely cancel all subsequent strikes.
-    if (!target || this.targets.length === 0) {
-      user.turnData.hitCount = 1;
-      user.turnData.hitsLeft = 1;
-    }
-  }
-
-  /**
-   * Unshifts a new `MoveEffectPhase` with the same properties as this phase.
-   * Used to queue the next hit of multi-strike moves.
-   */
-  protected addNextHitPhase(): void {
-    globalScene.phaseManager.unshiftNew("MoveEffectPhase", this.battlerIndex, this.targets, this.move, this.useMode);
-  }
-
-  /** Removes all substitutes that were broken by this phase's invoked move */
-  protected updateSubstitutes(): void {
-    const targets = this.getTargets();
-    for (const target of targets) {
-      const substitute = target.getTag(SubstituteTag);
-      if (substitute && substitute.hp <= 0) {
-        target.lapseTag(BattlerTagType.SUBSTITUTE);
-      }
-    }
+    // TODO: Break up this chunky boolean to make it more palatable
+    return (
+      ![MoveTarget.ENEMY_SIDE, MoveTarget.BOTH_SIDES].includes(this.move.moveTarget) &&
+      (bypassIgnoreProtect.value || !this.move.doesFlagEffectApply({ flag: MoveFlags.IGNORE_PROTECT, user, target })) &&
+      (hasConditionalProtectApplied.value ||
+        (!target.findTags(t => t instanceof DamageProtectedTag).length &&
+          target.findTags(t => t instanceof ProtectedTag).some(t => target.lapseTag(t.tagType))) ||
+        (this.move.category !== MoveCategory.STATUS &&
+          target.findTags(t => t instanceof DamageProtectedTag).some(t => target.lapseTag(t.tagType))))
+    );
   }
 
   /**
@@ -757,9 +554,6 @@ export class MoveEffectPhase extends PokemonPhase {
    */
   protected applyMoveEffects(target: Pokemon, effectiveness: TypeDamageMultiplier, firstTarget: boolean): void {
     const user = this.getUserPokemon();
-    if (isNullOrUndefined(user)) {
-      return;
-    }
 
     this.triggerMoveEffects(MoveEffectTrigger.PRE_APPLY, user, target);
 
@@ -783,7 +577,33 @@ export class MoveEffectPhase extends PokemonPhase {
   }
 
   /**
-   * Sub-method of for {@linkcode applyMoveEffects} that applies damage to the target.
+   * Apply the result of this phase's move to the given target
+   * @param user - The {@linkcode Pokemon} using this phase's invoked move
+   * @param target - The {@linkcode Pokemon} struck by the move
+   * @param effectiveness - The effectiveness of the move against the target
+   */
+  protected applyMove(user: Pokemon, target: Pokemon, effectiveness: TypeDamageMultiplier): [HitResult, boolean] {
+    const moveCategory = user.getMoveCategory(target, this.move);
+
+    if (moveCategory === MoveCategory.STATUS) {
+      return [HitResult.STATUS, false];
+    }
+
+    const result = this.applyMoveDamage(user, target, effectiveness);
+
+    if (user.turnData.hitsLeft === 1 || target.isFainted()) {
+      this.queueHitResultMessage(result[0]);
+    }
+
+    if (target.isFainted()) {
+      this.onFaintTarget(user, target);
+    }
+
+    return result;
+  }
+
+  /**
+   * Sub-method of {@linkcode applyMove} that applies damage to the target.
    *
    * @param user - The {@linkcode Pokemon} using this phase's invoked move
    * @param target - The {@linkcode Pokemon} targeted by the move
@@ -882,6 +702,29 @@ export class MoveEffectPhase extends PokemonPhase {
     return [result, isCritical];
   }
 
+  /**
+   * Sub-method of {@linkcode applyMove} that queues the hit-result message
+   * on the final strike of the move against a target
+   * @param result - The {@linkcode HitResult} of the move
+   */
+  protected queueHitResultMessage(result: HitResult) {
+    let msg: string | undefined;
+    switch (result) {
+      case HitResult.SUPER_EFFECTIVE:
+        msg = i18next.t("battle:hitResultSuperEffective");
+        break;
+      case HitResult.NOT_VERY_EFFECTIVE:
+        msg = i18next.t("battle:hitResultNotVeryEffective");
+        break;
+      case HitResult.ONE_HIT_KO:
+        msg = i18next.t("battle:hitResultOneHitKO");
+        break;
+    }
+    if (msg) {
+      globalScene.phaseManager.queueMessage(msg);
+    }
+  }
+
   /**
    * Sub-method of {@linkcode applyMove} that handles the event of a target fainting.
    * @param user - The {@linkcode Pokemon} using this phase's invoked move
@@ -906,55 +749,7 @@ export class MoveEffectPhase extends PokemonPhase {
   }
 
   /**
-   * Sub-method of {@linkcode applyMove} that queues the hit-result message
-   * on the final strike of the move against a target
-   * @param result - The {@linkcode HitResult} of the move
-   */
-  protected queueHitResultMessage(result: HitResult) {
-    let msg: string | undefined;
-    switch (result) {
-      case HitResult.SUPER_EFFECTIVE:
-        msg = i18next.t("battle:hitResultSuperEffective");
-        break;
-      case HitResult.NOT_VERY_EFFECTIVE:
-        msg = i18next.t("battle:hitResultNotVeryEffective");
-        break;
-      case HitResult.ONE_HIT_KO:
-        msg = i18next.t("battle:hitResultOneHitKO");
-        break;
-    }
-    if (msg) {
-      globalScene.phaseManager.queueMessage(msg);
-    }
-  }
-
-  /** Apply the result of this phase's move to the given target
-   * @param user - The {@linkcode Pokemon} using this phase's invoked move
-   * @param target - The {@linkcode Pokemon} struck by the move
-   * @param effectiveness - The effectiveness of the move against the target
-   */
-  protected applyMove(user: Pokemon, target: Pokemon, effectiveness: TypeDamageMultiplier): [HitResult, boolean] {
-    const moveCategory = user.getMoveCategory(target, this.move);
-
-    if (moveCategory === MoveCategory.STATUS) {
-      return [HitResult.STATUS, false];
-    }
-
-    const result = this.applyMoveDamage(user, target, effectiveness);
-
-    if (user.turnData.hitsLeft === 1 || target.isFainted()) {
-      this.queueHitResultMessage(result[0]);
-    }
-
-    if (target.isFainted()) {
-      this.onFaintTarget(user, target);
-    }
-
-    return result;
-  }
-
-  /**
-   * Applies all effects aimed at the move's target.
+   * Sub-method of {@linkcode applyMovetEffects} that applies all effects aimed at the move's target.
    * To be used when the target is successfully and directly hit by the move.
    * @param user - The {@linkcode Pokemon} using the move
    * @param target - The {@linkcode Pokemon} targeted by the move
@@ -992,4 +787,173 @@ export class MoveEffectPhase extends PokemonPhase {
       globalScene.applyModifiers(ContactHeldItemTransferChanceModifier, this.player, user, target);
     }
   }
+
+  /**
+   * Sub-method of {@linkcode applyOnTargetEffects} that applies reactive effects that occur when a Pokémon is hit.
+   * (i.e. Effect Spore, Disguise, Liquid Ooze, Beak Blast)
+   * @param user - The {@linkcode Pokemon} using this phase's invoked move
+   * @param target - {@linkcode Pokemon} the current target of this phase's invoked move
+   * @param hitResult - The {@linkcode HitResult} of the attempted move
+   * @param wasCritical - `true` if the move was a critical hit
+   */
+  protected applyOnGetHitAbEffects(user: Pokemon, target: Pokemon, hitResult: HitResult, wasCritical = false): void {
+    const params = { pokemon: target, opponent: user, move: this.move, hitResult };
+    applyAbAttrs("PostDefendAbAttr", params);
+
+    if (wasCritical) {
+      applyAbAttrs("PostReceiveCritStatStageChangeAbAttr", params);
+    }
+    target.lapseTags(BattlerTagLapseType.AFTER_HIT);
+  }
+
+  /**
+   * Sub-method of {@linkcode applyOnTargetEffects} that handles checking for and applying flinches.
+   * @param user - The {@linkcode Pokemon} using this phase's invoked move
+   * @param target - {@linkcode Pokemon} the current target of this phase's invoked move
+   * @param dealsDamage - `true` if the attempted move successfully dealt damage
+   */
+  protected applyHeldItemFlinchCheck(user: Pokemon, target: Pokemon, dealsDamage: boolean): void {
+    if (this.move.hasAttr("FlinchAttr")) {
+      return;
+    }
+
+    if (
+      dealsDamage &&
+      !target.hasAbilityWithAttr("IgnoreMoveEffectsAbAttr") &&
+      !this.move.hitsSubstitute(user, target)
+    ) {
+      const flinched = new BooleanHolder(false);
+      globalScene.applyModifiers(FlinchChanceModifier, user.isPlayer(), user, flinched);
+      if (flinched.value) {
+        target.addTag(BattlerTagType.FLINCHED, undefined, this.move.id, user.id);
+      }
+    }
+  }
+
+  public override end(): void {
+    const user = this.getUserPokemon();
+
+    /**
+     * If this phase isn't for the invoked move's last strike (and we still have something to hit),
+     * unshift another MoveEffectPhase for the next strike before ending this phase.
+     */
+    if (--user.turnData.hitsLeft >= 1 && this.getFirstTarget()) {
+      this.addNextHitPhase();
+      super.end();
+      return;
+    }
+
+    /**
+     * All hits of the move have resolved by now.
+     * Queue message for multi-strike moves before applying Shell Bell heals & proccing Dancer-like effects.
+     */
+    const hitsTotal = user.turnData.hitCount - Math.max(user.turnData.hitsLeft, 0);
+    if (hitsTotal > 1 || user.turnData.hitsLeft > 0) {
+      // Queue message if multiple hits occurred or were slated to occur (such as a Triple Axel miss)
+      globalScene.phaseManager.queueMessage(i18next.t("battle:attackHitsCount", { count: hitsTotal }));
+    }
+
+    globalScene.applyModifiers(HitHealModifier, this.player, user);
+    this.getTargets().forEach(target => {
+      target.turnData.moveEffectiveness = null;
+    });
+    super.end();
+  }
+
+  // #region Helpers
+
+  /**
+   * @returns The {@linkcode Pokemon} using this phase's invoked move.
+   * Is never null during the move execution itself, as {@linkcode start} ends the phase immediately if a source is missing.
+   * @todo Delete in favor of {@linkcode PokemonPhase.getPokemon}
+   */
+  public getUserPokemon(): Pokemon {
+    return super.getPokemon()!;
+  }
+
+  /**
+   * @returns An array of {@linkcode Pokemon} that are:
+   * - On-field and active
+   * - Non-fainted
+   * - Targeted by this phase's invoked move
+   */
+  public getTargets(): Pokemon[] {
+    return globalScene.getField(true).filter(p => this.targets.indexOf(p.getBattlerIndex()) > -1);
+  }
+
+  /** @returns The first active, non-fainted target of this phase's invoked move. */
+  public getFirstTarget(): Pokemon | undefined {
+    return this.getTargets()[0];
+  }
+
+  /**
+   * Removes the given {@linkcode Pokemon} from this phase's target list
+   * @param target - The {@linkcode Pokemon} to be removed
+   */
+  protected removeTarget(target: Pokemon): void {
+    const targetIndex = this.targets.indexOf(target.getBattlerIndex());
+    if (targetIndex !== -1) {
+      this.targets.splice(this.targets.indexOf(target.getBattlerIndex()), 1);
+    }
+  }
+
+  /**
+   * Prevents subsequent strikes of this phase's invoked move from occurring
+   * @param target - If defined, only stop subsequent strikes against this {@linkcode Pokemon}
+   */
+  public stopMultiHit(target?: Pokemon): void {
+    // If given a specific target, remove the target from subsequent strikes
+    if (target) {
+      this.removeTarget(target);
+    }
+    const user = this.getUserPokemon();
+    // If no target specified, or the specified target was the last of this move's
+    // targets, completely cancel all subsequent strikes.
+    if (!target || this.targets.length === 0) {
+      user.turnData.hitCount = 1;
+      user.turnData.hitsLeft = 1;
+    }
+  }
+
+  /**
+   * Unshifts a new `MoveEffectPhase` with the same properties as this phase.
+   * Used to queue the next hit of multi-strike moves.
+   */
+  protected addNextHitPhase(): void {
+    globalScene.phaseManager.unshiftNew("MoveEffectPhase", this.battlerIndex, this.targets, this.move, this.useMode);
+  }
+
+  /** Removes all substitutes that were broken by this phase's invoked move */
+  protected updateSubstitutes(): void {
+    const targets = this.getTargets();
+    for (const target of targets) {
+      const substitute = target.getTag(SubstituteTag);
+      if (substitute && substitute.hp <= 0) {
+        target.lapseTag(BattlerTagType.SUBSTITUTE);
+      }
+    }
+  }
+
+  // # endregion Helpers
+}
+
+/**
+ * Check whether a given Move is able to be reflected by either
+ * {@linkcode MoveId.MAGIC_COAT | Magic Coat} or {@linkcode AbilityId.MAGIC_BOUNCE | Magic Bounce}.
+ * @param move - The {@linkcode Move} being used
+ * @param target - The targeted {@linkcode Pokemon} attempting to reflect the move
+ * @param useMode - The {@linkcode MoveUseMode} dictating how the move was used
+ * @returns Whether {@linkcode target} can reflect {@linkcode move}.
+ */
+function isMoveReflectableBy(move: Move, target: Pokemon, useMode: MoveUseMode): boolean {
+  return (
+    // The move must not have just been reflected
+    !isReflected(useMode) &&
+    // Reflections cannot occur while semi invulnerable
+    !target.getTag(SemiInvulnerableTag) &&
+    // Move must be reflectable
+    move.hasFlag(MoveFlags.REFLECTABLE) &&
+    // target must have a reflection effect active
+    (!!target.getTag(BattlerTagType.MAGIC_COAT) || target.hasAbilityWithAttr("ReflectStatusMoveAbAttr"))
+  );
 }

src/phases/move-reflect-phase.ts

@@ -0,0 +1,41 @@
+import { applyAbAttrs } from "#abilities/apply-ab-attrs";
+import { Phase } from "#app/phase";
+import type { MagicCoatTag } from "#data/battler-tags";
+import { BattlerTagType } from "#enums/battler-tag-type";
+// biome-ignore-start lint/correctness/noUnusedImports: TSDoc
+import type { MoveId } from "#enums/move-id";
+import type { Pokemon } from "#field/pokemon";
+import type { Move } from "#types/move-types";
+// biome-ignore-end lint/correctness/noUnusedImports: TSDoc
+
+/**
+ * The phase where Pokemon reflect moves via {@linkcode MoveId.MAGIC_COAT | Magic Coat} or {@linkcode AbilityId.MAGIC_BOUNCE | Magic Bounce}.
+ */
+export class MoveReflectPhase extends Phase {
+  public override readonly phaseName = "MoveReflectPhase";
+  /** The {@linkcode Pokemon} doing the reflecting. */
+  private readonly pokemon: Pokemon;
+  /** The pokemon having originally used the move. */
+  private opponent: Pokemon;
+  /** The {@linkcode Move} being reflected. */
+  private readonly move: Move;
+
+  constructor(pokemon: Pokemon, opponent: Pokemon, move: Move) {
+    super();
+    this.pokemon = pokemon;
+    this.opponent = opponent;
+    this.move = move;
+  }
+
+  override start(): void {
+    this.pokemon.turnData.extraTurns++;
+    // Magic Coat takes precedeence over Magic Bounce if both apply at once
+    const magicCoatTag = this.pokemon.getTag(BattlerTagType.MAGIC_COAT) as MagicCoatTag | undefined;
+    if (magicCoatTag) {
+      magicCoatTag.apply(this.pokemon, this.opponent, this.move);
+    } else {
+      applyAbAttrs("ReflectStatusMoveAbAttr", { pokemon: this.pokemon, opponent: this.opponent, move: this.move });
+    }
+    super.end();
+  }
+}

src/plugins/api/pokerogue-session-savedata-api.ts

@@ -56,15 +56,15 @@ export class PokerogueSessionSavedataApi extends ApiBase {
 
   /**
    * Update a session savedata.
-   * @param params The {@linkcode UpdateSessionSavedataRequest} to send
-   * @param rawSavedata The raw savedata (as `string`)
+   * @param params - The request to send
+   * @param rawSavedata - The raw, unencrypted savedata
    * @returns An error message if something went wrong
    */
-  public async update(params: UpdateSessionSavedataRequest, rawSavedata: string) {
+  public async update(params: UpdateSessionSavedataRequest, rawSavedata: string): Promise<string> {
     try {
       const urlSearchParams = this.toUrlSearchParams(params);
-      const response = await this.doPost(`/savedata/session/update?${urlSearchParams}`, rawSavedata);
 
+      const response = await this.doPost(`/savedata/session/update?${urlSearchParams}`, rawSavedata);
       return await response.text();
     } catch (err) {
       console.warn("Could not update session savedata!", err);

src/system/achv.ts

@@ -5,7 +5,6 @@ import {
   FlipStatChallenge,
   FreshStartChallenge,
   InverseBattleChallenge,
-  LimitedCatchChallenge,
   SingleGenerationChallenge,
   SingleTypeChallenge,
 } from "#data/challenge";
@@ -14,6 +13,7 @@ import { PlayerGender } from "#enums/player-gender";
 import { getShortenedStatKey, Stat } from "#enums/stat";
 import { TurnHeldItemTransferModifier } from "#modifiers/modifier";
 import type { ConditionFn } from "#types/common";
+import { isNuzlockeChallenge } from "#utils/challenge-utils";
 import { NumberHolder } from "#utils/common";
 import i18next from "i18next";
 import type { Modifier } from "typescript";
@@ -924,18 +924,7 @@ export const achvs = {
       globalScene.gameMode.challenges.some(c => c.id === Challenges.INVERSE_BATTLE && c.value > 0),
   ).setSecret(),
   // TODO: Decide on icon
-  NUZLOCKE: new ChallengeAchv(
-    "NUZLOCKE",
-    "",
-    "NUZLOCKE.description",
-    "leaf_stone",
-    100,
-    c =>
-      c instanceof LimitedCatchChallenge &&
-      c.value > 0 &&
-      globalScene.gameMode.challenges.some(c => c.id === Challenges.HARDCORE && c.value > 0) &&
-      globalScene.gameMode.challenges.some(c => c.id === Challenges.FRESH_START && c.value > 0),
-  ),
+  NUZLOCKE: new ChallengeAchv("NUZLOCKE", "", "NUZLOCKE.description", "leaf_stone", 100, isNuzlockeChallenge),
   BREEDERS_IN_SPACE: new Achv("BREEDERS_IN_SPACE", "", "BREEDERS_IN_SPACE.description", "moon_stone", 50).setSecret(),
 };
 

src/system/game-data.ts

@@ -48,6 +48,7 @@ import { EggData } from "#system/egg-data";
 import { GameStats } from "#system/game-stats";
 import { ModifierData as PersistentModifierData } from "#system/modifier-data";
 import { PokemonData } from "#system/pokemon-data";
+import { RibbonData } from "#system/ribbons/ribbon-data";
 import { resetSettings, SettingKeys, setSetting } from "#system/settings";
 import { SettingGamepad, setSettingGamepad, settingGamepadDefaults } from "#system/settings-gamepad";
 import type { SettingKeyboard } from "#system/settings-keyboard";
@@ -127,7 +128,8 @@ export interface SessionSaveData {
   battleType: BattleType;
   trainer: TrainerData;
   gameVersion: string;
-  runNameText: string;
+  /** The player-chosen name of the run */
+  name: string;
   timestamp: number;
   challenges: ChallengeData[];
   mysteryEncounterType: MysteryEncounterType | -1; // Only defined when current wave is ME,
@@ -402,121 +404,121 @@ export class GameData {
   }
 
   public initSystem(systemDataStr: string, cachedSystemDataStr?: string): Promise<boolean> {
-    return new Promise<boolean>(resolve => {
-      try {
-        let systemData = this.parseSystemData(systemDataStr);
+    const { promise, resolve } = Promise.withResolvers<boolean>();
+    try {
+      let systemData = this.parseSystemData(systemDataStr);
 
-        if (cachedSystemDataStr) {
-          const cachedSystemData = this.parseSystemData(cachedSystemDataStr);
-          if (cachedSystemData.timestamp > systemData.timestamp) {
-            console.debug("Use cached system");
-            systemData = cachedSystemData;
-            systemDataStr = cachedSystemDataStr;
-          } else {
-            this.clearLocalData();
-          }
-        }
-
-        console.debug(systemData);
-
-        localStorage.setItem(`data_${loggedInUser?.username}`, encrypt(systemDataStr, bypassLogin));
-
-        const lsItemKey = `runHistoryData_${loggedInUser?.username}`;
-        const lsItem = localStorage.getItem(lsItemKey);
-        if (!lsItem) {
-          localStorage.setItem(lsItemKey, "");
-        }
-
-        applySystemVersionMigration(systemData);
-
-        this.trainerId = systemData.trainerId;
-        this.secretId = systemData.secretId;
-
-        this.gender = systemData.gender;
-
-        this.saveSetting(SettingKeys.Player_Gender, systemData.gender === PlayerGender.FEMALE ? 1 : 0);
-
-        if (!systemData.starterData) {
-          this.initStarterData();
-
-          if (systemData["starterMoveData"]) {
-            const starterMoveData = systemData["starterMoveData"];
-            for (const s of Object.keys(starterMoveData)) {
-              this.starterData[s].moveset = starterMoveData[s];
-            }
-          }
-
-          if (systemData["starterEggMoveData"]) {
-            const starterEggMoveData = systemData["starterEggMoveData"];
-            for (const s of Object.keys(starterEggMoveData)) {
-              this.starterData[s].eggMoves = starterEggMoveData[s];
-            }
-          }
-
-          this.migrateStarterAbilities(systemData, this.starterData);
-
-          const starterIds = Object.keys(this.starterData).map(s => Number.parseInt(s) as SpeciesId);
-          for (const s of starterIds) {
-            this.starterData[s].candyCount += systemData.dexData[s].caughtCount;
-            this.starterData[s].candyCount += systemData.dexData[s].hatchedCount * 2;
-            if (systemData.dexData[s].caughtAttr & DexAttr.SHINY) {
-              this.starterData[s].candyCount += 4;
-            }
-          }
+      if (cachedSystemDataStr) {
+        const cachedSystemData = this.parseSystemData(cachedSystemDataStr);
+        if (cachedSystemData.timestamp > systemData.timestamp) {
+          console.debug("Use cached system");
+          systemData = cachedSystemData;
+          systemDataStr = cachedSystemDataStr;
         } else {
-          this.starterData = systemData.starterData;
+          this.clearLocalData();
         }
-
-        if (systemData.gameStats) {
-          this.gameStats = systemData.gameStats;
-        }
-
-        if (systemData.unlocks) {
-          for (const key of Object.keys(systemData.unlocks)) {
-            if (this.unlocks.hasOwnProperty(key)) {
-              this.unlocks[key] = systemData.unlocks[key];
-            }
-          }
-        }
-
-        if (systemData.achvUnlocks) {
-          for (const a of Object.keys(systemData.achvUnlocks)) {
-            if (achvs.hasOwnProperty(a)) {
-              this.achvUnlocks[a] = systemData.achvUnlocks[a];
-            }
-          }
-        }
-
-        if (systemData.voucherUnlocks) {
-          for (const v of Object.keys(systemData.voucherUnlocks)) {
-            if (vouchers.hasOwnProperty(v)) {
-              this.voucherUnlocks[v] = systemData.voucherUnlocks[v];
-            }
-          }
-        }
-
-        if (systemData.voucherCounts) {
-          getEnumKeys(VoucherType).forEach(key => {
-            const index = VoucherType[key];
-            this.voucherCounts[index] = systemData.voucherCounts[index] || 0;
-          });
-        }
-
-        this.eggs = systemData.eggs ? systemData.eggs.map(e => e.toEgg()) : [];
-
-        this.eggPity = systemData.eggPity ? systemData.eggPity.slice(0) : [0, 0, 0, 0];
-        this.unlockPity = systemData.unlockPity ? systemData.unlockPity.slice(0) : [0, 0, 0, 0];
-
-        this.dexData = Object.assign(this.dexData, systemData.dexData);
-        this.consolidateDexData(this.dexData);
-        this.defaultDexData = null;
-
-        resolve(true);
-      } catch (err) {
-        console.error(err);
-        resolve(false);
       }
-    });
+
+      console.debug(systemData);
+
+      localStorage.setItem(`data_${loggedInUser?.username}`, encrypt(systemDataStr, bypassLogin));
+
+      const lsItemKey = `runHistoryData_${loggedInUser?.username}`;
+      const lsItem = localStorage.getItem(lsItemKey);
+      if (!lsItem) {
+        localStorage.setItem(lsItemKey, "");
+      }
+
+      applySystemVersionMigration(systemData);
+
+      this.trainerId = systemData.trainerId;
+      this.secretId = systemData.secretId;
+
+      this.gender = systemData.gender;
+
+      this.saveSetting(SettingKeys.Player_Gender, systemData.gender === PlayerGender.FEMALE ? 1 : 0);
+
+      if (!systemData.starterData) {
+        this.initStarterData();
+
+        if (systemData["starterMoveData"]) {
+          const starterMoveData = systemData["starterMoveData"];
+          for (const s of Object.keys(starterMoveData)) {
+            this.starterData[s].moveset = starterMoveData[s];
+          }
+        }
+
+        if (systemData["starterEggMoveData"]) {
+          const starterEggMoveData = systemData["starterEggMoveData"];
+          for (const s of Object.keys(starterEggMoveData)) {
+            this.starterData[s].eggMoves = starterEggMoveData[s];
+          }
+        }
+
+        this.migrateStarterAbilities(systemData, this.starterData);
+
+        const starterIds = Object.keys(this.starterData).map(s => Number.parseInt(s) as SpeciesId);
+        for (const s of starterIds) {
+          this.starterData[s].candyCount += systemData.dexData[s].caughtCount;
+          this.starterData[s].candyCount += systemData.dexData[s].hatchedCount * 2;
+          if (systemData.dexData[s].caughtAttr & DexAttr.SHINY) {
+            this.starterData[s].candyCount += 4;
+          }
+        }
+      } else {
+        this.starterData = systemData.starterData;
+      }
+
+      if (systemData.gameStats) {
+        this.gameStats = systemData.gameStats;
+      }
+
+      if (systemData.unlocks) {
+        for (const key of Object.keys(systemData.unlocks)) {
+          if (this.unlocks.hasOwnProperty(key)) {
+            this.unlocks[key] = systemData.unlocks[key];
+          }
+        }
+      }
+
+      if (systemData.achvUnlocks) {
+        for (const a of Object.keys(systemData.achvUnlocks)) {
+          if (achvs.hasOwnProperty(a)) {
+            this.achvUnlocks[a] = systemData.achvUnlocks[a];
+          }
+        }
+      }
+
+      if (systemData.voucherUnlocks) {
+        for (const v of Object.keys(systemData.voucherUnlocks)) {
+          if (vouchers.hasOwnProperty(v)) {
+            this.voucherUnlocks[v] = systemData.voucherUnlocks[v];
+          }
+        }
+      }
+
+      if (systemData.voucherCounts) {
+        getEnumKeys(VoucherType).forEach(key => {
+          const index = VoucherType[key];
+          this.voucherCounts[index] = systemData.voucherCounts[index] || 0;
+        });
+      }
+
+      this.eggs = systemData.eggs ? systemData.eggs.map(e => e.toEgg()) : [];
+
+      this.eggPity = systemData.eggPity ? systemData.eggPity.slice(0) : [0, 0, 0, 0];
+      this.unlockPity = systemData.unlockPity ? systemData.unlockPity.slice(0) : [0, 0, 0, 0];
+
+      this.dexData = Object.assign(this.dexData, systemData.dexData);
+      this.consolidateDexData(this.dexData);
+      this.defaultDexData = null;
+
+      resolve(true);
+    } catch (err) {
+      console.error(err);
+      resolve(false);
+    }
+    return promise;
   }
 
   /**
@@ -627,6 +629,9 @@ export class GameData {
         }
         return ret;
       }
+      if (k === "ribbons") {
+        return RibbonData.fromJSON(v);
+      }
 
       return k.endsWith("Attr") && !["natureAttr", "abilityAttr", "passiveAttr"].includes(k) ? BigInt(v ?? 0) : v;
     }) as SystemSaveData;
@@ -982,51 +987,45 @@ export class GameData {
   }
 
   async renameSession(slotId: number, newName: string): Promise<boolean> {
-    return new Promise(async resolve => {
-      if (slotId < 0) {
-        return resolve(false);
-      }
-      const sessionData: SessionSaveData | null = await this.getSession(slotId);
+    if (slotId < 0) {
+      return false;
+    }
+    if (newName === "") {
+      return true;
+    }
+    const sessionData: SessionSaveData | null = await this.getSession(slotId);
 
-      if (!sessionData) {
-        return resolve(false);
-      }
+    if (!sessionData) {
+      return false;
+    }
 
-      if (newName === "") {
-        return resolve(true);
-      }
+    sessionData.name = newName;
+    // update timestamp by 1 to ensure the session is saved
+    sessionData.timestamp += 1;
+    const updatedDataStr = JSON.stringify(sessionData);
+    const encrypted = encrypt(updatedDataStr, bypassLogin);
+    const secretId = this.secretId;
+    const trainerId = this.trainerId;
 
-      sessionData.runNameText = newName;
-      const updatedDataStr = JSON.stringify(sessionData);
-      const encrypted = encrypt(updatedDataStr, bypassLogin);
-      const secretId = this.secretId;
-      const trainerId = this.trainerId;
+    if (bypassLogin) {
+      localStorage.setItem(
+        `sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`,
+        encrypt(updatedDataStr, bypassLogin),
+      );
+      return true;
+    }
 
-      if (bypassLogin) {
-        localStorage.setItem(
-          `sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`,
-          encrypt(updatedDataStr, bypassLogin),
-        );
-        resolve(true);
-        return;
-      }
-      pokerogueApi.savedata.session
-        .update({ slot: slotId, trainerId, secretId, clientSessionId }, encrypted)
-        .then(error => {
-          if (error) {
-            console.error("Failed to update session name:", error);
-            resolve(false);
-          } else {
-            localStorage.setItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`, encrypted);
-            updateUserInfo().then(success => {
-              if (success !== null && !success) {
-                return resolve(false);
-              }
-            });
-            resolve(true);
-          }
-        });
-    });
+    const response = await pokerogueApi.savedata.session.update(
+      { slot: slotId, trainerId, secretId, clientSessionId },
+      updatedDataStr,
+    );
+
+    if (response) {
+      return false;
+    }
+    localStorage.setItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`, encrypted);
+    const success = await updateUserInfo();
+    return !(success !== null && !success);
   }
 
   loadSession(slotId: number, sessionData?: SessionSaveData): Promise<boolean> {
@@ -1634,6 +1633,7 @@ export class GameData {
         caughtCount: 0,
         hatchedCount: 0,
         ivs: [0, 0, 0, 0, 0, 0],
+        ribbons: new RibbonData(0),
       };
     }
 
@@ -1878,6 +1878,12 @@ export class GameData {
     });
   }
 
+  /**
+   * Increase the number of classic ribbons won with this species.
+   * @param species - The species to increment the ribbon count for
+   * @param forStarter - If true, will increment the ribbon count for the root species of the given species
+   * @returns The number of classic wins after incrementing.
+   */
   incrementRibbonCount(species: PokemonSpecies, forStarter = false): number {
     const speciesIdToIncrement: SpeciesId = species.getRootSpeciesId(forStarter);
 
@@ -2177,6 +2183,9 @@ export class GameData {
       if (!entry.hasOwnProperty("natureAttr") || (entry.caughtAttr && !entry.natureAttr)) {
         entry.natureAttr = this.defaultDexData?.[k].natureAttr || 1 << randInt(25, 1);
       }
+      if (!entry.hasOwnProperty("ribbons")) {
+        entry.ribbons = new RibbonData(0);
+      }
     }
   }
 

src/system/ribbons/ribbon-data.ts

@@ -0,0 +1,148 @@
+import type { Brander } from "#types/type-helpers";
+
+export type RibbonFlag = (number & Brander<"RibbonFlag">) | 0;
+
+/**
+ * Class for ribbon data management. Usually constructed via the {@linkcode fromJSON} method.
+ *
+ * @remarks
+ * Stores information about the ribbons earned by a species using a bitfield.
+ */
+export class RibbonData {
+  /** Internal bitfield storing the unlock state for each ribbon */
+  private payload: number;
+
+  //#region Ribbons
+  //#region Monotype challenge ribbons
+  /** Ribbon for winning the normal monotype challenge */
+  public static readonly MONO_NORMAL = 0x1 as RibbonFlag;
+  /** Ribbon for winning the fighting monotype challenge */
+  public static readonly MONO_FIGHTING = 0x2 as RibbonFlag;
+  /** Ribbon for winning the flying monotype challenge */
+  public static readonly MONO_FLYING = 0x4 as RibbonFlag;
+  /** Ribbon for winning the poision monotype challenge */
+  public static readonly MONO_POISON = 0x8 as RibbonFlag;
+  /** Ribbon for winning the ground monotype challenge */
+  public static readonly MONO_GROUND = 0x10 as RibbonFlag;
+  /** Ribbon for winning the rock monotype challenge */
+  public static readonly MONO_ROCK = 0x20 as RibbonFlag;
+  /** Ribbon for winning the bug monotype challenge */
+  public static readonly MONO_BUG = 0x40 as RibbonFlag;
+  /** Ribbon for winning the ghost monotype challenge */
+  public static readonly MONO_GHOST = 0x80 as RibbonFlag;
+  /** Ribbon for winning the steel monotype challenge */
+  public static readonly MONO_STEEL = 0x100 as RibbonFlag;
+  /** Ribbon for winning the fire monotype challenge */
+  public static readonly MONO_FIRE = 0x200 as RibbonFlag;
+  /** Ribbon for winning the water monotype challenge */
+  public static readonly MONO_WATER = 0x400 as RibbonFlag;
+  /** Ribbon for winning the grass monotype challenge */
+  public static readonly MONO_GRASS = 0x800 as RibbonFlag;
+  /** Ribbon for winning the electric monotype challenge */
+  public static readonly MONO_ELECTRIC = 0x1000 as RibbonFlag;
+  /** Ribbon for winning the psychic monotype challenge */
+  public static readonly MONO_PSYCHIC = 0x2000 as RibbonFlag;
+  /** Ribbon for winning the ice monotype challenge */
+  public static readonly MONO_ICE = 0x4000 as RibbonFlag;
+  /** Ribbon for winning the dragon monotype challenge */
+  public static readonly MONO_DRAGON = 0x8000 as RibbonFlag;
+  /** Ribbon for winning the dark monotype challenge */
+  public static readonly MONO_DARK = 0x10000 as RibbonFlag;
+  /** Ribbon for winning the fairy monotype challenge */
+  public static readonly MONO_FAIRY = 0x20000 as RibbonFlag;
+  //#endregion Monotype ribbons
+
+  //#region Monogen ribbons
+  /** Ribbon for winning the the mono gen 1 challenge */
+  public static readonly MONO_GEN_1 = 0x40000 as RibbonFlag;
+  /** Ribbon for winning the the mono gen 2 challenge */
+  public static readonly MONO_GEN_2 = 0x80000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 3 challenge */
+  public static readonly MONO_GEN_3 = 0x100000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 4 challenge */
+  public static readonly MONO_GEN_4 = 0x200000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 5 challenge */
+  public static readonly MONO_GEN_5 = 0x400000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 6 challenge */
+  public static readonly MONO_GEN_6 = 0x800000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 7 challenge */
+  public static readonly MONO_GEN_7 = 0x1000000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 8 challenge */
+  public static readonly MONO_GEN_8 = 0x2000000 as RibbonFlag;
+  /** Ribbon for winning the mono gen 9 challenge */
+  public static readonly MONO_GEN_9 = 0x4000000 as RibbonFlag;
+  //#endregion Monogen ribbons
+
+  /** Ribbon for winning classic */
+  public static readonly CLASSIC = 0x8000000 as RibbonFlag;
+  /** Ribbon for winning the nuzzlocke challenge */
+  public static readonly NUZLOCKE = 0x10000000 as RibbonFlag;
+  /** Ribbon for reaching max friendship */
+  public static readonly FRIENDSHIP = 0x20000000 as RibbonFlag;
+  /** Ribbon for winning the flip stats challenge */
+  public static readonly FLIP_STATS = 0x40000000 as RibbonFlag;
+  /** Ribbon for winning the inverse challenge */
+  public static readonly INVERSE = 0x80000000 as RibbonFlag;
+  /** Ribbon for winning the fresh start challenge */
+  public static readonly FRESH_START = 0x100000000 as RibbonFlag;
+  /** Ribbon for winning the hardcore challenge */
+  public static readonly HARDCORE = 0x200000000 as RibbonFlag;
+  /** Ribbon for winning the limited catch challenge */
+  public static readonly LIMITED_CATCH = 0x400000000 as RibbonFlag;
+  /** Ribbon for winning the limited support challenge set to no heal */
+  public static readonly NO_HEAL = 0x800000000 as RibbonFlag;
+  /** Ribbon for winning the limited uspport challenge set to no shop */
+  public static readonly NO_SHOP = 0x1000000000 as RibbonFlag;
+  /** Ribbon for winning the limited support challenge set to both*/
+  public static readonly NO_SUPPORT = 0x2000000000 as RibbonFlag;
+
+  // NOTE: max possible ribbon flag is 0x20000000000000 (53 total ribbons)
+  // Once this is exceeded, bitfield needs to be changed to a bigint or even a uint array
+  // Note that this has no impact on serialization as it is stored in hex.
+
+  //#endregion Ribbons
+
+  /** Create a new instance of RibbonData. Generally, {@linkcode fromJSON} is used instead. */
+  constructor(value: number) {
+    this.payload = value;
+  }
+
+  /** Serialize the bitfield payload as a hex encoded string */
+  public toJSON(): string {
+    return this.payload.toString(16);
+  }
+
+  /**
+   * Decode a hexadecimal string representation of the bitfield into a `RibbonData` instance
+   *
+   * @param value - Hexadecimal string representation of the bitfield (without the leading 0x)
+   * @returns A new instance of `RibbonData` initialized with the provided bitfield.
+   */
+  public static fromJSON(value: string): RibbonData {
+    try {
+      return new RibbonData(Number.parseInt(value, 16));
+    } catch {
+      return new RibbonData(0);
+    }
+  }
+
+  /**
+   * Award one or more ribbons to the ribbon data by setting the corresponding flags in the bitfield.
+   *
+   * @param flags - The flags to set. Can be a single flag or multiple flags.
+   */
+  public award(...flags: [RibbonFlag, ...RibbonFlag[]]): void {
+    for (const f of flags) {
+      this.payload |= f;
+    }
+  }
+
+  /**
+   * Check if a specific ribbon has been awarded
+   * @param flag - The ribbon to check
+   * @returns Whether the specified flag has been awarded
+   */
+  public has(flag: RibbonFlag): boolean {
+    return !!(this.payload & flag);
+  }
+}

src/system/ribbons/ribbon-methods.ts

@@ -0,0 +1,20 @@
+import { globalScene } from "#app/global-scene";
+import { pokemonPrevolutions } from "#balance/pokemon-evolutions";
+import type { SpeciesId } from "#enums/species-id";
+import type { RibbonFlag } from "#system/ribbons/ribbon-data";
+import { isNullOrUndefined } from "#utils/common";
+
+/**
+ * Award one or more ribbons to a species and its pre-evolutions
+ *
+ * @param id - The ID of the species to award ribbons to
+ * @param ribbons - The ribbon(s) to award (use bitwise OR to combine multiple)
+ */
+export function awardRibbonsToSpeciesLine(id: SpeciesId, ribbons: RibbonFlag): void {
+  const dexData = globalScene.gameData.dexData;
+  dexData[id].ribbons.award(ribbons);
+  // Mark all pre-evolutions of the Pokémon with the same ribbon flags.
+  for (let prevoId = pokemonPrevolutions[id]; !isNullOrUndefined(prevoId); prevoId = pokemonPrevolutions[prevoId]) {
+    dexData[id].ribbons.award(ribbons);
+  }
+}

src/ui/party-ui-handler.ts

@@ -31,6 +31,11 @@ import { toTitleCase } from "#utils/strings";
 import i18next from "i18next";
 import type BBCodeText from "phaser3-rex-plugins/plugins/bbcodetext";
 
+const DISCARD_BUTTON_X = 60;
+const DISCARD_BUTTON_X_DOUBLES = 64;
+const DISCARD_BUTTON_Y = -73;
+const DISCARD_BUTTON_Y_DOUBLES = -58;
+
 const defaultMessage = i18next.t("partyUiHandler:choosePokemon");
 
 /**
@@ -301,7 +306,7 @@ export class PartyUiHandler extends MessageUiHandler {
     const partyMessageText = addTextObject(10, 8, defaultMessage, TextStyle.WINDOW, { maxLines: 2 });
     partyMessageText.setName("text-party-msg");
 
-    partyMessageText.setOrigin(0, 0);
+    partyMessageText.setOrigin(0);
     partyMessageBoxContainer.add(partyMessageText);
 
     this.message = partyMessageText;
@@ -317,10 +322,8 @@ export class PartyUiHandler extends MessageUiHandler {
     this.iconAnimHandler = new PokemonIconAnimHandler();
     this.iconAnimHandler.setup();
 
-    const partyDiscardModeButton = new PartyDiscardModeButton(60, -globalScene.game.canvas.height / 15 - 1, this);
-
+    const partyDiscardModeButton = new PartyDiscardModeButton(DISCARD_BUTTON_X, DISCARD_BUTTON_Y, this);
     partyContainer.add(partyDiscardModeButton);
-
     this.partyDiscardModeButton = partyDiscardModeButton;
 
     // prepare move overlay
@@ -1233,7 +1236,7 @@ export class PartyUiHandler extends MessageUiHandler {
     }
     if (!this.optionsCursorObj) {
       this.optionsCursorObj = globalScene.add.image(0, 0, "cursor");
-      this.optionsCursorObj.setOrigin(0, 0);
+      this.optionsCursorObj.setOrigin(0);
       this.optionsContainer.add(this.optionsCursorObj);
     }
     this.optionsCursorObj.setPosition(
@@ -1605,7 +1608,7 @@ export class PartyUiHandler extends MessageUiHandler {
         optionText.setColor("#40c8f8");
         optionText.setShadowColor("#006090");
       }
-      optionText.setOrigin(0, 0);
+      optionText.setOrigin(0);
 
       /** For every item that has stack bigger than 1, display the current quantity selection */
       const itemModifiers = this.getItemModifiers(pokemon);
@@ -1802,6 +1805,7 @@ class PartySlot extends Phaser.GameObjects.Container {
   private selected: boolean;
   private transfer: boolean;
   private slotIndex: number;
+  private isBenched: boolean;
   private pokemon: PlayerPokemon;
 
   private slotBg: Phaser.GameObjects.Image;
@@ -1812,6 +1816,7 @@ class PartySlot extends Phaser.GameObjects.Container {
   public slotHpText: Phaser.GameObjects.Text;
   public slotDescriptionLabel: Phaser.GameObjects.Text; // this is used to show text instead of the HP bar i.e. for showing "Able"/"Not Able" for TMs when you try to learn them
 
+  private slotBgKey: string;
   private pokemonIcon: Phaser.GameObjects.Container;
   private iconAnimHandler: PokemonIconAnimHandler;
 
@@ -1822,19 +1827,34 @@ class PartySlot extends Phaser.GameObjects.Container {
     partyUiMode: PartyUiMode,
     tmMoveId: MoveId,
   ) {
-    super(
-      globalScene,
-      slotIndex >= globalScene.currentBattle.getBattlerCount() ? 230.5 : 64,
-      slotIndex >= globalScene.currentBattle.getBattlerCount()
-        ? -184 +
-            (globalScene.currentBattle.double ? -40 : 0) +
-            (28 + (globalScene.currentBattle.double ? 8 : 0)) * slotIndex
-        : partyUiMode === PartyUiMode.MODIFIER_TRANSFER
-          ? -124 + (globalScene.currentBattle.double ? -20 : 0) + slotIndex * 55
-          : -124 + (globalScene.currentBattle.double ? -8 : 0) + slotIndex * 64,
-    );
+    const isBenched = slotIndex >= globalScene.currentBattle.getBattlerCount();
+    const isDoubleBattle = globalScene.currentBattle.double;
+    const isItemManageMode = partyUiMode === PartyUiMode.MODIFIER_TRANSFER || partyUiMode === PartyUiMode.DISCARD;
+
+    /*
+     * Here we determine the position of the slot.
+     * The x coordinate depends on whether the pokemon is on the field or in the bench.
+     * The y coordinate depends on various factors, such as the number of pokémon on the field,
+     * and whether the transfer/discard button is also on the screen.
+     */
+    const slotPositionX = isBenched ? 143 : 9;
+
+    let slotPositionY: number;
+    if (isBenched) {
+      slotPositionY = -196 + (isDoubleBattle ? -40 : 0);
+      slotPositionY += (28 + (isDoubleBattle ? 8 : 0)) * slotIndex;
+    } else {
+      slotPositionY = -148.5;
+      if (isDoubleBattle) {
+        slotPositionY += isItemManageMode ? -20 : -8;
+      }
+      slotPositionY += (isItemManageMode ? (isDoubleBattle ? 47 : 55) : 64) * slotIndex;
+    }
+
+    super(globalScene, slotPositionX, slotPositionY);
 
     this.slotIndex = slotIndex;
+    this.isBenched = isBenched;
     this.pokemon = pokemon;
     this.iconAnimHandler = iconAnimHandler;
 
@@ -1848,27 +1868,75 @@ class PartySlot extends Phaser.GameObjects.Container {
   setup(partyUiMode: PartyUiMode, tmMoveId: MoveId) {
     const currentLanguage = i18next.resolvedLanguage ?? "en";
     const offsetJa = currentLanguage === "ja";
+    const isItemManageMode = partyUiMode === PartyUiMode.MODIFIER_TRANSFER || partyUiMode === PartyUiMode.DISCARD;
 
-    const battlerCount = globalScene.currentBattle.getBattlerCount();
+    this.slotBgKey = this.isBenched
+      ? "party_slot"
+      : isItemManageMode && globalScene.currentBattle.double
+        ? "party_slot_main_short"
+        : "party_slot_main";
+    const fullSlotBgKey = this.pokemon.hp ? this.slotBgKey : `${this.slotBgKey}${"_fnt"}`;
+    this.slotBg = globalScene.add.sprite(0, 0, this.slotBgKey, fullSlotBgKey);
+    this.slotBg.setOrigin(0);
+    this.add(this.slotBg);
 
-    const slotKey = `party_slot${this.slotIndex >= battlerCount ? "" : "_main"}`;
+    const genderSymbol = getGenderSymbol(this.pokemon.getGender(true));
+    const isFusion = this.pokemon.isFusion();
 
-    const slotBg = globalScene.add.sprite(0, 0, slotKey, `${slotKey}${this.pokemon.hp ? "" : "_fnt"}`);
-    this.slotBg = slotBg;
+    // Here we define positions and offsets
+    // Base values are for the active pokemon; they are changed for benched pokemon,
+    // or for active pokemon if in a double battle in item management mode.
 
-    this.add(slotBg);
+    // icon position relative to slot background
+    let slotPb = { x: 4, y: 4 };
+    // name position relative to slot background
+    let namePosition = { x: 24, y: 10 + (offsetJa ? 2 : 0) };
+    // maximum allowed length of name; must accomodate fusion symbol
+    let maxNameTextWidth = 76 - (isFusion ? 8 : 0);
+    // "Lv." label position relative to slot background
+    let levelLabelPosition = { x: 24 + 8, y: 10 + 12 };
+    // offset from "Lv." to the level number; should not be changed.
+    const levelTextToLevelLabelOffset = { x: 9, y: offsetJa ? 1.5 : 0 };
+    // offests from "Lv." to gender, spliced and status icons, these depend on the type of slot.
+    let genderTextToLevelLabelOffset = { x: 68 - (isFusion ? 8 : 0), y: -9 };
+    let splicedIconToLevelLabelOffset = { x: 68, y: 3.5 - 12 };
+    let statusIconToLevelLabelOffset = { x: 55, y: 0 };
+    // offset from the name to the shiny icon (on the left); should not be changed.
+    const shinyIconToNameOffset = { x: -9, y: 3 };
+    // hp bar position relative to slot background
+    let hpBarPosition = { x: 8, y: 31 };
+    // offsets of hp bar overlay (showing the remaining hp) and number; should not be changed.
+    const hpOverlayToBarOffset = { x: 16, y: 2 };
+    const hpTextToBarOffset = { x: -3, y: -2 + (offsetJa ? 2 : 0) };
+    // description position relative to slot background
+    let descriptionLabelPosition = { x: 32, y: 46 };
 
-    const slotPb = globalScene.add.sprite(
-      this.slotIndex >= battlerCount ? -85.5 : -51,
-      this.slotIndex >= battlerCount ? 0 : -20.5,
-      "party_pb",
-    );
-    this.slotPb = slotPb;
+    // If in item management mode, the active slots are shorter
+    if (isItemManageMode && globalScene.currentBattle.double && !this.isBenched) {
+      namePosition.y -= 8;
+      levelLabelPosition.y -= 8;
+      hpBarPosition.y -= 8;
+      descriptionLabelPosition.y -= 8;
+    }
 
-    this.add(slotPb);
+    // Benched slots have significantly different parameters
+    if (this.isBenched) {
+      slotPb = { x: 2, y: 12 };
+      namePosition = { x: 21, y: 2 + (offsetJa ? 2 : 0) };
+      maxNameTextWidth = 52;
+      levelLabelPosition = { x: 21 + 8, y: 2 + 12 };
+      genderTextToLevelLabelOffset = { x: 36, y: 0 };
+      splicedIconToLevelLabelOffset = { x: 36 + (genderSymbol ? 8 : 0), y: 0.5 };
+      statusIconToLevelLabelOffset = { x: 43, y: 0 };
+      hpBarPosition = { x: 72, y: 6 };
+      descriptionLabelPosition = { x: 94, y: 16 };
+    }
 
-    this.pokemonIcon = globalScene.addPokemonIcon(this.pokemon, slotPb.x, slotPb.y, 0.5, 0.5, true);
+    this.slotPb = globalScene.add.sprite(0, 0, "party_pb");
+    this.slotPb.setPosition(slotPb.x, slotPb.y);
+    this.add(this.slotPb);
 
+    this.pokemonIcon = globalScene.addPokemonIcon(this.pokemon, this.slotPb.x, this.slotPb.y, 0.5, 0.5, true);
     this.add(this.pokemonIcon);
 
     this.iconAnimHandler.addOrUpdate(this.pokemonIcon, PokemonIconAnimMode.PASSIVE);
@@ -1882,7 +1950,7 @@ class PartySlot extends Phaser.GameObjects.Container {
     const nameSizeTest = addTextObject(0, 0, displayName, TextStyle.PARTY);
     nameTextWidth = nameSizeTest.displayWidth;
 
-    while (nameTextWidth > (this.slotIndex >= battlerCount ? 52 : 76 - (this.pokemon.fusionSpecies ? 8 : 0))) {
+    while (nameTextWidth > maxNameTextWidth) {
       displayName = `${displayName.slice(0, displayName.endsWith(".") ? -2 : -1).trimEnd()}.`;
       nameSizeTest.setText(displayName);
       nameTextWidth = nameSizeTest.displayWidth;
@@ -1891,78 +1959,59 @@ class PartySlot extends Phaser.GameObjects.Container {
     nameSizeTest.destroy();
 
     this.slotName = addTextObject(0, 0, displayName, TextStyle.PARTY);
-    this.slotName.setPositionRelative(
-      slotBg,
-      this.slotIndex >= battlerCount ? 21 : 24,
-      (this.slotIndex >= battlerCount ? 2 : 10) + (offsetJa ? 2 : 0),
-    );
-    this.slotName.setOrigin(0, 0);
+    this.slotName.setPositionRelative(this.slotBg, namePosition.x, namePosition.y);
+    this.slotName.setOrigin(0);
 
-    const slotLevelLabel = globalScene.add.image(0, 0, "party_slot_overlay_lv");
-    slotLevelLabel.setPositionRelative(
-      slotBg,
-      (this.slotIndex >= battlerCount ? 21 : 24) + 8,
-      (this.slotIndex >= battlerCount ? 2 : 10) + 12,
-    );
-    slotLevelLabel.setOrigin(0, 0);
+    const slotLevelLabel = globalScene.add
+      .image(0, 0, "party_slot_overlay_lv")
+      .setPositionRelative(this.slotBg, levelLabelPosition.x, levelLabelPosition.y)
+      .setOrigin(0);
 
     const slotLevelText = addTextObject(
       0,
       0,
       this.pokemon.level.toString(),
       this.pokemon.level < globalScene.getMaxExpLevel() ? TextStyle.PARTY : TextStyle.PARTY_RED,
-    );
-    slotLevelText.setPositionRelative(slotLevelLabel, 9, offsetJa ? 1.5 : 0);
-    slotLevelText.setOrigin(0, 0.25);
-
+    )
+      .setPositionRelative(slotLevelLabel, levelTextToLevelLabelOffset.x, levelTextToLevelLabelOffset.y)
+      .setOrigin(0, 0.25);
     slotInfoContainer.add([this.slotName, slotLevelLabel, slotLevelText]);
 
-    const genderSymbol = getGenderSymbol(this.pokemon.getGender(true));
-
     if (genderSymbol) {
-      const slotGenderText = addTextObject(0, 0, genderSymbol, TextStyle.PARTY);
-      slotGenderText.setColor(getGenderColor(this.pokemon.getGender(true)));
-      slotGenderText.setShadowColor(getGenderColor(this.pokemon.getGender(true), true));
-      if (this.slotIndex >= battlerCount) {
-        slotGenderText.setPositionRelative(slotLevelLabel, 36, 0);
-      } else {
-        slotGenderText.setPositionRelative(this.slotName, 76 - (this.pokemon.fusionSpecies ? 8 : 0), 3);
-      }
-      slotGenderText.setOrigin(0, 0.25);
-
+      const slotGenderText = addTextObject(0, 0, genderSymbol, TextStyle.PARTY)
+        .setColor(getGenderColor(this.pokemon.getGender(true)))
+        .setShadowColor(getGenderColor(this.pokemon.getGender(true), true))
+        .setPositionRelative(slotLevelLabel, genderTextToLevelLabelOffset.x, genderTextToLevelLabelOffset.y)
+        .setOrigin(0, 0.25);
       slotInfoContainer.add(slotGenderText);
     }
 
-    if (this.pokemon.fusionSpecies) {
-      const splicedIcon = globalScene.add.image(0, 0, "icon_spliced");
-      splicedIcon.setScale(0.5);
-      splicedIcon.setOrigin(0, 0);
-      if (this.slotIndex >= battlerCount) {
-        splicedIcon.setPositionRelative(slotLevelLabel, 36 + (genderSymbol ? 8 : 0), 0.5);
-      } else {
-        splicedIcon.setPositionRelative(this.slotName, 76, 3.5);
-      }
-
+    if (isFusion) {
+      const splicedIcon = globalScene.add
+        .image(0, 0, "icon_spliced")
+        .setScale(0.5)
+        .setOrigin(0)
+        .setPositionRelative(slotLevelLabel, splicedIconToLevelLabelOffset.x, splicedIconToLevelLabelOffset.y);
       slotInfoContainer.add(splicedIcon);
     }
 
     if (this.pokemon.status) {
-      const statusIndicator = globalScene.add.sprite(0, 0, getLocalizedSpriteKey("statuses"));
-      statusIndicator.setFrame(StatusEffect[this.pokemon.status?.effect].toLowerCase());
-      statusIndicator.setOrigin(0, 0);
-      statusIndicator.setPositionRelative(slotLevelLabel, this.slotIndex >= battlerCount ? 43 : 55, 0);
-
+      const statusIndicator = globalScene.add
+        .sprite(0, 0, getLocalizedSpriteKey("statuses"))
+        .setFrame(StatusEffect[this.pokemon.status?.effect].toLowerCase())
+        .setOrigin(0)
+        .setPositionRelative(slotLevelLabel, statusIconToLevelLabelOffset.x, statusIconToLevelLabelOffset.y);
       slotInfoContainer.add(statusIndicator);
     }
 
     if (this.pokemon.isShiny()) {
       const doubleShiny = this.pokemon.isDoubleShiny(false);
 
-      const shinyStar = globalScene.add.image(0, 0, `shiny_star_small${doubleShiny ? "_1" : ""}`);
-      shinyStar.setOrigin(0, 0);
-      shinyStar.setPositionRelative(this.slotName, -9, 3);
-      shinyStar.setTint(getVariantTint(this.pokemon.getBaseVariant()));
-
+      const shinyStar = globalScene.add
+        .image(0, 0, `shiny_star_small${doubleShiny ? "_1" : ""}`)
+        .setOrigin(0)
+        .setPositionRelative(this.slotName, shinyIconToNameOffset.x, shinyIconToNameOffset.y)
+        .setTint(getVariantTint(this.pokemon.getBaseVariant()));
       slotInfoContainer.add(shinyStar);
 
       if (doubleShiny) {
@@ -1971,50 +2020,38 @@ class PartySlot extends Phaser.GameObjects.Container {
           .setOrigin(0)
           .setPosition(shinyStar.x, shinyStar.y)
           .setTint(getVariantTint(this.pokemon.fusionVariant));
-
         slotInfoContainer.add(fusionShinyStar);
       }
     }
 
-    this.slotHpBar = globalScene.add.image(0, 0, "party_slot_hp_bar");
-    this.slotHpBar.setPositionRelative(
-      slotBg,
-      this.slotIndex >= battlerCount ? 72 : 8,
-      this.slotIndex >= battlerCount ? 6 : 31,
-    );
-    this.slotHpBar.setOrigin(0, 0);
-    this.slotHpBar.setVisible(false);
+    this.slotHpBar = globalScene.add
+      .image(0, 0, "party_slot_hp_bar")
+      .setOrigin(0)
+      .setVisible(false)
+      .setPositionRelative(this.slotBg, hpBarPosition.x, hpBarPosition.y);
 
     const hpRatio = this.pokemon.getHpRatio();
 
-    this.slotHpOverlay = globalScene.add.sprite(
-      0,
-      0,
-      "party_slot_hp_overlay",
-      hpRatio > 0.5 ? "high" : hpRatio > 0.25 ? "medium" : "low",
-    );
-    this.slotHpOverlay.setPositionRelative(this.slotHpBar, 16, 2);
-    this.slotHpOverlay.setOrigin(0, 0);
-    this.slotHpOverlay.setScale(hpRatio, 1);
-    this.slotHpOverlay.setVisible(false);
+    this.slotHpOverlay = globalScene.add
+      .sprite(0, 0, "party_slot_hp_overlay", hpRatio > 0.5 ? "high" : hpRatio > 0.25 ? "medium" : "low")
+      .setOrigin(0)
+      .setPositionRelative(this.slotHpBar, hpOverlayToBarOffset.x, hpOverlayToBarOffset.y)
+      .setScale(hpRatio, 1)
+      .setVisible(false);
 
-    this.slotHpText = addTextObject(0, 0, `${this.pokemon.hp}/${this.pokemon.getMaxHp()}`, TextStyle.PARTY);
-    this.slotHpText.setPositionRelative(
-      this.slotHpBar,
-      this.slotHpBar.width - 3,
-      this.slotHpBar.height - 2 + (offsetJa ? 2 : 0),
-    );
-    this.slotHpText.setOrigin(1, 0);
-    this.slotHpText.setVisible(false);
+    this.slotHpText = addTextObject(0, 0, `${this.pokemon.hp}/${this.pokemon.getMaxHp()}`, TextStyle.PARTY)
+      .setOrigin(1, 0)
+      .setPositionRelative(
+        this.slotHpBar,
+        this.slotHpBar.width + hpTextToBarOffset.x,
+        this.slotHpBar.height + hpTextToBarOffset.y,
+      ) // TODO: annoying because it contains the width
+      .setVisible(false);
 
-    this.slotDescriptionLabel = addTextObject(0, 0, "", TextStyle.MESSAGE);
-    this.slotDescriptionLabel.setPositionRelative(
-      slotBg,
-      this.slotIndex >= battlerCount ? 94 : 32,
-      this.slotIndex >= battlerCount ? 16 : 46,
-    );
-    this.slotDescriptionLabel.setOrigin(0, 1);
-    this.slotDescriptionLabel.setVisible(false);
+    this.slotDescriptionLabel = addTextObject(0, 0, "", TextStyle.MESSAGE)
+      .setOrigin(0, 1)
+      .setVisible(false)
+      .setPositionRelative(this.slotBg, descriptionLabelPosition.x, descriptionLabelPosition.y);
 
     slotInfoContainer.add([this.slotHpBar, this.slotHpOverlay, this.slotHpText, this.slotDescriptionLabel]);
 
@@ -2076,10 +2113,9 @@ class PartySlot extends Phaser.GameObjects.Container {
   }
 
   private updateSlotTexture(): void {
-    const battlerCount = globalScene.currentBattle.getBattlerCount();
     this.slotBg.setTexture(
-      `party_slot${this.slotIndex >= battlerCount ? "" : "_main"}`,
-      `party_slot${this.slotIndex >= battlerCount ? "" : "_main"}${this.transfer ? "_swap" : this.pokemon.hp ? "" : "_fnt"}${this.selected ? "_sel" : ""}`,
+      this.slotBgKey,
+      `${this.slotBgKey}${this.transfer ? "_swap" : this.pokemon.hp ? "" : "_fnt"}${this.selected ? "_sel" : ""}`,
     );
   }
 }
@@ -2198,10 +2234,6 @@ class PartyDiscardModeButton extends Phaser.GameObjects.Container {
         this.discardIcon.setVisible(false);
         this.textBox.setVisible(true);
         this.textBox.setText(i18next.t("partyUiHandler:TRANSFER"));
-        this.setPosition(
-          globalScene.currentBattle.double ? 64 : 60,
-          globalScene.currentBattle.double ? -48 : -globalScene.game.canvas.height / 15 - 1,
-        );
         this.transferIcon.displayWidth = this.textBox.text.length * 9 + 3;
         break;
       case PartyUiMode.DISCARD:
@@ -2209,13 +2241,13 @@ class PartyDiscardModeButton extends Phaser.GameObjects.Container {
         this.discardIcon.setVisible(true);
         this.textBox.setVisible(true);
         this.textBox.setText(i18next.t("partyUiHandler:DISCARD"));
-        this.setPosition(
-          globalScene.currentBattle.double ? 64 : 60,
-          globalScene.currentBattle.double ? -48 : -globalScene.game.canvas.height / 15 - 1,
-        );
         this.discardIcon.displayWidth = this.textBox.text.length * 9 + 3;
         break;
     }
+    this.setPosition(
+      globalScene.currentBattle.double ? DISCARD_BUTTON_X_DOUBLES : DISCARD_BUTTON_X,
+      globalScene.currentBattle.double ? DISCARD_BUTTON_Y_DOUBLES : DISCARD_BUTTON_Y,
+    );
   }
 
   clear() {

src/ui/run-info-ui-handler.ts

@@ -208,7 +208,7 @@ export class RunInfoUiHandler extends UiHandler {
     headerText.setOrigin(0, 0);
     headerText.setPositionRelative(headerBg, 8, 4);
     this.runContainer.add(headerText);
-    const runName = addTextObject(0, 0, this.runInfo.runNameText, TextStyle.WINDOW);
+    const runName = addTextObject(0, 0, this.runInfo.name, TextStyle.WINDOW);
     runName.setOrigin(0, 0);
     runName.setPositionRelative(headerBg, 60, 4);
     this.runContainer.add(runName);

src/ui/save-slot-select-ui-handler.ts

@@ -377,7 +377,7 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
         "select_cursor_highlight_thick",
         undefined,
         294,
-        this.sessionSlots[prevSlotIndex ?? 0]?.saveData?.runNameText ? 50 : 60,
+        this.sessionSlots[prevSlotIndex ?? 0]?.saveData?.name ? 50 : 60,
         6,
         6,
         6,
@@ -553,10 +553,10 @@ class SessionSlot extends Phaser.GameObjects.Container {
   }
 
   async setupWithData(data: SessionSaveData) {
-    const hasName = data?.runNameText;
+    const hasName = data?.name;
     this.remove(this.loadingLabel, true);
     if (hasName) {
-      const nameLabel = addTextObject(8, 5, data.runNameText, TextStyle.WINDOW);
+      const nameLabel = addTextObject(8, 5, data.name, TextStyle.WINDOW);
       this.add(nameLabel);
     } else {
       const fallbackName = this.decideFallback(data);

src/ui/starter-select-ui-handler.ts

@@ -45,6 +45,7 @@ import type { Variant } from "#sprites/variant";
 import { getVariantIcon, getVariantTint } from "#sprites/variant";
 import { achvs } from "#system/achv";
 import type { DexAttrProps, StarterAttributes, StarterMoveset } from "#system/game-data";
+import { RibbonData } from "#system/ribbons/ribbon-data";
 import { SettingKeyboard } from "#system/settings-keyboard";
 import type { DexEntry } from "#types/dex-data";
 import type { OptionSelectItem } from "#ui/abstract-option-select-ui-handler";
@@ -3226,6 +3227,8 @@ export class StarterSelectUiHandler extends MessageUiHandler {
       onScreenFirstIndex + maxRows * maxColumns - 1,
     );
 
+    const gameData = globalScene.gameData;
+
     this.starterSelectScrollBar.setScrollCursor(this.scrollCursor);
 
     let pokerusCursorIndex = 0;
@@ -3265,9 +3268,9 @@ export class StarterSelectUiHandler extends MessageUiHandler {
 
       container.label.setVisible(true);
       const speciesVariants =
-        speciesId && globalScene.gameData.dexData[speciesId].caughtAttr & DexAttr.SHINY
+        speciesId && gameData.dexData[speciesId].caughtAttr & DexAttr.SHINY
           ? [DexAttr.DEFAULT_VARIANT, DexAttr.VARIANT_2, DexAttr.VARIANT_3].filter(
-              v => !!(globalScene.gameData.dexData[speciesId].caughtAttr & v),
+              v => !!(gameData.dexData[speciesId].caughtAttr & v),
             )
           : [];
       for (let v = 0; v < 3; v++) {
@@ -3282,12 +3285,15 @@ export class StarterSelectUiHandler extends MessageUiHandler {
         }
       }
 
-      container.starterPassiveBgs.setVisible(!!globalScene.gameData.starterData[speciesId].passiveAttr);
+      container.starterPassiveBgs.setVisible(!!gameData.starterData[speciesId].passiveAttr);
       container.hiddenAbilityIcon.setVisible(
-        !!globalScene.gameData.dexData[speciesId].caughtAttr &&
-          !!(globalScene.gameData.starterData[speciesId].abilityAttr & 4),
+        !!gameData.dexData[speciesId].caughtAttr && !!(gameData.starterData[speciesId].abilityAttr & 4),
       );
-      container.classicWinIcon.setVisible(globalScene.gameData.starterData[speciesId].classicWinCount > 0);
+      container.classicWinIcon
+        .setVisible(gameData.starterData[speciesId].classicWinCount > 0)
+        .setTexture(
+          gameData.dexData[speciesId].ribbons.has(RibbonData.NUZLOCKE) ? "champion_ribbon_emerald" : "champion_ribbon",
+        );
       container.favoriteIcon.setVisible(this.starterPreferences[speciesId]?.favorite ?? false);
 
       // 'Candy Icon' mode

src/utils/challenge-utils.ts

@@ -4,6 +4,7 @@ import { pokemonEvolutions } from "#balance/pokemon-evolutions";
 import { pokemonFormChanges } from "#data/pokemon-forms";
 import type { PokemonSpecies } from "#data/pokemon-species";
 import { ChallengeType } from "#enums/challenge-type";
+import { Challenges } from "#enums/challenges";
 import type { MoveId } from "#enums/move-id";
 import type { MoveSourceType } from "#enums/move-source-type";
 import type { SpeciesId } from "#enums/species-id";
@@ -378,7 +379,7 @@ export function checkStarterValidForChallenge(species: PokemonSpecies, props: De
  * @param soft - If `true`, allow it if it could become valid through a form change.
  * @returns `true` if the species is considered valid.
  */
-function checkSpeciesValidForChallenge(species: PokemonSpecies, props: DexAttrProps, soft: boolean) {
+export function checkSpeciesValidForChallenge(species: PokemonSpecies, props: DexAttrProps, soft: boolean) {
   const isValidForChallenge = new BooleanHolder(true);
   applyChallenges(ChallengeType.STARTER_CHOICE, species, isValidForChallenge, props);
   if (!soft || !pokemonFormChanges.hasOwnProperty(species.speciesId)) {
@@ -407,3 +408,28 @@ function checkSpeciesValidForChallenge(species: PokemonSpecies, props: DexAttrPr
   });
   return result;
 }
+
+/** @returns Whether the current game mode meets the criteria to be considered a Nuzlocke challenge */
+export function isNuzlockeChallenge(): boolean {
+  let isFreshStart = false;
+  let isLimitedCatch = false;
+  let isHardcore = false;
+  for (const challenge of globalScene.gameMode.challenges) {
+    // value is 0 if challenge is not active
+    if (!challenge.value) {
+      continue;
+    }
+    switch (challenge.id) {
+      case Challenges.FRESH_START:
+        isFreshStart = true;
+        break;
+      case Challenges.LIMITED_CATCH:
+        isLimitedCatch = true;
+        break;
+      case Challenges.HARDCORE:
+        isHardcore = true;
+        break;
+    }
+  }
+  return isFreshStart && isLimitedCatch && isHardcore;
+}

src/utils/data.ts

@@ -45,17 +45,17 @@ export function deepMergeSpriteData(dest: object, source: object) {
 }
 
 export function encrypt(data: string, bypassLogin: boolean): string {
-  return (bypassLogin
-    ? (data: string) => btoa(encodeURIComponent(data))
-    : (data: string) => AES.encrypt(data, saveKey))(data) as unknown as string; // TODO: is this correct?
+  if (bypassLogin) {
+    return btoa(encodeURIComponent(data));
+  }
+  return AES.encrypt(data, saveKey).toString();
 }
 
 export function decrypt(data: string, bypassLogin: boolean): string {
-  return (
-    bypassLogin
-      ? (data: string) => decodeURIComponent(atob(data))
-      : (data: string) => AES.decrypt(data, saveKey).toString(enc.Utf8)
-  )(data);
+  if (bypassLogin) {
+    return decodeURIComponent(atob(data));
+  }
+  return AES.decrypt(data, saveKey).toString(enc.Utf8);
 }
 
 // the latest data saved/loaded for the Starter Preferences. Required to reduce read/writes. Initialize as "{}", since this is the default value and no data needs to be stored if present.

test/@types/test-helpers.ts

@@ -0,0 +1,27 @@
+import type { AtLeastOne, NonFunctionPropertiesRecursive as nonFunc } from "#types/type-helpers";
+
+/**
+ * Helper type to admit an object containing the given properties
+ * _and_ at least 1 other non-function property.
+ * @example
+ * ```ts
+ * type foo = {
+ *   qux: 1 | 2 | 3,
+ *   bar: number,
+ *   baz: string
+ *   quux: () => void; // ignored!
+ * }
+ *
+ * type quxAndSomethingElse = OneOther<foo, "qux">
+ *
+ * const good1: quxAndSomethingElse = {qux: 1, bar: 3} // OK!
+ * const good2: quxAndSomethingElse = {qux: 2, baz: "4", bar: 12} // OK!
+ * const bad1: quxAndSomethingElse = {baz: "4", bar: 12} // Errors because `qux` is required
+ * const bad2: quxAndSomethingElse = {qux: 1} // Errors because at least 1 thing _other_ than `qux` is required
+ * ```
+ * @typeParam O - The object to source keys from
+ * @typeParam K - One or more of O's keys to render mandatory
+ */
+export type OneOther<O extends object, K extends keyof O> = AtLeastOne<Omit<nonFunc<O>, K>> & {
+  [key in K]: O[K];
+};

test/@types/vitest.d.ts

@@ -1,23 +1,32 @@
 import type { TerrainType } from "#app/data/terrain";
+import type Overrides from "#app/overrides";
+import type { ArenaTag } from "#data/arena-tag";
+import type { PositionalTag } from "#data/positional-tags/positional-tag";
 import type { AbilityId } from "#enums/ability-id";
+import type { ArenaTagSide } from "#enums/arena-tag-side";
+import type { ArenaTagType } from "#enums/arena-tag-type";
 import type { BattlerTagType } from "#enums/battler-tag-type";
 import type { MoveId } from "#enums/move-id";
 import type { PokemonType } from "#enums/pokemon-type";
+import type { PositionalTagType } from "#enums/positional-tag-type";
 import type { BattleStat, EffectiveStat, Stat } from "#enums/stat";
 import type { StatusEffect } from "#enums/status-effect";
 import type { WeatherType } from "#enums/weather-type";
+import type { Arena } from "#field/arena";
 import type { Pokemon } from "#field/pokemon";
-import type { ToHaveEffectiveStatMatcherOptions } from "#test/test-utils/matchers/to-have-effective-stat";
+import type { PokemonMove } from "#moves/pokemon-move";
+import type { toHaveArenaTagOptions } from "#test/test-utils/matchers/to-have-arena-tag";
+import type { toHaveEffectiveStatOptions } from "#test/test-utils/matchers/to-have-effective-stat";
+import type { toHavePositionalTagOptions } from "#test/test-utils/matchers/to-have-positional-tag";
 import type { expectedStatusType } from "#test/test-utils/matchers/to-have-status-effect";
 import type { toHaveTypesOptions } from "#test/test-utils/matchers/to-have-types";
 import type { TurnMove } from "#types/turn-move";
 import type { AtLeastOne } from "#types/type-helpers";
+import type { toDmgValue } from "utils/common";
 import type { expect } from "vitest";
-import type Overrides from "#app/overrides";
-import type { PokemonMove } from "#moves/pokemon-move";
 
 declare module "vitest" {
-  interface Assertion {
+  interface Assertion<T> {
     /**
      * Check whether an array contains EXACTLY the given items (in any order).
      *
@@ -27,45 +36,9 @@ declare module "vitest" {
      * @param expected - The expected contents of the array, in any order
      * @see {@linkcode expect.arrayContaining}
      */
-    toEqualArrayUnsorted<E>(expected: E[]): void;
+    toEqualArrayUnsorted(expected: T[]): void;
 
-    /**
-     * Check whether a {@linkcode Pokemon}'s current typing includes the given types.
-     *
-     * @param expected - The expected types (in any order)
-     * @param options - The options passed to the matcher
-     */
-    toHaveTypes(expected: [PokemonType, ...PokemonType[]], options?: toHaveTypesOptions): void;
-
-    /**
-     * Matcher to check the contents of a {@linkcode Pokemon}'s move history.
-     *
-     * @param expectedValue - The expected value; can be a {@linkcode MoveId} or a partially filled {@linkcode TurnMove}
-     * containing the desired properties to check
-     * @param index - The index of the move history entry to check, in order from most recent to least recent.
-     * Default `0` (last used move)
-     * @see {@linkcode Pokemon.getLastXMoves}
-     */
-    toHaveUsedMove(expected: MoveId | AtLeastOne<TurnMove>, index?: number): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon}'s effective stat is as expected
-     * (checked after all stat value modifications).
-     *
-     * @param stat - The {@linkcode EffectiveStat} to check
-     * @param expectedValue - The expected value of {@linkcode stat}
-     * @param options - (Optional) The {@linkcode ToHaveEffectiveStatMatcherOptions}
-     * @remarks
-     * If you want to check the stat **before** modifiers are applied, use {@linkcode Pokemon.getStat} instead.
-     */
-    toHaveEffectiveStat(stat: EffectiveStat, expectedValue: number, options?: ToHaveEffectiveStatMatcherOptions): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has taken a specific amount of damage.
-     * @param expectedDamageTaken - The expected amount of damage taken
-     * @param roundDown - Whether to round down {@linkcode expectedDamageTaken} with {@linkcode toDmgValue}; default `true`
-     */
-    toHaveTakenDamage(expectedDamageTaken: number, roundDown?: boolean): void;
+    // #region Arena Matchers
 
     /**
      * Check whether the current {@linkcode WeatherType} is as expected.
@@ -80,9 +53,60 @@ declare module "vitest" {
     toHaveTerrain(expectedTerrainType: TerrainType): void;
 
     /**
-     * Check whether a {@linkcode Pokemon} is at full HP.
+     * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
+     * @param expectedTag - A partially-filled {@linkcode ArenaTag} containing the desired properties
      */
-    toHaveFullHp(): void;
+    toHaveArenaTag<A extends ArenaTagType>(expectedTag: toHaveArenaTagOptions<A>): void;
+    /**
+     * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
+     * @param expectedType - The {@linkcode ArenaTagType} of the desired tag
+     * @param side - The {@linkcode ArenaTagSide | side(s) of the field} the tag should affect; default {@linkcode ArenaTagSide.BOTH}
+     */
+    toHaveArenaTag(expectedType: ArenaTagType, side?: ArenaTagSide): void;
+
+    /**
+     * Check whether the current {@linkcode Arena} contains the given {@linkcode PositionalTag}.
+     * @param expectedTag - A partially-filled `PositionalTag` containing the desired properties
+     */
+    toHavePositionalTag<P extends PositionalTagType>(expectedTag: toHavePositionalTagOptions<P>): void;
+    /**
+     * Check whether the current {@linkcode Arena} contains the given number of {@linkcode PositionalTag}s.
+     * @param expectedType - The {@linkcode PositionalTagType} of the desired tag
+     * @param count - The number of instances of {@linkcode expectedType} that should be active;
+     * defaults to `1` and must be within the range `[0, 4]`
+     */
+    toHavePositionalTag(expectedType: PositionalTagType, count?: number): void;
+
+    // #endregion Arena Matchers
+
+    // #region Pokemon Matchers
+
+    /**
+     * Check whether a {@linkcode Pokemon}'s current typing includes the given types.
+     * @param expectedTypes - The expected {@linkcode PokemonType}s to check against; must have length `>0`
+     * @param options - The {@linkcode toHaveTypesOptions | options} passed to the matcher
+     */
+    toHaveTypes(expectedTypes: PokemonType[], options?: toHaveTypesOptions): void;
+
+    /**
+     * Check whether a {@linkcode Pokemon} has used a move matching the given criteria.
+     * @param expectedMove - The {@linkcode MoveId} the Pokemon is expected to have used,
+     * or a partially filled {@linkcode TurnMove} containing the desired properties to check
+     * @param index - The index of the move history entry to check, in order from most recent to least recent; default `0`
+     * @see {@linkcode Pokemon.getLastXMoves}
+     */
+    toHaveUsedMove(expectedMove: MoveId | AtLeastOne<TurnMove>, index?: number): void;
+
+    /**
+     * Check whether a {@linkcode Pokemon}'s effective stat is as expected
+     * (checked after all stat value modifications).
+     * @param stat - The {@linkcode EffectiveStat} to check
+     * @param expectedValue - The expected value of {@linkcode stat}
+     * @param options - The {@linkcode toHaveEffectiveStatOptions | options} passed to the matcher
+     * @remarks
+     * If you want to check the stat **before** modifiers are applied, use {@linkcode Pokemon.getStat} instead.
+     */
+    toHaveEffectiveStat(stat: EffectiveStat, expectedValue: number, options?: toHaveEffectiveStatOptions): void;
 
     /**
      * Check whether a {@linkcode Pokemon} has a specific {@linkcode StatusEffect | non-volatile status effect}.
@@ -106,7 +130,7 @@ declare module "vitest" {
 
     /**
      * Check whether a {@linkcode Pokemon} has applied a specific {@linkcode AbilityId}.
-     * @param expectedAbilityId - The expected {@linkcode AbilityId}
+     * @param expectedAbilityId - The `AbilityId` to check for
      */
     toHaveAbilityApplied(expectedAbilityId: AbilityId): void;
 
@@ -116,24 +140,36 @@ declare module "vitest" {
      */
     toHaveHp(expectedHp: number): void;
 
+    /**
+     * Check whether a {@linkcode Pokemon} has taken a specific amount of damage.
+     * @param expectedDamageTaken - The expected amount of damage taken
+     * @param roundDown - Whether to round down `expectedDamageTaken` with {@linkcode toDmgValue}; default `true`
+     */
+    toHaveTakenDamage(expectedDamageTaken: number, roundDown?: boolean): void;
+
     /**
      * Check whether a {@linkcode Pokemon} is currently fainted (as determined by {@linkcode Pokemon.isFainted}).
      * @remarks
-     * When checking whether an enemy wild Pokemon is fainted, one must reference it in a variable _before_ the fainting effect occurs
-     * as otherwise the Pokemon will be GC'ed and rendered `undefined`.
+     * When checking whether an enemy wild Pokemon is fainted, one must store a reference to it in a variable _before_ the fainting effect occurs.
+     * Otherwise, the Pokemon will be removed from the field and garbage collected.
      */
     toHaveFainted(): void;
 
+    /**
+     * Check whether a {@linkcode Pokemon} is at full HP.
+     */
+    toHaveFullHp(): void;
     /**
      * Check whether a {@linkcode Pokemon} has consumed the given amount of PP for one of its moves.
-     * @param expectedValue - The {@linkcode MoveId} of the {@linkcode PokemonMove} that should have consumed PP
+     * @param moveId - The {@linkcode MoveId} corresponding to the {@linkcode PokemonMove} that should have consumed PP
      * @param ppUsed - The numerical amount of PP that should have been consumed,
      * or `all` to indicate the move should be _out_ of PP
      * @remarks
-     * If the Pokemon's moveset has been set via {@linkcode Overrides.MOVESET_OVERRIDE}/{@linkcode Overrides.OPP_MOVESET_OVERRIDE},
-     * does not contain {@linkcode expectedMove}
-     * or contains the desired move more than once, this will fail the test.
+     * If the Pokemon's moveset has been set via {@linkcode Overrides.MOVESET_OVERRIDE}/{@linkcode Overrides.ENEMY_MOVESET_OVERRIDE}
+     * or does not contain exactly one copy of `moveId`, this will fail the test.
      */
-    toHaveUsedPP(expectedMove: MoveId, ppUsed: number | "all"): void;
+    toHaveUsedPP(moveId: MoveId, ppUsed: number | "all"): void;
+
+    // #endregion Pokemon Matchers
   }
 }

test/abilities/magic-bounce.test.ts

@@ -1,345 +0,0 @@
-import { allAbilities, allMoves } from "#data/data-lists";
-import { AbilityId } from "#enums/ability-id";
-import { ArenaTagSide } from "#enums/arena-tag-side";
-import { ArenaTagType } from "#enums/arena-tag-type";
-import { BattlerIndex } from "#enums/battler-index";
-import { BattlerTagType } from "#enums/battler-tag-type";
-import { MoveId } from "#enums/move-id";
-import { SpeciesId } from "#enums/species-id";
-import { Stat } from "#enums/stat";
-import { StatusEffect } from "#enums/status-effect";
-import { GameManager } from "#test/test-utils/game-manager";
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("Abilities - Magic Bounce", () => {
-  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
-      .ability(AbilityId.BALL_FETCH)
-      .battleStyle("single")
-      .moveset([MoveId.GROWL, MoveId.SPLASH])
-      .criticalHits(false)
-      .enemySpecies(SpeciesId.MAGIKARP)
-      .enemyAbility(AbilityId.MAGIC_BOUNCE)
-      .enemyMoveset(MoveId.SPLASH);
-  });
-
-  it("should reflect basic status moves", async () => {
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.use(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should not bounce moves while the target is in the semi-invulnerable state", async () => {
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.use(MoveId.GROWL);
-    await game.move.forceEnemyMove(MoveId.FLY);
-    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(0);
-  });
-
-  it("should individually bounce back multi-target moves", async () => {
-    game.override.battleStyle("double");
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
-
-    game.move.use(MoveId.GROWL, 0);
-    game.move.use(MoveId.SPLASH, 1);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    const user = game.scene.getPlayerField()[0];
-    expect(user.getStatStage(Stat.ATK)).toBe(-2);
-  });
-
-  it("should still bounce back a move that would otherwise fail", async () => {
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    game.field.getEnemyPokemon().setStatStage(Stat.ATK, -6);
-
-    game.move.use(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should not bounce back a move that was just bounced", async () => {
-    game.override.ability(AbilityId.MAGIC_BOUNCE);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should receive the stat change after reflecting a move back to a mirror armor user", async () => {
-    game.override.ability(AbilityId.MIRROR_ARMOR);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getEnemyPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should not bounce back a move from a mold breaker user", async () => {
-    game.override.ability(AbilityId.MOLD_BREAKER);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.use(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getEnemyPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should bounce back a spread status move against both pokemon", async () => {
-    game.override.battleStyle("double").enemyMoveset([MoveId.SPLASH]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
-
-    game.move.use(MoveId.GROWL, 0);
-    game.move.use(MoveId.SPLASH, 1);
-
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.scene.getPlayerField().every(p => p.getStatStage(Stat.ATK) === -2)).toBeTruthy();
-  });
-
-  it("should only bounce spikes back once in doubles when both targets have magic bounce", async () => {
-    game.override.battleStyle("double").moveset([MoveId.SPIKES]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.SPIKES);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)!["layers"]).toBe(1);
-    expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY)).toBeUndefined();
-  });
-
-  it("should bounce spikes even when the target is protected", async () => {
-    game.override.moveset([MoveId.SPIKES]).enemyMoveset([MoveId.PROTECT]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.SPIKES);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)!["layers"]).toBe(1);
-  });
-
-  it("should not bounce spikes when the target is in the semi-invulnerable state", async () => {
-    game.override.moveset([MoveId.SPIKES]).enemyMoveset([MoveId.FLY]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.SPIKES);
-    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY)!["layers"]).toBe(1);
-  });
-
-  it("should not bounce back curse", async () => {
-    game.override.moveset([MoveId.CURSE]);
-    await game.classicMode.startBattle([SpeciesId.GASTLY]);
-
-    game.move.select(MoveId.CURSE);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getEnemyPokemon().getTag(BattlerTagType.CURSED)).toBeDefined();
-  });
-
-  // TODO: enable when Magic Bounce is fixed to properly reset the hit count
-  it.todo("should not cause encore to be interrupted after bouncing", async () => {
-    game.override.moveset([MoveId.SPLASH, MoveId.GROWL, MoveId.ENCORE]).enemyMoveset([MoveId.TACKLE, MoveId.GROWL]);
-    // game.override.ability(AbilityId.MOLD_BREAKER);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    const playerPokemon = game.field.getPlayerPokemon();
-    const enemyPokemon = game.field.getEnemyPokemon();
-
-    // Give the player MOLD_BREAKER for this turn to bypass Magic Bounce.
-    const playerAbilitySpy = game.field.mockAbility(playerPokemon, AbilityId.MOLD_BREAKER);
-
-    // turn 1
-    game.move.select(MoveId.ENCORE);
-    await game.move.selectEnemyMove(MoveId.TACKLE);
-    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
-    await game.toNextTurn();
-    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)!["moveId"]).toBe(MoveId.TACKLE);
-
-    // turn 2
-    playerAbilitySpy.mockRestore();
-    game.move.select(MoveId.GROWL);
-    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)!["moveId"]).toBe(MoveId.TACKLE);
-    expect(enemyPokemon.getLastXMoves()[0].move).toBe(MoveId.TACKLE);
-  });
-
-  // TODO: encore is failing if the last move was virtual.
-  it.todo("should not cause the bounced move to count for encore", async () => {
-    game.override
-      .moveset([MoveId.SPLASH, MoveId.GROWL, MoveId.ENCORE])
-      .enemyMoveset([MoveId.GROWL, MoveId.TACKLE])
-      .enemyAbility(AbilityId.MAGIC_BOUNCE);
-
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    const playerPokemon = game.field.getPlayerPokemon();
-    const enemyPokemon = game.field.getEnemyPokemon();
-
-    // turn 1
-    game.move.select(MoveId.GROWL);
-    await game.move.selectEnemyMove(MoveId.TACKLE);
-    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
-    await game.toNextTurn();
-
-    // Give the player MOLD_BREAKER for this turn to bypass Magic Bounce.
-    vi.spyOn(playerPokemon, "getAbility").mockReturnValue(allAbilities[AbilityId.MOLD_BREAKER]);
-
-    // turn 2
-    game.move.select(MoveId.ENCORE);
-    await game.move.selectEnemyMove(MoveId.TACKLE);
-    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)!["moveId"]).toBe(MoveId.TACKLE);
-    expect(enemyPokemon.getLastXMoves()[0].move).toBe(MoveId.TACKLE);
-  });
-
-  // TODO: stomping tantrum should consider moves that were bounced.
-  it.todo("should cause stomping tantrum to double in power when the last move was bounced", async () => {
-    game.override.battleStyle("single").moveset([MoveId.STOMPING_TANTRUM, MoveId.CHARM]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    const stomping_tantrum = allMoves[MoveId.STOMPING_TANTRUM];
-    vi.spyOn(stomping_tantrum, "calculateBattlePower");
-
-    game.move.select(MoveId.CHARM);
-    await game.toNextTurn();
-
-    game.move.select(MoveId.STOMPING_TANTRUM);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(stomping_tantrum.calculateBattlePower).toHaveReturnedWith(150);
-  });
-
-  // TODO: stomping tantrum should consider moves that were bounced
-  it.todo("should boost enemy's stomping tantrum after failed bounce", async () => {
-    game.override.enemyMoveset([MoveId.STOMPING_TANTRUM, MoveId.SPLASH, MoveId.CHARM]);
-    await game.classicMode.startBattle([SpeciesId.BULBASAUR]);
-
-    const stomping_tantrum = allMoves[MoveId.STOMPING_TANTRUM];
-    const enemy = game.field.getEnemyPokemon();
-    vi.spyOn(stomping_tantrum, "calculateBattlePower");
-
-    // Spore gets reflected back onto us
-    game.move.select(MoveId.SPORE);
-    await game.move.selectEnemyMove(MoveId.CHARM);
-    await game.toNextTurn();
-    expect(enemy.getLastXMoves(1)[0].result).toBe("success");
-
-    game.move.select(MoveId.SPORE);
-    await game.move.selectEnemyMove(MoveId.STOMPING_TANTRUM);
-    await game.toNextTurn();
-    expect(stomping_tantrum.calculateBattlePower).toHaveReturnedWith(150);
-  });
-
-  it("should respect immunities when bouncing a move", async () => {
-    vi.spyOn(allMoves[MoveId.THUNDER_WAVE], "accuracy", "get").mockReturnValue(100);
-    game.override.moveset([MoveId.THUNDER_WAVE, MoveId.GROWL]).ability(AbilityId.SOUNDPROOF);
-    await game.classicMode.startBattle([SpeciesId.PHANPY]);
-
-    // Turn 1 - thunder wave immunity test
-    game.move.select(MoveId.THUNDER_WAVE);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().status).toBeUndefined();
-
-    // Turn 2 - soundproof immunity test
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(0);
-  });
-
-  it("should bounce back a move before the accuracy check", async () => {
-    game.override.moveset([MoveId.SPORE]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    const attacker = game.field.getPlayerPokemon();
-
-    vi.spyOn(attacker, "getAccuracyMultiplier").mockReturnValue(0.0);
-    game.move.select(MoveId.SPORE);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().status?.effect).toBe(StatusEffect.SLEEP);
-  });
-
-  it("should take the accuracy of the magic bounce user into account", async () => {
-    game.override.moveset([MoveId.SPORE]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    const opponent = game.field.getEnemyPokemon();
-
-    vi.spyOn(opponent, "getAccuracyMultiplier").mockReturnValue(0);
-    game.move.select(MoveId.SPORE);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().status).toBeUndefined();
-  });
-
-  it("should always apply the leftmost available target's magic bounce when bouncing moves like sticky webs in doubles", async () => {
-    game.override.battleStyle("double").moveset([MoveId.STICKY_WEB, MoveId.SPLASH, MoveId.TRICK_ROOM]);
-
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
-    const [enemy_1, enemy_2] = game.scene.getEnemyField();
-    // set speed just incase logic erroneously checks for speed order
-    enemy_1.setStat(Stat.SPD, enemy_2.getStat(Stat.SPD) + 1);
-
-    // turn 1
-    game.move.select(MoveId.STICKY_WEB, 0);
-    game.move.select(MoveId.TRICK_ROOM, 1);
-    await game.phaseInterceptor.to("TurnEndPhase");
-
-    expect(
-      game.scene.arena
-        .getTagOnSide(ArenaTagType.STICKY_WEB, ArenaTagSide.PLAYER)
-        ?.getSourcePokemon()
-        ?.getBattlerIndex(),
-    ).toBe(BattlerIndex.ENEMY);
-    game.scene.arena.removeTagOnSide(ArenaTagType.STICKY_WEB, ArenaTagSide.PLAYER, true);
-
-    // turn 2
-    game.move.select(MoveId.STICKY_WEB, 0);
-    game.move.select(MoveId.TRICK_ROOM, 1);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(
-      game.scene.arena
-        .getTagOnSide(ArenaTagType.STICKY_WEB, ArenaTagSide.PLAYER)
-        ?.getSourcePokemon()
-        ?.getBattlerIndex(),
-    ).toBe(BattlerIndex.ENEMY);
-  });
-
-  it("should not bounce back status moves that hit through semi-invulnerable states", async () => {
-    game.override.moveset([MoveId.TOXIC, MoveId.CHARM]);
-    await game.classicMode.startBattle([SpeciesId.BULBASAUR]);
-
-    game.move.select(MoveId.TOXIC);
-    await game.move.selectEnemyMove(MoveId.FLY);
-    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getEnemyPokemon().status?.effect).toBe(StatusEffect.TOXIC);
-    expect(game.field.getPlayerPokemon().status).toBeUndefined();
-
-    game.override.ability(AbilityId.NO_GUARD);
-    game.move.select(MoveId.CHARM);
-    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getEnemyPokemon().getStatStage(Stat.ATK)).toBe(-2);
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(0);
-  });
-});

test/abilities/mirror-armor.test.ts

@@ -7,8 +7,6 @@ import { GameManager } from "#test/test-utils/game-manager";
 import Phaser from "phaser";
 import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 
-// TODO: When Magic Bounce is implemented, make a test for its interaction with mirror guard, use screech
-
 describe("Ability - Mirror Armor", () => {
   let phaserGame: Phaser.Game;
   let game: GameManager;

test/matchers.setup.ts

@@ -1,10 +1,12 @@
 import { toEqualArrayUnsorted } from "#test/test-utils/matchers/to-equal-array-unsorted";
 import { toHaveAbilityApplied } from "#test/test-utils/matchers/to-have-ability-applied";
+import { toHaveArenaTag } from "#test/test-utils/matchers/to-have-arena-tag";
 import { toHaveBattlerTag } from "#test/test-utils/matchers/to-have-battler-tag";
 import { toHaveEffectiveStat } from "#test/test-utils/matchers/to-have-effective-stat";
 import { toHaveFainted } from "#test/test-utils/matchers/to-have-fainted";
 import { toHaveFullHp } from "#test/test-utils/matchers/to-have-full-hp";
 import { toHaveHp } from "#test/test-utils/matchers/to-have-hp";
+import { toHavePositionalTag } from "#test/test-utils/matchers/to-have-positional-tag";
 import { toHaveStatStage } from "#test/test-utils/matchers/to-have-stat-stage";
 import { toHaveStatusEffect } from "#test/test-utils/matchers/to-have-status-effect";
 import { toHaveTakenDamage } from "#test/test-utils/matchers/to-have-taken-damage";
@@ -22,18 +24,20 @@ import { expect } from "vitest";
 
 expect.extend({
   toEqualArrayUnsorted,
+  toHaveWeather,
+  toHaveTerrain,
+  toHaveArenaTag,
+  toHavePositionalTag,
   toHaveTypes,
   toHaveUsedMove,
   toHaveEffectiveStat,
-  toHaveTakenDamage,
-  toHaveWeather,
-  toHaveTerrain,
-  toHaveFullHp,
   toHaveStatusEffect,
   toHaveStatStage,
   toHaveBattlerTag,
   toHaveAbilityApplied,
   toHaveHp,
+  toHaveTakenDamage,
+  toHaveFullHp,
   toHaveFainted,
   toHaveUsedPP,
 });

test/moves/delayed-attack.test.ts

@@ -385,5 +385,5 @@ describe("Moves - Delayed Attacks", () => {
   });
 
   // TODO: Implement and move to a power spot's test file
-  it.todo("Should activate ally's power spot when switched in during single battles");
+  it.todo("should activate ally's power spot when switched in during single battles");
 });

test/moves/encore.test.ts

@@ -1,10 +1,14 @@
+import { getPokemonNameWithAffix } from "#app/messages";
 import { AbilityId } from "#enums/ability-id";
 import { BattlerIndex } from "#enums/battler-index";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import { MoveId } from "#enums/move-id";
 import { MoveResult } from "#enums/move-result";
+import { MoveUseMode } from "#enums/move-use-mode";
 import { SpeciesId } from "#enums/species-id";
+import { invalidEncoreMoves } from "#moves/invalid-moves";
 import { GameManager } from "#test/test-utils/game-manager";
+import i18next from "i18next";
 import Phaser from "phaser";
 import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 
@@ -31,7 +35,6 @@ describe("Moves - Encore", () => {
       .criticalHits(false)
       .enemySpecies(SpeciesId.MAGIKARP)
       .enemyAbility(AbilityId.BALL_FETCH)
-      .enemyMoveset([MoveId.SPLASH, MoveId.TACKLE])
       .startingLevel(100)
       .enemyLevel(100);
   });
@@ -39,76 +42,154 @@ describe("Moves - Encore", () => {
   it("should prevent the target from using any move except the last used move", async () => {
     await game.classicMode.startBattle([SpeciesId.SNORLAX]);
 
-    const enemyPokemon = game.field.getEnemyPokemon();
+    const enemy = game.field.getEnemyPokemon();
 
-    game.move.select(MoveId.ENCORE);
-    await game.move.selectEnemyMove(MoveId.SPLASH);
+    game.move.use(MoveId.ENCORE);
+    await game.move.forceEnemyMove(MoveId.SPLASH);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+    await game.toNextTurn();
+
+    expect(enemy).toHaveBattlerTag(BattlerTagType.ENCORE);
+    expect(enemy.isMoveRestricted(MoveId.TACKLE)).toBe(true);
+    expect(enemy.isMoveRestricted(MoveId.SPLASH)).toBe(false);
+  });
+
+  it("should be removed on turn end after triggering thrice, ignoring Instruct", async () => {
+    await game.classicMode.startBattle([SpeciesId.SNORLAX]);
+
+    const enemy = game.field.getEnemyPokemon();
+    enemy.pushMoveHistory({ move: MoveId.SPLASH, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
+
+    game.move.use(MoveId.ENCORE);
+    await game.move.forceEnemyMove(MoveId.SPLASH);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toNextTurn();
+
+    // Should have ticked down once
+    expect(enemy).toHaveBattlerTag(BattlerTagType.ENCORE);
+    expect(enemy.getTag(BattlerTagType.ENCORE)!.turnCount).toBe(2);
+
+    game.move.use(MoveId.INSTRUCT);
+    await game.toNextTurn();
+
+    expect(enemy.getTag(BattlerTagType.ENCORE)!.turnCount).toBe(1);
+
+    game.move.use(MoveId.INSTRUCT);
+    await game.toEndOfTurn(false);
+
+    // Tag should still be present until the `TurnEndPhase` ticks it down
+    expect(enemy).toHaveBattlerTag(BattlerTagType.ENCORE);
 
     await game.toNextTurn();
-    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)).toBeDefined();
 
-    game.move.select(MoveId.SPLASH);
-    // The enemy AI would normally be inclined to use Tackle, but should be
-    // forced into using Splash.
-    await game.phaseInterceptor.to("BerryPhase", false);
-
-    expect(enemyPokemon.getLastXMoves().every(turnMove => turnMove.move === MoveId.SPLASH)).toBeTruthy();
+    expect(enemy).not.toHaveBattlerTag(BattlerTagType.ENCORE);
+    expect(game.textInterceptor.logs).toContain(
+      i18next.t("battlerTags:encoreOnRemove", {
+        pokemonNameWithAffix: getPokemonNameWithAffix(enemy),
+      }),
+    );
   });
 
-  describe("should fail against the following moves:", () => {
-    it.each([
-      { moveId: MoveId.TRANSFORM, name: "Transform", delay: false },
-      { moveId: MoveId.MIMIC, name: "Mimic", delay: true },
-      { moveId: MoveId.SKETCH, name: "Sketch", delay: true },
-      { moveId: MoveId.ENCORE, name: "Encore", delay: false },
-      { moveId: MoveId.STRUGGLE, name: "Struggle", delay: false },
-    ])("$name", async ({ moveId, delay }) => {
-      game.override.enemyMoveset(moveId);
+  it("should override any upcoming moves with the Encored move, while still consuming PP", async () => {
+    await game.classicMode.startBattle([SpeciesId.SNORLAX]);
 
-      await game.classicMode.startBattle([SpeciesId.SNORLAX]);
+    // Fake enemy having used tackle the turn prior
+    const enemy = game.field.getEnemyPokemon();
+    game.move.changeMoveset(enemy, [MoveId.SPLASH, MoveId.TACKLE]);
+    enemy.pushMoveHistory({ move: MoveId.TACKLE, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
 
-      const playerPokemon = game.field.getPlayerPokemon();
-      const enemyPokemon = game.field.getEnemyPokemon();
+    game.move.use(MoveId.ENCORE);
+    await game.move.selectEnemyMove(MoveId.SPLASH);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toNextTurn();
 
-      if (delay) {
-        game.move.select(MoveId.SPLASH);
-        await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
-        await game.toNextTurn();
-      }
-
-      game.move.select(MoveId.ENCORE);
-
-      const turnOrder = delay ? [BattlerIndex.PLAYER, BattlerIndex.ENEMY] : [BattlerIndex.ENEMY, BattlerIndex.PLAYER];
-      await game.setTurnOrder(turnOrder);
-
-      await game.phaseInterceptor.to("BerryPhase", false);
-      expect(playerPokemon.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
-      expect(enemyPokemon.getTag(BattlerTagType.ENCORE)).toBeUndefined();
-    });
+    expect(enemy).toHaveUsedMove({ move: MoveId.TACKLE, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
+    expect(enemy).toHaveUsedPP(MoveId.TACKLE, 1);
   });
 
-  it("Pokemon under both Encore and Torment should alternate between Struggle and restricted move", async () => {
-    const turnOrder = [BattlerIndex.ENEMY, BattlerIndex.PLAYER];
-    game.override.moveset([MoveId.ENCORE, MoveId.TORMENT, MoveId.SPLASH]);
+  // TODO: Make test using `changeMoveset`
+  it.todo("should end at turn end if the user forgets the Encored move");
+
+  it("should be removed at turn end if the Encored move runs out of PP", async () => {
+    await game.classicMode.startBattle([SpeciesId.SNORLAX]);
+
+    // Fake enemy having used tackle the turn prior
+    const enemy = game.field.getEnemyPokemon();
+    game.move.changeMoveset(enemy, [MoveId.SPLASH, MoveId.TACKLE]);
+    enemy.pushMoveHistory({ move: MoveId.TACKLE, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
+    enemy.moveset[1].ppUsed = enemy.moveset[1].getMovePp() - 2;
+
+    game.move.use(MoveId.ENCORE);
+    await game.move.selectEnemyMove(MoveId.SPLASH);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toNextTurn();
+
+    expect(enemy).toHaveUsedMove({ move: MoveId.TACKLE, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
+    expect(enemy).toHaveUsedPP(MoveId.TACKLE, enemy.moveset[1].getMovePp() - 1);
+    expect(enemy).toHaveBattlerTag(BattlerTagType.ENCORE);
+
+    game.move.use(MoveId.SPLASH);
+    await game.toEndOfTurn();
+
+    expect(enemy).toHaveUsedPP(MoveId.TACKLE, "all");
+    expect(enemy).not.toHaveBattlerTag(BattlerTagType.ENCORE);
+  });
+
+  const invalidMoves = [...invalidEncoreMoves].map(m => ({
+    name: MoveId[m],
+    move: m,
+  }));
+  it.each(invalidMoves)("should fail if the target's last move is $name", async ({ move }) => {
+    await game.classicMode.startBattle([SpeciesId.SNORLAX]);
+
+    const player = game.field.getPlayerPokemon();
+    const enemy = game.field.getEnemyPokemon();
+    enemy.pushMoveHistory({ move, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
+
+    game.move.use(MoveId.ENCORE);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toEndOfTurn();
+
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
+    expect(enemy).not.toHaveBattlerTag(BattlerTagType.ENCORE);
+  });
+
+  it("should fail if the target has not made a move", async () => {
+    await game.classicMode.startBattle([SpeciesId.SNORLAX]);
+
+    const player = game.field.getPlayerPokemon();
+    const enemy = game.field.getEnemyPokemon();
+
+    game.move.use(MoveId.ENCORE);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toEndOfTurn();
+
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
+    expect(enemy).not.toHaveBattlerTag(BattlerTagType.ENCORE);
+  });
+
+  it("should force a Tormented target to alternate between Struggle and the Encored move", async () => {
     await game.classicMode.startBattle([SpeciesId.FEEBAS]);
 
-    const enemyPokemon = game.field.getEnemyPokemon();
-    game.move.select(MoveId.ENCORE);
-    await game.setTurnOrder(turnOrder);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)).toBeDefined();
+    const enemy = game.field.getEnemyPokemon();
 
+    game.move.use(MoveId.ENCORE);
+    await game.move.forceEnemyMove(MoveId.TACKLE);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
     await game.toNextTurn();
-    game.move.select(MoveId.TORMENT);
-    await game.setTurnOrder(turnOrder);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(enemyPokemon.getTag(BattlerTagType.TORMENT)).toBeDefined();
 
+    expect(enemy).toHaveBattlerTag(BattlerTagType.ENCORE);
+
+    game.move.use(MoveId.TORMENT);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
     await game.toNextTurn();
-    game.move.select(MoveId.SPLASH);
-    await game.setTurnOrder(turnOrder);
-    await game.phaseInterceptor.to("BerryPhase");
-    const lastMove = enemyPokemon.getLastXMoves()[0];
-    expect(lastMove?.move).toBe(MoveId.STRUGGLE);
+
+    expect(enemy).toHaveBattlerTag(BattlerTagType.ENCORE);
+    expect(enemy).toHaveBattlerTag(BattlerTagType.TORMENT);
+
+    game.move.use(MoveId.SPLASH);
+    await game.toEndOfTurn();
+
+    expect(enemy).toHaveUsedMove(MoveId.STRUGGLE);
   });
 });

test/moves/magic-coat-magic-bounce.test.ts

@@ -0,0 +1,390 @@
+import { allMoves } from "#data/data-lists";
+import { AbilityId } from "#enums/ability-id";
+import { ArenaTagSide } from "#enums/arena-tag-side";
+import { ArenaTagType } from "#enums/arena-tag-type";
+import { BattlerIndex } from "#enums/battler-index";
+import { BattlerTagType } from "#enums/battler-tag-type";
+import { MoveId } from "#enums/move-id";
+import { MoveResult } from "#enums/move-result";
+import { MoveUseMode } from "#enums/move-use-mode";
+import { SpeciesId } from "#enums/species-id";
+import { Stat } from "#enums/stat";
+import { StatusEffect } from "#enums/status-effect";
+import { GameManager } from "#test/test-utils/game-manager";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("Moves - Reflecting effects", () => {
+  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
+      .ability(AbilityId.BALL_FETCH)
+      .battleStyle("single")
+      .criticalHits(false)
+      .enemySpecies(SpeciesId.MAGIKARP)
+      .enemyAbility(AbilityId.BALL_FETCH)
+      .enemyMoveset(MoveId.MAGIC_COAT);
+  });
+
+  describe("Reflecting effects", () => {
+    it("should reflect basic status moves, copying them against the user", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.GROWL);
+      await game.toEndOfTurn();
+
+      const player = game.field.getPlayerPokemon();
+      const enemy = game.field.getEnemyPokemon();
+
+      expect(enemy).toHaveUsedMove({
+        move: MoveId.GROWL,
+        useMode: MoveUseMode.REFLECTED,
+        targets: [BattlerIndex.PLAYER],
+      });
+      expect(player).toHaveStatStage(Stat.ATK, -1);
+    });
+
+    it("should bounce back multi-target moves against each target", async () => {
+      game.override.battleStyle("double");
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.GROWL, BattlerIndex.PLAYER);
+      game.move.use(MoveId.SPLASH, BattlerIndex.PLAYER_2);
+      await game.toEndOfTurn();
+
+      const [karp1, karp2] = game.scene.getPlayerField();
+      expect(karp1).toHaveStatStage(Stat.ATK, -2);
+      expect(karp2).toHaveStatStage(Stat.ATK, -2);
+    });
+
+    // TODO: This is broken - failed moves never make it to a MEP
+    it.todo("should still bounce back a move that would otherwise fail", async () => {
+      game.override.enemyAbility(AbilityId.INSOMNIA);
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.YAWN);
+      await game.toEndOfTurn();
+
+      expect(game.field.getPlayerPokemon()).toHaveBattlerTag(BattlerTagType.DROWSY);
+    });
+
+    it("should not bounce back a move that was just bounced", async () => {
+      game.override.battleStyle("double").ability(AbilityId.MAGIC_BOUNCE);
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.MAGIC_COAT, BattlerIndex.PLAYER);
+      game.move.use(MoveId.GROWL, BattlerIndex.PLAYER_2);
+      await game.move.forceEnemyMove(MoveId.MAGIC_COAT);
+      await game.move.forceEnemyMove(MoveId.SPLASH);
+      await game.toEndOfTurn();
+
+      expect(game.field.getEnemyPokemon()).toHaveStatStage(Stat.ATK, 0);
+    });
+
+    it("should take precedence over Mirror Armor", async () => {
+      game.override.enemyAbility(AbilityId.MIRROR_ARMOR);
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.GROWL);
+      await game.toEndOfTurn();
+
+      const enemy = game.field.getPlayerPokemon();
+      expect(enemy).toHaveStatStage(Stat.ATK, -1);
+      expect(enemy).not.toHaveAbilityApplied(AbilityId.MIRROR_ARMOR);
+    });
+
+    it("should not bounce back non-reflectable effects", async () => {
+      await game.classicMode.startBattle([SpeciesId.GASTLY]);
+
+      game.move.use(MoveId.CURSE);
+      await game.toEndOfTurn();
+
+      expect(game.field.getEnemyPokemon()).toHaveBattlerTag(BattlerTagType.CURSED);
+    });
+
+    it("should not cause encore to be interrupted after bouncing", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      const playerPokemon = game.field.getPlayerPokemon();
+      const enemyPokemon = game.field.getEnemyPokemon();
+
+      // Give the player MOLD_BREAKER for this turn to bypass Magic Bounce.
+      const playerAbilitySpy = game.field.mockAbility(playerPokemon, AbilityId.MOLD_BREAKER);
+
+      // turn 1
+      game.move.use(MoveId.ENCORE);
+      await game.move.forceEnemyMove(MoveId.TACKLE);
+      await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+      await game.toNextTurn();
+
+      expect(enemyPokemon.getTag(BattlerTagType.ENCORE)!["moveId"]).toBe(MoveId.TACKLE);
+
+      // turn 2
+      playerAbilitySpy.mockRestore();
+
+      game.move.use(MoveId.GROWL);
+      await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+      await game.toEndOfTurn();
+
+      expect(enemyPokemon.getTag(BattlerTagType.ENCORE)!["moveId"]).toBe(MoveId.TACKLE);
+      expect(enemyPokemon.getLastXMoves()[0].move).toBe(MoveId.TACKLE);
+    });
+
+    it("should not cause the bounced move to count for encore", async () => {
+      game.override.battleStyle("double");
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.ABRA]);
+
+      // Fake abra having mold breaker and the enemy having used Tackle
+      const [, abra, enemy1] = game.scene.getField();
+      game.field.mockAbility(abra, AbilityId.MOLD_BREAKER);
+      game.field.mockAbility(enemy1, AbilityId.MAGIC_BOUNCE);
+      game.move.changeMoveset(enemy1, [MoveId.TACKLE, MoveId.SPLASH]);
+      enemy1.pushMoveHistory({ move: MoveId.TACKLE, targets: [BattlerIndex.PLAYER], useMode: MoveUseMode.NORMAL });
+
+      // Magikarp uses growl as Abra attempts to encore enemy 1
+      game.move.use(MoveId.GROWL, BattlerIndex.PLAYER);
+      game.move.use(MoveId.ENCORE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
+      await game.move.selectEnemyMove(MoveId.SPLASH);
+      await game.move.forceEnemyMove(MoveId.SPLASH);
+      await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]);
+      await game.toNextTurn();
+
+      console.log(enemy1.getLastXMoves(-1));
+      // Encore locked into Tackle, replacing the enemy's Growl with another Tackle
+      expect(enemy1.getTag(BattlerTagType.ENCORE)?.["moveId"]).toBe(MoveId.TACKLE);
+      expect(enemy1).toHaveUsedMove({ move: MoveId.TACKLE, useMode: MoveUseMode.NORMAL });
+    });
+
+    it("should boost stomping tantrum after a failed bounce", async () => {
+      game.override.ability(AbilityId.INSOMNIA);
+      await game.classicMode.startBattle([SpeciesId.BULBASAUR]);
+
+      const enemy = game.field.getEnemyPokemon();
+      const powerSpy = vi.spyOn(allMoves[MoveId.STOMPING_TANTRUM], "calculateBattlePower");
+
+      // Yawn gets reflected back onto us, failing due to Insomnia
+      game.move.use(MoveId.YAWN);
+      await game.move.forceEnemyMove(MoveId.MAGIC_COAT);
+      await game.toNextTurn();
+
+      expect(enemy).toHaveUsedMove({ move: MoveId.YAWN, result: MoveResult.FAIL, useMode: MoveUseMode.REFLECTED });
+
+      game.move.use(MoveId.SPLASH);
+      await game.move.forceEnemyMove(MoveId.STOMPING_TANTRUM);
+      await game.toNextTurn();
+
+      expect(powerSpy).toHaveReturnedWith(150);
+    });
+
+    it("should respect immunities when bouncing a move", async () => {
+      vi.spyOn(allMoves[MoveId.THUNDER_WAVE], "accuracy", "get").mockReturnValue(100);
+      game.override.ability(AbilityId.SOUNDPROOF);
+      await game.classicMode.startBattle([SpeciesId.PHANPY]);
+
+      // Turn 1 - thunder wave immunity test
+      game.move.use(MoveId.THUNDER_WAVE);
+      await game.toEndOfTurn();
+      expect(game.field.getPlayerPokemon().status).toBeUndefined();
+
+      // Turn 2 - soundproof immunity test
+      game.move.use(MoveId.GROWL);
+      await game.toEndOfTurn();
+      expect(game.field.getPlayerPokemon()).toHaveStatStage(Stat.ATK, 0);
+    });
+
+    it("should ignore the original move's accuracy and use the user's accuracy", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      const magikarp = game.field.getPlayerPokemon();
+      const feebas = game.field.getEnemyPokemon();
+      const karpMissSpy = vi.spyOn(magikarp, "getAccuracyMultiplier").mockReturnValue(0);
+
+      // Turn 1: Force a miss on initial move
+      game.move.use(MoveId.SPORE);
+      await game.phaseInterceptor.to("MoveEndPhase");
+      await game.toEndOfTurn();
+
+      // todo change once matchers fixed
+      expect(magikarp.status?.effect).toBe(StatusEffect.SLEEP);
+
+      magikarp.clearStatus(false, false);
+
+      karpMissSpy.mockRestore();
+      vi.spyOn(feebas, "getAccuracyMultiplier").mockReturnValue(0);
+
+      // Turn 2: Force a miss on Feebas' reflected move
+      game.move.use(MoveId.SPORE);
+      await game.toEndOfTurn();
+
+      expect(magikarp.status?.effect).toBeFalsy();
+    });
+  });
+
+  describe("Magic Bounce", () => {
+    beforeEach(() => {
+      game.override.enemyAbility(AbilityId.MAGIC_BOUNCE).enemyMoveset(MoveId.SPLASH);
+    });
+
+    // TODO: Change post speed order rework to check the FASTER pokemon's ability
+    it("should only apply the leftmost available target's magic bounce when bouncing field-targeted moves in doubles", async () => {
+      game.override.battleStyle("double");
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
+
+      const [enemy1, enemy2] = game.scene.getEnemyField();
+      // set speed to different values just in case logic erroneously checks for speed order
+      enemy1.setStat(Stat.SPD, enemy2.getStat(Stat.SPD) + 1);
+
+      // turn 1
+      game.move.use(MoveId.SPIKES, 0);
+      game.move.use(MoveId.TRICK_ROOM, 1);
+      await game.toNextTurn();
+
+      // TODO: Replace this with `expect(game).toHaveArenaTag({tagType: ArenaTagType.SPIKES, side: ArenaTagSide.PLAYER, sourceId: enemy1.id, layers: 1})
+      const tag = game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)!;
+      expect(tag).toBeDefined();
+      expect(tag.getSourcePokemon()).toBe(enemy1);
+      expect(tag["layers"]).toBe(1);
+      game.scene.arena.removeTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER, true);
+
+      // turn 2
+      game.move.use(MoveId.SPIKES, 0);
+      game.move.use(MoveId.TRICK_ROOM, 1);
+      await game.toEndOfTurn();
+
+      // TODO: Replace this with `expect(game).toHaveArenaTag({tagType: ArenaTagType.SPIKES, side: ArenaTagSide.PLAYER, sourceId: enemy1.id, layers: 1})
+      expect(
+        game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)?.getSourcePokemon()?.getBattlerIndex(),
+      ).toBe(BattlerIndex.ENEMY);
+    });
+
+    it("should not bounce back status moves against semi-invulnerable Pokemon, even with No Guard", async () => {
+      await game.classicMode.startBattle([SpeciesId.BULBASAUR]);
+
+      const player = game.field.getPlayerPokemon();
+      const enemy = game.field.getEnemyPokemon();
+
+      // Turn 1: use charm while enemy is airborne; misses
+      game.move.use(MoveId.CHARM);
+      await game.move.forceEnemyMove(MoveId.FLY);
+      await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+      await game.toNextTurn();
+
+      expect(player).toHaveStatStage(Stat.ATK, 0);
+      expect(enemy).toHaveStatStage(Stat.ATK, 0);
+
+      // Turn 2: Use Charm through No Guard; should not be reflected
+      game.field.mockAbility(player, AbilityId.NO_GUARD);
+
+      game.move.use(MoveId.CHARM);
+      await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+      await game.toEndOfTurn();
+
+      expect(player).toHaveStatStage(Stat.ATK, 0);
+      expect(enemy).toHaveStatStage(Stat.ATK, -2);
+    });
+
+    it("should be overridden by Magic Coat without stacking", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      const karp = game.field.getPlayerPokemon();
+
+      game.move.use(MoveId.GROWL);
+      await game.move.forceEnemyMove(MoveId.MAGIC_COAT);
+      await game.toEndOfTurn();
+
+      expect(karp).toHaveStatStage(Stat.ATK, -1);
+      expect(game.field.getEnemyPokemon()).not.toHaveAbilityApplied(AbilityId.MAGIC_BOUNCE);
+    });
+
+    it("should bounce spikes even when the target is protected", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.SPIKES);
+      await game.move.forceEnemyMove(MoveId.PROTECT);
+      await game.toEndOfTurn();
+
+      // TODO: Replace this with `expect(game).toHaveArenaTag({tagType: ArenaTagType.SPIKES, side: ArenaTagSide.PLAYER, layers: 1})
+      expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)!["layers"]).toBe(1);
+    });
+
+    it("should not break subsequent multi-strike moves", async () => {
+      await game.classicMode.startBattle([SpeciesId.PALKIA]);
+
+      game.move.use(MoveId.GROWL);
+      await game.move.forceEnemyMove(MoveId.SURGING_STRIKES);
+      await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+      await game.toEndOfTurn();
+
+      const enemy = game.field.getEnemyPokemon();
+      expect(enemy.turnData.hitCount).toBe(3);
+    });
+  });
+
+  describe("Magic Coat", () => {
+    it("should fail if the user goes last in the turn", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.PROTECT);
+      await game.toEndOfTurn();
+
+      expect(game.field.getEnemyPokemon().getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+    });
+
+    it("should fail if called again in the same turn from Instruct", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.INSTRUCT);
+      await game.toEndOfTurn();
+      expect(game.field.getEnemyPokemon().getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+    });
+
+    it("should not reflect moves used on the next turn", async () => {
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      // turn 1
+      game.move.use(MoveId.SPLASH);
+      await game.move.forceEnemyMove(MoveId.MAGIC_COAT);
+      await game.toNextTurn();
+
+      // turn 2
+      game.move.use(MoveId.GROWL);
+      await game.move.forceEnemyMove(MoveId.SPLASH);
+      await game.toEndOfTurn();
+      expect(game.field.getEnemyPokemon()).toHaveStatStage(Stat.ATK, -1);
+    });
+
+    it("should still bounce back a move from a mold breaker user", async () => {
+      game.override.ability(AbilityId.MOLD_BREAKER).moveset([MoveId.GROWL]);
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.GROWL);
+      await game.toEndOfTurn();
+
+      expect(game.field.getEnemyPokemon()).toHaveStatStage(Stat.ATK, 0);
+      expect(game.field.getPlayerPokemon()).toHaveStatStage(Stat.ATK, -1);
+    });
+
+    it("should only bounce spikes back once when both targets use magic coat in doubles", async () => {
+      game.override.battleStyle("double");
+      await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
+
+      game.move.use(MoveId.SPIKES);
+      await game.toEndOfTurn();
+
+      expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)!["layers"]).toBe(1);
+      expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY)).toBeUndefined();
+    });
+  });
+});

test/moves/magic-coat.test.ts

@@ -1,285 +0,0 @@
-import { allMoves } from "#data/data-lists";
-import { AbilityId } from "#enums/ability-id";
-import { ArenaTagSide } from "#enums/arena-tag-side";
-import { ArenaTagType } from "#enums/arena-tag-type";
-import { BattlerIndex } from "#enums/battler-index";
-import { BattlerTagType } from "#enums/battler-tag-type";
-import { MoveId } from "#enums/move-id";
-import { MoveResult } from "#enums/move-result";
-import { SpeciesId } from "#enums/species-id";
-import { Stat } from "#enums/stat";
-import { StatusEffect } from "#enums/status-effect";
-import { GameManager } from "#test/test-utils/game-manager";
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("Moves - Magic Coat", () => {
-  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
-      .ability(AbilityId.BALL_FETCH)
-      .battleStyle("single")
-      .criticalHits(false)
-      .enemySpecies(SpeciesId.MAGIKARP)
-      .enemyAbility(AbilityId.BALL_FETCH)
-      .enemyMoveset(MoveId.MAGIC_COAT);
-  });
-
-  it("should fail if the user goes last in the turn", async () => {
-    game.override.moveset([MoveId.PROTECT]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.PROTECT);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getEnemyPokemon().getLastXMoves()[0].result).toBe(MoveResult.FAIL);
-  });
-
-  it("should fail if called again in the same turn due to moves like instruct", async () => {
-    game.override.moveset([MoveId.INSTRUCT]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.INSTRUCT);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getEnemyPokemon().getLastXMoves()[0].result).toBe(MoveResult.FAIL);
-  });
-
-  it("should not reflect moves used on the next turn", async () => {
-    game.override.moveset([MoveId.GROWL, MoveId.SPLASH]).enemyMoveset([MoveId.MAGIC_COAT, MoveId.SPLASH]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    // turn 1
-    game.move.select(MoveId.SPLASH);
-    await game.move.selectEnemyMove(MoveId.MAGIC_COAT);
-    await game.toNextTurn();
-
-    // turn 2
-    game.move.select(MoveId.GROWL);
-    await game.move.selectEnemyMove(MoveId.SPLASH);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getEnemyPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should reflect basic status moves", async () => {
-    game.override.moveset([MoveId.GROWL]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should individually bounce back multi-target moves when used by both targets in doubles", async () => {
-    game.override.battleStyle("double").moveset([MoveId.GROWL, MoveId.SPLASH]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL, 0);
-    game.move.select(MoveId.SPLASH, 1);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    const user = game.scene.getPlayerField()[0];
-    expect(user.getStatStage(Stat.ATK)).toBe(-2);
-  });
-
-  it("should bounce back a spread status move against both pokemon", async () => {
-    game.override
-      .battleStyle("double")
-      .moveset([MoveId.GROWL, MoveId.SPLASH])
-      .enemyMoveset([MoveId.SPLASH, MoveId.MAGIC_COAT]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL, 0);
-    game.move.select(MoveId.SPLASH, 1);
-    await game.move.selectEnemyMove(MoveId.SPLASH);
-    await game.move.selectEnemyMove(MoveId.MAGIC_COAT);
-
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.scene.getPlayerField().every(p => p.getStatStage(Stat.ATK) === -1)).toBeTruthy();
-  });
-
-  it("should still bounce back a move that would otherwise fail", async () => {
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    game.field.getEnemyPokemon().setStatStage(Stat.ATK, -6);
-    game.override.moveset([MoveId.GROWL]);
-
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should not bounce back a move that was just bounced", async () => {
-    game.override
-      .battleStyle("double")
-      .ability(AbilityId.MAGIC_BOUNCE)
-      .moveset([MoveId.GROWL, MoveId.MAGIC_COAT])
-      .enemyMoveset([MoveId.SPLASH, MoveId.MAGIC_COAT]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.MAGIC_COAT, 0);
-    game.move.select(MoveId.GROWL, 1);
-    await game.move.selectEnemyMove(MoveId.MAGIC_COAT);
-    await game.move.selectEnemyMove(MoveId.SPLASH);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.scene.getEnemyField()[0].getStatStage(Stat.ATK)).toBe(0);
-  });
-
-  // todo while Mirror Armor is not implemented
-  it.todo("should receive the stat change after reflecting a move back to a mirror armor user", async () => {
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getEnemyPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should still bounce back a move from a mold breaker user", async () => {
-    game.override.ability(AbilityId.MOLD_BREAKER).moveset([MoveId.GROWL]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getEnemyPokemon().getStatStage(Stat.ATK)).toBe(0);
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(-1);
-  });
-
-  it("should only bounce spikes back once when both targets use magic coat in doubles", async () => {
-    game.override.battleStyle("double").moveset([MoveId.SPIKES]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    game.move.select(MoveId.SPIKES);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.PLAYER)!["layers"]).toBe(1);
-    expect(game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY)).toBeUndefined();
-  });
-
-  it("should not bounce back curse", async () => {
-    game.override.moveset([MoveId.CURSE]);
-    await game.classicMode.startBattle([SpeciesId.GASTLY]);
-
-    game.move.select(MoveId.CURSE);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.field.getEnemyPokemon().getTag(BattlerTagType.CURSED)).toBeDefined();
-  });
-
-  // TODO: encore is failing if the last move was virtual.
-  it.todo("should not cause the bounced move to count for encore", async () => {
-    game.override
-      .moveset([MoveId.GROWL, MoveId.ENCORE])
-      .enemyMoveset([MoveId.MAGIC_COAT, MoveId.TACKLE])
-      .enemyAbility(AbilityId.MAGIC_BOUNCE);
-
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    const enemyPokemon = game.field.getEnemyPokemon();
-
-    // turn 1
-    game.move.select(MoveId.GROWL);
-    await game.move.selectEnemyMove(MoveId.MAGIC_COAT);
-    await game.toNextTurn();
-
-    // turn 2
-    game.move.select(MoveId.ENCORE);
-    await game.move.selectEnemyMove(MoveId.TACKLE);
-    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)!["moveId"]).toBe(MoveId.TACKLE);
-    expect(enemyPokemon.getLastXMoves()[0].move).toBe(MoveId.TACKLE);
-  });
-
-  // TODO: stomping tantrum should consider moves that were bounced.
-  it.todo("should cause stomping tantrum to double in power when the last move was bounced", async () => {
-    game.override.battleStyle("single").moveset([MoveId.STOMPING_TANTRUM, MoveId.CHARM]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    const stomping_tantrum = allMoves[MoveId.STOMPING_TANTRUM];
-    vi.spyOn(stomping_tantrum, "calculateBattlePower");
-
-    game.move.select(MoveId.CHARM);
-    await game.toNextTurn();
-
-    game.move.select(MoveId.STOMPING_TANTRUM);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(stomping_tantrum.calculateBattlePower).toHaveReturnedWith(150);
-  });
-
-  // TODO: stomping tantrum should consider moves that were bounced.
-  it.todo(
-    "should properly cause the enemy's stomping tantrum to be doubled in power after bouncing and failing",
-    async () => {
-      game.override.enemyMoveset([MoveId.STOMPING_TANTRUM, MoveId.SPLASH, MoveId.CHARM]);
-      await game.classicMode.startBattle([SpeciesId.BULBASAUR]);
-
-      const stomping_tantrum = allMoves[MoveId.STOMPING_TANTRUM];
-      const enemy = game.field.getEnemyPokemon();
-      vi.spyOn(stomping_tantrum, "calculateBattlePower");
-
-      game.move.select(MoveId.SPORE);
-      await game.move.selectEnemyMove(MoveId.CHARM);
-      await game.phaseInterceptor.to("TurnEndPhase");
-      expect(enemy.getLastXMoves(1)[0].result).toBe("success");
-
-      await game.phaseInterceptor.to("BerryPhase");
-      expect(stomping_tantrum.calculateBattlePower).toHaveReturnedWith(75);
-
-      await game.toNextTurn();
-      game.move.select(MoveId.GROWL);
-      await game.phaseInterceptor.to("BerryPhase");
-      expect(stomping_tantrum.calculateBattlePower).toHaveReturnedWith(75);
-    },
-  );
-
-  it("should respect immunities when bouncing a move", async () => {
-    vi.spyOn(allMoves[MoveId.THUNDER_WAVE], "accuracy", "get").mockReturnValue(100);
-    game.override.moveset([MoveId.THUNDER_WAVE, MoveId.GROWL]).ability(AbilityId.SOUNDPROOF);
-    await game.classicMode.startBattle([SpeciesId.PHANPY]);
-
-    // Turn 1 - thunder wave immunity test
-    game.move.select(MoveId.THUNDER_WAVE);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().status).toBeUndefined();
-
-    // Turn 2 - soundproof immunity test
-    game.move.select(MoveId.GROWL);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().getStatStage(Stat.ATK)).toBe(0);
-  });
-
-  it("should bounce back a move before the accuracy check", async () => {
-    game.override.moveset([MoveId.SPORE]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-
-    const attacker = game.field.getPlayerPokemon();
-
-    vi.spyOn(attacker, "getAccuracyMultiplier").mockReturnValue(0.0);
-    game.move.select(MoveId.SPORE);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().status?.effect).toBe(StatusEffect.SLEEP);
-  });
-
-  it("should take the accuracy of the magic bounce user into account", async () => {
-    game.override.moveset([MoveId.SPORE]);
-    await game.classicMode.startBattle([SpeciesId.MAGIKARP]);
-    const opponent = game.field.getEnemyPokemon();
-
-    vi.spyOn(opponent, "getAccuracyMultiplier").mockReturnValue(0);
-    game.move.select(MoveId.SPORE);
-    await game.phaseInterceptor.to("BerryPhase");
-    expect(game.field.getPlayerPokemon().status).toBeUndefined();
-  });
-});

test/moves/wish.test.ts

@@ -39,15 +39,6 @@ describe("Move - Wish", () => {
       .enemyLevel(100);
   });
 
-  /**
-   * Expect that wish is active with the specified number of attacks.
-   * @param numAttacks - The number of wish instances that should be queued; default `1`
-   */
-  function expectWishActive(numAttacks = 1) {
-    const wishes = game.scene.arena.positionalTagManager["tags"].filter(t => t.tagType === PositionalTagType.WISH);
-    expect(wishes).toHaveLength(numAttacks);
-  }
-
   it("should heal the Pokemon in the current slot for 50% of the user's maximum HP", async () => {
     await game.classicMode.startBattle([SpeciesId.ALOMOMOLA, SpeciesId.BLISSEY]);
 
@@ -58,19 +49,19 @@ describe("Move - Wish", () => {
     game.move.use(MoveId.WISH);
     await game.toNextTurn();
 
-    expectWishActive();
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);
 
     game.doSwitchPokemon(1);
     await game.toEndOfTurn();
 
-    expectWishActive(0);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 0);
     expect(game.textInterceptor.logs).toContain(
       i18next.t("arenaTag:wishTagOnAdd", {
         pokemonNameWithAffix: getPokemonNameWithAffix(alomomola),
       }),
     );
-    expect(alomomola.hp).toBe(1);
-    expect(blissey.hp).toBe(toDmgValue(alomomola.getMaxHp() / 2) + 1);
+    expect(alomomola).toHaveHp(1);
+    expect(blissey).toHaveHp(toDmgValue(alomomola.getMaxHp() / 2) + 1);
   });
 
   it("should work if the user has full HP, but not if it already has an active Wish", async () => {
@@ -82,13 +73,13 @@ describe("Move - Wish", () => {
     game.move.use(MoveId.WISH);
     await game.toNextTurn();
 
-    expectWishActive();
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);
 
     game.move.use(MoveId.WISH);
     await game.toEndOfTurn();
 
     expect(alomomola.hp).toBe(toDmgValue(alomomola.getMaxHp() / 2) + 1);
-    expect(alomomola.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+    expect(alomomola).toHaveUsedMove({ result: MoveResult.FAIL });
   });
 
   it("should function independently of Future Sight", async () => {
@@ -103,7 +94,8 @@ describe("Move - Wish", () => {
     await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
     await game.toNextTurn();
 
-    expectWishActive(1);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);
+    expect(game).toHavePositionalTag(PositionalTagType.DELAYED_ATTACK);
   });
 
   it("should work in double battles and trigger in order of creation", async () => {
@@ -127,7 +119,7 @@ describe("Move - Wish", () => {
     await game.setTurnOrder(oldOrder.map(p => p.getBattlerIndex()));
     await game.toNextTurn();
 
-    expectWishActive(4);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 4);
 
     // Lower speed to change turn order
     alomomola.setStatStage(Stat.SPD, 6);
@@ -141,7 +133,7 @@ describe("Move - Wish", () => {
     await game.phaseInterceptor.to("PositionalTagPhase");
 
     // all wishes have activated and added healing phases
-    expectWishActive(0);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 0);
 
     const healPhases = game.scene.phaseManager.phaseQueue.filter(p => p.is("PokemonHealPhase"));
     expect(healPhases).toHaveLength(4);
@@ -165,14 +157,14 @@ describe("Move - Wish", () => {
     game.move.use(MoveId.WISH, BattlerIndex.PLAYER_2);
     await game.toNextTurn();
 
-    expectWishActive();
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);
 
     game.move.use(MoveId.SPLASH, BattlerIndex.PLAYER);
     game.move.use(MoveId.MEMENTO, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY_2);
     await game.toEndOfTurn();
 
     // Wish went away without doing anything
-    expectWishActive(0);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 0);
     expect(game.textInterceptor.logs).not.toContain(
       i18next.t("arenaTag:wishTagOnAdd", {
         pokemonNameWithAffix: getPokemonNameWithAffix(blissey),

test/test-utils/game-manager.ts

@@ -224,7 +224,7 @@ export class GameManager {
     // This will consider all battle entry dialog as seens and skip them
     vi.spyOn(this.scene.ui, "shouldSkipDialogue").mockReturnValue(true);
 
-    if (overrides.OPP_HELD_ITEMS_OVERRIDE.length === 0) {
+    if (overrides.ENEMY_HELD_ITEMS_OVERRIDE.length === 0) {
       this.removeEnemyHeldItems();
     }
 
@@ -371,9 +371,13 @@ export class GameManager {
     console.log("==================[New Turn]==================");
   }
 
-  /** Transition to the {@linkcode TurnEndPhase | end of the current turn}. */
-  async toEndOfTurn() {
-    await this.phaseInterceptor.to("TurnEndPhase");
+  /**
+   * Transition to the {@linkcode TurnEndPhase | end of the current turn}.
+   * @param runTarget - Whether or not to run the {@linkcode TurnEndPhase}; default `true`
+   * @returns A Promise that resolves once the turn has ended.
+   */
+  async toEndOfTurn(runTarget = true): Promise<void> {
+    await this.phaseInterceptor.to("TurnEndPhase", runTarget);
     console.log("==================[End of Turn]==================");
   }
 
@@ -532,14 +536,16 @@ export class GameManager {
   }
 
   /**
-   * Intercepts `TurnStartPhase` and mocks {@linkcode TurnStartPhase.getSpeedOrder}'s return value.
+   * Intercepts `TurnStartPhase` and mocks {@linkcode TurnStartPhase.getSpeedOrder}'s return value. \
    * Used to manually modify Pokemon turn order.
-   * Note: This *DOES NOT* account for priority.
-   * @param order - The turn order to set as an array of {@linkcode BattlerIndex}es.
+   *
+   * @param order - The turn order to set, as an array of {@linkcode BattlerIndex}es
    * @example
    * ```ts
    * await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2]);
    * ```
+   * @remarks
+   * This *does not* account for priority and will override Trick Room's effect.
    */
   async setTurnOrder(order: BattlerIndex[]): Promise<void> {
     await this.phaseInterceptor.to(TurnStartPhase, false);

test/test-utils/helpers/challenge-mode-helper.ts

@@ -50,7 +50,7 @@ export class ChallengeModeHelper extends GameManagerHelper {
     });
 
     await this.game.phaseInterceptor.run(EncounterPhase);
-    if (overrides.OPP_HELD_ITEMS_OVERRIDE.length === 0 && this.game.override.removeEnemyStartingItems) {
+    if (overrides.ENEMY_HELD_ITEMS_OVERRIDE.length === 0 && this.game.override.removeEnemyStartingItems) {
       this.game.removeEnemyHeldItems();
     }
   }

test/test-utils/helpers/classic-mode-helper.ts

@@ -53,7 +53,7 @@ export class ClassicModeHelper extends GameManagerHelper {
     });
 
     await this.game.phaseInterceptor.to(EncounterPhase);
-    if (overrides.OPP_HELD_ITEMS_OVERRIDE.length === 0 && this.game.override.removeEnemyStartingItems) {
+    if (overrides.ENEMY_HELD_ITEMS_OVERRIDE.length === 0 && this.game.override.removeEnemyStartingItems) {
       this.game.removeEnemyHeldItems();
     }
   }

test/test-utils/helpers/daily-mode-helper.ts

@@ -37,7 +37,7 @@ export class DailyModeHelper extends GameManagerHelper {
 
     await this.game.phaseInterceptor.to(EncounterPhase);
 
-    if (overrides.OPP_HELD_ITEMS_OVERRIDE.length === 0 && this.game.override.removeEnemyStartingItems) {
+    if (overrides.ENEMY_HELD_ITEMS_OVERRIDE.length === 0 && this.game.override.removeEnemyStartingItems) {
       this.game.removeEnemyHeldItems();
     }
   }

test/test-utils/helpers/move-helper.ts

@@ -228,8 +228,8 @@ export class MoveHelper extends GameManagerHelper {
         console.warn("Player moveset override disabled due to use of `game.move.changeMoveset`!");
       }
     } else {
-      if (coerceArray(Overrides.OPP_MOVESET_OVERRIDE).length > 0) {
-        vi.spyOn(Overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([]);
+      if (coerceArray(Overrides.ENEMY_MOVESET_OVERRIDE).length > 0) {
+        vi.spyOn(Overrides, "ENEMY_MOVESET_OVERRIDE", "get").mockReturnValue([]);
         console.warn("Enemy moveset override disabled due to use of `game.move.changeMoveset`!");
       }
     }
@@ -302,8 +302,8 @@ export class MoveHelper extends GameManagerHelper {
         (this.game.scene.phaseManager.getCurrentPhase() as EnemyCommandPhase).getFieldIndex()
       ];
 
-    if ([Overrides.OPP_MOVESET_OVERRIDE].flat().length > 0) {
-      vi.spyOn(Overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([]);
+    if ([Overrides.ENEMY_MOVESET_OVERRIDE].flat().length > 0) {
+      vi.spyOn(Overrides, "ENEMY_MOVESET_OVERRIDE", "get").mockReturnValue([]);
       console.warn(
         "Warning: `forceEnemyMove` overwrites the Pokemon's moveset and disables the enemy moveset override!",
       );

test/test-utils/helpers/overrides-helper.ts

@@ -406,7 +406,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemySpecies(species: SpeciesId | number): this {
-    vi.spyOn(Overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(species);
+    vi.spyOn(Overrides, "ENEMY_SPECIES_OVERRIDE", "get").mockReturnValue(species);
     this.log(`Enemy Pokemon species set to ${SpeciesId[species]} (=${species})!`);
     return this;
   }
@@ -416,7 +416,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enableEnemyFusion(): this {
-    vi.spyOn(Overrides, "OPP_FUSION_OVERRIDE", "get").mockReturnValue(true);
+    vi.spyOn(Overrides, "ENEMY_FUSION_OVERRIDE", "get").mockReturnValue(true);
     this.log("Enemy Pokemon is a random fusion!");
     return this;
   }
@@ -427,7 +427,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyFusionSpecies(species: SpeciesId | number): this {
-    vi.spyOn(Overrides, "OPP_FUSION_SPECIES_OVERRIDE", "get").mockReturnValue(species);
+    vi.spyOn(Overrides, "ENEMY_FUSION_SPECIES_OVERRIDE", "get").mockReturnValue(species);
     this.log(`Enemy Pokemon fusion species set to ${SpeciesId[species]} (=${species})!`);
     return this;
   }
@@ -438,7 +438,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyAbility(ability: AbilityId): this {
-    vi.spyOn(Overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(ability);
+    vi.spyOn(Overrides, "ENEMY_ABILITY_OVERRIDE", "get").mockReturnValue(ability);
     this.log(`Enemy Pokemon ability set to ${AbilityId[ability]} (=${ability})!`);
     return this;
   }
@@ -449,7 +449,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyPassiveAbility(passiveAbility: AbilityId): this {
-    vi.spyOn(Overrides, "OPP_PASSIVE_ABILITY_OVERRIDE", "get").mockReturnValue(passiveAbility);
+    vi.spyOn(Overrides, "ENEMY_PASSIVE_ABILITY_OVERRIDE", "get").mockReturnValue(passiveAbility);
     this.log(`Enemy Pokemon PASSIVE ability set to ${AbilityId[passiveAbility]} (=${passiveAbility})!`);
     return this;
   }
@@ -460,7 +460,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyHasPassiveAbility(hasPassiveAbility: boolean | null): this {
-    vi.spyOn(Overrides, "OPP_HAS_PASSIVE_ABILITY_OVERRIDE", "get").mockReturnValue(hasPassiveAbility);
+    vi.spyOn(Overrides, "ENEMY_HAS_PASSIVE_ABILITY_OVERRIDE", "get").mockReturnValue(hasPassiveAbility);
     if (hasPassiveAbility === null) {
       this.log("Enemy Pokemon PASSIVE ability no longer force enabled or disabled!");
     } else {
@@ -475,7 +475,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyMoveset(moveset: MoveId | MoveId[]): this {
-    vi.spyOn(Overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue(moveset);
+    vi.spyOn(Overrides, "ENEMY_MOVESET_OVERRIDE", "get").mockReturnValue(moveset);
     moveset = coerceArray(moveset);
     const movesetStr = moveset.map(moveId => MoveId[moveId]).join(", ");
     this.log(`Enemy Pokemon moveset set to ${movesetStr} (=[${moveset.join(", ")}])!`);
@@ -488,7 +488,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyLevel(level: number): this {
-    vi.spyOn(Overrides, "OPP_LEVEL_OVERRIDE", "get").mockReturnValue(level);
+    vi.spyOn(Overrides, "ENEMY_LEVEL_OVERRIDE", "get").mockReturnValue(level);
     this.log(`Enemy Pokemon level set to ${level}!`);
     return this;
   }
@@ -499,7 +499,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyStatusEffect(statusEffect: StatusEffect): this {
-    vi.spyOn(Overrides, "OPP_STATUS_OVERRIDE", "get").mockReturnValue(statusEffect);
+    vi.spyOn(Overrides, "ENEMY_STATUS_OVERRIDE", "get").mockReturnValue(statusEffect);
     this.log(`Enemy Pokemon status-effect set to ${StatusEffect[statusEffect]} (=${statusEffect})!`);
     return this;
   }
@@ -510,7 +510,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyHeldItems(items: ModifierOverride[]): this {
-    vi.spyOn(Overrides, "OPP_HELD_ITEMS_OVERRIDE", "get").mockReturnValue(items);
+    vi.spyOn(Overrides, "ENEMY_HELD_ITEMS_OVERRIDE", "get").mockReturnValue(items);
     this.log("Enemy Pokemon held items set to:", items);
     return this;
   }
@@ -571,7 +571,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @param variant - (Optional) The enemy's shiny {@linkcode Variant}.
    */
   enemyShiny(shininess: boolean | null, variant?: Variant): this {
-    vi.spyOn(Overrides, "OPP_SHINY_OVERRIDE", "get").mockReturnValue(shininess);
+    vi.spyOn(Overrides, "ENEMY_SHINY_OVERRIDE", "get").mockReturnValue(shininess);
     if (shininess === null) {
       this.log("Disabled enemy Pokemon shiny override!");
     } else {
@@ -579,7 +579,7 @@ export class OverridesHelper extends GameManagerHelper {
     }
 
     if (variant !== undefined) {
-      vi.spyOn(Overrides, "OPP_VARIANT_OVERRIDE", "get").mockReturnValue(variant);
+      vi.spyOn(Overrides, "ENEMY_VARIANT_OVERRIDE", "get").mockReturnValue(variant);
       this.log(`Set enemy shiny variant to be ${variant}!`);
     }
     return this;
@@ -594,7 +594,7 @@ export class OverridesHelper extends GameManagerHelper {
    * @returns `this`
    */
   public enemyHealthSegments(healthSegments: number): this {
-    vi.spyOn(Overrides, "OPP_HEALTH_SEGMENTS_OVERRIDE", "get").mockReturnValue(healthSegments);
+    vi.spyOn(Overrides, "ENEMY_HEALTH_SEGMENTS_OVERRIDE", "get").mockReturnValue(healthSegments);
     this.log("Enemy Pokemon health segments set to:", healthSegments);
     return this;
   }

test/test-utils/matchers/to-equal-array-unsorted.ts

@@ -1,4 +1,5 @@
 import { getOnelineDiffStr } from "#test/test-utils/string-utils";
+import { receivedStr } from "#test/test-utils/test-utils";
 import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 
 /**
@@ -14,22 +15,22 @@ export function toEqualArrayUnsorted(
 ): SyncExpectationResult {
   if (!Array.isArray(received)) {
     return {
-      pass: false,
-      message: () => `Expected an array, but got ${this.utils.stringify(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive an array, but got ${receivedStr(received)}!`,
     };
   }
 
   if (received.length !== expected.length) {
     return {
       pass: false,
-      message: () => `Expected to receive array of length ${received.length}, but got ${expected.length} instead!`,
-      actual: received,
+      message: () => `Expected to receive an array of length ${received.length}, but got ${expected.length} instead!`,
       expected,
+      actual: received,
     };
   }
 
-  const actualSorted = received.slice().sort();
-  const expectedSorted = expected.slice().sort();
+  const actualSorted = received.toSorted();
+  const expectedSorted = expected.toSorted();
   const pass = this.equals(actualSorted, expectedSorted, [...this.customTesters, this.utils.iterableEquality]);
 
   const actualStr = getOnelineDiffStr.call(this, actualSorted);

test/test-utils/matchers/to-have-ability-applied.ts

@@ -21,8 +21,8 @@ export function toHaveAbilityApplied(
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
-      message: () => `Expected to recieve a Pokemon, but got ${receivedStr(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive a Pokemon, but got ${receivedStr(received)}!`,
     };
   }
 

test/test-utils/matchers/to-have-arena-tag.ts

@@ -0,0 +1,77 @@
+import type { ArenaTag, ArenaTagTypeMap } from "#data/arena-tag";
+import type { ArenaTagSide } from "#enums/arena-tag-side";
+import type { ArenaTagType } from "#enums/arena-tag-type";
+import type { OneOther } from "#test/@types/test-helpers";
+// biome-ignore lint/correctness/noUnusedImports: TSDoc
+import type { GameManager } from "#test/test-utils/game-manager";
+import { getOnelineDiffStr } from "#test/test-utils/string-utils";
+import { isGameManagerInstance, receivedStr } from "#test/test-utils/test-utils";
+import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
+
+// intersection required to preserve T for inferences
+export type toHaveArenaTagOptions<T extends ArenaTagType> = OneOther<ArenaTagTypeMap[T], "tagType" | "side"> & {
+  tagType: T;
+};
+
+/**
+ * Matcher to check if the {@linkcode Arena} has a given {@linkcode ArenaTag} active.
+ * @param received - The object to check. Should be the current {@linkcode GameManager}.
+ * @param expectedTag - The `ArenaTagType` of the desired tag, or a partially-filled object
+ * containing the desired properties
+ * @param side - The {@linkcode ArenaTagSide | side of the field} the tag should affect, or
+ * {@linkcode ArenaTagSide.BOTH} to check both sides
+ * @returns The result of the matching
+ */
+export function toHaveArenaTag<T extends ArenaTagType>(
+  this: MatcherState,
+  received: unknown,
+  expectedTag: T | toHaveArenaTagOptions<T>,
+  side?: ArenaTagSide,
+): SyncExpectationResult {
+  if (!isGameManagerInstance(received)) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected to receive a GameManager, but got ${receivedStr(received)}!`,
+    };
+  }
+
+  if (!received.scene?.arena) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected GameManager.${received.scene ? "scene.arena" : "scene"} to be defined!`,
+    };
+  }
+
+  // Coerce lone `tagType`s into objects
+  // Bangs are ok as we enforce safety via overloads
+  // @ts-expect-error - Typescript is being stupid as tag type and side will always exist
+  const etag: Partial<ArenaTag> & { tagType: T; side: ArenaTagSide } =
+    typeof expectedTag === "object" ? expectedTag : { tagType: expectedTag, side: side! };
+
+  // We need to get all tags for the case of checking properties of a tag present on both sides of the arena
+  const tags = received.scene.arena.findTagsOnSide(t => t.tagType === etag.tagType, etag.side);
+  if (tags.length === 0) {
+    return {
+      pass: false,
+      message: () => `Expected the Arena to have a tag of type ${etag.tagType}, but it didn't!`,
+      expected: etag.tagType,
+      actual: received.scene.arena.tags.map(t => t.tagType),
+    };
+  }
+
+  // Pass if any of the matching tags meet our criteria
+  const pass = tags.some(tag =>
+    this.equals(tag, expectedTag, [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality]),
+  );
+
+  const expectedStr = getOnelineDiffStr.call(this, expectedTag);
+  return {
+    pass,
+    message: () =>
+      pass
+        ? `Expected the Arena to NOT have a tag matching ${expectedStr}, but it did!`
+        : `Expected the Arena to have a tag matching ${expectedStr}, but it didn't!`,
+    expected: expectedTag,
+    actual: tags,
+  };
+}

test/test-utils/matchers/to-have-effective-stat.ts

@@ -6,7 +6,7 @@ import { getStatName } from "#test/test-utils/string-utils";
 import { isPokemonInstance, receivedStr } from "#test/test-utils/test-utils";
 import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 
-export interface ToHaveEffectiveStatMatcherOptions {
+export interface toHaveEffectiveStatOptions {
   /**
    * The target {@linkcode Pokemon}
    * @see {@linkcode Pokemon.getEffectiveStat}
@@ -30,7 +30,7 @@ export interface ToHaveEffectiveStatMatcherOptions {
  * @param received - The object to check. Should be a {@linkcode Pokemon}
  * @param stat - The {@linkcode EffectiveStat} to check
  * @param expectedValue - The expected value of the {@linkcode stat}
- * @param options - The {@linkcode ToHaveEffectiveStatMatcherOptions}
+ * @param options - The {@linkcode toHaveEffectiveStatOptions}
  * @returns Whether the matcher passed
  */
 export function toHaveEffectiveStat(
@@ -38,11 +38,11 @@ export function toHaveEffectiveStat(
   received: unknown,
   stat: EffectiveStat,
   expectedValue: number,
-  { enemy, move, isCritical = false }: ToHaveEffectiveStatMatcherOptions = {},
+  { enemy, move, isCritical = false }: toHaveEffectiveStatOptions = {},
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }

test/test-utils/matchers/to-have-fainted.ts

@@ -12,7 +12,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveFainted(this: MatcherState, received: unknown): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }

test/test-utils/matchers/to-have-full-hp.ts

@@ -12,7 +12,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveFullHp(this: MatcherState, received: unknown): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }

test/test-utils/matchers/to-have-hp.ts

@@ -13,7 +13,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveHp(this: MatcherState, received: unknown, expectedHp: number): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }

test/test-utils/matchers/to-have-positional-tag.ts

@@ -0,0 +1,107 @@
+// biome-ignore-start lint/correctness/noUnusedImports: TSDoc
+import type { GameManager } from "#test/test-utils/game-manager";
+// biome-ignore-end lint/correctness/noUnusedImports: TSDoc
+
+import type { serializedPosTagMap } from "#data/positional-tags/load-positional-tag";
+import type { PositionalTagType } from "#enums/positional-tag-type";
+import type { OneOther } from "#test/@types/test-helpers";
+import { getOnelineDiffStr } from "#test/test-utils/string-utils";
+import { isGameManagerInstance, receivedStr } from "#test/test-utils/test-utils";
+import { toTitleCase } from "#utils/strings";
+import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
+
+export type toHavePositionalTagOptions<P extends PositionalTagType> = OneOther<serializedPosTagMap[P], "tagType"> & {
+  tagType: P;
+};
+
+/**
+ * Matcher to check if the {@linkcode Arena} has a certain number of {@linkcode PositionalTag}s active.
+ * @param received - The object to check. Should be the current {@linkcode GameManager}
+ * @param expectedTag - The {@linkcode PositionalTagType} of the desired tag, or a partially-filled {@linkcode PositionalTag}
+ * containing the desired properties
+ * @param count - The number of tags that should be active; defaults to `1` and must be within the range `[0, 4]`
+ * @returns The result of the matching
+ */
+export function toHavePositionalTag<P extends PositionalTagType>(
+  this: MatcherState,
+  received: unknown,
+  expectedTag: P | toHavePositionalTagOptions<P>,
+  count = 1,
+): SyncExpectationResult {
+  if (!isGameManagerInstance(received)) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected to receive a GameManager, but got ${receivedStr(received)}!`,
+    };
+  }
+
+  if (!received.scene?.arena?.positionalTagManager) {
+    return {
+      pass: this.isNot,
+      message: () =>
+        `Expected GameManager.${received.scene?.arena ? "scene.arena.positionalTagManager" : received.scene ? "scene.arena" : "scene"} to be defined!`,
+    };
+  }
+
+  // TODO: Increase limit if triple battles are added
+  if (count < 0 || count > 4) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected count to be between 0 and 4, but got ${count} instead!`,
+    };
+  }
+
+  const allTags = received.scene.arena.positionalTagManager.tags;
+  const tagType = typeof expectedTag === "string" ? expectedTag : expectedTag.tagType;
+  const matchingTags = allTags.filter(t => t.tagType === tagType);
+
+  // If checking exclusively tag type, check solely the number of matching tags on field
+  if (typeof expectedTag === "string") {
+    const pass = matchingTags.length === count;
+    const expectedStr = getPosTagStr(expectedTag);
+
+    return {
+      pass,
+      message: () =>
+        pass
+          ? `Expected the Arena to NOT have ${count} ${expectedStr} active, but it did!`
+          : `Expected the Arena to have ${count} ${expectedStr} active, but got ${matchingTags.length} instead!`,
+      expected: expectedTag,
+      actual: allTags,
+    };
+  }
+
+  // Check for equality with the provided object
+  if (matchingTags.length === 0) {
+    return {
+      pass: false,
+      message: () => `Expected the Arena to have a tag of type ${expectedTag.tagType}, but it didn't!`,
+      expected: expectedTag.tagType,
+      actual: received.scene.arena.tags.map(t => t.tagType),
+    };
+  }
+
+  // Pass if any of the matching tags meet the criteria
+  const pass = matchingTags.some(tag =>
+    this.equals(tag, expectedTag, [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality]),
+  );
+
+  const expectedStr = getOnelineDiffStr.call(this, expectedTag);
+  return {
+    pass,
+    message: () =>
+      pass
+        ? `Expected the Arena to NOT have a tag matching ${expectedStr}, but it did!`
+        : `Expected the Arena to have a tag matching ${expectedStr}, but it didn't!`,
+    expected: expectedTag,
+    actual: matchingTags,
+  };
+}
+
+function getPosTagStr(pType: PositionalTagType, count = 1): string {
+  let ret = toTitleCase(pType) + "Tag";
+  if (count > 1) {
+    ret += "s";
+  }
+  return ret;
+}

test/test-utils/matchers/to-have-stat-stage.ts

@@ -23,14 +23,14 @@ export function toHaveStatStage(
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }
 
   if (expectedStage < -6 || expectedStage > 6) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected ${expectedStage} to be within the range [-6, 6]!`,
     };
   }

test/test-utils/matchers/to-have-status-effect.ts

@@ -28,7 +28,7 @@ export function toHaveStatusEffect(
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }
@@ -37,10 +37,8 @@ export function toHaveStatusEffect(
   const actualEffect = received.status?.effect ?? StatusEffect.NONE;
 
   // Check exclusively effect equality first, coercing non-matching status effects to numbers.
-  if (actualEffect !== (expectedStatus as Exclude<typeof expectedStatus, StatusEffect>)?.effect) {
-    // This is actually 100% safe as `expectedStatus?.effect` will evaluate to `undefined` if a StatusEffect was passed,
-    // which will never match actualEffect by definition
-    expectedStatus = (expectedStatus as Exclude<typeof expectedStatus, StatusEffect>).effect;
+  if (typeof expectedStatus === "object" && actualEffect !== expectedStatus.effect) {
+    expectedStatus = expectedStatus.effect;
   }
 
   if (typeof expectedStatus === "number") {

test/test-utils/matchers/to-have-taken-damage.ts

@@ -24,7 +24,7 @@ export function toHaveTakenDamage(
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }

test/test-utils/matchers/to-have-terrain.ts

@@ -20,15 +20,15 @@ export function toHaveTerrain(
 ): SyncExpectationResult {
   if (!isGameManagerInstance(received)) {
     return {
-      pass: false,
-      message: () => `Expected GameManager, but got ${receivedStr(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive a GameManager, but got ${receivedStr(received)}!`,
     };
   }
 
   if (!received.scene?.arena) {
     return {
-      pass: false,
-      message: () => `Expected GameManager.${received.scene ? "scene" : "scene.arena"} to be defined!`,
+      pass: this.isNot,
+      message: () => `Expected GameManager.${received.scene ? "scene.arena" : "scene"} to be defined!`,
     };
   }
 
@@ -41,8 +41,8 @@ export function toHaveTerrain(
     pass,
     message: () =>
       pass
-        ? `Expected Arena to NOT have ${expectedStr} active, but it did!`
-        : `Expected Arena to have ${expectedStr} active, but got ${actualStr} instead!`,
+        ? `Expected the Arena to NOT have ${expectedStr} active, but it did!`
+        : `Expected the Arena to have ${expectedStr} active, but got ${actualStr} instead!`,
     expected: expectedTerrainType,
     actual,
   };

test/test-utils/matchers/to-have-types.ts

@@ -7,10 +7,16 @@ import { isPokemonInstance, receivedStr } from "../test-utils";
 
 export interface toHaveTypesOptions {
   /**
-   * Whether to enforce exact matches (`true`) or superset matches (`false`).
-   * @defaultValue `true`
+   * Value dictating the strength of the enforced typing match.
+   *
+   * Possible values (in ascending order of strength) are:
+   * - `"ordered"`: Enforce that the {@linkcode Pokemon}'s types are identical **and in the same order**
+   * - `"unordered"`: Enforce that the {@linkcode Pokemon}'s types are identical **without checking order**
+   * - `"superset"`: Enforce that the {@linkcode Pokemon}'s types are **a superset of** the expected types
+   * (all must be present, but extras can be there)
+   * @defaultValue `"unordered"`
    */
-  exact?: boolean;
+  mode?: "ordered" | "unordered" | "superset";
   /**
    * Optional arguments to pass to {@linkcode Pokemon.getTypes}.
    */
@@ -18,35 +24,54 @@ export interface toHaveTypesOptions {
 }
 
 /**
- * Matcher that checks if an array contains exactly the given items, disregarding order.
- * @param received - The object to check. Should be an array of one or more {@linkcode PokemonType}s.
- * @param options - The {@linkcode toHaveTypesOptions | options} for this matcher
+ * Matcher that checks if a Pokemon's typing is as expected.
+ * @param received - The object to check. Should be a {@linkcode Pokemon}
+ * @param expectedTypes - An array of one or more {@linkcode PokemonType}s to compare against.
+ * @param mode - The mode to perform the matching in.
+ * Possible values (in ascending order of strength) are:
+ * - `"ordered"`: Enforce that the {@linkcode Pokemon}'s types are identical **and in the same order**
+ * - `"unordered"`: Enforce that the {@linkcode Pokemon}'s types are identical **without checking order**
+ * - `"superset"`: Enforce that the {@linkcode Pokemon}'s types are **a superset of** the expected types
+ * (all must be present, but extras can be there)
+ *
+ * Default `unordered`
+ * @param args - Extra arguments passed to {@linkcode Pokemon.getTypes}
  * @returns The result of the matching
  */
 export function toHaveTypes(
   this: MatcherState,
   received: unknown,
-  expected: [PokemonType, ...PokemonType[]],
-  options: toHaveTypesOptions = {},
+  expectedTypes: [PokemonType, ...PokemonType[]],
+  { mode = "unordered", args = [] }: toHaveTypesOptions = {},
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
-      message: () => `Expected to recieve a Pokémon, but got ${receivedStr(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }
 
-  const actualTypes = received.getTypes(...(options.args ?? [])).sort();
-  const expectedTypes = expected.slice().sort();
+  // Return early if no types were passed in
+  if (expectedTypes.length === 0) {
+    return {
+      pass: this.isNot,
+      message: () => "Expected to receive a non-empty array of PokemonTypes!",
+    };
+  }
+
+  // Avoid sorting the types if strict ordering is desired
+  const actualSorted = mode === "ordered" ? received.getTypes(...args) : received.getTypes(...args).toSorted();
+  const expectedSorted = mode === "ordered" ? expectedTypes : expectedTypes.toSorted();
 
   // Exact matches do not care about subset equality
-  const matchers = options.exact
-    ? [...this.customTesters, this.utils.iterableEquality]
-    : [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality];
-  const pass = this.equals(actualTypes, expectedTypes, matchers);
+  const matchers =
+    mode === "superset"
+      ? [...this.customTesters, this.utils.iterableEquality]
+      : [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality];
+  const pass = this.equals(actualSorted, expectedSorted, matchers);
 
-  const actualStr = stringifyEnumArray(PokemonType, actualTypes);
-  const expectedStr = stringifyEnumArray(PokemonType, expectedTypes);
+  const actualStr = stringifyEnumArray(PokemonType, actualSorted);
+  const expectedStr = stringifyEnumArray(PokemonType, expectedSorted);
   const pkmName = getPokemonNameWithAffix(received);
 
   return {
@@ -55,7 +80,7 @@ export function toHaveTypes(
       pass
         ? `Expected ${pkmName} to NOT have types ${expectedStr}, but it did!`
         : `Expected ${pkmName} to have types ${expectedStr}, but got ${actualStr} instead!`,
-    expected: expectedTypes,
-    actual: actualTypes,
+    expected: expectedSorted,
+    actual: actualSorted,
   };
 }

test/test-utils/matchers/to-have-used-move.ts

@@ -13,7 +13,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 /**
  * Matcher to check the contents of a {@linkcode Pokemon}'s move history.
  * @param received - The actual value received. Should be a {@linkcode Pokemon}
- * @param expectedValue - The {@linkcode MoveId} the Pokemon is expected to have used,
+ * @param expectedMove - The {@linkcode MoveId} the Pokemon is expected to have used,
  * or a partially filled {@linkcode TurnMove} containing the desired properties to check
  * @param index - The index of the move history entry to check, in order from most recent to least recent.
  * Default `0` (last used move)
@@ -22,12 +22,12 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveUsedMove(
   this: MatcherState,
   received: unknown,
-  expectedResult: MoveId | AtLeastOne<TurnMove>,
+  expectedMove: MoveId | AtLeastOne<TurnMove>,
   index = 0,
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }
@@ -37,34 +37,33 @@ export function toHaveUsedMove(
 
   if (move === undefined) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected ${pkmName} to have used ${index + 1} moves, but it didn't!`,
       actual: received.getLastXMoves(-1),
     };
   }
 
   // Coerce to a `TurnMove`
-  if (typeof expectedResult === "number") {
-    expectedResult = { move: expectedResult };
+  if (typeof expectedMove === "number") {
+    expectedMove = { move: expectedMove };
   }
 
   const moveIndexStr = index === 0 ? "last move" : `${getOrdinal(index)} most recent move`;
 
-  const pass = this.equals(move, expectedResult, [
+  const pass = this.equals(move, expectedMove, [
     ...this.customTesters,
     this.utils.subsetEquality,
     this.utils.iterableEquality,
   ]);
 
-  const expectedStr = getOnelineDiffStr.call(this, expectedResult);
+  const expectedStr = getOnelineDiffStr.call(this, expectedMove);
   return {
     pass,
     message: () =>
       pass
         ? `Expected ${pkmName}'s ${moveIndexStr} to NOT match ${expectedStr}, but it did!`
-        : // Replace newlines with spaces to preserve one-line ness
-          `Expected ${pkmName}'s ${moveIndexStr} to match ${expectedStr}, but it didn't!`,
-    expected: expectedResult,
+        : `Expected ${pkmName}'s ${moveIndexStr} to match ${expectedStr}, but it didn't!`,
+    expected: expectedMove,
     actual: move,
   };
 }

test/test-utils/matchers/to-have-used-pp.ts

@@ -13,7 +13,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 /**
  * Matcher to check the amount of PP consumed by a {@linkcode Pokemon}.
  * @param received - The actual value received. Should be a {@linkcode Pokemon}
- * @param expectedValue - The {@linkcode MoveId} that should have consumed PP
+ * @param moveId - The {@linkcode MoveId} that should have consumed PP
  * @param ppUsed - The numerical amount of PP that should have been consumed,
  * or `all` to indicate the move should be _out_ of PP
  * @returns Whether the matcher passed
@@ -23,35 +23,35 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveUsedPP(
   this: MatcherState,
   received: unknown,
-  expectedMove: MoveId,
+  moveId: MoveId,
   ppUsed: number | "all",
 ): SyncExpectationResult {
   if (!isPokemonInstance(received)) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
     };
   }
 
-  const override = received.isPlayer() ? Overrides.MOVESET_OVERRIDE : Overrides.OPP_MOVESET_OVERRIDE;
+  const override = received.isPlayer() ? Overrides.MOVESET_OVERRIDE : Overrides.ENEMY_MOVESET_OVERRIDE;
   if (coerceArray(override).length > 0) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () =>
         `Cannot test for PP consumption with ${received.isPlayer() ? "player" : "enemy"} moveset overrides active!`,
     };
   }
 
   const pkmName = getPokemonNameWithAffix(received);
-  const moveStr = getEnumStr(MoveId, expectedMove);
+  const moveStr = getEnumStr(MoveId, moveId);
 
-  const movesetMoves = received.getMoveset().filter(pm => pm.moveId === expectedMove);
+  const movesetMoves = received.getMoveset().filter(pm => pm.moveId === moveId);
   if (movesetMoves.length !== 1) {
     return {
-      pass: false,
+      pass: this.isNot,
       message: () =>
         `Expected MoveId.${moveStr} to appear in ${pkmName}'s moveset exactly once, but got ${movesetMoves.length} times!`,
-      expected: expectedMove,
+      expected: moveId,
       actual: received.getMoveset(),
     };
   }

test/test-utils/matchers/to-have-weather.ts

@@ -20,15 +20,15 @@ export function toHaveWeather(
 ): SyncExpectationResult {
   if (!isGameManagerInstance(received)) {
     return {
-      pass: false,
-      message: () => `Expected GameManager, but got ${receivedStr(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive a GameManager, but got ${receivedStr(received)}!`,
     };
   }
 
   if (!received.scene?.arena) {
     return {
-      pass: false,
-      message: () => `Expected GameManager.${received.scene ? "scene" : "scene.arena"} to be defined!`,
+      pass: this.isNot,
+      message: () => `Expected GameManager.${received.scene ? "scene.arena" : "scene"} to be defined!`,
     };
   }
 
@@ -41,8 +41,8 @@ export function toHaveWeather(
     pass,
     message: () =>
       pass
-        ? `Expected Arena to NOT have ${expectedStr} weather active, but it did!`
-        : `Expected Arena to have ${expectedStr} weather active, but got ${actualStr} instead!`,
+        ? `Expected the Arena to NOT have ${expectedStr} weather active, but it did!`
+        : `Expected the Arena to have ${expectedStr} weather active, but got ${actualStr} instead!`,
     expected: expectedWeatherType,
     actual,
   };

test/test-utils/string-utils.ts

@@ -34,10 +34,10 @@ interface getEnumStrOptions {
  * @returns The stringified representation of `val` as dictated by the options.
  * @example
  * ```ts
- * enum fakeEnum {
- *   ONE: 1,
- *   TWO: 2,
- *   THREE: 3,
+ * enum testEnum {
+ *   ONE = 1,
+ *   TWO = 2,
+ *   THREE = 3,
  * }
  * getEnumStr(fakeEnum, fakeEnum.ONE); // Output: "ONE (=1)"
  * getEnumStr(fakeEnum, fakeEnum.TWO, {casing: "Title", prefix: "fakeEnum.", suffix: "!!!"}); // Output: "fakeEnum.TWO!!! (=2)"
@@ -174,10 +174,14 @@ export function getStatName(s: Stat): string {
  * Convert an object into a oneline diff to be shown in an error message.
  * @param obj - The object to return the oneline diff of
  * @returns The updated diff
+ * @example
+ * ```ts
+ * const diff = getOnelineDiffStr.call(this, obj)
+ * ```
  */
 export function getOnelineDiffStr(this: MatcherState, obj: unknown): string {
   return this.utils
     .stringify(obj, undefined, { maxLength: 35, indent: 0, printBasicPrototype: false })
     .replace(/\n/g, " ") // Replace newlines with spaces
-    .replace(/,(\s*)}$/g, "$1}");
+    .replace(/,(\s*)}$/g, "$1}"); // Trim trailing commas
 }