beginnings of implementation of mirror armor

src/battle.ts

@@ -81,6 +81,9 @@ export default class Battle {
   public battleSeed: string = Utils.randomString(16, true);
   private battleSeedState: string | null = null;
   public moneyScattered: number = 0;
+  /** Primarily for double battles, keeps track of last enemy and player pokemon that triggered its ability or used a move */
+  public lastEnemyInvolved: number;
+  public lastPlayerInvolved: number;
   public lastUsedPokeball: PokeballType | null = null;
   /** The number of times a Pokemon on the player's side has fainted this battle */
   public playerFaints: number = 0;

src/data/ability.ts

@@ -2704,6 +2704,50 @@ export class PreStatStageChangeAbAttr extends AbAttr {
   }
 }
 
+/**
+ * Reflect one or all {@linkcode BattleStat} reductions caused by other Pokémon's moves and Abilities.
+ * Currently only applies to Mirror Armor
+ */
+// TODO: CODE INTERACTION WITH MAGIC BOUNCE AS WELL
+// TODO: CODE INTERACTION WITH STICKY WEB
+// TODO: PREVENT REFLECTION FROM OPPONENT MIRROR ARMOR FOR INFINITE LOOP
+export class ReflectStatStageChangeAbAttr extends PreStatStageChangeAbAttr {
+  /** {@linkcode BattleStat} to reflect */
+  private reflectedStat? : BattleStat;
+  constructor() {
+    super();
+  }
+
+  /**
+   * Apply the {@linkcode ReflectStatStageChangeAbAttr} to an interaction
+   * @param _pokemon The user pokemon
+   * @param _passive
+   * @param _simulated
+   * @param stat the {@linkcode BattleStat} being affected
+   * @param cancelled The {@linkcode Utils.BooleanHolder} that will be set to true due to reflection
+   * @param _args
+   * @returns true because it reflects any stat being lowered
+   */
+  applyPreStatStageChange(_pokemon: Pokemon, _passive: boolean, _simulated: boolean, stat: BattleStat, cancelled: Utils.BooleanHolder, _args: any[]): boolean {
+    const attacker: Pokemon = _args[0];
+    const stages = _args[1];
+    this.reflectedStat = stat;
+    if (!_simulated) {
+      attacker.scene.unshiftPhase(new StatStageChangePhase(attacker.scene, attacker.getBattlerIndex(), false, [ stat ], stages));
+    }
+    cancelled.value = true;
+    return true;
+  }
+
+  getTriggerMessage(pokemon: Pokemon, abilityName: string, ..._args: any[]): string {
+    return i18next.t("abilityTriggers:protectStat", {
+      pokemonNameWithAffix: getPokemonNameWithAffix(pokemon),
+      abilityName,
+      statName: this.reflectedStat ? i18next.t(getStatKey(this.reflectedStat)) : i18next.t("battle:stats")
+    });
+  }
+}
+
 /**
  * Protect one or all {@linkcode BattleStat} from reductions caused by other Pokémon's moves and Abilities
  */
