Compare commits
11 Commits
1e57f158e4
...
3456f33156
| Author | SHA1 | Date |
|---|---|---|
Blitzy
|
3456f33156 | |
|
NightKev
|
0989128deb | |
|
AJ Fontaine
|
4e0b10769b | |
|
Bertie690
|
4c17ebd400 | |
|
Madmadness65
|
ec09186264 | |
|
NightKev
|
e88b8aeb6f | |
|
AJ Fontaine
|
8d20b7b5e0 | |
|
damocleas
|
d14a5b8819 | |
|
NightKev
|
7563a6cd0b | |
|
AJ Fontaine
|
9fb9bb7e5d | |
|
damocleas
|
7ee573937e |
|
|
@ -1,12 +1,12 @@
|
|||
{
|
||||
"name": "pokemon-rogue-battle",
|
||||
"version": "1.5.0",
|
||||
"version": "1.5.2",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "pokemon-rogue-battle",
|
||||
"version": "1.5.0",
|
||||
"version": "1.5.2",
|
||||
"hasInstallScript": true,
|
||||
"dependencies": {
|
||||
"@material/material-color-utilities": "^0.2.7",
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"name": "pokemon-rogue-battle",
|
||||
"private": true,
|
||||
"version": "1.5.0",
|
||||
"version": "1.5.2",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"start": "vite",
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -869,6 +869,12 @@ export default class BattleScene extends SceneBase {
|
|||
return party.slice(0, Math.min(party.length, this.currentBattle?.double ? 2 : 1));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an array of Pokemon on both sides of the battle - player first, then enemy.
|
||||
* Does not actually check if the pokemon are on the field or not, and always has length 4 regardless of battle type.
|
||||
* @param activeOnly Whether to consider only active pokemon
|
||||
* @returns array of {@linkcode Pokemon}
|
||||
*/
|
||||
public getField(activeOnly: boolean = false): Pokemon[] {
|
||||
const ret = new Array(4).fill(null);
|
||||
const playerField = this.getPlayerField();
|
||||
|
|
@ -2084,8 +2090,11 @@ export default class BattleScene extends SceneBase {
|
|||
return sound;
|
||||
}
|
||||
|
||||
/** The loop point of any given battle, mystery encounter, or title track, read as seconds and milliseconds. */
|
||||
getBgmLoopPoint(bgmName: string): number {
|
||||
switch (bgmName) {
|
||||
case "title": //Firel PokéRogue Title
|
||||
return 46.500;
|
||||
case "battle_kanto_champion": //B2W2 Kanto Champion Battle
|
||||
return 13.950;
|
||||
case "battle_johto_champion": //B2W2 Johto Champion Battle
|
||||
|
|
|
|||
|
|
@ -1380,8 +1380,10 @@ export class UserHpDamageAttr extends FixedDamageAttr {
|
|||
}
|
||||
|
||||
export class TargetHalfHpDamageAttr extends FixedDamageAttr {
|
||||
// the initial amount of hp the target had before the first hit
|
||||
// used for multi lens
|
||||
/**
|
||||
* The initial amount of hp the target had before the first hit.
|
||||
* Used for calculating multi lens damage.
|
||||
*/
|
||||
private initialHp: number;
|
||||
constructor() {
|
||||
super(0);
|
||||
|
|
@ -1405,12 +1407,10 @@ export class TargetHalfHpDamageAttr extends FixedDamageAttr {
|
|||
// multi lens added hit; use initialHp tracker to ensure correct damage
|
||||
(args[0] as Utils.NumberHolder).value = Utils.toDmgValue(this.initialHp / 2);
|
||||
return true;
|
||||
break;
|
||||
case lensCount + 1:
|
||||
// parental bond added hit; calc damage as normal
|
||||
(args[0] as Utils.NumberHolder).value = Utils.toDmgValue(target.hp / 2);
|
||||
return true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -6129,7 +6129,7 @@ export class ForceSwitchOutAttr extends MoveEffectAttr {
|
|||
return false;
|
||||
}
|
||||
|
||||
// Don't allow wild mons to flee with U-turn et al
|
||||
// Don't allow wild mons to flee with U-turn et al.
|
||||
if (this.selfSwitch && !user.isPlayer() && move.category !== MoveCategory.STATUS) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -7084,7 +7084,25 @@ export class RepeatMoveAttr extends MoveEffectAttr {
|
|||
// get the last move used (excluding status based failures) as well as the corresponding moveset slot
|
||||
const lastMove = target.getLastXMoves(-1).find(m => m.move !== Moves.NONE)!;
|
||||
const movesetMove = target.getMoveset().find(m => m?.moveId === lastMove.move)!;
|
||||
const moveTargets = lastMove.targets ?? [];
|
||||
// If the last move used can hit more than one target or has variable targets,
|
||||
// re-compute the targets for the attack
|
||||
// (mainly for alternating double/single battle shenanigans)
|
||||
// Rampaging moves (e.g. Outrage) are not included due to being incompatible with Instruct
|
||||
// TODO: Fix this once dragon darts gets smart targeting
|
||||
let moveTargets = movesetMove.getMove().isMultiTarget() ? getMoveTargets(target, lastMove.move).targets : lastMove.targets;
|
||||
|
||||
/** In the event the instructed move's only target is a fainted opponent, redirect it to an alive ally if possible
|
||||
Normally, all yet-unexecuted move phases would swap over when the enemy in question faints
|
||||
(see `redirectPokemonMoves` in `battle-scene.ts`),
|
||||
but since instruct adds a new move phase pre-emptively, we need to handle this interaction manually.
|
||||
*/
|
||||
const firstTarget = globalScene.getField()[moveTargets[0]];
|
||||
if (globalScene.currentBattle.double && moveTargets.length === 1 && firstTarget.isFainted() && firstTarget !== target.getAlly()) {
|
||||
const ally = firstTarget.getAlly();
|
||||
if (ally.isActive()) { // ally exists, is not dead and can sponge the blast
|
||||
moveTargets = [ ally.getBattlerIndex() ];
|
||||
}
|
||||
}
|
||||
|
||||
globalScene.queueMessage(i18next.t("moveTriggers:instructingMove", {
|
||||
userPokemonName: getPokemonNameWithAffix(user),
|
||||
|
|
@ -7098,12 +7116,9 @@ export class RepeatMoveAttr extends MoveEffectAttr {
|
|||
|
||||
getCondition(): MoveConditionFunc {
|
||||
return (user, target, move) => {
|
||||
// TODO: Confirm behavior of instructing move known by target but called by another move
|
||||
const lastMove = target.getLastXMoves(-1).find(m => m.move !== Moves.NONE);
|
||||
const movesetMove = target.getMoveset().find(m => m?.moveId === lastMove?.move);
|
||||
const moveTargets = lastMove?.targets ?? [];
|
||||
// TODO: Add a way of adding moves to list procedurally rather than a pre-defined blacklist
|
||||
const unrepeatablemoves = [
|
||||
const uninstructableMoves = [
|
||||
// Locking/Continually Executed moves
|
||||
Moves.OUTRAGE,
|
||||
Moves.RAGING_FURY,
|
||||
|
|
@ -7158,11 +7173,11 @@ export class RepeatMoveAttr extends MoveEffectAttr {
|
|||
// TODO: Add Max/G-Move blockage if or when they are implemented
|
||||
];
|
||||
|
||||
if (!movesetMove // called move not in target's moveset (dancer, forgetting the move, etc.)
|
||||
if (!lastMove?.move // no move to instruct
|
||||
|| !movesetMove // called move not in target's moveset (forgetting the move, etc.)
|
||||
|| movesetMove.ppUsed === movesetMove.getMovePp() // move out of pp
|
||||
|| allMoves[lastMove?.move ?? Moves.NONE].isChargingMove() // called move is a charging/recharging move
|
||||
|| !moveTargets.length // called move has no targets
|
||||
|| unrepeatablemoves.includes(lastMove?.move ?? Moves.NONE)) { // called move is explicitly in the banlist
|
||||
|| allMoves[lastMove.move].isChargingMove() // called move is a charging/recharging move
|
||||
|| uninstructableMoves.includes(lastMove.move)) { // called move is in the banlist
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
|
@ -7170,7 +7185,7 @@ export class RepeatMoveAttr extends MoveEffectAttr {
|
|||
}
|
||||
|
||||
getTargetBenefitScore(user: Pokemon, target: Pokemon, move: Move): integer {
|
||||
// TODO: Make the AI acutally use instruct
|
||||
// TODO: Make the AI actually use instruct
|
||||
/* Ideally, the AI would score instruct based on the scorings of the on-field pokemons'
|
||||
* last used moves at the time of using Instruct (by the time the instructor gets to act)
|
||||
* with respect to the user's side.
|
||||
|
|
@ -10279,7 +10294,10 @@ export function initMoves() {
|
|||
new StatusMove(Moves.INSTRUCT, Type.PSYCHIC, -1, 15, -1, 0, 7)
|
||||
.ignoresSubstitute()
|
||||
.attr(RepeatMoveAttr)
|
||||
.edgeCase(), // incorrect interactions with Gigaton Hammer, Blood Moon & Torment
|
||||
// incorrect interactions with Gigaton Hammer, Blood Moon & Torment
|
||||
// Also has incorrect interactions with Dancer due to the latter
|
||||
// erroneously adding copied moves to move history.
|
||||
.edgeCase(),
|
||||
new AttackMove(Moves.BEAK_BLAST, Type.FLYING, MoveCategory.PHYSICAL, 100, 100, 15, -1, -3, 7)
|
||||
.attr(BeakBlastHeaderAttr)
|
||||
.ballBombMove()
|
||||
|
|
|
|||
|
|
@ -449,7 +449,7 @@ function getPokemonTradeOptions(): Map<number, EnemyPokemon[]> {
|
|||
});
|
||||
tradeOptionsMap.set(pokemon.id, tradeOptions);
|
||||
} else {
|
||||
const originalBst = pokemon.calculateBaseStats().reduce((a, b) => a + b, 0);
|
||||
const originalBst = pokemon.getSpeciesForm().getBaseStatTotal();
|
||||
|
||||
const tradeOptions: PokemonSpecies[] = [];
|
||||
for (let i = 0; i < 3; i++) {
|
||||
|
|
|
|||
|
|
@ -452,7 +452,7 @@ function getSpeciesFromPool(speciesPool: (Species | BreederSpeciesEvolution)[][]
|
|||
}
|
||||
|
||||
function calculateEggRewardsForPokemon(pokemon: PlayerPokemon): [number, number] {
|
||||
const bst = pokemon.calculateBaseStats().reduce((a, b) => a + b, 0);
|
||||
const bst = pokemon.getSpeciesForm().getBaseStatTotal();
|
||||
// 1 point for every 20 points below 680 BST the pokemon is, (max 18, min 1)
|
||||
const pointsFromBst = Math.min(Math.max(Math.floor((680 - bst) / 20), 1), 18);
|
||||
|
||||
|
|
|
|||
|
|
@ -147,8 +147,8 @@ export const TheStrongStuffEncounter: MysteryEncounter =
|
|||
// Sort party by bst
|
||||
const sortedParty = globalScene.getPlayerParty().slice(0)
|
||||
.sort((pokemon1, pokemon2) => {
|
||||
const pokemon1Bst = pokemon1.calculateBaseStats().reduce((a, b) => a + b, 0);
|
||||
const pokemon2Bst = pokemon2.calculateBaseStats().reduce((a, b) => a + b, 0);
|
||||
const pokemon1Bst = pokemon1.getSpeciesForm().getBaseStatTotal();
|
||||
const pokemon2Bst = pokemon2.getSpeciesForm().getBaseStatTotal();
|
||||
return pokemon2Bst - pokemon1Bst;
|
||||
});
|
||||
|
||||
|
|
|
|||
|
|
@ -360,7 +360,7 @@ function getTeamTransformations(): PokemonTransformation[] {
|
|||
const index = pokemonTransformations.findIndex(p => p.previousPokemon.id === removed.id);
|
||||
pokemonTransformations[index].heldItems = removed.getHeldItems().filter(m => !(m instanceof PokemonFormChangeItemModifier));
|
||||
|
||||
const bst = removed.calculateBaseStats().reduce((a, b) => a + b, 0);
|
||||
const bst = removed.getSpeciesForm().getBaseStatTotal();
|
||||
let newBstRange: [number, number];
|
||||
if (i < 2) {
|
||||
newBstRange = HIGH_BST_TRANSFORM_BASE_VALUES;
|
||||
|
|
|
|||
|
|
@ -890,7 +890,7 @@ export function getRandomEncounterSpecies(level: number, isBoss: boolean = false
|
|||
|
||||
if (eventEncounters.length > 0 && randSeedInt(2) === 1) {
|
||||
const eventEncounter = randSeedItem(eventEncounters);
|
||||
const levelSpecies = getPokemonSpecies(eventEncounter.species).getWildSpeciesForLevel(level, !isNullOrUndefined(eventEncounter.blockEvolution), isBoss, globalScene.gameMode);
|
||||
const levelSpecies = getPokemonSpecies(eventEncounter.species).getWildSpeciesForLevel(level, !eventEncounter.blockEvolution, isBoss, globalScene.gameMode);
|
||||
isEventEncounter = true;
|
||||
bossSpecies = getPokemonSpecies(levelSpecies);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ export function getNonVolatileStatusEffects():Array<StatusEffect> {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns whether a statuss effect is non volatile.
|
||||
* Returns whether a status effect is non volatile.
|
||||
* Non-volatile status condition is a status that remains after being switched out.
|
||||
* @param status The status to check
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -695,6 +695,7 @@ export class Arena {
|
|||
globalScene.loadBgm(this.bgm);
|
||||
}
|
||||
|
||||
/** The loop point of any given biome track, read as seconds and milliseconds. */
|
||||
getBgmLoopPoint(): number {
|
||||
switch (this.biomeType) {
|
||||
case Biome.TOWN:
|
||||
|
|
|
|||
|
|
@ -1108,6 +1108,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
|
|||
return this.getStat(Stat.HP);
|
||||
}
|
||||
|
||||
/** Returns the amount of hp currently missing from this {@linkcode Pokemon} (max - current) */
|
||||
getInverseHp(): integer {
|
||||
return this.getMaxHp() - this.hp;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ import { WeatherType } from "#enums/weather-type";
|
|||
*
|
||||
* Any override added here will be used instead of the value in {@linkcode DefaultOverrides}
|
||||
*
|
||||
* If an override name starts with "STARTING", it will apply when a new run begins
|
||||
* If an override name starts with "STARTING", it will only apply when a new run begins.
|
||||
*
|
||||
* @example
|
||||
* ```
|
||||
|
|
@ -39,7 +39,7 @@ const overrides = {} satisfies Partial<InstanceType<typeof DefaultOverrides>>;
|
|||
* ---
|
||||
* Defaults for Overrides that are used when testing different in game situations
|
||||
*
|
||||
* If an override name starts with "STARTING", it will apply when a new run begins
|
||||
* If an override name starts with "STARTING", it will only apply when a new run begins.
|
||||
*/
|
||||
class DefaultOverrides {
|
||||
// -----------------
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ export enum LearnMoveType {
|
|||
export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
|
||||
private moveId: Moves;
|
||||
private messageMode: Mode;
|
||||
private learnMoveType;
|
||||
private learnMoveType: LearnMoveType;
|
||||
private cost: number;
|
||||
|
||||
constructor(partyMemberIndex: integer, moveId: Moves, learnMoveType: LearnMoveType = LearnMoveType.LEARN_MOVE, cost: number = -1) {
|
||||
|
|
|
|||
|
|
@ -7,7 +7,6 @@ import GameManager from "#test/utils/gameManager";
|
|||
import Phaser from "phaser";
|
||||
import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
|
||||
|
||||
|
||||
describe("Abilities - Dancer", () => {
|
||||
let phaserGame: Phaser.Game;
|
||||
let game: GameManager;
|
||||
|
|
@ -24,20 +23,21 @@ describe("Abilities - Dancer", () => {
|
|||
|
||||
beforeEach(() => {
|
||||
game = new GameManager(phaserGame);
|
||||
game.override
|
||||
.battleType("double")
|
||||
.moveset([ Moves.SWORDS_DANCE, Moves.SPLASH ])
|
||||
.enemySpecies(Species.MAGIKARP)
|
||||
.enemyAbility(Abilities.DANCER)
|
||||
.enemyMoveset([ Moves.VICTORY_DANCE ]);
|
||||
game.override.battleType("double");
|
||||
});
|
||||
|
||||
// Reference Link: https://bulbapedia.bulbagarden.net/wiki/Dancer_(Ability)
|
||||
|
||||
it("triggers when dance moves are used, doesn't consume extra PP", async () => {
|
||||
game.override
|
||||
.enemyAbility(Abilities.DANCER)
|
||||
.enemySpecies(Species.MAGIKARP)
|
||||
.enemyMoveset(Moves.VICTORY_DANCE);
|
||||
await game.classicMode.startBattle([ Species.ORICORIO, Species.FEEBAS ]);
|
||||
|
||||
const [ oricorio ] = game.scene.getPlayerField();
|
||||
const [ oricorio, feebas ] = game.scene.getPlayerField();
|
||||
game.move.changeMoveset(oricorio, [ Moves.SWORDS_DANCE, Moves.VICTORY_DANCE, Moves.SPLASH ]);
|
||||
game.move.changeMoveset(feebas, [ Moves.SWORDS_DANCE, Moves.SPLASH ]);
|
||||
|
||||
game.move.select(Moves.SPLASH);
|
||||
game.move.select(Moves.SWORDS_DANCE, 1);
|
||||
|
|
@ -59,5 +59,44 @@ describe("Abilities - Dancer", () => {
|
|||
|
||||
// doesn't use PP if copied move is also in moveset
|
||||
expect(oricorio.moveset[0]?.ppUsed).toBe(0);
|
||||
expect(oricorio.moveset[1]?.ppUsed).toBe(0);
|
||||
});
|
||||
|
||||
// TODO: Enable after Dancer rework to not push to move history
|
||||
it.todo("should not count as the last move used for mirror move/instruct", async () => {
|
||||
game.override
|
||||
.moveset([ Moves.FIERY_DANCE, Moves.REVELATION_DANCE ])
|
||||
.enemyMoveset([ Moves.INSTRUCT, Moves.MIRROR_MOVE, Moves.SPLASH ])
|
||||
.enemySpecies(Species.SHUCKLE)
|
||||
.enemyLevel(10);
|
||||
await game.classicMode.startBattle([ Species.ORICORIO, Species.FEEBAS ]);
|
||||
|
||||
const [ oricorio ] = game.scene.getPlayerField();
|
||||
const [ , shuckle2 ] = game.scene.getEnemyField();
|
||||
|
||||
game.move.select(Moves.REVELATION_DANCE, BattlerIndex.PLAYER, BattlerIndex.ENEMY_2);
|
||||
game.move.select(Moves.FIERY_DANCE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY_2);
|
||||
await game.forceEnemyMove(Moves.INSTRUCT, BattlerIndex.PLAYER);
|
||||
await game.forceEnemyMove(Moves.MIRROR_MOVE, BattlerIndex.PLAYER);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY_2, BattlerIndex.ENEMY ]);
|
||||
await game.phaseInterceptor.to("MovePhase"); // Oricorio rev dance
|
||||
await game.phaseInterceptor.to("MovePhase"); // Feebas fiery dance
|
||||
await game.phaseInterceptor.to("MovePhase"); // Oricorio fiery dance (from dancer)
|
||||
await game.phaseInterceptor.to("MoveEndPhase", false);
|
||||
// dancer copied move doesn't appear in move history
|
||||
expect(oricorio.getLastXMoves(-1)[0].move).toBe(Moves.REVELATION_DANCE);
|
||||
|
||||
await game.phaseInterceptor.to("MovePhase"); // shuckle 2 mirror moves oricorio
|
||||
await game.phaseInterceptor.to("MovePhase"); // calls instructed rev dance
|
||||
let currentPhase = game.scene.getCurrentPhase() as MovePhase;
|
||||
expect(currentPhase.pokemon).toBe(shuckle2);
|
||||
expect(currentPhase.move.moveId).toBe(Moves.REVELATION_DANCE);
|
||||
|
||||
await game.phaseInterceptor.to("MovePhase"); // shuckle 1 instructs oricorio
|
||||
await game.phaseInterceptor.to("MovePhase");
|
||||
currentPhase = game.scene.getCurrentPhase() as MovePhase;
|
||||
expect(currentPhase.pokemon).toBe(oricorio);
|
||||
expect(currentPhase.move.moveId).toBe(Moves.REVELATION_DANCE);
|
||||
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
import { BattlerIndex } from "#app/battle";
|
||||
import type Pokemon from "#app/field/pokemon";
|
||||
import { MoveResult } from "#app/field/pokemon";
|
||||
import type { MovePhase } from "#app/phases/move-phase";
|
||||
import { Abilities } from "#enums/abilities";
|
||||
import { Moves } from "#enums/moves";
|
||||
import { Species } from "#enums/species";
|
||||
|
|
@ -12,10 +13,10 @@ describe("Moves - Instruct", () => {
|
|||
let phaserGame: Phaser.Game;
|
||||
let game: GameManager;
|
||||
|
||||
function instructSuccess(pokemon: Pokemon, move: Moves): void {
|
||||
expect(pokemon.getLastXMoves(-1)[0].move).toBe(move);
|
||||
expect(pokemon.getLastXMoves(-1)[1].move).toBe(pokemon.getLastXMoves()[0].move);
|
||||
expect(pokemon.getMoveset().find(m => m?.moveId === move)?.ppUsed).toBe(2);
|
||||
function instructSuccess(target: Pokemon, move: Moves): void {
|
||||
expect(target.getLastXMoves(-1)[0].move).toBe(move);
|
||||
expect(target.getLastXMoves(-1)[1].move).toBe(target.getLastXMoves()[0].move);
|
||||
expect(target.getMoveset().find(m => m?.moveId === move)?.ppUsed).toBe(2);
|
||||
}
|
||||
|
||||
beforeAll(() => {
|
||||
|
|
@ -36,27 +37,40 @@ describe("Moves - Instruct", () => {
|
|||
.enemyAbility(Abilities.NO_GUARD)
|
||||
.enemyLevel(100)
|
||||
.startingLevel(100)
|
||||
.ability(Abilities.BALL_FETCH)
|
||||
.moveset([ Moves.INSTRUCT, Moves.SONIC_BOOM, Moves.SPLASH, Moves.TORMENT ])
|
||||
.disableCrits();
|
||||
});
|
||||
|
||||
it("should repeat enemy's attack move when moving last", async () => {
|
||||
it("should repeat target's last used move", async () => {
|
||||
game.override
|
||||
.moveset(Moves.INSTRUCT)
|
||||
.enemyLevel(1000); // ensures shuckle no die
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
const enemy = game.scene.getEnemyPokemon()!;
|
||||
game.move.changeMoveset(enemy, Moves.SONIC_BOOM);
|
||||
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
await game.forceEnemyMove(Moves.SONIC_BOOM, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.forceEnemyMove(Moves.SONIC_BOOM);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
|
||||
await game.phaseInterceptor.to("MovePhase"); // enemy attacks us
|
||||
await game.phaseInterceptor.to("MovePhase", false); // instruct
|
||||
let currentPhase = game.scene.getCurrentPhase() as MovePhase;
|
||||
expect(currentPhase.pokemon).toBe(game.scene.getPlayerPokemon());
|
||||
await game.phaseInterceptor.to("MoveEndPhase");
|
||||
|
||||
await game.phaseInterceptor.to("MovePhase", false); // enemy repeats move
|
||||
currentPhase = game.scene.getCurrentPhase() as MovePhase;
|
||||
expect(currentPhase.pokemon).toBe(enemy);
|
||||
expect(currentPhase.move.moveId).toBe(Moves.SONIC_BOOM);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
expect(game.scene.getPlayerPokemon()?.getInverseHp()).toBe(40);
|
||||
instructSuccess(enemy, Moves.SONIC_BOOM);
|
||||
expect(game.scene.getPlayerPokemon()?.getInverseHp()).toBe(40);
|
||||
});
|
||||
|
||||
it("should repeat enemy's move through substitute", async () => {
|
||||
game.override.moveset([ Moves.INSTRUCT, Moves.SPLASH ]);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
const enemy = game.scene.getEnemyPokemon()!;
|
||||
|
|
@ -72,75 +86,94 @@ describe("Moves - Instruct", () => {
|
|||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
expect(game.scene.getPlayerPokemon()?.getInverseHp()).toBe(40);
|
||||
instructSuccess(game.scene.getEnemyPokemon()!, Moves.SONIC_BOOM);
|
||||
expect(game.scene.getPlayerPokemon()?.getInverseHp()).toBe(40);
|
||||
});
|
||||
|
||||
it("should repeat ally's attack on enemy", async () => {
|
||||
game.override
|
||||
.battleType("double")
|
||||
.moveset([]);
|
||||
.enemyMoveset(Moves.SPLASH);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS, Species.SHUCKLE ]);
|
||||
|
||||
const [ amoonguss, shuckle ] = game.scene.getPlayerField();
|
||||
game.move.changeMoveset(amoonguss, Moves.INSTRUCT);
|
||||
game.move.changeMoveset(shuckle, Moves.SONIC_BOOM);
|
||||
game.move.changeMoveset(amoonguss, [ Moves.INSTRUCT, Moves.SONIC_BOOM ]);
|
||||
game.move.changeMoveset(shuckle, [ Moves.INSTRUCT, Moves.SONIC_BOOM ]);
|
||||
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.PLAYER_2);
|
||||
game.move.select(Moves.SONIC_BOOM, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
expect(game.scene.getEnemyField()[0].getInverseHp()).toBe(40);
|
||||
instructSuccess(shuckle, Moves.SONIC_BOOM);
|
||||
expect(game.scene.getEnemyField()[0].getInverseHp()).toBe(40);
|
||||
});
|
||||
|
||||
// TODO: Enable test case once gigaton hammer (and blood moon) is fixed
|
||||
// TODO: Enable test case once gigaton hammer (and blood moon) are reworked
|
||||
it.todo("should repeat enemy's Gigaton Hammer", async () => {
|
||||
game.override
|
||||
.moveset(Moves.INSTRUCT)
|
||||
.enemyLevel(5);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
const enemy = game.scene.getEnemyPokemon()!;
|
||||
game.move.changeMoveset(enemy, Moves.GIGATON_HAMMER);
|
||||
game.move.changeMoveset(enemy, [ Moves.GIGATON_HAMMER, Moves.BLOOD_MOON ]);
|
||||
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
await game.phaseInterceptor.to("BerryPhase");
|
||||
|
||||
instructSuccess(enemy, Moves.GIGATON_HAMMER);
|
||||
expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived.length).toBe(2);
|
||||
});
|
||||
|
||||
it("should add moves to move queue for copycat", async () => {
|
||||
game.override
|
||||
.battleType("double")
|
||||
.moveset(Moves.INSTRUCT)
|
||||
.enemyLevel(5);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
const [ enemy1, enemy2 ] = game.scene.getEnemyField()!;
|
||||
game.move.changeMoveset(enemy1, Moves.WATER_GUN);
|
||||
game.move.changeMoveset(enemy2, Moves.COPYCAT);
|
||||
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("BerryPhase");
|
||||
|
||||
instructSuccess(enemy1, Moves.WATER_GUN);
|
||||
// amoonguss gets hit by water gun thrice; once by original attack, once by instructed use and once by copycat
|
||||
expect(game.scene.getPlayerPokemon()!.turnData.attacksReceived.length).toBe(3);
|
||||
});
|
||||
|
||||
it("should respect enemy's status condition", async () => {
|
||||
game.override
|
||||
.moveset([ Moves.THUNDER_WAVE, Moves.INSTRUCT ])
|
||||
.enemyMoveset([ Moves.SPLASH, Moves.SONIC_BOOM ]);
|
||||
.moveset([ Moves.INSTRUCT, Moves.THUNDER_WAVE ])
|
||||
.enemyMoveset(Moves.SONIC_BOOM);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
game.move.select(Moves.THUNDER_WAVE);
|
||||
await game.forceEnemyMove(Moves.SONIC_BOOM);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.toNextTurn();
|
||||
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.move.forceStatusActivation(true);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
|
||||
await game.phaseInterceptor.to("MovePhase");
|
||||
// force enemy's instructed move to bork and then immediately thaw out
|
||||
await game.move.forceStatusActivation(true);
|
||||
await game.move.forceStatusActivation(false);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
const moveHistory = game.scene.getEnemyPokemon()!.getMoveHistory();
|
||||
expect(moveHistory.length).toBe(3);
|
||||
expect(moveHistory[0].move).toBe(Moves.SONIC_BOOM);
|
||||
expect(moveHistory[1].move).toBe(Moves.NONE);
|
||||
expect(moveHistory[2].move).toBe(Moves.SONIC_BOOM);
|
||||
const moveHistory = game.scene.getEnemyPokemon()?.getLastXMoves(-1)!;
|
||||
expect(moveHistory.map(m => m.move)).toEqual([ Moves.SONIC_BOOM, Moves.NONE, Moves.SONIC_BOOM ]);
|
||||
expect(game.scene.getPlayerPokemon()?.getInverseHp()).toBe(40);
|
||||
});
|
||||
|
||||
it("should not repeat enemy's out of pp move", async () => {
|
||||
game.override.enemySpecies(Species.UNOWN);
|
||||
game.override
|
||||
.moveset(Moves.INSTRUCT)
|
||||
.enemySpecies(Species.UNOWN);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
const enemyPokemon = game.scene.getEnemyPokemon()!;
|
||||
|
|
@ -153,13 +186,85 @@ describe("Moves - Instruct", () => {
|
|||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
const playerMove = game.scene.getPlayerPokemon()!.getLastXMoves()!;
|
||||
expect(playerMove[0].result).toBe(MoveResult.FAIL);
|
||||
const playerMoves = game.scene.getPlayerPokemon()!.getLastXMoves(-1)!;
|
||||
expect(playerMoves[0].result).toBe(MoveResult.FAIL);
|
||||
expect(enemyPokemon.getMoveHistory().length).toBe(1);
|
||||
});
|
||||
|
||||
it("should redirect attacking moves if enemy faints", async () => {
|
||||
game.override
|
||||
.battleType("double")
|
||||
.enemyMoveset(Moves.SPLASH)
|
||||
.enemySpecies(Species.MAGIKARP)
|
||||
.enemyLevel(1);
|
||||
await game.classicMode.startBattle([ Species.HISUI_ELECTRODE, Species.KOMMO_O ]);
|
||||
|
||||
const [ electrode, kommo_o ] = game.scene.getPlayerField()!;
|
||||
game.move.changeMoveset(electrode, Moves.CHLOROBLAST);
|
||||
game.move.changeMoveset(kommo_o, Moves.INSTRUCT);
|
||||
|
||||
game.move.select(Moves.CHLOROBLAST, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("BerryPhase");
|
||||
|
||||
// Chloroblast always deals 50% max HP% recoil UNLESS you whiff
|
||||
// due to lack of targets or similar,
|
||||
// so all we have to do is check whether electrode fainted or not.
|
||||
// Naturally, both karps should also be dead as well.
|
||||
expect(electrode.isFainted()).toBe(true);
|
||||
const [ karp1, karp2 ] = game.scene.getEnemyField()!;
|
||||
expect(karp1.isFainted()).toBe(true);
|
||||
expect(karp2.isFainted()).toBe(true);
|
||||
}),
|
||||
|
||||
it("should allow for dancer copying of instructed dance move", async () => {
|
||||
game.override
|
||||
.battleType("double")
|
||||
.enemyMoveset([ Moves.INSTRUCT, Moves.SPLASH ]);
|
||||
await game.classicMode.startBattle([ Species.ORICORIO, Species.VOLCARONA ]);
|
||||
|
||||
const [ oricorio, volcarona ] = game.scene.getPlayerField();
|
||||
game.move.changeMoveset(oricorio, Moves.SPLASH);
|
||||
game.move.changeMoveset(volcarona, Moves.FIERY_DANCE);
|
||||
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.FIERY_DANCE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
|
||||
await game.forceEnemyMove(Moves.INSTRUCT, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("BerryPhase");
|
||||
|
||||
// fiery dance triggered dancer successfully for a total of 4 hits
|
||||
// Volcarona fiery dance has a _small_ chance to 3HKO a shuckle in worst case, so we add the hit count of both
|
||||
// foes to account for spillover
|
||||
instructSuccess(volcarona, Moves.FIERY_DANCE);
|
||||
expect(game.scene.getEnemyField()[0].turnData.attacksReceived.length +
|
||||
game.scene.getEnemyField()[1].turnData.attacksReceived.length).toBe(4);
|
||||
});
|
||||
|
||||
it("should not repeat move when switching out", async () => {
|
||||
game.override
|
||||
.enemyMoveset(Moves.INSTRUCT)
|
||||
.enemySpecies(Species.UNOWN);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS, Species.TOXICROAK ]);
|
||||
|
||||
const amoonguss = game.scene.getPlayerPokemon()!;
|
||||
game.move.changeMoveset(amoonguss, Moves.SEED_BOMB);
|
||||
|
||||
amoonguss.battleSummonData.moveHistory = [{ move: Moves.SEED_BOMB, targets: [ BattlerIndex.ENEMY ], result: MoveResult.SUCCESS }];
|
||||
|
||||
game.doSwitchPokemon(1);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
const enemyMoves = game.scene.getEnemyPokemon()!.getLastXMoves(-1)!;
|
||||
expect(enemyMoves[0].result).toBe(MoveResult.FAIL);
|
||||
});
|
||||
|
||||
it("should fail if no move has yet been used by target", async () => {
|
||||
game.override.enemyMoveset(Moves.SPLASH);
|
||||
game.override
|
||||
.moveset(Moves.INSTRUCT)
|
||||
.enemyMoveset(Moves.SPLASH);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
|
|
@ -183,48 +288,46 @@ describe("Moves - Instruct", () => {
|
|||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.DISABLE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
|
||||
await game.forceEnemyMove(Moves.SONIC_BOOM, BattlerIndex.PLAYER);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
expect(game.scene.getPlayerField()[0].getLastXMoves()[0].result).toBe(MoveResult.SUCCESS);
|
||||
const enemyMove = game.scene.getEnemyPokemon()!.getLastXMoves()[0];
|
||||
const enemyMove = game.scene.getEnemyField()[0]!.getLastXMoves()[0];
|
||||
expect(enemyMove.result).toBe(MoveResult.FAIL);
|
||||
expect(game.scene.getEnemyPokemon()!.getMoveset().find(m => m?.moveId === Moves.SONIC_BOOM)?.ppUsed).toBe(1);
|
||||
|
||||
expect(game.scene.getEnemyField()[0].getMoveset().find(m => m?.moveId === Moves.SONIC_BOOM)?.ppUsed).toBe(1);
|
||||
});
|
||||
|
||||
it("should not repeat enemy's move through protect", async () => {
|
||||
game.override.moveset([ Moves.INSTRUCT ]);
|
||||
await game.classicMode.startBattle([ Species.AMOONGUSS ]);
|
||||
|
||||
const MoveToUse = Moves.PROTECT;
|
||||
const enemyPokemon = game.scene.getEnemyPokemon()!;
|
||||
game.move.changeMoveset(enemyPokemon, MoveToUse);
|
||||
const enemy = game.scene.getEnemyPokemon()!;
|
||||
game.move.changeMoveset(enemy, Moves.PROTECT);
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.forceEnemyMove(Moves.PROTECT);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
expect(enemyPokemon.getLastXMoves(-1)[0].move).toBe(Moves.PROTECT);
|
||||
expect(enemyPokemon.getLastXMoves(-1)[1]).toBeUndefined(); // undefined because protect failed
|
||||
expect(enemyPokemon.getMoveset().find(m => m?.moveId === Moves.PROTECT)?.ppUsed).toBe(1);
|
||||
expect(enemy.getLastXMoves(-1)[0].move).toBe(Moves.PROTECT);
|
||||
expect(enemy.getLastXMoves(-1)[1]).toBeUndefined(); // undefined because instruct failed and didn't repeat
|
||||
expect(enemy.getMoveset().find(m => m?.moveId === Moves.PROTECT)?.ppUsed).toBe(1);
|
||||
});
|
||||
|
||||
it("should not repeat enemy's charging move", async () => {
|
||||
game.override
|
||||
.enemyMoveset([ Moves.SONIC_BOOM, Moves.HYPER_BEAM ])
|
||||
.enemyLevel(5);
|
||||
.moveset([ Moves.INSTRUCT ])
|
||||
.enemyMoveset([ Moves.SONIC_BOOM, Moves.HYPER_BEAM ]);
|
||||
await game.classicMode.startBattle([ Species.SHUCKLE ]);
|
||||
|
||||
const player = game.scene.getPlayerPokemon()!;
|
||||
const enemyPokemon = game.scene.getEnemyPokemon()!;
|
||||
enemyPokemon.battleSummonData.moveHistory = [{ move: Moves.SONIC_BOOM, targets: [ BattlerIndex.PLAYER ], result: MoveResult.SUCCESS, virtual: false }];
|
||||
const enemy = game.scene.getEnemyPokemon()!;
|
||||
enemy.battleSummonData.moveHistory = [{ move: Moves.SONIC_BOOM, targets: [ BattlerIndex.PLAYER ], result: MoveResult.SUCCESS, virtual: false }];
|
||||
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.forceEnemyMove(Moves.HYPER_BEAM);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.toNextTurn();
|
||||
|
||||
// instruct fails at copying last move due to charging turn (rather than instructing sonic boom)
|
||||
expect(player.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
|
||||
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
|
|
@ -234,31 +337,162 @@ describe("Moves - Instruct", () => {
|
|||
expect(player.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
|
||||
});
|
||||
|
||||
it("should not repeat dance move not known by target", async () => {
|
||||
it("should not repeat move since forgotten by target", async () => {
|
||||
game.override
|
||||
.battleType("double")
|
||||
.moveset([ Moves.INSTRUCT, Moves.FIERY_DANCE ])
|
||||
.enemyMoveset(Moves.SPLASH)
|
||||
.enemyAbility(Abilities.DANCER);
|
||||
await game.classicMode.startBattle([ Species.SHUCKLE, Species.SHUCKLE ]);
|
||||
.enemyLevel(5)
|
||||
.xpMultiplier(0)
|
||||
.enemySpecies(Species.WURMPLE)
|
||||
.enemyMoveset(Moves.INSTRUCT);
|
||||
await game.classicMode.startBattle([ Species.REGIELEKI ]);
|
||||
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.FIERY_DANCE, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
|
||||
const regieleki = game.scene.getPlayerPokemon()!;
|
||||
// fill out moveset with random moves
|
||||
game.move.changeMoveset(regieleki, [ Moves.ELECTRO_DRIFT, Moves.SPLASH, Moves.ICE_BEAM, Moves.ANCIENT_POWER ]);
|
||||
|
||||
game.move.select(Moves.ELECTRO_DRIFT);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
|
||||
await game.phaseInterceptor.to("FaintPhase");
|
||||
await game.move.learnMove(Moves.ELECTROWEB);
|
||||
await game.toNextWave();
|
||||
|
||||
game.move.select(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
expect(game.scene.getEnemyField()[0].getLastXMoves()[0].result).toBe(MoveResult.FAIL);
|
||||
});
|
||||
|
||||
it("should disregard priority of instructed move on use", async () => {
|
||||
game.override
|
||||
.enemyMoveset([ Moves.SPLASH, Moves.WHIRLWIND ])
|
||||
.moveset(Moves.INSTRUCT);
|
||||
await game.classicMode.startBattle([ Species.LUCARIO, Species.BANETTE ]);
|
||||
|
||||
const enemyPokemon = game.scene.getEnemyPokemon()!;
|
||||
enemyPokemon.battleSummonData.moveHistory = [{ move: Moves.WHIRLWIND, targets: [ BattlerIndex.PLAYER ], result: MoveResult.SUCCESS, virtual: false }];
|
||||
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
// lucario instructed enemy whirlwind at 0 priority to switch itself out
|
||||
const instructedMove = enemyPokemon.getLastXMoves(-1)[1];
|
||||
expect(instructedMove.result).toBe(MoveResult.SUCCESS);
|
||||
expect(instructedMove.move).toBe(Moves.WHIRLWIND);
|
||||
expect(game.scene.getPlayerPokemon()?.species.speciesId).toBe(Species.BANETTE);
|
||||
});
|
||||
|
||||
it("should respect moves' original priority for psychic terrain", async () => {
|
||||
game.override.
|
||||
battleType("double")
|
||||
.moveset([ Moves.QUICK_ATTACK, Moves.SPLASH, Moves.INSTRUCT ])
|
||||
.enemyMoveset([ Moves.SPLASH, Moves.PSYCHIC_TERRAIN ]);
|
||||
await game.classicMode.startBattle([ Species.BANETTE, Species.KLEFKI ]);
|
||||
|
||||
game.move.select(Moves.QUICK_ATTACK, BattlerIndex.PLAYER, BattlerIndex.ENEMY); // succeeds due to terrain no
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.forceEnemyMove(Moves.PSYCHIC_TERRAIN);
|
||||
await game.toNextTurn();
|
||||
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
|
||||
expect(game.scene.getPlayerField()[0].getLastXMoves()[0].result).toBe(MoveResult.FAIL);
|
||||
// quick attack failed when instructed
|
||||
const banette = game.scene.getPlayerPokemon()!;
|
||||
expect(banette.getLastXMoves(-1)[1].move).toBe(Moves.QUICK_ATTACK);
|
||||
expect(banette.getLastXMoves(-1)[1].result).toBe(MoveResult.FAIL);
|
||||
});
|
||||
|
||||
it("should still work w/ prankster in psychic terrain", async () => {
|
||||
game.override.
|
||||
battleType("double")
|
||||
.enemyMoveset([ Moves.SPLASH, Moves.PSYCHIC_TERRAIN ]);
|
||||
await game.classicMode.startBattle([ Species.BANETTE, Species.KLEFKI ]);
|
||||
|
||||
const [ banette, klefki ] = game.scene.getPlayerField()!;
|
||||
game.move.changeMoveset(banette, [ Moves.VINE_WHIP, Moves.SPLASH ]);
|
||||
game.move.changeMoveset(klefki, [ Moves.INSTRUCT, Moves.SPLASH ]);
|
||||
|
||||
game.move.select(Moves.VINE_WHIP, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.forceEnemyMove(Moves.PSYCHIC_TERRAIN);
|
||||
await game.toNextTurn();
|
||||
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER); // copies vine whip
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
expect(banette.getLastXMoves(-1)[1].move).toBe(Moves.VINE_WHIP);
|
||||
expect(banette.getLastXMoves(-1)[2].move).toBe(Moves.VINE_WHIP);
|
||||
expect(banette.getMoveset().find(m => m?.moveId === Moves.VINE_WHIP )?.ppUsed).toBe(2);
|
||||
});
|
||||
|
||||
it("should cause spread moves to correctly hit targets in doubles after singles", async () => {
|
||||
game.override
|
||||
.battleType("even-doubles")
|
||||
.moveset([ Moves.BREAKING_SWIPE, Moves.INSTRUCT, Moves.SPLASH ])
|
||||
.enemyMoveset(Moves.SONIC_BOOM)
|
||||
.enemySpecies(Species.AXEW)
|
||||
.startingLevel(500);
|
||||
await game.classicMode.startBattle([ Species.KORAIDON, Species.KLEFKI ]);
|
||||
|
||||
const koraidon = game.scene.getPlayerField()[0]!;
|
||||
|
||||
game.move.select(Moves.BREAKING_SWIPE);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
expect(koraidon.getInverseHp()).toBe(0);
|
||||
expect(koraidon.getLastXMoves(-1)[0].targets).toEqual([ BattlerIndex.ENEMY ]);
|
||||
await game.toNextWave();
|
||||
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
// did not take damage since enemies died beforehand;
|
||||
// last move used hit both enemies
|
||||
expect(koraidon.getInverseHp()).toBe(0);
|
||||
expect(koraidon.getLastXMoves(-1)[1].targets?.sort()).toEqual([ BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
});
|
||||
|
||||
it("should cause AoE moves to correctly hit everyone in doubles after singles", async () => {
|
||||
game.override
|
||||
.battleType("even-doubles")
|
||||
.moveset([ Moves.BRUTAL_SWING, Moves.INSTRUCT, Moves.SPLASH ])
|
||||
.enemySpecies(Species.AXEW)
|
||||
.enemyMoveset(Moves.SONIC_BOOM)
|
||||
.startingLevel(500);
|
||||
await game.classicMode.startBattle([ Species.KORAIDON, Species.KLEFKI ]);
|
||||
|
||||
const koraidon = game.scene.getPlayerField()[0]!;
|
||||
|
||||
game.move.select(Moves.BRUTAL_SWING);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
expect(koraidon.getInverseHp()).toBe(0);
|
||||
expect(koraidon.getLastXMoves(-1)[0].targets).toEqual([ BattlerIndex.ENEMY ]);
|
||||
await game.toNextWave();
|
||||
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.PLAYER);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER_2, BattlerIndex.PLAYER, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
await game.phaseInterceptor.to("TurnEndPhase", false);
|
||||
// did not take damage since enemies died beforehand;
|
||||
// last move used hit everything around it
|
||||
expect(koraidon.getInverseHp()).toBe(0);
|
||||
expect(koraidon.getLastXMoves(-1)[1].targets?.sort()).toEqual([ BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
});
|
||||
|
||||
it("should cause multi-hit moves to hit the appropriate number of times in singles", async () => {
|
||||
game.override
|
||||
.enemyAbility(Abilities.SKILL_LINK)
|
||||
.moveset([ Moves.SPLASH, Moves.INSTRUCT ])
|
||||
.enemyMoveset(Moves.BULLET_SEED);
|
||||
await game.classicMode.startBattle([ Species.BULBASAUR ]);
|
||||
|
||||
const player = game.scene.getPlayerPokemon()!;
|
||||
const bulbasaur = game.scene.getPlayerPokemon()!;
|
||||
|
||||
game.move.select(Moves.SPLASH);
|
||||
await game.toNextTurn();
|
||||
|
|
@ -267,34 +501,35 @@ describe("Moves - Instruct", () => {
|
|||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
|
||||
await game.phaseInterceptor.to("BerryPhase");
|
||||
|
||||
expect(player.turnData.attacksReceived.length).toBe(10);
|
||||
expect(bulbasaur.turnData.attacksReceived.length).toBe(10);
|
||||
|
||||
await game.toNextTurn();
|
||||
game.move.select(Moves.INSTRUCT);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.PLAYER ]);
|
||||
await game.phaseInterceptor.to("BerryPhase");
|
||||
|
||||
expect(player.turnData.attacksReceived.length).toBe(10);
|
||||
expect(bulbasaur.turnData.attacksReceived.length).toBe(10);
|
||||
});
|
||||
|
||||
it("should cause multi-hit moves to hit the appropriate number of times in doubles", async () => {
|
||||
game.override
|
||||
.battleType("double")
|
||||
.enemyAbility(Abilities.SKILL_LINK)
|
||||
.moveset([ Moves.SPLASH, Moves.INSTRUCT ])
|
||||
.enemyMoveset([ Moves.BULLET_SEED, Moves.SPLASH ])
|
||||
.enemyLevel(5);
|
||||
await game.classicMode.startBattle([ Species.BULBASAUR, Species.IVYSAUR ]);
|
||||
|
||||
const [ , ivysaur ] = game.scene.getPlayerField();
|
||||
|
||||
game.move.select(Moves.SPLASH);
|
||||
game.move.select(Moves.SPLASH, 1);
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER);
|
||||
game.move.select(Moves.SPLASH, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.BULLET_SEED, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.toNextTurn();
|
||||
|
||||
game.move.select(Moves.INSTRUCT, 0, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, 1, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
|
||||
await game.forceEnemyMove(Moves.BULLET_SEED, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
|
||||
|
|
@ -303,8 +538,8 @@ describe("Moves - Instruct", () => {
|
|||
expect(ivysaur.turnData.attacksReceived.length).toBe(15);
|
||||
|
||||
await game.toNextTurn();
|
||||
game.move.select(Moves.INSTRUCT, 0, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, 1, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER, BattlerIndex.ENEMY);
|
||||
game.move.select(Moves.INSTRUCT, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY);
|
||||
await game.forceEnemyMove(Moves.BULLET_SEED, BattlerIndex.PLAYER_2);
|
||||
await game.forceEnemyMove(Moves.SPLASH);
|
||||
await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER, BattlerIndex.PLAYER_2 ]);
|
||||
|
|
|
|||
|
|
@ -129,9 +129,10 @@ export default class GameManager {
|
|||
|
||||
/**
|
||||
* Adds an action to be executed on the next prompt.
|
||||
* This can be used to (among other things) simulate inputs or run functions mid-phase.
|
||||
* @param phaseTarget - The target phase.
|
||||
* @param mode - The mode to wait for.
|
||||
* @param callback - The callback to execute.
|
||||
* @param callback - The callback function to execute on next prompt.
|
||||
* @param expireFn - Optional function to determine if the prompt has expired.
|
||||
*/
|
||||
onNextPrompt(phaseTarget: string, mode: Mode, callback: () => void, expireFn?: () => void, awaitingActionInput: boolean = false) {
|
||||
|
|
@ -400,6 +401,11 @@ export default class GameManager {
|
|||
return updateUserInfo();
|
||||
}
|
||||
|
||||
/**
|
||||
* Faints a player or enemy pokemon instantly by setting their HP to 0.
|
||||
* @param pokemon The player/enemy pokemon being fainted
|
||||
* @returns A promise that resolves once the fainted pokemon's FaintPhase finishes running.
|
||||
*/
|
||||
async killPokemon(pokemon: PlayerPokemon | EnemyPokemon) {
|
||||
return new Promise<void>(async (resolve, reject) => {
|
||||
pokemon.hp = 0;
|
||||
|
|
@ -453,8 +459,9 @@ export default class GameManager {
|
|||
}
|
||||
|
||||
/**
|
||||
* Intercepts `TurnStartPhase` and mocks the getSpeedOrder's return value {@linkcode TurnStartPhase.getSpeedOrder}
|
||||
* Used to modify the turn order.
|
||||
* Intercepts `TurnStartPhase` and mocks {@linkcode TurnStartPhase.getSpeedOrder}'s return value.
|
||||
* Used to manually modify Pokemon turn order.
|
||||
* Note: This *DOES NOT* account for priority, only speed.
|
||||
* @param {BattlerIndex[]} order The turn order to set
|
||||
* @example
|
||||
* ```ts
|
||||
|
|
@ -468,7 +475,7 @@ export default class GameManager {
|
|||
}
|
||||
|
||||
/**
|
||||
* Removes all held items from enemy pokemon
|
||||
* Removes all held items from enemy pokemon.
|
||||
*/
|
||||
removeEnemyHeldItems(): void {
|
||||
this.scene.clearEnemyHeldItemModifiers();
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ export class OverridesHelper extends GameManagerHelper {
|
|||
}
|
||||
|
||||
/**
|
||||
* Override the player (pokemon) {@linkcode Abilities | ability}
|
||||
* Override the player (pokemon) {@linkcode Abilities | ability}.
|
||||
* @param ability the (pokemon) {@linkcode Abilities | ability} to set
|
||||
* @returns `this`
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ const timedEvents: TimedEvent[] = [
|
|||
endDate: new Date(Date.UTC(2025, 1, 3, 0)),
|
||||
bannerKey: "yearofthesnakeevent-",
|
||||
scale: 0.21,
|
||||
availableLangs: [],
|
||||
availableLangs: [ "en", "de", "it", "fr", "ja", "ko", "es-ES", "pt-BR", "zh-CN" ],
|
||||
eventEncounters: [
|
||||
{ species: Species.EKANS },
|
||||
{ species: Species.ONIX },
|
||||
|
|
|
|||
|
|
@ -269,7 +269,7 @@ export default class UI extends Phaser.GameObjects.Container {
|
|||
return false;
|
||||
}
|
||||
|
||||
if ([ Mode.CONFIRM, Mode.COMMAND, Mode.FIGHT, Mode.MESSAGE ].includes(this.mode)) {
|
||||
if ([ Mode.CONFIRM, Mode.COMMAND, Mode.FIGHT, Mode.MESSAGE, Mode.TARGET_SELECT ].includes(this.mode)) {
|
||||
globalScene?.processInfoButton(pressed);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -277,6 +277,11 @@ export default class UI extends Phaser.GameObjects.Container {
|
|||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a player input of a button (delivering it to the current UI handler for processing)
|
||||
* @param button The {@linkcode Button} being inputted
|
||||
* @returns true if the input attempt succeeds
|
||||
*/
|
||||
processInput(button: Button): boolean {
|
||||
if (this.overlayActive) {
|
||||
return false;
|
||||
|
|
|
|||
Loading…
Reference in New Issue