diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts index 5fcc831f447..be725dd6fbd 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,26 @@ 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.fail(); const idx = pokemon.getBattlerIndex(); @@ -1243,13 +1268,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 +2063,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 +2899,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 { @@ -3076,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, @@ -3134,7 +3148,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 +3306,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 +3361,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 +3554,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 +3575,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..13cded8834e --- /dev/null +++ b/src/data/moves/move-condition.ts @@ -0,0 +1,259 @@ +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, 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"; + +/** + * 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) { + 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 => 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 + getUserBenefitScore(user: Pokemon, _target: Pokemon, _move: Move): number { + return this.apply(user, _target, _move) ? 10 : -20; + } +} + +/** + * 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 + * ⚠️ 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 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 + ); +}); + +/** + * 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 + * (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)); + 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 + * + * @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-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 ffcd844224c..61455c676d3 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,12 +92,14 @@ import { getEnumValues } from "#utils/enums"; 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}. * 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,62 @@ 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 + * 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. + * + * 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 but before the move is recorded as the last move used) + */ + 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 + */ + private restrictions: MoveRestriction[] = []; /** The move's {@linkcode MoveFlags} */ private flags: number = 0; private nameAppend: string = ""; @@ -370,13 +426,71 @@ 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` + * @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 | 4 = 4): 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; + } + + /** + * 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 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 + */ + 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. + * @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`. + * @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, conditionSeq = 4): this { + if (typeof restriction === "function") { + this.restrictions.push(new MoveRestriction(restriction)); + if (alsoCondition) { + 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); + } return this; } @@ -579,6 +693,24 @@ 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. + * + * @returns `this` + * + * @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} + */ + 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} @@ -609,16 +741,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} @@ -697,13 +819,49 @@ 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, 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, move: Move): boolean { - return this.conditions.every(cond => cond.apply(user, target, move)); + 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)); + } + + + /** + * 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 +1631,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; } /** @@ -1629,28 +1795,80 @@ 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); + 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 + || areAllies(userBattlerIndex, ar.sourceBattlerIndex) + || (this.moveFilter && category !== this.moveFilter)) { + continue; + } + damage = ar.damage; + break; + } (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(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; + } + return true; + } + return false; } } @@ -3642,7 +3860,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); } } @@ -7915,31 +8133,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; @@ -8040,8 +8233,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 +8272,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; @@ -8281,6 +8421,7 @@ const MoveAttrs = Object.freeze({ TargetHalfHpDamageAttr, MatchHpAttr, CounterDamageAttr, + CounterRedirectAttr, LevelDamageAttr, RandomLevelDamageAttr, ModifiedDamageAttr, @@ -8471,7 +8612,6 @@ const MoveAttrs = Object.freeze({ DestinyBondAttr, AddBattlerTagIfBoostedAttr, StatusIfBoostedAttr, - LastResortAttr, VariableTargetAttr, AfterYouAttr, ForceLastAttr, @@ -8538,7 +8678,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 +8693,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), @@ -8674,7 +8814,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), @@ -8774,7 +8915,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) @@ -8827,7 +8969,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) @@ -8868,7 +9010,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,13 +9064,13 @@ 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) .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), @@ -8940,7 +9082,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) @@ -8996,7 +9138,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) @@ -9028,7 +9170,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) @@ -9064,6 +9206,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); @@ -9087,7 +9230,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), @@ -9109,7 +9252,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(), @@ -9144,7 +9287,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) @@ -9247,7 +9390,9 @@ 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) + .attr(CounterRedirectAttr, MoveCategory.SPECIAL) + .condition(counterAttackCondition_Special, 3) .target(MoveTarget.ATTACKER), new StatusMove(MoveId.PSYCH_UP, PokemonType.NORMAL, -1, 10, -1, 0, 2) .ignoresSubstitute() @@ -9276,21 +9421,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(), @@ -9329,7 +9474,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) @@ -9348,6 +9494,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) @@ -9362,7 +9510,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 @@ -9395,6 +9543,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 ]) @@ -9563,7 +9713,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 +9765,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) @@ -9658,8 +9809,9 @@ 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) + .attr(CounterRedirectAttr) + .condition(counterAttackCondition_Both, 3) .makesContact(false) .target(MoveTarget.ATTACKER), new AttackMove(MoveId.U_TURN, PokemonType.BUG, MoveCategory.PHYSICAL, 70, 100, 20, -1, 0, 4) @@ -9721,19 +9873,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) @@ -9745,7 +9893,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)), 3) + .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) @@ -9954,11 +10103,15 @@ 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) .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) @@ -9974,12 +10127,13 @@ 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))) .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() @@ -10028,9 +10182,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() @@ -10055,7 +10213,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(), @@ -10078,7 +10236,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 +10424,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), + .condition(new FirstMoveCondition(), 3) + .condition(failIfLastCondition, 3), 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) => { @@ -10333,7 +10491,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) }), @@ -10361,7 +10519,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() @@ -10389,7 +10547,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() @@ -10557,10 +10715,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), @@ -10616,7 +10774,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) @@ -10629,16 +10792,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), @@ -10683,7 +10851,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 */ @@ -10720,7 +10897,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) @@ -10764,7 +10944,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) @@ -10804,7 +10984,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,15 +11039,20 @@ 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, + 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, 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) @@ -10951,7 +11137,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) @@ -10998,7 +11185,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) @@ -11012,7 +11199,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 }) @@ -11029,7 +11216,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()), @@ -11047,7 +11234,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) @@ -11291,7 +11478,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) @@ -11320,10 +11507,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) @@ -11353,7 +11537,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) @@ -11429,23 +11614,22 @@ 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) })); }), 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() + .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) .attr(HighCritAttr) @@ -11467,10 +11651,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) @@ -11500,15 +11681,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(), @@ -11536,7 +11711,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, 3), new AttackMove(MoveId.MALIGNANT_CHAIN, PokemonType.POISON, MoveCategory.SPECIAL, 100, 100, 5, 50, 0, 9) .attr(StatusEffectAttr, StatusEffect.TOXIC) ); 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..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. @@ -6,11 +8,23 @@ 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 + * + * @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, 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. + */ PRE_MOVE, /** Tag activates immediately after the holder's move finishes triggering (successful or not). */ AFTER_MOVE, @@ -32,6 +46,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-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 6cdc1e5f8cc..7504d3c1e95 100644 --- a/src/enums/move-flags.ts +++ b/src/enums/move-flags.ts @@ -47,8 +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 << 19, } diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index e12485a7272..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 @@ -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", { @@ -3295,9 +3297,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, true) ?? [false, ""]; } showInfo(): void { @@ -4267,19 +4275,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 +4308,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 +4398,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); } /** @@ -5746,7 +5787,7 @@ export class PlayerPokemon extends Pokemon { return globalScene.getPlayerField().indexOf(this); } - getBattlerIndex(): BattlerIndex { + getBattlerIndex(): Exclude { return this.getFieldIndex(); } @@ -6398,7 +6439,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 +6449,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 +6507,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 +6566,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; @@ -6862,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 87c33a4334b..90da939bdd8 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,16 @@ 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, ignorePP, true)[0]); - canUse ||= useStruggle; - - if (!canUse) { - this.queueFightErrorMessage(playerPokemon, cursor); + if (!canUse && !useStruggle) { + console.error("Cannot use move:", reason); + 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..91e0fdb0ee6 100644 --- a/src/phases/move-phase.ts +++ b/src/phases/move-phase.ts @@ -8,9 +8,11 @@ import { getStatusEffectActivationText, getStatusEffectHealText } from "#data/st 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 +26,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 { Move, 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 +46,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 +92,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,27 +110,240 @@ export class MovePhase extends BattlePhase { return this.forcedLast; } + /** + * 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): + * 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 + return ( + this.checkSleep() || + this.checkFreeze() || + this.checkPP() || + this.checkValidity() || + this.checkTagCancel(BattlerTagType.TRUANT) || + this.checkPreUseInterrupt() || + this.checkTagCancel(BattlerTagType.FLINCHED) || + this.checkTagCancel(BattlerTagType.DISABLED) || + this.checkTagCancel(BattlerTagType.HEAL_BLOCK) || + this.checkTagCancel(BattlerTagType.THROAT_CHOPPED) || + this.checkGravity() || + this.checkTagCancel(BattlerTagType.TAUNT) || + this.checkTagCancel(BattlerTagType.IMPRISON) || + this.checkTagCancel(BattlerTagType.CONFUSED) || + this.checkPara() || + this.checkTagCancel(BattlerTagType.INFATUATED) + ); + } + + /** + * 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() + ); + } + + /** + * 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 + * - 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 + * + * After all checks, Powder causing the user to explode + */ + 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; + } 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); + } + return this.failed; + } + + /** + * Third failure check is from moves and abilities themselves + * + * @returns Whether the move failed + * + * @remarks + * - 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 { + /** + * 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 failedDueToTerrain = arena.isMoveTerrainCancelled(user, this.targets, move); + let failed = failsConditions || 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(failedDueToTerrain); + 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; } - this.pokemon.turnData.acted = true; + const user = this.pokemon; + + // Removing gigaton hammer always happens first + 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. + user.turnData.acted = true; + const useMode = this.useMode; + const ignoreStatus = isIgnoreStatus(useMode); + 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(); + return; + } + // If this is a follow-up move , at this point, we need to re-check a few conditions + + // 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(this.useMode)) { + if (isVirtual(useMode)) { this.pokemon.turnData.hitsLeft = -1; this.pokemon.turnData.hitCount = 0; } @@ -151,22 +359,41 @@ 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(); - this.resolvePreMoveStatusEffects(); + // Move is announced + this.showMoveText(); + // Stance change happens + const charging = this.move.getMove().isChargingMove() && !this.pokemon.getTag(BattlerTagType.CHARGING); + const move = this.move.getMove(); - this.lapsePreMoveAndMoveTags(); - - if (!(this.failed || this.cancelled)) { - this.resolveFinalPreMoveCancellationChecks(); + // 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; } - // Cancel, charge or use the move as applicable. - if (this.cancelled || this.failed) { + // 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.handlePreMoveFailures(); - } else if (this.move.getMove().isChargingMove() && !this.pokemon.getTag(BattlerTagType.CHARGING)) { + this.end(); + return; + } + + if (this.resolveFinalPreMoveCancellationChecks()) { + this.end(); + } + + if (charging) { this.chargeMove(); } else { this.useMove(); @@ -175,8 +402,11 @@ export class MovePhase extends BattlePhase { this.end(); } - /** Check for cancellation edge cases - no targets remaining, or {@linkcode MoveId.NONE} is in the queue */ - protected resolveFinalPreMoveCancellationChecks(): void { + /** + * Check for cancellation edge cases - no targets remaining + * @returns Whether the move fails + */ + protected resolveFinalPreMoveCancellationChecks(): boolean { const targets = this.getActiveTargetPokemon(); const moveQueue = this.pokemon.getMoveQueue(); @@ -184,10 +414,12 @@ 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(); + this.fail(); + return true; } + this.pokemon.lapseTags(BattlerTagLapseType.MOVE); + return false; } public getActiveTargetPokemon(): Pokemon[] { @@ -195,177 +427,290 @@ 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 + * @param msg - A custom message to display when curing the status effect (used for curing freeze due to move use) */ - 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, msg?: string): void { + const pokemon = this.pokemon; + // Freeze healed by move uses its own msg + globalScene.phaseManager.queueMessage(msg ?? 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; + } + + // For some reason, dancer will immediately wake its user from sleep when triggering + 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; + } + + // 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) { + 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 + .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) { + 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) && + // 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): boolean { + 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 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); - - // 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; - } - + 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], move); - const failedDueToWeather = globalScene.arena.isMoveWeatherCancelled(this.pokemon, move); - const failedDueToTerrain = globalScene.arena.isMoveTerrainCancelled(this.pokemon, this.targets, move); - 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 user = 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] }); - this.showMoveText(); - globalScene.phaseManager.unshiftNew( - "MoveEffectPhase", - this.pokemon.getBattlerIndex(), - this.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. @@ -373,7 +718,7 @@ export class MovePhase extends BattlePhase { const dancerModes: MoveUseMode[] = [MoveUseMode.INDIRECT, MoveUseMode.REFLECTED] as const; if (this.move.getMove().hasFlag(MoveFlags.DANCE_MOVE) && !dancerModes.includes(this.useMode)) { globalScene.getField(true).forEach(pokemon => { - applyAbAttrs("PostMoveUsedAbAttr", { pokemon, move: this.move, source: this.pokemon, targets: this.targets }); + applyAbAttrs("PostMoveUsedAbAttr", { pokemon, move: this.move, source: user, targets: targets }); }); } } @@ -381,11 +726,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(); @@ -407,10 +750,6 @@ export class MovePhase extends BattlePhase { }); } - if (showText) { - this.showMoveText(); - } - this.pokemon.pushMoveHistory({ move: this.move.moveId, targets: this.targets, @@ -424,9 +763,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); @@ -442,8 +779,8 @@ export class MovePhase extends BattlePhase { const move = this.move.getMove(); const targets = this.getActiveTargetPokemon(); - if (!move.applyConditions(this.pokemon, targets[0], move)) { - this.failMove(true); + if (!move.applyConditions(this.pokemon, targets[0])) { + this.failMove(); return; } @@ -506,6 +843,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) @@ -570,33 +908,21 @@ 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) { + console.log("%cSkipping counter attack target resolution", "color: blue"); return; } - // TODO: This should be covered in move conditions - if (this.pokemon.turnData.attacksReceived.length === 0) { + const targetHolder = new NumberHolder(BattlerIndex.ATTACKER); + + 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(); - this.showMoveText(); - this.showFailedText(); - return; - } - - 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; } } @@ -619,13 +945,6 @@ export class MovePhase extends BattlePhase { return; } - 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)); - } - 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..4b624d2669c 100644 --- a/src/utils/pokemon-utils.ts +++ b/src/utils/pokemon-utils.ts @@ -2,7 +2,10 @@ 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"; +// biome-ignore lint/correctness/noUnusedImports: Used in a TSDoc comment +import type { Pokemon } from "#field/pokemon"; import { randSeedItem } from "./common"; /** @@ -123,3 +126,20 @@ export function getPokemonSpeciesForm(species: SpeciesId, formIndex: number): Po } return retSpecies; } + +/** + * 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`. + */ +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/abilities/cud-chew.test.ts b/test/abilities/cud-chew.test.ts index f68141096eb..e62a8897e02 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 }, @@ -121,7 +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(); @@ -196,10 +196,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/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); 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", + ); + }); +}); 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(); 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]);