diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 976c0cd7d97..023a879bdb9 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -5776,20 +5776,21 @@ export class ProtectAttr extends AddBattlerTagAttr { getCondition(): MoveConditionFunc { return ((user, target, move): boolean => { let timesUsed = 0; - const moveHistory = user.getLastXMoves(); - let turnMove: TurnMove | undefined; - while (moveHistory.length) { - turnMove = moveHistory.shift(); - if (!allMoves[turnMove?.move ?? MoveId.NONE].hasAttr(ProtectAttr) || turnMove?.result !== MoveResult.SUCCESS) { + for (const turnMove of user.tempSummonData.waveMoveHistory.slice().reverse()) { + if ( + // Quick & Wide guard increment the Protect counter without using it for fail chance + !(allMoves[turnMove.move].hasAttr(ProtectAttr) || + [MoveId.QUICK_GUARD, MoveId.WIDE_GUARD].includes(turnMove.move)) || + turnMove.result !== MoveResult.SUCCESS + ) { break; } - timesUsed++; + + timesUsed++ } - if (timesUsed) { - return !user.randBattleSeedInt(Math.pow(3, timesUsed)); - } - return true; + + return timesUsed === 0 || user.randBattleSeedInt(Math.pow(3, timesUsed)) === 0; }); } } diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index 71b21076ae6..39ee26fd190 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -4351,6 +4351,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container { } turnMove.turn = globalScene.currentBattle?.turn; this.getMoveHistory().push(turnMove); + this.tempSummonData.waveMoveHistory.push(turnMove) } /** @@ -4941,6 +4942,8 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container { */ resetWaveData(): void { this.waveData = new PokemonWaveData(); + this.tempSummonData.waveTurnCount = 1; + this.tempSummonData.waveMoveHistory = []; } resetTera(): void { @@ -6850,7 +6853,11 @@ export class PokemonSummonData { } } -// TODO: Merge this inside `summmonData` but exclude from save if/when a save data serializer is added +/** + * Pokemon data that is not stored in `SummonData` to avoid being written to the save file. + * + * TODO: Merge this inside `summmonData` but exclude from save if/when a save data serializer is added + */ export class PokemonTempSummonData { /** * The number of turns this pokemon has spent without switching out. @@ -6861,12 +6868,21 @@ export class PokemonTempSummonData { /** * The number of turns this pokemon has spent in the active position since the start of the wave * without switching out. - * Reset on switch and new wave, but not stored in `SummonData` to avoid being written to the save file. - + * Reset on switch and new wave. + * * Used to evaluate "first turn only" conditions such as * {@linkcode MoveId.FAKE_OUT | Fake Out} and {@linkcode MoveId.FIRST_IMPRESSION | First Impression}). */ waveTurnCount = 1; + + /** + * An array containing all moves this Pokemon has used since the start of the wave + * without switching out. + * Reset on switch and new wave. + + * Used to calculate {@link https://bulbapedia.bulbagarden.net/wiki/Protection | Protecting moves}' fail chances. + */ + waveMoveHistory: TurnMove[] = []; } /** diff --git a/src/phases/battle-end-phase.ts b/src/phases/battle-end-phase.ts index e169de58cb3..7f3afb7db7e 100644 --- a/src/phases/battle-end-phase.ts +++ b/src/phases/battle-end-phase.ts @@ -58,12 +58,6 @@ export class BattleEndPhase extends BattlePhase { globalScene.phaseManager.unshiftNew("GameOverPhase", true); } - for (const pokemon of globalScene.getField()) { - if (pokemon) { - pokemon.tempSummonData.waveTurnCount = 1; - } - } - for (const pokemon of globalScene.getPokemonAllowedInBattle()) { applyPostBattleAbAttrs(PostBattleAbAttr, pokemon, false, this.isVictory); } diff --git a/test/moves/baneful_bunker.test.ts b/test/moves/baneful_bunker.test.ts index 80b9b5470b1..a20a23593ef 100644 --- a/test/moves/baneful_bunker.test.ts +++ b/test/moves/baneful_bunker.test.ts @@ -1,5 +1,5 @@ import Phaser from "phaser"; -import { afterEach, beforeAll, beforeEach, describe, expect, test } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest"; import GameManager from "#test/testUtils/gameManager"; import { SpeciesId } from "#enums/species-id"; import { AbilityId } from "#enums/ability-id"; @@ -24,59 +24,53 @@ describe("Moves - Baneful Bunker", () => { beforeEach(() => { game = new GameManager(phaserGame); - game.override.battleStyle("single"); - - game.override.moveset(MoveId.SLASH); - - game.override.enemySpecies(SpeciesId.SNORLAX); - game.override.enemyAbility(AbilityId.INSOMNIA); - game.override.enemyMoveset(MoveId.BANEFUL_BUNKER); - - game.override.startingLevel(100); - game.override.enemyLevel(100); + game.override + .battleStyle("single") + .moveset([MoveId.SLASH, MoveId.FLASH_CANNON]) + .enemySpecies(SpeciesId.TOXAPEX) + .enemyAbility(AbilityId.INSOMNIA) + .enemyMoveset(MoveId.BANEFUL_BUNKER) + .startingLevel(100) + .enemyLevel(100); }); - test("should protect the user and poison attackers that make contact", async () => { - await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; - const enemyPokemon = game.scene.getEnemyPokemon()!; + function expectProtected() { + expect(game.scene.getEnemyPokemon()?.hp).toBe(game.scene.getEnemyPokemon()?.getMaxHp()); + expect(game.scene.getPlayerPokemon()?.status?.effect).toBe(StatusEffect.POISON); + } + + it("should protect the user and poison attackers that make contact", async () => { + await game.classicMode.startBattle([SpeciesId.CHARIZARD]); game.move.select(MoveId.SLASH); await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]); await game.phaseInterceptor.to("BerryPhase", false); - expect(enemyPokemon.hp).toBe(enemyPokemon.getMaxHp()); - expect(leadPokemon.status?.effect === StatusEffect.POISON).toBeTruthy(); + + expectProtected(); }); - test("should protect the user and poison attackers that make contact, regardless of accuracy checks", async () => { + + it("should ignore accuracy checks", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; - const enemyPokemon = game.scene.getEnemyPokemon()!; - game.move.select(MoveId.SLASH); - await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]); - await game.phaseInterceptor.to("MoveEffectPhase"); - + await game.phaseInterceptor.to("MoveEndPhase"); // baneful bunker await game.move.forceMiss(); + await game.phaseInterceptor.to("BerryPhase", false); - expect(enemyPokemon.hp).toBe(enemyPokemon.getMaxHp()); - expect(leadPokemon.status?.effect === StatusEffect.POISON).toBeTruthy(); + + expectProtected(); }); - test("should not poison attackers that don't make contact", async () => { - game.override.moveset(MoveId.FLASH_CANNON); + it("should block non-contact moves without poisoning attackers", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; - const enemyPokemon = game.scene.getEnemyPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; + const toxapex = game.scene.getEnemyPokemon()!; game.move.select(MoveId.FLASH_CANNON); - await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]); - await game.phaseInterceptor.to("MoveEffectPhase"); - - await game.move.forceMiss(); await game.phaseInterceptor.to("BerryPhase", false); - expect(enemyPokemon.hp).toBe(enemyPokemon.getMaxHp()); - expect(leadPokemon.status?.effect === StatusEffect.POISON).toBeFalsy(); + + expect(toxapex.hp).toBe(toxapex.getMaxHp()); + expect(charizard.status?.effect).toBeUndefined(); }); }); diff --git a/test/moves/crafty_shield.test.ts b/test/moves/crafty_shield.test.ts index 01ab0416e5a..40f8ce03829 100644 --- a/test/moves/crafty_shield.test.ts +++ b/test/moves/crafty_shield.test.ts @@ -1,13 +1,14 @@ import Phaser from "phaser"; -import { afterEach, beforeAll, beforeEach, describe, expect, test } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest"; import GameManager from "#test/testUtils/gameManager"; import { SpeciesId } from "#enums/species-id"; import { AbilityId } from "#enums/ability-id"; import { MoveId } from "#enums/move-id"; import { Stat } from "#enums/stat"; import { BattlerTagType } from "#app/enums/battler-tag-type"; -import { BerryPhase } from "#app/phases/berry-phase"; -import { CommandPhase } from "#app/phases/command-phase"; +import { BattlerIndex } from "#app/battle"; +import { ArenaTagType } from "#enums/arena-tag-type"; +import { ArenaTagSide } from "#app/data/arena-tag"; describe("Moves - Crafty Shield", () => { let phaserGame: Phaser.Game; @@ -26,85 +27,103 @@ describe("Moves - Crafty Shield", () => { beforeEach(() => { game = new GameManager(phaserGame); - game.override.battleStyle("double"); - - game.override.moveset([MoveId.CRAFTY_SHIELD, MoveId.SPLASH, MoveId.SWORDS_DANCE]); - - game.override.enemySpecies(SpeciesId.SNORLAX); - game.override.enemyMoveset([MoveId.GROWL]); - game.override.enemyAbility(AbilityId.INSOMNIA); - - game.override.startingLevel(100); - game.override.enemyLevel(100); + game.override + .battleStyle("double") + .moveset([MoveId.CRAFTY_SHIELD, MoveId.SPLASH, MoveId.SWORDS_DANCE, MoveId.HOWL]) + .enemySpecies(SpeciesId.DUSKNOIR) + .enemyMoveset(MoveId.GROWL) + .enemyAbility(AbilityId.INSOMNIA) + .startingLevel(100) + .enemyLevel(100); }); - test("should protect the user and allies from status moves", async () => { + it("should protect the user and allies from status moves", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const leadPokemon = game.scene.getPlayerField(); + const [charizard, blastoise] = game.scene.getPlayerField(); + game.move.select(MoveId.CRAFTY_SHIELD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.GROWL); + await game.move.forceEnemyMove(MoveId.GROWL); - game.move.select(MoveId.CRAFTY_SHIELD); + await game.phaseInterceptor.to("TurnEndPhase"); - await game.phaseInterceptor.to(CommandPhase); - - game.move.select(MoveId.SPLASH, 1); - - await game.phaseInterceptor.to(BerryPhase, false); - - leadPokemon.forEach(p => expect(p.getStatStage(Stat.ATK)).toBe(0)); + expect(charizard.getStatStage(Stat.ATK)).toBe(0); + expect(blastoise.getStatStage(Stat.ATK)).toBe(0); }); - test("should not protect the user and allies from attack moves", async () => { - game.override.enemyMoveset([MoveId.TACKLE]); + it("should not protect the user and allies from attack moves", async () => { + game.override.enemyMoveset(MoveId.TACKLE); + await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); + + const [charizard, blastoise] = game.scene.getPlayerField(); + + game.move.select(MoveId.CRAFTY_SHIELD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.TACKLE, BattlerIndex.PLAYER); + await game.move.forceEnemyMove(MoveId.TACKLE, BattlerIndex.PLAYER_2); + await game.phaseInterceptor.to("TurnEndPhase"); + + expect(charizard.isFullHp()).toBe(false); + expect(blastoise.isFullHp()).toBe(false); + }); + + it("should not block entry hazards and field-targeted moves", async () => { + game.override.enemyMoveset([MoveId.PERISH_SONG, MoveId.TOXIC_SPIKES]); + await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); + + const [charizard, blastoise] = game.scene.getPlayerField(); + + game.move.select(MoveId.CRAFTY_SHIELD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.PERISH_SONG); + await game.move.forceEnemyMove(MoveId.TOXIC_SPIKES); + await game.phaseInterceptor.to("TurnEndPhase"); + + expect(game.scene.arena.getTagOnSide(ArenaTagType.TOXIC_SPIKES, ArenaTagSide.PLAYER)).toBeDefined(); + expect(charizard.getTag(BattlerTagType.PERISH_SONG)).toBeDefined(); + expect(blastoise.getTag(BattlerTagType.PERISH_SONG)).toBeDefined(); + }); + + it("should protect the user and allies from moves that ignore other protection", async () => { + game.override.moveset(MoveId.CURSE); await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const leadPokemon = game.scene.getPlayerField(); + const [charizard, blastoise] = game.scene.getPlayerField(); - game.move.select(MoveId.CRAFTY_SHIELD); + game.move.select(MoveId.CRAFTY_SHIELD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.CURSE, BattlerIndex.PLAYER); + await game.move.forceEnemyMove(MoveId.CURSE, BattlerIndex.PLAYER_2); - await game.phaseInterceptor.to(CommandPhase); + await game.phaseInterceptor.to("TurnEndPhase"); - game.move.select(MoveId.SPLASH, 1); + expect(charizard.getTag(BattlerTagType.CURSED)).toBeDefined(); + expect(blastoise.getTag(BattlerTagType.CURSED)).toBeDefined(); - await game.phaseInterceptor.to(BerryPhase, false); - - expect(leadPokemon.some(p => p.hp < p.getMaxHp())).toBeTruthy(); + const [dusknoir1, dusknoir2] = game.scene.getEnemyField(); + expect(dusknoir1.isFullHp()).toBe(false); + expect(dusknoir2.isFullHp()).toBe(false); }); - test("should protect the user and allies from moves that ignore other protection", async () => { - game.override.enemySpecies(SpeciesId.DUSCLOPS); - game.override.enemyMoveset([MoveId.CURSE]); - + it("should not block allies' self or ally-targeted moves", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const leadPokemon = game.scene.getPlayerField(); + const [charizard, blastoise] = game.scene.getPlayerField(); - game.move.select(MoveId.CRAFTY_SHIELD); + game.move.select(MoveId.CRAFTY_SHIELD, BattlerIndex.PLAYER); + game.move.select(MoveId.SWORDS_DANCE, BattlerIndex.PLAYER_2); + await game.phaseInterceptor.to("TurnEndPhase"); - await game.phaseInterceptor.to(CommandPhase); + expect(charizard.getStatStage(Stat.ATK)).toBe(0); + expect(blastoise.getStatStage(Stat.ATK)).toBe(2); - game.move.select(MoveId.SPLASH, 1); + game.move.select(MoveId.HOWL, BattlerIndex.PLAYER); + game.move.select(MoveId.CRAFTY_SHIELD, BattlerIndex.PLAYER_2); + await game.phaseInterceptor.to("TurnEndPhase"); - await game.phaseInterceptor.to(BerryPhase, false); - - leadPokemon.forEach(p => expect(p.getTag(BattlerTagType.CURSED)).toBeUndefined()); - }); - - test("should not block allies' self-targeted moves", async () => { - await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - - const leadPokemon = game.scene.getPlayerField(); - - game.move.select(MoveId.CRAFTY_SHIELD); - - await game.phaseInterceptor.to(CommandPhase); - - game.move.select(MoveId.SWORDS_DANCE, 1); - - await game.phaseInterceptor.to(BerryPhase, false); - - expect(leadPokemon[0].getStatStage(Stat.ATK)).toBe(0); - expect(leadPokemon[1].getStatStage(Stat.ATK)).toBe(2); + expect(charizard.getStatStage(Stat.ATK)).toBe(1); + expect(blastoise.getStatStage(Stat.ATK)).toBe(3); }); }); diff --git a/test/moves/endure.test.ts b/test/moves/endure.test.ts index 799be22ba45..0ab38f4ad05 100644 --- a/test/moves/endure.test.ts +++ b/test/moves/endure.test.ts @@ -1,9 +1,10 @@ +import { HitResult } from "#app/field/pokemon"; 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 } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; describe("Moves - Endure", () => { let phaserGame: Phaser.Game; @@ -22,7 +23,7 @@ describe("Moves - Endure", () => { beforeEach(() => { game = new GameManager(phaserGame); game.override - .moveset([MoveId.THUNDER, MoveId.BULLET_SEED, MoveId.TOXIC, MoveId.SHEER_COLD]) + .moveset([MoveId.THUNDER, MoveId.BULLET_SEED, MoveId.SHEER_COLD]) .ability(AbilityId.SKILL_LINK) .startingLevel(100) .battleStyle("single") @@ -32,55 +33,55 @@ describe("Moves - Endure", () => { .enemyMoveset(MoveId.ENDURE); }); - it("should let the pokemon survive with 1 HP", async () => { + it("should let the pokemon survive with 1 HP from attacks", async () => { await game.classicMode.startBattle([SpeciesId.ARCEUS]); game.move.select(MoveId.THUNDER); await game.phaseInterceptor.to("BerryPhase"); - expect(game.scene.getEnemyPokemon()!.hp).toBe(1); + const enemy = game.scene.getEnemyPokemon()!; + expect(enemy.hp).toBe(1); }); - it("should let the pokemon survive with 1 HP when hit with a multihit move", async () => { + it("should let the pokemon survive with 1 HP from multi-strike moves", async () => { await game.classicMode.startBattle([SpeciesId.ARCEUS]); game.move.select(MoveId.BULLET_SEED); await game.phaseInterceptor.to("BerryPhase"); - expect(game.scene.getEnemyPokemon()!.hp).toBe(1); + const enemy = game.scene.getEnemyPokemon()!; + expect(enemy.hp).toBe(1); }); it("should let the pokemon survive against OHKO moves", async () => { await game.classicMode.startBattle([SpeciesId.MAGIKARP]); - const enemy = game.scene.getEnemyPokemon()!; game.move.select(MoveId.SHEER_COLD); await game.phaseInterceptor.to("TurnEndPhase"); - expect(enemy.isFainted()).toBeFalsy(); + const enemy = game.scene.getEnemyPokemon()!; + expect(enemy.hp).toBe(1); }); // comprehensive indirect damage test copied from Reviver Seed test it.each([ - { moveType: "Damaging Move Chip Damage", move: MoveId.SALT_CURE }, - { moveType: "Chip Damage", move: MoveId.LEECH_SEED }, - { moveType: "Trapping Chip Damage", move: MoveId.WHIRLPOOL }, - { moveType: "Status Effect Damage", move: MoveId.TOXIC }, + { moveType: "Damaging Move Chip", move: MoveId.SALT_CURE }, + { moveType: "Status Move Chip", move: MoveId.LEECH_SEED }, + { moveType: "Partial Trapping move", move: MoveId.WHIRLPOOL }, + { moveType: "Status Effect", move: MoveId.TOXIC }, { moveType: "Weather", move: MoveId.SANDSTORM }, - ])("should not prevent fainting from $moveType", async ({ move }) => { - game.override - .enemyLevel(1) - .startingLevel(100) - .enemySpecies(SpeciesId.MAGIKARP) - .moveset(move) - .enemyMoveset(MoveId.ENDURE); + ])("should not prevent fainting from $moveType Damage", async ({ move }) => { + game.override.moveset(move).enemyLevel(100); await game.classicMode.startBattle([SpeciesId.MAGIKARP, SpeciesId.FEEBAS]); + const enemy = game.scene.getEnemyPokemon()!; - enemy.damageAndUpdate(enemy.hp - 1); + enemy.hp = 2; + // force attack to do 1 dmg (for salt cure) + vi.spyOn(enemy, "getAttackDamage").mockReturnValue({ cancelled: false, result: HitResult.EFFECTIVE, damage: 1 }); game.move.select(move); await game.phaseInterceptor.to("TurnEndPhase"); - expect(enemy.isFainted()).toBeTruthy(); + expect(enemy.isFainted()).toBe(true); }); }); diff --git a/test/moves/protect.test.ts b/test/moves/protect.test.ts index 519021023fa..1ab31b67c58 100644 --- a/test/moves/protect.test.ts +++ b/test/moves/protect.test.ts @@ -1,14 +1,13 @@ import Phaser from "phaser"; -import { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import GameManager from "#test/testUtils/gameManager"; import { SpeciesId } from "#enums/species-id"; import { AbilityId } from "#enums/ability-id"; import { MoveId } from "#enums/move-id"; import { Stat } from "#enums/stat"; -import { allMoves } from "#app/data/data-lists"; -import { ArenaTagSide, ArenaTrapTag } from "#app/data/arena-tag"; -import { BattlerIndex } from "#app/battle"; import { MoveResult } from "#app/field/pokemon"; +import { BattlerIndex } from "#app/battle"; +import { allMoves } from "#app/data/data-lists"; describe("Moves - Protect", () => { let phaserGame: Phaser.Game; @@ -26,92 +25,205 @@ describe("Moves - Protect", () => { beforeEach(() => { game = new GameManager(phaserGame); - - game.override.battleStyle("single"); - - game.override.moveset([MoveId.PROTECT]); - game.override.enemySpecies(SpeciesId.SNORLAX); - - game.override.enemyAbility(AbilityId.INSOMNIA); - game.override.enemyMoveset([MoveId.TACKLE]); - - game.override.startingLevel(100); - game.override.enemyLevel(100); + game.override + .battleStyle("single") + .moveset([MoveId.PROTECT, MoveId.SPIKY_SHIELD, MoveId.ENDURE, MoveId.SPLASH]) + .enemySpecies(SpeciesId.SNORLAX) + .enemyAbility(AbilityId.INSOMNIA) + .enemyMoveset(MoveId.LUMINA_CRASH) + .startingLevel(100) + .enemyLevel(100); }); - test("should protect the user from attacks", async () => { + it("should protect the user from attacks and their secondary effects", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; game.move.select(MoveId.PROTECT); - await game.phaseInterceptor.to("BerryPhase", false); - expect(leadPokemon.hp).toBe(leadPokemon.getMaxHp()); + expect(charizard.hp).toBe(charizard.getMaxHp()); + expect(charizard.getStatStage(Stat.SPDEF)).toBe(0); + expect(charizard); }); - test("should prevent secondary effects from the opponent's attack", async () => { - game.override.enemyMoveset([MoveId.CEASELESS_EDGE]); - vi.spyOn(allMoves[MoveId.CEASELESS_EDGE], "accuracy", "get").mockReturnValue(100); - + it.each<{ numTurns: number; chance: number }>([ + { numTurns: 1, chance: 3 }, + { numTurns: 2, chance: 9 }, + { numTurns: 3, chance: 27 }, + { numTurns: 4, chance: 81 }, + ])("should have a 1/$chance success rate after $numTurns successful uses", async ({ numTurns, chance }) => { await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; + + // mock RNG roll to suceed unless exactly the desired chance is hit + vi.spyOn(charizard, "randBattleSeedInt").mockImplementation(range => (range !== chance ? 0 : 1)); + const conditionSpy = vi.spyOn(allMoves[MoveId.PROTECT]["conditions"][0], "apply"); + + // click protect many times + for (let x = 0; x < numTurns; x++) { + game.move.select(MoveId.PROTECT); + await game.toNextTurn(); + + expect(charizard.hp).toBe(charizard.getMaxHp()); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + expect(conditionSpy).toHaveLastReturnedWith(true); + } game.move.select(MoveId.PROTECT); + await game.toNextTurn(); - await game.phaseInterceptor.to("BerryPhase", false); - - expect(leadPokemon.hp).toBe(leadPokemon.getMaxHp()); - expect(game.scene.arena.getTagOnSide(ArenaTrapTag, ArenaTagSide.ENEMY)).toBeUndefined(); + expect(charizard.hp).toBeLessThan(charizard.getMaxHp()); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.FAIL); + expect(conditionSpy).toHaveLastReturnedWith(false); }); - test("should protect the user from status moves", async () => { - game.override.enemyMoveset([MoveId.CHARM]); - + it("should share fail chance with all move variants", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; + charizard.tempSummonData.waveMoveHistory = [ + { move: MoveId.ENDURE, result: MoveResult.SUCCESS, targets: [BattlerIndex.PLAYER] }, + { move: MoveId.SPIKY_SHIELD, result: MoveResult.SUCCESS, targets: [BattlerIndex.PLAYER] }, + ]; + // force protect to fail on anything >=2 uses (1/9 chance) + vi.spyOn(charizard, "randBattleSeedInt").mockImplementation(range => (range >= 9 ? 1 : 0)); game.move.select(MoveId.PROTECT); + await game.toNextTurn(); - await game.phaseInterceptor.to("BerryPhase", false); - - expect(leadPokemon.getStatStage(Stat.ATK)).toBe(0); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.FAIL); }); - test("should stop subsequent hits of a multi-hit move", async () => { + it("should reset fail chance on move failure", async () => { + await game.classicMode.startBattle([SpeciesId.CHARIZARD]); + + const charizard = game.scene.getPlayerPokemon()!; + // force protect to always fail if RNG roll attempt is made + vi.spyOn(charizard, "randBattleSeedInt").mockReturnValue(1); + + game.move.select(MoveId.PROTECT); + await game.toNextTurn(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + + game.move.select(MoveId.SPIKY_SHIELD); + await game.toNextTurn(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.FAIL); + + game.move.select(MoveId.SPIKY_SHIELD); + await game.toNextTurn(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + }); + + it("should reset fail chance on using another move", async () => { + await game.classicMode.startBattle([SpeciesId.CHARIZARD]); + + const charizard = game.scene.getPlayerPokemon()!; + // force protect to always fail if RNG roll attempt is made + vi.spyOn(charizard, "randBattleSeedInt").mockReturnValue(1); + + game.move.select(MoveId.PROTECT); + await game.toNextTurn(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + + game.move.select(MoveId.SPLASH); + await game.toNextTurn(); + + game.move.select(MoveId.PROTECT); + await game.toNextTurn(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + }); + + it("should reset fail chance on starting a new wave", async () => { + await game.classicMode.startBattle([SpeciesId.CHARIZARD]); + + const charizard = game.scene.getPlayerPokemon()!; + // force protect to always fail if RNG roll attempt is made + vi.spyOn(charizard, "randBattleSeedInt").mockReturnValue(1); + + game.move.select(MoveId.PROTECT); + // Wait until move end phase to kill opponent to ensure protect doesn't fail due to going last + await game.phaseInterceptor.to("MoveEndPhase"); + await game.doKillOpponents(); + await game.toNextWave(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + + game.move.select(MoveId.SPIKY_SHIELD); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + }); + + it("should not be blocked by Psychic Terrain", async () => { + game.override.ability(AbilityId.PSYCHIC_SURGE); + await game.classicMode.startBattle([SpeciesId.CHARIZARD]); + + const charizard = game.scene.getPlayerPokemon()!; + game.move.select(MoveId.PROTECT); + await game.toNextTurn(); + + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + }); + + it("should stop subsequent hits of multi-hit moves", async () => { game.override.enemyMoveset([MoveId.TACHYON_CUTTER]); - await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; const enemyPokemon = game.scene.getEnemyPokemon()!; game.move.select(MoveId.PROTECT); - await game.phaseInterceptor.to("BerryPhase", false); - expect(leadPokemon.hp).toBe(leadPokemon.getMaxHp()); + expect(charizard.hp).toBe(charizard.getMaxHp()); expect(enemyPokemon.turnData.hitCount).toBe(1); }); - test("should fail if the user is the last to move in the turn", async () => { - game.override.enemyMoveset([MoveId.PROTECT]); - + it("should fail if the user moves last in the turn", async () => { + game.override.enemyMoveset(MoveId.PROTECT); await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const leadPokemon = game.scene.getPlayerPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; const enemyPokemon = game.scene.getEnemyPokemon()!; game.move.select(MoveId.PROTECT); - await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]); - await game.phaseInterceptor.to("BerryPhase", false); expect(enemyPokemon.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); - expect(leadPokemon.getLastXMoves()[0].result).toBe(MoveResult.FAIL); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.FAIL); }); + + it("should not block Protection-bypassing moves or Future Sight", async () => { + game.override.enemyMoveset([MoveId.FUTURE_SIGHT, MoveId.MIGHTY_CLEAVE, MoveId.SPORE]); + await game.classicMode.startBattle([SpeciesId.AGGRON]); + + const aggron = game.scene.getPlayerPokemon()!; + vi.spyOn(aggron, "randBattleSeedInt").mockReturnValue(0); + + // Turn 1: setup future sight + game.move.select(MoveId.PROTECT); + await game.move.forceEnemyMove(MoveId.FUTURE_SIGHT); + await game.toNextTurn(); + + // Turn 2: mighty cleave + game.move.select(MoveId.PROTECT); + await game.move.forceEnemyMove(MoveId.MIGHTY_CLEAVE); + await game.toNextTurn(); + + expect(aggron.hp).toBeLessThan(aggron.getMaxHp()); + + aggron.hp = aggron.getMaxHp(); + + // turn 3: Future Sight hits + game.move.select(MoveId.PROTECT); + await game.move.forceEnemyMove(MoveId.SPORE); + await game.toNextTurn(); + + expect(aggron.hp).toBeLessThan(aggron.getMaxHp()); + expect(aggron.status?.effect).toBeUndefined(); // check that protect actually worked + }); + + // TODO: Add test + it.todo("should not reset counter when throwing balls"); }); diff --git a/test/moves/quick_guard.test.ts b/test/moves/quick_guard.test.ts index 0c0ab8d6ad0..786a61dc937 100644 --- a/test/moves/quick_guard.test.ts +++ b/test/moves/quick_guard.test.ts @@ -1,10 +1,9 @@ import Phaser from "phaser"; -import { afterEach, beforeAll, beforeEach, describe, expect, test } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import GameManager from "#test/testUtils/gameManager"; import { SpeciesId } from "#enums/species-id"; import { AbilityId } from "#enums/ability-id"; import { MoveId } from "#enums/move-id"; -import { Stat } from "#enums/stat"; import { BattlerIndex } from "#app/battle"; import { MoveResult } from "#app/field/pokemon"; @@ -25,80 +24,74 @@ describe("Moves - Quick Guard", () => { beforeEach(() => { game = new GameManager(phaserGame); - game.override.battleStyle("double"); - - game.override.moveset([MoveId.QUICK_GUARD, MoveId.SPLASH, MoveId.FOLLOW_ME]); - - game.override.enemySpecies(SpeciesId.SNORLAX); - game.override.enemyMoveset([MoveId.QUICK_ATTACK]); - game.override.enemyAbility(AbilityId.INSOMNIA); - - game.override.startingLevel(100); - game.override.enemyLevel(100); + game.override + .battleStyle("double") + .moveset([MoveId.QUICK_GUARD, MoveId.SPLASH, MoveId.SPIKY_SHIELD]) + .enemySpecies(SpeciesId.SNORLAX) + .enemyMoveset(MoveId.QUICK_ATTACK) + .enemyAbility(AbilityId.BALL_FETCH) + .startingLevel(100) + .enemyLevel(100); }); - test("should protect the user and allies from priority moves", async () => { + it("should protect the user and allies from priority moves", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const playerPokemon = game.scene.getPlayerField(); - - game.move.select(MoveId.QUICK_GUARD); - game.move.select(MoveId.SPLASH, 1); + const [charizard, blastoise] = game.scene.getPlayerField(); + game.move.select(MoveId.QUICK_GUARD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.QUICK_ATTACK, BattlerIndex.PLAYER); + await game.move.forceEnemyMove(MoveId.QUICK_ATTACK, BattlerIndex.PLAYER_2); await game.phaseInterceptor.to("BerryPhase", false); - playerPokemon.forEach(p => expect(p.hp).toBe(p.getMaxHp())); + expect(charizard.hp).toBe(charizard.getMaxHp()); + expect(blastoise.hp).toBe(blastoise.getMaxHp()); }); - test("should protect the user and allies from Prankster-boosted moves", async () => { - game.override.enemyAbility(AbilityId.PRANKSTER); - game.override.enemyMoveset([MoveId.GROWL]); - + it.each<{ name: string; move: MoveId; ability: AbilityId }>([ + { name: "Prankster", move: MoveId.SPORE, ability: AbilityId.PRANKSTER }, + { name: "Gale Wings", move: MoveId.BRAVE_BIRD, ability: AbilityId.GALE_WINGS }, + ])("should protect the user and allies from $name-boosted moves", async ({ move, ability }) => { + game.override.enemyMoveset(move).enemyAbility(ability); await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const playerPokemon = game.scene.getPlayerField(); - - game.move.select(MoveId.QUICK_GUARD); - game.move.select(MoveId.SPLASH, 1); + const [charizard, blastoise] = game.scene.getPlayerField(); + game.move.select(MoveId.QUICK_GUARD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(move, BattlerIndex.PLAYER); + await game.move.forceEnemyMove(move, BattlerIndex.PLAYER_2); await game.phaseInterceptor.to("BerryPhase", false); - playerPokemon.forEach(p => expect(p.getStatStage(Stat.ATK)).toBe(0)); + expect(charizard.hp).toBe(charizard.getMaxHp()); + expect(blastoise.hp).toBe(blastoise.getMaxHp()); + expect(charizard.status?.effect).toBeUndefined(); + expect(blastoise.status?.effect).toBeUndefined(); }); - test("should stop subsequent hits of a multi-hit priority move", async () => { - game.override.enemyMoveset([MoveId.WATER_SHURIKEN]); - - await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - - const playerPokemon = game.scene.getPlayerField(); - const enemyPokemon = game.scene.getEnemyField(); - - game.move.select(MoveId.QUICK_GUARD); - game.move.select(MoveId.FOLLOW_ME, 1); - - await game.phaseInterceptor.to("BerryPhase", false); - - playerPokemon.forEach(p => expect(p.hp).toBe(p.getMaxHp())); - enemyPokemon.forEach(p => expect(p.turnData.hitCount).toBe(1)); - }); - - test("should fail if the user is the last to move in the turn", async () => { + it("should increment (but not respect) other protection moves' fail counters", async () => { game.override.battleStyle("single"); - game.override.enemyMoveset([MoveId.QUICK_GUARD]); - await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - const playerPokemon = game.scene.getPlayerPokemon()!; - const enemyPokemon = game.scene.getEnemyPokemon()!; + const charizard = game.scene.getPlayerPokemon()!; + // force protect to fail on anything >0 uses + vi.spyOn(charizard, "randBattleSeedInt").mockReturnValue(1); game.move.select(MoveId.QUICK_GUARD); + await game.toNextTurn(); - await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); - await game.phaseInterceptor.to("BerryPhase", false); + game.move.select(MoveId.QUICK_GUARD); + await game.toNextTurn(); - expect(enemyPokemon.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); - expect(playerPokemon.getLastXMoves()[0].result).toBe(MoveResult.FAIL); + // ignored fail chance + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + + game.move.select(MoveId.SPIKY_SHIELD); + await game.toNextTurn(); + + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.FAIL); }); }); diff --git a/test/moves/wide_guard.test.ts b/test/moves/wide_guard.test.ts index 65c3a0a805f..bd89582370e 100644 --- a/test/moves/wide_guard.test.ts +++ b/test/moves/wide_guard.test.ts @@ -1,12 +1,12 @@ import Phaser from "phaser"; -import { afterEach, beforeAll, beforeEach, describe, expect, test } from "vitest"; +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; import GameManager from "#test/testUtils/gameManager"; import { SpeciesId } from "#enums/species-id"; import { AbilityId } from "#enums/ability-id"; import { MoveId } from "#enums/move-id"; import { Stat } from "#enums/stat"; -import { BerryPhase } from "#app/phases/berry-phase"; -import { CommandPhase } from "#app/phases/command-phase"; +import { BattlerIndex } from "#app/battle"; +import { MoveResult } from "#app/field/pokemon"; describe("Moves - Wide Guard", () => { let phaserGame: Phaser.Game; @@ -25,87 +25,86 @@ describe("Moves - Wide Guard", () => { beforeEach(() => { game = new GameManager(phaserGame); - game.override.battleStyle("double"); - - game.override.moveset([MoveId.WIDE_GUARD, MoveId.SPLASH, MoveId.SURF]); - - game.override.enemySpecies(SpeciesId.SNORLAX); - game.override.enemyMoveset([MoveId.SWIFT]); - game.override.enemyAbility(AbilityId.INSOMNIA); - - game.override.startingLevel(100); - game.override.enemyLevel(100); + game.override + .battleStyle("double") + .moveset([MoveId.WIDE_GUARD, MoveId.SPLASH, MoveId.SURF, MoveId.SPIKY_SHIELD]) + .enemySpecies(SpeciesId.SNORLAX) + .enemyMoveset([MoveId.SWIFT, MoveId.GROWL, MoveId.TACKLE]) + .enemyAbility(AbilityId.INSOMNIA) + .startingLevel(100) + .enemyLevel(100); }); - test("should protect the user and allies from multi-target attack moves", async () => { + it("should protect the user and allies from multi-target attack and status moves", async () => { + await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); + const [charizard, blastoise] = game.scene.getPlayerField(); + + game.move.select(MoveId.WIDE_GUARD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.SWIFT); + await game.move.forceEnemyMove(MoveId.GROWL); + await game.phaseInterceptor.to("TurnEndPhase"); + + expect(charizard.hp).toBe(charizard.getMaxHp()); + expect(blastoise.hp).toBe(blastoise.getMaxHp()); + expect(charizard.getStatStage(Stat.ATK)).toBe(0); + expect(blastoise.getStatStage(Stat.ATK)).toBe(0); + }); + + it("should not protect the user and allies from single-target moves", async () => { await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const leadPokemon = game.scene.getPlayerField(); + const [charizard, blastoise] = game.scene.getPlayerField(); + game.move.select(MoveId.WIDE_GUARD, BattlerIndex.PLAYER); + game.move.select(MoveId.SPLASH, BattlerIndex.PLAYER_2); + await game.move.forceEnemyMove(MoveId.TACKLE, BattlerIndex.PLAYER); + await game.move.forceEnemyMove(MoveId.TACKLE, BattlerIndex.PLAYER_2); + await game.phaseInterceptor.to("TurnEndPhase"); - game.move.select(MoveId.WIDE_GUARD); - - await game.phaseInterceptor.to(CommandPhase); - - game.move.select(MoveId.SPLASH, 1); - - await game.phaseInterceptor.to(BerryPhase, false); - - leadPokemon.forEach(p => expect(p.hp).toBe(p.getMaxHp())); + expect(charizard.hp).toBeLessThan(charizard.getMaxHp()); + expect(blastoise.hp).toBeLessThan(blastoise.getMaxHp()); }); - test("should protect the user and allies from multi-target status moves", async () => { - game.override.enemyMoveset([MoveId.GROWL]); + it("should protect the user from its ally's multi-target move", async () => { + game.override.enemyMoveset(MoveId.SPLASH); await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - const leadPokemon = game.scene.getPlayerField(); + const charizard = game.scene.getPlayerPokemon()!; + const [snorlax1, snorlax2] = game.scene.getEnemyField(); - game.move.select(MoveId.WIDE_GUARD); + game.move.select(MoveId.WIDE_GUARD, BattlerIndex.PLAYER); + game.move.select(MoveId.SURF, BattlerIndex.PLAYER_2); + await game.phaseInterceptor.to("TurnEndPhase"); - await game.phaseInterceptor.to(CommandPhase); - - game.move.select(MoveId.SPLASH, 1); - - await game.phaseInterceptor.to(BerryPhase, false); - - leadPokemon.forEach(p => expect(p.getStatStage(Stat.ATK)).toBe(0)); + expect(charizard.hp).toBe(charizard.getMaxHp()); + expect(snorlax1.hp).toBeLessThan(snorlax1.getMaxHp()); + expect(snorlax2.hp).toBeLessThan(snorlax2.getMaxHp()); }); - test("should not protect the user and allies from single-target moves", async () => { - game.override.enemyMoveset([MoveId.TACKLE]); + it("should increment (but not respect) other protection moves' fail counters", async () => { + game.override.battleStyle("single"); + await game.classicMode.startBattle([SpeciesId.CHARIZARD]); - await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - - const leadPokemon = game.scene.getPlayerField(); + const charizard = game.scene.getPlayerPokemon()!; + // force protect to fail on anything other than a guaranteed success + vi.spyOn(charizard, "randBattleSeedInt").mockReturnValue(1); game.move.select(MoveId.WIDE_GUARD); + await game.toNextTurn(); - await game.phaseInterceptor.to(CommandPhase); - - game.move.select(MoveId.SPLASH, 1); - - await game.phaseInterceptor.to(BerryPhase, false); - - expect(leadPokemon.some(p => p.hp < p.getMaxHp())).toBeTruthy(); - }); - - test("should protect the user from its ally's multi-target move", async () => { - game.override.enemyMoveset([MoveId.SPLASH]); - - await game.classicMode.startBattle([SpeciesId.CHARIZARD, SpeciesId.BLASTOISE]); - - const leadPokemon = game.scene.getPlayerField(); - const enemyPokemon = game.scene.getEnemyField(); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); + // ignored fail chance game.move.select(MoveId.WIDE_GUARD); + await game.toNextTurn(); - await game.phaseInterceptor.to(CommandPhase); + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS); - game.move.select(MoveId.SURF, 1); + game.move.select(MoveId.SPIKY_SHIELD); + await game.toNextTurn(); - await game.phaseInterceptor.to(BerryPhase, false); - - expect(leadPokemon[0].hp).toBe(leadPokemon[0].getMaxHp()); - enemyPokemon.forEach(p => expect(p.hp).toBeLessThan(p.getMaxHp())); + // ignored fail chance + expect(charizard.getLastXMoves()[0].result).toBe(MoveResult.FAIL); }); });