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

import { MysteryEncounterOptionBuilder } from "#app/data/mystery-encounters/mystery-encounter-option";
import type {
  EnemyPartyConfig } from "#app/data/mystery-encounters/utils/encounter-phase-utils";
import {
  generateModifierType,
  generateModifierTypeOption,
  initBattleWithEnemyConfig,
  leaveEncounterWithoutBattle,
  setEncounterExp,
  setEncounterRewards
} from "#app/data/mystery-encounters/utils/encounter-phase-utils";
import type { PlayerPokemon } from "#app/field/pokemon";
import type Pokemon from "#app/field/pokemon";
import { EnemyPokemon } from "#app/field/pokemon";
import type {
  BerryModifierType,
  ModifierTypeOption } from "#app/modifier/modifier-type";
import {
  getPartyLuckValue,
  ModifierPoolType,
  modifierTypes,
  regenerateModifierPoolThresholds,
} from "#app/modifier/modifier-type";
import { randSeedInt, randSeedItem } from "#app/utils";
import { BattlerTagType } from "#enums/battler-tag-type";
import { MysteryEncounterType } from "#enums/mystery-encounter-type";
import { globalScene } from "#app/global-scene";
import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
import { queueEncounterMessage, showEncounterText } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
import { getPokemonNameWithAffix } from "#app/messages";
import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
import { TrainerSlot } from "#app/data/trainer-config";
import { applyModifierTypeToPlayerPokemon, getEncounterPokemonLevelForWave, getHighestStatPlayerPokemon, getSpriteKeysFromPokemon, STANDARD_ENCOUNTER_BOOSTED_LEVEL_MODIFIER } from "#app/data/mystery-encounters/utils/encounter-pokemon-utils";
import PokemonData from "#app/system/pokemon-data";
import { BerryModifier } from "#app/modifier/modifier";
import i18next from "#app/plugins/i18n";
import { BerryType } from "#enums/berry-type";
import { PERMANENT_STATS, Stat } from "#enums/stat";
import { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
import { CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES } from "#app/game-mode";
import type PokemonSpecies from "#app/data/pokemon-species";
import { getPokemonSpecies } from "#app/data/pokemon-species";

/** the i18n namespace for the encounter */
const namespace = "mysteryEncounters/berriesAbound";

/**
 * Berries Abound encounter.
 * @see {@link https://github.com/pagefaultgames/pokerogue/issues/3810 | GitHub Issue #3810}
 * @see For biome requirements check {@linkcode mysteryEncountersByBiome}
 */
export const BerriesAboundEncounter: MysteryEncounter =
  MysteryEncounterBuilder.withEncounterType(MysteryEncounterType.BERRIES_ABOUND)
    .withEncounterTier(MysteryEncounterTier.COMMON)
    .withSceneWaveRangeRequirement(...CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES)
    .withCatchAllowed(true)
    .withHideWildIntroMessage(true)
    .withFleeAllowed(false)
    .withIntroSpriteConfigs([]) // Set in onInit()
    .withIntroDialogue([
      {
        text: `${namespace}:intro`,
      },
    ])
    .withOnInit(() => {
      const encounter = globalScene.currentBattle.mysteryEncounter!;

      // Calculate boss mon
      const level = getEncounterPokemonLevelForWave(STANDARD_ENCOUNTER_BOOSTED_LEVEL_MODIFIER);
      let bossSpecies: PokemonSpecies;
      if (globalScene.eventManager.isEventActive() && globalScene.eventManager.activeEvent()?.uncommonBreedEncounters && randSeedInt(2) === 1) {
        const eventEncounter = randSeedItem(globalScene.eventManager.activeEvent()!.uncommonBreedEncounters!);
        const levelSpecies = getPokemonSpecies(eventEncounter.species).getWildSpeciesForLevel(level, eventEncounter.allowEvolution ?? false, true, globalScene.gameMode);
        bossSpecies = getPokemonSpecies( levelSpecies );
      } else {
        bossSpecies = globalScene.arena.randomSpecies(globalScene.currentBattle.waveIndex, level, 0, getPartyLuckValue(globalScene.getPlayerParty()), true);
      }
      const bossPokemon = new EnemyPokemon(bossSpecies, level, TrainerSlot.NONE, true);
      encounter.setDialogueToken("enemyPokemon", getPokemonNameWithAffix(bossPokemon));
      const config: EnemyPartyConfig = {
        pokemonConfigs: [{
          level: level,
          species: bossSpecies,
          dataSource: new PokemonData(bossPokemon),
          isBoss: true
        }],
      };
      encounter.enemyPartyConfigs = [ config ];

      // Calculate the number of extra berries that player receives
      // 10-40: 2, 40-120: 4, 120-160: 5, 160-180: 7
      const numBerries =
        globalScene.currentBattle.waveIndex > 160 ? 7
          : globalScene.currentBattle.waveIndex > 120 ? 5
            : globalScene.currentBattle.waveIndex > 40 ? 4 : 2;
      regenerateModifierPoolThresholds(globalScene.getPlayerParty(), ModifierPoolType.PLAYER, 0);
      encounter.misc = { numBerries };

      const { spriteKey, fileRoot } = getSpriteKeysFromPokemon(bossPokemon);
      encounter.spriteConfigs = [
        {
          spriteKey: "berries_abound_bush",
          fileRoot: "mystery-encounters",
          x: 25,
          y: -6,
          yShadow: -7,
          disableAnimation: true,
          hasShadow: true
        },
        {
          spriteKey: spriteKey,
          fileRoot: fileRoot,
          hasShadow: true,
          tint: 0.25,
          x: -5,
          repeat: true,
          isPokemon: true,
          isShiny: bossPokemon.shiny,
          variant: bossPokemon.variant
        }
      ];

      // Get fastest party pokemon for option 2
      const fastestPokemon = getHighestStatPlayerPokemon(PERMANENT_STATS[Stat.SPD], true, false);
      encounter.misc.fastestPokemon = fastestPokemon;
      encounter.misc.enemySpeed = bossPokemon.getStat(Stat.SPD);
      encounter.setDialogueToken("fastestPokemon", fastestPokemon.getNameToRender());

      return true;
    })
    .setLocalizationKey(`${namespace}`)
    .withTitle(`${namespace}:title`)
    .withDescription(`${namespace}:description`)
    .withQuery(`${namespace}:query`)
    .withSimpleOption(
      {
        buttonLabel: `${namespace}:option.1.label`,
        buttonTooltip: `${namespace}:option.1.tooltip`,
        selected: [
          {
            text: `${namespace}:option.1.selected`,
          },
        ],
      },
      async () => {
        // Pick battle
        const encounter = globalScene.currentBattle.mysteryEncounter!;
        const numBerries = encounter.misc.numBerries;

        const doBerryRewards = () => {
          const berryText = i18next.t(`${namespace}:berries`);

          globalScene.playSound("item_fanfare");
          queueEncounterMessage(i18next.t("battle:rewardGainCount", { modifierName: berryText, count: numBerries }));

          // Generate a random berry and give it to the first Pokemon with room for it
          for (let i = 0; i < numBerries; i++) {
            tryGiveBerry();
          }
        };

        const shopOptions: ModifierTypeOption[] = [];
        for (let i = 0; i < 5; i++) {
          // Generate shop berries
          const mod = generateModifierTypeOption(modifierTypes.BERRY);
          if (mod) {
            shopOptions.push(mod);
          }
        }

        setEncounterRewards({ guaranteedModifierTypeOptions: shopOptions, fillRemaining: false }, undefined, doBerryRewards);
        await initBattleWithEnemyConfig(globalScene.currentBattle.mysteryEncounter!.enemyPartyConfigs[0]);
      }
    )
    .withOption(
      MysteryEncounterOptionBuilder
        .newOptionWithMode(MysteryEncounterOptionMode.DEFAULT)
        .withDialogue({
          buttonLabel: `${namespace}:option.2.label`,
          buttonTooltip: `${namespace}:option.2.tooltip`
        })
        .withOptionPhase(async () => {
          // Pick race for berries
          const encounter = globalScene.currentBattle.mysteryEncounter!;
          const fastestPokemon: PlayerPokemon = encounter.misc.fastestPokemon;
          const enemySpeed: number = encounter.misc.enemySpeed;
          const speedDiff = fastestPokemon.getStat(Stat.SPD) / (enemySpeed * 1.1);
          const numBerries: number = encounter.misc.numBerries;

          const shopOptions: ModifierTypeOption[] = [];
          for (let i = 0; i < 5; i++) {
            // Generate shop berries
            const mod = generateModifierTypeOption(modifierTypes.BERRY);
            if (mod) {
              shopOptions.push(mod);
            }
          }

          if (speedDiff < 1) {
            // Caught and attacked by boss, gets +1 to all stats at start of fight
            const doBerryRewards = () => {
              const berryText = i18next.t(`${namespace}:berries`);

              globalScene.playSound("item_fanfare");
              queueEncounterMessage(i18next.t("battle:rewardGainCount", { modifierName: berryText, count: numBerries }));

              // Generate a random berry and give it to the first Pokemon with room for it
              for (let i = 0; i < numBerries; i++) {
                tryGiveBerry();
              }
            };

            // Defense/Spd buffs below wave 50, +1 to all stats otherwise
            const statChangesForBattle: (Stat.ATK | Stat.DEF | Stat.SPATK | Stat.SPDEF | Stat.SPD | Stat.ACC | Stat.EVA)[] = globalScene.currentBattle.waveIndex < 50 ?
              [ Stat.DEF, Stat.SPDEF, Stat.SPD ] :
              [ Stat.ATK, Stat.DEF, Stat.SPATK, Stat.SPDEF, Stat.SPD ];

            const config = globalScene.currentBattle.mysteryEncounter!.enemyPartyConfigs[0];
            config.pokemonConfigs![0].tags = [ BattlerTagType.MYSTERY_ENCOUNTER_POST_SUMMON ];
            config.pokemonConfigs![0].mysteryEncounterBattleEffects = (pokemon: Pokemon) => {
              queueEncounterMessage(`${namespace}:option.2.boss_enraged`);
              globalScene.unshiftPhase(new StatStageChangePhase(pokemon.getBattlerIndex(), true, statChangesForBattle, 1));
            };
            setEncounterRewards({ guaranteedModifierTypeOptions: shopOptions, fillRemaining: false }, undefined, doBerryRewards);
            await showEncounterText(`${namespace}:option.2.selected_bad`);
            await initBattleWithEnemyConfig(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 2
            const numBerriesGrabbed = Math.max(Math.min(Math.round((speedDiff - 1) / 0.08), numBerries), 2);
            encounter.setDialogueToken("numBerries", String(numBerriesGrabbed));
            const doFasterBerryRewards = () => {
              const berryText = i18next.t(`${namespace}:berries`);

              globalScene.playSound("item_fanfare");
              queueEncounterMessage(i18next.t("battle:rewardGainCount", { modifierName: berryText, count: numBerriesGrabbed }));

              // Generate a random berry and give it to the first Pokemon with room for it (trying to give to fastest first)
              for (let i = 0; i < numBerriesGrabbed; i++) {
                tryGiveBerry(fastestPokemon);
              }
            };

            setEncounterExp(fastestPokemon.id, encounter.enemyPartyConfigs[0].pokemonConfigs![0].species.baseExp);
            setEncounterRewards({ guaranteedModifierTypeOptions: shopOptions, fillRemaining: false }, undefined, doFasterBerryRewards);
            await showEncounterText(`${namespace}:option.2.selected`);
            leaveEncounterWithoutBattle();
          }
        })
        .build()
    )
    .withSimpleOption(
      {
        buttonLabel: `${namespace}:option.3.label`,
        buttonTooltip: `${namespace}:option.3.tooltip`,
        selected: [
          {
            text: `${namespace}:option.3.selected`,
          },
        ],
      },
      async () => {
        // Leave encounter with no rewards or exp
        leaveEncounterWithoutBattle(true);
        return true;
      }
    )
    .build();

function tryGiveBerry(prioritizedPokemon?: PlayerPokemon) {
  const berryType = randSeedInt(Object.keys(BerryType).filter(s => !isNaN(Number(s))).length) as BerryType;
  const berry = generateModifierType(modifierTypes.BERRY, [ berryType ]) as BerryModifierType;

  const party = globalScene.getPlayerParty();

  // Will try to apply to prioritized pokemon first, then do normal application method if it fails
  if (prioritizedPokemon) {
    const heldBerriesOfType = globalScene.findModifier(m => m instanceof BerryModifier
      && m.pokemonId === prioritizedPokemon.id && (m as BerryModifier).berryType === berryType, true) as BerryModifier;

    if (!heldBerriesOfType || heldBerriesOfType.getStackCount() < heldBerriesOfType.getMaxStackCount()) {
      applyModifierTypeToPlayerPokemon(prioritizedPokemon, berry);
      return;
    }
  }

  // Iterate over the party until berry was successfully given
  for (const pokemon of party) {
    const heldBerriesOfType = globalScene.findModifier(m => m instanceof BerryModifier
      && m.pokemonId === pokemon.id && (m as BerryModifier).berryType === berryType, true) as BerryModifier;

    if (!heldBerriesOfType || heldBerriesOfType.getStackCount() < heldBerriesOfType.getMaxStackCount()) {
      applyModifierTypeToPlayerPokemon(pokemon, berry);
      return;
    }
  }
}