Merge branch 'beta' into commander

src/battle-scene.ts

@@ -4,7 +4,7 @@ import Pokemon, { EnemyPokemon, PlayerPokemon } from "#app/field/pokemon";
 import PokemonSpecies, { allSpecies, getPokemonSpecies, PokemonSpeciesFilter } from "#app/data/pokemon-species";
 import { Constructor, isNullOrUndefined, randSeedInt } from "#app/utils";
 import * as Utils from "#app/utils";
-import { ConsumableModifier, ConsumablePokemonModifier, DoubleBattleChanceBoosterModifier, ExpBalanceModifier, ExpShareModifier, FusePokemonModifier, HealingBoosterModifier, Modifier, ModifierBar, ModifierPredicate, MultipleParticipantExpBonusModifier, overrideHeldItems, overrideModifiers, PersistentModifier, PokemonExpBoosterModifier, PokemonFormChangeItemModifier, PokemonHeldItemModifier, PokemonHpRestoreModifier, PokemonIncrementingStatModifier, TerastallizeModifier, TurnHeldItemTransferModifier } from "./modifier/modifier";
+import { ConsumableModifier, ConsumablePokemonModifier, DoubleBattleChanceBoosterModifier, ExpBalanceModifier, ExpShareModifier, FusePokemonModifier, HealingBoosterModifier, Modifier, ModifierBar, ModifierPredicate, MultipleParticipantExpBonusModifier, overrideHeldItems, overrideModifiers, PersistentModifier, PokemonExpBoosterModifier, PokemonFormChangeItemModifier, PokemonHeldItemModifier, PokemonHpRestoreModifier, PokemonIncrementingStatModifier, RememberMoveModifier, TerastallizeModifier, TurnHeldItemTransferModifier } from "./modifier/modifier";
 import { PokeballType } from "#app/data/pokeball";
 import { initCommonAnims, initMoveAnim, loadCommonAnimAssets, loadMoveAnimAssets, populateAnims } from "#app/data/battle-anims";
 import { Phase } from "#app/phase";
@@ -96,6 +96,7 @@ import { ShowPartyExpBarPhase } from "#app/phases/show-party-exp-bar-phase";
 import { MysteryEncounterMode } from "#enums/mystery-encounter-mode";
 import { ExpGainsSpeed } from "#enums/exp-gains-speed";
 import { BattlerTagType } from "#enums/battler-tag-type";
+import { FRIENDSHIP_GAIN_FROM_BATTLE } from "#app/data/balance/starters";
 
 export const bypassLogin = import.meta.env.VITE_BYPASS_LOGIN === "1";
 
