Merge cbeea82219 into 4b70fab608

fix: wrap setOverlayMode args in array to mystery-encounter

Co-authored-by: Sirz Benjie <142067137+SirzBenjie@users.noreply.github.com>

src/data/abilities/ability.ts

@@ -306,13 +306,6 @@ export class BlockRecoilDamageAttr extends AbAttr {
   ): void {
     cancelled.value = true;
   }
-
-  getTriggerMessage(pokemon: Pokemon, abilityName: string, ..._args: any[]) {
-    return i18next.t("abilityTriggers:blockRecoilDamage", {
-      pokemonName: getPokemonNameWithAffix(pokemon),
-      abilityName: abilityName,
-    });
-  }
 }
 
 /**

src/data/moves/move.ts

@@ -93,6 +93,10 @@ import { ChargingMove, MoveAttrMap, MoveAttrString, MoveKindString, MoveClassMap
 import { applyMoveAttrs } from "./apply-attrs";
 import { frenzyMissFunc, getMoveTargets } from "./move-utils";
 
+/**
+ * A function used to conditionally determine execution of a given {@linkcode MoveAttr}.
+ * Conventionally returns `true` for success and `false` for failure.
+*/
 type MoveConditionFunc = (user: Pokemon, target: Pokemon, move: Move) => boolean;
 export type UserMoveConditionFunc = (user: Pokemon, move: Move) => boolean;
 
@@ -1390,18 +1394,31 @@ export class BeakBlastHeaderAttr extends AddBattlerTagHeaderAttr {
   }
 }
 
+/**
+ * Attribute to display a message before a move is executed.
+ */
 export class PreMoveMessageAttr extends MoveAttr {
-  private message: string | ((user: Pokemon, target: Pokemon, move: Move) => string);
+  /** The message to display or a function returning one */
+  private message: string | ((user: Pokemon, target: Pokemon, move: Move) => string | undefined);
 
+  /**
+   * Create a new {@linkcode PreMoveMessageAttr} to display a message before move execution.
+   * @param message - The message to display before move use, either as a string or a function producing one.
+   * @remarks
+   * If {@linkcode message} evaluates to an empty string (`''`), no message will be displayed
+   * (though the move will still succeed).
+   */
   constructor(message: string | ((user: Pokemon, target: Pokemon, move: Move) => string)) {
     super();
     this.message = message;
   }
 
-  apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
-    const message = typeof this.message === "string"
-      ? this.message as string
-      : this.message(user, target, move);
+  apply(user: Pokemon, target: Pokemon, move: Move, _args: any[]): boolean {
+    const message = typeof this.message === "function"
+      ? this.message(user, target, move)
+      : this.message;
+
+    // TODO: Consider changing if/when MoveAttr `apply` return values become significant
     if (message) {
       globalScene.phaseManager.queueMessage(message, 500);
       return true;
@@ -11299,7 +11316,11 @@ export function initMoves() {
       .attr(ForceSwitchOutAttr, true, SwitchType.SHED_TAIL)
       .condition(failIfLastInPartyCondition),
     new SelfStatusMove(MoveId.CHILLY_RECEPTION, PokemonType.ICE, -1, 10, -1, 0, 9)
-      .attr(PreMoveMessageAttr, (user, move) => i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(user) }))
+      .attr(PreMoveMessageAttr, (user, _target, _move) =>
+        // Don't display text if current move phase is follow up (ie move called indirectly)
+        isVirtual((globalScene.phaseManager.getCurrentPhase() as MovePhase).useMode)
+          ? ""
+          : i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(user) }))
       .attr(ChillyReceptionAttr, true),
     new SelfStatusMove(MoveId.TIDY_UP, PokemonType.NORMAL, -1, 10, -1, 0, 9)
       .attr(StatStageChangeAttr, [ Stat.ATK, Stat.SPD ], 1, true)

src/data/mystery-encounters/encounters/clowning-around-encounter.ts

@@ -468,14 +468,52 @@ function displayYesNoOptions(resolve) {
   globalScene.ui.setModeWithoutClear(UiMode.OPTION_SELECT, config, null, true);
 }
 
