[P2] Fix Early Bird (#4632)

* Fix Early Bird, add tests

* Update tsdocs for Early Bird's `AbAttr`

Rename `turnCount` to `toxicTurnCount` and
`turnsRemaining` to `sleepTurnsRemaining` in `status-effect.ts`

* Fix Toxic Orb test

* Redundant code :despair:

* Fix status override to set the number of sleep turns

src/data/ability.ts

@@ -4200,6 +4200,11 @@ export class RedirectTypeMoveAbAttr extends RedirectMoveAbAttr {
 
 export class BlockRedirectAbAttr extends AbAttr { }
 
+/**
+ * Used by Early Bird, makes the pokemon wake up faster
+ * @param statusEffect - The {@linkcode StatusEffect} to check for
+ * @see {@linkcode apply}
+ */
 export class ReduceStatusEffectDurationAbAttr extends AbAttr {
   private statusEffect: StatusEffect;
 
@@ -4209,9 +4214,19 @@ export class ReduceStatusEffectDurationAbAttr extends AbAttr {
     this.statusEffect = statusEffect;
   }
 
-  apply(pokemon: Pokemon, passive: boolean, simulated: boolean, cancelled: Utils.BooleanHolder, args: any[]): boolean {
+  /**
+   * Reduces the number of sleep turns remaining by an extra 1 when applied
+   * @param args - The args passed to the `AbAttr`:
+   * - `[0]` - The {@linkcode StatusEffect} of the Pokemon
+   * - `[1]` - The number of turns remaining until the status is healed
+   * @returns `true` if the ability was applied
+   */
+  apply(_pokemon: Pokemon, _passive: boolean, _simulated: boolean, _cancelled: Utils.BooleanHolder, args: any[]): boolean {
+    if (!(args[1] instanceof Utils.NumberHolder)) {
+      return false;
+    }
     if (args[0] === this.statusEffect) {
-      (args[1] as Utils.IntegerHolder).value = Utils.toDmgValue((args[1] as Utils.IntegerHolder).value / 2);
+      args[1].value -= 1;
       return true;
     }
 

src/data/move.ts

@@ -2050,15 +2050,15 @@ export class WaterShurikenMultiHitTypeAttr extends ChangeMultiHitTypeAttr {
 
 export class StatusEffectAttr extends MoveEffectAttr {
   public effect: StatusEffect;
-  public cureTurn: integer | null;
+  public turnsRemaining?: number;
-  public overrideStatus: boolean;
+  public overrideStatus: boolean = false;
 
-  constructor(effect: StatusEffect, selfTarget?: boolean, cureTurn?: integer, overrideStatus?: boolean) {
+  constructor(effect: StatusEffect, selfTarget?: boolean, turnsRemaining?: number, overrideStatus: boolean = false) {
     super(selfTarget, MoveEffectTrigger.HIT);
 
     this.effect = effect;
-    this.cureTurn = cureTurn!; // TODO: is this bang correct?
+    this.turnsRemaining = turnsRemaining;
-    this.overrideStatus = !!overrideStatus;
+    this.overrideStatus = overrideStatus;
   }
 
   apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
@@ -2085,7 +2085,7 @@ export class StatusEffectAttr extends MoveEffectAttr {
         return false;
       }
       if ((!pokemon.status || (pokemon.status.effect === this.effect && moveChance < 0))
-        && pokemon.trySetStatus(this.effect, true, user, this.cureTurn)) {
+        && pokemon.trySetStatus(this.effect, true, user, this.turnsRemaining)) {
         applyPostAttackAbAttrs(ConfusionOnStatusEffectAbAttr, user, target, move, null, false, this.effect);
         return true;
       }
@@ -2102,8 +2102,8 @@ export class StatusEffectAttr extends MoveEffectAttr {
 export class MultiStatusEffectAttr extends StatusEffectAttr {
   public effects: StatusEffect[];
 
-  constructor(effects: StatusEffect[], selfTarget?: boolean, cureTurn?: integer, overrideStatus?: boolean) {
+  constructor(effects: StatusEffect[], selfTarget?: boolean, turnsRemaining?: number, overrideStatus?: boolean) {
-    super(effects[0], selfTarget, cureTurn, overrideStatus);
+    super(effects[0], selfTarget, turnsRemaining, overrideStatus);
     this.effects = effects;
   }
 

src/data/status-effect.ts

@@ -1,4 +1,4 @@
-import * as Utils from "../utils";
+import { randIntRange } from "#app/utils";
 import { StatusEffect } from "#enums/status-effect";
 import i18next, { ParseKeys } from "i18next";
 
@@ -6,17 +6,21 @@ export { StatusEffect };
 
 export class Status {
   public effect: StatusEffect;
-  public turnCount: integer;
+  /** Toxic damage is `1/16 max HP * toxicTurnCount` */
-  public cureTurn: integer | null;
+  public toxicTurnCount: number = 0;
+  public sleepTurnsRemaining?: number;
 
-  constructor(effect: StatusEffect, turnCount: integer = 0, cureTurn?: integer) {
+  constructor(effect: StatusEffect, toxicTurnCount: number = 0, sleepTurnsRemaining?: number) {
     this.effect = effect;
-    this.turnCount = turnCount === undefined ? 0 : turnCount;
+    this.toxicTurnCount = toxicTurnCount;
-    this.cureTurn = cureTurn!; // TODO: is this bang correct?
+    this.sleepTurnsRemaining = sleepTurnsRemaining;
   }
 
   incrementTurn(): void {
-    this.turnCount++;
+    this.toxicTurnCount++;
+    if (this.sleepTurnsRemaining) {
+      this.sleepTurnsRemaining--;
+    }
   }
 
   isPostTurn(): boolean {
@@ -107,7 +111,7 @@ export function getStatusEffectCatchRateMultiplier(statusEffect: StatusEffect):
 * Returns a random non-volatile StatusEffect
 */
 export function generateRandomStatusEffect(): StatusEffect {
-  return Utils.randIntRange(1, 6);
+  return randIntRange(1, 6);
 }
 
 /**
@@ -123,7 +127,7 @@ export function getRandomStatusEffect(statusEffectA: StatusEffect, statusEffectB
     return statusEffectA;
   }
 
-  return Utils.randIntRange(0, 2) ? statusEffectA : statusEffectB;
+  return randIntRange(0, 2) ? statusEffectA : statusEffectB;
 }
 
 /**
@@ -140,7 +144,7 @@ export function getRandomStatus(statusA: Status | null, statusB: Status | null):
   }
 
 
-  return Utils.randIntRange(0, 2) ? statusA : statusB;
+  return randIntRange(0, 2) ? statusA : statusB;
 }
 
 /**

src/field/pokemon.ts

@@ -22,7 +22,7 @@ import { reverseCompatibleTms, tmSpecies, tmPoolTiers } from "#app/data/balance/
 import { BattlerTag, BattlerTagLapseType, EncoreTag, GroundedTag, HighestStatBoostTag, SubstituteTag, TypeImmuneTag, getBattlerTag, SemiInvulnerableTag, TypeBoostTag, MoveRestrictionBattlerTag, ExposedTag, DragonCheerTag, CritBoostTag, TrappedTag, TarShotTag, AutotomizedTag, PowerTrickTag } from "../data/battler-tags";
 import { WeatherType } from "#app/data/weather";
 import { ArenaTagSide, NoCritTag, WeakenMoveScreenTag } from "#app/data/arena-tag";
-import { Ability, AbAttr, StatMultiplierAbAttr, BlockCritAbAttr, BonusCritAbAttr, BypassBurnDamageReductionAbAttr, FieldPriorityMoveImmunityAbAttr, IgnoreOpponentStatStagesAbAttr, MoveImmunityAbAttr, PreDefendFullHpEndureAbAttr, ReceivedMoveDamageMultiplierAbAttr, ReduceStatusEffectDurationAbAttr, StabBoostAbAttr, StatusEffectImmunityAbAttr, TypeImmunityAbAttr, WeightMultiplierAbAttr, allAbilities, applyAbAttrs, applyStatMultiplierAbAttrs, applyPreApplyBattlerTagAbAttrs, applyPreAttackAbAttrs, applyPreDefendAbAttrs, applyPreSetStatusAbAttrs, UnsuppressableAbilityAbAttr, SuppressFieldAbilitiesAbAttr, NoFusionAbilityAbAttr, MultCritAbAttr, IgnoreTypeImmunityAbAttr, DamageBoostAbAttr, IgnoreTypeStatusEffectImmunityAbAttr, ConditionalCritAbAttr, applyFieldStatMultiplierAbAttrs, FieldMultiplyStatAbAttr, AddSecondStrikeAbAttr, UserFieldStatusEffectImmunityAbAttr, UserFieldBattlerTagImmunityAbAttr, BattlerTagImmunityAbAttr, MoveTypeChangeAbAttr, FullHpResistTypeAbAttr, applyCheckTrappedAbAttrs, CheckTrappedAbAttr, PostSetStatusAbAttr, applyPostSetStatusAbAttrs, InfiltratorAbAttr } from "#app/data/ability";
+import { Ability, AbAttr, StatMultiplierAbAttr, BlockCritAbAttr, BonusCritAbAttr, BypassBurnDamageReductionAbAttr, FieldPriorityMoveImmunityAbAttr, IgnoreOpponentStatStagesAbAttr, MoveImmunityAbAttr, PreDefendFullHpEndureAbAttr, ReceivedMoveDamageMultiplierAbAttr, StabBoostAbAttr, StatusEffectImmunityAbAttr, TypeImmunityAbAttr, WeightMultiplierAbAttr, allAbilities, applyAbAttrs, applyStatMultiplierAbAttrs, applyPreApplyBattlerTagAbAttrs, applyPreAttackAbAttrs, applyPreDefendAbAttrs, applyPreSetStatusAbAttrs, UnsuppressableAbilityAbAttr, SuppressFieldAbilitiesAbAttr, NoFusionAbilityAbAttr, MultCritAbAttr, IgnoreTypeImmunityAbAttr, DamageBoostAbAttr, IgnoreTypeStatusEffectImmunityAbAttr, ConditionalCritAbAttr, applyFieldStatMultiplierAbAttrs, FieldMultiplyStatAbAttr, AddSecondStrikeAbAttr, UserFieldStatusEffectImmunityAbAttr, UserFieldBattlerTagImmunityAbAttr, BattlerTagImmunityAbAttr, MoveTypeChangeAbAttr, FullHpResistTypeAbAttr, applyCheckTrappedAbAttrs, CheckTrappedAbAttr, PostSetStatusAbAttr, applyPostSetStatusAbAttrs, InfiltratorAbAttr } from "#app/data/ability";
 import PokemonData from "#app/system/pokemon-data";
 import { BattlerIndex } from "#app/battle";
 import { Mode } from "#app/ui/ui";
@@ -3430,7 +3430,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     return true;
   }
 
-  trySetStatus(effect: StatusEffect | undefined, asPhase: boolean = false, sourcePokemon: Pokemon | null = null, cureTurn: integer | null = 0, sourceText: string | null = null): boolean {
+  trySetStatus(effect?: StatusEffect, asPhase: boolean = false, sourcePokemon: Pokemon | null = null, turnsRemaining: number = 0, sourceText: string | null = null): boolean {
     if (!this.canSetStatus(effect, asPhase, false, sourcePokemon)) {
       return false;
     }
@@ -3444,15 +3444,14 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     }
 
     if (asPhase) {
-      this.scene.unshiftPhase(new ObtainStatusEffectPhase(this.scene, this.getBattlerIndex(), effect, cureTurn, sourceText, sourcePokemon));
+      this.scene.unshiftPhase(new ObtainStatusEffectPhase(this.scene, this.getBattlerIndex(), effect, turnsRemaining, sourceText, sourcePokemon));
       return true;
     }
 
-    let statusCureTurn: Utils.IntegerHolder;
+    let sleepTurnsRemaining: Utils.NumberHolder;
 
     if (effect === StatusEffect.SLEEP) {
-      statusCureTurn = new Utils.IntegerHolder(this.randSeedIntRange(2, 4));
+      sleepTurnsRemaining = new Utils.NumberHolder(this.randSeedIntRange(2, 4));
-      applyAbAttrs(ReduceStatusEffectDurationAbAttr, this, null, false, effect, statusCureTurn);
 
       this.setFrameRate(4);
 
@@ -3472,9 +3471,9 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       }
     }
 
-    statusCureTurn = statusCureTurn!; // tell TS compiler it's defined
+    sleepTurnsRemaining = sleepTurnsRemaining!; // tell TS compiler it's defined
     effect = effect!; // If `effect` is undefined then `trySetStatus()` will have already returned early via the `canSetStatus()` call
-    this.status = new Status(effect, 0, statusCureTurn?.value);
+    this.status = new Status(effect, 0, sleepTurnsRemaining?.value);
 
     if (effect !== StatusEffect.FAINT) {
       this.scene.triggerPokemonFormChange(this, SpeciesFormChangeStatusEffectTrigger, true);
@@ -4001,7 +4000,7 @@ export class PlayerPokemon extends Pokemon {
     super(scene, 106, 148, species, level, abilityIndex, formIndex, gender, shiny, variant, ivs, nature, dataSource);
 
     if (Overrides.STATUS_OVERRIDE) {
-      this.status = new Status(Overrides.STATUS_OVERRIDE);
+      this.status = new Status(Overrides.STATUS_OVERRIDE, 0, 4);
     }
 
     if (Overrides.SHINY_OVERRIDE) {
@@ -4481,7 +4480,7 @@ export class EnemyPokemon extends Pokemon {
     }
 
     if (Overrides.OPP_STATUS_OVERRIDE) {
-      this.status = new Status(Overrides.OPP_STATUS_OVERRIDE);
+      this.status = new Status(Overrides.OPP_STATUS_OVERRIDE, 0, 4);
     }
 
     if (Overrides.OPP_GENDER_OVERRIDE) {
@@ -4490,9 +4489,11 @@ export class EnemyPokemon extends Pokemon {
 
     const speciesId = this.species.speciesId;
 
-    if (speciesId in Overrides.OPP_FORM_OVERRIDES
+    if (
+      speciesId in Overrides.OPP_FORM_OVERRIDES
       && Overrides.OPP_FORM_OVERRIDES[speciesId]
-      && this.species.forms[Overrides.OPP_FORM_OVERRIDES[speciesId]]) {
+      && this.species.forms[Overrides.OPP_FORM_OVERRIDES[speciesId]]
+    ) {
       this.formIndex = Overrides.OPP_FORM_OVERRIDES[speciesId] ?? 0;
     }
 

src/phases/move-phase.ts

@@ -1,6 +1,6 @@
 import { BattlerIndex } from "#app/battle";
 import BattleScene from "#app/battle-scene";
-import { applyAbAttrs, applyPostMoveUsedAbAttrs, applyPreAttackAbAttrs, BlockRedirectAbAttr, IncreasePpAbAttr, PokemonTypeChangeAbAttr, PostMoveUsedAbAttr, RedirectMoveAbAttr } from "#app/data/ability";
+import { applyAbAttrs, applyPostMoveUsedAbAttrs, applyPreAttackAbAttrs, BlockRedirectAbAttr, IncreasePpAbAttr, PokemonTypeChangeAbAttr, PostMoveUsedAbAttr, RedirectMoveAbAttr, ReduceStatusEffectDurationAbAttr } from "#app/data/ability";
 import { CommonAnim } from "#app/data/battle-anims";
 import { BattlerTagLapseType, CenterOfAttentionTag } from "#app/data/battler-tags";
 import { allMoves, applyMoveAttrs, BypassRedirectAttr, BypassSleepAttr, ChargeAttr, CopyMoveAttr, HealStatusEffectAttr, MoveFlags, PreMoveMessageAttr } from "#app/data/move";
@@ -175,7 +175,10 @@ export class MovePhase extends BattlePhase {
           break;
         case StatusEffect.SLEEP:
           applyMoveAttrs(BypassSleepAttr, this.pokemon, null, this.move.getMove());
-          healed = this.pokemon.status.turnCount === this.pokemon.status.cureTurn;
+          const turnsRemaining = new NumberHolder(this.pokemon.status.sleepTurnsRemaining ?? 0);
+          applyAbAttrs(ReduceStatusEffectDurationAbAttr, this.pokemon, null, false, this.pokemon.status.effect, turnsRemaining);
+          this.pokemon.status.sleepTurnsRemaining = turnsRemaining.value;
+          healed = this.pokemon.status.sleepTurnsRemaining <= 0;
           activated = !healed && !this.pokemon.getTag(BattlerTagType.BYPASS_SLEEP);
           this.cancelled = activated;
           break;

src/phases/obtain-status-effect-phase.ts

@@ -8,26 +8,26 @@ import { getPokemonNameWithAffix } from "#app/messages";
 import { PokemonPhase } from "./pokemon-phase";
 
 export class ObtainStatusEffectPhase extends PokemonPhase {
-  private statusEffect?: StatusEffect | undefined;
+  private statusEffect?: StatusEffect;
-  private cureTurn?: integer | null;
+  private turnsRemaining?: number;
   private sourceText?: string | null;
   private sourcePokemon?: Pokemon | null;
 
-  constructor(scene: BattleScene, battlerIndex: BattlerIndex, statusEffect?: StatusEffect, cureTurn?: integer | null, sourceText?: string | null, sourcePokemon?: Pokemon | null) {
+  constructor(scene: BattleScene, battlerIndex: BattlerIndex, statusEffect?: StatusEffect, turnsRemaining?: number, sourceText?: string | null, sourcePokemon?: Pokemon | null) {
     super(scene, battlerIndex);
 
     this.statusEffect = statusEffect;
-    this.cureTurn = cureTurn;
+    this.turnsRemaining = turnsRemaining;
     this.sourceText = sourceText;
-    this.sourcePokemon = sourcePokemon; // For tracking which Pokemon caused the status effect
+    this.sourcePokemon = sourcePokemon;
   }
 
   start() {
     const pokemon = this.getPokemon();
     if (pokemon && !pokemon.status) {
       if (pokemon.trySetStatus(this.statusEffect, false, this.sourcePokemon)) {
-        if (this.cureTurn) {
+        if (this.turnsRemaining) {
-          pokemon.status!.cureTurn = this.cureTurn; // TODO: is this bang correct?
+          pokemon.status!.sleepTurnsRemaining = this.turnsRemaining;
         }
         pokemon.updateInfo(true);
         new CommonBattleAnim(CommonAnim.POISON + (this.statusEffect! - 1), pokemon).play(this.scene, false, () => {

src/phases/post-summon-phase.ts

@@ -18,7 +18,7 @@ export class PostSummonPhase extends PokemonPhase {
     const pokemon = this.getPokemon();
 
     if (pokemon.status?.effect === StatusEffect.TOXIC) {
-      pokemon.status.turnCount = 0;
+      pokemon.status.toxicTurnCount = 0;
     }
     this.scene.arena.applyTags(ArenaTrapTag, false, pokemon);
 

src/phases/post-turn-status-effect-phase.ts

@@ -30,7 +30,7 @@ export class PostTurnStatusEffectPhase extends PokemonPhase {
             damage.value = Math.max(pokemon.getMaxHp() >> 3, 1);
             break;
           case StatusEffect.TOXIC:
-            damage.value = Math.max(Math.floor((pokemon.getMaxHp() / 16) * pokemon.status.turnCount), 1);
+            damage.value = Math.max(Math.floor((pokemon.getMaxHp() / 16) * pokemon.status.toxicTurnCount), 1);
             break;
           case StatusEffect.BURN:
             damage.value = Math.max(pokemon.getMaxHp() >> 4, 1);

src/system/pokemon-data.ts

@@ -137,7 +137,7 @@ export default class PokemonData {
       this.moveset = (source.moveset || [ new PokemonMove(Moves.TACKLE), new PokemonMove(Moves.GROWL) ]).filter(m => m).map((m: any) => new PokemonMove(m.moveId, m.ppUsed, m.ppUp));
       if (!forHistory) {
         this.status = source.status
-          ? new Status(source.status.effect, source.status.turnCount, source.status.cureTurn)
+          ? new Status(source.status.effect, source.status.toxicTurnCount, source.status.sleepTurnsRemaining)
           : null;
       }
 

src/test/abilities/early_bird.test.ts

@@ -0,0 +1,93 @@
+import { Status } from "#app/data/status-effect";
+import { MoveResult } from "#app/field/pokemon";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import { StatusEffect } from "#enums/status-effect";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Abilities - Early Bird", () => {
+  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.REST, Moves.BELLY_DRUM, Moves.SPLASH ])
+      .ability(Abilities.EARLY_BIRD)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("reduces Rest's sleep time to 1 turn", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const player = game.scene.getPlayerPokemon()!;
+
+    game.move.select(Moves.BELLY_DRUM);
+    await game.toNextTurn();
+    game.move.select(Moves.REST);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBe(StatusEffect.SLEEP);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBe(StatusEffect.SLEEP);
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBeUndefined();
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.SUCCESS);
+  });
+
+  it("reduces 3-turn sleep to 1 turn", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const player = game.scene.getPlayerPokemon()!;
+    player.status = new Status(StatusEffect.SLEEP, 0, 4);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBe(StatusEffect.SLEEP);
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBeUndefined();
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.SUCCESS);
+  });
+
+  it("reduces 1-turn sleep to 0 turns", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const player = game.scene.getPlayerPokemon()!;
+    player.status = new Status(StatusEffect.SLEEP, 0, 2);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBeUndefined();
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.SUCCESS);
+  });
+});

src/test/abilities/magic_guard.test.ts

@@ -150,7 +150,7 @@ describe("Abilities - Magic Guard", () => {
 
       const enemyPokemon = game.scene.getEnemyPokemon()!;
 
-      const toxicStartCounter = enemyPokemon.status!.turnCount;
+      const toxicStartCounter = enemyPokemon.status!.toxicTurnCount;
       //should be 0
 
       await game.phaseInterceptor.to(TurnEndPhase);
@@ -162,7 +162,7 @@ describe("Abilities - Magic Guard", () => {
        * - The enemy Pokemon's hypothetical CatchRateMultiplier should be 1.5
        */
       expect(enemyPokemon.hp).toBe(enemyPokemon.getMaxHp());
-      expect(enemyPokemon.status!.turnCount).toBeGreaterThan(toxicStartCounter);
+      expect(enemyPokemon.status!.toxicTurnCount).toBeGreaterThan(toxicStartCounter);
       expect(getStatusEffectCatchRateMultiplier(enemyPokemon.status!.effect)).toBe(1.5);
     }
   );

src/test/data/status-effect.test.ts

@@ -1,4 +1,5 @@
 import {
+  Status,
   StatusEffect,
   getStatusEffectActivationText,
   getStatusEffectDescriptor,
@@ -6,14 +7,19 @@ import {
   getStatusEffectObtainText,
   getStatusEffectOverlapText,
 } from "#app/data/status-effect";
+import { MoveResult } from "#app/field/pokemon";
+import GameManager from "#app/test/utils/gameManager";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
 import { mockI18next } from "#test/utils/testUtils";
 import i18next from "i18next";
-import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 const pokemonName = "PKM";
 const sourceText = "SOURCE";
 
-describe("status-effect", () => {
+describe("Status Effect Messages", () => {
   beforeAll(() => {
     i18next.init();
   });
@@ -299,3 +305,59 @@ describe("status-effect", () => {
     vi.resetAllMocks();
   });
 });
+
+describe("Status Effects - Sleep", () => {
+  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 ])
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("should last the appropriate number of turns", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const player = game.scene.getPlayerPokemon()!;
+    player.status = new Status(StatusEffect.SLEEP, 0, 4);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status.effect).toBe(StatusEffect.SLEEP);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status.effect).toBe(StatusEffect.SLEEP);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status.effect).toBe(StatusEffect.SLEEP);
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(player.status?.effect).toBeUndefined();
+    expect(player.getLastXMoves(1)[0].result).toBe(MoveResult.SUCCESS);
+  });
+});

src/test/items/toxic_orb.test.ts

@@ -7,8 +7,6 @@ import GameManager from "#test/utils/gameManager";
 import Phaser from "phaser";
 import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
-const TIMEOUT = 20 * 1000;
-
 describe("Items - Toxic orb", () => {
   let phaserGame: Phaser.Game;
   let game: GameManager;
@@ -27,10 +25,10 @@ describe("Items - Toxic orb", () => {
     game = new GameManager(phaserGame);
     game.override
       .battleType("single")
-      .enemySpecies(Species.RATTATA)
+      .enemySpecies(Species.MAGIKARP)
       .ability(Abilities.BALL_FETCH)
       .enemyAbility(Abilities.BALL_FETCH)
-      .moveset([ Moves.SPLASH ])
+      .moveset(Moves.SPLASH)
       .enemyMoveset(Moves.SPLASH)
       .startingHeldItems([{
         name: "TOXIC_ORB",
@@ -39,22 +37,19 @@ describe("Items - Toxic orb", () => {
     vi.spyOn(i18next, "t");
   });
 
-  it("badly poisons the holder", async () => {
+  it("should badly poison the holder", async () => {
-    await game.classicMode.startBattle([ Species.MIGHTYENA ]);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
 
-    const player = game.scene.getPlayerField()[0];
+    const player = game.scene.getPlayerPokemon()!;
+    expect(player.getHeldItems()[0].type.id).toBe("TOXIC_ORB");
 
     game.move.select(Moves.SPLASH);
 
     await game.phaseInterceptor.to("TurnEndPhase");
-    // Toxic orb should trigger here
+    await game.phaseInterceptor.to("MessagePhase");
-    await game.phaseInterceptor.run("MessagePhase");
     expect(i18next.t).toHaveBeenCalledWith("statusEffect:toxic.obtainSource", expect.anything());
 
-    await game.toNextTurn();
-
     expect(player.status?.effect).toBe(StatusEffect.TOXIC);
-    // Damage should not have ticked yet.
+    expect(player.status?.toxicTurnCount).toBe(0);
-    expect(player.status?.turnCount).toBe(0);
+  });
-  }, TIMEOUT);
 });

src/test/moves/nightmare.test.ts

@@ -1,12 +1,10 @@
-import { CommandPhase } from "#app/phases/command-phase";
+import { StatusEffect } from "#app/data/status-effect";
-import { TurnInitPhase } from "#app/phases/turn-init-phase";
 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 { StatusEffect } from "#app/data/status-effect";
 
 describe("Moves - Nightmare", () => {
   let phaserGame: Phaser.Game;
@@ -39,16 +37,16 @@ describe("Moves - Nightmare", () => {
 
     const enemyPokemon = game.scene.getEnemyPokemon()!;
     const enemyMaxHP = enemyPokemon.hp;
+
     game.move.select(Moves.NIGHTMARE);
-    await game.phaseInterceptor.to(TurnInitPhase);
+    await game.toNextTurn();
 
     expect(enemyPokemon.hp).toBe(enemyMaxHP - Math.floor(enemyMaxHP / 4));
 
     // take a second turn to make sure damage occurs again
-    await game.phaseInterceptor.to(CommandPhase);
     game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
 
-    await game.phaseInterceptor.to(TurnInitPhase);
     expect(enemyPokemon.hp).toBe(enemyMaxHP - Math.floor(enemyMaxHP / 4) - Math.floor(enemyMaxHP / 4));
   });
 });

src/test/moves/will_o_wisp.test.ts

@@ -0,0 +1,53 @@
+import { BattlerIndex } from "#app/battle";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import { StatusEffect } from "#enums/status-effect";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Moves - Will-O-Wisp", () => {
+  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.WILL_O_WISP, Moves.SPLASH ])
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset(Moves.SPLASH);
+  });
+
+  it("should burn the opponent", async () => {
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const enemy = game.scene.getEnemyPokemon()!;
+
+    game.move.select(Moves.WILL_O_WISP);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+    await game.move.forceHit();
+    await game.toNextTurn();
+
+    expect(enemy.status?.effect).toBe(StatusEffect.BURN);
+
+    game.move.select(Moves.SPLASH);
+    await game.toNextTurn();
+
+    expect(enemy.status?.effect).toBe(StatusEffect.BURN);
+  });
+});