[Balance] Rework Multi-Lens (#4831)

* Rework Multi-Lens

* Multi-Lens integration tests

* Apply suggestions from code review

Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>

* Fix obsolete tests related to Multi-Lens

* Fix flaky unburden tests

* maybe fix flaky ceaseless edge test?

* Fixed Multi-Lens apply comment

* Fix ceaseless edge test for real this time

* Update locales

* Another locale update

---------

Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>

public/locales

@@ -1 +1 @@
-Subproject commit d600913dbf1f8b47dae8dccbd8296df78f1c51b5
+Subproject commit 5775faa6b3184082df73f6cdb96b253ea7dae3fe

src/data/ability.ts

@@ -7,7 +7,7 @@ import { Weather } from "#app/data/weather";
 import { BattlerTag, BattlerTagLapseType, GroundedTag } from "./battler-tags";
 import { getNonVolatileStatusEffects, getStatusEffectDescriptor, getStatusEffectHealText } from "#app/data/status-effect";
 import { Gender } from "./gender";
-import Move, { AttackMove, MoveCategory, MoveFlags, MoveTarget, FlinchAttr, OneHitKOAttr, HitHealAttr, allMoves, StatusMove, SelfStatusMove, VariablePowerAttr, applyMoveAttrs, VariableMoveTypeAttr, RandomMovesetMoveAttr, RandomMoveAttr, NaturePowerAttr, CopyMoveAttr, MoveAttr, MultiHitAttr, SacrificialAttr, SacrificialAttrOnHit, NeutralDamageAgainstFlyingTypeMultiplierAttr, FixedDamageAttr } from "./move";
+import Move, { AttackMove, MoveCategory, MoveFlags, MoveTarget, FlinchAttr, OneHitKOAttr, HitHealAttr, allMoves, StatusMove, SelfStatusMove, VariablePowerAttr, applyMoveAttrs, VariableMoveTypeAttr, RandomMovesetMoveAttr, RandomMoveAttr, NaturePowerAttr, CopyMoveAttr, NeutralDamageAgainstFlyingTypeMultiplierAttr, FixedDamageAttr } from "./move";
 import { ArenaTagSide, ArenaTrapTag } from "./arena-tag";
 import { BerryModifier, HitHealModifier, PokemonHeldItemModifier } from "../modifier/modifier";
 import { TerrainType } from "./terrain";
@@ -1351,65 +1351,30 @@ export class AddSecondStrikeAbAttr extends PreAttackAbAttr {
     this.damageMultiplier = damageMultiplier;
   }
 
-  /**
-   * Determines whether this attribute can apply to a given move.
-   * @param {Move} move the move to which this attribute may apply
-   * @param numTargets the number of {@linkcode Pokemon} targeted by this move
-   * @returns true if the attribute can apply to the move, false otherwise
-   */
-  canApplyPreAttack(move: Move, numTargets: integer): boolean {
-    /**
-     * Parental Bond cannot apply to multi-hit moves, charging moves, or
-     * moves that cause the user to faint.
-     */
-    const exceptAttrs: Constructor<MoveAttr>[] = [
-      MultiHitAttr,
-      SacrificialAttr,
-      SacrificialAttrOnHit
-    ];
-
-    /** Parental Bond cannot apply to these specific moves */
-    const exceptMoves: Moves[] = [
-      Moves.FLING,
-      Moves.UPROAR,
-      Moves.ROLLOUT,
-      Moves.ICE_BALL,
-      Moves.ENDEAVOR
-    ];
-
-    /** Also check if this move is an Attack move and if it's only targeting one Pokemon */
-    return numTargets === 1
-      && !move.isChargingMove()
-      && !exceptAttrs.some(attr => move.hasAttr(attr))
-      && !exceptMoves.some(id => move.id === id)
-      && move.category !== MoveCategory.STATUS;
-  }
-
   /**
    * If conditions are met, this doubles the move's hit count (via args[1])
    * or multiplies the damage of secondary strikes (via args[2])
-   * @param {Pokemon} pokemon the Pokemon using the move
+   * @param pokemon the {@linkcode Pokemon} using the move
    * @param passive n/a
    * @param defender n/a
-   * @param {Move} move the move used by the ability source
+   * @param move the {@linkcode Move} used by the ability source
-   * @param args\[0\] the number of Pokemon this move is targeting
+   * @param args Additional arguments:
-   * @param {Utils.IntegerHolder} args\[1\] the number of strikes with this move
+   * - `[0]` the number of strikes this move currently has ({@linkcode Utils.NumberHolder})
-   * @param {Utils.NumberHolder} args\[2\] the damage multiplier for the current strike
+   * - `[1]` the damage multiplier for the current strike ({@linkcode Utils.NumberHolder})
    * @returns
    */
   applyPreAttack(pokemon: Pokemon, passive: boolean, simulated: boolean, defender: Pokemon, move: Move, args: any[]): boolean {
-    const numTargets = args[0] as integer;
+    const hitCount = args[0] as Utils.NumberHolder;
-    const hitCount = args[1] as Utils.IntegerHolder;
+    const multiplier = args[1] as Utils.NumberHolder;
-    const multiplier = args[2] as Utils.NumberHolder;
 
-    if (this.canApplyPreAttack(move, numTargets)) {
+    if (move.canBeMultiStrikeEnhanced(pokemon)) {
       this.showAbility = !!hitCount?.value;
-      if (!!hitCount?.value) {
+      if (hitCount?.value) {
-        hitCount.value *= 2;
+        hitCount.value += 1;
       }
 
-      if (!!multiplier?.value && pokemon.turnData.hitsLeft % 2 === 1 && pokemon.turnData.hitsLeft !== pokemon.turnData.hitCount) {
+      if (multiplier?.value && pokemon.turnData.hitsLeft === 1) {
-        multiplier.value *= this.damageMultiplier;
+        multiplier.value = this.damageMultiplier;
       }
       return true;
     }

src/data/move.ts

@@ -818,7 +818,7 @@ export default class Move implements Localizable {
 
     applyMoveAttrs(VariablePowerAttr, source, target, this, power);
 
-    source.scene.applyModifiers(PokemonMultiHitModifier, source.isPlayer(), source, new Utils.IntegerHolder(0), power);
+    source.scene.applyModifiers(PokemonMultiHitModifier, source.isPlayer(), source, this.id, null, power);
 
     if (!this.hasAttr(TypelessAttr)) {
       source.scene.arena.applyTags(WeakenMoveTypeTag, simulated, this.type, power);
@@ -840,6 +840,42 @@ export default class Move implements Localizable {
 
     return priority.value;
   }
+
+  /**
+   * Returns `true` if this move can be given additional strikes
+   * by enhancing effects.
+   * Currently used for {@link https://bulbapedia.bulbagarden.net/wiki/Parental_Bond_(Ability) | Parental Bond}
+   * and {@linkcode PokemonMultiHitModifier | Multi-Lens}.
+   */
+  canBeMultiStrikeEnhanced(user: Pokemon): boolean {
+    // Multi-strike enhancers...
+
+    // ...cannot enhance moves that hit multiple targets
+    const { targets, multiple } = getMoveTargets(user, this.id);
+    const isMultiTarget = multiple && targets.length > 1;
+
+    // ...cannot enhance multi-hit or sacrificial moves
+    const exceptAttrs: Constructor<MoveAttr>[] = [
+      MultiHitAttr,
+      SacrificialAttr,
+      SacrificialAttrOnHit
+    ];
+
+    // ...and cannot enhance these specific moves.
+    const exceptMoves: Moves[] = [
+      Moves.FLING,
+      Moves.UPROAR,
+      Moves.ROLLOUT,
+      Moves.ICE_BALL,
+      Moves.ENDEAVOR
+    ];
+
+    return !isMultiTarget
+      && !this.isChargingMove()
+      && !exceptAttrs.some(attr => this.hasAttr(attr))
+      && !exceptMoves.some(id => this.id === id)
+      && this.category !== MoveCategory.STATUS;
+  }
 }
 
 export class AttackMove extends Move {

src/field/pokemon.ts

@@ -2642,10 +2642,11 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     const numTargets = multiple ? targets.length : 1;
     const targetMultiplier = (numTargets > 1) ? 0.75 : 1;
 
-    /** 0.25x multiplier if this is an added strike from the attacker's Parental Bond */
+    /** Multiplier for moves enhanced by Multi-Lens and/or Parental Bond */
-    const parentalBondMultiplier = new Utils.NumberHolder(1);
+    const multiStrikeEnhancementMultiplier = new Utils.NumberHolder(1);
+    source.scene.applyModifiers(PokemonMultiHitModifier, source.isPlayer(), source, move.id, null, multiStrikeEnhancementMultiplier);
     if (!ignoreSourceAbility) {
-      applyPreAttackAbAttrs(AddSecondStrikeAbAttr, source, this, move, simulated, numTargets, new Utils.IntegerHolder(0), parentalBondMultiplier);
+      applyPreAttackAbAttrs(AddSecondStrikeAbAttr, source, this, move, simulated, null, multiStrikeEnhancementMultiplier);
     }
 
     /** Doubles damage if this Pokemon's last move was Glaive Rush */
@@ -2722,7 +2723,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     damage.value = Utils.toDmgValue(
       baseDamage
       * targetMultiplier
-      * parentalBondMultiplier.value
+      * multiStrikeEnhancementMultiplier.value
       * arenaAttackTypeMultiplier.value
       * glaiveRushMultiplier.value
       * criticalMultiplier.value

src/modifier/modifier.ts

@@ -6,7 +6,6 @@ import { allMoves } from "#app/data/move";
 import { MAX_PER_TYPE_POKEBALLS } from "#app/data/pokeball";
 import { type FormChangeItem, SpeciesFormChangeItemTrigger, SpeciesFormChangeLapseTeraTrigger, SpeciesFormChangeTeraTrigger } from "#app/data/pokemon-forms";
 import { getStatusEffectHealText } from "#app/data/status-effect";
-import { Type } from "#enums/type";
 import Pokemon, { type PlayerPokemon } from "#app/field/pokemon";
 import { getPokemonNameWithAffix } from "#app/messages";
 import Overrides from "#app/overrides";
@@ -22,11 +21,13 @@ import { BooleanHolder, hslToHex, isNullOrUndefined, NumberHolder, toDmgValue }
 import { Abilities } from "#enums/abilities";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import { BerryType } from "#enums/berry-type";
+import { Moves } from "#enums/moves";
 import type { Nature } from "#enums/nature";
 import type { PokeballType } from "#enums/pokeball";
 import { Species } from "#enums/species";
 import { type PermanentStat, type TempBattleStat, BATTLE_STATS, Stat, TEMP_BATTLE_STATS } from "#enums/stat";
 import { StatusEffect } from "#enums/status-effect";
+import { Type } from "#enums/type";
 import i18next from "i18next";
 import { type DoubleBattleChanceBoosterModifierType, type EvolutionItemModifierType, type FormChangeItemModifierType, type ModifierOverride, type ModifierType, type PokemonBaseStatTotalModifierType, type PokemonExpBoosterModifierType, type PokemonFriendshipBoosterModifierType, type PokemonMoveAccuracyBoosterModifierType, type PokemonMultiHitModifierType, type TerastallizeModifierType, type TmModifierType, getModifierType, ModifierPoolType, ModifierTypeGenerator, modifierTypes, PokemonHeldItemModifierType } from "./modifier-type";
 import { Color, ShadowColor } from "#enums/color";
@@ -2689,32 +2690,57 @@ export class PokemonMultiHitModifier extends PokemonHeldItemModifier {
   }
 
   /**
-   * Applies {@linkcode PokemonMultiHitModifier}
+   * For each stack, converts 25 percent of attack damage into an additional strike.
-   * @param _pokemon The {@linkcode Pokemon} using the move
+   * @param pokemon The {@linkcode Pokemon} using the move
-   * @param count {@linkcode NumberHolder} holding the number of items
+   * @param moveId The {@linkcode Moves | identifier} for the move being used
-   * @param power {@linkcode NumberHolder} holding the power of the move
+   * @param count {@linkcode NumberHolder} holding the move's hit count for this turn
+   * @param damageMultiplier {@linkcode NumberHolder} holding a damage multiplier applied to a strike of this move
    * @returns always `true`
    */
-  override apply(_pokemon: Pokemon, count: NumberHolder, power: NumberHolder): boolean {
+  override apply(pokemon: Pokemon, moveId: Moves, count: NumberHolder | null = null, damageMultiplier: NumberHolder | null = null): boolean {
-    count.value *= (this.getStackCount() + 1);
+    const move = allMoves[moveId];
-
+    /**
-    switch (this.getStackCount()) {
+     * The move must meet Parental Bond's restrictions for this item
-      case 1:
+     * to apply. This means
-        power.value *= 0.4;
+     * - Only attacks are boosted
-        break;
+     * - Multi-strike moves, charge moves, and self-sacrificial moves are not boosted
-      case 2:
+     *   (though Multi-Lens can still affect moves boosted by Parental Bond)
-        power.value *= 0.25;
+     * - Multi-target moves are not boosted *unless* they can only hit a single Pokemon
-        break;
+     * - Fling, Uproar, Rollout, Ice Ball, and Endeavor are not boosted
-      case 3:
+     */
-        power.value *= 0.175;
+    if (!move.canBeMultiStrikeEnhanced(pokemon)) {
-        break;
+      return false;
     }
 
+    if (!isNullOrUndefined(count)) {
+      return this.applyHitCountBoost(count);
+    } else if (!isNullOrUndefined(damageMultiplier)) {
+      return this.applyPowerModifier(pokemon, damageMultiplier);
+    }
+
+    return false;
+  }
+
+  /** Adds strikes to a move equal to the number of stacked Multi-Lenses */
+  private applyHitCountBoost(count: NumberHolder): boolean {
+    count.value += this.getStackCount();
+    return true;
+  }
+
+  /**
+   * If applied to the first hit of a move, sets the damage multiplier
+   * equal to (1 - the number of stacked Multi-Lenses).
+   * Additional strikes beyond that are given a 0.25x damage multiplier
+   */
+  private applyPowerModifier(pokemon: Pokemon, damageMultiplier: NumberHolder): boolean {
+    damageMultiplier.value = (pokemon.turnData.hitsLeft === pokemon.turnData.hitCount)
+      ? (1 - (0.25 * this.getStackCount()))
+      : 0.25;
     return true;
   }
 
   getMaxHeldItemCount(pokemon: Pokemon): number {
-    return 3;
+    return 2;
   }
 }
 

src/phases/move-effect-phase.ts

@@ -26,7 +26,6 @@ import {
   applyMoveAttrs,
   AttackMove,
   DelayedAttackAttr,
-  FixedDamageAttr,
   HitsTagAttr,
   MissEffectAttr,
   MoveAttr,
@@ -122,12 +121,10 @@ export class MoveEffectPhase extends PokemonPhase {
         const hitCount = new NumberHolder(1);
         // Assume single target for multi hit
         applyMoveAttrs(MultiHitAttr, user, this.getFirstTarget() ?? null, move, hitCount);
-        // If Parental Bond is applicable, double the hit count
+        // If Parental Bond is applicable, add another hit
-        applyPreAttackAbAttrs(AddSecondStrikeAbAttr, user, null, move, false, targets.length, hitCount, new NumberHolder(0));
+        applyPreAttackAbAttrs(AddSecondStrikeAbAttr, user, null, move, false, hitCount, null);
-        // If Multi-Lens is applicable, multiply the hit count by 1 + the number of Multi-Lenses held by the user
+        // If Multi-Lens is applicable, add hits equal to the number of held Multi-Lenses
-        if (move instanceof AttackMove && !move.hasAttr(FixedDamageAttr)) {
+        this.scene.applyModifiers(PokemonMultiHitModifier, user.isPlayer(), user, move.id, hitCount);
-          this.scene.applyModifiers(PokemonMultiHitModifier, user.isPlayer(), user, hitCount, new NumberHolder(0));
-        }
         // Set the user's relevant turnData fields to reflect the final hit count
         user.turnData.hitCount = hitCount.value;
         user.turnData.hitsLeft = hitCount.value;

src/test/abilities/parental_bond.test.ts

@@ -274,7 +274,7 @@ describe("Abilities - Parental Bond", () => {
   );
 
   it(
-    "Moves boosted by this ability and Multi-Lens should strike 4 times",
+    "Moves boosted by this ability and Multi-Lens should strike 3 times",
     async () => {
       game.override.moveset([ Moves.TACKLE ]);
       game.override.startingHeldItems([{ name: "MULTI_LENS", count: 1 }]);
@@ -287,36 +287,12 @@ describe("Abilities - Parental Bond", () => {
 
       await game.phaseInterceptor.to("DamagePhase");
 
-      expect(leadPokemon.turnData.hitCount).toBe(4);
+      expect(leadPokemon.turnData.hitCount).toBe(3);
     }
   );
 
   it(
-    "Super Fang boosted by this ability and Multi-Lens should strike twice",
+    "Seismic Toss boosted by this ability and Multi-Lens should strike 3 times",
-    async () => {
-      game.override.moveset([ Moves.SUPER_FANG ]);
-      game.override.startingHeldItems([{ name: "MULTI_LENS", count: 1 }]);
-
-      await game.classicMode.startBattle([ Species.MAGIKARP ]);
-
-      const leadPokemon = game.scene.getPlayerPokemon()!;
-      const enemyPokemon = game.scene.getEnemyPokemon()!;
-
-      game.move.select(Moves.SUPER_FANG);
-      await game.move.forceHit();
-
-      await game.phaseInterceptor.to("DamagePhase");
-
-      expect(leadPokemon.turnData.hitCount).toBe(2);
-
-      await game.phaseInterceptor.to("MoveEndPhase", false);
-
-      expect(enemyPokemon.hp).toBe(Math.ceil(enemyPokemon.getMaxHp() * 0.25));
-    }
-  );
-
-  it(
-    "Seismic Toss boosted by this ability and Multi-Lens should strike twice",
     async () => {
       game.override.moveset([ Moves.SEISMIC_TOSS ]);
       game.override.startingHeldItems([{ name: "MULTI_LENS", count: 1 }]);
@@ -333,11 +309,11 @@ describe("Abilities - Parental Bond", () => {
 
       await game.phaseInterceptor.to("DamagePhase");
 
-      expect(leadPokemon.turnData.hitCount).toBe(2);
+      expect(leadPokemon.turnData.hitCount).toBe(3);
 
       await game.phaseInterceptor.to("MoveEndPhase", false);
 
-      expect(enemyPokemon.hp).toBe(enemyStartingHp - 200);
+      expect(enemyPokemon.hp).toBe(enemyStartingHp - 300);
     }
   );
 
@@ -494,30 +470,4 @@ describe("Abilities - Parental Bond", () => {
       expect(enemyPokemon.getStatStage(Stat.SPATK)).toBe(1);
     }
   );
-
-  it(
-    "should not apply to multi-target moves with Multi-Lens",
-    async () => {
-      game.override.battleType("double");
-      game.override.moveset([ Moves.EARTHQUAKE, Moves.SPLASH ]);
-      game.override.passiveAbility(Abilities.LEVITATE);
-      game.override.startingHeldItems([{ name: "MULTI_LENS", count: 1 }]);
-
-      await game.classicMode.startBattle([ Species.MAGIKARP, Species.FEEBAS ]);
-
-      const enemyPokemon = game.scene.getEnemyField();
-
-      const enemyStartingHp = enemyPokemon.map(p => p.hp);
-
-      game.move.select(Moves.EARTHQUAKE);
-      game.move.select(Moves.SPLASH, 1);
-
-      await game.phaseInterceptor.to("DamagePhase");
-      const enemyFirstHitDamage = enemyStartingHp.map((hp, i) => hp - enemyPokemon[i].hp);
-
-      await game.phaseInterceptor.to("BerryPhase", false);
-
-      enemyPokemon.forEach((p, i) => expect(enemyStartingHp[i] - p.hp).toBe(2 * enemyFirstHitDamage[i]));
-    }
-  );
 });

src/test/items/multi_lens.test.ts

@@ -0,0 +1,98 @@
+import { BattlerIndex } from "#app/battle";
+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, vi } from "vitest";
+
+describe("Items - Multi Lens", () => {
+  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.TACKLE, Moves.TRAILBLAZE, Moves.TACHYON_CUTTER ])
+      .ability(Abilities.BALL_FETCH)
+      .startingHeldItems([{ name: "MULTI_LENS" }])
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.SNORLAX)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH)
+      .startingLevel(100)
+      .enemyLevel(100);
+  });
+
+  it.each([
+    { stackCount: 1, firstHitDamage: 0.75 },
+    { stackCount: 2, firstHitDamage: 0.50 }
+  ])("$stackCount count: should deal {$firstHitDamage}x damage on the first hit, then hit $stackCount times for 0.25x",
+    async ({ stackCount, firstHitDamage }) => {
+      game.override.startingHeldItems([{ name: "MULTI_LENS", count: stackCount }]);
+
+      await game.classicMode.startBattle([ Species.MAGIKARP ]);
+
+      const enemyPokemon = game.scene.getEnemyPokemon()!;
+      const spy = vi.spyOn(enemyPokemon, "getAttackDamage");
+      vi.spyOn(enemyPokemon, "getBaseDamage").mockReturnValue(100);
+
+      game.move.select(Moves.TACKLE);
+      await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+
+      await game.phaseInterceptor.to("MoveEndPhase");
+      const damageResults = spy.mock.results.map(result => result.value?.damage);
+
+      expect(damageResults).toHaveLength(1 + stackCount);
+      expect(damageResults[0]).toBe(firstHitDamage * 100);
+      damageResults.slice(1).forEach(dmg => expect(dmg).toBe(25));
+    });
+
+  it("should stack additively with Parental Bond", async () => {
+    game.override.ability(Abilities.PARENTAL_BOND);
+
+    await game.classicMode.startBattle([ Species.MAGIKARP ]);
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+
+    game.move.select(Moves.TACKLE);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+
+    await game.phaseInterceptor.to("MoveEndPhase");
+    expect(playerPokemon.turnData.hitCount).toBe(3);
+  });
+
+  it("should apply secondary effects on each hit", async () => {
+    await game.classicMode.startBattle([ Species.MAGIKARP ]);
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+
+    game.move.select(Moves.TRAILBLAZE);
+
+    await game.phaseInterceptor.to("BerryPhase", false);
+    expect(playerPokemon.getStatStage(Stat.SPD)).toBe(2);
+  });
+
+  it("should not enhance multi-hit moves", async () => {
+    await game.classicMode.startBattle([ Species.MAGIKARP ]);
+
+    const playerPokemon = game.scene.getPlayerPokemon()!;
+
+    game.move.select(Moves.TACHYON_CUTTER);
+
+    await game.phaseInterceptor.to("BerryPhase", false);
+    expect(playerPokemon.turnData.hitCount).toBe(2);
+  });
+});

src/test/moves/beat_up.test.ts

@@ -74,29 +74,4 @@ describe("Moves - Beat Up", () => {
       expect(playerPokemon.turnData.hitCount).toBe(5);
     }
   );
-
-  it(
-    "should hit twice for each player Pokemon if the user has Multi-Lens",
-    async () => {
-      game.override.startingHeldItems([{ name: "MULTI_LENS", count: 1 }]);
-      await game.startBattle([ Species.MAGIKARP, Species.BULBASAUR, Species.CHARMANDER, Species.SQUIRTLE, Species.PIKACHU, Species.EEVEE ]);
-
-      const playerPokemon = game.scene.getPlayerPokemon()!;
-      const enemyPokemon = game.scene.getEnemyPokemon()!;
-      let enemyStartingHp = enemyPokemon.hp;
-
-      game.move.select(Moves.BEAT_UP);
-
-      await game.phaseInterceptor.to(MoveEffectPhase);
-
-      expect(playerPokemon.turnData.hitCount).toBe(12);
-      expect(enemyPokemon.hp).toBeLessThan(enemyStartingHp);
-
-      while (playerPokemon.turnData.hitsLeft > 0) {
-        enemyStartingHp = enemyPokemon.hp;
-        await game.phaseInterceptor.to(MoveEffectPhase);
-        expect(enemyPokemon.hp).toBeLessThan(enemyStartingHp);
-      }
-    }
-  );
 });

src/test/moves/ceaseless_edge.test.ts

@@ -34,7 +34,7 @@ describe("Moves - Ceaseless Edge", () => {
     game.override.startingLevel(100);
     game.override.enemyLevel(100);
     game.override.moveset([ Moves.CEASELESS_EDGE, Moves.SPLASH, Moves.ROAR ]);
-    game.override.enemyMoveset([ Moves.SPLASH, Moves.SPLASH, Moves.SPLASH, Moves.SPLASH ]);
+    game.override.enemyMoveset(Moves.SPLASH);
     vi.spyOn(allMoves[Moves.CEASELESS_EDGE], "accuracy", "get").mockReturnValue(100);
 
   });
@@ -42,7 +42,7 @@ describe("Moves - Ceaseless Edge", () => {
   test(
     "move should hit and apply spikes",
     async () => {
-      await game.startBattle([ Species.ILLUMISE ]);
+      await game.classicMode.startBattle([ Species.ILLUMISE ]);
 
       const enemyPokemon = game.scene.getEnemyPokemon()!;
 
@@ -67,7 +67,7 @@ describe("Moves - Ceaseless Edge", () => {
     "move should hit twice with multi lens and apply two layers of spikes",
     async () => {
       game.override.startingHeldItems([{ name: "MULTI_LENS" }]);
-      await game.startBattle([ Species.ILLUMISE ]);
+      await game.classicMode.startBattle([ Species.ILLUMISE ]);
 
       const enemyPokemon = game.scene.getEnemyPokemon()!;
 
@@ -92,9 +92,9 @@ describe("Moves - Ceaseless Edge", () => {
     "trainer - move should hit twice, apply two layers of spikes, force switch opponent - opponent takes damage",
     async () => {
       game.override.startingHeldItems([{ name: "MULTI_LENS" }]);
-      game.override.startingWave(5);
+      game.override.startingWave(25);
 
-      await game.startBattle([ Species.ILLUMISE ]);
+      await game.classicMode.startBattle([ Species.ILLUMISE ]);
 
       game.move.select(Moves.CEASELESS_EDGE);
       await game.phaseInterceptor.to(MoveEffectPhase, false);
@@ -102,7 +102,7 @@ describe("Moves - Ceaseless Edge", () => {
       const tagBefore = game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY) as ArenaTrapTag;
       expect(tagBefore instanceof ArenaTrapTag).toBeFalsy();
 
-      await game.phaseInterceptor.to(TurnEndPhase, false);
+      await game.toNextTurn();
       const tagAfter = game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY) as ArenaTrapTag;
       expect(tagAfter instanceof ArenaTrapTag).toBeTruthy();
       expect(tagAfter.layers).toBe(2);

src/test/moves/dragon_rage.test.ts

@@ -2,7 +2,6 @@ import { Stat } from "#enums/stat";
 import { Type } from "#enums/type";
 import { Species } from "#app/enums/species";
 import { EnemyPokemon, PlayerPokemon } from "#app/field/pokemon";
-import { modifierTypes } from "#app/modifier/modifier-type";
 import { TurnEndPhase } from "#app/phases/turn-end-phase";
 import { Abilities } from "#enums/abilities";
 import { BattlerTagType } from "#enums/battler-tag-type";
@@ -114,14 +113,4 @@ describe("Moves - Dragon Rage", () => {
 
     expect(enemyPokemon.getInverseHp()).toBe(dragonRageDamage);
   });
-
-  it("ignores multi hit", async () => {
-    game.override.disableCrits();
-    game.scene.addModifier(modifierTypes.MULTI_LENS().newModifier(partyPokemon), false);
-
-    game.move.select(Moves.DRAGON_RAGE);
-    await game.phaseInterceptor.to(TurnEndPhase);
-
-    expect(enemyPokemon.getInverseHp()).toBe(dragonRageDamage);
-  });
 });

src/test/moves/electro_shot.test.ts

@@ -98,7 +98,7 @@ describe("Moves - Electro Shot", () => {
     game.move.select(Moves.ELECTRO_SHOT);
 
     await game.phaseInterceptor.to("MoveEndPhase");
-    expect(playerPokemon.turnData.hitCount).toBe(2);
+    expect(playerPokemon.turnData.hitCount).toBe(1);
     expect(playerPokemon.getStatStage(Stat.SPATK)).toBe(1);
   });
 });