Add Fee Waiving Overrides

xsn34kzx · Jul 9, 2024 · f58e08c · f58e08c
1 parent c145998
commit f58e08c
Show file tree

Hide file tree

Showing 3 changed files with 227 additions and 2 deletions.
diff --git a/src/overrides.ts b/src/overrides.ts
@@ -38,6 +38,10 @@ export const XP_MULTIPLIER_OVERRIDE: number = null;
 export const NEVER_CRIT_OVERRIDE: boolean = false;
 // default 1000
 export const STARTING_MONEY_OVERRIDE: integer = 0;
+/** Sets all shop item prices to 0 */
+export const WAIVE_SHOP_FEES_OVERRIDE: boolean = false;
+/** Sets reroll price to 0 */
+export const WAIVE_REROLL_FEE_OVERRIDE: boolean = false;
 export const FREE_CANDY_UPGRADE_OVERRIDE: boolean = false;
 export const POKEBALL_OVERRIDE: { active: boolean, pokeballs: PokeballCounts } = {
   active: false,

diff --git a/src/phases.ts b/src/phases.ts
@@ -5378,6 +5378,225 @@ export class AttemptRunPhase extends PokemonPhase {
   }
 }
 
+export class SelectModifierPhase extends BattlePhase {
+  private rerollCount: integer;
+  private modifierTiers: ModifierTier[];
+
+  constructor(scene: BattleScene, rerollCount: integer = 0, modifierTiers?: ModifierTier[]) {
+    super(scene);
+
+    this.rerollCount = rerollCount;
+    this.modifierTiers = modifierTiers;
+  }
+
+  start() {
+    super.start();
+
+    if (!this.rerollCount) {
+      this.updateSeed();
+    } else {
+      this.scene.reroll = false;
+    }
+
+    const party = this.scene.getParty();
+    regenerateModifierPoolThresholds(party, this.getPoolType(), this.rerollCount);
+    const modifierCount = new Utils.IntegerHolder(3);
+    if (this.isPlayer()) {
+      this.scene.applyModifiers(ExtraModifierModifier, true, modifierCount);
+    }
+    const typeOptions: ModifierTypeOption[] = this.getModifierTypeOptions(modifierCount.value);
+
+    const modifierSelectCallback = (rowCursor: integer, cursor: integer) => {
+      if (rowCursor < 0 || cursor < 0) {
+        this.scene.ui.showText(i18next.t("battle:skipItemQuestion"), null, () => {
+          this.scene.ui.setOverlayMode(Mode.CONFIRM, () => {
+            this.scene.ui.revertMode();
+            this.scene.ui.setMode(Mode.MESSAGE);
+            super.end();
+          }, () => this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers)));
+        });
+        return false;
+      }
+      let modifierType: ModifierType;
+      let cost: integer;
+      switch (rowCursor) {
+      case 0:
+        switch (cursor) {
+        case 0:
+          const rerollCost = this.getRerollCost(typeOptions, this.scene.lockModifierTiers);
+          if (this.scene.money < rerollCost) {
+            this.scene.ui.playError();
+            return false;
+          } else {
+            this.scene.reroll = true;
+            this.scene.unshiftPhase(new SelectModifierPhase(this.scene, this.rerollCount + 1, typeOptions.map(o => o.type.tier)));
+            this.scene.ui.clearText();
+            this.scene.ui.setMode(Mode.MESSAGE).then(() => super.end());
+            if (!Overrides.WAIVE_REROLL_FEE_OVERRIDE) {
+              this.scene.money -= rerollCost;
+              this.scene.updateMoneyText();
+              this.scene.animateMoneyChanged(false);
+            }
+            this.scene.playSound("buy");
+          }
+          break;
+        case 1:
+          this.scene.ui.setModeWithoutClear(Mode.PARTY, PartyUiMode.MODIFIER_TRANSFER, -1, (fromSlotIndex: integer, itemIndex: integer, itemQuantity: integer, toSlotIndex: integer) => {
+            if (toSlotIndex !== undefined && fromSlotIndex < 6 && toSlotIndex < 6 && fromSlotIndex !== toSlotIndex && itemIndex > -1) {
+              const itemModifiers = this.scene.findModifiers(m => m instanceof PokemonHeldItemModifier
+                      && (m as PokemonHeldItemModifier).getTransferrable(true) && (m as PokemonHeldItemModifier).pokemonId === party[fromSlotIndex].id) as PokemonHeldItemModifier[];
+              const itemModifier = itemModifiers[itemIndex];
+              this.scene.tryTransferHeldItemModifier(itemModifier, party[toSlotIndex], true, itemQuantity);
+            } else {
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+            }
+          }, PartyUiHandler.FilterItemMaxStacks);
+          break;
+        case 2:
+          this.scene.ui.setModeWithoutClear(Mode.PARTY, PartyUiMode.CHECK, -1, () => {
+            this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+          });
+          break;
+        case 3:
+          this.scene.lockModifierTiers = !this.scene.lockModifierTiers;
+          const uiHandler = this.scene.ui.getHandler() as ModifierSelectUiHandler;
+          uiHandler.setRerollCost(this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+          uiHandler.updateLockRaritiesText();
+          uiHandler.updateRerollCostText();
+          return false;
+        }
+        return true;
+      case 1:
+        modifierType = typeOptions[cursor].type;
+        break;
+      default:
+        const shopOptions = getPlayerShopModifierTypeOptionsForWave(this.scene.currentBattle.waveIndex, this.scene.getWaveMoneyAmount(1));
+        const shopOption = shopOptions[rowCursor > 2 || shopOptions.length <= SHOP_OPTIONS_ROW_LIMIT ? cursor : cursor + SHOP_OPTIONS_ROW_LIMIT];
+        modifierType = shopOption.type;
+        cost = shopOption.cost;
+        break;
+      }
+
+      if (cost && (this.scene.money < cost) && !Overrides.WAIVE_SHOP_FEES_OVERRIDE) {
+        this.scene.ui.playError();
+        return false;
+      }
+
+      const applyModifier = (modifier: Modifier, playSound: boolean = false) => {
+        const result = this.scene.addModifier(modifier, false, playSound);
+        if (cost) {
+          result.then(success => {
+            if (success) {
+              if (!Overrides.WAIVE_SHOP_FEES_OVERRIDE) {
+                this.scene.money -= cost;
+                this.scene.updateMoneyText();
+                this.scene.animateMoneyChanged(false);
+              }
+              this.scene.playSound("buy");
+              (this.scene.ui.getHandler() as ModifierSelectUiHandler).updateCostText();
+            } else {
+              this.scene.ui.playError();
+            }
+          });
+        } else {
+          const doEnd = () => {
+            this.scene.ui.clearText();
+            this.scene.ui.setMode(Mode.MESSAGE);
+            super.end();
+          };
+          if (result instanceof Promise) {
+            result.then(() => doEnd());
+          } else {
+            doEnd();
+          }
+        }
+      };
+
+      if (modifierType instanceof PokemonModifierType) {
+        if (modifierType instanceof FusePokemonModifierType) {
+          this.scene.ui.setModeWithoutClear(Mode.PARTY, PartyUiMode.SPLICE, -1, (fromSlotIndex: integer, spliceSlotIndex: integer) => {
+            if (spliceSlotIndex !== undefined && fromSlotIndex < 6 && spliceSlotIndex < 6 && fromSlotIndex !== spliceSlotIndex) {
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer()).then(() => {
+                const modifier = modifierType.newModifier(party[fromSlotIndex], party[spliceSlotIndex]);
+                applyModifier(modifier, true);
+              });
+            } else {
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+            }
+          }, modifierType.selectFilter);
+        } else {
+          const pokemonModifierType = modifierType as PokemonModifierType;
+          const isMoveModifier = modifierType instanceof PokemonMoveModifierType;
+          const isTmModifier = modifierType instanceof TmModifierType;
+          const isRememberMoveModifier = modifierType instanceof RememberMoveModifierType;
+          const isPpRestoreModifier = (modifierType instanceof PokemonPpRestoreModifierType || modifierType instanceof PokemonPpUpModifierType);
+          const partyUiMode = isMoveModifier ? PartyUiMode.MOVE_MODIFIER
+            : isTmModifier ? PartyUiMode.TM_MODIFIER
+              : isRememberMoveModifier ? PartyUiMode.REMEMBER_MOVE_MODIFIER
+                : PartyUiMode.MODIFIER;
+          const tmMoveId = isTmModifier
+            ? (modifierType as TmModifierType).moveId
+            : undefined;
+          this.scene.ui.setModeWithoutClear(Mode.PARTY, partyUiMode, -1, (slotIndex: integer, option: PartyOption) => {
+            if (slotIndex < 6) {
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer()).then(() => {
+                const modifier = !isMoveModifier
+                  ? !isRememberMoveModifier
+                    ? modifierType.newModifier(party[slotIndex])
+                    : modifierType.newModifier(party[slotIndex], option as integer)
+                  : modifierType.newModifier(party[slotIndex], option - PartyOption.MOVE_1);
+                applyModifier(modifier, true);
+              });
+            } else {
+              this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+            }
+          }, pokemonModifierType.selectFilter, modifierType instanceof PokemonMoveModifierType ? (modifierType as PokemonMoveModifierType).moveSelectFilter : undefined, tmMoveId, isPpRestoreModifier);
+        }
+      } else {
+        applyModifier(modifierType.newModifier());
+      }
+
+      return !cost;
+    };
+    this.scene.ui.setMode(Mode.MODIFIER_SELECT, this.isPlayer(), typeOptions, modifierSelectCallback, this.getRerollCost(typeOptions, this.scene.lockModifierTiers));
+  }
+
+  updateSeed(): void {
+    this.scene.resetSeed();
+  }
+
+  isPlayer(): boolean {
+    return true;
+  }
+
+  getRerollCost(typeOptions: ModifierTypeOption[], lockRarities: boolean): integer {
+    let baseValue = 0;
+    if (Overrides.WAIVE_REROLL_FEE_OVERRIDE) {
+      return baseValue;
+    } else if (lockRarities) {
+      const tierValues = [ 50, 125, 300, 750, 2000 ];
+      for (const opt of typeOptions) {
+        baseValue += tierValues[opt.type.tier];
+      }
+    } else {
+      baseValue = 250;
+    }
+    return Math.min(Math.ceil(this.scene.currentBattle.waveIndex / 10) * baseValue * Math.pow(2, this.rerollCount), Number.MAX_SAFE_INTEGER);
+  }
+
+  getPoolType(): ModifierPoolType {
+    return ModifierPoolType.PLAYER;
+  }
+
+  getModifierTypeOptions(modifierCount: integer): ModifierTypeOption[] {
+    return getPlayerModifierTypeOptions(modifierCount, this.scene.getParty(), this.scene.lockModifierTiers ? this.modifierTiers : undefined);
+  }
+
+  addModifier(modifier: Modifier): Promise<boolean> {
+    return this.scene.addModifier(modifier, false, true);
+  }
+}
+
 export class EggLapsePhase extends Phase {
   constructor(scene: BattleScene) {
     super(scene);

diff --git a/src/ui/modifier-select-ui-handler.ts b/src/ui/modifier-select-ui-handler.ts
@@ -10,6 +10,7 @@ import {Button} from "#enums/buttons";
 import MoveInfoOverlay from "./move-info-overlay";
 import { allMoves } from "../data/move";
 import * as Utils from "./../utils";
+import * as Overrides from "#app/overrides";
 import i18next from "i18next";
 
 export const SHOP_OPTIONS_ROW_LIMIT = 6;
@@ -764,9 +765,10 @@ class ModifierOption extends Phaser.GameObjects.Container {
 
   updateCostText(): void {
     const scene = this.scene as BattleScene;
-    const textStyle = this.modifierTypeOption.cost <= scene.money ? TextStyle.MONEY : TextStyle.PARTY_RED;
+    const cost = Overrides.WAIVE_SHOP_FEES_OVERRIDE ? 0 : this.modifierTypeOption.cost;
+    const textStyle = cost <= scene.money ? TextStyle.MONEY : TextStyle.PARTY_RED;
 
-    const formattedMoney = Utils.formatMoney(scene.moneyFormat, this.modifierTypeOption.cost);
+    const formattedMoney = Utils.formatMoney(scene.moneyFormat, cost);
 
     this.itemCostText.setText(i18next.t("modifierSelectUiHandler:itemCost", { formattedMoney }));
     this.itemCostText.setColor(getTextColor(textStyle, false, scene.uiTheme));