Merge d6c9209c42 into 1ff2701964

fix: wrap setOverlayMode args in array to mystery-encounter

Co-authored-by: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com>

src/data/moves/move.ts

@@ -93,6 +93,10 @@ import { ChargingMove, MoveAttrMap, MoveAttrString, MoveKindString, MoveClassMap
 import { applyMoveAttrs } from "./apply-attrs";
 import { frenzyMissFunc, getMoveTargets } from "./move-utils";
 
+/**
+ * A function used to conditionally determine execution of a given {@linkcode MoveAttr}.
+ * Conventionally returns `true` for success and `false` for failure.
+*/
 type MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => boolean;
 export type UserMoveConditionFunc = (user: Pokemon, move: Move) => boolean;
 
@@ -1390,18 +1394,31 @@ export class BeakBlastHeaderAttr extends AddBattlerTagHeaderAttr {
   }
 }
 
+/**
+ * Attribute to display a message before a move is executed.
+ */
 export class PreMoveMessageAttr extends MoveAttr {
-  private message: string | ((user: Pokemon, target: Pokemon, move: Move) => string);
+  /** The message to display or a function returning one */
+  private message: string | ((user: Pokemon, target: Pokemon, move: Move) => string | undefined);
 
+  /**
+   * Create a new {@linkcode PreMoveMessageAttr} to display a message before move execution.
+   * @param message - The message to display before move use, either as a string or a function producing one.
+   * @remarks
+   * If {@linkcode message} evaluates to an empty string (`''`), no message will be displayed
+   * (though the move will still succeed).
+   */
   constructor(message: string | ((user: Pokemon, target: Pokemon, move: Move) => string)) {
     super();
     this.message = message;
   }
 
-  apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
+  apply(user: Pokemon, target: Pokemon, move: Move, _args: any[]): boolean {
-    const message = typeof this.message === "string"
+    const message = typeof this.message === "function"
-      ? this.message as string
+      ? this.message(user, target, move)
-      : this.message(user, target, move);
+      : this.message;
+
+    // TODO: Consider changing if/when MoveAttr `apply` return values become significant
     if (message) {
       globalScene.phaseManager.queueMessage(message, 500);
       return true;
@@ -4073,30 +4090,6 @@ export class OpponentHighHpPowerAttr extends VariablePowerAttr {
   }
 }
 
-/**
- * Attribute to double this move's power if the target hasn't acted yet in the current turn.
- * Used by {@linkcode Moves.BOLT_BEAK} and {@linkcode Moves.FISHIOUS_REND}
- */
-export class FirstAttackDoublePowerAttr extends VariablePowerAttr {
-  /**
-   * Double this move's power if the user is acting before the target.
-   * @param user - Unused
-   * @param target - The {@linkcode Pokemon} being targeted by this move
-   * @param move - Unused
-   * @param args `[0]` - A {@linkcode NumberHolder} containing move base power
-   * @returns Whether the attribute was successfully applied
-   */
-  apply(_user: Pokemon, target: Pokemon, move: Move, args: [NumberHolder]): boolean {
-    if (target.turnData.acted) {
-      return false;
-    }
-
-    args[0].value *= 2;
-    return true;
-  }
-}
-
-
 export class TurnDamagedDoublePowerAttr extends VariablePowerAttr {
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
     if (user.turnData.attacksReceived.find(r => r.damage && r.sourceId === target.id)) {
@@ -8276,7 +8269,6 @@ const MoveAttrs = Object.freeze({
   CompareWeightPowerAttr,
   HpPowerAttr,
   OpponentHighHpPowerAttr,
-  FirstAttackDoublePowerAttr,
   TurnDamagedDoublePowerAttr,
   MagnitudePowerAttr,
   AntiSunlightPowerDecreaseAttr,
@@ -9579,7 +9571,8 @@ export function initMoves() {
     new AttackMove(MoveId.CLOSE_COMBAT, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 120, 100, 5, -1, 0, 4)
       .attr(StatStageChangeAttr, [ Stat.DEF, Stat.SPDEF ], -1, true),
     new AttackMove(MoveId.PAYBACK, PokemonType.DARK, MoveCategory.PHYSICAL, 50, 100, 10, -1, 0, 4)
-      .attr(MovePowerMultiplierAttr, (user, target, move) => target.getLastXMoves(1).find(m => m.turn === globalScene.currentBattle.turn) || globalScene.currentBattle.turnCommands[target.getBattlerIndex()]?.command === Command.BALL ? 2 : 1),
+      // Payback boosts power on enemy item use
+      .attr(MovePowerMultiplierAttr, (_user, target) => target.turnData.acted || globalScene.currentBattle.turnCommands[target.getBattlerIndex()]?.command === Command.BALL ? 2 : 1),
     new AttackMove(MoveId.ASSURANCE, PokemonType.DARK, MoveCategory.PHYSICAL, 60, 100, 10, -1, 0, 4)
       .attr(MovePowerMultiplierAttr, (user, target, move) => target.turnData.damageTaken > 0 ? 2 : 1),
     new StatusMove(MoveId.EMBARGO, PokemonType.DARK, 100, 15, -1, 0, 4)
@@ -10791,9 +10784,9 @@ export function initMoves() {
       .condition(failIfGhostTypeCondition)
       .attr(AddBattlerTagAttr, BattlerTagType.OCTOLOCK, false, true, 1),
     new AttackMove(MoveId.BOLT_BEAK, PokemonType.ELECTRIC, MoveCategory.PHYSICAL, 85, 100, 10, -1, 0, 8)
-      .attr(FirstAttackDoublePowerAttr),
+      .attr(MovePowerMultiplierAttr, (_user, target) => target.turnData.acted ? 1 : 2),
     new AttackMove(MoveId.FISHIOUS_REND, PokemonType.WATER, MoveCategory.PHYSICAL, 85, 100, 10, -1, 0, 8)
-      .attr(FirstAttackDoublePowerAttr)
+      .attr(MovePowerMultiplierAttr, (_user, target) => target.turnData.acted ? 1 : 2)
       .bitingMove(),
     new StatusMove(MoveId.COURT_CHANGE, PokemonType.NORMAL, 100, 10, -1, 0, 8)
       .attr(SwapArenaTagsAttr, [ ArenaTagType.AURORA_VEIL, ArenaTagType.LIGHT_SCREEN, ArenaTagType.MIST, ArenaTagType.REFLECT, ArenaTagType.SPIKES, ArenaTagType.STEALTH_ROCK, ArenaTagType.STICKY_WEB, ArenaTagType.TAILWIND, ArenaTagType.TOXIC_SPIKES ]),
@@ -11299,7 +11292,11 @@ export function initMoves() {
       .attr(ForceSwitchOutAttr, true, SwitchType.SHED_TAIL)
       .condition(failIfLastInPartyCondition),
     new SelfStatusMove(MoveId.CHILLY_RECEPTION, PokemonType.ICE, -1, 10, -1, 0, 9)
-      .attr(PreMoveMessageAttr, (user, move) => i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(user) }))
+      .attr(PreMoveMessageAttr, (user, _target, _move) =>
+        // Don't display text if current move phase is follow up (ie move called indirectly)
+        isVirtual((globalScene.phaseManager.getCurrentPhase() as MovePhase).useMode)
+          ? ""
+          : i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(user) }))
       .attr(ChillyReceptionAttr, true),
     new SelfStatusMove(MoveId.TIDY_UP, PokemonType.NORMAL, -1, 10, -1, 0, 9)
       .attr(StatStageChangeAttr, [ Stat.ATK, Stat.SPD ], 1, true)

src/data/mystery-encounters/utils/encounter-pokemon-utils.ts

@@ -751,7 +751,7 @@ export async function catchPokemon(
                       UiMode.POKEDEX_PAGE,
                       pokemon.species,
                       pokemon.formIndex,
-                      attributes,
+                      [attributes],
                       null,
                       () => {
                         globalScene.ui.setMode(UiMode.MESSAGE).then(() => {

src/data/pokemon-species.ts

@@ -764,7 +764,7 @@ export default class PokemonSpecies extends PokemonSpeciesForm implements Locali
   readonly subLegendary: boolean;
   readonly legendary: boolean;
   readonly mythical: boolean;
-  readonly species: string;
+  public category: string;
   readonly growthRate: GrowthRate;
   /** The chance (as a decimal) for this Species to be male, or `null` for genderless species */
   readonly malePercent: number | null;
@@ -778,7 +778,7 @@ export default class PokemonSpecies extends PokemonSpeciesForm implements Locali
     subLegendary: boolean,
     legendary: boolean,
     mythical: boolean,
-    species: string,
+    category: string,
     type1: PokemonType,
     type2: PokemonType | null,
     height: number,
@@ -829,7 +829,7 @@ export default class PokemonSpecies extends PokemonSpeciesForm implements Locali
     this.subLegendary = subLegendary;
     this.legendary = legendary;
     this.mythical = mythical;
-    this.species = species;
+    this.category = category;
     this.growthRate = growthRate;
     this.malePercent = malePercent;
     this.genderDiffs = genderDiffs;
@@ -968,6 +968,7 @@ export default class PokemonSpecies extends PokemonSpeciesForm implements Locali
 
   localize(): void {
     this.name = i18next.t(`pokemon:${SpeciesId[this.speciesId].toLowerCase()}`);
+    this.category = i18next.t(`pokemonCategory:${SpeciesId[this.speciesId].toLowerCase()}_category`);
   }
 
   getWildSpeciesForLevel(level: number, allowEvolving: boolean, isBoss: boolean, gameMode: GameMode): SpeciesId {

src/phases/move-phase.ts

@@ -668,6 +668,9 @@ export class MovePhase extends BattlePhase {
       }),
       500,
     );
+
+    // Moves with pre-use messages (Magnitude, Chilly Reception, Fickle Beam, etc.) always display their messages even on failure
+    // TODO: This assumes single target for message funcs - is this sustainable?
     applyMoveAttrs("PreMoveMessageAttr", this.pokemon, this.pokemon.getOpponents(false)[0], this.move.getMove());
   }
 

src/plugins/i18n.ts

@@ -245,6 +245,7 @@ export async function initI18n(): Promise<void> {
       "pokeball",
       "pokedexUiHandler",
       "pokemon",
+      "pokemonCategory",
       "pokemonEvolutions",
       "pokemonForm",
       "pokemonInfo",

src/ui/pokedex-page-ui-handler.ts

@@ -174,6 +174,7 @@ export default class PokedexPageUiHandler extends MessageUiHandler {
   private pokemonCaughtHatchedContainer: Phaser.GameObjects.Container;
   private pokemonCaughtCountText: Phaser.GameObjects.Text;
   private pokemonFormText: Phaser.GameObjects.Text;
+  private pokemonCategoryText: Phaser.GameObjects.Text;
   private pokemonHatchedIcon: Phaser.GameObjects.Sprite;
   private pokemonHatchedCountText: Phaser.GameObjects.Text;
   private pokemonShinyIcons: Phaser.GameObjects.Sprite[];
@@ -409,6 +410,12 @@ export default class PokedexPageUiHandler extends MessageUiHandler {
     this.pokemonFormText.setOrigin(0, 0);
     this.starterSelectContainer.add(this.pokemonFormText);
 
+    this.pokemonCategoryText = addTextObject(100, 18, "Category", TextStyle.WINDOW_ALT, {
+      fontSize: "42px",
+    });
+    this.pokemonCategoryText.setOrigin(1, 0);
+    this.starterSelectContainer.add(this.pokemonCategoryText);
+
     this.pokemonCaughtHatchedContainer = globalScene.add.container(2, 25);
     this.pokemonCaughtHatchedContainer.setScale(0.5);
     this.starterSelectContainer.add(this.pokemonCaughtHatchedContainer);
@@ -2354,6 +2361,7 @@ export default class PokedexPageUiHandler extends MessageUiHandler {
         this.pokemonCaughtHatchedContainer.setVisible(true);
         this.pokemonCandyContainer.setVisible(false);
         this.pokemonFormText.setVisible(false);
+        this.pokemonCategoryText.setVisible(false);
 
         const defaultDexAttr = globalScene.gameData.getSpeciesDefaultDexAttr(species, true, true);
         const props = globalScene.gameData.getSpeciesDexAttrProps(species, defaultDexAttr);
@@ -2382,6 +2390,7 @@ export default class PokedexPageUiHandler extends MessageUiHandler {
       this.pokemonCaughtHatchedContainer.setVisible(false);
       this.pokemonCandyContainer.setVisible(false);
       this.pokemonFormText.setVisible(false);
+      this.pokemonCategoryText.setVisible(false);
 
       this.setSpeciesDetails(species!, {
         // TODO: is this bang correct?
@@ -2534,6 +2543,13 @@ export default class PokedexPageUiHandler extends MessageUiHandler {
         this.pokemonNameText.setText(species ? "???" : "");
       }
 
+      // Setting the category
+      if (isFormCaught) {
+        this.pokemonCategoryText.setText(species.category);
+      } else {
+        this.pokemonCategoryText.setText("");
+      }
+
       // Setting tint of the sprite
       if (isFormCaught) {
         this.species.loadAssets(female!, formIndex, shiny, variant as Variant, true).then(() => {

test/abilities/guard-dog.test.ts

@@ -0,0 +1,39 @@
+import { AbilityId } from "#enums/ability-id";
+import { SpeciesId } from "#enums/species-id";
+import { Stat } from "#enums/stat";
+import GameManager from "#test/testUtils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Ability - Guard Dog", () => {
+  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.GUARD_DOG)
+      .battleStyle("single")
+      .enemySpecies(SpeciesId.MAGIKARP)
+      .enemyAbility(AbilityId.INTIMIDATE);
+  });
+
+  it("should raise attack by 1 stage when Intimidated instead of being lowered", async () => {
+    await game.classicMode.startBattle([SpeciesId.MABOSSTIFF]);
+
+    const mabostiff = game.field.getPlayerPokemon();
+    expect(mabostiff.getStatStage(Stat.ATK)).toBe(1);
+    expect(mabostiff.waveData.abilitiesApplied.has(AbilityId.GUARD_DOG)).toBe(true);
+    expect(game.phaseInterceptor.log.filter(l => l === "StatStageChangePhase")).toHaveLength(1);
+  });
+});

test/abilities/intimidate.test.ts

@@ -1,12 +1,11 @@
 import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 import Phaser from "phaser";
 import GameManager from "#test/testUtils/gameManager";
-import { UiMode } from "#enums/ui-mode";
 import { Stat } from "#enums/stat";
-import { getMovePosition } from "#test/testUtils/gameManagerUtils";
 import { AbilityId } from "#enums/ability-id";
 import { MoveId } from "#enums/move-id";
 import { SpeciesId } from "#enums/species-id";
+import { BattleType } from "#enums/battle-type";
 
 describe("Abilities - Intimidate", () => {
   let phaserGame: Phaser.Game;
@@ -28,106 +27,65 @@ describe("Abilities - Intimidate", () => {
       .battleStyle("single")
       .enemySpecies(SpeciesId.RATTATA)
       .enemyAbility(AbilityId.INTIMIDATE)
-      .enemyPassiveAbility(AbilityId.HYDRATION)
       .ability(AbilityId.INTIMIDATE)
-      .startingWave(3)
+      .moveset(MoveId.SPLASH)
       .enemyMoveset(MoveId.SPLASH);
   });
 
-  it("should lower ATK stat stage by 1 of enemy Pokemon on entry and player switch", async () => {
+  it("should lower all opponents' ATK by 1 stage on entry and switch", async () => {
-    await game.classicMode.runToSummon([SpeciesId.MIGHTYENA, SpeciesId.POOCHYENA]);
+    await game.classicMode.startBattle([SpeciesId.MIGHTYENA, SpeciesId.POOCHYENA]);
-    game.onNextPrompt(
-      "CheckSwitchPhase",
-      UiMode.CONFIRM,
-      () => {
-        game.setMode(UiMode.MESSAGE);
-        game.endPhase();
-      },
-      () => game.isCurrentPhase("CommandPhase") || game.isCurrentPhase("TurnInitPhase"),
-    );
-    await game.phaseInterceptor.to("CommandPhase", false);
 
-    let playerPokemon = game.scene.getPlayerPokemon()!;
+    const enemy = game.field.getEnemyPokemon();
-    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    expect(enemy.getStatStage(Stat.ATK)).toBe(-1);
-
-    expect(playerPokemon.species.speciesId).toBe(SpeciesId.MIGHTYENA);
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-1);
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(-1);
 
     game.doSwitchPokemon(1);
-    await game.phaseInterceptor.run("CommandPhase");
+    await game.toNextTurn();
-    await game.phaseInterceptor.to("CommandPhase");
 
-    playerPokemon = game.scene.getPlayerPokemon()!;
+    expect(enemy.getStatStage(Stat.ATK)).toBe(-2);
-    expect(playerPokemon.species.speciesId).toBe(SpeciesId.POOCHYENA);
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(0);
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-2);
   });
 
-  it("should lower ATK stat stage by 1 for every enemy Pokemon in a double battle on entry", async () => {
+  it("should lower ATK of all opponents in a double battle", async () => {
-    game.override.battleStyle("double").startingWave(3);
+    game.override.battleStyle("double");
-    await game.classicMode.runToSummon([SpeciesId.MIGHTYENA, SpeciesId.POOCHYENA]);
+    await game.classicMode.startBattle([SpeciesId.MIGHTYENA]);
-    game.onNextPrompt(
-      "CheckSwitchPhase",
-      UiMode.CONFIRM,
-      () => {
-        game.setMode(UiMode.MESSAGE);
-        game.endPhase();
-      },
-      () => game.isCurrentPhase("CommandPhase") || game.isCurrentPhase("TurnInitPhase"),
-    );
-    await game.phaseInterceptor.to("CommandPhase", false);
 
-    const playerField = game.scene.getPlayerField()!;
+    const [enemy1, enemy2] = game.scene.getEnemyField();
-    const enemyField = game.scene.getEnemyField()!;
 
-    expect(enemyField[0].getStatStage(Stat.ATK)).toBe(-2);
+    expect(enemy1.getStatStage(Stat.ATK)).toBe(-1);
-    expect(enemyField[1].getStatStage(Stat.ATK)).toBe(-2);
+    expect(enemy2.getStatStage(Stat.ATK)).toBe(-1);
-    expect(playerField[0].getStatStage(Stat.ATK)).toBe(-2);
-    expect(playerField[1].getStatStage(Stat.ATK)).toBe(-2);
   });
 
-  it("should not activate again if there is no switch or new entry", async () => {
+  it("should not trigger on switching moves used by wild Pokemon", async () => {
-    game.override.startingWave(2).moveset([MoveId.SPLASH]);
+    game.override.enemyMoveset(MoveId.VOLT_SWITCH).battleType(BattleType.WILD);
-    await game.classicMode.startBattle([SpeciesId.MIGHTYENA, SpeciesId.POOCHYENA]);
+    await game.classicMode.startBattle([SpeciesId.MIGHTYENA]);
 
-    const playerPokemon = game.scene.getPlayerPokemon()!;
+    const player = game.field.getPlayerPokemon();
-    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    expect(player.getStatStage(Stat.ATK)).toBe(-1);
-
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-1);
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(-1);
 
     game.move.select(MoveId.SPLASH);
     await game.toNextTurn();
 
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-1);
+    // doesn't lower attack due to not actually switching out
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(-1);
+    expect(player.getStatStage(Stat.ATK)).toBe(-1);
   });
 
-  it("should lower ATK stat stage by 1 for every switch", async () => {
+  it("should trigger on moves that switch user/target out during trainer battles", async () => {
-    game.override.moveset([MoveId.SPLASH]).enemyMoveset([MoveId.VOLT_SWITCH]).startingWave(5);
+    game.override.battleType(BattleType.TRAINER).passiveAbility(AbilityId.NO_GUARD);
-    await game.classicMode.startBattle([SpeciesId.MIGHTYENA, SpeciesId.POOCHYENA]);
 
-    const playerPokemon = game.scene.getPlayerPokemon()!;
+    await game.classicMode.startBattle([SpeciesId.MIGHTYENA]);
-    let enemyPokemon = game.scene.getEnemyPokemon()!;
 
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-1);
+    const player = game.field.getPlayerPokemon();
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(-1);
+    expect(player.getStatStage(Stat.ATK)).toBe(-1);
 
-    game.move.select(getMovePosition(game.scene, 0, MoveId.SPLASH));
+    game.move.use(MoveId.SPLASH);
+    await game.move.forceEnemyMove(MoveId.TELEPORT);
     await game.toNextTurn();
 
-    enemyPokemon = game.scene.getEnemyPokemon()!;
+    expect(player.getStatStage(Stat.ATK)).toBe(-2);
 
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(-2);
+    game.move.use(MoveId.DRAGON_TAIL);
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(0);
+    await game.move.forceEnemyMove(MoveId.SPLASH);
-
-    game.move.select(MoveId.SPLASH);
     await game.toNextTurn();
 
-    enemyPokemon = game.scene.getEnemyPokemon()!;
+    expect(player.getStatStage(Stat.ATK)).toBe(-3);
-
-    expect(playerPokemon.getStatStage(Stat.ATK)).toBe(-3);
-    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(0);
   });
 });

test/moves/ability-ignore-moves.test.ts

@@ -0,0 +1,109 @@
+import { BattlerIndex } from "#enums/battler-index";
+import { RandomMoveAttr } from "#app/data/moves/move";
+import { AbilityId } from "#enums/ability-id";
+import { MoveId } from "#enums/move-id";
+import { SpeciesId } from "#enums/species-id";
+import GameManager from "#test/testUtils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("Moves - Ability-Ignoring Moves", () => {
+  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([MoveId.MOONGEIST_BEAM, MoveId.SUNSTEEL_STRIKE, MoveId.PHOTON_GEYSER, MoveId.METRONOME])
+      .ability(AbilityId.BALL_FETCH)
+      .startingLevel(200)
+      .battleStyle("single")
+      .criticalHits(false)
+      .enemySpecies(SpeciesId.MAGIKARP)
+      .enemyAbility(AbilityId.STURDY)
+      .enemyMoveset(MoveId.SPLASH);
+  });
+
+  it.each<{ name: string; move: MoveId }>([
+    { name: "Sunsteel Strike", move: MoveId.SUNSTEEL_STRIKE },
+    { name: "Moongeist Beam", move: MoveId.MOONGEIST_BEAM },
+    { name: "Photon Geyser", move: MoveId.PHOTON_GEYSER },
+  ])("$name should ignore enemy abilities during move use", async ({ move }) => {
+    await game.classicMode.startBattle([SpeciesId.NECROZMA]);
+
+    const player = game.field.getPlayerPokemon();
+    const enemy = game.field.getEnemyPokemon();
+
+    game.move.select(move);
+    await game.phaseInterceptor.to("MoveEffectPhase");
+
+    expect(game.scene.arena.ignoreAbilities).toBe(true);
+    expect(game.scene.arena.ignoringEffectSource).toBe(player.getBattlerIndex());
+
+    await game.toEndOfTurn();
+    expect(game.scene.arena.ignoreAbilities).toBe(false);
+    expect(enemy.isFainted()).toBe(true);
+  });
+
+  it("should not ignore enemy abilities when called by metronome", async () => {
+    await game.classicMode.startBattle([SpeciesId.MILOTIC]);
+    vi.spyOn(RandomMoveAttr.prototype, "getMoveOverride").mockReturnValue(MoveId.PHOTON_GEYSER);
+
+    const enemy = game.field.getEnemyPokemon();
+    game.move.select(MoveId.METRONOME);
+    await game.toEndOfTurn();
+
+    expect(enemy.isFainted()).toBe(false);
+    expect(game.field.getPlayerPokemon().getLastXMoves()[0].move).toBe(MoveId.PHOTON_GEYSER);
+  });
+
+  it("should not ignore enemy abilities when called by Mirror Move", async () => {
+    game.override.moveset(MoveId.MIRROR_MOVE).enemyMoveset(MoveId.SUNSTEEL_STRIKE);
+
+    await game.classicMode.startBattle([SpeciesId.MILOTIC]);
+
+    const enemy = game.field.getEnemyPokemon();
+    game.move.select(MoveId.MIRROR_MOVE);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+    await game.toEndOfTurn();
+
+    expect(enemy.isFainted()).toBe(false);
+    expect(game.scene.getPlayerPokemon()?.getLastXMoves()[0].move).toBe(MoveId.SUNSTEEL_STRIKE);
+  });
+
+  // TODO: Verify this behavior on cart
+  it("should ignore enemy abilities when called by Instruct", async () => {
+    game.override.moveset([MoveId.SUNSTEEL_STRIKE, MoveId.INSTRUCT]).battleStyle("double");
+    await game.classicMode.startBattle([SpeciesId.SOLGALEO, SpeciesId.LUNALA]);
+
+    const solgaleo = game.field.getPlayerPokemon();
+
+    game.move.select(MoveId.SUNSTEEL_STRIKE, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
+    game.move.select(MoveId.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]);
+
+    await game.phaseInterceptor.to("MoveEffectPhase"); // initial attack
+    await game.phaseInterceptor.to("MoveEffectPhase"); // instruct
+    await game.phaseInterceptor.to("MoveEffectPhase"); // instructed move use
+
+    expect(game.scene.arena.ignoreAbilities).toBe(true);
+    expect(game.scene.arena.ignoringEffectSource).toBe(solgaleo.getBattlerIndex());
+
+    await game.toEndOfTurn();
+
+    // Both the initial and redirected instruct use ignored sturdy
+    const [enemy1, enemy2] = game.scene.getEnemyField();
+    expect(enemy1.isFainted()).toBe(true);
+    expect(enemy2.isFainted()).toBe(true);
+  });
+});

test/moves/chilly_reception.test.ts

@@ -1,11 +1,14 @@
-import { AbilityId } from "#enums/ability-id";
+import { RandomMoveAttr } from "#app/data/moves/move";
+import { MoveResult } from "#enums/move-result";
+import { getPokemonNameWithAffix } from "#app/messages";
 import { MoveId } from "#enums/move-id";
 import { SpeciesId } from "#enums/species-id";
+import { AbilityId } from "#app/enums/ability-id";
 import { WeatherType } from "#enums/weather-type";
 import GameManager from "#test/testUtils/gameManager";
+import i18next from "i18next";
 import Phaser from "phaser";
-//import { TurnInitPhase } from "#app/phases/turn-init-phase";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
 
 describe("Moves - Chilly Reception", () => {
   let phaserGame: Phaser.Game;
@@ -25,95 +28,121 @@ describe("Moves - Chilly Reception", () => {
     game = new GameManager(phaserGame);
     game.override
       .battleStyle("single")
-      .moveset([MoveId.CHILLY_RECEPTION, MoveId.SNOWSCAPE])
+      .moveset([MoveId.CHILLY_RECEPTION, MoveId.SNOWSCAPE, MoveId.SPLASH, MoveId.METRONOME])
       .enemyMoveset(MoveId.SPLASH)
       .enemyAbility(AbilityId.BALL_FETCH)
       .ability(AbilityId.BALL_FETCH);
   });
 
-  it("should still change the weather if user can't switch out", async () => {
+  it("should display message before use, switch the user out and change the weather to snow", async () => {
+    await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
+
+    const [slowking, meowth] = game.scene.getPlayerParty();
+
+    game.move.select(MoveId.CHILLY_RECEPTION);
+    game.doSelectPartyPokemon(1);
+    await game.toEndOfTurn();
+
+    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.scene.getPlayerPokemon()).toBe(meowth);
+    expect(slowking.isOnField()).toBe(false);
+    expect(game.phaseInterceptor.log).toContain("SwitchSummonPhase");
+    expect(game.textInterceptor.logs).toContain(
+      i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(slowking) }),
+    );
+  });
+
+  it("should still change weather if user can't switch out", async () => {
     await game.classicMode.startBattle([SpeciesId.SLOWKING]);
 
     game.move.select(MoveId.CHILLY_RECEPTION);
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.phaseInterceptor.log).not.toContain("SwitchSummonPhase");
+    expect(game.scene.getPlayerPokemon()?.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS);
   });
 
-  it("should switch out even if it's snowing", async () => {
+  it("should still switch out even if weather cannot be changed", async () => {
     await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
-    // first turn set up snow with snowscape, try chilly reception on second turn
+
+    expect(game.scene.arena.weather?.weatherType).not.toBe(WeatherType.SNOW);
+
+    const [slowking, meowth] = game.scene.getPlayerParty();
+
     game.move.select(MoveId.SNOWSCAPE);
-    await game.phaseInterceptor.to("BerryPhase", false);
+    await game.toNextTurn();
+
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
 
-    await game.phaseInterceptor.to("TurnInitPhase", false);
     game.move.select(MoveId.CHILLY_RECEPTION);
     game.doSelectPartyPokemon(1);
+    // TODO: Uncomment lines once wimp out PR fixes force switches to not reset summon data immediately
+    //  await game.phaseInterceptor.to("SwitchSummonPhase", false);
+    //  expect(slowking.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS);
+
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    expect(game.scene.getPlayerField()[0].species.speciesId).toBe(SpeciesId.MEOWTH);
+    expect(game.phaseInterceptor.log).toContain("SwitchSummonPhase");
+    expect(game.scene.getPlayerPokemon()).toBe(meowth);
+    expect(slowking.isOnField()).toBe(false);
   });
 
-  it("happy case - switch out and weather changes", async () => {
+  // Source: https://replay.pokemonshowdown.com/gen9ou-2367532550
+  it("should fail (while still displaying message) if neither weather change nor switch out succeeds", async () => {
+    await game.classicMode.startBattle([SpeciesId.SLOWKING]);
+
+    expect(game.scene.arena.weather?.weatherType).not.toBe(WeatherType.SNOW);
+
+    const slowking = game.scene.getPlayerPokemon()!;
+
+    game.move.select(MoveId.SNOWSCAPE);
+    await game.toNextTurn();
+
+    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+
+    game.move.select(MoveId.CHILLY_RECEPTION);
+    game.doSelectPartyPokemon(1);
+    await game.toEndOfTurn();
+
+    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.phaseInterceptor.log).not.toContain("SwitchSummonPhase");
+    expect(game.scene.getPlayerPokemon()).toBe(slowking);
+    expect(slowking.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+    expect(game.textInterceptor.logs).toContain(
+      i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(slowking) }),
+    );
+  });
+
+  it("should succeed without message if called indirectly", async () => {
+    vi.spyOn(RandomMoveAttr.prototype, "getMoveOverride").mockReturnValue(MoveId.CHILLY_RECEPTION);
     await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
 
-    game.move.select(MoveId.CHILLY_RECEPTION);
+    const [slowking, meowth] = game.scene.getPlayerParty();
-    game.doSelectPartyPokemon(1);
+
+    game.move.select(MoveId.METRONOME);
+    game.doSelectPartyPokemon(1);
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    expect(game.scene.getPlayerField()[0].species.speciesId).toBe(SpeciesId.MEOWTH);
+    expect(game.scene.getPlayerPokemon()).toBe(meowth);
+    expect(slowking.isOnField()).toBe(false);
+    expect(game.phaseInterceptor.log).toContain("SwitchSummonPhase");
+    expect(game.textInterceptor.logs).not.toContain(
+      i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(slowking) }),
+    );
   });
 
-  // enemy uses another move and weather doesn't change
+  // Bugcheck test for enemy AI bug
-  it("check case - enemy not selecting chilly reception doesn't change weather ", async () => {
+  it("check case - enemy not selecting chilly reception doesn't change weather", async () => {
-    game.override.battleStyle("single").enemyMoveset([MoveId.CHILLY_RECEPTION, MoveId.TACKLE]).moveset(MoveId.SPLASH);
+    game.override.enemyMoveset([MoveId.CHILLY_RECEPTION, MoveId.TACKLE]);
-
     await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
 
     game.move.select(MoveId.SPLASH);
     await game.move.selectEnemyMove(MoveId.TACKLE);
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
+    expect(game.scene.arena.weather?.weatherType).toBeUndefined();
-    expect(game.scene.arena.weather?.weatherType).toBe(undefined);
-  });
-
-  it("enemy trainer - expected behavior ", async () => {
-    game.override
-      .battleStyle("single")
-      .startingWave(8)
-      .enemyMoveset(MoveId.CHILLY_RECEPTION)
-      .enemySpecies(SpeciesId.MAGIKARP)
-      .moveset([MoveId.SPLASH, MoveId.THUNDERBOLT]);
-
-    await game.classicMode.startBattle([SpeciesId.JOLTEON]);
-    const RIVAL_MAGIKARP1 = game.scene.getEnemyPokemon()?.id;
-
-    game.move.select(MoveId.SPLASH);
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    expect(game.scene.getEnemyPokemon()?.id !== RIVAL_MAGIKARP1);
-
-    await game.phaseInterceptor.to("TurnInitPhase", false);
-    game.move.select(MoveId.SPLASH);
-
-    // second chilly reception should still switch out
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    await game.phaseInterceptor.to("TurnInitPhase", false);
-    expect(game.scene.getEnemyPokemon()?.id === RIVAL_MAGIKARP1);
-    game.move.select(MoveId.THUNDERBOLT);
-
-    // enemy chilly recep move should fail: it's snowing and no option to switch out
-    // no crashing
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    await game.phaseInterceptor.to("TurnInitPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    game.move.select(MoveId.SPLASH);
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
   });
 });

test/moves/first-attack-double-power.test.ts

@@ -0,0 +1,122 @@
+import { BattlerIndex } from "#enums/battler-index";
+import { allMoves } from "#app/data/data-lists";
+import { AbilityId } from "#enums/ability-id";
+import { BattleType } from "#enums/battle-type";
+import { MoveId } from "#enums/move-id";
+import { SpeciesId } from "#enums/species-id";
+import GameManager from "#test/testUtils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi, type MockInstance } from "vitest";
+import { MoveUseMode } from "#enums/move-use-mode";
+
+describe("Moves - Fishious Rend & Bolt Beak", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+  let powerSpy: MockInstance;
+
+  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")
+      .battleType(BattleType.TRAINER)
+      .criticalHits(false)
+      .enemyLevel(100)
+      .enemySpecies(SpeciesId.DRACOVISH)
+      .enemyAbility(AbilityId.BALL_FETCH)
+      .enemyMoveset(MoveId.SPLASH);
+
+    powerSpy = vi.spyOn(allMoves[MoveId.BOLT_BEAK], "calculateBattlePower");
+  });
+
+  it.each<{ name: string; move: MoveId }>([
+    { name: "Bolt Beak", move: MoveId.BOLT_BEAK },
+    { name: "Fishious Rend", move: MoveId.FISHIOUS_REND },
+  ])("$name should double power if the user moves before the target", async ({ move }) => {
+    powerSpy = vi.spyOn(allMoves[move], "calculateBattlePower");
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    // turn 1: enemy, then player (no boost)
+    game.move.use(move);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+    await game.toNextTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[move].power);
+
+    // turn 2: player, then enemy (boost)
+    game.move.use(move);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[move].power * 2);
+  });
+
+  it("should only consider the selected target in Double Battles", async () => {
+    game.override.battleStyle("double");
+    await game.classicMode.startBattle([SpeciesId.FEEBAS, SpeciesId.MILOTIC]);
+
+    // Use move after everyone but P1 and enemy 1 have already moved
+    game.move.use(MoveId.BOLT_BEAK, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
+    game.move.use(MoveId.SPLASH, BattlerIndex.PLAYER_2);
+    await game.setTurnOrder([BattlerIndex.PLAYER_2, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.BOLT_BEAK].power * 2);
+  });
+
+  it("should double power on the turn the target switches in", async () => {
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    game.move.select(MoveId.BOLT_BEAK);
+    game.forceEnemyToSwitch();
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.BOLT_BEAK].power * 2);
+  });
+
+  it("should double power on forced switch-induced sendouts", async () => {
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    game.move.select(MoveId.BOLT_BEAK);
+    await game.move.forceEnemyMove(MoveId.U_TURN);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.BOLT_BEAK].power * 2);
+  });
+
+  it.each<{ type: string; allyMove: MoveId }>([
+    { type: "a Dancer-induced", allyMove: MoveId.FIERY_DANCE },
+    { type: "an Instructed", allyMove: MoveId.INSTRUCT },
+  ])("should double power if $type move is used as the target's first action that turn", async ({ allyMove }) => {
+    game.override.battleStyle("double").enemyAbility(AbilityId.DANCER);
+    powerSpy = vi.spyOn(allMoves[MoveId.FISHIOUS_REND], "calculateBattlePower");
+    await game.classicMode.startBattle([SpeciesId.DRACOVISH, SpeciesId.ARCTOZOLT]);
+
+    // Simulate enemy having used splash last turn to allow Instruct to copy it
+    const enemy = game.field.getEnemyPokemon();
+    enemy.pushMoveHistory({
+      move: MoveId.SPLASH,
+      targets: [BattlerIndex.ENEMY],
+      turn: game.scene.currentBattle.turn - 1,
+      useMode: MoveUseMode.NORMAL,
+    });
+
+    game.move.use(MoveId.FISHIOUS_REND, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
+    game.move.use(allyMove, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
+    await game.setTurnOrder([BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2]);
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.FISHIOUS_REND].power);
+  });
+});

test/moves/moongeist_beam.test.ts

@@ -1,61 +0,0 @@
-import { allMoves } from "#app/data/data-lists";
-import { AbilityId } from "#enums/ability-id";
-import { MoveId } from "#enums/move-id";
-import { SpeciesId } from "#enums/species-id";
-import GameManager from "#test/testUtils/gameManager";
-import Phaser from "phaser";
-import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("Moves - Moongeist Beam", () => {
-  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([MoveId.MOONGEIST_BEAM, MoveId.METRONOME])
-      .ability(AbilityId.BALL_FETCH)
-      .startingLevel(200)
-      .battleStyle("single")
-      .criticalHits(false)
-      .enemySpecies(SpeciesId.MAGIKARP)
-      .enemyAbility(AbilityId.STURDY)
-      .enemyMoveset(MoveId.SPLASH);
-  });
-
-  // Also covers Photon Geyser and Sunsteel Strike
-  it("should ignore enemy abilities", async () => {
-    await game.classicMode.startBattle([SpeciesId.MILOTIC]);
-
-    const enemy = game.scene.getEnemyPokemon()!;
-
-    game.move.select(MoveId.MOONGEIST_BEAM);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(enemy.isFainted()).toBe(true);
-  });
-
-  // Also covers Photon Geyser and Sunsteel Strike
-  it("should not ignore enemy abilities when called by another move, such as metronome", async () => {
-    await game.classicMode.startBattle([SpeciesId.MILOTIC]);
-    vi.spyOn(allMoves[MoveId.METRONOME].getAttrs("RandomMoveAttr")[0], "getMoveOverride").mockReturnValue(
-      MoveId.MOONGEIST_BEAM,
-    );
-
-    game.move.select(MoveId.METRONOME);
-    await game.phaseInterceptor.to("BerryPhase");
-
-    expect(game.scene.getEnemyPokemon()!.isFainted()).toBe(false);
-    expect(game.scene.getPlayerPokemon()!.getLastXMoves()[0].move).toBe(MoveId.MOONGEIST_BEAM);
-  });
-});

test/moves/payback.test.ts

@@ -0,0 +1,68 @@
+import { allMoves, allSpecies } from "#app/data/data-lists";
+import { AbilityId } from "#enums/ability-id";
+import { BattlerIndex } from "#enums/battler-index";
+import { MoveId } from "#enums/move-id";
+import { SpeciesId } from "#enums/species-id";
+import GameManager from "#test/testUtils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi, type MockInstance } from "vitest";
+
+describe("Move - Payback", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+  let powerSpy: MockInstance;
+
+  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)
+      .enemyLevel(100)
+      .enemySpecies(SpeciesId.DRACOVISH)
+      .enemyAbility(AbilityId.BALL_FETCH)
+      .enemyMoveset(MoveId.SPLASH);
+
+    powerSpy = vi.spyOn(allMoves[MoveId.PAYBACK], "calculateBattlePower");
+  });
+
+  it("should double power if the user moves after the target", async () => {
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    // turn 1: enemy, then player (boost)
+    game.move.use(MoveId.PAYBACK);
+    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
+    await game.toNextTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.PAYBACK].power * 2);
+
+    // turn 2: player, then enemy (no boost)
+    game.move.use(MoveId.PAYBACK);
+    await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.PAYBACK].power);
+  });
+
+  it("should trigger for enemies on player failed ball catch", async () => {
+    // Make dracovish uncatchable so we don't flake out
+    vi.spyOn(allSpecies[SpeciesId.DRACOVISH], "catchRate", "get").mockReturnValue(0);
+    await game.classicMode.startBattle([SpeciesId.FEEBAS]);
+
+    game.doThrowPokeball(0);
+    await game.move.forceEnemyMove(MoveId.PAYBACK);
+    await game.toEndOfTurn();
+
+    expect(powerSpy).toHaveLastReturnedWith(allMoves[MoveId.PAYBACK].power * 2);
+  });
+});