Merge 9d5e84dd90 into 10e0f9f0de

src/battle.ts

@@ -7,7 +7,7 @@ import { MoneyMultiplierModifier, PokemonHeldItemModifier } from "./modifier/mod
 import { PokeballType } from "#enums/pokeball";
 import { trainerConfigs } from "#app/data/trainer-config";
 import { SpeciesFormKey } from "#enums/species-form-key";
-import Pokemon, { EnemyPokemon, PlayerPokemon, QueuedMove } from "#app/field/pokemon";
+import Pokemon, { EnemyPokemon, PlayerPokemon, TurnMove } from "#app/field/pokemon";
 import { ArenaTagType } from "#enums/arena-tag-type";
 import { BattleSpec } from "#enums/battle-spec";
 import { Moves } from "#enums/moves";
@@ -44,12 +44,12 @@ export enum BattlerIndex {
 }
 
 export interface TurnCommand {
-  command: Command;
+    command: Command;
-  cursor?: number;
+    cursor?: number;
-  move?: QueuedMove;
+    move?: TurnMove;
-  targets?: BattlerIndex[];
+    targets?: BattlerIndex[];
-  skip?: boolean;
+    skip?: boolean;
-  args?: any[];
+    args?: any[];
 }
 
 export interface FaintLogEntry {
@@ -91,6 +91,7 @@ export default class Battle {
   public playerFaintsHistory: FaintLogEntry[] = [];
   public enemyFaintsHistory: FaintLogEntry[] = [];
 
+
   public mysteryEncounterType?: MysteryEncounterType;
   /** If the current battle is a Mystery Encounter, this will always be defined */
   public mysteryEncounter?: MysteryEncounter;

src/data/battler-tags.ts

@@ -610,7 +610,7 @@ export class InterruptedTag extends BattlerTag {
     super.onAdd(pokemon);
 
     pokemon.getMoveQueue().shift();
-    pokemon.pushMoveHistory({ move: Moves.NONE, result: MoveResult.OTHER });
+    pokemon.pushMoveHistory({ move: Moves.NONE, result: MoveResult.OTHER, targets: []});
   }
 
   lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {

src/field/pokemon.ts

@@ -3286,7 +3286,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     }
   }
 
-  getMoveQueue(): QueuedMove[] {
+  getMoveQueue(): TurnMove[] {
     return this.summonData.moveQueue;
   }
 
@@ -4801,17 +4801,19 @@ export class EnemyPokemon extends Pokemon {
    * the Pokemon the move will target.
    * @returns this Pokemon's next move in the format {move, moveTargets}
    */
-  getNextMove(): QueuedMove {
+  getNextMove(): TurnMove {
     // If this Pokemon has a move already queued, return it.
-    const queuedMove = this.getMoveQueue().length
+    const moveQueue = this.getMoveQueue();
-      ? this.getMoveset().find(m => m?.moveId === this.getMoveQueue()[0].move)
+    if (moveQueue.length !== 0) {
-      : null;
+      const queuedMove = moveQueue[0];
-    if (queuedMove) {
+      if (queuedMove) {
-      if (queuedMove.isUsable(this, this.getMoveQueue()[0].ignorePP)) {
+        const moveIndex = this.getMoveset().findIndex(m => m?.moveId === moveQueue[0].move);
-        return { move: queuedMove.moveId, targets: this.getMoveQueue()[0].targets, ignorePP: this.getMoveQueue()[0].ignorePP };
+        if ((moveIndex > -1 && this.getMoveset()[moveIndex]!.isUsable(this, queuedMove.ignorePP)) || queuedMove.virtual) {
-      } else {
+          return queuedMove;
-        this.getMoveQueue().shift();
+        } else {
-        return this.getNextMove();
+          this.getMoveQueue().shift();
+          return this.getNextMove();
+        }
       }
     }
 
@@ -5233,15 +5235,10 @@ export class EnemyPokemon extends Pokemon {
 
 export interface TurnMove {
   move: Moves;
-  targets?: BattlerIndex[];
+  targets: BattlerIndex[];
-  result: MoveResult;
+  result?: MoveResult;
   virtual?: boolean;
   turn?: number;
-}
-
-export interface QueuedMove {
-  move: Moves;
-  targets: BattlerIndex[];
   ignorePP?: boolean;
 }
 
@@ -5257,7 +5254,7 @@ export interface AttackMoveResult {
 export class PokemonSummonData {
   /** [Atk, Def, SpAtk, SpDef, Spd, Acc, Eva] */
   public statStages: number[] = [ 0, 0, 0, 0, 0, 0, 0 ];
-  public moveQueue: QueuedMove[] = [];
+  public moveQueue: TurnMove[] = [];
   public tags: BattlerTag[] = [];
   public abilitySuppressed: boolean = false;
   public abilitiesApplied: Abilities[] = [];

src/phases/command-phase.ts

@@ -8,7 +8,7 @@ import { BattlerTagType } from "#app/enums/battler-tag-type";
 import { Biome } from "#app/enums/biome";
 import { Moves } from "#app/enums/moves";
 import { PokeballType } from "#enums/pokeball";
-import { FieldPosition, PlayerPokemon } from "#app/field/pokemon";
+import { FieldPosition, PlayerPokemon, TurnMove } from "#app/field/pokemon";
 import { getPokemonNameWithAffix } from "#app/messages";
 import { Command } from "#app/ui/command-ui-handler";
 import { Mode } from "#app/ui/ui";
@@ -76,19 +76,19 @@ export class CommandPhase extends FieldPhase {
     const moveQueue = playerPokemon.getMoveQueue();
 
     while (moveQueue.length && moveQueue[0]
-        && moveQueue[0].move && (!playerPokemon.getMoveset().find(m => m?.moveId === moveQueue[0].move)
+        && moveQueue[0].move && !moveQueue[0].virtual && (!playerPokemon.getMoveset().find(m => m?.moveId === moveQueue[0].move)
           || !playerPokemon.getMoveset()[playerPokemon.getMoveset().findIndex(m => m?.moveId === moveQueue[0].move)]!.isUsable(playerPokemon, moveQueue[0].ignorePP))) { // TODO: is the bang correct?
       moveQueue.shift();
     }
 
-    if (moveQueue.length) {
+    if (moveQueue.length !== 0) {
       const queuedMove = moveQueue[0];
       if (!queuedMove.move) {
-        this.handleCommand(Command.FIGHT, -1, false);
+        this.handleCommand(Command.FIGHT, -1, undefined);
       } else {
         const moveIndex = playerPokemon.getMoveset().findIndex(m => m?.moveId === queuedMove.move);
-        if (moveIndex > -1 && playerPokemon.getMoveset()[moveIndex]!.isUsable(playerPokemon, queuedMove.ignorePP)) { // TODO: is the bang correct?
+        if ((moveIndex > -1 && playerPokemon.getMoveset()[moveIndex]!.isUsable(playerPokemon, queuedMove.ignorePP)) || queuedMove.virtual) { // TODO: is the bang correct?
-          this.handleCommand(Command.FIGHT, moveIndex, queuedMove.ignorePP, { targets: queuedMove.targets, multiple: queuedMove.targets.length > 1 });
+          this.handleCommand(Command.FIGHT, moveIndex, queuedMove.ignorePP, queuedMove);
         } else {
           this.scene.ui.setMode(Mode.COMMAND, this.fieldIndex);
         }
@@ -110,12 +110,24 @@ export class CommandPhase extends FieldPhase {
     switch (command) {
       case Command.FIGHT:
         let useStruggle = false;
+        const turnMove: TurnMove | undefined = (args.length === 2 ? (args[1] as TurnMove) : undefined);
         if (cursor === -1 ||
             playerPokemon.trySelectMove(cursor, args[0] as boolean) ||
             (useStruggle = cursor > -1 && !playerPokemon.getMoveset().filter(m => m?.isUsable(playerPokemon)).length)) {
-          const moveId = !useStruggle ? cursor > -1 ? playerPokemon.getMoveset()[cursor]!.moveId : Moves.NONE : Moves.STRUGGLE; // TODO: is the bang correct?
+
+          let moveId: Moves;
+          if (useStruggle) {
+            moveId = Moves.STRUGGLE;
+          } else if (turnMove !== undefined) {
+            moveId = turnMove.move;
+          } else if (cursor > -1) {
+            moveId = playerPokemon.getMoveset()[cursor]!.moveId;
+          } else {
+            moveId = Moves.NONE;
+          }
+
           const turnCommand: TurnCommand = { command: Command.FIGHT, cursor: cursor, move: { move: moveId, targets: [], ignorePP: args[0] }, args: args };
-          const moveTargets: MoveTargetSet = args.length < 3 ? getMoveTargets(playerPokemon, moveId) : args[2];
+          const moveTargets: MoveTargetSet = turnMove === undefined ? getMoveTargets(playerPokemon, moveId) : { targets: turnMove.targets, multiple: turnMove.targets.length > 1 };
           if (!moveId) {
             turnCommand.targets = [ this.fieldIndex ];
           }

src/phases/move-phase.ts

@@ -294,11 +294,6 @@ export class MovePhase extends BattlePhase {
       this.scene.eventTarget.dispatchEvent(new MoveUsedEvent(this.pokemon?.id, this.move.getMove(), this.move.ppUsed));
     }
 
-    // Update the battle's "last move" pointer, unless we're currently mimicking a move.
-    if (!allMoves[this.move.moveId].hasAttr(CopyMoveAttr)) {
-      this.scene.currentBattle.lastMove = this.move.moveId;
-    }
-
     /**
      * Determine if the move is successful (meaning that its damage/effects can be attempted)
      * by checking that all of the following are true:
@@ -322,6 +317,14 @@ export class MovePhase extends BattlePhase {
 
     const success = passesConditions && !failedDueToWeather && !failedDueToTerrain;
 
+    // Update the battle's "last move" pointer, unless we're currently mimicking a move.
+    if (!allMoves[this.move.moveId].hasAttr(CopyMoveAttr)) {
+      // The last move used is unaffected by moves that fail
+      if (success) {
+        this.scene.currentBattle.lastMove = this.move.moveId;
+      }
+    }
+
     /**
      * If the move has not failed, trigger ability-based user type changes and then execute it.
      *
@@ -516,7 +519,7 @@ export class MovePhase extends BattlePhase {
         frenzyMissFunc(this.pokemon, this.move.getMove());
       }
 
-      this.pokemon.pushMoveHistory({ move: Moves.NONE, result: MoveResult.FAIL });
+      this.pokemon.pushMoveHistory({ move: Moves.NONE, result: MoveResult.FAIL, targets: this.targets });
 
       this.pokemon.lapseTags(BattlerTagLapseType.MOVE_EFFECT);
       this.pokemon.lapseTags(BattlerTagLapseType.AFTER_MOVE);

src/test/moves/assist.test.ts

@@ -0,0 +1,70 @@
+import { BattlerIndex } from "#app/battle";
+import { Stat } from "#app/enums/stat";
+import { MoveResult } from "#app/field/pokemon";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Moves - Assist", () => {
+  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
+      .moveset([ Moves.ASSIST, Moves.SKETCH, Moves.FLY, Moves.DRAGON_TAIL ]) // These are all moves Assist cannot call; Sketch will be used to test that it can call other moves properly
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyLevel(100)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("should be able to use an ally's moves", async () => {
+    game.override
+      .battleType("double")
+      .enemyMoveset(Moves.SWORDS_DANCE);
+    await game.classicMode.startBattle([ Species.FEEBAS, Species.SHUCKLE ]);
+
+    game.move.select(Moves.ASSIST, 0);
+    game.move.select(Moves.SKETCH, 1);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER ]);
+    // Player_2 uses Sketch, copies Swords Dance, Player_1 uses Assist, uses Player_2's Sketched Swords Dance
+    await game.toNextTurn();
+
+    expect(game.scene.getPlayerPokemon()!.getStatStage(Stat.ATK)).toBe(2); // Stat raised from Assist -> Swords Dance
+  });
+
+  it("should fail if there are no usable moves", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+    // Moves above are already unusable by Assist
+    game.move.select(Moves.ASSIST, 0);
+    await game.toNextTurn();
+    expect(game.scene.getPlayerPokemon()!.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+  });
+
+  it("should apply secondary effects of a move", async () => {
+    game.override.moveset([ Moves.ASSIST, Moves.WOOD_HAMMER, Moves.WOOD_HAMMER, Moves.WOOD_HAMMER ]);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.ASSIST, 0);
+    await game.toNextTurn();
+
+    expect(game.scene.getPlayerPokemon()!.isFullHp()).toBeFalsy(); // should receive recoil damage from Wood Hammer
+  });
+});

src/test/moves/copycat.test.ts

@@ -0,0 +1,88 @@
+import { BattlerIndex } from "#app/battle";
+import { Stat } from "#app/enums/stat";
+import { MoveResult } from "#app/field/pokemon";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("Moves - Copycat", () => {
+  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
+      .moveset([ Moves.COPYCAT, Moves.SPIKY_SHIELD, Moves.SWORDS_DANCE, Moves.SPLASH ])
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .starterSpecies(Species.FEEBAS)
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("should copy the last move successfully executed", async () => {
+    game.override.enemyMoveset(Moves.SUCKER_PUNCH);
+    await game.classicMode.startBattle();
+
+    game.move.select(Moves.SWORDS_DANCE);
+    await game.toNextTurn();
+
+    game.move.select(Moves.COPYCAT); // Last successful move should be Swords Dance
+    await game.toNextTurn();
+
+    expect(game.scene.getPlayerPokemon()!.getStatStage(Stat.ATK)).toBe(4);
+  });
+
+  it("should fail when the last move used is not a valid Copycat move", async () => {
+    game.override.enemyMoveset(Moves.PROTECT); // Protect is not a valid move for Copycat to copy
+    await game.classicMode.startBattle();
+
+    game.move.select(Moves.SPIKY_SHIELD); // Spiky Shield is not a valid move for Copycat to copy
+    await game.toNextTurn();
+
+    game.move.select(Moves.COPYCAT);
+    await game.toNextTurn();
+
+    expect(game.scene.getPlayerPokemon()!.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+  });
+
+  it("should copy the called move when the last move successfully calls another", async () => {
+    game.override
+      .moveset([ Moves.SPLASH, Moves.METRONOME ])
+      .enemyMoveset(Moves.COPYCAT);
+    await game.classicMode.startBattle();
+    vi.spyOn(game.scene.getPlayerPokemon()!, "randSeedInt").mockReturnValue(Moves.SWORDS_DANCE);
+
+    game.move.select(Moves.METRONOME);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]); // Player moves first, so enemy can copy Swords Dance
+    await game.toNextTurn();
+
+    expect(game.scene.getEnemyPokemon()!.getStatStage(Stat.ATK)).toBe(2);
+  });
+
+  it("should apply secondary effects of a move", async () => {
+    game.override.enemyMoveset(Moves.ACID_SPRAY); // Secondary effect lowers SpDef by 2 stages
+    await game.classicMode.startBattle();
+
+    game.move.select(Moves.COPYCAT);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+
+    expect(game.scene.getEnemyPokemon()!.getStatStage(Stat.SPDEF)).toBe(-2);
+  });
+});

src/test/moves/metronome.test.ts

@@ -0,0 +1,117 @@
+import { RechargingTag, SemiInvulnerableTag } from "#app/data/battler-tags";
+import { Abilities } from "#app/enums/abilities";
+import { Stat } from "#app/enums/stat";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, it, expect, vi } from "vitest";
+
+describe("Moves - Metronome", () => {
+  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
+      .moveset([ Moves.METRONOME, Moves.SPLASH ])
+      .battleType("single")
+      .startingLevel(100)
+      .starterSpecies(Species.REGIELEKI)
+      .enemyLevel(100)
+      .enemySpecies(Species.SHUCKLE)
+      .enemyMoveset(Moves.SPLASH)
+      .enemyAbility(Abilities.BALL_FETCH);
+  });
+
+  it("should have one semi-invulnerable turn and deal damage on the second turn when a semi-invulnerable move is called", async () => {
+    await game.classicMode.startBattle();
+    const player = game.scene.getPlayerPokemon()!;
+    const enemy = game.scene.getEnemyPokemon()!;
+    vi.spyOn(player, "randSeedInt").mockReturnValue(Moves.DIVE);
+
+    game.move.select(Moves.METRONOME);
+    await game.toNextTurn();
+
+    expect(player.getTag(SemiInvulnerableTag)).toBeTruthy();
+    await game.move.forceHit(); // Force hit on Dive, required due to randSeedInt mock making hitCheck return false every time.
+
+    await game.toNextTurn();
+    expect(player.getTag(SemiInvulnerableTag)).toBeFalsy();
+    expect(enemy.isFullHp()).toBeFalsy();
+  });
+
+  it("should apply secondary effects of a move", async () => {
+    await game.classicMode.startBattle();
+    const player = game.scene.getPlayerPokemon()!;
+    vi.spyOn(player, "randSeedInt").mockReturnValue(Moves.WOOD_HAMMER);
+
+    game.move.select(Moves.METRONOME);
+    await game.phaseInterceptor.to("MoveEffectPhase"); // Metronome has its own MoveEffectPhase, followed by Wood Hammer's MoveEffectPhase
+    await game.move.forceHit(); // Calls forceHit on Wood Hammer's MoveEffectPhase, required due to randSeedInt mock making hitCheck return false every time.
+    await game.toNextTurn();
+
+    expect(player.isFullHp()).toBeFalsy();
+  });
+
+  it("should recharge after using recharge move", async () => {
+    await game.classicMode.startBattle();
+    const player = game.scene.getPlayerPokemon()!;
+    vi.spyOn(player, "randSeedInt").mockReturnValue(Moves.HYPER_BEAM);
+
+    game.move.select(Moves.METRONOME);
+    await game.phaseInterceptor.to("MoveEffectPhase");
+    await game.move.forceHit();
+    await game.toNextTurn();
+
+    expect(player.getTag(RechargingTag)).toBeTruthy();
+  });
+
+  it("should only target ally for Aromatic Mist", async () => {
+    game.override.battleType("double");
+    await game.classicMode.startBattle([ Species.REGIELEKI, Species.RATTATA ]);
+    const [ leftPlayer, rightPlayer ] = game.scene.getPlayerField();
+    const [ leftOpp, rightOpp ] = game.scene.getEnemyField();
+    vi.spyOn(leftPlayer, "randSeedInt").mockReturnValue(Moves.AROMATIC_MIST);
+
+    game.move.select(Moves.METRONOME);
+    game.move.select(Moves.SPLASH, 1);
+    await game.phaseInterceptor.to("MoveEffectPhase");
+    await game.move.forceHit();
+    await game.toNextTurn();
+
+    expect(rightPlayer.getStatStage(Stat.SPDEF)).toBe(1);
+    expect(leftPlayer.getStatStage(Stat.SPDEF)).toBe(0);
+    expect(leftOpp.getStatStage(Stat.SPDEF)).toBe(0);
+    expect(rightOpp.getStatStage(Stat.SPDEF)).toBe(0);
+  });
+
+  it("should cause opponent to flee, and not crash for Roar", async () => {
+    await game.classicMode.startBattle();
+    const player = game.scene.getPlayerPokemon()!;
+    vi.spyOn(player, "randSeedInt").mockReturnValue(Moves.ROAR);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+
+    game.move.select(Moves.METRONOME);
+    await game.phaseInterceptor.to("MoveEffectPhase");
+    await game.move.forceHit();
+    await game.phaseInterceptor.to("BerryPhase");
+
+    const isVisible = enemyPokemon.visible;
+    const hasFled = enemyPokemon.switchOutStatus;
+    expect(!isVisible && hasFled).toBe(true);
+
+    await game.phaseInterceptor.to("BattleEndPhase");
+  });
+});

src/test/moves/mirror_move.test.ts

@@ -0,0 +1,84 @@
+import { BattlerIndex } from "#app/battle";
+import { Stat } from "#app/enums/stat";
+import { MoveResult } from "#app/field/pokemon";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Moves - Mirror Move", () => {
+  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
+      .moveset([ Moves.MIRROR_MOVE, Moves.SPLASH ])
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("should use the last move that the target", async () => {
+    game.override
+      .battleType("double")
+      .enemyMoveset([ Moves.TACKLE, Moves.GROWL ]);
+    await game.classicMode.startBattle([ Species.FEEBAS, Species.MAGIKARP ]);
+
+    game.move.select(Moves.MIRROR_MOVE, 0, BattlerIndex.ENEMY); // target's last move is Tackle, enemy should receive damage from Mirror Move copying Tackle
+    game.move.select(Moves.SPLASH, 1);
+    await game.forceEnemyMove(Moves.TACKLE, BattlerIndex.PLAYER_2);
+    await game.forceEnemyMove(Moves.GROWL, BattlerIndex.PLAYER_2);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+
+    expect(game.scene.getEnemyField()[0].isFullHp()).toBeFalsy();
+  });
+
+  it("should apply secondary effects of a move", async () => {
+    game.override.enemyMoveset(Moves.ACID_SPRAY);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.MIRROR_MOVE);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+
+    expect(game.scene.getEnemyPokemon()!.getStatStage(Stat.SPDEF)).toBe(-2);
+  });
+
+  it("should be able to copy status moves", async () => {
+    game.override.enemyMoveset(Moves.GROWL);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.MIRROR_MOVE);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
+    await game.toNextTurn();
+
+    expect(game.scene.getEnemyPokemon()!.getStatStage(Stat.ATK)).toBe(-1);
+  });
+
+  it("should fail if the target has not used any moves", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.MIRROR_MOVE);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+    await game.toNextTurn();
+
+    expect(game.scene.getPlayerPokemon()!.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+  });
+});

src/test/moves/sleep_talk.test.ts

@@ -0,0 +1,75 @@
+import { Stat } from "#app/enums/stat";
+import { StatusEffect } from "#app/enums/status-effect";
+import { MoveResult } from "#app/field/pokemon";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Moves - Sleep Talk", () => {
+  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
+      .moveset([ Moves.SPLASH, Moves.SLEEP_TALK ])
+      .statusEffect(StatusEffect.SLEEP)
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH)
+      .enemyLevel(100);
+  });
+
+  it("should fail when the user is not asleep", async () => {
+    game.override.statusEffect(StatusEffect.NONE);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.SLEEP_TALK);
+    await game.toNextTurn();
+    expect(game.scene.getPlayerPokemon()!.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+  });
+
+  it("should fail if the user has no valid moves", async () => {
+    game.override.moveset([ Moves.SLEEP_TALK, Moves.DIG, Moves.METRONOME, Moves.SOLAR_BEAM, Moves.SLEEP_TALK ]);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.SLEEP_TALK);
+    await game.toNextTurn();
+    expect(game.scene.getPlayerPokemon()!.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+  });
+
+  it("should call a random valid move if the user is asleep", async () => {
+    game.override.moveset([ Moves.SLEEP_TALK, Moves.DIG, Moves.FLY, Moves.SWORDS_DANCE ]); // Dig and Fly are invalid moves, Swords Dance should always be called
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    game.move.select(Moves.SLEEP_TALK);
+    await game.toNextTurn();
+    expect(game.scene.getPlayerPokemon()!.getStatStage(Stat.ATK));
+  });
+
+  it("should apply secondary effects of a move", async () => {
+    game.override.moveset([ Moves.SLEEP_TALK, Moves.DIG, Moves.FLY, Moves.WOOD_HAMMER ]); // Dig and Fly are invalid moves, Wood Hammer should always be called
+    await game.classicMode.startBattle();
+
+    game.move.select(Moves.SLEEP_TALK);
+    await game.toNextTurn();
+
+    expect(game.scene.getPlayerPokemon()!.isFullHp()).toBeFalsy(); // Wood Hammer recoil effect should be applied
+  });
+});

src/test/moves/spit_up.test.ts

@@ -124,7 +124,7 @@ describe("Moves - Spit Up", () => {
     game.move.select(Moves.SPIT_UP);
     await game.phaseInterceptor.to(TurnInitPhase);
 
-    expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SPIT_UP, result: MoveResult.FAIL });
+    expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SPIT_UP, result: MoveResult.FAIL, targets: [ game.scene.getEnemyPokemon()!.getBattlerIndex() ]});
 
     expect(spitUp.calculateBattlePower).not.toHaveBeenCalled();
   });
@@ -147,7 +147,7 @@ describe("Moves - Spit Up", () => {
 
       await game.phaseInterceptor.to(TurnInitPhase);
 
-      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SPIT_UP, result: MoveResult.SUCCESS });
+      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SPIT_UP, result: MoveResult.SUCCESS, targets: [ game.scene.getEnemyPokemon()!.getBattlerIndex() ]});
 
       expect(spitUp.calculateBattlePower).toHaveBeenCalledOnce();
 
@@ -175,7 +175,7 @@ describe("Moves - Spit Up", () => {
       game.move.select(Moves.SPIT_UP);
       await game.phaseInterceptor.to(TurnInitPhase);
 
-      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SPIT_UP, result: MoveResult.SUCCESS });
+      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SPIT_UP, result: MoveResult.SUCCESS, targets: [ game.scene.getEnemyPokemon()!.getBattlerIndex() ]});
 
       expect(spitUp.calculateBattlePower).toHaveBeenCalledOnce();
 

src/test/moves/stockpile.test.ts

@@ -71,7 +71,7 @@ describe("Moves - Stockpile", () => {
           expect(user.getStatStage(Stat.SPDEF)).toBe(3);
           expect(stockpilingTag).toBeDefined();
           expect(stockpilingTag.stockpiledCount).toBe(3);
-          expect(user.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ result: MoveResult.FAIL, move: Moves.STOCKPILE });
+          expect(user.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ result: MoveResult.FAIL, move: Moves.STOCKPILE, targets: [ user.getBattlerIndex() ]});
         }
       }
     });

src/test/moves/swallow.test.ts

@@ -134,7 +134,7 @@ describe("Moves - Swallow", () => {
     game.move.select(Moves.SWALLOW);
     await game.phaseInterceptor.to(TurnInitPhase);
 
-    expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SWALLOW, result: MoveResult.FAIL });
+    expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SWALLOW, result: MoveResult.FAIL, targets: [ pokemon.getBattlerIndex() ]});
   });
 
   describe("restores stat stage boosts granted by stacks", () => {
@@ -155,7 +155,7 @@ describe("Moves - Swallow", () => {
 
       await game.phaseInterceptor.to(TurnInitPhase);
 
-      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SWALLOW, result: MoveResult.SUCCESS });
+      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SWALLOW, result: MoveResult.SUCCESS, targets: [ pokemon.getBattlerIndex() ]});
 
       expect(pokemon.getStatStage(Stat.DEF)).toBe(0);
       expect(pokemon.getStatStage(Stat.SPDEF)).toBe(0);
@@ -182,7 +182,7 @@ describe("Moves - Swallow", () => {
 
       await game.phaseInterceptor.to(TurnInitPhase);
 
-      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SWALLOW, result: MoveResult.SUCCESS });
+      expect(pokemon.getMoveHistory().at(-1)).toMatchObject<TurnMove>({ move: Moves.SWALLOW, result: MoveResult.SUCCESS, targets: [ pokemon.getBattlerIndex() ]});
 
       expect(pokemon.getStatStage(Stat.DEF)).toBe(1);
       expect(pokemon.getStatStage(Stat.SPDEF)).toBe(-2);