2023-11-09 13:27:17 +00:00
|
|
|
import BattleScene, { startingWave } from "../battle-scene";
|
2023-12-08 14:48:03 +00:00
|
|
|
import { ModifierTypeFunc, modifierTypes } from "../modifier/modifier-type";
|
2024-03-01 01:08:50 +00:00
|
|
|
import { EnemyPokemon } from "../field/pokemon";
|
2023-10-07 21:08:33 +01:00
|
|
|
import * as Utils from "../utils";
|
2024-01-13 17:24:24 +00:00
|
|
|
import { TrainerType } from "./enums/trainer-type";
|
|
|
|
import { Moves } from "./enums/moves";
|
2024-01-08 04:17:24 +00:00
|
|
|
import { PokeballType } from "./pokeball";
|
2023-10-18 23:01:15 +01:00
|
|
|
import { pokemonEvolutions, pokemonPrevolutions } from "./pokemon-evolutions";
|
|
|
|
import PokemonSpecies, { PokemonSpeciesFilter, getPokemonSpecies } from "./pokemon-species";
|
2024-01-13 17:24:24 +00:00
|
|
|
import { Species } from "./enums/species";
|
2023-10-10 01:20:02 +01:00
|
|
|
import { tmSpecies } from "./tms";
|
|
|
|
import { Type } from "./type";
|
2024-01-13 17:24:24 +00:00
|
|
|
import { initTrainerTypeDialogue } from "./dialogue";
|
2024-02-17 05:40:03 +00:00
|
|
|
import { PersistentModifier, TerastallizeModifier } from "../modifier/modifier";
|
2023-10-10 01:20:02 +01:00
|
|
|
|
|
|
|
export enum TrainerPoolTier {
|
|
|
|
COMMON,
|
|
|
|
UNCOMMON,
|
|
|
|
RARE,
|
|
|
|
SUPER_RARE,
|
|
|
|
ULTRA_RARE
|
2023-12-14 05:41:35 +00:00
|
|
|
}
|
2023-10-10 01:20:02 +01:00
|
|
|
|
|
|
|
export interface TrainerTierPools {
|
|
|
|
[key: integer]: Species[]
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
export enum TrainerPartyMemberStrength {
|
2024-01-09 05:06:11 +00:00
|
|
|
WEAKEST,
|
2023-10-18 23:01:15 +01:00
|
|
|
WEAKER,
|
|
|
|
WEAK,
|
|
|
|
AVERAGE,
|
|
|
|
STRONG,
|
|
|
|
STRONGER
|
|
|
|
}
|
|
|
|
|
|
|
|
export class TrainerPartyTemplate {
|
|
|
|
public size: integer;
|
|
|
|
public strength: TrainerPartyMemberStrength;
|
|
|
|
public sameSpecies: boolean;
|
|
|
|
public balanced: boolean;
|
|
|
|
|
|
|
|
constructor(size: integer, strength: TrainerPartyMemberStrength, sameSpecies?: boolean, balanced?: boolean) {
|
|
|
|
this.size = size;
|
|
|
|
this.strength = strength;
|
|
|
|
this.sameSpecies = !!sameSpecies;
|
|
|
|
this.balanced = !!balanced;
|
|
|
|
}
|
|
|
|
|
|
|
|
getStrength(index: integer): TrainerPartyMemberStrength {
|
|
|
|
return this.strength;
|
|
|
|
}
|
|
|
|
|
|
|
|
isSameSpecies(index: integer): boolean {
|
|
|
|
return this.sameSpecies;
|
|
|
|
}
|
|
|
|
|
|
|
|
isBalanced(index: integer): boolean {
|
|
|
|
return this.balanced;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export class TrainerPartyCompoundTemplate extends TrainerPartyTemplate {
|
|
|
|
public templates: TrainerPartyTemplate[];
|
|
|
|
|
|
|
|
constructor(...templates: TrainerPartyTemplate[]) {
|
|
|
|
super(templates.reduce((total: integer, template: TrainerPartyTemplate) => {
|
|
|
|
total += template.size;
|
|
|
|
return total;
|
|
|
|
}, 0), TrainerPartyMemberStrength.AVERAGE);
|
|
|
|
this.templates = templates;
|
|
|
|
}
|
|
|
|
|
|
|
|
getStrength(index: integer): TrainerPartyMemberStrength {
|
|
|
|
let t = 0;
|
|
|
|
for (let template of this.templates) {
|
|
|
|
if (t + template.size > index)
|
|
|
|
return template.getStrength(index - t);
|
|
|
|
t += template.size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return super.getStrength(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
isSameSpecies(index: integer): boolean {
|
|
|
|
let t = 0;
|
|
|
|
for (let template of this.templates) {
|
|
|
|
if (t + template.size > index)
|
|
|
|
return template.isSameSpecies(index - t);
|
|
|
|
t += template.size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return super.isSameSpecies(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
isBalanced(index: integer): boolean {
|
|
|
|
let t = 0;
|
|
|
|
for (let template of this.templates) {
|
|
|
|
if (t + template.size > index)
|
|
|
|
return template.isBalanced(index - t);
|
|
|
|
t += template.size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return super.isBalanced(index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export const trainerPartyTemplates = {
|
2023-12-08 13:15:36 +00:00
|
|
|
ONE_WEAK_ONE_STRONG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.WEAK), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG)),
|
2023-10-18 23:01:15 +01:00
|
|
|
ONE_AVG: new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE),
|
2023-12-08 13:15:36 +00:00
|
|
|
ONE_AVG_ONE_STRONG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG)),
|
2023-10-18 23:01:15 +01:00
|
|
|
ONE_STRONG: new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG),
|
|
|
|
ONE_STRONGER: new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER),
|
|
|
|
TWO_WEAKER: new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAKER),
|
|
|
|
TWO_WEAK: new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAK),
|
2023-12-02 06:12:32 +00:00
|
|
|
TWO_WEAK_ONE_AVG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAK), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE)),
|
2023-10-18 23:01:15 +01:00
|
|
|
TWO_WEAK_SAME_ONE_AVG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAK, true), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE)),
|
|
|
|
TWO_WEAK_SAME_TWO_WEAK_SAME: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAK, true), new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAK, true)),
|
2023-12-02 06:12:32 +00:00
|
|
|
TWO_WEAK_ONE_STRONG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.WEAK), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG)),
|
2023-10-18 23:01:15 +01:00
|
|
|
TWO_AVG: new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE),
|
2023-12-02 06:12:32 +00:00
|
|
|
TWO_AVG_ONE_STRONG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG)),
|
2023-10-18 23:01:15 +01:00
|
|
|
TWO_AVG_SAME_ONE_AVG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE, true), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE)),
|
|
|
|
TWO_AVG_SAME_ONE_STRONG: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE, true), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG)),
|
|
|
|
TWO_AVG_SAME_TWO_AVG_SAME: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE, true), new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE, true)),
|
2023-12-03 01:56:53 +00:00
|
|
|
TWO_STRONG: new TrainerPartyTemplate(2, TrainerPartyMemberStrength.STRONG),
|
2023-10-18 23:01:15 +01:00
|
|
|
THREE_WEAK: new TrainerPartyTemplate(3, TrainerPartyMemberStrength.WEAK),
|
|
|
|
THREE_WEAK_SAME: new TrainerPartyTemplate(3, TrainerPartyMemberStrength.WEAK, true),
|
|
|
|
THREE_AVG: new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE),
|
|
|
|
THREE_AVG_SAME: new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE, true),
|
2023-10-20 22:22:07 +01:00
|
|
|
THREE_WEAK_BALANCED: new TrainerPartyTemplate(3, TrainerPartyMemberStrength.WEAK, false, true),
|
2023-10-18 23:01:15 +01:00
|
|
|
FOUR_WEAKER: new TrainerPartyTemplate(4, TrainerPartyMemberStrength.WEAKER),
|
|
|
|
FOUR_WEAKER_SAME: new TrainerPartyTemplate(4, TrainerPartyMemberStrength.WEAKER, true),
|
|
|
|
FOUR_WEAK: new TrainerPartyTemplate(4, TrainerPartyMemberStrength.WEAK),
|
2023-10-20 22:22:07 +01:00
|
|
|
FOUR_WEAK_SAME: new TrainerPartyTemplate(4, TrainerPartyMemberStrength.WEAK, true),
|
|
|
|
FOUR_WEAK_BALANCED: new TrainerPartyTemplate(4, TrainerPartyMemberStrength.WEAK, false, true),
|
|
|
|
FIVE_WEAKER: new TrainerPartyTemplate(5, TrainerPartyMemberStrength.WEAKER),
|
|
|
|
FIVE_WEAK: new TrainerPartyTemplate(5, TrainerPartyMemberStrength.WEAK),
|
|
|
|
FIVE_WEAK_BALANCED: new TrainerPartyTemplate(5, TrainerPartyMemberStrength.WEAK, false, true),
|
2023-10-18 23:01:15 +01:00
|
|
|
SIX_WEAKER: new TrainerPartyTemplate(6, TrainerPartyMemberStrength.WEAKER),
|
|
|
|
SIX_WEAKER_SAME: new TrainerPartyTemplate(6, TrainerPartyMemberStrength.WEAKER, true),
|
2024-01-09 05:06:11 +00:00
|
|
|
SIX_WEAK_SAME: new TrainerPartyTemplate(6, TrainerPartyMemberStrength.WEAKER, true),
|
2023-10-18 23:01:15 +01:00
|
|
|
SIX_WEAK_BALANCED: new TrainerPartyTemplate(6, TrainerPartyMemberStrength.WEAK, false, true),
|
|
|
|
|
2023-10-20 16:38:41 +01:00
|
|
|
GYM_LEADER_1: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER)),
|
2024-01-08 05:07:42 +00:00
|
|
|
GYM_LEADER_2: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER)),
|
|
|
|
GYM_LEADER_3: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(2, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER)),
|
|
|
|
GYM_LEADER_4: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER)),
|
|
|
|
GYM_LEADER_5: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(4, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER)),
|
2023-10-20 16:38:41 +01:00
|
|
|
|
|
|
|
ELITE_FOUR: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(2, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER)),
|
|
|
|
|
|
|
|
CHAMPION: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER), new TrainerPartyTemplate(5, TrainerPartyMemberStrength.STRONG, false, true)),
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
RIVAL: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE)),
|
|
|
|
RIVAL_2: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE)),
|
|
|
|
RIVAL_3: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE, false, true)),
|
|
|
|
RIVAL_4: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE, false, true)),
|
|
|
|
RIVAL_5: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE, false, true), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG)),
|
|
|
|
RIVAL_6: new TrainerPartyCompoundTemplate(new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONG), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.AVERAGE), new TrainerPartyTemplate(3, TrainerPartyMemberStrength.AVERAGE, false, true), new TrainerPartyTemplate(1, TrainerPartyMemberStrength.STRONGER))
|
|
|
|
};
|
|
|
|
|
2023-10-20 16:38:41 +01:00
|
|
|
type PartyTemplateFunc = (scene: BattleScene) => TrainerPartyTemplate;
|
2023-10-18 23:01:15 +01:00
|
|
|
type PartyMemberFunc = (scene: BattleScene, level: integer) => EnemyPokemon;
|
2024-02-17 05:40:03 +00:00
|
|
|
type GenModifiersFunc = (party: EnemyPokemon[]) => PersistentModifier[];
|
2023-10-18 23:01:15 +01:00
|
|
|
|
|
|
|
export interface PartyMemberFuncs {
|
|
|
|
[key: integer]: PartyMemberFunc
|
|
|
|
}
|
|
|
|
|
2023-10-07 21:08:33 +01:00
|
|
|
export class TrainerConfig {
|
|
|
|
public trainerType: TrainerType;
|
2023-10-10 01:20:02 +01:00
|
|
|
public name: string;
|
|
|
|
public nameFemale: string;
|
2024-02-06 04:05:56 +00:00
|
|
|
public title: string;
|
2023-10-07 21:08:33 +01:00
|
|
|
public hasGenders: boolean = false;
|
2024-02-22 23:03:36 +00:00
|
|
|
public hasCharSprite: boolean = false;
|
2023-10-07 21:08:33 +01:00
|
|
|
public isDouble: boolean = false;
|
2023-11-10 20:51:34 +00:00
|
|
|
public moneyMultiplier: number = 1;
|
2023-10-24 15:05:07 +01:00
|
|
|
public isBoss: boolean = false;
|
|
|
|
public hasStaticParty: boolean = false;
|
2023-12-08 13:15:36 +00:00
|
|
|
public useSameSeedForAllMembers: boolean = false;
|
2023-10-18 23:01:15 +01:00
|
|
|
public battleBgm: string;
|
2023-10-10 01:20:02 +01:00
|
|
|
public encounterBgm: string;
|
|
|
|
public femaleEncounterBgm: string;
|
2023-10-20 16:38:41 +01:00
|
|
|
public victoryBgm: string;
|
2024-02-17 05:40:03 +00:00
|
|
|
public genModifiersFunc: GenModifiersFunc;
|
2023-10-25 19:15:44 +01:00
|
|
|
public modifierRewardFuncs: ModifierTypeFunc[] = [];
|
2023-10-18 23:01:15 +01:00
|
|
|
public partyTemplates: TrainerPartyTemplate[];
|
2023-10-20 16:38:41 +01:00
|
|
|
public partyTemplateFunc: PartyTemplateFunc;
|
2023-10-18 23:01:15 +01:00
|
|
|
public partyMemberFuncs: PartyMemberFuncs = {};
|
2023-10-10 01:20:02 +01:00
|
|
|
public speciesPools: TrainerTierPools;
|
|
|
|
public speciesFilter: PokemonSpeciesFilter;
|
2023-12-31 04:31:26 +00:00
|
|
|
public specialtyTypes: Type[] = [];
|
2023-10-07 21:08:33 +01:00
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
public encounterMessages: string[] = [];
|
|
|
|
public victoryMessages: string[] = [];
|
|
|
|
public defeatMessages: string[] = [];
|
|
|
|
|
|
|
|
public femaleEncounterMessages: string[];
|
|
|
|
public femaleVictoryMessages: string[];
|
|
|
|
public femaleDefeatMessages: string[];
|
|
|
|
|
2023-10-10 01:20:02 +01:00
|
|
|
constructor(trainerType: TrainerType, allowLegendaries?: boolean) {
|
2023-10-07 21:08:33 +01:00
|
|
|
this.trainerType = trainerType;
|
2023-10-18 23:01:15 +01:00
|
|
|
this.name = Utils.toReadableString(TrainerType[this.getDerivedType()]);
|
|
|
|
this.battleBgm = 'battle_trainer';
|
2023-10-20 16:38:41 +01:00
|
|
|
this.victoryBgm = 'victory_trainer';
|
2023-10-18 23:01:15 +01:00
|
|
|
this.partyTemplates = [ trainerPartyTemplates.TWO_AVG ];
|
2023-10-10 01:20:02 +01:00
|
|
|
this.speciesFilter = species => allowLegendaries || (!species.legendary && !species.pseudoLegendary && !species.mythical);
|
2023-10-07 21:08:33 +01:00
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
getKey(female?: boolean): string {
|
|
|
|
let ret = TrainerType[this.getDerivedType()].toString().toLowerCase();
|
2023-10-07 21:08:33 +01:00
|
|
|
if (this.hasGenders)
|
|
|
|
ret += `_${female ? 'f' : 'm'}`;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setName(name: string): TrainerConfig {
|
2023-10-10 01:20:02 +01:00
|
|
|
this.name = name;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2024-02-06 04:05:56 +00:00
|
|
|
setTitle(title: string): TrainerConfig {
|
|
|
|
this.title = title;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
getDerivedType(): TrainerType {
|
|
|
|
let trainerType = this.trainerType;
|
|
|
|
switch (trainerType) {
|
|
|
|
case TrainerType.RIVAL_2:
|
|
|
|
case TrainerType.RIVAL_3:
|
|
|
|
case TrainerType.RIVAL_4:
|
|
|
|
case TrainerType.RIVAL_5:
|
|
|
|
case TrainerType.RIVAL_6:
|
|
|
|
trainerType = TrainerType.RIVAL;
|
|
|
|
break;
|
2024-01-05 00:37:07 +00:00
|
|
|
case TrainerType.LANCE_CHAMPION:
|
|
|
|
trainerType = TrainerType.LANCE;
|
|
|
|
break;
|
2024-02-06 04:46:45 +00:00
|
|
|
case TrainerType.LARRY_ELITE:
|
2024-01-05 00:37:07 +00:00
|
|
|
trainerType = TrainerType.LARRY;
|
2024-02-06 04:46:45 +00:00
|
|
|
break;
|
2023-10-18 23:01:15 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return trainerType;
|
|
|
|
}
|
|
|
|
|
|
|
|
setHasGenders(nameFemale?: string, femaleEncounterBgm?: TrainerType | string): TrainerConfig {
|
2023-10-07 21:08:33 +01:00
|
|
|
this.hasGenders = true;
|
2023-10-10 01:20:02 +01:00
|
|
|
this.nameFemale = nameFemale;
|
|
|
|
if (femaleEncounterBgm)
|
|
|
|
this.femaleEncounterBgm = typeof femaleEncounterBgm === 'number' ? TrainerType[femaleEncounterBgm].toString().replace(/\_/g, ' ').toLowerCase() : femaleEncounterBgm;
|
2023-10-07 21:08:33 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2024-02-22 23:03:36 +00:00
|
|
|
setHasCharSprite(): TrainerConfig {
|
|
|
|
this.hasCharSprite = true;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setDouble(): TrainerConfig {
|
2023-10-07 21:08:33 +01:00
|
|
|
this.isDouble = true;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-11-10 20:51:34 +00:00
|
|
|
setMoneyMultiplier(moneyMultiplier: number): TrainerConfig {
|
|
|
|
this.moneyMultiplier = moneyMultiplier;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-24 15:05:07 +01:00
|
|
|
setBoss(): TrainerConfig {
|
|
|
|
this.isBoss = true;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setStaticParty(): TrainerConfig {
|
2023-10-24 15:05:07 +01:00
|
|
|
this.hasStaticParty = true;
|
2023-10-18 23:01:15 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-12-08 13:15:36 +00:00
|
|
|
setUseSameSeedForAllMembers(): TrainerConfig {
|
|
|
|
this.useSameSeedForAllMembers = true;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setBattleBgm(battleBgm: string): TrainerConfig {
|
|
|
|
this.battleBgm = battleBgm;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
setEncounterBgm(encounterBgm: TrainerType | string): TrainerConfig {
|
2023-10-10 01:20:02 +01:00
|
|
|
this.encounterBgm = typeof encounterBgm === 'number' ? TrainerType[encounterBgm].toString().replace(/\_/g, ' ').toLowerCase() : encounterBgm;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-20 16:38:41 +01:00
|
|
|
setVictoryBgm(victoryBgm: string): TrainerConfig {
|
|
|
|
this.victoryBgm = victoryBgm;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setPartyTemplates(...partyTemplates: TrainerPartyTemplate[]): TrainerConfig {
|
|
|
|
this.partyTemplates = partyTemplates;
|
2023-10-10 01:20:02 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-20 16:38:41 +01:00
|
|
|
setPartyTemplateFunc(partyTemplateFunc: PartyTemplateFunc): TrainerConfig {
|
|
|
|
this.partyTemplateFunc = partyTemplateFunc;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setPartyMemberFunc(slotIndex: integer, partyMemberFunc: PartyMemberFunc): TrainerConfig {
|
|
|
|
this.partyMemberFuncs[slotIndex] = partyMemberFunc;
|
2023-10-10 01:20:02 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
setSpeciesPools(speciesPools: TrainerTierPools | Species[]): TrainerConfig {
|
|
|
|
this.speciesPools = (Array.isArray(speciesPools) ? { [TrainerPoolTier.COMMON]: speciesPools } : speciesPools) as unknown as TrainerTierPools;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
setSpeciesFilter(speciesFilter: PokemonSpeciesFilter, allowLegendaries?: boolean): TrainerConfig {
|
2023-10-10 01:20:02 +01:00
|
|
|
const baseFilter = this.speciesFilter;
|
|
|
|
this.speciesFilter = allowLegendaries ? speciesFilter : species => speciesFilter(species) && baseFilter(species);
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-12-31 04:31:26 +00:00
|
|
|
setSpecialtyTypes(...specialtyTypes: Type[]): TrainerConfig {
|
|
|
|
this.specialtyTypes = specialtyTypes;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2024-02-17 05:40:03 +00:00
|
|
|
setGenModifiersFunc(genModifiersFunc: GenModifiersFunc): TrainerConfig {
|
|
|
|
this.genModifiersFunc = genModifiersFunc;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-22 01:23:43 +01:00
|
|
|
setModifierRewardFuncs(...modifierTypeFuncs: (() => ModifierTypeFunc)[]): TrainerConfig {
|
|
|
|
this.modifierRewardFuncs = modifierTypeFuncs.map(func => () => {
|
|
|
|
const modifierTypeFunc = func();
|
2023-10-21 04:00:08 +01:00
|
|
|
const modifierType = modifierTypeFunc();
|
2024-02-17 05:40:03 +00:00
|
|
|
modifierType.withIdFromFunc(modifierTypeFunc);
|
2023-10-21 04:00:08 +01:00
|
|
|
return modifierType;
|
|
|
|
});
|
2023-10-20 16:38:41 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2024-01-05 00:37:07 +00:00
|
|
|
initForGymLeader(signatureSpecies: (Species | Species[])[], ...specialtyTypes: Type[]): TrainerConfig {
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setPartyTemplateFunc(getGymLeaderPartyTemplate);
|
2024-01-05 00:37:07 +00:00
|
|
|
signatureSpecies.forEach((speciesPool, s) => {
|
|
|
|
if (!Array.isArray(speciesPool))
|
|
|
|
speciesPool = [ speciesPool ];
|
|
|
|
this.setPartyMemberFunc(-(s + 1), getRandomPartyMemberFunc(speciesPool));
|
|
|
|
});
|
|
|
|
if (specialtyTypes.length) {
|
2024-01-08 05:35:41 +00:00
|
|
|
this.setSpeciesFilter(p => specialtyTypes.find(t => p.isOfType(t)) !== undefined);
|
2024-01-05 00:37:07 +00:00
|
|
|
this.setSpecialtyTypes(...specialtyTypes);
|
|
|
|
}
|
2024-02-06 04:05:56 +00:00
|
|
|
this.setTitle('Gym Leader');
|
2023-11-10 20:51:34 +00:00
|
|
|
this.setMoneyMultiplier(2.5);
|
2023-10-24 15:05:07 +01:00
|
|
|
this.setBoss();
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setStaticParty();
|
2024-03-06 23:55:55 +00:00
|
|
|
this.setBattleBgm('battle_unova_gym');
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setVictoryBgm('victory_gym');
|
2024-02-17 05:40:03 +00:00
|
|
|
this.setGenModifiersFunc(party => {
|
|
|
|
const waveIndex = party[0].scene.currentBattle.waveIndex;
|
|
|
|
return getRandomTeraModifiers(party, waveIndex >= 100 ? 1 : 0, specialtyTypes.length ? specialtyTypes : null);
|
|
|
|
});
|
2023-10-20 16:38:41 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2024-01-05 00:37:07 +00:00
|
|
|
initForEliteFour(signatureSpecies: (Species | Species[])[], ...specialtyTypes: Type[]): TrainerConfig {
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setPartyTemplates(trainerPartyTemplates.ELITE_FOUR);
|
2024-01-05 00:37:07 +00:00
|
|
|
signatureSpecies.forEach((speciesPool, s) => {
|
|
|
|
if (!Array.isArray(speciesPool))
|
|
|
|
speciesPool = [ speciesPool ];
|
|
|
|
this.setPartyMemberFunc(-(s + 1), getRandomPartyMemberFunc(speciesPool));
|
|
|
|
});
|
|
|
|
if (specialtyTypes.length) {
|
|
|
|
this.setSpeciesFilter(p => specialtyTypes.find(t => p.isOfType(t)) && p.baseTotal >= 450);
|
|
|
|
this.setSpecialtyTypes(...specialtyTypes);
|
2023-12-31 04:31:26 +00:00
|
|
|
} else
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setSpeciesFilter(p => p.baseTotal >= 450);
|
2024-02-06 04:05:56 +00:00
|
|
|
this.setTitle('Elite Four');
|
2023-11-10 20:51:34 +00:00
|
|
|
this.setMoneyMultiplier(3.25);
|
2023-10-24 15:05:07 +01:00
|
|
|
this.setBoss();
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setStaticParty();
|
|
|
|
this.setBattleBgm('battle_elite');
|
|
|
|
this.setVictoryBgm('victory_gym');
|
2024-02-17 05:40:03 +00:00
|
|
|
this.setGenModifiersFunc(party => getRandomTeraModifiers(party, 2, specialtyTypes.length ? specialtyTypes : null));
|
2023-10-20 16:38:41 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2024-01-05 00:37:07 +00:00
|
|
|
initForChampion(signatureSpecies: (Species | Species[])[]): TrainerConfig {
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setPartyTemplates(trainerPartyTemplates.CHAMPION);
|
2024-01-05 00:37:07 +00:00
|
|
|
signatureSpecies.forEach((speciesPool, s) => {
|
|
|
|
if (!Array.isArray(speciesPool))
|
|
|
|
speciesPool = [ speciesPool ];
|
|
|
|
this.setPartyMemberFunc(-(s + 1), getRandomPartyMemberFunc(speciesPool));
|
|
|
|
});
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setSpeciesFilter(p => p.baseTotal >= 470);
|
2024-02-06 04:05:56 +00:00
|
|
|
this.setTitle('Champion');
|
2023-11-10 20:51:34 +00:00
|
|
|
this.setMoneyMultiplier(10);
|
2023-10-24 15:05:07 +01:00
|
|
|
this.setBoss();
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setStaticParty();
|
2024-03-06 23:55:55 +00:00
|
|
|
this.setBattleBgm('battle_champion_alder');
|
2023-10-20 16:38:41 +01:00
|
|
|
this.setVictoryBgm('victory_champion');
|
2024-02-17 05:40:03 +00:00
|
|
|
this.setGenModifiersFunc(party => getRandomTeraModifiers(party, 3));
|
2023-10-20 16:38:41 +01:00
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2023-10-18 23:01:15 +01:00
|
|
|
getName(female?: boolean): string {
|
2023-10-10 01:20:02 +01:00
|
|
|
let ret = this.name;
|
|
|
|
|
|
|
|
if (this.hasGenders) {
|
|
|
|
if (this.nameFemale) {
|
|
|
|
if (female)
|
|
|
|
return this.nameFemale;
|
|
|
|
} else
|
|
|
|
ret += !female ? '♂' : '♀';
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2023-10-07 21:08:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
loadAssets(scene: BattleScene, female: boolean): Promise<void> {
|
|
|
|
return new Promise(resolve => {
|
|
|
|
const trainerKey = this.getKey(female);
|
|
|
|
scene.loadAtlas(trainerKey, 'trainer');
|
|
|
|
scene.load.once(Phaser.Loader.Events.COMPLETE, () => {
|
|
|
|
const originalWarn = console.warn;
|
|
|
|
// Ignore warnings for missing frames, because there will be a lot
|
|
|
|
console.warn = () => {};
|
2023-10-20 16:38:41 +01:00
|
|
|
const frameNames = scene.anims.generateFrameNames(trainerKey, { zeroPad: 4, suffix: ".png", start: 1, end: 128 });
|
2023-10-07 21:08:33 +01:00
|
|
|
console.warn = originalWarn;
|
|
|
|
scene.anims.create({
|
|
|
|
key: trainerKey,
|
|
|
|
frames: frameNames,
|
2023-10-20 16:38:41 +01:00
|
|
|
frameRate: 24,
|
2023-10-07 21:08:33 +01:00
|
|
|
repeat: -1
|
|
|
|
});
|
|
|
|
resolve();
|
|
|
|
});
|
|
|
|
if (!scene.load.isLoading())
|
|
|
|
scene.load.start();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let t = 0;
|
|
|
|
|
|
|
|
interface TrainerConfigs {
|
|
|
|
[key: integer]: TrainerConfig
|
|
|
|
}
|
|
|
|
|
2023-10-20 22:22:07 +01:00
|
|
|
function getWavePartyTemplate(scene: BattleScene, ...templates: TrainerPartyTemplate[]) {
|
2024-01-08 05:07:42 +00:00
|
|
|
return templates[Math.min(Math.max(Math.ceil(((scene.currentBattle?.waveIndex || startingWave) - 20) / 30), 0), templates.length - 1)];
|
2023-10-20 22:22:07 +01:00
|
|
|
}
|
|
|
|
|
2023-10-20 16:38:41 +01:00
|
|
|
function getGymLeaderPartyTemplate(scene: BattleScene) {
|
2024-01-08 05:07:42 +00:00
|
|
|
return getWavePartyTemplate(scene, trainerPartyTemplates.GYM_LEADER_1, trainerPartyTemplates.GYM_LEADER_2, trainerPartyTemplates.GYM_LEADER_3, trainerPartyTemplates.GYM_LEADER_4, trainerPartyTemplates.GYM_LEADER_5);
|
2023-10-20 16:38:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
function getRandomPartyMemberFunc(speciesPool: Species[], postProcess?: (enemyPokemon: EnemyPokemon) => void): PartyMemberFunc {
|
2023-10-18 23:01:15 +01:00
|
|
|
return (scene: BattleScene, level: integer) => {
|
2024-02-17 05:40:03 +00:00
|
|
|
const species = getPokemonSpecies(Utils.randSeedItem(speciesPool)).getSpeciesForLevel(level, true, true, scene.currentBattle.trainer.config.isBoss);
|
2024-01-08 04:17:24 +00:00
|
|
|
return scene.addEnemyPokemon(getPokemonSpecies(species), level, true, undefined, undefined, postProcess);
|
2023-10-18 23:01:15 +01:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
function getSpeciesFilterRandomPartyMemberFunc(speciesFilter: PokemonSpeciesFilter, allowLegendaries?: boolean, postProcess?: (EnemyPokemon: EnemyPokemon) => void): PartyMemberFunc {
|
|
|
|
const originalSpeciesFilter = speciesFilter;
|
|
|
|
speciesFilter = (species: PokemonSpecies) => allowLegendaries || (!species.legendary && !species.pseudoLegendary && !species.mythical) && originalSpeciesFilter(species);
|
|
|
|
return (scene: BattleScene, level: integer) => {
|
2024-01-08 04:17:24 +00:00
|
|
|
const ret = scene.addEnemyPokemon(getPokemonSpecies(scene.randomSpecies(scene.currentBattle.waveIndex, level, false, speciesFilter).getSpeciesForLevel(level, true, true, scene.currentBattle.trainer.config.isBoss)), level, true, undefined, undefined, postProcess);
|
2023-10-18 23:01:15 +01:00
|
|
|
return ret;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2024-02-17 05:40:03 +00:00
|
|
|
function getRandomTeraModifiers(party: EnemyPokemon[], count: integer, types?: Type[]): PersistentModifier[] {
|
|
|
|
const ret: PersistentModifier[] = [];
|
|
|
|
const partyMemberIndexes = new Array(party.length).fill(null).map((_, i) => i);
|
|
|
|
for (let t = 0; t < Math.min(count, party.length); t++) {
|
|
|
|
const randomIndex = Utils.randSeedItem(partyMemberIndexes);
|
|
|
|
partyMemberIndexes.splice(partyMemberIndexes.indexOf(randomIndex), 1);
|
|
|
|
ret.push(modifierTypes.TERA_SHARD().generateType(null, [ Utils.randSeedItem(types ? types : party[randomIndex].getTypes()) ]).withIdFromFunc(modifierTypes.TERA_SHARD).newModifier(party[randomIndex]) as PersistentModifier);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2023-10-10 01:20:02 +01:00
|
|
|
export const trainerConfigs: TrainerConfigs = {
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerType.UNKNOWN]: new TrainerConfig(0).setHasGenders(),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.ACE_TRAINER]: new TrainerConfig(++t).setHasGenders().setMoneyMultiplier(2.25).setEncounterBgm(TrainerType.ACE_TRAINER)
|
2023-10-20 22:22:07 +01:00
|
|
|
.setPartyTemplateFunc(scene => getWavePartyTemplate(scene, trainerPartyTemplates.THREE_WEAK_BALANCED, trainerPartyTemplates.FOUR_WEAK_BALANCED, trainerPartyTemplates.FIVE_WEAK_BALANCED, trainerPartyTemplates.SIX_WEAK_BALANCED)),
|
2023-12-02 06:12:32 +00:00
|
|
|
[TrainerType.ARTIST]: new TrainerConfig(++t).setEncounterBgm(TrainerType.RICH).setPartyTemplates(trainerPartyTemplates.ONE_STRONG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.THREE_AVG)
|
|
|
|
.setSpeciesPools([ Species.SMEARGLE ]),
|
2023-10-20 16:38:41 +01:00
|
|
|
[TrainerType.BACKERS]: new TrainerConfig(++t).setHasGenders().setDouble().setEncounterBgm(TrainerType.CYCLIST),
|
2023-12-08 13:15:36 +00:00
|
|
|
[TrainerType.BACKPACKER]: new TrainerConfig(++t).setHasGenders().setSpeciesFilter(s => s.isOfType(Type.FLYING) || s.isOfType(Type.ROCK)).setEncounterBgm(TrainerType.BACKPACKER)
|
|
|
|
.setPartyTemplates(trainerPartyTemplates.ONE_STRONG, trainerPartyTemplates.ONE_WEAK_ONE_STRONG, trainerPartyTemplates.ONE_AVG_ONE_STRONG)
|
|
|
|
.setSpeciesPools({
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.RHYHORN, Species.AIPOM, Species.MAKUHITA, Species.MAWILE, Species.NUMEL, Species.LILLIPUP, Species.SANDILE, Species.WOOLOO ],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.GIRAFARIG, Species.ZANGOOSE, Species.SEVIPER, Species.CUBCHOO, Species.PANCHAM, Species.SKIDDO, Species.MUDBRAY ],
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.TAUROS, Species.STANTLER, Species.DARUMAKA, Species.BOUFFALANT, Species.DEERLING, Species.IMPIDIMP ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.GALAR_DARUMAKA, Species.TEDDIURSA ]
|
2023-12-08 13:15:36 +00:00
|
|
|
}),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.BAKER]: new TrainerConfig(++t).setEncounterBgm(TrainerType.CLERK).setMoneyMultiplier(1.35).setSpeciesFilter(s => s.isOfType(Type.GRASS) || s.isOfType(Type.FIRE)),
|
|
|
|
[TrainerType.BEAUTY]: new TrainerConfig(++t).setMoneyMultiplier(1.55).setEncounterBgm(TrainerType.PARASOL_LADY),
|
|
|
|
[TrainerType.BIKER]: new TrainerConfig(++t).setMoneyMultiplier(1.4).setEncounterBgm(TrainerType.ROUGHNECK).setSpeciesFilter(s => s.isOfType(Type.POISON)),
|
2023-12-31 04:31:26 +00:00
|
|
|
[TrainerType.BLACK_BELT]: new TrainerConfig(++t).setHasGenders('Battle Girl', TrainerType.PSYCHIC).setEncounterBgm(TrainerType.ROUGHNECK).setSpecialtyTypes(Type.FIGHTING)
|
2023-12-02 06:12:32 +00:00
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_WEAK_ONE_AVG, trainerPartyTemplates.TWO_WEAK_ONE_AVG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_WEAK_ONE_STRONG, trainerPartyTemplates.THREE_AVG, trainerPartyTemplates.TWO_AVG_ONE_STRONG)
|
|
|
|
.setSpeciesPools({
|
|
|
|
[TrainerPoolTier.COMMON]: [ Species.NIDORAN_F, Species.NIDORAN_M, Species.MACHOP, Species.MAKUHITA, Species.MEDITITE, Species.CROAGUNK, Species.TIMBURR ],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.MANKEY, Species.POLIWRATH, Species.TYROGUE, Species.BRELOOM, Species.SCRAGGY, Species.MIENFOO, Species.PANCHAM, Species.STUFFUL, Species.CRABRAWLER ],
|
2023-12-28 22:49:09 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.HERACROSS, Species.RIOLU, Species.THROH, Species.SAWK, Species.PASSIMIAN, Species.CLOBBOPUS ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.HITMONTOP, Species.INFERNAPE, Species.GALLADE, Species.HAWLUCHA, Species.HAKAMO_O ],
|
2023-12-09 05:33:29 +00:00
|
|
|
[TrainerPoolTier.ULTRA_RARE]: [ Species.KUBFU ]
|
2023-12-02 06:12:32 +00:00
|
|
|
}),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.BREEDER]: new TrainerConfig(++t).setMoneyMultiplier(1.325).setEncounterBgm(TrainerType.POKEFAN).setHasGenders().setDouble()
|
2024-02-25 06:03:06 +00:00
|
|
|
.setPartyTemplateFunc(scene => getWavePartyTemplate(scene, trainerPartyTemplates.FOUR_WEAKER, trainerPartyTemplates.FIVE_WEAKER, trainerPartyTemplates.SIX_WEAKER)),
|
2023-12-02 06:12:32 +00:00
|
|
|
[TrainerType.CLERK]: new TrainerConfig(++t).setHasGenders().setEncounterBgm(TrainerType.CLERK)
|
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_WEAK, trainerPartyTemplates.THREE_WEAK, trainerPartyTemplates.ONE_AVG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_WEAK_ONE_AVG)
|
|
|
|
.setSpeciesPools({
|
2023-12-09 05:33:29 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.MEOWTH, Species.PSYDUCK, Species.BUDEW, Species.PIDOVE, Species.CINCCINO, Species.LITLEO ],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.JIGGLYPUFF, Species.MAGNEMITE, Species.MARILL, Species.COTTONEE, Species.SKIDDO ],
|
|
|
|
[TrainerPoolTier.RARE]: [ Species.BUIZEL, Species.SNEASEL, Species.KLEFKI, Species.INDEEDEE ]
|
2023-12-02 06:12:32 +00:00
|
|
|
}),
|
2023-12-31 04:31:26 +00:00
|
|
|
[TrainerType.CYCLIST]: new TrainerConfig(++t).setMoneyMultiplier(1.3).setHasGenders().setEncounterBgm(TrainerType.CYCLIST)
|
2023-12-02 06:12:32 +00:00
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_WEAK, trainerPartyTemplates.ONE_AVG)
|
|
|
|
.setSpeciesPools({
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.PICHU, Species.STARLY, Species.TAILLOW, Species.BOLTUND ],
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.DODUO, Species.ELECTRIKE, Species.BLITZLE, Species.WATTREL ],
|
2023-12-02 06:12:32 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.YANMA, Species.NINJASK, Species.WHIRLIPEDE, Species.EMOLGA ],
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.ACCELGOR, Species.DREEPY ]
|
2023-12-02 06:12:32 +00:00
|
|
|
}),
|
|
|
|
[TrainerType.DANCER]: new TrainerConfig(++t).setMoneyMultiplier(1.55).setEncounterBgm(TrainerType.CYCLIST)
|
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_WEAK, trainerPartyTemplates.ONE_AVG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_WEAK_SAME_TWO_WEAK_SAME)
|
|
|
|
.setSpeciesPools({
|
|
|
|
[TrainerPoolTier.COMMON]: [ Species.RALTS, Species.SPOINK, Species.LOTAD, Species.BUDEW ],
|
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.SPINDA, Species.SWABLU, Species.MARACTUS,],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.BELLOSSOM, Species.HITMONTOP, Species.MIME_JR, Species.ORICORIO ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.POPPLIO ]
|
2023-12-02 06:12:32 +00:00
|
|
|
}),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.DEPOT_AGENT]: new TrainerConfig(++t).setMoneyMultiplier(1.45).setEncounterBgm(TrainerType.CLERK),
|
|
|
|
[TrainerType.DOCTOR]: new TrainerConfig(++t).setMoneyMultiplier(3).setEncounterBgm(TrainerType.CLERK),
|
2023-12-31 04:31:26 +00:00
|
|
|
[TrainerType.FISHERMAN]: new TrainerConfig(++t).setMoneyMultiplier(1.25).setEncounterBgm(TrainerType.BACKPACKER).setSpecialtyTypes(Type.WATER)
|
2023-10-18 23:01:15 +01:00
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_WEAK_SAME_ONE_AVG, trainerPartyTemplates.ONE_AVG, trainerPartyTemplates.THREE_WEAK_SAME, trainerPartyTemplates.ONE_STRONG, trainerPartyTemplates.SIX_WEAKER)
|
|
|
|
.setSpeciesPools({
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.TENTACOOL, Species.MAGIKARP, Species.GOLDEEN, Species.STARYU, Species.REMORAID, Species.SKRELP, Species.CLAUNCHER, Species.ARROKUDA ],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.POLIWAG, Species.SHELLDER, Species.KRABBY, Species.HORSEA, Species.CARVANHA, Species.BARBOACH, Species.CORPHISH, Species.FINNEON, Species.TYMPOLE, Species.BASCULIN, Species.FRILLISH, Species.INKAY ],
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.CHINCHOU, Species.CORSOLA, Species.WAILMER, Species.BARBOACH, Species.CLAMPERL, Species.LUVDISC, Species.MANTYKE, Species.ALOMOMOLA, Species.TATSUGIRI, Species.VELUZA ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.LAPRAS, Species.FEEBAS, Species.RELICANTH, Species.DONDOZO ]
|
2023-12-02 06:12:32 +00:00
|
|
|
}),
|
2023-12-31 04:31:26 +00:00
|
|
|
[TrainerType.GUITARIST]: new TrainerConfig(++t).setMoneyMultiplier(1.2).setEncounterBgm(TrainerType.ROUGHNECK).setSpecialtyTypes(Type.ELECTRIC).setSpeciesFilter(s => s.isOfType(Type.ELECTRIC)),
|
2023-10-10 01:20:02 +01:00
|
|
|
[TrainerType.HARLEQUIN]: new TrainerConfig(++t).setEncounterBgm(TrainerType.PSYCHIC).setSpeciesFilter(s => tmSpecies[Moves.TRICK_ROOM].indexOf(s.speciesId) > -1),
|
2023-12-31 04:31:26 +00:00
|
|
|
[TrainerType.HIKER]: new TrainerConfig(++t).setEncounterBgm(TrainerType.BACKPACKER)
|
2023-12-08 13:15:36 +00:00
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_AVG_SAME_ONE_AVG, trainerPartyTemplates.TWO_AVG_SAME_ONE_STRONG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.FOUR_WEAK, trainerPartyTemplates.ONE_STRONG)
|
|
|
|
.setSpeciesPools({
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.SANDSHREW, Species.DIGLETT, Species.GEODUDE, Species.MACHOP, Species.ARON, Species.ROGGENROLA, Species.DRILBUR, Species.NACLI ],
|
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.ZUBAT, Species.RHYHORN, Species.ONIX, Species.CUBONE, Species.WOOBAT, Species.SWINUB, Species.NOSEPASS, Species.HIPPOPOTAS, Species.DWEBBLE, Species.KLAWF, Species.TOEDSCOOL ],
|
|
|
|
[TrainerPoolTier.RARE]: [ Species.TORKOAL, Species.TRAPINCH, Species.BARBOACH, Species.GOLETT, Species.ALOLA_DIGLETT, Species.ALOLA_GEODUDE, Species.GALAR_STUNFISK, Species.PALDEA_WOOPER ],
|
2023-12-08 13:15:36 +00:00
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.MAGBY, Species.LARVITAR ]
|
|
|
|
}),
|
2023-10-10 01:20:02 +01:00
|
|
|
[TrainerType.HOOLIGANS]: new TrainerConfig(++t).setDouble().setEncounterBgm(TrainerType.ROUGHNECK).setSpeciesFilter(s => s.isOfType(Type.POISON) || s.isOfType(Type.DARK)),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.HOOPSTER]: new TrainerConfig(++t).setMoneyMultiplier(1.2).setEncounterBgm(TrainerType.CYCLIST),
|
|
|
|
[TrainerType.INFIELDER]: new TrainerConfig(++t).setMoneyMultiplier(1.2).setEncounterBgm(TrainerType.CYCLIST),
|
|
|
|
[TrainerType.JANITOR]: new TrainerConfig(++t).setMoneyMultiplier(1.1).setEncounterBgm(TrainerType.CLERK),
|
|
|
|
[TrainerType.LINEBACKER]: new TrainerConfig(++t).setMoneyMultiplier(1.2).setEncounterBgm(TrainerType.CYCLIST),
|
2023-12-05 22:12:39 +00:00
|
|
|
[TrainerType.MAID]: new TrainerConfig(++t).setMoneyMultiplier(1.6).setEncounterBgm(TrainerType.RICH),
|
2023-11-04 04:32:12 +00:00
|
|
|
[TrainerType.MUSICIAN]: new TrainerConfig(++t).setEncounterBgm(TrainerType.ROUGHNECK).setSpeciesFilter(s => !!s.getLevelMoves().find(plm => plm[1] === Moves.SING)),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.NURSE]: new TrainerConfig(++t).setMoneyMultiplier(1.8).setEncounterBgm('lass').setSpeciesFilter(s => !!s.getLevelMoves().find(plm => plm[1] === Moves.CHARM) || !!s.getLevelMoves().find(plm => plm[1] === Moves.HEAL_PULSE)),
|
|
|
|
[TrainerType.NURSERY_AIDE]: new TrainerConfig(++t).setMoneyMultiplier(1.3).setEncounterBgm('lass'),
|
2023-12-02 06:12:32 +00:00
|
|
|
[TrainerType.OFFICER]: new TrainerConfig(++t).setMoneyMultiplier(1.55).setEncounterBgm(TrainerType.CLERK)
|
2023-12-21 00:19:23 +00:00
|
|
|
.setPartyTemplates(trainerPartyTemplates.ONE_AVG, trainerPartyTemplates.ONE_STRONG, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_WEAK_SAME_ONE_AVG)
|
2023-12-03 01:56:53 +00:00
|
|
|
.setSpeciesPools({
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.VULPIX, Species.GROWLITHE, Species.SNUBBULL, Species.POOCHYENA, Species.ELECTRIKE, Species.LILLIPUP, Species.YAMPER, Species.FIDOUGH ],
|
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.HOUNDOUR, Species.ROCKRUFF, Species.MASCHIFF ],
|
2023-12-02 06:12:32 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.JOLTEON, Species.RIOLU ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [],
|
|
|
|
[TrainerPoolTier.ULTRA_RARE]: [ Species.ENTEI, Species.SUICUNE, Species.RAIKOU ]
|
|
|
|
}),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.PARASOL_LADY]: new TrainerConfig(++t).setMoneyMultiplier(1.55).setEncounterBgm(TrainerType.PARASOL_LADY).setSpeciesFilter(s => s.isOfType(Type.WATER)),
|
2023-10-10 01:20:02 +01:00
|
|
|
[TrainerType.PILOT]: new TrainerConfig(++t).setEncounterBgm(TrainerType.CLERK).setSpeciesFilter(s => tmSpecies[Moves.FLY].indexOf(s.speciesId) > -1),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.POKEFAN]: new TrainerConfig(++t).setMoneyMultiplier(1.4).setHasGenders().setEncounterBgm(TrainerType.POKEFAN)
|
2023-12-03 01:59:47 +00:00
|
|
|
.setPartyTemplates(trainerPartyTemplates.SIX_WEAKER, trainerPartyTemplates.FOUR_WEAK, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.ONE_STRONG, trainerPartyTemplates.FOUR_WEAK_SAME, trainerPartyTemplates.FIVE_WEAK, trainerPartyTemplates.SIX_WEAKER_SAME),
|
2023-12-03 01:56:53 +00:00
|
|
|
[TrainerType.PRESCHOOLER]: new TrainerConfig(++t).setMoneyMultiplier(0.2).setEncounterBgm(TrainerType.YOUNGSTER).setHasGenders(undefined, 'lass')
|
|
|
|
.setPartyTemplates(trainerPartyTemplates.THREE_WEAK, trainerPartyTemplates.FOUR_WEAKER, trainerPartyTemplates.TWO_WEAK_SAME_ONE_AVG, trainerPartyTemplates.FIVE_WEAKER)
|
|
|
|
.setSpeciesPools({
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.CATERPIE, Species.PICHU, Species.SANDSHREW, Species.LEDYBA, Species.BUDEW, Species.BURMY, Species.WOOLOO, Species.PAWMI, Species.SMOLIV ],
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.EEVEE, Species.CLEFFA, Species.IGGLYBUFF, Species.SWINUB, Species.WOOPER, Species.DRIFLOON, Species.DEDENNE, Species.STUFFUL ],
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.RALTS, Species.RIOLU, Species.JOLTIK, Species.TANDEMAUS ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.DARUMAKA, Species.TINKATINK ],
|
2023-12-03 01:56:53 +00:00
|
|
|
}),
|
|
|
|
[TrainerType.PSYCHIC]: new TrainerConfig(++t).setHasGenders().setMoneyMultiplier(1.4).setEncounterBgm(TrainerType.PSYCHIC)
|
|
|
|
.setPartyTemplates(trainerPartyTemplates.TWO_WEAK, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_WEAK_SAME_ONE_AVG, trainerPartyTemplates.TWO_WEAK_SAME_TWO_WEAK_SAME, trainerPartyTemplates.ONE_STRONGER)
|
|
|
|
.setSpeciesPools({
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.ABRA, Species.DROWZEE, Species.RALTS, Species.SPOINK, Species.GOTHITA, Species.SOLOSIS, Species.BLIPBUG, Species.ESPURR, Species.HATENNA ],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.MIME_JR, Species.EXEGGCUTE, Species.MEDITITE, Species.NATU, Species.EXEGGCUTE, Species.WOOBAT, Species.INKAY, Species.ORANGURU ],
|
2023-12-09 05:33:29 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.ELGYEM, Species.SIGILYPH, Species.BALTOY, Species.GIRAFARIG, Species.MEOWSTIC ],
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.BELDUM, Species.ESPEON, Species.WYRDEER ],
|
2023-12-03 01:56:53 +00:00
|
|
|
}),
|
2023-12-09 05:33:29 +00:00
|
|
|
[TrainerType.RANGER]: new TrainerConfig(++t).setMoneyMultiplier(1.4).setEncounterBgm(TrainerType.BACKPACKER).setHasGenders()
|
|
|
|
.setSpeciesPools({
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.COMMON]: [ Species.PICHU, Species.GROWLITHE, Species.PONYTA, Species.ZIGZAGOON, Species.SEEDOT, Species.BIDOOF, Species.RIOLU, Species.SEWADDLE, Species.SKIDDO, Species.SALANDIT, Species.YAMPER ],
|
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.AZURILL, Species.TAUROS, Species.MAREEP, Species.FARFETCHD, Species.TEDDIURSA, Species.SHROOMISH, Species.ELECTRIKE, Species.BUDEW, Species.BUIZEL, Species.MUDBRAY, Species.STUFFUL ],
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.EEVEE, Species.SCYTHER, Species.KANGASKHAN, Species.RALTS, Species.MUNCHLAX, Species.ZORUA, Species.PALDEA_TAUROS, Species.TINKATINK, Species.CYCLIZAR, Species.FLAMIGO ],
|
2023-12-09 05:33:29 +00:00
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.LARVESTA ],
|
|
|
|
}),
|
2023-12-05 22:12:39 +00:00
|
|
|
[TrainerType.RICH]: new TrainerConfig(++t).setMoneyMultiplier(5).setName('Gentleman').setHasGenders(),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.RICH_KID]: new TrainerConfig(++t).setMoneyMultiplier(3.75).setName('Rich Boy').setHasGenders('Lady').setEncounterBgm(TrainerType.RICH),
|
|
|
|
[TrainerType.ROUGHNECK]: new TrainerConfig(++t).setMoneyMultiplier(1.4).setEncounterBgm(TrainerType.ROUGHNECK).setSpeciesFilter(s => s.isOfType(Type.DARK)),
|
2023-12-02 06:12:32 +00:00
|
|
|
[TrainerType.SCIENTIST]: new TrainerConfig(++t).setHasGenders().setMoneyMultiplier(1.7).setEncounterBgm(TrainerType.SCIENTIST)
|
|
|
|
.setSpeciesPools({
|
|
|
|
[TrainerPoolTier.COMMON]: [ Species.MAGNEMITE, Species.GRIMER, Species.DROWZEE, Species.VOLTORB, Species.KOFFING ],
|
2023-12-12 20:32:50 +00:00
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.BALTOY, Species.BRONZOR, Species.FERROSEED, Species.KLINK, Species.CHARJABUG, Species.BLIPBUG, Species.HELIOPTILE ],
|
2023-12-28 22:49:09 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.ABRA, Species.DITTO, Species.PORYGON, Species.ELEKID, Species.SOLOSIS, Species.GALAR_WEEZING ],
|
|
|
|
[TrainerPoolTier.SUPER_RARE]: [ Species.OMANYTE, Species.KABUTO, Species.AERODACTYL, Species.LILEEP, Species.ANORITH, Species.CRANIDOS, Species.SHIELDON, Species.TIRTOUGA, Species.ARCHEN, Species.ARCTOVISH, Species.ARCTOZOLT, Species.DRACOVISH, Species.DRACOZOLT ],
|
2023-12-14 05:41:35 +00:00
|
|
|
[TrainerPoolTier.ULTRA_RARE]: [ Species.ROTOM, Species.MELTAN ]
|
2023-12-02 06:12:32 +00:00
|
|
|
}),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.SMASHER]: new TrainerConfig(++t).setMoneyMultiplier(1.2).setEncounterBgm(TrainerType.CYCLIST),
|
|
|
|
[TrainerType.SNOW_WORKER]: new TrainerConfig(++t).setName('Worker').setMoneyMultiplier(1.7).setEncounterBgm(TrainerType.CLERK).setSpeciesFilter(s => s.isOfType(Type.ICE) || s.isOfType(Type.STEEL)),
|
|
|
|
[TrainerType.STRIKER]: new TrainerConfig(++t).setMoneyMultiplier(1.2).setEncounterBgm(TrainerType.CYCLIST),
|
2023-10-07 21:08:33 +01:00
|
|
|
[TrainerType.STUDENT]: new TrainerConfig(++t).setHasGenders(),
|
2023-12-31 04:31:26 +00:00
|
|
|
[TrainerType.SWIMMER]: new TrainerConfig(++t).setMoneyMultiplier(1.3).setEncounterBgm(TrainerType.PARASOL_LADY).setHasGenders().setSpecialtyTypes(Type.WATER).setSpeciesFilter(s => s.isOfType(Type.WATER)),
|
2023-12-08 13:15:36 +00:00
|
|
|
[TrainerType.TWINS]: new TrainerConfig(++t).setDouble().setMoneyMultiplier(0.65).setUseSameSeedForAllMembers()
|
2023-12-03 01:56:53 +00:00
|
|
|
.setPartyTemplateFunc(scene => getWavePartyTemplate(scene, trainerPartyTemplates.TWO_WEAK, trainerPartyTemplates.TWO_AVG, trainerPartyTemplates.TWO_STRONG))
|
2023-12-08 13:15:36 +00:00
|
|
|
.setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.PLUSLE, Species.VOLBEAT, Species.PACHIRISU, Species.SILCOON, Species.METAPOD, Species.IGGLYBUFF, Species.PETILIL, Species.EEVEE ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.MINUN, Species.ILLUMISE, Species.EMOLGA, Species.CASCOON, Species.KAKUNA, Species.CLEFFA, Species.COTTONEE, Species.EEVEE ]))
|
2023-11-10 20:51:34 +00:00
|
|
|
.setEncounterBgm(TrainerType.TWINS),
|
|
|
|
[TrainerType.VETERAN]: new TrainerConfig(++t).setHasGenders().setMoneyMultiplier(2.5).setEncounterBgm(TrainerType.RICH),
|
2023-12-28 22:49:09 +00:00
|
|
|
[TrainerType.WAITER]: new TrainerConfig(++t).setMoneyMultiplier(1.5).setHasGenders('Waitress').setEncounterBgm(TrainerType.CLERK)
|
|
|
|
.setSpeciesPools({
|
|
|
|
[TrainerPoolTier.COMMON]: [ Species.CLEFFA, Species.CHATOT, Species.PANSAGE, Species.PANSEAR, Species.PANPOUR, Species.MINCCINO ],
|
|
|
|
[TrainerPoolTier.UNCOMMON]: [ Species.TROPIUS, Species.PETILIL, Species.BOUNSWEET, Species.INDEEDEE ],
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerPoolTier.RARE]: [ Species.APPLIN, Species.SINISTEA, Species.POLTCHAGEIST ]
|
2023-12-28 22:49:09 +00:00
|
|
|
}),
|
2023-11-10 20:51:34 +00:00
|
|
|
[TrainerType.WORKER]: new TrainerConfig(++t).setEncounterBgm(TrainerType.CLERK).setMoneyMultiplier(1.7).setSpeciesFilter(s => s.isOfType(Type.ROCK) || s.isOfType(Type.STEEL)),
|
|
|
|
[TrainerType.YOUNGSTER]: new TrainerConfig(++t).setMoneyMultiplier(0.5).setEncounterBgm(TrainerType.YOUNGSTER).setHasGenders('Lass', 'lass').setPartyTemplates(trainerPartyTemplates.TWO_WEAKER)
|
2023-10-20 16:48:19 +01:00
|
|
|
.setSpeciesPools(
|
|
|
|
[ Species.CATERPIE, Species.WEEDLE, Species.RATTATA, Species.SENTRET, Species.POOCHYENA, Species.ZIGZAGOON, Species.WURMPLE, Species.BIDOOF, Species.PATRAT, Species.LILLIPUP ]
|
2024-01-13 17:24:24 +00:00
|
|
|
),
|
2024-03-06 23:55:55 +00:00
|
|
|
[TrainerType.BROCK]: new TrainerConfig((t = TrainerType.BROCK)).initForGymLeader([ Species.GEODUDE, Species.ONIX ], Type.ROCK).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.MISTY]: new TrainerConfig(++t).initForGymLeader([ Species.STARYU, Species.PSYDUCK ], Type.WATER).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.LT_SURGE]: new TrainerConfig(++t).initForGymLeader([ Species.VOLTORB, Species.PIKACHU, Species.ELECTABUZZ ], Type.ELECTRIC).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.ERIKA]: new TrainerConfig(++t).initForGymLeader([ Species.ODDISH, Species.BELLSPROUT, Species.TANGELA, Species.HOPPIP ], Type.GRASS).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.JANINE]: new TrainerConfig(++t).initForGymLeader([ Species.VENONAT, Species.SPINARAK, Species.ZUBAT ], Type.POISON).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.SABRINA]: new TrainerConfig(++t).initForGymLeader([ Species.ABRA, Species.MR_MIME, Species.ESPEON ], Type.PSYCHIC).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.BLAINE]: new TrainerConfig(++t).initForGymLeader([ Species.GROWLITHE, Species.PONYTA, Species.MAGMAR ], Type.FIRE).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.GIOVANNI]: new TrainerConfig(++t).initForGymLeader([ Species.SANDILE, Species.MURKROW, Species.NIDORAN_M, Species.NIDORAN_F ], Type.DARK).setBattleBgm('battle_kanto_gym'),
|
|
|
|
[TrainerType.FALKNER]: new TrainerConfig(++t).initForGymLeader([ Species.PIDGEY, Species.HOOTHOOT, Species.DODUO ], Type.FLYING).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.BUGSY]: new TrainerConfig(++t).initForGymLeader([ Species.SCYTHER, Species.HERACROSS, Species.SHUCKLE, Species.PINSIR ], Type.BUG).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.WHITNEY]: new TrainerConfig(++t).initForGymLeader([ Species.CLEFAIRY, Species.MILTANK ], Type.NORMAL).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.MORTY]: new TrainerConfig(++t).initForGymLeader([ Species.GASTLY, Species.MISDREAVUS, Species.SABLEYE ], Type.GHOST).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.CHUCK]: new TrainerConfig(++t).initForGymLeader([ Species.POLIWRATH, ], Type.FIGHTING).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.JASMINE]: new TrainerConfig(++t).initForGymLeader([ Species.MAGNEMITE, Species.STEELIX ], Type.STEEL).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.PRYCE]: new TrainerConfig(++t).initForGymLeader([ Species.SEEL, Species.SWINUB ], Type.ICE).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.CLAIR]: new TrainerConfig(++t).initForGymLeader([ Species.DRATINI, Species.HORSEA, Species.GYARADOS ], Type.DRAGON).setBattleBgm('battle_johto_gym'),
|
|
|
|
[TrainerType.ROXANNE]: new TrainerConfig(++t).initForGymLeader([ Species.GEODUDE, Species.NOSEPASS ], Type.ROCK).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.BRAWLY]: new TrainerConfig(++t).initForGymLeader([ Species.MACHOP, Species.MAKUHITA ], Type.FIGHTING).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.WATTSON]: new TrainerConfig(++t).initForGymLeader([ Species.MAGNEMITE, Species.VOLTORB, Species.ELECTRIKE ], Type.ELECTRIC).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.FLANNERY]: new TrainerConfig(++t).initForGymLeader([ Species.SLUGMA, Species.TORKOAL, Species.NUMEL ], Type.FIRE).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.NORMAN]: new TrainerConfig(++t).initForGymLeader([ Species.SLAKOTH, Species.SPINDA, Species.CHANSEY, Species.KANGASKHAN ], Type.NORMAL).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.WINONA]: new TrainerConfig(++t).initForGymLeader([ Species.SWABLU, Species.WINGULL, Species.TROPIUS, Species.SKARMORY ], Type.FLYING).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.TATE]: new TrainerConfig(++t).initForGymLeader([ Species.SOLROCK, Species.NATU, Species.CHIMECHO, Species.GALLADE ], Type.PSYCHIC).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.LIZA]: new TrainerConfig(++t).initForGymLeader([ Species.LUNATONE, Species.SPOINK, Species.BALTOY, Species.GARDEVOIR ], Type.PSYCHIC).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.JUAN]: new TrainerConfig(++t).initForGymLeader([ Species.HORSEA, Species.BARBOACH, Species.SPHEAL, Species.RELICANTH ], Type.WATER).setBattleBgm('battle_hoenn_gym'),
|
|
|
|
[TrainerType.ROARK]: new TrainerConfig(++t).initForGymLeader([ Species.CRANIDOS, Species.LARVITAR, Species.GEODUDE ], Type.ROCK).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.GARDENIA]: new TrainerConfig(++t).initForGymLeader([ Species.ROSELIA, Species.TANGELA, Species.TURTWIG ], Type.GRASS).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.MAYLENE]: new TrainerConfig(++t).initForGymLeader([ Species.LUCARIO, Species.MEDITITE, Species.CHIMCHAR ], Type.FIGHTING).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.CRASHER_WAKE]: new TrainerConfig(++t).initForGymLeader([ Species.BUIZEL, Species.MAGIKARP, Species.PIPLUP ], Type.WATER).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.FANTINA]: new TrainerConfig(++t).initForGymLeader([ Species.MISDREAVUS, Species.DRIFLOON, Species.SPIRITOMB ], Type.GHOST).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.BYRON]: new TrainerConfig(++t).initForGymLeader([ Species.SHIELDON, Species.BRONZOR, Species.AGGRON ], Type.STEEL).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.CANDICE]: new TrainerConfig(++t).initForGymLeader([ Species.SNEASEL, Species.SNOVER, Species.SNORUNT ], Type.ICE).setBattleBgm('battle_sinnoh_gym'),
|
|
|
|
[TrainerType.VOLKNER]: new TrainerConfig(++t).initForGymLeader([ Species.SHINX, Species.CHINCHOU, Species.ROTOM ], Type.ELECTRIC).setBattleBgm('battle_sinnoh_gym'),
|
2024-01-05 00:37:07 +00:00
|
|
|
[TrainerType.CILAN]: new TrainerConfig(++t).initForGymLeader([ Species.PANSAGE, Species.COTTONEE, Species.PETILIL ], Type.GRASS),
|
|
|
|
[TrainerType.CHILI]: new TrainerConfig(++t).initForGymLeader([ Species.PANSEAR, Species.DARUMAKA, Species.HEATMOR ], Type.FIRE),
|
|
|
|
[TrainerType.CRESS]: new TrainerConfig(++t).initForGymLeader([ Species.PANPOUR, Species.BASCULIN, Species.TYMPOLE ], Type.WATER),
|
|
|
|
[TrainerType.CHEREN]: new TrainerConfig(++t).initForGymLeader([ Species.LILLIPUP, Species.MINCCINO, Species.PATRAT ], Type.NORMAL),
|
|
|
|
[TrainerType.LENORA]: new TrainerConfig(++t).initForGymLeader([ Species.KANGASKHAN, Species.DEERLING, Species.AUDINO ], Type.NORMAL),
|
|
|
|
[TrainerType.ROXIE]: new TrainerConfig(++t).initForGymLeader([ Species.VENIPEDE, Species.TRUBBISH, Species.SKORUPI ], Type.POISON),
|
|
|
|
[TrainerType.BURGH]: new TrainerConfig(++t).initForGymLeader([ Species.SEWADDLE, Species.SHELMET, Species.KARRABLAST ], Type.BUG),
|
|
|
|
[TrainerType.ELESA]: new TrainerConfig(++t).initForGymLeader([ Species.EMOLGA, Species.BLITZLE, Species.JOLTIK ], Type.ELECTRIC),
|
|
|
|
[TrainerType.CLAY]: new TrainerConfig(++t).initForGymLeader([ Species.DRILBUR, Species.SANDILE, Species.GOLETT ], Type.GROUND),
|
|
|
|
[TrainerType.SKYLA]: new TrainerConfig(++t).initForGymLeader([ Species.DUCKLETT, Species.WOOBAT, Species.RUFFLET ], Type.FLYING),
|
|
|
|
[TrainerType.BRYCEN]: new TrainerConfig(++t).initForGymLeader([ Species.CRYOGONAL, Species.VANILLITE, Species.CUBCHOO ], Type.ICE),
|
|
|
|
[TrainerType.DRAYDEN]: new TrainerConfig(++t).initForGymLeader([ Species.DRUDDIGON, Species.AXEW, Species.DEINO ], Type.DRAGON),
|
|
|
|
[TrainerType.MARLON]: new TrainerConfig(++t).initForGymLeader([ Species.WAILMER, Species.FRILLISH, Species.TIRTOUGA ], Type.WATER),
|
|
|
|
[TrainerType.VIOLA]: new TrainerConfig(++t).initForGymLeader([ Species.SURSKIT, Species.SCATTERBUG ], Type.BUG),
|
|
|
|
[TrainerType.GRANT]: new TrainerConfig(++t).initForGymLeader([ Species.AMAURA, Species.TYRUNT ], Type.ROCK),
|
|
|
|
[TrainerType.KORRINA]: new TrainerConfig(++t).initForGymLeader([ Species.HAWLUCHA, Species.LUCARIO, Species.MIENFOO ], Type.FIGHTING),
|
|
|
|
[TrainerType.RAMOS]: new TrainerConfig(++t).initForGymLeader([ Species.SKIDDO, Species.HOPPIP, Species.BELLSPROUT ], Type.GRASS),
|
|
|
|
[TrainerType.CLEMONT]: new TrainerConfig(++t).initForGymLeader([ Species.HELIOPTILE, Species.MAGNEMITE, Species.EMOLGA ], Type.ELECTRIC),
|
|
|
|
[TrainerType.VALERIE]: new TrainerConfig(++t).initForGymLeader([ Species.SYLVEON, Species.MAWILE, Species.MR_MIME ], Type.FAIRY),
|
|
|
|
[TrainerType.OLYMPIA]: new TrainerConfig(++t).initForGymLeader([ Species.ESPURR, Species.SIGILYPH, Species.SLOWKING ], Type.PSYCHIC),
|
|
|
|
[TrainerType.WULFRIC]: new TrainerConfig(++t).initForGymLeader([ Species.BERGMITE, Species.SNOVER, Species.CRYOGONAL ], Type.ICE),
|
|
|
|
[TrainerType.MILO]: new TrainerConfig(++t).initForGymLeader([ Species.GOSSIFLEUR, Species.APPLIN, Species.BOUNSWEET ], Type.GRASS),
|
|
|
|
[TrainerType.NESSA]: new TrainerConfig(++t).initForGymLeader([ Species.CHEWTLE, Species.ARROKUDA, Species.WIMPOD ], Type.WATER),
|
|
|
|
[TrainerType.KABU]: new TrainerConfig(++t).initForGymLeader([ Species.SIZZLIPEDE, Species.VULPIX, Species.TORKOAL ], Type.FIRE),
|
|
|
|
[TrainerType.BEA]: new TrainerConfig(++t).initForGymLeader([ Species.GALAR_FARFETCHD, Species.MACHOP, Species.CLOBBOPUS ], Type.FIGHTING),
|
|
|
|
[TrainerType.ALLISTER]: new TrainerConfig(++t).initForGymLeader([ Species.GALAR_YAMASK, Species.GALAR_CORSOLA, Species.GASTLY ], Type.GHOST),
|
|
|
|
[TrainerType.OPAL]: new TrainerConfig(++t).initForGymLeader([ Species.MILCERY, Species.TOGETIC, Species.GALAR_WEEZING ], Type.FAIRY),
|
|
|
|
[TrainerType.BEDE]: new TrainerConfig(++t).initForGymLeader([ Species.HATENNA, Species.GALAR_PONYTA, Species.GARDEVOIR ], Type.FAIRY),
|
|
|
|
[TrainerType.GORDIE]: new TrainerConfig(++t).initForGymLeader([ Species.ROLYCOLY, Species.STONJOURNER, Species.BINACLE ], Type.ROCK),
|
|
|
|
[TrainerType.MELONY]: new TrainerConfig(++t).initForGymLeader([ Species.SNOM, Species.GALAR_DARUMAKA, Species.GALAR_MR_MIME ], Type.ICE),
|
|
|
|
[TrainerType.PIERS]: new TrainerConfig(++t).initForGymLeader([ Species.GALAR_ZIGZAGOON, Species.SCRAGGY, Species.INKAY ], Type.DARK),
|
|
|
|
[TrainerType.MARNIE]: new TrainerConfig(++t).initForGymLeader([ Species.IMPIDIMP, Species.PURRLOIN, Species.MORPEKO ], Type.DARK),
|
|
|
|
[TrainerType.RAIHAN]: new TrainerConfig(++t).initForGymLeader([ Species.DURALUDON, Species.TURTONATOR, Species.GOOMY ], Type.DRAGON),
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerType.KATY]: new TrainerConfig(++t).initForGymLeader([ Species.NYMBLE, Species.TAROUNTULA, Species.HERACROSS ], Type.BUG),
|
2024-01-05 00:37:07 +00:00
|
|
|
[TrainerType.BRASSIUS]: new TrainerConfig(++t).initForGymLeader([ Species.SMOLIV, Species.SHROOMISH, Species.ODDISH ], Type.GRASS),
|
|
|
|
[TrainerType.IONO]: new TrainerConfig(++t).initForGymLeader([ Species.TADBULB, Species.WATTREL, Species.VOLTORB ], Type.ELECTRIC),
|
|
|
|
[TrainerType.KOFU]: new TrainerConfig(++t).initForGymLeader([ Species.VELUZA, Species.WIGLETT, Species.WINGULL ], Type.WATER),
|
|
|
|
[TrainerType.LARRY]: new TrainerConfig(++t).initForGymLeader([ Species.STARLY, Species.DUNSPARCE, Species.KOMALA ], Type.NORMAL),
|
|
|
|
[TrainerType.RYME]: new TrainerConfig(++t).initForGymLeader([ Species.GREAVARD, Species.SHUPPET, Species.MIMIKYU ], Type.GHOST),
|
|
|
|
[TrainerType.TULIP]: new TrainerConfig(++t).initForGymLeader([ Species.GIRAFARIG, Species.FLITTLE, Species.RALTS ], Type.PSYCHIC),
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerType.GRUSHA]: new TrainerConfig(++t).initForGymLeader([ Species.CETODDLE, Species.ALOLA_VULPIX, Species.CUBCHOO ], Type.ICE),
|
2023-12-14 05:41:35 +00:00
|
|
|
|
2024-01-05 00:37:07 +00:00
|
|
|
[TrainerType.LORELEI]: new TrainerConfig((t = TrainerType.LORELEI)).initForEliteFour([ Species.SLOWBRO, Species.LAPRAS, Species.DEWGONG, Species.ALOLA_SANDSLASH ], Type.ICE),
|
|
|
|
[TrainerType.BRUNO]: new TrainerConfig(++t).initForEliteFour([ Species.ONIX, Species.HITMONCHAN, Species.HITMONLEE, Species.ALOLA_GOLEM ], Type.FIGHTING),
|
|
|
|
[TrainerType.AGATHA]: new TrainerConfig(++t).initForEliteFour([ Species.GENGAR, Species.ARBOK, Species.CROBAT, Species.ALOLA_MAROWAK ], Type.GHOST),
|
|
|
|
[TrainerType.LANCE]: new TrainerConfig(++t).initForEliteFour([ Species.DRAGONITE, Species.GYARADOS, Species.AERODACTYL, Species.ALOLA_EXEGGUTOR ], Type.DRAGON),
|
|
|
|
[TrainerType.WILL]: new TrainerConfig(++t).initForEliteFour([ Species.XATU, Species.JYNX, Species.SLOWBRO, Species.EXEGGUTOR ], Type.PSYCHIC),
|
|
|
|
[TrainerType.KOGA]: new TrainerConfig(++t).initForEliteFour([ Species.WEEZING, Species.VENOMOTH, Species.CROBAT, Species.TENTACRUEL ], Type.POISON),
|
|
|
|
[TrainerType.KAREN]: new TrainerConfig(++t).initForEliteFour([ Species.UMBREON, Species.HONCHKROW, Species.HOUNDOOM, Species.WEAVILE ], Type.DARK),
|
|
|
|
[TrainerType.SIDNEY]: new TrainerConfig(++t).initForEliteFour([ Species.SHIFTRY, Species.SHARPEDO, Species.ABSOL, Species.ZOROARK ], Type.DARK),
|
|
|
|
[TrainerType.PHOEBE]: new TrainerConfig(++t).initForEliteFour([ Species.SABLEYE, Species.DUSKNOIR, Species.BANETTE, Species.CHANDELURE ], Type.GHOST),
|
|
|
|
[TrainerType.GLACIA]: new TrainerConfig(++t).initForEliteFour([ Species.GLALIE, Species.WALREIN, Species.FROSLASS, Species.ABOMASNOW ], Type.ICE),
|
|
|
|
[TrainerType.DRAKE]: new TrainerConfig(++t).initForEliteFour([ Species.ALTARIA, Species.SALAMENCE, Species.FLYGON, Species.KINGDRA ], Type.DRAGON),
|
|
|
|
[TrainerType.AARON]: new TrainerConfig(++t).initForEliteFour([ Species.SCIZOR, Species.HERACROSS, Species.VESPIQUEN, Species.DRAPION ], Type.BUG),
|
|
|
|
[TrainerType.BERTHA]: new TrainerConfig(++t).initForEliteFour([ Species.WHISCASH, Species.HIPPOWDON, Species.GLISCOR, Species.RHYPERIOR ], Type.GROUND),
|
|
|
|
[TrainerType.FLINT]: new TrainerConfig(++t).initForEliteFour([ Species.FLAREON, Species.HOUNDOOM, Species.RAPIDASH, Species.INFERNAPE ], Type.FIRE),
|
|
|
|
[TrainerType.LUCIAN]: new TrainerConfig(++t).initForEliteFour([ Species.MR_MIME, Species.GALLADE, Species.BRONZONG, Species.ALAKAZAM ], Type.PSYCHIC),
|
|
|
|
[TrainerType.SHAUNTAL]: new TrainerConfig(++t).initForEliteFour([ Species.COFAGRIGUS, Species.CHANDELURE, Species.GOLURK, Species.DRIFBLIM ], Type.GHOST),
|
|
|
|
[TrainerType.MARSHAL]: new TrainerConfig(++t).initForEliteFour([ Species.TIMBURR, Species.MIENFOO, Species.THROH, Species.SAWK ], Type.FIGHTING),
|
|
|
|
[TrainerType.GRIMSLEY]: new TrainerConfig(++t).initForEliteFour([ Species.LIEPARD, Species.KINGAMBIT, Species.SCRAFTY, Species.KROOKODILE ], Type.DARK),
|
|
|
|
[TrainerType.CAITLIN]: new TrainerConfig(++t).initForEliteFour([ Species.MUSHARNA, Species.GOTHITELLE, Species.SIGILYPH, Species.REUNICLUS ], Type.PSYCHIC),
|
|
|
|
[TrainerType.MALVA]: new TrainerConfig(++t).initForEliteFour([ Species.PYROAR, Species.TORKOAL, Species.CHANDELURE, Species.TALONFLAME ], Type.FIRE),
|
|
|
|
[TrainerType.SIEBOLD]: new TrainerConfig(++t).initForEliteFour([ Species.CLAWITZER, Species.GYARADOS, Species.BARBARACLE, Species.STARMIE ], Type.WATER),
|
|
|
|
[TrainerType.WIKSTROM]: new TrainerConfig(++t).initForEliteFour([ Species.KLEFKI, Species.PROBOPASS, Species.SCIZOR, Species.AEGISLASH ], Type.STEEL),
|
|
|
|
[TrainerType.DRASNA]: new TrainerConfig(++t).initForEliteFour([ Species.DRAGALGE, Species.DRUDDIGON, Species.ALTARIA, Species.NOIVERN ], Type.DRAGON),
|
|
|
|
[TrainerType.HALA]: new TrainerConfig(++t).initForEliteFour([ Species.HARIYAMA, Species.BEWEAR, Species.CRABOMINABLE, Species.POLIWRATH ], Type.FIGHTING),
|
|
|
|
[TrainerType.MOLAYNE]: new TrainerConfig(++t).initForEliteFour([ Species.KLEFKI, Species.MAGNEZONE, Species.METAGROSS, Species.ALOLA_DUGTRIO ], Type.PSYCHIC),
|
|
|
|
[TrainerType.OLIVIA]: new TrainerConfig(++t).initForEliteFour([ Species.ARMALDO, Species.CRADILY, Species.ALOLA_GOLEM, Species.LYCANROC ], Type.ROCK),
|
|
|
|
[TrainerType.ACEROLA]: new TrainerConfig(++t).initForEliteFour([ Species.BANETTE, Species.DRIFBLIM, Species.DHELMISE, Species.PALOSSAND ], Type.GHOST),
|
|
|
|
[TrainerType.KAHILI]: new TrainerConfig(++t).initForEliteFour([ Species.BRAVIARY, Species.HAWLUCHA, Species.ORICORIO, Species.TOUCANNON ], Type.FLYING),
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerType.RIKA]: new TrainerConfig(++t).initForEliteFour([ Species. WHISCASH, Species.DONPHAN, Species.CAMERUPT, Species.CLODSIRE ], Type.GROUND),
|
2024-01-05 00:37:07 +00:00
|
|
|
[TrainerType.POPPY]: new TrainerConfig(++t).initForEliteFour([ Species.COPPERAJAH, Species.BRONZONG, Species.CORVIKNIGHT, Species.TINKATON ], Type.STEEL),
|
|
|
|
[TrainerType.LARRY_ELITE]: new TrainerConfig(++t).initForEliteFour([ Species.STARAPTOR, Species.FLAMIGO, Species.ALTARIA, Species.TROPIUS ], Type.NORMAL, Type.FLYING),
|
|
|
|
[TrainerType.HASSEL]: new TrainerConfig(++t).initForEliteFour([ Species.NOIVERN, Species.HAXORUS, Species.DRAGALGE, Species.BAXCALIBUR ], Type.DRAGON),
|
|
|
|
[TrainerType.CRISPIN]: new TrainerConfig(++t).initForEliteFour([ Species.TALONFLAME, Species.CAMERUPT, Species.MAGMORTAR, Species.BLAZIKEN ], Type.FIRE),
|
|
|
|
[TrainerType.AMARYS]: new TrainerConfig(++t).initForEliteFour([ Species.SKARMORY, Species.EMPOLEON, Species.SCIZOR, Species.METAGROSS ], Type.STEEL),
|
|
|
|
[TrainerType.LACEY]: new TrainerConfig(++t).initForEliteFour([ Species.EXCADRILL, Species.PRIMARINA, Species.ALCREMIE, Species.GALAR_SLOWBRO ], Type.FAIRY),
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerType.DRAYTON]: new TrainerConfig(++t).initForEliteFour([ Species.DRAGONITE, Species.ARCHALUDON, Species.FLYGON, Species.SCEPTILE ], Type.DRAGON),
|
2024-01-05 00:37:07 +00:00
|
|
|
|
2024-03-06 23:55:55 +00:00
|
|
|
[TrainerType.BLUE]: new TrainerConfig((t = TrainerType.BLUE)).initForChampion([ Species.GYARADOS, Species.MEWTWO, Species.ARCANINE, Species.ALAKAZAM, Species.PIDGEOT ]).setBattleBgm('battle_kanto_champion'),
|
|
|
|
[TrainerType.RED]: new TrainerConfig(++t).initForChampion([ Species.CHARIZARD, [ Species.LUGIA, Species.HO_OH ], Species.SNORLAX, Species.RAICHU, Species.ESPEON ]).setBattleBgm('battle_johto_champion'),
|
|
|
|
[TrainerType.LANCE_CHAMPION]: new TrainerConfig(++t).initForChampion([ Species.DRAGONITE, [ Species.ZACIAN, Species.ZAMAZENTA ], Species.AERODACTYL, Species.KINGDRA, Species.ALOLA_EXEGGUTOR ]).setBattleBgm('battle_johto_champion'),
|
|
|
|
[TrainerType.STEVEN]: new TrainerConfig(++t).initForChampion([ Species.METAGROSS, [ Species.DIALGA, Species.PALKIA ], Species.SKARMORY, Species.AGGRON, Species.CARBINK ]).setBattleBgm('battle_hoenn_champion'),
|
|
|
|
[TrainerType.WALLACE]: new TrainerConfig(++t).initForChampion([ Species.MILOTIC, Species.KYOGRE, Species.WHISCASH, Species.WALREIN, Species.LUDICOLO ]).setBattleBgm('battle_hoenn_champion'),
|
|
|
|
[TrainerType.CYNTHIA]: new TrainerConfig(++t).initForChampion([ Species.SPIRITOMB, Species.GIRATINA, Species.GARCHOMP, Species.MILOTIC, Species.LUCARIO, Species.TOGEKISS ]).setBattleBgm('battle_sinnoh_champion'),
|
2024-01-05 00:37:07 +00:00
|
|
|
[TrainerType.ALDER]: new TrainerConfig(++t).initForChampion([ Species.VOLCARONA, Species.GROUDON, Species.BOUFFALANT, Species.ACCELGOR, Species.CONKELDURR ]),
|
2024-03-06 23:55:55 +00:00
|
|
|
[TrainerType.IRIS]: new TrainerConfig(++t).initForChampion([ Species.HAXORUS, Species.YVELTAL, Species.DRUDDIGON, Species.ARON, Species.LAPRAS ]).setBattleBgm('battle_champion_iris'),
|
2024-01-05 00:37:07 +00:00
|
|
|
[TrainerType.DIANTHA]: new TrainerConfig(++t).initForChampion([ Species.HAWLUCHA, Species.XERNEAS, Species.GOURGEIST, Species.GOODRA, Species.GARDEVOIR ]),
|
2024-02-19 01:17:30 +00:00
|
|
|
[TrainerType.HAU]: new TrainerConfig(++t).initForChampion([ Species.ALOLA_RAICHU, [ Species.SOLGALEO, Species.LUNALA ], Species.NOIVERN, [ Species.DECIDUEYE, Species.INCINEROAR, Species.PRIMARINA ], Species.CRABOMINABLE ]),
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerType.GEETA]: new TrainerConfig(++t).initForChampion([ Species.GLIMMORA, Species.MIRAIDON, Species.ESPATHRA, Species.VELUZA, Species.KINGAMBIT ]),
|
2024-01-05 01:28:24 +00:00
|
|
|
[TrainerType.NEMONA]: new TrainerConfig(++t).initForChampion([ Species.LYCANROC, Species.KORAIDON, Species.KOMMO_O, Species.PAWMOT, Species.DUSKNOIR ]),
|
2024-02-06 04:46:45 +00:00
|
|
|
[TrainerType.KIERAN]: new TrainerConfig(++t).initForChampion([ Species.POLITOED, Species.TERAPAGOS, Species.HYDRAPPLE, Species.PORYGON_Z, Species.GRIMMSNARL ]),
|
2024-02-23 05:24:44 +00:00
|
|
|
[TrainerType.LEON]: new TrainerConfig(++t).initForChampion([ Species.DRAGAPULT, [ Species.ZACIAN, Species.ZAMAZENTA ], Species.SEISMITOAD, Species.AEGISLASH, Species.MR_RIME ]),
|
2023-12-14 05:41:35 +00:00
|
|
|
|
2024-02-22 23:03:36 +00:00
|
|
|
[TrainerType.RIVAL]: new TrainerConfig((t = TrainerType.RIVAL)).setName('Finn').setHasGenders('Ivy').setHasCharSprite().setTitle('Rival').setStaticParty().setEncounterBgm(TrainerType.RIVAL).setBattleBgm('battle_rival').setPartyTemplates(trainerPartyTemplates.RIVAL)
|
2024-02-06 04:46:45 +00:00
|
|
|
.setModifierRewardFuncs(() => modifierTypes.SUPER_EXP_CHARM, () => modifierTypes.EXP_SHARE).setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.BULBASAUR, Species.CHARMANDER, Species.SQUIRTLE, Species.CHIKORITA, Species.CYNDAQUIL, Species.TOTODILE, Species.TREECKO, Species.TORCHIC, Species.MUDKIP, Species.TURTWIG, Species.CHIMCHAR, Species.PIPLUP, Species.SNIVY, Species.TEPIG, Species.OSHAWOTT, Species.CHESPIN, Species.FENNEKIN, Species.FROAKIE, Species.ROWLET, Species.LITTEN, Species.POPPLIO, Species.GROOKEY, Species.SCORBUNNY, Species.SOBBLE, Species.SPRIGATITO, Species.FUECOCO, Species.QUAXLY ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.PIDGEY, Species.HOOTHOOT, Species.TAILLOW, Species.STARLY, Species.PIDOVE, Species.FLETCHLING, Species.PIKIPEK, Species.ROOKIDEE, Species.WATTREL ])),
|
2024-02-22 23:03:36 +00:00
|
|
|
[TrainerType.RIVAL_2]: new TrainerConfig(++t).setName('Finn').setHasGenders('Ivy').setHasCharSprite().setTitle('Rival').setStaticParty().setMoneyMultiplier(1.25).setEncounterBgm(TrainerType.RIVAL).setBattleBgm('battle_rival').setPartyTemplates(trainerPartyTemplates.RIVAL_2)
|
2024-02-06 04:46:45 +00:00
|
|
|
.setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.IVYSAUR, Species.CHARMELEON, Species.WARTORTLE, Species.BAYLEEF, Species.QUILAVA, Species.CROCONAW, Species.GROVYLE, Species.COMBUSKEN, Species.MARSHTOMP, Species.GROTLE, Species.MONFERNO, Species.PRINPLUP, Species.SERVINE, Species.PIGNITE, Species.DEWOTT, Species.QUILLADIN, Species.BRAIXEN, Species.FROGADIER, Species.DARTRIX, Species.TORRACAT, Species.BRIONNE, Species.THWACKEY, Species.RABOOT, Species.DRIZZILE, Species.FLORAGATO, Species.CROCALOR, Species.QUAXWELL ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.PIDGEOTTO, Species.HOOTHOOT, Species.TAILLOW, Species.STARAVIA, Species.TRANQUILL, Species.FLETCHINDER, Species.TRUMBEAK, Species.CORVISQUIRE, Species.WATTREL ]))
|
2023-10-18 23:01:15 +01:00
|
|
|
.setPartyMemberFunc(2, getSpeciesFilterRandomPartyMemberFunc((species: PokemonSpecies) => !pokemonEvolutions.hasOwnProperty(species.speciesId) && !pokemonPrevolutions.hasOwnProperty(species.speciesId) && species.baseTotal >= 450)),
|
2024-02-22 23:03:36 +00:00
|
|
|
[TrainerType.RIVAL_3]: new TrainerConfig(++t).setName('Finn').setHasGenders('Ivy').setHasCharSprite().setTitle('Rival').setStaticParty().setMoneyMultiplier(1.5).setEncounterBgm(TrainerType.RIVAL).setBattleBgm('battle_rival').setPartyTemplates(trainerPartyTemplates.RIVAL_3)
|
2024-02-06 04:46:45 +00:00
|
|
|
.setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.VENUSAUR, Species.CHARIZARD, Species.BLASTOISE, Species.MEGANIUM, Species.TYPHLOSION, Species.FERALIGATR, Species.SCEPTILE, Species.BLAZIKEN, Species.SWAMPERT, Species.TORTERRA, Species.INFERNAPE, Species.EMPOLEON, Species.SERPERIOR, Species.EMBOAR, Species.SAMUROTT, Species.CHESNAUGHT, Species.DELPHOX, Species.GRENINJA, Species.DECIDUEYE, Species.INCINEROAR, Species.PRIMARINA, Species.RILLABOOM, Species.CINDERACE, Species.INTELEON, Species.MEOWSCARADA, Species.SKELEDIRGE, Species.QUAQUAVAL ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.PIDGEOT, Species.NOCTOWL, Species.SWELLOW, Species.STARAPTOR, Species.UNFEZANT, Species.TALONFLAME, Species.TOUCANNON, Species.CORVIKNIGHT, Species.KILOWATTREL ]))
|
2023-10-18 23:01:15 +01:00
|
|
|
.setPartyMemberFunc(2, getSpeciesFilterRandomPartyMemberFunc((species: PokemonSpecies) => !pokemonEvolutions.hasOwnProperty(species.speciesId) && !pokemonPrevolutions.hasOwnProperty(species.speciesId) && species.baseTotal >= 450))
|
|
|
|
.setSpeciesFilter(species => species.baseTotal >= 540),
|
2024-02-22 23:03:36 +00:00
|
|
|
[TrainerType.RIVAL_4]: new TrainerConfig(++t).setName('Finn').setHasGenders('Ivy').setHasCharSprite().setTitle('Rival').setBoss().setStaticParty().setMoneyMultiplier(1.75).setEncounterBgm(TrainerType.RIVAL).setBattleBgm('battle_rival_2').setPartyTemplates(trainerPartyTemplates.RIVAL_4)
|
2024-02-06 04:46:45 +00:00
|
|
|
.setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.VENUSAUR, Species.CHARIZARD, Species.BLASTOISE, Species.MEGANIUM, Species.TYPHLOSION, Species.FERALIGATR, Species.SCEPTILE, Species.BLAZIKEN, Species.SWAMPERT, Species.TORTERRA, Species.INFERNAPE, Species.EMPOLEON, Species.SERPERIOR, Species.EMBOAR, Species.SAMUROTT, Species.CHESNAUGHT, Species.DELPHOX, Species.GRENINJA, Species.DECIDUEYE, Species.INCINEROAR, Species.PRIMARINA, Species.RILLABOOM, Species.CINDERACE, Species.INTELEON, Species.MEOWSCARADA, Species.SKELEDIRGE, Species.QUAQUAVAL ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.PIDGEOT, Species.NOCTOWL, Species.SWELLOW, Species.STARAPTOR, Species.UNFEZANT, Species.TALONFLAME, Species.TOUCANNON, Species.CORVIKNIGHT, Species.KILOWATTREL ]))
|
2023-10-18 23:01:15 +01:00
|
|
|
.setPartyMemberFunc(2, getSpeciesFilterRandomPartyMemberFunc((species: PokemonSpecies) => !pokemonEvolutions.hasOwnProperty(species.speciesId) && !pokemonPrevolutions.hasOwnProperty(species.speciesId) && species.baseTotal >= 450))
|
2024-02-17 05:40:03 +00:00
|
|
|
.setSpeciesFilter(species => species.baseTotal >= 540)
|
|
|
|
.setGenModifiersFunc(party => {
|
|
|
|
const starter = party[0];
|
|
|
|
return [ modifierTypes.TERA_SHARD().generateType(null, [ starter.species.type1 ]).withIdFromFunc(modifierTypes.TERA_SHARD).newModifier(starter) as PersistentModifier ];
|
|
|
|
}),
|
2024-02-22 23:03:36 +00:00
|
|
|
[TrainerType.RIVAL_5]: new TrainerConfig(++t).setName('Finn').setHasGenders('Ivy').setHasCharSprite().setTitle('Rival').setBoss().setStaticParty().setMoneyMultiplier(2.25).setEncounterBgm(TrainerType.RIVAL).setBattleBgm('battle_rival_3').setPartyTemplates(trainerPartyTemplates.RIVAL_5)
|
2024-02-06 04:46:45 +00:00
|
|
|
.setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.VENUSAUR, Species.CHARIZARD, Species.BLASTOISE, Species.MEGANIUM, Species.TYPHLOSION, Species.FERALIGATR, Species.SCEPTILE, Species.BLAZIKEN, Species.SWAMPERT, Species.TORTERRA, Species.INFERNAPE, Species.EMPOLEON, Species.SERPERIOR, Species.EMBOAR, Species.SAMUROTT, Species.CHESNAUGHT, Species.DELPHOX, Species.GRENINJA, Species.DECIDUEYE, Species.INCINEROAR, Species.PRIMARINA, Species.RILLABOOM, Species.CINDERACE, Species.INTELEON, Species.MEOWSCARADA, Species.SKELEDIRGE, Species.QUAQUAVAL ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.PIDGEOT, Species.NOCTOWL, Species.SWELLOW, Species.STARAPTOR, Species.UNFEZANT, Species.TALONFLAME, Species.TOUCANNON, Species.CORVIKNIGHT, Species.KILOWATTREL ]))
|
2023-10-18 23:01:15 +01:00
|
|
|
.setPartyMemberFunc(2, getSpeciesFilterRandomPartyMemberFunc((species: PokemonSpecies) => !pokemonEvolutions.hasOwnProperty(species.speciesId) && !pokemonPrevolutions.hasOwnProperty(species.speciesId) && species.baseTotal >= 450))
|
|
|
|
.setSpeciesFilter(species => species.baseTotal >= 540)
|
2024-01-08 04:17:24 +00:00
|
|
|
.setPartyMemberFunc(5, getRandomPartyMemberFunc([ Species.RAYQUAZA ], p => {
|
|
|
|
p.setBoss();
|
|
|
|
p.pokeball = PokeballType.MASTER_BALL;
|
2024-02-17 05:40:03 +00:00
|
|
|
}))
|
|
|
|
.setGenModifiersFunc(party => {
|
|
|
|
const starter = party[0];
|
|
|
|
return [ modifierTypes.TERA_SHARD().generateType(null, [ starter.species.type1 ]).withIdFromFunc(modifierTypes.TERA_SHARD).newModifier(starter) as PersistentModifier ];
|
|
|
|
}),
|
2024-02-22 23:03:36 +00:00
|
|
|
[TrainerType.RIVAL_6]: new TrainerConfig(++t).setName('Finn').setHasGenders('Ivy').setHasCharSprite().setTitle('Rival').setBoss().setStaticParty().setMoneyMultiplier(3).setEncounterBgm('final').setBattleBgm('battle_rival_3').setPartyTemplates(trainerPartyTemplates.RIVAL_6)
|
2024-03-07 17:54:12 +00:00
|
|
|
.setPartyMemberFunc(0, getRandomPartyMemberFunc([ Species.VENUSAUR, Species.CHARIZARD, Species.BLASTOISE, Species.MEGANIUM, Species.TYPHLOSION, Species.FERALIGATR, Species.SCEPTILE, Species.BLAZIKEN, Species.SWAMPERT, Species.TORTERRA, Species.INFERNAPE, Species.EMPOLEON, Species.SERPERIOR, Species.EMBOAR, Species.SAMUROTT, Species.CHESNAUGHT, Species.DELPHOX, Species.GRENINJA, Species.DECIDUEYE, Species.INCINEROAR, Species.PRIMARINA, Species.RILLABOOM, Species.CINDERACE, Species.INTELEON, Species.MEOWSCARADA, Species.SKELEDIRGE, Species.QUAQUAVAL ]))
|
|
|
|
.setPartyMemberFunc(1, getRandomPartyMemberFunc([ Species.PIDGEOT, Species.NOCTOWL, Species.SWELLOW, Species.STARAPTOR, Species.UNFEZANT, Species.TALONFLAME, Species.TOUCANNON, Species.CORVIKNIGHT, Species.KILOWATTREL ]))
|
2023-10-18 23:01:15 +01:00
|
|
|
.setPartyMemberFunc(2, getSpeciesFilterRandomPartyMemberFunc((species: PokemonSpecies) => !pokemonEvolutions.hasOwnProperty(species.speciesId) && !pokemonPrevolutions.hasOwnProperty(species.speciesId) && species.baseTotal >= 450))
|
|
|
|
.setSpeciesFilter(species => species.baseTotal >= 540)
|
2024-01-08 04:17:24 +00:00
|
|
|
.setPartyMemberFunc(5, getRandomPartyMemberFunc([ Species.RAYQUAZA ], p => {
|
|
|
|
p.setBoss();
|
|
|
|
p.pokeball = PokeballType.MASTER_BALL;
|
|
|
|
p.formIndex = 1;
|
2024-02-17 05:40:03 +00:00
|
|
|
}))
|
|
|
|
.setGenModifiersFunc(party => {
|
|
|
|
const starter = party[0];
|
|
|
|
return [ modifierTypes.TERA_SHARD().generateType(null, [ starter.species.type1 ]).withIdFromFunc(modifierTypes.TERA_SHARD).newModifier(starter) as PersistentModifier ];
|
|
|
|
}),
|
2024-01-13 17:24:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
(function() {
|
|
|
|
initTrainerTypeDialogue();
|
|
|
|
})();
|