@@ -790,7 +791,7 @@ export default class BattleScene extends SceneBase {
   }
 
   getEnemyParty(): EnemyPokemon[] {
-    return this.currentBattle?.enemyParty || [];
+    return this.currentBattle?.enemyParty ?? [];
   }
 
   getEnemyPokemon(): EnemyPokemon | undefined {
@@ -2428,7 +2429,7 @@ export default class BattleScene extends SceneBase {
     return Math.floor(moneyValue / 10) * 10;
   }
 
-  addModifier(modifier: Modifier | null, ignoreUpdate?: boolean, playSound?: boolean, virtual?: boolean, instant?: boolean): Promise<boolean> {
+  addModifier(modifier: Modifier | null, ignoreUpdate?: boolean, playSound?: boolean, virtual?: boolean, instant?: boolean, cost?: number): Promise<boolean> {
     if (!modifier) {
       return Promise.resolve(false);
     }
@@ -2485,6 +2486,8 @@ export default class BattleScene extends SceneBase {
               }
             } else if (modifier instanceof FusePokemonModifier) {
               args.push(this.getPokemonById(modifier.fusePokemonId) as PlayerPokemon);
+            } else if (modifier instanceof RememberMoveModifier && !Utils.isNullOrUndefined(cost)) {
+              args.push(cost);
             }
 
             if (modifier.shouldApply(pokemon, ...args)) {
@@ -3055,7 +3058,7 @@ export default class BattleScene extends SceneBase {
         const pId = partyMember.id;
         const participated = participantIds.has(pId);
         if (participated && pokemonDefeated) {
-          partyMember.addFriendship(2);
+          partyMember.addFriendship(FRIENDSHIP_GAIN_FROM_BATTLE);
           const machoBraceModifier = partyMember.getHeldItems().find(m => m instanceof PokemonIncrementingStatModifier);
           if (machoBraceModifier && machoBraceModifier.stackCount < machoBraceModifier.getMaxStackCount(this)) {
             machoBraceModifier.stackCount++;

src/data/balance/starters.ts

@@ -2,6 +2,12 @@ import { Species } from "#enums/species";
 
 export const POKERUS_STARTER_COUNT = 5;
 
+// #region Friendship constants
+export const CLASSIC_CANDY_FRIENDSHIP_MULTIPLIER = 2;
+export const FRIENDSHIP_GAIN_FROM_BATTLE = 2;
+export const FRIENDSHIP_GAIN_FROM_RARE_CANDY = 5;
+export const FRIENDSHIP_LOSS_FROM_FAINT = 10;
+
 /**
  * Function to get the cumulative friendship threshold at which a candy is earned
  * @param starterCost The cost of the starter, found in {@linkcode speciesStarterCosts}

src/data/move.ts

@@ -1028,7 +1028,7 @@ export class MoveEffectAttr extends MoveAttr {
 
     applyAbAttrs(MoveEffectChanceMultiplierAbAttr, user, null, false, moveChance, move, target, selfEffect, showAbility);
 
-    if (!move.hasAttr(FlinchAttr) || moveChance.value <= move.chance) {
+    if ((!move.hasAttr(FlinchAttr) || moveChance.value <= move.chance) && !move.hasAttr(SecretPowerAttr)) {
       const userSide = user.isPlayer() ? ArenaTagSide.PLAYER : ArenaTagSide.ENEMY;
       user.scene.arena.applyTagsForSide(ArenaTagType.WATER_FIRE_PLEDGE, userSide, false, moveChance);
     }
@@ -2879,6 +2879,162 @@ export class StatStageChangeAttr extends MoveEffectAttr {
   }
 }
 
+/**
+ * Attribute used to determine the Biome/Terrain-based secondary effect of Secret Power
+ */
+export class SecretPowerAttr extends MoveEffectAttr {
+  constructor() {
+    super(false);
+  }
+
+  /**
+   * Used to determine if the move should apply a secondary effect based on Secret Power's 30% chance
+   * @returns `true` if the move's secondary effect should apply
+   */
+  override canApply(user: Pokemon, target: Pokemon, move: Move, args?: any[]): boolean {
+    this.effectChanceOverride = move.chance;
+    const moveChance = this.getMoveChance(user, target, move, this.selfTarget);
+    if (moveChance < 0 || moveChance === 100 || user.randSeedInt(100) < moveChance) {
+      // effectChanceOverride used in the application of the actual secondary effect
+      this.effectChanceOverride = 100;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * Used to apply the secondary effect to the target Pokemon
+   * @returns `true` if a secondary effect is successfully applied
+   */
+  override apply(user: Pokemon, target: Pokemon, move: Move, args?: any[]): boolean | Promise<boolean> {
+    if (!super.apply(user, target, move, args)) {
+      return false;
+    }
+    let secondaryEffect: MoveEffectAttr;
+    const terrain = user.scene.arena.getTerrainType();
+    if (terrain !== TerrainType.NONE) {
+      secondaryEffect = this.determineTerrainEffect(terrain);
+    } else {
+      const biome = user.scene.arena.biomeType;
+      secondaryEffect = this.determineBiomeEffect(biome);
+    }
+    return secondaryEffect.apply(user, target, move, []);
+  }
+
+  /**
+   * Determines the secondary effect based on terrain.
+   * Takes precedence over biome-based effects.
+   * ```
+   * Electric Terrain | Paralysis
+   * Misty Terrain    | SpAtk -1
+   * Grassy Terrain   | Sleep
+   * Psychic Terrain  | Speed -1
+   * ```
+   * @param terrain - {@linkcode TerrainType} The current terrain
+   * @returns the chosen secondary effect {@linkcode MoveEffectAttr}
+   */
+  private determineTerrainEffect(terrain: TerrainType): MoveEffectAttr {
+    let secondaryEffect: MoveEffectAttr;
+    switch (terrain) {
+    case TerrainType.ELECTRIC:
+    default:
+      secondaryEffect = new StatusEffectAttr(StatusEffect.PARALYSIS, false);
+      break;
+    case TerrainType.MISTY:
+      secondaryEffect = new StatStageChangeAttr([ Stat.SPATK ], -1, false);
+      break;
+    case TerrainType.GRASSY:
+      secondaryEffect = new StatusEffectAttr(StatusEffect.SLEEP, false);
+      break;
+    case TerrainType.PSYCHIC:
+      secondaryEffect = new StatStageChangeAttr([ Stat.SPD ], -1, false);
+      break;
+    }
+    return secondaryEffect;
+  }
+
+  /**
+   * Determines the secondary effect based on biome
+   * ```
+   * Town, Metropolis, Slum, Dojo, Laboratory, Power Plant + Default | Paralysis
+   * Plains, Grass, Tall Grass, Forest, Jungle, Meadow               | Sleep
+   * Swamp, Mountain, Temple, Ruins                                  | Speed -1
+   * Ice Cave, Snowy Forest                                          | Freeze
+   * Volcano                                                         | Burn
+   * Fairy Cave                                                      | SpAtk -1
+   * Desert, Construction Site, Beach, Island, Badlands              | Accuracy -1
+   * Sea, Lake, Seabed                                               | Atk -1
+   * Cave, Wasteland, Graveyard, Abyss, Space                        | Flinch
+   * End                                                             | Def -1
+   * ```
+   * @param biome - The current {@linkcode Biome} the battle is set in
+   * @returns the chosen secondary effect {@linkcode MoveEffectAttr}
+   */
+  private determineBiomeEffect(biome: Biome): MoveEffectAttr {
+    let secondaryEffect: MoveEffectAttr;
+    switch (biome) {
+    case Biome.PLAINS:
+    case Biome.GRASS:
+    case Biome.TALL_GRASS:
+    case Biome.FOREST:
+    case Biome.JUNGLE:
+    case Biome.MEADOW:
+      secondaryEffect = new StatusEffectAttr(StatusEffect.SLEEP, false);
+      break;
+    case Biome.SWAMP:
+    case Biome.MOUNTAIN:
+    case Biome.TEMPLE:
+    case Biome.RUINS:
+      secondaryEffect = new StatStageChangeAttr([ Stat.SPD ], -1, false);
+      break;
+    case Biome.ICE_CAVE:
+    case Biome.SNOWY_FOREST:
+      secondaryEffect = new StatusEffectAttr(StatusEffect.FREEZE, false);
+      break;
+    case Biome.VOLCANO:
+      secondaryEffect = new StatusEffectAttr(StatusEffect.BURN, false);
+      break;
+    case Biome.FAIRY_CAVE:
+      secondaryEffect = new StatStageChangeAttr([ Stat.SPATK ], -1, false);
+      break;
+    case Biome.DESERT:
+    case Biome.CONSTRUCTION_SITE:
+    case Biome.BEACH:
+    case Biome.ISLAND:
+    case Biome.BADLANDS:
+      secondaryEffect = new StatStageChangeAttr([ Stat.ACC ], -1, false);
+      break;
+    case Biome.SEA:
+    case Biome.LAKE:
+    case Biome.SEABED:
+      secondaryEffect = new StatStageChangeAttr([ Stat.ATK ], -1, false);
+      break;
+    case Biome.CAVE:
+    case Biome.WASTELAND:
+    case Biome.GRAVEYARD:
+    case Biome.ABYSS:
+    case Biome.SPACE:
+      secondaryEffect = new AddBattlerTagAttr(BattlerTagType.FLINCHED, false, true);
+      break;
+    case Biome.END:
+      secondaryEffect = new StatStageChangeAttr([ Stat.DEF ], -1, false);
+      break;
+    case Biome.TOWN:
+    case Biome.METROPOLIS:
+    case Biome.SLUM:
+    case Biome.DOJO:
+    case Biome.FACTORY:
+    case Biome.LABORATORY:
+    case Biome.POWER_PLANT:
+    default:
+      secondaryEffect = new StatusEffectAttr(StatusEffect.PARALYSIS, false);
+      break;
+    }
+    return secondaryEffect;
+  }
+}
+
 export class PostVictoryStatStageChangeAttr extends MoveAttr {
   private stats: BattleStat[];
   private stages: number;
@@ -3873,8 +4029,8 @@ export class LastMoveDoublePowerAttr extends VariablePowerAttr {
 
     for (const p of pokemonActed) {
       const [ lastMove ] = p.getLastXMoves(1);
-      if (lastMove.result !== MoveResult.FAIL) {
+      if (lastMove?.result !== MoveResult.FAIL) {
-        if ((lastMove.result === MoveResult.SUCCESS) && (lastMove.move === this.move)) {
+        if ((lastMove?.result === MoveResult.SUCCESS) && (lastMove?.move === this.move)) {
           power.value *= 2;
           return true;
         } else {
@@ -4775,7 +4931,7 @@ export class AddBattlerTagAttr extends MoveEffectAttr {
   }
 
   canApply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
-    if (!super.canApply(user, target, move, args) || (this.cancelOnFail === true && user.getLastXMoves(1)[0].result === MoveResult.FAIL)) {
+    if (!super.canApply(user, target, move, args) || (this.cancelOnFail === true && user.getLastXMoves(1)[0]?.result === MoveResult.FAIL)) {
       return false;
     } else {
       return true;
@@ -5213,7 +5369,7 @@ export class AddArenaTagAttr extends MoveEffectAttr {
       return false;
     }
 
-    if ((move.chance < 0 || move.chance === 100 || user.randSeedInt(100) < move.chance) && user.getLastXMoves(1)[0].result === MoveResult.SUCCESS) {
+    if ((move.chance < 0 || move.chance === 100 || user.randSeedInt(100) < move.chance) && user.getLastXMoves(1)[0]?.result === MoveResult.SUCCESS) {
       user.scene.arena.addTag(this.tagType, this.turnCount, move.id, user.id, (this.selfSideTarget ? user : target).isPlayer() ? ArenaTagSide.PLAYER : ArenaTagSide.ENEMY);
       return true;
     }
@@ -5288,7 +5444,7 @@ export class AddArenaTrapTagHitAttr extends AddArenaTagAttr {
     const moveChance = this.getMoveChance(user, target, move, this.selfTarget, true);
     const side = (this.selfSideTarget ? user : target).isPlayer() ? ArenaTagSide.PLAYER : ArenaTagSide.ENEMY;
     const tag = user.scene.arena.getTagOnSide(this.tagType, side) as ArenaTrapTag;
-    if ((moveChance < 0 || moveChance === 100 || user.randSeedInt(100) < moveChance) && user.getLastXMoves(1)[0].result === MoveResult.SUCCESS) {
+    if ((moveChance < 0 || moveChance === 100 || user.randSeedInt(100) < moveChance) && user.getLastXMoves(1)[0]?.result === MoveResult.SUCCESS) {
       user.scene.arena.addTag(this.tagType, 0, move.id, user.id, side);
       if (!tag) {
         return true;
@@ -5425,7 +5581,7 @@ export class AddPledgeEffectAttr extends AddArenaTagAttr {
 
   override apply(user: Pokemon, target: Pokemon, move: Move, args: any[]): boolean {
     // TODO: add support for `HIT` effect triggering in AddArenaTagAttr to remove the need for this check
-    if (user.getLastXMoves(1)[0].result !== MoveResult.SUCCESS) {
+    if (user.getLastXMoves(1)[0]?.result !== MoveResult.SUCCESS) {
       return false;
     }
 
@@ -7945,7 +8101,7 @@ export function initMoves() {
       .unimplemented(),
     new AttackMove(Moves.SECRET_POWER, Type.NORMAL, MoveCategory.PHYSICAL, 70, 100, 20, 30, 0, 3)
       .makesContact(false)
-      .partial(), // No effect implemented
+      .attr(SecretPowerAttr),
     new AttackMove(Moves.DIVE, Type.WATER, MoveCategory.PHYSICAL, 80, 100, 10, -1, 0, 3)
       .attr(ChargeAttr, ChargeAnim.DIVE_CHARGING, i18next.t("moveTriggers:hidUnderwater", { pokemonName: "{USER}" }), BattlerTagType.UNDERWATER, true)
       .attr(GulpMissileTagAttr)

src/data/mystery-encounters/encounters/a-trainers-test-encounter.ts

@@ -154,7 +154,7 @@ export const ATrainersTestEncounter: MysteryEncounter =
         };
         encounter.setDialogueToken("eggType", i18next.t(`${namespace}:eggTypes.epic`));
         setEncounterRewards(scene, { guaranteedModifierTypeFuncs: [ modifierTypes.SACRED_ASH ], guaranteedModifierTiers: [ ModifierTier.ROGUE, ModifierTier.ULTRA ], fillRemaining: true }, [ eggOptions ]);
-        return initBattleWithEnemyConfig(scene, config);
+        await initBattleWithEnemyConfig(scene, config);
       }
     )
     .withSimpleOption(

src/data/mystery-encounters/encounters/absolute-avarice-encounter.ts

@@ -286,7 +286,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter =
             ignorePp: true
           });
 
-          transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
+          await transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
           await initBattleWithEnemyConfig(scene, encounter.enemyPartyConfigs[0]);
         })
         .build()
@@ -328,7 +328,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter =
           });
           await scene.updateModifiers(true);
 
-          transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
+          await transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
           leaveEncounterWithoutBattle(scene, true);
         })
         .build()
@@ -359,7 +359,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter =
           greedent.moveset = [ new PokemonMove(Moves.THRASH), new PokemonMove(Moves.BODY_PRESS), new PokemonMove(Moves.STUFF_CHEEKS), new PokemonMove(Moves.SLACK_OFF) ];
           greedent.passive = true;
 
-          transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
+          await transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
           await catchPokemon(scene, greedent, null, PokeballType.POKEBALL, false);
           leaveEncounterWithoutBattle(scene, true);
         })

src/data/mystery-encounters/encounters/dancing-lessons-encounter.ts

@@ -228,7 +228,7 @@ export const DancingLessonsEncounter: MysteryEncounter =
         })
         .withOptionPhase(async (scene: BattleScene) => {
           // Learn its Dance
-          hideOricorioPokemon(scene);
+          await hideOricorioPokemon(scene);
           leaveEncounterWithoutBattle(scene, true);
         })
         .build()
@@ -303,7 +303,7 @@ export const DancingLessonsEncounter: MysteryEncounter =
             }
           }
 
-          hideOricorioPokemon(scene);
+          await hideOricorioPokemon(scene);
           await catchPokemon(scene, oricorio, null, PokeballType.POKEBALL, false);
           leaveEncounterWithoutBattle(scene, true);
         })

src/data/mystery-encounters/encounters/dark-deal-encounter.ts

@@ -182,7 +182,7 @@ export const DarkDealEncounter: MysteryEncounter =
           const config: EnemyPartyConfig = {
             pokemonConfigs: [ pokemonConfig ],
           };
-          return initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .build()
     )

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

@@ -222,12 +222,13 @@ export const FieryFalloutEncounter: MysteryEncounter =
           ],
         })
         .withPreOptionPhase(async (scene: BattleScene) => {
+          // Do NOT await this, to prevent player from repeatedly pressing options
           transitionMysteryEncounterIntroVisuals(scene, false, false, 2000);
         })
         .withOptionPhase(async (scene: BattleScene) => {
           // Fire types help calm the Volcarona
           const encounter = scene.currentBattle.mysteryEncounter!;
-          transitionMysteryEncounterIntroVisuals(scene);
+          await transitionMysteryEncounterIntroVisuals(scene);
           setEncounterRewards(scene,
             { fillRemaining: true },
             undefined,

src/data/mystery-encounters/encounters/fun-and-games-encounter.ts

@@ -152,7 +152,7 @@ export const FunAndGamesEncounter: MysteryEncounter =
       },
       async (scene: BattleScene) => {
         // Leave encounter with no rewards or exp
-        transitionMysteryEncounterIntroVisuals(scene, true, true);
+        await transitionMysteryEncounterIntroVisuals(scene, true, true);
         leaveEncounterWithoutBattle(scene, true);
         return true;
       }

src/data/mystery-encounters/encounters/global-trade-system-encounter.ts

@@ -399,7 +399,7 @@ export const GlobalTradeSystemEncounter: MysteryEncounter =
           if (modifier.stackCount === 0) {
             scene.removeModifier(modifier);
           }
-          scene.updateModifiers(true, true);
+          await scene.updateModifiers(true, true);
 
           // Generate a trainer name
           const traderName = generateRandomTraderName();

src/data/mystery-encounters/encounters/lost-at-sea-encounter.ts

@@ -129,7 +129,7 @@ export const LostAtSeaEncounter: MysteryEncounter = MysteryEncounterBuilder.with
  *
  * @param scene Battle scene
  */
-async function handlePokemonGuidingYouPhase(scene: BattleScene) {
+function handlePokemonGuidingYouPhase(scene: BattleScene) {
   const laprasSpecies = getPokemonSpecies(Species.LAPRAS);
   const { mysteryEncounter } = scene.currentBattle;
 

src/data/mystery-encounters/encounters/mysterious-challengers-encounter.ts

@@ -147,11 +147,11 @@ export const MysteriousChallengersEncounter: MysteryEncounter =
         setEncounterRewards(scene, { guaranteedModifierTypeFuncs: [ modifierTypes.TM_COMMON, modifierTypes.TM_GREAT, modifierTypes.MEMORY_MUSHROOM ], fillRemaining: true });
 
         // Seed offsets to remove possibility of different trainers having exact same teams
-        let ret;
+        let initBattlePromise: Promise<void>;
         scene.executeWithSeedOffset(() => {
-          ret = initBattleWithEnemyConfig(scene, config);
+          initBattlePromise = initBattleWithEnemyConfig(scene, config);
         }, scene.currentBattle.waveIndex * 10);
-        return ret;
+        await initBattlePromise!;
       }
     )
     .withSimpleOption(
@@ -172,11 +172,11 @@ export const MysteriousChallengersEncounter: MysteryEncounter =
         setEncounterRewards(scene, { guaranteedModifierTiers: [ ModifierTier.ULTRA, ModifierTier.ULTRA, ModifierTier.GREAT, ModifierTier.GREAT ], fillRemaining: true });
 
         // Seed offsets to remove possibility of different trainers having exact same teams
-        let ret;
+        let initBattlePromise: Promise<void>;
         scene.executeWithSeedOffset(() => {
-          ret = initBattleWithEnemyConfig(scene, config);
+          initBattlePromise = initBattleWithEnemyConfig(scene, config);
         }, scene.currentBattle.waveIndex * 100);
-        return ret;
+        await initBattlePromise!;
       }
     )
     .withSimpleOption(
@@ -200,11 +200,11 @@ export const MysteriousChallengersEncounter: MysteryEncounter =
         setEncounterRewards(scene, { guaranteedModifierTiers: [ ModifierTier.ROGUE, ModifierTier.ROGUE, ModifierTier.ULTRA, ModifierTier.GREAT ], fillRemaining: true });
 
         // Seed offsets to remove possibility of different trainers having exact same teams
-        let ret;
+        let initBattlePromise: Promise<void>;
         scene.executeWithSeedOffset(() => {
-          ret = initBattleWithEnemyConfig(scene, config);
+          initBattlePromise = initBattleWithEnemyConfig(scene, config);
         }, scene.currentBattle.waveIndex * 1000);
-        return ret;
+        await initBattlePromise!;
       }
     )
     .withOutroDialogue([

src/data/mystery-encounters/encounters/mysterious-chest-encounter.ts

@@ -184,7 +184,7 @@ export const MysteriousChestEncounter: MysteryEncounter =
               scene.unshiftPhase(new GameOverPhase(scene));
             } else {
               // Show which Pokemon was KOed, then start battle against Gimmighoul
-              transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
+              await transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
               setEncounterRewards(scene, { fillRemaining: true });
               await initBattleWithEnemyConfig(scene, encounter.enemyPartyConfigs[0]);
             }

src/data/mystery-encounters/encounters/safari-zone-encounter.ts

@@ -303,13 +303,11 @@ async function summonSafariPokemon(scene: BattleScene) {
   scene.unshiftPhase(new SummonPhase(scene, 0, false));
 
   encounter.setDialogueToken("pokemonName", getPokemonNameWithAffix(pokemon));
-  showEncounterText(scene, getEncounterText(scene, "battle:singleWildAppeared") ?? "", null, 1500, false)
+
-    .then(() => {
+  const ivScannerModifier = scene.findModifier(m => m instanceof IvScannerModifier);
-      const ivScannerModifier = scene.findModifier(m => m instanceof IvScannerModifier);
+  if (ivScannerModifier) {
-      if (ivScannerModifier) {
+    scene.pushPhase(new ScanIvsPhase(scene, pokemon.getBattlerIndex(), Math.min(ivScannerModifier.getStackCount() * 2, 6)));
-        scene.pushPhase(new ScanIvsPhase(scene, pokemon.getBattlerIndex(), Math.min(ivScannerModifier.getStackCount() * 2, 6)));
+  }
-      }
-    });
 }
 
 function throwPokeball(scene: BattleScene, pokemon: EnemyPokemon): Promise<boolean> {

src/data/mystery-encounters/encounters/shady-vitamin-dealer-encounter.ts

@@ -142,7 +142,7 @@ export const ShadyVitaminDealerEncounter: MysteryEncounter =
           encounter.setDialogueToken("newNature", getNatureName(newNature));
           queueEncounterMessage(scene, `${namespace}:cheap_side_effects`);
           setEncounterExp(scene, [ chosenPokemon.id ], 100);
-          chosenPokemon.updateInfo();
+          await chosenPokemon.updateInfo();
         })
         .build()
     )
@@ -204,7 +204,7 @@ export const ShadyVitaminDealerEncounter: MysteryEncounter =
           queueEncounterMessage(scene, `${namespace}:no_bad_effects`);
           setEncounterExp(scene, [ chosenPokemon.id ], 100);
 
-          chosenPokemon.updateInfo();
+          await chosenPokemon.updateInfo();
         })
         .build()
     )

