mika/pokerogue
1
0
Fork 0
mirror of https://github.com/pagefaultgames/pokerogue.git synced 2025-06-21 17:12:44 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/beta' into modifier-fixes

Browse Source
This commit is contained in:
Bertie690 2025-06-09 18:26:25 -04:00
commit 5531b3c5cd
6 changed files with 379 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2534,48 +2534,38 @@ export class AllyStatMultiplierAbAttr extends AbAttr {
}
/**
* Ability attribute for Gorilla Tactics
* @extends PostAttackAbAttr
* Takes effect whenever a move succesfully executes, such as gorilla tactics' move-locking.
* (More specifically, whenever a move is pushed to the move history)
* @extends AbAttr
*/
export class GorillaTacticsAbAttr extends PostAttackAbAttr {
constructor() {
super((_user, _target, _move) => true, false);
}
override canApplyPostAttack(
pokemon: Pokemon,
passive: boolean,
simulated: boolean,
defender: Pokemon,
move: Move,
hitResult: HitResult | null,
args: any[],
export class ExecutedMoveAbAttr extends AbAttr {
canApplyExecutedMove(
_pokemon: Pokemon,
_simulated: boolean,
): boolean {
return (
(super.canApplyPostAttack(pokemon, passive, simulated, defender, move, hitResult, args) && simulated) ||
!pokemon.getTag(BattlerTagType.GORILLA_TACTICS)
);
return true;
}
/**
*
* @param {Pokemon} pokemon the {@linkcode Pokemon} with this ability
* @param _passive n/a
* @param simulated whether the ability is being simulated
* @param _defender n/a
* @param _move n/a
* @param _hitResult n/a
* @param _args n/a
applyExecutedMove(
_pokemon: Pokemon,
_simulated: boolean,
): void {}
}
/**
* Ability attribute for Gorilla Tactics
* @extends ExecutedMoveAbAttr
*/
override applyPostAttack(
pokemon: Pokemon,
_passive: boolean,
simulated: boolean,
_defender: Pokemon,
_move: Move,
_hitResult: HitResult | null,
_args: any[],
): void {
export class GorillaTacticsAbAttr extends ExecutedMoveAbAttr {
constructor(showAbility: boolean = false) {
super(showAbility);
}
override canApplyExecutedMove(pokemon: Pokemon, simulated: boolean): boolean {
return simulated || !pokemon.getTag(BattlerTagType.GORILLA_TACTICS);
}
override applyExecutedMove(pokemon: Pokemon, simulated: boolean): void {
if (!simulated) {
pokemon.addTag(BattlerTagType.GORILLA_TACTICS);
}
@ -7797,6 +7787,22 @@ export function applyPreAttackAbAttrs(
);
}
export function applyExecutedMoveAbAttrs(
attrType: Constructor<ExecutedMoveAbAttr>,
pokemon: Pokemon,
simulated: boolean = false,
...args: any[]
): void {
applyAbAttrsInternal<ExecutedMoveAbAttr>(
attrType,
pokemon,
attr => attr.applyExecutedMove(pokemon, simulated),
attr => attr.canApplyExecutedMove(pokemon, simulated),
args,
simulated,
);
}
export function applyPostAttackAbAttrs(
attrType: Constructor<PostAttackAbAttr>,
pokemon: Pokemon,

7
src/data/balance/tms.ts
View File

@ -5988,6 +5988,7 @@ export const tmSpecies: TmSpecies = {
SpeciesId.FEZANDIPITI,
SpeciesId.ARCHALUDON,
SpeciesId.IRON_CROWN,
SpeciesId.TERAPAGOS,
SpeciesId.ALOLA_RATICATE,
SpeciesId.ALOLA_RAICHU,
SpeciesId.ALOLA_SANDSLASH,
@ -16248,6 +16249,7 @@ export const tmSpecies: TmSpecies = {
SpeciesId.CALYREX,
SpeciesId.SANDY_SHOCKS,
SpeciesId.IRON_JUGULIS,
SpeciesId.TERAPAGOS,
SpeciesId.ALOLA_DUGTRIO,
SpeciesId.GALAR_SLOWPOKE,
SpeciesId.GALAR_SLOWBRO,
@ -39466,6 +39468,8 @@ export const tmSpecies: TmSpecies = {
SpeciesId.FARFETCHD,
SpeciesId.DODUO,
SpeciesId.DODRIO,
SpeciesId.DEWGONG,
SpeciesId.GRIMER,
SpeciesId.MUK,
SpeciesId.GASTLY,
SpeciesId.HAUNTER,
@ -39477,6 +39481,7 @@ export const tmSpecies: TmSpecies = {
SpeciesId.CUBONE,
SpeciesId.MAROWAK,
SpeciesId.HITMONLEE,
SpeciesId.HITMONCHAN,
SpeciesId.LICKITUNG,
SpeciesId.TANGELA,
SpeciesId.GOLDEEN,
@ -48806,6 +48811,7 @@ export const tmSpecies: TmSpecies = {
SpeciesId.GARGANACL,
SpeciesId.GLIMMET,
SpeciesId.GLIMMORA,
SpeciesId.TERAPAGOS,
SpeciesId.ALOLA_GEODUDE,
SpeciesId.ALOLA_GRAVELER,
SpeciesId.ALOLA_GOLEM,
@ -53077,6 +53083,7 @@ export const tmSpecies: TmSpecies = {
SpeciesId.MIRAIDON,
SpeciesId.ARCHALUDON,
SpeciesId.IRON_CROWN,
SpeciesId.TERAPAGOS,
[
SpeciesId.WORMADAM,
"trash",

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

@ -3,10 +3,12 @@ import { globalScene } from "#app/global-scene";
import {
AddSecondStrikeAbAttr,
AlwaysHitAbAttr,
applyExecutedMoveAbAttrs,
applyPostAttackAbAttrs,
applyPostDamageAbAttrs,
applyPostDefendAbAttrs,
applyPreAttackAbAttrs,
ExecutedMoveAbAttr,
IgnoreMoveEffectsAbAttr,
MaxMultiHitAbAttr,
PostAttackAbAttr,
@ -380,6 +382,7 @@ export class MoveEffectPhase extends PokemonPhase {
// Add to the move history entry
if (this.firstHit) {
user.pushMoveHistory(this.moveHistoryEntry);
applyExecutedMoveAbAttrs(ExecutedMoveAbAttr, user);
}
try {

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

@ -31,6 +31,8 @@ import Overrides from "#app/overrides";
import type { CustomModifierSettings } from "#app/modifier/modifier-type";
import { isNullOrUndefined, NumberHolder } from "#app/utils/common";
export type ModifierSelectCallback = (rowCursor: number, cursor: number) => boolean;
export class SelectModifierPhase extends BattlePhase {
public readonly phaseName = "SelectModifierPhase";
private rerollCount: number;
@ -57,6 +59,10 @@ export class SelectModifierPhase extends BattlePhase {
start() {
super.start();
if (!this.isPlayer()) {
return false;
}
if (!this.rerollCount && !this.isCopy) {
this.updateSeed();
} else if (this.rerollCount) {
@ -67,27 +73,9 @@ export class SelectModifierPhase extends BattlePhase {
if (!this.isCopy) {
regenerateModifierPoolThresholds(party, this.getPoolType(), this.rerollCount);
}
const modifierCount = new NumberHolder(3);
if (this.isPlayer()) {
globalScene.applyModifiers(ExtraModifierModifier, true, modifierCount);
globalScene.applyModifiers(TempExtraModifierModifier, true, modifierCount);
}
const modifierCount = this.getModifierCount();
// If custom modifiers are specified, overrides default item count
if (this.customModifierSettings) {
const newItemCount =
(this.customModifierSettings.guaranteedModifierTiers?.length || 0) +
(this.customModifierSettings.guaranteedModifierTypeOptions?.length || 0) +
(this.customModifierSettings.guaranteedModifierTypeFuncs?.length || 0);
if (this.customModifierSettings.fillRemaining) {
const originalCount = modifierCount.value;
modifierCount.value = originalCount > newItemCount ? originalCount : newItemCount;
} else {
modifierCount.value = newItemCount;
}
}
this.typeOptions = this.getModifierTypeOptions(modifierCount.value);
this.typeOptions = this.getModifierTypeOptions(modifierCount);
const modifierSelectCallback = (rowCursor: number, cursor: number) => {
if (rowCursor < 0 || cursor < 0) {
@ -99,25 +87,105 @@ export class SelectModifierPhase extends BattlePhase {
globalScene.ui.setMode(UiMode.MESSAGE);
super.end();
},
() =>
globalScene.ui.setMode(
UiMode.MODIFIER_SELECT,
this.isPlayer(),
this.typeOptions,
modifierSelectCallback,
this.getRerollCost(globalScene.lockModifierTiers),
),
() => this.resetModifierSelect(modifierSelectCallback),
);
});
return false;
}
let modifierType: ModifierType;
let cost: number;
const rerollCost = this.getRerollCost(globalScene.lockModifierTiers);
switch (rowCursor) {
// Execute one of the options from the bottom row
case 0:
switch (cursor) {
case 0:
return this.rerollModifiers();
case 1:
return this.openModifierTransferScreen(modifierSelectCallback);
// Check the party, pass a callback to restore the modifier select screen.
case 2:
globalScene.ui.setModeWithoutClear(UiMode.PARTY, PartyUiMode.CHECK, -1, () => {
this.resetModifierSelect(modifierSelectCallback);
});
return true;
case 3:
return this.toggleRerollLock();
default:
return false;
}
// Pick an option from the rewards
case 1:
return this.selectRewardModifierOption(cursor, modifierSelectCallback);
// Pick an option from the shop
default: {
return this.selectShopModifierOption(rowCursor, cursor, modifierSelectCallback);
}
}
};
this.resetModifierSelect(modifierSelectCallback);
}
// Pick a modifier from among the rewards and apply it
private selectRewardModifierOption(cursor: number, modifierSelectCallback: ModifierSelectCallback): boolean {
if (this.typeOptions.length === 0) {
globalScene.ui.clearText();
globalScene.ui.setMode(UiMode.MESSAGE);
super.end();
return true;
}
const modifierType = this.typeOptions[cursor].type;
return this.applyChosenModifier(modifierType, 0, modifierSelectCallback);
}
// Pick a modifier from the shop and apply it
private selectShopModifierOption(
rowCursor: number,
cursor: number,
modifierSelectCallback: ModifierSelectCallback,
): boolean {
const shopOptions = getPlayerShopModifierTypeOptionsForWave(
globalScene.currentBattle.waveIndex,
globalScene.getWaveMoneyAmount(1),
);
const shopOption =
shopOptions[
rowCursor > 2 || shopOptions.length <= SHOP_OPTIONS_ROW_LIMIT ? cursor : cursor + SHOP_OPTIONS_ROW_LIMIT
];
const modifierType = shopOption.type;
// Apply Black Sludge to healing item cost
const healingItemCost = new NumberHolder(shopOption.cost);
globalScene.applyModifier(HealShopCostModifier, true, healingItemCost);
const cost = healingItemCost.value;
if (globalScene.money < cost && !Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
globalScene.ui.playError();
return false;
}
return this.applyChosenModifier(modifierType, cost, modifierSelectCallback);
}
// Apply a chosen modifier: do an effect or open the party menu
private applyChosenModifier(
modifierType: ModifierType,
cost: number,
modifierSelectCallback: ModifierSelectCallback,
): boolean {
if (modifierType instanceof PokemonModifierType) {
if (modifierType instanceof FusePokemonModifierType) {
this.openFusionMenu(modifierType, cost, modifierSelectCallback);
} else {
this.openModifierMenu(modifierType, cost, modifierSelectCallback);
}
} else {
this.applyModifier(modifierType.newModifier()!);
}
return !cost;
}
// Reroll rewards
private rerollModifiers() {
const rerollCost = this.getRerollCost(globalScene.lockModifierTiers);
if (rerollCost < 0 || globalScene.money < rerollCost) {
globalScene.ui.playError();
return false;
@ -136,8 +204,12 @@ export class SelectModifierPhase extends BattlePhase {
globalScene.animateMoneyChanged(false);
}
globalScene.playSound("se/buy");
break;
case 1:
return true;
}
// Transfer modifiers among party pokemon
private openModifierTransferScreen(modifierSelectCallback: ModifierSelectCallback) {
const party = globalScene.getPlayerParty();
globalScene.ui.setModeWithoutClear(
UiMode.PARTY,
PartyUiMode.MODIFIER_TRANSFER,
@ -151,10 +223,7 @@ export class SelectModifierPhase extends BattlePhase {
itemIndex > -1
) {
const itemModifiers = globalScene.findModifiers(
m =>
m instanceof PokemonHeldItemModifier &&
m.isTransferable &&
m.pokemonId === party[fromSlotIndex].id,
m => m instanceof PokemonHeldItemModifier && m.isTransferable && m.pokemonId === party[fromSlotIndex].id,
) as PokemonHeldItemModifier[];
const itemModifier = itemModifiers[itemIndex];
globalScene.tryTransferHeldItemModifier(
@ -162,33 +231,22 @@ export class SelectModifierPhase extends BattlePhase {
party[toSlotIndex],
true,
itemQuantity,
undefined,
undefined,
false,
);
} else {
globalScene.ui.setMode(
UiMode.MODIFIER_SELECT,
this.isPlayer(),
this.typeOptions,
modifierSelectCallback,
this.getRerollCost(globalScene.lockModifierTiers),
);
this.resetModifierSelect(modifierSelectCallback);
}
},
PartyUiHandler.FilterItemMaxStacks,
);
break;
case 2:
globalScene.ui.setModeWithoutClear(UiMode.PARTY, PartyUiMode.CHECK, -1, () => {
globalScene.ui.setMode(
UiMode.MODIFIER_SELECT,
this.isPlayer(),
this.typeOptions,
modifierSelectCallback,
this.getRerollCost(globalScene.lockModifierTiers),
);
});
break;
case 3:
return true;
}
// Toggle reroll lock
private toggleRerollLock() {
const rerollCost = this.getRerollCost(globalScene.lockModifierTiers);
if (rerollCost < 0) {
// Reroll lock button is also disabled when reroll is disabled
globalScene.ui.playError();
@ -201,44 +259,9 @@ export class SelectModifierPhase extends BattlePhase {
uiHandler.updateRerollCostText();
return false;
}
return true;
case 1:
if (this.typeOptions.length === 0) {
globalScene.ui.clearText();
globalScene.ui.setMode(UiMode.MESSAGE);
super.end();
return true;
}
if (this.typeOptions[cursor].type) {
modifierType = this.typeOptions[cursor].type;
}
break;
default:
const shopOptions = getPlayerShopModifierTypeOptionsForWave(
globalScene.currentBattle.waveIndex,
globalScene.getWaveMoneyAmount(1),
);
const shopOption =
shopOptions[
rowCursor > 2 || shopOptions.length <= SHOP_OPTIONS_ROW_LIMIT ? cursor : cursor + SHOP_OPTIONS_ROW_LIMIT
];
if (shopOption.type) {
modifierType = shopOption.type;
}
// Apply Black Sludge to healing item cost
const healingItemCost = new NumberHolder(shopOption.cost);
globalScene.applyModifier(HealShopCostModifier, true, healingItemCost);
cost = healingItemCost.value;
break;
}
if (cost! && globalScene.money < cost && !Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
// TODO: is the bang on cost correct?
globalScene.ui.playError();
return false;
}
const applyModifier = (modifier: Modifier, playSound = false) => {
// Applies the effects of the chosen modifier
private applyModifier(modifier: Modifier, cost = 0, playSound = false): void {
const result = globalScene.addModifier(modifier, false, playSound, undefined, undefined, cost);
// Queue a copy of this phase when applying a TM or Memory Mushroom.
// If the player selects either of these, then escapes out of consuming them,
@ -264,11 +287,15 @@ export class SelectModifierPhase extends BattlePhase {
globalScene.ui.setMode(UiMode.MESSAGE);
super.end();
}
};
}
if (modifierType! instanceof PokemonModifierType) {
//TODO: is the bang correct?
if (modifierType instanceof FusePokemonModifierType) {
// Opens the party menu specifically for fusions
private openFusionMenu(
modifierType: PokemonModifierType,
cost: number,
modifierSelectCallback: ModifierSelectCallback,
): void {
const party = globalScene.getPlayerParty();
globalScene.ui.setModeWithoutClear(
UiMode.PARTY,
PartyUiMode.SPLICE,
@ -282,21 +309,23 @@ export class SelectModifierPhase extends BattlePhase {
) {
globalScene.ui.setMode(UiMode.MODIFIER_SELECT, this.isPlayer()).then(() => {
const modifier = modifierType.newModifier(party[fromSlotIndex], party[spliceSlotIndex])!; //TODO: is the bang correct?
applyModifier(modifier, true);
this.applyModifier(modifier, cost, true);
});
} else {
globalScene.ui.setMode(
UiMode.MODIFIER_SELECT,
this.isPlayer(),
this.typeOptions,
modifierSelectCallback,
this.getRerollCost(globalScene.lockModifierTiers),
);
this.resetModifierSelect(modifierSelectCallback);
}
},
modifierType.selectFilter,
);
} else {
}
// Opens the party menu to apply one of various modifiers
private openModifierMenu(
modifierType: PokemonModifierType,
cost: number,
modifierSelectCallback: ModifierSelectCallback,
): void {
const party = globalScene.getPlayerParty();
const pokemonModifierType = modifierType as PokemonModifierType;
const isMoveModifier = modifierType instanceof PokemonMoveModifierType;
const isTmModifier = modifierType instanceof TmModifierType;
@ -323,16 +352,10 @@ export class SelectModifierPhase extends BattlePhase {
? modifierType.newModifier(party[slotIndex])
: modifierType.newModifier(party[slotIndex], option as number)
: modifierType.newModifier(party[slotIndex], option - PartyOption.MOVE_1);
applyModifier(modifier!, true); // TODO: is the bang correct?
this.applyModifier(modifier!, cost, true); // TODO: is the bang correct?
});
} else {
globalScene.ui.setMode(
UiMode.MODIFIER_SELECT,
this.isPlayer(),
this.typeOptions,
modifierSelectCallback,
this.getRerollCost(globalScene.lockModifierTiers),
);
this.resetModifierSelect(modifierSelectCallback);
}
},
pokemonModifierType.selectFilter,
@ -343,12 +366,33 @@ export class SelectModifierPhase extends BattlePhase {
isPpRestoreModifier,
);
}
// Function that determines how many reward slots are available
private getModifierCount(): number {
const modifierCountHolder = new NumberHolder(3);
globalScene.applyModifiers(ExtraModifierModifier, true, modifierCountHolder);
globalScene.applyModifiers(TempExtraModifierModifier, true, modifierCountHolder);
// If custom modifiers are specified, overrides default item count
if (this.customModifierSettings) {
const newItemCount =
(this.customModifierSettings.guaranteedModifierTiers?.length ?? 0) +
(this.customModifierSettings.guaranteedModifierTypeOptions?.length ?? 0) +
(this.customModifierSettings.guaranteedModifierTypeFuncs?.length ?? 0);
if (this.customModifierSettings.fillRemaining) {
const originalCount = modifierCountHolder.value;
modifierCountHolder.value = originalCount > newItemCount ? originalCount : newItemCount;
} else {
applyModifier(modifierType!.newModifier()!); // TODO: is the bang correct?
modifierCountHolder.value = newItemCount;
}
}
return !cost!; // TODO: is the bang correct?
};
return modifierCountHolder.value;
}
// Function that resets the reward selection screen,
// e.g. after pressing cancel in the party ui or while learning a move
private resetModifierSelect(modifierSelectCallback: ModifierSelectCallback) {
globalScene.ui.setMode(
UiMode.MODIFIER_SELECT,
this.isPlayer(),

2
test/abilities/dancer.test.ts
View File

@ -25,7 +25,7 @@ describe("Abilities - Dancer", () => {
beforeEach(() => {
game = new GameManager(phaserGame);
game.override.battleStyle("double");
game.override.battleStyle("double").enemyAbility(AbilityId.BALL_FETCH);
});
// Reference Link: https://bulbapedia.bulbagarden.net/wiki/Dancer_(Ability)

29
test/abilities/gorilla_tactics.test.ts
View File

@ -73,9 +73,38 @@ describe("Abilities - Gorilla Tactics", () => {
await game.toNextTurn();
game.move.select(MoveId.TACKLE);
await game.move.forceEnemyMove(MoveId.SPLASH); //prevent protect from being used by the enemy
await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
await game.phaseInterceptor.to("MoveEndPhase");
expect(darmanitan.hp).toBeLessThan(darmanitan.getMaxHp());
});
it("should activate when the opponenet protects", async () => {
await game.classicMode.startBattle([SpeciesId.GALAR_DARMANITAN]);
const darmanitan = game.field.getPlayerPokemon();
game.move.select(MoveId.TACKLE);
await game.move.selectEnemyMove(MoveId.PROTECT);
await game.toEndOfTurn();
expect(darmanitan.isMoveRestricted(MoveId.SPLASH)).toBe(true);
expect(darmanitan.isMoveRestricted(MoveId.TACKLE)).toBe(false);
});
it("should activate when a move is succesfully executed but misses", async () => {
await game.classicMode.startBattle([SpeciesId.GALAR_DARMANITAN]);
const darmanitan = game.field.getPlayerPokemon();
game.move.select(MoveId.TACKLE);
await game.move.selectEnemyMove(MoveId.SPLASH);
await game.setTurnOrder([BattlerIndex.PLAYER, BattlerIndex.ENEMY]);
await game.move.forceMiss();
await game.toEndOfTurn();
expect(darmanitan.isMoveRestricted(MoveId.SPLASH)).toBe(true);
expect(darmanitan.isMoveRestricted(MoveId.TACKLE)).toBe(false);
});
});