pokerogue/src/arena.ts

471 lines
14 KiB
TypeScript
Raw Normal View History

2023-04-17 01:41:52 +01:00
import BattleScene from "./battle-scene";
import { Biome, BiomePoolTier, BiomeTierPokemonPools, BiomeTierTrainerPools, biomePokemonPools, biomeTrainerPools } from "./data/biome";
2023-04-17 01:41:52 +01:00
import * as Utils from "./utils";
2023-04-20 20:46:05 +01:00
import PokemonSpecies, { getPokemonSpecies } from "./data/pokemon-species";
import { Species } from "./data/species";
import { Weather, WeatherType, getWeatherClearMessage, getWeatherStartMessage } from "./data/weather";
2023-04-23 03:14:53 +01:00
import { CommonAnimPhase } from "./battle-phases";
2023-04-20 20:46:05 +01:00
import { CommonAnim } from "./data/battle-anims";
import { Type } from "./data/type";
import Move, { Moves } from "./data/move";
2023-04-22 00:30:04 +01:00
import { ArenaTag, ArenaTagType, getArenaTag } from "./data/arena-tag";
import { GameMode } from "./game-mode";
import { TrainerType } from "./data/trainer-type";
2023-12-04 05:09:38 +00:00
import { BattlerIndex } from "./battle";
2023-04-17 01:41:52 +01:00
2023-11-25 09:21:27 +00:00
const WEATHER_OVERRIDE = WeatherType.NONE;
2023-04-17 01:41:52 +01:00
export class Arena {
2023-04-22 00:30:04 +01:00
public scene: BattleScene;
2023-04-17 01:41:52 +01:00
public biomeType: Biome;
public weather: Weather;
2023-04-22 00:30:04 +01:00
public tags: ArenaTag[];
public bgm: string;
2023-04-17 01:41:52 +01:00
private pokemonPool: BiomeTierPokemonPools;
private trainerPool: BiomeTierTrainerPools;
2023-04-17 01:41:52 +01:00
constructor(scene: BattleScene, biome: Biome, bgm: string) {
this.scene = scene;
this.biomeType = biome;
2023-04-22 00:30:04 +01:00
this.tags = [];
2023-04-17 01:41:52 +01:00
this.bgm = bgm;
this.pokemonPool = biomePokemonPools[biome];
this.trainerPool = biomeTrainerPools[biome];
2023-04-17 01:41:52 +01:00
}
2023-04-20 06:04:36 +01:00
randomSpecies(waveIndex: integer, level: integer, attempt?: integer): PokemonSpecies {
const isBoss = (waveIndex % 10 === 0 || (this.scene.gameMode !== GameMode.CLASSIC && Utils.randSeedInt(100) < Math.min(Math.max(Math.ceil((waveIndex - 250) / 50), 0) * 2, 30))) && !!this.pokemonPool[BiomePoolTier.BOSS].length
&& (this.biomeType !== Biome.END || this.scene.gameMode === GameMode.CLASSIC || waveIndex % 250 === 0);
const tierValue = Utils.randSeedInt(!isBoss ? 512 : 64);
2023-04-17 01:41:52 +01:00
let tier = !isBoss
? tierValue >= 156 ? BiomePoolTier.COMMON : tierValue >= 32 ? BiomePoolTier.UNCOMMON : tierValue >= 6 ? BiomePoolTier.RARE : tierValue >= 1 ? BiomePoolTier.SUPER_RARE : BiomePoolTier.ULTRA_RARE
: tierValue >= 20 ? BiomePoolTier.BOSS : tierValue >= 6 ? BiomePoolTier.BOSS_RARE : tierValue >= 1 ? BiomePoolTier.BOSS_SUPER_RARE : BiomePoolTier.BOSS_ULTRA_RARE;
console.log(BiomePoolTier[tier]);
2023-04-17 01:41:52 +01:00
while (!this.pokemonPool[tier].length) {
console.log(`Downgraded rarity tier from ${BiomePoolTier[tier]} to ${BiomePoolTier[tier - 1]}`);
tier--;
}
const tierPool = this.pokemonPool[tier];
let ret: PokemonSpecies;
2023-04-20 06:04:36 +01:00
let regen = false;
2023-04-17 01:41:52 +01:00
if (!tierPool.length)
ret = this.scene.randomSpecies(waveIndex, level);
2023-04-17 01:41:52 +01:00
else {
const entry = tierPool[Utils.randSeedInt(tierPool.length)];
2023-04-17 01:41:52 +01:00
let species: Species;
if (typeof entry === 'number')
species = entry as Species;
else {
const levelThresholds = Object.keys(entry);
for (let l = levelThresholds.length - 1; l >= 0; l--) {
const levelThreshold = parseInt(levelThresholds[l]);
if (level >= levelThreshold) {
const speciesIds = entry[levelThreshold];
if (speciesIds.length > 1)
species = speciesIds[Utils.randSeedInt(speciesIds.length)];
2023-04-17 01:41:52 +01:00
else
species = speciesIds[0];
break;
}
}
}
ret = getPokemonSpecies(species);
2023-04-20 06:04:36 +01:00
2023-05-02 21:58:18 +01:00
if (ret.pseudoLegendary || ret.legendary || ret.mythical) {
2023-04-20 06:04:36 +01:00
switch (true) {
case (ret.baseTotal >= 720):
regen = level < 90;
break;
case (ret.baseTotal >= 670):
regen = level < 70;
break;
case (ret.baseTotal >= 580):
regen = level < 50;
break;
default:
regen = level < 30;
break;
}
}
}
if (regen && (attempt || 0) < 10) {
console.log('Incompatible level: regenerating...');
return this.randomSpecies(waveIndex, level, (attempt || 0) + 1);
2023-04-17 01:41:52 +01:00
}
2023-04-20 06:04:36 +01:00
const newSpeciesId = ret.getSpeciesForLevel(level, true);
2023-04-17 01:41:52 +01:00
if (newSpeciesId !== ret.speciesId) {
console.log('Replaced', Species[ret.speciesId], 'with', Species[newSpeciesId]);
ret = getPokemonSpecies(newSpeciesId);
}
return ret;
}
randomTrainerType(waveIndex: integer): TrainerType {
const isBoss = waveIndex > 20 && !(waveIndex % 30) && !!this.trainerPool[BiomePoolTier.BOSS].length
&& (this.biomeType !== Biome.END || this.scene.gameMode === GameMode.CLASSIC || waveIndex % 250 === 0);
const tierValue = Utils.randSeedInt(!isBoss ? 512 : 64);
let tier = !isBoss
? tierValue >= 156 ? BiomePoolTier.COMMON : tierValue >= 32 ? BiomePoolTier.UNCOMMON : tierValue >= 6 ? BiomePoolTier.RARE : tierValue >= 1 ? BiomePoolTier.SUPER_RARE : BiomePoolTier.ULTRA_RARE
: tierValue >= 20 ? BiomePoolTier.BOSS : tierValue >= 6 ? BiomePoolTier.BOSS_RARE : tierValue >= 1 ? BiomePoolTier.BOSS_SUPER_RARE : BiomePoolTier.BOSS_ULTRA_RARE;
console.log(BiomePoolTier[tier]);
while (tier && !this.trainerPool[tier].length) {
console.log(`Downgraded trainer rarity tier from ${BiomePoolTier[tier]} to ${BiomePoolTier[tier - 1]}`);
tier--;
}
const tierPool = this.trainerPool[tier] || [];
return !tierPool.length ? TrainerType.BREEDER : tierPool[Utils.randSeedInt(tierPool.length)];
}
2023-10-30 18:57:23 +00:00
getSpeciesFormIndex(species: PokemonSpecies): integer {
2023-10-28 05:18:44 +01:00
switch (species.speciesId) {
case Species.BURMY:
case Species.WORMADAM:
switch (this.biomeType) {
case Biome.BEACH:
return 1;
case Biome.CITY:
return 2;
}
break;
}
2023-10-30 18:57:23 +00:00
return 0;
}
2023-04-22 00:30:04 +01:00
getTypeForBiome() {
switch (this.biomeType) {
case Biome.TOWN:
2023-04-22 00:30:04 +01:00
case Biome.PLAINS:
return Type.NORMAL;
case Biome.GRASS:
case Biome.TALL_GRASS:
return Type.GRASS;
2023-05-01 06:00:46 +01:00
case Biome.FOREST:
return Type.BUG;
2023-04-22 00:30:04 +01:00
case Biome.CITY:
case Biome.SWAMP:
return Type.POISON;
case Biome.SEA:
case Biome.BEACH:
case Biome.LAKE:
case Biome.SEABED:
return Type.WATER;
case Biome.MOUNTAIN:
return Type.FLYING;
2023-05-11 15:31:39 +01:00
case Biome.BADLANDS:
2023-04-22 00:30:04 +01:00
return Type.GROUND;
case Biome.CAVE:
case Biome.DESERT:
return Type.ROCK;
case Biome.ICE_CAVE:
return Type.ICE;
case Biome.MEADOW:
return Type.FAIRY;
case Biome.POWER_PLANT:
return Type.ELECTRIC;
case Biome.VOLCANO:
return Type.FIRE;
case Biome.GRAVEYARD:
return Type.GHOST;
case Biome.DOJO:
return Type.FIGHTING;
2023-05-01 06:00:46 +01:00
case Biome.FACTORY:
return Type.STEEL;
2023-04-22 00:30:04 +01:00
case Biome.RUINS:
case Biome.SPACE:
2023-04-22 00:30:04 +01:00
return Type.PSYCHIC;
case Biome.WASTELAND:
2023-05-01 06:00:46 +01:00
case Biome.END:
2023-04-22 00:30:04 +01:00
return Type.DRAGON;
case Biome.ABYSS:
return Type.DARK;
}
}
trySetWeatherOverride(weather: WeatherType): boolean {
this.weather = new Weather(weather, 0);
this.scene.unshiftPhase(new CommonAnimPhase(this.scene, undefined, undefined, CommonAnim.SUNNY + (weather - 1)));
this.scene.queueMessage(getWeatherStartMessage(weather));
return true
}
trySetWeather(weather: WeatherType, viaMove: boolean): boolean {
// override hook for debugging
if (WEATHER_OVERRIDE) {
return this.trySetWeatherOverride(WEATHER_OVERRIDE);
}
2023-04-19 04:54:07 +01:00
if (this.weather?.weatherType === (weather || undefined))
2023-04-17 01:41:52 +01:00
return false;
const oldWeatherType = this.weather?.weatherType || WeatherType.NONE;
this.weather = weather ? new Weather(weather, viaMove ? 5 : 0) : null;
if (this.weather) {
this.scene.unshiftPhase(new CommonAnimPhase(this.scene, undefined, undefined, CommonAnim.SUNNY + (weather - 1)));
2023-04-22 00:30:04 +01:00
this.scene.queueMessage(getWeatherStartMessage(weather));
} else
2023-04-22 00:30:04 +01:00
this.scene.queueMessage(getWeatherClearMessage(oldWeatherType));
2023-04-17 01:41:52 +01:00
return true;
}
2023-04-22 00:30:04 +01:00
isMoveWeatherCancelled(move: Move) {
return this.weather && !this.weather.isEffectSuppressed(this.scene) && this.weather.isMoveWeatherCancelled(move);
2023-04-22 00:30:04 +01:00
}
getAttackTypeMultiplier(attackType: Type): number {
if (!this.weather || this.weather.isEffectSuppressed(this.scene))
return 1;
return this.weather.getAttackTypeMultiplier(attackType);
}
getTrainerChance(): integer {
switch (this.biomeType) {
case Biome.CITY:
case Biome.BEACH:
case Biome.DOJO:
case Biome.CONSTRUCTION_SITE:
return 4;
case Biome.PLAINS:
case Biome.GRASS:
case Biome.LAKE:
case Biome.CAVE:
return 6;
case Biome.TALL_GRASS:
case Biome.FOREST:
case Biome.SEA:
case Biome.SWAMP:
case Biome.MOUNTAIN:
case Biome.BADLANDS:
case Biome.DESERT:
case Biome.MEADOW:
case Biome.POWER_PLANT:
case Biome.GRAVEYARD:
case Biome.FACTORY:
return 8;
case Biome.ICE_CAVE:
case Biome.VOLCANO:
case Biome.RUINS:
case Biome.WASTELAND:
case Biome.JUNGLE:
return 12;
case Biome.SEABED:
case Biome.ABYSS:
case Biome.SPACE:
return 16;
default:
return 0;
}
}
2023-04-17 01:41:52 +01:00
isDaytime(): boolean {
switch (this.biomeType) {
case Biome.TOWN:
2023-04-17 01:41:52 +01:00
case Biome.PLAINS:
case Biome.GRASS:
case Biome.SEA:
case Biome.BEACH:
case Biome.LAKE:
case Biome.MOUNTAIN:
2023-05-11 15:31:39 +01:00
case Biome.BADLANDS:
2023-04-17 01:41:52 +01:00
case Biome.DESERT:
case Biome.MEADOW:
case Biome.DOJO:
case Biome.CONSTRUCTION_SITE:
2023-04-17 01:41:52 +01:00
return true;
}
}
2023-04-22 00:30:04 +01:00
applyTags(tagType: ArenaTagType | { new(...args: any[]): ArenaTag }, ...args: any[]): void {
const tags = typeof tagType === 'number'
? this.tags.filter(t => t.tagType === tagType)
: this.tags.filter(t => t instanceof tagType);
tags.forEach(t => t.apply(args));
}
2023-12-04 05:09:38 +00:00
addTag(tagType: ArenaTagType, turnCount: integer, sourceMove: Moves, sourceId: integer, targetIndex?: BattlerIndex): boolean {
2023-04-22 00:30:04 +01:00
const existingTag = this.getTag(tagType);
if (existingTag) {
existingTag.onOverlap(this);
return false;
}
2023-12-04 05:09:38 +00:00
const newTag = getArenaTag(tagType, turnCount || 0, sourceMove, sourceId, targetIndex);
2023-04-22 00:30:04 +01:00
this.tags.push(newTag);
newTag.onAdd(this);
return true;
}
getTag(tagType: ArenaTagType | { new(...args: any[]): ArenaTag }): ArenaTag {
return typeof(tagType) === 'number'
? this.tags.find(t => t.tagType === tagType)
: this.tags.find(t => t instanceof tagType);
}
lapseTags(): void {
const tags = this.tags;
tags.filter(t => !(t.lapse(this))).forEach(t => {
t.onRemove(this);
tags.splice(tags.indexOf(t), 1);
});
}
2023-04-17 01:41:52 +01:00
preloadBgm(): void {
this.scene.loadBgm(this.bgm);
}
2023-04-26 04:56:38 +01:00
getBgmLoopPoint(): number {
switch (this.biomeType) {
case Biome.TOWN:
return 7.288;
case Biome.PLAINS:
return 7.693;
case Biome.GRASS:
return 1.995;
case Biome.TALL_GRASS:
return 9.608;
case Biome.CITY:
return 1.221;
case Biome.FOREST:
return 4.294;
case Biome.SEA:
return 1.672;
case Biome.SWAMP:
return 4.461;
case Biome.BEACH:
return 3.462;
case Biome.LAKE:
return 5.350;
case Biome.SEABED:
return 2.629;
case Biome.MOUNTAIN:
return 4.018;
2023-05-11 15:31:39 +01:00
case Biome.BADLANDS:
2023-04-26 04:56:38 +01:00
return 17.790;
case Biome.CAVE:
return 14.240;
case Biome.DESERT:
return 1.143;
case Biome.ICE_CAVE:
return 15.010;
case Biome.MEADOW:
return 3.891;
case Biome.POWER_PLANT:
return 2.810;
case Biome.VOLCANO:
return 5.116;
case Biome.GRAVEYARD:
return 3.232;
case Biome.DOJO:
return 6.205;
2023-05-01 06:00:46 +01:00
case Biome.FACTORY:
return 4.985;
2023-04-26 04:56:38 +01:00
case Biome.RUINS:
return 2.270;
case Biome.WASTELAND:
return 6.336;
case Biome.ABYSS:
return 5.130;
case Biome.SPACE:
return 21.347;
case Biome.CONSTRUCTION_SITE:
return 1.222;
case Biome.JUNGLE:
return 2.477;
2023-04-26 04:56:38 +01:00
}
}
}
export function getBiomeKey(biome: Biome): string {
switch (biome) {
case Biome.POWER_PLANT:
return 'ruins';
case Biome.CONSTRUCTION_SITE:
return 'city';
case Biome.JUNGLE:
return 'tall_grass';
case Biome.END:
return 'wasteland';
}
return Biome[biome].toLowerCase();
}
export function getBiomeHasProps(biomeType: Biome): boolean {
switch (biomeType) {
2023-05-11 17:16:10 +01:00
case Biome.BEACH:
case Biome.LAKE:
2023-05-11 17:16:10 +01:00
case Biome.SEABED:
2023-05-30 14:46:42 +01:00
case Biome.MOUNTAIN:
2023-05-11 15:31:39 +01:00
case Biome.BADLANDS:
2023-05-11 17:16:10 +01:00
case Biome.CAVE:
case Biome.DESERT:
2023-05-15 13:45:26 +01:00
case Biome.ICE_CAVE:
2023-05-31 15:21:38 +01:00
case Biome.MEADOW:
case Biome.VOLCANO:
case Biome.GRAVEYARD:
2023-06-01 18:54:52 +01:00
case Biome.FACTORY:
2023-06-06 16:09:34 +01:00
case Biome.RUINS:
2023-05-30 15:21:09 +01:00
case Biome.WASTELAND:
2023-06-06 04:25:17 +01:00
case Biome.ABYSS:
return true;
}
return false;
}
export class ArenaBase extends Phaser.GameObjects.Container {
public player: boolean;
public biome: Biome;
public propValue: integer;
public base: Phaser.GameObjects.Sprite;
public props: Phaser.GameObjects.Sprite[];
constructor(scene: BattleScene, player: boolean) {
super(scene, 0, 0);
this.player = player;
this.base = scene.add.sprite(0, 0, 'plains_a');
this.base.setOrigin(0, 0);
this.props = !player ?
new Array(3).fill(null).map(() => {
const ret = scene.add.sprite(0, 0, 'plains_b');
ret.setOrigin(0, 0);
ret.setVisible(false);
return ret;
}) : [];
}
setBiome(biome: Biome, propValue?: integer): void {
if (this.biome === biome)
return;
const hasProps = getBiomeHasProps(biome);
const biomeKey = getBiomeKey(biome);
this.base.setTexture(`${biomeKey}_${this.player ? 'a' : 'b'}`);
this.add(this.base);
if (!this.player) {
(this.scene as BattleScene).executeWithSeedOffset(() => {
this.propValue = propValue === undefined
? hasProps ? Utils.randSeedInt(8) : 0
: propValue;
this.props.forEach((prop, p) => {
prop.setTexture(`${biomeKey}_b${hasProps ? `_${p + 1}` : ''}`);
prop.setVisible(hasProps && !!(this.propValue & (1 << p)));
this.add(prop);
});
}, (this.scene as BattleScene).currentBattle?.waveIndex || 0);
}
}
2023-04-17 01:41:52 +01:00
}