diff --git a/src/battle-scene.ts b/src/battle-scene.ts index cce26a5adf6..df827f5201c 100644 --- a/src/battle-scene.ts +++ b/src/battle-scene.ts @@ -159,7 +159,7 @@ export default class BattleScene extends SceneBase { public gameData: GameData; public sessionSlotId: integer; - private phaseQueue: Phase[]; + public phaseQueue: Phase[]; private phaseQueuePrepend: Phase[]; private phaseQueuePrependSpliceIndex: integer; private nextCommandPhaseQueue: Phase[]; @@ -201,7 +201,7 @@ export default class BattleScene extends SceneBase { public arenaFlyout: ArenaFlyout; private fieldOverlay: Phaser.GameObjects.Rectangle; - private modifiers: PersistentModifier[]; + public modifiers: PersistentModifier[]; private enemyModifiers: PersistentModifier[]; public uiContainer: Phaser.GameObjects.Container; public ui: UI; @@ -300,7 +300,8 @@ export default class BattleScene extends SceneBase { this.fieldSpritePipeline = new FieldSpritePipeline(this.game); (this.renderer as Phaser.Renderer.WebGL.WebGLRenderer).pipelines.add("FieldSprite", this.fieldSpritePipeline); - this.time.delayedCall(20, () => this.launchBattle()); + + this.launchBattle(); } update() { @@ -947,7 +948,8 @@ export default class BattleScene extends SceneBase { } newBattle(waveIndex?: integer, battleType?: BattleType, trainerData?: TrainerData, double?: boolean): Battle { - const newWaveIndex = waveIndex || ((this.currentBattle?.waveIndex || (startingWave - 1)) + 1); + const _startingWave = Overrides.STARTING_WAVE_OVERRIDE || startingWave; + const newWaveIndex = waveIndex || ((this.currentBattle?.waveIndex || (_startingWave - 1)) + 1); let newDouble: boolean; let newBattleType: BattleType; let newTrainer: Trainer; @@ -1007,6 +1009,9 @@ export default class BattleScene extends SceneBase { if (Overrides.DOUBLE_BATTLE_OVERRIDE) { newDouble = true; } + if (Overrides.SINGLE_BATTLE_OVERRIDE) { + newDouble = false; + } const lastBattle = this.currentBattle; diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index 65742d18b94..ff277fc865b 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -1727,6 +1727,9 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container { } const critChance = [24, 8, 2, 1][Math.max(0, Math.min(critLevel.value, 3))]; isCritical = !source.getTag(BattlerTagType.NO_CRIT) && (critChance === 1 || !this.scene.randBattleSeedInt(critChance)); + if (Overrides.NEVER_CRIT_OVERRIDE) { + isCritical = false; + } } if (isCritical) { const blockCrit = new Utils.BooleanHolder(false); diff --git a/src/inputs-controller.ts b/src/inputs-controller.ts index ac5d339c048..3ef8fa24115 100644 --- a/src/inputs-controller.ts +++ b/src/inputs-controller.ts @@ -94,7 +94,6 @@ export class InputsController { private buttonLock: Button; private interactions: Map> = new Map(); - private time: Phaser.Time.Clock; private configs: Map = new Map(); public gamepadSupport: boolean = true; @@ -121,7 +120,6 @@ export class InputsController { constructor(scene: BattleScene) { this.scene = scene; - this.time = this.scene.time; this.selectedDevice = { [Device.GAMEPAD]: null, [Device.KEYBOARD]: "default" @@ -246,6 +244,9 @@ export class InputsController { * If an interaction is valid and should be processed, it emits an 'input_down' event with details of the interaction. */ update(): void { + if (this.pauseUpdate) { + return; + } for (const b of Utils.getEnumValues(Button).reverse()) { if ( this.interactions.hasOwnProperty(b) && @@ -256,8 +257,7 @@ export class InputsController { if ( (!this.gamepadSupport && this.interactions[b].source === "gamepad") || (this.interactions[b].source === "gamepad" && this.interactions[b].sourceName && this.interactions[b].sourceName !== this.selectedDevice[Device.GAMEPAD]) || - (this.interactions[b].source === "keyboard" && this.interactions[b].sourceName && this.interactions[b].sourceName !== this.selectedDevice[Device.KEYBOARD]) || - this.pauseUpdate + (this.interactions[b].source === "keyboard" && this.interactions[b].sourceName && this.interactions[b].sourceName !== this.selectedDevice[Device.KEYBOARD]) ) { // Deletes the last interaction for a button if gamepad is disabled. this.delLastProcessedMovementTime(b as Button); @@ -548,7 +548,8 @@ export class InputsController { if (!this.isButtonLocked(button)) { return false; } - if (this.time.now - this.interactions[button].pressTime >= repeatInputDelayMillis) { + const duration = Date.now() - this.interactions[button].pressTime; + if (duration >= repeatInputDelayMillis) { return true; } } @@ -573,7 +574,7 @@ export class InputsController { return; } this.setButtonLock(button); - this.interactions[button].pressTime = this.time.now; + this.interactions[button].pressTime = Date.now(); this.interactions[button].isPressed = true; this.interactions[button].source = source; this.interactions[button].sourceName = sourceName.toLowerCase(); @@ -633,7 +634,7 @@ export class InputsController { this.interactions[b].sourceName = null; } } - setTimeout(() => this.pauseUpdate = false, 500); + this.pauseUpdate = false; } /** diff --git a/src/loading-scene.ts b/src/loading-scene.ts index 5713bf69fde..8bb811e3d9b 100644 --- a/src/loading-scene.ts +++ b/src/loading-scene.ts @@ -16,6 +16,7 @@ import {initPokemonForms} from "#app/data/pokemon-forms"; import {initSpecies} from "#app/data/pokemon-species"; import {initMoves} from "#app/data/move"; import {initAbilities} from "#app/data/ability"; +import {initAchievements} from "#app/system/achv"; import {initTrainerTypeDialogue} from "#app/data/dialogue"; import i18next from "i18next"; import { initStatsKeys } from "./ui/game-stats-ui-handler"; @@ -328,6 +329,7 @@ export class LoadingScene extends SceneBase { this.loadLoadingScreen(); + initAchievements(); initStatsKeys(); initPokemonPrevolutions(); initBiomes(); diff --git a/src/overrides.ts b/src/overrides.ts index 148dc352ae9..f8e3152de98 100644 --- a/src/overrides.ts +++ b/src/overrides.ts @@ -29,6 +29,7 @@ import { modifierTypes } from "./modifier/modifier-type"; export const SEED_OVERRIDE: string = ""; export const WEATHER_OVERRIDE: WeatherType = WeatherType.NONE; export const DOUBLE_BATTLE_OVERRIDE: boolean = false; +export const SINGLE_BATTLE_OVERRIDE: boolean = false; export const STARTING_WAVE_OVERRIDE: integer = 0; export const STARTING_BIOME_OVERRIDE: Biome = Biome.TOWN; export const ARENA_TINT_OVERRIDE: TimeOfDay = null; @@ -110,6 +111,7 @@ export const OPP_MODIFIER_OVERRIDE: Array = []; export const STARTING_HELD_ITEMS_OVERRIDE: Array = []; export const OPP_HELD_ITEMS_OVERRIDE: Array = []; +export const NEVER_CRIT_OVERRIDE: boolean = false; /** * An array of items by keys as defined in the "modifierTypes" object in the "modifier/modifier-type.ts" file. diff --git a/src/phases.ts b/src/phases.ts index ac38796784b..a235349cd6f 100644 --- a/src/phases.ts +++ b/src/phases.ts @@ -149,7 +149,7 @@ export class LoginPhase extends Phase { export class TitlePhase extends Phase { private loaded: boolean; private lastSessionData: SessionSaveData; - private gameMode: GameModes; + public gameMode: GameModes; constructor(scene: BattleScene) { super(scene); @@ -527,60 +527,63 @@ export class SelectStarterPhase extends Phase { return this.end(); } this.scene.sessionSlotId = slotId; - - const party = this.scene.getParty(); - const loadPokemonAssets: Promise[] = []; - starters.forEach((starter: Starter, i: integer) => { - if (!i && Overrides.STARTER_SPECIES_OVERRIDE) { - starter.species = getPokemonSpecies(Overrides.STARTER_SPECIES_OVERRIDE as Species); - } - const starterProps = this.scene.gameData.getSpeciesDexAttrProps(starter.species, starter.dexAttr); - let starterFormIndex = Math.min(starterProps.formIndex, Math.max(starter.species.forms.length - 1, 0)); - if (!i && Overrides.STARTER_SPECIES_OVERRIDE) { - starterFormIndex = Overrides.STARTER_FORM_OVERRIDE; - } - let starterGender = starter.species.malePercent !== null - ? !starterProps.female ? Gender.MALE : Gender.FEMALE - : Gender.GENDERLESS; - if (Overrides.GENDER_OVERRIDE !== null) { - starterGender = Overrides.GENDER_OVERRIDE; - } - const starterIvs = this.scene.gameData.dexData[starter.species.speciesId].ivs.slice(0); - const starterPokemon = this.scene.addPlayerPokemon(starter.species, this.scene.gameMode.getStartingLevel(), starter.abilityIndex, starterFormIndex, starterGender, starterProps.shiny, starterProps.variant, starterIvs, starter.nature); - starterPokemon.tryPopulateMoveset(starter.moveset); - if (starter.passive) { - starterPokemon.passive = true; - } - starterPokemon.luck = this.scene.gameData.getDexAttrLuck(this.scene.gameData.dexData[starter.species.speciesId].caughtAttr); - if (starter.pokerus) { - starterPokemon.pokerus = true; - } - if (this.scene.gameMode.isSplicedOnly) { - starterPokemon.generateFusionSpecies(true); - } - starterPokemon.setVisible(false); - party.push(starterPokemon); - loadPokemonAssets.push(starterPokemon.loadAssets()); - }); - overrideModifiers(this.scene); - overrideHeldItems(this.scene, party[0]); - Promise.all(loadPokemonAssets).then(() => { - SoundFade.fadeOut(this.scene, this.scene.sound.get("menu"), 500, true); - this.scene.time.delayedCall(500, () => this.scene.playBgm()); - if (this.scene.gameMode.isClassic) { - this.scene.gameData.gameStats.classicSessionsPlayed++; - } else { - this.scene.gameData.gameStats.endlessSessionsPlayed++; - } - this.scene.newBattle(); - this.scene.arena.init(); - this.scene.sessionPlayTime = 0; - this.scene.lastSavePlayTime = 0; - this.end(); - }); + this.initBattle(starters); }); }, this.gameMode); } + + initBattle(starters: Starter[]) { + const party = this.scene.getParty(); + const loadPokemonAssets: Promise[] = []; + starters.forEach((starter: Starter, i: integer) => { + if (!i && Overrides.STARTER_SPECIES_OVERRIDE) { + starter.species = getPokemonSpecies(Overrides.STARTER_SPECIES_OVERRIDE as Species); + } + const starterProps = this.scene.gameData.getSpeciesDexAttrProps(starter.species, starter.dexAttr); + let starterFormIndex = Math.min(starterProps.formIndex, Math.max(starter.species.forms.length - 1, 0)); + if (!i && Overrides.STARTER_SPECIES_OVERRIDE) { + starterFormIndex = Overrides.STARTER_FORM_OVERRIDE; + } + let starterGender = starter.species.malePercent !== null + ? !starterProps.female ? Gender.MALE : Gender.FEMALE + : Gender.GENDERLESS; + if (Overrides.GENDER_OVERRIDE !== null) { + starterGender = Overrides.GENDER_OVERRIDE; + } + const starterIvs = this.scene.gameData.dexData[starter.species.speciesId].ivs.slice(0); + const starterPokemon = this.scene.addPlayerPokemon(starter.species, this.scene.gameMode.getStartingLevel(), starter.abilityIndex, starterFormIndex, starterGender, starterProps.shiny, starterProps.variant, starterIvs, starter.nature); + starterPokemon.tryPopulateMoveset(starter.moveset); + if (starter.passive) { + starterPokemon.passive = true; + } + starterPokemon.luck = this.scene.gameData.getDexAttrLuck(this.scene.gameData.dexData[starter.species.speciesId].caughtAttr); + if (starter.pokerus) { + starterPokemon.pokerus = true; + } + if (this.scene.gameMode.isSplicedOnly) { + starterPokemon.generateFusionSpecies(true); + } + starterPokemon.setVisible(false); + party.push(starterPokemon); + loadPokemonAssets.push(starterPokemon.loadAssets()); + }); + overrideModifiers(this.scene); + overrideHeldItems(this.scene, party[0]); + Promise.all(loadPokemonAssets).then(() => { + SoundFade.fadeOut(this.scene, this.scene.sound.get("menu"), 500, true); + this.scene.time.delayedCall(500, () => this.scene.playBgm()); + if (this.scene.gameMode.isClassic) { + this.scene.gameData.gameStats.classicSessionsPlayed++; + } else { + this.scene.gameData.gameStats.endlessSessionsPlayed++; + } + this.scene.newBattle(); + this.scene.arena.init(); + this.scene.sessionPlayTime = 0; + this.scene.lastSavePlayTime = 0; + this.end(); + }); + } } export class BattlePhase extends Phase { diff --git a/src/system/achv.ts b/src/system/achv.ts index f52d547a53f..364b7e0c579 100644 --- a/src/system/achv.ts +++ b/src/system/achv.ts @@ -40,6 +40,10 @@ export class Achv { return i18next.t(`achv:${this.localizationKey}.name`); } + getDescription(): string { + return this.description; + } + getIconImage(): string { return this.iconImage; } @@ -259,14 +263,12 @@ export const achvs = { CLASSIC_VICTORY: new Achv("CLASSIC_VICTORY","", "CLASSIC_VICTORY.description", "relic_crown", 150), }; -{ - (function() { - const achvKeys = Object.keys(achvs); - achvKeys.forEach((a: string, i: integer) => { - achvs[a].id = a; - if (achvs[a].hasParent) { - achvs[a].parentId = achvKeys[i - 1]; - } - }); - })(); +export function initAchievements() { + const achvKeys = Object.keys(achvs); + achvKeys.forEach((a: string, i: integer) => { + achvs[a].id = a; + if (achvs[a].hasParent) { + achvs[a].parentId = achvKeys[i - 1]; + } + }); } diff --git a/src/system/game-data.ts b/src/system/game-data.ts index 8ed7f521507..c5e2cd6eb91 100644 --- a/src/system/game-data.ts +++ b/src/system/game-data.ts @@ -60,13 +60,13 @@ export function getDataTypeKey(dataType: GameDataType, slotId: integer = 0): str } } -function encrypt(data: string, bypassLogin: boolean): string { +export function encrypt(data: string, bypassLogin: boolean): string { return (bypassLogin ? (data: string) => btoa(data) : (data: string) => AES.encrypt(data, saveKey))(data); } -function decrypt(data: string, bypassLogin: boolean): string { +export function decrypt(data: string, bypassLogin: boolean): string { return (bypassLogin ? (data: string) => atob(data) : (data: string) => AES.decrypt(data, saveKey).toString(enc.Utf8))(data); @@ -493,7 +493,7 @@ export class GameData { }); } - private parseSystemData(dataStr: string): SystemSaveData { + parseSystemData(dataStr: string): SystemSaveData { return JSON.parse(dataStr, (k: string, v: any) => { if (k === "gameStats") { return new GameStats(v); @@ -512,7 +512,7 @@ export class GameData { }) as SystemSaveData; } - private convertSystemDataStr(dataStr: string, shorten: boolean = false): string { + convertSystemDataStr(dataStr: string, shorten: boolean = false): string { if (!shorten) { // Account for past key oversight dataStr = dataStr.replace(/\$pAttr/g, "$pa"); diff --git a/src/test/abilities/intimidate.test.ts b/src/test/abilities/intimidate.test.ts new file mode 100644 index 00000000000..b8a1d65088f --- /dev/null +++ b/src/test/abilities/intimidate.test.ts @@ -0,0 +1,83 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + CheckSwitchPhase, CommandPhase, MessagePhase, + PostSummonPhase, + ShinySparklePhase, + ShowAbilityPhase, + StatChangePhase, + SummonPhase, + ToggleDoublePositionPhase, TurnInitPhase +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {BattleStat} from "#app/data/battle-stat"; + + +describe("Abilities - Intimidate", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.MIGHTYENA); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INTIMIDATE); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INTIMIDATE); + }); + + it("INTIMIDATE", async() => { + await game.runToSummon([ + Species.MIGHTYENA, + Species.MIGHTYENA, + ]); + await game.phaseInterceptor.run(PostSummonPhase); + + + expect(game.scene.getParty()[0].summonData).not.toBeUndefined(); + let battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[BattleStat.ATK]).toBe(0); + await game.phaseInterceptor.run(ShowAbilityPhase); + await game.phaseInterceptor.run(StatChangePhase); + battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[BattleStat.ATK]).toBe(-1); + + + await game.phaseInterceptor.run(SummonPhase); + await game.phaseInterceptor.run(ShinySparklePhase, () => game.isCurrentPhase(ToggleDoublePositionPhase)); + await game.phaseInterceptor.run(ToggleDoublePositionPhase); + game.onNextPrompt("CheckSwitchPhase", Mode.CONFIRM, () => { + game.setMode(Mode.MESSAGE); + game.endPhase(); + }); + await game.phaseInterceptor.run(CheckSwitchPhase); + await game.phaseInterceptor.run(PostSummonPhase); + + + let battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.ATK]).toBe(0); + await game.phaseInterceptor.run(ShowAbilityPhase); + game.scene.moveAnimations = null; // Mandatory to avoid crash + await game.phaseInterceptor.run(StatChangePhase); + battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.ATK]).toBe(-1); + + + await game.phaseInterceptor.run(MessagePhase); + await game.phaseInterceptor.run(TurnInitPhase); + await game.phaseInterceptor.run(CommandPhase); + }, 20000); +}); diff --git a/src/test/abilities/intrepid_sword.test.ts b/src/test/abilities/intrepid_sword.test.ts new file mode 100644 index 00000000000..f2e8eeb12cb --- /dev/null +++ b/src/test/abilities/intrepid_sword.test.ts @@ -0,0 +1,65 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + MessagePhase, + PostSummonPhase, + ShowAbilityPhase, + StatChangePhase, + ToggleDoublePositionPhase +} from "#app/phases"; +import {BattleStat} from "#app/data/battle-stat"; + + +describe("Abilities - Intrepid Sword", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.ZACIAN); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INTREPID_SWORD); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INTREPID_SWORD); + }); + + it("INTREPID SWORD on player", async() => { + await game.runToSummon([ + Species.ZACIAN, + ]); + await game.phaseInterceptor.runFrom(PostSummonPhase).to(PostSummonPhase); + expect(game.scene.getParty()[0].summonData).not.toBeUndefined(); + let battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[BattleStat.ATK]).toBe(0); + await game.phaseInterceptor.mustRun(ShowAbilityPhase).catch((error) => expect(error).toBe(ShowAbilityPhase)); + await game.phaseInterceptor.mustRun(StatChangePhase).catch((error) => expect(error).toBe(StatChangePhase)); + battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[BattleStat.ATK]).toBe(1); + }, 20000); + + it("INTREPID SWORD on opponent", async() => { + await game.runToSummon([ + Species.ZACIAN, + ]); + let battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.ATK]).toBe(0); + await game.phaseInterceptor.runFrom(PostSummonPhase).to(ToggleDoublePositionPhase); + await game.phaseInterceptor.mustRun(StatChangePhase).catch((error) => expect(error).toBe(StatChangePhase)); + await game.phaseInterceptor.whenAboutToRun(MessagePhase); + battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.ATK]).toBe(1); + }, 20000); +}); diff --git a/src/test/abilities/moxie.test.ts b/src/test/abilities/moxie.test.ts new file mode 100644 index 00000000000..ed27c670c87 --- /dev/null +++ b/src/test/abilities/moxie.test.ts @@ -0,0 +1,67 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + CommandPhase, + EnemyCommandPhase, + VictoryPhase +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {Stat} from "#app/data/pokemon-stat"; +import {Moves} from "#app/data/enums/moves"; +import {getMovePosition} from "#app/test/utils/gameManagerUtils"; +import {Command} from "#app/ui/command-ui-handler"; +import {BattleStat} from "#app/data/battle-stat"; + + +describe("Abilities - Moxie", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + const moveToUse = Moves.AERIAL_ACE; + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RATTATA); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.MOXIE); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.MOXIE); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(2000); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([moveToUse]); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TACKLE,Moves.TACKLE,Moves.TACKLE,Moves.TACKLE]); + }); + + it("MOXIE", async() => { + const moveToUse = Moves.AERIAL_ACE; + await game.startBattle([ + Species.MIGHTYENA, + Species.MIGHTYENA, + ]); + + let battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[Stat.ATK]).toBe(0); + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, moveToUse); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.runFrom(EnemyCommandPhase).to(VictoryPhase); + battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[BattleStat.ATK]).toBe(1); + }, 20000); +}); diff --git a/src/test/achievement.test.ts b/src/test/achievement.test.ts deleted file mode 100644 index c33707cf5b2..00000000000 --- a/src/test/achievement.test.ts +++ /dev/null @@ -1,9 +0,0 @@ -import { MoneyAchv } from "#app/system/achv"; -import { describe, expect, it } from "vitest"; - -describe("check some Achievement related stuff", () => { - it ("should check Achievement creation", () => { - const ach = new MoneyAchv("", "Achievement", 1000, null, 100); - expect(ach.name).toBe("Achievement"); - }); -}); diff --git a/src/test/achievements/achievement.test.ts b/src/test/achievements/achievement.test.ts new file mode 100644 index 00000000000..f24529187c6 --- /dev/null +++ b/src/test/achievements/achievement.test.ts @@ -0,0 +1,274 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import {MoneyAchv, Achv, AchvTier, RibbonAchv, DamageAchv, HealAchv, LevelAchv, ModifierAchv, achvs} from "#app/system/achv"; +import BattleScene from "../../battle-scene"; +import { IntegerHolder, NumberHolder } from "#app/utils.js"; +import { TurnHeldItemTransferModifier } from "#app/modifier/modifier.js"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; + +describe("check some Achievement related stuff", () => { + it ("should check Achievement creation", () => { + const ach = new MoneyAchv("", "Achievement", 1000, null, 100); + expect(ach.name).toBe("Achievement"); + }); +}); + + +describe("Achv", () => { + let achv: Achv; + + beforeEach(() => { + achv = new Achv("", "Test Achievement", "This is a test achievement", "test_icon", 10); + }); + + it("should have the correct name", () => { + expect(achv.getDescription()).toBe("This is a test achievement"); + }); + + it("should have the correct icon image", () => { + expect(achv.getIconImage()).toBe("test_icon"); + }); + + it("should set the achievement as secret", () => { + achv.setSecret(); + expect(achv.secret).toBe(true); + expect(achv.hasParent).toBe(false); + + achv.setSecret(true); + expect(achv.secret).toBe(true); + expect(achv.hasParent).toBe(true); + + achv.setSecret(false); + expect(achv.secret).toBe(true); + expect(achv.hasParent).toBe(false); + }); + + it("should return the correct tier based on the score", () => { + const achv1 = new Achv("", "Test Achievement 1", "Test Description", "test_icon", 10); + const achv2 = new Achv("", "Test Achievement 2", "Test Description", "test_icon", 25); + const achv3 = new Achv("", "Test Achievement 3", "Test Description", "test_icon", 50); + const achv4 = new Achv("", "Test Achievement 4", "Test Description", "test_icon", 75); + const achv5 = new Achv("", "Test Achievement 5", "Test Description", "test_icon", 100); + + expect(achv1.getTier()).toBe(AchvTier.COMMON); + expect(achv2.getTier()).toBe(AchvTier.GREAT); + expect(achv3.getTier()).toBe(AchvTier.ULTRA); + expect(achv4.getTier()).toBe(AchvTier.ROGUE); + expect(achv5.getTier()).toBe(AchvTier.MASTER); + }); + + it("should validate the achievement based on the condition function", () => { + const conditionFunc = jest.fn((scene: BattleScene, args: any[]) => args[0] === 10); + const achv = new Achv("", "Test Achievement", "Test Description", "test_icon", 10, conditionFunc); + + expect(achv.validate(new BattleScene(), [5])).toBe(false); + expect(achv.validate(new BattleScene(), [10])).toBe(true); + expect(conditionFunc).toHaveBeenCalledTimes(2); + }); +}); + +describe("MoneyAchv", () => { + it("should create an instance of MoneyAchv", () => { + const moneyAchv = new MoneyAchv("", "Test Money Achievement", 10000, "money_icon", 10); + expect(moneyAchv).toBeInstanceOf(MoneyAchv); + expect(moneyAchv instanceof Achv).toBe(true); + }); + + it("should validate the achievement based on the money amount", () => { + const moneyAchv = new MoneyAchv("", "Test Money Achievement", 10000, "money_icon", 10); + const scene = new BattleScene(); + scene.money = 5000; + + expect(moneyAchv.validate(scene, [])).toBe(false); + + scene.money = 15000; + expect(moneyAchv.validate(scene, [])).toBe(true); + }); +}); + +describe("RibbonAchv", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + let scene: BattleScene; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + vi.spyOn(overrides, "STARTER_SPECIES_OVERRIDE", "get").mockReturnValue(0); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(0); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(0); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(0); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([]); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([]); + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(false); + vi.spyOn(overrides, "DOUBLE_BATTLE_OVERRIDE", "get").mockReturnValue(false); + game = new GameManager(phaserGame); + scene = game.scene; + }); + + it("should create an instance of RibbonAchv", () => { + const ribbonAchv = new RibbonAchv("", "Test Ribbon Achievement", 10, "ribbon_icon", 10); + expect(ribbonAchv).toBeInstanceOf(RibbonAchv); + expect(ribbonAchv instanceof Achv).toBe(true); + }); + + it("should validate the achievement based on the ribbon amount", () => { + const ribbonAchv = new RibbonAchv("", "Test Ribbon Achievement", 10, "ribbon_icon", 10); + scene.gameData.gameStats.ribbonsOwned = 5; + + expect(ribbonAchv.validate(scene, [])).toBe(false); + + scene.gameData.gameStats.ribbonsOwned = 15; + expect(ribbonAchv.validate(scene, [])).toBe(true); + }); +}); + +describe("DamageAchv", () => { + it("should create an instance of DamageAchv", () => { + const damageAchv = new DamageAchv("", "Test Damage Achievement", 250, "damage_icon", 10); + expect(damageAchv).toBeInstanceOf(DamageAchv); + expect(damageAchv instanceof Achv).toBe(true); + }); + + it("should validate the achievement based on the damage amount", () => { + const damageAchv = new DamageAchv("", "Test Damage Achievement", 250, "damage_icon", 10); + const scene = new BattleScene(); + const numberHolder = new NumberHolder(200); + + expect(damageAchv.validate(scene, [numberHolder])).toBe(false); + + numberHolder.value = 300; + expect(damageAchv.validate(scene, [numberHolder])).toBe(true); + }); +}); + +describe("HealAchv", () => { + it("should create an instance of HealAchv", () => { + const healAchv = new HealAchv("", "Test Heal Achievement", 250, "heal_icon", 10); + expect(healAchv).toBeInstanceOf(HealAchv); + expect(healAchv instanceof Achv).toBe(true); + }); + + it("should validate the achievement based on the heal amount", () => { + const healAchv = new HealAchv("", "Test Heal Achievement", 250, "heal_icon", 10); + const scene = new BattleScene(); + const numberHolder = new NumberHolder(200); + + expect(healAchv.validate(scene, [numberHolder])).toBe(false); + + numberHolder.value = 300; + expect(healAchv.validate(scene, [numberHolder])).toBe(true); + }); +}); + +describe("LevelAchv", () => { + it("should create an instance of LevelAchv", () => { + const levelAchv = new LevelAchv("", "Test Level Achievement", 100, "level_icon", 10); + expect(levelAchv).toBeInstanceOf(LevelAchv); + expect(levelAchv instanceof Achv).toBe(true); + }); + + it("should validate the achievement based on the level", () => { + const levelAchv = new LevelAchv("", "Test Level Achievement", 100, "level_icon", 10); + const scene = new BattleScene(); + const integerHolder = new IntegerHolder(50); + + expect(levelAchv.validate(scene, [integerHolder])).toBe(false); + + integerHolder.value = 150; + expect(levelAchv.validate(scene, [integerHolder])).toBe(true); + }); +}); + +describe("ModifierAchv", () => { + it("should create an instance of ModifierAchv", () => { + const modifierAchv = new ModifierAchv("", "Test Modifier Achievement", "Test Description", "modifier_icon", 10, () => true); + expect(modifierAchv).toBeInstanceOf(ModifierAchv); + expect(modifierAchv instanceof Achv).toBe(true); + }); + + it("should validate the achievement based on the modifier function", () => { + const modifierAchv = new ModifierAchv("", "Test Modifier Achievement", "Test Description", "modifier_icon", 10, () => true); + const scene = new BattleScene(); + const modifier = new TurnHeldItemTransferModifier(null, 3, 1); + + expect(modifierAchv.validate(scene, [modifier])).toBe(true); + }); +}); + +describe("achvs", () => { + it("should contain the predefined achievements", () => { + expect(achvs._10K_MONEY).toBeInstanceOf(MoneyAchv); + expect(achvs._100K_MONEY).toBeInstanceOf(MoneyAchv); + expect(achvs._1M_MONEY).toBeInstanceOf(MoneyAchv); + expect(achvs._10M_MONEY).toBeInstanceOf(MoneyAchv); + expect(achvs._250_DMG).toBeInstanceOf(DamageAchv); + expect(achvs._1000_DMG).toBeInstanceOf(DamageAchv); + expect(achvs._2500_DMG).toBeInstanceOf(DamageAchv); + expect(achvs._10000_DMG).toBeInstanceOf(DamageAchv); + expect(achvs._250_HEAL).toBeInstanceOf(HealAchv); + expect(achvs._1000_HEAL).toBeInstanceOf(HealAchv); + expect(achvs._2500_HEAL).toBeInstanceOf(HealAchv); + expect(achvs._10000_HEAL).toBeInstanceOf(HealAchv); + expect(achvs.LV_100).toBeInstanceOf(LevelAchv); + expect(achvs.LV_250).toBeInstanceOf(LevelAchv); + expect(achvs.LV_1000).toBeInstanceOf(LevelAchv); + expect(achvs._10_RIBBONS).toBeInstanceOf(RibbonAchv); + expect(achvs._25_RIBBONS).toBeInstanceOf(RibbonAchv); + expect(achvs._50_RIBBONS).toBeInstanceOf(RibbonAchv); + expect(achvs._75_RIBBONS).toBeInstanceOf(RibbonAchv); + expect(achvs._100_RIBBONS).toBeInstanceOf(RibbonAchv); + expect(achvs.TRANSFER_MAX_BATTLE_STAT).toBeInstanceOf(Achv); + expect(achvs.MAX_FRIENDSHIP).toBeInstanceOf(Achv); + expect(achvs.MEGA_EVOLVE).toBeInstanceOf(Achv); + expect(achvs.GIGANTAMAX).toBeInstanceOf(Achv); + expect(achvs.TERASTALLIZE).toBeInstanceOf(Achv); + expect(achvs.STELLAR_TERASTALLIZE).toBeInstanceOf(Achv); + expect(achvs.SPLICE).toBeInstanceOf(Achv); + expect(achvs.MINI_BLACK_HOLE).toBeInstanceOf(ModifierAchv); + expect(achvs.CATCH_MYTHICAL).toBeInstanceOf(Achv); + expect(achvs.CATCH_SUB_LEGENDARY).toBeInstanceOf(Achv); + expect(achvs.CATCH_LEGENDARY).toBeInstanceOf(Achv); + expect(achvs.SEE_SHINY).toBeInstanceOf(Achv); + expect(achvs.SHINY_PARTY).toBeInstanceOf(Achv); + expect(achvs.HATCH_MYTHICAL).toBeInstanceOf(Achv); + expect(achvs.HATCH_SUB_LEGENDARY).toBeInstanceOf(Achv); + expect(achvs.HATCH_LEGENDARY).toBeInstanceOf(Achv); + expect(achvs.HATCH_SHINY).toBeInstanceOf(Achv); + expect(achvs.HIDDEN_ABILITY).toBeInstanceOf(Achv); + expect(achvs.PERFECT_IVS).toBeInstanceOf(Achv); + expect(achvs.CLASSIC_VICTORY).toBeInstanceOf(Achv); + }); + + it("should initialize the achievements with IDs and parent IDs", () => { + + expect(achvs._10K_MONEY.id).toBe("_10K_MONEY"); + expect(achvs._10K_MONEY.hasParent).toBe(undefined); + expect(achvs._100K_MONEY.id).toBe("_100K_MONEY"); + expect(achvs._100K_MONEY.hasParent).toBe(true); + expect(achvs._100K_MONEY.parentId).toBe("_10K_MONEY"); + expect(achvs._1M_MONEY.id).toBe("_1M_MONEY"); + expect(achvs._1M_MONEY.hasParent).toBe(true); + expect(achvs._1M_MONEY.parentId).toBe("_100K_MONEY"); + expect(achvs._10M_MONEY.id).toBe("_10M_MONEY"); + expect(achvs._10M_MONEY.hasParent).toBe(true); + expect(achvs._10M_MONEY.parentId).toBe("_1M_MONEY"); + expect(achvs.LV_100.id).toBe("LV_100"); + expect(achvs.LV_100.hasParent).toBe(false); + expect(achvs.LV_250.id).toBe("LV_250"); + expect(achvs.LV_250.hasParent).toBe(true); + expect(achvs.LV_250.parentId).toBe("LV_100"); + expect(achvs.LV_1000.id).toBe("LV_1000"); + expect(achvs.LV_1000.hasParent).toBe(true); + expect(achvs.LV_1000.parentId).toBe("LV_250"); + }); +}); diff --git a/src/test/battle/battle-order.test.ts b/src/test/battle/battle-order.test.ts new file mode 100644 index 00000000000..e481150fafe --- /dev/null +++ b/src/test/battle/battle-order.test.ts @@ -0,0 +1,220 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + CommandPhase, EnemyCommandPhase, + TurnStartPhase +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {getMovePosition} from "#app/test/utils/gameManagerUtils"; +import {Moves} from "#app/data/enums/moves"; +import {Command} from "#app/ui/command-ui-handler"; +import {Stat} from "#app/data/pokemon-stat"; +import TargetSelectUiHandler from "#app/ui/target-select-ui-handler"; +import {Button} from "#app/enums/buttons"; + + +describe("Battle order", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.MEWTWO); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TACKLE]); + }); + + it("opponent faster than player 50 vs 150", async() => { + await game.startBattle([ + Species.BULBASAUR, + ]); + game.scene.getParty()[0].stats[Stat.SPD] = 50; + game.scene.currentBattle.enemyParty[0].stats[Stat.SPD] = 150; + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.whenAboutToRun(TurnStartPhase); + const phase = game.scene.getCurrentPhase() as TurnStartPhase; + const order = phase.getOrder(); + expect(order[0]).toBe(2); + expect(order[1]).toBe(0); + }, 20000); + + it("Player faster than opponent 150 vs 50", async() => { + await game.startBattle([ + Species.BULBASAUR, + ]); + game.scene.getParty()[0].stats[Stat.SPD] = 150; + game.scene.currentBattle.enemyParty[0].stats[Stat.SPD] = 50; + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.whenAboutToRun(TurnStartPhase); + const phase = game.scene.getCurrentPhase() as TurnStartPhase; + const order = phase.getOrder(); + expect(order[0]).toBe(0); + expect(order[1]).toBe(2); + }, 20000); + + it("double - both opponents faster than player 50/50 vs 150/150", async() => { + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(false); + vi.spyOn(overrides, "DOUBLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + await game.startBattle([ + Species.BULBASAUR, + Species.BLASTOISE, + ]); + game.scene.getParty()[0].stats[Stat.SPD] = 50; + game.scene.getParty()[1].stats[Stat.SPD] = 50; + game.scene.currentBattle.enemyParty[0].stats[Stat.SPD] = 150; + game.scene.currentBattle.enemyParty[1].stats[Stat.SPD] = 150; + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + game.onNextPrompt("SelectTargetPhase", Mode.TARGET_SELECT, () => { + const handler = game.scene.ui.getHandler() as TargetSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + game.onNextPrompt("SelectTargetPhase", Mode.TARGET_SELECT, () => { + const handler = game.scene.ui.getHandler() as TargetSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.runFrom(CommandPhase).to(EnemyCommandPhase); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.whenAboutToRun(TurnStartPhase); + const phase = game.scene.getCurrentPhase() as TurnStartPhase; + const order = phase.getOrder(); + expect(order.indexOf(0)).toBeGreaterThan(order.indexOf(2)); + expect(order.indexOf(0)).toBeGreaterThan(order.indexOf(3)); + expect(order.indexOf(1)).toBeGreaterThan(order.indexOf(2)); + expect(order.indexOf(1)).toBeGreaterThan(order.indexOf(3)); + }, 20000); + + it("double - speed tie except 1 - 100/100 vs 100/150", async() => { + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(false); + vi.spyOn(overrides, "DOUBLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + await game.startBattle([ + Species.BULBASAUR, + Species.BLASTOISE, + ]); + game.scene.getParty()[0].stats[Stat.SPD] = 100; + game.scene.getParty()[1].stats[Stat.SPD] = 100; + game.scene.currentBattle.enemyParty[0].stats[Stat.SPD] = 100; + game.scene.currentBattle.enemyParty[1].stats[Stat.SPD] = 150; + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + game.onNextPrompt("SelectTargetPhase", Mode.TARGET_SELECT, () => { + const handler = game.scene.ui.getHandler() as TargetSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + game.onNextPrompt("SelectTargetPhase", Mode.TARGET_SELECT, () => { + const handler = game.scene.ui.getHandler() as TargetSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.runFrom(CommandPhase).to(EnemyCommandPhase); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.whenAboutToRun(TurnStartPhase); + const phase = game.scene.getCurrentPhase() as TurnStartPhase; + const order = phase.getOrder(); + expect(order.indexOf(3)).toBeLessThan(order.indexOf(0)); + expect(order.indexOf(3)).toBeLessThan(order.indexOf(1)); + expect(order.indexOf(3)).toBeLessThan(order.indexOf(2)); + }, 20000); + + it("double - speed tie 100/150 vs 100/150", async() => { + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(false); + vi.spyOn(overrides, "DOUBLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + await game.startBattle([ + Species.BULBASAUR, + Species.BLASTOISE, + ]); + game.scene.getParty()[0].stats[Stat.SPD] = 100; + game.scene.getParty()[1].stats[Stat.SPD] = 150; + game.scene.currentBattle.enemyParty[0].stats[Stat.SPD] = 100; + game.scene.currentBattle.enemyParty[1].stats[Stat.SPD] = 150; + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + game.onNextPrompt("SelectTargetPhase", Mode.TARGET_SELECT, () => { + const handler = game.scene.ui.getHandler() as TargetSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + game.onNextPrompt("SelectTargetPhase", Mode.TARGET_SELECT, () => { + const handler = game.scene.ui.getHandler() as TargetSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.runFrom(CommandPhase).to(EnemyCommandPhase); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.whenAboutToRun(TurnStartPhase); + const phase = game.scene.getCurrentPhase() as TurnStartPhase; + const order = phase.getOrder(); + expect(order.indexOf(1)).toBeLessThan(order.indexOf(0)); + expect(order.indexOf(1)).toBeLessThan(order.indexOf(2)); + expect(order.indexOf(3)).toBeLessThan(order.indexOf(0)); + expect(order.indexOf(3)).toBeLessThan(order.indexOf(2)); + }, 20000); +}); diff --git a/src/test/battle/battle.test.ts b/src/test/battle/battle.test.ts new file mode 100644 index 00000000000..521b56a8db2 --- /dev/null +++ b/src/test/battle/battle.test.ts @@ -0,0 +1,248 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import {generateStarter, getMovePosition, waitUntil,} from "#app/test/utils/gameManagerUtils"; +import {Mode} from "#app/ui/ui"; +import {GameModes} from "#app/game-mode"; +import {Species} from "#app/data/enums/species"; +import * as overrides from "../../overrides"; +import {Command} from "#app/ui/command-ui-handler"; +import { + BattleEndPhase, + BerryPhase, + CommandPhase, + DamagePhase, + EggLapsePhase, + EncounterPhase, + EnemyCommandPhase, + FaintPhase, + LoginPhase, + MessagePhase, + MoveEffectPhase, + MoveEndPhase, + MovePhase, + PostSummonPhase, + SelectGenderPhase, + SelectModifierPhase, + SelectStarterPhase, + StatChangePhase, + TitlePhase, + TurnEndPhase, + TurnInitPhase, + TurnStartPhase, + VictoryPhase, +} from "#app/phases"; +import {Moves} from "#app/data/enums/moves"; +import GameManager from "#app/test/utils/gameManager"; +import Phaser from "phaser"; +import {allSpecies} from "#app/data/pokemon-species"; +import {PlayerGender} from "#app/data/enums/player-gender"; + +describe("Test Battle Phase", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + }); + + it("test phase interceptor with remove", async() => { + await game.phaseInterceptor.run(LoginPhase); + + await game.phaseInterceptor.run(LoginPhase, () => { + return game.phaseInterceptor.log.includes("LoginPhase"); + }); + + game.scene.gameData.gender = PlayerGender.MALE; + await game.phaseInterceptor.remove(SelectGenderPhase, () => game.isCurrentPhase(TitlePhase)); + + await game.phaseInterceptor.run(TitlePhase); + await waitUntil(() => game.scene.ui?.getMode() === Mode.TITLE); + + expect(game.scene.ui?.getMode()).toBe(Mode.TITLE); + }, 100000); + + it("test phase interceptor with prompt", async() => { + await game.phaseInterceptor.run(LoginPhase); + + game.onNextPrompt("SelectGenderPhase", Mode.OPTION_SELECT, () => { + game.scene.gameData.gender = PlayerGender.MALE; + game.endPhase(); + }); + + await game.phaseInterceptor.run(SelectGenderPhase); + + await game.phaseInterceptor.run(TitlePhase); + await game.waitMode(Mode.TITLE); + + + expect(game.scene.ui?.getMode()).toBe(Mode.TITLE); + expect(game.scene.gameData.gender).toBe(PlayerGender.MALE); + }, 100000); + + it("test phase interceptor with prompt with preparation for a future prompt", async() => { + await game.phaseInterceptor.run(LoginPhase); + + game.onNextPrompt("SelectGenderPhase", Mode.OPTION_SELECT, () => { + game.scene.gameData.gender = PlayerGender.MALE; + game.endPhase(); + }); + + game.onNextPrompt("CheckSwitchPhase", Mode.CONFIRM, () => { + game.setMode(Mode.MESSAGE); + game.endPhase(); + }); + await game.phaseInterceptor.run(SelectGenderPhase); + + await game.phaseInterceptor.run(TitlePhase); + await game.waitMode(Mode.TITLE); + + + expect(game.scene.ui?.getMode()).toBe(Mode.TITLE); + expect(game.scene.gameData.gender).toBe(PlayerGender.MALE); + }, 100000); + + it("newGame one-liner", async() => { + await game.startBattle(); + expect(game.scene.ui?.getMode()).toBe(Mode.COMMAND); + expect(game.scene.getCurrentPhase().constructor.name).toBe(CommandPhase.name); + }, 100000); + + it("do attack wave 3 - single battle - regular - OHKO", async() => { + vi.spyOn(overrides, "STARTER_SPECIES_OVERRIDE", "get").mockReturnValue(Species.MEWTWO); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RATTATA); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(2000); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(3); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TACKLE]); + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + await game.startBattle(); + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.run(TurnStartPhase); + + await game.phaseInterceptor.run(MovePhase); + await game.phaseInterceptor.run(MessagePhase); + await game.phaseInterceptor.run(MoveEffectPhase); + await game.phaseInterceptor.run(DamagePhase); + await game.phaseInterceptor.run(MessagePhase, () => game.isCurrentPhase(FaintPhase)); + await game.phaseInterceptor.run(FaintPhase); + await game.phaseInterceptor.run(MessagePhase); + + await game.phaseInterceptor.run(VictoryPhase); + await game.phaseInterceptor.run(MoveEndPhase); + await game.phaseInterceptor.run(MovePhase); + await game.phaseInterceptor.run(BerryPhase); + await game.phaseInterceptor.run(TurnEndPhase); + await game.phaseInterceptor.run(BattleEndPhase); + await game.phaseInterceptor.run(EggLapsePhase); + await game.phaseInterceptor.run(SelectModifierPhase); + expect(game.scene.ui?.getMode()).toBe(Mode.MODIFIER_SELECT); + expect(game.scene.getCurrentPhase().constructor.name).toBe(SelectModifierPhase.name); + }, 100000); + + it("do attack wave 3 - single battle - regular - NO OHKO with opponent using non damage attack", async() => { + vi.spyOn(overrides, "STARTER_SPECIES_OVERRIDE", "get").mockReturnValue(Species.MEWTWO); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RATTATA); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(5); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(3); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TACKLE]); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TAIL_WHIP]); + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + await game.startBattle(); + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, Moves.TACKLE); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.run(EnemyCommandPhase); + await game.phaseInterceptor.run(TurnStartPhase); + + await game.phaseInterceptor.run(MovePhase); + await game.phaseInterceptor.run(MessagePhase); + await game.phaseInterceptor.run(MoveEffectPhase); + await game.phaseInterceptor.run(DamagePhase); + await game.phaseInterceptor.run(MessagePhase, () => game.isCurrentPhase(MoveEndPhase)); + await game.phaseInterceptor.run(MoveEndPhase); + + await game.phaseInterceptor.run(MovePhase); + await game.phaseInterceptor.run(MessagePhase, () => game.isCurrentPhase(MoveEffectPhase)); + await game.phaseInterceptor.run(MoveEffectPhase); + game.scene.moveAnimations = null; // Mandatory to avoid the crash + await game.phaseInterceptor.run(StatChangePhase, () => game.isCurrentPhase(MessagePhase) || game.isCurrentPhase(MoveEndPhase) || game.isCurrentPhase(DamagePhase)); + await game.phaseInterceptor.run(DamagePhase, () => game.isCurrentPhase(MessagePhase) || game.isCurrentPhase(MoveEndPhase)); + await game.phaseInterceptor.run(MessagePhase, () => game.isCurrentPhase(MoveEndPhase)); + await game.phaseInterceptor.run(MoveEndPhase); + + await game.phaseInterceptor.run(BerryPhase); + await game.phaseInterceptor.run(MessagePhase, () => game.isCurrentPhase(TurnEndPhase)); + await game.phaseInterceptor.run(TurnEndPhase); + + await game.phaseInterceptor.run(TurnInitPhase); + await game.phaseInterceptor.run(CommandPhase); + await waitUntil(() => game.scene.ui?.getMode() === Mode.COMMAND); + expect(game.scene.ui?.getMode()).toBe(Mode.COMMAND); + expect(game.scene.getCurrentPhase().constructor.name).toBe(CommandPhase.name); + }, 100000); + + it("load 100% data file", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + const caughtCount = Object.keys(game.scene.gameData.dexData).filter((key) => { + const species = game.scene.gameData.dexData[key]; + return species.caughtAttr !== 0n; + }).length; + expect(caughtCount).toBe(Object.keys(allSpecies).length); + }, 50000); + + it("start battle with selected team", async() => { + await game.startBattle([ + Species.CHARIZARD, + Species.CHANSEY, + Species.MEW + ]); + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.CHARIZARD); + expect(game.scene.getParty()[1].species.speciesId).toBe(Species.CHANSEY); + expect(game.scene.getParty()[2].species.speciesId).toBe(Species.MEW); + }, 50000); + + it("assert next phase", async() => { + await game.phaseInterceptor.run(LoginPhase); + game.onNextPrompt("SelectGenderPhase", Mode.OPTION_SELECT, () => { + game.scene.gameData.gender = PlayerGender.MALE; + game.endPhase(); + }, () => game.isCurrentPhase(TitlePhase)); + await game.phaseInterceptor.mustRun(SelectGenderPhase).catch((error) => expect(error).toBe(SelectGenderPhase)); + await game.phaseInterceptor.mustRun(TitlePhase).catch((error) => expect(error).toBe(TitlePhase)); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const starters = generateStarter(game.scene); + const selectStarterPhase = new SelectStarterPhase(game.scene, GameModes.CLASSIC); + game.scene.pushPhase(new EncounterPhase(game.scene, false)); + selectStarterPhase.initBattle(starters); + }); + await game.phaseInterceptor.mustRun(EncounterPhase).catch((error) => expect(error).toBe(EncounterPhase)); + await game.phaseInterceptor.mustRun(PostSummonPhase).catch((error) => expect(error).toBe(PostSummonPhase)); + }, 50000); + + it("test remove random battle seed int", async() => { + for (let i=0; i<10; i++) { + const rand = game.scene.randBattleSeedInt(15); + expect(rand).toBe(14); + } + }); +}); + diff --git a/src/test/eggs/egg.test.ts b/src/test/eggs/egg.test.ts new file mode 100644 index 00000000000..7cfe7fda651 --- /dev/null +++ b/src/test/eggs/egg.test.ts @@ -0,0 +1,33 @@ +import {beforeAll, describe, expect, it} from "vitest"; +import BattleScene from "../../battle-scene"; +import { getLegendaryGachaSpeciesForTimestamp } from "#app/data/egg.js"; +import { Species } from "#app/data/enums/species.js"; +import Phaser from "phaser"; + +describe("getLegendaryGachaSpeciesForTimestamp", () => { + + beforeAll(() => { + new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + it("should return Arceus for the 10th of June", () => { + const scene = new BattleScene(); + const timestamp = new Date(2024, 5, 10, 15, 0, 0, 0).getTime(); + const expectedSpecies = Species.ARCEUS; + + const result = getLegendaryGachaSpeciesForTimestamp(scene, timestamp); + + expect(result).toBe(expectedSpecies); + }); + it("should return Arceus for the 10th of July", () => { + const scene = new BattleScene(); + const timestamp = new Date(2024, 6, 10, 15, 0, 0, 0).getTime(); + const expectedSpecies = Species.ARCEUS; + + const result = getLegendaryGachaSpeciesForTimestamp(scene, timestamp); + + expect(result).toBe(expectedSpecies); + }); +}); diff --git a/src/test/debugImports.test.ts b/src/test/imports.test.ts similarity index 100% rename from src/test/debugImports.test.ts rename to src/test/imports.test.ts diff --git a/src/test/inputs/inputs.test.ts b/src/test/inputs/inputs.test.ts new file mode 100644 index 00000000000..4924ade0fc4 --- /dev/null +++ b/src/test/inputs/inputs.test.ts @@ -0,0 +1,105 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import pad_xbox360 from "#app/configs/inputs/pad_xbox360"; +import cfg_keyboard_qwerty from "#app/configs/inputs/cfg_keyboard_qwerty"; +import InputsHandler from "#app/test/utils/inputsHandler"; + + +describe("Inputs", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + let originalDocument: Document; + + beforeAll(() => { + originalDocument = window.document; + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + Object.defineProperty(window, "document", { + value: originalDocument, + configurable: true, + writable: true, + }); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + game.inputsHandler = new InputsHandler(game.scene); + }); + + it("Mobile - test touch holding for 1ms - 1 input", async () => { + await game.inputsHandler.pressTouch("dpadUp", 1); + expect(game.inputsHandler.log.length).toBe(1); + }); + + it("Mobile - test touch holding for 200ms - 1 input", async () => { + await game.inputsHandler.pressTouch("dpadUp", 200); + expect(game.inputsHandler.log.length).toBe(1); + }); + + it("Mobile - test touch holding for 300ms - 2 input", async () => { + await game.inputsHandler.pressTouch("dpadUp", 300); + expect(game.inputsHandler.log.length).toBe(2); + }); + + it("Mobile - test touch holding for 1000ms - 4 input", async () => { + await game.inputsHandler.pressTouch("dpadUp", 1000); + expect(game.inputsHandler.log.length).toBe(4); + }); + + it("keyboard - test input holding for 1ms - 1 input", async() => { + await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 1); + expect(game.inputsHandler.log.length).toBe(1); + }); + + it("keyboard - test input holding for 200ms - 1 input", async() => { + await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 200); + expect(game.inputsHandler.log.length).toBe(1); + }); + + it("keyboard - test input holding for 300ms - 2 input", async() => { + await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 300); + expect(game.inputsHandler.log.length).toBe(2); + }); + + it("keyboard - test input holding for 1000ms - 4 input", async() => { + await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 1000); + expect(game.inputsHandler.log.length).toBe(4); + }); + + it("keyboard - test input holding for 2000ms - 8 input", async() => { + await game.inputsHandler.pressKeyboardKey(cfg_keyboard_qwerty.deviceMapping.KEY_ARROW_UP, 2000); + expect(game.inputsHandler.log.length).toBe(8); + }); + + it("gamepad - test input holding for 1ms - 1 input", async() => { + await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 1); + expect(game.inputsHandler.log.length).toBe(1); + }); + + it("gamepad - test input holding for 200ms - 1 input", async() => { + await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 200); + expect(game.inputsHandler.log.length).toBe(1); + }); + + it("gamepad - test input holding for 300ms - 2 input", async() => { + await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 300); + expect(game.inputsHandler.log.length).toBe(2); + }); + + it("gamepad - test input holding for 1000ms - 4 input", async() => { + await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 1000); + expect(game.inputsHandler.log.length).toBe(4); + }); + + it("gamepad - test input holding for 2000ms - 8 input", async() => { + await game.inputsHandler.pressGamepadButton(pad_xbox360.deviceMapping.RC_S, 2000); + expect(game.inputsHandler.log.length).toBe(8); + }); +}); + diff --git a/src/test/items/toxic_orb.test.ts b/src/test/items/toxic_orb.test.ts new file mode 100644 index 00000000000..7064bcd13a1 --- /dev/null +++ b/src/test/items/toxic_orb.test.ts @@ -0,0 +1,80 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + CommandPhase, + EnemyCommandPhase, + MessagePhase, + TurnEndPhase, +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {Moves} from "#app/data/enums/moves"; +import {getMovePosition} from "#app/test/utils/gameManagerUtils"; +import {Command} from "#app/ui/command-ui-handler"; +import {StatusEffect} from "#app/data/status-effect"; + + +describe("Items - Toxic orb", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + const moveToUse = Moves.GROWTH; + const oppMoveToUse = Moves.TACKLE; + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RATTATA); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(2000); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([moveToUse]); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([oppMoveToUse, oppMoveToUse, oppMoveToUse, oppMoveToUse]); + vi.spyOn(overrides, "STARTING_HELD_ITEMS_OVERRIDE", "get").mockReturnValue([{ + name: "TOXIC_ORB", + }]); + }); + + it("TOXIC ORB", async() => { + const moveToUse = Moves.GROWTH; + await game.startBattle([ + Species.MIGHTYENA, + Species.MIGHTYENA, + ]); + expect(game.scene.modifiers[0].type.id).toBe("TOXIC_ORB"); + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + // Select Attack + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + // Select Move Growth + const movePosition = getMovePosition(game.scene, 0, moveToUse); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + + // will run the 13 phase from enemyCommandPhase to TurnEndPhase + await game.phaseInterceptor.runFrom(EnemyCommandPhase).to(TurnEndPhase); + // Toxic orb should trigger here + await game.phaseInterceptor.run(MessagePhase); + const message = game.textInterceptor.getLatestMessage(); + expect(message).toContain("was badly poisoned by Toxic Orb"); + await game.phaseInterceptor.run(MessagePhase); + const message2 = game.textInterceptor.getLatestMessage(); + expect(message2).toContain("is hurt"); + expect(message2).toContain("by poison"); + expect(game.scene.getParty()[0].status.effect).toBe(StatusEffect.TOXIC); + }, 20000); +}); diff --git a/src/test/lokalisation/french.test.ts b/src/test/lokalisation/french.test.ts new file mode 100644 index 00000000000..25b7d7d9803 --- /dev/null +++ b/src/test/lokalisation/french.test.ts @@ -0,0 +1,42 @@ +import {afterEach, beforeAll, describe, expect, it} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import {Species} from "#app/data/enums/species"; +import i18next from "i18next"; +import {initI18n} from "#app/plugins/i18n"; + +describe("Lokalization - french", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + initI18n(); + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + it("test bulbasaur name english", async () => { + game = new GameManager(phaserGame); + await game.startBattle([ + Species.BULBASAUR, + ]); + expect(game.scene.getParty()[0].name).toBe("Bulbasaur"); + }, 20000); + + it("test bulbasaure name french", async () => { + const locale = "fr"; + i18next.changeLanguage(locale); + localStorage.setItem("prLang", locale); + game = new GameManager(phaserGame); + + await game.startBattle([ + Species.BULBASAUR, + ]); + expect(game.scene.getParty()[0].name).toBe("Bulbizarre"); + }, 20000); +}); diff --git a/src/test/moves/growth.test.ts b/src/test/moves/growth.test.ts new file mode 100644 index 00000000000..9a6e13f06a3 --- /dev/null +++ b/src/test/moves/growth.test.ts @@ -0,0 +1,69 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + CommandPhase, + EnemyCommandPhase, + TurnInitPhase, +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {Stat} from "#app/data/pokemon-stat"; +import {Moves} from "#app/data/enums/moves"; +import {getMovePosition} from "#app/test/utils/gameManagerUtils"; +import {Command} from "#app/ui/command-ui-handler"; +import {BattleStat} from "#app/data/battle-stat"; + + +describe("Moves - Growth", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + const moveToUse = Moves.GROWTH; + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RATTATA); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.MOXIE); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(2000); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([moveToUse]); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TACKLE,Moves.TACKLE,Moves.TACKLE,Moves.TACKLE]); + }); + + it("GROWTH", async() => { + const moveToUse = Moves.GROWTH; + await game.startBattle([ + Species.MIGHTYENA, + Species.MIGHTYENA, + ]); + let battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[Stat.SPATK]).toBe(0); + + const battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.SPATK]).toBe(0); + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, moveToUse); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.runFrom(EnemyCommandPhase).to(TurnInitPhase); + battleStatsPokemon = game.scene.getParty()[0].summonData.battleStats; + expect(battleStatsPokemon[BattleStat.SPATK]).toBe(1); + }, 20000); +}); diff --git a/src/test/moves/tackle.test.ts b/src/test/moves/tackle.test.ts new file mode 100644 index 00000000000..ca3f95731f2 --- /dev/null +++ b/src/test/moves/tackle.test.ts @@ -0,0 +1,85 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Species} from "#app/data/enums/species"; +import { + CommandPhase, + EnemyCommandPhase, TurnEndPhase, +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {Moves} from "#app/data/enums/moves"; +import {getMovePosition} from "#app/test/utils/gameManagerUtils"; +import {Command} from "#app/ui/command-ui-handler"; +import {Stat} from "#app/data/pokemon-stat"; + + +describe("Moves - Tackle", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + const moveToUse = Moves.TACKLE; + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.MAGIKARP); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(1); + vi.spyOn(overrides, "STARTING_WAVE_OVERRIDE", "get").mockReturnValue(97); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([moveToUse]); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([Moves.GROWTH,Moves.GROWTH,Moves.GROWTH,Moves.GROWTH]); + vi.spyOn(overrides, "NEVER_CRIT_OVERRIDE", "get").mockReturnValue(true); + }); + + it("TACKLE against ghost", async() => { + const moveToUse = Moves.TACKLE; + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.GENGAR); + await game.startBattle([ + Species.MIGHTYENA, + ]); + const hpOpponent = game.scene.currentBattle.enemyParty[0].hp; + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, moveToUse); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.runFrom(EnemyCommandPhase).to(TurnEndPhase); + const hpLost = hpOpponent - game.scene.currentBattle.enemyParty[0].hp; + expect(hpLost).toBe(0); + }, 20000); + + it("TACKLE against not resistant", async() => { + const moveToUse = Moves.TACKLE; + await game.startBattle([ + Species.MIGHTYENA, + ]); + game.scene.currentBattle.enemyParty[0].stats[Stat.DEF] = 50; + game.scene.getParty()[0].stats[Stat.ATK] = 50; + + + const hpOpponent = game.scene.currentBattle.enemyParty[0].hp; + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, moveToUse); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.runFrom(EnemyCommandPhase).to(TurnEndPhase); + const hpLost = hpOpponent - game.scene.currentBattle.enemyParty[0].hp; + expect(hpLost).toBeGreaterThan(0); + expect(hpLost).toBe(4); + }, 20000); +}); diff --git a/src/test/moves/tail_whip.test.ts b/src/test/moves/tail_whip.test.ts new file mode 100644 index 00000000000..2d6789102d1 --- /dev/null +++ b/src/test/moves/tail_whip.test.ts @@ -0,0 +1,66 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import * as overrides from "#app/overrides"; +import {Abilities} from "#app/data/enums/abilities"; +import {Species} from "#app/data/enums/species"; +import { + CommandPhase, + EnemyCommandPhase, + TurnInitPhase, +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {Moves} from "#app/data/enums/moves"; +import {getMovePosition} from "#app/test/utils/gameManagerUtils"; +import {Command} from "#app/ui/command-ui-handler"; +import {BattleStat} from "#app/data/battle-stat"; + + +describe("Moves - Tail whip", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + const moveToUse = Moves.TAIL_WHIP; + vi.spyOn(overrides, "SINGLE_BATTLE_OVERRIDE", "get").mockReturnValue(true); + vi.spyOn(overrides, "OPP_SPECIES_OVERRIDE", "get").mockReturnValue(Species.RATTATA); + vi.spyOn(overrides, "OPP_ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "ABILITY_OVERRIDE", "get").mockReturnValue(Abilities.INSOMNIA); + vi.spyOn(overrides, "STARTING_LEVEL_OVERRIDE", "get").mockReturnValue(2000); + vi.spyOn(overrides, "MOVESET_OVERRIDE", "get").mockReturnValue([moveToUse]); + vi.spyOn(overrides, "OPP_MOVESET_OVERRIDE", "get").mockReturnValue([Moves.TACKLE,Moves.TACKLE,Moves.TACKLE,Moves.TACKLE]); + }); + + it("TAIL_WHIP", async() => { + const moveToUse = Moves.TAIL_WHIP; + await game.startBattle([ + Species.MIGHTYENA, + Species.MIGHTYENA, + ]); + + let battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.DEF]).toBe(0); + + game.onNextPrompt("CommandPhase", Mode.COMMAND, () => { + game.scene.ui.setMode(Mode.FIGHT, (game.scene.getCurrentPhase() as CommandPhase).getFieldIndex()); + }); + game.onNextPrompt("CommandPhase", Mode.FIGHT, () => { + const movePosition = getMovePosition(game.scene, 0, moveToUse); + (game.scene.getCurrentPhase() as CommandPhase).handleCommand(Command.FIGHT, movePosition, false); + }); + await game.phaseInterceptor.runFrom(EnemyCommandPhase).to(TurnInitPhase); + battleStatsOpponent = game.scene.currentBattle.enemyParty[0].summonData.battleStats; + expect(battleStatsOpponent[BattleStat.DEF]).toBe(-1); + }, 20000); +}); diff --git a/src/test/phaser.setup.ts b/src/test/phaser.setup.ts deleted file mode 100644 index 1776e8134e2..00000000000 --- a/src/test/phaser.setup.ts +++ /dev/null @@ -1,5 +0,0 @@ -import Phaser from "phaser"; - -export default new Phaser.Game({ - type: Phaser.HEADLESS, -}); diff --git a/src/test/phases/phases.test.ts b/src/test/phases/phases.test.ts new file mode 100644 index 00000000000..abb7ac2c975 --- /dev/null +++ b/src/test/phases/phases.test.ts @@ -0,0 +1,51 @@ +import BattleScene from "#app/battle-scene.js"; +import { LoginPhase, TitlePhase, UnavailablePhase } from "#app/phases.js"; +import { Mode } from "#app/ui/ui.js"; +import {afterEach, beforeAll, beforeEach, describe, expect, it} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; + +describe("Phases", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + let scene: BattleScene; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + scene = game.scene; + }); + + describe("LoginPhase", () => { + it("should start the login phase", async () => { + const loginPhase = new LoginPhase(scene); + loginPhase.start(); + expect(scene.ui.getMode()).to.equal(Mode.MESSAGE); + }); + }); + + describe("TitlePhase", () => { + it("should start the title phase", async () => { + const titlePhase = new TitlePhase(scene); + titlePhase.start(); + expect(scene.ui.getMode()).to.equal(Mode.MESSAGE); + }); + }); + + describe("UnavailablePhase", () => { + it("should start the unavailable phase", async () => { + const unavailablePhase = new UnavailablePhase(scene); + unavailablePhase.start(); + expect(scene.ui.getMode()).to.equal(Mode.UNAVAILABLE); + }); + }); +}); diff --git a/src/test/pokemon.test.ts b/src/test/pokemon.test.ts deleted file mode 100644 index d1f7da45256..00000000000 --- a/src/test/pokemon.test.ts +++ /dev/null @@ -1,57 +0,0 @@ -import {describe, expect, it} from "vitest"; -import {getPokemonSpecies} from "#app/data/pokemon-species"; -import {PokemonMove} from "#app/field/pokemon"; -import {Species} from "#app/data/enums/species"; -import {Moves} from "#app/data/enums/moves"; -import PokemonData from "#app/system/pokemon-data"; - -describe("some tests related to PokemonData and Species", () => { - it("should create a species", () => { - const species = getPokemonSpecies(Species.MEW); - expect(species).not.toBeNull(); - }); - - it("should create a pokemon", () => { - const pokemon = new PokemonData({ - species: Species.MEW, - level: 1, - }); - expect(pokemon).not.toBeNull(); - expect(pokemon.level).toEqual(1); - expect(pokemon.species).toEqual(Species.MEW); - }); - - it("should generate a moveset", () => { - const pokemon = new PokemonData({ - species: Species.MEW, - level: 1, - }); - expect(pokemon.moveset[0].moveId).toBe(Moves.TACKLE); - expect(pokemon.moveset[1].moveId).toBe(Moves.GROWL); - }); - - it("should create an ennemypokemon", () => { - const ennemyPokemon = new PokemonData({ - species: Species.MEWTWO, - level: 100, - }); - expect(ennemyPokemon).not.toBeNull(); - expect(ennemyPokemon.level).toEqual(100); - expect(ennemyPokemon.species).toEqual(Species.MEWTWO); - }); - - it("should create an ennemypokemon with specified moveset", () => { - const ennemyPokemon = new PokemonData({ - species: Species.MEWTWO, - level: 100, - moveset: [ - new PokemonMove(Moves.ACID), - new PokemonMove(Moves.ACROBATICS), - new PokemonMove(Moves.FOCUS_ENERGY), - ] - }); - expect(ennemyPokemon.moveset[0].moveId).toBe(Moves.ACID); - expect(ennemyPokemon.moveset[1].moveId).toBe(Moves.ACROBATICS); - expect(ennemyPokemon.moveset[2].moveId).toBe(Moves.FOCUS_ENERGY); - }); -}); diff --git a/src/test/helpers/inGameManip.ts b/src/test/settingMenu/helpers/inGameManip.ts similarity index 100% rename from src/test/helpers/inGameManip.ts rename to src/test/settingMenu/helpers/inGameManip.ts diff --git a/src/test/helpers/menuManip.ts b/src/test/settingMenu/helpers/menuManip.ts similarity index 100% rename from src/test/helpers/menuManip.ts rename to src/test/settingMenu/helpers/menuManip.ts diff --git a/src/test/rebinding_setting.test.ts b/src/test/settingMenu/rebinding_setting.test.ts similarity index 99% rename from src/test/rebinding_setting.test.ts rename to src/test/settingMenu/rebinding_setting.test.ts index 03e8cbb51c4..dee29cd42a2 100644 --- a/src/test/rebinding_setting.test.ts +++ b/src/test/settingMenu/rebinding_setting.test.ts @@ -5,8 +5,8 @@ import { getKeyWithKeycode, getKeyWithSettingName, } from "#app/configs/inputs/configHandler"; -import {MenuManip} from "#app/test/helpers/menuManip"; -import {InGameManip} from "#app/test/helpers/inGameManip"; +import {MenuManip} from "#app/test/settingMenu/helpers/menuManip"; +import {InGameManip} from "#app/test/settingMenu/helpers/inGameManip"; import {Device} from "#app/enums/devices"; import {InterfaceConfig} from "#app/inputs-controller"; import cfg_keyboard_qwerty from "#app/configs/inputs/cfg_keyboard_qwerty"; diff --git a/src/test/pokemonSprite.test.ts b/src/test/sprites/pokemonSprite.test.ts similarity index 98% rename from src/test/pokemonSprite.test.ts rename to src/test/sprites/pokemonSprite.test.ts index 07b3cd01cc7..5c1db85fa6f 100644 --- a/src/test/pokemonSprite.test.ts +++ b/src/test/sprites/pokemonSprite.test.ts @@ -1,8 +1,8 @@ import {beforeAll, describe, expect, it} from "vitest"; -import _masterlist from "../../public/images/pokemon/variant/_masterlist.json"; +import _masterlist from "../../../public/images/pokemon/variant/_masterlist.json"; import fs from "fs"; import path from "path"; -import {getAppRootDir} from "#app/test/testUtils"; +import {getAppRootDir} from "#app/test/sprites/spritesUtils"; const deepCopy = (data) => { return JSON.parse(JSON.stringify(data)); diff --git a/src/test/testUtils.ts b/src/test/sprites/spritesUtils.ts similarity index 100% rename from src/test/testUtils.ts rename to src/test/sprites/spritesUtils.ts diff --git a/src/test/ui/starter-select.test.ts b/src/test/ui/starter-select.test.ts new file mode 100644 index 00000000000..802542da259 --- /dev/null +++ b/src/test/ui/starter-select.test.ts @@ -0,0 +1,612 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import {Species} from "#app/data/enums/species"; +import { + EncounterPhase, + SelectStarterPhase, + TitlePhase, +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; +import {GameModes} from "#app/game-mode"; +import StarterSelectUiHandler from "#app/ui/starter-select-ui-handler"; +import {Button} from "#app/enums/buttons"; +import OptionSelectUiHandler from "#app/ui/settings/option-select-ui-handler"; +import SaveSlotSelectUiHandler from "#app/ui/save-slot-select-ui-handler"; +import {OptionSelectItem} from "#app/ui/abstact-option-select-ui-handler"; +import {Gender} from "#app/data/gender"; +import {Nature} from "#app/data/nature"; +import {Abilities} from "#app/data/enums/abilities"; +import {allSpecies} from "#app/data/pokemon-species"; + + +describe("UI - Starter select", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + }); + + it("Bulbasaur - shiny - variant 2 male", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + const caughtCount = Object.keys(game.scene.gameData.dexData).filter((key) => { + const species = game.scene.gameData.dexData[key]; + return species.caughtAttr !== 0n; + }).length; + expect(caughtCount).toBe(Object.keys(allSpecies).length); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(2); + expect(game.scene.getParty()[0].gender).toBe(Gender.MALE); + }, 20000); + + it("Bulbasaur - shiny - variant 2 female hardy overgrow", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.CYCLE_GENDER); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(2); + expect(game.scene.getParty()[0].nature).toBe(Nature.HARDY); + expect(game.scene.getParty()[0].getAbility().id).toBe(Abilities.OVERGROW); + }, 20000); + + it("Bulbasaur - shiny - variant 2 female lonely cholorophyl", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.CYCLE_GENDER); + handler.processInput(Button.CYCLE_NATURE); + handler.processInput(Button.CYCLE_ABILITY); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(2); + expect(game.scene.getParty()[0].nature).toBe(Nature.LONELY); + expect(game.scene.getParty()[0].getAbility().id).toBe(Abilities.CHLOROPHYLL); + }, 20000); + + it("Bulbasaur - shiny - variant 2 female", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.CYCLE_GENDER); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(2); + expect(game.scene.getParty()[0].gender).toBe(Gender.FEMALE); + }, 20000); + + it("Bulbasaur - not shiny", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.CYCLE_SHINY); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(false); + expect(game.scene.getParty()[0].variant).toBe(0); + }, 20000); + + it("Bulbasaur - shiny - variant 0", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.V); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(0); + }, 20000); + + it("Bulbasaur - shiny - variant 1", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.V); + handler.processInput(Button.V); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(1); + }, 20000); + + it("Bulbasaur - shiny - variant 1", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.V); + handler.processInput(Button.V); + handler.processInput(Button.V); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.SUBMIT); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.BULBASAUR); + expect(game.scene.getParty()[0].shiny).toBe(true); + expect(game.scene.getParty()[0].variant).toBe(2); + }, 20000); + + it("Check if first pokemon in party is caterpie from gen 1 and 1rd row, 3rd column ", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.RIGHT); + handler.processInput(Button.RIGHT); + handler.processInput(Button.RIGHT); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + let starterSelectUiHandler: StarterSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + starterSelectUiHandler = game.scene.ui.getHandler() as StarterSelectUiHandler; + starterSelectUiHandler.processInput(Button.SUBMIT); + resolve(); + }); + }); + expect(starterSelectUiHandler.starterGens[0]).toBe(0); + expect(starterSelectUiHandler.starterCursors[0]).toBe(3); + expect(starterSelectUiHandler.cursorObj.x).toBe(132 + 4 * 18); + expect(starterSelectUiHandler.cursorObj.y).toBe(10); + + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.CATERPIE); + }, 20000); + + it("Check if first pokemon in party is nidoran_m from gen 1 and 2nd row, 4th column (cursor (9+4)-1) ", async() => { + await game.importData("src/test/utils/saves/everything.prsv"); + await game.runToTitle(); + game.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const currentPhase = game.scene.getCurrentPhase() as TitlePhase; + currentPhase.gameMode = GameModes.CLASSIC; + currentPhase.end(); + }); + await game.phaseInterceptor.mustRun(SelectStarterPhase).catch((error) => expect(error).toBe(SelectStarterPhase)); + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.RIGHT); + handler.processInput(Button.RIGHT); + handler.processInput(Button.RIGHT); + handler.processInput(Button.RIGHT); + handler.processInput(Button.DOWN); + handler.processInput(Button.ACTION); + }); + let options: OptionSelectItem[]; + let optionSelectUiHandler: OptionSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.OPTION_SELECT, () => { + optionSelectUiHandler = game.scene.ui.getHandler() as OptionSelectUiHandler; + options = optionSelectUiHandler.getOptionsWithScroll(); + resolve(); + }); + }); + expect(options.some(option => option.label === "Add to Party")).toBe(true); + expect(options.some(option => option.label === "Toggle IVs")).toBe(true); + expect(options.some(option => option.label === "Manage Moves")).toBe(true); + expect(options.some(option => option.label === "Use Candies")).toBe(true); + expect(options.some(option => option.label === "Cancel")).toBe(true); + optionSelectUiHandler.processInput(Button.ACTION); + + let starterSelectUiHandler: StarterSelectUiHandler; + await new Promise((resolve) => { + game.onNextPrompt("SelectStarterPhase", Mode.STARTER_SELECT, () => { + starterSelectUiHandler = game.scene.ui.getHandler() as StarterSelectUiHandler; + starterSelectUiHandler.processInput(Button.SUBMIT); + resolve(); + }); + }); + expect(starterSelectUiHandler.starterGens[0]).toBe(0); + expect(starterSelectUiHandler.starterCursors[0]).toBe(12); + expect(starterSelectUiHandler.cursorObj.x).toBe(132 + 4 * 18); + expect(starterSelectUiHandler.cursorObj.y).toBe(28); + + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.SAVE_SLOT, () => { + const saveSlotSelectUiHandler = game.scene.ui.getHandler() as SaveSlotSelectUiHandler; + saveSlotSelectUiHandler.processInput(Button.ACTION); + }); + game.onNextPrompt("SelectStarterPhase", Mode.CONFIRM, () => { + const handler = game.scene.ui.getHandler() as StarterSelectUiHandler; + handler.processInput(Button.ACTION); + }); + await game.phaseInterceptor.whenAboutToRun(EncounterPhase); + expect(game.scene.getParty()[0].species.speciesId).toBe(Species.NIDORAN_M); + }, 20000); +}); diff --git a/src/test/utils/TextInterceptor.ts b/src/test/utils/TextInterceptor.ts new file mode 100644 index 00000000000..d3048f23f74 --- /dev/null +++ b/src/test/utils/TextInterceptor.ts @@ -0,0 +1,16 @@ +export default class TextInterceptor { + private scene; + private logs = []; + constructor(scene) { + this.scene = scene; + scene.messageWrapper = this; + } + + showText(text: string, delay?: integer, callback?: Function, callbackDelay?: integer, prompt?: boolean, promptDelay?: integer): void { + this.logs.push(text); + } + + getLatestMessage(): string { + return this.logs[this.logs.length - 1]; + } +} diff --git a/src/test/utils/fakeMobile.html b/src/test/utils/fakeMobile.html new file mode 100644 index 00000000000..6fa0406f361 --- /dev/null +++ b/src/test/utils/fakeMobile.html @@ -0,0 +1,50 @@ + +
+
+ + + + + + + +
+ +
+
+ A +
+
+ B +
+
+
+ R +
+
+ V +
+
+ C +
+
+ Menu +
+
+
+
+ F +
+
+ G +
+
+ E +
+
+ N +
+
+
+
+ \ No newline at end of file diff --git a/src/test/utils/gameManager.ts b/src/test/utils/gameManager.ts new file mode 100644 index 00000000000..cc759fd1563 --- /dev/null +++ b/src/test/utils/gameManager.ts @@ -0,0 +1,223 @@ +import GameWrapper from "#app/test/utils/gameWrapper"; +import {Mode} from "#app/ui/ui"; +import {generateStarter, waitUntil} from "#app/test/utils/gameManagerUtils"; +import { + CheckSwitchPhase, + CommandPhase, + EncounterPhase, + LoginPhase, + PostSummonPhase, + SelectGenderPhase, + SelectStarterPhase, + SummonPhase, + TitlePhase, + ToggleDoublePositionPhase, +} from "#app/phases"; +import BattleScene from "#app/battle-scene.js"; +import PhaseInterceptor from "#app/test/utils/phaseInterceptor"; +import TextInterceptor from "#app/test/utils/TextInterceptor"; +import {expect} from "vitest"; +import {GameModes} from "#app/game-mode"; +import fs from "fs"; +import { AES, enc } from "crypto-js"; +import {updateUserInfo} from "#app/account"; +import {Species} from "#app/data/enums/species"; +import {PlayerGender} from "#app/data/enums/player-gender"; +import {GameDataType} from "#app/data/enums/game-data-type"; +import InputsHandler from "#app/test/utils/inputsHandler"; +import {ExpNotification} from "#app/enums/exp-notification"; + +/** + * Class to manage the game state and transitions between phases. + */ +export default class GameManager { + public gameWrapper: GameWrapper; + public scene: BattleScene; + public phaseInterceptor: PhaseInterceptor; + public textInterceptor: TextInterceptor; + public inputsHandler: InputsHandler; + + /** + * Creates an instance of GameManager. + * @param phaserGame - The Phaser game instance. + * @param bypassLogin - Whether to bypass the login phase. + */ + constructor(phaserGame: Phaser.Game, bypassLogin: boolean = true) { + BattleScene.prototype.randBattleSeedInt = (arg) => arg-1; + this.gameWrapper = new GameWrapper(phaserGame, bypassLogin); + this.scene = new BattleScene(); + this.phaseInterceptor = new PhaseInterceptor(this.scene); + this.textInterceptor = new TextInterceptor(this.scene); + this.gameWrapper.setScene(this.scene); + } + + /** + * Sets the game mode. + * @param mode - The mode to set. + */ + setMode(mode: Mode) { + this.scene.ui?.setMode(mode); + } + + /** + * Waits until the specified mode is set. + * @param mode - The mode to wait for. + * @returns A promise that resolves when the mode is set. + */ + waitMode(mode: Mode): Promise { + return new Promise(async (resolve) => { + await waitUntil(() => this.scene.ui?.getMode() === mode); + return resolve(); + }); + } + + /** + * Ends the current phase. + */ + endPhase() { + this.scene.getCurrentPhase().end(); + } + + /** + * Adds an action to be executed on the next prompt. + * @param phaseTarget - The target phase. + * @param mode - The mode to wait for. + * @param callback - The callback to execute. + * @param expireFn - Optional function to determine if the prompt has expired. + */ + onNextPrompt(phaseTarget: string, mode: Mode, callback: () => void, expireFn?: () => void) { + this.phaseInterceptor.addToNextPrompt(phaseTarget, mode, callback, expireFn); + } + + /** + * Runs the game to the title phase. + * @returns A promise that resolves when the title phase is reached. + */ + runToTitle(): Promise { + return new Promise(async(resolve) => { + await this.phaseInterceptor.run(LoginPhase); + this.onNextPrompt("SelectGenderPhase", Mode.OPTION_SELECT, () => { + this.scene.gameData.gender = PlayerGender.MALE; + this.endPhase(); + }, () => this.isCurrentPhase(TitlePhase)); + await this.phaseInterceptor.run(SelectGenderPhase, () => this.isCurrentPhase(TitlePhase)); + await this.phaseInterceptor.run(TitlePhase); + this.scene.gameSpeed = 5; + this.scene.moveAnimations = false; + this.scene.showLevelUpStats = false; + this.scene.expGainsSpeed = 3; + this.scene.expParty = ExpNotification.SKIP; + this.scene.hpBarSpeed = 3; + resolve(); + }); + } + + /** + * Runs the game to the summon phase. + * @param species - Optional array of species to summon. + * @returns A promise that resolves when the summon phase is reached. + */ + runToSummon(species?: Species[]): Promise { + return new Promise(async(resolve) => { + await this.runToTitle(); + this.onNextPrompt("TitlePhase", Mode.TITLE, () => { + const starters = generateStarter(this.scene, species); + const selectStarterPhase = new SelectStarterPhase(this.scene, GameModes.CLASSIC); + this.scene.pushPhase(new EncounterPhase(this.scene, false)); + selectStarterPhase.initBattle(starters); + }); + await this.phaseInterceptor.run(EncounterPhase); + resolve(); + }); + } + + /** + * Starts a battle. + * @param species - Optional array of species to start the battle with. + * @returns A promise that resolves when the battle is started. + */ + startBattle(species?: Species[]): Promise { + return new Promise(async(resolve) => { + await this.runToSummon(species); + await this.phaseInterceptor.runFrom(PostSummonPhase).to(ToggleDoublePositionPhase); + await this.phaseInterceptor.run(SummonPhase, () => this.isCurrentPhase(CheckSwitchPhase) || this.isCurrentPhase(PostSummonPhase)); + this.onNextPrompt("CheckSwitchPhase", Mode.CONFIRM, () => { + this.setMode(Mode.MESSAGE); + this.endPhase(); + }, () => this.isCurrentPhase(PostSummonPhase)); + this.onNextPrompt("CheckSwitchPhase", Mode.CONFIRM, () => { + this.setMode(Mode.MESSAGE); + this.endPhase(); + }, () => this.isCurrentPhase(PostSummonPhase)); + await this.phaseInterceptor.run(CheckSwitchPhase, () => this.isCurrentPhase(PostSummonPhase)); + await this.phaseInterceptor.run(CheckSwitchPhase, () => this.isCurrentPhase(PostSummonPhase)); + await this.phaseInterceptor.runFrom(PostSummonPhase).to(CommandPhase); + await waitUntil(() => this.scene.ui?.getMode() === Mode.COMMAND); + console.log("==================[New Turn]=================="); + expect(this.scene.ui?.getMode()).toBe(Mode.COMMAND); + expect(this.scene.getCurrentPhase().constructor.name).toBe(CommandPhase.name); + return resolve(); + }); + } + + /** + * Checks if the player has won the battle. + * @returns True if the player has won, otherwise false. + */ + isVictory() { + return this.scene.currentBattle.enemyParty.every(pokemon => pokemon.isFainted()); + } + + /** + * Checks if the current phase matches the target phase. + * @param phaseTarget - The target phase. + * @returns True if the current phase matches the target phase, otherwise false. + */ + isCurrentPhase(phaseTarget) { + const targetName = typeof phaseTarget === "string" ? phaseTarget : phaseTarget.name; + return this.scene.getCurrentPhase().constructor.name === targetName; + } + + /** + * Checks if the current mode matches the target mode. + * @param mode - The target mode. + * @returns True if the current mode matches the target mode, otherwise false. + */ + isCurrentMode(mode: Mode) { + return this.scene.ui?.getMode() === mode; + } + + /** + * Exports the save data to import it in a test game. + * @returns A promise that resolves with the exported save data. + */ + exportSaveToTest(): Promise { + return new Promise(async (resolve) => { + await this.scene.gameData.saveAll(this.scene, true, true, true, true); + this.scene.reset(true); + await waitUntil(() => this.scene.ui?.getMode() === Mode.TITLE); + await this.scene.gameData.tryExportData(GameDataType.SESSION, 0); + await waitUntil(() => localStorage.hasOwnProperty("toExport")); + return resolve(localStorage.getItem("toExport")); + }); + } + + /** + * Imports game data from a file. + * @param path - The path to the data file. + * @returns A promise that resolves with a tuple containing a boolean indicating success and an integer status code. + */ + async importData(path): Promise<[boolean, integer]> { + const saveKey = "x0i2O7WRiANTqPmZ"; + const dataRaw = fs.readFileSync(path, {encoding: "utf8", flag: "r"}); + let dataStr = AES.decrypt(dataRaw, saveKey).toString(enc.Utf8); + dataStr = this.scene.gameData.convertSystemDataStr(dataStr); + const systemData = this.scene.gameData.parseSystemData(dataStr); + const valid = !!systemData.dexData && !!systemData.timestamp; + if (valid) { + await updateUserInfo(); + await this.scene.gameData.initSystem(dataStr); + } + return updateUserInfo(); + } +} diff --git a/src/test/utils/gameManagerUtils.ts b/src/test/utils/gameManagerUtils.ts new file mode 100644 index 00000000000..4a72006faa6 --- /dev/null +++ b/src/test/utils/gameManagerUtils.ts @@ -0,0 +1,87 @@ +// Function to convert Blob to string +import {getDailyRunStarters} from "#app/data/daily-run"; +import {Gender} from "#app/data/gender"; +import {Species} from "#app/data/enums/species"; +import {Starter} from "#app/ui/starter-select-ui-handler"; +import {GameModes, gameModes} from "#app/game-mode"; +import {getPokemonSpecies, getPokemonSpeciesForm} from "#app/data/pokemon-species"; +import {PlayerPokemon} from "#app/field/pokemon"; + +export function blobToString(blob) { + return new Promise((resolve, reject) => { + const reader = new FileReader(); + + reader.onloadend = () => { + resolve(reader.result); + }; + + reader.onerror = () => { + reject(new Error("Error reading Blob as string")); + }; + + reader.readAsText(blob); + }); +} + + +export function holdOn(ms: number) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +export function generateStarter(scene, species?: Species[]) { + const seed = "test"; + const starters = getTestRunStarters(scene, seed, species); + const startingLevel = scene.gameMode.getStartingLevel(); + for (const starter of starters) { + const starterProps = scene.gameData.getSpeciesDexAttrProps(starter.species, starter.dexAttr); + const starterFormIndex = Math.min(starterProps.formIndex, Math.max(starter.species.forms.length - 1, 0)); + const starterGender = starter.species.malePercent !== null + ? !starterProps.female ? Gender.MALE : Gender.FEMALE + : Gender.GENDERLESS; + const starterPokemon = scene.addPlayerPokemon(starter.species, startingLevel, starter.abilityIndex, starterFormIndex, starterGender, starterProps.shiny, starterProps.variant, undefined, starter.nature); + starter.moveset = starterPokemon.moveset; + } + return starters; +} + +function getTestRunStarters(scene, seed, species) { + if (!species) { + return getDailyRunStarters(scene, seed); + } + const starters: Starter[] = []; + const startingLevel = gameModes[GameModes.CLASSIC].getStartingLevel(); + + for (const specie of species) { + const starterSpeciesForm = getPokemonSpeciesForm(specie, 0); + const starterSpecies = getPokemonSpecies(starterSpeciesForm.speciesId); + const pokemon = new PlayerPokemon(scene, starterSpecies, startingLevel, undefined, 0, undefined, undefined, undefined, undefined, undefined, undefined); + const starter: Starter = { + species: starterSpecies, + dexAttr: pokemon.getDexAttr(), + abilityIndex: pokemon.abilityIndex, + passive: false, + nature: pokemon.getNature(), + pokerus: pokemon.pokerus + }; + starters.push(starter); + } + return starters; +} + +export function waitUntil(truth) { + return new Promise(resolve => { + const interval = setInterval(() => { + if (truth()) { + clearInterval(interval); + resolve(true); + } + }, 1000); + }); +} + +export function getMovePosition(scene, pokemonIndex, moveIndex) { + const playerPokemon = scene.getPlayerField()[pokemonIndex]; + const moveSet = playerPokemon.getMoveset(); + const index = moveSet.findIndex((move) => move.moveId === moveIndex); + return index; +} diff --git a/src/test/utils/gameWrapper.ts b/src/test/utils/gameWrapper.ts new file mode 100644 index 00000000000..c9aed9865db --- /dev/null +++ b/src/test/utils/gameWrapper.ts @@ -0,0 +1,252 @@ +/* eslint-disable */ +// @ts-nocheck +import * as main from "#app/main"; +import fs from "fs"; +import InputManager = Phaser.Input.InputManager; +import KeyboardManager = Phaser.Input.Keyboard.KeyboardManager; +import KeyboardPlugin = Phaser.Input.Keyboard.KeyboardPlugin; +import GamepadPlugin = Phaser.Input.Gamepad.GamepadPlugin; +import EventEmitter = Phaser.Events.EventEmitter; +import UpdateList = Phaser.GameObjects.UpdateList; +import MockGraphics from "#app/test/utils/mocks/mocksContainer/mockGraphics"; +import MockTextureManager from "#app/test/utils/mocks/mockTextureManager"; +import Phaser from "phaser"; +import {blobToString} from "#app/test/utils/gameManagerUtils"; +import {vi} from "vitest"; +import mockLocalStorage from "#app/test/utils/mocks/mockLocalStorage"; +import mockConsoleLog from "#app/test/utils/mocks/mockConsoleLog"; +import MockLoader from "#app/test/utils/mocks/mockLoader"; +import {MockFetch} from "#app/test/utils/mocks/mockFetch"; +import * as Utils from "#app/utils"; +import InputText from "phaser3-rex-plugins/plugins/inputtext"; +import {MockClock} from "#app/test/utils/mocks/mockClock"; +import BattleScene from "#app/battle-scene.js"; +import {MoveAnim} from "#app/data/battle-anims"; +import Pokemon from "#app/field/pokemon"; +import * as battleScene from "#app/battle-scene"; + +Object.defineProperty(window, "localStorage", { + value: mockLocalStorage(), +}); +Object.defineProperty(window, "console", { + value: mockConsoleLog(false), +}); + + +InputText.prototype.setElement = () => null; +InputText.prototype.resize = () => null; +window.URL.createObjectURL = (blob: Blob) => { + blobToString(blob).then((data: string) => { + localStorage.setItem("toExport", data); + }) + return null; +}; +navigator.getGamepads = vi.fn().mockReturnValue([]); +global.fetch = vi.fn(MockFetch); +Utils.setCookie(Utils.sessionIdKey, 'fake_token'); + + +window.matchMedia = () => ({ + matches: false, +}); + + +/** + * Sets this object's position relative to another object with a given offset + * @param guideObject {@linkcode Phaser.GameObjects.GameObject} to base the position off of + * @param x The relative x position + * @param y The relative y position + */ +const setPositionRelative = function (guideObject: any, x: number, y: number) { + const offsetX = guideObject.width * (-0.5 + (0.5 - guideObject.originX)); + const offsetY = guideObject.height * (-0.5 + (0.5 - guideObject.originY)); + this.setPosition(guideObject.x + offsetX + x, guideObject.y + offsetY + y); +}; + +Phaser.GameObjects.Container.prototype.setPositionRelative = setPositionRelative; +Phaser.GameObjects.Sprite.prototype.setPositionRelative = setPositionRelative; +Phaser.GameObjects.Image.prototype.setPositionRelative = setPositionRelative; +Phaser.GameObjects.NineSlice.prototype.setPositionRelative = setPositionRelative; +Phaser.GameObjects.Text.prototype.setPositionRelative = setPositionRelative; +Phaser.GameObjects.Rectangle.prototype.setPositionRelative = setPositionRelative; + + +export default class GameWrapper { + public game: Phaser.Game; + public scene: BattleScene; + + constructor(phaserGame: Phaser.Game, bypassLogin: boolean) { + Phaser.Math.RND.sow([ 'test' ]); + vi.spyOn(Utils, "apiFetch", "get").mockReturnValue(fetch); + if (bypassLogin) { + vi.spyOn(battleScene, "bypassLogin", "get").mockReturnValue(true); + } + this.game = phaserGame; + MoveAnim.prototype.getAnim = () => ({ + frames: {}, + }); + Pokemon.prototype.enableMask = () => null; + localStorage.clear(); + } + + setScene(scene: BattleScene) { + this.scene = scene; + this.injectMandatory(); + this.scene.preload && this.scene.preload(); + this.scene.create(); + } + + injectMandatory() { + this.game.config = { + seed: ["test"], + } + this.scene.game = this.game; + this.game.renderer = { + maxTextures: -1, + gl: {}, + deleteTexture: () => null, + canvasToTexture: () => ({}), + createCanvasTexture: () => ({}), + pipelines: { + add: () => null, + }, + }; + this.scene.renderer = this.game.renderer; + this.scene.children = { + removeAll: () => null, + }; + + this.scene.sound = { + play: () => null, + pause: () => null, + setRate: () => null, + add: () => this.scene.sound, + get: () => this.scene.sound, + getAllPlaying: () => [], + manager: { + game: this.game, + }, + setVolume: () => null, + stopByKey: () => null, + on: (evt, callback) => callback(), + key: "", + }; + + this.scene.tweens = { + add: (data) => { + if (data.onComplete) { + data.onComplete(); + } + }, + getTweensOf: () => ([]), + killTweensOf: () => ([]), + chain: () => null, + addCounter: (data) => { + if (data.onComplete) { + data.onComplete(); + } + }, + }; + + this.scene.anims = this.game.anims; + this.scene.cache = this.game.cache; + this.scene.plugins = this.game.plugins; + this.scene.registry = this.game.registry; + this.scene.scale = this.game.scale; + this.scene.textures = this.game.textures; + this.scene.events = this.game.events; + this.scene.manager = new InputManager(this.game, {}); + this.scene.manager.keyboard = new KeyboardManager(this.scene); + this.scene.pluginEvents = new EventEmitter(); + this.scene.domContainer = {} as HTMLDivElement; + this.scene.spritePipeline = {}; + this.scene.fieldSpritePipeline = {}; + this.scene.load = new MockLoader(this.scene); + this.scene.sys = { + queueDepthSort: () => null, + anims: this.game.anims, + game: this.game, + textures: { + addCanvas: () => ({ + get: () => ({ // this.frame in Text.js + source: {}, + setSize: () => null, + glTexture: () => ({ + spectorMetadata: {}, + }), + }), + }) + }, + cache: this.scene.load.cacheManager, + scale: this.game.scale, + // _scene.sys.scale = new ScaleManager(_scene); + // events: { + // on: () => null, + // }, + events: new EventEmitter(), + settings: { + loader: { + key: 'battle', + } + }, + input: this.game.input, + }; + const mockTextureManager = new MockTextureManager(this.scene); + this.scene.add = mockTextureManager.add; + this.scene.sys.displayList = this.scene.add.displayList; + this.scene.sys.updateList = new UpdateList(this.scene); + this.scene.systems = this.scene.sys; + this.scene.input = this.game.input; + this.scene.scene = this.scene; + this.scene.input.keyboard = new KeyboardPlugin(this.scene); + this.scene.input.gamepad = new GamepadPlugin(this.scene); + this.scene.cachedFetch = (url, init) => { + return new Promise((resolve) => { + // need to remove that if later we want to test battle-anims + const newUrl = url.includes('./battle-anims/') ? prependPath('./battle-anims/tackle.json') : prependPath(url); + let raw; + try { + raw = fs.readFileSync(newUrl, {encoding: "utf8", flag: "r"}); + } catch(e) { + return resolve(createFetchBadResponse({})); + } + const data = JSON.parse(raw); + const response = createFetchResponse(data); + return resolve(response); + }); + }; + this.scene.make = { + graphics: (config) => new MockGraphics(mockTextureManager, config), + rexTransitionImagePack: () => ({ + transit: () => null, + }), + }; + this.scene.time = new MockClock(this.scene); + } +} + +function prependPath(originalPath) { + const prefix = "public"; + if (originalPath.startsWith("./")) { + return originalPath.replace("./", `${prefix}/`); + } + return originalPath; +} +// Simulate fetch response +function createFetchResponse(data) { + return { + ok: true, + status: 200, + json: () => Promise.resolve(data), + text: () => Promise.resolve(JSON.stringify(data)), + }; +} +// Simulate fetch response +function createFetchBadResponse(data) { + return { + ok: false, + status: 404, + json: () => Promise.resolve(data), + text: () => Promise.resolve(JSON.stringify(data)), + }; +} \ No newline at end of file diff --git a/src/test/utils/inputsHandler.ts b/src/test/utils/inputsHandler.ts new file mode 100644 index 00000000000..fd961ed3ef6 --- /dev/null +++ b/src/test/utils/inputsHandler.ts @@ -0,0 +1,115 @@ +import BattleScene from "#app/battle-scene"; +import Phaser from "phaser"; +import {InputsController} from "#app/inputs-controller"; +import pad_xbox360 from "#app/configs/inputs/pad_xbox360"; +import {holdOn} from "#app/test/utils/gameManagerUtils"; +import {initTouchControls} from "#app/touch-controls"; +import { JSDOM } from "jsdom"; +import fs from "fs"; + + +export default class InputsHandler { + private scene: BattleScene; + private events: Phaser.Events.EventEmitter; + private inputController: InputsController; + public log = []; + public logUp = []; + private fakePad: Fakepad; + private fakeMobile: FakeMobile; + + constructor(scene: BattleScene) { + this.scene = scene; + this.inputController = this.scene.inputController; + this.fakePad = new Fakepad(pad_xbox360); + this.fakeMobile = new FakeMobile(); + this.scene.input.gamepad.gamepads.push(this.fakePad); + this.init(); + } + + pressTouch(button: string, duration: integer): Promise { + return new Promise(async (resolve) => { + this.fakeMobile.touchDown(button); + await holdOn(duration); + this.fakeMobile.touchUp(button); + resolve(); + }); + } + + pressGamepadButton(button: integer, duration: integer): Promise { + return new Promise(async (resolve) => { + this.scene.input.gamepad.emit("down", this.fakePad, {index: button}); + await holdOn(duration); + this.scene.input.gamepad.emit("up", this.fakePad, {index: button}); + resolve(); + }); + } + + pressKeyboardKey(key: integer, duration: integer): Promise { + return new Promise(async (resolve) => { + this.scene.input.keyboard.emit("keydown", {keyCode: key}); + await holdOn(duration); + this.scene.input.keyboard.emit("keyup", {keyCode: key}); + resolve(); + }); + } + + init(): void { + setInterval(() => { + this.inputController.update(); + }); + initTouchControls(this.inputController.events); + this.events = this.inputController.events; + this.scene.input.gamepad.emit("connected", this.fakePad); + this.listenInputs(); + } + + listenInputs(): void { + this.events.on("input_down", (event) => { + this.log.push({type: "input_down", button: event.button}); + }, this); + + this.events.on("input_up", (event) => { + this.logUp.push({type: "input_up", button: event.button}); + }, this); + } +} + +class Fakepad extends Phaser.Input.Gamepad.Gamepad { + public id: string; + public index: number; + + constructor(pad) { + super(undefined, {...pad, buttons: pad.deviceMapping, axes: []}); + this.id = "xbox_360_fakepad"; + this.index = 0; + } +} + +class FakeMobile { + constructor() { + const fakeMobilePage = fs.readFileSync("./src/test/utils/fakeMobile.html", {encoding: "utf8", flag: "r"}); + const dom = new JSDOM(fakeMobilePage); + Object.defineProperty(window, "document", { + value: dom.window.document, + configurable: true, + }); + } + + touchDown(button: string) { + const node = document.querySelector(`[data-key][id='${button}']`); + if (!node) { + return; + } + const event = new Event("touchstart"); + node.dispatchEvent(event); + } + + touchUp(button: string) { + const node = document.querySelector(`[data-key][id='${button}']`); + if (!node) { + return; + } + const event = new Event("touchend"); + node.dispatchEvent(event); + } +} diff --git a/src/test/utils/misc.test.ts b/src/test/utils/misc.test.ts new file mode 100644 index 00000000000..da67fb48192 --- /dev/null +++ b/src/test/utils/misc.test.ts @@ -0,0 +1,79 @@ +import {afterEach, beforeAll, beforeEach, describe, expect, it, vi} from "vitest"; +import Phaser from "phaser"; +import GameManager from "#app/test/utils/gameManager"; +import {apiFetch} from "#app/utils"; +import {waitUntil} from "#app/test/utils/gameManagerUtils"; + +describe("Test misc", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + }); + + it("test fetch mock async", async () => { + const spy = vi.fn(); + await fetch("https://localhost:8080/account/info").then(response => { + expect(response.status).toBe(200); + expect(response.ok).toBe(true); + return response.json(); + }).then(data => { + spy(); // Call the spy function + expect(data).toEqual({"username":"greenlamp","lastSessionSlot":0}); + }); + expect(spy).toHaveBeenCalled(); + }); + + it("test apifetch mock async", async () => { + const spy = vi.fn(); + await apiFetch("https://localhost:8080/account/info").then(response => { + expect(response.status).toBe(200); + expect(response.ok).toBe(true); + return response.json(); + }).then(data => { + spy(); // Call the spy function + expect(data).toEqual({"username":"greenlamp","lastSessionSlot":0}); + }); + expect(spy).toHaveBeenCalled(); + }); + + it("test fetch mock sync", async () => { + const response = await fetch("https://localhost:8080/account/info"); + const data = await response.json(); + + expect(response.ok).toBe(true); + expect(response.status).toBe(200); + expect(data).toEqual({"username":"greenlamp","lastSessionSlot":0}); + }); + + it("test apifetch mock sync", async () => { + const data = await game.scene.cachedFetch("./battle-anims/splishy-splash.json"); + expect(data).not.toBeUndefined(); + }); + + it("testing wait phase queue", async () => { + const fakeScene = { + phaseQueue: [1, 2, 3] // Initially not empty + }; + setTimeout(() => { + fakeScene.phaseQueue = []; + }, 500); + const spy = vi.fn(); + await waitUntil(() => fakeScene.phaseQueue.length === 0).then(result => { + expect(result).toBe(true); + spy(); // Call the spy function + }); + expect(spy).toHaveBeenCalled(); + }); +}); diff --git a/src/test/utils/mocks/mockClock.ts b/src/test/utils/mocks/mockClock.ts new file mode 100644 index 00000000000..0d5ea68ed59 --- /dev/null +++ b/src/test/utils/mocks/mockClock.ts @@ -0,0 +1,17 @@ +import Clock = Phaser.Time.Clock; + + +export class MockClock extends Clock { + constructor(scene) { + super(scene); + setInterval(() => { + /* + To simulate frame update + eventEmitter.on(SceneEvents.PRE_UPDATE, this.preUpdate, this); + eventEmitter.on(SceneEvents.UPDATE, this.update, this); + */ + this.preUpdate(this.systems.game.loop.time, 100); + this.update(this.systems.game.loop.time, 100); + }, 100); + } +} diff --git a/src/test/utils/mocks/mockConsoleLog.ts b/src/test/utils/mocks/mockConsoleLog.ts new file mode 100644 index 00000000000..61c6c14b989 --- /dev/null +++ b/src/test/utils/mocks/mockConsoleLog.ts @@ -0,0 +1,82 @@ +const MockConsoleLog = (_logDisabled= false, _phaseText=false) => { + let logs = []; + const logDisabled: boolean = _logDisabled; + const phaseText: boolean = _phaseText; + const originalLog = console.log; + const originalError = console.error; + const originalDebug = console.debug; + const originalWarn = console.warn; + const notified = []; + + const blacklist = ["Phaser", "variant icon does not exist", "Texture \"%s\" not found"]; + const whitelist = ["Phase"]; + + return ({ + log(...args) { + const argsStr = this.getStr(args); + logs.push(argsStr); + if (logDisabled && (!phaseText)) { + return; + } + if ((phaseText && !whitelist.some((b) => argsStr.includes(b))) || blacklist.some((b) => argsStr.includes(b))) { + return; + } + originalLog(args); + }, + error(...args) { + const argsStr = this.getStr(args); + logs.push(argsStr); + originalError(args); // Appelle le console.error originel + }, + debug(...args) { + const argsStr = this.getStr(args); + logs.push(argsStr); + if (logDisabled && (!phaseText)) { + return; + } + if (!whitelist.some((b) => argsStr.includes(b)) || blacklist.some((b) => argsStr.includes(b))) { + return; + } + originalDebug(args); + }, + warn(...args) { + const argsStr = this.getStr(args); + logs.push(args); + if (logDisabled && (!phaseText)) { + return; + } + if (!whitelist.some((b) => argsStr.includes(b)) || blacklist.some((b) => argsStr.includes(b))) { + return; + } + originalWarn(args); + }, + notify(msg) { + originalLog(msg); + notified.push(msg); + }, + getLogs() { + return logs; + }, + clearLogs() { + logs = []; + }, + getStr(...args) { + return args.map(arg => { + if (typeof arg === "object" && arg !== null) { + // Handle objects including arrays + return JSON.stringify(arg, (key, value) => + typeof value === "bigint" ? value.toString() : value + ); + } else if (typeof arg === "bigint") { + // Handle BigInt values + return arg.toString(); + } else { + // Handle all other types + return arg.toString(); + } + }).join(";"); + }, + }); +}; + +export default MockConsoleLog; diff --git a/src/test/utils/mocks/mockFetch.ts b/src/test/utils/mocks/mockFetch.ts new file mode 100644 index 00000000000..ad364a95885 --- /dev/null +++ b/src/test/utils/mocks/mockFetch.ts @@ -0,0 +1,32 @@ +export const MockFetch = (input, init) => { + const url = typeof input === "string" ? input : input.url; + + let responseHandler; + let responseText; + + const handlers = { + "account/info": {"username":"greenlamp","lastSessionSlot":0}, + "savedata/session": {}, + "savedata/system": {}, + "savedata/updateall": "", + "daily/rankingpagecount": { data: 0 }, + "game/titlestats": {"playerCount":0,"battleCount":5}, + "daily/rankings": [], + }; + + + for (const key of Object.keys(handlers)) { + if (url.includes(key)) { + responseHandler = async() => handlers[key]; + responseText = async() => handlers[key] ? JSON.stringify(handlers[key]) : handlers[key]; + break; + } + } + + return Promise.resolve({ + ok: true, + status: 200, + json: responseHandler, + text: responseText, + }); +}; diff --git a/src/test/utils/mocks/mockLoader.ts b/src/test/utils/mocks/mockLoader.ts new file mode 100644 index 00000000000..661eb72f2c2 --- /dev/null +++ b/src/test/utils/mocks/mockLoader.ts @@ -0,0 +1,42 @@ +import CacheManager = Phaser.Cache.CacheManager; + + +export default class MockLoader { + public cacheManager; + constructor(scene) { + this.cacheManager = new CacheManager(scene); + } + + once(event, callback) { + callback(); + } + + setBaseURL(url) { + return null; + } + + video() { + return null; + } + + spritesheet(key, url, frameConfig) { + } + + audio(key, url) { + + } + + isLoading() { + return false; + } + + start() { + } + + image() { + + } + + atlas(key, textureUrl, atlasUrl) { + } +} diff --git a/src/test/utils/mocks/mockLocalStorage.ts b/src/test/utils/mocks/mockLocalStorage.ts new file mode 100644 index 00000000000..bb4ea4e890d --- /dev/null +++ b/src/test/utils/mocks/mockLocalStorage.ts @@ -0,0 +1,27 @@ +const mockLocalStorage = (() => { + let store = {} as Storage; + + return { + getItem(key: string) { + return store[key]; + }, + + setItem(key: string, value: string) { + store[key] = value; + }, + + hasOwnProperty(key: string) { + return store.hasOwnProperty(key); + }, + + removeItem(key: string) { + delete store[key]; + }, + + clear() { + store = {} as Storage; + }, + }; +}); + +export default mockLocalStorage; diff --git a/src/test/utils/mocks/mockTextureManager.ts b/src/test/utils/mocks/mockTextureManager.ts new file mode 100644 index 00000000000..e207f96b722 --- /dev/null +++ b/src/test/utils/mocks/mockTextureManager.ts @@ -0,0 +1,85 @@ +import MockContainer from "#app/test/utils/mocks/mocksContainer/mockContainer"; +import MockSprite from "#app/test/utils/mocks/mocksContainer/mockSprite"; +import MockRectangle from "#app/test/utils/mocks/mocksContainer/mockRectangle"; +import MockNineslice from "#app/test/utils/mocks/mocksContainer/mockNineslice"; +import MockImage from "#app/test/utils/mocks/mocksContainer/mockImage"; +import MockText from "#app/test/utils/mocks/mocksContainer/mockText"; +import MockPolygon from "#app/test/utils/mocks/mocksContainer/mockPolygon"; + + +export default class MockTextureManager { + private textures: Map; + private scene; + public add; + public displayList; + public list = []; + + constructor(scene) { + this.scene = scene; + this.textures = new Map(); + this.displayList = new Phaser.GameObjects.DisplayList(scene); + this.add = { + container: this.container.bind(this), + sprite: this.sprite.bind(this), + tileSprite: this.sprite.bind(this), + existing: this.existing.bind(this), + rectangle: this.rectangle.bind(this), + nineslice: this.nineslice.bind(this), + image: this.image.bind(this), + polygon: this.polygon.bind(this), + text: this.text.bind(this), + bitmapText: this.text.bind(this), + displayList: this.displayList, + }; + } + + container(x, y) { + const container = new MockContainer(this, x, y); + this.list.push(container); + return container; + } + + sprite(x,y, texture) { + const sprite = new MockSprite(this, x, y, texture); + this.list.push(sprite); + return sprite; + } + + existing(obj) { + // const whitelist = ["ArenaBase", "PlayerPokemon", "EnemyPokemon"]; + // const key = obj.constructor.name; + // if (whitelist.includes(key) || obj.texture?.key?.includes("trainer_")) { + // this.containers.push(obj); + // } + } + + rectangle(x, y, width, height, fillColor) { + const rectangle = new MockRectangle(this, x, y, width, height, fillColor); + this.list.push(rectangle); + return rectangle; + } + + nineslice(x, y, texture, frame, width, height, leftWidth, rightWidth, topHeight, bottomHeight) { + const nineSlice = new MockNineslice(this, x, y, texture, frame, width, height, leftWidth, rightWidth, topHeight, bottomHeight); + this.list.push(nineSlice); + return nineSlice; + } + + image(x, y, texture) { + const image = new MockImage(this, x, y, texture); + this.list.push(image); + return image; + } + + text(x, y, content, styleOptions) { + const text = new MockText(this, x, y, content, styleOptions); + this.list.push(text); + return text; + } + + polygon(x, y, content, fillColor, fillAlpha) { + const polygon = new MockPolygon(this, x, y, content, fillColor, fillAlpha); + this.list.push(polygon); + return polygon; + } +} diff --git a/src/test/utils/mocks/mocksContainer/mockContainer.ts b/src/test/utils/mocks/mocksContainer/mockContainer.ts new file mode 100644 index 00000000000..2e2b9567796 --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockContainer.ts @@ -0,0 +1,207 @@ +import MockTextureManager from "#app/test/utils/mocks/mockTextureManager"; + +export default class MockContainer { + protected x; + protected y; + protected scene; + protected width; + protected height; + protected visible; + private alpha; + private style; + public frame; + protected textureManager; + public list = []; + + constructor(textureManager: MockTextureManager, x, y) { + this.x = x; + this.y = y; + this.frame = {}; + this.textureManager = textureManager; + } + setVisible(visible) { + this.visible = visible; + } + + once(event, callback, source) { + } + + off(event, callback, source) { + } + + removeFromDisplayList() { + // same as remove or destroy + } + + addedToScene() { + // This callback is invoked when this Game Object is added to a Scene. + } + + setSize(width, height) { + // Sets the size of this Game Object. + } + + setMask() { + /// Sets the mask that this Game Object will use to render with. + } + + setPositionRelative(source, x, y) { + /// Sets the position of this Game Object to be a relative position from the source Game Object. + } + + setInteractive(hitArea?, callback?, dropZone?) { + /// Sets the InteractiveObject to be a drop zone for a drag and drop operation. + } + setOrigin(x, y) { + this.x = x; + this.y = y; + } + + setAlpha(alpha) { + this.alpha = alpha; + } + + setFrame(frame, updateSize?: boolean, updateOrigin?: boolean) { + // Sets the frame this Game Object will use to render with. + } + + setScale(scale) { + // Sets the scale of this Game Object. + } + + setPosition(x, y) { + this.x = x; + this.y = y; + } + + setX(x) { + this.x = x; + } + + setY(y) { + this.y = y; + } + + destroy() { + this.list = []; + } + + setShadow(shadowXpos, shadowYpos, shadowColor) { + // Sets the shadow settings for this Game Object. + } + + setLineSpacing(lineSpacing) { + // Sets the line spacing value of this Game Object. + } + + setText(text) { + // Sets the text this Game Object will display. + } + + setAngle(angle) { + // Sets the angle of this Game Object. + } + + setShadowOffset(offsetX, offsetY) { + // Sets the shadow offset values. + } + + setWordWrapWidth(width) { + // Sets the width (in pixels) to use for wrapping lines. + } + + setFontSize(fontSize) { + // Sets the font size of this Game Object. + } + getBounds() { + return { width: this.width, height: this.height }; + } + + setColor(color) { + // Sets the tint of this Game Object. + } + + setShadowColor(color) { + // Sets the shadow color. + } + + setTint(color) { + // Sets the tint of this Game Object. + } + + setStrokeStyle(thickness, color) { + // Sets the stroke style for the graphics. + return this; + } + + setDepth(depth) { + // Sets the depth of this Game Object. + } + + setTexture(texture) { + // Sets the texture this Game Object will use to render with. + } + + clearTint() { + // Clears any previously set tint. + } + + sendToBack() { + // Sends this Game Object to the back of its parent's display list. + } + + moveAbove(obj) { + // Moves this Game Object to be above the given Game Object in the display list. + } + + moveBelow(obj) { + // Moves this Game Object to be below the given Game Object in the display list. + } + + setName(name) { + // return this.phaserSprite.setName(name); + } + + bringToTop(obj) { + // Brings this Game Object to the top of its parents display list. + } + + on(event, callback, source) { + } + + add(obj) { + // Adds a child to this Game Object. + this.list.push(obj); + } + + removeAll() { + // Removes all Game Objects from this Container. + this.list = []; + } + + addAt(obj, index) { + // Adds a Game Object to this Container at the given index. + this.list.splice(index, 0, obj); + } + + remove(obj) { + const index = this.list.indexOf(obj); + if (index !== -1) { + this.list.splice(index, 1); + } + } + + getIndex(obj) { + const index = this.list.indexOf(obj); + return index || -1; + } + + getAt(index) { + return this.list[index]; + } + + getAll() { + return this.list; + } + +} diff --git a/src/test/utils/mocks/mocksContainer/mockGraphics.ts b/src/test/utils/mocks/mocksContainer/mockGraphics.ts new file mode 100644 index 00000000000..a08f150fe61 --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockGraphics.ts @@ -0,0 +1,96 @@ +export default class MockGraphics { + private scene; + public list = []; + constructor(textureManager, config) { + this.scene = textureManager.scene; + } + + fillStyle(color) { + // Sets the fill style to be used by the fill methods. + } + + beginPath() { + // Starts a new path by emptying the list of sub-paths. Call this method when you want to create a new path. + } + + fillRect(x, y, width, height) { + // Adds a rectangle shape to the path which is filled when you call fill(). + } + + createGeometryMask() { + // Creates a geometry mask. + } + + setOrigin(x, y) { + } + + setAlpha(alpha) { + } + + setVisible(visible) { + } + + setName(name) { + } + + once(event, callback, source) { + } + + removeFromDisplayList() { + // same as remove or destroy + } + + addedToScene() { + // This callback is invoked when this Game Object is added to a Scene. + } + + setPositionRelative(source, x, y) { + /// Sets the position of this Game Object to be a relative position from the source Game Object. + } + + destroy() { + this.list = []; + } + + setScale(scale) { + // Sets the scale of this Game Object. + } + + off(event, callback, source) { + } + + add(obj) { + // Adds a child to this Game Object. + this.list.push(obj); + } + + removeAll() { + // Removes all Game Objects from this Container. + this.list = []; + } + + addAt(obj, index) { + // Adds a Game Object to this Container at the given index. + this.list.splice(index, 0, obj); + } + + remove(obj) { + const index = this.list.indexOf(obj); + if (index !== -1) { + this.list.splice(index, 1); + } + } + + getIndex(obj) { + const index = this.list.indexOf(obj); + return index || -1; + } + + getAt(index) { + return this.list[index]; + } + + getAll() { + return this.list; + } +} diff --git a/src/test/utils/mocks/mocksContainer/mockImage.ts b/src/test/utils/mocks/mocksContainer/mockImage.ts new file mode 100644 index 00000000000..601dfd22811 --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockImage.ts @@ -0,0 +1,11 @@ +import MockContainer from "#app/test/utils/mocks/mocksContainer/mockContainer"; + + +export default class MockImage extends MockContainer { + private texture; + + constructor(textureManager, x, y, texture) { + super(textureManager, x, y); + this.texture = texture; + } +} diff --git a/src/test/utils/mocks/mocksContainer/mockNineslice.ts b/src/test/utils/mocks/mocksContainer/mockNineslice.ts new file mode 100644 index 00000000000..3edbbb18c31 --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockNineslice.ts @@ -0,0 +1,20 @@ +import MockContainer from "#app/test/utils/mocks/mocksContainer/mockContainer"; + + +export default class MockNineslice extends MockContainer { + private texture; + private leftWidth; + private rightWidth; + private topHeight; + private bottomHeight; + + constructor(textureManager, x, y, texture, frame, width, height, leftWidth, rightWidth, topHeight, bottomHeight) { + super(textureManager, x, y); + this.texture = texture; + this.frame = frame; + this.leftWidth = leftWidth; + this.rightWidth = rightWidth; + this.topHeight = topHeight; + this.bottomHeight = bottomHeight; + } +} diff --git a/src/test/utils/mocks/mocksContainer/mockPolygon.ts b/src/test/utils/mocks/mocksContainer/mockPolygon.ts new file mode 100644 index 00000000000..cf448883ce0 --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockPolygon.ts @@ -0,0 +1,9 @@ +import MockContainer from "#app/test/utils/mocks/mocksContainer/mockContainer"; + + +export default class MockPolygon extends MockContainer { + constructor(textureManager, x, y, content, fillColor, fillAlpha) { + super(textureManager, x, y); + } +} + diff --git a/src/test/utils/mocks/mocksContainer/mockRectangle.ts b/src/test/utils/mocks/mocksContainer/mockRectangle.ts new file mode 100644 index 00000000000..f4ecd2af9d8 --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockRectangle.ts @@ -0,0 +1,74 @@ +export default class MockRectangle { + private fillColor; + private scene; + public list = []; + + constructor(textureManager, x, y, width, height, fillColor) { + this.fillColor = fillColor; + this.scene = textureManager.scene; + } + setOrigin(x, y) { + } + + setAlpha(alpha) { + } + setVisible(visible) { + } + + setName(name) { + } + + once(event, callback, source) { + } + + removeFromDisplayList() { + // same as remove or destroy + } + + addedToScene() { + // This callback is invoked when this Game Object is added to a Scene. + } + + setPositionRelative(source, x, y) { + /// Sets the position of this Game Object to be a relative position from the source Game Object. + } + + destroy() { + this.list = []; + } + + add(obj) { + // Adds a child to this Game Object. + this.list.push(obj); + } + + removeAll() { + // Removes all Game Objects from this Container. + this.list = []; + } + + addAt(obj, index) { + // Adds a Game Object to this Container at the given index. + this.list.splice(index, 0, obj); + } + + remove(obj) { + const index = this.list.indexOf(obj); + if (index !== -1) { + this.list.splice(index, 1); + } + } + + getIndex(obj) { + const index = this.list.indexOf(obj); + return index || -1; + } + + getAt(index) { + return this.list[index]; + } + + getAll() { + return this.list; + } +} diff --git a/src/test/utils/mocks/mocksContainer/mockSprite.ts b/src/test/utils/mocks/mocksContainer/mockSprite.ts new file mode 100644 index 00000000000..30effe185ad --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockSprite.ts @@ -0,0 +1,205 @@ +import Sprite = Phaser.GameObjects.Sprite; +import Frame = Phaser.Textures.Frame; +import Phaser from "phaser"; + + +export default class MockSprite { + private phaserSprite; + public pipelineData; + public texture; + public key; + public frame; + public textureManager; + public scene; + public anims; + public list = []; + constructor(textureManager, x, y, texture) { + this.textureManager = textureManager; + this.scene = textureManager.scene; + Phaser.GameObjects.Sprite.prototype.setInteractive = this.setInteractive; + // @ts-ignore + Phaser.GameObjects.Sprite.prototype.setTexture = this.setTexture; + Phaser.GameObjects.Sprite.prototype.setSizeToFrame = this.setSizeToFrame; + Phaser.GameObjects.Sprite.prototype.setFrame = this.setFrame; + // Phaser.GameObjects.Sprite.prototype.disable = this.disable; + + // Phaser.GameObjects.Sprite.prototype.texture = { frameTotal: 1, get: () => null }; + this.phaserSprite = new Phaser.GameObjects.Sprite(textureManager.scene, x, y, texture); + this.pipelineData = {}; + this.texture = { + key: texture || "", + }; + this.anims = { + pause: () => null, + }; + } + + setTexture(key: string, frame?: string | number) { + return this; + } + + setSizeToFrame(frame?: boolean | Frame): Sprite { + return {} as Sprite; + } + + setPipeline(obj) { + // Sets the pipeline of this Game Object. + return this.phaserSprite.setPipeline(obj); + } + + off(event, callback, source) { + } + + setTintFill(color) { + // Sets the tint fill color. + return this.phaserSprite.setTintFill(color); + } + + setScale(scale) { + return this.phaserSprite.setScale(scale); + } + + setOrigin(x, y) { + return this.phaserSprite.setOrigin(x, y); + } + + setSize(width, height) { + // Sets the size of this Game Object. + return this.phaserSprite.setSize(width, height); + } + + once(event, callback, source) { + return this.phaserSprite.once(event, callback, source); + } + + removeFromDisplayList() { + // same as remove or destroy + return this.phaserSprite.removeFromDisplayList(); + } + + addedToScene() { + // This callback is invoked when this Game Object is added to a Scene. + return this.phaserSprite.addedToScene(); + } + + setVisible(visible) { + return this.phaserSprite.setVisible(visible); + } + + setPosition(x, y) { + return this.phaserSprite.setPosition(x, y); + } + + stop() { + return this.phaserSprite.stop(); + } + + setInteractive(hitArea, hitAreaCallback, dropZone) { + return null; + } + + on(event, callback, source) { + return this.phaserSprite.on(event, callback, source); + } + + setAlpha(alpha) { + return this.phaserSprite.setAlpha(alpha); + } + + setTint(color) { + // Sets the tint of this Game Object. + return this.phaserSprite.setTint(color); + } + + setFrame(frame, updateSize?: boolean, updateOrigin?: boolean) { + // Sets the frame this Game Object will use to render with. + this.frame = frame; + return frame; + } + + setPositionRelative(source, x, y) { + /// Sets the position of this Game Object to be a relative position from the source Game Object. + return this.phaserSprite.setPositionRelative(source, x, y); + } + + setCrop(x, y, width, height) { + // Sets the crop size of this Game Object. + return this.phaserSprite.setCrop(x, y, width, height); + } + + clearTint() { + // Clears any previously set tint. + return this.phaserSprite.clearTint(); + } + + disableInteractive() { + // Disables Interactive features of this Game Object. + return null; + } + + apply() { + return this.phaserSprite.apply(); + } + + play() { + // return this.phaserSprite.play(); + } + + setPipelineData(key, value) { + this.pipelineData[key] = value; + } + + destroy() { + return this.phaserSprite.destroy(); + } + + setName(name) { + return this.phaserSprite.setName(name); + } + + setAngle(angle) { + return this.phaserSprite.setAngle(angle); + } + + setMask() { + + } + + add(obj) { + // Adds a child to this Game Object. + this.list.push(obj); + } + + removeAll() { + // Removes all Game Objects from this Container. + this.list = []; + } + + addAt(obj, index) { + // Adds a Game Object to this Container at the given index. + this.list.splice(index, 0, obj); + } + + remove(obj) { + const index = this.list.indexOf(obj); + if (index !== -1) { + this.list.splice(index, 1); + } + } + + getIndex(obj) { + const index = this.list.indexOf(obj); + return index || -1; + } + + getAt(index) { + return this.list[index]; + } + + getAll() { + return this.list; + } + + + +} diff --git a/src/test/utils/mocks/mocksContainer/mockText.ts b/src/test/utils/mocks/mocksContainer/mockText.ts new file mode 100644 index 00000000000..f219a6d1bad --- /dev/null +++ b/src/test/utils/mocks/mocksContainer/mockText.ts @@ -0,0 +1,265 @@ +import UI from "#app/ui/ui"; + +export default class MockText { + private phaserText; + private wordWrapWidth; + private splitRegExp; + private scene; + private textureManager; + public list = []; + constructor(textureManager, x, y, content, styleOptions) { + this.scene = textureManager.scene; + this.textureManager = textureManager; + // Phaser.GameObjects.TextStyle.prototype.setStyle = () => null; + // Phaser.GameObjects.Text.prototype.updateText = () => null; + // Phaser.Textures.TextureManager.prototype.addCanvas = () => {}; + UI.prototype.showText = this.showText; + // super(scene, x, y); + // this.phaserText = new Phaser.GameObjects.Text(scene, x, y, content, styleOptions); + } + + runWordWrap(text) { + if (!text) { + return ""; + } + let result = ""; + this.splitRegExp = /(?:\r\n|\r|\n)/; + const lines = text.split(this.splitRegExp); + const lastLineIndex = lines.length - 1; + const whiteSpaceWidth = 2; + + for (let i = 0; i <= lastLineIndex; i++) { + let spaceLeft = this.wordWrapWidth; + const words = lines[i].split(" "); + const lastWordIndex = words.length - 1; + + for (let j = 0; j <= lastWordIndex; j++) { + const word = words[j]; + const wordWidth = word.length * 2; + let wordWidthWithSpace = wordWidth; + + if (j < lastWordIndex) { + wordWidthWithSpace += whiteSpaceWidth; + } + + if (wordWidthWithSpace > spaceLeft) { + // Skip printing the newline if it's the first word of the line that is greater + // than the word wrap width. + if (j > 0) { + result += "\n"; + spaceLeft = this.wordWrapWidth; + } + } + + result += word; + + if (j < lastWordIndex) { + result += " "; + spaceLeft -= wordWidthWithSpace; + } else { + spaceLeft -= wordWidth; + } + } + + if (i < lastLineIndex) { + result += "\n"; + } + } + + return result; + } + + showText(text, delay, callback, callbackDelay, prompt, promptDelay) { + this.scene.messageWrapper.showText(text, delay, callback, callbackDelay, prompt, promptDelay); + if (callback) { + callback(); + } + } + + setScale(scale) { + // return this.phaserText.setScale(scale); + } + + setShadow(shadowXpos, shadowYpos, shadowColor) { + // Sets the shadow settings for this Game Object. + // return this.phaserText.setShadow(shadowXpos, shadowYpos, shadowColor); + } + + setLineSpacing(lineSpacing) { + // Sets the line spacing value of this Game Object. + // return this.phaserText.setLineSpacing(lineSpacing); + } + + setOrigin(x, y) { + // return this.phaserText.setOrigin(x, y); + } + + once(event, callback, source) { + // return this.phaserText.once(event, callback, source); + } + + off(event, callback, obj) { + } + + removedFromScene() { + + } + + addToDisplayList() { + + } + + setStroke(color, thickness) { + // Sets the stroke color and thickness. + // return this.phaserText.setStroke(color, thickness); + } + + removeFromDisplayList() { + // same as remove or destroy + // return this.phaserText.removeFromDisplayList(); + } + + addedToScene() { + // This callback is invoked when this Game Object is added to a Scene. + // return this.phaserText.addedToScene(); + } + + setVisible(visible) { + // return this.phaserText.setVisible(visible); + } + + setY(y) { + // return this.phaserText.setY(y); + } + + setX(x) { + // return this.phaserText.setX(x); + } + + setText(text) { + // Sets the text this Game Object will display. + // return this.phaserText.setText(text); + } + + setAngle(angle) { + // Sets the angle of this Game Object. + // return this.phaserText.setAngle(angle); + } + + setPositionRelative(source, x, y) { + /// Sets the position of this Game Object to be a relative position from the source Game Object. + // return this.phaserText.setPositionRelative(source, x, y); + } + + setShadowOffset(offsetX, offsetY) { + // Sets the shadow offset values. + // return this.phaserText.setShadowOffset(offsetX, offsetY); + } + + setWordWrapWidth(width) { + // Sets the width (in pixels) to use for wrapping lines. + this.wordWrapWidth = width; + } + + setFontSize(fontSize) { + // Sets the font size of this Game Object. + // return this.phaserText.setFontSize(fontSize); + } + + getBounds() { + // return this.phaserText.getBounds(); + return { + width: 1, + }; + } + + setColor(color) { + // Sets the tint of this Game Object. + // return this.phaserText.setColor(color); + } + + setShadowColor(color) { + // Sets the shadow color. + // return this.phaserText.setShadowColor(color); + } + + setTint(color) { + // Sets the tint of this Game Object. + // return this.phaserText.setTint(color); + } + + setStrokeStyle(thickness, color) { + // Sets the stroke style for the graphics. + // return this.phaserText.setStrokeStyle(thickness, color); + } + + destroy() { + // return this.phaserText.destroy(); + this.list = []; + } + + setAlpha(alpha) { + // return this.phaserText.setAlpha(alpha); + } + + setName(name) { + // return this.phaserText.setName(name); + } + + setAlign(align) { + // return this.phaserText.setAlign(align); + } + + setMask() { + /// Sets the mask that this Game Object will use to render with. + } + + getBottomLeft() { + return { + x: 0, + y: 0, + }; + } + + getTopLeft() { + return { + x: 0, + y: 0, + }; + } + + add(obj) { + // Adds a child to this Game Object. + this.list.push(obj); + } + + removeAll() { + // Removes all Game Objects from this Container. + this.list = []; + } + + addAt(obj, index) { + // Adds a Game Object to this Container at the given index. + this.list.splice(index, 0, obj); + } + + remove(obj) { + const index = this.list.indexOf(obj); + if (index !== -1) { + this.list.splice(index, 1); + } + } + + getIndex(obj) { + const index = this.list.indexOf(obj); + return index || -1; + } + + getAt(index) { + return this.list[index]; + } + + getAll() { + return this.list; + } +} diff --git a/src/test/utils/phaseInterceptor.ts b/src/test/utils/phaseInterceptor.ts new file mode 100644 index 00000000000..2915f2e614b --- /dev/null +++ b/src/test/utils/phaseInterceptor.ts @@ -0,0 +1,279 @@ +import { + BattleEndPhase, + BerryPhase, + CheckSwitchPhase, CommandPhase, DamagePhase, EggLapsePhase, + EncounterPhase, EnemyCommandPhase, FaintPhase, + LoginPhase, MessagePhase, MoveEffectPhase, MoveEndPhase, MovePhase, NewBattlePhase, NextEncounterPhase, + PostSummonPhase, + SelectGenderPhase, SelectModifierPhase, + SelectStarterPhase, ShinySparklePhase, ShowAbilityPhase, StatChangePhase, SummonPhase, + TitlePhase, ToggleDoublePositionPhase, TurnEndPhase, TurnInitPhase, TurnStartPhase, VictoryPhase +} from "#app/phases"; +import {Mode} from "#app/ui/ui"; + +export default class PhaseInterceptor { + public scene; + public phases = {}; + public log; + private onHold; + private interval; + private promptInterval; + private intervalRun; + private prompts; + private phaseFrom; + + /** + * List of phases with their corresponding start methods. + */ + private PHASES = [ + [LoginPhase, this.startPhase], + [TitlePhase, this.startPhase], + [SelectGenderPhase, this.startPhase], + [EncounterPhase, this.startPhase], + [SelectStarterPhase, this.startPhase], + [PostSummonPhase, this.startPhase], + [SummonPhase, this.startPhase], + [ToggleDoublePositionPhase, this.startPhase], + [CheckSwitchPhase, this.startPhase], + [ShowAbilityPhase, this.startPhase], + [MessagePhase, this.startPhase], + [TurnInitPhase, this.startPhase], + [CommandPhase, this.startPhase], + [EnemyCommandPhase, this.startPhase], + [TurnStartPhase, this.startPhase], + [MovePhase, this.startPhase], + [MoveEffectPhase, this.startPhase], + [DamagePhase, this.startPhase], + [FaintPhase, this.startPhase], + [BerryPhase, this.startPhase], + [TurnEndPhase, this.startPhase], + [BattleEndPhase, this.startPhase], + [EggLapsePhase, this.startPhase], + [SelectModifierPhase, this.startPhase], + [NextEncounterPhase, this.startPhase], + [NewBattlePhase, this.startPhase], + [VictoryPhase, this.startPhase], + [MoveEndPhase, this.startPhase], + [StatChangePhase, this.startPhase], + [ShinySparklePhase, this.startPhase], + ]; + + /** + * Constructor to initialize the scene and properties, and to start the phase handling. + * @param scene - The scene to be managed. + */ + constructor(scene) { + this.scene = scene; + this.log = []; + this.onHold = []; + this.prompts = []; + this.initPhases(); + this.startPromptHander(); + } + + /** + * Method to set the starting phase. + * @param phaseFrom - The phase to start from. + * @returns The instance of the PhaseInterceptor. + */ + runFrom(phaseFrom) { + this.phaseFrom = phaseFrom; + return this; + } + + /** + * Method to transition to a target phase. + * @param phaseTo - The phase to transition to. + * @returns A promise that resolves when the transition is complete. + */ + async to(phaseTo): Promise { + return new Promise(async (resolve) => { + await this.run(this.phaseFrom); + this.phaseFrom = null; + const targetName = typeof phaseTo === "string" ? phaseTo : phaseTo.name; + this.intervalRun = setInterval(async () => { + const currentPhase = this.onHold?.length && this.onHold[0]; + if (currentPhase && currentPhase.name !== targetName) { + await this.run(currentPhase.name); + } else if (currentPhase.name === targetName) { + await this.run(currentPhase.name); + clearInterval(this.intervalRun); + return resolve(); + } + }); + }); + } + + /** + * Method to run a phase with an optional skip function. + * @param phaseTarget - The phase to run. + * @param skipFn - Optional skip function. + * @returns A promise that resolves when the phase is run. + */ + run(phaseTarget, skipFn?): Promise { + this.scene.moveAnimations = null; // Mandatory to avoid crash + return new Promise(async (resolve) => { + this.waitUntil(phaseTarget, skipFn).then(() => { + const currentPhase = this.onHold.shift(); + currentPhase.call(); + resolve(); + }).catch(() => { + resolve(); + }); + }); + } + + /** + * Method to ensure a phase is run, to throw error on test if not. + * @param phaseTarget - The phase to run. + * @returns A promise that resolves when the phase is run. + */ + mustRun(phaseTarget): Promise { + const targetName = typeof phaseTarget === "string" ? phaseTarget : phaseTarget.name; + this.scene.moveAnimations = null; // Mandatory to avoid crash + return new Promise(async (resolve, reject) => { + const interval = setInterval(async () => { + const currentPhase = this.onHold?.length && this.onHold[0]; + if (currentPhase && currentPhase.name !== targetName) { + reject(currentPhase); + } else if (currentPhase && currentPhase.name === targetName) { + clearInterval(interval); + await this.run(phaseTarget); + resolve(); + } + }); + }); + } + + /** + * Method to execute actions when about to run a phase. Does not run the phase, stop right before. + * @param phaseTarget - The phase to run. + * @param skipFn - Optional skip function. + * @returns A promise that resolves when the phase is about to run. + */ + whenAboutToRun(phaseTarget, skipFn?): Promise { + return new Promise(async (resolve) => { + this.waitUntil(phaseTarget, skipFn).then(() => { + resolve(); + }).catch(() => { + resolve(); + }); + }); + } + + /** + * Method to remove a phase from the list. + * @param phaseTarget - The phase to remove. + * @param skipFn - Optional skip function. + * @returns A promise that resolves when the phase is removed. + */ + remove(phaseTarget, skipFn?): Promise { + return new Promise(async (resolve) => { + this.waitUntil(phaseTarget, skipFn).then(() => { + this.onHold.shift(); + this.scene.getCurrentPhase().end(); + resolve(); + }).catch(() => { + resolve(); + }); + }); + } + + /** + * Method to wait until a specific phase is reached. + * @param phaseTarget - The phase to wait for. + * @param skipFn - Optional skip function. + * @returns A promise that resolves when the phase is reached. + */ + waitUntil(phaseTarget, skipFn?): Promise { + const targetName = typeof phaseTarget === "string" ? phaseTarget : phaseTarget.name; + return new Promise((resolve, reject) => { + this.interval = setInterval(() => { + const currentPhase = this.onHold?.length && this.onHold[0] && this.onHold[0].name; + // if the currentPhase here is not filled, it means it's a phase we haven't added to the list + if (currentPhase === targetName) { + clearInterval(this.interval); + return resolve(); + } else if (skipFn && skipFn()) { + clearInterval(this.interval); + return reject("Skipped phase"); + } + }); + }); + } + + /** + * Method to initialize phases and their corresponding methods. + */ + initPhases() { + for (const [phase, method] of this.PHASES) { + const originalStart = phase.prototype.start; + this.phases[phase.name] = originalStart; + phase.prototype.start = () => method.call(this, phase); + } + } + + /** + * Method to start a phase and log it. + * @param phase - The phase to start. + */ + startPhase(phase) { + this.log.push(phase.name); + const instance = this.scene.getCurrentPhase(); + this.onHold.push({ + name: phase.name, + call: () => { + this.phases[phase.name].apply(instance); + } + }); + } + + /** + * Method to start the prompt handler. + */ + startPromptHander() { + this.promptInterval = setInterval(() => { + if (this.prompts.length) { + const actionForNextPrompt = this.prompts[0]; + const expireFn = actionForNextPrompt.expireFn && actionForNextPrompt.expireFn(); + const currentMode = this.scene.ui.getMode(); + const currentPhase = this.scene.getCurrentPhase().constructor.name; + if (expireFn) { + this.prompts.shift(); + } else if (currentMode === actionForNextPrompt.mode && currentPhase === actionForNextPrompt.phaseTarget) { + this.prompts.shift().callback(); + } + } + }); + } + + /** + * Method to add an action to the next prompt. + * @param phaseTarget - The target phase for the prompt. + * @param mode - The mode of the UI. + * @param callback - The callback function to execute. + * @param expireFn - The function to determine if the prompt has expired. + */ + addToNextPrompt(phaseTarget: string, mode: Mode, callback: () => void, expireFn: () => void) { + this.prompts.push({ + phaseTarget, + mode, + callback, + expireFn + }); + } + + /** + * Restores the original state of phases and clears intervals. + * + * This function iterates through all phases and resets their `start` method to the original + * function stored in `this.phases`. Additionally, it clears the `promptInterval` and `interval`. + */ + restoreOg() { + for (const [phase] of this.PHASES) { + phase.prototype.start = this.phases[phase.name]; + } + clearInterval(this.promptInterval); + clearInterval(this.interval); + } +} diff --git a/src/test/utils/saves/everything.prsv b/src/test/utils/saves/everything.prsv new file mode 100644 index 00000000000..2e4a851eb8f --- /dev/null +++ b/src/test/utils/saves/everything.prsv @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/src/test/vitest.setup.ts b/src/test/vitest.setup.ts index 5777cc00611..8729e7796f0 100644 --- a/src/test/vitest.setup.ts +++ b/src/test/vitest.setup.ts @@ -1,5 +1,4 @@ import "vitest-canvas-mock"; -import "#app/test/phaser.setup"; import "#app/test/fontFace.setup"; import {initStatsKeys} from "#app/ui/game-stats-ui-handler"; import {initPokemonPrevolutions} from "#app/data/pokemon-evolutions"; @@ -9,7 +8,9 @@ import {initPokemonForms} from "#app/data/pokemon-forms"; import {initSpecies} from "#app/data/pokemon-species"; import {initMoves} from "#app/data/move"; import {initAbilities} from "#app/data/ability"; +import {initAchievements} from "#app/system/achv.js"; +initAchievements(); initStatsKeys(); initPokemonPrevolutions(); initBiomes(); diff --git a/src/ui/game-stats-ui-handler.ts b/src/ui/game-stats-ui-handler.ts index 86b4e71f72d..eda36919d3b 100644 --- a/src/ui/game-stats-ui-handler.ts +++ b/src/ui/game-stats-ui-handler.ts @@ -1,3 +1,4 @@ +import Phaser from "phaser"; import BattleScene from "../battle-scene"; import { TextStyle, addTextObject } from "./text"; import { Mode } from "./ui"; diff --git a/src/ui/starter-select-ui-handler.ts b/src/ui/starter-select-ui-handler.ts index 29926568d80..16406fad675 100644 --- a/src/ui/starter-select-ui-handler.ts +++ b/src/ui/starter-select-ui-handler.ts @@ -207,8 +207,8 @@ export default class StarterSelectUiHandler extends MessageUiHandler { private genSpecies: PokemonSpecies[][] = []; private lastSpecies: PokemonSpecies; private speciesLoaded: Map = new Map(); - private starterGens: integer[] = []; - private starterCursors: integer[] = []; + public starterGens: integer[] = []; + public starterCursors: integer[] = []; private pokerusGens: integer[] = []; private pokerusCursors: integer[] = []; private starterAttr: bigint[] = []; @@ -227,7 +227,7 @@ export default class StarterSelectUiHandler extends MessageUiHandler { private canAddParty: boolean; private assetLoadCancelled: Utils.BooleanHolder; - private cursorObj: Phaser.GameObjects.Image; + public cursorObj: Phaser.GameObjects.Image; private starterCursorObjs: Phaser.GameObjects.Image[]; private pokerusCursorObjs: Phaser.GameObjects.Image[]; private starterIcons: Phaser.GameObjects.Sprite[]; diff --git a/src/utils.test.ts b/src/utils.test.ts index 01bdd5db542..93f2a96ec4c 100644 --- a/src/utils.test.ts +++ b/src/utils.test.ts @@ -1,9 +1,15 @@ -import { expect, describe, it } from "vitest"; +import {expect, describe, it, beforeAll} from "vitest"; import { randomString, padInt } from "./utils"; import Phaser from "phaser"; describe("utils", () => { + + beforeAll(() => { + new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); describe("randomString", () => { it("should return a string of the specified length", () => { const str = randomString(10); diff --git a/vitest.config.js b/vitest.config.js index c73476431dd..5dcb326e1ea 100644 --- a/vitest.config.js +++ b/vitest.config.js @@ -15,6 +15,7 @@ export default defineConfig(({ mode }) => { }, threads: false, trace: true, + restoreMocks: true, environmentOptions: { jsdom: { resources: 'usable',