Merge ee80615436 into 6c0253ada4

* Modify custom starters and added boss, biome and luck custom seed overrides

* Added form index to boss custom seed

* Fix circular dependency in daily-run.ts

* Review for PR 6248

- Use early returns

- Update TSDocs

- Use `getEnumValues` instead of `Object.values` for `enum`s

- Add console logging for invalid seeds

---------

Co-authored-by: Jimmybald1 <147992650+IBBCalc@users.noreply.github.com>
Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>

src/data/daily-run.ts

@@ -5,10 +5,9 @@ import type { PokemonSpeciesForm } from "#data/pokemon-species";
 import { PokemonSpecies } from "#data/pokemon-species";
 import { BiomeId } from "#enums/biome-id";
 import { PartyMemberStrength } from "#enums/party-member-strength";
-import type { SpeciesId } from "#enums/species-id";
-import { PlayerPokemon } from "#field/pokemon";
+import { SpeciesId } from "#enums/species-id";
 import type { Starter } from "#ui/starter-select-ui-handler";
-import { randSeedGauss, randSeedInt, randSeedItem } from "#utils/common";
+import { isNullOrUndefined, randSeedGauss, randSeedInt, randSeedItem } from "#utils/common";
 import { getEnumValues } from "#utils/enums";
 import { getPokemonSpecies, getPokemonSpeciesForm } from "#utils/pokemon-utils";
 
