From 6b34ea3c462d50323af3c8b447f17a42105400c2 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Sat, 16 Aug 2025 14:32:47 -0500 Subject: [PATCH 1/9] Add failure conditions and move failures part 1 --- src/data/battler-tags.ts | 157 ++++++----- src/data/moves/move-condition.ts | 117 ++++++++ src/data/moves/move.ts | 209 ++++++++------ src/data/moves/pokemon-move.ts | 50 +++- src/enums/battler-tag-lapse-type.ts | 17 +- src/enums/move-flags.ts | 4 +- src/field/pokemon.ts | 69 ++++- src/phases/command-phase.ts | 56 +--- src/phases/move-header-phase.ts | 2 +- src/phases/move-phase.ts | 409 +++++++++++++++++++--------- test/moves/belch.test.ts | 49 ++++ 11 files changed, 783 insertions(+), 356 deletions(-) create mode 100644 src/data/moves/move-condition.ts create mode 100644 test/moves/belch.test.ts diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts index 5fcc831f447..69e1812a164 100644 --- a/src/data/battler-tags.ts +++ b/src/data/battler-tags.ts @@ -9,7 +9,7 @@ import { getStatusEffectHealText } from "#data/status-effect"; import { TerrainType } from "#data/terrain"; import { AbilityId } from "#enums/ability-id"; import type { BattlerIndex } from "#enums/battler-index"; -import { BattlerTagLapseType } from "#enums/battler-tag-lapse-type"; +import { BattlerTagLapseType, type NonCustomBattlerTagLapseType } from "#enums/battler-tag-lapse-type"; import { BattlerTagType } from "#enums/battler-tag-type"; import { HitResult } from "#enums/hit-result"; import { ChargeAnim, CommonAnim } from "#enums/move-anims-common"; @@ -121,6 +121,11 @@ export class BattlerTag implements BaseBattlerTag { } #lapseTypes: readonly [BattlerTagLapseType, ...BattlerTagLapseType[]]; + /** + * The set of lapse types that this tag can be automatically lapsed with. + * If this is exclusively {@linkcode BattlerTagLapseType.CUSTOM}, then the tag can only ever be lapsed + * manually via {@linkcode Pokemon.lapseTag} (or calling the tag's lapse method directly) + */ public get lapseTypes(): readonly BattlerTagLapseType[] { return this.#lapseTypes; } @@ -128,7 +133,7 @@ export class BattlerTag implements BaseBattlerTag { constructor( tagType: BattlerTagType, - lapseType: BattlerTagLapseType | [BattlerTagLapseType, ...BattlerTagLapseType[]], + lapseType: BattlerTagLapseType | [NonCustomBattlerTagLapseType, ...NonCustomBattlerTagLapseType[]], turnCount: number, sourceMove?: MoveId, sourceId?: number, @@ -160,7 +165,10 @@ export class BattlerTag implements BaseBattlerTag { onOverlap(_pokemon: Pokemon): void {} /** - * Tick down this {@linkcode BattlerTag}'s duration. + * Apply the battler tag's effects based on the lapse type + * + * @remarks + * Generally, this involves ticking down the tag's duration. The tag also initiates the effects it is responsbile for * @param _pokemon - The {@linkcode Pokemon} whom this tag belongs to. * Unused by default but can be used by subclasses. * @param _lapseType - The {@linkcode BattlerTagLapseType} being lapsed. @@ -302,12 +310,7 @@ export abstract class MoveRestrictionBattlerTag extends SerializableBattlerTag { export class ThroatChoppedTag extends MoveRestrictionBattlerTag { public override readonly tagType = BattlerTagType.THROAT_CHOPPED; constructor() { - super( - BattlerTagType.THROAT_CHOPPED, - [BattlerTagLapseType.TURN_END, BattlerTagLapseType.PRE_MOVE], - 2, - MoveId.THROAT_CHOP, - ); + super(BattlerTagType.THROAT_CHOPPED, BattlerTagLapseType.TURN_END, 2, MoveId.THROAT_CHOP); } /** @@ -356,13 +359,7 @@ export class DisabledTag extends MoveRestrictionBattlerTag { public readonly moveId: MoveId = MoveId.NONE; constructor(sourceId: number) { - super( - BattlerTagType.DISABLED, - [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.TURN_END], - 4, - MoveId.DISABLE, - sourceId, - ); + super(BattlerTagType.DISABLED, BattlerTagLapseType.TURN_END, 4, MoveId.DISABLE, sourceId); } override isMoveRestricted(move: MoveId): boolean { @@ -511,7 +508,10 @@ export class RechargingTag extends SerializableBattlerTag { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), }), ); - (globalScene.phaseManager.getCurrentPhase() as MovePhase).cancel(); + const currentPhase = globalScene.phaseManager.getCurrentPhase(); + if (currentPhase?.is("MovePhase")) { + currentPhase.cancel(); + } pokemon.getMoveQueue().shift(); } return super.lapse(pokemon, lapseType); @@ -708,18 +708,21 @@ class NoRetreatTag extends TrappedTag { export class FlinchedTag extends BattlerTag { public override readonly tagType = BattlerTagType.FLINCHED; constructor(sourceMove: MoveId) { - super(BattlerTagType.FLINCHED, [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.TURN_END], 1, sourceMove); + super(BattlerTagType.FLINCHED, BattlerTagLapseType.TURN_END, 1, sourceMove); } /** * Cancels the flinched Pokemon's currently used move this turn if called mid-execution, or removes the tag at end of turn. * @param pokemon - The {@linkcode Pokemon} with this tag. - * @param lapseType - The {@linkcode BattlerTagLapseType | lapse type} used for this function call. + * @param lapseType - The {@linkcode BattlerTagLapseType | lapse type} used for this function call. Must be {@linkcode BattlerTagLapseType.PRE_MOVE} in order to apply the flinch effect. * @returns Whether the tag should remain active. */ lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean { if (lapseType === BattlerTagLapseType.PRE_MOVE) { - (globalScene.phaseManager.getCurrentPhase() as MovePhase).cancel(); + const currentPhase = globalScene.phaseManager.getCurrentPhase(); + if (currentPhase?.is("MovePhase")) { + currentPhase.cancel(); + } globalScene.phaseManager.queueMessage( i18next.t("battlerTags:flinchedLapse", { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), @@ -729,7 +732,7 @@ export class FlinchedTag extends BattlerTag { return true; } - return super.lapse(pokemon, lapseType); + return lapseType === BattlerTagLapseType.TURN_END && super.lapse(pokemon, lapseType); } getDescriptor(): string { @@ -760,7 +763,10 @@ export class InterruptedTag extends BattlerTag { } lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean { - (globalScene.phaseManager.getCurrentPhase() as MovePhase).cancel(); + const currentPhase = globalScene.phaseManager.getCurrentPhase(); + if (currentPhase?.is("MovePhase")) { + currentPhase.cancel(); + } return super.lapse(pokemon, lapseType); } } @@ -771,7 +777,7 @@ export class InterruptedTag extends BattlerTag { export class ConfusedTag extends SerializableBattlerTag { public override readonly tagType = BattlerTagType.CONFUSED; constructor(turnCount: number, sourceMove: MoveId) { - super(BattlerTagType.CONFUSED, BattlerTagLapseType.MOVE, turnCount, sourceMove, undefined, true); + super(BattlerTagType.CONFUSED, BattlerTagLapseType.CUSTOM, turnCount, sourceMove, undefined, true); } canAdd(pokemon: Pokemon): boolean { @@ -814,8 +820,18 @@ export class ConfusedTag extends SerializableBattlerTag { ); } + /** + * Tick down the confusion duration and, if there are remaining turns, activate the confusion effect + * + * @remarks + * Rolls the + * @param pokemon - The pokemon with this tag + * @param lapseType - The lapse type + * @returns + */ lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean { - const shouldLapse = lapseType !== BattlerTagLapseType.CUSTOM && super.lapse(pokemon, lapseType); + // Duration is only ticked down for PRE_MOVE lapse type + const shouldLapse = lapseType === BattlerTagLapseType.PRE_MOVE && super.lapse(pokemon, lapseType); if (!shouldLapse) { return false; @@ -840,7 +856,10 @@ export class ConfusedTag extends SerializableBattlerTag { // Intentionally don't increment rage fist's hitCount phaseManager.queueMessage(i18next.t("battlerTags:confusedLapseHurtItself")); pokemon.damageAndUpdate(damage, { result: HitResult.CONFUSION }); - (phaseManager.getCurrentPhase() as MovePhase).cancel(); + const currentPhase = phaseManager.getCurrentPhase(); + if (currentPhase?.is("MovePhase") && currentPhase.pokemon === pokemon) { + currentPhase.cancel(); + } } return true; @@ -916,7 +935,7 @@ export class DestinyBondTag extends SerializableBattlerTag { export class InfatuatedTag extends SerializableBattlerTag { public override readonly tagType = BattlerTagType.INFATUATED; constructor(sourceMove: number, sourceId: number) { - super(BattlerTagType.INFATUATED, BattlerTagLapseType.MOVE, 1, sourceMove, sourceId); + super(BattlerTagType.INFATUATED, BattlerTagLapseType.CUSTOM, 1, sourceMove, sourceId); } canAdd(pokemon: Pokemon): boolean { @@ -979,7 +998,10 @@ export class InfatuatedTag extends SerializableBattlerTag { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), }), ); - (phaseManager.getCurrentPhase() as MovePhase).cancel(); + const currentPhase = phaseManager.getCurrentPhase(); + if (currentPhase?.is("MovePhase")) { + currentPhase.cancel(); + } } return true; @@ -1105,7 +1127,7 @@ export class SeedTag extends SerializableBattlerTag { export class PowderTag extends BattlerTag { public override readonly tagType = BattlerTagType.POWDER; constructor() { - super(BattlerTagType.POWDER, [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.TURN_END], 1); + super(BattlerTagType.POWDER, BattlerTagLapseType.TURN_END, 1); } onAdd(pokemon: Pokemon): void { @@ -1127,23 +1149,27 @@ export class PowderTag extends BattlerTag { * @returns `true` if the tag should remain active. */ lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean { - const movePhase = globalScene.phaseManager.getCurrentPhase(); - if (lapseType !== BattlerTagLapseType.PRE_MOVE || !movePhase?.is("MovePhase")) { + if (lapseType === BattlerTagLapseType.TURN_END) { return false; } + const currentPhase = globalScene.phaseManager.getCurrentPhase(); - const move = movePhase.move.getMove(); + if (!currentPhase?.is("MovePhase")) { + return true; + } + + const move = currentPhase.move.getMove(); const weather = globalScene.arena.weather; if ( pokemon.getMoveType(move) !== PokemonType.FIRE || - (weather?.weatherType === WeatherType.HEAVY_RAIN && !weather.isEffectSuppressed()) // Heavy rain takes priority over powder + (weather?.weatherType === WeatherType.HEAVY_RAIN && !weather.isEffectSuppressed()) // Since gen 7, Heavy rain takes priority over powder ) { return true; } // Disable the target's fire type move and damage it (subject to Magic Guard) - movePhase.showMoveText(); - movePhase.fail(); + currentPhase.showMoveText(); + currentPhase.fail(); const idx = pokemon.getBattlerIndex(); @@ -1243,13 +1269,7 @@ export class EncoreTag extends MoveRestrictionBattlerTag { public moveId: MoveId; constructor(sourceId: number) { - super( - BattlerTagType.ENCORE, - [BattlerTagLapseType.CUSTOM, BattlerTagLapseType.AFTER_MOVE], - 3, - MoveId.ENCORE, - sourceId, - ); + super(BattlerTagType.ENCORE, BattlerTagLapseType.AFTER_MOVE, 3, MoveId.ENCORE, sourceId); } public override loadTag(source: BaseBattlerTag & Pick): void { @@ -2044,7 +2064,7 @@ export class UnburdenTag extends AbilityBattlerTag { export class TruantTag extends AbilityBattlerTag { public override readonly tagType = BattlerTagType.TRUANT; constructor() { - super(BattlerTagType.TRUANT, AbilityId.TRUANT, BattlerTagLapseType.MOVE, 1); + super(BattlerTagType.TRUANT, AbilityId.TRUANT, BattlerTagLapseType.CUSTOM, 1); } lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean { @@ -2880,12 +2900,7 @@ export class ExposedTag extends SerializableBattlerTag { export class HealBlockTag extends MoveRestrictionBattlerTag { public override readonly tagType = BattlerTagType.HEAL_BLOCK; constructor(turnCount: number, sourceMove: MoveId) { - super( - BattlerTagType.HEAL_BLOCK, - [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.TURN_END], - turnCount, - sourceMove, - ); + super(BattlerTagType.HEAL_BLOCK, BattlerTagLapseType.TURN_END, turnCount, sourceMove); } onActivation(pokemon: Pokemon): string { @@ -3134,7 +3149,7 @@ export class SubstituteTag extends SerializableBattlerTag { lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean { switch (lapseType) { - case BattlerTagLapseType.PRE_MOVE: + case BattlerTagLapseType.MOVE: this.onPreMove(pokemon); break; case BattlerTagLapseType.AFTER_MOVE: @@ -3292,7 +3307,7 @@ export class TormentTag extends MoveRestrictionBattlerTag { export class TauntTag extends MoveRestrictionBattlerTag { public override readonly tagType = BattlerTagType.TAUNT; constructor() { - super(BattlerTagType.TAUNT, [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.AFTER_MOVE], 4, MoveId.TAUNT); + super(BattlerTagType.TAUNT, BattlerTagLapseType.AFTER_MOVE, 4, MoveId.TAUNT); } override onAdd(pokemon: Pokemon) { @@ -3347,13 +3362,7 @@ export class TauntTag extends MoveRestrictionBattlerTag { export class ImprisonTag extends MoveRestrictionBattlerTag { public override readonly tagType = BattlerTagType.IMPRISON; constructor(sourceId: number) { - super( - BattlerTagType.IMPRISON, - [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.AFTER_MOVE], - 1, - MoveId.IMPRISON, - sourceId, - ); + super(BattlerTagType.IMPRISON, BattlerTagLapseType.AFTER_MOVE, 1, MoveId.IMPRISON, sourceId); } /** @@ -3546,7 +3555,7 @@ export class PowerTrickTag extends SerializableBattlerTag { export class GrudgeTag extends SerializableBattlerTag { public override readonly tagType = BattlerTagType.GRUDGE; constructor() { - super(BattlerTagType.GRUDGE, [BattlerTagLapseType.CUSTOM, BattlerTagLapseType.PRE_MOVE], 1, MoveId.GRUDGE); + super(BattlerTagType.GRUDGE, BattlerTagLapseType.PRE_MOVE, 1, MoveId.GRUDGE); } onAdd(pokemon: Pokemon) { @@ -3567,23 +3576,23 @@ export class GrudgeTag extends SerializableBattlerTag { */ // TODO: Confirm whether this should interact with copying moves override lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType, sourcePokemon?: Pokemon): boolean { - if (lapseType === BattlerTagLapseType.CUSTOM && sourcePokemon) { - if (sourcePokemon.isActive() && pokemon.isOpponent(sourcePokemon)) { - const lastMove = pokemon.turnData.attacksReceived[0]; - const lastMoveData = sourcePokemon.getMoveset().find(m => m.moveId === lastMove.move); - if (lastMoveData && lastMove.move !== MoveId.STRUGGLE) { - lastMoveData.ppUsed = lastMoveData.getMovePp(); - globalScene.phaseManager.queueMessage( - i18next.t("battlerTags:grudgeLapse", { - pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), - moveName: lastMoveData.getName(), - }), - ); - } - } - return false; + if (!sourcePokemon || lapseType !== BattlerTagLapseType.CUSTOM) { + return super.lapse(pokemon, lapseType); } - return super.lapse(pokemon, lapseType); + if (sourcePokemon.isActive() && pokemon.isOpponent(sourcePokemon)) { + const lastMove = pokemon.turnData.attacksReceived[0]; + const lastMoveData = sourcePokemon.getMoveset().find(m => m.moveId === lastMove.move); + if (lastMoveData && lastMove.move !== MoveId.STRUGGLE) { + lastMoveData.ppUsed = lastMoveData.getMovePp(); + globalScene.phaseManager.queueMessage( + i18next.t("battlerTags:grudgeLapse", { + pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), + moveName: lastMoveData.getName(), + }), + ); + } + } + return false; } } diff --git a/src/data/moves/move-condition.ts b/src/data/moves/move-condition.ts new file mode 100644 index 00000000000..ffb52294123 --- /dev/null +++ b/src/data/moves/move-condition.ts @@ -0,0 +1,117 @@ +import { globalScene } from "#app/global-scene"; +import { getPokemonNameWithAffix } from "#app/messages"; +import { allMoves } from "#data/data-lists"; +import { ArenaTagType } from "#enums/arena-tag-type"; +import { Command } from "#enums/command"; +import { MoveCategory } from "#enums/move-category"; +import type { Pokemon } from "#field/pokemon"; +import type { Move, MoveConditionFunc, UserMoveConditionFunc } from "#moves/move"; +import i18next from "i18next"; + +/** + * A condition that determines whether a move can be used successfully. + * + * @remarks + * This is only checked when the move is attempted to be invoked. To prevent a move from being selected, + * use a {@linkcode MoveRestriction} instead. + */ +export class MoveCondition { + public declare readonly func: MoveConditionFunc; + + /** + * @param func - A condition function that determines if the move can be used successfully + */ + constructor(func?: MoveConditionFunc) { + if (func) { + this.func = func; + } + } + + apply(user: Pokemon, target: Pokemon, move: Move): boolean { + return this.func(user, target, move); + } + + getUserBenefitScore(_user: Pokemon, _target: Pokemon, _move: Move): number { + return 0; + } +} +/** + * Condition to allow a move's use only on the first turn this Pokemon is sent into battle + * (or the start of a new wave, whichever comes first). + */ + +export class FirstMoveCondition extends MoveCondition { + public override readonly func: MoveConditionFunc = user => { + return user.tempSummonData.waveTurnCount === 1; + }; + + getUserBenefitScore(user: Pokemon, _target: Pokemon, _move: Move): number { + return this.apply(user, _target, _move) ? 10 : -20; + } +} + +/** + * Condition used by the move {@link https://bulbapedia.bulbagarden.net/wiki/Upper_Hand_(move) | Upper Hand}. + * Moves with this condition are only successful when the target has selected + * a high-priority attack (after factoring in priority-boosting effects) and + * hasn't moved yet this turn. + */ +export class UpperHandCondition extends MoveCondition { + public override readonly func: MoveConditionFunc = (_user, target) => { + const targetCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; + return ( + targetCommand?.command === Command.FIGHT && + !target.turnData.acted && + !!targetCommand.move?.move && + allMoves[targetCommand.move.move].category !== MoveCategory.STATUS && + allMoves[targetCommand.move.move].getPriority(target) > 0 + ); + }; +} + +/** + * A restriction that prevents a move from being selected + * + * @remarks + * Only checked when the move is selected, but not when it is attempted to be invoked. To prevent a move from being used, + * use a {@linkcode MoveCondition} instead. + */ +export class MoveRestriction { + public declare readonly func: UserMoveConditionFunc; + public declare readonly i18nkey: string; + constructor(func: UserMoveConditionFunc, i18nkey = "battle:moveRestricted") { + this.func = func; + this.i18nkey = i18nkey; + } + + /** + * @param user - The Pokemon attempting to select the move + * @param move - The move being selected + * @returns Whether the move is restricted for the user. + */ + apply(user: Pokemon, move: Move): boolean { + return this.func(user, move); + } + + public getSelectionDeniedText(user: Pokemon, move: Move): string { + // While not all restriction texts use all the parameters, passing extra ones is harmless + return i18next.t(this.i18nkey, { pokemonNameWithAffix: getPokemonNameWithAffix(user), moveName: move.name }); + } +} + +/** + * Prevents a Pokemon from using the move if it was the last move it used + * + * @remarks + * Used by {@link https://bulbapedia.bulbagarden.net/wiki/Blood_Moon_(move) | Blood Moon} and {@link https://bulbapedia.bulbagarden.net/wiki/Gigaton_Hammer_(move) | Gigaton Hammer} + */ +export const ConsecutiveUseRestriction = new MoveRestriction( + (user, move) => user.getLastXMoves(1)[0]?.move === move.id, + "battle:moveDisabledConsecutive", +); + +/** Prevents a move from being selected if Gravity is in effect */ +export const GravityUseRestriction = new MoveRestriction( + () => globalScene.arena.hasTag(ArenaTagType.GRAVITY), + "battle:moveDisabledGravity", +); diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index ffcd844224c..4c6dd3ab599 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -93,12 +93,13 @@ import { getEnumValues } from "#utils/enums"; import { toCamelCase, toTitleCase } from "#utils/strings"; import i18next from "i18next"; import { applyChallenges } from "#utils/challenge-utils"; +import { ConsecutiveUseRestriction, FirstMoveCondition, GravityUseRestriction, MoveCondition, MoveRestriction, UpperHandCondition } from "#moves/move-condition"; /** * A function used to conditionally determine execution of a given {@linkcode MoveAttr}. * Conventionally returns `true` for success and `false` for failure. */ -type MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => boolean; +export type MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => boolean; export type UserMoveConditionFunc = (user: Pokemon, move: Move) => boolean; export abstract class Move implements Localizable { @@ -116,7 +117,16 @@ export abstract class Move implements Localizable { public priority: number; public generation: number; public attrs: MoveAttr[] = []; + /** Conditions that must be met for the move to succeed when it is used. + * + * @remarks Different from {@linkcode restrictions}, which is checked when the move is selected + */ private conditions: MoveCondition[] = []; + /** Conditions that must be false for a move to be able to be selected. + * + * @remarks Different from {@linkcode conditions}, which is checked when the move is invoked + */ + private restrictions: MoveRestriction[] = []; /** The move's {@linkcode MoveFlags} */ private flags: number = 0; private nameAppend: string = ""; @@ -370,7 +380,7 @@ export abstract class Move implements Localizable { * Adds a condition to this move (in addition to any provided by its prior {@linkcode MoveAttr}s). * The move will fail upon use if at least 1 of its conditions is not met. * @param condition - The {@linkcode MoveCondition} or {@linkcode MoveConditionFunc} to add to the conditions array. - * @returns `this` + * @returns `this` for method chaining */ condition(condition: MoveCondition | MoveConditionFunc): this { if (typeof condition === "function") { @@ -381,6 +391,48 @@ export abstract class Move implements Localizable { return this; } + /** + * Adds a restriction condition to this move. + * The move will not be selectable if at least 1 of its restrictions is met. + * @param restriction - A function that evaluates to `true` if the move is restricted from being selected + * @returns `this` for method chaining + */ + public restriction(restriction: MoveRestriction): this; + /** + * Adds a restriction condition to this move. + * The move will not be selectable if at least 1 of its restrictions is met. + * @param restriction - The function or `MoveRestriction` that evaluates to `true` if the move is restricted from + * being selected + * @param i18nkey - The i18n key for the restriction text + * @param alsoCondition - If `true`, also adds a {@linkcode MoveCondition} that checks the same condition when the + * move is used; default `false` + * @returns `this` for method chaining + */ + + public restriction(restriction: UserMoveConditionFunc, i18nkey: string, alsoCondition?: boolean): this; + /** + * Adds a restriction condition to this move. + * The move will not be selectable if at least 1 of its restrictions is met. + * @param restriction - The function or `MoveRestriction` that evaluates to `true` if the move is restricted from + * being selected + * @param i18nkey - The i18n key for the restriction text, ignored if `restriction` is a `MoveRestriction` + * @param alsoCondition - If `true`, also adds a {@linkcode MoveCondition} that checks the same condition when the + * move is used; default `false`. Ignored if `restriction` is a `MoveRestriction`. + * @returns `this` for method chaining + */ + public restriction(restriction: T, i18nkey?: string, alsoCondition: typeof restriction extends MoveRestriction ? false : boolean = false): this { + if (typeof restriction === "function") { + this.restrictions.push(new MoveRestriction(restriction)); + if (alsoCondition) { + this.conditions.push(new MoveCondition((user, _, move) => restriction(user, move))); + } + } else { + this.restrictions.push(restriction); + } + + return this; + } + /** * Mark a move as having one or more edge cases. * The move may lack certain niche interactions with other moves/abilities, @@ -579,6 +631,19 @@ export abstract class Move implements Localizable { return this; } + /** + * Sets the {@linkcode MoveFlags.GRAVITY} flag for the calling Move and adds {@linkcode GravityUseRestriction} to the + * move's restrictions. + * + * @see {@linkcode MoveId.GRAVITY} + * @returns The {@linkcode Move} that called this function + */ + affectedByGravity(): this { + this.setFlag(MoveFlags.GRAVITY, true); + this.restrictions.push(GravityUseRestriction); + return this; + } + /** * Sets the {@linkcode MoveFlags.IGNORE_ABILITIES} flag for the calling Move * @see {@linkcode MoveId.SUNSTEEL_STRIKE} @@ -702,8 +767,29 @@ export abstract class Move implements Localizable { * @param move {@linkcode Move} to apply conditions to * @returns boolean: false if any of the apply()'s return false, else true */ - applyConditions(user: Pokemon, target: Pokemon, move: Move): boolean { - return this.conditions.every(cond => cond.apply(user, target, move)); + applyConditions(user: Pokemon, target: Pokemon): boolean { + return this.conditions.every(cond => cond.apply(user, target, this)); + } + + + /** + * Determine whether the move is restricted from being selected due to its own requirements. + * + * @remarks + * Does not check for external factors that prohibit move selection, such as disable + * + * @param user - The Pokemon using the move + * @returns - An array whose first element is `false` if the move is restricted, and the second element is a string + * with the reason for the restriction, otherwise, `false` and the empty string. + */ + public checkRestrictions(user: Pokemon): [boolean, string] { + for (const restriction of this.restrictions) { + if (restriction.apply(user, this)) { + return [false, restriction.getSelectionDeniedText(user, this)]; + } + } + + return [true, ""]; } /** @@ -1473,13 +1559,21 @@ export class PreUseInterruptAttr extends MoveAttr { } /** - * Message to display when a move is interrupted. - * @param user {@linkcode Pokemon} using the move - * @param target {@linkcode Pokemon} target of the move - * @param move {@linkcode Move} with this attribute + * Cancel the current MovePhase and queue the interrupt message if the condition is met + * @param user - {@linkcode Pokemon} using the move + * @param target - {@linkcode Pokemon} target of the move + * @param move - {@linkcode Move} with this attribute */ override apply(user: Pokemon, target: Pokemon, move: Move): boolean { - return this.conditionFunc(user, target, move); + const currentPhase = globalScene.phaseManager.getCurrentPhase(); + if (!currentPhase?.is("MovePhase") || !this.conditionFunc(user, target, move)) { + return false; + } + currentPhase.cancel(); + globalScene.phaseManager.queueMessage( + typeof this.message === "string" ? this.message : this.message(user, target, move) + ) + return true; } /** @@ -8040,8 +8134,6 @@ const phaseForcedSlower = (phase: MovePhase, target: Pokemon, trickRoom: boolean return phase.isForcedLast() && slower; }; -const failOnGravityCondition: MoveConditionFunc = (user, target, move) => !globalScene.arena.getTag(ArenaTagType.GRAVITY); - const failOnBossCondition: MoveConditionFunc = (user, target, move) => !target.isBossImmune(); const failIfSingleBattle: MoveConditionFunc = (user, target, move) => globalScene.currentBattle.double; @@ -8081,57 +8173,6 @@ const attackedByItemMessageFunc = (user: Pokemon, target: Pokemon, move: Move) = return message; }; -export class MoveCondition { - protected func: MoveConditionFunc; - - constructor(func: MoveConditionFunc) { - this.func = func; - } - - apply(user: Pokemon, target: Pokemon, move: Move): boolean { - return this.func(user, target, move); - } - - getUserBenefitScore(user: Pokemon, target: Pokemon, move: Move): number { - return 0; - } -} - -/** - * Condition to allow a move's use only on the first turn this Pokemon is sent into battle - * (or the start of a new wave, whichever comes first). - */ - -export class FirstMoveCondition extends MoveCondition { - constructor() { - super((user, _target, _move) => user.tempSummonData.waveTurnCount === 1); - } - - getUserBenefitScore(user: Pokemon, _target: Pokemon, _move: Move): number { - return this.apply(user, _target, _move) ? 10 : -20; - } -} - -/** - * Condition used by the move {@link https://bulbapedia.bulbagarden.net/wiki/Upper_Hand_(move) | Upper Hand}. - * Moves with this condition are only successful when the target has selected - * a high-priority attack (after factoring in priority-boosting effects) and - * hasn't moved yet this turn. - */ -export class UpperHandCondition extends MoveCondition { - constructor() { - super((user, target, move) => { - const targetCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; - - return targetCommand?.command === Command.FIGHT - && !target.turnData.acted - && !!targetCommand.move?.move - && allMoves[targetCommand.move.move].category !== MoveCategory.STATUS - && allMoves[targetCommand.move.move].getPriority(target) > 0; - }); - } -} - export class HitsSameTypeAttr extends VariableMoveTypeMultiplierAttr { apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean { const multiplier = args[0] as NumberHolder; @@ -8538,7 +8579,7 @@ export function initMoves() { new ChargingAttackMove(MoveId.FLY, PokemonType.FLYING, MoveCategory.PHYSICAL, 90, 95, 15, -1, 0, 1) .chargeText(i18next.t("moveTriggers:flewUpHigh", { pokemonName: "{USER}" })) .chargeAttr(SemiInvulnerableAttr, BattlerTagType.FLYING) - .condition(failOnGravityCondition), + .affectedByGravity(), new AttackMove(MoveId.BIND, PokemonType.NORMAL, MoveCategory.PHYSICAL, 15, 85, 20, -1, 0, 1) .attr(TrapAttr, BattlerTagType.BIND), new AttackMove(MoveId.SLAM, PokemonType.NORMAL, MoveCategory.PHYSICAL, 80, 75, 20, -1, 0, 1), @@ -8553,7 +8594,7 @@ export function initMoves() { new AttackMove(MoveId.JUMP_KICK, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 100, 95, 10, -1, 0, 1) .attr(MissEffectAttr, crashDamageFunc) .attr(NoEffectAttr, crashDamageFunc) - .condition(failOnGravityCondition) + .affectedByGravity() .recklessMove(), new AttackMove(MoveId.ROLLING_KICK, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 60, 85, 15, 30, 0, 1) .attr(FlinchAttr), @@ -8868,7 +8909,7 @@ export function initMoves() { new AttackMove(MoveId.HIGH_JUMP_KICK, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 130, 90, 10, -1, 0, 1) .attr(MissEffectAttr, crashDamageFunc) .attr(NoEffectAttr, crashDamageFunc) - .condition(failOnGravityCondition) + .affectedByGravity() .recklessMove(), new StatusMove(MoveId.GLARE, PokemonType.NORMAL, 100, 30, -1, 0, 1) .attr(StatusEffectAttr, StatusEffect.PARALYSIS) @@ -8922,7 +8963,7 @@ export function initMoves() { .attr(RandomLevelDamageAttr), new SelfStatusMove(MoveId.SPLASH, PokemonType.NORMAL, -1, 40, -1, 0, 1) .attr(MessageAttr, i18next.t("moveTriggers:splash")) - .condition(failOnGravityCondition), + .affectedByGravity(), new SelfStatusMove(MoveId.ACID_ARMOR, PokemonType.POISON, -1, 20, -1, 0, 1) .attr(StatStageChangeAttr, [ Stat.DEF ], 2, true), new AttackMove(MoveId.CRABHAMMER, PokemonType.WATER, MoveCategory.PHYSICAL, 100, 90, 10, -1, 0, 1) @@ -9563,7 +9604,7 @@ export function initMoves() { .chargeText(i18next.t("moveTriggers:sprangUp", { pokemonName: "{USER}" })) .chargeAttr(SemiInvulnerableAttr, BattlerTagType.FLYING) .attr(StatusEffectAttr, StatusEffect.PARALYSIS) - .condition(failOnGravityCondition), + .affectedByGravity(), new AttackMove(MoveId.MUD_SHOT, PokemonType.GROUND, MoveCategory.SPECIAL, 55, 95, 15, 100, 0, 3) .attr(StatStageChangeAttr, [ Stat.SPD ], -1), new AttackMove(MoveId.POISON_TAIL, PokemonType.POISON, MoveCategory.PHYSICAL, 50, 100, 25, 10, 0, 3) @@ -9615,6 +9656,7 @@ export function initMoves() { new StatusMove(MoveId.GRAVITY, PokemonType.PSYCHIC, -1, 5, -1, 0, 4) .ignoresProtect() .attr(AddArenaTagAttr, ArenaTagType.GRAVITY, 5) + .condition(() => !globalScene.arena.hasTag(ArenaTagType.GRAVITY)) .target(MoveTarget.BOTH_SIDES), new StatusMove(MoveId.MIRACLE_EYE, PokemonType.PSYCHIC, -1, 40, -1, 0, 4) .attr(ExposedMoveAttr, BattlerTagType.IGNORE_DARK) @@ -9745,7 +9787,8 @@ export function initMoves() { .attr(AddBattlerTagAttr, BattlerTagType.AQUA_RING, true, true), new SelfStatusMove(MoveId.MAGNET_RISE, PokemonType.ELECTRIC, -1, 10, -1, 0, 4) .attr(AddBattlerTagAttr, BattlerTagType.FLOATING, true, true, 5) - .condition((user, target, move) => !globalScene.arena.getTag(ArenaTagType.GRAVITY) && [ BattlerTagType.FLOATING, BattlerTagType.IGNORE_FLYING, BattlerTagType.INGRAIN ].every((tag) => !user.getTag(tag))), + .condition(user => [ BattlerTagType.FLOATING, BattlerTagType.IGNORE_FLYING, BattlerTagType.INGRAIN ].every((tag) => !user.getTag(tag))) + .affectedByGravity(), new AttackMove(MoveId.FLARE_BLITZ, PokemonType.FIRE, MoveCategory.PHYSICAL, 120, 100, 15, 10, 0, 4) .attr(RecoilAttr, false, 0.33) .attr(HealStatusEffectAttr, true, StatusEffect.FREEZE) @@ -9974,7 +10017,7 @@ export function initMoves() { .powderMove() .attr(AddBattlerTagAttr, BattlerTagType.CENTER_OF_ATTENTION, true), new StatusMove(MoveId.TELEKINESIS, PokemonType.PSYCHIC, -1, 15, -1, 0, 5) - .condition(failOnGravityCondition) + .affectedByGravity() .condition((_user, target, _move) => ![ SpeciesId.DIGLETT, SpeciesId.DUGTRIO, SpeciesId.ALOLA_DIGLETT, SpeciesId.ALOLA_DUGTRIO, SpeciesId.SANDYGAST, SpeciesId.PALOSSAND, SpeciesId.WIGLETT, SpeciesId.WUGTRIO ].includes(target.species.speciesId)) .condition((_user, target, _move) => !(target.species.speciesId === SpeciesId.GENGAR && target.getFormKey() === "mega")) .condition((_user, target, _move) => isNullOrUndefined(target.getTag(BattlerTagType.INGRAIN)) && isNullOrUndefined(target.getTag(BattlerTagType.IGNORE_FLYING))) @@ -10078,7 +10121,7 @@ export function initMoves() { new ChargingAttackMove(MoveId.SKY_DROP, PokemonType.FLYING, MoveCategory.PHYSICAL, 60, 100, 10, -1, 0, 5) .chargeText(i18next.t("moveTriggers:tookTargetIntoSky", { pokemonName: "{USER}", targetName: "{TARGET}" })) .chargeAttr(SemiInvulnerableAttr, BattlerTagType.FLYING) - .condition(failOnGravityCondition) + .affectedByGravity() .condition((user, target, move) => !target.getTag(BattlerTagType.SUBSTITUTE)) /* * Cf https://bulbapedia.bulbagarden.net/wiki/Sky_Drop_(move) and https://www.smogon.com/dex/sv/moves/sky-drop/: @@ -10266,14 +10309,14 @@ export function initMoves() { .attr(AlwaysHitMinimizeAttr) .attr(FlyingTypeMultiplierAttr) .attr(HitsTagForDoubleDamageAttr, BattlerTagType.MINIMIZED) - .condition(failOnGravityCondition), + .affectedByGravity(), new StatusMove(MoveId.MAT_BLOCK, PokemonType.FIGHTING, -1, 10, -1, 0, 6) .target(MoveTarget.USER_SIDE) .attr(AddArenaTagAttr, ArenaTagType.MAT_BLOCK, 1, true, true) .condition(new FirstMoveCondition()) .condition(failIfLastCondition), new AttackMove(MoveId.BELCH, PokemonType.POISON, MoveCategory.SPECIAL, 120, 90, 10, -1, 0, 6) - .condition((user, target, move) => user.battleData.hasEatenBerry), + .restriction(user => !user.battleData.hasEatenBerry, "battle:moveDisabledBelch", true), new StatusMove(MoveId.ROTOTILLER, PokemonType.GROUND, -1, 10, -1, 0, 6) .target(MoveTarget.ALL) .condition((user, target, move) => { @@ -10804,7 +10847,8 @@ export function initMoves() { .attr(StatusEffectAttr, StatusEffect.PARALYSIS) .target(MoveTarget.ALL_NEAR_ENEMIES), new AttackMove(MoveId.FLOATY_FALL, PokemonType.FLYING, MoveCategory.PHYSICAL, 90, 95, 15, 30, 0, 7) - .attr(FlinchAttr), + .attr(FlinchAttr) + .affectedByGravity(), new AttackMove(MoveId.PIKA_PAPOW, PokemonType.ELECTRIC, MoveCategory.SPECIAL, -1, -1, 20, -1, 0, 7) .attr(FriendshipPowerAttr), new AttackMove(MoveId.BOUNCY_BUBBLE, PokemonType.WATER, MoveCategory.SPECIAL, 60, 100, 20, -1, 0, 7) @@ -10858,11 +10902,10 @@ export function initMoves() { new SelfStatusMove(MoveId.STUFF_CHEEKS, PokemonType.NORMAL, -1, 10, -1, 0, 8) .attr(EatBerryAttr, true) .attr(StatStageChangeAttr, [ Stat.DEF ], 2, true) - .condition((user) => { - const userBerries = globalScene.findModifiers(m => m instanceof BerryModifier, user.isPlayer()); - return userBerries.length > 0; - }) - .edgeCase(), // Stuff Cheeks should not be selectable when the user does not have a berry, see wiki + .restriction( + user => globalScene.findModifiers(m => m instanceof BerryModifier, user.isPlayer()).length > 0, + "battle:moveDisabledNoBerry", + true), new SelfStatusMove(MoveId.NO_RETREAT, PokemonType.FIGHTING, -1, 5, -1, 0, 8) .attr(StatStageChangeAttr, [ Stat.ATK, Stat.DEF, Stat.SPATK, Stat.SPDEF, Stat.SPD ], 1, true) .attr(AddBattlerTagAttr, BattlerTagType.NO_RETREAT, true, false) @@ -11439,10 +11482,7 @@ export function initMoves() { }), new AttackMove(MoveId.GIGATON_HAMMER, PokemonType.STEEL, MoveCategory.PHYSICAL, 160, 100, 5, -1, 0, 9) .makesContact(false) - .condition((user, target, move) => { - const turnMove = user.getLastXMoves(1); - return !turnMove.length || turnMove[0].move !== move.id || turnMove[0].result !== MoveResult.SUCCESS; - }), // TODO Add Instruct/Encore interaction + .restriction(ConsecutiveUseRestriction), new AttackMove(MoveId.COMEUPPANCE, PokemonType.DARK, MoveCategory.PHYSICAL, -1, 100, 10, -1, 0, 9) .attr(CounterDamageAttr, (move: Move) => (move.category === MoveCategory.PHYSICAL || move.category === MoveCategory.SPECIAL), 1.5) .redirectCounter() @@ -11467,10 +11507,7 @@ export function initMoves() { .attr(ConfuseAttr) .makesContact(false), new AttackMove(MoveId.BLOOD_MOON, PokemonType.NORMAL, MoveCategory.SPECIAL, 140, 100, 5, -1, 0, 9) - .condition((user, target, move) => { - const turnMove = user.getLastXMoves(1); - return !turnMove.length || turnMove[0].move !== move.id || turnMove[0].result !== MoveResult.SUCCESS; - }), // TODO Add Instruct/Encore interaction + .restriction(ConsecutiveUseRestriction), new AttackMove(MoveId.MATCHA_GOTCHA, PokemonType.GRASS, MoveCategory.SPECIAL, 80, 90, 15, 20, 0, 9) .attr(HitHealAttr) .attr(HealStatusEffectAttr, true, StatusEffect.FREEZE) diff --git a/src/data/moves/pokemon-move.ts b/src/data/moves/pokemon-move.ts index cdb8d628be1..c47445b9949 100644 --- a/src/data/moves/pokemon-move.ts +++ b/src/data/moves/pokemon-move.ts @@ -5,6 +5,7 @@ import type { Pokemon } from "#field/pokemon"; import type { Move } from "#moves/move"; import { applyChallenges } from "#utils/challenge-utils"; import { BooleanHolder, toDmgValue } from "#utils/common"; +import i18next from "i18next"; /** * Wrapper class for the {@linkcode Move} class for Pokemon to interact with. @@ -38,33 +39,58 @@ export class PokemonMove { } /** - * Checks whether this move can be selected/performed by a Pokemon, without consideration for the move's targets. + * Checks whether this move can be performed by a Pokemon, without consideration for the move's targets. * The move is unusable if it is out of PP, restricted by an effect, or unimplemented. * + * Should not be confused with {@linkcode isSelectable}, which only checks if the move can be selected by a Pokemon. + * * @param pokemon - The {@linkcode Pokemon} attempting to use this move * @param ignorePp - Whether to ignore checking if the move is out of PP; default `false` - * @param ignoreRestrictionTags - Whether to skip checks for {@linkcode MoveRestrictionBattlerTag}s; default `false` + * @param forSelection - Whether this is being checked for move selection; default `false` * @returns Whether this {@linkcode PokemonMove} can be selected by this Pokemon. */ - isUsable(pokemon: Pokemon, ignorePp = false, ignoreRestrictionTags = false): boolean { + public isUsable(pokemon: Pokemon, ignorePp = false, forSelection = false): [boolean, string] { const move = this.getMove(); + const moveName = move.name; + // TODO: Add Sky Drop's 1 turn stall - const usability = new BooleanHolder( - !move.name.endsWith(" (N)") && - (ignorePp || this.ppUsed < this.getMovePp() || move.pp === -1) && - // TODO: Review if the `MoveId.NONE` check is even necessary anymore - !(this.moveId !== MoveId.NONE && !ignoreRestrictionTags && pokemon.isMoveRestricted(this.moveId, pokemon)), - ); - if (pokemon.isPlayer()) { - applyChallenges(ChallengeType.POKEMON_MOVE, move.id, usability); + if (this.moveId === MoveId.NONE || move.name.endsWith(" (N)")) { + return [false, i18next.t("battle:moveNotImplemented", moveName.replace(" (N)", ""))]; } - return usability.value; + + if (!ignorePp && move.pp !== -1 && this.ppUsed >= this.getMovePp()) { + return [false, i18next.t("battle:moveNoPP", { moveName: move.name })]; + } + + if (forSelection) { + const result = pokemon.isMoveSelectable(this.moveId); + if (!result[0]) { + return result; + } + } + + const usability = new BooleanHolder(true); + if (applyChallenges(ChallengeType.POKEMON_MOVE, this.moveId, usability) && !usability.value) { + return [false, i18next.t("battle:moveCannotUseChallenge", { moveName: move.name })]; + } + + return [true, ""]; } getMove(): Move { return allMoves[this.moveId]; } + /** + * Determine whether the move can be selected by the pokemon + * + * @param pokemon - The Pokemon under consideration + * @returns An array containing a boolean indicating whether the move can be selected, and a string with the reason if it cannot + */ + public isSelectable(pokemon: Pokemon): [boolean, string] { + return pokemon.isMoveSelectable(this.moveId); + } + /** * Sets {@link ppUsed} for this move and ensures the value does not exceed {@link getMovePp} * @param count Amount of PP to use diff --git a/src/enums/battler-tag-lapse-type.ts b/src/enums/battler-tag-lapse-type.ts index 4375e87e4e0..f9486876993 100644 --- a/src/enums/battler-tag-lapse-type.ts +++ b/src/enums/battler-tag-lapse-type.ts @@ -6,11 +6,12 @@ export enum BattlerTagLapseType { // TODO: This is unused... FAINT, /** - * Tag activate before the holder uses a non-virtual move, possibly interrupting its action. + * Tag activate before the holder uses a non-virtual move, after passing the first failure check sequence during the + * move phase. * @see MoveUseMode for more information */ MOVE, - /** Tag activates before the holder uses **any** move, triggering effects or interrupting its action. */ + /** Tag activates during (or just after) the first failure check sequence in the move phase. */ PRE_MOVE, /** Tag activates immediately after the holder's move finishes triggering (successful or not). */ AFTER_MOVE, @@ -32,6 +33,16 @@ export enum BattlerTagLapseType { * but still triggers on being KO'd. */ AFTER_HIT, - /** The tag has some other custom activation or removal condition. */ + /** + * The tag has some other custom activation or removal condition. + * @remarks + * Tags can use this lapse type to prevent them from being automatically lapsed during automatic lapse instances, + * such as before a move is used or at the end of a turn. Note that a tag's lapse method can still make use of + * these lapse types, which can be invoked via the `lapseTag` method on {@linkcode Pokemon} with the tag and + * lapse type. + * */ CUSTOM, } + +/** Same type as {@linkcode BattlerTagLapseType}, but excludes the {@linkcode BattlerTagLapseType.CUSTOM} type */ +export type NonCustomBattlerTagLapseType = Exclude; \ No newline at end of file diff --git a/src/enums/move-flags.ts b/src/enums/move-flags.ts index 6cdc1e5f8cc..dc0964ad2a0 100644 --- a/src/enums/move-flags.ts +++ b/src/enums/move-flags.ts @@ -50,5 +50,7 @@ export enum MoveFlags { /** Indicates a move is able to be redirected to allies in a double battle if the attacker faints */ REDIRECT_COUNTER = 1 << 18, /** Indicates a move is able to be reflected by {@linkcode AbilityId.MAGIC_BOUNCE} and {@linkcode MoveId.MAGIC_COAT} */ - REFLECTABLE = 1 << 19 + REFLECTABLE = 1 << 19, + /** Indicates a move that fails when {@link https://bulbapedia.bulbagarden.net/wiki/Gravity_(move) | Gravity} is in effect */ + GRAVITY = 1 << 20, } diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index e12485a7272..9c6c817cc38 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -3295,9 +3295,15 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { } } - public trySelectMove(moveIndex: number, ignorePp?: boolean): boolean { + /** + * Attempt to select the move at the move index. + * @param moveIndex + * @param ignorePp + * @returns + */ + public trySelectMove(moveIndex: number, ignorePp?: boolean): [boolean, string] { const move = this.getMoveset().length > moveIndex ? this.getMoveset()[moveIndex] : null; - return move?.isUsable(this, ignorePp) ?? false; + return move?.isUsable(this, ignorePp) ?? [false, ""]; } showInfo(): void { @@ -4267,19 +4273,28 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { } /** - * Tick down the first {@linkcode BattlerTag} found matching the given {@linkcode BattlerTagType}, - * removing it if its duration goes below 0. - * @param tagType the {@linkcode BattlerTagType} to check against - * @returns `true` if the tag was present + * Lapse the first {@linkcode BattlerTag} matching `tagType` + * + * @remarks + * Also responsible for removing the tag when the lapse method returns `false`. + * + * + * ⚠️ Lapse types other than `CUSTOM` are generally lapsed automatically. However, some tags + * support manually lapsing + * + * @param tagType - The {@linkcode BattlerTagType} to search for + * @param lapseType - The lapse type to use for the lapse method; defaults to {@linkcode BattlerTagLapseType.CUSTOM} + * @returns Whether a tag matching the given type was found + * @see {@linkcode BattlerTag.lapse} */ - lapseTag(tagType: BattlerTagType): boolean { + lapseTag(tagType: BattlerTagType, lapseType = BattlerTagLapseType.CUSTOM): boolean { const tags = this.summonData.tags; const tag = tags.find(t => t.tagType === tagType); if (!tag) { return false; } - if (!tag.lapse(this, BattlerTagLapseType.CUSTOM)) { + if (!tag.lapse(this, lapseType)) { tag.onRemove(this); tags.splice(tags.indexOf(tag), 1); } @@ -4291,7 +4306,7 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { * removing any whose durations fall below 0. * @param tagType the {@linkcode BattlerTagLapseType} to tick down */ - lapseTags(lapseType: BattlerTagLapseType): void { + lapseTags(lapseType: Exclude): void { const tags = this.summonData.tags; tags .filter( @@ -4381,13 +4396,37 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { /** * Gets whether the given move is currently disabled for this Pokemon. * + * @remarks + * ⚠️ Only checks for restrictions due to a battler tag, not due to the move's own attributes. + * (for that behavior, see {@linkcode isMoveSelectable}). + * * @param moveId - The {@linkcode MoveId} ID of the move to check * @returns `true` if the move is disabled for this Pokemon, otherwise `false` * * @see {@linkcode MoveRestrictionBattlerTag} */ - public isMoveRestricted(moveId: MoveId, pokemon?: Pokemon): boolean { - return this.getRestrictingTag(moveId, pokemon) !== null; + // TODO: rename this method as it can be easily confused with a move being restricted + public isMoveRestricted(moveId: MoveId): boolean { + return this.getRestrictingTag(moveId, this) !== null; + } + + /** + * Determine whether the given move is selectable by this Pokemon and the message to display if it is not. + * + * @remarks + * Checks both the move's own restrictions and any restrictions imposed by battler tags like disable or throat chop. + * + * @param moveId - The move ID to check + * @returns A tuple of the form [response, msg], where msg contains the text to display if `response` is false. + * + * @see {@linkcode isMoveRestricted} + */ + public isMoveSelectable(moveId: MoveId): [boolean, string] { + const restrictedTag = this.getRestrictingTag(moveId, this); + if (restrictedTag) { + return [false, restrictedTag.selectionDeniedText(this, moveId)]; + } + return allMoves[moveId].checkRestrictions(this); } /** @@ -6398,7 +6437,7 @@ export class EnemyPokemon extends Pokemon { // If the queued move was called indirectly, ignore all PP and usability checks. // Otherwise, ensure that the move being used is actually usable & in our moveset. // TODO: What should happen if a pokemon forgets a charging move mid-use? - if (isVirtual(queuedMove.useMode) || movesetMove?.isUsable(this, isIgnorePP(queuedMove.useMode))) { + if (isVirtual(queuedMove.useMode) || movesetMove?.isUsable(this, isIgnorePP(queuedMove.useMode), true)) { moveQueue.splice(0, i); // TODO: This should not be done here return queuedMove; } @@ -6408,7 +6447,7 @@ export class EnemyPokemon extends Pokemon { this.summonData.moveQueue = []; // Filter out any moves this Pokemon cannot use - let movePool = this.getMoveset().filter(m => m.isUsable(this)); + let movePool = this.getMoveset().filter(m => m.isUsable(this, false, true)[0]); // If no moves are left, use Struggle. Otherwise, continue with move selection if (movePool.length) { // If there's only 1 move in the move pool, use it. @@ -6466,7 +6505,7 @@ export class EnemyPokemon extends Pokemon { move.category !== MoveCategory.STATUS && moveTargets.some(p => { const doesNotFail = - move.applyConditions(this, p, move) || + move.applyConditions(this, p) || [MoveId.SUCKER_PUNCH, MoveId.UPPER_HAND, MoveId.THUNDERCLAP].includes(move.id); return ( doesNotFail && @@ -6525,7 +6564,7 @@ export class EnemyPokemon extends Pokemon { * target score to -20 */ if ( - (move.name.endsWith(" (N)") || !move.applyConditions(this, target, move)) && + (move.name.endsWith(" (N)") || !move.applyConditions(this, target)) && ![MoveId.SUCKER_PUNCH, MoveId.UPPER_HAND, MoveId.THUNDERCLAP].includes(move.id) ) { targetScore = -20; diff --git a/src/phases/command-phase.ts b/src/phases/command-phase.ts index 87c33a4334b..e1d472ae650 100644 --- a/src/phases/command-phase.ts +++ b/src/phases/command-phase.ts @@ -9,7 +9,6 @@ import { ArenaTagType } from "#enums/arena-tag-type"; import { BattleType } from "#enums/battle-type"; import { BattlerTagType } from "#enums/battler-tag-type"; import { BiomeId } from "#enums/biome-id"; -import { ChallengeType } from "#enums/challenge-type"; import { Command } from "#enums/command"; import { FieldPosition } from "#enums/field-position"; import { MoveId } from "#enums/move-id"; @@ -22,8 +21,6 @@ import type { MoveTargetSet } from "#moves/move"; import { getMoveTargets } from "#moves/move-utils"; import { FieldPhase } from "#phases/field-phase"; import type { TurnMove } from "#types/turn-move"; -import { applyChallenges } from "#utils/challenge-utils"; -import { BooleanHolder } from "#utils/common"; import i18next from "i18next"; export class CommandPhase extends FieldPhase { @@ -126,7 +123,7 @@ export class CommandPhase extends FieldPhase { if ( queuedMove.move !== MoveId.NONE && !isVirtual(queuedMove.useMode) && - !movesetQueuedMove?.isUsable(playerPokemon, isIgnorePP(queuedMove.useMode)) + !movesetQueuedMove?.isUsable(playerPokemon, isIgnorePP(queuedMove.useMode), true) ) { entriesToDelete++; } else { @@ -204,40 +201,18 @@ export class CommandPhase extends FieldPhase { } /** - * Submethod of {@linkcode handleFightCommand} responsible for queuing the appropriate - * error message when a move cannot be used. - * @param user - The pokemon using the move - * @param cursor - The index of the move in the moveset + * Submethod of {@linkcode handleFightCommand} responsible for queuing the provided error message when the move cannot be used + * @param msg - The reason why the move cannot be used */ - private queueFightErrorMessage(user: PlayerPokemon, cursor: number) { - const move = user.getMoveset()[cursor]; - globalScene.ui.setMode(UiMode.MESSAGE); - - // Set the translation key for why the move cannot be selected - let cannotSelectKey: string; - const moveStatus = new BooleanHolder(true); - applyChallenges(ChallengeType.POKEMON_MOVE, move.moveId, moveStatus); - if (!moveStatus.value) { - cannotSelectKey = "battle:moveCannotUseChallenge"; - } else if (move.getPpRatio() === 0) { - cannotSelectKey = "battle:moveNoPP"; - } else if (move.getName().endsWith(" (N)")) { - cannotSelectKey = "battle:moveNotImplemented"; - } else if (user.isMoveRestricted(move.moveId, user)) { - cannotSelectKey = user.getRestrictingTag(move.moveId, user)!.selectionDeniedText(user, move.moveId); - } else { - // TODO: Consider a message that signals a being unusable for an unknown reason - cannotSelectKey = ""; - } - - const moveName = move.getName().replace(" (N)", ""); // Trims off the indicator - - globalScene.ui.showText( - i18next.t(cannotSelectKey, { moveName: moveName }), + private queueFightErrorMessage(msg: string) { + const ui = globalScene.ui; + ui.setMode(UiMode.MESSAGE); + ui.showText( + msg, null, () => { - globalScene.ui.clearText(); - globalScene.ui.setMode(UiMode.FIGHT, this.fieldIndex); + ui.clearText(); + ui.setMode(UiMode.FIGHT, this.fieldIndex); }, null, true, @@ -274,18 +249,15 @@ export class CommandPhase extends FieldPhase { ): boolean { const playerPokemon = this.getPokemon(); const ignorePP = isIgnorePP(useMode); - - let canUse = cursor === -1 || playerPokemon.trySelectMove(cursor, ignorePP); + const [canUse, reason] = cursor === -1 ? [true, ""] : playerPokemon.trySelectMove(cursor, ignorePP); // Ternary here ensures we don't compute struggle conditions unless necessary const useStruggle = canUse ? false - : cursor > -1 && !playerPokemon.getMoveset().some(m => m.isUsable(playerPokemon)); + : cursor > -1 && !playerPokemon.getMoveset().some(m => m.isUsable(playerPokemon)[0]); - canUse ||= useStruggle; - - if (!canUse) { - this.queueFightErrorMessage(playerPokemon, cursor); + if (!canUse && !useStruggle) { + this.queueFightErrorMessage(reason); return false; } diff --git a/src/phases/move-header-phase.ts b/src/phases/move-header-phase.ts index 5c69dcd1217..f2ef7f11c5b 100644 --- a/src/phases/move-header-phase.ts +++ b/src/phases/move-header-phase.ts @@ -16,7 +16,7 @@ export class MoveHeaderPhase extends BattlePhase { } canMove(): boolean { - return this.pokemon.isActive(true) && this.move.isUsable(this.pokemon); + return this.pokemon.isActive(true) && this.move.isUsable(this.pokemon)[0]; } start() { diff --git a/src/phases/move-phase.ts b/src/phases/move-phase.ts index f88f9d0cad1..96d28fff603 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -2,15 +2,19 @@ import { applyAbAttrs } from "#abilities/apply-ab-attrs"; import { globalScene } from "#app/global-scene"; import { getPokemonNameWithAffix } from "#app/messages"; import Overrides from "#app/overrides"; +// biome-ignore lint/correctness/noUnusedImports: Used in a tsdoc comment +import type { TauntTag, TruantTag } from "#data/battler-tags"; import { CenterOfAttentionTag } from "#data/battler-tags"; import { SpeciesFormChangePreMoveTrigger } from "#data/form-change-triggers"; import { getStatusEffectActivationText, getStatusEffectHealText } from "#data/status-effect"; import { getTerrainBlockMessage } from "#data/terrain"; import { getWeatherBlockMessage } from "#data/weather"; import { AbilityId } from "#enums/ability-id"; +import { ArenaTagType } from "#enums/arena-tag-type"; import { BattlerIndex } from "#enums/battler-index"; import { BattlerTagLapseType } from "#enums/battler-tag-lapse-type"; import { BattlerTagType } from "#enums/battler-tag-type"; +import { ChallengeType } from "#enums/challenge-type"; import { CommonAnim } from "#enums/move-anims-common"; import { MoveFlags } from "#enums/move-flags"; import { MoveId } from "#enums/move-id"; @@ -24,7 +28,10 @@ import { applyMoveAttrs } from "#moves/apply-attrs"; import { frenzyMissFunc } from "#moves/move-utils"; import type { PokemonMove } from "#moves/pokemon-move"; import { BattlePhase } from "#phases/battle-phase"; -import { NumberHolder } from "#utils/common"; +// biome-ignore lint/correctness/noUnusedImports: Used in a tsdoc comment +import type { PreUseInterruptAttr } from "#types/move-types"; +import { applyChallenges } from "#utils/challenge-utils"; +import { BooleanHolder, NumberHolder } from "#utils/common"; import { enumValueToKey } from "#utils/enums"; import i18next from "i18next"; @@ -41,6 +48,9 @@ export class MovePhase extends BattlePhase { /** Whether the current move should fail and retain PP. */ protected cancelled = false; + /** Flag set to `true` during {@linkcode checkFreeze} that indicates that the pokemon will thaw if it passes the failure conditions */ + private declare thaw?: boolean; + public get pokemon(): Pokemon { return this._pokemon; } @@ -84,19 +94,6 @@ export class MovePhase extends BattlePhase { this.forcedLast = forcedLast; } - /** - * Checks if the pokemon is active, if the move is usable, and that the move is targeting something. - * @param ignoreDisableTags `true` to not check if the move is disabled - * @returns `true` if all the checks pass - */ - public canMove(ignoreDisableTags = false): boolean { - return ( - this.pokemon.isActive(true) && - this.move.isUsable(this.pokemon, isIgnorePP(this.useMode), ignoreDisableTags) && - this.targets.length > 0 - ); - } - /** Signifies the current move should fail but still use PP */ public fail(): void { this.failed = true; @@ -115,24 +112,78 @@ export class MovePhase extends BattlePhase { return this.forcedLast; } + /** + * Check the first round of failure checks. + * + * @remarks + * Based on battle mechanics research conducted primarily by Smogon, checks happen in the following order (as of Gen 9): + * 1. Sleep/Freeze + * 2. Disobedience due to overleveled (not implemented in Pokerogue) + * 3. Insufficient PP after being selected + * 4. (Pokerogue specific) Moves disabled because they are not implemented / prevented from a challenge / somehow have no targets + * 5. Sky battle (not implemented in Pokerogue) + * 6. Truant + * 7. Loss of focus + * 8. Flinch + * 9. Move was disabled after being selected + * 10. Healing move with heal block + * 11. Sound move with throat chop + * 12. Failure due to gravity + * 13. Move lock from choice items (not implemented in Pokerogue, can't occur here from gorilla tactics) + * 14. Failure from taunt + * 15. Failure from imprison + * 16. Failure from confusion + * 17. Failure from paralysis + * 18. Failure from infatuation + */ + protected firstFailureCheck(): boolean { + // A big if statement will handle the checks (that each have side effects!) in the correct order + if ( + this.checkSleep() || + this.checkFreeze() || + this.checkPP() || + this.checkValidity() || + this.checkTagCancel(BattlerTagType.TRUANT, true) || + this.checkPreUseInterrupt() || + this.checkTagCancel(BattlerTagType.FLINCHED) || + this.checkTagCancel(BattlerTagType.DISABLED, true) || + this.checkGravity() || + this.checkTagCancel(BattlerTagType.TAUNT, true) || + this.checkTagCancel(BattlerTagType.IMPRISON) || + this.checkTagCancel(BattlerTagType.CONFUSED) || + this.checkPara() || + this.checkTagCancel(BattlerTagType.INFATUATED) + ) { + this.handlePreMoveFailures(); + return true; + } + return false; + } + public start(): void { super.start(); - console.log(MoveId[this.move.moveId], enumValueToKey(MoveUseMode, this.useMode)); - - // Check if move is unusable (e.g. running out of PP due to a mid-turn Spite - // or the user no longer being on field), ending the phase early if not. - if (!this.canMove(true)) { - if (this.pokemon.isActive(true)) { - this.fail(); - this.showMoveText(); - this.showFailedText(); - } + if (!this.pokemon.isActive(true)) { this.end(); return; } + // Removing gigaton hammer always happens first + this.pokemon.removeTag(BattlerTagType.ALWAYS_GET_HIT); + console.log(MoveId[this.move.moveId], enumValueToKey(MoveUseMode, this.useMode)); + + // For the purposes of payback and kin, the pokemon is considered to have acted + // if it attempted to move at all. this.pokemon.turnData.acted = true; + // TODO: skip this check for moves like metronome. + if (this.firstFailureCheck()) { + // Lapse all other pre-move tags + this.pokemon.lapseTags(BattlerTagLapseType.PRE_MOVE); + this.end(); + return; + } + + // Begin second failure checks.. // Reset hit-related turn data when starting follow-up moves (e.g. Metronomed moves, Dancer repeats) if (isVirtual(this.useMode)) { @@ -155,10 +206,6 @@ export class MovePhase extends BattlePhase { this.resolveCounterAttackTarget(); - this.resolvePreMoveStatusEffects(); - - this.lapsePreMoveAndMoveTags(); - if (!(this.failed || this.cancelled)) { this.resolveFinalPreMoveCancellationChecks(); } @@ -187,6 +234,8 @@ export class MovePhase extends BattlePhase { this.showMoveText(); this.showFailedText(); this.cancel(); + } else { + this.pokemon.lapseTags(BattlerTagLapseType.MOVE); } } @@ -195,96 +244,220 @@ export class MovePhase extends BattlePhase { } /** - * Handles {@link StatusEffect.SLEEP | Sleep}/{@link StatusEffect.PARALYSIS | Paralysis}/{@link StatusEffect.FREEZE | Freeze} rolls and side effects. + * Queue the status cure message, reset the status, and update the Pokemon info display + * @param effect - The effect being cured */ - protected resolvePreMoveStatusEffects(): void { - // Skip for follow ups/reflected moves, no status condition or post turn statuses (e.g. Poison/Toxic) - if (!this.pokemon.status?.effect || this.pokemon.status.isPostTurn() || isIgnoreStatus(this.useMode)) { - return; - } - - if ( - this.useMode === MoveUseMode.INDIRECT && - [StatusEffect.SLEEP, StatusEffect.FREEZE].includes(this.pokemon.status.effect) - ) { - // Dancer thaws out or wakes up a frozen/sleeping user prior to use - this.pokemon.resetStatus(false); - return; - } - - this.pokemon.status.incrementTurn(); - - /** Whether to prevent us from using the move */ - let activated = false; - /** Whether to cure the status */ - let healed = false; - - switch (this.pokemon.status.effect) { - case StatusEffect.PARALYSIS: - activated = - (this.pokemon.randBattleSeedInt(4) === 0 || Overrides.STATUS_ACTIVATION_OVERRIDE === true) && - Overrides.STATUS_ACTIVATION_OVERRIDE !== false; - break; - case StatusEffect.SLEEP: { - applyMoveAttrs("BypassSleepAttr", this.pokemon, null, this.move.getMove()); - const turnsRemaining = new NumberHolder(this.pokemon.status.sleepTurnsRemaining ?? 0); - applyAbAttrs("ReduceStatusEffectDurationAbAttr", { - pokemon: this.pokemon, - statusEffect: this.pokemon.status.effect, - duration: turnsRemaining, - }); - this.pokemon.status.sleepTurnsRemaining = turnsRemaining.value; - healed = this.pokemon.status.sleepTurnsRemaining <= 0; - activated = !healed && !this.pokemon.getTag(BattlerTagType.BYPASS_SLEEP); - break; - } - case StatusEffect.FREEZE: - healed = - !!this.move - .getMove() - .findAttr( - attr => attr.is("HealStatusEffectAttr") && attr.selfTarget && attr.isOfEffect(StatusEffect.FREEZE), - ) || - (!this.pokemon.randBattleSeedInt(5) && Overrides.STATUS_ACTIVATION_OVERRIDE !== true) || - Overrides.STATUS_ACTIVATION_OVERRIDE === false; - - activated = !healed; - break; - } - - if (activated) { - // Cancel move activation and play effect - this.cancel(); - globalScene.phaseManager.queueMessage( - getStatusEffectActivationText(this.pokemon.status.effect, getPokemonNameWithAffix(this.pokemon)), - ); - globalScene.phaseManager.unshiftNew( - "CommonAnimPhase", - this.pokemon.getBattlerIndex(), - undefined, - CommonAnim.POISON + (this.pokemon.status.effect - 1), // offset anim # by effect # - ); - } else if (healed) { - // cure status and play effect - globalScene.phaseManager.queueMessage( - getStatusEffectHealText(this.pokemon.status.effect, getPokemonNameWithAffix(this.pokemon)), - ); - this.pokemon.resetStatus(); - this.pokemon.updateInfo(); - } + private cureStatus(effect: StatusEffect): void { + const pokemon = this.pokemon; + globalScene.phaseManager.queueMessage(getStatusEffectHealText(effect, getPokemonNameWithAffix(pokemon))); + pokemon.resetStatus(); + pokemon.updateInfo(); } /** - * Lapse {@linkcode BattlerTagLapseType.PRE_MOVE | PRE_MOVE} tags that trigger before a move is used, regardless of whether or not it failed. - * Also lapse {@linkcode BattlerTagLapseType.MOVE | MOVE} tags if the move is successful and not called indirectly. + * Queue the status activation message, play its animation, and cancel the move + * @param effect - The effect being triggered */ - protected lapsePreMoveAndMoveTags(): void { - this.pokemon.lapseTags(BattlerTagLapseType.PRE_MOVE); + private triggerStatus(effect: StatusEffect): void { + const pokemon = this.pokemon; + this.showFailedText(getStatusEffectActivationText(effect, getPokemonNameWithAffix(pokemon))); + globalScene.phaseManager.unshiftNew( + "CommonAnimPhase", + pokemon.getBattlerIndex(), + undefined, + CommonAnim.POISON + (effect - 1), // offset anim # by effect # + ); + this.cancelled = true; + } - // This intentionally happens before moves without targets are cancelled (Truant takes priority over lack of targets) - if (!isIgnoreStatus(this.useMode) && this.canMove() && !this.cancelled) { - this.pokemon.lapseTags(BattlerTagLapseType.MOVE); + /** + * Handle the sleep check + * @returns Whether the move was cancelled due to sleep + */ + protected checkSleep(): boolean { + if (this.pokemon.status?.effect !== StatusEffect.SLEEP) { + return false; } + + if (this.useMode === MoveUseMode.INDIRECT) { + this.pokemon.resetStatus(false); + return false; + } + + this.pokemon.status.incrementTurn(); + applyMoveAttrs("BypassSleepAttr", this.pokemon, null, this.move.getMove()); + const turnsRemaining = new NumberHolder(this.pokemon.status.sleepTurnsRemaining ?? 0); + applyAbAttrs("ReduceStatusEffectDurationAbAttr", { + pokemon: this.pokemon, + statusEffect: this.pokemon.status.effect, + duration: turnsRemaining, + }); + this.pokemon.status.sleepTurnsRemaining = turnsRemaining.value; + if (this.pokemon.status.sleepTurnsRemaining <= 0) { + this.cureStatus(StatusEffect.SLEEP); + return false; + } + + this.triggerStatus(StatusEffect.SLEEP); + return true; + } + + /** + * Handle the freeze status effect check + * + * @remarks + * Responsible for the following + * - Checking if the pokemon is frozen + * - Checking if the pokemon will thaw from random chance, OR from a thawing move. + * Thawing from a freeze move is not applied until AFTER all other failure checks. + * - Activating the freeze status effect (cancelling the move, playing the message, and displaying the animation) + */ + protected checkFreeze(): boolean { + if (this.pokemon.status?.effect !== StatusEffect.FREEZE) { + return false; + } + + // Heal the user if it thaws from the move or random chance + // Check if the user will thaw due to a move + + if ( + Overrides.STATUS_ACTIVATION_OVERRIDE === false || + this.move + .getMove() + .findAttr(attr => attr.selfTarget && attr.is("HealStatusEffectAttr") && attr.isOfEffect(StatusEffect.FREEZE)) || + (!this.pokemon.randBattleSeedInt(5) && Overrides.STATUS_ACTIVATION_OVERRIDE !== true) + ) { + this.cureStatus(StatusEffect.FREEZE); + return false; + } + + // Otherwise, trigger the freeze status effect + this.triggerStatus(StatusEffect.FREEZE); + return true; + } + + /** + * Check if the move is usable based on PP + * @returns Whether the move was cancelled due to insufficient PP + */ + protected checkPP(): boolean { + const move = this.move; + if (move.getMove().pp !== -1 && !isIgnorePP(this.useMode) && move.ppUsed >= move.getMovePp()) { + this.cancel(); + this.showFailedText(); + return true; + } + return false; + } + + /** + * Check if the move is valid and not in an error state + * + * @remarks + * Checks occur in the following order + * 1. Move is not implemented + * 2. Move is somehow invalid (it is {@linkcode MoveId.NONE} or {@linkcode targets} is somehow empty) + * 3. Move cannot be used by the player due to a challenge + * + * @returns Whether the move was cancelled due to being invalid + */ + protected checkValidity(): boolean { + const move = this.move; + const moveId = move.moveId; + const moveName = move.getName(); + let failedText: string | undefined; + const usability = new BooleanHolder(false); + if (moveName.endsWith(" (N)")) { + failedText = i18next.t("battle:moveNotImplemented", { moveName: moveName.replace(" (N)", "") }); + } else if (moveId === MoveId.NONE || this.targets.length === 0) { + // TODO: Create a locale key with some failure text + } else if ( + this.pokemon.isPlayer() && + applyChallenges(ChallengeType.POKEMON_MOVE, moveId, usability) && + // check the value inside of usability after calling applyChallenges + !usability.value + ) { + failedText = i18next.t("battle:moveCannotUseChallenge", { moveName }); + } else { + return false; + } + + this.cancel(); + this.showFailedText(failedText); + return true; + } + + /** + * Cancel the move if its pre use condition fails + * + * @remarks + * The only official move with a pre-use condition is Focus Punch + * + * @returns Whether the move was cancelled due to a pre-use interruption + * @see {@linkcode PreUseInterruptAttr} + */ + private checkPreUseInterrupt(): boolean { + const move = this.move.getMove(); + const user = this.pokemon; + const target = this.getActiveTargetPokemon()[0]; + return !!move.getAttrs("PreUseInterruptAttr").some(attr => { + attr.apply(user, target, move); + if (this.cancelled) { + return true; + } + return false; + }); + } + + /** + * Lapse the tag type and check if the move is cancelled from it. Meant to be used during the first failure check + * @param tag - The tag type whose lapse method will be called with {@linkcode BattlerTagLapseType.PRE_MOVE} + * @param checkIgnoreStatus - Whether to check {@link isIgnoreStatus} for the current {@linkcode MoveUseMode} to skip this check + */ + private checkTagCancel(tag: BattlerTagType, checkIgnoreStatus = false): boolean { + if (checkIgnoreStatus && isIgnoreStatus(this.useMode)) { + return false; + } + this.pokemon.lapseTag(tag, BattlerTagLapseType.PRE_MOVE); + return this.cancelled; + } + + /** + * Handle move failures due to Gravity, cancelling the move and showing the failure text + * @returns - Whether the move was cancelled due to Gravity + */ + private checkGravity(): boolean { + const move = this.move.getMove(); + if (globalScene.arena.hasTag(ArenaTagType.GRAVITY) && move.hasFlag(MoveFlags.GRAVITY)) { + // Play the failure message + this.showFailedText( + i18next.t("battle:moveDisabledGravity", { + pokemonNameWithAffix: getPokemonNameWithAffix(this.pokemon), + moveName: move.name, + }), + ); + return true; + } + return false; + } + + /** + * Handle the paralysis status effect check, cancelling the move and queueing the activation message and animation + * + * @returns Whether the move was cancelled due to paralysis + */ + private checkPara(): boolean { + if (this.pokemon.status?.effect !== StatusEffect.PARALYSIS) { + return false; + } + const proc = + (this.pokemon.randBattleSeedInt(4) === 0 || Overrides.STATUS_ACTIVATION_OVERRIDE === true) && + Overrides.STATUS_ACTIVATION_OVERRIDE !== false; + if (!proc) { + return false; + } + this.triggerStatus(StatusEffect.PARALYSIS); + return true; } protected useMove(): void { @@ -295,14 +468,6 @@ export class MovePhase extends BattlePhase { // form changes happen even before we know that the move wll execute. globalScene.triggerPokemonFormChange(this.pokemon, SpeciesFormChangePreMoveTrigger); - // Check if the move has any attributes that can interrupt its own use **before** displaying text. - // TODO: This should not rely on direct return values - let failed = move.getAttrs("PreUseInterruptAttr").some(attr => attr.apply(this.pokemon, targets[0], move)); - if (failed) { - this.failMove(false); - return; - } - // Clear out any two turn moves once they've been used. // TODO: Refactor move queues and remove this assignment; // Move queues should be handled by the calling `CommandPhase` or a manager for it @@ -332,10 +497,10 @@ export class MovePhase extends BattlePhase { * Move conditions assume the move has a single target * TODO: is this sustainable? */ - const failsConditions = !move.applyConditions(this.pokemon, targets[0], move); + const failsConditions = !move.applyConditions(this.pokemon, targets[0]); const failedDueToWeather = globalScene.arena.isMoveWeatherCancelled(this.pokemon, move); const failedDueToTerrain = globalScene.arena.isMoveTerrainCancelled(this.pokemon, this.targets, move); - failed ||= failsConditions || failedDueToWeather || failedDueToTerrain; + const failed = failsConditions || failedDueToWeather || failedDueToTerrain; if (failed) { this.failMove(true, failedDueToWeather, failedDueToTerrain); @@ -442,7 +607,7 @@ export class MovePhase extends BattlePhase { const move = this.move.getMove(); const targets = this.getActiveTargetPokemon(); - if (!move.applyConditions(this.pokemon, targets[0], move)) { + if (!move.applyConditions(this.pokemon, targets[0])) { this.failMove(true); return; } diff --git a/test/moves/belch.test.ts b/test/moves/belch.test.ts new file mode 100644 index 00000000000..16eda37f89a --- /dev/null +++ b/test/moves/belch.test.ts @@ -0,0 +1,49 @@ +import { AbilityId } from "#enums/ability-id"; +import { MoveId } from "#enums/move-id"; +import { SpeciesId } from "#enums/species-id"; +import { GameManager } from "#test/test-utils/game-manager"; +import Phaser from "phaser"; +import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest"; + +describe("Move - Belch", () => { + let phaserGame: Phaser.Game; + let game: GameManager; + + beforeAll(() => { + phaserGame = new Phaser.Game({ + type: Phaser.HEADLESS, + }); + }); + + afterEach(() => { + game.phaseInterceptor.restoreOg(); + }); + + beforeEach(() => { + game = new GameManager(phaserGame); + game.override + .ability(AbilityId.BALL_FETCH) + .battleStyle("single") + .criticalHits(false) + .moveset(MoveId.BELCH) + .enemySpecies(SpeciesId.MAGIKARP) + .enemyAbility(AbilityId.BALL_FETCH) + .enemyMoveset(MoveId.SPLASH); + }); + + it("should only be selectable if the user has previously eaten a berry", async () => { + await game.classicMode.startBattle([SpeciesId.FEEBAS]); + const player = game.field.getPlayerPokemon(); + expect( + !game.field.getPlayerPokemon().isMoveSelectable(MoveId.BELCH), + "Belch should not be selectable without a berry", + ); + + player.battleData.hasEatenBerry = true; + + expect( + game.field.getPlayerPokemon().isMoveSelectable(MoveId.BELCH), + "Belch should be selectable after eating a berry", + ); + }); +}); From a77e3c911f43d3cf6884967795d073f856394a24 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Sun, 17 Aug 2025 21:26:45 -0500 Subject: [PATCH 2/9] Add second and third failure sequences --- src/data/moves/move-condition.ts | 41 +++-- src/data/moves/move.ts | 78 ++++++-- src/field/pokemon.ts | 6 +- src/phases/command-phase.ts | 1 + src/phases/move-phase.ts | 304 +++++++++++++++++++++++-------- 5 files changed, 319 insertions(+), 111 deletions(-) diff --git a/src/data/moves/move-condition.ts b/src/data/moves/move-condition.ts index ffb52294123..5d03bc7926d 100644 --- a/src/data/moves/move-condition.ts +++ b/src/data/moves/move-condition.ts @@ -1,3 +1,5 @@ +// biome-ignore lint/correctness/noUnusedImports: Used in a tsdoc comment +import type { GameMode } from "#app/game-mode"; import { globalScene } from "#app/global-scene"; import { getPokemonNameWithAffix } from "#app/messages"; import { allMoves } from "#data/data-lists"; @@ -45,29 +47,44 @@ export class FirstMoveCondition extends MoveCondition { return user.tempSummonData.waveTurnCount === 1; }; + // TODO: Update AI move selection logic to not require this method at all + // Currently, it is used to avoid having the AI select the move if its condition will fail getUserBenefitScore(user: Pokemon, _target: Pokemon, _move: Move): number { return this.apply(user, _target, _move) ? 10 : -20; } } +/** + * Condition that forces moves to fail against the final boss in classic and the major boss in endless + * @remarks + * ⚠️ Only works reliably for single-target moves as only one target is provided; should not be used for multi-target moves + * @see {@linkcode GameMode.isBattleClassicFinalBoss} + * @see {@linkcode GameMode.isEndlessMinorBoss} + */ +export const failAgainstFinalBossCondition = new MoveCondition((_user, target) => { + const gameMode = globalScene.gameMode; + const currentWave = globalScene.currentBattle.waveIndex; + return ( + target.isEnemy() && (gameMode.isBattleClassicFinalBoss(currentWave) || gameMode.isEndlessMinorBoss(currentWave)) + ); +}); + /** * Condition used by the move {@link https://bulbapedia.bulbagarden.net/wiki/Upper_Hand_(move) | Upper Hand}. * Moves with this condition are only successful when the target has selected * a high-priority attack (after factoring in priority-boosting effects) and * hasn't moved yet this turn. */ -export class UpperHandCondition extends MoveCondition { - public override readonly func: MoveConditionFunc = (_user, target) => { - const targetCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; - return ( - targetCommand?.command === Command.FIGHT && - !target.turnData.acted && - !!targetCommand.move?.move && - allMoves[targetCommand.move.move].category !== MoveCategory.STATUS && - allMoves[targetCommand.move.move].getPriority(target) > 0 - ); - }; -} +export const UpperHandCondition = new MoveCondition((_user, target) => { + const targetCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; + return ( + targetCommand?.command === Command.FIGHT && + !target.turnData.acted && + !!targetCommand.move?.move && + allMoves[targetCommand.move.move].category !== MoveCategory.STATUS && + allMoves[targetCommand.move.move].getPriority(target) > 0 + ); +}); /** * A restriction that prevents a move from being selected diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 4c6dd3ab599..7ef35de9422 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -93,7 +93,7 @@ import { getEnumValues } from "#utils/enums"; import { toCamelCase, toTitleCase } from "#utils/strings"; import i18next from "i18next"; import { applyChallenges } from "#utils/challenge-utils"; -import { ConsecutiveUseRestriction, FirstMoveCondition, GravityUseRestriction, MoveCondition, MoveRestriction, UpperHandCondition } from "#moves/move-condition"; +import { ConsecutiveUseRestriction, failAgainstFinalBossCondition, FirstMoveCondition, GravityUseRestriction, MoveCondition, MoveRestriction, UpperHandCondition } from "#moves/move-condition"; /** * A function used to conditionally determine execution of a given {@linkcode MoveAttr}. @@ -122,6 +122,10 @@ export abstract class Move implements Localizable { * @remarks Different from {@linkcode restrictions}, which is checked when the move is selected */ private conditions: MoveCondition[] = []; + /** + * Move failure conditions that occur during the second check (after move message and before ) + */ + private conditionsSeq2: MoveCondition[] = []; /** Conditions that must be false for a move to be able to be selected. * * @remarks Different from {@linkcode conditions}, which is checked when the move is invoked @@ -380,13 +384,15 @@ export abstract class Move implements Localizable { * Adds a condition to this move (in addition to any provided by its prior {@linkcode MoveAttr}s). * The move will fail upon use if at least 1 of its conditions is not met. * @param condition - The {@linkcode MoveCondition} or {@linkcode MoveConditionFunc} to add to the conditions array. + * @param checkSequence - The sequence number where the failure check occurs * @returns `this` for method chaining */ - condition(condition: MoveCondition | MoveConditionFunc): this { + condition(condition: MoveCondition | MoveConditionFunc, checkSequence: 2 | 3 = 3): this { + const conditionsArray = checkSequence === 2 ? this.conditionsSeq2 : this.conditions; if (typeof condition === "function") { condition = new MoveCondition(condition); } - this.conditions.push(condition); + conditionsArray.push(condition); return this; } @@ -762,13 +768,15 @@ export abstract class Move implements Localizable { /** * Applies each {@linkcode MoveCondition} function of this move to the params, determines if the move can be used prior to calling each attribute's apply() - * @param user {@linkcode Pokemon} to apply conditions to - * @param target {@linkcode Pokemon} to apply conditions to - * @param move {@linkcode Move} to apply conditions to + * @param user - {@linkcode Pokemon} to apply conditions to + * @param target - {@linkcode Pokemon} to apply conditions to + * @param move - {@linkcode Move} to apply conditions to + * @param sequence - The sequence number where the condition check occurs, defaults to 3 * @returns boolean: false if any of the apply()'s return false, else true */ - applyConditions(user: Pokemon, target: Pokemon): boolean { - return this.conditions.every(cond => cond.apply(user, target, this)); + applyConditions(user: Pokemon, target: Pokemon, sequence: number = 3): boolean { + const conditionsArray = sequence === 2 ? this.conditionsSeq2 : this.conditions; + return conditionsArray.every(cond => cond.apply(user, target, this)); } @@ -9105,6 +9113,7 @@ export function initMoves() { new SelfStatusMove(MoveId.DESTINY_BOND, PokemonType.GHOST, -1, 5, -1, 0, 2) .ignoresProtect() .attr(DestinyBondAttr) + .condition(failAgainstFinalBossCondition, 2) .condition((user, target, move) => { // Retrieves user's previous move, returns empty array if no moves have been used const lastTurnMove = user.getLastXMoves(1); @@ -9389,6 +9398,8 @@ export function initMoves() { .unimplemented(), new StatusMove(MoveId.ROLE_PLAY, PokemonType.PSYCHIC, -1, 10, -1, 0, 3) .ignoresSubstitute() + // TODO: Enable / remove once balance reaches a consensus on ability overrides during boss fights + // .condition(failAgainstFinalBossCondition, 3) .attr(AbilityCopyAttr), new SelfStatusMove(MoveId.WISH, PokemonType.NORMAL, -1, 10, -1, 0, 3) .attr(WishAttr) @@ -9436,6 +9447,8 @@ export function initMoves() { new StatusMove(MoveId.IMPRISON, PokemonType.PSYCHIC, 100, 10, -1, 0, 3) .ignoresSubstitute() .attr(AddArenaTagAttr, ArenaTagType.IMPRISON, 1, true, false) + // TODO: Enable / remove once balance reaches a consensus on imprison interaction during the final boss fight + // .condition(failAgainstFinalBossCondition, 2) .target(MoveTarget.ENEMY_SIDE), new SelfStatusMove(MoveId.REFRESH, PokemonType.NORMAL, -1, 20, -1, 0, 3) .attr(HealStatusEffectAttr, true, [ StatusEffect.PARALYSIS, StatusEffect.POISON, StatusEffect.TOXIC, StatusEffect.BURN ]) @@ -9767,6 +9780,8 @@ export function initMoves() { .edgeCase(), // May or may not need to ignore remotely called moves depending on how it works new StatusMove(MoveId.WORRY_SEED, PokemonType.GRASS, 100, 10, -1, 0, 4) .attr(AbilityChangeAttr, AbilityId.INSOMNIA) + // TODO: Enable / remove once balance reaches a consensus on ability overrides during boss fights + // .condition(failAgainstFinalBossCondition, 3) .reflectable(), new AttackMove(MoveId.SUCKER_PUNCH, PokemonType.DARK, MoveCategory.PHYSICAL, 70, 100, 5, -1, 1, 4) .condition((user, target, move) => { @@ -9999,9 +10014,13 @@ export function initMoves() { .attr(AddArenaTagAttr, ArenaTagType.WIDE_GUARD, 1, true, true) .condition(failIfLastCondition), new StatusMove(MoveId.GUARD_SPLIT, PokemonType.PSYCHIC, -1, 10, -1, 0, 5) + // TODO: Enable / remove once balance reaches a consensus on imprison interaction during the final boss fight + // .condition(failAgainstFinalBossCondition, 2) .attr(AverageStatsAttr, [ Stat.DEF, Stat.SPDEF ], "moveTriggers:sharedGuard"), new StatusMove(MoveId.POWER_SPLIT, PokemonType.PSYCHIC, -1, 10, -1, 0, 5) .attr(AverageStatsAttr, [ Stat.ATK, Stat.SPATK ], "moveTriggers:sharedPower"), + // TODO: Enable / remove once balance reaches a consensus on imprison interaction during the final boss fight + // .condition(failAgainstFinalBossCondition, 2) new StatusMove(MoveId.WONDER_ROOM, PokemonType.PSYCHIC, -1, 10, -1, 0, 5) .ignoresProtect() .target(MoveTarget.BOTH_SIDES) @@ -10071,9 +10090,13 @@ export function initMoves() { .attr(TargetAtkUserAtkAttr), new StatusMove(MoveId.SIMPLE_BEAM, PokemonType.NORMAL, 100, 15, -1, 0, 5) .attr(AbilityChangeAttr, AbilityId.SIMPLE) + // TODO: Enable / remove once balance reaches a consensus on ability overrides during boss fights + // .condition(failAgainstFinalBossCondition, 3) .reflectable(), new StatusMove(MoveId.ENTRAINMENT, PokemonType.NORMAL, 100, 15, -1, 0, 5) .attr(AbilityGiveAttr) + // TODO: Enable / remove once balance reaches a consensus on ability overrides during boss fights + // .condition(failAgainstFinalBossCondition, 3) .reflectable(), new StatusMove(MoveId.AFTER_YOU, PokemonType.NORMAL, -1, 15, -1, 0, 5) .ignoresProtect() @@ -10659,7 +10682,12 @@ export function initMoves() { new AttackMove(MoveId.POLLEN_PUFF, PokemonType.BUG, MoveCategory.SPECIAL, 90, 100, 15, -1, 0, 7) .attr(StatusCategoryOnAllyAttr) .attr(HealOnAllyAttr, 0.5, true, false) - .ballBombMove(), + .ballBombMove() + // Fail if used against an ally that is affected by heal block, during the second failure check + .condition( + (user, target) => target.getAlly() === user && !!target.getTag(BattlerTagType.HEAL_BLOCK), + 2 + ), new AttackMove(MoveId.ANCHOR_SHOT, PokemonType.STEEL, MoveCategory.PHYSICAL, 80, 100, 20, 100, 0, 7) .attr(AddBattlerTagAttr, BattlerTagType.TRAPPED, false, false, 1, 1, true), new StatusMove(MoveId.PSYCHIC_TERRAIN, PokemonType.PSYCHIC, -1, 10, -1, 0, 7) @@ -10672,16 +10700,21 @@ export function initMoves() { new AttackMove(MoveId.POWER_TRIP, PokemonType.DARK, MoveCategory.PHYSICAL, 20, 100, 10, -1, 0, 7) .attr(PositiveStatStagePowerAttr), new AttackMove(MoveId.BURN_UP, PokemonType.FIRE, MoveCategory.SPECIAL, 130, 100, 5, -1, 0, 7) - .condition((user) => { - const userTypes = user.getTypes(true); - return userTypes.includes(PokemonType.FIRE); - }) + .condition( + // Pass `true` to `ForDefend` as it should fail if the user is terastallized to a type that is not FIRE + user => user.isOfType(PokemonType.FIRE, true, true), + 2 + ) .attr(HealStatusEffectAttr, true, StatusEffect.FREEZE) .attr(AddBattlerTagAttr, BattlerTagType.BURNED_UP, true, false) .attr(RemoveTypeAttr, PokemonType.FIRE, (user) => { globalScene.phaseManager.queueMessage(i18next.t("moveTriggers:burnedItselfOut", { pokemonName: getPokemonNameWithAffix(user) })); }), new StatusMove(MoveId.SPEED_SWAP, PokemonType.PSYCHIC, -1, 10, -1, 0, 7) + // Note: the 3 is NOT a typo; unlike power split / guard split which happen in the second failure sequence, speed + // swap's check happens in the third + // TODO: Enable / remove once balance reaches a consensus on imprison interaction during the final boss fight + // .condition(failAgainstFinalBossCondition, 3) .attr(SwapStatAttr, Stat.SPD) .ignoresSubstitute(), new AttackMove(MoveId.SMART_STRIKE, PokemonType.STEEL, MoveCategory.PHYSICAL, 70, -1, 10, -1, 0, 7), @@ -10908,8 +10941,12 @@ export function initMoves() { true), new SelfStatusMove(MoveId.NO_RETREAT, PokemonType.FIGHTING, -1, 5, -1, 0, 8) .attr(StatStageChangeAttr, [ Stat.ATK, Stat.DEF, Stat.SPATK, Stat.SPDEF, Stat.SPD ], 1, true) - .attr(AddBattlerTagAttr, BattlerTagType.NO_RETREAT, true, false) - .condition((user, target, move) => user.getTag(TrappedTag)?.tagType !== BattlerTagType.NO_RETREAT), // fails if the user is currently trapped by No Retreat + .attr(AddBattlerTagAttr, BattlerTagType.NO_RETREAT, true, true /* NOT ADDED if already trapped */) + .condition( + // fails if the user is currently trapped specifically from no retreat + user => user.getTag(TrappedTag)?.tagType !== BattlerTagType.NO_RETREAT, + 2 + ), new StatusMove(MoveId.TAR_SHOT, PokemonType.ROCK, 100, 15, -1, 0, 8) .attr(StatStageChangeAttr, [ Stat.SPD ], -1) .attr(AddBattlerTagAttr, BattlerTagType.TAR_SHOT, false) @@ -11472,10 +11509,11 @@ export function initMoves() { .slicingMove() .triageMove(), new AttackMove(MoveId.DOUBLE_SHOCK, PokemonType.ELECTRIC, MoveCategory.PHYSICAL, 120, 100, 5, -1, 0, 9) - .condition((user) => { - const userTypes = user.getTypes(true); - return userTypes.includes(PokemonType.ELECTRIC); - }) + .condition( + // Pass `true` to `isOfType` to fail if the user is terastallized to a type other than ELECTRIC + user => user.isOfType(PokemonType.ELECTRIC, true, true), + 2 + ) .attr(AddBattlerTagAttr, BattlerTagType.DOUBLE_SHOCKED, true, false) .attr(RemoveTypeAttr, PokemonType.ELECTRIC, (user) => { globalScene.phaseManager.queueMessage(i18next.t("moveTriggers:usedUpAllElectricity", { pokemonName: getPokemonNameWithAffix(user) })); @@ -11573,7 +11611,7 @@ export function initMoves() { .attr(AddBattlerTagAttr, BattlerTagType.HEAL_BLOCK, false, false, 2), new AttackMove(MoveId.UPPER_HAND, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 65, 100, 15, 100, 3, 9) .attr(FlinchAttr) - .condition(new UpperHandCondition()), + .condition(UpperHandCondition), new AttackMove(MoveId.MALIGNANT_CHAIN, PokemonType.POISON, MoveCategory.SPECIAL, 100, 100, 5, 50, 0, 9) .attr(StatusEffectAttr, StatusEffect.TOXIC) ); diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index 9c6c817cc38..f7542b84034 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -2375,7 +2375,7 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { * @param source {@linkcode Pokemon} The attacking Pokémon. * @param move {@linkcode Move} The move being used by the attacking Pokémon. * @param ignoreAbility Whether to ignore abilities that might affect type effectiveness or immunity (defaults to `false`). - * @param simulated Whether to apply abilities via simulated calls (defaults to `true`) + * @param simulated - Whether to apply abilities via simulated calls (defaults to `true`). This should only be false during the move effect phase * @param cancelled {@linkcode BooleanHolder} Stores whether the move was cancelled by a non-type-based immunity. * @param useIllusion - Whether we want the attack move effectiveness on the illusion or not * @returns The type damage multiplier, indicating the effectiveness of the move @@ -2429,7 +2429,9 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { applyAbAttrs("MoveImmunityAbAttr", commonAbAttrParams); } - if (!cancelledHolder.value) { + // Do not check queenly majesty unless this is being simulated + // This is because the move effect phase should not check queenly majesty, as that is handled by the move phase + if (simulated && !cancelledHolder.value) { const defendingSidePlayField = this.isPlayer() ? globalScene.getPlayerField() : globalScene.getEnemyField(); defendingSidePlayField.forEach(p => applyAbAttrs("FieldPriorityMoveImmunityAbAttr", { diff --git a/src/phases/command-phase.ts b/src/phases/command-phase.ts index e1d472ae650..6b51bb379a5 100644 --- a/src/phases/command-phase.ts +++ b/src/phases/command-phase.ts @@ -257,6 +257,7 @@ export class CommandPhase extends FieldPhase { : cursor > -1 && !playerPokemon.getMoveset().some(m => m.isUsable(playerPokemon)[0]); if (!canUse && !useStruggle) { + console.error("Cannot use move:", reason); this.queueFightErrorMessage(reason); return false; } diff --git a/src/phases/move-phase.ts b/src/phases/move-phase.ts index 96d28fff603..115cbfb1ecc 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -2,8 +2,6 @@ import { applyAbAttrs } from "#abilities/apply-ab-attrs"; import { globalScene } from "#app/global-scene"; import { getPokemonNameWithAffix } from "#app/messages"; import Overrides from "#app/overrides"; -// biome-ignore lint/correctness/noUnusedImports: Used in a tsdoc comment -import type { TauntTag, TruantTag } from "#data/battler-tags"; import { CenterOfAttentionTag } from "#data/battler-tags"; import { SpeciesFormChangePreMoveTrigger } from "#data/form-change-triggers"; import { getStatusEffectActivationText, getStatusEffectHealText } from "#data/status-effect"; @@ -113,7 +111,9 @@ export class MovePhase extends BattlePhase { } /** - * Check the first round of failure checks. + * Check the first round of failure checks + * + * @returns Whether the move failed * * @remarks * Based on battle mechanics research conducted primarily by Smogon, checks happen in the following order (as of Gen 9): @@ -147,6 +147,8 @@ export class MovePhase extends BattlePhase { this.checkPreUseInterrupt() || this.checkTagCancel(BattlerTagType.FLINCHED) || this.checkTagCancel(BattlerTagType.DISABLED, true) || + this.checkTagCancel(BattlerTagType.HEAL_BLOCK) || + this.checkTagCancel(BattlerTagType.THROAT_CHOPPED) || this.checkGravity() || this.checkTagCancel(BattlerTagType.TAUNT, true) || this.checkTagCancel(BattlerTagType.IMPRISON) || @@ -160,6 +162,115 @@ export class MovePhase extends BattlePhase { return false; } + /** + * Handle the status interactions for sleep and freeze that happen after passing the first failure check + * + * @remarks + * - If the user is asleep but can use the move, the sleep animation and message is still shown + * - If the user is frozen but is thawed from its move, the user's status is cured and the thaw message is shown + */ + private post1stFailSleepOrThaw(): void { + const user = this.pokemon; + // If the move was successful, then... play the "sleeping" animation if the user is asleep but uses something like rest / snore + // Cure the user's freeze and queue the thaw message from unfreezing due to move use + if (!isIgnoreStatus(this.useMode)) { + if (user.status?.effect === StatusEffect.SLEEP) { + // Commence the sleeping animation and message, which happens anyway + // TODO... + } else if (this.thaw) { + this.cureStatus( + StatusEffect.FREEZE, + i18next.t("statusEffect:freeze.healByMove", { + pokemonName: getPokemonNameWithAffix(user), + moveName: this.move.getMove().name, + }), + ); + } + } + } + + /** + * Second failure check that occurs after the "Pokemon used move" text is shown but BEFORE the move has been registered + * as being the last move used (for the purposes of something like Copycat) + * + * @remarks + * Other than powder, each failure condition is mutually exclusive (as they are tied to specific moves), so order does not matter. + * Notably, this failure check only includes failure conditions intrinsic to the move itself, ther than Powder (which marks the end of this failure check) + * + * + * - Pollen puff used on an ally that is under effect of heal block + * - Burn up / Double shock when the user does not have the required type + * - No Retreat while already under its effects + * - (on cart, not applicable to Pokerogue) Moves that fail if used ON a raid / special boss: selfdestruct/explosion/imprision/power split / guard split + * - (on cart, not applicable to Pokerogue) Moves that fail during a "co-op" battle (like when Arven helps during raid boss): ally switch / teatime + * + * After all checks, Powder causing the user to explode + */ + protected secondFailureCheck(): boolean { + const move = this.move.getMove(); + const user = this.pokemon; + if (!move.applyConditions(user, this.getActiveTargetPokemon()[0], 2)) { + this.failed = true; + // Note: If any of the moves have custom failure messages, this needs to be changed + // As of Gen 9, none do. (Except maybe pollen puff? Need to check) + return true; + } + // Powder *always* happens last + // Note: Powder's lapse method handles everything: messages, damage, animation, primal weather interaction, + // determining type of type changing moves, etc. + // It will set this phase's `failed` flag to true if it procs + user.lapseTag(BattlerTagType.POWDER, BattlerTagLapseType.PRE_MOVE); + return this.failed; + } + + /** + * Third failure check is from moves and abilities themselves + * + * @returns Whether the move failed + * + * @remarks + * - Conditional attributes of the move + * - Weather blocking the move + * - Terrain blocking the move + * - Queenly Majesty / Dazzling + */ + protected thirdFailureCheck(): boolean { + /** + * Move conditions assume the move has a single target + * TODO: is this sustainable? + */ + const move = this.move.getMove(); + const targets = this.getActiveTargetPokemon(); + const arena = globalScene.arena; + const user = this.pokemon; + const failsConditions = !move.applyConditions(user, targets[0]); + const failedDueToWeather = arena.isMoveWeatherCancelled(user, move); + const failedDueToTerrain = arena.isMoveTerrainCancelled(user, this.targets, move); + let failed = failsConditions || failedDueToWeather || failedDueToTerrain; + + // Apply queenly majesty / dazzling + if (!failed) { + const defendingSidePlayField = user.isPlayer() ? globalScene.getPlayerField() : globalScene.getEnemyField(); + const cancelled = new BooleanHolder(false); + defendingSidePlayField.forEach((pokemon: Pokemon) => { + applyAbAttrs("FieldPriorityMoveImmunityAbAttr", { + pokemon, + opponent: user, + move, + cancelled, + }); + }); + failed = cancelled.value; + } + + if (failed) { + this.failMove(true, failedDueToWeather, failedDueToTerrain); + return true; + } + + return false; + } + public start(): void { super.start(); @@ -168,25 +279,52 @@ export class MovePhase extends BattlePhase { return; } + const user = this.pokemon; + // Removing gigaton hammer always happens first - this.pokemon.removeTag(BattlerTagType.ALWAYS_GET_HIT); + user.removeTag(BattlerTagType.ALWAYS_GET_HIT); console.log(MoveId[this.move.moveId], enumValueToKey(MoveUseMode, this.useMode)); // For the purposes of payback and kin, the pokemon is considered to have acted // if it attempted to move at all. - this.pokemon.turnData.acted = true; - // TODO: skip this check for moves like metronome. - if (this.firstFailureCheck()) { + user.turnData.acted = true; + const useMode = this.useMode; + const virtual = isVirtual(useMode); + if (!virtual && this.firstFailureCheck()) { // Lapse all other pre-move tags - this.pokemon.lapseTags(BattlerTagLapseType.PRE_MOVE); + user.lapseTags(BattlerTagLapseType.PRE_MOVE); this.end(); + + /* + On cartridge, certain things *react* to move failures, depending on failure reason + The following would happen at this time on cartridge: + - Steadfast giving user speed boost if failed due to flinch + - Protect, detect, ally switch, etc, resetting consecutive use count + - Rollout / ice ball "unlocking" + - protect / ally switch / other moves resetting their consecutive use count + - and others + In Pokerogue, these are instead handled by their respective methods, which generally + */ return; } - // Begin second failure checks.. + // Now, issue the second failure checks + + // If the user was asleep but is using a move anyway, it should STILL display the "user is sleeping" message! + // At this point, cure the user's freeze + + // At this point, called moves should be decided. + // For now, this is a placeholder until we rework how called moves are handled + // For correct alignment with mainline, this SHOULD go here, and it SHOULD rewrite its own move + // Though, this is not the case in pokerogue. + + // At this point... + // If the first failure check passes, then thaw the user if its move will thaw it. + // The sleep message and animation are also played if the user is asleep but using a move anyway (snore, sleep talk, etc) + this.post1stFailSleepOrThaw(); // Reset hit-related turn data when starting follow-up moves (e.g. Metronomed moves, Dancer repeats) - if (isVirtual(this.useMode)) { + if (virtual) { this.pokemon.turnData.hitsLeft = -1; this.pokemon.turnData.hitCount = 0; } @@ -202,10 +340,30 @@ export class MovePhase extends BattlePhase { globalScene.arena.setIgnoreAbilities(true, this.pokemon.getBattlerIndex()); } - this.resolveRedirectTarget(); + // At this point, move's type changing and multi-target effects *should* be applied + // Pokerogue's current implementation applies these effects during the move effect phase + // as there is not (yet) a notion of a move-in-flight for determinations to occur + this.resolveRedirectTarget(); this.resolveCounterAttackTarget(); + // Move is announced + this.showMoveText(); + + // Stance change happens + const charging = this.move.getMove().isChargingMove() && !this.pokemon.getTag(BattlerTagType.CHARGING); + // Stance change happens now if the move is about to be executed + if (!charging) { + globalScene.triggerPokemonFormChange(this.pokemon, SpeciesFormChangePreMoveTrigger); + } + + if (this.secondFailureCheck()) { + this.showFailedText(); + this.handlePreMoveFailures(); + this.end(); + return; + } + if (!(this.failed || this.cancelled)) { this.resolveFinalPreMoveCancellationChecks(); } @@ -213,7 +371,7 @@ export class MovePhase extends BattlePhase { // Cancel, charge or use the move as applicable. if (this.cancelled || this.failed) { this.handlePreMoveFailures(); - } else if (this.move.getMove().isChargingMove() && !this.pokemon.getTag(BattlerTagType.CHARGING)) { + } else if (charging) { this.chargeMove(); } else { this.useMove(); @@ -222,7 +380,7 @@ export class MovePhase extends BattlePhase { this.end(); } - /** Check for cancellation edge cases - no targets remaining, or {@linkcode MoveId.NONE} is in the queue */ + /** Check for cancellation edge cases - no targets remaining */ protected resolveFinalPreMoveCancellationChecks(): void { const targets = this.getActiveTargetPokemon(); const moveQueue = this.pokemon.getMoveQueue(); @@ -231,7 +389,6 @@ export class MovePhase extends BattlePhase { (targets.length === 0 && !this.move.getMove().hasAttr("AddArenaTrapTagAttr")) || (moveQueue.length > 0 && moveQueue[0].move === MoveId.NONE) ) { - this.showMoveText(); this.showFailedText(); this.cancel(); } else { @@ -246,10 +403,12 @@ export class MovePhase extends BattlePhase { /** * Queue the status cure message, reset the status, and update the Pokemon info display * @param effect - The effect being cured + * @param msg - A custom message to display when curing the status effect (used for curing freeze due to move use) */ - private cureStatus(effect: StatusEffect): void { + private cureStatus(effect: StatusEffect, msg?: string): void { const pokemon = this.pokemon; - globalScene.phaseManager.queueMessage(getStatusEffectHealText(effect, getPokemonNameWithAffix(pokemon))); + // Freeze healed by move uses its own msg + globalScene.phaseManager.queueMessage(msg ?? getStatusEffectHealText(effect, getPokemonNameWithAffix(pokemon))); pokemon.resetStatus(); pokemon.updateInfo(); } @@ -317,9 +476,23 @@ export class MovePhase extends BattlePhase { return false; } - // Heal the user if it thaws from the move or random chance - // Check if the user will thaw due to a move + // Check if move use would heal the user + if (Overrides.STATUS_ACTIVATION_OVERRIDE) { + return false; + } + + // Check if the move will heal + const move = this.move.getMove(); + if ( + move.findAttr(attr => attr.selfTarget && attr.is("HealStatusEffectAttr") && attr.isOfEffect(StatusEffect.FREEZE)) + ) { + // On cartridge, burn up will not cure if it would fail + if (move.id === MoveId.BURN_UP && !this.pokemon.isOfType(PokemonType.FIRE)) { + } + this.thaw = true; + return false; + } if ( Overrides.STATUS_ACTIVATION_OVERRIDE === false || this.move @@ -370,7 +543,17 @@ export class MovePhase extends BattlePhase { if (moveName.endsWith(" (N)")) { failedText = i18next.t("battle:moveNotImplemented", { moveName: moveName.replace(" (N)", "") }); } else if (moveId === MoveId.NONE || this.targets.length === 0) { - // TODO: Create a locale key with some failure text + this.cancel(); + + const pokemonName = this.pokemon.name; + const warningText = + moveId === MoveId.NONE + ? `${pokemonName} is attempting to use MoveId.NONE` + : `${pokemonName} is attempting to use a move with no targets`; + + console.warn(warningText); + + return true; } else if ( this.pokemon.isPlayer() && applyChallenges(ChallengeType.POKEMON_MOVE, moveId, usability) && @@ -460,85 +643,54 @@ export class MovePhase extends BattlePhase { return true; } + protected usePP(): void { + if (!isIgnorePP(this.useMode)) { + const move = this.move; + // "commit" to using the move, deducting PP. + const ppUsed = 1 + this.getPpIncreaseFromPressure(this.getActiveTargetPokemon()); + move.usePp(ppUsed); + globalScene.eventTarget.dispatchEvent(new MoveUsedEvent(this.pokemon.id, this.move.getMove(), this.move.ppUsed)); + } + } + protected useMove(): void { - const targets = this.getActiveTargetPokemon(); - const moveQueue = this.pokemon.getMoveQueue(); - const move = this.move.getMove(); - - // form changes happen even before we know that the move wll execute. - globalScene.triggerPokemonFormChange(this.pokemon, SpeciesFormChangePreMoveTrigger); - + const user = this.pokemon; // Clear out any two turn moves once they've been used. // TODO: Refactor move queues and remove this assignment; // Move queues should be handled by the calling `CommandPhase` or a manager for it // @ts-expect-error - useMode is readonly and shouldn't normally be assigned to - this.useMode = moveQueue.shift()?.useMode ?? this.useMode; + this.useMode = user.getMoveQueue().shift()?.useMode ?? this.useMode; - if (this.pokemon.getTag(BattlerTagType.CHARGING)?.sourceMove === this.move.moveId) { - this.pokemon.lapseTag(BattlerTagType.CHARGING); + if (user.getTag(BattlerTagType.CHARGING)?.sourceMove === this.move.moveId) { + user.lapseTag(BattlerTagType.CHARGING); } - if (!isIgnorePP(this.useMode)) { - // "commit" to using the move, deducting PP. - const ppUsed = 1 + this.getPpIncreaseFromPressure(targets); - this.move.usePp(ppUsed); - globalScene.eventTarget.dispatchEvent(new MoveUsedEvent(this.pokemon.id, move, this.move.ppUsed)); + if (!this.thirdFailureCheck()) { + this.executeMove(); } - - /** - * Determine if the move is successful (meaning that its damage/effects can be attempted) - * by checking that all of the following are true: - * - Conditional attributes of the move are all met - * - Weather does not block the move - * - Terrain does not block the move - */ - - /** - * Move conditions assume the move has a single target - * TODO: is this sustainable? - */ - const failsConditions = !move.applyConditions(this.pokemon, targets[0]); - const failedDueToWeather = globalScene.arena.isMoveWeatherCancelled(this.pokemon, move); - const failedDueToTerrain = globalScene.arena.isMoveTerrainCancelled(this.pokemon, this.targets, move); - const failed = failsConditions || failedDueToWeather || failedDueToTerrain; - - if (failed) { - this.failMove(true, failedDueToWeather, failedDueToTerrain); - return; - } - - this.executeMove(); } /** Execute the current move and apply its effects. */ private executeMove() { + const pokemon = this.pokemon; const move = this.move.getMove(); - const targets = this.getActiveTargetPokemon(); - - // Update the battle's "last move" pointer unless we're currently mimicking a move or triggering Dancer. - if (!move.hasAttr("CopyMoveAttr") && !isReflected(this.useMode)) { - globalScene.currentBattle.lastMove = move.id; - } + const opponent = this.getActiveTargetPokemon()[0]; + const targets = this.targets; // Trigger ability-based user type changes, display move text and then execute move effects. // TODO: Investigate whether PokemonTypeChangeAbAttr can drop the "opponent" parameter - applyAbAttrs("PokemonTypeChangeAbAttr", { pokemon: this.pokemon, move, opponent: targets[0] }); + applyAbAttrs("PokemonTypeChangeAbAttr", { pokemon, move, opponent }); this.showMoveText(); - globalScene.phaseManager.unshiftNew( - "MoveEffectPhase", - this.pokemon.getBattlerIndex(), - this.targets, - move, - this.useMode, - ); + globalScene.phaseManager.unshiftNew("MoveEffectPhase", pokemon.getBattlerIndex(), targets, move, this.useMode); // Handle Dancer, which triggers immediately after a move is used (rather than waiting on `this.end()`). // Note the MoveUseMode check here prevents an infinite Dancer loop. // TODO: This needs to go at the end of `MoveEffectPhase` to check move results const dancerModes: MoveUseMode[] = [MoveUseMode.INDIRECT, MoveUseMode.REFLECTED] as const; if (this.move.getMove().hasFlag(MoveFlags.DANCE_MOVE) && !dancerModes.includes(this.useMode)) { + // biome-ignore lint/nursery/noShadow: We don't need to access `pokemon` from the outer scope globalScene.getField(true).forEach(pokemon => { - applyAbAttrs("PostMoveUsedAbAttr", { pokemon, move: this.move, source: this.pokemon, targets: this.targets }); + applyAbAttrs("PostMoveUsedAbAttr", { pokemon, move: this.move, source: pokemon, targets: targets }); }); } } @@ -671,6 +823,7 @@ export class MovePhase extends BattlePhase { const redirectTarget = new NumberHolder(currentTarget); // check move redirection abilities of every pokemon *except* the user. + // TODO: Make storm drain, lightning rod, etc, redirect at this point for type changing moves globalScene .getField(true) .filter(p => p !== this.pokemon) @@ -785,10 +938,7 @@ export class MovePhase extends BattlePhase { } if (this.failed) { - // TODO: should this consider struggle? - const ppUsed = isIgnorePP(this.useMode) ? 0 : 1; - this.move.usePp(ppUsed); - globalScene.eventTarget.dispatchEvent(new MoveUsedEvent(this.pokemon?.id, this.move.getMove(), ppUsed)); + this.usePP(); } if (this.cancelled && this.pokemon.summonData.tags.some(t => t.tagType === BattlerTagType.FRENZY)) { From c0827230cbb1744d3668c4816b63e26639bede65 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 19:24:22 -0500 Subject: [PATCH 3/9] Refactor mostly complete, need to recheck tests --- src/data/battler-tags.ts | 1 - src/data/moves/move-condition.ts | 132 +++++++++++- src/data/moves/move-utils.ts | 24 +++ src/data/moves/move.ts | 340 +++++++++++++++++++------------ src/enums/move-category.ts | 3 + src/enums/move-flags.ts | 6 +- src/field/pokemon.ts | 8 +- src/phases/command-phase.ts | 2 +- src/phases/move-phase.ts | 146 ++++++------- src/utils/pokemon-utils.ts | 17 ++ test/moves/throat-chop.test.ts | 3 + 11 files changed, 464 insertions(+), 218 deletions(-) diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts index 69e1812a164..0e272272f71 100644 --- a/src/data/battler-tags.ts +++ b/src/data/battler-tags.ts @@ -1168,7 +1168,6 @@ export class PowderTag extends BattlerTag { } // Disable the target's fire type move and damage it (subject to Magic Guard) - currentPhase.showMoveText(); currentPhase.fail(); const idx = pokemon.getBattlerIndex(); diff --git a/src/data/moves/move-condition.ts b/src/data/moves/move-condition.ts index 5d03bc7926d..5c06ab9bebe 100644 --- a/src/data/moves/move-condition.ts +++ b/src/data/moves/move-condition.ts @@ -1,13 +1,16 @@ -// biome-ignore lint/correctness/noUnusedImports: Used in a tsdoc comment -import type { GameMode } from "#app/game-mode"; import { globalScene } from "#app/global-scene"; import { getPokemonNameWithAffix } from "#app/messages"; +import { TrappedTag } from "#data/battler-tags"; import { allMoves } from "#data/data-lists"; import { ArenaTagType } from "#enums/arena-tag-type"; import { Command } from "#enums/command"; -import { MoveCategory } from "#enums/move-category"; +import { MoveCategory, type MoveDamageCategory } from "#enums/move-category"; +import type { MoveId } from "#enums/move-id"; +import { isVirtual } from "#enums/move-use-mode"; +import { PokemonType } from "#enums/pokemon-type"; import type { Pokemon } from "#field/pokemon"; import type { Move, MoveConditionFunc, UserMoveConditionFunc } from "#moves/move"; +import { getCounterAttackTarget } from "#moves/move-utils"; import i18next from "i18next"; /** @@ -54,6 +57,81 @@ export class FirstMoveCondition extends MoveCondition { } } +/** + * Condition that fails the move if the user has less than 1/x of their max HP. + * @remarks + * Used by Clangorous Soul and Fillet Away + */ +export class FailIfInsufficientHpCondition extends MoveCondition { + /** + * Condition that fails the move if the user has less than 1/x of their max HP. + * @param ratio - The required HP ratio (the `x` in `1/x`) + */ + constructor(cutRatio: number) { + super(user => user.getHpRatio() > 1 / cutRatio); + } +} + +/** + * Teleport condition checks + * + * @remarks + * For trainer pokemon, just checks if there are any benched pokemon allowed in battle + * + * Wild pokemon cannot teleport if either: + * - The current battle is a double battle + * - They are under the effects of a *move-based* trapping effect like and are neither a ghost type nor have an active run away ability + */ +export const failTeleportCondition = new MoveCondition(user => { + if (user.hasTrainer()) { + const party = user.isPlayer() ? globalScene.getPlayerParty() : globalScene.getEnemyParty(); + for (const pokemon of party) { + if (!pokemon.isOnField() && pokemon.isAllowedInBattle()) { + return true; + } + } + return false; + } + + // Wild pokemon + + // Cannot teleport in double battles (even if last remaining) + if (globalScene.currentBattle.double) { + return false; + } + // If smoke ball / shed tail items are ever added, checks for them should be placed here + // If a conditional "run away" ability is ever added, then we should use the apply method instead of the `hasAbility` + if (user.isOfType(PokemonType.GHOST, true, true) || user.hasAbilityWithAttr("RunSuccessAbAttr")) { + return true; + } + + // Wild pokemon are prevented from fleeing if they are trapped *specifically* + if (globalScene.arena.hasTag(ArenaTagType.FAIRY_LOCK) || user.getTag(TrappedTag) !== undefined) { + // Fairy Lock prevents teleporting + return false; + } + + return true; +}); + +/** + * Condition that forces moves to fail if the target's selected move is not an attacking move + * + * @remarks + * Used by Sucker Punch and Thunderclap + */ +export const failIfTargetNotAttackingCondition = new MoveCondition((_user, target) => { + const turnCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; + if (!turnCommand || !turnCommand.move) { + return false; + } + return ( + turnCommand.command === Command.FIGHT && + !target.turnData.acted && + allMoves[turnCommand.move.move].category !== MoveCategory.STATUS + ); +}); + /** * Condition that forces moves to fail against the final boss in classic and the major boss in endless * @remarks @@ -86,6 +164,54 @@ export const UpperHandCondition = new MoveCondition((_user, target) => { ); }); +/** + * Condition used by the move {@link https://bulbapedia.bulbagarden.net/wiki/Last_Resort_(move) | Last Resort} + * + * @remarks + * Last resort fails if + * - It is not in the user's moveset + * - The user does not know at least one other move + * - The user has not directly used each other move in its moveset since it was sent into battle + * - A move is considered *used* for this purpose if it passed the first failure check sequence in the move phase + */ +export const lastResortCondition = new MoveCondition((user, _target, move) => { + const otherMovesInMoveset = new Set(user.getMoveset().map(m => m.moveId)); + if (!otherMovesInMoveset.delete(move.id) || !otherMovesInMoveset.size) { + return false; // Last resort fails if used when not in user's moveset or no other moves exist + } + + const movesInHistory = new Set( + user + .getMoveHistory() + .filter(m => !isVirtual(m.useMode)) // Last resort ignores virtual moves + .map(m => m.move), + ); + + // Since `Set.intersection()` is only present in ESNext, we have to do this to check inclusion + return [...otherMovesInMoveset].every(m => movesInHistory.has(m)); +}); + +/** + * Condition used by counter-like moves if the user was hit by at least one qualifying attack this turn. + * Qualifying attacks are those that match the specified category (physical, special or either) + * that did not come from an ally. + */ +class CounterAttackConditon extends MoveCondition { + /** + * @param damageCategory - The category of move to counter (physical or special), or `undefined` to counter both + */ + constructor(damageCategory?: MoveDamageCategory) { + super(user => getCounterAttackTarget(user, damageCategory) !== null); + } +} + +/** Condition check for counterattacks that proc againt physical moves */ +export const counterAttackCondition_Physical = new CounterAttackConditon(MoveCategory.PHYSICAL); +/** Condition check for counterattacks that proc against special moves*/ +export const counterAttackCondition_Special = new CounterAttackConditon(MoveCategory.SPECIAL); +/** Condition check for counterattacks that proc against moves regardless of damage type */ +export const counterAttackCondition_Both = new CounterAttackConditon(); + /** * A restriction that prevents a move from being selected * diff --git a/src/data/moves/move-utils.ts b/src/data/moves/move-utils.ts index 241144599e5..4d59921751d 100644 --- a/src/data/moves/move-utils.ts +++ b/src/data/moves/move-utils.ts @@ -1,6 +1,7 @@ import { allMoves } from "#data/data-lists"; import type { BattlerIndex } from "#enums/battler-index"; import { BattlerTagType } from "#enums/battler-tag-type"; +import { MoveCategory, type MoveDamageCategory } from "#enums/move-category"; import type { MoveId } from "#enums/move-id"; import { MoveTarget } from "#enums/move-target"; import { PokemonType } from "#enums/pokemon-type"; @@ -8,6 +9,7 @@ import type { Pokemon } from "#field/pokemon"; import { applyMoveAttrs } from "#moves/apply-attrs"; import type { Move, MoveTargetSet, UserMoveConditionFunc } from "#moves/move"; import { isNullOrUndefined, NumberHolder } from "#utils/common"; +import { areAllies } from "#utils/pokemon-utils"; /** * Return whether the move targets the field @@ -133,3 +135,25 @@ export const frenzyMissFunc: UserMoveConditionFunc = (user: Pokemon, move: Move) return true; }; + +/** + * Determine the target for the `user`'s counter-attack move + * @param user - The pokemon using the counter-like move + * @param damageCategory - The category of move to counter (physical or special), or `undefined` to counter both + * @returns - The battler index of the most recent, non-ally attacker using a move that matches the specified category, or `null` if no such attacker exists + */ +export function getCounterAttackTarget(user: Pokemon, damageCategory?: MoveDamageCategory): BattlerIndex | null { + for (const attackRecord of user.turnData.attacksReceived) { + // check if the attacker was an ally + const moveCategory = allMoves[attackRecord.move].category; + const sourceBattlerIndex = attackRecord.sourceBattlerIndex; + if ( + moveCategory !== MoveCategory.STATUS && + !areAllies(sourceBattlerIndex, user.getBattlerIndex()) && + (damageCategory === undefined || moveCategory === damageCategory) + ) { + return sourceBattlerIndex; + } + } + return null; +} diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 7ef35de9422..b9dc493064d 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -36,7 +36,7 @@ import { AbilityId } from "#enums/ability-id"; import { ArenaTagSide } from "#enums/arena-tag-side"; import { ArenaTagType } from "#enums/arena-tag-type"; import { BattleType } from "#enums/battle-type"; -import type { BattlerIndex } from "#enums/battler-index"; +import { BattlerIndex } from "#enums/battler-index"; import { BattlerTagType } from "#enums/battler-tag-type"; import { BiomeId } from "#enums/biome-id"; import { ChallengeType } from "#enums/challenge-type"; @@ -48,7 +48,7 @@ import { ChargeAnim } from "#enums/move-anims-common"; import { MoveId } from "#enums/move-id"; import { MoveResult } from "#enums/move-result"; import { isVirtual, MoveUseMode } from "#enums/move-use-mode"; -import { MoveCategory } from "#enums/move-category"; +import { MoveCategory, MoveDamageCategory } from "#enums/move-category"; import { MoveEffectTrigger } from "#enums/move-effect-trigger"; import { MoveFlags } from "#enums/move-flags"; import { MoveTarget } from "#enums/move-target"; @@ -78,13 +78,12 @@ import { } from "#modifiers/modifier"; import { applyMoveAttrs } from "#moves/apply-attrs"; import { invalidAssistMoves, invalidCopycatMoves, invalidMetronomeMoves, invalidMirrorMoveMoves, invalidSketchMoves, invalidSleepTalkMoves } from "#moves/invalid-moves"; -import { frenzyMissFunc, getMoveTargets } from "#moves/move-utils"; +import { frenzyMissFunc, getCounterAttackTarget, getMoveTargets } from "#moves/move-utils"; import { PokemonMove } from "#moves/pokemon-move"; import { MoveEndPhase } from "#phases/move-end-phase"; import { MovePhase } from "#phases/move-phase"; import { PokemonHealPhase } from "#phases/pokemon-heal-phase"; import { SwitchSummonPhase } from "#phases/switch-summon-phase"; -import type { AttackMoveResult } from "#types/attack-move-result"; import type { Localizable } from "#types/locales"; import type { ChargingMove, MoveAttrMap, MoveAttrString, MoveClassMap, MoveKindString, MoveMessageFunc } from "#types/move-types"; import type { TurnMove } from "#types/turn-move"; @@ -93,7 +92,7 @@ import { getEnumValues } from "#utils/enums"; import { toCamelCase, toTitleCase } from "#utils/strings"; import i18next from "i18next"; import { applyChallenges } from "#utils/challenge-utils"; -import { ConsecutiveUseRestriction, failAgainstFinalBossCondition, FirstMoveCondition, GravityUseRestriction, MoveCondition, MoveRestriction, UpperHandCondition } from "#moves/move-condition"; +import { ConsecutiveUseRestriction, counterAttackCondition_Both, counterAttackCondition_Physical, counterAttackCondition_Special, failAgainstFinalBossCondition, FailIfInsufficientHpCondition, failIfTargetNotAttackingCondition, failTeleportCondition, FirstMoveCondition, GravityUseRestriction, lastResortCondition, MoveCondition, MoveRestriction, UpperHandCondition } from "#moves/move-condition"; /** * A function used to conditionally determine execution of a given {@linkcode MoveAttr}. @@ -117,15 +116,56 @@ export abstract class Move implements Localizable { public priority: number; public generation: number; public attrs: MoveAttr[] = []; - /** Conditions that must be met for the move to succeed when it is used. - * + /** + * Conditions that must be met for the move to succeed when it is used. + * + * @remarks + * These are the default conditions checked during the move effect phase (aka sequence 4). + * When adding a new condition, if unsure of where it occurs in the failure checks, it should go here. * @remarks Different from {@linkcode restrictions}, which is checked when the move is selected */ private conditions: MoveCondition[] = []; /** - * Move failure conditions that occur during the second check (after move message and before ) + * Move failure conditions that occur during the second sequence (after move message and before ) */ private conditionsSeq2: MoveCondition[] = []; + /** + * Move failure conditions that occur during the third sequence (after accuracy and before move effects). + * + * @remarks + * List of *move-based* conditions that occur in this sequence: + * - Battle mechanics research conducted by Smogon and manual checks from SirzBenjie + * - Steel Roller with no terrain + * - Follow Me / Rage Powder failing due to being used in single battle + * - Stockpile with >= 3 stacks already + * - Spit up / swallow with 0 stockpiles + * - Counter / Mirror Coat / Metal Burst with no damage taken from enemies this turn + * - Last resort's bespoke failure conditions + * - Snore while not asleep + * - Sucker punch failling due to the target having already used their selected move or not having selected a damaging move + * - Magic Coat failing due to being used as the last move in the turn + * - Protect-like moves failing due to consecutive use or being the last move in the turn + * - First turn moves (e.g. mat block, fake out) failing due to not being used on first turn + * - Rest failing due, in this order, to already being asleep (including from comatose), under the effect of heal block, being full hp, having insomnia / vital spirit + * - Teleport failing when used by a wild pokemon that can't use it to flee (because it is trapped, in a double battle, etc) or used by a trainer pokemon with no pokemon to switch to + * - Fling with no usable item (not done as Pokerogue does not yet implement fling) + * - Magnet rise failing while under the effect of ingrain, smack down, or gravity (gravity check not done as redundant with sequence 1) + * - Splash failing when gravity is in effect (Not done in Pokerogue as this is redundant with the check that occurs during sequence 1) + * - Stuff cheeks with no berry + * - Destiny bond failing on consecutive use + * - Quick Guard / Wide Guard failing due to being used as the last move in the turn + * - Ally switch's chance to fail on consecutive use + * - Species specific moves (like hyperspace fury, aura wheel, dark void) being used by a pokemon that is not hoopa (Not applicable to Pokerogue, which permits this) + * - Poltergeist against a target with no item + * - Shell Trap failing due to not being hit by a physical move + * - Aurora veil failing due to no hail + * - Clangorous soul and Fillet Awayfailing due to insufficient HP + * - Upper hand failing due to the target not selecting a priority move + * - (Various moves that fail when used against titans / raid bosses, not listed as pokerogue does not yet implement each) + * + * @see {@link https://www.smogon.com/forums/threads/sword-shield-battle-mechanics-research.3655528/page-54#post-8548957} + */ + private conditionsSeq3: MoveCondition[] = []; /** Conditions that must be false for a move to be able to be selected. * * @remarks Different from {@linkcode conditions}, which is checked when the move is invoked @@ -387,7 +427,7 @@ export abstract class Move implements Localizable { * @param checkSequence - The sequence number where the failure check occurs * @returns `this` for method chaining */ - condition(condition: MoveCondition | MoveConditionFunc, checkSequence: 2 | 3 = 3): this { + condition(condition: MoveCondition | MoveConditionFunc, checkSequence: 2 | 3 | 4 = 4): this { const conditionsArray = checkSequence === 2 ? this.conditionsSeq2 : this.conditions; if (typeof condition === "function") { condition = new MoveCondition(condition); @@ -412,10 +452,10 @@ export abstract class Move implements Localizable { * @param i18nkey - The i18n key for the restriction text * @param alsoCondition - If `true`, also adds a {@linkcode MoveCondition} that checks the same condition when the * move is used; default `false` + * @param conditionSeq - The sequence number where the failure check occurs; default `4` * @returns `this` for method chaining */ - - public restriction(restriction: UserMoveConditionFunc, i18nkey: string, alsoCondition?: boolean): this; + public restriction(restriction: UserMoveConditionFunc, i18nkey: string, alsoCondition?: boolean, conditionSeq?: number): this; /** * Adds a restriction condition to this move. * The move will not be selectable if at least 1 of its restrictions is met. @@ -424,13 +464,27 @@ export abstract class Move implements Localizable { * @param i18nkey - The i18n key for the restriction text, ignored if `restriction` is a `MoveRestriction` * @param alsoCondition - If `true`, also adds a {@linkcode MoveCondition} that checks the same condition when the * move is used; default `false`. Ignored if `restriction` is a `MoveRestriction`. + * @param conditionSeq - The sequence number where the failure check occurs; default `4`. Ignored if `alsoCondition` + * is false * @returns `this` for method chaining */ - public restriction(restriction: T, i18nkey?: string, alsoCondition: typeof restriction extends MoveRestriction ? false : boolean = false): this { + public restriction(restriction: T, i18nkey?: string, alsoCondition: typeof restriction extends MoveRestriction ? false : boolean = false, conditionSeq = 4): this { if (typeof restriction === "function") { this.restrictions.push(new MoveRestriction(restriction)); if (alsoCondition) { - this.conditions.push(new MoveCondition((user, _, move) => restriction(user, move))); + let conditionArray: MoveCondition[]; + switch (conditionSeq) { + case 2: + conditionArray = this.conditionsSeq2; + break; + case 3: + conditionArray = this.conditionsSeq3; + break; + default: + conditionArray = this.conditions; + } + + conditionArray.push(new MoveCondition((user, _, move) => !restriction(user, move))); } } else { this.restrictions.push(restriction); @@ -640,9 +694,14 @@ export abstract class Move implements Localizable { /** * Sets the {@linkcode MoveFlags.GRAVITY} flag for the calling Move and adds {@linkcode GravityUseRestriction} to the * move's restrictions. + * + * @returns The {@linkcode Move} that called this function + * + * @remarks + * No {@linkcode condition} is added, as gravity's condition is already checked + * during the first sequence of a move's failure check, and this would be redundant. * * @see {@linkcode MoveId.GRAVITY} - * @returns The {@linkcode Move} that called this function */ affectedByGravity(): this { this.setFlag(MoveFlags.GRAVITY, true); @@ -680,16 +739,6 @@ export abstract class Move implements Localizable { return this; } - /** - * Sets the {@linkcode MoveFlags.REDIRECT_COUNTER} flag for the calling Move - * @see {@linkcode MoveId.METAL_BURST} - * @returns The {@linkcode Move} that called this function - */ - redirectCounter(): this { - this.setFlag(MoveFlags.REDIRECT_COUNTER, true); - return this; - } - /** * Sets the {@linkcode MoveFlags.REFLECTABLE} flag for the calling Move * @see {@linkcode MoveId.ATTRACT} @@ -771,11 +820,24 @@ export abstract class Move implements Localizable { * @param user - {@linkcode Pokemon} to apply conditions to * @param target - {@linkcode Pokemon} to apply conditions to * @param move - {@linkcode Move} to apply conditions to - * @param sequence - The sequence number where the condition check occurs, defaults to 3 + * @param sequence - The sequence number where the condition check occurs, or `-1` to check all; defaults to 3. Pass -1 to check all * @returns boolean: false if any of the apply()'s return false, else true */ - applyConditions(user: Pokemon, target: Pokemon, sequence: number = 3): boolean { - const conditionsArray = sequence === 2 ? this.conditionsSeq2 : this.conditions; + applyConditions(user: Pokemon, target: Pokemon, sequence: -1 | 2 | 3 | 4 = 4): boolean { + let conditionsArray: MoveCondition[]; + switch (sequence) { + case -1: + conditionsArray = [...this.conditionsSeq2, ...this.conditionsSeq3, ...this.conditions]; + case 2: + conditionsArray = this.conditionsSeq2; + break; + case 3: + conditionsArray = this.conditionsSeq3; + break; + case 4: + default: + conditionsArray = this.conditions; + } return conditionsArray.every(cond => cond.apply(user, target, this)); } @@ -1731,28 +1793,77 @@ export class MatchHpAttr extends FixedDamageAttr { }*/ } -type MoveFilter = (move: Move) => boolean; - export class CounterDamageAttr extends FixedDamageAttr { - private moveFilter: MoveFilter; + /** The damage category of counter attacks to process, or `undefined` for either */ + private moveFilter?: MoveDamageCategory; private multiplier: number; - constructor(moveFilter: MoveFilter, multiplier: number) { + /** + * @param multiplier - The damage multiplier to apply to the total damage received + * @param moveFilter - If set, only damage from moves of this category will be counted, otherwise all damage is counted + */ + constructor(multiplier: number, moveFilter?: MoveDamageCategory) { super(0); - this.moveFilter = moveFilter; this.multiplier = multiplier; } apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean { - const damage = user.turnData.attacksReceived.filter(ar => this.moveFilter(allMoves[ar.move])).reduce((total: number, ar: AttackMoveResult) => total + ar.damage, 0); + let damage = 0; + for (const ar of user.turnData.attacksReceived) { + // TODO: Adjust this for moves with variable damage categories + const category = allMoves[ar.move].category; + if (category === MoveCategory.STATUS || (this.moveFilter && category !== this.moveFilter)) { + continue; + } + damage += ar.damage; + + } (args[0] as NumberHolder).value = toDmgValue(damage * this.multiplier); return true; } +} - getCondition(): MoveConditionFunc { - return (user, target, move) => !!user.turnData.attacksReceived.filter(ar => this.moveFilter(allMoves[ar.move])).length; +/** + * Attribute for counter-like moves to redirect the move to a different target + */ +export class CounterRedirectAttr extends MoveAttr { + declare private moveFilter?: MoveDamageCategory; + constructor(moveFilter? : MoveDamageCategory) { + super(); + if (moveFilter !== undefined) { + this.moveFilter = moveFilter; + } + } + + /** + * Applies the counter redirect attribute to the move + * @param user - The user of the counter move + * @param target - The target of the move (unused) + * @param move - The move being used + * @param args - args[0] holds the battler index of the target that the move will be redirected to + */ + override apply(user: Pokemon, target: Pokemon | null, move: Move, args: [NumberHolder, ...any[]]): boolean { + const desiredTarget = getCounterAttackTarget(user, this.moveFilter); + if (desiredTarget !== null && desiredTarget !== BattlerIndex.ATTACKER) { + // check if the target is still alive + if ( + globalScene.currentBattle.double && + !globalScene.getField()[desiredTarget]?.isActive + ) { + const targetField = desiredTarget >= BattlerIndex.ENEMY ? globalScene.getEnemyField() : globalScene.getPlayerField(); + args[0].value = targetField.find(p => p.hp > 0)?.getBattlerIndex() ?? BattlerIndex.ATTACKER; + } else { + args[0].value = desiredTarget; + } + return true; + } + return false; + } + + override canApply(user: Pokemon, target: Pokemon, move: Move, args: [NumberHolder, ...any[]]): boolean { + return args[0].value === BattlerIndex.ATTACKER; } } @@ -3744,7 +3855,7 @@ export class CutHpStatStageBoostAttr extends StatStageChangeAttr { } getCondition(): MoveConditionFunc { - return (user, _target, _move) => user.getHpRatio() > 1 / this.cutRatio && this.stats.some(s => user.getStatStage(s) < 6); + return user => user.getHpRatio() > 1 / this.cutRatio && this.stats.some(s => user.getStatStage(s) < 6); } } @@ -8017,31 +8128,6 @@ export class StatusIfBoostedAttr extends MoveEffectAttr { } } -/** - * Attribute to fail move usage unless all of the user's other moves have been used at least once. - * Used by {@linkcode MoveId.LAST_RESORT}. - */ -export class LastResortAttr extends MoveAttr { - // TODO: Verify behavior as Bulbapedia page is _extremely_ poorly documented - getCondition(): MoveConditionFunc { - return (user: Pokemon, _target: Pokemon, move: Move) => { - const otherMovesInMoveset = new Set(user.getMoveset().map(m => m.moveId)); - if (!otherMovesInMoveset.delete(move.id) || !otherMovesInMoveset.size) { - return false; // Last resort fails if used when not in user's moveset or no other moves exist - } - - const movesInHistory = new Set( - user.getMoveHistory() - .filter(m => !isVirtual(m.useMode)) // Last resort ignores virtual moves - .map(m => m.move) - ); - - // Since `Set.intersection()` is only present in ESNext, we have to do this to check inclusion - return [...otherMovesInMoveset].every(m => movesInHistory.has(m)) - }; - } -} - export class VariableTargetAttr extends MoveAttr { private targetChangeFunc: (user: Pokemon, target: Pokemon, move: Move) => number; @@ -8330,6 +8416,7 @@ const MoveAttrs = Object.freeze({ TargetHalfHpDamageAttr, MatchHpAttr, CounterDamageAttr, + CounterRedirectAttr, LevelDamageAttr, RandomLevelDamageAttr, ModifiedDamageAttr, @@ -8520,7 +8607,6 @@ const MoveAttrs = Object.freeze({ DestinyBondAttr, AddBattlerTagIfBoostedAttr, StatusIfBoostedAttr, - LastResortAttr, VariableTargetAttr, AfterYouAttr, ForceLastAttr, @@ -8723,7 +8809,8 @@ export function initMoves() { new AttackMove(MoveId.LOW_KICK, PokemonType.FIGHTING, MoveCategory.PHYSICAL, -1, 100, 20, -1, 0, 1) .attr(WeightPowerAttr), new AttackMove(MoveId.COUNTER, PokemonType.FIGHTING, MoveCategory.PHYSICAL, -1, 100, 20, -1, -5, 1) - .attr(CounterDamageAttr, (move: Move) => move.category === MoveCategory.PHYSICAL, 2) + .attr(CounterDamageAttr, 2, MoveCategory.PHYSICAL) + .condition(counterAttackCondition_Physical, 3) .target(MoveTarget.ATTACKER), new AttackMove(MoveId.SEISMIC_TOSS, PokemonType.FIGHTING, MoveCategory.PHYSICAL, -1, 100, 20, -1, 0, 1) .attr(LevelDamageAttr), @@ -8823,7 +8910,8 @@ export function initMoves() { .partial(), // No effect implemented new SelfStatusMove(MoveId.TELEPORT, PokemonType.PSYCHIC, -1, 20, -1, -6, 1) .attr(ForceSwitchOutAttr, true) - .hidesUser(), + .hidesUser() + .condition(failTeleportCondition, 3), new AttackMove(MoveId.NIGHT_SHADE, PokemonType.GHOST, MoveCategory.SPECIAL, -1, 100, 15, -1, 0, 1) .attr(LevelDamageAttr), new StatusMove(MoveId.MIMIC, PokemonType.NORMAL, -1, 10, -1, 0, 1) @@ -8876,7 +8964,7 @@ export function initMoves() { new AttackMove(MoveId.SELF_DESTRUCT, PokemonType.NORMAL, MoveCategory.PHYSICAL, 200, 100, 5, -1, 0, 1) .attr(SacrificialAttr) .makesContact(false) - .condition(failIfDampCondition) + .condition(failIfDampCondition, 3) .target(MoveTarget.ALL_NEAR_OTHERS), new AttackMove(MoveId.EGG_BOMB, PokemonType.NORMAL, MoveCategory.PHYSICAL, 100, 75, 10, -1, 0, 1) .makesContact(false) @@ -8977,7 +9065,7 @@ export function initMoves() { new AttackMove(MoveId.CRABHAMMER, PokemonType.WATER, MoveCategory.PHYSICAL, 100, 90, 10, -1, 0, 1) .attr(HighCritAttr), new AttackMove(MoveId.EXPLOSION, PokemonType.NORMAL, MoveCategory.PHYSICAL, 250, 100, 5, -1, 0, 1) - .condition(failIfDampCondition) + .condition(failIfDampCondition, 3) .attr(SacrificialAttr) .makesContact(false) .target(MoveTarget.ALL_NEAR_OTHERS), @@ -8989,7 +9077,7 @@ export function initMoves() { new SelfStatusMove(MoveId.REST, PokemonType.PSYCHIC, -1, 5, -1, 0, 1) .attr(StatusEffectAttr, StatusEffect.SLEEP, true, 3, true) .attr(HealAttr, 1, true) - .condition((user, target, move) => !user.isFullHp() && user.canSetStatus(StatusEffect.SLEEP, true, true, user)) + .condition((user, target, move) => !user.isFullHp() && user.canSetStatus(StatusEffect.SLEEP, true, true, user), 3) .triageMove(), new AttackMove(MoveId.ROCK_SLIDE, PokemonType.ROCK, MoveCategory.PHYSICAL, 75, 90, 10, 30, 0, 1) .attr(FlinchAttr) @@ -9045,7 +9133,7 @@ export function initMoves() { new AttackMove(MoveId.SNORE, PokemonType.NORMAL, MoveCategory.SPECIAL, 50, 100, 15, 30, 0, 2) .attr(BypassSleepAttr) .attr(FlinchAttr) - .condition(userSleptOrComatoseCondition) + .condition(userSleptOrComatoseCondition, 3) .soundBased(), new StatusMove(MoveId.CURSE, PokemonType.GHOST, -1, 10, -1, 0, 2) .attr(CurseAttr) @@ -9077,7 +9165,7 @@ export function initMoves() { .target(MoveTarget.ALL_NEAR_ENEMIES), new SelfStatusMove(MoveId.PROTECT, PokemonType.NORMAL, -1, 10, -1, 4, 2) .attr(ProtectAttr) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new AttackMove(MoveId.MACH_PUNCH, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 40, 100, 30, -1, 1, 2) .punchingMove(), new StatusMove(MoveId.SCARY_FACE, PokemonType.NORMAL, 100, 10, -1, 0, 2) @@ -9137,7 +9225,7 @@ export function initMoves() { .target(MoveTarget.ALL_NEAR_ENEMIES), new SelfStatusMove(MoveId.DETECT, PokemonType.FIGHTING, -1, 5, -1, 4, 2) .attr(ProtectAttr) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new AttackMove(MoveId.BONE_RUSH, PokemonType.GROUND, MoveCategory.PHYSICAL, 25, 90, 10, -1, 0, 2) .attr(MultiHitAttr) .makesContact(false), @@ -9159,7 +9247,7 @@ export function initMoves() { .triageMove(), new SelfStatusMove(MoveId.ENDURE, PokemonType.NORMAL, -1, 10, -1, 4, 2) .attr(ProtectAttr, BattlerTagType.ENDURING) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new StatusMove(MoveId.CHARM, PokemonType.FAIRY, 100, 20, -1, 0, 2) .attr(StatStageChangeAttr, [ Stat.ATK ], -2) .reflectable(), @@ -9194,7 +9282,7 @@ export function initMoves() { new SelfStatusMove(MoveId.SLEEP_TALK, PokemonType.NORMAL, -1, 10, -1, 0, 2) .attr(BypassSleepAttr) .attr(RandomMovesetMoveAttr, invalidSleepTalkMoves, false) - .condition(userSleptOrComatoseCondition) + .condition(userSleptOrComatoseCondition, 3) .target(MoveTarget.NEAR_ENEMY), new StatusMove(MoveId.HEAL_BELL, PokemonType.NORMAL, -1, 5, -1, 0, 2) .attr(PartyStatusCureAttr, i18next.t("moveTriggers:bellChimed"), AbilityId.SOUNDPROOF) @@ -9297,7 +9385,8 @@ export function initMoves() { .attr(StatStageChangeAttr, [ Stat.DEF ], -1) .bitingMove(), new AttackMove(MoveId.MIRROR_COAT, PokemonType.PSYCHIC, MoveCategory.SPECIAL, -1, 100, 20, -1, -5, 2) - .attr(CounterDamageAttr, (move: Move) => move.category === MoveCategory.SPECIAL, 2) + .attr(CounterDamageAttr, 2, MoveCategory.SPECIAL) + .condition(counterAttackCondition_Special, 3) .target(MoveTarget.ATTACKER), new StatusMove(MoveId.PSYCH_UP, PokemonType.NORMAL, -1, 10, -1, 0, 2) .ignoresSubstitute() @@ -9326,21 +9415,21 @@ export function initMoves() { .makesContact(false), new AttackMove(MoveId.FAKE_OUT, PokemonType.NORMAL, MoveCategory.PHYSICAL, 40, 100, 10, 100, 3, 3) .attr(FlinchAttr) - .condition(new FirstMoveCondition()), + .condition(new FirstMoveCondition(), 3), new AttackMove(MoveId.UPROAR, PokemonType.NORMAL, MoveCategory.SPECIAL, 90, 100, 10, -1, 0, 3) .soundBased() .target(MoveTarget.RANDOM_NEAR_ENEMY) .partial(), // Does not lock the user, does not stop Pokemon from sleeping // Likely can make use of FrenzyAttr and an ArenaTag (just without the FrenzyMissFunc) new SelfStatusMove(MoveId.STOCKPILE, PokemonType.NORMAL, -1, 20, -1, 0, 3) - .condition(user => (user.getTag(StockpilingTag)?.stockpiledCount ?? 0) < 3) + .condition(user => (user.getTag(StockpilingTag)?.stockpiledCount ?? 0) < 3, 3) .attr(AddBattlerTagAttr, BattlerTagType.STOCKPILING, true), new AttackMove(MoveId.SPIT_UP, PokemonType.NORMAL, MoveCategory.SPECIAL, -1, 100, 10, -1, 0, 3) - .condition(hasStockpileStacksCondition) + .condition(hasStockpileStacksCondition, 3) .attr(SpitUpPowerAttr, 100) .attr(RemoveBattlerTagAttr, [ BattlerTagType.STOCKPILING ], true), new SelfStatusMove(MoveId.SWALLOW, PokemonType.NORMAL, -1, 10, -1, 0, 3) - .condition(hasStockpileStacksCondition) + .condition(hasStockpileStacksCondition, 3) .attr(SwallowHealAttr) .attr(RemoveBattlerTagAttr, [ BattlerTagType.STOCKPILING ], true) .triageMove(), @@ -9379,7 +9468,8 @@ export function initMoves() { .attr(MovePowerMultiplierAttr, (user, target, move) => target.status?.effect === StatusEffect.PARALYSIS ? 2 : 1) .attr(HealStatusEffectAttr, true, StatusEffect.PARALYSIS), new SelfStatusMove(MoveId.FOLLOW_ME, PokemonType.NORMAL, -1, 20, -1, 2, 3) - .attr(AddBattlerTagAttr, BattlerTagType.CENTER_OF_ATTENTION, true), + .attr(AddBattlerTagAttr, BattlerTagType.CENTER_OF_ATTENTION, true) + .condition(failIfSingleBattle, 3), new StatusMove(MoveId.NATURE_POWER, PokemonType.NORMAL, -1, 20, -1, 0, 3) .attr(NaturePowerAttr), new SelfStatusMove(MoveId.CHARGE, PokemonType.ELECTRIC, -1, 20, -1, 0, 3) @@ -9414,7 +9504,7 @@ export function initMoves() { .attr(StatStageChangeAttr, [ Stat.ATK, Stat.DEF ], -1, true), new SelfStatusMove(MoveId.MAGIC_COAT, PokemonType.PSYCHIC, -1, 15, -1, 4, 3) .attr(AddBattlerTagAttr, BattlerTagType.MAGIC_COAT, true, true, 0) - .condition(failIfLastCondition) + .condition(failIfLastCondition, 3) // Interactions with stomping tantrum, instruct, and other moves that // rely on move history // Also will not reflect roar / whirlwind if the target has ForceSwitchOutImmunityAbAttr @@ -9713,8 +9803,8 @@ export function initMoves() { .attr(AcupressureStatStageChangeAttr) .target(MoveTarget.USER_OR_NEAR_ALLY), new AttackMove(MoveId.METAL_BURST, PokemonType.STEEL, MoveCategory.PHYSICAL, -1, 100, 10, -1, 0, 4) - .attr(CounterDamageAttr, (move: Move) => (move.category === MoveCategory.PHYSICAL || move.category === MoveCategory.SPECIAL), 1.5) - .redirectCounter() + .attr(CounterDamageAttr, 1.5) + .condition(counterAttackCondition_Both, 3) .makesContact(false) .target(MoveTarget.ATTACKER), new AttackMove(MoveId.U_TURN, PokemonType.BUG, MoveCategory.PHYSICAL, 70, 100, 20, -1, 0, 4) @@ -9776,21 +9866,15 @@ export function initMoves() { .makesContact(true) .attr(PunishmentPowerAttr), new AttackMove(MoveId.LAST_RESORT, PokemonType.NORMAL, MoveCategory.PHYSICAL, 140, 100, 5, -1, 0, 4) - .attr(LastResortAttr) - .edgeCase(), // May or may not need to ignore remotely called moves depending on how it works + .condition(lastResortCondition, 3) + .edgeCase(), // When a move is overwritten and later relearned, Last Resort's tracking of it should be reset new StatusMove(MoveId.WORRY_SEED, PokemonType.GRASS, 100, 10, -1, 0, 4) .attr(AbilityChangeAttr, AbilityId.INSOMNIA) // TODO: Enable / remove once balance reaches a consensus on ability overrides during boss fights // .condition(failAgainstFinalBossCondition, 3) .reflectable(), new AttackMove(MoveId.SUCKER_PUNCH, PokemonType.DARK, MoveCategory.PHYSICAL, 70, 100, 5, -1, 1, 4) - .condition((user, target, move) => { - const turnCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; - if (!turnCommand || !turnCommand.move) { - return false; - } - return (turnCommand.command === Command.FIGHT && !target.turnData.acted && allMoves[turnCommand.move.move].category !== MoveCategory.STATUS); - }), + .condition(failIfTargetNotAttackingCondition, 3), new StatusMove(MoveId.TOXIC_SPIKES, PokemonType.POISON, -1, 20, -1, 0, 4) .attr(AddArenaTrapTagAttr, ArenaTagType.TOXIC_SPIKES) .target(MoveTarget.ENEMY_SIDE) @@ -9802,7 +9886,7 @@ export function initMoves() { .attr(AddBattlerTagAttr, BattlerTagType.AQUA_RING, true, true), new SelfStatusMove(MoveId.MAGNET_RISE, PokemonType.ELECTRIC, -1, 10, -1, 0, 4) .attr(AddBattlerTagAttr, BattlerTagType.FLOATING, true, true, 5) - .condition(user => [ BattlerTagType.FLOATING, BattlerTagType.IGNORE_FLYING, BattlerTagType.INGRAIN ].every((tag) => !user.getTag(tag))) + .condition(user => [ BattlerTagType.FLOATING, BattlerTagType.IGNORE_FLYING, BattlerTagType.INGRAIN ].every((tag) => !user.getTag(tag)), 3) .affectedByGravity(), new AttackMove(MoveId.FLARE_BLITZ, PokemonType.FIRE, MoveCategory.PHYSICAL, 120, 100, 15, 10, 0, 4) .attr(RecoilAttr, false, 0.33) @@ -10012,7 +10096,7 @@ export function initMoves() { new StatusMove(MoveId.WIDE_GUARD, PokemonType.ROCK, -1, 10, -1, 3, 5) .target(MoveTarget.USER_SIDE) .attr(AddArenaTagAttr, ArenaTagType.WIDE_GUARD, 1, true, true) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new StatusMove(MoveId.GUARD_SPLIT, PokemonType.PSYCHIC, -1, 10, -1, 0, 5) // TODO: Enable / remove once balance reaches a consensus on imprison interaction during the final boss fight // .condition(failAgainstFinalBossCondition, 2) @@ -10042,6 +10126,7 @@ export function initMoves() { .condition((_user, target, _move) => isNullOrUndefined(target.getTag(BattlerTagType.INGRAIN)) && isNullOrUndefined(target.getTag(BattlerTagType.IGNORE_FLYING))) .attr(AddBattlerTagAttr, BattlerTagType.TELEKINESIS, false, true, 3) .attr(AddBattlerTagAttr, BattlerTagType.FLOATING, false, true, 3) + .affectedByGravity() .reflectable(), new StatusMove(MoveId.MAGIC_ROOM, PokemonType.PSYCHIC, -1, 10, -1, 0, 5) .ignoresProtect() @@ -10121,7 +10206,7 @@ export function initMoves() { new StatusMove(MoveId.QUICK_GUARD, PokemonType.FIGHTING, -1, 15, -1, 3, 5) .target(MoveTarget.USER_SIDE) .attr(AddArenaTagAttr, ArenaTagType.QUICK_GUARD, 1, true, true) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new SelfStatusMove(MoveId.ALLY_SWITCH, PokemonType.PSYCHIC, -1, 15, -1, 2, 5) .ignoresProtect() .unimplemented(), @@ -10336,8 +10421,8 @@ export function initMoves() { new StatusMove(MoveId.MAT_BLOCK, PokemonType.FIGHTING, -1, 10, -1, 0, 6) .target(MoveTarget.USER_SIDE) .attr(AddArenaTagAttr, ArenaTagType.MAT_BLOCK, 1, true, true) - .condition(new FirstMoveCondition()) - .condition(failIfLastCondition), + .condition(new FirstMoveCondition(), 3) + .condition(failIfLastCondition, 3), new AttackMove(MoveId.BELCH, PokemonType.POISON, MoveCategory.SPECIAL, 120, 90, 10, -1, 0, 6) .restriction(user => !user.battleData.hasEatenBerry, "battle:moveDisabledBelch", true), new StatusMove(MoveId.ROTOTILLER, PokemonType.GROUND, -1, 10, -1, 0, 6) @@ -10399,7 +10484,7 @@ export function initMoves() { new StatusMove(MoveId.CRAFTY_SHIELD, PokemonType.FAIRY, -1, 10, -1, 3, 6) .target(MoveTarget.USER_SIDE) .attr(AddArenaTagAttr, ArenaTagType.CRAFTY_SHIELD, 1, true, true) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new StatusMove(MoveId.FLOWER_SHIELD, PokemonType.FAIRY, -1, 10, -1, 0, 6) .target(MoveTarget.ALL) .attr(StatStageChangeAttr, [ Stat.DEF ], 1, false, { condition: (user, target, move) => target.getTypes().includes(PokemonType.GRASS) && !target.getTag(SemiInvulnerableTag) }), @@ -10427,7 +10512,7 @@ export function initMoves() { .attr(AddArenaTagAttr, ArenaTagType.FAIRY_LOCK, 2, true), new SelfStatusMove(MoveId.KINGS_SHIELD, PokemonType.STEEL, -1, 10, -1, 4, 6) .attr(ProtectAttr, BattlerTagType.KINGS_SHIELD) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new StatusMove(MoveId.PLAY_NICE, PokemonType.NORMAL, -1, 20, -1, 0, 6) .attr(StatStageChangeAttr, [ Stat.ATK ], -1) .ignoresSubstitute() @@ -10455,7 +10540,7 @@ export function initMoves() { .attr(StatStageChangeAttr, [ Stat.SPATK ], -1), new SelfStatusMove(MoveId.SPIKY_SHIELD, PokemonType.GRASS, -1, 10, -1, 4, 6) .attr(ProtectAttr, BattlerTagType.SPIKY_SHIELD) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new StatusMove(MoveId.AROMATIC_MIST, PokemonType.FAIRY, -1, 20, -1, 0, 6) .attr(StatStageChangeAttr, [ Stat.SPDEF ], 1) .ignoresSubstitute() @@ -10623,10 +10708,10 @@ export function initMoves() { .attr(SandHealAttr) .triageMove(), new AttackMove(MoveId.FIRST_IMPRESSION, PokemonType.BUG, MoveCategory.PHYSICAL, 90, 100, 10, -1, 2, 7) - .condition(new FirstMoveCondition()), + .condition(new FirstMoveCondition(), 3), new SelfStatusMove(MoveId.BANEFUL_BUNKER, PokemonType.POISON, -1, 10, -1, 4, 7) .attr(ProtectAttr, BattlerTagType.BANEFUL_BUNKER) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new AttackMove(MoveId.SPIRIT_SHACKLE, PokemonType.GHOST, MoveCategory.PHYSICAL, 80, 100, 10, 100, 0, 7) .attr(AddBattlerTagAttr, BattlerTagType.TRAPPED, false, false, 1, 1, true) .makesContact(false), @@ -10759,7 +10844,16 @@ export function initMoves() { new AttackMove(MoveId.BRUTAL_SWING, PokemonType.DARK, MoveCategory.PHYSICAL, 60, 100, 20, -1, 0, 7) .target(MoveTarget.ALL_NEAR_OTHERS), new StatusMove(MoveId.AURORA_VEIL, PokemonType.ICE, -1, 20, -1, 0, 7) - .condition((user, target, move) => (globalScene.arena.weather?.weatherType === WeatherType.HAIL || globalScene.arena.weather?.weatherType === WeatherType.SNOW) && !globalScene.arena.weather?.isEffectSuppressed()) + .condition( + () => { + const weather = globalScene.arena.weather; + if (isNullOrUndefined(weather) || weather.isEffectSuppressed()) { + return false; + } + return weather.weatherType === WeatherType.HAIL || weather.weatherType === WeatherType.SNOW; + }, + 3 + ) .attr(AddArenaTagAttr, ArenaTagType.AURORA_VEIL, 5, true) .target(MoveTarget.USER_SIDE), /* Unused */ @@ -10796,7 +10890,10 @@ export function initMoves() { .attr(AddBattlerTagHeaderAttr, BattlerTagType.SHELL_TRAP) .target(MoveTarget.ALL_NEAR_ENEMIES) // Fails if the user was not hit by a physical attack during the turn - .condition((user, target, move) => user.getTag(ShellTrapTag)?.activated === true), + .condition( + user => user.getTag(ShellTrapTag)?.activated === true, + 3 + ), new AttackMove(MoveId.FLEUR_CANNON, PokemonType.FAIRY, MoveCategory.SPECIAL, 130, 90, 5, -1, 0, 7) .attr(StatStageChangeAttr, [ Stat.SPATK ], -2, true), new AttackMove(MoveId.PSYCHIC_FANGS, PokemonType.PSYCHIC, MoveCategory.PHYSICAL, 85, 100, 10, -1, 0, 7) @@ -10840,7 +10937,7 @@ export function initMoves() { .edgeCase(), // I assume it's because it needs thunderbolt and pikachu in a cap /* End Unused */ new AttackMove(MoveId.MIND_BLOWN, PokemonType.FIRE, MoveCategory.SPECIAL, 150, 100, 5, -1, 0, 7) - .condition(failIfDampCondition) + .condition(failIfDampCondition, 3) .attr(HalfSacrificialAttr) .target(MoveTarget.ALL_NEAR_OTHERS), new AttackMove(MoveId.PLASMA_FISTS, PokemonType.ELECTRIC, MoveCategory.PHYSICAL, 100, 100, 15, -1, 0, 7) @@ -11031,7 +11128,8 @@ export function initMoves() { new SelfStatusMove(MoveId.CLANGOROUS_SOUL, PokemonType.DRAGON, 100, 5, -1, 0, 8) .attr(CutHpStatStageBoostAttr, [ Stat.ATK, Stat.DEF, Stat.SPATK, Stat.SPDEF, Stat.SPD ], 1, 3) .soundBased() - .danceMove(), + .danceMove() + .condition(new FailIfInsufficientHpCondition(3), 3), new AttackMove(MoveId.BODY_PRESS, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 80, 100, 10, -1, 0, 8) .attr(DefAtkAttr), new StatusMove(MoveId.DECORATE, PokemonType.FAIRY, -1, 15, -1, 0, 8) @@ -11078,7 +11176,7 @@ export function initMoves() { .triageMove(), new SelfStatusMove(MoveId.OBSTRUCT, PokemonType.DARK, 100, 10, -1, 4, 8) .attr(ProtectAttr, BattlerTagType.OBSTRUCT) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new AttackMove(MoveId.FALSE_SURRENDER, PokemonType.DARK, MoveCategory.PHYSICAL, 80, -1, 10, -1, 0, 8), new AttackMove(MoveId.METEOR_ASSAULT, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 150, 100, 5, -1, 0, 8) .attr(RechargeAttr) @@ -11092,7 +11190,7 @@ export function initMoves() { .attr(VariableTargetAttr, (user, target, move) => globalScene.arena.getTerrainType() === TerrainType.PSYCHIC && user.isGrounded() ? MoveTarget.ALL_NEAR_ENEMIES : MoveTarget.NEAR_OTHER), new AttackMove(MoveId.STEEL_ROLLER, PokemonType.STEEL, MoveCategory.PHYSICAL, 130, 100, 5, -1, 0, 8) .attr(ClearTerrainAttr) - .condition((user, target, move) => !!globalScene.arena.terrain), + .condition(() => !!globalScene.arena.terrain, 3), new AttackMove(MoveId.SCALE_SHOT, PokemonType.DRAGON, MoveCategory.PHYSICAL, 25, 90, 20, -1, 0, 8) .attr(StatStageChangeAttr, [ Stat.SPD ], 1, true, { lastHitOnly: true }) .attr(StatStageChangeAttr, [ Stat.DEF ], -1, true, { lastHitOnly: true }) @@ -11109,7 +11207,7 @@ export function initMoves() { .attr(SacrificialAttr) .target(MoveTarget.ALL_NEAR_OTHERS) .attr(MovePowerMultiplierAttr, (user, target, move) => globalScene.arena.getTerrainType() === TerrainType.MISTY && user.isGrounded() ? 1.5 : 1) - .condition(failIfDampCondition) + .condition(failIfDampCondition, 3) .makesContact(false), new AttackMove(MoveId.GRASSY_GLIDE, PokemonType.GRASS, MoveCategory.PHYSICAL, 55, 100, 20, -1, 0, 8) .attr(IncrementMovePriorityAttr, (user, target, move) => globalScene.arena.getTerrainType() === TerrainType.GRASSY && user.isGrounded()), @@ -11127,7 +11225,7 @@ export function initMoves() { new AttackMove(MoveId.LASH_OUT, PokemonType.DARK, MoveCategory.PHYSICAL, 75, 100, 5, -1, 0, 8) .attr(MovePowerMultiplierAttr, (user, _target, _move) => user.turnData.statStagesDecreased ? 2 : 1), new AttackMove(MoveId.POLTERGEIST, PokemonType.GHOST, MoveCategory.PHYSICAL, 110, 90, 5, -1, 0, 8) - .condition(failIfNoTargetHeldItemsCondition) + .condition(failIfNoTargetHeldItemsCondition, 3) .attr(PreMoveMessageAttr, attackedByItemMessageFunc) .makesContact(false), new StatusMove(MoveId.CORROSIVE_GAS, PokemonType.POISON, 100, 40, -1, 0, 8) @@ -11371,7 +11469,7 @@ export function initMoves() { .attr(StatStageChangeAttr, [ Stat.ATK, Stat.SPATK ], -1, true, { condition: (user, target, move) => user.isTerastallized && user.isOfType(PokemonType.STELLAR) }), new SelfStatusMove(MoveId.SILK_TRAP, PokemonType.BUG, -1, 10, -1, 4, 9) .attr(ProtectAttr, BattlerTagType.SILK_TRAP) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new AttackMove(MoveId.AXE_KICK, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 120, 90, 10, 30, 0, 9) .attr(MissEffectAttr, crashDamageFunc) .attr(NoEffectAttr, crashDamageFunc) @@ -11400,10 +11498,7 @@ export function initMoves() { .attr(ClearTerrainAttr), new AttackMove(MoveId.GLAIVE_RUSH, PokemonType.DRAGON, MoveCategory.PHYSICAL, 120, 100, 5, -1, 0, 9) .attr(AddBattlerTagAttr, BattlerTagType.ALWAYS_GET_HIT, true, false, 0, 0, true) - .attr(AddBattlerTagAttr, BattlerTagType.RECEIVE_DOUBLE_DAMAGE, true, false, 0, 0, true) - .condition((user, target, move) => { - return !(target.getTag(BattlerTagType.PROTECTED)?.tagType === "PROTECTED" || globalScene.arena.getTag(ArenaTagType.MAT_BLOCK)?.tagType === "MAT_BLOCK"); - }), + .attr(AddBattlerTagAttr, BattlerTagType.RECEIVE_DOUBLE_DAMAGE, true, false, 0, 0, true), new StatusMove(MoveId.REVIVAL_BLESSING, PokemonType.NORMAL, -1, 1, -1, 0, 9) .triageMove() .attr(RevivalBlessingAttr) @@ -11433,7 +11528,8 @@ export function initMoves() { new StatusMove(MoveId.DOODLE, PokemonType.NORMAL, 100, 10, -1, 0, 9) .attr(AbilityCopyAttr, true), new SelfStatusMove(MoveId.FILLET_AWAY, PokemonType.NORMAL, -1, 10, -1, 0, 9) - .attr(CutHpStatStageBoostAttr, [ Stat.ATK, Stat.SPATK, Stat.SPD ], 2, 2), + .attr(CutHpStatStageBoostAttr, [ Stat.ATK, Stat.SPATK, Stat.SPD ], 2, 2) + .condition(new FailIfInsufficientHpCondition(2), 3), new AttackMove(MoveId.KOWTOW_CLEAVE, PokemonType.DARK, MoveCategory.PHYSICAL, 85, -1, 10, -1, 0, 9) .slicingMove(), new AttackMove(MoveId.FLOWER_TRICK, PokemonType.GRASS, MoveCategory.PHYSICAL, 70, -1, 10, -1, 0, 9) @@ -11522,8 +11618,8 @@ export function initMoves() { .makesContact(false) .restriction(ConsecutiveUseRestriction), new AttackMove(MoveId.COMEUPPANCE, PokemonType.DARK, MoveCategory.PHYSICAL, -1, 100, 10, -1, 0, 9) - .attr(CounterDamageAttr, (move: Move) => (move.category === MoveCategory.PHYSICAL || move.category === MoveCategory.SPECIAL), 1.5) - .redirectCounter() + .attr(CounterDamageAttr, 1.5) + .condition(counterAttackCondition_Both, 3) .target(MoveTarget.ATTACKER), new AttackMove(MoveId.AQUA_CUTTER, PokemonType.WATER, MoveCategory.PHYSICAL, 70, 100, 20, -1, 0, 9) .attr(HighCritAttr) @@ -11575,15 +11671,9 @@ export function initMoves() { .edgeCase(), // Should not interact with Sheer Force new SelfStatusMove(MoveId.BURNING_BULWARK, PokemonType.FIRE, -1, 10, -1, 4, 9) .attr(ProtectAttr, BattlerTagType.BURNING_BULWARK) - .condition(failIfLastCondition), + .condition(failIfLastCondition, 3), new AttackMove(MoveId.THUNDERCLAP, PokemonType.ELECTRIC, MoveCategory.SPECIAL, 70, 100, 5, -1, 1, 9) - .condition((user, target, move) => { - const turnCommand = globalScene.currentBattle.turnCommands[target.getBattlerIndex()]; - if (!turnCommand || !turnCommand.move) { - return false; - } - return (turnCommand.command === Command.FIGHT && !target.turnData.acted && allMoves[turnCommand.move.move].category !== MoveCategory.STATUS); - }), + .condition(failIfTargetNotAttackingCondition, 3), new AttackMove(MoveId.MIGHTY_CLEAVE, PokemonType.ROCK, MoveCategory.PHYSICAL, 95, 100, 5, -1, 0, 9) .slicingMove() .ignoresProtect(), @@ -11611,7 +11701,7 @@ export function initMoves() { .attr(AddBattlerTagAttr, BattlerTagType.HEAL_BLOCK, false, false, 2), new AttackMove(MoveId.UPPER_HAND, PokemonType.FIGHTING, MoveCategory.PHYSICAL, 65, 100, 15, 100, 3, 9) .attr(FlinchAttr) - .condition(UpperHandCondition), + .condition(UpperHandCondition, 3), new AttackMove(MoveId.MALIGNANT_CHAIN, PokemonType.POISON, MoveCategory.SPECIAL, 100, 100, 5, 50, 0, 9) .attr(StatusEffectAttr, StatusEffect.TOXIC) ); diff --git a/src/enums/move-category.ts b/src/enums/move-category.ts index 0408655e6db..fd788055e02 100644 --- a/src/enums/move-category.ts +++ b/src/enums/move-category.ts @@ -3,3 +3,6 @@ export enum MoveCategory { SPECIAL, STATUS } + +/** Type of damage categories */ +export type MoveDamageCategory = Exclude; \ No newline at end of file diff --git a/src/enums/move-flags.ts b/src/enums/move-flags.ts index dc0964ad2a0..7504d3c1e95 100644 --- a/src/enums/move-flags.ts +++ b/src/enums/move-flags.ts @@ -47,10 +47,8 @@ export enum MoveFlags { CHECK_ALL_HITS = 1 << 16, /** Indicates a move is able to bypass its target's Substitute (if the target has one) */ IGNORE_SUBSTITUTE = 1 << 17, - /** Indicates a move is able to be redirected to allies in a double battle if the attacker faints */ - REDIRECT_COUNTER = 1 << 18, /** Indicates a move is able to be reflected by {@linkcode AbilityId.MAGIC_BOUNCE} and {@linkcode MoveId.MAGIC_COAT} */ - REFLECTABLE = 1 << 19, + REFLECTABLE = 1 << 18, /** Indicates a move that fails when {@link https://bulbapedia.bulbagarden.net/wiki/Gravity_(move) | Gravity} is in effect */ - GRAVITY = 1 << 20, + GRAVITY = 1 << 19, } diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index f7542b84034..c5e1b8d51ab 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -724,7 +724,7 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { abstract getFieldIndex(): number; - abstract getBattlerIndex(): BattlerIndex; + abstract getBattlerIndex(): Exclude; /** * Load all assets needed for this Pokemon's use in battle @@ -3305,7 +3305,7 @@ export abstract class Pokemon extends Phaser.GameObjects.Container { */ public trySelectMove(moveIndex: number, ignorePp?: boolean): [boolean, string] { const move = this.getMoveset().length > moveIndex ? this.getMoveset()[moveIndex] : null; - return move?.isUsable(this, ignorePp) ?? [false, ""]; + return move?.isUsable(this, ignorePp, true) ?? [false, ""]; } showInfo(): void { @@ -5787,7 +5787,7 @@ export class PlayerPokemon extends Pokemon { return globalScene.getPlayerField().indexOf(this); } - getBattlerIndex(): BattlerIndex { + getBattlerIndex(): Exclude { return this.getFieldIndex(); } @@ -6903,7 +6903,7 @@ export class EnemyPokemon extends Pokemon { return globalScene.getEnemyField().indexOf(this); } - getBattlerIndex(): BattlerIndex { + getBattlerIndex(): Exclude { return BattlerIndex.ENEMY + this.getFieldIndex(); } diff --git a/src/phases/command-phase.ts b/src/phases/command-phase.ts index 6b51bb379a5..90da939bdd8 100644 --- a/src/phases/command-phase.ts +++ b/src/phases/command-phase.ts @@ -254,7 +254,7 @@ export class CommandPhase extends FieldPhase { // Ternary here ensures we don't compute struggle conditions unless necessary const useStruggle = canUse ? false - : cursor > -1 && !playerPokemon.getMoveset().some(m => m.isUsable(playerPokemon)[0]); + : cursor > -1 && !playerPokemon.getMoveset().some(m => m.isUsable(playerPokemon, ignorePP, true)[0]); if (!canUse && !useStruggle) { console.error("Cannot use move:", reason); diff --git a/src/phases/move-phase.ts b/src/phases/move-phase.ts index 115cbfb1ecc..22731977187 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -27,7 +27,7 @@ import { frenzyMissFunc } from "#moves/move-utils"; import type { PokemonMove } from "#moves/pokemon-move"; import { BattlePhase } from "#phases/battle-phase"; // biome-ignore lint/correctness/noUnusedImports: Used in a tsdoc comment -import type { PreUseInterruptAttr } from "#types/move-types"; +import type { Move, PreUseInterruptAttr } from "#types/move-types"; import { applyChallenges } from "#utils/challenge-utils"; import { BooleanHolder, NumberHolder } from "#utils/common"; import { enumValueToKey } from "#utils/enums"; @@ -201,6 +201,7 @@ export class MovePhase extends BattlePhase { * - Pollen puff used on an ally that is under effect of heal block * - Burn up / Double shock when the user does not have the required type * - No Retreat while already under its effects + * - Failure due to primal weather * - (on cart, not applicable to Pokerogue) Moves that fail if used ON a raid / special boss: selfdestruct/explosion/imprision/power split / guard split * - (on cart, not applicable to Pokerogue) Moves that fail during a "co-op" battle (like when Arven helps during raid boss): ally switch / teatime * @@ -209,17 +210,26 @@ export class MovePhase extends BattlePhase { protected secondFailureCheck(): boolean { const move = this.move.getMove(); const user = this.pokemon; + let failedText: string | undefined; + const arena = globalScene.arena; + if (!move.applyConditions(user, this.getActiveTargetPokemon()[0], 2)) { + // TODO: Make pollen puff failing from heal block use its own message this.failed = true; - // Note: If any of the moves have custom failure messages, this needs to be changed - // As of Gen 9, none do. (Except maybe pollen puff? Need to check) - return true; + } else if (arena.isMoveWeatherCancelled(user, move)) { + failedText = getWeatherBlockMessage(globalScene.arena.getWeatherType()); + this.failed = true; + } else { + // Powder *always* happens last + // Note: Powder's lapse method handles everything: messages, damage, animation, primal weather interaction, + // determining type of type changing moves, etc. + // It will set this phase's `failed` flag to true if it procs + user.lapseTag(BattlerTagType.POWDER, BattlerTagLapseType.PRE_MOVE); + return this.failed; + } + if (this.failed) { + this.showFailedText(failedText); } - // Powder *always* happens last - // Note: Powder's lapse method handles everything: messages, damage, animation, primal weather interaction, - // determining type of type changing moves, etc. - // It will set this phase's `failed` flag to true if it procs - user.lapseTag(BattlerTagType.POWDER, BattlerTagLapseType.PRE_MOVE); return this.failed; } @@ -229,10 +239,13 @@ export class MovePhase extends BattlePhase { * @returns Whether the move failed * * @remarks - * - Conditional attributes of the move + * - Anything in {@linkcode Move.conditionsSeq3} * - Weather blocking the move * - Terrain blocking the move * - Queenly Majesty / Dazzling + * - Damp (which is handled by move conditions in pokerogue rather than the ability, like queenly majesty / dazzling) + * + * The rest of the failure conditions are marked as sequence 4 and happen in the move effect phase. */ protected thirdFailureCheck(): boolean { /** @@ -244,9 +257,8 @@ export class MovePhase extends BattlePhase { const arena = globalScene.arena; const user = this.pokemon; const failsConditions = !move.applyConditions(user, targets[0]); - const failedDueToWeather = arena.isMoveWeatherCancelled(user, move); const failedDueToTerrain = arena.isMoveTerrainCancelled(user, this.targets, move); - let failed = failsConditions || failedDueToWeather || failedDueToTerrain; + let failed = failsConditions || failedDueToTerrain; // Apply queenly majesty / dazzling if (!failed) { @@ -264,7 +276,7 @@ export class MovePhase extends BattlePhase { } if (failed) { - this.failMove(true, failedDueToWeather, failedDueToTerrain); + this.failMove(failedDueToTerrain); return true; } @@ -308,17 +320,10 @@ export class MovePhase extends BattlePhase { return; } - // Now, issue the second failure checks - - // If the user was asleep but is using a move anyway, it should STILL display the "user is sleeping" message! - // At this point, cure the user's freeze - // At this point, called moves should be decided. - // For now, this is a placeholder until we rework how called moves are handled - // For correct alignment with mainline, this SHOULD go here, and it SHOULD rewrite its own move - // Though, this is not the case in pokerogue. + // For now, this comment works as a placeholder until we rework how called moves are handled + // For correct alignment with mainline, this SHOULD go here, and this phase SHOULD rewrite its own move - // At this point... // If the first failure check passes, then thaw the user if its move will thaw it. // The sleep message and animation are also played if the user is asleep but using a move anyway (snore, sleep talk, etc) this.post1stFailSleepOrThaw(); @@ -349,29 +354,36 @@ export class MovePhase extends BattlePhase { // Move is announced this.showMoveText(); - // Stance change happens const charging = this.move.getMove().isChargingMove() && !this.pokemon.getTag(BattlerTagType.CHARGING); - // Stance change happens now if the move is about to be executed + const move = this.move.getMove(); + + // Update the battle's "last move" pointer unless we're currently mimicking a move or triggering Dancer. + if (!move.hasAttr("CopyMoveAttr") && !isReflected(this.useMode)) { + globalScene.currentBattle.lastMove = move.id; + } + + // Stance change happens now if the move is about to be executed and is not a charging move if (!charging) { + this.usePP(); globalScene.triggerPokemonFormChange(this.pokemon, SpeciesFormChangePreMoveTrigger); } - if (this.secondFailureCheck()) { - this.showFailedText(); + // At this point, if the target index has not moved on from attacker, the move must fail + if (this.targets[0] === BattlerIndex.ATTACKER) { + this.fail(); + } + if (this.targets[0] === BattlerIndex.ATTACKER || this.secondFailureCheck()) { this.handlePreMoveFailures(); this.end(); return; } - if (!(this.failed || this.cancelled)) { - this.resolveFinalPreMoveCancellationChecks(); + if (this.resolveFinalPreMoveCancellationChecks()) { + this.end(); } - // Cancel, charge or use the move as applicable. - if (this.cancelled || this.failed) { - this.handlePreMoveFailures(); - } else if (charging) { + if (charging) { this.chargeMove(); } else { this.useMove(); @@ -380,20 +392,25 @@ export class MovePhase extends BattlePhase { this.end(); } - /** Check for cancellation edge cases - no targets remaining */ - protected resolveFinalPreMoveCancellationChecks(): void { + /** + * Check for cancellation edge cases - no targets remaining or the battler index being targeted is still the attacker + * @returns Whether the move fails + */ + protected resolveFinalPreMoveCancellationChecks(): boolean { const targets = this.getActiveTargetPokemon(); const moveQueue = this.pokemon.getMoveQueue(); if ( (targets.length === 0 && !this.move.getMove().hasAttr("AddArenaTrapTagAttr")) || - (moveQueue.length > 0 && moveQueue[0].move === MoveId.NONE) + (moveQueue.length > 0 && moveQueue[0].move === MoveId.NONE) || + this.targets[0] === BattlerIndex.ATTACKER ) { this.showFailedText(); - this.cancel(); - } else { - this.pokemon.lapseTags(BattlerTagLapseType.MOVE); + this.fail(); + return true; } + this.pokemon.lapseTags(BattlerTagLapseType.MOVE); + return false; } public getActiveTargetPokemon(): Pokemon[] { @@ -672,25 +689,23 @@ export class MovePhase extends BattlePhase { /** Execute the current move and apply its effects. */ private executeMove() { - const pokemon = this.pokemon; + const user = this.pokemon; const move = this.move.getMove(); const opponent = this.getActiveTargetPokemon()[0]; const targets = this.targets; // Trigger ability-based user type changes, display move text and then execute move effects. // TODO: Investigate whether PokemonTypeChangeAbAttr can drop the "opponent" parameter - applyAbAttrs("PokemonTypeChangeAbAttr", { pokemon, move, opponent }); - this.showMoveText(); - globalScene.phaseManager.unshiftNew("MoveEffectPhase", pokemon.getBattlerIndex(), targets, move, this.useMode); + applyAbAttrs("PokemonTypeChangeAbAttr", { pokemon: user, move, opponent }); + globalScene.phaseManager.unshiftNew("MoveEffectPhase", user.getBattlerIndex(), targets, move, this.useMode); // Handle Dancer, which triggers immediately after a move is used (rather than waiting on `this.end()`). // Note the MoveUseMode check here prevents an infinite Dancer loop. // TODO: This needs to go at the end of `MoveEffectPhase` to check move results const dancerModes: MoveUseMode[] = [MoveUseMode.INDIRECT, MoveUseMode.REFLECTED] as const; if (this.move.getMove().hasFlag(MoveFlags.DANCE_MOVE) && !dancerModes.includes(this.useMode)) { - // biome-ignore lint/nursery/noShadow: We don't need to access `pokemon` from the outer scope globalScene.getField(true).forEach(pokemon => { - applyAbAttrs("PostMoveUsedAbAttr", { pokemon, move: this.move, source: pokemon, targets: targets }); + applyAbAttrs("PostMoveUsedAbAttr", { pokemon, move: this.move, source: user, targets: targets }); }); } } @@ -698,11 +713,9 @@ export class MovePhase extends BattlePhase { /** * Fail the move currently being used. * Handles failure messages, pushing to move history, etc. - * @param showText - Whether to show move text when failing the move. - * @param failedDueToWeather - Whether the move failed due to weather (default `false`) * @param failedDueToTerrain - Whether the move failed due to terrain (default `false`) */ - protected failMove(showText: boolean, failedDueToWeather = false, failedDueToTerrain = false) { + protected failMove(failedDueToTerrain = false) { const move = this.move.getMove(); const targets = this.getActiveTargetPokemon(); @@ -724,10 +737,6 @@ export class MovePhase extends BattlePhase { }); } - if (showText) { - this.showMoveText(); - } - this.pokemon.pushMoveHistory({ move: this.move.moveId, targets: this.targets, @@ -741,9 +750,7 @@ export class MovePhase extends BattlePhase { move.getFailedText(this.pokemon, targets[0], move) || (failedDueToTerrain ? getTerrainBlockMessage(targets[0], globalScene.arena.getTerrainType()) - : failedDueToWeather - ? getWeatherBlockMessage(globalScene.arena.getWeatherType()) - : i18next.t("battle:attackFailed")); + : i18next.t("battle:attackFailed")); this.showFailedText(failureMessage); @@ -760,7 +767,7 @@ export class MovePhase extends BattlePhase { const targets = this.getActiveTargetPokemon(); if (!move.applyConditions(this.pokemon, targets[0])) { - this.failMove(true); + this.failMove(); return; } @@ -888,34 +895,17 @@ export class MovePhase extends BattlePhase { * to reflect the actual battler index of the user's last attacker. * * If there is no last attacker or they are no longer on the field, a message is displayed and the - * move is marked for failure. - * @todo Make this a feature of the move rather than basing logic on {@linkcode BattlerIndex.ATTACKER} + * move is marked for failure */ protected resolveCounterAttackTarget(): void { if (this.targets.length !== 1 || this.targets[0] !== BattlerIndex.ATTACKER) { return; } - // TODO: This should be covered in move conditions - if (this.pokemon.turnData.attacksReceived.length === 0) { - this.fail(); - this.showMoveText(); - this.showFailedText(); - return; - } + const targetHolder = new NumberHolder(BattlerIndex.ATTACKER); - this.targets[0] = this.pokemon.turnData.attacksReceived[0].sourceBattlerIndex; - - // account for metal burst and comeuppance hitting remaining targets in double battles - // counterattack will redirect to remaining ally if original attacker faints - if ( - globalScene.currentBattle.double && - this.move.getMove().hasFlag(MoveFlags.REDIRECT_COUNTER) && - globalScene.getField()[this.targets[0]].hp === 0 - ) { - const opposingField = this.pokemon.isPlayer() ? globalScene.getEnemyField() : globalScene.getPlayerField(); - this.targets[0] = opposingField.find(p => p.hp > 0)?.getBattlerIndex() ?? BattlerIndex.ATTACKER; - } + applyMoveAttrs("CounterRedirectAttr", this.pokemon, null, this.move.getMove(), targetHolder); + this.targets[0] = targetHolder.value; } /** @@ -937,10 +927,6 @@ export class MovePhase extends BattlePhase { return; } - if (this.failed) { - this.usePP(); - } - if (this.cancelled && this.pokemon.summonData.tags.some(t => t.tagType === BattlerTagType.FRENZY)) { frenzyMissFunc(this.pokemon, this.move.getMove()); } diff --git a/src/utils/pokemon-utils.ts b/src/utils/pokemon-utils.ts index 8de0a3bfcf1..21c9531aadb 100644 --- a/src/utils/pokemon-utils.ts +++ b/src/utils/pokemon-utils.ts @@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene"; import { POKERUS_STARTER_COUNT, speciesStarterCosts } from "#balance/starters"; import { allSpecies } from "#data/data-lists"; import type { PokemonSpecies, PokemonSpeciesForm } from "#data/pokemon-species"; +import { BattlerIndex } from "#enums/battler-index"; import type { SpeciesId } from "#enums/species-id"; import { randSeedItem } from "./common"; @@ -123,3 +124,19 @@ export function getPokemonSpeciesForm(species: SpeciesId, formIndex: number): Po } return retSpecies; } + +/** + * Return whether two battler indices are allies + * @param a - First battler index + * @param b - Second battler index + * @returns Whether the two battler indices are allies. Always `false` if either index is `ATTACKER`. + */ +export function areAllies(a: BattlerIndex, b: BattlerIndex): boolean { + if (a === BattlerIndex.ATTACKER || b === BattlerIndex.ATTACKER) { + return false; + } + return ( + (a === BattlerIndex.PLAYER || a === BattlerIndex.PLAYER_2) === + (b === BattlerIndex.PLAYER || b === BattlerIndex.PLAYER_2) + ); +} diff --git a/test/moves/throat-chop.test.ts b/test/moves/throat-chop.test.ts index a4f090b2de1..335bfce2f40 100644 --- a/test/moves/throat-chop.test.ts +++ b/test/moves/throat-chop.test.ts @@ -35,6 +35,7 @@ describe("Moves - Throat Chop", () => { await game.classicMode.startBattle([SpeciesId.MAGIKARP]); const enemy = game.field.getEnemyPokemon(); + const player = game.field.getPlayerPokemon(); game.move.select(MoveId.GROWL); await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]); @@ -46,6 +47,8 @@ describe("Moves - Throat Chop", () => { // Second turn, struggle if no valid moves await game.toNextTurn(); + expect(player.trySelectMove(MoveId.GROWL)[0]).toBe(false); + game.move.select(MoveId.GROWL); await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]); From ce752c9d0758527a7d752dff4aceec2872050e83 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 20:23:27 -0500 Subject: [PATCH 4/9] Adjust status checks to respect ignoreStatus useModes --- src/enums/battler-tag-lapse-type.ts | 12 ++++++++++- src/phases/move-phase.ts | 33 +++++++++++++++++------------ test/abilities/cud-chew.test.ts | 6 ++---- test/moves/gigaton-hammer.test.ts | 10 ++++----- 4 files changed, 38 insertions(+), 23 deletions(-) diff --git a/src/enums/battler-tag-lapse-type.ts b/src/enums/battler-tag-lapse-type.ts index f9486876993..cc93d6c6782 100644 --- a/src/enums/battler-tag-lapse-type.ts +++ b/src/enums/battler-tag-lapse-type.ts @@ -11,7 +11,17 @@ export enum BattlerTagLapseType { * @see MoveUseMode for more information */ MOVE, - /** Tag activates during (or just after) the first failure check sequence in the move phase. */ + /** + * Tag activates during (or just after) the first failure check sequence in the move phase. + * + * @remarks + * + * Note tags with this lapse type will lapse immediately after the first failure check sequence, + * regardless of whether the move was successful or not. + * + * To only lapse the tag between the first and second failure check sequences, use + * {@linkcode BattlerTagLapseType.MOVE} instead. + */ PRE_MOVE, /** Tag activates immediately after the holder's move finishes triggering (successful or not). */ AFTER_MOVE, diff --git a/src/phases/move-phase.ts b/src/phases/move-phase.ts index 22731977187..c5e9d6dfad1 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -301,8 +301,8 @@ export class MovePhase extends BattlePhase { // if it attempted to move at all. user.turnData.acted = true; const useMode = this.useMode; - const virtual = isVirtual(useMode); - if (!virtual && this.firstFailureCheck()) { + const ignoreStatus = isIgnoreStatus(useMode); + if (!ignoreStatus && this.firstFailureCheck()) { // Lapse all other pre-move tags user.lapseTags(BattlerTagLapseType.PRE_MOVE); this.end(); @@ -314,11 +314,13 @@ export class MovePhase extends BattlePhase { - Protect, detect, ally switch, etc, resetting consecutive use count - Rollout / ice ball "unlocking" - protect / ally switch / other moves resetting their consecutive use count - - and others - In Pokerogue, these are instead handled by their respective methods, which generally + - and many others + In Pokerogue, these are instead handled elsewhere, and generally work in a way that aligns with cartridge behavior */ return; } + // Tags still need to be lapsed if no failure occured + user.lapseTags(BattlerTagLapseType.PRE_MOVE); // At this point, called moves should be decided. // For now, this comment works as a placeholder until we rework how called moves are handled @@ -329,7 +331,7 @@ export class MovePhase extends BattlePhase { this.post1stFailSleepOrThaw(); // Reset hit-related turn data when starting follow-up moves (e.g. Metronomed moves, Dancer repeats) - if (virtual) { + if (isVirtual(useMode)) { this.pokemon.turnData.hitsLeft = -1; this.pokemon.turnData.hitCount = 0; } @@ -369,11 +371,7 @@ export class MovePhase extends BattlePhase { globalScene.triggerPokemonFormChange(this.pokemon, SpeciesFormChangePreMoveTrigger); } - // At this point, if the target index has not moved on from attacker, the move must fail - if (this.targets[0] === BattlerIndex.ATTACKER) { - this.fail(); - } - if (this.targets[0] === BattlerIndex.ATTACKER || this.secondFailureCheck()) { + if (this.secondFailureCheck()) { this.handlePreMoveFailures(); this.end(); return; @@ -393,7 +391,7 @@ export class MovePhase extends BattlePhase { } /** - * Check for cancellation edge cases - no targets remaining or the battler index being targeted is still the attacker + * Check for cancellation edge cases - no targets remaining * @returns Whether the move fails */ protected resolveFinalPreMoveCancellationChecks(): boolean { @@ -402,8 +400,7 @@ export class MovePhase extends BattlePhase { if ( (targets.length === 0 && !this.move.getMove().hasAttr("AddArenaTrapTagAttr")) || - (moveQueue.length > 0 && moveQueue[0].move === MoveId.NONE) || - this.targets[0] === BattlerIndex.ATTACKER + (moveQueue.length > 0 && moveQueue[0].move === MoveId.NONE) ) { this.showFailedText(); this.fail(); @@ -455,6 +452,7 @@ export class MovePhase extends BattlePhase { return false; } + // For some reason, dancer will immediately wake its user from sleep when triggering if (this.useMode === MoveUseMode.INDIRECT) { this.pokemon.resetStatus(false); return false; @@ -493,6 +491,12 @@ export class MovePhase extends BattlePhase { return false; } + // For some reason, dancer will immediately its user + if (this.useMode === MoveUseMode.INDIRECT) { + this.pokemon.resetStatus(false); + return false; + } + // Check if move use would heal the user if (Overrides.STATUS_ACTIVATION_OVERRIDE) { @@ -906,6 +910,9 @@ export class MovePhase extends BattlePhase { applyMoveAttrs("CounterRedirectAttr", this.pokemon, null, this.move.getMove(), targetHolder); this.targets[0] = targetHolder.value; + if (targetHolder.value === BattlerIndex.ATTACKER) { + this.fail(); + } } /** diff --git a/test/abilities/cud-chew.test.ts b/test/abilities/cud-chew.test.ts index f68141096eb..2c1850d8e42 100644 --- a/test/abilities/cud-chew.test.ts +++ b/test/abilities/cud-chew.test.ts @@ -1,4 +1,3 @@ -import { CudChewConsumeBerryAbAttr } from "#abilities/ability"; import { globalScene } from "#app/global-scene"; import { getPokemonNameWithAffix } from "#app/messages"; import { AbilityId } from "#enums/ability-id"; @@ -6,7 +5,6 @@ import { BerryType } from "#enums/berry-type"; import { MoveId } from "#enums/move-id"; import { SpeciesId } from "#enums/species-id"; import { Stat } from "#enums/stat"; -import { Pokemon } from "#field/pokemon"; import { GameManager } from "#test/test-utils/game-manager"; import i18next from "i18next"; import Phaser from "phaser"; @@ -111,7 +109,6 @@ describe("Abilities - Cud Chew", () => { it("can store multiple berries across 2 turns with teatime", async () => { // always eat first berry for stuff cheeks & company - vi.spyOn(Pokemon.prototype, "randBattleSeedInt").mockReturnValue(0); game.override .startingHeldItems([ { name: "BERRY", type: BerryType.PETAYA, count: 3 }, @@ -122,6 +119,7 @@ describe("Abilities - Cud Chew", () => { const farigiraf = game.field.getPlayerPokemon(); farigiraf.hp = 1; // needed to allow berry procs + vi.spyOn(farigiraf, "randBattleSeedInt").mockReturnValue(0); game.move.select(MoveId.STUFF_CHEEKS); await game.toNextTurn(); @@ -196,10 +194,10 @@ describe("Abilities - Cud Chew", () => { describe("regurgiates berries", () => { it("re-triggers effects on eater without pushing to array", async () => { - const apply = vi.spyOn(CudChewConsumeBerryAbAttr.prototype, "apply"); await game.classicMode.startBattle([SpeciesId.FARIGIRAF]); const farigiraf = game.field.getPlayerPokemon(); + const apply = vi.spyOn(farigiraf.getAbilityAttrs("CudChewConsumeBerryAbAttr")[0], "apply"); farigiraf.hp = 1; game.move.select(MoveId.SPLASH); diff --git a/test/moves/gigaton-hammer.test.ts b/test/moves/gigaton-hammer.test.ts index e5009310de6..d217290034b 100644 --- a/test/moves/gigaton-hammer.test.ts +++ b/test/moves/gigaton-hammer.test.ts @@ -33,7 +33,7 @@ describe("Moves - Gigaton Hammer", () => { }); it("can't be used two turns in a row", async () => { - await game.classicMode.startBattle(); + await game.classicMode.startBattle([SpeciesId.MAGIKARP]); const enemy1 = game.field.getEnemyPokemon(); @@ -46,17 +46,17 @@ describe("Moves - Gigaton Hammer", () => { await game.doKillOpponents(); await game.toNextWave(); + // Attempting to use Gigaton Hammer again should result in struggle game.move.select(MoveId.GIGATON_HAMMER); await game.toNextTurn(); - const enemy2 = game.field.getEnemyPokemon(); - - expect(enemy2.hp).toBe(enemy2.getMaxHp()); + const player = game.field.getPlayerPokemon(); + expect(player.getLastXMoves()[0]?.move).toBe(MoveId.STRUGGLE); }); it("can be used again if recalled and sent back out", async () => { game.override.startingWave(4); - await game.classicMode.startBattle(); + await game.classicMode.startBattle([SpeciesId.MAGIKARP]); const enemy1 = game.field.getEnemyPokemon(); From 92c7ece725c9082f709d9b345b7b114e524c8402 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 20:28:26 -0500 Subject: [PATCH 5/9] Adjust restriction for stuff cheeks --- src/data/moves/move-condition.ts | 13 +++-- src/data/moves/move.ts | 10 ++-- src/enums/battler-tag-lapse-type.ts | 7 ++- src/phases/move-phase.ts | 79 ++++++++++++++++------------- test/abilities/cud-chew.test.ts | 2 + 5 files changed, 63 insertions(+), 48 deletions(-) diff --git a/src/data/moves/move-condition.ts b/src/data/moves/move-condition.ts index 5c06ab9bebe..13cded8834e 100644 --- a/src/data/moves/move-condition.ts +++ b/src/data/moves/move-condition.ts @@ -26,10 +26,8 @@ export class MoveCondition { /** * @param func - A condition function that determines if the move can be used successfully */ - constructor(func?: MoveConditionFunc) { - if (func) { - this.func = func; - } + constructor(func: MoveConditionFunc) { + this.func = func; } apply(user: Pokemon, target: Pokemon, move: Move): boolean { @@ -46,9 +44,9 @@ export class MoveCondition { */ export class FirstMoveCondition extends MoveCondition { - public override readonly func: MoveConditionFunc = user => { - return user.tempSummonData.waveTurnCount === 1; - }; + constructor() { + super(user => user.tempSummonData.waveTurnCount === 0 && user.tempSummonData.turnCount === 0); + } // TODO: Update AI move selection logic to not require this method at all // Currently, it is used to avoid having the AI select the move if its condition will fail @@ -173,6 +171,7 @@ export const UpperHandCondition = new MoveCondition((_user, target) => { * - The user does not know at least one other move * - The user has not directly used each other move in its moveset since it was sent into battle * - A move is considered *used* for this purpose if it passed the first failure check sequence in the move phase + * (i.e. its usage message was displayed) */ export const lastResortCondition = new MoveCondition((user, _target, move) => { const otherMovesInMoveset = new Set(user.getMoveset().map(m => m.moveId)); diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index b9dc493064d..6aa7378e838 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -450,8 +450,8 @@ export abstract class Move implements Localizable { * @param restriction - The function or `MoveRestriction` that evaluates to `true` if the move is restricted from * being selected * @param i18nkey - The i18n key for the restriction text - * @param alsoCondition - If `true`, also adds a {@linkcode MoveCondition} that checks the same condition when the - * move is used; default `false` + * @param alsoCondition - If `true`, also adds an equivalent {@linkcode MoveCondition} that checks the same condition when the + * move is used (while taking care to invert the return value); default `false` * @param conditionSeq - The sequence number where the failure check occurs; default `4` * @returns `this` for method chaining */ @@ -11033,9 +11033,11 @@ export function initMoves() { .attr(EatBerryAttr, true) .attr(StatStageChangeAttr, [ Stat.DEF ], 2, true) .restriction( - user => globalScene.findModifiers(m => m instanceof BerryModifier, user.isPlayer()).length > 0, + user => globalScene.findModifiers(m => m instanceof BerryModifier, user.isPlayer()).length === 0, "battle:moveDisabledNoBerry", - true), + true, + 3 + ), new SelfStatusMove(MoveId.NO_RETREAT, PokemonType.FIGHTING, -1, 5, -1, 0, 8) .attr(StatStageChangeAttr, [ Stat.ATK, Stat.DEF, Stat.SPATK, Stat.SPDEF, Stat.SPD ], 1, true) .attr(AddBattlerTagAttr, BattlerTagType.NO_RETREAT, true, true /* NOT ADDED if already trapped */) diff --git a/src/enums/battler-tag-lapse-type.ts b/src/enums/battler-tag-lapse-type.ts index cc93d6c6782..f4fbcdda9a6 100644 --- a/src/enums/battler-tag-lapse-type.ts +++ b/src/enums/battler-tag-lapse-type.ts @@ -1,3 +1,5 @@ +import type { MoveUseMode } from "#enums/move-use-mode"; + /** * Enum representing the possible ways a given BattlerTag can activate and/or tick down. * Each tag can have multiple different behaviors attached to different lapse types. @@ -12,12 +14,13 @@ export enum BattlerTagLapseType { */ MOVE, /** - * Tag activates during (or just after) the first failure check sequence in the move phase. + * Tag activates during (or just after) the first failure check sequence in the move phase * * @remarks * * Note tags with this lapse type will lapse immediately after the first failure check sequence, - * regardless of whether the move was successful or not. + * regardless of whether the move was successful or not, but is skipped if the move is a + * {@linkcode MoveUseMode.FOLLOW_UP | follow-up} move. * * To only lapse the tag between the first and second failure check sequences, use * {@linkcode BattlerTagLapseType.MOVE} instead. diff --git a/src/phases/move-phase.ts b/src/phases/move-phase.ts index c5e9d6dfad1..787d2819f28 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -138,28 +138,44 @@ export class MovePhase extends BattlePhase { */ protected firstFailureCheck(): boolean { // A big if statement will handle the checks (that each have side effects!) in the correct order - if ( + return ( this.checkSleep() || this.checkFreeze() || this.checkPP() || this.checkValidity() || - this.checkTagCancel(BattlerTagType.TRUANT, true) || + this.checkTagCancel(BattlerTagType.TRUANT) || this.checkPreUseInterrupt() || this.checkTagCancel(BattlerTagType.FLINCHED) || - this.checkTagCancel(BattlerTagType.DISABLED, true) || + this.checkTagCancel(BattlerTagType.DISABLED) || this.checkTagCancel(BattlerTagType.HEAL_BLOCK) || this.checkTagCancel(BattlerTagType.THROAT_CHOPPED) || this.checkGravity() || - this.checkTagCancel(BattlerTagType.TAUNT, true) || + this.checkTagCancel(BattlerTagType.TAUNT) || this.checkTagCancel(BattlerTagType.IMPRISON) || this.checkTagCancel(BattlerTagType.CONFUSED) || this.checkPara() || this.checkTagCancel(BattlerTagType.INFATUATED) - ) { - this.handlePreMoveFailures(); - return true; - } - return false; + ); + } + + /** + * Follow up moves need to check a subset of the first failure checks + * + * @remarks + * + * Based on smogon battle mechanics research, checks happen in the following order: + * 1. Invalid move (skipped in pokerogue) + * 2. Move prevented by heal block + * 3. Move prevented by throat chop + * 4. Gravity + * 5. sky battle (unused in Pokerogue) + */ + protected followUpMoveFirstFailureCheck(): boolean { + return ( + this.checkTagCancel(BattlerTagType.HEAL_BLOCK) || + this.checkTagCancel(BattlerTagType.THROAT_CHOPPED) || + this.checkGravity() + ); } /** @@ -302,33 +318,29 @@ export class MovePhase extends BattlePhase { user.turnData.acted = true; const useMode = this.useMode; const ignoreStatus = isIgnoreStatus(useMode); - if (!ignoreStatus && this.firstFailureCheck()) { - // Lapse all other pre-move tags + if (!ignoreStatus) { + this.firstFailureCheck(); user.lapseTags(BattlerTagLapseType.PRE_MOVE); + // At this point, called moves should be decided. + // For now, this comment works as a placeholder until called moves are reworked + // For correct alignment with mainline, this SHOULD go here, and this phase SHOULD rewrite its own move + } else if (useMode === MoveUseMode.FOLLOW_UP) { + this.followUpMoveFirstFailureCheck(); + } + // If the first failure check did not pass, then the move is cancelled + // Note: This only checks `cancelled`, as `failed` should NEVER be set by anything in the first failure check + if (this.cancelled) { + this.handlePreMoveFailures(); this.end(); - - /* - On cartridge, certain things *react* to move failures, depending on failure reason - The following would happen at this time on cartridge: - - Steadfast giving user speed boost if failed due to flinch - - Protect, detect, ally switch, etc, resetting consecutive use count - - Rollout / ice ball "unlocking" - - protect / ally switch / other moves resetting their consecutive use count - - and many others - In Pokerogue, these are instead handled elsewhere, and generally work in a way that aligns with cartridge behavior - */ return; } - // Tags still need to be lapsed if no failure occured - user.lapseTags(BattlerTagLapseType.PRE_MOVE); + // If this is a follow-up move , at this point, we need to re-check a few conditions - // At this point, called moves should be decided. - // For now, this comment works as a placeholder until we rework how called moves are handled - // For correct alignment with mainline, this SHOULD go here, and this phase SHOULD rewrite its own move - - // If the first failure check passes, then thaw the user if its move will thaw it. - // The sleep message and animation are also played if the user is asleep but using a move anyway (snore, sleep talk, etc) - this.post1stFailSleepOrThaw(); + // If the first failure check passes (and this is not a sub-move) then thaw the user if its move will thaw it. + // The sleep message and animation should also play if the user is asleep but using a move anyway (snore, sleep talk, etc) + if (useMode !== MoveUseMode.FOLLOW_UP) { + this.post1stFailSleepOrThaw(); + } // Reset hit-related turn data when starting follow-up moves (e.g. Metronomed moves, Dancer repeats) if (isVirtual(useMode)) { @@ -618,10 +630,7 @@ export class MovePhase extends BattlePhase { * @param tag - The tag type whose lapse method will be called with {@linkcode BattlerTagLapseType.PRE_MOVE} * @param checkIgnoreStatus - Whether to check {@link isIgnoreStatus} for the current {@linkcode MoveUseMode} to skip this check */ - private checkTagCancel(tag: BattlerTagType, checkIgnoreStatus = false): boolean { - if (checkIgnoreStatus && isIgnoreStatus(this.useMode)) { - return false; - } + private checkTagCancel(tag: BattlerTagType): boolean { this.pokemon.lapseTag(tag, BattlerTagLapseType.PRE_MOVE); return this.cancelled; } diff --git a/test/abilities/cud-chew.test.ts b/test/abilities/cud-chew.test.ts index 2c1850d8e42..e62a8897e02 100644 --- a/test/abilities/cud-chew.test.ts +++ b/test/abilities/cud-chew.test.ts @@ -118,8 +118,10 @@ describe("Abilities - Cud Chew", () => { await game.classicMode.startBattle([SpeciesId.FARIGIRAF]); const farigiraf = game.field.getPlayerPokemon(); + const enemy = game.field.getEnemyPokemon(); farigiraf.hp = 1; // needed to allow berry procs vi.spyOn(farigiraf, "randBattleSeedInt").mockReturnValue(0); + vi.spyOn(enemy, "randBattleSeedInt").mockReturnValue(0); game.move.select(MoveId.STUFF_CHEEKS); await game.toNextTurn(); From 7207c3b6ab4d6dcbeca2ddb0875523cd3e69b38d Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 21:12:38 -0500 Subject: [PATCH 6/9] Address bertie's review comments --- src/data/moves/move.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 6aa7378e838..95a7f0f9ced 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -122,11 +122,12 @@ export abstract class Move implements Localizable { * @remarks * These are the default conditions checked during the move effect phase (aka sequence 4). * When adding a new condition, if unsure of where it occurs in the failure checks, it should go here. - * @remarks Different from {@linkcode restrictions}, which is checked when the move is selected + * + * Different from {@linkcode restrictions}, which are checked when the move is selected */ private conditions: MoveCondition[] = []; /** - * Move failure conditions that occur during the second sequence (after move message and before ) + * Move failure conditions that occur during the second sequence (after move message but before the move is recorded as the last move used) */ private conditionsSeq2: MoveCondition[] = []; /** @@ -695,7 +696,7 @@ export abstract class Move implements Localizable { * Sets the {@linkcode MoveFlags.GRAVITY} flag for the calling Move and adds {@linkcode GravityUseRestriction} to the * move's restrictions. * - * @returns The {@linkcode Move} that called this function + * @returns `this` * * @remarks * No {@linkcode condition} is added, as gravity's condition is already checked From d74a70a529db61d114d0ddf965b8111162314b57 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 21:23:50 -0500 Subject: [PATCH 7/9] Add counterRedirectAttr to other counter-like moves --- src/data/moves/move.ts | 10 +++++----- src/phases/move-phase.ts | 2 ++ 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 95a7f0f9ced..010b787e098 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -1851,21 +1851,18 @@ export class CounterRedirectAttr extends MoveAttr { // check if the target is still alive if ( globalScene.currentBattle.double && - !globalScene.getField()[desiredTarget]?.isActive + !globalScene.getField()[desiredTarget]?.isActive(true) ) { const targetField = desiredTarget >= BattlerIndex.ENEMY ? globalScene.getEnemyField() : globalScene.getPlayerField(); args[0].value = targetField.find(p => p.hp > 0)?.getBattlerIndex() ?? BattlerIndex.ATTACKER; } else { args[0].value = desiredTarget; } + console.log(`CounterRedirectAttr: Redirecting move to battler index ${BattlerIndex[args[0].value]}`); return true; } return false; } - - override canApply(user: Pokemon, target: Pokemon, move: Move, args: [NumberHolder, ...any[]]): boolean { - return args[0].value === BattlerIndex.ATTACKER; - } } export class LevelDamageAttr extends FixedDamageAttr { @@ -9387,6 +9384,7 @@ export function initMoves() { .bitingMove(), new AttackMove(MoveId.MIRROR_COAT, PokemonType.PSYCHIC, MoveCategory.SPECIAL, -1, 100, 20, -1, -5, 2) .attr(CounterDamageAttr, 2, MoveCategory.SPECIAL) + .attr(CounterRedirectAttr, MoveCategory.SPECIAL) .condition(counterAttackCondition_Special, 3) .target(MoveTarget.ATTACKER), new StatusMove(MoveId.PSYCH_UP, PokemonType.NORMAL, -1, 10, -1, 0, 2) @@ -9805,6 +9803,7 @@ export function initMoves() { .target(MoveTarget.USER_OR_NEAR_ALLY), new AttackMove(MoveId.METAL_BURST, PokemonType.STEEL, MoveCategory.PHYSICAL, -1, 100, 10, -1, 0, 4) .attr(CounterDamageAttr, 1.5) + .attr(CounterRedirectAttr) .condition(counterAttackCondition_Both, 3) .makesContact(false) .target(MoveTarget.ATTACKER), @@ -11622,6 +11621,7 @@ export function initMoves() { .restriction(ConsecutiveUseRestriction), new AttackMove(MoveId.COMEUPPANCE, PokemonType.DARK, MoveCategory.PHYSICAL, -1, 100, 10, -1, 0, 9) .attr(CounterDamageAttr, 1.5) + .attr(CounterRedirectAttr) .condition(counterAttackCondition_Both, 3) .target(MoveTarget.ATTACKER), new AttackMove(MoveId.AQUA_CUTTER, PokemonType.WATER, MoveCategory.PHYSICAL, 70, 100, 20, -1, 0, 9) diff --git a/src/phases/move-phase.ts b/src/phases/move-phase.ts index 787d2819f28..91e0fdb0ee6 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -912,6 +912,7 @@ export class MovePhase extends BattlePhase { */ protected resolveCounterAttackTarget(): void { if (this.targets.length !== 1 || this.targets[0] !== BattlerIndex.ATTACKER) { + console.log("%cSkipping counter attack target resolution", "color: blue"); return; } @@ -920,6 +921,7 @@ export class MovePhase extends BattlePhase { applyMoveAttrs("CounterRedirectAttr", this.pokemon, null, this.move.getMove(), targetHolder); this.targets[0] = targetHolder.value; if (targetHolder.value === BattlerIndex.ATTACKER) { + console.log("%cSkipping counter attack target resolution", "color: red"); this.fail(); } } From 55b842978761c2a33c71e7a4ae5ecefed63651c0 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 22:30:52 -0500 Subject: [PATCH 8/9] Adjust some documentation for new methods --- src/data/moves/move.ts | 15 +++++++++++---- src/utils/pokemon-utils.ts | 5 ++++- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/data/moves/move.ts b/src/data/moves/move.ts index 010b787e098..61455c676d3 100644 --- a/src/data/moves/move.ts +++ b/src/data/moves/move.ts @@ -93,6 +93,7 @@ import { toCamelCase, toTitleCase } from "#utils/strings"; import i18next from "i18next"; import { applyChallenges } from "#utils/challenge-utils"; import { ConsecutiveUseRestriction, counterAttackCondition_Both, counterAttackCondition_Physical, counterAttackCondition_Special, failAgainstFinalBossCondition, FailIfInsufficientHpCondition, failIfTargetNotAttackingCondition, failTeleportCondition, FirstMoveCondition, GravityUseRestriction, lastResortCondition, MoveCondition, MoveRestriction, UpperHandCondition } from "#moves/move-condition"; +import { areAllies } from "#utils/pokemon-utils"; /** * A function used to conditionally determine execution of a given {@linkcode MoveAttr}. @@ -1810,15 +1811,22 @@ export class CounterDamageAttr extends FixedDamageAttr { } apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean { + user.turnData.attacksReceived.find(ar => { + const category = allMoves[ar.move].category; + return (category !== MoveCategory.STATUS || areAllies(user.getBattlerIndex(), ar.sourceBattlerIndex)) + }) let damage = 0; + const userBattlerIndex = user.getBattlerIndex(); for (const ar of user.turnData.attacksReceived) { // TODO: Adjust this for moves with variable damage categories const category = allMoves[ar.move].category; - if (category === MoveCategory.STATUS || (this.moveFilter && category !== this.moveFilter)) { + if (category === MoveCategory.STATUS + || areAllies(userBattlerIndex, ar.sourceBattlerIndex) + || (this.moveFilter && category !== this.moveFilter)) { continue; } - damage += ar.damage; - + damage = ar.damage; + break; } (args[0] as NumberHolder).value = toDmgValue(damage * this.multiplier); @@ -1858,7 +1866,6 @@ export class CounterRedirectAttr extends MoveAttr { } else { args[0].value = desiredTarget; } - console.log(`CounterRedirectAttr: Redirecting move to battler index ${BattlerIndex[args[0].value]}`); return true; } return false; diff --git a/src/utils/pokemon-utils.ts b/src/utils/pokemon-utils.ts index 21c9531aadb..4b624d2669c 100644 --- a/src/utils/pokemon-utils.ts +++ b/src/utils/pokemon-utils.ts @@ -4,6 +4,8 @@ import { allSpecies } from "#data/data-lists"; import type { PokemonSpecies, PokemonSpeciesForm } from "#data/pokemon-species"; import { BattlerIndex } from "#enums/battler-index"; import type { SpeciesId } from "#enums/species-id"; +// biome-ignore lint/correctness/noUnusedImports: Used in a TSDoc comment +import type { Pokemon } from "#field/pokemon"; import { randSeedItem } from "./common"; /** @@ -126,7 +128,8 @@ export function getPokemonSpeciesForm(species: SpeciesId, formIndex: number): Po } /** - * Return whether two battler indices are allies + * Return whether two battler indices are considered allies. + * To instead check with {@linkcode Pokemon} objects, use {@linkcode Pokemon.isOpponent}. * @param a - First battler index * @param b - Second battler index * @returns Whether the two battler indices are allies. Always `false` if either index is `ATTACKER`. From 0112244de2a693f638b979166a28c2b122caef02 Mon Sep 17 00:00:00 2001 From: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com> Date: Mon, 18 Aug 2025 22:33:48 -0500 Subject: [PATCH 9/9] Make substitute use the move tag --- src/data/battler-tags.ts | 2 +- test/battler-tags/substitute.test.ts | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts index 0e272272f71..be725dd6fbd 100644 --- a/src/data/battler-tags.ts +++ b/src/data/battler-tags.ts @@ -3090,7 +3090,7 @@ export class SubstituteTag extends SerializableBattlerTag { constructor(sourceMove: MoveId, sourceId: number) { super( BattlerTagType.SUBSTITUTE, - [BattlerTagLapseType.PRE_MOVE, BattlerTagLapseType.AFTER_MOVE, BattlerTagLapseType.HIT], + [BattlerTagLapseType.MOVE, BattlerTagLapseType.AFTER_MOVE, BattlerTagLapseType.HIT], 0, sourceMove, sourceId, diff --git a/test/battler-tags/substitute.test.ts b/test/battler-tags/substitute.test.ts index 7ae60ad1408..fa8cb442d7e 100644 --- a/test/battler-tags/substitute.test.ts +++ b/test/battler-tags/substitute.test.ts @@ -142,7 +142,7 @@ describe("BattlerTag - SubstituteTag", () => { vi.spyOn(messages, "getPokemonNameWithAffix").mockReturnValue(""); }); - it("PRE_MOVE lapse triggers pre-move animation", async () => { + it("MOVE lapse triggers pre-move animation", async () => { const subject = new SubstituteTag(MoveId.SUBSTITUTE, mockPokemon.id); vi.spyOn(mockPokemon.scene as BattleScene, "triggerPokemonBattleAnim").mockImplementation( @@ -154,7 +154,7 @@ describe("BattlerTag - SubstituteTag", () => { vi.spyOn((mockPokemon.scene as BattleScene).phaseManager, "queueMessage").mockReturnValue(); - expect(subject.lapse(mockPokemon, BattlerTagLapseType.PRE_MOVE)).toBeTruthy(); + expect(subject.lapse(mockPokemon, BattlerTagLapseType.MOVE)).toBeTruthy(); expect(subject.sourceInFocus).toBeTruthy(); expect((mockPokemon.scene as BattleScene).triggerPokemonBattleAnim).toHaveBeenCalledTimes(1);