Merge ee80615436 into 2b3b47cc07

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 {
@@ -3082,27 +3082,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 +5659,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 +5696,6 @@ export class PlayerPokemon extends Pokemon {
         this.moveset = [];
       }
     }
-    this.generateCompatibleTms();
   }
 
   initBattleInfo(): void {
@@ -5743,35 +5727,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 +5973,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 +6084,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 +6100,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 +6139,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);

src/modifier/modifier-type.ts

@@ -4,7 +4,7 @@ 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 { allMoves, modifierTypes } from "#data/data-lists";
 import { SpeciesFormChangeItemTrigger } from "#data/form-change-triggers";
@@ -1141,10 +1141,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 +1154,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 +1515,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)

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", () => {