From b5d77c3d159a284834d1359d17fc92b15de8d649 Mon Sep 17 00:00:00 2001 From: "Amani H." <109637146+xsn34kzx@users.noreply.github.com> Date: Mon, 29 Jul 2024 17:32:02 -0400 Subject: [PATCH] [Move] Implement Fusion Flare and Fusion Bolt (#1774) --- src/data/move.ts | 72 ++++- src/field/pokemon.ts | 1 + src/phases.ts | 3 + src/test/moves/fusion_bolt.test.ts | 54 ++++ src/test/moves/fusion_flare.test.ts | 60 +++++ src/test/moves/fusion_flare_bolt.test.ts | 323 +++++++++++++++++++++++ 6 files changed, 510 insertions(+), 3 deletions(-) create mode 100644 src/test/moves/fusion_bolt.test.ts create mode 100644 src/test/moves/fusion_flare.test.ts create mode 100644 src/test/moves/fusion_flare_bolt.test.ts diff --git a/src/data/move.ts b/src/data/move.ts index 431ffb0bae4..4cc146ff99a 100644 --- a/src/data/move.ts +++ b/src/data/move.ts @@ -3406,6 +3406,72 @@ export class MultiHitPowerIncrementAttr extends VariablePowerAttr { } } +/** + * Attribute used for moves that double in power if the given move immediately + * preceded the move applying the attribute, namely Fusion Flare and + * Fusion Bolt. + * @extends VariablePowerAttr + * @see {@linkcode apply} + */ +export class LastMoveDoublePowerAttr extends VariablePowerAttr { + /** The move that must precede the current move */ + private move: Moves; + + constructor(move: Moves) { + super(); + + this.move = move; + } + + /** + * Doubles power of move if the given move is found to precede the current + * move with no other moves being executed in between, only ignoring failed + * moves if any. + * @param user {@linkcode Pokemon} that used the move + * @param target N/A + * @param move N/A + * @param args [0] {@linkcode Utils.NumberHolder} that holds the resulting power of the move + * @returns true if attribute application succeeds, false otherwise + */ + apply(user: Pokemon, _target: Pokemon, _move: Move, args: any[]): boolean { + const power = args[0] as Utils.NumberHolder; + const enemy = user.getOpponent(0); + const pokemonActed: Pokemon[] = []; + + if (enemy.turnData.acted) { + pokemonActed.push(enemy); + } + + if (user.scene.currentBattle.double) { + const userAlly = user.getAlly(); + const enemyAlly = enemy.getAlly(); + + if (userAlly && userAlly.turnData.acted) { + pokemonActed.push(userAlly); + } + if (enemyAlly && enemyAlly.turnData.acted) { + pokemonActed.push(enemyAlly); + } + } + + pokemonActed.sort((a, b) => b.turnData.order - a.turnData.order); + + for (const p of pokemonActed) { + const [ lastMove ] = p.getLastXMoves(1); + if (lastMove.result !== MoveResult.FAIL) { + if ((lastMove.result === MoveResult.SUCCESS) && (lastMove.move === this.move)) { + power.value *= 2; + return true; + } else { + break; + } + } + } + + return false; + } +} + export class VariableAtkAttr extends MoveAttr { constructor() { super(); @@ -7419,10 +7485,10 @@ export function initMoves() { .attr(StatChangeAttr, [ BattleStat.DEF, BattleStat.SPDEF, BattleStat.SPD ], -1, true), new AttackMove(Moves.FUSION_FLARE, Type.FIRE, MoveCategory.SPECIAL, 100, 100, 5, -1, 0, 5) .attr(HealStatusEffectAttr, true, StatusEffect.FREEZE) - .partial(), + .attr(LastMoveDoublePowerAttr, Moves.FUSION_BOLT), new AttackMove(Moves.FUSION_BOLT, Type.ELECTRIC, MoveCategory.PHYSICAL, 100, 100, 5, -1, 0, 5) - .makesContact(false) - .partial(), + .attr(LastMoveDoublePowerAttr, Moves.FUSION_FLARE) + .makesContact(false), new AttackMove(Moves.FLYING_PRESS, Type.FIGHTING, MoveCategory.PHYSICAL, 100, 95, 10, -1, 0, 6) .attr(MinimizeAccuracyAttr) .attr(FlyingTypeMultiplierAttr) diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index 8d6277da7f4..f151aef2751 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -4062,6 +4062,7 @@ export class PokemonTurnData { public currDamageDealt: integer = 0; public damageTaken: integer = 0; public attacksReceived: AttackMoveResult[] = []; + public order: number; } export enum AiType { diff --git a/src/phases.ts b/src/phases.ts index ceefc34ba17..fad95951c26 100644 --- a/src/phases.ts +++ b/src/phases.ts @@ -2314,6 +2314,8 @@ export class TurnStartPhase extends FieldPhase { return aIndex < bIndex ? -1 : aIndex > bIndex ? 1 : 0; }); + let orderIndex = 0; + for (const o of moveOrder) { const pokemon = field[o]; @@ -2326,6 +2328,7 @@ export class TurnStartPhase extends FieldPhase { switch (turnCommand.command) { case Command.FIGHT: const queuedMove = turnCommand.move; + pokemon.turnData.order = orderIndex++; if (!queuedMove) { continue; } diff --git a/src/test/moves/fusion_bolt.test.ts b/src/test/moves/fusion_bolt.test.ts new file mode 100644 index 00000000000..368c75b0f54 --- /dev/null +++ b/src/test/moves/fusion_bolt.test.ts @@ -0,0 +1,54 @@ +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import overrides from "#app/overrides"; +import { getMovePosition } from "#app/test/utils/gameManagerUtils"; +import { Species } from "#enums/species"; +import { Moves } from "#enums/moves"; +import { Abilities } from "#enums/abilities"; + +describe("Moves - Fusion Bolt", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + const fusionBolt = Moves.FUSION_BOLT; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([ fusionBolt ]); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(1); + + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RESHIRAM); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.ROUGH_SKIN); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([ Moves.SPLASH, Moves.SPLASH, Moves.SPLASH, Moves.SPLASH ]); + + vi.spyOn(overrides, "BATTLE_TYPE_OVERRIDE", "get").mockReturnValue("single"); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(97); + vi.spyOn(overrides, "NEVER_CRIT_OVERRIDE", "get").mockReturnValue(true); + }); + + it("should not make contact", async() => { + await game.startBattle([ + Species.ZEKROM, + ]); + + const partyMember = game.scene.getPlayerPokemon(); + const initialHp = partyMember.hp; + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt)); + + await game.toNextTurn(); + + expect(initialHp - partyMember.hp).toBe(0); + }, 20000); +}); diff --git a/src/test/moves/fusion_flare.test.ts b/src/test/moves/fusion_flare.test.ts new file mode 100644 index 00000000000..5ccbd82d25e --- /dev/null +++ b/src/test/moves/fusion_flare.test.ts @@ -0,0 +1,60 @@ +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import overrides from "#app/overrides"; +import { TurnStartPhase } from "#app/phases"; +import { getMovePosition } from "#app/test/utils/gameManagerUtils"; +import { StatusEffect } from "#app/data/status-effect"; +import { Species } from "#enums/species"; +import { Moves } from "#enums/moves"; + +describe("Moves - Fusion Flare", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + const fusionFlare = Moves.FUSION_FLARE; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([ fusionFlare ]); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(1); + + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RESHIRAM); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([ Moves.REST, Moves.REST, Moves.REST, Moves.REST ]); + + vi.spyOn(overrides, "BATTLE_TYPE_OVERRIDE", "get").mockReturnValue("single"); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(97); + vi.spyOn(overrides, "NEVER_CRIT_OVERRIDE", "get").mockReturnValue(true); + }); + + it("should thaw freeze status condition", async() => { + await game.startBattle([ + Species.RESHIRAM, + ]); + + const partyMember = game.scene.getPlayerPokemon(); + + game.doAttack(getMovePosition(game.scene, 0, fusionFlare)); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Inflict freeze quietly and check if it was properly inflicted + partyMember.trySetStatus(StatusEffect.FREEZE, false); + expect(partyMember.status.effect).toBe(StatusEffect.FREEZE); + + await game.toNextTurn(); + + // Check if FUSION_FLARE thawed freeze + expect(partyMember.status?.effect).toBeUndefined(); + }); +}); diff --git a/src/test/moves/fusion_flare_bolt.test.ts b/src/test/moves/fusion_flare_bolt.test.ts new file mode 100644 index 00000000000..83c7c0e5993 --- /dev/null +++ b/src/test/moves/fusion_flare_bolt.test.ts @@ -0,0 +1,323 @@ +import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import overrides from "#app/overrides"; +import { MoveEffectPhase, MovePhase, MoveEndPhase, TurnStartPhase, DamagePhase } from "#app/phases"; +import { getMovePosition } from "#app/test/utils/gameManagerUtils"; +import { Stat } from "#app/data/pokemon-stat"; +import { allMoves } from "#app/data/move"; +import { BattlerIndex } from "#app/battle"; +import { Species } from "#enums/species"; +import { Moves } from "#enums/moves"; + +describe("Moves - Fusion Flare and Fusion Bolt", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + const fusionFlare = allMoves[Moves.FUSION_FLARE]; + const fusionBolt = allMoves[Moves.FUSION_BOLT]; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([ fusionFlare.id, fusionBolt.id ]); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(1); + + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RESHIRAM); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([ Moves.REST, Moves.REST, Moves.REST, Moves.REST ]); + + vi.spyOn(overrides, "BATTLE_TYPE_OVERRIDE", "get").mockReturnValue("double"); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(97); + vi.spyOn(overrides, "NEVER_CRIT_OVERRIDE", "get").mockReturnValue(true); + + vi.spyOn(fusionFlare, "calculateBattlePower"); + vi.spyOn(fusionBolt, "calculateBattlePower"); + }); + + it("FUSION_FLARE should double power of subsequent FUSION_BOLT", async() => { + await game.startBattle([ + Species.ZEKROM, + Species.ZEKROM + ]); + + game.doAttack(getMovePosition(game.scene, 0, fusionFlare.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force user party to act before enemy party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(200); + }, 20000); + + it("FUSION_BOLT should double power of subsequent FUSION_FLARE", async() => { + await game.startBattle([ + Species.ZEKROM, + Species.ZEKROM + ]); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + game.doAttack(getMovePosition(game.scene, 0, fusionFlare.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force user party to act before enemy party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(200); + }, 20000); + + it("FUSION_FLARE should double power of subsequent FUSION_BOLT if a move failed in between", async() => { + await game.startBattle([ + Species.ZEKROM, + Species.ZEKROM + ]); + + game.doAttack(getMovePosition(game.scene, 0, fusionFlare.id)); + game.doSelectTarget(0); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(0); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force first enemy to act (and fail) in between party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEndPhase); + + // Skip enemy move; because the enemy is at full HP, Rest should fail + await game.phaseInterceptor.runFrom(MovePhase).to(MoveEndPhase); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(200); + }, 20000); + + it("FUSION_FLARE should not double power of subsequent FUSION_BOLT if a move succeeded in between", async() => { + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([ Moves.SPLASH, Moves.SPLASH, Moves.SPLASH, Moves.SPLASH ]); + await game.startBattle([ + Species.ZEKROM, + Species.ZEKROM + ]); + + game.doAttack(getMovePosition(game.scene, 0, fusionFlare.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force first enemy to act in between party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEndPhase); + // Skip enemy move + await game.phaseInterceptor.runFrom(MovePhase).to(MoveEndPhase); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(100); + }, 20000); + + it("FUSION_FLARE should double power of subsequent FUSION_BOLT if moves are aimed at allies", async() => { + await game.startBattle([ + Species.ZEKROM, + Species.RESHIRAM + ]); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.PLAYER_2); + + game.doAttack(getMovePosition(game.scene, 0, fusionFlare.id)); + game.doSelectTarget(BattlerIndex.PLAYER); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force user party to act before enemy party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(200); + }, 20000); + + it("FUSION_FLARE and FUSION_BOLT alternating throughout turn should double power of subsequent moves", async() => { + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([ fusionFlare.id, fusionFlare.id, fusionFlare.id, fusionFlare.id ]); + await game.startBattle([ + Species.ZEKROM, + Species.ZEKROM + ]); + + const party = game.scene.getParty(); + const enemyParty = game.scene.getEnemyParty(); + + // Get rid of any modifiers that may alter power + game.scene.clearEnemyHeldItemModifiers(); + game.scene.clearEnemyModifiers(); + + // Mock stats by replacing entries in copy with desired values for specific stats + const stats = { + enemy: [ + [...enemyParty[0].stats], + [...enemyParty[1].stats], + ], + player: [ + [...party[0].stats], + [...party[1].stats], + ] + }; + + // Ensure survival by reducing enemy Sp. Atk and boosting party Sp. Def + vi.spyOn(enemyParty[0], "stats", "get").mockReturnValue(stats.enemy[0].map((val, i) => (i === Stat.SPATK ? 1 : val))); + vi.spyOn(enemyParty[1], "stats", "get").mockReturnValue(stats.enemy[1].map((val, i) => (i === Stat.SPATK ? 1 : val))); + vi.spyOn(party[1], "stats", "get").mockReturnValue(stats.player[0].map((val, i) => (i === Stat.SPDEF ? 250 : val))); + vi.spyOn(party[1], "stats", "get").mockReturnValue(stats.player[1].map((val, i) => (i === Stat.SPDEF ? 250 : val))); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.ENEMY); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force first enemy to act in between party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(200); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(200); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(200); + }, 20000); + + it("FUSION_FLARE and FUSION_BOLT alternating throughout turn should double power of subsequent moves if moves are aimed at allies", async() => { + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([ fusionFlare.id, fusionFlare.id, fusionFlare.id, fusionFlare.id ]); + await game.startBattle([ + Species.ZEKROM, + Species.ZEKROM + ]); + + const party = game.scene.getParty(); + const enemyParty = game.scene.getEnemyParty(); + + // Get rid of any modifiers that may alter power + game.scene.clearEnemyHeldItemModifiers(); + game.scene.clearEnemyModifiers(); + + // Mock stats by replacing entries in copy with desired values for specific stats + const stats = { + enemy: [ + [...enemyParty[0].stats], + [...enemyParty[1].stats], + ], + player: [ + [...party[0].stats], + [...party[1].stats], + ] + }; + + // Ensure survival by reducing enemy Sp. Atk and boosting party Sp. Def + vi.spyOn(enemyParty[0], "stats", "get").mockReturnValue(stats.enemy[0].map((val, i) => (i === Stat.SPATK ? 1 : val))); + vi.spyOn(enemyParty[1], "stats", "get").mockReturnValue(stats.enemy[1].map((val, i) => (i === Stat.SPATK ? 1 : val))); + vi.spyOn(party[1], "stats", "get").mockReturnValue(stats.player[0].map((val, i) => (i === Stat.SPDEF ? 250 : val))); + vi.spyOn(party[1], "stats", "get").mockReturnValue(stats.player[1].map((val, i) => (i === Stat.SPDEF ? 250 : val))); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.PLAYER_2); + + game.doAttack(getMovePosition(game.scene, 0, fusionBolt.id)); + game.doSelectTarget(BattlerIndex.PLAYER); + + await game.phaseInterceptor.to(TurnStartPhase, false); + + // Force first enemy to act in between party + vi.spyOn(game.scene.getCurrentPhase() as TurnStartPhase, "getOrder").mockReturnValue([ BattlerIndex.PLAYER, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY ]); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(100); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(200); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionBolt.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionBolt.calculateBattlePower).toHaveLastReturnedWith(200); + + await game.phaseInterceptor.to(MoveEffectPhase, false); + expect((game.scene.getCurrentPhase() as MoveEffectPhase).move.moveId).toBe(fusionFlare.id); + await game.phaseInterceptor.to(DamagePhase, false); + expect(fusionFlare.calculateBattlePower).toHaveLastReturnedWith(200); + }, 20000); +});