+function handleRepeatedAbility(resolve, pokemon: PlayerPokemon, ability: AbilityId) {
+  showEncounterText(`${namespace}:option.1.repeated_ability`);
+  const fullOptions = [
+    {
+      label: i18next.t("menu:yes"),
+      handler: () => {
+        applyAbilityOverrideToPokemon(pokemon, ability, true);
+        globalScene.ui.setMode(UiMode.MESSAGE).then(() => resolve(true));
+        return true;
+      },
+    },
+    {
+      label: i18next.t("menu:no"),
+      handler: () => {
+        onYesAbilitySwap(resolve);
+        return true;
+      },
+    },
+  ];
+
+  const config: OptionSelectConfig = {
+    options: fullOptions,
+    maxOptions: 7,
+    yOffset: 0,
+  };
+  globalScene.ui.setModeWithoutClear(UiMode.OPTION_SELECT, config, null, true);
+}
+
 function onYesAbilitySwap(resolve) {
   const onPokemonSelected = (pokemon: PlayerPokemon) => {
     // Do ability swap
     const encounter = globalScene.currentBattle.mysteryEncounter!;
 
-    applyAbilityOverrideToPokemon(pokemon, encounter.misc.ability);
+    // Choose a random ability, to give a pokemon on the end of a battle
+    const randomAbility = encounter.misc.ability;
+    const newAbility = applyAbilityOverrideToPokemon(pokemon, randomAbility, false);
     encounter.setDialogueToken("chosenPokemon", pokemon.getNameToRender());
-    globalScene.ui.setMode(UiMode.MESSAGE).then(() => resolve(true));
+
+    globalScene.ui.setMode(UiMode.MESSAGE).then(() => {
+      // if Pokemon already has the same Ability
+      if (!newAbility) {
+        handleRepeatedAbility(resolve, pokemon, randomAbility);
+      } else {
+        resolve(true);
+      }
+    });
   };
 
   const onPokemonNotSelected = () => {

src/data/mystery-encounters/encounters/fiery-fallout-encounter.ts

@@ -250,7 +250,7 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
           queueEncounterMessage(`${namespace}:option.2.target_burned`);
 
           // Also permanently change the burned Pokemon's ability to Heatproof
-          applyAbilityOverrideToPokemon(chosenPokemon, AbilityId.HEATPROOF);
+          applyAbilityOverrideToPokemon(chosenPokemon, AbilityId.HEATPROOF, false);
         }
       }
 

src/data/mystery-encounters/utils/encounter-pokemon-utils.ts