src/data/mystery-encounters/encounters/teleporting-hijinks-encounter.ts

@@ -149,7 +149,7 @@ export const TeleportingHijinksEncounter: MysteryEncounter =
         const magnet = generateModifierTypeOption(scene, modifierTypes.ATTACK_TYPE_BOOSTER, [ Type.STEEL ])!;
         const metalCoat = generateModifierTypeOption(scene, modifierTypes.ATTACK_TYPE_BOOSTER, [ Type.ELECTRIC ])!;
         setEncounterRewards(scene, { guaranteedModifierTypeOptions: [ magnet, metalCoat ], fillRemaining: true });
-        transitionMysteryEncounterIntroVisuals(scene, true, true);
+        await transitionMysteryEncounterIntroVisuals(scene, true, true);
         await initBattleWithEnemyConfig(scene, config);
       }
     )

src/data/mystery-encounters/encounters/the-expert-pokemon-breeder-encounter.ts

@@ -245,7 +245,7 @@ export const TheExpertPokemonBreederEncounter: MysteryEncounter =
           }
 
           encounter.onGameOver = onGameOver;
-          initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .withPostOptionPhase(async (scene: BattleScene) => {
           await doPostEncounterCleanup(scene);
@@ -297,7 +297,7 @@ export const TheExpertPokemonBreederEncounter: MysteryEncounter =
           }
 
           encounter.onGameOver = onGameOver;
-          initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .withPostOptionPhase(async (scene: BattleScene) => {
           await doPostEncounterCleanup(scene);
@@ -349,7 +349,7 @@ export const TheExpertPokemonBreederEncounter: MysteryEncounter =
           }
 
           encounter.onGameOver = onGameOver;
-          initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .withPostOptionPhase(async (scene: BattleScene) => {
           await doPostEncounterCleanup(scene);

src/data/mystery-encounters/encounters/the-strong-stuff-encounter.ts

@@ -201,7 +201,7 @@ export const TheStrongStuffEncounter: MysteryEncounter =
           });
 
         encounter.dialogue.outro = [];
-        transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
+        await transitionMysteryEncounterIntroVisuals(scene, true, true, 500);
         await initBattleWithEnemyConfig(scene, encounter.enemyPartyConfigs[0]);
       }
     )

