2023-04-17 01:41:52 +01:00
|
|
|
import BattleScene from "./battle-scene";
|
2023-10-18 23:01:15 +01:00
|
|
|
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";
|
2023-04-24 19:30:21 +01:00
|
|
|
import Move, { Moves } from "./data/move";
|
2023-04-22 00:30:04 +01:00
|
|
|
import { ArenaTag, ArenaTagType, getArenaTag } from "./data/arena-tag";
|
2023-06-01 00:54:57 +01:00
|
|
|
import { GameMode } from "./game-mode";
|
2023-10-18 23:01:15 +01:00
|
|
|
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-11-25 03:25:09 +00:00
|
|
|
|
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[];
|
2023-10-10 01:20:02 +01:00
|
|
|
public bgm: string;
|
2023-04-17 01:41:52 +01:00
|
|
|
|
2023-10-10 01:20:02 +01:00
|
|
|
private pokemonPool: BiomeTierPokemonPools;
|
2023-10-18 23:01:15 +01:00
|
|
|
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;
|
2023-10-10 01:20:02 +01:00
|
|
|
this.pokemonPool = biomePokemonPools[biome];
|
2023-10-18 23:01:15 +01:00
|
|
|
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 {
|
2023-11-06 01:34:32 +00:00
|
|
|
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
|
2023-11-04 23:46:48 +00:00
|
|
|
&& (this.biomeType !== Biome.END || this.scene.gameMode === GameMode.CLASSIC || waveIndex % 250 === 0);
|
2023-10-18 23:01:15 +01:00
|
|
|
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;
|
2023-04-19 19:07:38 +01:00
|
|
|
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)
|
2023-04-19 19:07:38 +01:00
|
|
|
ret = this.scene.randomSpecies(waveIndex, level);
|
2023-04-17 01:41:52 +01:00
|
|
|
else {
|
2023-10-18 23:01:15 +01:00
|
|
|
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)
|
2023-10-18 23:01:15 +01:00
|
|
|
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
|
|
|
|
2023-04-22 06:09:35 +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;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
randomTrainerType(waveIndex: integer): TrainerType {
|
2023-10-23 04:31:41 +01:00
|
|
|
const isBoss = waveIndex > 20 && !(waveIndex % 30) && !!this.trainerPool[BiomePoolTier.BOSS].length
|
2023-11-04 23:46:48 +00:00
|
|
|
&& (this.biomeType !== Biome.END || this.scene.gameMode === GameMode.CLASSIC || waveIndex % 250 === 0);
|
2023-10-18 23:01:15 +01:00
|
|
|
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
|
|
|
|
2023-04-18 03:44:41 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-04-22 00:30:04 +01:00
|
|
|
getTypeForBiome() {
|
|
|
|
switch (this.biomeType) {
|
2023-04-22 01:29:22 +01:00
|
|
|
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:
|
2023-04-26 22:40:08 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-25 03:25:09 +00:00
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2023-04-17 05:46:50 +01:00
|
|
|
trySetWeather(weather: WeatherType, viaMove: boolean): boolean {
|
2023-11-25 03:25:09 +00:00
|
|
|
// 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;
|
|
|
|
|
2023-04-17 05:46:50 +01:00
|
|
|
const oldWeatherType = this.weather?.weatherType || WeatherType.NONE;
|
|
|
|
|
2023-11-25 03:25:09 +00:00
|
|
|
this.weather = weather ? new Weather(weather, viaMove ? 5 : 0) : null;
|
|
|
|
|
2023-04-17 05:46:50 +01:00
|
|
|
if (this.weather) {
|
2023-05-18 16:11:06 +01:00
|
|
|
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));
|
2023-04-17 05:46:50 +01:00
|
|
|
} else
|
2023-04-22 00:30:04 +01:00
|
|
|
this.scene.queueMessage(getWeatherClearMessage(oldWeatherType));
|
2023-04-17 05:46:50 +01:00
|
|
|
|
2023-04-17 01:41:52 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2023-04-22 00:30:04 +01:00
|
|
|
isMoveWeatherCancelled(move: Move) {
|
2023-04-27 19:30:03 +01:00
|
|
|
return this.weather && !this.weather.isEffectSuppressed(this.scene) && this.weather.isMoveWeatherCancelled(move);
|
2023-04-22 00:30:04 +01:00
|
|
|
}
|
|
|
|
|
2023-04-17 05:46:50 +01:00
|
|
|
getAttackTypeMultiplier(attackType: Type): number {
|
2023-04-27 19:30:03 +01:00
|
|
|
if (!this.weather || this.weather.isEffectSuppressed(this.scene))
|
2023-04-17 05:46:50 +01:00
|
|
|
return 1;
|
2023-04-27 19:30:03 +01:00
|
|
|
|
2023-04-17 05:46:50 +01:00
|
|
|
return this.weather.getAttackTypeMultiplier(attackType);
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
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) {
|
2023-04-22 01:29:22 +01:00
|
|
|
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:
|
2023-10-18 23:01:15 +01:00
|
|
|
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;
|
2023-10-10 04:43:19 +01:00
|
|
|
case Biome.CONSTRUCTION_SITE:
|
|
|
|
return 1.222;
|
|
|
|
case Biome.JUNGLE:
|
|
|
|
return 2.477;
|
2023-04-26 04:56:38 +01:00
|
|
|
}
|
|
|
|
}
|
2023-05-09 17:43:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
export function getBiomeKey(biome: Biome): string {
|
|
|
|
switch (biome) {
|
|
|
|
case Biome.POWER_PLANT:
|
|
|
|
return 'ruins';
|
2023-10-10 04:43:19 +01:00
|
|
|
case Biome.CONSTRUCTION_SITE:
|
|
|
|
return 'city';
|
|
|
|
case Biome.JUNGLE:
|
|
|
|
return 'tall_grass';
|
2023-05-09 17:43:28 +01:00
|
|
|
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:
|
2023-05-09 17:43:28 +01:00
|
|
|
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:
|
2023-05-09 17:43:28 +01:00
|
|
|
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:
|
2023-05-09 17:43:28 +01:00
|
|
|
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;
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
this.base = scene.add.sprite(0, 0, 'plains_a');
|
2023-05-09 17:43:28 +01:00
|
|
|
this.base.setOrigin(0, 0);
|
|
|
|
|
|
|
|
this.props = !player ?
|
|
|
|
new Array(3).fill(null).map(() => {
|
2023-10-18 23:01:15 +01:00
|
|
|
const ret = scene.add.sprite(0, 0, 'plains_b');
|
2023-05-09 17:43:28 +01:00
|
|
|
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) {
|
2023-10-18 23:01:15 +01:00
|
|
|
(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-05-09 17:43:28 +01:00
|
|
|
}
|
|
|
|
}
|
2023-04-17 01:41:52 +01:00
|
|
|
}
|