@@ -5712,8 +5756,8 @@ export function initAbilities() {
     new Ability(Abilities.PROPELLER_TAIL, 8)
       .attr(BlockRedirectAbAttr),
     new Ability(Abilities.MIRROR_ARMOR, 8)
-      .ignorable()
+      .attr(ReflectStatStageChangeAbAttr)
-      .unimplemented(),
+      .ignorable(),
     /**
      * Right now, the logic is attached to Surf and Dive moves. Ideally, the post-defend/hit should be an
      * ability attribute but the current implementation of move effects for BattlerTag does not support this- in the case

src/phases/move-effect-phase.ts

@@ -43,6 +43,13 @@ export class MoveEffectPhase extends PokemonPhase {
     /** All Pokemon targeted by this phase's invoked move */
     const targets = this.getTargets();
 
+    /** If an enemy used this move, set this as last enemy that used move or ability */
+    if (!user?.isPlayer()) {
+      this.scene.currentBattle.lastEnemyInvolved = this.fieldIndex;
+    } else {
+      this.scene.currentBattle.lastPlayerInvolved = this.fieldIndex;
+    }
+
     /** If the user was somehow removed from the field, end this phase */
     if (!user?.isOnField()) {
       return super.end();

src/phases/show-ability-phase.ts

@@ -20,6 +20,14 @@ export class ShowAbilityPhase extends PokemonPhase {
       this.scene.abilityBar.showAbility(pokemon, this.passive);
 
       if (pokemon?.battleData) {
+
+        if (!pokemon.isPlayer()) {
+          /** If its an enemy pokemon, list it as last enemy to use ability or move */
+          this.scene.currentBattle.lastEnemyInvolved = this.fieldIndex;
+        } else {
+          this.scene.currentBattle.lastPlayerInvolved = this.fieldIndex;
+        }
+
         pokemon.battleData.abilityRevealed = true;
       }
     }

src/phases/stat-stage-change-phase.ts

@@ -1,6 +1,6 @@
 import { BattlerIndex } from "#app/battle";
 import BattleScene from "#app/battle-scene";
-import { applyAbAttrs, applyPostStatStageChangeAbAttrs, applyPreStatStageChangeAbAttrs, PostStatStageChangeAbAttr, ProtectStatAbAttr, StatStageChangeCopyAbAttr, StatStageChangeMultiplierAbAttr } from "#app/data/ability";
+import { applyAbAttrs, applyPostStatStageChangeAbAttrs, applyPreStatStageChangeAbAttrs, PostStatStageChangeAbAttr, ProtectStatAbAttr, ReflectStatStageChangeAbAttr, StatStageChangeCopyAbAttr, StatStageChangeMultiplierAbAttr } from "#app/data/ability";
 import { ArenaTagSide, MistTag } from "#app/data/arena-tag";
 import Pokemon from "#app/field/pokemon";
 import { getPokemonNameWithAffix } from "#app/messages";
@@ -10,6 +10,7 @@ import { NumberHolder, BooleanHolder } from "#app/utils";
 import i18next from "i18next";
 import { PokemonPhase } from "./pokemon-phase";
 import { Stat, type BattleStat, getStatKey, getStatStageChangeDescriptionKey } from "#enums/stat";
+import { OctolockTag } from "#app/data/battler-tags";
 
 export type StatStageChangeCallback = (target: Pokemon | null, changed: BattleStat[], relativeChanges: number[]) => void;
 
@@ -47,6 +48,29 @@ export class StatStageChangePhase extends PokemonPhase {
     }
 
     const pokemon = this.getPokemon();
+    let opponentPokemon: Pokemon | undefined;
+
+    /** StickY web should be like
+     * if (stat loss due to switching in on sticky web)
+     *    if (have mirror armor)
+     *      if (enemy that used sticky web is in)
+     *        apply -1 spd to that enemy
+     */
+
+    // Gets the position of last enemy or player pokemon that used ability or move, primarily for double battles involving Mirror Armor
+    if (pokemon.isPlayer()) {
+      if (this.scene.currentBattle.double && this.scene.getEnemyField().length === 2) {
+        opponentPokemon = this.scene.getEnemyField()[this.scene.currentBattle.lastEnemyInvolved];
+      } else {
+        opponentPokemon = this.scene.getEnemyPokemon();
+      }
+    } else {
+      if (this.scene.currentBattle.double && this.scene.getPlayerField().length === 2) {
+        opponentPokemon = this.scene.getPlayerField()[this.scene.currentBattle.lastPlayerInvolved];
+      } else {
+        opponentPokemon = this.scene.getPlayerPokemon();
+      }
+    }
 
     if (!pokemon.isActive(true)) {
       return this.end();
@@ -70,6 +94,16 @@ export class StatStageChangePhase extends PokemonPhase {
 
       if (!cancelled.value && !this.selfTarget && stages.value < 0) {
         applyPreStatStageChangeAbAttrs(ProtectStatAbAttr, pokemon, stat, cancelled, simulate);
+
+
+        // TODO: CODE INTERACTION WITH MAGIC BOUNCE AS WELL
+        // TODO: CODE INTERACTION WITH STICKY WEB
+        // TODO: PREVENT REFLECTION FROM OPPONENT MIRROR ARMOR FOR INFINITE LOOP
+        // TODO: FIX INTERACTION WITH MEMENTO, SHOULD LOWER OPPONENT STATS THEN DIE
+        /** Potential stat reflection due to Mirror Armor, does not apply to Octolock end of turn effect */
+        if (opponentPokemon !== undefined && !pokemon.findTag(t => t instanceof OctolockTag)) {
+          applyPreStatStageChangeAbAttrs(ReflectStatStageChangeAbAttr, pokemon, stat, cancelled, simulate, opponentPokemon, this.stages);
+        }
       }
 
       // If one stat stage decrease is cancelled, simulate the rest of the applications

src/test/abilities/mirror_armor.test.ts

@@ -0,0 +1,272 @@
+//test memnto as well and double battles and multiple stats and octolock
+import { Stat } from "#enums/stat";
+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";
+import { BattlerIndex } from "#app/battle";
+
+describe("Ability - Mirror Armor", () => {
+  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.battleType("single")
+      .enemySpecies(Species.RATTATA)
+      .enemyMoveset([ Moves.SPLASH, Moves.MEMENTO, Moves.TICKLE, Moves.OCTOLOCK ])
+      .enemyAbility(Abilities.BALL_FETCH)
+      .startingLevel(2000)
+      .moveset([ Moves.SPLASH, Moves.MEMENTO, Moves.TICKLE, Moves.OCTOLOCK ])
+      .ability(Abilities.BALL_FETCH);
+  });
+
+  it("Player side + single battle Intimidate - opponent loses stats", async () => {
+    game.override.ability(Abilities.MIRROR_ARMOR);
+    game.override.enemyAbility(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy has intimidate, enemy should lose -1 atk
+    game.move.select(Moves.SPLASH);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-1);
+    expect(userPokemon.getStatStage(Stat.ATK)).toBe(0);
+  });
+
+  it("Enemy side + single battle Intimidate - player loses stats", async () => {
+    game.override.enemyAbility(Abilities.MIRROR_ARMOR);
+    game.override.ability(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy has intimidate, enemy should lose -1 atk
+    game.move.select(Moves.SPLASH);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(userPokemon.getStatStage(Stat.ATK)).toBe(-1);
+    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(0);
+  });
+
+  it("Player side + double battle Intimidate - opponents each lose -2 atk", async () => {
+    game.override.battleType("double");
+    game.override.ability(Abilities.MIRROR_ARMOR);
+    game.override.enemyAbility(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR, Species.CHARMANDER ]);
+
+    const [ enemy1, enemy2 ] = game.scene.getEnemyField();
+    const [ player1, player2 ] = game.scene.getPlayerField();
+
+    // Enemy has intimidate, enemy should lose -2 atk each
+    game.move.select(Moves.SPLASH);
+    game.move.select(Moves.SPLASH, 1);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER_2);
+    await game.toNextTurn();
+
+    expect(enemy1.getStatStage(Stat.ATK)).toBe(-2);
+    expect(enemy2.getStatStage(Stat.ATK)).toBe(-2);
+    expect(player1.getStatStage(Stat.ATK)).toBe(0);
+    expect(player2.getStatStage(Stat.ATK)).toBe(0);
+  });
+
+  it("Enemy side + double battle Intimidate - players each lose -2 atk", async () => {
+    game.override.battleType("double");
+    game.override.enemyAbility(Abilities.MIRROR_ARMOR);
+    game.override.ability(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR, Species.CHARMANDER ]);
+
+    const [ enemy1, enemy2 ] = game.scene.getEnemyField();
+    const [ player1, player2 ] = game.scene.getPlayerField();
+
+    // Enemy has intimidate, enemy should lose -1 atk
+    game.move.select(Moves.SPLASH);
+    game.move.select(Moves.SPLASH, 1);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER_2);
+    await game.toNextTurn();
+
+    expect(enemy1.getStatStage(Stat.ATK)).toBe(0);
+    expect(enemy2.getStatStage(Stat.ATK)).toBe(0);
+    expect(player1.getStatStage(Stat.ATK)).toBe(-2);
+    expect(player2.getStatStage(Stat.ATK)).toBe(-2);
+  });
+
+  it("Player side + single battle Intimidate + Tickle - opponent loses stats", async () => {
+    game.override.ability(Abilities.MIRROR_ARMOR);
+    game.override.enemyAbility(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy has intimidate and uses tickle, enemy receives -2 atk and -1 defense
+    game.move.select(Moves.SPLASH);
+    await game.forceEnemyMove(Moves.TICKLE, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(enemyPokemon.getStatStage(Stat.DEF)).toBe(-1);
+    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(-2);
+    expect(userPokemon.getStatStage(Stat.ATK)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.DEF)).toBe(0);
+  });
+
+  it("Player side + double battle Intimidate + Tickle - opponents each lose -3 atk, -1 def", async () => {
+    game.override.battleType("double");
+    game.override.ability(Abilities.MIRROR_ARMOR);
+    game.override.enemyAbility(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR, Species.CHARMANDER ]);
+
+    const [ enemy1, enemy2 ] = game.scene.getEnemyField();
+    const [ player1, player2 ] = game.scene.getPlayerField();
+
+    game.move.select(Moves.SPLASH);
+    game.move.select(Moves.SPLASH, 1);
+    await game.forceEnemyMove(Moves.TICKLE, BattlerIndex.PLAYER);
+    await game.forceEnemyMove(Moves.TICKLE, BattlerIndex.PLAYER_2);
+    await game.toNextTurn();
+
+    expect(player1.getStatStage(Stat.ATK)).toBe(0);
+    expect(player1.getStatStage(Stat.DEF)).toBe(0);
+    expect(player2.getStatStage(Stat.ATK)).toBe(0);
+    expect(player2.getStatStage(Stat.DEF)).toBe(0);
+    expect(enemy1.getStatStage(Stat.ATK)).toBe(-3);
+    expect(enemy1.getStatStage(Stat.DEF)).toBe(-1);
+    expect(enemy2.getStatStage(Stat.ATK)).toBe(-3);
+    expect(enemy2.getStatStage(Stat.DEF)).toBe(-1);
+
+  });
+
+  it("Enemy side + single battle Intimidate + Tickle - player loses stats", async () => {
+    game.override.enemyAbility(Abilities.MIRROR_ARMOR);
+    game.override.ability(Abilities.INTIMIDATE);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy has intimidate and uses tickle, enemy receives -2 atk and -1 defense
+    game.move.select(Moves.TICKLE);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(userPokemon.getStatStage(Stat.DEF)).toBe(-1);
+    expect(userPokemon.getStatStage(Stat.ATK)).toBe(-2);
+    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(0);
+    expect(enemyPokemon.getStatStage(Stat.DEF)).toBe(0);
+  });
+
+  it("Player side + single battle Intimidate + oppoenent has white smoke - no one loses stats", async () => {
+    game.override.enemyAbility(Abilities.WHITE_SMOKE);
+    game.override.ability(Abilities.MIRROR_ARMOR);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy has intimidate and uses tickle, enemy has white smoke, no one loses stats
+    game.move.select(Moves.SPLASH);
+    await game.forceEnemyMove(Moves.TICKLE, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(enemyPokemon.getStatStage(Stat.DEF)).toBe(0);
+    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.ATK)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.DEF)).toBe(0);
+  });
+
+  it("Enemy side + single battle Intimidate + player has white smoke - no one loses stats", async () => {
+    game.override.ability(Abilities.WHITE_SMOKE);
+    game.override.enemyAbility(Abilities.MIRROR_ARMOR);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy has intimidate and uses tickle, enemy has white smoke, no one loses stats
+    game.move.select(Moves.TICKLE);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(enemyPokemon.getStatStage(Stat.DEF)).toBe(0);
+    expect(enemyPokemon.getStatStage(Stat.ATK)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.ATK)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.DEF)).toBe(0);
+  });
+
+  it("Player side + single battle + opponent uses octolock - does not interact with mirror armor, player loses stats", async () => {
+    game.override.ability(Abilities.MIRROR_ARMOR);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Enemy uses octolock, player loses stats at end of turn
+    game.move.select(Moves.SPLASH);
+    await game.forceEnemyMove(Moves.OCTOLOCK, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(enemyPokemon.getStatStage(Stat.DEF)).toBe(0);
+    expect(enemyPokemon.getStatStage(Stat.SPDEF)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.DEF)).toBe(-1);
+    expect(userPokemon.getStatStage(Stat.SPDEF)).toBe(-1);
+  });
+
+  it("Enemy side + single battle + player uses octolock - does not interact with mirror armor, opponent loses stats", async () => {
+    game.override.enemyAbility(Abilities.MIRROR_ARMOR);
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+    const userPokemon = game.scene.getPlayerPokemon()!;
+
+    // Player uses octolock, enemy loses stats at end of turn
+    game.move.select(Moves.OCTOLOCK);
+    await game.forceEnemyMove(Moves.SPLASH, BattlerIndex.PLAYER);
+    await game.toNextTurn();
+
+    expect(userPokemon.getStatStage(Stat.DEF)).toBe(0);
+    expect(userPokemon.getStatStage(Stat.SPDEF)).toBe(0);
+    expect(enemyPokemon.getStatStage(Stat.DEF)).toBe(-1);
+    expect(enemyPokemon.getStatStage(Stat.SPDEF)).toBe(-1);
+  });
+
+  //   it("traps the target pokemon", async () => {
+  //     await game.classicMode.startBattle([ Species.GRAPPLOCT ]);
+
+  //     const enemyPokemon = game.scene.getEnemyPokemon()!;
+
+  //     // before Octolock - enemy should not be trapped
+  //     expect(enemyPokemon.findTag(t => t instanceof TrappedTag)).toBeUndefined();
+
+  //     game.move.select(Moves.OCTOLOCK);
+
+  //     // after Octolock - enemy should be trapped
+  //     await game.phaseInterceptor.to(MoveEndPhase);
+  //     expect(enemyPokemon.findTag(t => t instanceof TrappedTag)).toBeDefined();
+  //   });
+
+//TODO: Implement test for sticky web
+// TODO: IMPLEMENT TEST FOR MEMENTO
+// TODO: IMPLEMENT TEST FOR LOOPING MIRROR ARMORS BETWEEN OPPONENT AND PLAYER
+// TODO: IMPLEMENT MAGIC GUARD INTERACITON TEST
+});