mirror of
https://github.com/smogon/pokemon-showdown.git
synced 2026-03-21 17:25:10 -05:00
684150d9d7
* Implement Mega Stones as pairs {key: value}
* Fix Mega Evolution check
* Add constructor guards to Dex getters
* Update config/formats.ts
---------
Co-authored-by: Kris Johnson <11083252+KrisXV@users.noreply.github.com>
1956 lines
74 KiB
TypeScript
1956 lines
74 KiB
TypeScript
import { MoveCounter, type TeamData, RandomGen8Teams } from '../gen8/teams';
|
|
import type { PRNG, PRNGSeed } from '../../../sim/prng';
|
|
import { toID } from '../../../sim/dex';
|
|
|
|
export interface BattleFactorySpecies {
|
|
flags: { megaOnly?: 1, zmoveOnly?: 1, limEevee?: 1 };
|
|
sets: BattleFactorySet[];
|
|
}
|
|
interface BattleFactorySet {
|
|
species: string;
|
|
item: string;
|
|
ability: string;
|
|
nature: string;
|
|
moves: string[];
|
|
evs?: Partial<StatsTable>;
|
|
ivs?: Partial<StatsTable>;
|
|
}
|
|
|
|
export const ZeroAttackHPIVs: { [k: string]: SparseStatsTable } = {
|
|
grass: { hp: 30, spa: 30 },
|
|
fire: { spa: 30, spe: 30 },
|
|
ice: { def: 30 },
|
|
ground: { spa: 30, spd: 30 },
|
|
fighting: { def: 30, spa: 30, spd: 30, spe: 30 },
|
|
electric: { def: 30, spe: 30 },
|
|
psychic: { spe: 30 },
|
|
flying: { spa: 30, spd: 30, spe: 30 },
|
|
rock: { def: 30, spd: 30, spe: 30 },
|
|
};
|
|
|
|
// Moves that restore HP:
|
|
const RECOVERY_MOVES = [
|
|
'healorder', 'milkdrink', 'moonlight', 'morningsun', 'recover', 'recycle', 'roost', 'shoreup', 'slackoff', 'softboiled', 'strengthsap', 'synthesis',
|
|
];
|
|
// Moves that drop stats:
|
|
const CONTRARY_MOVES = [
|
|
'closecombat', 'leafstorm', 'overheat', 'superpower', 'vcreate',
|
|
];
|
|
// Moves that boost Attack:
|
|
const PHYSICAL_SETUP = [
|
|
'bellydrum', 'bulkup', 'coil', 'curse', 'dragondance', 'honeclaws', 'howl', 'meditate', 'poweruppunch', 'screech', 'swordsdance',
|
|
];
|
|
// Moves which boost Special Attack:
|
|
const SPECIAL_SETUP = [
|
|
'calmmind', 'chargebeam', 'geomancy', 'nastyplot', 'quiverdance', 'tailglow',
|
|
];
|
|
// Moves that boost Attack AND Special Attack:
|
|
const MIXED_SETUP = [
|
|
'celebrate', 'growth', 'happyhour', 'holdhands', 'shellsmash', 'workup',
|
|
];
|
|
// Some moves that only boost Speed:
|
|
const SPEED_SETUP = [
|
|
'agility', 'autotomize', 'flamecharge', 'rockpolish',
|
|
];
|
|
// Conglomerate for ease of access
|
|
const SETUP = [
|
|
'acidarmor', 'agility', 'autotomize', 'bellydrum', 'bulkup', 'calmmind', 'celebrate', 'coil', 'conversion', 'curse', 'dragondance',
|
|
'electricterrain', 'flamecharge', 'focusenergy', 'geomancy', 'growth', 'happyhour', 'holdhands', 'honeclaws', 'howl', 'irondefense', 'meditate',
|
|
'nastyplot', 'poweruppunch', 'quiverdance', 'raindance', 'rockpolish', 'shellsmash', 'shiftgear', 'swordsdance', 'tailglow', 'workup',
|
|
];
|
|
// Moves that shouldn't be the only STAB moves:
|
|
const NO_STAB = [
|
|
'accelerock', 'aquajet', 'bulletpunch', 'clearsmog', 'dragontail', 'eruption', 'explosion',
|
|
'fakeout', 'firstimpression', 'flamecharge', 'futuresight', 'iceshard', 'icywind', 'incinerate', 'infestation', 'machpunch',
|
|
'nuzzle', 'pluck', 'poweruppunch', 'pursuit', 'quickattack', 'rapidspin', 'reversal', 'selfdestruct', 'shadowsneak',
|
|
'skyattack', 'skydrop', 'snarl', 'suckerpunch', 'uturn', 'watershuriken', 'vacuumwave', 'voltswitch', 'waterspout',
|
|
];
|
|
// Hazard-setting moves
|
|
const HAZARDS = [
|
|
'spikes', 'stealthrock', 'stickyweb', 'toxicspikes',
|
|
];
|
|
// Protect and its variants
|
|
const PROTECT_MOVES = [
|
|
'banefulbunker', 'kingsshield', 'protect', 'spikyshield',
|
|
];
|
|
// Moves that switch the user out
|
|
const PIVOT_MOVES = [
|
|
'partingshot', 'uturn', 'voltswitch',
|
|
];
|
|
|
|
// Moves that should be paired together when possible
|
|
const MOVE_PAIRS = [
|
|
['lightscreen', 'reflect'],
|
|
['sleeptalk', 'rest'],
|
|
['protect', 'wish'],
|
|
['spikyshield', 'wish'],
|
|
['leechseed', 'substitute'],
|
|
['perishsong', 'protect'],
|
|
['solarbeam', 'sunnyday'],
|
|
];
|
|
|
|
/** Pokemon who always want priority STAB, and are fine with it as its only STAB move of that type */
|
|
const PRIORITY_POKEMON = [
|
|
'aegislash', 'banette', 'breloom', 'cacturne', 'doublade', 'dusknoir', 'golisopod', 'honchkrow', 'mimikyu', 'scizor', 'scizormega', 'shedinja',
|
|
];
|
|
function sereneGraceBenefits(move: Move) {
|
|
return move.secondary?.chance && move.secondary.chance >= 20 && move.secondary.chance < 100;
|
|
}
|
|
|
|
export class RandomGen7Teams extends RandomGen8Teams {
|
|
randomSets: { [species: string]: RandomTeamsTypes.RandomSpeciesData } = require('./sets.json');
|
|
protected cachedStatusMoves: ID[];
|
|
|
|
constructor(format: Format | string, prng: PRNG | PRNGSeed | null) {
|
|
super(format, prng);
|
|
|
|
this.noStab = NO_STAB;
|
|
this.priorityPokemon = PRIORITY_POKEMON;
|
|
|
|
this.moveEnforcementCheckers = {
|
|
Bug: (movePool, moves, abilities, types, counter) => (
|
|
['megahorn', 'pinmissile'].some(m => movePool.includes(m)) ||
|
|
!counter.get('Bug') && (abilities.includes('Tinted Lens') || abilities.includes('Adaptability'))
|
|
),
|
|
Dark: (movePool, moves, abilities, types, counter) => !counter.get('Dark'),
|
|
Dragon: (movePool, moves, abilities, types, counter) => !counter.get('Dragon'),
|
|
Electric: (movePool, moves, abilities, types, counter) => !counter.get('Electric'),
|
|
Fairy: (movePool, moves, abilities, types, counter) => !counter.get('Fairy'),
|
|
Fighting: (movePool, moves, abilities, types, counter) => !counter.get('Fighting'),
|
|
Fire: (movePool, moves, abilities, types, counter) => !counter.get('Fire'),
|
|
Flying: (movePool, moves, abilities, types, counter, species) => (
|
|
!counter.get('Flying') && !['aerodactyl', 'aerodactylmega', 'mantine'].includes(species.id) &&
|
|
!movePool.includes('hiddenpowerflying')
|
|
),
|
|
Ghost: (movePool, moves, abilities, types, counter) => !counter.get('Ghost'),
|
|
Grass: (movePool, moves, abilities, types, counter, species) => (
|
|
!counter.get('Grass') && (species.baseStats.atk >= 100 || movePool.includes('leafstorm'))
|
|
),
|
|
Ground: (movePool, moves, abilities, types, counter) => !counter.get('Ground'),
|
|
Ice: (movePool, moves, abilities, types, counter) => (
|
|
!counter.get('Ice') || (moves.has('icebeam') && movePool.includes('freezedry')) ||
|
|
(abilities.includes('Refrigerate') && movePool.includes('return'))
|
|
),
|
|
Normal: movePool => (movePool.includes('boomburst') || movePool.includes('hypervoice')),
|
|
Poison: (movePool, moves, abilities, types, counter) => !counter.get('Poison'),
|
|
Psychic: (movePool, moves, abilities, types, counter) => (
|
|
!counter.get('Psychic') && (
|
|
types.has('Fighting') || movePool.includes('psychicfangs') || movePool.includes('calmmind')
|
|
)
|
|
),
|
|
Rock: (movePool, moves, abilities, types, counter, species) => (!counter.get('Rock') && species.baseStats.atk >= 80),
|
|
Steel: (movePool, moves, abilities, types, counter, species) => (!counter.get('Steel') && species.baseStats.atk >= 100),
|
|
Water: (movePool, moves, abilities, types, counter) => !counter.get('Water'),
|
|
};
|
|
// Nature Power is Tri Attack this gen
|
|
this.cachedStatusMoves = this.dex.moves.all()
|
|
.filter(move => move.category === 'Status' && move.id !== 'naturepower')
|
|
.map(move => move.id);
|
|
}
|
|
|
|
newQueryMoves(
|
|
moves: Set<string> | null,
|
|
species: Species,
|
|
preferredType: string,
|
|
abilities: string[],
|
|
): MoveCounter {
|
|
// This is primarily a helper function for random setbuilder functions.
|
|
const counter = new MoveCounter();
|
|
const types = species.types;
|
|
if (!moves?.size) return counter;
|
|
|
|
const categories = { Physical: 0, Special: 0, Status: 0 };
|
|
|
|
// Iterate through all moves we've chosen so far and keep track of what they do:
|
|
for (const moveid of moves) {
|
|
let move = this.dex.moves.get(moveid);
|
|
// Nature Power calls Earthquake in Gen 5
|
|
if (this.gen === 5 && moveid === 'naturepower') move = this.dex.moves.get('earthquake');
|
|
if (this.gen > 5 && moveid === 'naturepower') move = this.dex.moves.get('triattack');
|
|
|
|
const moveType = this.getMoveType(move, species, abilities, preferredType);
|
|
if (move.damage || move.damageCallback) {
|
|
// Moves that do a set amount of damage:
|
|
counter.add('damage');
|
|
counter.damagingMoves.add(move);
|
|
} else {
|
|
// Are Physical/Special/Status moves:
|
|
categories[move.category]++;
|
|
}
|
|
// Moves that have a low base power:
|
|
if (moveid === 'lowkick' || (move.basePower && move.basePower <= 60 && !['nuzzle', 'rapidspin'].includes(moveid))) {
|
|
counter.add('technician');
|
|
}
|
|
// Moves that hit up to 5 times:
|
|
if (move.multihit && Array.isArray(move.multihit) && move.multihit[1] === 5) counter.add('skilllink');
|
|
if (move.recoil || move.hasCrashDamage) counter.add('recoil');
|
|
if (move.drain) counter.add('drain');
|
|
// Moves which have a base power:
|
|
if (move.basePower || move.basePowerCallback) {
|
|
if (!this.noStab.includes(moveid) || this.priorityPokemon.includes(species.id) && move.priority > 0) {
|
|
counter.add(moveType);
|
|
if (types.includes(moveType)) counter.add('stab');
|
|
if (preferredType === moveType) counter.add('preferred');
|
|
counter.damagingMoves.add(move);
|
|
}
|
|
if (move.flags['bite']) counter.add('strongjaw');
|
|
if (move.flags['punch']) counter.add('ironfist');
|
|
if (move.flags['sound']) counter.add('sound');
|
|
if (move.priority > 0) counter.add('priority');
|
|
}
|
|
// Moves with secondary effects:
|
|
if (move.secondary || move.hasSheerForce) {
|
|
counter.add('sheerforce');
|
|
if (sereneGraceBenefits(move)) {
|
|
counter.add('serenegrace');
|
|
}
|
|
}
|
|
// Moves with low accuracy:
|
|
if (move.accuracy && move.accuracy !== true && move.accuracy < 90) counter.add('inaccurate');
|
|
|
|
// Moves that change stats:
|
|
if (RECOVERY_MOVES.includes(moveid)) counter.add('recovery');
|
|
if (CONTRARY_MOVES.includes(moveid)) counter.add('contrary');
|
|
if (PHYSICAL_SETUP.includes(moveid)) counter.add('physicalsetup');
|
|
if (SPECIAL_SETUP.includes(moveid)) counter.add('specialsetup');
|
|
if (MIXED_SETUP.includes(moveid)) counter.add('mixedsetup');
|
|
if (SPEED_SETUP.includes(moveid)) counter.add('speedsetup');
|
|
if (SETUP.includes(moveid)) counter.add('setup');
|
|
if (HAZARDS.includes(moveid)) counter.add('hazards');
|
|
}
|
|
|
|
counter.set('Physical', Math.floor(categories['Physical']));
|
|
counter.set('Special', Math.floor(categories['Special']));
|
|
counter.set('Status', categories['Status']);
|
|
return counter;
|
|
}
|
|
|
|
cullMovePool(
|
|
types: string[],
|
|
moves: Set<string>,
|
|
abilities: string[],
|
|
counter: MoveCounter,
|
|
movePool: string[],
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
isLead: boolean,
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role,
|
|
): void {
|
|
// Pokemon cannot have multiple Hidden Powers in any circumstance
|
|
let hasHiddenPower = false;
|
|
for (const move of moves) {
|
|
if (move.startsWith('hiddenpower')) hasHiddenPower = true;
|
|
}
|
|
if (hasHiddenPower) {
|
|
let movePoolHasHiddenPower = true;
|
|
while (movePoolHasHiddenPower) {
|
|
movePoolHasHiddenPower = false;
|
|
for (const moveid of movePool) {
|
|
if (moveid.startsWith('hiddenpower')) {
|
|
this.fastPop(movePool, movePool.indexOf(moveid));
|
|
movePoolHasHiddenPower = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
// If we have two unfilled moves and only one unpaired move, cull the unpaired move.
|
|
if (moves.size === this.maxMoveCount - 2) {
|
|
const unpairedMoves = [...movePool];
|
|
for (const pair of MOVE_PAIRS) {
|
|
if (movePool.includes(pair[0]) && movePool.includes(pair[1])) {
|
|
this.fastPop(unpairedMoves, unpairedMoves.indexOf(pair[0]));
|
|
this.fastPop(unpairedMoves, unpairedMoves.indexOf(pair[1]));
|
|
}
|
|
}
|
|
if (unpairedMoves.length === 1) {
|
|
this.fastPop(movePool, movePool.indexOf(unpairedMoves[0]));
|
|
}
|
|
}
|
|
|
|
// These moves are paired, and shouldn't appear if there is not room for them both.
|
|
if (moves.size === this.maxMoveCount - 1) {
|
|
for (const pair of MOVE_PAIRS) {
|
|
if (movePool.includes(pair[0]) && movePool.includes(pair[1])) {
|
|
this.fastPop(movePool, movePool.indexOf(pair[0]));
|
|
this.fastPop(movePool, movePool.indexOf(pair[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Team-based move culls
|
|
if (teamDetails.screens && movePool.length >= this.maxMoveCount + 2) {
|
|
if (movePool.includes('reflect')) this.fastPop(movePool, movePool.indexOf('reflect'));
|
|
if (movePool.includes('lightscreen')) this.fastPop(movePool, movePool.indexOf('lightscreen'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (teamDetails.stickyWeb) {
|
|
if (movePool.includes('stickyweb')) this.fastPop(movePool, movePool.indexOf('stickyweb'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (teamDetails.stealthRock) {
|
|
if (movePool.includes('stealthrock')) this.fastPop(movePool, movePool.indexOf('stealthrock'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (teamDetails.defog || teamDetails.rapidSpin) {
|
|
if (movePool.includes('defog')) this.fastPop(movePool, movePool.indexOf('defog'));
|
|
if (movePool.includes('rapidspin')) this.fastPop(movePool, movePool.indexOf('rapidspin'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (teamDetails.toxicSpikes) {
|
|
if (movePool.includes('toxicspikes')) this.fastPop(movePool, movePool.indexOf('toxicspikes'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (teamDetails.spikes && teamDetails.spikes >= 2) {
|
|
if (movePool.includes('spikes')) this.fastPop(movePool, movePool.indexOf('spikes'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (teamDetails.statusCure) {
|
|
if (movePool.includes('aromatherapy')) this.fastPop(movePool, movePool.indexOf('aromatherapy'));
|
|
if (movePool.includes('healbell')) this.fastPop(movePool, movePool.indexOf('healbell'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
|
|
// Develop additional move lists
|
|
const badWithSetup = ['defog', 'dragontail', 'haze', 'healbell', 'nuzzle', 'pursuit', 'rapidspin', 'toxic'];
|
|
const statusMoves = this.cachedStatusMoves;
|
|
|
|
// General incompatibilities
|
|
const incompatiblePairs = [
|
|
// These moves don't mesh well with other aspects of the set
|
|
[statusMoves, ['healingwish', 'memento', 'switcheroo', 'trick']],
|
|
[PIVOT_MOVES, PIVOT_MOVES],
|
|
[SETUP, PIVOT_MOVES],
|
|
[SETUP, HAZARDS],
|
|
[SETUP, badWithSetup],
|
|
[PHYSICAL_SETUP, PHYSICAL_SETUP],
|
|
[SPEED_SETUP, 'quickattack'],
|
|
['defog', HAZARDS],
|
|
[['fakeout', 'uturn'], ['switcheroo', 'trick']],
|
|
['substitute', PIVOT_MOVES],
|
|
['leechseed', 'dragontail'],
|
|
['rest', 'substitute'],
|
|
[PHYSICAL_SETUP, 'dracometeor'],
|
|
[SPECIAL_SETUP, 'knockoff'],
|
|
|
|
// These attacks are redundant with each other
|
|
['psychic', 'psyshock'],
|
|
[['scald', 'surf'], ['hydropump', 'originpulse', 'waterpulse']],
|
|
['return', ['bodyslam', 'doubleedge', 'headbutt']],
|
|
[['fierydance', 'firelash', 'lavaplume'], ['fireblast', 'magmastorm']],
|
|
[['flamethrower', 'flareblitz'], ['fireblast', 'overheat']],
|
|
['hornleech', 'woodhammer'],
|
|
[['gigadrain', 'leafstorm'], ['energyball', 'leafstorm', 'petaldance', 'powerwhip']],
|
|
['wildcharge', 'thunderbolt'],
|
|
[['gunkshot', 'sludgewave'], 'poisonjab'],
|
|
[['drainpunch', 'focusblast'], ['closecombat', 'highjumpkick', 'superpower']],
|
|
['dracometeor', 'dragonpulse'],
|
|
['dragonclaw', 'outrage'],
|
|
['knockoff', ['darkestlariat', 'darkpulse', 'foulplay']],
|
|
|
|
// Status move incompatibilities
|
|
['toxic', 'toxicspikes'],
|
|
['taunt', 'disable'],
|
|
['defog', ['leechseed', 'substitute']],
|
|
|
|
// Assorted hardcodes go here:
|
|
// Lunatone
|
|
['moonlight', 'rockpolish'],
|
|
// Smeargle
|
|
['nuzzle', 'whirlwind'],
|
|
// Liepard
|
|
['copycat', 'uturn'],
|
|
// Seviper
|
|
['switcheroo', 'suckerpunch'],
|
|
// Jirachi
|
|
['bodyslam', 'healingwish'],
|
|
];
|
|
|
|
for (const pair of incompatiblePairs) this.incompatibleMoves(moves, movePool, pair[0], pair[1]);
|
|
|
|
if (!types.includes('Dark') && preferredType !== 'Dark') {
|
|
this.incompatibleMoves(moves, movePool, 'knockoff', ['pursuit', 'suckerpunch']);
|
|
}
|
|
|
|
const statusInflictingMoves = ['thunderwave', 'toxic', 'willowisp', 'yawn'];
|
|
if (!abilities.includes('Prankster') && role !== 'Staller') {
|
|
this.incompatibleMoves(moves, movePool, statusInflictingMoves, statusInflictingMoves);
|
|
}
|
|
|
|
if (abilities.includes('Guts')) this.incompatibleMoves(moves, movePool, 'protect', 'swordsdance');
|
|
|
|
// Z-Conversion Porygon-Z
|
|
if (species.id === 'porygonz') {
|
|
this.incompatibleMoves(moves, movePool, 'shadowball', 'recover');
|
|
}
|
|
|
|
// Cull filler moves for otherwise fixed set Stealth Rock users
|
|
if (!teamDetails.stealthRock) {
|
|
if (species.id === 'registeel' && role === 'Staller') {
|
|
if (movePool.includes('thunderwave')) this.fastPop(movePool, movePool.indexOf('thunderwave'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
if (species.baseSpecies === 'Wormadam' && role === 'Staller') {
|
|
if (movePool.includes('infestation')) this.fastPop(movePool, movePool.indexOf('infestation'));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checks for and removes incompatible moves, starting with the first move in movesA.
|
|
incompatibleMoves(
|
|
moves: Set<string>,
|
|
movePool: string[],
|
|
movesA: string | string[],
|
|
movesB: string | string[],
|
|
): void {
|
|
const moveArrayA = (Array.isArray(movesA)) ? movesA : [movesA];
|
|
const moveArrayB = (Array.isArray(movesB)) ? movesB : [movesB];
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
for (const moveid1 of moves) {
|
|
if (moveArrayB.includes(moveid1)) {
|
|
for (const moveid2 of moveArrayA) {
|
|
if (moveid1 !== moveid2 && movePool.includes(moveid2)) {
|
|
this.fastPop(movePool, movePool.indexOf(moveid2));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
}
|
|
}
|
|
if (moveArrayA.includes(moveid1)) {
|
|
for (const moveid2 of moveArrayB) {
|
|
if (moveid1 !== moveid2 && movePool.includes(moveid2)) {
|
|
this.fastPop(movePool, movePool.indexOf(moveid2));
|
|
if (moves.size + movePool.length <= this.maxMoveCount) return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Adds a move to the moveset, returns the MoveCounter
|
|
addMove(
|
|
move: string,
|
|
moves: Set<string>,
|
|
types: string[],
|
|
abilities: string[],
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
isLead: boolean,
|
|
movePool: string[],
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role,
|
|
): MoveCounter {
|
|
moves.add(move);
|
|
this.fastPop(movePool, movePool.indexOf(move));
|
|
const counter = this.newQueryMoves(moves, species, preferredType, abilities);
|
|
this.cullMovePool(types, moves, abilities, counter, movePool, teamDetails, species, isLead,
|
|
preferredType, role);
|
|
return counter;
|
|
}
|
|
|
|
// Returns the type of a given move for STAB/coverage enforcement purposes
|
|
getMoveType(move: Move, species: Species, abilities: string[], preferredType: string): string {
|
|
if (['judgment', 'multiattack', 'revelationdance'].includes(move.id)) return species.types[0];
|
|
if (species.id === 'genesectdouse' && move.id === 'technoblast') return 'Water';
|
|
|
|
const moveType = move.type;
|
|
if (moveType === 'Normal') {
|
|
if (abilities.includes('Aerilate')) return 'Flying';
|
|
if (abilities.includes('Galvanize')) return 'Electric';
|
|
if (abilities.includes('Pixilate')) return 'Fairy';
|
|
if (abilities.includes('Refrigerate')) return 'Ice';
|
|
}
|
|
return moveType;
|
|
}
|
|
|
|
// Generate random moveset for a given species, role, preferred type.
|
|
randomMoveset(
|
|
types: string[],
|
|
abilities: string[],
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
isLead: boolean,
|
|
movePool: string[],
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role,
|
|
): Set<string> {
|
|
const moves = new Set<string>();
|
|
let counter = this.newQueryMoves(moves, species, preferredType, abilities);
|
|
this.cullMovePool(types, moves, abilities, counter, movePool, teamDetails, species, isLead,
|
|
preferredType, role);
|
|
|
|
// If there are only four moves, add all moves and return early
|
|
if (movePool.length <= this.maxMoveCount) {
|
|
// Still need to ensure that multiple Hidden Powers are not added (if maxMoveCount is increased)
|
|
while (movePool.length) {
|
|
const moveid = this.sample(movePool);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
return moves;
|
|
}
|
|
|
|
const runEnforcementChecker = (checkerName: string) => {
|
|
if (!this.moveEnforcementCheckers[checkerName]) return false;
|
|
return this.moveEnforcementCheckers[checkerName](
|
|
movePool, moves, abilities, new Set(types), counter, species, teamDetails
|
|
);
|
|
};
|
|
|
|
// Add required move (e.g. Relic Song for Meloetta-P)
|
|
if (species.requiredMove) {
|
|
const move = this.dex.moves.get(species.requiredMove).id;
|
|
counter = this.addMove(move, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
|
|
// Add other moves you really want to have, e.g. STAB, recovery, setup.
|
|
|
|
// Enforce Facade if Guts is a possible ability
|
|
if (movePool.includes('facade') && abilities.includes('Guts')) {
|
|
counter = this.addMove('facade', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
|
|
// Enforce Aurora Veil, Blizzard, Seismic Toss, Spore, and Sticky Web
|
|
for (const moveid of ['auroraveil', 'blizzard', 'seismictoss', 'spore', 'stickyweb']) {
|
|
if (movePool.includes(moveid)) {
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// Enforce Thunder Wave on Prankster users
|
|
if (movePool.includes('thunderwave') && abilities.includes('Prankster')) {
|
|
counter = this.addMove('thunderwave', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
|
|
// Enforce Shadow Sneak on Kecleon
|
|
if (movePool.includes('shadowsneak') && species.id === 'kecleon') {
|
|
counter = this.addMove('shadowsneak', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
|
|
// Enforce Destiny Bond on Mega Banette, since that move is its entire reason to exist
|
|
if (movePool.includes('destinybond') && species.id === 'banettemega') {
|
|
counter = this.addMove('destinybond', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
|
|
// Enforce hazard removal on Bulky Support if the team doesn't already have it
|
|
if (role === 'Bulky Support' && !teamDetails.defog && !teamDetails.rapidSpin) {
|
|
if (movePool.includes('rapidspin')) {
|
|
counter = this.addMove('rapidspin', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
if (movePool.includes('defog')) {
|
|
counter = this.addMove('defog', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// Enforce STAB priority
|
|
if (['Bulky Attacker', 'Bulky Setup', 'Wallbreaker'].includes(role) || this.priorityPokemon.includes(species.id)) {
|
|
const priorityMoves = [];
|
|
for (const moveid of movePool) {
|
|
const move = this.dex.moves.get(moveid);
|
|
const moveType = this.getMoveType(move, species, abilities, preferredType);
|
|
if (types.includes(moveType) && move.priority > 0 && (move.basePower || move.basePowerCallback)) {
|
|
priorityMoves.push(moveid);
|
|
}
|
|
}
|
|
if (priorityMoves.length) {
|
|
const moveid = this.sample(priorityMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// Enforce STAB
|
|
for (const type of types) {
|
|
// Check if a STAB move of that type should be required
|
|
const stabMoves = [];
|
|
for (const moveid of movePool) {
|
|
const move = this.dex.moves.get(moveid);
|
|
const moveType = this.getMoveType(move, species, abilities, preferredType);
|
|
if (!this.noStab.includes(moveid) && (move.basePower || move.basePowerCallback) && type === moveType) {
|
|
stabMoves.push(moveid);
|
|
}
|
|
}
|
|
while (runEnforcementChecker(type)) {
|
|
if (!stabMoves.length) break;
|
|
const moveid = this.sampleNoReplace(stabMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// Enforce Preferred Type
|
|
if (!counter.get('preferred')) {
|
|
const stabMoves = [];
|
|
for (const moveid of movePool) {
|
|
const move = this.dex.moves.get(moveid);
|
|
const moveType = this.getMoveType(move, species, abilities, preferredType);
|
|
if (!this.noStab.includes(moveid) && (move.basePower || move.basePowerCallback) && preferredType === moveType) {
|
|
stabMoves.push(moveid);
|
|
}
|
|
}
|
|
if (stabMoves.length) {
|
|
const moveid = this.sample(stabMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// If no STAB move was added, add a STAB move
|
|
if (!counter.get('stab')) {
|
|
const stabMoves = [];
|
|
for (const moveid of movePool) {
|
|
const move = this.dex.moves.get(moveid);
|
|
const moveType = this.getMoveType(move, species, abilities, preferredType);
|
|
if (!this.noStab.includes(moveid) && (move.basePower || move.basePowerCallback) && types.includes(moveType)) {
|
|
stabMoves.push(moveid);
|
|
}
|
|
}
|
|
if (stabMoves.length) {
|
|
const moveid = this.sample(stabMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
} else {
|
|
// If they have no regular STAB move, enforce U-turn on Bug types.
|
|
if (movePool.includes('uturn') && types.includes('Bug')) {
|
|
counter = this.addMove('uturn', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enforce recovery
|
|
if (['Bulky Support', 'Bulky Attacker', 'Bulky Setup', 'Staller'].includes(role)) {
|
|
const recoveryMoves = movePool.filter(moveid => RECOVERY_MOVES.includes(moveid));
|
|
if (recoveryMoves.length) {
|
|
const moveid = this.sample(recoveryMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// Enforce Staller moves
|
|
if (role === 'Staller') {
|
|
const enforcedMoves = [...PROTECT_MOVES, 'toxic'];
|
|
for (const move of enforcedMoves) {
|
|
if (movePool.includes(move)) {
|
|
counter = this.addMove(move, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enforce setup
|
|
if (role.includes('Setup') || role === 'Z-Move user') {
|
|
// Prioritise other setup moves over Flame Charge
|
|
const setupMoves = movePool.filter(moveid => SETUP.includes(moveid) && moveid !== 'flamecharge');
|
|
if (setupMoves.length) {
|
|
const moveid = this.sample(setupMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
} else {
|
|
if (movePool.includes('flamecharge')) {
|
|
counter = this.addMove('flamecharge', moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enforce a move not on the noSTAB list
|
|
if (!counter.damagingMoves.size && !(moves.has('uturn') && types.includes('Bug'))) {
|
|
// Choose an attacking move
|
|
const attackingMoves = [];
|
|
for (const moveid of movePool) {
|
|
const move = this.dex.moves.get(moveid);
|
|
if (!this.noStab.includes(moveid) && (move.category !== 'Status')) attackingMoves.push(moveid);
|
|
}
|
|
if (attackingMoves.length) {
|
|
const moveid = this.sample(attackingMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
|
|
// Enforce coverage move
|
|
if (['Fast Attacker', 'Setup Sweeper', 'Bulky Attacker', 'Wallbreaker', 'Z-Move user'].includes(role)) {
|
|
if (counter.damagingMoves.size === 1) {
|
|
// Find the type of the current attacking move
|
|
const currentAttackType = counter.damagingMoves.values().next().value!.type;
|
|
// Choose an attacking move that is of different type to the current single attack
|
|
const coverageMoves = [];
|
|
for (const moveid of movePool) {
|
|
const move = this.dex.moves.get(moveid);
|
|
const moveType = this.getMoveType(move, species, abilities, preferredType);
|
|
if (!this.noStab.includes(moveid) && (move.basePower || move.basePowerCallback)) {
|
|
if (currentAttackType !== moveType) coverageMoves.push(moveid);
|
|
}
|
|
}
|
|
if (coverageMoves.length) {
|
|
const moveid = this.sample(coverageMoves);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Choose remaining moves randomly from movepool and add them to moves list:
|
|
while (moves.size < this.maxMoveCount && movePool.length) {
|
|
const moveid = this.sample(movePool);
|
|
counter = this.addMove(moveid, moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
for (const pair of MOVE_PAIRS) {
|
|
if (moveid === pair[0] && movePool.includes(pair[1])) {
|
|
counter = this.addMove(pair[1], moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
if (moveid === pair[1] && movePool.includes(pair[0])) {
|
|
counter = this.addMove(pair[0], moves, types, abilities, teamDetails, species, isLead,
|
|
movePool, preferredType, role);
|
|
}
|
|
}
|
|
}
|
|
return moves;
|
|
}
|
|
|
|
override shouldCullAbility(
|
|
ability: string,
|
|
types: Set<string>,
|
|
moves: Set<string>,
|
|
abilities: string[],
|
|
counter: MoveCounter,
|
|
movePool: string[],
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role
|
|
): boolean {
|
|
switch (ability) {
|
|
case 'Chlorophyll': case 'Solar Power':
|
|
return !teamDetails.sun;
|
|
case 'Hydration': case 'Swift Swim':
|
|
return !teamDetails.rain;
|
|
case 'Iron Fist': case 'Skill Link': case 'Technician':
|
|
return !counter.get(toID(ability));
|
|
case 'Overgrow':
|
|
return !counter.get('Grass');
|
|
case 'Prankster':
|
|
return !counter.get('Status');
|
|
case 'Rock Head':
|
|
return !counter.get('recoil');
|
|
case 'Sand Force': case 'Sand Rush':
|
|
return !teamDetails.sand;
|
|
case 'Slush Rush':
|
|
return !teamDetails.hail;
|
|
case 'Swarm':
|
|
return !counter.get('Bug');
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
override getAbility(
|
|
types: Set<string>,
|
|
moves: Set<string>,
|
|
abilities: string[],
|
|
counter: MoveCounter,
|
|
movePool: string[],
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role,
|
|
): string {
|
|
if (abilities.length <= 1) return abilities[0];
|
|
|
|
// Hard-code abilities here
|
|
if (species.id === 'pangoro' && counter.get('ironfist')) return 'Iron Fist';
|
|
if (species.id === 'tornadus' && counter.get('Status')) return 'Prankster';
|
|
if (species.id === 'marowak' && counter.get('recoil')) return 'Rock Head';
|
|
if (species.id === 'sawsbuck') return moves.has('headbutt') ? 'Serene Grace' : 'Sap Sipper';
|
|
if (species.id === 'toucannon' && counter.get('skilllink')) return 'Skill Link';
|
|
if (species.id === 'golduck' && teamDetails.rain) return 'Swift Swim';
|
|
if (species.id === 'roserade' && counter.get('technician')) return 'Technician';
|
|
|
|
const abilityAllowed: string[] = [];
|
|
// Obtain a list of abilities that are allowed (not culled)
|
|
for (const ability of abilities) {
|
|
if (!this.shouldCullAbility(
|
|
ability, types, moves, abilities, counter, movePool, teamDetails, species, preferredType, role
|
|
)) {
|
|
abilityAllowed.push(ability);
|
|
}
|
|
}
|
|
|
|
// Pick a random allowed ability
|
|
if (abilityAllowed.length >= 1) return this.sample(abilityAllowed);
|
|
|
|
// If all abilities are rejected, prioritize weather abilities over non-weather abilities
|
|
if (!abilityAllowed.length) {
|
|
const weatherAbilities = abilities.filter(
|
|
a => ['Chlorophyll', 'Hydration', 'Sand Force', 'Sand Rush', 'Slush Rush', 'Solar Power', 'Swift Swim'].includes(a)
|
|
);
|
|
if (weatherAbilities.length) return this.sample(weatherAbilities);
|
|
}
|
|
|
|
// Pick a random ability
|
|
return this.sample(abilities);
|
|
}
|
|
|
|
getPriorityItem(
|
|
ability: string,
|
|
types: string[],
|
|
moves: Set<string>,
|
|
counter: MoveCounter,
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
isLead: boolean,
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role,
|
|
): string | undefined {
|
|
// Z-Moves
|
|
if (role === 'Z-Move user') {
|
|
// Specific Z-Crystals
|
|
if (species.baseSpecies === 'Arceus' && species.requiredItems) return species.requiredItems[1];
|
|
if (species.name === 'Raichu-Alola') return 'Aloraichium Z';
|
|
if (species.name === 'Decidueye') return 'Decidium Z';
|
|
if (species.name === 'Incineroar') return 'Incinium Z';
|
|
if (species.name === 'Kommo-o') return 'Kommonium Z';
|
|
if (species.name === 'Lunala') return 'Lunalium Z';
|
|
if (species.baseSpecies === 'Lycanroc') return 'Lycanium Z';
|
|
if (species.name === 'Marshadow') return 'Marshadium Z';
|
|
if (species.name === 'Mew') return 'Mewnium Z';
|
|
if (species.name === 'Mimikyu') return 'Mimikium Z';
|
|
if (species.name === 'Necrozma-Dusk-Mane' || species.name === 'Necrozma-Dawn-Wings') {
|
|
if (moves.has('autotomize') && moves.has('sunsteelstrike')) return 'Solganium Z';
|
|
if (moves.has('autotomize') && moves.has('moongeistbeam')) return 'Lunalium Z';
|
|
return 'Ultranecrozium Z';
|
|
}
|
|
// General Z-Crystals
|
|
if (preferredType === 'Normal') return 'Normalium Z';
|
|
if (preferredType) return this.dex.species.get(`Arceus-${preferredType}`).requiredItems![1];
|
|
}
|
|
if (species.requiredItems) {
|
|
if (species.baseSpecies === 'Arceus') return species.requiredItems[0];
|
|
return this.sample(species.requiredItems);
|
|
}
|
|
if (role === 'AV Pivot') return 'Assault Vest';
|
|
if (species.name === 'Farfetch\u2019d') return 'Stick';
|
|
if (species.baseSpecies === 'Marowak') return 'Thick Club';
|
|
if (species.name === 'Pikachu') return 'Light Ball';
|
|
if (species.name === 'Shedinja' || species.name === 'Smeargle') return 'Focus Sash';
|
|
if (species.name === 'Unfezant' || moves.has('focusenergy')) return 'Scope Lens';
|
|
if (species.name === 'Unown') return 'Choice Specs';
|
|
if (species.name === 'Wobbuffet') return 'Custap Berry';
|
|
if (species.name === 'Shuckle') return 'Mental Herb';
|
|
if (species.name === 'Honchkrow') return 'Life Orb';
|
|
if (
|
|
ability === 'Harvest' || ability === 'Cheek Pouch' || (ability === 'Emergency Exit' && !!counter.get('Status'))
|
|
) return 'Sitrus Berry';
|
|
if (species.name === 'Ditto') return 'Choice Scarf';
|
|
if (ability === 'Poison Heal') return 'Toxic Orb';
|
|
if (ability === 'Speed Boost') return 'Life Orb';
|
|
if (species.nfe) return (species.name === 'Scyther' && role === 'Fast Attacker') ? 'Choice Band' : 'Eviolite';
|
|
if (['healingwish', 'memento', 'switcheroo', 'trick'].some(m => moves.has(m))) {
|
|
if (species.baseStats.spe >= 60 && species.baseStats.spe <= 108 && role !== 'Wallbreaker') {
|
|
return 'Choice Scarf';
|
|
} else {
|
|
return (counter.get('Physical') > counter.get('Special')) ? 'Choice Band' : 'Choice Specs';
|
|
}
|
|
}
|
|
if (moves.has('bellydrum') || moves.has('recycle')) {
|
|
if (ability === 'Gluttony') {
|
|
return `${this.sample(['Aguav', 'Figy', 'Iapapa', 'Mago', 'Wiki'])} Berry`;
|
|
} else {
|
|
return 'Sitrus Berry';
|
|
}
|
|
}
|
|
if (moves.has('waterspout')) return 'Choice Scarf';
|
|
if (moves.has('geomancy') || moves.has('skyattack')) return 'Power Herb';
|
|
if (moves.has('shellsmash')) {
|
|
return (ability === 'Solid Rock' && !!counter.get('priority')) ? 'Weakness Policy' : 'White Herb';
|
|
}
|
|
if ((ability === 'Guts' || moves.has('facade')) && !moves.has('sleeptalk') && species.id !== 'stoutland') {
|
|
return (types.includes('Fire') || ability === 'Quick Feet' || ability === 'Toxic Boost') ? 'Toxic Orb' : 'Flame Orb';
|
|
}
|
|
if (ability === 'Magic Guard') return moves.has('counter') ? 'Focus Sash' : 'Life Orb';
|
|
if (species.id === 'rampardos' && role === 'Fast Attacker') return 'Choice Scarf';
|
|
if (ability === 'Sheer Force' && counter.get('sheerforce')) return 'Life Orb';
|
|
if (ability === 'Unburden') return moves.has('closecombat') ? 'White Herb' : 'Sitrus Berry';
|
|
if (moves.has('acrobatics')) return '';
|
|
if (moves.has('auroraveil') || moves.has('lightscreen') && moves.has('reflect')) return 'Light Clay';
|
|
if (moves.has('rest') && !moves.has('sleeptalk') && !['Hydration', 'Natural Cure', 'Shed Skin'].includes(ability)) {
|
|
return 'Chesto Berry';
|
|
}
|
|
if (role === 'Staller') return 'Leftovers';
|
|
}
|
|
|
|
getItem(
|
|
ability: string,
|
|
types: string[],
|
|
moves: Set<string>,
|
|
counter: MoveCounter,
|
|
teamDetails: RandomTeamsTypes.TeamDetails,
|
|
species: Species,
|
|
isLead: boolean,
|
|
preferredType: string,
|
|
role: RandomTeamsTypes.Role,
|
|
): string {
|
|
const defensiveStatTotal = species.baseStats.hp + species.baseStats.def + species.baseStats.spd;
|
|
|
|
const scarfReqs = (
|
|
role !== 'Wallbreaker' &&
|
|
species.baseStats.spe >= 60 && species.baseStats.spe <= 109 &&
|
|
!counter.get('priority') && !moves.has('pursuit')
|
|
);
|
|
|
|
if (
|
|
moves.has('pursuit') && moves.has('suckerpunch') && counter.get('Dark') && !this.priorityPokemon.includes(species.id)
|
|
) return 'Black Glasses';
|
|
if (counter.get('Special') === 4) {
|
|
return (
|
|
scarfReqs && species.baseStats.spa >= 90 && this.randomChance(1, 2)
|
|
) ? 'Choice Scarf' : 'Choice Specs';
|
|
}
|
|
if (counter.get('Special') === 3 && moves.has('uturn')) return 'Choice Specs';
|
|
if (counter.get('Physical') === 4 && species.id !== 'jirachi' &&
|
|
['dragontail', 'fakeout', 'flamecharge', 'nuzzle', 'rapidspin'].every(m => !moves.has(m))
|
|
) {
|
|
return (
|
|
scarfReqs && (species.baseStats.atk >= 100 || ability === 'Pure Power' || ability === 'Huge Power') &&
|
|
this.randomChance(1, 2)
|
|
) ? 'Choice Scarf' : 'Choice Band';
|
|
}
|
|
|
|
if (ability === 'Sturdy' && moves.has('explosion') && !counter.get('speedsetup')) return 'Custap Berry';
|
|
if (types.includes('Normal') && moves.has('fakeout') && !!counter.get('Normal')) return 'Silk Scarf';
|
|
if (species.id === 'latias' || species.id === 'latios') return 'Soul Dew';
|
|
if (role === 'Bulky Setup' && (!!counter.get('speedsetup') || moves.has('shiftgear')) && !moves.has('swordsdance')) {
|
|
return 'Weakness Policy';
|
|
}
|
|
if (species.id === 'palkia') return 'Lustrous Orb';
|
|
if (species.id === 'archeops') return 'Expert Belt';
|
|
if (!counter.get('Status') && (
|
|
['Fast Support', 'Bulky Support', 'Bulky Attacker'].some(m => role === m) || moves.has('rapidspin')
|
|
)) {
|
|
return 'Assault Vest';
|
|
}
|
|
if (moves.has('outrage') && counter.get('setup')) return 'Lum Berry';
|
|
if (
|
|
(ability === 'Rough Skin') || (
|
|
species.id !== 'hooh' &&
|
|
ability === 'Regenerator' && species.baseStats.hp + species.baseStats.def >= 180 && this.randomChance(1, 2)
|
|
) || (
|
|
ability !== 'Regenerator' && !counter.get('setup') && counter.get('recovery') &&
|
|
this.dex.getEffectiveness('Fighting', species) < 1 &&
|
|
(species.baseStats.hp + species.baseStats.def) > 200 && this.randomChance(1, 2)
|
|
)
|
|
) return 'Rocky Helmet';
|
|
if (['kingsshield', 'protect', 'spikyshield', 'substitute'].some(m => moves.has(m))) return 'Leftovers';
|
|
if (
|
|
this.dex.getEffectiveness('Ground', species) >= 2 &&
|
|
ability !== 'Levitate' && species.id !== 'golemalola'
|
|
) {
|
|
return 'Air Balloon';
|
|
}
|
|
if (
|
|
(role === 'Fast Support' || moves.has('stickyweb')) && isLead && defensiveStatTotal < 255 &&
|
|
!counter.get('recovery') && (counter.get('hazards') || counter.get('setup')) &&
|
|
(!counter.get('recoil') || ability === 'Rock Head')
|
|
) return 'Focus Sash';
|
|
|
|
// Default Items
|
|
if (role === 'Fast Support') {
|
|
return (
|
|
counter.get('Physical') + counter.get('Special') >= 3 &&
|
|
['nuzzle', 'rapidspin', 'uturn', 'voltswitch'].every(m => !moves.has(m)) &&
|
|
this.dex.getEffectiveness('Rock', species) < 2
|
|
) ? 'Life Orb' : 'Leftovers';
|
|
}
|
|
if (!counter.get('Status')) {
|
|
return (
|
|
(moves.has('uturn') || moves.has('voltswitch')) && !counter.get('Dragon') && !counter.get('Normal')
|
|
) ? 'Expert Belt' : 'Life Orb';
|
|
}
|
|
if (
|
|
['Fast Attacker', 'Setup Sweeper', 'Wallbreaker'].some(m => role === m) &&
|
|
(this.dex.getEffectiveness('Rock', species) < 2 || species.id === 'ninjask') &&
|
|
ability !== 'Sturdy'
|
|
) return 'Life Orb';
|
|
return 'Leftovers';
|
|
}
|
|
|
|
override getLevel(species: Species): number {
|
|
// level set by rules
|
|
if (this.adjustLevel) return this.adjustLevel;
|
|
if (this.gen >= 2) {
|
|
// Revamped generations use random-sets.json
|
|
const sets = this.randomSets[species.id];
|
|
if (sets.level) return sets.level;
|
|
} else {
|
|
// Other generations use random-data.json
|
|
const data = this.randomData[species.id];
|
|
if (data.level) return data.level;
|
|
}
|
|
// Gen 2 still uses tier-based levelling
|
|
if (this.gen === 2) {
|
|
const levelScale: { [k: string]: number } = {
|
|
ZU: 81,
|
|
ZUBL: 79,
|
|
PU: 77,
|
|
PUBL: 75,
|
|
NU: 73,
|
|
NUBL: 71,
|
|
UU: 69,
|
|
UUBL: 67,
|
|
OU: 65,
|
|
Uber: 61,
|
|
};
|
|
if (levelScale[species.tier]) return levelScale[species.tier];
|
|
}
|
|
// Default to 80
|
|
return 80;
|
|
}
|
|
|
|
override randomSet(
|
|
species: string | Species,
|
|
teamDetails: RandomTeamsTypes.TeamDetails = {},
|
|
isLead = false
|
|
): RandomTeamsTypes.RandomSet {
|
|
const ruleTable = this.dex.formats.getRuleTable(this.format);
|
|
|
|
species = this.dex.species.get(species);
|
|
const forme = this.getForme(species);
|
|
const sets = this.randomSets[species.id]["sets"];
|
|
const possibleSets = [];
|
|
// Check if the Pokemon has a Z-Move user set
|
|
let canZMove = false;
|
|
for (const set of sets) {
|
|
if (!teamDetails.zMove && set.role === 'Z-Move user') canZMove = true;
|
|
}
|
|
for (const set of sets) {
|
|
// Prevent multiple Z-Move users
|
|
if (teamDetails.zMove && set.role === 'Z-Move user') continue;
|
|
// Prevent Setup Sweeper and Bulky Setup if Z-Move user is available
|
|
if (canZMove && ['Setup Sweeper', 'Bulky Setup'].includes(set.role)) continue;
|
|
possibleSets.push(set);
|
|
}
|
|
const set = this.sampleIfArray(possibleSets);
|
|
const role = set.role;
|
|
const movePool: string[] = Array.from(set.movepool);
|
|
const preferredTypes = set.preferredTypes;
|
|
const preferredType = this.sampleIfArray(preferredTypes) || '';
|
|
|
|
let ability = '';
|
|
let item = undefined;
|
|
|
|
const evs = { hp: 85, atk: 85, def: 85, spa: 85, spd: 85, spe: 85 };
|
|
const ivs = { hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31 };
|
|
|
|
const types = species.types;
|
|
const baseAbilities = set.abilities!;
|
|
// Use the mega's ability for moveset generation
|
|
const abilities = (species.battleOnly && !species.requiredAbility) ? Object.values(species.abilities) : baseAbilities;
|
|
|
|
// Get moves
|
|
const moves = this.randomMoveset(types, abilities, teamDetails, species, isLead, movePool,
|
|
preferredType, role);
|
|
const counter = this.newQueryMoves(moves, species, preferredType, abilities);
|
|
|
|
// Get ability
|
|
ability = this.getAbility(new Set(types), moves, baseAbilities, counter, movePool, teamDetails, species,
|
|
preferredType, role);
|
|
|
|
// Get items
|
|
item = this.getPriorityItem(ability, types, moves, counter, teamDetails, species, isLead, preferredType, role);
|
|
if (item === undefined) {
|
|
item = this.getItem(ability, types, moves, counter, teamDetails, species, isLead, preferredType, role);
|
|
}
|
|
|
|
// For Trick / Switcheroo
|
|
if (item === 'Leftovers' && types.includes('Poison')) {
|
|
item = 'Black Sludge';
|
|
}
|
|
|
|
const level = this.getLevel(species);
|
|
|
|
// Minimize confusion damage, including if Foul Play is its only physical attack
|
|
if (
|
|
(!counter.get('Physical') || (counter.get('Physical') <= 1 && (moves.has('foulplay') || moves.has('rapidspin')))) &&
|
|
!moves.has('copycat') && !moves.has('transform') &&
|
|
!ruleTable.has('forceofthefallenmod')
|
|
) {
|
|
evs.atk = 0;
|
|
ivs.atk = 0;
|
|
}
|
|
|
|
if (ability === 'Beast Boost' && !counter.get('Special')) {
|
|
evs.spa = 0;
|
|
ivs.spa = 0;
|
|
}
|
|
|
|
// We use a special variable to track Hidden Power
|
|
// so that we can check for all Hidden Powers at once
|
|
let hasHiddenPower = false;
|
|
for (const move of moves) {
|
|
if (move.startsWith('hiddenpower')) hasHiddenPower = true;
|
|
}
|
|
|
|
// Fix IVs for non-Bottle Cap-able sets
|
|
if (hasHiddenPower && level < 100) {
|
|
let hpType;
|
|
for (const move of moves) {
|
|
if (move.startsWith('hiddenpower')) hpType = move.substr(11);
|
|
}
|
|
if (!hpType) throw new Error(`hasHiddenPower is true, but no Hidden Power move was found.`);
|
|
const HPivs = ivs.atk === 0 ? ZeroAttackHPIVs[hpType] : this.dex.types.get(hpType).HPivs;
|
|
let iv: StatID;
|
|
for (iv in HPivs) {
|
|
ivs[iv] = HPivs[iv]!;
|
|
}
|
|
}
|
|
|
|
// Prepare optimal HP
|
|
const srImmunity = ability === 'Magic Guard';
|
|
const srWeakness = srImmunity ? 0 : this.dex.getEffectiveness('Rock', species);
|
|
while (evs.hp > 1) {
|
|
const hp = Math.floor(Math.floor(2 * species.baseStats.hp + ivs.hp + Math.floor(evs.hp / 4) + 100) * level / 100 + 10);
|
|
if (moves.has('substitute') && !['Black Sludge', 'Leftovers'].includes(item)) {
|
|
if (item === 'Sitrus Berry' || ability === 'Power Construct') {
|
|
// Two Substitutes should activate Sitrus Berry or Power Construct
|
|
if (hp % 4 === 0) break;
|
|
} else {
|
|
// Should be able to use Substitute four times from full HP without fainting
|
|
if (hp % 4 > 0) break;
|
|
}
|
|
} else if (moves.has('bellydrum') && (item === 'Sitrus Berry' || ability === 'Gluttony')) {
|
|
// Belly Drum should activate Sitrus Berry
|
|
if (hp % 2 === 0) break;
|
|
} else if (['highjumpkick', 'jumpkick'].some(m => moves.has(m))) {
|
|
// Crash damage move users want an odd HP to survive two misses
|
|
if (hp % 2 > 0) break;
|
|
} else {
|
|
// Maximize number of Stealth Rock switch-ins
|
|
if (srWeakness <= 0 || ability === 'Regenerator') break;
|
|
if (srWeakness === 1 && ['Black Sludge', 'Leftovers', 'Life Orb'].includes(item)) break;
|
|
if (item !== 'Sitrus Berry' && hp % (4 / srWeakness) > 0) break;
|
|
// Minimise number of Stealth Rock switch-ins to activate Sitrus Berry
|
|
if (item === 'Sitrus Berry' && hp % (4 / srWeakness) === 0) break;
|
|
}
|
|
evs.hp -= 4;
|
|
}
|
|
|
|
// Ensure Nihilego's Beast Boost gives it Special Attack boosts instead of Special Defense
|
|
if (forme === 'Nihilego') {
|
|
while (evs.spd > 1) {
|
|
const spa = Math.floor(Math.floor(2 * species.baseStats.spa + ivs.spa + Math.floor(evs.spa / 4)) * level / 100 + 5);
|
|
const spd = Math.floor(Math.floor(2 * species.baseStats.spd + ivs.spd + Math.floor(evs.spd / 4)) * level / 100 + 5);
|
|
if (spa >= spd) break;
|
|
evs.spd -= 4;
|
|
}
|
|
}
|
|
|
|
if (['gyroball', 'metalburst', 'trickroom'].some(m => moves.has(m))) {
|
|
evs.spe = 0;
|
|
ivs.spe = (hasHiddenPower && level < 100) ? ivs.spe - 30 : 0;
|
|
}
|
|
|
|
// shuffle moves to add more randomness to camomons
|
|
const shuffledMoves = Array.from(moves);
|
|
this.prng.shuffle(shuffledMoves);
|
|
|
|
// Z-Conversion Porygon-Z should have Shadow Ball first if no Recover, otherwise Thunderbolt
|
|
if (species.id === 'porygonz' && role === 'Z-Move user') {
|
|
const firstMove = (moves.has('shadowball') ? 'shadowball' : 'thunderbolt');
|
|
this.fastPop(shuffledMoves, shuffledMoves.indexOf(firstMove));
|
|
shuffledMoves.unshift(firstMove);
|
|
}
|
|
return {
|
|
name: species.baseSpecies,
|
|
species: forme,
|
|
gender: species.baseSpecies === 'Greninja' ? 'M' : (species.gender || (this.random(2) ? 'F' : 'M')),
|
|
shiny: this.randomChance(1, 1024),
|
|
level,
|
|
moves: shuffledMoves,
|
|
ability,
|
|
evs,
|
|
ivs,
|
|
item,
|
|
role,
|
|
};
|
|
}
|
|
|
|
override randomTeam() {
|
|
this.enforceNoDirectCustomBanlistChanges();
|
|
|
|
const seed = this.prng.getSeed();
|
|
const ruleTable = this.dex.formats.getRuleTable(this.format);
|
|
const pokemon: RandomTeamsTypes.RandomSet[] = [];
|
|
|
|
// For Monotype
|
|
const isMonotype = !!this.forceMonotype || ruleTable.has('sametypeclause');
|
|
const typePool = this.dex.types.names();
|
|
const type = this.forceMonotype || this.sample(typePool);
|
|
|
|
const baseFormes: { [k: string]: number } = {};
|
|
let hasMega = false;
|
|
|
|
const typeCount: { [k: string]: number } = {};
|
|
const typeComboCount: { [k: string]: number } = {};
|
|
const typeWeaknesses: { [k: string]: number } = {};
|
|
const typeDoubleWeaknesses: { [k: string]: number } = {};
|
|
const teamDetails: RandomTeamsTypes.TeamDetails = {};
|
|
let numMaxLevelPokemon = 0;
|
|
|
|
// We make at most two passes through the potential Pokemon pool when creating a team - if the first pass doesn't
|
|
// result in a team of six Pokemon we perform a second iteration relaxing as many restrictions as possible.
|
|
for (const restrict of [true, false]) {
|
|
if (pokemon.length >= this.maxTeamSize) break;
|
|
|
|
const pokemonList = Object.keys(this.randomSets);
|
|
const [pokemonPool, baseSpeciesPool] = this.getPokemonPool(type, pokemon, isMonotype, pokemonList);
|
|
while (baseSpeciesPool.length && pokemon.length < this.maxTeamSize) {
|
|
const baseSpecies = this.sampleNoReplace(baseSpeciesPool);
|
|
const currentSpeciesPool: Species[] = [];
|
|
// Check if the base species has a mega forme available
|
|
let canMega = false;
|
|
for (const poke of pokemonPool[baseSpecies]) {
|
|
const species = this.dex.species.get(poke);
|
|
if (!hasMega && species.isMega) canMega = true;
|
|
}
|
|
for (const poke of pokemonPool[baseSpecies]) {
|
|
const species = this.dex.species.get(poke);
|
|
// Prevent multiple megas
|
|
if (hasMega && species.isMega) continue;
|
|
// Prevent base forme, if a mega is available
|
|
if (canMega && !species.isMega) continue;
|
|
currentSpeciesPool.push(species);
|
|
}
|
|
const species = this.sample(currentSpeciesPool);
|
|
|
|
if (!species.exists) continue;
|
|
|
|
// Limit to one of each species (Species Clause)
|
|
if (baseFormes[species.baseSpecies]) continue;
|
|
|
|
// Limit one Mega per team
|
|
if (hasMega && species.isMega) continue;
|
|
|
|
const types = species.types;
|
|
const typeCombo = types.slice().sort().join();
|
|
const weakToFreezeDry = (
|
|
this.dex.getEffectiveness('Ice', species) > 0 ||
|
|
(this.dex.getEffectiveness('Ice', species) > -2 && types.includes('Water'))
|
|
);
|
|
// Dynamically scale limits for different team sizes. The default and minimum value is 1.
|
|
const limitFactor = Math.round(this.maxTeamSize / 6) || 1;
|
|
|
|
if (restrict) {
|
|
if (!isMonotype && !this.forceMonotype) {
|
|
// Limit two of any type
|
|
let skip = false;
|
|
for (const typeName of types) {
|
|
if (typeCount[typeName] >= 2 * limitFactor) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
if (skip) continue;
|
|
|
|
// Limit three weak to any type, and one double weak to any type
|
|
for (const typeName of this.dex.types.names()) {
|
|
// it's weak to the type
|
|
if (this.dex.getEffectiveness(typeName, species) > 0) {
|
|
if (!typeWeaknesses[typeName]) typeWeaknesses[typeName] = 0;
|
|
if (typeWeaknesses[typeName] >= 3 * limitFactor) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
if (this.dex.getEffectiveness(typeName, species) > 0) {
|
|
if (!typeDoubleWeaknesses[typeName]) typeDoubleWeaknesses[typeName] = 0;
|
|
if (typeDoubleWeaknesses[typeName] >= limitFactor) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (skip) continue;
|
|
|
|
// Count Dry Skin/Fluffy as Fire weaknesses
|
|
if (
|
|
this.dex.getEffectiveness('Fire', species) === 0 &&
|
|
Object.values(species.abilities).filter(a => ['Dry Skin', 'Fluffy'].includes(a)).length
|
|
) {
|
|
if (!typeWeaknesses['Fire']) typeWeaknesses['Fire'] = 0;
|
|
if (typeWeaknesses['Fire'] >= 3 * limitFactor) continue;
|
|
}
|
|
|
|
// Limit four weak to Freeze-Dry
|
|
if (weakToFreezeDry) {
|
|
if (!typeWeaknesses['Freeze-Dry']) typeWeaknesses['Freeze-Dry'] = 0;
|
|
if (typeWeaknesses['Freeze-Dry'] >= 4 * limitFactor) continue;
|
|
}
|
|
|
|
// Limit one level 100 Pokemon
|
|
if (!this.adjustLevel && (this.getLevel(species) === 100) && numMaxLevelPokemon >= limitFactor) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Limit three of any type combination in Monotype
|
|
if (!this.forceMonotype && isMonotype && (typeComboCount[typeCombo] >= 3 * limitFactor)) continue;
|
|
}
|
|
|
|
const set = this.randomSet(
|
|
species,
|
|
teamDetails,
|
|
pokemon.length === this.maxTeamSize - 1
|
|
);
|
|
|
|
const item = this.dex.items.get(set.item);
|
|
|
|
// Limit one Z-Move per team
|
|
if (item.zMove && teamDetails.zMove) continue;
|
|
|
|
// Zoroark copies the last Pokemon and should not be generated in that slot
|
|
if (set.ability === 'Illusion' && pokemon.length < 1) continue;
|
|
|
|
// Okay, the set passes, add it to our team
|
|
pokemon.unshift(set);
|
|
|
|
// Don't bother tracking details for the last Pokemon
|
|
if (pokemon.length === this.maxTeamSize) break;
|
|
|
|
// Now that our Pokemon has passed all checks, we can increment our counters
|
|
baseFormes[species.baseSpecies] = 1;
|
|
|
|
// Increment type counters
|
|
for (const typeName of types) {
|
|
if (typeName in typeCount) {
|
|
typeCount[typeName]++;
|
|
} else {
|
|
typeCount[typeName] = 1;
|
|
}
|
|
}
|
|
if (typeCombo in typeComboCount) {
|
|
typeComboCount[typeCombo]++;
|
|
} else {
|
|
typeComboCount[typeCombo] = 1;
|
|
}
|
|
|
|
// Increment weakness counter
|
|
for (const typeName of this.dex.types.names()) {
|
|
// it's weak to the type
|
|
if (this.dex.getEffectiveness(typeName, species) > 0) {
|
|
typeWeaknesses[typeName]++;
|
|
}
|
|
if (this.dex.getEffectiveness(typeName, species) > 1) {
|
|
typeDoubleWeaknesses[typeName]++;
|
|
}
|
|
}
|
|
// Count Dry Skin/Fluffy as Fire weaknesses
|
|
if (['Dry Skin', 'Fluffy'].includes(set.ability) && this.dex.getEffectiveness('Fire', species) === 0) {
|
|
typeWeaknesses['Fire']++;
|
|
}
|
|
if (weakToFreezeDry) typeWeaknesses['Freeze-Dry']++;
|
|
|
|
// Increment level 100 counter
|
|
if (set.level === 100) numMaxLevelPokemon++;
|
|
|
|
// Track what the team has
|
|
if (item.megaStone || species.name === 'Rayquaza-Mega') hasMega = true;
|
|
if (item.zMove) teamDetails.zMove = 1;
|
|
if (set.ability === 'Snow Warning' || set.moves.includes('hail')) teamDetails.hail = 1;
|
|
if (set.moves.includes('raindance') || set.ability === 'Drizzle' && !item.isPrimalOrb) teamDetails.rain = 1;
|
|
if (set.ability === 'Sand Stream') teamDetails.sand = 1;
|
|
if (set.moves.includes('sunnyday') || set.ability === 'Drought' && !item.isPrimalOrb) teamDetails.sun = 1;
|
|
if (set.moves.includes('aromatherapy') || set.moves.includes('healbell')) teamDetails.statusCure = 1;
|
|
if (set.moves.includes('spikes')) teamDetails.spikes = (teamDetails.spikes || 0) + 1;
|
|
if (set.moves.includes('stealthrock')) teamDetails.stealthRock = 1;
|
|
if (set.moves.includes('stickyweb')) teamDetails.stickyWeb = 1;
|
|
if (set.moves.includes('toxicspikes')) teamDetails.toxicSpikes = 1;
|
|
if (set.moves.includes('defog')) teamDetails.defog = 1;
|
|
if (set.moves.includes('rapidspin')) teamDetails.rapidSpin = 1;
|
|
if (set.moves.includes('auroraveil') || (set.moves.includes('reflect') && set.moves.includes('lightscreen'))) {
|
|
teamDetails.screens = 1;
|
|
}
|
|
}
|
|
}
|
|
if (pokemon.length < this.maxTeamSize && pokemon.length < 12) {
|
|
throw new Error(`Could not build a random team for ${this.format} (seed=${seed})`);
|
|
}
|
|
return pokemon;
|
|
}
|
|
|
|
override randomFactorySets: {
|
|
[format: string]: { [species: string]: BattleFactorySpecies },
|
|
} = require('./factory-sets.json');
|
|
|
|
override randomFactorySet(
|
|
species: Species, teamData: RandomTeamsTypes.FactoryTeamDetails, tier: string
|
|
): RandomTeamsTypes.RandomFactorySet | null {
|
|
const id = toID(species.name);
|
|
const setList = this.randomFactorySets[tier][id].sets;
|
|
|
|
const itemsMax: { [k: string]: number } = {
|
|
choicespecs: 1,
|
|
choiceband: 1,
|
|
choicescarf: 1,
|
|
};
|
|
const movesMax: { [k: string]: number } = {
|
|
rapidspin: 1,
|
|
batonpass: 1,
|
|
stealthrock: 1,
|
|
defog: 1,
|
|
spikes: 1,
|
|
toxicspikes: 1,
|
|
};
|
|
const requiredMoves: { [k: string]: string } = {
|
|
stealthrock: 'hazardSet',
|
|
rapidspin: 'hazardClear',
|
|
defog: 'hazardClear',
|
|
};
|
|
const weatherAbilitiesRequire: { [k: string]: string } = {
|
|
hydration: 'raindance', swiftswim: 'raindance',
|
|
leafguard: 'sunnyday', solarpower: 'sunnyday', chlorophyll: 'sunnyday',
|
|
sandforce: 'sandstorm', sandrush: 'sandstorm', sandveil: 'sandstorm',
|
|
slushrush: 'hail', snowcloak: 'hail',
|
|
};
|
|
const weatherAbilities = ['drizzle', 'drought', 'snowwarning', 'sandstream'];
|
|
|
|
// Build a pool of eligible sets, given the team partners
|
|
// Also keep track of sets with moves the team requires
|
|
let effectivePool: { set: AnyObject, moveVariants?: number[], item?: string, ability?: string }[] = [];
|
|
const priorityPool = [];
|
|
for (const curSet of setList) {
|
|
if (this.forceMonotype && !species.types.includes(this.forceMonotype)) continue;
|
|
|
|
// reject disallowed items
|
|
const allowedItems: string[] = [];
|
|
for (const itemString of curSet.item) {
|
|
const item = this.dex.items.get(itemString);
|
|
if (teamData.megaCount && teamData.megaCount > 0 && item.megaStone) continue; // reject 2+ mega stones
|
|
if (teamData.zCount && teamData.zCount > 0 && item.zMove) continue; // reject 2+ Z stones
|
|
if (itemsMax[item.id] && teamData.has[item.id] >= itemsMax[item.id]) continue; // reject 2+ same choice item
|
|
allowedItems.push(itemString);
|
|
}
|
|
if (allowedItems.length === 0) continue;
|
|
const curSetItem = this.sample(allowedItems);
|
|
|
|
// reject bad weather abilities
|
|
const allowedAbilities: string[] = [];
|
|
for (const abilityString of curSet.ability) {
|
|
const ability = this.dex.abilities.get(abilityString);
|
|
if (weatherAbilitiesRequire[ability.id] && teamData.weather !== weatherAbilitiesRequire[ability.id]) continue;
|
|
if (teamData.weather && weatherAbilities.includes(ability.id)) continue; // reject 2+ weather setters
|
|
allowedAbilities.push(abilityString);
|
|
}
|
|
if (allowedAbilities.length === 0) continue;
|
|
const curSetAbility = this.sample(allowedAbilities);
|
|
|
|
let reject = false;
|
|
let hasRequiredMove = false;
|
|
const curSetVariants = [];
|
|
for (const move of curSet.moves) {
|
|
const variantIndex = this.random(move.length);
|
|
const moveId = toID(move[variantIndex]);
|
|
if (movesMax[moveId] && teamData.has[moveId] >= movesMax[moveId]) {
|
|
reject = true;
|
|
break;
|
|
}
|
|
if (requiredMoves[moveId] && !teamData.has[requiredMoves[moveId]]) {
|
|
hasRequiredMove = true;
|
|
}
|
|
curSetVariants.push(variantIndex);
|
|
}
|
|
if (reject) continue;
|
|
|
|
const fullSetSpec = { set: curSet, moveVariants: curSetVariants, item: curSetItem, ability: curSetAbility };
|
|
effectivePool.push(fullSetSpec);
|
|
if (hasRequiredMove) priorityPool.push(fullSetSpec);
|
|
}
|
|
if (priorityPool.length) effectivePool = priorityPool;
|
|
|
|
if (!effectivePool.length) {
|
|
if (!teamData.forceResult) return null;
|
|
for (const curSet of setList) {
|
|
effectivePool.push({ set: curSet });
|
|
}
|
|
}
|
|
|
|
const setData = this.sample(effectivePool);
|
|
const moves = [];
|
|
for (const [i, moveSlot] of setData.set.moves.entries()) {
|
|
moves.push(setData.moveVariants ? moveSlot[setData.moveVariants[i]] : this.sample(moveSlot));
|
|
}
|
|
|
|
const item = setData.item || this.sampleIfArray(setData.set.item);
|
|
const ability = setData.ability || this.sampleIfArray(setData.set.ability);
|
|
const nature = this.sampleIfArray(setData.set.nature);
|
|
const level = this.adjustLevel || setData.set.level || (tier === "LC" ? 5 : 100);
|
|
|
|
return {
|
|
name: setData.set.name || species.baseSpecies,
|
|
species: setData.set.species,
|
|
gender: setData.set.gender || species.gender || (this.randomChance(1, 2) ? 'M' : 'F'),
|
|
item: item || '',
|
|
ability: ability || species.abilities['0'],
|
|
shiny: typeof setData.set.shiny === 'undefined' ? this.randomChance(1, 1024) : setData.set.shiny,
|
|
level,
|
|
happiness: typeof setData.set.happiness === 'undefined' ? 255 : setData.set.happiness,
|
|
evs: { hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0, ...setData.set.evs },
|
|
ivs: { hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31, ...setData.set.ivs },
|
|
nature: nature || 'Serious',
|
|
moves,
|
|
};
|
|
}
|
|
|
|
override randomFactoryTeam(side: PlayerOptions, depth = 0): RandomTeamsTypes.RandomFactorySet[] {
|
|
this.enforceNoDirectCustomBanlistChanges();
|
|
|
|
const forceResult = (depth >= 12);
|
|
const isMonotype = !!this.forceMonotype || this.dex.formats.getRuleTable(this.format).has('sametypeclause');
|
|
|
|
// The teams generated depend on the tier choice in such a way that
|
|
// no exploitable information is leaked from rolling the tier in getTeam(p1).
|
|
if (!this.factoryTier) {
|
|
this.factoryTier = isMonotype ? 'Mono' : this.sample(['Uber', 'OU', 'UU', 'RU', 'NU', 'PU', 'LC']);
|
|
} else if (isMonotype && this.factoryTier !== 'Mono') {
|
|
// I don't think this can ever happen?
|
|
throw new Error(`Can't generate a Monotype Battle Factory set in a battle with factory tier ${this.factoryTier}`);
|
|
}
|
|
|
|
const tierValues: { [k: string]: number } = {
|
|
Uber: 5,
|
|
OU: 4, UUBL: 4,
|
|
UU: 3, RUBL: 3,
|
|
RU: 2, NUBL: 2,
|
|
NU: 1, PUBL: 1,
|
|
PU: 0,
|
|
};
|
|
|
|
const pokemon = [];
|
|
const pokemonPool = Object.keys(this.randomFactorySets[this.factoryTier]);
|
|
|
|
const typePool = this.dex.types.names();
|
|
const type = this.sample(typePool);
|
|
|
|
const teamData: TeamData = {
|
|
typeCount: {}, typeComboCount: {}, baseFormes: {}, megaCount: 0, zCount: 0,
|
|
has: {}, forceResult, weaknesses: {}, resistances: {},
|
|
};
|
|
const requiredMoveFamilies = ['hazardSet', 'hazardClear'];
|
|
const requiredMoves: { [k: string]: string } = {
|
|
stealthrock: 'hazardSet',
|
|
rapidspin: 'hazardClear',
|
|
defog: 'hazardClear',
|
|
};
|
|
const weatherAbilitiesSet: { [k: string]: string } = {
|
|
drizzle: 'raindance',
|
|
drought: 'sunnyday',
|
|
snowwarning: 'hail',
|
|
sandstream: 'sandstorm',
|
|
};
|
|
const resistanceAbilities: { [k: string]: string[] } = {
|
|
dryskin: ['Water'], waterabsorb: ['Water'], stormdrain: ['Water'],
|
|
flashfire: ['Fire'], heatproof: ['Fire'],
|
|
lightningrod: ['Electric'], motordrive: ['Electric'], voltabsorb: ['Electric'],
|
|
sapsipper: ['Grass'],
|
|
thickfat: ['Ice', 'Fire'],
|
|
levitate: ['Ground'],
|
|
};
|
|
|
|
while (pokemonPool.length && pokemon.length < this.maxTeamSize) {
|
|
const species = this.dex.species.get(this.sampleNoReplace(pokemonPool));
|
|
if (!species.exists) continue;
|
|
|
|
// Lessen the need of deleting sets of Pokemon after tier shifts
|
|
if (
|
|
this.factoryTier in tierValues && species.tier in tierValues &&
|
|
tierValues[species.tier] > tierValues[this.factoryTier]
|
|
) continue;
|
|
|
|
const speciesFlags = this.randomFactorySets[this.factoryTier][species.id].flags;
|
|
|
|
// Limit to one of each species (Species Clause)
|
|
if (teamData.baseFormes[species.baseSpecies]) continue;
|
|
|
|
// Limit the number of Megas to one
|
|
if (!teamData.megaCount) teamData.megaCount = 0;
|
|
if (teamData.megaCount >= 1 && speciesFlags.megaOnly) continue;
|
|
|
|
const set = this.randomFactorySet(species, teamData, this.factoryTier);
|
|
if (!set) continue;
|
|
|
|
const itemData = this.dex.items.get(set.item);
|
|
|
|
// Actually limit the number of Megas to one
|
|
if (teamData.megaCount >= 1 && itemData.megaStone) continue;
|
|
|
|
// Limit the number of Z moves to one
|
|
if (teamData.zCount && teamData.zCount >= 1 && itemData.zMove) continue;
|
|
|
|
let types = species.types;
|
|
// Dynamically scale limits for different team sizes. The default and minimum value is 1.
|
|
const limitFactor = Math.round(this.maxTeamSize / 6) || 1;
|
|
|
|
// Enforce Monotype
|
|
if (isMonotype) {
|
|
// Prevents Mega Evolutions from breaking the type limits
|
|
if (itemData.megaStone) {
|
|
const megaSpecies = this.dex.species.get(Object.values(itemData.megaStone)[0]);
|
|
if (types.length > megaSpecies.types.length) types = [species.types[0]];
|
|
// Only check the second type because a Mega Evolution should always share the first type with its base forme.
|
|
if (megaSpecies.types[1] && types[1] && megaSpecies.types[1] !== types[1]) {
|
|
types = [megaSpecies.types[0]];
|
|
}
|
|
}
|
|
if (!types.includes(type)) continue;
|
|
} else {
|
|
// If not Monotype, limit to two of each type
|
|
let skip = false;
|
|
for (const typeName of types) {
|
|
if (teamData.typeCount[typeName] >= 2 * limitFactor && this.randomChance(4, 5)) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
if (skip) continue;
|
|
|
|
// Limit 1 of any type combination
|
|
let typeCombo = types.slice().sort().join();
|
|
if (set.ability === 'Drought' || set.ability === 'Drizzle') {
|
|
// Drought and Drizzle don't count towards the type combo limit
|
|
typeCombo = set.ability;
|
|
}
|
|
if (teamData.typeComboCount[typeCombo] >= limitFactor) continue;
|
|
}
|
|
|
|
// Okay, the set passes, add it to our team
|
|
pokemon.push(set);
|
|
const typeCombo = types.slice().sort().join();
|
|
// Now that our Pokemon has passed all checks, we can update team data:
|
|
for (const typeName of types) {
|
|
if (typeName in teamData.typeCount) {
|
|
teamData.typeCount[typeName]++;
|
|
} else {
|
|
teamData.typeCount[typeName] = 1;
|
|
}
|
|
}
|
|
teamData.typeComboCount[typeCombo] = (teamData.typeComboCount[typeCombo] + 1) || 1;
|
|
|
|
teamData.baseFormes[species.baseSpecies] = 1;
|
|
|
|
if (itemData.megaStone) teamData.megaCount++;
|
|
if (itemData.zMove) {
|
|
if (!teamData.zCount) teamData.zCount = 0;
|
|
teamData.zCount++;
|
|
}
|
|
if (itemData.id in teamData.has) {
|
|
teamData.has[itemData.id]++;
|
|
} else {
|
|
teamData.has[itemData.id] = 1;
|
|
}
|
|
|
|
const abilityState = this.dex.abilities.get(set.ability);
|
|
if (abilityState.id in weatherAbilitiesSet) {
|
|
teamData.weather = weatherAbilitiesSet[abilityState.id];
|
|
}
|
|
|
|
for (const move of set.moves) {
|
|
const moveId = toID(move);
|
|
if (moveId in teamData.has) {
|
|
teamData.has[moveId]++;
|
|
} else {
|
|
teamData.has[moveId] = 1;
|
|
}
|
|
if (moveId in requiredMoves) {
|
|
teamData.has[requiredMoves[moveId]] = 1;
|
|
}
|
|
}
|
|
|
|
for (const typeName of this.dex.types.names()) {
|
|
// Cover any major weakness (3+) with at least one resistance
|
|
if (teamData.resistances[typeName] >= 1) continue;
|
|
if (resistanceAbilities[abilityState.id]?.includes(typeName) || !this.dex.getImmunity(typeName, types)) {
|
|
// Heuristic: assume that Pokémon with these abilities don't have (too) negative typing.
|
|
teamData.resistances[typeName] = (teamData.resistances[typeName] || 0) + 1;
|
|
if (teamData.resistances[typeName] >= 1) teamData.weaknesses[typeName] = 0;
|
|
continue;
|
|
}
|
|
const typeMod = this.dex.getEffectiveness(typeName, types);
|
|
if (typeMod < 0) {
|
|
teamData.resistances[typeName] = (teamData.resistances[typeName] || 0) + 1;
|
|
if (teamData.resistances[typeName] >= 1) teamData.weaknesses[typeName] = 0;
|
|
} else if (typeMod > 0) {
|
|
teamData.weaknesses[typeName] = (teamData.weaknesses[typeName] || 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
if (pokemon.length < this.maxTeamSize) return this.randomFactoryTeam(side, ++depth);
|
|
|
|
// Quality control
|
|
if (!teamData.forceResult) {
|
|
for (const requiredFamily of requiredMoveFamilies) {
|
|
if (!teamData.has[requiredFamily]) return this.randomFactoryTeam(side, ++depth);
|
|
}
|
|
for (const typeName in teamData.weaknesses) {
|
|
if (teamData.weaknesses[typeName] >= 3) return this.randomFactoryTeam(side, ++depth);
|
|
}
|
|
}
|
|
|
|
return pokemon;
|
|
}
|
|
|
|
override randomBSSFactorySets: AnyObject = require('./bss-factory-sets.json');
|
|
|
|
override randomBSSFactorySet(
|
|
species: Species, teamData: RandomTeamsTypes.FactoryTeamDetails
|
|
): RandomTeamsTypes.RandomFactorySet | null {
|
|
const id = toID(species.name);
|
|
// const flags = this.randomBSSFactorySets[tier][id].flags;
|
|
const setList = this.randomBSSFactorySets[id].sets;
|
|
|
|
const movesMax: { [k: string]: number } = {
|
|
batonpass: 1,
|
|
stealthrock: 1,
|
|
spikes: 1,
|
|
toxicspikes: 1,
|
|
doubleedge: 1,
|
|
trickroom: 1,
|
|
};
|
|
const requiredMoves: { [k: string]: number } = {};
|
|
const weatherAbilitiesRequire: { [k: string]: string } = {
|
|
swiftswim: 'raindance',
|
|
sandrush: 'sandstorm', sandveil: 'sandstorm',
|
|
};
|
|
const weatherAbilities = ['drizzle', 'drought', 'snowwarning', 'sandstream'];
|
|
|
|
// Build a pool of eligible sets, given the team partners
|
|
// Also keep track of sets with moves the team requires
|
|
let effectivePool: { set: AnyObject, moveVariants?: number[], itemVariants?: number, abilityVariants?: number }[] = [];
|
|
const priorityPool = [];
|
|
for (const curSet of setList) {
|
|
if (this.forceMonotype && !species.types.includes(this.forceMonotype)) continue;
|
|
|
|
const item = this.dex.items.get(curSet.item);
|
|
if (teamData.megaCount && teamData.megaCount > 1 && item.megaStone) continue; // reject 3+ mega stones
|
|
if (teamData.zCount && teamData.zCount > 1 && item.zMove) continue; // reject 3+ Z stones
|
|
if (teamData.has[item.id]) continue; // Item clause
|
|
|
|
const ability = this.dex.abilities.get(curSet.ability);
|
|
if (weatherAbilitiesRequire[ability.id] && teamData.weather !== weatherAbilitiesRequire[ability.id]) continue;
|
|
if (teamData.weather && weatherAbilities.includes(ability.id)) continue; // reject 2+ weather setters
|
|
|
|
if (curSet.species === 'Aron' && teamData.weather !== 'sandstorm') continue; // reject Aron without a Sand Stream user
|
|
|
|
let reject = false;
|
|
let hasRequiredMove = false;
|
|
const curSetVariants = [];
|
|
for (const move of curSet.moves) {
|
|
const variantIndex = this.random(move.length);
|
|
const moveId = toID(move[variantIndex]);
|
|
if (movesMax[moveId] && teamData.has[moveId] >= movesMax[moveId]) {
|
|
reject = true;
|
|
break;
|
|
}
|
|
if (requiredMoves[moveId] && !teamData.has[requiredMoves[moveId]]) {
|
|
hasRequiredMove = true;
|
|
}
|
|
curSetVariants.push(variantIndex);
|
|
}
|
|
if (reject) continue;
|
|
effectivePool.push({ set: curSet, moveVariants: curSetVariants });
|
|
if (hasRequiredMove) priorityPool.push({ set: curSet, moveVariants: curSetVariants });
|
|
}
|
|
if (priorityPool.length) effectivePool = priorityPool;
|
|
|
|
if (!effectivePool.length) {
|
|
if (!teamData.forceResult) return null;
|
|
for (const curSet of setList) {
|
|
effectivePool.push({ set: curSet });
|
|
}
|
|
}
|
|
|
|
const setData = this.sample(effectivePool);
|
|
const moves = [];
|
|
for (const [i, moveSlot] of setData.set.moves.entries()) {
|
|
moves.push(setData.moveVariants ? moveSlot[setData.moveVariants[i]] : this.sample(moveSlot));
|
|
}
|
|
|
|
return {
|
|
name: setData.set.nickname || setData.set.name || species.baseSpecies,
|
|
species: setData.set.species,
|
|
gender: setData.set.gender || species.gender || (this.randomChance(1, 2) ? 'M' : 'F'),
|
|
item: this.sampleIfArray(setData.set.item) || '',
|
|
ability: setData.set.ability || species.abilities['0'],
|
|
shiny: typeof setData.set.shiny === 'undefined' ? this.randomChance(1, 1024) : setData.set.shiny,
|
|
level: setData.set.level || 50,
|
|
happiness: typeof setData.set.happiness === 'undefined' ? 255 : setData.set.happiness,
|
|
evs: { hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0, ...setData.set.evs },
|
|
ivs: { hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31, ...setData.set.ivs },
|
|
nature: setData.set.nature || 'Serious',
|
|
moves,
|
|
};
|
|
}
|
|
|
|
override randomBSSFactoryTeam(side: PlayerOptions, depth = 0): RandomTeamsTypes.RandomFactorySet[] {
|
|
this.enforceNoDirectCustomBanlistChanges();
|
|
|
|
const forceResult = (depth >= 4);
|
|
|
|
const pokemon = [];
|
|
|
|
const pokemonPool = Object.keys(this.randomBSSFactorySets);
|
|
|
|
const teamData: TeamData = {
|
|
typeCount: {}, typeComboCount: {}, baseFormes: {}, megaCount: 0, zCount: 0,
|
|
eeveeLimCount: 0, has: {}, forceResult, weaknesses: {}, resistances: {},
|
|
};
|
|
const requiredMoveFamilies: string[] = [];
|
|
const requiredMoves: { [k: string]: string } = {};
|
|
const weatherAbilitiesSet: { [k: string]: string } = {
|
|
drizzle: 'raindance',
|
|
drought: 'sunnyday',
|
|
snowwarning: 'hail',
|
|
sandstream: 'sandstorm',
|
|
};
|
|
const resistanceAbilities: { [k: string]: string[] } = {
|
|
waterabsorb: ['Water'],
|
|
flashfire: ['Fire'],
|
|
lightningrod: ['Electric'], voltabsorb: ['Electric'],
|
|
thickfat: ['Ice', 'Fire'],
|
|
levitate: ['Ground'],
|
|
};
|
|
|
|
while (pokemonPool.length && pokemon.length < this.maxTeamSize) {
|
|
const species = this.dex.species.get(this.sampleNoReplace(pokemonPool));
|
|
if (!species.exists) continue;
|
|
|
|
const speciesFlags = this.randomBSSFactorySets[species.id].flags;
|
|
if (!teamData.megaCount) teamData.megaCount = 0;
|
|
|
|
// Limit to one of each species (Species Clause)
|
|
if (teamData.baseFormes[species.baseSpecies]) continue;
|
|
|
|
// Limit the number of Megas + Z-moves to 3
|
|
if (teamData.megaCount + (teamData.zCount ? teamData.zCount : 0) >= 3 && speciesFlags.megaOnly) continue;
|
|
|
|
// Dynamically scale limits for different team sizes. The default and minimum value is 1.
|
|
const limitFactor = Math.round(this.maxTeamSize / 6) || 1;
|
|
|
|
// Limit 2 of any type
|
|
const types = species.types;
|
|
let skip = false;
|
|
for (const type of types) {
|
|
if (teamData.typeCount[type] >= 2 * limitFactor && this.randomChance(4, 5)) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
if (skip) continue;
|
|
|
|
// Restrict Eevee with certain Pokemon
|
|
if (speciesFlags.limEevee) {
|
|
if (!teamData.eeveeLimCount) teamData.eeveeLimCount = 0;
|
|
teamData.eeveeLimCount++;
|
|
}
|
|
if (teamData.eeveeLimCount && teamData.eeveeLimCount >= 1 && speciesFlags.limEevee) continue;
|
|
|
|
const set = this.randomBSSFactorySet(species, teamData);
|
|
if (!set) continue;
|
|
|
|
// Limit 1 of any type combination
|
|
let typeCombo = types.slice().sort().join();
|
|
if (set.ability === 'Drought' || set.ability === 'Drizzle') {
|
|
// Drought and Drizzle don't count towards the type combo limit
|
|
typeCombo = set.ability;
|
|
}
|
|
if (teamData.typeComboCount[typeCombo] >= limitFactor) continue;
|
|
|
|
// Okay, the set passes, add it to our team
|
|
pokemon.push(set);
|
|
|
|
// Now that our Pokemon has passed all checks, we can update team data:
|
|
for (const type of types) {
|
|
if (type in teamData.typeCount) {
|
|
teamData.typeCount[type]++;
|
|
} else {
|
|
teamData.typeCount[type] = 1;
|
|
}
|
|
}
|
|
teamData.typeComboCount[typeCombo] = (teamData.typeComboCount[typeCombo] + 1) || 1;
|
|
|
|
teamData.baseFormes[species.baseSpecies] = 1;
|
|
|
|
// Limit Mega and Z-move
|
|
const itemData = this.dex.items.get(set.item);
|
|
if (itemData.megaStone) teamData.megaCount++;
|
|
if (itemData.zMove) {
|
|
if (!teamData.zCount) teamData.zCount = 0;
|
|
teamData.zCount++;
|
|
}
|
|
teamData.has[itemData.id] = 1;
|
|
|
|
const abilityState = this.dex.abilities.get(set.ability);
|
|
if (abilityState.id in weatherAbilitiesSet) {
|
|
teamData.weather = weatherAbilitiesSet[abilityState.id];
|
|
}
|
|
|
|
for (const move of set.moves) {
|
|
const moveId = toID(move);
|
|
if (moveId in teamData.has) {
|
|
teamData.has[moveId]++;
|
|
} else {
|
|
teamData.has[moveId] = 1;
|
|
}
|
|
if (moveId in requiredMoves) {
|
|
teamData.has[requiredMoves[moveId]] = 1;
|
|
}
|
|
}
|
|
|
|
for (const typeName of this.dex.types.names()) {
|
|
// Cover any major weakness (3+) with at least one resistance
|
|
if (teamData.resistances[typeName] >= 1) continue;
|
|
if (resistanceAbilities[abilityState.id]?.includes(typeName) || !this.dex.getImmunity(typeName, types)) {
|
|
// Heuristic: assume that Pokémon with these abilities don't have (too) negative typing.
|
|
teamData.resistances[typeName] = (teamData.resistances[typeName] || 0) + 1;
|
|
if (teamData.resistances[typeName] >= 1) teamData.weaknesses[typeName] = 0;
|
|
continue;
|
|
}
|
|
const typeMod = this.dex.getEffectiveness(typeName, types);
|
|
if (typeMod < 0) {
|
|
teamData.resistances[typeName] = (teamData.resistances[typeName] || 0) + 1;
|
|
if (teamData.resistances[typeName] >= 1) teamData.weaknesses[typeName] = 0;
|
|
} else if (typeMod > 0) {
|
|
teamData.weaknesses[typeName] = (teamData.weaknesses[typeName] || 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
if (pokemon.length < this.maxTeamSize) return this.randomBSSFactoryTeam(side, ++depth);
|
|
|
|
// Quality control
|
|
if (!teamData.forceResult) {
|
|
for (const requiredFamily of requiredMoveFamilies) {
|
|
if (!teamData.has[requiredFamily]) return this.randomBSSFactoryTeam(side, ++depth);
|
|
}
|
|
for (const type in teamData.weaknesses) {
|
|
if (teamData.weaknesses[type] >= 3) return this.randomBSSFactoryTeam(side, ++depth);
|
|
}
|
|
}
|
|
|
|
return pokemon;
|
|
}
|
|
}
|
|
|
|
export default RandomGen7Teams;
|