@@ -751,7 +751,7 @@ export async function catchPokemon(
                       UiMode.POKEDEX_PAGE,
                       pokemon.species,
                       pokemon.formIndex,
-                      attributes,
+                      [attributes],
                       null,
                       () => {
                         globalScene.ui.setMode(UiMode.MESSAGE).then(() => {
@@ -1022,14 +1022,23 @@ export function isPokemonValidForEncounterOptionSelection(
 /**
  * Permanently overrides the ability (not passive) of a pokemon.
  * If the pokemon is a fusion, instead overrides the fused pokemon's ability.
+ * @param ability
+ * @param pokemon
+ * @param flagAcceptAbility
  */
-export function applyAbilityOverrideToPokemon(pokemon: Pokemon, ability: AbilityId) {
-  if (pokemon.isFusion()) {
-    if (!pokemon.fusionCustomPokemonData) {
-      pokemon.fusionCustomPokemonData = new CustomPokemonData();
-    }
-    pokemon.fusionCustomPokemonData.ability = ability;
-  } else {
-    pokemon.customPokemonData.ability = ability;
+
+export function applyAbilityOverrideToPokemon(pokemon: Pokemon, ability: AbilityId, flagAcceptAbility: boolean) {
+  const isFusion = pokemon.isFusion();
+  const data = isFusion
+    ? (pokemon.fusionCustomPokemonData ??= new CustomPokemonData())
+    : (pokemon.customPokemonData ??= new CustomPokemonData());
+
+  const shouldOverride = data.ability !== ability || flagAcceptAbility;
+
+  if (shouldOverride) {
+    data.ability = ability;
+    return true;
   }
+
+  return false;
 }

src/phases/move-phase.ts

@@ -668,6 +668,9 @@ export class MovePhase extends BattlePhase {
       }),
       500,
     );
+
+    // Moves with pre-use messages (Magnitude, Chilly Reception, Fickle Beam, etc.) always display their messages even on failure
+    // TODO: This assumes single target for message funcs - is this sustainable?
     applyMoveAttrs("PreMoveMessageAttr", this.pokemon, this.pokemon.getOpponents(false)[0], this.move.getMove());
   }
 

test/moves/chilly_reception.test.ts

@@ -1,11 +1,14 @@
-import { AbilityId } from "#enums/ability-id";
+import { RandomMoveAttr } from "#app/data/moves/move";
+import { MoveResult } from "#enums/move-result";
+import { getPokemonNameWithAffix } from "#app/messages";
 import { MoveId } from "#enums/move-id";
 import { SpeciesId } from "#enums/species-id";
+import { AbilityId } from "#app/enums/ability-id";
 import { WeatherType } from "#enums/weather-type";
 import GameManager from "#test/testUtils/gameManager";
+import i18next from "i18next";
 import Phaser from "phaser";
-//import { TurnInitPhase } from "#app/phases/turn-init-phase";
-import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 describe("Moves - Chilly Reception", () => {
   let phaserGame: Phaser.Game;
@@ -25,95 +28,121 @@ describe("Moves - Chilly Reception", () => {
     game = new GameManager(phaserGame);
     game.override
       .battleStyle("single")
-      .moveset([MoveId.CHILLY_RECEPTION, MoveId.SNOWSCAPE])
+      .moveset([MoveId.CHILLY_RECEPTION, MoveId.SNOWSCAPE, MoveId.SPLASH, MoveId.METRONOME])
       .enemyMoveset(MoveId.SPLASH)
       .enemyAbility(AbilityId.BALL_FETCH)
       .ability(AbilityId.BALL_FETCH);
   });
 
-  it("should still change the weather if user can't switch out", async () => {
+  it("should display message before use, switch the user out and change the weather to snow", async () => {
+    await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
+
+    const [slowking, meowth] = game.scene.getPlayerParty();
+
+    game.move.select(MoveId.CHILLY_RECEPTION);
+    game.doSelectPartyPokemon(1);
+    await game.toEndOfTurn();
+
+    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.scene.getPlayerPokemon()).toBe(meowth);
+    expect(slowking.isOnField()).toBe(false);
+    expect(game.phaseInterceptor.log).toContain("SwitchSummonPhase");
+    expect(game.textInterceptor.logs).toContain(
+      i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(slowking) }),
+    );
+  });
+
+  it("should still change weather if user can't switch out", async () => {
     await game.classicMode.startBattle([SpeciesId.SLOWKING]);
 
     game.move.select(MoveId.CHILLY_RECEPTION);
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.phaseInterceptor.log).not.toContain("SwitchSummonPhase");
+    expect(game.scene.getPlayerPokemon()?.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS);
   });
 
-  it("should switch out even if it's snowing", async () => {
+  it("should still switch out even if weather cannot be changed", async () => {
     await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
-    // first turn set up snow with snowscape, try chilly reception on second turn
+
+    expect(game.scene.arena.weather?.weatherType).not.toBe(WeatherType.SNOW);
+
+    const [slowking, meowth] = game.scene.getPlayerParty();
+
     game.move.select(MoveId.SNOWSCAPE);
-    await game.phaseInterceptor.to("BerryPhase", false);
+    await game.toNextTurn();
+
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
 
-    await game.phaseInterceptor.to("TurnInitPhase", false);
     game.move.select(MoveId.CHILLY_RECEPTION);
     game.doSelectPartyPokemon(1);
+    // TODO: Uncomment lines once wimp out PR fixes force switches to not reset summon data immediately
+    //  await game.phaseInterceptor.to("SwitchSummonPhase", false);
+    //  expect(slowking.getLastXMoves()[0].result).toBe(MoveResult.SUCCESS);
+
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    expect(game.scene.getPlayerField()[0].species.speciesId).toBe(SpeciesId.MEOWTH);
+    expect(game.phaseInterceptor.log).toContain("SwitchSummonPhase");
+    expect(game.scene.getPlayerPokemon()).toBe(meowth);
+    expect(slowking.isOnField()).toBe(false);
   });
 
-  it("happy case - switch out and weather changes", async () => {
+  // Source: https://replay.pokemonshowdown.com/gen9ou-2367532550
+  it("should fail (while still displaying message) if neither weather change nor switch out succeeds", async () => {
+    await game.classicMode.startBattle([SpeciesId.SLOWKING]);
+
+    expect(game.scene.arena.weather?.weatherType).not.toBe(WeatherType.SNOW);
+
+    const slowking = game.scene.getPlayerPokemon()!;
+
+    game.move.select(MoveId.SNOWSCAPE);
+    await game.toNextTurn();
+
+    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+
+    game.move.select(MoveId.CHILLY_RECEPTION);
+    game.doSelectPartyPokemon(1);
+    await game.toEndOfTurn();
+
+    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.phaseInterceptor.log).not.toContain("SwitchSummonPhase");
+    expect(game.scene.getPlayerPokemon()).toBe(slowking);
+    expect(slowking.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+    expect(game.textInterceptor.logs).toContain(
+      i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(slowking) }),
+    );
+  });
+
+  it("should succeed without message if called indirectly", async () => {
+    vi.spyOn(RandomMoveAttr.prototype, "getMoveOverride").mockReturnValue(MoveId.CHILLY_RECEPTION);
     await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
 
-    game.move.select(MoveId.CHILLY_RECEPTION);
-    game.doSelectPartyPokemon(1);
+    const [slowking, meowth] = game.scene.getPlayerParty();
+
+    game.move.select(MoveId.METRONOME);
+    game.doSelectPartyPokemon(1);
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
     expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    expect(game.scene.getPlayerField()[0].species.speciesId).toBe(SpeciesId.MEOWTH);
+    expect(game.scene.getPlayerPokemon()).toBe(meowth);
+    expect(slowking.isOnField()).toBe(false);
+    expect(game.phaseInterceptor.log).toContain("SwitchSummonPhase");
+    expect(game.textInterceptor.logs).not.toContain(
+      i18next.t("moveTriggers:chillyReception", { pokemonName: getPokemonNameWithAffix(slowking) }),
+    );
   });
 
-  // enemy uses another move and weather doesn't change
-  it("check case - enemy not selecting chilly reception doesn't change weather ", async () => {
-    game.override.battleStyle("single").enemyMoveset([MoveId.CHILLY_RECEPTION, MoveId.TACKLE]).moveset(MoveId.SPLASH);
-
+  // Bugcheck test for enemy AI bug
+  it("check case - enemy not selecting chilly reception doesn't change weather", async () => {
+    game.override.enemyMoveset([MoveId.CHILLY_RECEPTION, MoveId.TACKLE]);
     await game.classicMode.startBattle([SpeciesId.SLOWKING, SpeciesId.MEOWTH]);
 
     game.move.select(MoveId.SPLASH);
     await game.move.selectEnemyMove(MoveId.TACKLE);
+    await game.toEndOfTurn();
 
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(undefined);
-  });
-
-  it("enemy trainer - expected behavior ", async () => {
-    game.override
-      .battleStyle("single")
-      .startingWave(8)
-      .enemyMoveset(MoveId.CHILLY_RECEPTION)
-      .enemySpecies(SpeciesId.MAGIKARP)
-      .moveset([MoveId.SPLASH, MoveId.THUNDERBOLT]);
-
-    await game.classicMode.startBattle([SpeciesId.JOLTEON]);
-    const RIVAL_MAGIKARP1 = game.scene.getEnemyPokemon()?.id;
-
-    game.move.select(MoveId.SPLASH);
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    expect(game.scene.getEnemyPokemon()?.id !== RIVAL_MAGIKARP1);
-
-    await game.phaseInterceptor.to("TurnInitPhase", false);
-    game.move.select(MoveId.SPLASH);
-
-    // second chilly reception should still switch out
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    await game.phaseInterceptor.to("TurnInitPhase", false);
-    expect(game.scene.getEnemyPokemon()?.id === RIVAL_MAGIKARP1);
-    game.move.select(MoveId.THUNDERBOLT);
-
-    // enemy chilly recep move should fail: it's snowing and no option to switch out
-    // no crashing
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    await game.phaseInterceptor.to("TurnInitPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
-    game.move.select(MoveId.SPLASH);
-    await game.phaseInterceptor.to("BerryPhase", false);
-    expect(game.scene.arena.weather?.weatherType).toBe(WeatherType.SNOW);
+    expect(game.scene.arena.weather?.weatherType).toBeUndefined();
   });
 });

test/mystery-encounter/encounters/clowning-around-encounter.test.ts

@@ -37,6 +37,7 @@ import { CommandPhase } from "#app/phases/command-phase";
 import { MovePhase } from "#app/phases/move-phase";
 import { SelectModifierPhase } from "#app/phases/select-modifier-phase";
 import { NewBattlePhase } from "#app/phases/new-battle-phase";
+import { allAbilities } from "#app/data/data-lists";
 
 const namespace = "mysteryEncounters/clowningAround";
 const defaultParty = [SpeciesId.LAPRAS, SpeciesId.GENGAR, SpeciesId.ABRA];
@@ -233,6 +234,58 @@ describe("Clowning Around - Mystery Encounter", () => {
       const leadPokemon = scene.getPlayerParty()[0];
       expect(leadPokemon.customPokemonData?.ability).toBe(abilityToTrain);
     });
+
+    it("should let the player know their pokemon already has the ability and accept it", async () => {
+      await game.runToMysteryEncounter(MysteryEncounterType.CLOWNING_AROUND, defaultParty);
+      await runMysteryEncounterToEnd(game, 1, undefined, true);
+      await skipBattleRunMysteryEncounterRewardsPhase(game);
+      await game.phaseInterceptor.to(SelectModifierPhase, false);
+      expect(scene.phaseManager.getCurrentPhase()?.constructor.name).toBe(SelectModifierPhase.name);
+      await game.phaseInterceptor.run(SelectModifierPhase);
+
+      const leadPokemon = scene.getPlayerParty()[0];
+      // offer Prankster abiliy for winning the battle
+      const abilityToTrain = AbilityId.PRANKSTER;
+
+      game.onNextPrompt("PostMysteryEncounterPhase", UiMode.MESSAGE, () => {
+        game.scene.ui.getHandler().processInput(Button.ACTION);
+      });
+
+      // Give fto the first Pokemon the Prankster ability
+      vi.spyOn(leadPokemon, "getAbility").mockReturnValue(allAbilities[AbilityId.PRANKSTER]);
+
+      // Run to ability train option selection
+      const optionSelectUiHandler = game.scene.ui.handlers[UiMode.OPTION_SELECT] as OptionSelectUiHandler;
+      vi.spyOn(optionSelectUiHandler, "show");
+      const partyUiHandler = game.scene.ui.handlers[UiMode.PARTY] as PartyUiHandler;
+      vi.spyOn(partyUiHandler, "show");
+      const optionSelectUiHandlerRepeatedAbility = game.scene.ui.handlers[
+        UiMode.OPTION_SELECT
+      ] as OptionSelectUiHandler;
+      vi.spyOn(optionSelectUiHandlerRepeatedAbility, "show");
+      game.endPhase();
+      await game.phaseInterceptor.to(PostMysteryEncounterPhase);
+      expect(scene.phaseManager.getCurrentPhase()?.constructor.name).toBe(PostMysteryEncounterPhase.name);
+
+      // Wait for Yes/No confirmation to appear -> accepting the Ability
+      await vi.waitFor(() => expect(optionSelectUiHandler.show).toHaveBeenCalled());
+      // Select "Yes" on train ability
+      optionSelectUiHandler.processInput(Button.ACTION);
+      // Select first pokemon in party to train
+      await vi.waitFor(() => expect(partyUiHandler.show).toHaveBeenCalled());
+      partyUiHandler.processInput(Button.ACTION);
+      // Click "Select" on Pokemon
+      partyUiHandler.processInput(Button.ACTION);
+      // Wait for Yes/No confirmation to appear -> Accepting the Ability, besides being repeated
+      await vi.waitFor(() => expect(optionSelectUiHandlerRepeatedAbility.show).toHaveBeenCalled());
+      // Select "Yes" on train the same ability as before
+      optionSelectUiHandlerRepeatedAbility.processInput(Button.ACTION);
+
+      // Stop next battle before it runs
+      await game.phaseInterceptor.to(NewBattlePhase, false);
+
+      expect(leadPokemon.getAbility().id).toBe(abilityToTrain);
+    });
   });
 
   describe("Option 2 - Remain Unprovoked", () => {