src/data/mystery-encounters/encounters/the-winstrate-challenge-encounter.ts

@@ -112,8 +112,8 @@ export const TheWinstrateChallengeEncounter: MysteryEncounter =
       },
       async (scene: BattleScene) => {
         // Spawn 5 trainer battles back to back with Macho Brace in rewards
-        scene.currentBattle.mysteryEncounter!.doContinueEncounter = (scene: BattleScene) => {
+        scene.currentBattle.mysteryEncounter!.doContinueEncounter = async (scene: BattleScene) => {
-          return endTrainerBattleAndShowDialogue(scene);
+          await endTrainerBattleAndShowDialogue(scene);
         };
         await transitionMysteryEncounterIntroVisuals(scene, true, false);
         await spawnNextTrainerOrEndEncounter(scene);

src/data/mystery-encounters/encounters/training-session-encounter.ts

@@ -162,7 +162,7 @@ export const TrainingSessionEncounter: MysteryEncounter =
 
           setEncounterRewards(scene, { fillRemaining: true }, undefined, onBeforeRewardsPhase);
 
-          return initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .build()
     )
@@ -238,7 +238,7 @@ export const TrainingSessionEncounter: MysteryEncounter =
 
           setEncounterRewards(scene, { fillRemaining: true }, undefined, onBeforeRewardsPhase);
 
-          return initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .build()
     )
@@ -351,7 +351,7 @@ export const TrainingSessionEncounter: MysteryEncounter =
 
           setEncounterRewards(scene, { fillRemaining: true }, undefined, onBeforeRewardsPhase);
 
-          return initBattleWithEnemyConfig(scene, config);
+          await initBattleWithEnemyConfig(scene, config);
         })
         .build()
     )

src/data/mystery-encounters/encounters/trash-to-treasure-encounter.ts

