src/battle.ts
Rama beta · réplica de lectura del repositorio original.
import { DAILY_BOSS_LEVEL } from "#app/constants";
import type { GameMode } from "#app/game-mode";
import { globalScene } from "#app/global-scene";
import { settings } from "#app/global-settings-manager";
import { isDailyFinalBoss } from "#data/daily-seed-utils";
import { ArenaTagType } from "#enums/arena-tag-type";
import { BattleType } from "#enums/battle-type";
import { BattlerIndex } from "#enums/battler-index";
import { BiomeId } from "#enums/biome-id";
import type { Command } from "#enums/command";
import { MoveId } from "#enums/move-id";
import { MysteryEncounterMode } from "#enums/mystery-encounter-mode";
import type { MysteryEncounterType } from "#enums/mystery-encounter-type";
import type { PokeballType } from "#enums/pokeball";
import { SpeciesFormKey } from "#enums/species-form-key";
import { SpeciesId } from "#enums/species-id";
import { TrainerType } from "#enums/trainer-type";
import { TrainerVariant } from "#enums/trainer-variant";
import type { EnemyPokemon, PlayerPokemon, Pokemon } from "#field/pokemon";
import { Trainer } from "#field/trainer";
import { MoneyMultiplierModifier, type PokemonHeldItemModifier } from "#modifiers/modifier";
import type { CustomModifierSettings } from "#modifiers/modifier-type";
import type { MysteryEncounter } from "#mystery-encounters/mystery-encounter";
import { trainerConfigs } from "#trainers/trainer-config";
import type { NewBattleResolvedProps } from "#types/new-battle-props";
import type { TurnMove } from "#types/turn-move";
import {
isBetween,
NumberHolder,
randInt,
randomString,
randSeedFloat,
randSeedInt,
randSeedItem,
shiftCharCodes,
} from "#utils/common";
import { getEnumValues } from "#utils/enums";
import { randSeedUniqueItem } from "#utils/random";
import i18next from "i18next";
import Phaser from "phaser";
export interface TurnCommand {
command: Command;
cursor?: number | undefined;
move?: TurnMove;
targets?: BattlerIndex[];
skip?: boolean;
args?: any[];
}
export interface FaintLogEntry {
pokemon: Pokemon;
turn: number;
}
interface TurnCommands {
[key: number]: TurnCommand | null;
}
export class Battle {
protected gameMode: GameMode;
public waveIndex: number;
public battleType: BattleType;
public trainer: Trainer | null;
public enemyLevels: number[] | undefined;
public enemyParty: EnemyPokemon[] = [];
public seenEnemyPartyMemberIds: Set<number> = new Set<number>();
public double: boolean;
public started = false;
public enemySwitchCounter = 0;
public turn = 0;
public preTurnCommands: TurnCommands;
public turnCommands: TurnCommands;
public playerParticipantIds: Set<number> = new Set<number>();
public battleScore = 0;
public postBattleLoot: PokemonHeldItemModifier[] = [];
public escapeAttempts = 0;
/**
* A tracker of the last {@linkcode MoveId} successfully used this battle.
*/
public lastMove: MoveId = MoveId.NONE;
public battleSeed: string = randomString(16, true);
private battleSeedState: string | null = null;
public moneyScattered = 0;
// TODO: These trackers are only used for Sticky Web + Mirror Armor edge cases
// and are abhorrently janky.
/** Primarily for double battles, keeps track of last enemy and player pokemon that triggered its ability or used a move */
public lastEnemyInvolved: number;
public lastPlayerInvolved: number;
public lastUsedPokeball: PokeballType | null = null;
/**
* Saves the number of times a Pokemon on the enemy's side has fainted during this battle.
* This is saved here since we encounter a new enemy every wave.
* {@linkcode globalScene.arena.playerFaints} is the corresponding faint counter for the player and needs to be save across waves (reset every arena encounter).
*/
public enemyFaints = 0;
public playerFaintsHistory: FaintLogEntry[] = [];
public enemyFaintsHistory: FaintLogEntry[] = [];
public mysteryEncounterType?: MysteryEncounterType | undefined;
/** If the current battle is a Mystery Encounter, this will always be defined */
public mysteryEncounter?: MysteryEncounter | undefined;
/**
* Tracker for whether the last run attempt failed.
* @defaultValue `false`
*/
public failedRunAway = false;
public successfulRun = false;
constructor(
gameMode: GameMode,
{ waveIndex, battleType, trainer, mysteryEncounterType, double = false }: NewBattleResolvedProps,
) {
this.gameMode = gameMode;
this.waveIndex = waveIndex;
this.battleType = battleType;
this.trainer = trainer ?? null;
this.mysteryEncounterType = mysteryEncounterType;
this.double = double;
this.enemyLevels =
battleType === BattleType.TRAINER
? trainer?.getPartyLevels(this.waveIndex)
: // TODO: Remove array.fill.map
new Array(double ? 2 : 1).fill(null).map(() => this.getLevelForWave());
}
public get isClassicFinalBoss(): boolean {
return this.gameMode.isClassic && this.gameMode.isWaveFinal(this.waveIndex);
}
public getLevelForWave(): number {
if (isDailyFinalBoss(this.waveIndex)) {
return DAILY_BOSS_LEVEL;
}
const levelWaveIndex = this.gameMode.getWaveForDifficulty(this.waveIndex);
const baseLevel = 1 + levelWaveIndex / 2 + Math.pow(levelWaveIndex / 25, 2);
const bossMultiplier = 1.2;
if (this.gameMode.isBoss(this.waveIndex)) {
const ret = Math.floor(baseLevel * bossMultiplier);
if (this.isClassicFinalBoss || !(this.waveIndex % 250)) {
return Math.ceil(ret / 25) * 25;
}
let levelOffset = 0;
if (!this.gameMode.isWaveFinal(this.waveIndex)) {
levelOffset = Math.round(Phaser.Math.RND.realInRange(-1, 1) * Math.floor(levelWaveIndex / 10));
}
return ret + levelOffset;
}
let levelOffset = 0;
const deviation = 10 / levelWaveIndex;
levelOffset = Math.abs(this.randSeedGaussForLevel(deviation));
return Math.max(Math.round(baseLevel + levelOffset), 1);
}
randSeedGaussForLevel(value: number): number {
let rand = 0;
for (let i = value; i > 0; i--) {
rand += randSeedFloat();
}
return rand / value;
}
getBattlerCount(): number {
return this.double ? 2 : 1;
}
incrementTurn(): void {
this.turn++;
this.turnCommands = Object.fromEntries(getEnumValues(BattlerIndex).map(bt => [bt, null]));
this.preTurnCommands = Object.fromEntries(getEnumValues(BattlerIndex).map(bt => [bt, null]));
this.battleSeedState = null;
}
addParticipant(playerPokemon: PlayerPokemon): void {
this.playerParticipantIds.add(playerPokemon.id);
}
removeFaintedParticipant(playerPokemon: PlayerPokemon): void {
this.playerParticipantIds.delete(playerPokemon.id);
}
addPostBattleLoot(enemyPokemon: EnemyPokemon): void {
this.postBattleLoot.push(
...(globalScene.findModifiers(
m => m.is("PokemonHeldItemModifier") && m.pokemonId === enemyPokemon.id && m.isTransferable,
false,
) as PokemonHeldItemModifier[]),
);
}
pickUpScatteredMoney(): void {
const moneyAmount = new NumberHolder(globalScene.currentBattle.moneyScattered);
globalScene.applyModifiers(MoneyMultiplierModifier, true, moneyAmount);
if (globalScene.arena.getTag(ArenaTagType.HAPPY_HOUR)) {
moneyAmount.value *= 2;
}
globalScene.addMoney(moneyAmount.value);
const userLocale = navigator.language || "en-US";
const formattedMoneyAmount = moneyAmount.value.toLocaleString(userLocale);
const message = i18next.t("battle:moneyPickedUp", {
moneyAmount: formattedMoneyAmount,
});
globalScene.phaseManager.queueMessage(message, undefined, true);
globalScene.currentBattle.moneyScattered = 0;
}
addBattleScore(): void {
let partyMemberTurnMultiplier = globalScene.getEnemyParty().length / 2 + 0.5;
if (this.double) {
partyMemberTurnMultiplier /= 1.5;
}
for (const p of globalScene.getEnemyParty()) {
if (p.isBoss()) {
partyMemberTurnMultiplier *= p.bossSegments / 1.5 / globalScene.getEnemyParty().length;
}
}
const turnMultiplier = Phaser.Tweens.Builders.GetEaseFunction("Sine.easeIn")(
1 - Math.min(this.turn - 2, 10 * partyMemberTurnMultiplier) / (10 * partyMemberTurnMultiplier),
);
const finalBattleScore = Math.ceil(this.battleScore * turnMultiplier);
globalScene.score += finalBattleScore;
console.log(
`Battle Score: ${finalBattleScore} (${this.turn - 1} Turns x${Math.floor(turnMultiplier * 100) / 100})`,
);
console.log(`Total Score: ${globalScene.score}`);
globalScene.updateScoreText();
}
getBgmOverride(): string | null {
if (this.isBattleMysteryEncounter() && this.mysteryEncounter?.encounterMode === MysteryEncounterMode.DEFAULT) {
// Music is overridden for MEs during ME onInit()
// Should not use any BGM overrides before swapping from DEFAULT mode
return null;
}
if (
this.battleType === BattleType.TRAINER
|| this.mysteryEncounter?.encounterMode === MysteryEncounterMode.TRAINER_BATTLE
) {
if (!this.started && this.trainer?.config.encounterBgm && this.trainer.getEncounterMessages().length > 0) {
return `encounter_${this.trainer.getEncounterBgm()}`;
}
if (!settings.musicPreferenceAllGens) {
return this.trainer?.getBattleBgm() ?? null;
}
return this.trainer?.getMixedBattleBgm() ?? null;
}
if (this.gameMode.isClassic) {
if (isBetween(this.waveIndex, 191, 194)) {
return "end";
}
if (isBetween(this.waveIndex, 196, 199)) {
return "end_summit";
}
}
const wildOpponents = globalScene.getEnemyParty();
for (const pokemon of wildOpponents) {
if (this.isClassicFinalBoss) {
if (pokemon.species.getFormSpriteKey(pokemon.formIndex) === SpeciesFormKey.ETERNAMAX) {
return "battle_final";
}
return "battle_final_encounter";
}
if (
pokemon.species.legendary
|| pokemon.species.subLegendary
|| pokemon.species.mythical
|| (pokemon.species.category.startsWith("Paradox") && globalScene.arena.biomeId !== BiomeId.END)
) {
if (!settings.musicPreferenceAllGens) {
switch (pokemon.species.speciesId) {
case SpeciesId.ARTICUNO:
case SpeciesId.ZAPDOS:
case SpeciesId.MOLTRES:
case SpeciesId.MEWTWO:
case SpeciesId.MEW:
return "battle_legendary_mew";
case SpeciesId.REGIROCK:
case SpeciesId.REGICE:
case SpeciesId.REGISTEEL:
case SpeciesId.REGIGIGAS:
case SpeciesId.REGIDRAGO:
case SpeciesId.REGIELEKI:
return "battle_legendary_regis_g5";
case SpeciesId.KYUREM:
return "battle_legendary_kyurem";
default:
if (pokemon.species.legendary) {
return "battle_legendary_res_zek";
}
return "battle_legendary_unova";
}
}
if (settings.musicPreferenceAllGens) {
switch (pokemon.species.speciesId) {
case SpeciesId.ARTICUNO:
case SpeciesId.ZAPDOS:
case SpeciesId.MOLTRES:
case SpeciesId.MEWTWO:
case SpeciesId.MEW:
return "battle_legendary_kanto";
case SpeciesId.RAIKOU:
return "battle_legendary_raikou";
case SpeciesId.ENTEI:
return "battle_legendary_entei";
case SpeciesId.SUICUNE:
return "battle_legendary_suicune";
case SpeciesId.LUGIA:
return "battle_legendary_lugia";
case SpeciesId.HO_OH:
return "battle_legendary_ho_oh";
case SpeciesId.REGIROCK:
case SpeciesId.REGICE:
case SpeciesId.REGISTEEL:
case SpeciesId.REGIGIGAS:
case SpeciesId.REGIDRAGO:
case SpeciesId.REGIELEKI:
return "battle_legendary_regis_g6";
case SpeciesId.GROUDON:
case SpeciesId.KYOGRE:
if (pokemon.getFormKey() === SpeciesFormKey.PRIMAL) {
return "battle_legendary_gro_kyo";
}
return "battle_legendary_rayquaza";
case SpeciesId.RAYQUAZA:
return "battle_legendary_rayquaza";
case SpeciesId.DEOXYS:
return "battle_legendary_deoxys";
case SpeciesId.UXIE:
case SpeciesId.MESPRIT:
case SpeciesId.AZELF:
return "battle_legendary_lake_trio";
case SpeciesId.HEATRAN:
case SpeciesId.CRESSELIA:
case SpeciesId.DARKRAI:
case SpeciesId.SHAYMIN:
return "battle_legendary_sinnoh";
case SpeciesId.DIALGA:
case SpeciesId.PALKIA:
if (pokemon.getFormKey() === SpeciesFormKey.ORIGIN) {
return "battle_legendary_origin_forme";
}
return "battle_legendary_dia_pal";
case SpeciesId.GIRATINA:
return "battle_legendary_giratina";
case SpeciesId.ARCEUS:
return "battle_legendary_arceus";
case SpeciesId.COBALION:
case SpeciesId.TERRAKION:
case SpeciesId.VIRIZION:
case SpeciesId.KELDEO:
case SpeciesId.TORNADUS:
case SpeciesId.LANDORUS:
case SpeciesId.THUNDURUS:
case SpeciesId.MELOETTA:
case SpeciesId.GENESECT:
return "battle_legendary_unova";
case SpeciesId.KYUREM:
return "battle_legendary_kyurem";
case SpeciesId.XERNEAS:
case SpeciesId.YVELTAL:
case SpeciesId.ZYGARDE:
return "battle_legendary_xern_yvel";
case SpeciesId.TAPU_KOKO:
case SpeciesId.TAPU_LELE:
case SpeciesId.TAPU_BULU:
case SpeciesId.TAPU_FINI:
return "battle_legendary_tapu";
case SpeciesId.COSMOG:
case SpeciesId.COSMOEM:
case SpeciesId.SOLGALEO:
case SpeciesId.LUNALA:
return "battle_legendary_sol_lun";
case SpeciesId.NECROZMA:
switch (pokemon.getFormKey()) {
case "dusk-mane":
case "dawn-wings":
return "battle_legendary_dusk_dawn";
case "ultra":
return "battle_legendary_ultra_nec";
default:
return "battle_legendary_sol_lun";
}
case SpeciesId.NIHILEGO:
case SpeciesId.PHEROMOSA:
case SpeciesId.BUZZWOLE:
case SpeciesId.XURKITREE:
case SpeciesId.CELESTEELA:
case SpeciesId.KARTANA:
case SpeciesId.GUZZLORD:
case SpeciesId.POIPOLE:
case SpeciesId.NAGANADEL:
case SpeciesId.STAKATAKA:
case SpeciesId.BLACEPHALON:
return "battle_legendary_ub";
case SpeciesId.ZACIAN:
case SpeciesId.ZAMAZENTA:
return "battle_legendary_zac_zam";
case SpeciesId.ETERNATUS:
if (pokemon.getFormKey() === "eternamax") {
return "battle_legendary_eternatus_p2";
}
return "battle_legendary_eternatus_p1";
case SpeciesId.GLASTRIER:
case SpeciesId.SPECTRIER:
return "battle_legendary_glas_spec";
case SpeciesId.CALYREX:
if (pokemon.getFormKey() === "ice" || pokemon.getFormKey() === "shadow") {
return "battle_legendary_riders";
}
return "battle_legendary_calyrex";
case SpeciesId.GALAR_ARTICUNO:
case SpeciesId.GALAR_ZAPDOS:
case SpeciesId.GALAR_MOLTRES:
return "battle_legendary_birds_galar";
case SpeciesId.WO_CHIEN:
case SpeciesId.CHIEN_PAO:
case SpeciesId.TING_LU:
case SpeciesId.CHI_YU:
return "battle_legendary_ruinous";
case SpeciesId.GREAT_TUSK:
case SpeciesId.SCREAM_TAIL:
case SpeciesId.BRUTE_BONNET:
case SpeciesId.FLUTTER_MANE:
case SpeciesId.SLITHER_WING:
case SpeciesId.SANDY_SHOCKS:
case SpeciesId.IRON_TREADS:
case SpeciesId.IRON_BUNDLE:
case SpeciesId.IRON_HANDS:
case SpeciesId.IRON_JUGULIS:
case SpeciesId.IRON_MOTH:
case SpeciesId.IRON_THORNS:
case SpeciesId.ROARING_MOON:
case SpeciesId.IRON_VALIANT:
case SpeciesId.WALKING_WAKE:
case SpeciesId.IRON_LEAVES:
case SpeciesId.GOUGING_FIRE:
case SpeciesId.RAGING_BOLT:
case SpeciesId.IRON_BOULDER:
case SpeciesId.IRON_CROWN:
case SpeciesId.KORAIDON:
case SpeciesId.MIRAIDON:
return "battle_legendary_kor_mir";
case SpeciesId.OKIDOGI:
case SpeciesId.MUNKIDORI:
case SpeciesId.FEZANDIPITI:
return "battle_legendary_loyal_three";
case SpeciesId.OGERPON:
return "battle_legendary_ogerpon";
case SpeciesId.TERAPAGOS:
return "battle_legendary_terapagos";
case SpeciesId.PECHARUNT:
return "battle_legendary_pecharunt";
default:
if (pokemon.species.legendary) {
return "battle_legendary_res_zek";
}
return "battle_legendary_unova";
}
}
}
}
if (globalScene.gameMode.isClassic && this.waveIndex <= 4) {
return "battle_wild";
}
return null;
}
/**
* Generates a random number using the current battle's seed. Calls {@linkcode randSeedInt}
* @param range How large of a range of random numbers to choose from. If {@linkcode range} <= 1, returns {@linkcode min}
* @param min The minimum integer to pick, default `0`
* @returns A random integer between {@linkcode min} and ({@linkcode min} + {@linkcode range} - 1)
*/
randSeedInt(range: number, min = 0): number {
if (range <= 1) {
return min;
}
const tempSeedOverride = globalScene.rngSeedOverride;
const state = Phaser.Math.RND.state();
if (this.battleSeedState) {
Phaser.Math.RND.state(this.battleSeedState);
} else {
Phaser.Math.RND.sow([shiftCharCodes(this.battleSeed, this.turn << 6)]);
console.log("Battle Seed:", this.battleSeed);
}
globalScene.rngSeedOverride = this.battleSeed;
const ret = randSeedInt(range, min);
this.battleSeedState = Phaser.Math.RND.state();
Phaser.Math.RND.state(state);
globalScene.rngSeedOverride = tempSeedOverride;
return ret;
}
/**
* Returns if the battle is of type {@linkcode BattleType.MYSTERY_ENCOUNTER}
*/
isBattleMysteryEncounter(): boolean {
return this.battleType === BattleType.MYSTERY_ENCOUNTER;
}
}
export class FixedBattle extends Battle {
constructor(waveIndex: number, config: FixedBattleConfig) {
super(globalScene.gameMode, {
waveIndex,
battleType: config.battleType,
trainer: config.battleType === BattleType.TRAINER ? config.getTrainer() : undefined,
double: config.double,
});
if (config.getEnemyParty) {
this.enemyParty = config.getEnemyParty();
}
}
}
type GetTrainerFunc = () => Trainer;
type GetEnemyPartyFunc = () => EnemyPokemon[];
export class FixedBattleConfig {
// TODO: All fixed battles are currently trainer battles
public battleType: Exclude<BattleType, BattleType.CLEAR>;
public double: boolean;
public getTrainer: GetTrainerFunc;
public getEnemyParty: GetEnemyPartyFunc;
public seedOffsetWaveIndex: number;
public customModifierRewardSettings?: CustomModifierSettings;
setBattleType(battleType: Exclude<BattleType, BattleType.CLEAR>): FixedBattleConfig {
this.battleType = battleType;
return this;
}
setDouble(double: boolean): FixedBattleConfig {
this.double = double;
return this;
}
setGetTrainerFunc(getTrainerFunc: GetTrainerFunc): FixedBattleConfig {
this.getTrainer = getTrainerFunc;
return this;
}
setGetEnemyPartyFunc(getEnemyPartyFunc: GetEnemyPartyFunc): FixedBattleConfig {
this.getEnemyParty = getEnemyPartyFunc;
return this;
}
setSeedOffsetWave(seedOffsetWaveIndex: number): FixedBattleConfig {
this.seedOffsetWaveIndex = seedOffsetWaveIndex;
return this;
}
setCustomModifierRewards(customModifierRewardSettings: CustomModifierSettings) {
this.customModifierRewardSettings = customModifierRewardSettings;
return this;
}
}
/**
* Helper function to generate a random trainer for evil team trainers and the elite 4/champion
* @param trainerPool - The TrainerType or list of TrainerTypes that can possibly be generated
* @param randomGender - (default `false`); Whether or not to randomly (50%) generate a female trainer (for use with evil team grunts)
* @param seedOffset - (default `0`); A seed offset indicating the invocation count of the function to attempt to choose a random, but unique, trainer from the pool
* @returns A function to generate a random trainer
*/
export function getRandomTrainerFunc(
trainerPool: readonly (TrainerType | readonly TrainerType[])[],
randomGender = false,
seedOffset = 0,
): GetTrainerFunc {
return () => {
/** The chosen entry in the pool */
let choice = randSeedItem(trainerPool);
if (typeof choice !== "number") {
choice = seedOffset === 0 ? randSeedItem(choice) : randSeedUniqueItem(choice, seedOffset);
}
let trainerGender = TrainerVariant.DEFAULT;
if (randomGender) {
trainerGender = randInt(2) === 0 ? TrainerVariant.FEMALE : TrainerVariant.DEFAULT;
}
/* 1/3 chance for evil team grunts to be double battles */
const evilTeamGrunts = [
TrainerType.ROCKET_GRUNT,
TrainerType.MAGMA_GRUNT,
TrainerType.AQUA_GRUNT,
TrainerType.GALACTIC_GRUNT,
TrainerType.PLASMA_GRUNT,
TrainerType.FLARE_GRUNT,
TrainerType.AETHER_GRUNT,
TrainerType.SKULL_GRUNT,
TrainerType.MACRO_GRUNT,
TrainerType.STAR_GRUNT,
];
const isEvilTeamGrunt = evilTeamGrunts.includes(choice);
if (trainerConfigs[choice].hasDouble && isEvilTeamGrunt) {
return new Trainer(choice, randInt(3) === 0 ? TrainerVariant.DOUBLE : trainerGender);
}
return new Trainer(choice, trainerGender);
};
}