@@ -32,15 +31,9 @@ export function getDailyRunStarters(seed: string): Starter[] {
     () => {
       const startingLevel = globalScene.gameMode.getStartingLevel();
 
-      if (/\d{18}$/.test(seed)) {
-        for (let s = 0; s < 3; s++) {
-          const offset = 6 + s * 6;
-          const starterSpeciesForm = getPokemonSpeciesForm(
-            Number.parseInt(seed.slice(offset, offset + 4)) as SpeciesId,
-            Number.parseInt(seed.slice(offset + 4, offset + 6)),
-          );
-          starters.push(getDailyRunStarter(starterSpeciesForm, startingLevel));
-        }
+      const eventStarters = getDailyEventSeedStarters(seed);
+      if (!isNullOrUndefined(eventStarters)) {
+        starters.push(...eventStarters);
         return;
       }
 
@@ -72,18 +65,7 @@ function getDailyRunStarter(starterSpeciesForm: PokemonSpeciesForm, startingLeve
   const starterSpecies =
     starterSpeciesForm instanceof PokemonSpecies ? starterSpeciesForm : getPokemonSpecies(starterSpeciesForm.speciesId);
   const formIndex = starterSpeciesForm instanceof PokemonSpecies ? undefined : starterSpeciesForm.formIndex;
-  const pokemon = new PlayerPokemon(
-    starterSpecies,
-    startingLevel,
-    undefined,
-    formIndex,
-    undefined,
-    undefined,
-    undefined,
-    undefined,
-    undefined,
-    undefined,
-  );
+  const pokemon = globalScene.addPlayerPokemon(starterSpecies, startingLevel, undefined, formIndex);
   const starter: Starter = {
     species: starterSpecies,
     dexAttr: pokemon.getDexAttr(),
@@ -145,6 +127,11 @@ const dailyBiomeWeights: BiomeWeights = {
 };
 
 export function getDailyStartingBiome(): BiomeId {
+  const eventBiome = getDailyEventSeedBiome(globalScene.seed);
+  if (!isNullOrUndefined(eventBiome)) {
+    return eventBiome;
+  }
+
   const biomes = getEnumValues(BiomeId).filter(b => b !== BiomeId.TOWN && b !== BiomeId.END);
 
   let totalWeight = 0;
@@ -169,3 +156,126 @@ export function getDailyStartingBiome(): BiomeId {
   // TODO: should this use `randSeedItem`?
   return biomes[randSeedInt(biomes.length)];
 }
+
+/**
+ * If this is Daily Mode and the seed is longer than a default seed
+ * then it has been modified and could contain a custom event seed. \
+ * Default seeds are always exactly 24 characters.
+ * @returns `true` if it is a Daily Event Seed.
+ */
+export function isDailyEventSeed(seed: string): boolean {
+  return globalScene.gameMode.isDaily && seed.length > 24;
+}
+
+/**
+ * Expects the seed to contain `/starters\d{18}/`
+ * where the digits alternate between 4 digits for the species ID and 2 digits for the form index
+ * (left padded with `0`s as necessary).
+ * @returns An array of {@linkcode Starter}s, or `null` if no valid match.
+ */
+export function getDailyEventSeedStarters(seed: string): Starter[] | null {
+  if (!isDailyEventSeed(seed)) {
+    return null;
+  }
+
+  const starters: Starter[] = [];
+  const match = /starters(\d{4})(\d{2})(\d{4})(\d{2})(\d{4})(\d{2})/g.exec(seed);
+
+  if (!match || match.length !== 7) {
+    return null;
+  }
+
+  for (let i = 1; i < match.length; i += 2) {
+    const speciesId = Number.parseInt(match[i]) as SpeciesId;
+    const formIndex = Number.parseInt(match[i + 1]);
+
+    if (!getEnumValues(SpeciesId).includes(speciesId)) {
+      console.warn("Invalid species ID used for custom daily run seed starter:", speciesId);
+      return null;
+    }
+
+    const starterForm = getPokemonSpeciesForm(speciesId, formIndex);
+    const startingLevel = globalScene.gameMode.getStartingLevel();
+    const starter = getDailyRunStarter(starterForm, startingLevel);
+    starters.push(starter);
+  }
+
+  return starters;
+}
+
+/**
+ * Expects the seed to contain `/boss\d{4}\d{2}/`
+ * where the first 4 digits are the species ID and the next 2 digits are the form index
+ * (left padded with `0`s as necessary).
+ * @returns A {@linkcode PokemonSpeciesForm} to be used for the boss, or `null` if no valid match.
+ */
+export function getDailyEventSeedBoss(seed: string): PokemonSpeciesForm | null {
+  if (!isDailyEventSeed(seed)) {
+    return null;
+  }
+
+  const match = /boss(\d{4})(\d{2})/g.exec(seed);
+  if (!match || match.length !== 3) {
+    return null;
+  }
+
+  const speciesId = Number.parseInt(match[1]) as SpeciesId;
+  const formIndex = Number.parseInt(match[2]);
+
+  if (!getEnumValues(SpeciesId).includes(speciesId)) {
+    console.warn("Invalid species ID used for custom daily run seed boss:", speciesId);
+    return null;
+  }
+
+  const starterForm = getPokemonSpeciesForm(speciesId, formIndex);
+  return starterForm;
+}
+
+/**
+ * Expects the seed to contain `/biome\d{2}/` where the 2 digits are a biome ID (left padded with `0` if necessary).
+ * @returns The biome to use or `null` if no valid match.
+ */
+export function getDailyEventSeedBiome(seed: string): BiomeId | null {
+  if (!isDailyEventSeed(seed)) {
+    return null;
+  }
+
+  const match = /biome(\d{2})/g.exec(seed);
+  if (!match || match.length !== 2) {
+    return null;
+  }
+
+  const startingBiome = Number.parseInt(match[1]) as BiomeId;
+
+  if (!getEnumValues(BiomeId).includes(startingBiome)) {
+    console.warn("Invalid biome ID used for custom daily run seed:", startingBiome);
+    return null;
+  }
+
+  return startingBiome;
+}
+
+/**
+ * Expects the seed to contain `/luck\d{2}/` where the 2 digits are a number between `0` and `14`
+ * (left padded with `0` if necessary).
+ * @returns The custom luck value or `null` if no valid match.
+ */
+export function getDailyEventSeedLuck(seed: string): number | null {
+  if (!isDailyEventSeed(seed)) {
+    return null;
+  }
+
+  const match = /luck(\d{2})/g.exec(seed);
+  if (!match || match.length !== 2) {
+    return null;
+  }
+
+  const luck = Number.parseInt(match[1]);
+
+  if (luck < 0 || luck > 14) {
+    console.warn("Invalid luck value used for custom daily run seed:", luck);
+    return null;
+  }
+
+  return luck;
+}

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

@@ -620,26 +620,14 @@ export class CompatibleMoveRequirement extends EncounterPokemonRequirement {
 
   override queryParty(partyPokemon: PlayerPokemon[]): PlayerPokemon[] {
     if (!this.invertQuery) {
-      return partyPokemon.filter(
-        pokemon =>
-          this.requiredMoves.filter(learnableMove =>
-            pokemon.compatibleTms.filter(tm => !pokemon.moveset.find(m => m.moveId === tm)).includes(learnableMove),
-          ).length > 0,
-      );
+      return partyPokemon.filter(pokemon => this.requiredMoves.some(m => pokemon.isTmCompatible(m, true)));
     }
     // for an inverted query, we only want to get the pokemon that don't have ANY of the listed learnableMoves
-    return partyPokemon.filter(
-      pokemon =>
-        this.requiredMoves.filter(learnableMove =>
-          pokemon.compatibleTms.filter(tm => !pokemon.moveset.find(m => m.moveId === tm)).includes(learnableMove),
-        ).length === 0,
-    );
+    return partyPokemon.filter(pokemon => !this.requiredMoves.some(m => pokemon.isTmCompatible(m, true)));
   }
 
   override getDialogueToken(pokemon?: PlayerPokemon): [string, string] {
-    const includedCompatMoves = this.requiredMoves.filter(reqMove =>
-      pokemon?.compatibleTms.filter(tm => !pokemon.moveset.find(m => m.moveId === tm)).includes(reqMove),
-    );
+    const includedCompatMoves = this.requiredMoves.filter(reqMove => pokemon?.isTmCompatible(reqMove, true));
     if (includedCompatMoves.length > 0) {
       return ["compatibleMove", MoveId[includedCompatMoves[0]]];
     }

src/data/mystery-encounters/requirements/can-learn-move-requirement.ts

@@ -81,7 +81,7 @@ export class CanLearnMoveRequirement extends EncounterPokemonRequirement {
     }
 
     if (!this.excludeTmMoves) {
-      allPokemonMoves.push(...(pkm.compatibleTms ?? []));
+      allPokemonMoves.push(...(pkm.getCompatibleTms() ?? []));
     }
 
     if (!this.excludeEggMoves) {

src/data/pokemon-species.ts

@@ -13,10 +13,12 @@ import {
   pokemonSpeciesLevelMoves,
 } from "#balance/pokemon-level-moves";
 import { speciesStarterCosts } from "#balance/starters";
+import { speciesFormTmList, speciesTmList } from "#balance/tms";
 import type { GrowthRate } from "#data/exp";
 import { Gender } from "#data/gender";
 import { AbilityId } from "#enums/ability-id";
 import { DexAttr } from "#enums/dex-attr";
+import type { MoveId } from "#enums/move-id";
 import { PartyMemberStrength } from "#enums/party-member-strength";
 import type { PokemonType } from "#enums/pokemon-type";
 import { SpeciesFormKey } from "#enums/species-form-key";
@@ -351,6 +353,41 @@ export abstract class PokemonSpeciesForm {
     return `pokemon_icons_${this.generation}${isVariant ? "v" : ""}`;
   }
 
+  /**
+   * Compiles a list of all TMs compatible with this SpeciesForm
+   * @param formIndex formIndex to check
+   * @returns
+   */
+  getCompatibleTms(formIndex?: number): MoveId[] {
+    const tms: MoveId[] = [];
+    tms.push(...speciesTmList[this.speciesId]);
+    if (speciesFormTmList.hasOwnProperty(this.speciesId)) {
+      formIndex = this.formIndex ?? formIndex ?? -1;
+      const formKey = getPokemonSpecies(this.speciesId).forms[formIndex].formKey;
+      tms.push(...(speciesFormTmList[this.speciesId][formKey] ?? []));
+    }
+    return tms;
+  }
+
+  /**
+   * Gets the actual formKey associated with a given formIndex
+   * @param formIndex The formIndex to check
+   */
+  abstract getFormKey(formIndex?: number): string;
+
+  /**
+   * Checks whether a TM is compatible with a SpeciesForm
+   * @param tm The move to check for
+   * @param formIndex If provided, looks specifically for this form
+   * @returns Whether the TM is compatible with this SpeciesForm
+   */
+  isTmCompatible(tm: MoveId, formIndex?: number): boolean {
+    return (
+      speciesTmList[this.speciesId].includes(tm) ||
+      speciesFormTmList[this.speciesId][this.getFormKey(formIndex)].includes(tm)
+    );
+  }
+
   getIconId(female: boolean, formIndex?: number, shiny?: boolean, variant?: number): string {
     if (formIndex === undefined) {
       formIndex = this.formIndex;
@@ -878,6 +915,15 @@ export class PokemonSpecies extends PokemonSpeciesForm implements Localizable {
       : ret;
   }
 
+  /**
+   * Returns the actual formKey associated with the form at the specified index
+   * @param formIndex the formIndex to check
+   * @returns
+   */
+  getFormKey(formIndex?: number): string {
+    return this.forms[formIndex ?? this.formIndex].formKey ?? "";
+  }
+
   localize(): void {
     this.name = i18next.t(`pokemon:${SpeciesId[this.speciesId].toLowerCase()}`);
     this.category = i18next.t(`pokemonCategory:${SpeciesId[this.speciesId].toLowerCase()}_category`);
@@ -1317,6 +1363,13 @@ export class PokemonForm extends PokemonSpeciesForm {
     this.isUnobtainable = isUnobtainable;
   }
 
+  /**
+   * Returns the actual formKey for this PokemonForm
+   */
+  getFormKey(_formIndex?: number): string {
+    return this.formKey;
+  }
+
   getFormSpriteKey(_formIndex?: number) {
     return this.formSpriteKey !== null ? this.formSpriteKey : this.formKey;
   }

src/data/trainers/trainer-config.ts

@@ -2,7 +2,7 @@ import { timedEventManager } from "#app/global-event-manager";
 import { globalScene } from "#app/global-scene";
 import { pokemonEvolutions, pokemonPrevolutions } from "#balance/pokemon-evolutions";
 import { signatureSpecies } from "#balance/signature-species";
-import { tmSpecies } from "#balance/tms";
+import { speciesTmList } from "#balance/tms";
 import { modifierTypes } from "#data/data-lists";
 import { doubleBattleDialogue } from "#data/double-battle-dialogue";
 import { Gender } from "#data/gender";
@@ -1445,7 +1445,7 @@ export const trainerConfigs: TrainerConfigs = {
     .setSpeciesFilter(s => s.isOfType(PokemonType.ELECTRIC)),
   [TrainerType.HARLEQUIN]: new TrainerConfig(++t)
     .setEncounterBgm(TrainerType.PSYCHIC)
-    .setSpeciesFilter(s => tmSpecies[MoveId.TRICK_ROOM].indexOf(s.speciesId) > -1),
+    .setSpeciesFilter(s => speciesTmList[s.speciesId].includes(MoveId.TRICK_ROOM)),
   [TrainerType.HIKER]: new TrainerConfig(++t)
     .setEncounterBgm(TrainerType.BACKPACKER)
     .setPartyTemplates(
@@ -1589,7 +1589,7 @@ export const trainerConfigs: TrainerConfigs = {
       trainerPartyTemplates.TWO_AVG,
       trainerPartyTemplates.THREE_AVG,
     )
-    .setSpeciesFilter(s => tmSpecies[MoveId.FLY].indexOf(s.speciesId) > -1),
+    .setSpeciesFilter(s => speciesTmList[s.speciesId].includes(MoveId.FLY)),
   [TrainerType.POKEFAN]: new TrainerConfig(++t)
     .setMoneyMultiplier(1.4)
     .setName("Pokéfan")
@@ -1605,7 +1605,7 @@ export const trainerConfigs: TrainerConfigs = {
       trainerPartyTemplates.FIVE_WEAK,
       trainerPartyTemplates.SIX_WEAKER_SAME,
     )
-    .setSpeciesFilter(s => tmSpecies[MoveId.HELPING_HAND].indexOf(s.speciesId) > -1),
+    .setSpeciesFilter(s => speciesTmList[s.speciesId].includes(MoveId.HELPING_HAND)),
   [TrainerType.PRESCHOOLER]: new TrainerConfig(++t)
     .setMoneyMultiplier(0.2)
     .setEncounterBgm(TrainerType.YOUNGSTER)

src/field/pokemon.ts

@@ -18,7 +18,7 @@ import type { LevelMoves } from "#balance/pokemon-level-moves";
 import { EVOLVE_MOVE, RELEARN_MOVE } from "#balance/pokemon-level-moves";
 import { BASE_HIDDEN_ABILITY_CHANCE, BASE_SHINY_CHANCE, SHINY_EPIC_CHANCE, SHINY_VARIANT_CHANCE } from "#balance/rates";
 import { getStarterValueFriendshipCap, speciesStarterCosts } from "#balance/starters";
-import { reverseCompatibleTms, tmPoolTiers, tmSpecies } from "#balance/tms";
+import { tmPoolTiers } from "#balance/tms";
 import type { SuppressAbilitiesTag } from "#data/arena-tag";
 import { NoCritTag, WeakenMoveScreenTag } from "#data/arena-tag";
 import {
@@ -39,6 +39,7 @@ import {
   TrappedTag,
   TypeImmuneTag,
 } from "#data/battler-tags";
+import { getDailyEventSeedBoss } from "#data/daily-run";
 import { allAbilities, allMoves } from "#data/data-lists";
 import { getLevelTotalExp } from "#data/exp";
 import {
@@ -3082,27 +3083,13 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
     }
 
     if (this.hasTrainer()) {
-      const tms = Object.keys(tmSpecies);
-      for (const tm of tms) {
-        const moveId = Number.parseInt(tm) as MoveId;
-        let compatible = false;
-        for (const p of tmSpecies[tm]) {
-          if (Array.isArray(p)) {
-            if (
-              p[0] === this.species.speciesId ||
-              (this.fusionSpecies &&
-                p[0] === this.fusionSpecies.speciesId &&
-                p.slice(1).indexOf(this.species.forms[this.formIndex]) > -1)
-            ) {
-              compatible = true;
-              break;
-            }
-          } else if (p === this.species.speciesId || (this.fusionSpecies && p === this.fusionSpecies.speciesId)) {
-            compatible = true;
-            break;
-          }
-        }
-        if (compatible && !movePool.some(m => m[0] === moveId) && !allMoves[moveId].name.endsWith(" (N)")) {
+      const tmset = new Set(this.species.getCompatibleTms(this.formIndex));
+      if (this.fusionSpecies) {
+        this.fusionSpecies.getCompatibleTms(this.fusionFormIndex).forEach(m => tmset.add(m));
+      }
+      const tms = Array.from(tmset);
+      for (const moveId of tms) {
+        if (!movePool.some(m => m[0] === moveId) && !allMoves[moveId].name.endsWith(" (N)")) {
           if (tmPoolTiers[moveId] === ModifierTier.COMMON && this.level >= 15) {
             movePool.push([moveId, 4]);
           } else if (tmPoolTiers[moveId] === ModifierTier.GREAT && this.level >= 30) {
@@ -5673,7 +5660,6 @@ export abstract class Pokemon extends Phaser.GameObjects.Container {
 
 export class PlayerPokemon extends Pokemon {
   protected declare battleInfo: PlayerBattleInfo;
-  public compatibleTms: MoveId[];
 
   constructor(
     species: PokemonSpecies,
@@ -5711,7 +5697,6 @@ export class PlayerPokemon extends Pokemon {
         this.moveset = [];
       }
     }
-    this.generateCompatibleTms();
   }
 
   initBattleInfo(): void {
@@ -5743,35 +5728,48 @@ export class PlayerPokemon extends Pokemon {
     return this.getFieldIndex();
   }
 
-  generateCompatibleTms(): void {
-    this.compatibleTms = [];
-
-    const tms = Object.keys(tmSpecies);
-    for (const tm of tms) {
-      const moveId = Number.parseInt(tm) as MoveId;
-      let compatible = false;
-      for (const p of tmSpecies[tm]) {
-        if (Array.isArray(p)) {
-          const [pkm, form] = p;
-          if (
-            (pkm === this.species.speciesId || (this.fusionSpecies && pkm === this.fusionSpecies.speciesId)) &&
-            form === this.getFormKey()
-          ) {
-            compatible = true;
-            break;
-          }
-        } else if (p === this.species.speciesId || (this.fusionSpecies && p === this.fusionSpecies.speciesId)) {
-          compatible = true;
-          break;
-        }
+  /**
+   * Compiles a list of all TMs compatible with this PlayerPokemon, including its fusion
+   * @param excludeKnown Whether to exclude moves in its current moveset
+   * @param excludeLevelUp Whether to exclude moves learnable at a previous level (incl. relearn-only & evo moves)
+   * @param excludeUsed Whether to exclude TMs which were used before on the mon, contained in its "usedTMs" array
+   * @returns An array of all compatible MoveId[]
+   */
+  getCompatibleTms(excludeKnown = false, excludeLevelUp = false, excludeUsed = false): MoveId[] {
+    const tms = new Set(this.species.getCompatibleTms(this.formIndex));
+    if (this.fusionSpecies) {
+      this.fusionSpecies.getCompatibleTms(this.fusionFormIndex).forEach(m => tms.add(m));
+    }
+    if (excludeKnown && excludeLevelUp && excludeUsed) {
+      // All these cases are covered at once by getLearnableLevelMoves
+      this.getLearnableLevelMoves().forEach(m => tms.delete(m));
+    } else {
+      // If any of these are true, but not all three, they need to be individually filtered
+      if (excludeKnown) {
+        this.moveset.forEach(pm => tms.delete(pm.moveId));
       }
-      if (reverseCompatibleTms.indexOf(moveId) > -1) {
-        compatible = !compatible;
+      if (excludeLevelUp) {
+        this.getLevelMoves(undefined, true, false, true).forEach(lm => tms.delete(lm[1]));
       }
-      if (compatible) {
-        this.compatibleTms.push(moveId);
+      if (excludeUsed) {
+        this.usedTMs.forEach(tm => tms.delete(tm));
       }
     }
+    return Array.from(tms);
+  }
+
+  /**
+   * Determines if a TM is compatible with this PlayerPokemon
+   * @param tm The TM move to check for
+   * @param excludeKnown Whether to exclude moves in its current moveset
+   * @returns Whether it's compatible
+   */
+  isTmCompatible(tm: MoveId, excludeKnown = false): boolean {
+    return (
+      !(excludeKnown && this.moveset.some(pm => pm.moveId === tm)) &&
+      (this.species.isTmCompatible(tm, this.formIndex) ||
+        (!!this.fusionSpecies && this.fusionSpecies.isTmCompatible(tm, this.fusionFormIndex)))
+    );
   }
 
   tryPopulateMoveset(moveset: StarterMoveset): boolean {
@@ -5976,8 +5974,6 @@ export class PlayerPokemon extends Pokemon {
           this.fusionAbilityIndex = 0;
         }
       }
-      this.compatibleTms.splice(0, this.compatibleTms.length);
-      this.generateCompatibleTms();
       const updateAndResolve = () => {
         this.loadAssets().then(() => {
           this.calculateStats();
@@ -6089,8 +6085,6 @@ export class PlayerPokemon extends Pokemon {
         this.abilityIndex = abilityCount - 1;
       }
 
-      this.compatibleTms.splice(0, this.compatibleTms.length);
-      this.generateCompatibleTms();
       const updateAndResolve = () => {
         this.loadAssets().then(() => {
           this.calculateStats();
@@ -6107,11 +6101,6 @@ export class PlayerPokemon extends Pokemon {
     });
   }
 
-  clearFusionSpecies(): void {
-    super.clearFusionSpecies();
-    this.generateCompatibleTms();
-  }
-
   /**
    * Returns a Promise to fuse two PlayerPokemon together
    * @param pokemon The PlayerPokemon to fuse to this one
@@ -6151,7 +6140,6 @@ export class PlayerPokemon extends Pokemon {
       this.status = pokemon.status; // Inherit the other Pokemon's status
     }
 
-    this.generateCompatibleTms();
     this.updateInfo(true);
     const fusedPartyMemberIndex = globalScene.getPlayerParty().indexOf(pokemon);
     let partyMemberIndex = globalScene.getPlayerParty().indexOf(this);
@@ -6256,6 +6244,11 @@ export class EnemyPokemon extends Pokemon {
       this.species.forms[Overrides.OPP_FORM_OVERRIDES[speciesId]]
     ) {
       this.formIndex = Overrides.OPP_FORM_OVERRIDES[speciesId];
+    } else if (globalScene.gameMode.isDaily && globalScene.gameMode.isWaveFinal(globalScene.currentBattle.waveIndex)) {
+      const eventBoss = getDailyEventSeedBoss(globalScene.seed);
+      if (!isNullOrUndefined(eventBoss)) {
+        this.formIndex = eventBoss.formIndex;
+      }
     }
 
     if (!dataSource) {

src/game-mode.ts

@@ -3,7 +3,7 @@ import { CHALLENGE_MODE_MYSTERY_ENCOUNTER_WAVES, CLASSIC_MODE_MYSTERY_ENCOUNTER_
 import { globalScene } from "#app/global-scene";
 import Overrides from "#app/overrides";
 import { allChallenges, type Challenge, copyChallenge } from "#data/challenge";
-import { getDailyStartingBiome } from "#data/daily-run";
+import { getDailyEventSeedBoss, getDailyStartingBiome } from "#data/daily-run";
 import { allSpecies } from "#data/data-lists";
 import type { PokemonSpecies } from "#data/pokemon-species";
 import { BiomeId } from "#enums/biome-id";
@@ -15,6 +15,7 @@ import type { Arena } from "#field/arena";
 import { classicFixedBattles, type FixedBattleConfigs } from "#trainers/fixed-battle-configs";
 import { applyChallenges } from "#utils/challenge-utils";
 import { BooleanHolder, isNullOrUndefined, randSeedInt, randSeedItem } from "#utils/common";
+import { getPokemonSpecies } from "#utils/pokemon-utils";
 import i18next from "i18next";
 
 interface GameModeConfig {
@@ -211,6 +212,12 @@ export class GameMode implements GameModeConfig {
 
   getOverrideSpecies(waveIndex: number): PokemonSpecies | null {
     if (this.isDaily && this.isWaveFinal(waveIndex)) {
+      const eventBoss = getDailyEventSeedBoss(globalScene.seed);
+      if (!isNullOrUndefined(eventBoss)) {
+        // Cannot set form index here, it will be overriden when adding it as enemy pokemon.
+        return getPokemonSpecies(eventBoss.speciesId);
+      }
+
       const allFinalBossSpecies = allSpecies.filter(
         s =>
           (s.subLegendary || s.legendary || s.mythical) &&

src/modifier/modifier-type.ts

@@ -4,8 +4,9 @@ import { globalScene } from "#app/global-scene";
 import { getPokemonNameWithAffix } from "#app/messages";
 import Overrides from "#app/overrides";
 import { EvolutionItem, pokemonEvolutions } from "#balance/pokemon-evolutions";
-import { tmPoolTiers, tmSpecies } from "#balance/tms";
+import { tmPoolTiers } from "#balance/tms";
 import { getBerryEffectDescription, getBerryName } from "#data/berry";
+import { getDailyEventSeedLuck } from "#data/daily-run";
 import { allMoves, modifierTypes } from "#data/data-lists";
 import { SpeciesFormChangeItemTrigger } from "#data/form-change-triggers";
 import { getNatureName, getNatureStatMultiplier } from "#data/nature";
@@ -1141,10 +1142,7 @@ export class TmModifierType extends PokemonModifierType {
       `tm_${PokemonType[allMoves[moveId].type].toLowerCase()}`,
       (_type, args) => new TmModifier(this, (args[0] as PlayerPokemon).id),
       (pokemon: PlayerPokemon) => {
-        if (
-          pokemon.compatibleTms.indexOf(moveId) === -1 ||
-          pokemon.getMoveset().filter(m => m.moveId === moveId).length
-        ) {
+        if (!pokemon.isTmCompatible(moveId, true)) {
           return PartyUiHandler.NoEffectMessage;
         }
         return null;
@@ -1157,7 +1155,7 @@ export class TmModifierType extends PokemonModifierType {
 
   get name(): string {
     return i18next.t("modifierType:ModifierType.TmModifierType.name", {
-      moveId: padInt(Object.keys(tmSpecies).indexOf(this.moveId.toString()) + 1, 3),
+      moveId: padInt(Object.keys(tmPoolTiers).indexOf(this.moveId.toString()) + 1, 3),
       moveName: allMoves[this.moveId].name,
     });
   }
@@ -1518,12 +1516,7 @@ class TmModifierTypeGenerator extends ModifierTypeGenerator {
       if (pregenArgs && pregenArgs.length === 1 && pregenArgs[0] in MoveId) {
         return new TmModifierType(pregenArgs[0] as MoveId);
       }
-      const partyMemberCompatibleTms = party.map(p => {
-        const previousLevelMoves = p.getLearnableLevelMoves();
-        return (p as PlayerPokemon).compatibleTms.filter(
-          tm => !p.moveset.find(m => m.moveId === tm) && !previousLevelMoves.find(lm => lm === tm),
-        );
-      });
+      const partyMemberCompatibleTms = party.map(p => (p as PlayerPokemon).getCompatibleTms(true, true));
       const tierUniqueCompatibleTms = partyMemberCompatibleTms
         .flat()
         .filter(tm => tmPoolTiers[tm] === tier)
@@ -2921,6 +2914,12 @@ export function getPartyLuckValue(party: Pokemon[]): number {
     const DailyLuck = new NumberHolder(0);
     globalScene.executeWithSeedOffset(
       () => {
+        const eventLuck = getDailyEventSeedLuck(globalScene.seed);
+        if (!isNullOrUndefined(eventLuck)) {
+          DailyLuck.value = eventLuck;
+          return;
+        }
+
         DailyLuck.value = randSeedInt(15); // Random number between 0 and 14
       },
       0,
@@ -2928,6 +2927,7 @@ export function getPartyLuckValue(party: Pokemon[]): number {
     );
     return DailyLuck.value;
   }
+
   const eventSpecies = timedEventManager.getEventLuckBoostedSpecies();
   const luck = Phaser.Math.Clamp(
     party

src/ui/party-ui-handler.ts

@@ -2029,9 +2029,9 @@ class PartySlot extends Phaser.GameObjects.Container {
       this.slotHpText.setVisible(false);
       let slotTmText: string;
 
-      if (this.pokemon.getMoveset().filter(m => m.moveId === tmMoveId).length > 0) {
+      if (this.pokemon.getMoveset().some(m => m.moveId === tmMoveId)) {
         slotTmText = i18next.t("partyUiHandler:learned");
-      } else if (this.pokemon.compatibleTms.indexOf(tmMoveId) === -1) {
+      } else if (!this.pokemon.isTmCompatible(tmMoveId)) {
         slotTmText = i18next.t("partyUiHandler:notAble");
       } else {
         slotTmText = i18next.t("partyUiHandler:able");

src/ui/pokedex-page-ui-handler.ts

@@ -16,7 +16,6 @@ import {
   getValueReductionCandyCounts,
   speciesStarterCosts,
 } from "#balance/starters";
-import { speciesTmMoves } from "#balance/tms";
 import { allAbilities, allMoves, allSpecies } from "#data/data-lists";
 import { Egg, getEggTierForSpecies } from "#data/egg";
 import { GrowthRate, getGrowthRateColor } from "#data/exp";
@@ -838,10 +837,7 @@ export class PokedexPageUiHandler extends MessageUiHandler {
     );
 
     this.tmMoves =
-      speciesTmMoves[species.speciesId]
-        ?.filter(m => (Array.isArray(m) ? m[0] === formKey : true))
-        .map(m => (Array.isArray(m) ? m[1] : m))
-        .sort((a, b) => (allMoves[a].name > allMoves[b].name ? 1 : -1)) ?? [];
+      species.getCompatibleTms(formIndex).sort((a, b) => (allMoves[a].name > allMoves[b].name ? 1 : -1)) ?? [];
 
     const passiveId = starterPassiveAbilities.hasOwnProperty(species.speciesId)
       ? species.speciesId

src/ui/pokedex-ui-handler.ts

@@ -12,7 +12,6 @@ import {
   POKERUS_STARTER_COUNT,
   speciesStarterCosts,
 } from "#balance/starters";
-import { speciesTmMoves } from "#balance/tms";
 import { allAbilities, allMoves, allSpecies } from "#data/data-lists";
 import type { PokemonForm, PokemonSpecies } from "#data/pokemon-species";
 import { normalForm } from "#data/pokemon-species";
@@ -1380,7 +1379,7 @@ export class PokedexUiHandler extends MessageUiHandler {
       const levelMoves = pokemonSpeciesLevelMoves[species.speciesId].map(m => allMoves[m[1]].name);
       // This always gets egg moves from the starter
       const eggMoves = speciesEggMoves[starterId]?.map(m => allMoves[m].name) ?? [];
-      const tmMoves = speciesTmMoves[species.speciesId]?.map(m => allMoves[Array.isArray(m) ? m[1] : m].name) ?? [];
+      const tmMoves = species.getCompatibleTms().map(m => allMoves[m].name) ?? [];
       const selectedMove1 = this.filterText.getValue(FilterTextRow.MOVE_1);
       const selectedMove2 = this.filterText.getValue(FilterTextRow.MOVE_2);
 

test/field/pokemon.test.ts

@@ -80,8 +80,8 @@ describe("Spec - Pokemon", () => {
 
     const fanRotom = game.field.getPlayerPokemon();
 
-    expect(fanRotom.compatibleTms).not.toContain(MoveId.BLIZZARD);
-    expect(fanRotom.compatibleTms).toContain(MoveId.AIR_SLASH);
+    expect(fanRotom.isTmCompatible(MoveId.BLIZZARD)).toBe(false);
+    expect(fanRotom.isTmCompatible(MoveId.AIR_SLASH)).toBe(true);
   });
 
   describe("Get correct fusion type", () => {