adds teleporting hijinks encounter

public/images/mystery-encounters/berry_bush.json

@@ -0,0 +1,41 @@
+{
+	"textures": [
+		{
+			"image": "berry_bush.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 49,
+				"h": 53
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "0001.png",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 49,
+						"h": 53
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 49,
+						"h": 53
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 49,
+						"h": 53
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:d5f83625477b5f98b726343f4a3a396f:f4665258986e97345cfeee041b4b8bcf:e7781fcc447e6d12deb2af78c9493c7f$"
+	}
+}

public/images/mystery-encounters/teleporter.json

@@ -0,0 +1,41 @@
+{
+	"textures": [
+		{
+			"image": "teleporter.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 64,
+				"h": 78
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "0001.png",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 64,
+						"h": 78
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 64,
+						"h": 78
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 64,
+						"h": 78
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:a8e006630c2838130468b0d5c9aeb8a6:684c1813cb6c86e395c18027a593ed28:ce1615396ce7b0a146766d50b319bb81$"
+	}
+}

src/data/mystery-encounters/encounters/berries-abound-encounter.ts

@@ -46,96 +46,7 @@ export const BerriesAboundEncounter: MysteryEncounter =
     .withSceneWaveRangeRequirement(10, 180) // waves 10 to 180
     .withCatchAllowed(true)
     .withHideWildIntroMessage(true)
-    .withIntroSpriteConfigs([
+    .withIntroSpriteConfigs([]) // Set in onInit()
-      {
-        spriteKey: "lum_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 7,
-        y: -14,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "salac_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 2,
-        y: 4,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "lansat_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 32,
-        y: 5,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "liechi_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 6,
-        y: -5,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "sitrus_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 7,
-        y: 8,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "enigma_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 26,
-        y: -4,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "leppa_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 16,
-        y: -27,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "petaya_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 30,
-        y: -17,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "ganlon_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 16,
-        y: -11,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "apicot_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 14,
-        y: -2,
-        disableAnimation: true
-      },
-      {
-        spriteKey: "starf_berry",
-        fileRoot: "items",
-        isItem: true,
-        x: 18,
-        y: 9,
-        disableAnimation: true
-      },
-    ]) // Set in onInit()
     .withIntroDialogue([
       {
         text: `${namespace}.intro`,
@@ -145,12 +56,14 @@ export const BerriesAboundEncounter: MysteryEncounter =
       const encounter = scene.currentBattle.mysteryEncounter;
 
       // Calculate boss mon
-      const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, scene.currentBattle.waveIndex, 0, getPartyLuckValue(scene.getParty()), true);
+      const level = (scene.currentBattle.enemyLevels?.[0] ?? scene.currentBattle.waveIndex) + Math.max(Math.round((scene.currentBattle.waveIndex / 10)), 0);
-      const bossPokemon = new EnemyPokemon(scene, bossSpecies, scene.currentBattle.waveIndex, TrainerSlot.NONE, true);
+      const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, level, 0, getPartyLuckValue(scene.getParty()), true);
+      const bossPokemon = new EnemyPokemon(scene, bossSpecies, level, TrainerSlot.NONE, true);
       encounter.setDialogueToken("enemyPokemon", getPokemonNameWithAffix(bossPokemon));
       const config: EnemyPartyConfig = {
         levelAdditiveMultiplier: 1,
         pokemonConfigs: [{
+          level: level,
           species: bossSpecies,
           dataSource: new PokemonData(bossPokemon),
           isBoss: true
@@ -168,15 +81,26 @@ export const BerriesAboundEncounter: MysteryEncounter =
       encounter.misc = { numBerries };
 
       const { spriteKey, fileRoot } = getSpriteKeysFromPokemon(bossPokemon);
-      encounter.spriteConfigs.push({
+      encounter.spriteConfigs = [
-        spriteKey: spriteKey,
+        {
-        fileRoot: fileRoot,
+          spriteKey: "berry_bush",
-        hasShadow: true,
+          fileRoot: "mystery-encounters",
-        tint: 0.25,
+          x: 25,
-        x: -5,
+          y: -6,
-        repeat: true,
+          yShadow: -7,
-        isPokemon: true
+          disableAnimation: true,
-      });
+          hasShadow: true
+        },
+        {
+          spriteKey: spriteKey,
+          fileRoot: fileRoot,
+          hasShadow: true,
+          tint: 0.25,
+          x: -5,
+          repeat: true,
+          isPokemon: true
+        }
+      ];
 
       // Get fastest party pokemon for option 2
       const fastestPokemon = getHighestStatPlayerPokemon(scene, Stat.SPD, true);
@@ -238,7 +162,7 @@ export const BerriesAboundEncounter: MysteryEncounter =
           const encounter = scene.currentBattle.mysteryEncounter;
           const fastestPokemon = encounter.misc.fastestPokemon;
           const enemySpeed = encounter.misc.enemySpeed;
-          const speedDiff = fastestPokemon.getStat(Stat.SPD) / enemySpeed;
+          const speedDiff = fastestPokemon.getStat(Stat.SPD) / (enemySpeed * 1.1);
           const numBerries = encounter.misc.numBerries;
 
           const shopOptions: ModifierTypeOption[] = [];
@@ -272,8 +196,8 @@ export const BerriesAboundEncounter: MysteryEncounter =
             await initBattleWithEnemyConfig(scene, config);
             return;
           } else {
-            // Gains 1 berry for every 10% faster the player's pokemon is than the enemy, up to a max of numBerries, minimum of 1
+            // Gains 1 berry for every 10% faster the player's pokemon is than the enemy, up to a max of numBerries, minimum of 2
-            const numBerriesGrabbed = Math.max(Math.min(Math.round((speedDiff - 1)/0.1), numBerries), 1);
+            const numBerriesGrabbed = Math.max(Math.min(Math.round((speedDiff - 1)/0.08), numBerries), 2);
             encounter.setDialogueToken("numBerries", String(numBerriesGrabbed));
             const doFasterBerryRewards = async () => {
               const berryText = numBerriesGrabbed + " " + i18next.t(`${namespace}.berries`);

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

@@ -1,5 +1,5 @@
 import { MysteryEncounterOptionBuilder } from "#app/data/mystery-encounters/mystery-encounter-option";
-import { EnemyPartyConfig, generateModifierTypeOption, initBattleWithEnemyConfig, loadCustomMovesForEncounter, leaveEncounterWithoutBattle, setEncounterExp, setEncounterRewards, transitionMysteryEncounterIntroVisuals } from "#app/data/mystery-encounters/utils/encounter-phase-utils";
+import { EnemyPartyConfig, initBattleWithEnemyConfig, loadCustomMovesForEncounter, leaveEncounterWithoutBattle, setEncounterExp, setEncounterRewards, transitionMysteryEncounterIntroVisuals, generateModifierType } from "#app/data/mystery-encounters/utils/encounter-phase-utils";
 import { AttackTypeBoosterModifierType, modifierTypes, } from "#app/modifier/modifier-type";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
 import BattleScene from "#app/battle-scene";
@@ -243,7 +243,7 @@ function giveLeadPokemonCharcoal(scene: BattleScene) {
   // Give first party pokemon Charcoal for free at end of battle
   const leadPokemon = scene.getParty()?.[0];
   if (leadPokemon) {
-    const charcoal = generateModifierTypeOption(scene, modifierTypes.ATTACK_TYPE_BOOSTER, [Type.FIRE]).type as AttackTypeBoosterModifierType;
+    const charcoal = generateModifierType(scene, modifierTypes.ATTACK_TYPE_BOOSTER, [Type.FIRE]) as AttackTypeBoosterModifierType;
     applyModifierTypeToPlayerPokemon(scene, leadPokemon, charcoal);
     scene.currentBattle.mysteryEncounter.setDialogueToken("leadPokemon", leadPokemon.getNameToRender());
     queueEncounterMessage(scene, `${namespace}.found_charcoal`);

src/data/mystery-encounters/encounters/fight-or-flight-encounter.ts

@@ -49,11 +49,13 @@ export const FightOrFlightEncounter: MysteryEncounter =
       const encounter = scene.currentBattle.mysteryEncounter;
 
       // Calculate boss mon
-      const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, scene.currentBattle.waveIndex, 0, getPartyLuckValue(scene.getParty()), true);
+      const level = (scene.currentBattle.enemyLevels?.[0] ?? scene.currentBattle.waveIndex) + Math.max(Math.round((scene.currentBattle.waveIndex / 10)), 0);
-      const bossPokemon = new EnemyPokemon(scene, bossSpecies, scene.currentBattle.waveIndex, TrainerSlot.NONE, true);
+      const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, level, 0, getPartyLuckValue(scene.getParty()), true);
+      const bossPokemon = new EnemyPokemon(scene, bossSpecies, level, TrainerSlot.NONE, true);
       const config: EnemyPartyConfig = {
         levelAdditiveMultiplier: 1,
         pokemonConfigs: [{
+          level: level,
           species: bossSpecies,
           dataSource: new PokemonData(bossPokemon),
           isBoss: true

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

@@ -0,0 +1,258 @@
+import { EnemyPartyConfig, generateModifierTypeOption, initBattleWithEnemyConfig, setEncounterExp, setEncounterRewards, transitionMysteryEncounterIntroVisuals, updatePlayerMoney, } from "#app/data/mystery-encounters/utils/encounter-phase-utils";
+import { randSeedInt } from "#app/utils";
+import { MysteryEncounterType } from "#enums/mystery-encounter-type";
+import BattleScene from "#app/battle-scene";
+import MysteryEncounter, { MysteryEncounterBuilder } from "../mystery-encounter";
+import { MoneyRequirement, WaveModulusRequirement } from "../mystery-encounter-requirements";
+import Pokemon, { EnemyPokemon } from "#app/field/pokemon";
+import { MysteryEncounterOptionBuilder } from "#app/data/mystery-encounters/mystery-encounter-option";
+import { queueEncounterMessage, showEncounterText } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
+import PokemonData from "#app/system/pokemon-data";
+import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
+import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
+import { Biome } from "#enums/biome";
+import { getBiomeKey } from "#app/field/arena";
+import { Type } from "#app/data/type";
+import { getPartyLuckValue, modifierTypes } from "#app/modifier/modifier-type";
+import { TrainerSlot } from "#app/data/trainer-config";
+import { BattlerTagType } from "#enums/battler-tag-type";
+import { StatChangePhase } from "#app/phases/stat-change-phase";
+import { BattleStat } from "#app/data/battle-stat";
+import { getPokemonNameWithAffix } from "#app/messages";
+
+/** the i18n namespace for this encounter */
+const namespace = "mysteryEncounter:teleportingHijinks";
+
+const MONEY_COST_MULTIPLIER = 2.5;
+const BIOME_CANDIDATES = [Biome.SPACE, Biome.FAIRY_CAVE, Biome.LABORATORY, Biome.ISLAND];
+
+/**
+ * Teleporting Hijinks encounter.
+ * @see {@link https://github.com/AsdarDevelops/PokeRogue-Events/issues/119 | GitHub Issue #119}
+ * @see For biome requirements check {@linkcode mysteryEncountersByBiome}
+ */
+export const TeleportingHijinksEncounter: MysteryEncounter =
+  MysteryEncounterBuilder.withEncounterType(MysteryEncounterType.TELEPORTING_HIJINKS)
+    .withEncounterTier(MysteryEncounterTier.COMMON)
+    .withSceneWaveRangeRequirement(10, 180)
+    .withSceneRequirement(new WaveModulusRequirement([1, 2, 3], 10)) // Must be in first 3 waves after boss wave
+    .withSceneRequirement(new MoneyRequirement(undefined, MONEY_COST_MULTIPLIER)) // Must be able to pay teleport cost
+    .withAutoHideIntroVisuals(false)
+    .withCatchAllowed(true)
+    .withIntroSpriteConfigs([
+      {
+        spriteKey: "teleporter",
+        fileRoot: "mystery-encounters",
+        hasShadow: true,
+        y: 4
+      }
+    ])
+    .withIntroDialogue([
+      {
+        text: `${namespace}.intro`,
+      }
+    ])
+    .withTitle(`${namespace}.title`)
+    .withDescription(`${namespace}.description`)
+    .withQuery(`${namespace}.query`)
+    .withOnInit((scene: BattleScene) => {
+      const encounter = scene.currentBattle.mysteryEncounter;
+      const price = scene.getWaveMoneyAmount(MONEY_COST_MULTIPLIER);
+      encounter.setDialogueToken("price", price.toString());
+      encounter.misc = {
+        price
+      };
+
+      return true;
+    })
+    .withOption(
+      MysteryEncounterOptionBuilder
+        .newOptionWithMode(MysteryEncounterOptionMode.DISABLED_OR_DEFAULT)
+        .withSceneMoneyRequirement(undefined, MONEY_COST_MULTIPLIER) // Must be able to pay teleport cost
+        .withDialogue({
+          buttonLabel: `${namespace}.option.1.label`,
+          buttonTooltip: `${namespace}.option.1.tooltip`,
+          selected: [
+            {
+              text: `${namespace}.option.1.selected`,
+            }
+          ],
+        })
+        .withPreOptionPhase(async (scene: BattleScene) => {
+          // Update money
+          updatePlayerMoney(scene, -scene.currentBattle.mysteryEncounter.misc.price, true, false);
+        })
+        .withOptionPhase(async (scene: BattleScene) => {
+          const encounter = scene.currentBattle.mysteryEncounter;
+
+          // Calculate new biome (cannot be current biome)
+          const filteredBiomes = BIOME_CANDIDATES.filter(b => scene.arena.biomeType !== b);
+          const newBiome = filteredBiomes[randSeedInt(filteredBiomes.length)];
+
+          // Show dialogue
+          await showEncounterText(scene, `${namespace}.transport`);
+          await Promise.all([animateBiomeChange(scene, newBiome), transitionMysteryEncounterIntroVisuals(scene)]);
+          scene.playBgm();
+          await showEncounterText(scene, `${namespace}.attacked`);
+
+          // Init enemy
+          const level = (scene.currentBattle.enemyLevels?.[0] ?? scene.currentBattle.waveIndex) + Math.max(Math.round((scene.currentBattle.waveIndex / 10)), 0);
+          const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, level, 0, getPartyLuckValue(scene.getParty()), true);
+          const bossPokemon = new EnemyPokemon(scene, bossSpecies, level, TrainerSlot.NONE, true);
+          encounter.setDialogueToken("enemyPokemon", getPokemonNameWithAffix(bossPokemon));
+          const config: EnemyPartyConfig = {
+            pokemonConfigs: [{
+              level: level,
+              species: bossSpecies,
+              dataSource: new PokemonData(bossPokemon),
+              isBoss: true,
+              tags: [BattlerTagType.MYSTERY_ENCOUNTER_POST_SUMMON],
+              mysteryEncounterBattleEffects: (pokemon: Pokemon) => {
+                queueEncounterMessage(pokemon.scene, `${namespace}.boss_enraged`);
+                pokemon.scene.unshiftPhase(new StatChangePhase(pokemon.scene, pokemon.getBattlerIndex(), true, [BattleStat.ATK, BattleStat.DEF, BattleStat.SPATK, BattleStat.SPDEF, BattleStat.SPD], 1));
+              }
+            }],
+          };
+
+          setEncounterRewards(scene, { fillRemaining: true });
+          await initBattleWithEnemyConfig(scene, config);
+        })
+        .build()
+    )
+    .withOption(
+      MysteryEncounterOptionBuilder
+        .newOptionWithMode(MysteryEncounterOptionMode.DISABLED_OR_DEFAULT)
+        .withPokemonTypeRequirement([Type.ELECTRIC, Type.STEEL], true, 1) // Must have Steel or Electric type
+        .withDialogue({
+          buttonLabel: `${namespace}.option.2.label`,
+          buttonTooltip: `${namespace}.option.2.tooltip`,
+          selected: [
+            {
+              text: `${namespace}.option.2.selected`,
+            }
+          ],
+        })
+        .withOptionPhase(async (scene: BattleScene) => {
+          const encounter = scene.currentBattle.mysteryEncounter;
+
+          // Calculate new biome (cannot be current biome)
+          const filteredBiomes = BIOME_CANDIDATES.filter(b => scene.arena.biomeType !== b);
+          const newBiome = filteredBiomes[randSeedInt(filteredBiomes.length)];
+
+          // Show dialogue
+          await showEncounterText(scene, `${namespace}.transport`);
+          await Promise.all([animateBiomeChange(scene, newBiome), transitionMysteryEncounterIntroVisuals(scene)]);
+          scene.playBgm();
+          await showEncounterText(scene, `${namespace}.attacked`);
+
+          // Init enemy
+          const level = (scene.currentBattle.enemyLevels?.[0] ?? scene.currentBattle.waveIndex) + Math.max(Math.round((scene.currentBattle.waveIndex / 10)), 0);
+          const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, level, 0, getPartyLuckValue(scene.getParty()), true);
+          const bossPokemon = new EnemyPokemon(scene, bossSpecies, level, TrainerSlot.NONE, true);
+          encounter.setDialogueToken("enemyPokemon", getPokemonNameWithAffix(bossPokemon));
+          const config: EnemyPartyConfig = {
+            pokemonConfigs: [{
+              level: level,
+              species: bossSpecies,
+              dataSource: new PokemonData(bossPokemon),
+              isBoss: true,
+              tags: [BattlerTagType.MYSTERY_ENCOUNTER_POST_SUMMON],
+              mysteryEncounterBattleEffects: (pokemon: Pokemon) => {
+                queueEncounterMessage(pokemon.scene, `${namespace}.boss_enraged`);
+                pokemon.scene.unshiftPhase(new StatChangePhase(pokemon.scene, pokemon.getBattlerIndex(), true, [BattleStat.ATK, BattleStat.DEF, BattleStat.SPATK, BattleStat.SPDEF, BattleStat.SPD], 1));
+              }
+            }],
+          };
+
+          setEncounterRewards(scene, { fillRemaining: true });
+          setEncounterExp(scene, encounter.selectedOption!.primaryPokemon!.id, 100);
+          await initBattleWithEnemyConfig(scene, config);
+        })
+        .build()
+    )
+    .withSimpleOption(
+      {
+        buttonLabel: `${namespace}.option.3.label`,
+        buttonTooltip: `${namespace}.option.3.tooltip`,
+        selected: [
+          {
+            text: `${namespace}.option.3.selected`,
+          },
+        ],
+      },
+      async (scene: BattleScene) => {
+        // Inspect the Machine
+        const encounter = scene.currentBattle.mysteryEncounter;
+
+        // Init enemy
+        const level = (scene.currentBattle.enemyLevels?.[0] ?? scene.currentBattle.waveIndex) + Math.max(Math.round((scene.currentBattle.waveIndex / 10)), 0);
+        const bossSpecies = scene.arena.randomSpecies(scene.currentBattle.waveIndex, level, 0, getPartyLuckValue(scene.getParty()), true);
+        const bossPokemon = new EnemyPokemon(scene, bossSpecies, level, TrainerSlot.NONE, true);
+        encounter.setDialogueToken("enemyPokemon", getPokemonNameWithAffix(bossPokemon));
+        const config: EnemyPartyConfig = {
+          pokemonConfigs: [{
+            level: level,
+            species: bossSpecies,
+            dataSource: new PokemonData(bossPokemon),
+            isBoss: true,
+          }],
+        };
+
+        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 });
+        setEncounterExp(scene, encounter.selectedOption!.primaryPokemon!.id, 100);
+        transitionMysteryEncounterIntroVisuals(scene, true, true);
+        await initBattleWithEnemyConfig(scene, config);
+      }
+    )
+    .build();
+
+async function animateBiomeChange(scene: BattleScene, nextBiome: Biome) {
+  return new Promise<void>(resolve => {
+    scene.tweens.add({
+      targets: [scene.arenaEnemy, scene.lastEnemyTrainer],
+      x: "+=300",
+      duration: 2000,
+      onComplete: () => {
+        scene.newArena(nextBiome);
+
+        const biomeKey = getBiomeKey(nextBiome);
+        const bgTexture = `${biomeKey}_bg`;
+        scene.arenaBgTransition.setTexture(bgTexture);
+        scene.arenaBgTransition.setAlpha(0);
+        scene.arenaBgTransition.setVisible(true);
+        scene.arenaPlayerTransition.setBiome(nextBiome);
+        scene.arenaPlayerTransition.setAlpha(0);
+        scene.arenaPlayerTransition.setVisible(true);
+
+        scene.tweens.add({
+          targets: [scene.arenaPlayer, scene.arenaBgTransition, scene.arenaPlayerTransition],
+          duration: 1000,
+          ease: "Sine.easeInOut",
+          alpha: (target: any) => target === scene.arenaPlayer ? 0 : 1,
+          onComplete: () => {
+            scene.arenaBg.setTexture(bgTexture);
+            scene.arenaPlayer.setBiome(nextBiome);
+            scene.arenaPlayer.setAlpha(1);
+            scene.arenaEnemy.setBiome(nextBiome);
+            scene.arenaEnemy.setAlpha(1);
+            scene.arenaNextEnemy.setBiome(nextBiome);
+            scene.arenaBgTransition.setVisible(false);
+            scene.arenaPlayerTransition.setVisible(false);
+            if (scene.lastEnemyTrainer) {
+              scene.lastEnemyTrainer.destroy();
+            }
+
+            resolve();
+
+            scene.tweens.add({
+              targets: scene.arenaEnemy,
+              x: "-=300",
+            });
+          }
+        });
+      }
+    });
+  });
+}

src/data/mystery-encounters/mystery-encounter-requirements.ts

@@ -153,7 +153,36 @@ export class WaveRangeRequirement extends EncounterSceneRequirement {
   }
 
   getDialogueToken(scene: BattleScene, pokemon?: PlayerPokemon): [string, string] {
-    return ["waveCount", scene.currentBattle.waveIndex.toString()];
+    return ["waveIndex", scene.currentBattle.waveIndex.toString()];
+  }
+}
+
+export class WaveModulusRequirement extends EncounterSceneRequirement {
+  waveModuli: number[];
+  modulusValue: number;
+
+  /**
+   * Used for specifying a modulus requirement on the wave index
+   * For example, can be used to require the wave index to end with 1, 2, or 3
+   * @param waveModuli - number[], the allowed modulus results
+   * @param modulusValue - number, the modulus calculation value
+   *
+   * Example:
+   * new WaveModulusRequirement([1, 2, 3], 10) will check for 1st/2nd/3rd waves that are immediately after a multiple of 10 wave
+   * So waves 21, 32, 53 all return true. 58, 14, 99 return false.
+   */
+  constructor(waveModuli: number[], modulusValue: number) {
+    super();
+    this.waveModuli = waveModuli;
+    this.modulusValue = modulusValue;
+  }
+
+  meetsRequirement(scene: BattleScene): boolean {
+    return this.waveModuli.includes(scene.currentBattle.waveIndex % this.modulusValue);
+  }
+
+  getDialogueToken(scene: BattleScene, pokemon?: PlayerPokemon): [string, string] {
+    return ["waveIndex", scene.currentBattle.waveIndex.toString()];
   }
 }
 

src/data/mystery-encounters/mystery-encounters.ts

@@ -26,6 +26,7 @@ import { PartTimerEncounter } from "#app/data/mystery-encounters/encounters/part
 import { DancingLessonsEncounter } from "#app/data/mystery-encounters/encounters/dancing-lessons-encounter";
 import { WeirdDreamEncounter } from "#app/data/mystery-encounters/encounters/weird-dream-encounter";
 import { TheWinstrateChallengeEncounter } from "#app/data/mystery-encounters/encounters/the-winstrate-challenge-encounter";
+import { TeleportingHijinksEncounter } from "#app/data/mystery-encounters/encounters/teleporting-hijinks-encounter";
 
 // Spawn chance: (BASE_MYSTERY_ENCOUNTER_SPAWN_WEIGHT + WIGHT_INCREMENT_ON_SPAWN_MISS * <number of missed spawns>) / 256
 export const BASE_MYSTERY_ENCOUNTER_SPAWN_WEIGHT = 1;
@@ -169,7 +170,8 @@ const anyBiomeEncounters: MysteryEncounterType[] = [
   MysteryEncounterType.TRASH_TO_TREASURE,
   MysteryEncounterType.BERRIES_ABOUND,
   MysteryEncounterType.CLOWNING_AROUND,
-  MysteryEncounterType.WEIRD_DREAM
+  MysteryEncounterType.WEIRD_DREAM,
+  MysteryEncounterType.TELEPORTING_HIJINKS
 ];
 
 /**
@@ -273,6 +275,7 @@ export function initMysteryEncounters() {
   allMysteryEncounters[MysteryEncounterType.DANCING_LESSONS] = DancingLessonsEncounter;
   allMysteryEncounters[MysteryEncounterType.WEIRD_DREAM] = WeirdDreamEncounter;
   allMysteryEncounters[MysteryEncounterType.THE_WINSTRATE_CHALLENGE] = TheWinstrateChallengeEncounter;
+  allMysteryEncounters[MysteryEncounterType.TELEPORTING_HIJINKS] = TeleportingHijinksEncounter;
 
   // Add extreme encounters to biome map
   extremeBiomeEncounters.forEach(encounter => {

src/enums/mystery-encounter-type.ts

@@ -23,5 +23,6 @@ export enum MysteryEncounterType {
   PART_TIMER,
   DANCING_LESSONS,
   WEIRD_DREAM,
-  THE_WINSTRATE_CHALLENGE
+  THE_WINSTRATE_CHALLENGE,
+  TELEPORTING_HIJINKS
 }

src/locales/en/mystery-encounter.ts

@@ -23,6 +23,7 @@ import { partTimerDialogue } from "#app/locales/en/mystery-encounters/part-timer
 import { dancingLessonsDialogue } from "#app/locales/en/mystery-encounters/dancing-lessons-dialogue";
 import { weirdDreamDialogue } from "#app/locales/en/mystery-encounters/weird-dream-dialogue";
 import { theWinstrateChallengeDialogue } from "#app/locales/en/mystery-encounters/the-winstrate-challenge-dialogue";
+import { teleportingHijinksDialogue } from "#app/locales/en/mystery-encounters/teleporting-hijinks-dialogue";
 
 /**
  * Injection patterns that can be used:
@@ -73,5 +74,6 @@ export const mysteryEncounter = {
   partTimer: partTimerDialogue,
   dancingLessons: dancingLessonsDialogue,
   weirdDream: weirdDreamDialogue,
-  theWinstrateChallenge: theWinstrateChallengeDialogue
+  theWinstrateChallenge: theWinstrateChallengeDialogue,
+  teleportingHijinks: teleportingHijinksDialogue
 } as const;

src/locales/en/mystery-encounters/teleporting-hijinks-dialogue.ts

@@ -0,0 +1,30 @@
+export const teleportingHijinksDialogue = {
+  intro: "It's a strange machine, whirring noisily...",
+  title: "Teleportating Hijinks",
+  description: "The machine has a sign on it that reads:\n  \"To use, insert money then step into the capsule.\"\n\nPerhaps it can transport you somewhere...",
+  query: "What will you do?",
+  option: {
+    1: {
+      label: "Put Money In",
+      tooltip: "(-) Pay {{price, money}}\n(?) Teleport to New Biome",
+      selected: "You insert some money, and the capsule opens.\nYou step inside...",
+    },
+    2: {
+      label: "A Pokémon Helps",
+      tooltip: "(-) {{option2PrimaryName}} Helps\n(+) {{option2PrimaryName}} gains EXP\n(?) Teleport to New Biome",
+      selected: `{{option2PrimaryName}} uses its typing and overloads the machine!
+        $The capsule opens, and you step inside...`
+    },
+    3: {
+      label: "Inspect the Machine",
+      tooltip: "(-) Pokémon Battle",
+      selected: `You are drawn in by the blinking lights\nand strange noises coming from the machine...
+        $You don't even notice as a wild\nPokémon sneaks up and ambushes you!`,
+    },
+  },
+  transport: `The machine shakes violently,\nmaking all sorts of strange noises!
+      $Just as soon as it had started, it quiets once more.`,
+  attacked: `You step out into a completely new area, startling a wild Pokémon!
+      $The wild Pokémon attacks!`,
+  boss_enraged: "The opposing {{enemyPokemon}} has become enraged!"
+};

src/overrides.ts

@@ -131,9 +131,9 @@ class DefaultOverrides {
   // MYSTERY ENCOUNTER OVERRIDES
   // -------------------------
   // 1 to 256, set to null to ignore
-  readonly MYSTERY_ENCOUNTER_RATE_OVERRIDE: number | null = null;
+  readonly MYSTERY_ENCOUNTER_RATE_OVERRIDE: number | null = 256;
   readonly MYSTERY_ENCOUNTER_TIER_OVERRIDE: MysteryEncounterTier | null = null;
-  readonly MYSTERY_ENCOUNTER_OVERRIDE: MysteryEncounterType | null = null;
+  readonly MYSTERY_ENCOUNTER_OVERRIDE: MysteryEncounterType | null = MysteryEncounterType.TELEPORTING_HIJINKS;
 
   // -------------------------
   // MODIFIER / ITEM OVERRIDES