mika/pokerogue
1
0
Fork 0
mirror of https://github.com/pagefaultgames/pokerogue.git synced 2025-06-29 04:52:43 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'fix-rattled-speed-stat-increase-delay' into fix-rattled-speed-stat-increase-delay

Browse Source
This commit is contained in:
Dobin Shin 2025-06-07 20:53:57 +09:00 committed by GitHub
commit 7925ff39da
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
119 changed files with 906 additions and 648 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lefthook.yml
View File

@ -9,6 +9,11 @@ pre-commit:
- rebase
post-merge:
commands:
update-submodules:
run: git submodule update --init --recursive
post-checkout:
commands:
update-submodules:
run: git submodule update --init --recursive

BIN
public/images/egg/gacha_legendary.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.0 KiB

After

Width:  |  Height:  |  Size: 3.7 KiB

286
src/@types/phase-types.ts Normal file
View File

@ -0,0 +1,286 @@
import type { MoveAnim } from "#app/data/battle-anims";
import type { AddEnemyBuffModifierPhase } from "#app/phases/add-enemy-buff-modifier-phase";
import type { AttemptCapturePhase } from "#app/phases/attempt-capture-phase";
import type { AttemptRunPhase } from "#app/phases/attempt-run-phase";
import type { BattleEndPhase } from "#app/phases/battle-end-phase";
import type { BerryPhase } from "#app/phases/berry-phase";
import type { CheckStatusEffectPhase } from "#app/phases/check-status-effect-phase";
import type { CheckSwitchPhase } from "#app/phases/check-switch-phase";
import type { CommandPhase } from "#app/phases/command-phase";
import type { CommonAnimPhase } from "#app/phases/common-anim-phase";
import type { DamageAnimPhase } from "#app/phases/damage-anim-phase";
import type { EggHatchPhase } from "#app/phases/egg-hatch-phase";
import type { EggLapsePhase } from "#app/phases/egg-lapse-phase";
import type { EggSummaryPhase } from "#app/phases/egg-summary-phase";
import type { EncounterPhase } from "#app/phases/encounter-phase";
import type { EndCardPhase } from "#app/phases/end-card-phase";
import type { EndEvolutionPhase } from "#app/phases/end-evolution-phase";
import type { EnemyCommandPhase } from "#app/phases/enemy-command-phase";
import type { EvolutionPhase } from "#app/phases/evolution-phase";
import type { ExpPhase } from "#app/phases/exp-phase";
import type { FaintPhase } from "#app/phases/faint-phase";
import type { FormChangePhase } from "#app/phases/form-change-phase";
import type { GameOverModifierRewardPhase } from "#app/phases/game-over-modifier-reward-phase";
import type { GameOverPhase } from "#app/phases/game-over-phase";
import type { HideAbilityPhase } from "#app/phases/hide-ability-phase";
import type { HidePartyExpBarPhase } from "#app/phases/hide-party-exp-bar-phase";
import type { LearnMovePhase } from "#app/phases/learn-move-phase";
import type { LevelCapPhase } from "#app/phases/level-cap-phase";
import type { LevelUpPhase } from "#app/phases/level-up-phase";
import type { LoadMoveAnimPhase } from "#app/phases/load-move-anim-phase";
import type { LoginPhase } from "#app/phases/login-phase";
import type { MessagePhase } from "#app/phases/message-phase";
import type { ModifierRewardPhase } from "#app/phases/modifier-reward-phase";
import type { MoneyRewardPhase } from "#app/phases/money-reward-phase";
import type { MoveAnimPhase } from "#app/phases/move-anim-phase";
import type { MoveChargePhase } from "#app/phases/move-charge-phase";
import type { MoveEffectPhase } from "#app/phases/move-effect-phase";
import type { MoveEndPhase } from "#app/phases/move-end-phase";
import type { MoveHeaderPhase } from "#app/phases/move-header-phase";
import type { MovePhase } from "#app/phases/move-phase";
import type {
MysteryEncounterPhase,
MysteryEncounterOptionSelectedPhase,
MysteryEncounterBattlePhase,
MysteryEncounterRewardsPhase,
PostMysteryEncounterPhase,
MysteryEncounterBattleStartCleanupPhase,
} from "#app/phases/mystery-encounter-phases";
import type { NewBattlePhase } from "#app/phases/new-battle-phase";
import type { NewBiomeEncounterPhase } from "#app/phases/new-biome-encounter-phase";
import type { NextEncounterPhase } from "#app/phases/next-encounter-phase";
import type { ObtainStatusEffectPhase } from "#app/phases/obtain-status-effect-phase";
import type { PartyExpPhase } from "#app/phases/party-exp-phase";
import type { PartyHealPhase } from "#app/phases/party-heal-phase";
import type { PokemonAnimPhase } from "#app/phases/pokemon-anim-phase";
import type { PokemonHealPhase } from "#app/phases/pokemon-heal-phase";
import type { PokemonTransformPhase } from "#app/phases/pokemon-transform-phase";
import type { PostGameOverPhase } from "#app/phases/post-game-over-phase";
import type { PostSummonPhase } from "#app/phases/post-summon-phase";
import type { PostTurnStatusEffectPhase } from "#app/phases/post-turn-status-effect-phase";
import type { QuietFormChangePhase } from "#app/phases/quiet-form-change-phase";
import type { ReloadSessionPhase } from "#app/phases/reload-session-phase";
import type { ResetStatusPhase } from "#app/phases/reset-status-phase";
import type { ReturnPhase } from "#app/phases/return-phase";
import type { RevivalBlessingPhase } from "#app/phases/revival-blessing-phase";
import type { RibbonModifierRewardPhase } from "#app/phases/ribbon-modifier-reward-phase";
import type { ScanIvsPhase } from "#app/phases/scan-ivs-phase";
import type { SelectBiomePhase } from "#app/phases/select-biome-phase";
import type { SelectChallengePhase } from "#app/phases/select-challenge-phase";
import type { SelectGenderPhase } from "#app/phases/select-gender-phase";
import type { SelectModifierPhase } from "#app/phases/select-modifier-phase";
import type { SelectStarterPhase } from "#app/phases/select-starter-phase";
import type { SelectTargetPhase } from "#app/phases/select-target-phase";
import type { ShinySparklePhase } from "#app/phases/shiny-sparkle-phase";
import type { ShowAbilityPhase } from "#app/phases/show-ability-phase";
import type { ShowPartyExpBarPhase } from "#app/phases/show-party-exp-bar-phase";
import type { ShowTrainerPhase } from "#app/phases/show-trainer-phase";
import type { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
import type { SummonMissingPhase } from "#app/phases/summon-missing-phase";
import type { SummonPhase } from "#app/phases/summon-phase";
import type { SwitchBiomePhase } from "#app/phases/switch-biome-phase";
import type { SwitchPhase } from "#app/phases/switch-phase";
import type { SwitchSummonPhase } from "#app/phases/switch-summon-phase";
import type { TeraPhase } from "#app/phases/tera-phase";
import type { TitlePhase } from "#app/phases/title-phase";
import type { ToggleDoublePositionPhase } from "#app/phases/toggle-double-position-phase";
import type { TrainerVictoryPhase } from "#app/phases/trainer-victory-phase";
import type { TurnEndPhase } from "#app/phases/turn-end-phase";
import type { TurnInitPhase } from "#app/phases/turn-init-phase";
import type { TurnStartPhase } from "#app/phases/turn-start-phase";
import type { UnavailablePhase } from "#app/phases/unavailable-phase";
import type { UnlockPhase } from "#app/phases/unlock-phase";
import type { VictoryPhase } from "#app/phases/victory-phase";
import type { WeatherEffectPhase } from "#app/phases/weather-effect-phase";
export type PhaseClass =
| typeof AddEnemyBuffModifierPhase
| typeof AttemptCapturePhase
| typeof AttemptRunPhase
| typeof BattleEndPhase
| typeof BerryPhase
| typeof CheckStatusEffectPhase
| typeof CheckSwitchPhase
| typeof CommandPhase
| typeof CommonAnimPhase
| typeof DamageAnimPhase
| typeof EggHatchPhase
| typeof EggLapsePhase
| typeof EggSummaryPhase
| typeof EncounterPhase
| typeof EndCardPhase
| typeof EndEvolutionPhase
| typeof EnemyCommandPhase
| typeof EvolutionPhase
| typeof FormChangePhase
| typeof ExpPhase
| typeof FaintPhase
| typeof FormChangePhase
| typeof GameOverPhase
| typeof GameOverModifierRewardPhase
| typeof HideAbilityPhase
| typeof HidePartyExpBarPhase
| typeof LearnMovePhase
| typeof LevelUpPhase
| typeof LevelCapPhase
| typeof LoadMoveAnimPhase
| typeof LoginPhase
| typeof MessagePhase
| typeof ModifierRewardPhase
| typeof MoneyRewardPhase
| typeof MoveAnimPhase
| typeof MoveChargePhase
| typeof MoveEffectPhase
| typeof MoveEndPhase
| typeof MoveHeaderPhase
| typeof MovePhase
| typeof MysteryEncounterPhase
| typeof MysteryEncounterOptionSelectedPhase
| typeof MysteryEncounterBattlePhase
| typeof MysteryEncounterRewardsPhase
| typeof MysteryEncounterBattleStartCleanupPhase
| typeof MysteryEncounterRewardsPhase
| typeof PostMysteryEncounterPhase
| typeof NewBattlePhase
| typeof NewBiomeEncounterPhase
| typeof NextEncounterPhase
| typeof ObtainStatusEffectPhase
| typeof PartyExpPhase
| typeof PartyHealPhase
| typeof PokemonAnimPhase
| typeof PokemonHealPhase
| typeof PokemonTransformPhase
| typeof PostGameOverPhase
| typeof PostSummonPhase
| typeof PostTurnStatusEffectPhase
| typeof QuietFormChangePhase
| typeof ReloadSessionPhase
| typeof ResetStatusPhase
| typeof ReturnPhase
| typeof RevivalBlessingPhase
| typeof RibbonModifierRewardPhase
| typeof ScanIvsPhase
| typeof SelectBiomePhase
| typeof SelectChallengePhase
| typeof SelectGenderPhase
| typeof SelectModifierPhase
| typeof SelectStarterPhase
| typeof SelectTargetPhase
| typeof ShinySparklePhase
| typeof ShowAbilityPhase
| typeof ShowTrainerPhase
| typeof ShowPartyExpBarPhase
| typeof StatStageChangePhase
| typeof SummonMissingPhase
| typeof SummonPhase
| typeof SwitchBiomePhase
| typeof SwitchPhase
| typeof SwitchSummonPhase
| typeof TeraPhase
| typeof TitlePhase
| typeof ToggleDoublePositionPhase
| typeof TrainerVictoryPhase
| typeof TurnEndPhase
| typeof TurnInitPhase
| typeof TurnStartPhase
| typeof UnavailablePhase
| typeof UnlockPhase
| typeof VictoryPhase
| typeof WeatherEffectPhase;
/** Typescript map used to map a string phase to the actual phase type */
export type PhaseMap = {
AddEnemyBuffModifierPhase: AddEnemyBuffModifierPhase;
AttemptCapturePhase: AttemptCapturePhase;
AttemptRunPhase: AttemptRunPhase;
BattleEndPhase: BattleEndPhase;
BerryPhase: BerryPhase;
CheckStatusEffectPhase: CheckStatusEffectPhase;
CheckSwitchPhase: CheckSwitchPhase;
CommandPhase: CommandPhase;
CommonAnimPhase: CommonAnimPhase;
DamageAnimPhase: DamageAnimPhase;
EggHatchPhase: EggHatchPhase;
EggLapsePhase: EggLapsePhase;
EggSummaryPhase: EggSummaryPhase;
EncounterPhase: EncounterPhase;
EndCardPhase: EndCardPhase;
EndEvolutionPhase: EndEvolutionPhase;
EnemyCommandPhase: EnemyCommandPhase;
EvolutionPhase: EvolutionPhase;
ExpPhase: ExpPhase;
FaintPhase: FaintPhase;
FormChangePhase: FormChangePhase;
GameOverPhase: GameOverPhase;
GameOverModifierRewardPhase: GameOverModifierRewardPhase;
HideAbilityPhase: HideAbilityPhase;
HidePartyExpBarPhase: HidePartyExpBarPhase;
LearnMovePhase: LearnMovePhase;
LevelCapPhase: LevelCapPhase;
LevelUpPhase: LevelUpPhase;
LoadMoveAnimPhase: LoadMoveAnimPhase;
LoginPhase: LoginPhase;
MessagePhase: MessagePhase;
ModifierRewardPhase: ModifierRewardPhase;
MoneyRewardPhase: MoneyRewardPhase;
MoveAnimPhase: MoveAnimPhase<MoveAnim>;
MoveChargePhase: MoveChargePhase;
MoveEffectPhase: MoveEffectPhase;
MoveEndPhase: MoveEndPhase;
MoveHeaderPhase: MoveHeaderPhase;
MovePhase: MovePhase;
MysteryEncounterPhase: MysteryEncounterPhase;
MysteryEncounterOptionSelectedPhase: MysteryEncounterOptionSelectedPhase;
MysteryEncounterBattlePhase: MysteryEncounterBattlePhase;
MysteryEncounterBattleStartCleanupPhase: MysteryEncounterBattleStartCleanupPhase;
MysteryEncounterRewardsPhase: MysteryEncounterRewardsPhase;
PostMysteryEncounterPhase: PostMysteryEncounterPhase;
NewBattlePhase: NewBattlePhase;
NewBiomeEncounterPhase: NewBiomeEncounterPhase;
NextEncounterPhase: NextEncounterPhase;
ObtainStatusEffectPhase: ObtainStatusEffectPhase;
PartyExpPhase: PartyExpPhase;
PartyHealPhase: PartyHealPhase;
PokemonAnimPhase: PokemonAnimPhase;
PokemonHealPhase: PokemonHealPhase;
PokemonTransformPhase: PokemonTransformPhase;
PostGameOverPhase: PostGameOverPhase;
PostSummonPhase: PostSummonPhase;
PostTurnStatusEffectPhase: PostTurnStatusEffectPhase;
QuietFormChangePhase: QuietFormChangePhase;
ReloadSessionPhase: ReloadSessionPhase;
ResetStatusPhase: ResetStatusPhase;
ReturnPhase: ReturnPhase;
RevivalBlessingPhase: RevivalBlessingPhase;
RibbonModifierRewardPhase: RibbonModifierRewardPhase;
ScanIvsPhase: ScanIvsPhase;
SelectBiomePhase: SelectBiomePhase;
SelectChallengePhase: SelectChallengePhase;
SelectGenderPhase: SelectGenderPhase;
SelectModifierPhase: SelectModifierPhase;
SelectStarterPhase: SelectStarterPhase;
SelectTargetPhase: SelectTargetPhase;
ShinySparklePhase: ShinySparklePhase;
ShowAbilityPhase: ShowAbilityPhase;
ShowPartyExpBarPhase: ShowPartyExpBarPhase;
ShowTrainerPhase: ShowTrainerPhase;
StatStageChangePhase: StatStageChangePhase;
SummonMissingPhase: SummonMissingPhase;
SummonPhase: SummonPhase;
SwitchBiomePhase: SwitchBiomePhase;
SwitchPhase: SwitchPhase;
SwitchSummonPhase: SwitchSummonPhase;
TeraPhase: TeraPhase;
TitlePhase: TitlePhase;
ToggleDoublePositionPhase: ToggleDoublePositionPhase;
TrainerVictoryPhase: TrainerVictoryPhase;
TurnEndPhase: TurnEndPhase;
TurnInitPhase: TurnInitPhase;
TurnStartPhase: TurnStartPhase;
UnavailablePhase: UnavailablePhase;
UnlockPhase: UnlockPhase;
VictoryPhase: VictoryPhase;
WeatherEffectPhase: WeatherEffectPhase;
};
export type PhaseString = keyof PhaseMap;

45
src/battle-scene.ts
View File

@ -145,7 +145,7 @@ import { LoadingScene } from "#app/loading-scene";
import { LevelCapPhase } from "#app/phases/level-cap-phase";
import { LoginPhase } from "#app/phases/login-phase";
import { MessagePhase } from "#app/phases/message-phase";
import { MovePhase } from "#app/phases/move-phase";
import type { MovePhase } from "#app/phases/move-phase";
import { NewBiomeEncounterPhase } from "#app/phases/new-biome-encounter-phase";
import { NextEncounterPhase } from "#app/phases/next-encounter-phase";
import { PokemonAnimPhase } from "#app/phases/pokemon-anim-phase";
@ -153,7 +153,6 @@ import { QuietFormChangePhase } from "#app/phases/quiet-form-change-phase";
import { ReturnPhase } from "#app/phases/return-phase";
import { ShowTrainerPhase } from "#app/phases/show-trainer-phase";
import { SummonPhase } from "#app/phases/summon-phase";
import { SwitchPhase } from "#app/phases/switch-phase";
import { TitlePhase } from "#app/phases/title-phase";
import { ToggleDoublePositionPhase } from "#app/phases/toggle-double-position-phase";
import { TurnInitPhase } from "#app/phases/turn-init-phase";
@ -901,7 +900,7 @@ export default class BattleScene extends SceneBase {
do {
targetingMovePhase = this.findPhase(
mp =>
mp instanceof MovePhase &&
mp.is("MovePhase") &&
mp.targets.length === 1 &&
mp.targets[0] === removedPokemon.getBattlerIndex() &&
mp.pokemon.isPlayer() !== allyPokemon.isPlayer(),
@ -1450,7 +1449,7 @@ export default class BattleScene extends SceneBase {
}
if (lastBattle?.double && !newDouble) {
this.tryRemovePhase(p => p instanceof SwitchPhase);
this.tryRemovePhase((p: Phase) => p.is("SwitchPhase"));
for (const p of this.getPlayerField()) {
p.lapseTag(BattlerTagType.COMMANDED);
}
@ -1588,9 +1587,7 @@ export default class BattleScene extends SceneBase {
return 0;
}
const isEggPhase: boolean = ["EggLapsePhase", "EggHatchPhase"].includes(
this.getCurrentPhase()?.constructor.name ?? "",
);
const isEggPhase: boolean = ["EggLapsePhase", "EggHatchPhase"].includes(this.getCurrentPhase()?.phaseName ?? "");
if (
// Give trainers with specialty types an appropriately-typed form for Wormadam, Rotom, Arceus, Oricorio, Silvally, or Paldean Tauros.
@ -3569,21 +3566,18 @@ export default class BattleScene extends SceneBase {
gameMode: this.currentBattle ? this.gameMode.getName() : "Title",
biome: this.currentBattle ? getBiomeName(this.arena.biomeType) : "",
wave: this.currentBattle?.waveIndex ?? 0,
party: this.party
? this.party.map(p => {
return {
name: p.name,
form: p.getFormKey(),
types: p.getTypes().map(type => PokemonType[type]),
teraType: PokemonType[p.getTeraType()],
isTerastallized: p.isTerastallized,
level: p.level,
currentHP: p.hp,
maxHP: p.getMaxHp(),
status: p.status?.effect ? StatusEffect[p.status.effect] : "",
};
})
: [],
party:
this.party?.map(p => ({
name: p.name,
form: p.getFormKey(),
types: p.getTypes().map(type => PokemonType[type]),
teraType: PokemonType[p.getTeraType()],
isTerastallized: p.isTerastallized,
level: p.level,
currentHP: p.hp,
maxHP: p.getMaxHp(),
status: p.status?.effect ? StatusEffect[p.status.effect] : "",
})) ?? [], // TODO: review if this can be nullish
modeChain: this.ui?.getModeChain() ?? [],
};
(window as any).gameInfo = gameInfo;
@ -3966,16 +3960,13 @@ export default class BattleScene extends SceneBase {
if (previousEncounter !== null && encounterType === previousEncounter) {
return false;
}
if (
return !(
this.mysteryEncounterSaveData.encounteredEvents.length > 0 &&
encounterCandidate.maxAllowedEncounters &&
encounterCandidate.maxAllowedEncounters > 0 &&
this.mysteryEncounterSaveData.encounteredEvents.filter(e => e.type === encounterType).length >=
encounterCandidate.maxAllowedEncounters
) {
return false;
}
return true;
);
})
.map(m => allMysteryEncounters[m]);
// Decrement tier

5
src/configs/inputs/configHandler.ts
View File

@ -197,10 +197,7 @@ export function canIAssignThisKey(config, key) {
export function canIOverrideThisSetting(config, settingName) {
const key = getKeyWithSettingName(config, settingName);
// || isTheLatestBind(config, settingName) no longer needed since action and cancel are protected
if (config.blacklist?.includes(key)) {
return false;
}
return true;
return !config.blacklist?.includes(key);
}
export function canIDeleteThisKey(config, key) {

47
src/data/abilities/ability.ts
View File

@ -2130,6 +2130,7 @@ export class PostIntimidateStatStageChangeAbAttr extends AbAttr {
if (!simulated) {
globalScene.unshiftPhase(new StatStageChangePhase(pokemon.getBattlerIndex(), false, this.stats, this.stages));
}
cancelled.value = this.overwrites;
}
}
@ -2649,11 +2650,7 @@ export class PostSummonCopyAllyStatsAbAttr extends PostSummonAbAttr {
}
const ally = pokemon.getAlly();
if (isNullOrUndefined(ally) || ally.getStatStages().every(s => s === 0)) {
return false;
}
return true;
return !(isNullOrUndefined(ally) || ally.getStatStages().every(s => s === 0));
}
override applyPostSummon(pokemon: Pokemon, passive: boolean, simulated: boolean, args: any[]): void {
@ -2719,11 +2716,7 @@ export class PostSummonTransformAbAttr extends PostSummonAbAttr {
}
// transforming from or into fusion pokemon causes various problems (including crashes and save corruption)
if (this.getTarget(targets).fusionSpecies || pokemon.fusionSpecies) {
return false;
}
return true;
return !(this.getTarget(targets).fusionSpecies || pokemon.fusionSpecies);
}
override applyPostSummon(pokemon: Pokemon, _passive: boolean, simulated: boolean, _args: any[]): void {
@ -2824,7 +2817,7 @@ export class CommanderAbAttr extends AbAttr {
// Apply boosts from this effect to the ally Dondozo
pokemon.getAlly()?.addTag(BattlerTagType.COMMANDED, 0, MoveId.NONE, pokemon.id);
// Cancel the source Pokemon's next move (if a move is queued)
globalScene.tryRemovePhase((phase) => phase instanceof MovePhase && phase.pokemon === pokemon);
globalScene.tryRemovePhase((phase) => phase.is("MovePhase") && phase.pokemon === pokemon);
}
}
}
@ -3540,10 +3533,7 @@ export class BlockStatusDamageAbAttr extends AbAttr {
}
override canApply(pokemon: Pokemon, passive: boolean, simulated: boolean, args: any[]): boolean {
if (pokemon.status && this.effects.includes(pokemon.status.effect)) {
return true;
}
return false;
return !!pokemon.status?.effect && this.effects.includes(pokemon.status.effect);
}
/**
@ -4799,11 +4789,7 @@ export class PostFaintContactDamageAbAttr extends PostFaintAbAttr {
const diedToDirectDamage = move !== undefined && attacker !== undefined && move.doesFlagEffectApply({flag: MoveFlags.MAKES_CONTACT, user: attacker, target: pokemon});
const cancelled = new BooleanHolder(false);
globalScene.getField(true).map(p => applyAbAttrs(FieldPreventExplosiveMovesAbAttr, p, cancelled, simulated));
if (!diedToDirectDamage || cancelled.value || attacker!.hasAbilityWithAttr(BlockNonDirectDamageAbAttr)) {
return false;
}
return true;
return !(!diedToDirectDamage || cancelled.value || attacker!.hasAbilityWithAttr(BlockNonDirectDamageAbAttr));
}
override applyPostFaint(pokemon: Pokemon, passive: boolean, simulated: boolean, attacker?: Pokemon, move?: Move, hitResult?: HitResult, ...args: any[]): void {
@ -6504,12 +6490,7 @@ export function initAbilities() {
new Ability(AbilityId.INTIMIDATE, 3)
.attr(PostSummonStatStageChangeAbAttr, [ Stat.ATK ], -1, false, true),
new Ability(AbilityId.SHADOW_TAG, 3)
.attr(ArenaTrapAbAttr, (user, target) => {
if (target.hasAbility(AbilityId.SHADOW_TAG)) {
return false;
}
return true;
}),
.attr(ArenaTrapAbAttr, (_user, target) => !target.hasAbility(AbilityId.SHADOW_TAG)),
new Ability(AbilityId.ROUGH_SKIN, 3)
.attr(PostDefendContactDamageAbAttr, 8)
.bypassFaint(),
@ -6569,10 +6550,7 @@ export function initAbilities() {
.ignorable(),
new Ability(AbilityId.MAGNET_PULL, 3)
.attr(ArenaTrapAbAttr, (user, target) => {
if (target.getTypes(true).includes(PokemonType.STEEL) || (target.getTypes(true).includes(PokemonType.STELLAR) && target.getTypes().includes(PokemonType.STEEL))) {
return true;
}
return false;
return target.getTypes(true).includes(PokemonType.STEEL) || (target.getTypes(true).includes(PokemonType.STELLAR) && target.getTypes().includes(PokemonType.STEEL));
}),
new Ability(AbilityId.SOUNDPROOF, 3)
.attr(MoveImmunityAbAttr, (pokemon, attacker, move) => pokemon !== attacker && move.hasFlag(MoveFlags.SOUND_BASED))
@ -6650,12 +6628,7 @@ export function initAbilities() {
.attr(PostSummonWeatherChangeAbAttr, WeatherType.SUNNY)
.attr(PostBiomeChangeWeatherChangeAbAttr, WeatherType.SUNNY),
new Ability(AbilityId.ARENA_TRAP, 3)
.attr(ArenaTrapAbAttr, (user, target) => {
if (target.isGrounded()) {
return true;
}
return false;
})
.attr(ArenaTrapAbAttr, (user, target) => target.isGrounded())
.attr(DoubleBattleChanceAbAttr),
new Ability(AbilityId.VITAL_SPIRIT, 3)
.attr(StatusEffectImmunityAbAttr, StatusEffect.SLEEP)
@ -6893,7 +6866,7 @@ export function initAbilities() {
.ignorable(),
new Ability(AbilityId.ANALYTIC, 5)
.attr(MovePowerBoostAbAttr, (user, target, move) => {
const movePhase = globalScene.findPhase((phase) => phase instanceof MovePhase && phase.pokemon.id !== user?.id);
const movePhase = globalScene.findPhase((phase) => phase.is("MovePhase") && phase.pokemon.id !== user?.id);
return isNullOrUndefined(movePhase);
}, 1.3),
new Ability(AbilityId.ILLUSION, 5)

2
src/data/arena-tag.ts
View File

@ -383,7 +383,7 @@ const QuickGuardConditionFunc: ProtectConditionFunc = (_arena, moveId) => {
const move = allMoves[moveId];
const effectPhase = globalScene.getCurrentPhase();
if (effectPhase instanceof MoveEffectPhase) {
if (effectPhase?.is("MoveEffectPhase")) {
const attacker = effectPhase.getUserPokemon();
if (attacker) {
return move.getPriority(attacker) > 0;

45
src/data/battler-tags.ts
View File

@ -28,7 +28,7 @@ import type Pokemon from "#app/field/pokemon";
import { HitResult, MoveResult } from "#app/field/pokemon";
import { getPokemonNameWithAffix } from "#app/messages";
import { CommonAnimPhase } from "#app/phases/common-anim-phase";
import { MoveEffectPhase } from "#app/phases/move-effect-phase";
import type { MoveEffectPhase } from "#app/phases/move-effect-phase";
import { MovePhase } from "#app/phases/move-phase";
import { PokemonHealPhase } from "#app/phases/pokemon-heal-phase";
import type { StatStageChangeCallback } from "#app/phases/stat-stage-change-phase";
@ -553,9 +553,9 @@ export class ShellTrapTag extends BattlerTag {
// Trap should only be triggered by opponent's Physical moves
if (phaseData?.move.category === MoveCategory.PHYSICAL && pokemon.isOpponent(phaseData.attacker)) {
const shellTrapPhaseIndex = globalScene.phaseQueue.findIndex(
phase => phase instanceof MovePhase && phase.pokemon === pokemon,
phase => phase.is("MovePhase") && phase.pokemon === pokemon,
);
const firstMovePhaseIndex = globalScene.phaseQueue.findIndex(phase => phase instanceof MovePhase);
const firstMovePhaseIndex = globalScene.phaseQueue.findIndex(phase => phase.is("MovePhase"));
// Only shift MovePhase timing if it's not already next up
if (shellTrapPhaseIndex !== -1 && shellTrapPhaseIndex !== firstMovePhaseIndex) {
@ -1027,7 +1027,7 @@ export class PowderTag extends BattlerTag {
lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {
if (lapseType === BattlerTagLapseType.PRE_MOVE) {
const movePhase = globalScene.getCurrentPhase();
if (movePhase instanceof MovePhase) {
if (movePhase?.is("MovePhase")) {
const move = movePhase.move.getMove();
const weather = globalScene.arena.weather;
if (
@ -1183,13 +1183,13 @@ export class EncoreTag extends MoveRestrictionBattlerTag {
}),
);
const movePhase = globalScene.findPhase(m => m instanceof MovePhase && m.pokemon === pokemon);
const movePhase = globalScene.findPhase(m => m.is("MovePhase") && m.pokemon === pokemon);
if (movePhase) {
const movesetMove = pokemon.getMoveset().find(m => m.moveId === this.moveId);
if (movesetMove) {
const lastMove = pokemon.getLastXMoves(1)[0];
globalScene.tryReplacePhase(
m => m instanceof MovePhase && m.pokemon === pokemon,
m => m.is("MovePhase") && m.pokemon === pokemon,
new MovePhase(pokemon, lastMove.targets ?? [], movesetMove),
);
}
@ -1203,10 +1203,7 @@ export class EncoreTag extends MoveRestrictionBattlerTag {
override lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {
if (lapseType === BattlerTagLapseType.CUSTOM) {
const encoredMove = pokemon.getMoveset().find(m => m.moveId === this.moveId);
if (encoredMove && encoredMove?.getPpRatio() > 0) {
return true;
}
return false;
return !isNullOrUndefined(encoredMove) && encoredMove.getPpRatio() > 0;
}
return super.lapse(pokemon, lapseType);
}
@ -1218,10 +1215,7 @@ export class EncoreTag extends MoveRestrictionBattlerTag {
* @returns `true` if the move does not match with the moveId stored and as a result, restricted
*/
override isMoveRestricted(move: MoveId, _user?: Pokemon): boolean {
if (move !== this.moveId) {
return true;
}
return false;
return move !== this.moveId;
}
override selectionDeniedText(_pokemon: Pokemon, move: MoveId): string {
@ -1624,7 +1618,7 @@ export class ProtectedTag extends BattlerTag {
// Stop multi-hit moves early
const effectPhase = globalScene.getCurrentPhase();
if (effectPhase instanceof MoveEffectPhase) {
if (effectPhase?.is("MoveEffectPhase")) {
effectPhase.stopMultiHit(pokemon);
}
return true;
@ -2646,7 +2640,7 @@ export class GulpMissileTag extends BattlerTag {
}
const moveEffectPhase = globalScene.getCurrentPhase();
if (moveEffectPhase instanceof MoveEffectPhase) {
if (moveEffectPhase?.is("MoveEffectPhase")) {
const attacker = moveEffectPhase.getUserPokemon();
if (!attacker) {
@ -2768,10 +2762,7 @@ export class HealBlockTag extends MoveRestrictionBattlerTag {
* @returns `true` if the move has a TRIAGE_MOVE flag and is a status move
*/
override isMoveRestricted(move: MoveId): boolean {
if (allMoves[move].hasFlag(MoveFlags.TRIAGE_MOVE) && allMoves[move].category === MoveCategory.STATUS) {
return true;
}
return false;
return allMoves[move].hasFlag(MoveFlags.TRIAGE_MOVE) && allMoves[move].category === MoveCategory.STATUS;
}
/**
@ -2785,10 +2776,7 @@ export class HealBlockTag extends MoveRestrictionBattlerTag {
override isMoveTargetRestricted(move: MoveId, user: Pokemon, target: Pokemon) {
const moveCategory = new NumberHolder(allMoves[move].category);
applyMoveAttrs(StatusCategoryOnAllyAttr, user, target, allMoves[move], moveCategory);
if (allMoves[move].hasAttr(HealOnAllyAttr) && moveCategory.value === MoveCategory.STATUS) {
return true;
}
return false;
return allMoves[move].hasAttr(HealOnAllyAttr) && moveCategory.value === MoveCategory.STATUS;
}
/**
@ -3004,7 +2992,7 @@ export class SubstituteTag extends BattlerTag {
/** If the Substitute redirects damage, queue a message to indicate it. */
onHit(pokemon: Pokemon): void {
const moveEffectPhase = globalScene.getCurrentPhase();
if (moveEffectPhase instanceof MoveEffectPhase) {
if (moveEffectPhase?.is("MoveEffectPhase")) {
const attacker = moveEffectPhase.getUserPokemon();
if (!attacker) {
return;
@ -3126,10 +3114,7 @@ export class TormentTag extends MoveRestrictionBattlerTag {
const moveObj = allMoves[lastMove.move];
const isUnaffected = moveObj.hasAttr(ConsecutiveUseDoublePowerAttr) || user.getTag(BattlerTagType.FRENZY);
const validLastMoveResult = lastMove.result === MoveResult.SUCCESS || lastMove.result === MoveResult.MISS;
if (lastMove.move === move && validLastMoveResult && lastMove.move !== MoveId.STRUGGLE && !isUnaffected) {
return true;
}
return false;
return lastMove.move === move && validLastMoveResult && lastMove.move !== MoveId.STRUGGLE && !isUnaffected;
}
override selectionDeniedText(pokemon: Pokemon, _move: MoveId): string {
@ -3693,7 +3678,7 @@ export function loadBattlerTag(source: BattlerTag | any): BattlerTag {
*/
function getMoveEffectPhaseData(_pokemon: Pokemon): { phase: MoveEffectPhase; attacker: Pokemon; move: Move } | null {
const phase = globalScene.getCurrentPhase();
if (phase instanceof MoveEffectPhase) {
if (phase?.is("MoveEffectPhase")) {
return {
phase: phase,
attacker: phase.getPokemon(),

29
src/data/moves/move.ts
View File

@ -3109,7 +3109,7 @@ export class AwaitCombinedPledgeAttr extends OverrideMoveEffectAttr {
const overridden = args[0] as BooleanHolder;
const allyMovePhase = globalScene.findPhase<MovePhase>((phase) => phase instanceof MovePhase && phase.pokemon.isPlayer() === user.isPlayer());
const allyMovePhase = globalScene.findPhase<MovePhase>((phase) => phase.is("MovePhase") && phase.pokemon.isPlayer() === user.isPlayer());
if (allyMovePhase) {
const allyMove = allyMovePhase.move.getMove();
if (allyMove !== move && allyMove.hasAttr(AwaitCombinedPledgeAttr)) {
@ -3123,7 +3123,7 @@ export class AwaitCombinedPledgeAttr extends OverrideMoveEffectAttr {
// Move the ally's MovePhase (if needed) so that the ally moves next
const allyMovePhaseIndex = globalScene.phaseQueue.indexOf(allyMovePhase);
const firstMovePhaseIndex = globalScene.phaseQueue.findIndex((phase) => phase instanceof MovePhase);
const firstMovePhaseIndex = globalScene.phaseQueue.findIndex((phase) => phase.is("MovePhase"));
if (allyMovePhaseIndex !== firstMovePhaseIndex) {
globalScene.prependToPhase(globalScene.phaseQueue.splice(allyMovePhaseIndex, 1)[0], MovePhase);
}
@ -4477,7 +4477,7 @@ export class CueNextRoundAttr extends MoveEffectAttr {
override apply(user: Pokemon, target: Pokemon, move: Move, args?: any[]): boolean {
const nextRoundPhase = globalScene.findPhase<MovePhase>(phase =>
phase instanceof MovePhase && phase.move.moveId === MoveId.ROUND
phase.is("MovePhase") && phase.move.moveId === MoveId.ROUND
);
if (!nextRoundPhase) {
@ -4486,7 +4486,7 @@ export class CueNextRoundAttr extends MoveEffectAttr {
// Update the phase queue so that the next Pokemon using Round moves next
const nextRoundIndex = globalScene.phaseQueue.indexOf(nextRoundPhase);
const nextMoveIndex = globalScene.phaseQueue.findIndex(phase => phase instanceof MovePhase);
const nextMoveIndex = globalScene.phaseQueue.findIndex(phase => phase.is("MovePhase"));
if (nextRoundIndex !== nextMoveIndex) {
globalScene.prependToPhase(globalScene.phaseQueue.splice(nextRoundIndex, 1)[0], MovePhase);
}
@ -5472,13 +5472,6 @@ export class AddBattlerTagAttr extends MoveEffectAttr {
this.failOnOverlap = !!failOnOverlap;
}
canApply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
if (!super.canApply(user, target, move, args)) {
return false;
}
return true;
}
apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
if (!super.apply(user, target, move, args)) {
return false;
@ -6177,7 +6170,7 @@ export class RevivalBlessingAttr extends MoveEffectAttr {
// Handle cases where revived pokemon needs to get switched in on same turn
if (allyPokemon.isFainted() || allyPokemon === pokemon) {
// Enemy switch phase should be removed and replaced with the revived pkmn switching in
globalScene.tryRemovePhase((phase: SwitchSummonPhase) => phase instanceof SwitchSummonPhase && phase.getPokemon() === pokemon);
globalScene.tryRemovePhase((phase: SwitchSummonPhase) => phase.is("SwitchSummonPhase") && phase.getPokemon() === pokemon);
// If the pokemon being revived was alive earlier in the turn, cancel its move
// (revived pokemon can't move in the turn they're brought back)
globalScene.findPhase((phase: MovePhase) => phase.pokemon === pokemon)?.cancel();
@ -6832,7 +6825,7 @@ export class RandomMovesetMoveAttr extends CallMoveAttr {
return false;
}
this.moveId = moves[user.randBattleSeedInt(moves.length)]!.moveId;
this.moveId = moves[user.randBattleSeedInt(moves.length)].moveId;
return true;
};
}
@ -7367,11 +7360,7 @@ export class SketchAttr extends MoveEffectAttr {
return false;
}
if (user.getMoveset().find(m => m.moveId === targetMove.move)) {
return false;
}
return true;
return !user.getMoveset().some(m => m.moveId === targetMove.move);
};
}
}
@ -7896,7 +7885,7 @@ export class ForceLastAttr extends MoveEffectAttr {
// Either the end of the turn or in front of another, slower move which has also been forced last
const prependPhase = globalScene.findPhase((phase) =>
[ MovePhase, MoveEndPhase ].every(cls => !(phase instanceof cls))
|| (phase instanceof MovePhase) && phaseForcedSlower(phase, target, !!globalScene.arena.getTag(ArenaTagType.TRICK_ROOM))
|| (phase.is("MovePhase")) && phaseForcedSlower(phase, target, !!globalScene.arena.getTag(ArenaTagType.TRICK_ROOM))
);
if (prependPhase) {
globalScene.phaseQueue.splice(
@ -7942,7 +7931,7 @@ const userSleptOrComatoseCondition: MoveConditionFunc = (user: Pokemon, target:
const targetSleptOrComatoseCondition: MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => target.status?.effect === StatusEffect.SLEEP || target.hasAbility(AbilityId.COMATOSE);
const failIfLastCondition: MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => globalScene.phaseQueue.find(phase => phase instanceof MovePhase) !== undefined;
const failIfLastCondition: MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => globalScene.phaseQueue.find(phase => phase.is("MovePhase")) !== undefined;
const failIfLastInPartyCondition: MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => {
const party: Pokemon[] = user.isPlayer() ? globalScene.getPlayerParty() : globalScene.getEnemyParty();

31
src/data/mystery-encounters/mystery-encounter-requirements.ts
View File

@ -275,15 +275,11 @@ export class TimeOfDayRequirement extends EncounterSceneRequirement {
override meetsRequirement(): boolean {
const timeOfDay = globalScene.arena?.getTimeOfDay();
if (
return !(
!isNullOrUndefined(timeOfDay) &&
this.requiredTimeOfDay?.length > 0 &&
!this.requiredTimeOfDay.includes(timeOfDay)
) {
return false;
}
return true;
);
}
override getDialogueToken(_pokemon?: PlayerPokemon): [string, string] {
@ -301,15 +297,11 @@ export class WeatherRequirement extends EncounterSceneRequirement {
override meetsRequirement(): boolean {
const currentWeather = globalScene.arena.weather?.weatherType;
if (
return !(
!isNullOrUndefined(currentWeather) &&
this.requiredWeather?.length > 0 &&
!this.requiredWeather.includes(currentWeather!)
) {
return false;
}
return true;
);
}
override getDialogueToken(_pokemon?: PlayerPokemon): [string, string] {
@ -803,7 +795,7 @@ export class CanFormChangeWithItemRequirement extends EncounterPokemonRequiremen
}
filterByForm(pokemon, formChangeItem) {
if (
return (
pokemonFormChanges.hasOwnProperty(pokemon.species.speciesId) &&
// Get all form changes for this species with an item trigger, including any compound triggers
pokemonFormChanges[pokemon.species.speciesId]
@ -812,10 +804,7 @@ export class CanFormChangeWithItemRequirement extends EncounterPokemonRequiremen
.flatMap(fc => fc.findTrigger(SpeciesFormChangeItemTrigger) as SpeciesFormChangeItemTrigger)
.flatMap(fc => fc.item)
.includes(formChangeItem)
) {
return true;
}
return false;
);
}
override queryParty(partyPokemon: PlayerPokemon[]): PlayerPokemon[] {
@ -873,17 +862,15 @@ export class CanEvolveWithItemRequirement extends EncounterPokemonRequirement {
) {
return true;
}
if (
return (
pokemon.isFusion() &&
pokemonEvolutions.hasOwnProperty(pokemon.fusionSpecies.speciesId) &&
pokemonEvolutions[pokemon.fusionSpecies.speciesId].filter(
e => e.item === evolutionItem && (!e.condition || e.condition.predicate(pokemon)),
).length &&
pokemon.getFusionFormKey() !== SpeciesFormKey.GIGANTAMAX
) {
return true;
}
return false;
);
}
override queryParty(partyPokemon: PlayerPokemon[]): PlayerPokemon[] {

2
src/data/mystery-encounters/utils/encounter-phase-utils.ts
View File

@ -769,7 +769,7 @@ export function setEncounterRewards(
if (customShopRewards) {
globalScene.unshiftPhase(new SelectModifierPhase(0, undefined, customShopRewards));
} else {
globalScene.tryRemovePhase(p => p instanceof SelectModifierPhase);
globalScene.tryRemovePhase(p => p.is("MysteryEncounterRewardsPhase"));
}
if (eggRewards) {

6
src/data/pokemon-forms.ts
View File

@ -186,11 +186,7 @@ export class SpeciesFormChange {
}
}
if (!this.trigger.canChange(pokemon)) {
return false;
}
return true;
return this.trigger.canChange(pokemon);
}
findTrigger(triggerType: Constructor<SpeciesFormChangeTrigger>): SpeciesFormChangeTrigger | nil {

4
src/data/pokemon-species.ts
View File

@ -1281,10 +1281,6 @@ export default class PokemonSpecies extends PokemonSpeciesForm implements Locali
};
}
isObtainable() {
return super.isObtainable();
}
hasVariants() {
let variantDataIndex: string | number = this.speciesId;
if (this.forms.length > 0) {

35
src/field/pokemon.ts
View File

@ -232,7 +232,6 @@ import { getPokemonNameWithAffix } from "#app/messages";
import { DamageAnimPhase } from "#app/phases/damage-anim-phase";
import { FaintPhase } from "#app/phases/faint-phase";
import { LearnMovePhase } from "#app/phases/learn-move-phase";
import { MoveEffectPhase } from "#app/phases/move-effect-phase";
import { MoveEndPhase } from "#app/phases/move-end-phase";
import { ObtainStatusEffectPhase } from "#app/phases/obtain-status-effect-phase";
import { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
@ -1293,19 +1292,12 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
*/
isOffsetBySubstitute(): boolean {
const substitute = this.getTag(SubstituteTag);
if (substitute) {
if (substitute.sprite === undefined) {
return false;
}
// During the Pokemon's MoveEffect phase, the offset is removed to put the Pokemon "in focus"
const currentPhase = globalScene.getCurrentPhase();
if (currentPhase instanceof MoveEffectPhase && currentPhase.getPokemon() === this) {
return false;
}
return true;
if (!substitute || substitute.sprite === undefined) {
return false;
}
return false;
// During the Pokemon's MoveEffect phase, the offset is removed to put the Pokemon "in focus"
const currentPhase = globalScene.getCurrentPhase();
return !(currentPhase?.is("MoveEffectPhase") && currentPhase.getPokemon() === this);
}
/** If this Pokemon has a Substitute on the field, removes its sprite from the field. */
@ -2242,10 +2234,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
if (this.getAbility(ignoreOverride).id === ability && (!canApply || this.canApplyAbility())) {
return true;
}
if (this.getPassiveAbility().id === ability && this.hasPassive() && (!canApply || this.canApplyAbility(true))) {
return true;
}
return false;
return this.getPassiveAbility().id === ability && this.hasPassive() && (!canApply || this.canApplyAbility(true));
}
/**
@ -2262,10 +2251,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
if ((!canApply || this.canApplyAbility()) && this.getAbility(ignoreOverride).hasAttr(attrType)) {
return true;
}
if (this.hasPassive() && (!canApply || this.canApplyAbility(true)) && this.getPassiveAbility().hasAttr(attrType)) {
return true;
}
return false;
return this.hasPassive() && (!canApply || this.canApplyAbility(true)) && this.getPassiveAbility().hasAttr(attrType);
}
/**
@ -4775,7 +4761,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
*/
if (effect === StatusEffect.SLEEP || effect === StatusEffect.FREEZE) {
const currentPhase = globalScene.getCurrentPhase();
if (currentPhase instanceof MoveEffectPhase && currentPhase.getUserPokemon() === this) {
if (currentPhase?.is("MoveEffectPhase") && currentPhase.getUserPokemon() === this) {
this.turnData.hitCount = 1;
this.turnData.hitsLeft = 1;
}
@ -5465,10 +5451,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
if ((ownedAbilityAttrs & 2) > 0 && this.hasSameAbilityInRootForm(1)) {
return true;
}
if ((ownedAbilityAttrs & 4) > 0 && this.hasSameAbilityInRootForm(2)) {
return true;
}
return false;
return (ownedAbilityAttrs & 4) > 0 && this.hasSameAbilityInRootForm(2);
}
/**

31
src/modifier/modifier.ts
View File

@ -40,7 +40,6 @@ import {
type TerastallizeModifierType,
type TmModifierType,
getModifierType,
ModifierPoolType,
ModifierTypeGenerator,
modifierTypes,
PokemonHeldItemModifierType,
@ -1091,10 +1090,6 @@ export class PokemonIncrementingStatModifier extends PokemonHeldItemModifier {
return new PokemonIncrementingStatModifier(this.type, this.pokemonId, this.stackCount);
}
getArgs(): any[] {
return super.getArgs();
}
/**
* Checks if the {@linkcode PokemonIncrementingStatModifier} should be applied to the {@linkcode Pokemon}.
* @param pokemon The {@linkcode Pokemon} that holds the item
@ -1217,10 +1212,6 @@ export class StatBoosterModifier extends PokemonHeldItemModifier {
* @see {@linkcode apply}
*/
export class EvolutionStatBoosterModifier extends StatBoosterModifier {
clone() {
return super.clone() as EvolutionStatBoosterModifier;
}
matchType(modifier: Modifier): boolean {
return modifier instanceof EvolutionStatBoosterModifier;
}
@ -3232,8 +3223,7 @@ export abstract class HeldItemTransferModifier extends PokemonHeldItemModifier {
}
/**
* Steals an item from a set of target Pokemon.
* This prioritizes high-tier held items when selecting the item to steal.
* Steals an item, chosen randomly, from a set of target Pokemon.
* @param pokemon The {@linkcode Pokemon} holding this item
* @param target The {@linkcode Pokemon} to steal from (optional)
* @param _args N/A
@ -3253,30 +3243,15 @@ export abstract class HeldItemTransferModifier extends PokemonHeldItemModifier {
return false;
}
const poolType = pokemon.isPlayer()
? ModifierPoolType.PLAYER
: pokemon.hasTrainer()
? ModifierPoolType.TRAINER
: ModifierPoolType.WILD;
const transferredModifierTypes: ModifierType[] = [];
const itemModifiers = globalScene.findModifiers(
m => m instanceof PokemonHeldItemModifier && m.pokemonId === targetPokemon.id && m.isTransferable,
targetPokemon.isPlayer(),
) as PokemonHeldItemModifier[];
let highestItemTier = itemModifiers
.map(m => m.type.getOrInferTier(poolType))
.reduce((highestTier, tier) => Math.max(tier!, highestTier), 0); // TODO: is this bang correct?
let tierItemModifiers = itemModifiers.filter(m => m.type.getOrInferTier(poolType) === highestItemTier);
for (let i = 0; i < transferredItemCount; i++) {
if (!tierItemModifiers.length) {
while (highestItemTier-- && !tierItemModifiers.length) {
tierItemModifiers = itemModifiers.filter(m => m.type.tier === highestItemTier);
}
if (!tierItemModifiers.length) {
break;
}
if (!itemModifiers.length) {
break;
}
const randItemIndex = pokemon.randBattleSeedInt(itemModifiers.length);
const randItem = itemModifiers[randItemIndex];

26
src/phase.ts
View File

@ -1,9 +1,33 @@
import { globalScene } from "#app/global-scene";
import type { PhaseMap, PhaseString } from "./@types/phase-types";
export class Phase {
export abstract class Phase {
start() {}
end() {
globalScene.shiftPhase();
}
/**
* The string name of the phase, used to identify the phase type for {@linkcode is}
*
* @privateremarks
*
* When implementing a phase, you must set the `phaseName` property to the name of the phase.
*/
public abstract readonly phaseName: PhaseString;
/**
* Check if the phase is of the given type without requiring `instanceof`.
*
* @param phase - The string name of the phase to check.
* @returns Whether this phase is of the provided type.
*
* @remarks
* This does not check for subclasses! It only checks if the phase is *exactly* the given type.
* This method exists to avoid circular import issues, as using `instanceof` would require importing each phase.
*/
is<K extends keyof PhaseMap>(phase: K): this is PhaseMap[K] {
return this.phaseName === phase;
}
}

1
src/phases/add-enemy-buff-modifier-phase.ts
View File

@ -9,6 +9,7 @@ import { Phase } from "#app/phase";
import { globalScene } from "#app/global-scene";
export class AddEnemyBuffModifierPhase extends Phase {
public readonly phaseName = "AddEnemyBuffModifierPhase";
start() {
super.start();

1
src/phases/attempt-capture-phase.ts
View File

@ -27,6 +27,7 @@ import { globalScene } from "#app/global-scene";
import { Gender } from "#app/data/gender";
export class AttemptCapturePhase extends PokemonPhase {
public readonly phaseName = "AttemptCapturePhase";
private pokeballType: PokeballType;
private pokeball: Phaser.GameObjects.Sprite;
private originalY: number;

1
src/phases/attempt-run-phase.ts
View File

@ -17,6 +17,7 @@ import { globalScene } from "#app/global-scene";
import { SelectBiomePhase } from "./select-biome-phase";
export class AttemptRunPhase extends PokemonPhase {
public readonly phaseName = "AttemptRunPhase";
/** For testing purposes: this is to force the pokemon to fail and escape */
public forceFailEscape = false;

5
src/phases/battle-end-phase.ts
View File

@ -5,6 +5,7 @@ import { BattlePhase } from "./battle-phase";
import { GameOverPhase } from "./game-over-phase";
export class BattleEndPhase extends BattlePhase {
public readonly phaseName = "BattleEndPhase";
/** If true, will increment battles won */
isVictory: boolean;
@ -19,7 +20,7 @@ export class BattleEndPhase extends BattlePhase {
// cull any extra `BattleEnd` phases from the queue.
globalScene.phaseQueue = globalScene.phaseQueue.filter(phase => {
if (phase instanceof BattleEndPhase) {
if (phase.is("BattleEndPhase")) {
this.isVictory ||= phase.isVictory;
return false;
}
@ -28,7 +29,7 @@ export class BattleEndPhase extends BattlePhase {
// `phaseQueuePrepend` is private, so we have to use this inefficient loop.
while (
globalScene.tryRemoveUnshiftedPhase(phase => {
if (phase instanceof BattleEndPhase) {
if (phase.is("BattleEndPhase")) {
this.isVictory ||= phase.isVictory;
return true;
}

2
src/phases/battle-phase.ts
View File

@ -2,7 +2,7 @@ import { globalScene } from "#app/global-scene";
import { TrainerSlot } from "#enums/trainer-slot";
import { Phase } from "#app/phase";
export class BattlePhase extends Phase {
export abstract class BattlePhase extends Phase {
showEnemyTrainer(trainerSlot: TrainerSlot = TrainerSlot.NONE): void {
if (!globalScene.currentBattle.trainer) {
console.warn("Enemy trainer is missing!");

1
src/phases/berry-phase.ts
View File

@ -20,6 +20,7 @@ import type Pokemon from "#app/field/pokemon";
* Also triggers Cud Chew's "repeat berry use" effects
*/
export class BerryPhase extends FieldPhase {
public readonly phaseName = "BerryPhase";
start() {
super.start();

1
src/phases/check-status-effect-phase.ts
View File

@ -4,6 +4,7 @@ import type { BattlerIndex } from "#app/battle";
import { globalScene } from "#app/global-scene";
export class CheckStatusEffectPhase extends Phase {
public readonly phaseName = "CheckStatusEffectPhase";
private order: BattlerIndex[];
constructor(order: BattlerIndex[]) {
super();

1
src/phases/check-switch-phase.ts
View File

@ -10,6 +10,7 @@ import { SwitchPhase } from "./switch-phase";
import { SwitchType } from "#enums/switch-type";
export class CheckSwitchPhase extends BattlePhase {
public readonly phaseName = "CheckSwitchPhase";
protected fieldIndex: number;
protected useName: boolean;

1
src/phases/command-phase.ts
View File

@ -25,6 +25,7 @@ import { ArenaTagSide } from "#app/data/arena-tag";
import { ArenaTagType } from "#app/enums/arena-tag-type";
export class CommandPhase extends FieldPhase {
public readonly phaseName = "CommandPhase";
protected fieldIndex: number;
constructor(fieldIndex: number) {

3
src/phases/common-anim-phase.ts
View File

@ -5,6 +5,9 @@ import { CommonBattleAnim } from "#app/data/battle-anims";
import { PokemonPhase } from "./pokemon-phase";
export class CommonAnimPhase extends PokemonPhase {
// PokemonHealPhase extends CommonAnimPhase, and to make typescript happy,
// we need to allow phaseName to be a union of the two
public readonly phaseName: "CommonAnimPhase" | "PokemonHealPhase" | "WeatherEffectPhase" = "CommonAnimPhase";
private anim: CommonAnim | null;
private targetIndex?: BattlerIndex;
private playOnEmptyField: boolean;

1
src/phases/damage-anim-phase.ts
View File

@ -6,6 +6,7 @@ import { fixedInt } from "#app/utils/common";
import { PokemonPhase } from "#app/phases/pokemon-phase";
export class DamageAnimPhase extends PokemonPhase {
public readonly phaseName = "DamageAnimPhase";
private amount: number;
private damageResult: DamageResult;
private critical: boolean;

3
src/phases/egg-hatch-phase.ts
View File

@ -20,6 +20,7 @@ import { doShinySparkleAnim } from "#app/field/anims";
* Class that represents egg hatching
*/
export class EggHatchPhase extends Phase {
public readonly phaseName = "EggHatchPhase";
/** The egg that is hatching */
private egg: Egg;
/** The new EggHatchData for the egg/pokemon that hatches */
@ -224,7 +225,7 @@ export class EggHatchPhase extends Phase {
}
end() {
if (globalScene.findPhase(p => p instanceof EggHatchPhase)) {
if (globalScene.findPhase(p => p.is("EggHatchPhase"))) {
this.eggHatchHandler.clear();
} else {
globalScene.time.delayedCall(250, () => globalScene.setModifiersVisible(true));

1
src/phases/egg-lapse-phase.ts
View File

@ -16,6 +16,7 @@ import { EggHatchData } from "#app/data/egg-hatch-data";
* Also handles prompts for skipping animation, and calling the egg summary phase
*/
export class EggLapsePhase extends Phase {
public readonly phaseName = "EggLapsePhase";
private eggHatchData: EggHatchData[] = [];
private readonly minEggsToSkip: number = 2;

1
src/phases/egg-summary-phase.ts
View File

@ -9,6 +9,7 @@ import type { EggHatchData } from "#app/data/egg-hatch-data";
* Phase is handled mostly by the egg-hatch-scene-handler UI
*/
export class EggSummaryPhase extends Phase {
public readonly phaseName = "EggSummaryPhase";
private eggHatchData: EggHatchData[];
constructor(eggHatchData: EggHatchData[]) {

2
src/phases/encounter-phase.ts
View File

@ -47,6 +47,8 @@ import { WEIGHT_INCREMENT_ON_SPAWN_MISS } from "#app/data/mystery-encounters/mys
import { getNatureName } from "#app/data/nature";
export class EncounterPhase extends BattlePhase {
// Union type is necessary as this is subclassed, and typescript will otherwise complain
public readonly phaseName: "EncounterPhase" | "NextEncounterPhase" | "NewBiomeEncounterPhase" = "EncounterPhase";
private loaded: boolean;
constructor(loaded = false) {

1
src/phases/end-card-phase.ts
View File

@ -5,6 +5,7 @@ import { addTextObject, TextStyle } from "#app/ui/text";
import i18next from "i18next";
export class EndCardPhase extends Phase {
public readonly phaseName = "EndCardPhase";
public endCard: Phaser.GameObjects.Image;
public text: Phaser.GameObjects.Text;
start(): void {

1
src/phases/end-evolution-phase.ts
View File

@ -3,6 +3,7 @@ import { Phase } from "#app/phase";
import { UiMode } from "#enums/ui-mode";
export class EndEvolutionPhase extends Phase {
public readonly phaseName = "EndEvolutionPhase";
start() {
super.start();

1
src/phases/enemy-command-phase.ts
View File

@ -15,6 +15,7 @@ import { BattlerTagType } from "#enums/battler-tag-type";
* @see {@linkcode EnemyPokemon.getNextMove}
*/
export class EnemyCommandPhase extends FieldPhase {
public readonly phaseName = "EnemyCommandPhase";
protected fieldIndex: number;
protected skipTurn = false;

3
src/phases/evolution-phase.ts
View File

@ -19,6 +19,9 @@ import { EndEvolutionPhase } from "#app/phases/end-evolution-phase";
import { EVOLVE_MOVE } from "#app/data/balance/pokemon-level-moves";
export class EvolutionPhase extends Phase {
// FormChangePhase inherits from this, but EvolutionPhase is not abstract.
// We have to use the union here
public readonly phaseName: "EvolutionPhase" | "FormChangePhase" = "EvolutionPhase";
protected pokemon: PlayerPokemon;
protected lastLevel: number;

1
src/phases/exp-phase.ts
View File

@ -7,6 +7,7 @@ import { PlayerPartyMemberPokemonPhase } from "./player-party-member-pokemon-pha
import { LevelUpPhase } from "./level-up-phase";
export class ExpPhase extends PlayerPartyMemberPokemonPhase {
public readonly phaseName = "ExpPhase";
private expValue: number;
constructor(partyMemberIndex: number, expValue: number) {

12
src/phases/faint-phase.ts
View File

@ -35,6 +35,7 @@ import { FRIENDSHIP_LOSS_FROM_FAINT } from "#app/data/balance/starters";
import { BattlerTagType } from "#enums/battler-tag-type";
export class FaintPhase extends PokemonPhase {
public readonly phaseName = "FaintPhase";
/**
* Whether or not instant revive should be prevented
*/
@ -78,10 +79,15 @@ export class FaintPhase extends PokemonPhase {
}
}
/** In case the current pokemon was just switched in, make sure it is counted as participating in the combat */
/**
* In case the current pokemon was just switched in, make sure it is counted as participating in the combat.
* For EXP_SHARE purposes, if the current pokemon faints as the combat ends and it was the ONLY player pokemon
* involved in combat, it needs to be counted as a participant so the other party pokemon can get their EXP,
* so the fainted pokemon has been included.
*/
for (const pokemon of globalScene.getPlayerField()) {
if (pokemon?.isActive(true) && pokemon.isPlayer()) {
globalScene.currentBattle.addParticipant(pokemon as PlayerPokemon);
if (pokemon?.isActive() || pokemon?.isFainted()) {
globalScene.currentBattle.addParticipant(pokemon);
}
}

1
src/phases/form-change-phase.ts
View File

@ -13,6 +13,7 @@ import { BattlerTagType } from "#enums/battler-tag-type";
import { SpeciesFormKey } from "#enums/species-form-key";
export class FormChangePhase extends EvolutionPhase {
public readonly phaseName = "FormChangePhase";
private formChange: SpeciesFormChange;
private modal: boolean;

1
src/phases/game-over-modifier-reward-phase.ts
View File

@ -4,6 +4,7 @@ import i18next from "i18next";
import { ModifierRewardPhase } from "./modifier-reward-phase";
export class GameOverModifierRewardPhase extends ModifierRewardPhase {
public readonly phaseName = "GameOverModifierRewardPhase";
doReward(): Promise<void> {
return new Promise<void>(resolve => {
const newModifier = this.modifierType.newModifier();

1
src/phases/game-over-phase.ts
View File

@ -34,6 +34,7 @@ import { pokerogueApi } from "#app/plugins/api/pokerogue-api";
import { MessagePhase } from "./message-phase";
export class GameOverPhase extends BattlePhase {
public readonly phaseName = "GameOverPhase";
private isVictory: boolean;
private firstRibbons: PokemonSpecies[] = [];

1
src/phases/hide-ability-phase.ts
View File

@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
import { Phase } from "#app/phase";
export class HideAbilityPhase extends Phase {
public readonly phaseName = "HideAbilityPhase";
start() {
super.start();

1
src/phases/hide-party-exp-bar-phase.ts
View File

@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
import { BattlePhase } from "./battle-phase";
export class HidePartyExpBarPhase extends BattlePhase {
public readonly phaseName = "HidePartyExpBarPhase";
start() {
super.start();

6
src/phases/learn-move-phase.ts
View File

@ -12,7 +12,6 @@ import { UiMode } from "#enums/ui-mode";
import i18next from "i18next";
import { PlayerPartyMemberPokemonPhase } from "#app/phases/player-party-member-pokemon-phase";
import type Pokemon from "#app/field/pokemon";
import { SelectModifierPhase } from "#app/phases/select-modifier-phase";
export enum LearnMoveType {
/** For learning a move via level-up, evolution, or other non-item-based event */
@ -24,6 +23,7 @@ export enum LearnMoveType {
}
export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
public readonly phaseName = "LearnMovePhase";
private moveId: MoveId;
private messageMode: UiMode;
private learnMoveType: LearnMoveType;
@ -195,7 +195,7 @@ export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
pokemon.usedTMs = [];
}
pokemon.usedTMs.push(this.moveId);
globalScene.tryRemovePhase(phase => phase instanceof SelectModifierPhase);
globalScene.tryRemovePhase(phase => phase.is("SelectModifierPhase"));
} else if (this.learnMoveType === LearnMoveType.MEMORY) {
if (this.cost !== -1) {
if (!Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
@ -205,7 +205,7 @@ export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
}
globalScene.playSound("se/buy");
} else {
globalScene.tryRemovePhase(phase => phase instanceof SelectModifierPhase);
globalScene.tryRemovePhase(phase => phase.is("SelectModifierPhase"));
}
}
pokemon.setMove(index, this.moveId);

1
src/phases/level-cap-phase.ts
View File

@ -4,6 +4,7 @@ import i18next from "i18next";
import { FieldPhase } from "./field-phase";
export class LevelCapPhase extends FieldPhase {
public readonly phaseName = "LevelCapPhase";
start(): void {
super.start();

1
src/phases/level-up-phase.ts
View File

@ -10,6 +10,7 @@ import { NumberHolder } from "#app/utils/common";
import i18next from "i18next";
export class LevelUpPhase extends PlayerPartyMemberPokemonPhase {
public readonly phaseName = "LevelUpPhase";
protected lastLevel: number;
protected level: number;
protected pokemon: PlayerPokemon = this.getPlayerPokemon();

1
src/phases/load-move-anim-phase.ts
View File

@ -8,6 +8,7 @@ import { Phase } from "#app/phase";
* isn't already loaded (e.g. for Metronome)
*/
export class LoadMoveAnimPhase extends Phase {
public readonly phaseName = "LoadMoveAnimPhase";
constructor(protected moveId: MoveId) {
super();
}

1
src/phases/login-phase.ts
View File

@ -11,6 +11,7 @@ import { SelectGenderPhase } from "./select-gender-phase";
import { UnavailablePhase } from "./unavailable-phase";
export class LoginPhase extends Phase {
public readonly phaseName = "LoginPhase";
private showText: boolean;
constructor(showText = true) {

1
src/phases/message-phase.ts
View File

@ -2,6 +2,7 @@ import { globalScene } from "#app/global-scene";
import { Phase } from "#app/phase";
export class MessagePhase extends Phase {
public readonly phaseName = "MessagePhase";
private text: string;
private callbackDelay?: number | null;
private prompt?: boolean | null;

4
src/phases/modifier-reward-phase.ts
View File

@ -5,6 +5,10 @@ import i18next from "i18next";
import { BattlePhase } from "./battle-phase";
export class ModifierRewardPhase extends BattlePhase {
// RibbonModifierRewardPhase extends ModifierRewardPhase and to make typescript happy
// we need to use a union type here
public readonly phaseName: "ModifierRewardPhase" | "RibbonModifierRewardPhase" | "GameOverModifierRewardPhase" =
"ModifierRewardPhase";
protected modifierType: ModifierType;
constructor(modifierTypeFunc: ModifierTypeFunc) {

1
src/phases/money-reward-phase.ts
View File

@ -6,6 +6,7 @@ import { NumberHolder } from "#app/utils/common";
import { BattlePhase } from "./battle-phase";
export class MoneyRewardPhase extends BattlePhase {
public readonly phaseName = "MoneyRewardPhase";
private moneyMultiplier: number;
constructor(moneyMultiplier: number) {

2
src/phases/move-anim-phase.ts
View File

@ -5,6 +5,8 @@ import { Phase } from "#app/phase";
* Plays the given {@linkcode MoveAnim} sequentially.
*/
export class MoveAnimPhase<Anim extends MoveAnim> extends Phase {
public readonly phaseName = "MoveAnimPhase";
constructor(
protected anim: Anim,
protected onSubstitute = false,

4
src/phases/move-charge-phase.ts
View File

@ -9,13 +9,13 @@ import { BooleanHolder } from "#app/utils/common";
import { MovePhase } from "#app/phases/move-phase";
import { PokemonPhase } from "#app/phases/pokemon-phase";
import { BattlerTagType } from "#enums/battler-tag-type";
import { MoveEndPhase } from "#app/phases/move-end-phase";
/**
* Phase for the "charging turn" of two-turn moves (e.g. Dig).
* @extends {@linkcode PokemonPhase}
*/
export class MoveChargePhase extends PokemonPhase {
public readonly phaseName = "MoveChargePhase";
/** The move instance that this phase applies */
public move: PokemonMove;
/** The field index targeted by the move (Charging moves assume single target) */
@ -62,7 +62,7 @@ export class MoveChargePhase extends PokemonPhase {
if (instantCharge.value) {
// this MoveEndPhase will be duplicated by the queued MovePhase if not removed
globalScene.tryRemovePhase(phase => phase instanceof MoveEndPhase && phase.getPokemon() === user);
globalScene.tryRemovePhase(phase => phase.is("MoveEndPhase") && phase.getPokemon() === user);
// queue a new MovePhase for this move's attack phase
globalScene.unshiftPhase(new MovePhase(user, [this.targetIndex], this.move, false));
} else {

1
src/phases/move-effect-phase.ts
View File

@ -82,6 +82,7 @@ import { DamageAchv } from "#app/system/achv";
type HitCheckEntry = [HitCheckResult, TypeDamageMultiplier];
export class MoveEffectPhase extends PokemonPhase {
public readonly phaseName = "MoveEffectPhase";
public move: Move;
private virtual = false;
protected targets: BattlerIndex[];

1
src/phases/move-end-phase.ts
View File

@ -6,6 +6,7 @@ import { applyPostSummonAbAttrs, PostSummonRemoveEffectAbAttr } from "#app/data/
import type Pokemon from "#app/field/pokemon";
export class MoveEndPhase extends PokemonPhase {
public readonly phaseName = "MoveEndPhase";
private wasFollowUp: boolean;
/** Targets from the preceding MovePhase */

1
src/phases/move-header-phase.ts
View File

@ -4,6 +4,7 @@ import type Pokemon from "#app/field/pokemon";
import { BattlePhase } from "./battle-phase";
export class MoveHeaderPhase extends BattlePhase {
public readonly phaseName = "MoveHeaderPhase";
public pokemon: Pokemon;
public move: PokemonMove;

1
src/phases/move-phase.ts
View File

@ -52,6 +52,7 @@ import { StatusEffect } from "#enums/status-effect";
import i18next from "i18next";
export class MovePhase extends BattlePhase {
public readonly phaseName = "MovePhase";
protected _pokemon: Pokemon;
protected _move: PokemonMove;
protected _targets: BattlerIndex[];

13
src/phases/mystery-encounter-phases.ts
View File

@ -6,7 +6,6 @@ import { getEncounterText } from "#app/data/mystery-encounters/utils/encounter-d
import { CheckSwitchPhase } from "#app/phases/check-switch-phase";
import { GameOverPhase } from "#app/phases/game-over-phase";
import { NewBattlePhase } from "#app/phases/new-battle-phase";
import { PostTurnStatusEffectPhase } from "#app/phases/post-turn-status-effect-phase";
import { ReturnPhase } from "#app/phases/return-phase";
import { ScanIvsPhase } from "#app/phases/scan-ivs-phase";
import { SelectModifierPhase } from "#app/phases/select-modifier-phase";
@ -39,6 +38,7 @@ import { SelectBiomePhase } from "./select-biome-phase";
* - Queuing of the {@linkcode MysteryEncounterOptionSelectedPhase}
*/
export class MysteryEncounterPhase extends Phase {
public readonly phaseName = "MysteryEncounterPhase";
private readonly FIRST_DIALOGUE_PROMPT_DELAY = 300;
optionSelectSettings?: OptionSelectSettings;
@ -180,6 +180,7 @@ export class MysteryEncounterPhase extends Phase {
* Any phase that is meant to follow this one MUST be queued via the onOptionSelect() logic of the selected option
*/
export class MysteryEncounterOptionSelectedPhase extends Phase {
public readonly phaseName = "MysteryEncounterOptionSelectedPhase";
onOptionSelect: OptionPhaseCallback;
constructor() {
@ -221,6 +222,7 @@ export class MysteryEncounterOptionSelectedPhase extends Phase {
* See {@linkcode TurnEndPhase} for more details
*/
export class MysteryEncounterBattleStartCleanupPhase extends Phase {
public readonly phaseName = "MysteryEncounterBattleStartCleanupPhase";
/**
* Cleans up `TURN_END` tags, any {@linkcode PostTurnStatusEffectPhase}s, checks for Pokemon switches, then continues
*/
@ -245,8 +247,8 @@ export class MysteryEncounterBattleStartCleanupPhase extends Phase {
});
// Remove any status tick phases
while (globalScene.findPhase(p => p instanceof PostTurnStatusEffectPhase)) {
globalScene.tryRemovePhase(p => p instanceof PostTurnStatusEffectPhase);
while (globalScene.findPhase(p => p.is("PostTurnStatusEffectPhase"))) {
globalScene.tryRemovePhase(p => p.is("PostTurnStatusEffectPhase"));
}
// The total number of Pokemon in the player's party that can legally fight
@ -284,6 +286,7 @@ export class MysteryEncounterBattleStartCleanupPhase extends Phase {
* - Queue the {@linkcode SummonPhase}s, {@linkcode PostSummonPhase}s, etc., required to initialize the phase queue for a battle
*/
export class MysteryEncounterBattlePhase extends Phase {
public readonly phaseName = "MysteryEncounterBattlePhase";
disableSwitch: boolean;
constructor(disableSwitch = false) {
@ -513,6 +516,7 @@ export class MysteryEncounterBattlePhase extends Phase {
* - Queuing of the {@linkcode PostMysteryEncounterPhase}
*/
export class MysteryEncounterRewardsPhase extends Phase {
public readonly phaseName = "MysteryEncounterRewardsPhase";
addHealPhase: boolean;
constructor(addHealPhase = false) {
@ -558,7 +562,7 @@ export class MysteryEncounterRewardsPhase extends Phase {
if (encounter.doEncounterRewards) {
encounter.doEncounterRewards();
} else if (this.addHealPhase) {
globalScene.tryRemovePhase(p => p instanceof SelectModifierPhase);
globalScene.tryRemovePhase(p => p.is("SelectModifierPhase"));
globalScene.unshiftPhase(
new SelectModifierPhase(0, undefined, {
fillRemaining: false,
@ -580,6 +584,7 @@ export class MysteryEncounterRewardsPhase extends Phase {
* - Queuing of the next wave
*/
export class PostMysteryEncounterPhase extends Phase {
public readonly phaseName = "PostMysteryEncounterPhase";
private readonly FIRST_DIALOGUE_PROMPT_DELAY = 750;
onPostOptionSelect?: OptionPhaseCallback;

5
src/phases/new-battle-phase.ts
View File

@ -2,13 +2,14 @@ import { globalScene } from "#app/global-scene";
import { BattlePhase } from "./battle-phase";
export class NewBattlePhase extends BattlePhase {
public readonly phaseName = "NewBattlePhase";
start() {
super.start();
// cull any extra `NewBattle` phases from the queue.
globalScene.phaseQueue = globalScene.phaseQueue.filter(phase => !(phase instanceof NewBattlePhase));
globalScene.phaseQueue = globalScene.phaseQueue.filter(phase => !phase.is("NewBattlePhase"));
// `phaseQueuePrepend` is private, so we have to use this inefficient loop.
while (globalScene.tryRemoveUnshiftedPhase(phase => phase instanceof NewBattlePhase)) {}
while (globalScene.tryRemoveUnshiftedPhase(phase => phase.is("NewBattlePhase"))) {}
globalScene.newBattle();

1
src/phases/new-biome-encounter-phase.ts
View File

@ -4,6 +4,7 @@ import { getRandomWeatherType } from "#app/data/weather";
import { NextEncounterPhase } from "./next-encounter-phase";
export class NewBiomeEncounterPhase extends NextEncounterPhase {
public readonly phaseName = "NewBiomeEncounterPhase";
doEncounter(): void {
globalScene.playBgm(undefined, true);

1
src/phases/next-encounter-phase.ts
View File

@ -6,6 +6,7 @@ import { EncounterPhase } from "./encounter-phase";
* Handles generating, loading and preparing for it.
*/
export class NextEncounterPhase extends EncounterPhase {
public readonly phaseName: "NextEncounterPhase" | "NewBiomeEncounterPhase" = "NextEncounterPhase";
start() {
super.start();
}

1
src/phases/obtain-status-effect-phase.ts
View File

@ -11,6 +11,7 @@ import { applyPostSetStatusAbAttrs, PostSetStatusAbAttr } from "#app/data/abilit
import { isNullOrUndefined } from "#app/utils/common";
export class ObtainStatusEffectPhase extends PokemonPhase {
public readonly phaseName = "ObtainStatusEffectPhase";
private statusEffect?: StatusEffect;
private turnsRemaining?: number;
private sourceText?: string | null;

1
src/phases/party-exp-phase.ts
View File

@ -6,6 +6,7 @@ import { Phase } from "#app/phase";
* Intended to be used as a more 1-off phase to provide exp to the party (such as during MEs), rather than cleanup a battle entirely
*/
export class PartyExpPhase extends Phase {
public readonly phaseName = "PartyExpPhase";
expValue: number;
useWaveIndexMultiplier?: boolean;
pokemonParticipantIds?: Set<number>;

1
src/phases/party-heal-phase.ts
View File

@ -3,6 +3,7 @@ import { fixedInt } from "#app/utils/common";
import { BattlePhase } from "./battle-phase";
export class PartyHealPhase extends BattlePhase {
public readonly phaseName = "PartyHealPhase";
private resumeBgm: boolean;
constructor(resumeBgm: boolean) {

1
src/phases/pokemon-anim-phase.ts
View File

@ -7,6 +7,7 @@ import { PokemonAnimType } from "#enums/pokemon-anim-type";
import { SpeciesId } from "#enums/species-id";
export class PokemonAnimPhase extends BattlePhase {
public readonly phaseName = "PokemonAnimPhase";
/** The type of animation to play in this phase */
protected key: PokemonAnimType;
/** The Pokemon to which this animation applies */

1
src/phases/pokemon-heal-phase.ts
View File

@ -14,6 +14,7 @@ import { BattlerTagType } from "#app/enums/battler-tag-type";
import type { HealBlockTag } from "#app/data/battler-tags";
export class PokemonHealPhase extends CommonAnimPhase {
public readonly phaseName = "PokemonHealPhase";
private hpHealed: number;
private message: string | null;
private showFullHpMessage: boolean;

1
src/phases/pokemon-transform-phase.ts
View File

@ -13,6 +13,7 @@ import i18next from "i18next";
* Used for Transform (move) and Imposter (ability)
*/
export class PokemonTransformPhase extends PokemonPhase {
public readonly phaseName = "PokemonTransformPhase";
protected targetIndex: BattlerIndex;
private playSound: boolean;

1
src/phases/post-game-over-phase.ts
View File

@ -4,6 +4,7 @@ import type { EndCardPhase } from "./end-card-phase";
import { TitlePhase } from "./title-phase";
export class PostGameOverPhase extends Phase {
public readonly phaseName = "PostGameOverPhase";
private endCardPhase?: EndCardPhase;
constructor(endCardPhase?: EndCardPhase) {

1
src/phases/post-summon-phase.ts
View File

@ -7,6 +7,7 @@ import { MysteryEncounterPostSummonTag } from "#app/data/battler-tags";
import { BattlerTagType } from "#enums/battler-tag-type";
export class PostSummonPhase extends PokemonPhase {
public readonly phaseName = "PostSummonPhase";
start() {
super.start();

1
src/phases/post-turn-status-effect-phase.ts
View File

@ -17,6 +17,7 @@ import { BooleanHolder, NumberHolder } from "#app/utils/common";
import { PokemonPhase } from "./pokemon-phase";
export class PostTurnStatusEffectPhase extends PokemonPhase {
public readonly phaseName = "PostTurnStatusEffectPhase";
// biome-ignore lint/complexity/noUselessConstructor: Not unnecessary as it makes battlerIndex required
constructor(battlerIndex: BattlerIndex) {
super(battlerIndex);

5
src/phases/quiet-form-change-phase.ts
View File

@ -9,7 +9,7 @@ import type Pokemon from "#app/field/pokemon";
import { EnemyPokemon } from "#app/field/pokemon";
import { getPokemonNameWithAffix } from "#app/messages";
import { BattlePhase } from "./battle-phase";
import { MovePhase } from "./move-phase";
import type { MovePhase } from "./move-phase";
import { PokemonHealPhase } from "./pokemon-heal-phase";
import {
applyAbAttrs,
@ -19,6 +19,7 @@ import {
} from "#app/data/abilities/ability";
export class QuietFormChangePhase extends BattlePhase {
public readonly phaseName = "QuietFormChangePhase";
protected pokemon: Pokemon;
protected formChange: SpeciesFormChange;
@ -168,7 +169,7 @@ export class QuietFormChangePhase extends BattlePhase {
this.pokemon.initBattleInfo();
this.pokemon.cry();
const movePhase = globalScene.findPhase(p => p instanceof MovePhase && p.pokemon === this.pokemon) as MovePhase;
const movePhase = globalScene.findPhase(p => p.is("MovePhase") && p.pokemon === this.pokemon) as MovePhase;
if (movePhase) {
movePhase.cancel();
}

1
src/phases/reload-session-phase.ts
View File

@ -4,6 +4,7 @@ import { UiMode } from "#enums/ui-mode";
import { fixedInt } from "#app/utils/common";
export class ReloadSessionPhase extends Phase {
public readonly phaseName = "ReloadSessionPhase";
private systemDataStr?: string;
constructor(systemDataStr?: string) {

1
src/phases/reset-status-phase.ts
View File

@ -7,6 +7,7 @@ import { BattlePhase } from "#app/phases/battle-phase";
* This is necessary to perform in a phase primarly to ensure that the status icon disappears at the correct time in the battle
*/
export class ResetStatusPhase extends BattlePhase {
public readonly phaseName = "ResetStatusPhase";
private readonly pokemon: Pokemon;
private readonly affectConfusion: boolean;
private readonly reloadAssets: boolean;

1
src/phases/return-phase.ts
View File

@ -4,6 +4,7 @@ import { SwitchType } from "#enums/switch-type";
import { SwitchSummonPhase } from "./switch-summon-phase";
export class ReturnPhase extends SwitchSummonPhase {
public readonly phaseName = "ReturnPhase";
constructor(fieldIndex: number) {
super(SwitchType.SWITCH, fieldIndex, -1, true);
}

1
src/phases/revival-blessing-phase.ts
View File

@ -15,6 +15,7 @@ import type { PlayerPokemon } from "#app/field/pokemon";
* when used by one of the player's Pokemon.
*/
export class RevivalBlessingPhase extends BattlePhase {
public readonly phaseName = "RevivalBlessingPhase";
constructor(protected user: PlayerPokemon) {
super();
}

1
src/phases/ribbon-modifier-reward-phase.ts
View File

@ -6,6 +6,7 @@ import i18next from "i18next";
import { ModifierRewardPhase } from "./modifier-reward-phase";
export class RibbonModifierRewardPhase extends ModifierRewardPhase {
public readonly phaseName = "RibbonModifierRewardPhase";
private species: PokemonSpecies;
constructor(modifierTypeFunc: ModifierTypeFunc, species: PokemonSpecies) {

1
src/phases/scan-ivs-phase.ts
View File

@ -8,6 +8,7 @@ import i18next from "i18next";
import { PokemonPhase } from "./pokemon-phase";
export class ScanIvsPhase extends PokemonPhase {
public readonly phaseName = "ScanIvsPhase";
// biome-ignore lint/complexity/noUselessConstructor: This changes `battlerIndex` to be required
constructor(battlerIndex: BattlerIndex) {
super(battlerIndex);

1
src/phases/select-biome-phase.ts
View File

@ -10,6 +10,7 @@ import { PartyHealPhase } from "./party-heal-phase";
import { SwitchBiomePhase } from "./switch-biome-phase";
export class SelectBiomePhase extends BattlePhase {
public readonly phaseName = "SelectBiomePhase";
start() {
super.start();

1
src/phases/select-challenge-phase.ts
View File

@ -3,6 +3,7 @@ import { Phase } from "#app/phase";
import { UiMode } from "#enums/ui-mode";
export class SelectChallengePhase extends Phase {
public readonly phaseName = "SelectChallengePhase";
start() {
super.start();

1
src/phases/select-gender-phase.ts
View File

@ -6,6 +6,7 @@ import { UiMode } from "#enums/ui-mode";
import i18next from "i18next";
export class SelectGenderPhase extends Phase {
public readonly phaseName = "SelectGenderPhase";
start(): void {
super.start();

1
src/phases/select-modifier-phase.ts
View File

@ -32,6 +32,7 @@ import type { CustomModifierSettings } from "#app/modifier/modifier-type";
import { isNullOrUndefined, NumberHolder } from "#app/utils/common";
export class SelectModifierPhase extends BattlePhase {
public readonly phaseName = "SelectModifierPhase";
private rerollCount: number;
private modifierTiers?: ModifierTier[];
private customModifierSettings?: CustomModifierSettings;

1
src/phases/select-starter-phase.ts
View File

@ -15,6 +15,7 @@ import SoundFade from "phaser3-rex-plugins/plugins/soundfade";
import { isNullOrUndefined } from "#app/utils/common";
export class SelectStarterPhase extends Phase {
public readonly phaseName = "SelectStarterPhase";
start() {
super.start();

1
src/phases/select-target-phase.ts
View File

@ -8,6 +8,7 @@ import i18next from "#app/plugins/i18n";
import { allMoves } from "#app/data/data-lists";
export class SelectTargetPhase extends PokemonPhase {
public readonly phaseName = "SelectTargetPhase";
// biome-ignore lint/complexity/noUselessConstructor: This makes `fieldIndex` required
constructor(fieldIndex: number) {
super(fieldIndex);

1
src/phases/shiny-sparkle-phase.ts
View File

@ -3,6 +3,7 @@ import type { BattlerIndex } from "#app/battle";
import { PokemonPhase } from "./pokemon-phase";
export class ShinySparklePhase extends PokemonPhase {
public readonly phaseName = "ShinySparklePhase";
// biome-ignore lint/complexity/noUselessConstructor: This makes `battlerIndex` required
constructor(battlerIndex: BattlerIndex) {
super(battlerIndex);

1
src/phases/show-ability-phase.ts
View File

@ -5,6 +5,7 @@ import { getPokemonNameWithAffix } from "#app/messages";
import { HideAbilityPhase } from "#app/phases/hide-ability-phase";
export class ShowAbilityPhase extends PokemonPhase {
public readonly phaseName = "ShowAbilityPhase";
private passive: boolean;
private pokemonName: string;
private abilityName: string;

1
src/phases/show-party-exp-bar-phase.ts
View File

@ -8,6 +8,7 @@ import { LevelUpPhase } from "./level-up-phase";
import { PlayerPartyMemberPokemonPhase } from "./player-party-member-pokemon-phase";
export class ShowPartyExpBarPhase extends PlayerPartyMemberPokemonPhase {
public readonly phaseName = "ShowPartyExpBarPhase";
private expValue: number;
constructor(partyMemberIndex: number, expValue: number) {

1
src/phases/show-trainer-phase.ts
View File

@ -3,6 +3,7 @@ import { PlayerGender } from "#app/enums/player-gender";
import { BattlePhase } from "./battle-phase";
export class ShowTrainerPhase extends BattlePhase {
public readonly phaseName = "ShowTrainerPhase";
start() {
super.start();

9
src/phases/stat-stage-change-phase.ts
View File

@ -31,6 +31,7 @@ export type StatStageChangeCallback = (
) => void;
export class StatStageChangePhase extends PokemonPhase {
public readonly phaseName = "StatStageChangePhase";
private stats: BattleStat[];
private selfTarget: boolean;
private stages: number;
@ -235,9 +236,9 @@ export class StatStageChangePhase extends PokemonPhase {
// Look for any other stat change phases; if this is the last one, do White Herb check
const existingPhase = globalScene.findPhase(
p => p instanceof StatStageChangePhase && p.battlerIndex === this.battlerIndex,
p => p.is("StatStageChangePhase") && p.battlerIndex === this.battlerIndex,
);
if (!(existingPhase instanceof StatStageChangePhase)) {
if (!existingPhase?.is("StatStageChangePhase")) {
// Apply White Herb if needed
const whiteHerb = globalScene.applyModifier(
ResetNegativeStatStageModifier,
@ -316,7 +317,7 @@ export class StatStageChangePhase extends PokemonPhase {
while (
(existingPhase = globalScene.findPhase(
p =>
p instanceof StatStageChangePhase &&
p.is("StatStageChangePhase") &&
p.battlerIndex === this.battlerIndex &&
p.stats.length === 1 &&
p.stats[0] === this.stats[0] &&
@ -335,7 +336,7 @@ export class StatStageChangePhase extends PokemonPhase {
while (
(existingPhase = globalScene.findPhase(
p =>
p instanceof StatStageChangePhase &&
p.is("StatStageChangePhase") &&
p.battlerIndex === this.battlerIndex &&
p.selfTarget === this.selfTarget &&
accEva.some(s => p.stats.includes(s)) === isAccEva &&

1
src/phases/summon-missing-phase.ts
View File

@ -4,6 +4,7 @@ import { SummonPhase } from "./summon-phase";
import { globalScene } from "#app/global-scene";
export class SummonMissingPhase extends SummonPhase {
public readonly phaseName = "SummonMissingPhase";
preSummon(): void {
globalScene.ui.showText(
i18next.t("battle:sendOutPokemon", {

2
src/phases/summon-phase.ts
View File

@ -17,6 +17,8 @@ import { applyPreSummonAbAttrs, PreSummonAbAttr } from "#app/data/abilities/abil
import { globalScene } from "#app/global-scene";
export class SummonPhase extends PartyMemberPokemonPhase {
// The union type is needed to keep typescript happy as these phases extend from SummonPhase
public readonly phaseName: "SummonPhase" | "SummonMissingPhase" | "SwitchSummonPhase" | "ReturnPhase" = "SummonPhase";
private loaded: boolean;
constructor(fieldIndex: number, player = true, loaded = false) {

1
src/phases/switch-biome-phase.ts
View File

@ -4,6 +4,7 @@ import { getBiomeKey } from "#app/field/arena";
import { BattlePhase } from "./battle-phase";
export class SwitchBiomePhase extends BattlePhase {
public readonly phaseName = "SwitchBiomePhase";
private nextBiome: BiomeId;
constructor(nextBiome: BiomeId) {

4
src/phases/switch-phase.ts
View File

@ -3,7 +3,6 @@ import PartyUiHandler, { PartyOption, PartyUiMode } from "#app/ui/party-ui-handl
import { UiMode } from "#enums/ui-mode";
import { SwitchType } from "#enums/switch-type";
import { BattlePhase } from "./battle-phase";
import { PostSummonPhase } from "./post-summon-phase";
import { SwitchSummonPhase } from "./switch-summon-phase";
/**
@ -11,6 +10,7 @@ import { SwitchSummonPhase } from "./switch-summon-phase";
* for the player (if a switch would be valid for the current battle state).
*/
export class SwitchPhase extends BattlePhase {
public readonly phaseName = "SwitchPhase";
protected readonly fieldIndex: number;
private readonly switchType: SwitchType;
private readonly isModal: boolean;
@ -76,7 +76,7 @@ export class SwitchPhase extends BattlePhase {
if (slotIndex >= globalScene.currentBattle.getBattlerCount() && slotIndex < 6) {
// Remove any pre-existing PostSummonPhase under the same field index.
// Pre-existing PostSummonPhases may occur when this phase is invoked during a prompt to switch at the start of a wave.
globalScene.tryRemovePhase(p => p instanceof PostSummonPhase && p.player && p.fieldIndex === this.fieldIndex);
globalScene.tryRemovePhase(p => p.is("PostSummonPhase") && p.player && p.fieldIndex === this.fieldIndex);
const switchType = option === PartyOption.PASS_BATON ? SwitchType.BATON_PASS : this.switchType;
globalScene.unshiftPhase(new SwitchSummonPhase(switchType, fieldIndex, slotIndex, this.doReturn));
}

1
src/phases/switch-summon-phase.ts
View File

@ -22,6 +22,7 @@ import { SubstituteTag } from "#app/data/battler-tags";
import { SwitchType } from "#enums/switch-type";
export class SwitchSummonPhase extends SummonPhase {
public readonly phaseName: "SwitchSummonPhase" | "ReturnPhase" = "SwitchSummonPhase";
private readonly switchType: SwitchType;
private readonly slotIndex: number;
private readonly doReturn: boolean;

1
src/phases/tera-phase.ts
View File

@ -9,6 +9,7 @@ import { SpeciesFormChangeTeraTrigger } from "#app/data/pokemon-forms";
import { CommonAnim, CommonBattleAnim } from "#app/data/battle-anims";
export class TeraPhase extends BattlePhase {
public readonly phaseName = "TeraPhase";
public pokemon: Pokemon;
constructor(pokemon: Pokemon) {

1
src/phases/title-phase.ts
View File

@ -29,6 +29,7 @@ import { globalScene } from "#app/global-scene";
import Overrides from "#app/overrides";
export class TitlePhase extends Phase {
public readonly phaseName = "TitlePhase";
private loaded = false;
private lastSessionData: SessionSaveData;
public gameMode: GameModes;

1
src/phases/toggle-double-position-phase.ts
View File

@ -3,6 +3,7 @@ import { FieldPosition } from "#app/field/pokemon";
import { BattlePhase } from "./battle-phase";
export class ToggleDoublePositionPhase extends BattlePhase {
public readonly phaseName = "ToggleDoublePositionPhase";
private double: boolean;
constructor(double: boolean) {

1
src/phases/trainer-victory-phase.ts
View File

@ -14,6 +14,7 @@ import { achvs } from "#app/system/achv";
import { timedEventManager } from "#app/global-event-manager";
export class TrainerVictoryPhase extends BattlePhase {
public readonly phaseName = "TrainerVictoryPhase";
start() {
globalScene.disableMenu = true;

1
src/phases/turn-end-phase.ts
View File

@ -18,6 +18,7 @@ import { PokemonHealPhase } from "./pokemon-heal-phase";
import { globalScene } from "#app/global-scene";
export class TurnEndPhase extends FieldPhase {
public readonly phaseName = "TurnEndPhase";
start() {
super.start();

1
src/phases/turn-init-phase.ts
View File

@ -15,6 +15,7 @@ import { TurnStartPhase } from "./turn-start-phase";
import { globalScene } from "#app/global-scene";
export class TurnInitPhase extends FieldPhase {
public readonly phaseName = "TurnInitPhase";
start() {
super.start();

1
src/phases/turn-start-phase.ts
View File

@ -25,6 +25,7 @@ import { globalScene } from "#app/global-scene";
import { TeraPhase } from "./tera-phase";
export class TurnStartPhase extends FieldPhase {
public readonly phaseName = "TurnStartPhase";
/**
* This orders the active Pokemon on the field by speed into an BattlerIndex array and returns that array.
* It also checks for Trick Room and reverses the array if it is present.

1
src/phases/unavailable-phase.ts
View File

@ -4,6 +4,7 @@ import { UiMode } from "#enums/ui-mode";
import { LoginPhase } from "./login-phase";
export class UnavailablePhase extends Phase {
public readonly phaseName = "UnavailablePhase";
start(): void {
globalScene.ui.setMode(UiMode.UNAVAILABLE, () => {
globalScene.unshiftPhase(new LoginPhase(true));

Some files were not shown because too many files have changed in this diff Show More