Merge remote-tracking branch 'upstream/beta' into move-use-type

src/data/balance/tms.ts

@@ -5988,6 +5988,7 @@ export const tmSpecies: TmSpecies = {
     SpeciesId.FEZANDIPITI,
     SpeciesId.ARCHALUDON,
     SpeciesId.IRON_CROWN,
+    SpeciesId.TERAPAGOS,
     SpeciesId.ALOLA_RATICATE,
     SpeciesId.ALOLA_RAICHU,
     SpeciesId.ALOLA_SANDSLASH,
@@ -16248,6 +16249,7 @@ export const tmSpecies: TmSpecies = {
     SpeciesId.CALYREX,
     SpeciesId.SANDY_SHOCKS,
     SpeciesId.IRON_JUGULIS,
+    SpeciesId.TERAPAGOS,
     SpeciesId.ALOLA_DUGTRIO,
     SpeciesId.GALAR_SLOWPOKE,
     SpeciesId.GALAR_SLOWBRO,
@@ -39466,6 +39468,8 @@ export const tmSpecies: TmSpecies = {
     SpeciesId.FARFETCHD,
     SpeciesId.DODUO,
     SpeciesId.DODRIO,
+    SpeciesId.DEWGONG,
+    SpeciesId.GRIMER,
     SpeciesId.MUK,
     SpeciesId.GASTLY,
     SpeciesId.HAUNTER,
@@ -39477,6 +39481,7 @@ export const tmSpecies: TmSpecies = {
     SpeciesId.CUBONE,
     SpeciesId.MAROWAK,
     SpeciesId.HITMONLEE,
+    SpeciesId.HITMONCHAN,
     SpeciesId.LICKITUNG,
     SpeciesId.TANGELA,
     SpeciesId.GOLDEEN,
@@ -48806,6 +48811,7 @@ export const tmSpecies: TmSpecies = {
     SpeciesId.GARGANACL,
     SpeciesId.GLIMMET,
     SpeciesId.GLIMMORA,
+    SpeciesId.TERAPAGOS,
     SpeciesId.ALOLA_GEODUDE,
     SpeciesId.ALOLA_GRAVELER,
     SpeciesId.ALOLA_GOLEM,
@@ -53077,6 +53083,7 @@ export const tmSpecies: TmSpecies = {
     SpeciesId.MIRAIDON,
     SpeciesId.ARCHALUDON,
     SpeciesId.IRON_CROWN,
+    SpeciesId.TERAPAGOS,
     [
       SpeciesId.WORMADAM,
       "trash",

src/phases/select-modifier-phase.ts

@@ -31,6 +31,8 @@ import Overrides from "#app/overrides";
 import type { CustomModifierSettings } from "#app/modifier/modifier-type";
 import { isNullOrUndefined, NumberHolder } from "#app/utils/common";
 
+export type ModifierSelectCallback = (rowCursor: number, cursor: number) => boolean;
+
 export class SelectModifierPhase extends BattlePhase {
   public readonly phaseName = "SelectModifierPhase";
   private rerollCount: number;
@@ -57,6 +59,10 @@ export class SelectModifierPhase extends BattlePhase {
   start() {
     super.start();
 
+    if (!this.isPlayer()) {
+      return false;
+    }
+
     if (!this.rerollCount && !this.isCopy) {
       this.updateSeed();
     } else if (this.rerollCount) {
@@ -67,27 +73,9 @@ export class SelectModifierPhase extends BattlePhase {
     if (!this.isCopy) {
       regenerateModifierPoolThresholds(party, this.getPoolType(), this.rerollCount);
     }
-    const modifierCount = new NumberHolder(3);
+    const modifierCount = this.getModifierCount();
-    if (this.isPlayer()) {
-      globalScene.applyModifiers(ExtraModifierModifier, true, modifierCount);
-      globalScene.applyModifiers(TempExtraModifierModifier, true, modifierCount);
-    }
 
-    // If custom modifiers are specified, overrides default item count
+    this.typeOptions = this.getModifierTypeOptions(modifierCount);
-    if (this.customModifierSettings) {
-      const newItemCount =
-        (this.customModifierSettings.guaranteedModifierTiers?.length || 0) +
-        (this.customModifierSettings.guaranteedModifierTypeOptions?.length || 0) +
-        (this.customModifierSettings.guaranteedModifierTypeFuncs?.length || 0);
-      if (this.customModifierSettings.fillRemaining) {
-        const originalCount = modifierCount.value;
-        modifierCount.value = originalCount > newItemCount ? originalCount : newItemCount;
-      } else {
-        modifierCount.value = newItemCount;
-      }
-    }
-
-    this.typeOptions = this.getModifierTypeOptions(modifierCount.value);
 
     const modifierSelectCallback = (rowCursor: number, cursor: number) => {
       if (rowCursor < 0 || cursor < 0) {
@@ -99,25 +87,105 @@ export class SelectModifierPhase extends BattlePhase {
               globalScene.ui.setMode(UiMode.MESSAGE);
               super.end();
             },
-            () =>
+            () => this.resetModifierSelect(modifierSelectCallback),
-              globalScene.ui.setMode(
-                UiMode.MODIFIER_SELECT,
-                this.isPlayer(),
-                this.typeOptions,
-                modifierSelectCallback,
-                this.getRerollCost(globalScene.lockModifierTiers),
-              ),
           );
         });
         return false;
       }
-      let modifierType: ModifierType;
+
-      let cost: number;
-      const rerollCost = this.getRerollCost(globalScene.lockModifierTiers);
       switch (rowCursor) {
+        // Execute one of the options from the bottom row
         case 0:
           switch (cursor) {
             case 0:
+              return this.rerollModifiers();
+            case 1:
+              return this.openModifierTransferScreen(modifierSelectCallback);
+            // Check the party, pass a callback to restore the modifier select screen.
+            case 2:
+              globalScene.ui.setModeWithoutClear(UiMode.PARTY, PartyUiMode.CHECK, -1, () => {
+                this.resetModifierSelect(modifierSelectCallback);
+              });
+              return true;
+            case 3:
+              return this.toggleRerollLock();
+            default:
+              return false;
+          }
+        // Pick an option from the rewards
+        case 1:
+          return this.selectRewardModifierOption(cursor, modifierSelectCallback);
+        // Pick an option from the shop
+        default: {
+          return this.selectShopModifierOption(rowCursor, cursor, modifierSelectCallback);
+        }
+      }
+    };
+
+    this.resetModifierSelect(modifierSelectCallback);
+  }
+
+  // Pick a modifier from among the rewards and apply it
+  private selectRewardModifierOption(cursor: number, modifierSelectCallback: ModifierSelectCallback): boolean {
+    if (this.typeOptions.length === 0) {
+      globalScene.ui.clearText();
+      globalScene.ui.setMode(UiMode.MESSAGE);
+      super.end();
+      return true;
+    }
+    const modifierType = this.typeOptions[cursor].type;
+    return this.applyChosenModifier(modifierType, 0, modifierSelectCallback);
+  }
+
+  // Pick a modifier from the shop and apply it
+  private selectShopModifierOption(
+    rowCursor: number,
+    cursor: number,
+    modifierSelectCallback: ModifierSelectCallback,
+  ): boolean {
+    const shopOptions = getPlayerShopModifierTypeOptionsForWave(
+      globalScene.currentBattle.waveIndex,
+      globalScene.getWaveMoneyAmount(1),
+    );
+    const shopOption =
+      shopOptions[
+        rowCursor > 2 || shopOptions.length <= SHOP_OPTIONS_ROW_LIMIT ? cursor : cursor + SHOP_OPTIONS_ROW_LIMIT
+      ];
+    const modifierType = shopOption.type;
+    // Apply Black Sludge to healing item cost
+    const healingItemCost = new NumberHolder(shopOption.cost);
+    globalScene.applyModifier(HealShopCostModifier, true, healingItemCost);
+    const cost = healingItemCost.value;
+
+    if (globalScene.money < cost && !Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
+      globalScene.ui.playError();
+      return false;
+    }
+
+    return this.applyChosenModifier(modifierType, cost, modifierSelectCallback);
+  }
+
+  // Apply a chosen modifier: do an effect or open the party menu
+  private applyChosenModifier(
+    modifierType: ModifierType,
+    cost: number,
+    modifierSelectCallback: ModifierSelectCallback,
+  ): boolean {
+    if (modifierType instanceof PokemonModifierType) {
+      if (modifierType instanceof FusePokemonModifierType) {
+        this.openFusionMenu(modifierType, cost, modifierSelectCallback);
+      } else {
+        this.openModifierMenu(modifierType, cost, modifierSelectCallback);
+      }
+    } else {
+      this.applyModifier(modifierType.newModifier()!);
+    }
+    return !cost;
+  }
+
+  // Reroll rewards
+  private rerollModifiers() {
+    const rerollCost = this.getRerollCost(globalScene.lockModifierTiers);
     if (rerollCost < 0 || globalScene.money < rerollCost) {
       globalScene.ui.playError();
       return false;
@@ -136,8 +204,12 @@ export class SelectModifierPhase extends BattlePhase {
       globalScene.animateMoneyChanged(false);
     }
     globalScene.playSound("se/buy");
-              break;
+    return true;
-            case 1:
+  }
+
+  // Transfer modifiers among party pokemon
+  private openModifierTransferScreen(modifierSelectCallback: ModifierSelectCallback) {
+    const party = globalScene.getPlayerParty();
     globalScene.ui.setModeWithoutClear(
       UiMode.PARTY,
       PartyUiMode.MODIFIER_TRANSFER,
@@ -151,10 +223,7 @@ export class SelectModifierPhase extends BattlePhase {
           itemIndex > -1
         ) {
           const itemModifiers = globalScene.findModifiers(
-                      m =>
+            m => m instanceof PokemonHeldItemModifier && m.isTransferable && m.pokemonId === party[fromSlotIndex].id,
-                        m instanceof PokemonHeldItemModifier &&
-                        m.isTransferable &&
-                        m.pokemonId === party[fromSlotIndex].id,
           ) as PokemonHeldItemModifier[];
           const itemModifier = itemModifiers[itemIndex];
           globalScene.tryTransferHeldItemModifier(
@@ -167,30 +236,17 @@ export class SelectModifierPhase extends BattlePhase {
             false,
           );
         } else {
-                    globalScene.ui.setMode(
+          this.resetModifierSelect(modifierSelectCallback);
-                      UiMode.MODIFIER_SELECT,
-                      this.isPlayer(),
-                      this.typeOptions,
-                      modifierSelectCallback,
-                      this.getRerollCost(globalScene.lockModifierTiers),
-                    );
         }
       },
       PartyUiHandler.FilterItemMaxStacks,
     );
-              break;
+    return true;
-            case 2:
+  }
-              globalScene.ui.setModeWithoutClear(UiMode.PARTY, PartyUiMode.CHECK, -1, () => {
+
-                globalScene.ui.setMode(
+  // Toggle reroll lock
-                  UiMode.MODIFIER_SELECT,
+  private toggleRerollLock() {
-                  this.isPlayer(),
+    const rerollCost = this.getRerollCost(globalScene.lockModifierTiers);
-                  this.typeOptions,
-                  modifierSelectCallback,
-                  this.getRerollCost(globalScene.lockModifierTiers),
-                );
-              });
-              break;
-            case 3:
     if (rerollCost < 0) {
       // Reroll lock button is also disabled when reroll is disabled
       globalScene.ui.playError();
@@ -203,44 +259,9 @@ export class SelectModifierPhase extends BattlePhase {
     uiHandler.updateRerollCostText();
     return false;
   }
-          return true;
-        case 1:
-          if (this.typeOptions.length === 0) {
-            globalScene.ui.clearText();
-            globalScene.ui.setMode(UiMode.MESSAGE);
-            super.end();
-            return true;
-          }
-          if (this.typeOptions[cursor].type) {
-            modifierType = this.typeOptions[cursor].type;
-          }
-          break;
-        default:
-          const shopOptions = getPlayerShopModifierTypeOptionsForWave(
-            globalScene.currentBattle.waveIndex,
-            globalScene.getWaveMoneyAmount(1),
-          );
-          const shopOption =
-            shopOptions[
-              rowCursor > 2 || shopOptions.length <= SHOP_OPTIONS_ROW_LIMIT ? cursor : cursor + SHOP_OPTIONS_ROW_LIMIT
-            ];
-          if (shopOption.type) {
-            modifierType = shopOption.type;
-          }
-          // Apply Black Sludge to healing item cost
-          const healingItemCost = new NumberHolder(shopOption.cost);
-          globalScene.applyModifier(HealShopCostModifier, true, healingItemCost);
-          cost = healingItemCost.value;
-          break;
-      }
 
-      if (cost! && globalScene.money < cost && !Overrides.WAIVE_ROLL_FEE_OVERRIDE) {
+  // Applies the effects of the chosen modifier
-        // TODO: is the bang on cost correct?
+  private applyModifier(modifier: Modifier, cost = 0, playSound = false): void {
-        globalScene.ui.playError();
-        return false;
-      }
-
-      const applyModifier = (modifier: Modifier, playSound = false) => {
     const result = globalScene.addModifier(modifier, false, playSound, undefined, undefined, 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,
@@ -266,11 +287,15 @@ export class SelectModifierPhase extends BattlePhase {
       globalScene.ui.setMode(UiMode.MESSAGE);
       super.end();
     }
-      };
+  }
 
-      if (modifierType! instanceof PokemonModifierType) {
+  // Opens the party menu specifically for fusions
-        //TODO: is the bang correct?
+  private openFusionMenu(
-        if (modifierType instanceof FusePokemonModifierType) {
+    modifierType: PokemonModifierType,
+    cost: number,
+    modifierSelectCallback: ModifierSelectCallback,
+  ): void {
+    const party = globalScene.getPlayerParty();
     globalScene.ui.setModeWithoutClear(
       UiMode.PARTY,
       PartyUiMode.SPLICE,
@@ -284,21 +309,23 @@ export class SelectModifierPhase extends BattlePhase {
         ) {
           globalScene.ui.setMode(UiMode.MODIFIER_SELECT, this.isPlayer()).then(() => {
             const modifier = modifierType.newModifier(party[fromSlotIndex], party[spliceSlotIndex])!; //TODO: is the bang correct?
-                  applyModifier(modifier, true);
+            this.applyModifier(modifier, cost, true);
           });
         } else {
-                globalScene.ui.setMode(
+          this.resetModifierSelect(modifierSelectCallback);
-                  UiMode.MODIFIER_SELECT,
-                  this.isPlayer(),
-                  this.typeOptions,
-                  modifierSelectCallback,
-                  this.getRerollCost(globalScene.lockModifierTiers),
-                );
         }
       },
       modifierType.selectFilter,
     );
-        } else {
+  }
+
+  // Opens the party menu to apply one of various modifiers
+  private openModifierMenu(
+    modifierType: PokemonModifierType,
+    cost: number,
+    modifierSelectCallback: ModifierSelectCallback,
+  ): void {
+    const party = globalScene.getPlayerParty();
     const pokemonModifierType = modifierType as PokemonModifierType;
     const isMoveModifier = modifierType instanceof PokemonMoveModifierType;
     const isTmModifier = modifierType instanceof TmModifierType;
@@ -325,16 +352,10 @@ export class SelectModifierPhase extends BattlePhase {
                 ? modifierType.newModifier(party[slotIndex])
                 : modifierType.newModifier(party[slotIndex], option as number)
               : modifierType.newModifier(party[slotIndex], option - PartyOption.MOVE_1);
-                  applyModifier(modifier!, true); // TODO: is the bang correct?
+            this.applyModifier(modifier!, cost, true); // TODO: is the bang correct?
           });
         } else {
-                globalScene.ui.setMode(
+          this.resetModifierSelect(modifierSelectCallback);
-                  UiMode.MODIFIER_SELECT,
-                  this.isPlayer(),
-                  this.typeOptions,
-                  modifierSelectCallback,
-                  this.getRerollCost(globalScene.lockModifierTiers),
-                );
         }
       },
       pokemonModifierType.selectFilter,
@@ -345,12 +366,33 @@ export class SelectModifierPhase extends BattlePhase {
       isPpRestoreModifier,
     );
   }
+
+  // Function that determines how many reward slots are available
+  private getModifierCount(): number {
+    const modifierCountHolder = new NumberHolder(3);
+    globalScene.applyModifiers(ExtraModifierModifier, true, modifierCountHolder);
+    globalScene.applyModifiers(TempExtraModifierModifier, true, modifierCountHolder);
+
+    // If custom modifiers are specified, overrides default item count
+    if (this.customModifierSettings) {
+      const newItemCount =
+        (this.customModifierSettings.guaranteedModifierTiers?.length ?? 0) +
+        (this.customModifierSettings.guaranteedModifierTypeOptions?.length ?? 0) +
+        (this.customModifierSettings.guaranteedModifierTypeFuncs?.length ?? 0);
+      if (this.customModifierSettings.fillRemaining) {
+        const originalCount = modifierCountHolder.value;
+        modifierCountHolder.value = originalCount > newItemCount ? originalCount : newItemCount;
       } else {
-        applyModifier(modifierType!.newModifier()!); // TODO: is the bang correct?
+        modifierCountHolder.value = newItemCount;
+      }
     }
 
-      return !cost!; // TODO: is the bang correct?
+    return modifierCountHolder.value;
-    };
+  }
+
+  // Function that resets the reward selection screen,
+  // e.g. after pressing cancel in the party ui or while learning a move
+  private resetModifierSelect(modifierSelectCallback: ModifierSelectCallback) {
     globalScene.ui.setMode(
       UiMode.MODIFIER_SELECT,
       this.isPlayer(),

test/abilities/dancer.test.ts

@@ -25,7 +25,7 @@ describe("Abilities - Dancer", () => {
 
   beforeEach(() => {
     game = new GameManager(phaserGame);
-    game.override.battleStyle("double");
+    game.override.battleStyle("double").enemyAbility(AbilityId.BALL_FETCH);
   });
 
   // Reference Link: https://bulbapedia.bulbagarden.net/wiki/Dancer_(Ability)