@@ -105,7 +105,7 @@ export const TrashToTreasureEncounter: MysteryEncounter =
         })
         .withOptionPhase(async (scene: BattleScene) => {
           // Gain 2 Leftovers and 2 Shell Bell
-          transitionMysteryEncounterIntroVisuals(scene);
+          await transitionMysteryEncounterIntroVisuals(scene);
           await tryApplyDigRewardItems(scene);
 
           const blackSludge = generateModifierType(scene, modifierTypes.MYSTERY_ENCOUNTER_BLACK_SLUDGE, [ SHOP_ITEM_COST_MULTIPLIER ]);
@@ -136,7 +136,7 @@ export const TrashToTreasureEncounter: MysteryEncounter =
           // Investigate garbage, battle Gmax Garbodor
           scene.setFieldScale(0.75);
           await showEncounterText(scene, `${namespace}:option.2.selected_2`);
-          transitionMysteryEncounterIntroVisuals(scene);
+          await transitionMysteryEncounterIntroVisuals(scene);
 
           const encounter = scene.currentBattle.mysteryEncounter!;
 
@@ -222,7 +222,7 @@ async function tryApplyDigRewardItems(scene: BattleScene) {
   await showEncounterText(scene, i18next.t("battle:rewardGainCount", { modifierName: shellBell.name, count: 2 }), null, undefined, true);
 }
 
-async function doGarbageDig(scene: BattleScene) {
+function doGarbageDig(scene: BattleScene) {
   scene.playSound("battle_anims/PRSFX- Dig2");
   scene.time.delayedCall(SOUND_EFFECT_WAIT_TIME, () => {
     scene.playSound("battle_anims/PRSFX- Dig2");

src/field/pokemon.ts

@@ -5,7 +5,7 @@ import { variantData } from "#app/data/variant";
 import BattleInfo, { PlayerBattleInfo, EnemyBattleInfo } from "#app/ui/battle-info";
 import Move, { HighCritAttr, HitsTagAttr, applyMoveAttrs, FixedDamageAttr, VariableAtkAttr, allMoves, MoveCategory, TypelessAttr, CritOnlyAttr, getMoveTargets, OneHitKOAttr, VariableMoveTypeAttr, VariableDefAttr, AttackMove, ModifiedDamageAttr, VariableMoveTypeMultiplierAttr, IgnoreOpponentStatStagesAttr, SacrificialAttr, VariableMoveCategoryAttr, CounterDamageAttr, StatStageChangeAttr, RechargeAttr, ChargeAttr, IgnoreWeatherTypeDebuffAttr, BypassBurnDamageReductionAttr, SacrificialAttrOnHit, OneHitKOAccuracyAttr, RespectAttackTypeImmunityAttr, MoveTarget, CombinedPledgeStabBoostAttr } from "#app/data/move";
 import { default as PokemonSpecies, PokemonSpeciesForm, getFusedSpeciesName, getPokemonSpecies, getPokemonSpeciesForm } from "#app/data/pokemon-species";
-import { getStarterValueFriendshipCap, speciesStarterCosts } from "#app/data/balance/starters";
+import { CLASSIC_CANDY_FRIENDSHIP_MULTIPLIER, getStarterValueFriendshipCap, speciesStarterCosts } from "#app/data/balance/starters";
 import { starterPassiveAbilities } from "#app/data/balance/passives";
 import { Constructor, isNullOrUndefined, randSeedInt } from "#app/utils";
 import * as Utils from "#app/utils";
@@ -2815,16 +2815,17 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       if (this.isFainted()) {
         // set splice index here, so future scene queues happen before FaintedPhase
         this.scene.setPhaseQueueSplice();
-        this.scene.unshiftPhase(new FaintPhase(this.scene, this.getBattlerIndex(), isOneHitKo));
+        if (!isNullOrUndefined(destinyTag) && dmg) {
+          // Destiny Bond will activate during FaintPhase
+          this.scene.unshiftPhase(new FaintPhase(this.scene, this.getBattlerIndex(), isOneHitKo, destinyTag, source));
+        } else {
+          this.scene.unshiftPhase(new FaintPhase(this.scene, this.getBattlerIndex(), isOneHitKo));
+        }
         this.destroySubstitute();
         this.lapseTag(BattlerTagType.COMMANDED);
         this.resetSummonData();
       }
 
-      if (dmg) {
-        destinyTag?.lapse(source, BattlerTagLapseType.CUSTOM);
-      }
-
       return result;
     }
   }
@@ -4088,7 +4089,7 @@ export class PlayerPokemon extends Pokemon {
       fusionStarterSpeciesId ? this.scene.gameData.starterData[fusionStarterSpeciesId] : null
     ].filter(d => !!d);
     const amount = new Utils.IntegerHolder(friendship);
-    const starterAmount = new Utils.IntegerHolder(Math.floor(friendship * (this.scene.gameMode.isClassic && friendship > 0 ? 2 : 1) / (fusionStarterSpeciesId ? 2 : 1)));
+    const starterAmount = new Utils.IntegerHolder(Math.floor(friendship * (this.scene.gameMode.isClassic && friendship > 0 ? CLASSIC_CANDY_FRIENDSHIP_MULTIPLIER : 1) / (fusionStarterSpeciesId ? 2 : 1)));
     if (amount.value > 0) {
       this.scene.applyModifier(PokemonFriendshipBoosterModifier, true, this, amount);
       this.scene.applyModifier(PokemonFriendshipBoosterModifier, true, this, starterAmount);

src/modifier/modifier-type.ts

@@ -2227,7 +2227,8 @@ export function getPlayerShopModifierTypeOptionsForWave(waveIndex: integer, base
     ],
     [
       new ModifierTypeOption(modifierTypes.HYPER_POTION(), 0, baseCost * 0.8),
-      new ModifierTypeOption(modifierTypes.MAX_REVIVE(), 0, baseCost * 2.75)
+      new ModifierTypeOption(modifierTypes.MAX_REVIVE(), 0, baseCost * 2.75),
+      new ModifierTypeOption(modifierTypes.MEMORY_MUSHROOM(), 0, baseCost * 4)
     ],
     [
       new ModifierTypeOption(modifierTypes.MAX_POTION(), 0, baseCost * 1.5),

src/modifier/modifier.ts

@@ -11,7 +11,7 @@ import Pokemon, { type PlayerPokemon } from "#app/field/pokemon";
 import { getPokemonNameWithAffix } from "#app/messages";
 import Overrides from "#app/overrides";
 import { EvolutionPhase } from "#app/phases/evolution-phase";
-import { LearnMovePhase } from "#app/phases/learn-move-phase";
+import { LearnMovePhase, LearnMoveType } from "#app/phases/learn-move-phase";
 import { LevelUpPhase } from "#app/phases/level-up-phase";
 import { PokemonHealPhase } from "#app/phases/pokemon-heal-phase";
 import { achvs } from "#app/system/achv";
@@ -30,6 +30,7 @@ import { StatusEffect } from "#enums/status-effect";
 import i18next from "i18next";
 import { type DoubleBattleChanceBoosterModifierType, type EvolutionItemModifierType, type FormChangeItemModifierType, type ModifierOverride, type ModifierType, type PokemonBaseStatTotalModifierType, type PokemonExpBoosterModifierType, type PokemonFriendshipBoosterModifierType, type PokemonMoveAccuracyBoosterModifierType, type PokemonMultiHitModifierType, type TerastallizeModifierType, type TmModifierType, getModifierType, ModifierPoolType, ModifierTypeGenerator, modifierTypes, PokemonHeldItemModifierType } from "./modifier-type";
 import { Color, ShadowColor } from "#enums/color";
+import { FRIENDSHIP_GAIN_FROM_RARE_CANDY } from "#app/data/balance/starters";
 
 export type ModifierPredicate = (modifier: Modifier) => boolean;
 
@@ -2213,7 +2214,7 @@ export class PokemonLevelIncrementModifier extends ConsumablePokemonModifier {
       playerPokemon.levelExp = 0;
     }
 
-    playerPokemon.addFriendship(5);
+    playerPokemon.addFriendship(FRIENDSHIP_GAIN_FROM_RARE_CANDY);
 
     playerPokemon.scene.unshiftPhase(new LevelUpPhase(playerPokemon.scene, playerPokemon.scene.getParty().indexOf(playerPokemon), playerPokemon.level - levelCount.value, playerPokemon.level));
 
@@ -2235,7 +2236,7 @@ export class TmModifier extends ConsumablePokemonModifier {
    */
   override apply(playerPokemon: PlayerPokemon): boolean {
 
-    playerPokemon.scene.unshiftPhase(new LearnMovePhase(playerPokemon.scene, playerPokemon.scene.getParty().indexOf(playerPokemon), this.type.moveId, true));
+    playerPokemon.scene.unshiftPhase(new LearnMovePhase(playerPokemon.scene, playerPokemon.scene.getParty().indexOf(playerPokemon), this.type.moveId, LearnMoveType.TM));
 
     return true;
   }
@@ -2255,8 +2256,9 @@ export class RememberMoveModifier extends ConsumablePokemonModifier {
    * @param playerPokemon The {@linkcode PlayerPokemon} that should remember the move
    * @returns always `true`
    */
-  override apply(playerPokemon: PlayerPokemon): boolean {
+  override apply(playerPokemon: PlayerPokemon, cost?: number): boolean {
-    playerPokemon.scene.unshiftPhase(new LearnMovePhase(playerPokemon.scene, playerPokemon.scene.getParty().indexOf(playerPokemon), playerPokemon.getLearnableLevelMoves()[this.levelMoveIndex]));
+
+    playerPokemon.scene.unshiftPhase(new LearnMovePhase(playerPokemon.scene, playerPokemon.scene.getParty().indexOf(playerPokemon), playerPokemon.getLearnableLevelMoves()[this.levelMoveIndex], LearnMoveType.MEMORY, cost));
 
     return true;
   }

src/phases/faint-phase.ts

@@ -1,12 +1,12 @@
 import BattleScene from "#app/battle-scene";
 import { BattlerIndex, BattleType } from "#app/battle";
 import { applyPostFaintAbAttrs, PostFaintAbAttr, applyPostKnockOutAbAttrs, PostKnockOutAbAttr, applyPostVictoryAbAttrs, PostVictoryAbAttr } from "#app/data/ability";
-import { BattlerTagLapseType } from "#app/data/battler-tags";
+import { BattlerTagLapseType, DestinyBondTag } from "#app/data/battler-tags";
 import { battleSpecDialogue } from "#app/data/dialogue";
 import { allMoves, PostVictoryStatStageChangeAttr } from "#app/data/move";
 import { BattleSpec } from "#app/enums/battle-spec";
 import { StatusEffect } from "#app/enums/status-effect";
-import { PokemonMove, EnemyPokemon, PlayerPokemon, HitResult } from "#app/field/pokemon";
+import Pokemon, { PokemonMove, EnemyPokemon, PlayerPokemon, HitResult } from "#app/field/pokemon";
 import { getPokemonNameWithAffix } from "#app/messages";
 import { PokemonInstantReviveModifier } from "#app/modifier/modifier";
 import i18next from "i18next";
@@ -19,19 +19,40 @@ import { SwitchPhase } from "./switch-phase";
 import { VictoryPhase } from "./victory-phase";
 import { SpeciesFormChangeActiveTrigger } from "#app/data/pokemon-forms";
 import { SwitchType } from "#enums/switch-type";
+import { isNullOrUndefined } from "#app/utils";
+import { FRIENDSHIP_LOSS_FROM_FAINT } from "#app/data/balance/starters";
 
 export class FaintPhase extends PokemonPhase {
+  /**
+   * Whether or not enduring (for this phase's purposes, Reviver Seed) should be prevented
+   */
   private preventEndure: boolean;
 
-  constructor(scene: BattleScene, battlerIndex: BattlerIndex, preventEndure?: boolean) {
+  /**
+   * Destiny Bond tag belonging to the currently fainting Pokemon, if applicable
+   */
+  private destinyTag?: DestinyBondTag;
+
+  /**
+   * The source Pokemon that dealt fatal damage and should get KO'd by Destiny Bond, if applicable
+   */
+  private source?: Pokemon;
+
+  constructor(scene: BattleScene, battlerIndex: BattlerIndex, preventEndure: boolean = false, destinyTag?: DestinyBondTag, source?: Pokemon) {
     super(scene, battlerIndex);
 
-    this.preventEndure = preventEndure!; // TODO: is this bang correct?
+    this.preventEndure = preventEndure;
+    this.destinyTag = destinyTag;
+    this.source = source;
   }
 
   start() {
     super.start();
 
+    if (!isNullOrUndefined(this.destinyTag) && !isNullOrUndefined(this.source)) {
+      this.destinyTag.lapse(this.source, BattlerTagLapseType.CUSTOM);
+    }
+
     if (!this.preventEndure) {
       const instantReviveModifier = this.scene.applyModifier(PokemonInstantReviveModifier, this.player, this.getPokemon()) as PokemonInstantReviveModifier;
 
@@ -127,7 +148,7 @@ export class FaintPhase extends PokemonPhase {
 
     pokemon.faintCry(() => {
       if (pokemon instanceof PlayerPokemon) {
-        pokemon.addFriendship(-10);
+        pokemon.addFriendship(-FRIENDSHIP_LOSS_FROM_FAINT);
       }
       pokemon.hideInfo();
       this.scene.playSound("se/faint");

src/phases/learn-move-phase.ts

@@ -2,24 +2,37 @@ import BattleScene from "#app/battle-scene";
 import { initMoveAnim, loadMoveAnimAssets } from "#app/data/battle-anims";
 import Move, { allMoves } from "#app/data/move";
 import { SpeciesFormChangeMoveLearnedTrigger } from "#app/data/pokemon-forms";
-import { Moves } from "#app/enums/moves";
+import { Moves } from "#enums/moves";
 import { getPokemonNameWithAffix } from "#app/messages";
+import Overrides from "#app/overrides";
 import EvolutionSceneHandler from "#app/ui/evolution-scene-handler";
 import { SummaryUiMode } from "#app/ui/summary-ui-handler";
 import { Mode } from "#app/ui/ui";
 import i18next from "i18next";
-import { PlayerPartyMemberPokemonPhase } from "./player-party-member-pokemon-phase";
+import { PlayerPartyMemberPokemonPhase } from "#app/phases/player-party-member-pokemon-phase";
 import 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 */
+  LEARN_MOVE,
+  /** For learning a move via Memory Mushroom */
+  MEMORY,
+  /** For learning a move via TM */
+  TM
+}
 
 export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
   private moveId: Moves;
   private messageMode: Mode;
-  private fromTM: boolean;
+  private learnMoveType;
+  private cost: number;
 
-  constructor(scene: BattleScene, partyMemberIndex: integer, moveId: Moves, fromTM?: boolean) {
+  constructor(scene: BattleScene, partyMemberIndex: integer, moveId: Moves, learnMoveType: LearnMoveType = LearnMoveType.LEARN_MOVE, cost: number = -1) {
     super(scene, partyMemberIndex);
     this.moveId = moveId;
-    this.fromTM = fromTM ?? false;
+    this.learnMoveType = learnMoveType;
+    this.cost = cost;
   }
 
   start() {
@@ -136,11 +149,23 @@ export class LearnMovePhase extends PlayerPartyMemberPokemonPhase {
    * @param Pokemon The Pokemon learning the move
    */
   async learnMove(index: number, move: Move, pokemon: Pokemon, textMessage?: string) {
-    if (this.fromTM) {
+    if (this.learnMoveType === LearnMoveType.TM) {
       if (!pokemon.usedTMs) {
         pokemon.usedTMs = [];
       }
       pokemon.usedTMs.push(this.moveId);
+      this.scene.tryRemovePhase((phase) => phase instanceof SelectModifierPhase);
+    } else if (this.learnMoveType === LearnMoveType.MEMORY) {
+      if (this.cost !== -1) {
+        if (!Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
+          this.scene.money -= this.cost;
+          this.scene.updateMoneyText();
+          this.scene.animateMoneyChanged(false);
+        }
+        this.scene.playSound("se/buy");
+      } else {
+        this.scene.tryRemovePhase((phase) => phase instanceof SelectModifierPhase);
+      }
     }
     pokemon.setMove(index, this.moveId);
     initMoveAnim(this.scene, this.moveId).then(() => {

src/phases/select-modifier-phase.ts

@@ -16,26 +16,32 @@ export class SelectModifierPhase extends BattlePhase {
   private rerollCount: integer;
   private modifierTiers?: ModifierTier[];
   private customModifierSettings?: CustomModifierSettings;
+  private isCopy: boolean;
 
-  constructor(scene: BattleScene, rerollCount: integer = 0, modifierTiers?: ModifierTier[], customModifierSettings?: CustomModifierSettings) {
+  private typeOptions: ModifierTypeOption[];
+
+  constructor(scene: BattleScene, rerollCount: integer = 0, modifierTiers?: ModifierTier[], customModifierSettings?: CustomModifierSettings, isCopy: boolean = false) {
     super(scene);
 
     this.rerollCount = rerollCount;
     this.modifierTiers = modifierTiers;
     this.customModifierSettings = customModifierSettings;
+    this.isCopy = isCopy;
   }
 
   start() {
     super.start();
 
-    if (!this.rerollCount) {
+    if (!this.rerollCount && !this.isCopy) {
       this.updateSeed();
-    } else {
+    } else if (this.rerollCount) {
       this.scene.reroll = false;
     }
 
     const party = this.scene.getParty();
-    regenerateModifierPoolThresholds(party, this.getPoolType(), this.rerollCount);
+    if (!this.isCopy) {
+      regenerateModifierPoolThresholds(party, this.getPoolType(), this.rerollCount);
+    }
     const modifierCount = new Utils.IntegerHolder(3);
     if (this.isPlayer()) {
       this.scene.applyModifiers(ExtraModifierModifier, true, modifierCount);
@@ -54,7 +60,7 @@ export class SelectModifierPhase extends BattlePhase {
       }
     }
 
-    const typeOptions: ModifierTypeOption[] = this.getModifierTypeOptions(modifierCount.value);
+    this.typeOptions = this.getModifierTypeOptions(modifierCount.value);
 
     const modifierSelectCallback = (rowCursor: integer, cursor: integer) => {
       if (rowCursor < 0 || cursor < 0) {
@@ -63,13 +69,13 @@ export class SelectModifierPhase extends BattlePhase {
             this.scene.ui.revertMode();
             this.scene.ui.setMode(Mode.MESSAGE);
             super.end();
-          }, () => this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers)));
+          }, () => this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), this.typeOptions, modifierSelectCallback, this.getRerollCost(this.scene.lockModifierTiers)));
         });
         return false;
       }
       let modifierType: ModifierType;
       let cost: integer;
-      const rerollCost = this.getRerollCost(typeOptions, this.scene.lockModifierTiers);
+      const rerollCost = this.getRerollCost(this.scene.lockModifierTiers);
       switch (rowCursor) {
       case 0:
         switch (cursor) {
@@ -79,7 +85,7 @@ export class SelectModifierPhase extends BattlePhase {
             return false;
           } else {
             this.scene.reroll = true;
-            this.scene.unshiftPhase(new SelectModifierPhase(this.scene, this.rerollCount + 1, typeOptions.map(o => o.type?.tier).filter(t => t !== undefined) as ModifierTier[]));
+            this.scene.unshiftPhase(new SelectModifierPhase(this.scene, this.rerollCount + 1, this.typeOptions.map(o => o.type?.tier).filter(t => t !== undefined) as ModifierTier[]));
             this.scene.ui.clearText();
             this.scene.ui.setMode(Mode.MESSAGE).then(() => super.end());
             if (!Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
@@ -98,13 +104,13 @@ export class SelectModifierPhase extends BattlePhase {
               const itemModifier = itemModifiers[itemIndex];
               this.scene.tryTransferHeldItemModifier(itemModifier, party[toSlotIndex], true, itemQuantity);
             } else {
-              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), this.typeOptions, modifierSelectCallback, this.getRerollCost(this.scene.lockModifierTiers));
             }
           }, PartyUiHandler.FilterItemMaxStacks);
           break;
         case 2:
           this.scene.ui.setModeWithoutClear(Mode.PARTY, PartyUiMode.CHECK, -1, () => {
-            this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+            this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), this.typeOptions, modifierSelectCallback, this.getRerollCost(this.scene.lockModifierTiers));
           });
           break;
         case 3:
@@ -115,21 +121,21 @@ export class SelectModifierPhase extends BattlePhase {
           }
           this.scene.lockModifierTiers = !this.scene.lockModifierTiers;
           const uiHandler = this.scene.ui.getHandler() as ModifierSelectUiHandler;
-          uiHandler.setRerollCost(this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+          uiHandler.setRerollCost(this.getRerollCost(this.scene.lockModifierTiers));
           uiHandler.updateLockRaritiesText();
           uiHandler.updateRerollCostText();
           return false;
         }
         return true;
       case 1:
-        if (typeOptions.length === 0) {
+        if (this.typeOptions.length === 0) {
           this.scene.ui.clearText();
           this.scene.ui.setMode(Mode.MESSAGE);
           super.end();
           return true;
         }
-        if (typeOptions[cursor].type) {
+        if (this.typeOptions[cursor].type) {
-          modifierType = typeOptions[cursor].type;
+          modifierType = this.typeOptions[cursor].type;
         }
         break;
       default:
@@ -151,8 +157,16 @@ export class SelectModifierPhase extends BattlePhase {
       }
 
       const applyModifier = (modifier: Modifier, playSound: boolean = false) => {
-        const result = this.scene.addModifier(modifier, false, playSound);
+        const result = this.scene.addModifier(modifier, false, playSound, undefined, undefined, cost);
-        if (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,
+        // they are returned to a shop in the same state.
+        if (modifier.type instanceof RememberMoveModifierType ||
+            modifier.type instanceof TmModifierType) {
+          this.scene.unshiftPhase(this.copy());
+        }
+
+        if (cost && !(modifier.type instanceof RememberMoveModifierType)) {
           result.then(success => {
             if (success) {
               if (!Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
@@ -189,7 +203,7 @@ export class SelectModifierPhase extends BattlePhase {
                 applyModifier(modifier, true);
               });
             } else {
-              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), this.typeOptions, modifierSelectCallback, this.getRerollCost(this.scene.lockModifierTiers));
             }
           }, modifierType.selectFilter);
         } else {
@@ -216,7 +230,7 @@ export class SelectModifierPhase extends BattlePhase {
                 applyModifier(modifier!, true); // TODO: is the bang correct?
               });
             } else {
-              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), this.typeOptions, modifierSelectCallback, this.getRerollCost(this.scene.lockModifierTiers));
             }
           }, pokemonModifierType.selectFilter, modifierType instanceof PokemonMoveModifierType ? (modifierType as PokemonMoveModifierType).moveSelectFilter : undefined, tmMoveId, isPpRestoreModifier);
         }
@@ -226,7 +240,7 @@ export class SelectModifierPhase extends BattlePhase {
 
       return !cost!;// TODO: is the bang correct?
     };
-    this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+    this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), this.typeOptions, modifierSelectCallback, this.getRerollCost(this.scene.lockModifierTiers));
   }
 
   updateSeed(): void {
@@ -237,13 +251,13 @@ export class SelectModifierPhase extends BattlePhase {
     return true;
   }
 
-  getRerollCost(typeOptions: ModifierTypeOption[], lockRarities: boolean): number {
+  getRerollCost(lockRarities: boolean): number {
     let baseValue = 0;
     if (Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
       return baseValue;
     } else if (lockRarities) {
       const tierValues = [ 50, 125, 300, 750, 2000 ];
-      for (const opt of typeOptions) {
+      for (const opt of this.typeOptions) {
         baseValue += tierValues[opt.type.tier ?? 0];
       }
     } else {
@@ -271,6 +285,16 @@ export class SelectModifierPhase extends BattlePhase {
     return getPlayerModifierTypeOptions(modifierCount, this.scene.getParty(), this.scene.lockModifierTiers ? this.modifierTiers : undefined, this.customModifierSettings);
   }
 
+  copy(): SelectModifierPhase {
+    return new SelectModifierPhase(
+      this.scene,
+      this.rerollCount,
+      this.modifierTiers,
+      { guaranteedModifierTypeOptions: this.typeOptions, rerollMultiplier: this.customModifierSettings?.rerollMultiplier, allowLuckUpgrades: false },
+      true
+    );
+  }
+
   addModifier(modifier: Modifier): Promise<boolean> {
     return this.scene.addModifier(modifier, false, true);
   }

src/test/items/lock_capsule.test.ts

@@ -1,7 +1,8 @@
 import { Abilities } from "#app/enums/abilities";
 import { Moves } from "#app/enums/moves";
-import { ModifierTypeOption, modifierTypes } from "#app/modifier/modifier-type";
+import { ModifierTier } from "#app/modifier/modifier-tier";
 import { SelectModifierPhase } from "#app/phases/select-modifier-phase";
+import { Mode } from "#app/ui/ui";
 import GameManager from "#test/utils/gameManager";
 import Phase from "phaser";
 import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
@@ -32,15 +33,16 @@ describe("Items - Lock Capsule", () => {
   });
 
   it("doesn't set the cost of common tier items to 0", async () => {
-    await game.startBattle();
+    await game.classicMode.startBattle();
+    game.scene.overridePhase(new SelectModifierPhase(game.scene, 0, undefined, { guaranteedModifierTiers: [ ModifierTier.COMMON, ModifierTier.COMMON, ModifierTier.COMMON ], fillRemaining: false }));
 
-    game.move.select(Moves.SURF);
+    game.onNextPrompt("SelectModifierPhase", Mode.MODIFIER_SELECT, () => {
-    await game.phaseInterceptor.to(SelectModifierPhase, false);
+      const selectModifierPhase = game.scene.getCurrentPhase() as SelectModifierPhase;
+      const rerollCost = selectModifierPhase.getRerollCost(true);
+      expect(rerollCost).toBe(150);
+    });
 
-    const rewards = game.scene.getCurrentPhase() as SelectModifierPhase;
+    game.doSelectModifier();
-    const potion = new ModifierTypeOption(modifierTypes.POTION(), 0, 40); // Common tier item
+    await game.phaseInterceptor.to("SelectModifierPhase");
-    const rerollCost = rewards.getRerollCost([ potion, potion, potion ], true);
-
-    expect(rerollCost).toBe(150);
   }, 20000);
 });

src/test/moves/destiny_bond.test.ts

@@ -0,0 +1,255 @@
+import { ArenaTagSide, ArenaTrapTag } from "#app/data/arena-tag";
+import { allMoves } from "#app/data/move";
+import { Abilities } from "#enums/abilities";
+import { ArenaTagType } from "#enums/arena-tag-type";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { BattlerIndex } from "#app/battle";
+import { StatusEffect } from "#enums/status-effect";
+import { PokemonInstantReviveModifier } from "#app/modifier/modifier";
+
+
+describe("Moves - Destiny Bond", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+
+  const defaultParty = [ Species.BULBASAUR, Species.SQUIRTLE ];
+  const enemyFirst = [ BattlerIndex.ENEMY, BattlerIndex.PLAYER ];
+  const playerFirst = [ BattlerIndex.PLAYER, BattlerIndex.ENEMY ];
+
+  beforeAll(() => {
+    phaserGame = new Phaser.Game({
+      type: Phaser.HEADLESS,
+    });
+  });
+
+  afterEach(() => {
+    game.phaseInterceptor.restoreOg();
+  });
+
+  beforeEach(() => {
+    game = new GameManager(phaserGame);
+    game.override.battleType("single")
+      .ability(Abilities.UNNERVE) // Pre-emptively prevent flakiness from opponent berries
+      .enemySpecies(Species.RATTATA)
+      .enemyAbility(Abilities.RUN_AWAY)
+      .startingLevel(100) // Make sure tested moves KO
+      .enemyLevel(5)
+      .enemyMoveset(Moves.DESTINY_BOND);
+  });
+
+  it("should KO the opponent on the same turn", async () => {
+    const moveToUse = Moves.TACKLE;
+
+    game.override.moveset(moveToUse);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    game.move.select(moveToUse);
+    await game.setTurnOrder(enemyFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(true);
+  });
+
+  it("should KO the opponent on the next turn", async () => {
+    const moveToUse = Moves.TACKLE;
+
+    game.override.moveset([ Moves.SPLASH, moveToUse ]);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    // Turn 1: Enemy uses Destiny Bond and doesn't faint
+    game.move.select(Moves.SPLASH);
+    await game.setTurnOrder(playerFirst);
+    await game.toNextTurn();
+
+    expect(enemyPokemon?.isFainted()).toBe(false);
+    expect(playerPokemon?.isFainted()).toBe(false);
+
+    // Turn 2: Player KO's the enemy before the enemy's turn
+    game.move.select(moveToUse);
+    await game.setTurnOrder(playerFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(true);
+  });
+
+  it("should fail if used twice in a row", async () => {
+    const moveToUse = Moves.TACKLE;
+
+    game.override.moveset([ Moves.SPLASH, moveToUse ]);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    // Turn 1: Enemy uses Destiny Bond and doesn't faint
+    game.move.select(Moves.SPLASH);
+    await game.setTurnOrder(enemyFirst);
+    await game.toNextTurn();
+
+    expect(enemyPokemon?.isFainted()).toBe(false);
+    expect(playerPokemon?.isFainted()).toBe(false);
+
+    // Turn 2: Enemy should fail Destiny Bond then get KO'd
+    game.move.select(moveToUse);
+    await game.setTurnOrder(enemyFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(false);
+  });
+
+  it("should not KO the opponent if the user dies to weather", async () => {
+    // Opponent will be reduced to 1 HP by False Swipe, then faint to Sandstorm
+    const moveToUse = Moves.FALSE_SWIPE;
+
+    game.override.moveset(moveToUse)
+      .ability(Abilities.SAND_STREAM);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    game.move.select(moveToUse);
+    await game.setTurnOrder(enemyFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(false);
+  });
+
+  it("should not KO the opponent if the user had another turn", async () => {
+    const moveToUse = Moves.TACKLE;
+
+    game.override.moveset([ Moves.SPORE, moveToUse ]);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    // Turn 1: Enemy uses Destiny Bond and doesn't faint
+    game.move.select(Moves.SPORE);
+    await game.setTurnOrder(enemyFirst);
+    await game.toNextTurn();
+
+    expect(enemyPokemon?.isFainted()).toBe(false);
+    expect(playerPokemon?.isFainted()).toBe(false);
+    expect(enemyPokemon?.status?.effect).toBe(StatusEffect.SLEEP);
+
+    // Turn 2: Enemy should skip a turn due to sleep, then get KO'd
+    game.move.select(moveToUse);
+    await game.setTurnOrder(enemyFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(false);
+  });
+
+  it("should not KO an ally", async () => {
+    game.override.moveset([ Moves.DESTINY_BOND, Moves.CRUNCH ])
+      .battleType("double");
+    await game.classicMode.startBattle([ Species.SHEDINJA, Species.BULBASAUR, Species.SQUIRTLE ]);
+
+    const enemyPokemon0 = game.scene.getEnemyField()[0];
+    const enemyPokemon1 = game.scene.getEnemyField()[1];
+    const playerPokemon0 = game.scene.getPlayerField()[0];
+    const playerPokemon1 = game.scene.getPlayerField()[1];
+
+    // Shedinja uses Destiny Bond, then ally Bulbasaur KO's Shedinja with Crunch
+    game.move.select(Moves.DESTINY_BOND, 0);
+    game.move.select(Moves.CRUNCH, 1, BattlerIndex.PLAYER);
+    await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY, BattlerIndex.ENEMY_2 ]);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon0?.isFainted()).toBe(false);
+    expect(enemyPokemon1?.isFainted()).toBe(false);
+    expect(playerPokemon0?.isFainted()).toBe(true);
+    expect(playerPokemon1?.isFainted()).toBe(false);
+  });
+
+  it("should not cause a crash if the user is KO'd by Ceaseless Edge", async () => {
+    const moveToUse = Moves.CEASELESS_EDGE;
+    vi.spyOn(allMoves[moveToUse], "accuracy", "get").mockReturnValue(100);
+
+    game.override.moveset(moveToUse);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    game.move.select(moveToUse);
+    await game.setTurnOrder(enemyFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(true);
+
+    // Ceaseless Edge spikes effect should still activate
+    const tagAfter = game.scene.arena.getTagOnSide(ArenaTagType.SPIKES, ArenaTagSide.ENEMY) as ArenaTrapTag;
+    expect(tagAfter.tagType).toBe(ArenaTagType.SPIKES);
+    expect(tagAfter.layers).toBe(1);
+  });
+
+  it("should not cause a crash if the user is KO'd by Pledge moves", async () => {
+    game.override.moveset([ Moves.GRASS_PLEDGE, Moves.WATER_PLEDGE ])
+      .battleType("double");
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon0 = game.scene.getEnemyField()[0];
+    const enemyPokemon1 = game.scene.getEnemyField()[1];
+    const playerPokemon0 = game.scene.getPlayerField()[0];
+    const playerPokemon1 = game.scene.getPlayerField()[1];
+
+    game.move.select(Moves.GRASS_PLEDGE, 0, BattlerIndex.ENEMY);
+    game.move.select(Moves.WATER_PLEDGE, 1, BattlerIndex.ENEMY);
+    await game.setTurnOrder([ BattlerIndex.ENEMY, BattlerIndex.ENEMY_2, BattlerIndex.PLAYER, BattlerIndex.PLAYER_2 ]);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon0?.isFainted()).toBe(true);
+    expect(enemyPokemon1?.isFainted()).toBe(false);
+    expect(playerPokemon0?.isFainted()).toBe(false);
+    expect(playerPokemon1?.isFainted()).toBe(true);
+
+    // Pledge secondary effect should still activate
+    const tagAfter = game.scene.arena.getTagOnSide(ArenaTagType.GRASS_WATER_PLEDGE, ArenaTagSide.ENEMY) as ArenaTrapTag;
+    expect(tagAfter.tagType).toBe(ArenaTagType.GRASS_WATER_PLEDGE);
+  });
+
+  /**
+   * In particular, this should prevent something like
+   * {@link https://github.com/pagefaultgames/pokerogue/issues/4219}
+   * from occurring with fainting by KO'ing a Destiny Bond user with U-Turn.
+   */
+  it("should not allow the opponent to revive via Reviver Seed", async () => {
+    const moveToUse = Moves.TACKLE;
+
+    game.override.moveset(moveToUse)
+      .startingHeldItems([{ name: "REVIVER_SEED" }]);
+    await game.classicMode.startBattle(defaultParty);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    const playerPokemon = game.scene.getPlayerPokemon();
+
+    game.move.select(moveToUse);
+    await game.setTurnOrder(enemyFirst);
+    await game.phaseInterceptor.to("BerryPhase");
+
+    expect(enemyPokemon?.isFainted()).toBe(true);
+    expect(playerPokemon?.isFainted()).toBe(true);
+
+    // Check that the Tackle user's Reviver Seed did not activate
+    const revSeeds = game.scene.getModifiers(PokemonInstantReviveModifier).filter(m => m.pokemonId === playerPokemon?.id);
+    expect(revSeeds.length).toBe(1);
+  });
+});

src/test/moves/secret_power.test.ts

@@ -0,0 +1,89 @@
+import { Abilities } from "#enums/abilities";
+import { Biome } from "#enums/biome";
+import { Moves } from "#enums/moves";
+import { Stat } from "#enums/stat";
+import { allMoves, SecretPowerAttr } from "#app/data/move";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { StatusEffect } from "#enums/status-effect";
+import { BattlerIndex } from "#app/battle";
+import { ArenaTagType } from "#enums/arena-tag-type";
+import { ArenaTagSide } from "#app/data/arena-tag";
+
+describe("Moves - Secret Power", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+
+  beforeAll(() => {
+    phaserGame = new Phaser.Game({
+      type: Phaser.HEADLESS,
+    });
+  });
+
+  afterEach(() => {
+    game.phaseInterceptor.restoreOg();
+  });
+
+  beforeEach(() => {
+    game = new GameManager(phaserGame);
+    game.override
+      .moveset([ Moves.SECRET_POWER ])
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyLevel(60)
+      .enemyAbility(Abilities.BALL_FETCH);
+  });
+
+  it("Secret Power checks for an active terrain first then looks at the biome for its secondary effect", async () => {
+    game.override
+      .startingBiome(Biome.VOLCANO)
+      .enemyMoveset([ Moves.SPLASH, Moves.MISTY_TERRAIN ]);
+    vi.spyOn(allMoves[Moves.SECRET_POWER], "chance", "get").mockReturnValue(100);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const enemyPokemon  = game.scene.getEnemyPokemon()!;
+
+    // No Terrain + Biome.VOLCANO --> Burn
+    game.move.select(Moves.SECRET_POWER);
+    await game.forceEnemyMove(Moves.SPLASH);
+    await game.phaseInterceptor.to("TurnEndPhase");
+    expect(enemyPokemon.status?.effect).toBe(StatusEffect.BURN);
+
+    // Misty Terrain --> SpAtk -1
+    game.move.select(Moves.SECRET_POWER);
+    await game.forceEnemyMove(Moves.MISTY_TERRAIN);
+    await game.phaseInterceptor.to("TurnEndPhase");
+    expect(enemyPokemon.getStatStage(Stat.SPATK)).toBe(-1);
+  });
+
+  it("the 'rainbow' effect of fire+water pledge does not double the chance of secret power's secondary effect",
+    async () => {
+      game.override
+        .moveset([ Moves.FIRE_PLEDGE, Moves.WATER_PLEDGE, Moves.SECRET_POWER, Moves.SPLASH ])
+        .enemyMoveset([ Moves.SPLASH ])
+        .battleType("double");
+      await game.classicMode.startBattle([ Species.BLASTOISE, Species.CHARIZARD ]);
+
+      const secretPowerAttr = allMoves[Moves.SECRET_POWER].getAttrs(SecretPowerAttr)[0];
+      vi.spyOn(secretPowerAttr, "getMoveChance");
+
+      game.move.select(Moves.WATER_PLEDGE, 0, BattlerIndex.ENEMY);
+      game.move.select(Moves.FIRE_PLEDGE, 1, BattlerIndex.ENEMY_2);
+
+      await game.phaseInterceptor.to("TurnEndPhase");
+
+      expect(game.scene.arena.getTagOnSide(ArenaTagType.WATER_FIRE_PLEDGE, ArenaTagSide.PLAYER)).toBeDefined();
+
+      game.move.select(Moves.SECRET_POWER, 0, BattlerIndex.ENEMY);
+      game.move.select(Moves.SPLASH, 1);
+
+      await game.phaseInterceptor.to("BerryPhase", false);
+
+      expect(secretPowerAttr.getMoveChance).toHaveLastReturnedWith(30);
+    }
+  );
+});

src/test/mystery-encounter/encounters/the-expert-breeder-encounter.test.ts

@@ -124,10 +124,31 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       });
     });
 
-    it("should start battle against the trainer", async () => {
+    it("should start battle against the trainer with correctly loaded assets", async () => {
       await game.runToMysteryEncounter(MysteryEncounterType.THE_EXPERT_POKEMON_BREEDER, defaultParty);
+
+      let successfullyLoaded = false;
+      vi.spyOn(scene, "getEnemyParty").mockImplementation(() => {
+        const ace = scene.currentBattle?.enemyParty[0];
+        if (ace) {
+          // Pretend that loading assets takes an extra 500ms
+          vi.spyOn(ace, "loadAssets").mockImplementation(() => new Promise(resolve => {
+            setTimeout(() => {
+              successfullyLoaded = true;
+              resolve();
+            }, 500);
+          }));
+        }
+
+        return scene.currentBattle?.enemyParty ?? [];
+      });
+
       await runMysteryEncounterToEnd(game, 1, undefined, true);
 
+      // Check that assets are successfully loaded
+      expect(successfullyLoaded).toBe(true);
+
+      // Check usual battle stuff
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
@@ -182,10 +203,31 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       });
     });
 
-    it("should start battle against the trainer", async () => {
+    it("should start battle against the trainer with correctly loaded assets", async () => {
       await game.runToMysteryEncounter(MysteryEncounterType.THE_EXPERT_POKEMON_BREEDER, defaultParty);
+
+      let successfullyLoaded = false;
+      vi.spyOn(scene, "getEnemyParty").mockImplementation(() => {
+        const ace = scene.currentBattle?.enemyParty[0];
+        if (ace) {
+          // Pretend that loading assets takes an extra 500ms
+          vi.spyOn(ace, "loadAssets").mockImplementation(() => new Promise(resolve => {
+            setTimeout(() => {
+              successfullyLoaded = true;
+              resolve();
+            }, 500);
+          }));
+        }
+
+        return scene.currentBattle?.enemyParty ?? [];
+      });
+
       await runMysteryEncounterToEnd(game, 2, undefined, true);
 
+      // Check that assets are successfully loaded
+      expect(successfullyLoaded).toBe(true);
+
+      // Check usual battle stuff
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);
@@ -240,10 +282,31 @@ describe("The Expert Pokémon Breeder - Mystery Encounter", () => {
       });
     });
 
-    it("should start battle against the trainer", async () => {
+    it("should start battle against the trainer with correctly loaded assets", async () => {
       await game.runToMysteryEncounter(MysteryEncounterType.THE_EXPERT_POKEMON_BREEDER, defaultParty);
+
+      let successfullyLoaded = false;
+      vi.spyOn(scene, "getEnemyParty").mockImplementation(() => {
+        const ace = scene.currentBattle?.enemyParty[0];
+        if (ace) {
+          // Pretend that loading assets takes an extra 500ms
+          vi.spyOn(ace, "loadAssets").mockImplementation(() => new Promise(resolve => {
+            setTimeout(() => {
+              successfullyLoaded = true;
+              resolve();
+            }, 500);
+          }));
+        }
+
+        return scene.currentBattle?.enemyParty ?? [];
+      });
+
       await runMysteryEncounterToEnd(game, 3, undefined, true);
 
+      // Check that assets are successfully loaded
+      expect(successfullyLoaded).toBe(true);
+
+      // Check usual battle stuff
       expect(scene.getCurrentPhase()?.constructor.name).toBe(CommandPhase.name);
       expect(scene.currentBattle.trainer).toBeDefined();
       expect(scene.currentBattle.mysteryEncounter?.encounterMode).toBe(MysteryEncounterMode.TRAINER_BATTLE);

src/test/phases/select-modifier-phase.test.ts

@@ -63,11 +63,11 @@ describe("SelectModifierPhase", () => {
       new ModifierTypeOption(modifierTypes.REVIVE(), 0, 1000)
     ];
 
-    const selectModifierPhase1 = new SelectModifierPhase(scene);
+    const selectModifierPhase1 = new SelectModifierPhase(scene, 0, undefined, { guaranteedModifierTypeOptions: options });
-    const selectModifierPhase2 = new SelectModifierPhase(scene, 0, undefined, { rerollMultiplier: 2 });
+    const selectModifierPhase2 = new SelectModifierPhase(scene, 0, undefined, { guaranteedModifierTypeOptions: options, rerollMultiplier: 2 });
 
-    const cost1 = selectModifierPhase1.getRerollCost(options, false);
+    const cost1 = selectModifierPhase1.getRerollCost(false);
-    const cost2 = selectModifierPhase2.getRerollCost(options, false);
+    const cost2 = selectModifierPhase2.getRerollCost(false);
     expect(cost2).toEqual(cost1 * 2);
   });
 

src/ui/modifier-select-ui-handler.ts

@@ -16,7 +16,7 @@ import { ShopCursorTarget } from "#app/enums/shop-cursor-target";
 import { IntegerHolder } from "./../utils";
 import Phaser from "phaser";
 
-export const SHOP_OPTIONS_ROW_LIMIT = 6;
+export const SHOP_OPTIONS_ROW_LIMIT = 7;
 
 export default class ModifierSelectUiHandler extends AwaitableUiHandler {
   private modifierContainer: Phaser.GameObjects.Container;
@@ -211,7 +211,7 @@ export default class ModifierSelectUiHandler extends AwaitableUiHandler {
       const row = m < SHOP_OPTIONS_ROW_LIMIT ? 0 : 1;
       const col = m < SHOP_OPTIONS_ROW_LIMIT ? m : m - SHOP_OPTIONS_ROW_LIMIT;
       const rowOptions = shopTypeOptions.slice(row ? SHOP_OPTIONS_ROW_LIMIT : 0, row ? undefined : SHOP_OPTIONS_ROW_LIMIT);
-      const sliceWidth = (this.scene.game.canvas.width / SHOP_OPTIONS_ROW_LIMIT) / (rowOptions.length + 2);
+      const sliceWidth = (this.scene.game.canvas.width / 6) / (rowOptions.length + 2);
       const option = new ModifierOption(this.scene, sliceWidth * (col + 1) + (sliceWidth * 0.5), ((-this.scene.game.canvas.height / 12) - (this.scene.game.canvas.height / 32) - (40 - (28 * row - 1))), shopTypeOptions[m]);
       option.setScale(0.375);
       this.scene.add.existing(option);

src/ui/party-ui-handler.ts

@@ -671,6 +671,9 @@ export default class PartyUiHandler extends MessageUiHandler {
     } else if (this.cursor === 6) {
       this.partyCancelButton.select();
     }
+    if (this.lastCursor < 6 && this.lastCursor >= party.length) {
+      this.lastCursor = party.length - 1;
+    }
 
     for (const p in party) {
       const slotIndex = parseInt(p);