mirror of
https://github.com/smogon/pokemon-showdown.git
synced 2026-03-21 17:25:10 -05:00
2881 lines
109 KiB
TypeScript
2881 lines
109 KiB
TypeScript
/**
|
|
* Team Validator
|
|
* Pokemon Showdown - http://pokemonshowdown.com/
|
|
*
|
|
* Handles team validation, and specifically learnset checking.
|
|
*
|
|
* @license MIT
|
|
*/
|
|
|
|
import { Dex, toID } from './dex';
|
|
import type { MoveSource } from './dex-species';
|
|
import { Utils } from '../lib/utils';
|
|
import { Tags } from '../data/tags';
|
|
import { Teams } from './teams';
|
|
import { PRNG } from './prng';
|
|
import { type RuleTable } from './dex-formats';
|
|
|
|
/**
|
|
* Describes a possible way to get a pokemon. Is not exhaustive!
|
|
* sourcesBefore covers all sources that do not have exclusive
|
|
* moves (like catching wild pokemon).
|
|
*
|
|
* First character is a generation number, 1-8.
|
|
* Second character is a source ID, one of:
|
|
*
|
|
* - E = egg, 3rd char+ is the father in gen 2-5, empty in gen 6-7
|
|
* because egg moves aren't restricted to fathers anymore
|
|
* - S = event, 3rd char+ is the index in .eventData
|
|
* - D = Dream World, only 5D is valid
|
|
* - V = Virtual Console or Let's Go transfer, only 7V/8V is valid
|
|
*
|
|
* Designed to match MoveSource where possible.
|
|
*/
|
|
export type PokemonSource = string;
|
|
|
|
/**
|
|
* Represents a set of possible ways to get a Pokémon with a given
|
|
* set.
|
|
*
|
|
* `new PokemonSources()` creates an empty set;
|
|
* `new PokemonSources(dex.gen)` allows all Pokemon.
|
|
*
|
|
* The set mainly stored as an Array `sources`, but for sets that
|
|
* could be sourced from anywhere (for instance, TM moves), we
|
|
* instead just set `sourcesBefore` to a number meaning "any
|
|
* source at or before this gen is possible."
|
|
*
|
|
* In other words, this variable represents the set of all
|
|
* sources in `sources`, union all sources at or before
|
|
* gen `sourcesBefore`.
|
|
*/
|
|
export class PokemonSources {
|
|
/**
|
|
* A set of specific possible PokemonSources; implemented as
|
|
* an Array rather than a Set for perf reasons.
|
|
*/
|
|
sources: PokemonSource[];
|
|
/**
|
|
* if nonzero: the set also contains all possible sources from
|
|
* this gen and earlier.
|
|
*/
|
|
sourcesBefore: number;
|
|
/**
|
|
* the set requires sources from this gen or later
|
|
* this should be unchanged from the format's minimum past gen
|
|
* (3 in modern games, 6 if pentagon is required, etc)
|
|
*/
|
|
sourcesAfter: number;
|
|
isHidden: boolean | null;
|
|
/**
|
|
* `limitedEggMoves` is a list of moves that can only be obtained from an
|
|
* egg with another father in gen 2-5. If there are multiple such moves,
|
|
* potential fathers need to be checked to see if they can actually
|
|
* learn the move combination in question.
|
|
*
|
|
* `null` = the current move is definitely not a limited egg move
|
|
*
|
|
* `undefined` = the current move may or may not be a limited egg move
|
|
*/
|
|
limitedEggMoves?: ID[] | null;
|
|
/**
|
|
* Moves that should be in limitedEggMoves that would otherwise be skipped
|
|
* because they can be learned universally in a past generation
|
|
*/
|
|
possiblyLimitedEggMoves?: ID[] | null;
|
|
/**
|
|
* Moves that should be in limitedEggMoves that would otherwise be skipped
|
|
* because they can be learned via Gen 1-2 tradeback
|
|
*/
|
|
tradebackLimitedEggMoves?: ID[] | null;
|
|
/**
|
|
* Tracks level up egg moves for female-only Pokemon
|
|
*/
|
|
levelUpEggMoves?: ID[] | null;
|
|
/**
|
|
* Moves that can be learned via Pomeg glitch and does not require a
|
|
* particular parent to learn
|
|
*/
|
|
pomegEggMoves?: ID[] | null;
|
|
/**
|
|
* Event egg source that may be used with the Pomeg glitch
|
|
*
|
|
* `null` = definitely not an event egg that can be used with the Pomeg glitch
|
|
*/
|
|
pomegEventEgg?: string | null;
|
|
/**
|
|
* For event-only Pokemon that do not have a minimum source gen identified by its moves
|
|
*/
|
|
eventOnlyMinSourceGen?: number;
|
|
/**
|
|
* A list of movepools, identified by gen and species, which moves can be pulled from.
|
|
* Used to deal with compatibility issues for prevo/evo-exclusive moves
|
|
*/
|
|
learnsetDomain?: string[] | null;
|
|
/**
|
|
* Some Pokemon evolve by having a move in their learnset (like Piloswine
|
|
* with Ancient Power). These can only carry three other moves from their
|
|
* prevo, because the fourth move must be the evo move. This restriction
|
|
* doesn't apply to gen 6+ eggs, which can get around the restriction with
|
|
* the relearner.
|
|
*/
|
|
moveEvoCarryCount: number;
|
|
|
|
babyOnly?: string;
|
|
sketchMove?: string;
|
|
dreamWorldMoveCount: number;
|
|
hm?: string;
|
|
isFromPokemonGo?: boolean;
|
|
pokemonGoSource?: string;
|
|
restrictiveMoves?: string[];
|
|
/** Obscure learn methods */
|
|
restrictedMove?: ID;
|
|
|
|
constructor(sourcesBefore = 0, sourcesAfter = 0) {
|
|
this.sources = [];
|
|
this.sourcesBefore = sourcesBefore;
|
|
this.sourcesAfter = sourcesAfter;
|
|
this.isHidden = null;
|
|
this.limitedEggMoves = undefined;
|
|
this.moveEvoCarryCount = 0;
|
|
this.dreamWorldMoveCount = 0;
|
|
}
|
|
size() {
|
|
if (this.sourcesBefore) return Infinity;
|
|
return this.sources.length;
|
|
}
|
|
add(source: PokemonSource, limitedEggMove?: ID | null) {
|
|
if (this.sources[this.sources.length - 1] !== source) this.sources.push(source);
|
|
if (limitedEggMove) {
|
|
if (source.substr(0, 3) === '1ET') {
|
|
this.tradebackLimitedEggMoves = [limitedEggMove];
|
|
}
|
|
}
|
|
if (limitedEggMove && this.limitedEggMoves !== null) {
|
|
this.limitedEggMoves = [limitedEggMove];
|
|
} else if (limitedEggMove === null) {
|
|
this.limitedEggMoves = null;
|
|
}
|
|
}
|
|
addGen(sourceGen: number) {
|
|
this.sourcesBefore = Math.max(this.sourcesBefore, sourceGen);
|
|
this.limitedEggMoves = null;
|
|
}
|
|
minSourceGen() {
|
|
if (this.eventOnlyMinSourceGen) return this.eventOnlyMinSourceGen;
|
|
if (this.sourcesBefore) return this.sourcesAfter || 1;
|
|
let min = 10;
|
|
for (const source of this.sources) {
|
|
const sourceGen = parseInt(source.charAt(0));
|
|
if (sourceGen < min) min = sourceGen;
|
|
}
|
|
if (min === 10) return 0;
|
|
return min;
|
|
}
|
|
maxSourceGen() {
|
|
let max = this.sourcesBefore;
|
|
for (const source of this.sources) {
|
|
const sourceGen = parseInt(source.charAt(0));
|
|
if (sourceGen > max) max = sourceGen;
|
|
}
|
|
return max;
|
|
}
|
|
intersectWith(other: PokemonSources) {
|
|
if (this.pomegEventEgg && other.pomegEggMoves) {
|
|
const newSources = [];
|
|
for (const source of other.sources) {
|
|
newSources.push(source.substr(0, 2) === '3E' ? this.pomegEventEgg : source);
|
|
}
|
|
other.sources = newSources;
|
|
} else if (other.pomegEventEgg && this.pomegEventEgg !== null) {
|
|
const newSources = [];
|
|
for (const source of this.sources) {
|
|
newSources.push(source.substr(0, 2) === '3E' ? other.pomegEventEgg : source);
|
|
}
|
|
this.sources = newSources;
|
|
this.pomegEventEgg = other.pomegEventEgg;
|
|
} else if (!other.pomegEggMoves && !other.sourcesBefore) {
|
|
this.pomegEventEgg = null;
|
|
}
|
|
if (other.sourcesBefore || this.sourcesBefore) {
|
|
// having sourcesBefore is the equivalent of having everything before that gen
|
|
// in sources, so we fill the other array in preparation for intersection
|
|
if (other.sourcesBefore > this.sourcesBefore) {
|
|
for (const source of this.sources) {
|
|
const sourceGen = parseInt(source.charAt(0));
|
|
if (sourceGen <= other.sourcesBefore) {
|
|
other.sources.push(source);
|
|
}
|
|
}
|
|
} else if (this.sourcesBefore > other.sourcesBefore) {
|
|
for (const source of other.sources) {
|
|
const sourceGen = parseInt(source.charAt(0));
|
|
if (sourceGen <= this.sourcesBefore) {
|
|
this.sources.push(source);
|
|
}
|
|
}
|
|
}
|
|
this.sourcesBefore = Math.min(other.sourcesBefore, this.sourcesBefore);
|
|
}
|
|
if (this.sources.length) {
|
|
if (other.sources.length) {
|
|
const sourcesSet = new Set(other.sources);
|
|
const intersectSources = this.sources.filter(source => sourcesSet.has(source));
|
|
this.sources = intersectSources;
|
|
} else {
|
|
this.sources = [];
|
|
}
|
|
}
|
|
|
|
if (other.restrictedMove && other.restrictedMove !== this.restrictedMove) {
|
|
if (this.restrictedMove) {
|
|
// incompatible
|
|
this.sources = [];
|
|
this.sourcesBefore = 0;
|
|
} else {
|
|
this.restrictedMove = other.restrictedMove;
|
|
}
|
|
}
|
|
if (other.limitedEggMoves) {
|
|
if (!this.limitedEggMoves) {
|
|
this.limitedEggMoves = other.limitedEggMoves;
|
|
} else {
|
|
this.limitedEggMoves.push(...other.limitedEggMoves);
|
|
}
|
|
}
|
|
if (other.possiblyLimitedEggMoves) {
|
|
if (!this.possiblyLimitedEggMoves) {
|
|
this.possiblyLimitedEggMoves = other.possiblyLimitedEggMoves;
|
|
} else {
|
|
this.possiblyLimitedEggMoves.push(...other.possiblyLimitedEggMoves);
|
|
}
|
|
}
|
|
if (other.tradebackLimitedEggMoves) {
|
|
if (!this.tradebackLimitedEggMoves) {
|
|
this.tradebackLimitedEggMoves = other.tradebackLimitedEggMoves;
|
|
} else {
|
|
this.tradebackLimitedEggMoves.push(...other.tradebackLimitedEggMoves);
|
|
}
|
|
}
|
|
if (other.levelUpEggMoves) {
|
|
if (!this.levelUpEggMoves) {
|
|
this.levelUpEggMoves = other.levelUpEggMoves;
|
|
} else {
|
|
this.levelUpEggMoves.push(...other.levelUpEggMoves);
|
|
}
|
|
}
|
|
if (other.pomegEggMoves) {
|
|
if (!this.pomegEggMoves) {
|
|
this.pomegEggMoves = other.pomegEggMoves;
|
|
} else {
|
|
this.pomegEggMoves.push(...other.pomegEggMoves);
|
|
}
|
|
}
|
|
if (other.learnsetDomain) {
|
|
if (!this.learnsetDomain) {
|
|
this.learnsetDomain = other.learnsetDomain;
|
|
} else {
|
|
this.learnsetDomain.filter(source => other.learnsetDomain?.includes(source));
|
|
}
|
|
}
|
|
if (this.possiblyLimitedEggMoves && !this.sourcesBefore) {
|
|
const eggSources = this.sources.filter(source => source.charAt(1) === 'E');
|
|
let minEggGen = parseInt(eggSources[0]);
|
|
for (const source of eggSources) {
|
|
minEggGen = Math.min(minEggGen, parseInt(source.charAt(0)));
|
|
}
|
|
if (minEggGen) {
|
|
for (const eggMoveAndGen of this.possiblyLimitedEggMoves) {
|
|
if (!this.limitedEggMoves) this.limitedEggMoves = [];
|
|
if (parseInt(eggMoveAndGen.charAt(0)) < minEggGen) {
|
|
const eggMove = toID(eggMoveAndGen.substr(1));
|
|
if (!this.limitedEggMoves.includes(eggMove)) this.limitedEggMoves.push(eggMove);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let eggTradebackLegal = false;
|
|
for (const source of this.sources) {
|
|
if (source.substr(0, 3) === '1ET') {
|
|
eggTradebackLegal = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!eggTradebackLegal && this.tradebackLimitedEggMoves) {
|
|
for (const eggMove of this.tradebackLimitedEggMoves) {
|
|
if (!this.limitedEggMoves) this.limitedEggMoves = [];
|
|
if (!this.limitedEggMoves.includes(eggMove)) this.limitedEggMoves.push(eggMove);
|
|
}
|
|
}
|
|
this.moveEvoCarryCount += other.moveEvoCarryCount;
|
|
this.dreamWorldMoveCount += other.dreamWorldMoveCount;
|
|
if (other.sourcesAfter > this.sourcesAfter) this.sourcesAfter = other.sourcesAfter;
|
|
if (other.isHidden) this.isHidden = true;
|
|
}
|
|
}
|
|
|
|
export class TeamValidator {
|
|
readonly format: Format;
|
|
readonly dex: ModdedDex;
|
|
readonly gen: number;
|
|
readonly ruleTable: RuleTable;
|
|
readonly minSourceGen: number;
|
|
|
|
readonly toID: (str: any) => ID;
|
|
constructor(format: string | Format, dex = Dex) {
|
|
this.format = dex.formats.get(format);
|
|
if (this.format.effectType !== 'Format') {
|
|
throw new Error(`format should be a 'Format', but was a '${this.format.effectType}'`);
|
|
}
|
|
this.dex = dex.forFormat(this.format);
|
|
this.gen = this.dex.gen;
|
|
this.ruleTable = this.dex.formats.getRuleTable(this.format);
|
|
|
|
this.minSourceGen = this.ruleTable.minSourceGen;
|
|
|
|
this.toID = toID;
|
|
}
|
|
|
|
validateTeam(
|
|
team: PokemonSet[] | null,
|
|
options: {
|
|
removeNicknames?: boolean,
|
|
skipSets?: { [name: string]: { [key: string]: boolean } },
|
|
} = {}
|
|
): string[] | null {
|
|
if (team && this.format.validateTeam) {
|
|
return this.format.validateTeam.call(this, team, options) || null;
|
|
}
|
|
return this.baseValidateTeam(team, options);
|
|
}
|
|
|
|
baseValidateTeam(
|
|
team: PokemonSet[] | null,
|
|
options: {
|
|
removeNicknames?: boolean,
|
|
skipSets?: { [name: string]: { [key: string]: boolean } },
|
|
} = {}
|
|
): string[] | null {
|
|
const format = this.format;
|
|
const dex = this.dex;
|
|
|
|
let problems: string[] = [];
|
|
const ruleTable = this.ruleTable;
|
|
if (format.team) {
|
|
if (team) {
|
|
return [
|
|
`This format doesn't let you use your own team.`,
|
|
`If you're not using a custom client, please report this as a bug. If you are, remember to use \`/utm null\` before starting a game in this format.`,
|
|
];
|
|
}
|
|
const testTeamSeed = PRNG.generateSeed();
|
|
try {
|
|
const testTeamGenerator = Teams.getGenerator(format, testTeamSeed);
|
|
testTeamGenerator.getTeam(options); // Throws error if generation fails
|
|
} catch (e) {
|
|
return [
|
|
`${format.name}'s team generator (${format.team}) failed using these rules and seed (${testTeamSeed}):-`,
|
|
`${e}`,
|
|
];
|
|
}
|
|
return null;
|
|
}
|
|
if (!team) {
|
|
return [
|
|
`This format requires you to use your own team.`,
|
|
`If you're not using a custom client, please report this as a bug.`,
|
|
];
|
|
}
|
|
if (!Array.isArray(team)) {
|
|
throw new Error(`Invalid team data`);
|
|
}
|
|
|
|
if (team.length < ruleTable.minTeamSize) {
|
|
problems.push(`You must bring at least ${ruleTable.minTeamSize} Pok\u00E9mon (your team has ${team.length}).`);
|
|
}
|
|
if (team.length > ruleTable.maxTeamSize) {
|
|
return [`You may only bring up to ${ruleTable.maxTeamSize} Pok\u00E9mon (your team has ${team.length}).`];
|
|
}
|
|
|
|
// A limit is imposed here to prevent too much engine strain or
|
|
// too much layout deformation - to be exact, this is the limit
|
|
// allowed in Custom Game.
|
|
if (team.length > 24) {
|
|
problems.push(`Your team has more than than 24 Pok\u00E9mon, which the simulator can't handle.`);
|
|
return problems;
|
|
}
|
|
|
|
const teamHas: { [k: string]: number } = {};
|
|
let lgpeStarterCount = 0;
|
|
let deoxysType;
|
|
for (const set of team) {
|
|
if (!set) return [`You sent invalid team data. If you're not using a custom client, please report this as a bug.`];
|
|
|
|
let setProblems: string[] | null = null;
|
|
if (options.skipSets?.[set.name]) {
|
|
for (const i in options.skipSets[set.name]) {
|
|
teamHas[i] = (teamHas[i] || 0) + 1;
|
|
}
|
|
} else {
|
|
setProblems = (format.validateSet || this.validateSet).call(this, set, teamHas);
|
|
}
|
|
|
|
if (set.species === 'Pikachu-Starter' || set.species === 'Eevee-Starter') {
|
|
lgpeStarterCount++;
|
|
if (lgpeStarterCount === 2 && ruleTable.isBanned('nonexistent')) {
|
|
problems.push(`You can only have one of Pikachu-Starter or Eevee-Starter on a team.`);
|
|
}
|
|
}
|
|
if (dex.gen === 3 && set.species.startsWith('Deoxys')) {
|
|
if (!deoxysType) {
|
|
deoxysType = set.species;
|
|
} else if (deoxysType !== set.species && ruleTable.isBanned('nonexistent')) {
|
|
return [
|
|
`You cannot have more than one type of Deoxys forme.`,
|
|
`(Each game in Gen 3 supports only one forme of Deoxys.)`,
|
|
];
|
|
}
|
|
}
|
|
if (setProblems) {
|
|
problems = problems.concat(setProblems);
|
|
}
|
|
if (options.removeNicknames) {
|
|
const useCrossSpeciesNicknames = format.name.includes('Cross Evolution') || ruleTable.has('franticfusionsmod');
|
|
const species = dex.species.get(set.species);
|
|
let crossSpecies: Species;
|
|
if (useCrossSpeciesNicknames && (crossSpecies = dex.species.get(set.name)).exists) {
|
|
set.name = crossSpecies.name;
|
|
} else {
|
|
set.name = species.baseSpecies;
|
|
if (species.baseSpecies === 'Unown') set.species = 'Unown';
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const [rule, source, limit, bans] of ruleTable.complexTeamBans) {
|
|
let count = 0;
|
|
for (const ban of bans) {
|
|
if (teamHas[ban] > 0) {
|
|
count += limit ? teamHas[ban] : 1;
|
|
}
|
|
}
|
|
if (limit && count > limit) {
|
|
const clause = source ? ` by ${source}` : ``;
|
|
problems.push(`You are limited to ${limit} of ${rule}${clause}.`);
|
|
} else if (!limit && count >= bans.length) {
|
|
const clause = source ? ` by ${source}` : ``;
|
|
problems.push(`Your team has the combination of ${rule}, which is banned${clause}.`);
|
|
}
|
|
}
|
|
|
|
for (const rule of ruleTable.keys()) {
|
|
if ('!+-*'.includes(rule.charAt(0))) continue;
|
|
const subformat = dex.formats.get(rule);
|
|
if (subformat.onValidateTeam && ruleTable.has(subformat.id)) {
|
|
problems = problems.concat(subformat.onValidateTeam.call(this, team, format, teamHas) || []);
|
|
}
|
|
}
|
|
if (format.onValidateTeam) {
|
|
problems = problems.concat(format.onValidateTeam.call(this, team, format, teamHas) || []);
|
|
}
|
|
|
|
if (!problems.length) return null;
|
|
return problems;
|
|
}
|
|
|
|
getEventOnlyData(species: Species, noRecurse?: boolean): { species: Species, eventData: EventInfo[] } | null {
|
|
const dex = this.dex;
|
|
const learnset = dex.species.getLearnsetData(species.id);
|
|
if (!learnset?.eventOnly) {
|
|
if (noRecurse) return null;
|
|
return this.getEventOnlyData(dex.species.get(species.prevo), true);
|
|
}
|
|
|
|
if (!learnset.eventData && species.forme) {
|
|
return this.getEventOnlyData(dex.species.get(species.baseSpecies), true);
|
|
}
|
|
if (!learnset.eventData) {
|
|
throw new Error(`Event-only species ${species.name} has no eventData table`);
|
|
}
|
|
|
|
return { species, eventData: learnset.eventData };
|
|
}
|
|
|
|
getValidationSpecies(set: PokemonSet): { outOfBattleSpecies: Species, tierSpecies: Species } {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
const species = dex.species.get(set.species);
|
|
const item = dex.items.get(set.item);
|
|
const ability = dex.abilities.get(set.ability);
|
|
|
|
let outOfBattleSpecies = species;
|
|
let tierSpecies = species;
|
|
if (ability.id === 'battlebond' && toID(species.baseSpecies) === 'greninja') {
|
|
outOfBattleSpecies = dex.species.get('greninjabond');
|
|
if (ruleTable.has('obtainableformes')) {
|
|
tierSpecies = outOfBattleSpecies;
|
|
}
|
|
}
|
|
if (ability.id === 'owntempo' && toID(species.baseSpecies) === 'rockruff') {
|
|
outOfBattleSpecies = dex.species.get('rockruffdusk');
|
|
if (ruleTable.has('obtainableformes')) {
|
|
tierSpecies = outOfBattleSpecies;
|
|
}
|
|
}
|
|
|
|
if (ruleTable.has('obtainableformes')) {
|
|
const canMegaEvo = dex.gen <= 7 || ruleTable.has('+pokemontag:past');
|
|
if (item.megaEvolves === species.name) {
|
|
if (!item.megaStone) throw new Error(`Item ${item.name} has no base form for mega evolution`);
|
|
tierSpecies = dex.species.get(item.megaStone);
|
|
} else if (item.id === 'redorb' && species.id === 'groudon') {
|
|
tierSpecies = dex.species.get('Groudon-Primal');
|
|
} else if (item.id === 'blueorb' && species.id === 'kyogre') {
|
|
tierSpecies = dex.species.get('Kyogre-Primal');
|
|
} else if (
|
|
canMegaEvo && species.id === 'rayquaza' && set.moves.map(toID).includes('dragonascent' as ID) &&
|
|
!ruleTable.has('megarayquazaclause')
|
|
) {
|
|
tierSpecies = dex.species.get('Rayquaza-Mega');
|
|
} else if (item.id === 'rustedsword' && species.id === 'zacian') {
|
|
tierSpecies = dex.species.get('Zacian-Crowned');
|
|
} else if (item.id === 'rustedshield' && species.id === 'zamazenta') {
|
|
tierSpecies = dex.species.get('Zamazenta-Crowned');
|
|
}
|
|
}
|
|
|
|
return { outOfBattleSpecies, tierSpecies };
|
|
}
|
|
|
|
validateSet(set: PokemonSet, teamHas: AnyObject): string[] | null {
|
|
const format = this.format;
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
let problems: string[] = [];
|
|
if (!set) {
|
|
return [`This is not a Pokemon.`];
|
|
}
|
|
|
|
let species = dex.species.get(set.species);
|
|
set.species = species.name;
|
|
// Backwards compatibility with old Gmax format
|
|
if (set.species.toLowerCase().endsWith('-gmax') && this.format.id !== 'gen8megamax') {
|
|
set.species = set.species.slice(0, -5);
|
|
species = dex.species.get(set.species);
|
|
if (set.name?.endsWith('-Gmax')) set.name = species.baseSpecies;
|
|
set.gigantamax = true;
|
|
}
|
|
if (set.name && set.name.length > 18) {
|
|
if (set.name === set.species) {
|
|
set.name = species.baseSpecies;
|
|
} else {
|
|
problems.push(`Nickname "${set.name}" too long (should be 18 characters or fewer)`);
|
|
}
|
|
}
|
|
set.name = dex.getName(set.name);
|
|
let item = dex.items.get(Utils.getString(set.item));
|
|
set.item = item.name;
|
|
let ability = dex.abilities.get(Utils.getString(set.ability));
|
|
set.ability = ability.name;
|
|
let nature = dex.natures.get(Utils.getString(set.nature));
|
|
set.nature = nature.name;
|
|
if (!Array.isArray(set.moves)) set.moves = [];
|
|
|
|
set.name = set.name || species.baseSpecies;
|
|
let name = set.species;
|
|
if (set.species !== set.name && species.baseSpecies !== set.name) {
|
|
name = `${set.name} (${set.species})`;
|
|
}
|
|
|
|
if (!set.teraType && this.gen === 9) {
|
|
set.teraType = species.types[0];
|
|
}
|
|
|
|
if (!set.level) set.level = ruleTable.defaultLevel;
|
|
|
|
let adjustLevel = ruleTable.adjustLevel;
|
|
if (ruleTable.adjustLevelDown && set.level >= ruleTable.adjustLevelDown) {
|
|
adjustLevel = ruleTable.adjustLevelDown;
|
|
}
|
|
if (set.level === adjustLevel || (set.level === 100 && ruleTable.maxLevel < 100)) {
|
|
// Note that we're temporarily setting level 50 pokemon in VGC to level 100
|
|
// This allows e.g. level 50 Hydreigon even though it doesn't evolve until level 64.
|
|
// Leveling up can't make an obtainable pokemon unobtainable, so this is safe.
|
|
// Just remember to set the level back to adjustLevel at the end of validation.
|
|
set.level = ruleTable.maxLevel;
|
|
}
|
|
if (set.level < ruleTable.minLevel) {
|
|
problems.push(`${name} (level ${set.level}) is below the minimum level of ${ruleTable.minLevel}${ruleTable.blame('minlevel')}`);
|
|
}
|
|
if (set.level > ruleTable.maxLevel) {
|
|
problems.push(`${name} (level ${set.level}) is above the maximum level of ${ruleTable.maxLevel}${ruleTable.blame('maxlevel')}`);
|
|
}
|
|
|
|
const setHas: { [k: string]: true } = {};
|
|
|
|
if (!set.evs) set.evs = TeamValidator.fillStats(null, ruleTable.evLimit === null ? 252 : 0);
|
|
if (!set.ivs) set.ivs = TeamValidator.fillStats(null, 31);
|
|
|
|
if (ruleTable.has('obtainableformes')) {
|
|
problems.push(...this.validateForme(set));
|
|
species = dex.species.get(set.species);
|
|
}
|
|
const setSources = this.allSources(species);
|
|
|
|
for (const [rule] of ruleTable) {
|
|
if ('!+-*'.includes(rule.charAt(0))) continue;
|
|
const subformat = dex.formats.get(rule);
|
|
if (subformat.onChangeSet && ruleTable.has(subformat.id)) {
|
|
problems = problems.concat(subformat.onChangeSet.call(this, set, format, setHas, teamHas) || []);
|
|
}
|
|
}
|
|
if (format.onChangeSet) {
|
|
problems = problems.concat(format.onChangeSet.call(this, set, format, setHas, teamHas) || []);
|
|
}
|
|
|
|
// onChangeSet can modify set.species, set.item, set.ability
|
|
species = dex.species.get(set.species);
|
|
item = dex.items.get(set.item);
|
|
ability = dex.abilities.get(set.ability);
|
|
|
|
const { outOfBattleSpecies, tierSpecies } = this.getValidationSpecies(set);
|
|
if (ability.id === 'battlebond' && toID(species.baseSpecies) === 'greninja') {
|
|
if (ruleTable.has('obtainablemisc')) {
|
|
if (set.gender && set.gender !== 'M') {
|
|
problems.push(`Battle Bond Greninja must be male.`);
|
|
}
|
|
set.gender = 'M';
|
|
}
|
|
}
|
|
if (species.id === 'melmetal' && set.gigantamax && this.dex.species.getLearnsetData(species.id).eventData) {
|
|
setSources.sourcesBefore = 0;
|
|
setSources.sources = ['8S0 melmetal'];
|
|
}
|
|
if (!species.exists) {
|
|
return [`The Pokemon "${set.species}" does not exist.`];
|
|
}
|
|
|
|
if (item.id && !item.exists) {
|
|
return [`"${set.item}" is an invalid item.`];
|
|
}
|
|
if (ability.id && !ability.exists) {
|
|
if (dex.gen < 3) {
|
|
// gen 1-2 don't have abilities, just silently remove
|
|
ability = dex.abilities.get('');
|
|
set.ability = '';
|
|
} else {
|
|
return [`"${set.ability}" is an invalid ability.`];
|
|
}
|
|
}
|
|
if (nature.id && !nature.exists) {
|
|
if (dex.gen < 3) {
|
|
// gen 1-2 don't have natures, just remove them
|
|
nature = dex.natures.get('');
|
|
set.nature = '';
|
|
} else {
|
|
problems.push(`"${set.nature}" is an invalid nature.`);
|
|
}
|
|
}
|
|
if (set.happiness !== undefined && isNaN(set.happiness)) {
|
|
problems.push(`${name} has an invalid happiness value.`);
|
|
}
|
|
if (set.hpType) {
|
|
const type = dex.types.get(set.hpType);
|
|
if (!type.exists || ['normal', 'fairy', 'stellar'].includes(type.id)) {
|
|
problems.push(`${name}'s Hidden Power type (${set.hpType}) is invalid.`);
|
|
} else {
|
|
set.hpType = type.name;
|
|
}
|
|
}
|
|
if (species.forceTeraType) {
|
|
set.teraType = species.forceTeraType;
|
|
}
|
|
if (set.teraType) {
|
|
const type = dex.types.get(set.teraType);
|
|
if (!type.exists || type.isNonstandard) {
|
|
problems.push(`${name}'s Terastal type (${set.teraType}) is invalid.`);
|
|
} else {
|
|
set.teraType = type.name;
|
|
}
|
|
if (dex.gen !== 9 || (ruleTable.has('terastalclause') && !ruleTable.has('bonustypemod'))) {
|
|
delete set.teraType;
|
|
}
|
|
}
|
|
|
|
let problem = this.checkSpecies(set, species, tierSpecies, setHas);
|
|
if (problem) problems.push(problem);
|
|
|
|
problem = this.checkItem(set, item, setHas);
|
|
if (problem) problems.push(problem);
|
|
if (ruleTable.has('obtainablemisc')) {
|
|
if (dex.gen === 4 && item.id === 'griseousorb' && species.num !== 487) {
|
|
problems.push(`${set.name} cannot hold the Griseous Orb.`, `(In Gen 4, only Giratina could hold the Griseous Orb).`);
|
|
}
|
|
if (dex.gen <= 1 || dex.currentMod === 'gen7letsgo') {
|
|
if (item.id) {
|
|
// no items allowed
|
|
set.item = '';
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!set.ability) set.ability = 'No Ability';
|
|
if (ruleTable.has('obtainableabilities')) {
|
|
if (dex.gen <= 2 || dex.currentMod === 'gen7letsgo') {
|
|
set.ability = 'No Ability';
|
|
} else {
|
|
if (!ability.name || ability.name === 'No Ability') {
|
|
problems.push(`${name} needs to have an ability.`);
|
|
} else if (!Object.values(species.abilities).includes(ability.name)) {
|
|
if (tierSpecies.abilities[0] === ability.name) {
|
|
set.ability = species.abilities[0];
|
|
} else {
|
|
problems.push(`${name} can't have ${set.ability}.`);
|
|
}
|
|
}
|
|
if (ability.name === species.abilities['H']) {
|
|
setSources.isHidden = true;
|
|
|
|
let unreleasedHidden = species.unreleasedHidden;
|
|
if (unreleasedHidden === 'Past' && this.minSourceGen < dex.gen) unreleasedHidden = false;
|
|
|
|
if (unreleasedHidden && ruleTable.has('-unreleased')) {
|
|
problems.push(`${name}'s Hidden Ability is unreleased.`);
|
|
} else if (dex.gen === 7 && ['entei', 'suicune', 'raikou'].includes(species.id) && this.minSourceGen > 1) {
|
|
problems.push(`${name}'s Hidden Ability is only available from Virtual Console, which is not allowed in this format.`);
|
|
} else if (dex.gen === 6 && ability.name === 'Symbiosis' &&
|
|
(set.species.endsWith('Orange') || set.species.endsWith('White'))) {
|
|
problems.push(`${name}'s Hidden Ability is unreleased for the Orange and White forms.`);
|
|
} else if (dex.gen === 5 && set.level < 10 && (species.maleOnlyHidden || species.gender === 'N')) {
|
|
problems.push(`${name} must be at least level 10 to have a Hidden Ability.`);
|
|
}
|
|
if (species.maleOnlyHidden) {
|
|
if (set.gender && set.gender !== 'M') {
|
|
problems.push(`${name} must be male to have a Hidden Ability.`);
|
|
}
|
|
set.gender = 'M';
|
|
setSources.sources = ['5D'];
|
|
}
|
|
} else {
|
|
setSources.isHidden = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
ability = dex.abilities.get(set.ability);
|
|
problem = this.checkAbility(set, ability, setHas);
|
|
if (problem) problems.push(problem);
|
|
|
|
if (!set.nature || dex.gen <= 2) {
|
|
set.nature = '';
|
|
}
|
|
nature = dex.natures.get(set.nature);
|
|
problem = this.checkNature(set, nature, setHas);
|
|
if (problem) problems.push(problem);
|
|
|
|
if (set.shiny && dex.gen === 1) {
|
|
set.shiny = false;
|
|
}
|
|
|
|
if (set.moves && Array.isArray(set.moves)) {
|
|
set.moves = set.moves.filter(val => val);
|
|
}
|
|
if (!set.moves?.length) {
|
|
problems.push(`${name} has no moves (it must have at least one to be usable).`);
|
|
set.moves = [];
|
|
}
|
|
if (set.moves.length > ruleTable.maxMoveCount) {
|
|
problems.push(`${name} has ${set.moves.length} moves, which is more than the limit of ${ruleTable.maxMoveCount}.`);
|
|
return problems;
|
|
}
|
|
|
|
const pokemonGoProblems = this.validatePokemonGo(outOfBattleSpecies, set, setSources);
|
|
if (ruleTable.isBanned('nonexistent')) {
|
|
problems.push(...this.validateStats(set, species, setSources, pokemonGoProblems));
|
|
}
|
|
|
|
const moveLegalityWhitelist: { [k: string]: true | undefined } = {};
|
|
for (const moveName of set.moves) {
|
|
if (!moveName) continue;
|
|
const move = dex.moves.get(Utils.getString(moveName));
|
|
if (!move.exists) return [`"${move.name}" is an invalid move.`];
|
|
|
|
problem = this.checkMove(set, move, setHas);
|
|
if (problem) {
|
|
let allowedByOM;
|
|
if (problem.includes('hacking or glitches') &&
|
|
ruleTable.has('omunobtainablemoves')) {
|
|
problem = `${name}'s ${problem}`;
|
|
allowedByOM = !this.omCheckCanLearn(move, outOfBattleSpecies, setSources, set, problem);
|
|
}
|
|
if (!allowedByOM) {
|
|
problems.push(problem);
|
|
} else {
|
|
moveLegalityWhitelist[move.id] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
const learnsetSpecies = dex.species.getLearnsetData(outOfBattleSpecies.id);
|
|
let isFromRBYEncounter = false;
|
|
if (this.gen === 1 && ruleTable.has('obtainablemisc') && !this.ruleTable.has('allowtradeback')) {
|
|
let lowestEncounterLevel;
|
|
for (const encounter of learnsetSpecies.encounters || []) {
|
|
if (encounter.generation !== 1) continue;
|
|
if (!encounter.level) continue;
|
|
if (lowestEncounterLevel && encounter.level > lowestEncounterLevel) continue;
|
|
|
|
lowestEncounterLevel = encounter.level;
|
|
}
|
|
|
|
if (lowestEncounterLevel) {
|
|
if (set.level < lowestEncounterLevel) {
|
|
problems.push(`${name} is not obtainable at levels below ${lowestEncounterLevel} in Gen 1.`);
|
|
}
|
|
isFromRBYEncounter = true;
|
|
}
|
|
}
|
|
let isUnderleveled;
|
|
let requiredLevel;
|
|
if (!isFromRBYEncounter && ruleTable.has('obtainablemisc')) {
|
|
// FIXME: Event pokemon given at a level under what it normally can be attained at gives a false positive
|
|
let evoSpecies = species;
|
|
while (evoSpecies.prevo) {
|
|
if (set.level < (evoSpecies.evoLevel || 0)) {
|
|
isUnderleveled = evoSpecies.name;
|
|
requiredLevel = evoSpecies.evoLevel;
|
|
break;
|
|
}
|
|
evoSpecies = dex.species.get(evoSpecies.prevo);
|
|
}
|
|
}
|
|
|
|
let moveProblems;
|
|
if (ruleTable.has('obtainablemoves')) {
|
|
moveProblems = this.validateMoves(outOfBattleSpecies, set.moves, setSources, set, name, moveLegalityWhitelist);
|
|
problems.push(...moveProblems);
|
|
}
|
|
|
|
let eventOnlyData;
|
|
|
|
if ((!setSources.sourcesBefore && setSources.sources.length) || isUnderleveled) {
|
|
let checkGoLegality = false;
|
|
let skippedEggSource = true;
|
|
const legalSources = [];
|
|
if (isUnderleveled && !setSources.sources.length) {
|
|
let evoSpecies = species;
|
|
while (evoSpecies.prevo) {
|
|
const eventData = dex.species.getLearnsetData(evoSpecies.id).eventData;
|
|
if (eventData) {
|
|
for (let eventIndex = 0; eventIndex < eventData.length; eventIndex++) {
|
|
const eventLevel = eventData[eventIndex].level;
|
|
if (eventLevel && set.level >= eventLevel) {
|
|
setSources.sources.push(`${eventData[eventIndex].generation}S${eventIndex} ${evoSpecies.id}`);
|
|
}
|
|
}
|
|
}
|
|
if (evoSpecies.name === isUnderleveled) break;
|
|
evoSpecies = dex.species.get(evoSpecies.prevo);
|
|
}
|
|
} else {
|
|
checkGoLegality = true;
|
|
}
|
|
for (const source of setSources.sources) {
|
|
if (isUnderleveled) {
|
|
if (source.charAt(1) === 'S') {
|
|
const eventSpecies = dex.species.get(source.substr(3)).baseSpecies;
|
|
const underleveledSpecies = dex.species.get(isUnderleveled).baseSpecies;
|
|
// Can only be an FE species or in a three-stage line, the prevo
|
|
if (eventSpecies !== species.baseSpecies && eventSpecies !== underleveledSpecies) continue;
|
|
} else if (source !== '8V') {
|
|
continue;
|
|
}
|
|
}
|
|
if (['2E', '3E'].includes(source.substr(0, 2)) && set.level < 5) continue;
|
|
skippedEggSource = false;
|
|
if (this.validateSource(set, source, setSources, outOfBattleSpecies)) continue;
|
|
legalSources.push(source);
|
|
}
|
|
if (checkGoLegality && !legalSources.includes('8V')) setSources.isFromPokemonGo = false;
|
|
if (setSources.isFromPokemonGo !== false && pokemonGoProblems && !pokemonGoProblems.length) {
|
|
if (!legalSources.length) setSources.isFromPokemonGo = true;
|
|
if (!legalSources.includes('8V')) legalSources.push('8V');
|
|
}
|
|
if (legalSources.length) {
|
|
setSources.sources = legalSources;
|
|
} else if (isUnderleveled) {
|
|
problems.push(`${name} must be at least level ${requiredLevel} to be evolved.`);
|
|
const firstEventSource = setSources.sources.find(source => source.charAt(1) === 'S');
|
|
if (firstEventSource) {
|
|
const eventProblems = this.validateSource(
|
|
set, firstEventSource, setSources, outOfBattleSpecies, ` to be underleveled`
|
|
);
|
|
if (eventProblems) problems.push(...eventProblems);
|
|
}
|
|
if (pokemonGoProblems?.length) {
|
|
problems.push(`It failed to validate as a Pokemon from Pokemon GO because:`);
|
|
for (const pokemonGoProblem of pokemonGoProblems) {
|
|
problems.push(pokemonGoProblem);
|
|
}
|
|
}
|
|
} else {
|
|
let nonEggSource = null;
|
|
for (const source of setSources.sources) {
|
|
if (source.charAt(1) !== 'E') {
|
|
nonEggSource = source;
|
|
break;
|
|
}
|
|
}
|
|
if (!nonEggSource) {
|
|
// all egg moves
|
|
if (skippedEggSource) {
|
|
problems.push(`${name} is from a Gen 2 or 3 egg, which cannot be obtained at levels below 5.`);
|
|
} else {
|
|
problems.push(`${name} can't get its egg move combination (${setSources.limitedEggMoves!.join(', ')}) from any possible father.`);
|
|
problems.push(`(Is this incorrect? If so, post the chainbreeding instructions in Bug Reports)`);
|
|
}
|
|
} else {
|
|
if (species.id === 'mew' && pokemonGoProblems && !pokemonGoProblems.length) {
|
|
// Whitelist Pokemon GO Mew, which cannot be sent to Let's Go
|
|
setSources.isFromPokemonGo = true;
|
|
} else {
|
|
if (setSources.sources.length > 1) {
|
|
problems.push(`${name} has an event-exclusive move that it doesn't qualify for (only one of several ways to get the move will be listed):`);
|
|
}
|
|
const eventProblems = this.validateSource(
|
|
set, nonEggSource, setSources, outOfBattleSpecies, ` because it has a move only available`
|
|
);
|
|
if (eventProblems) problems.push(...eventProblems);
|
|
if (species.id === 'mew' && pokemonGoProblems?.length) {
|
|
problems.push(`Additionally, it failed to validate as a Pokemon from Pokemon GO because:`);
|
|
for (const pokemonGoProblem of pokemonGoProblems) {
|
|
problems.push(pokemonGoProblem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (ruleTable.has('obtainablemisc') && (eventOnlyData = this.getEventOnlyData(outOfBattleSpecies))) {
|
|
const { species: eventSpecies, eventData } = eventOnlyData;
|
|
let legal = false;
|
|
for (const event of eventData) {
|
|
if (this.validateEvent(set, setSources, event, eventSpecies)) continue;
|
|
setSources.eventOnlyMinSourceGen = event.generation;
|
|
legal = true;
|
|
break;
|
|
}
|
|
if (!legal && species.gen <= 2 && dex.gen >= 7 && !this.validateSource(set, '7V', setSources, species)) {
|
|
legal = true;
|
|
}
|
|
if (!legal) {
|
|
if (!pokemonGoProblems || (pokemonGoProblems?.length)) {
|
|
if (eventData.length === 1) {
|
|
problems.push(`${species.name} is only obtainable from an event - it needs to match its event:`);
|
|
} else {
|
|
problems.push(`${species.name} is only obtainable from events - it needs to match one of its events:`);
|
|
}
|
|
for (const [i, event] of eventData.entries()) {
|
|
if (event.generation <= dex.gen && (event.generation >= this.minSourceGen || dex.gen > 8)) {
|
|
const eventInfo = event;
|
|
const eventNum = i + 1;
|
|
const eventName = eventData.length > 1 ? ` #${eventNum}` : ``;
|
|
const eventProblems = this.validateEvent(
|
|
set, setSources, eventInfo, eventSpecies, ` to be`, `from its event${eventName}`
|
|
);
|
|
if (eventProblems) problems.push(...eventProblems);
|
|
}
|
|
}
|
|
if (pokemonGoProblems?.length) {
|
|
problems.push(`Additionally, it failed to validate as a Pokemon from Pokemon GO because:`);
|
|
for (const pokemonGoProblem of pokemonGoProblems) {
|
|
problems.push(pokemonGoProblem);
|
|
}
|
|
}
|
|
} else {
|
|
setSources.isFromPokemonGo = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Hardcoded forced validation for Pokemon GO
|
|
const pokemonGoOnlySpecies = ['meltan', 'melmetal', 'gimmighoulroaming'];
|
|
if (ruleTable.has('obtainablemisc') && (pokemonGoOnlySpecies.includes(species.id))) {
|
|
setSources.isFromPokemonGo = true;
|
|
if (pokemonGoProblems?.length) {
|
|
problems.push(`${name} is only obtainable from Pokemon GO, and failed to validate because:`);
|
|
for (const pokemonGoProblem of pokemonGoProblems) {
|
|
problems.push(pokemonGoProblem);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Attempt move validation again after verifying Pokemon GO origin
|
|
if (ruleTable.has('obtainablemoves') && setSources.isFromPokemonGo) {
|
|
setSources.restrictiveMoves = [];
|
|
setSources.sources = ['8V'];
|
|
setSources.sourcesBefore = 0;
|
|
if (moveProblems && !moveProblems.length) {
|
|
problems.push(...this.validateMoves(outOfBattleSpecies, set.moves, setSources, set, name,
|
|
moveLegalityWhitelist));
|
|
}
|
|
}
|
|
|
|
if (ruleTable.has('obtainablemoves')) {
|
|
if (species.id === 'keldeo' && set.moves.includes('secretsword') && this.minSourceGen > 5 && dex.gen <= 7) {
|
|
problems.push(`${name} has Secret Sword, which is only compatible with Keldeo-Ordinary obtained from Gen 5.`);
|
|
}
|
|
const requiresGen3Source = setSources.maxSourceGen() <= 3;
|
|
if (requiresGen3Source && dex.abilities.get(set.ability).gen === 4 && !species.prevo && dex.gen <= 5) {
|
|
// Ability Capsule allows this in Gen 6+
|
|
problems.push(`${name} has a Gen 4 ability and isn't evolved - it can't use moves from Gen 3.`);
|
|
}
|
|
const canUseAbilityPatch = dex.gen >= 8 && format.mod !== 'gen8dlc1';
|
|
if (setSources.isHidden && !canUseAbilityPatch && setSources.maxSourceGen() < 5) {
|
|
problems.push(`${name} has a Hidden Ability - it can't use moves from before Gen 5.`);
|
|
}
|
|
if (
|
|
species.maleOnlyHidden && setSources.isHidden && setSources.sourcesBefore < 5 &&
|
|
setSources.sources.every(source => source.charAt(1) === 'E')
|
|
) {
|
|
problems.push(`${name} has an unbreedable Hidden Ability - it can't use egg moves.`);
|
|
}
|
|
}
|
|
|
|
if (teamHas) {
|
|
for (const i in setHas) {
|
|
if (i in teamHas) {
|
|
teamHas[i]++;
|
|
} else {
|
|
teamHas[i] = 1;
|
|
}
|
|
}
|
|
}
|
|
for (const [rule, source, limit, bans] of ruleTable.complexBans) {
|
|
let count = 0;
|
|
for (const ban of bans) {
|
|
if (setHas[ban]) count++;
|
|
}
|
|
if (limit && count > limit) {
|
|
const clause = source ? ` by ${source}` : ``;
|
|
problems.push(`${name} is limited to ${limit} of ${rule}${clause}.`);
|
|
} else if (!limit && count >= bans.length) {
|
|
const clause = source ? ` by ${source}` : ``;
|
|
if (source === 'Obtainable Moves') {
|
|
problems.push(`${name} has the combination of ${rule}, which is impossible to obtain legitimately.`);
|
|
} else {
|
|
problems.push(`${name} has the combination of ${rule}, which is banned${clause}.`);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const [rule] of ruleTable) {
|
|
if ('!+-*'.includes(rule.charAt(0))) continue;
|
|
const subformat = dex.formats.get(rule);
|
|
if (subformat.onValidateSet && ruleTable.has(subformat.id)) {
|
|
problems = problems.concat(subformat.onValidateSet.call(this, set, format, setHas, teamHas) || []);
|
|
}
|
|
}
|
|
if (format.onValidateSet) {
|
|
problems = problems.concat(format.onValidateSet.call(this, set, format, setHas, teamHas) || []);
|
|
}
|
|
|
|
const nameSpecies = dex.species.get(set.name);
|
|
if (nameSpecies.exists && nameSpecies.name.toLowerCase() === set.name.toLowerCase()) {
|
|
// nickname is the name of a species
|
|
if (nameSpecies.baseSpecies === species.baseSpecies) {
|
|
set.name = species.baseSpecies;
|
|
} else if (nameSpecies.name !== species.name &&
|
|
nameSpecies.name !== species.baseSpecies && ruleTable.has('nicknameclause')) {
|
|
// nickname species doesn't match actual species
|
|
// Nickname Clause
|
|
problems.push(`${name} must not be nicknamed a different Pokémon species than what it actually is.`);
|
|
}
|
|
}
|
|
|
|
if (!problems.length) {
|
|
if (set.gender === '' && !species.gender) {
|
|
set.gender = ['M', 'F'][Math.floor(Math.random() * 2)];
|
|
}
|
|
if (adjustLevel) set.level = adjustLevel;
|
|
return null;
|
|
}
|
|
|
|
return problems;
|
|
}
|
|
|
|
validateStats(set: PokemonSet, species: Species, setSources: PokemonSources, pokemonGoProblems: string[] | null) {
|
|
const ruleTable = this.ruleTable;
|
|
const dex = this.dex;
|
|
|
|
const allowAVs = ruleTable.has('allowavs');
|
|
const evLimit = ruleTable.evLimit;
|
|
const canBottleCap = dex.gen >= 7 && (set.level >= (dex.gen < 9 ? 100 : 50) || !ruleTable.has('obtainablemisc'));
|
|
|
|
if (!set.evs) set.evs = TeamValidator.fillStats(null, evLimit === null ? 252 : 0);
|
|
if (!set.ivs) set.ivs = TeamValidator.fillStats(null, 31);
|
|
|
|
const problems = [];
|
|
const name = set.name || set.species;
|
|
|
|
const maxedIVs = Object.values(set.ivs).every(stat => stat === 31);
|
|
for (const moveName of set.moves) {
|
|
const move = dex.moves.get(moveName);
|
|
if (move.id === 'hiddenpower' && move.type !== 'Normal') {
|
|
if (!set.hpType) {
|
|
set.hpType = move.type;
|
|
} else if (set.hpType !== move.type && ruleTable.has('obtainablemisc')) {
|
|
problems.push(`${name}'s Hidden Power type ${set.hpType} is incompatible with Hidden Power ${move.type}`);
|
|
}
|
|
}
|
|
}
|
|
if (set.hpType && maxedIVs && ruleTable.has('obtainablemisc')) {
|
|
if (dex.gen <= 2) {
|
|
const HPdvs = dex.types.get(set.hpType).HPdvs;
|
|
set.ivs = { hp: 30, atk: 30, def: 30, spa: 30, spd: 30, spe: 30 };
|
|
let statName: StatID;
|
|
for (statName in HPdvs) {
|
|
set.ivs[statName] = HPdvs[statName]! * 2;
|
|
}
|
|
set.ivs.hp = -1;
|
|
} else if (!canBottleCap) {
|
|
set.ivs = TeamValidator.fillStats(dex.types.get(set.hpType).HPivs, 31);
|
|
}
|
|
}
|
|
if (!set.hpType && set.moves.some(m => dex.moves.get(m).id === 'hiddenpower')) {
|
|
set.hpType = dex.getHiddenPower(set.ivs).type;
|
|
}
|
|
|
|
const cantBreedNorEvolve = (species.eggGroups[0] === 'Undiscovered' && !species.prevo && !species.nfe);
|
|
const isLegendary = (cantBreedNorEvolve && !species.tags.includes('Paradox') && ![
|
|
'Pikachu', 'Unown', 'Dracozolt', 'Arctozolt', 'Dracovish', 'Arctovish', 'Gouging Fire', 'Raging Bolt', 'Iron Boulder', 'Iron Crown', 'Terapagos',
|
|
].includes(species.baseSpecies)) || [
|
|
'Manaphy', 'Cosmog', 'Cosmoem', 'Solgaleo', 'Lunala',
|
|
].includes(species.baseSpecies);
|
|
const diancieException = species.name === 'Diancie' && !set.shiny;
|
|
const has3PerfectIVs = setSources.minSourceGen() >= 6 && isLegendary && !diancieException;
|
|
|
|
if (set.hpType === 'Fighting' && ruleTable.has('obtainablemisc')) {
|
|
if (has3PerfectIVs) {
|
|
// Legendary Pokemon must have at least 3 perfect IVs in gen 6+
|
|
problems.push(`${name} must not have Hidden Power Fighting because it starts with 3 perfect IVs because it's a Gen 6+ legendary.`);
|
|
}
|
|
}
|
|
|
|
if (has3PerfectIVs && ruleTable.has('obtainablemisc')) {
|
|
let perfectIVs = 0;
|
|
for (const stat in set.ivs) {
|
|
if (set.ivs[stat as 'hp'] >= 31) perfectIVs++;
|
|
}
|
|
if (perfectIVs < 3) {
|
|
if (!pokemonGoProblems || pokemonGoProblems?.length) {
|
|
const reason = (this.minSourceGen === 6 ? ` and this format requires Gen ${dex.gen} Pokémon` : ` in Gen 6 or later`);
|
|
problems.push(`${name} must have at least three perfect IVs because it's a legendary${reason}.`);
|
|
if (pokemonGoProblems?.length) {
|
|
problems.push(`Additionally, it failed to validate as a Pokemon from Pokemon GO because:`);
|
|
for (const pokemonGoProblem of pokemonGoProblems) {
|
|
problems.push(pokemonGoProblem);
|
|
}
|
|
}
|
|
} else {
|
|
setSources.isFromPokemonGo = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (set.hpType && !canBottleCap) {
|
|
const ivHpType = dex.getHiddenPower(set.ivs).type;
|
|
if (set.hpType !== ivHpType) {
|
|
problems.push(`${name} has Hidden Power ${set.hpType}, but its IVs are for Hidden Power ${ivHpType}.`);
|
|
}
|
|
} else if (set.hpType) {
|
|
if (!this.possibleBottleCapHpType(set.hpType, set.ivs)) {
|
|
problems.push(`${name} has Hidden Power ${set.hpType}, but its IVs don't allow this even with (Bottle Cap) Hyper Training.`);
|
|
}
|
|
}
|
|
|
|
if (dex.gen <= 2) {
|
|
// validate DVs
|
|
const ivs = set.ivs;
|
|
const atkDV = Math.floor(ivs.atk / 2);
|
|
const defDV = Math.floor(ivs.def / 2);
|
|
const speDV = Math.floor(ivs.spe / 2);
|
|
const spcDV = Math.floor(ivs.spa / 2);
|
|
const expectedHpDV = (atkDV % 2) * 8 + (defDV % 2) * 4 + (speDV % 2) * 2 + (spcDV % 2);
|
|
if (ivs.hp === -1) ivs.hp = expectedHpDV * 2;
|
|
const hpDV = Math.floor(ivs.hp / 2);
|
|
if (expectedHpDV !== hpDV) {
|
|
problems.push(`${name} has an HP DV of ${hpDV}, but its Atk, Def, Spe, and Spc DVs give it an HP DV of ${expectedHpDV}.`);
|
|
}
|
|
if (ivs.spa !== ivs.spd) {
|
|
if (dex.gen === 2) {
|
|
problems.push(`${name} has different SpA and SpD DVs, which is not possible in Gen 2.`);
|
|
} else {
|
|
ivs.spd = ivs.spa;
|
|
}
|
|
}
|
|
if (dex.gen > 1 && !species.gender) {
|
|
// Gen 2 gender is calculated from the Atk DV.
|
|
// High Atk DV <-> M. The meaning of "high" depends on the gender ratio.
|
|
const genderThreshold = species.genderRatio.F * 16;
|
|
|
|
const expectedGender = (atkDV >= genderThreshold ? 'M' : 'F');
|
|
if (set.gender && set.gender !== expectedGender) {
|
|
problems.push(`${name} is ${set.gender}, but it has an Atk DV of ${atkDV}, which makes its gender ${expectedGender}.`);
|
|
} else {
|
|
set.gender = expectedGender;
|
|
}
|
|
}
|
|
if (
|
|
set.species === 'Marowak' && toID(set.item) === 'thickclub' &&
|
|
set.moves.map(toID).includes('swordsdance' as ID) && set.level === 100
|
|
) {
|
|
// Marowak hack
|
|
set.ivs.atk = Math.floor(set.ivs.atk / 2) * 2;
|
|
while (set.evs.atk > 0 && 2 * 80 + set.ivs.atk + Math.floor(set.evs.atk / 4) + 5 > 255) {
|
|
set.evs.atk -= 4;
|
|
}
|
|
}
|
|
if (dex.gen > 1) {
|
|
const expectedShiny = !!(defDV === 10 && speDV === 10 && spcDV === 10 && atkDV % 4 >= 2);
|
|
if (expectedShiny && !set.shiny) {
|
|
problems.push(`${name} is not shiny, which does not match its DVs.`);
|
|
} else if (!expectedShiny && set.shiny) {
|
|
problems.push(`${name} is shiny, which does not match its DVs (its DVs must all be 10, except Atk which must be 2, 3, 6, 7, 10, 11, 14, or 15).`);
|
|
}
|
|
}
|
|
set.nature = 'Serious';
|
|
}
|
|
|
|
for (const stat in set.evs) {
|
|
if (set.evs[stat as 'hp'] < 0) {
|
|
problems.push(`${name} has less than 0 ${allowAVs ? 'Awakening Values' : 'EVs'} in ${Dex.stats.names[stat as 'hp']}.`);
|
|
}
|
|
}
|
|
|
|
if (dex.currentMod === 'gen7letsgo') { // AVs
|
|
for (const stat in set.evs) {
|
|
if (set.evs[stat as 'hp'] > 0 && !allowAVs) {
|
|
problems.push(`${name} has Awakening Values but this format doesn't allow them.`);
|
|
break;
|
|
} else if (set.evs[stat as 'hp'] > 200) {
|
|
problems.push(`${name} has more than 200 Awakening Values in ${Dex.stats.names[stat as 'hp']}.`);
|
|
}
|
|
}
|
|
} else { // EVs
|
|
for (const stat in set.evs) {
|
|
if (set.evs[stat as StatID] > 255) {
|
|
problems.push(`${name} has more than 255 EVs in ${Dex.stats.names[stat as 'hp']}.`);
|
|
}
|
|
}
|
|
if (dex.gen <= 2) {
|
|
if (set.evs.spa !== set.evs.spd) {
|
|
if (dex.gen === 2) {
|
|
problems.push(`${name} has different SpA and SpD EVs, which is not possible in Gen 2.`);
|
|
} else {
|
|
set.evs.spd = set.evs.spa;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let totalEV = 0;
|
|
for (const stat in set.evs) totalEV += set.evs[stat as 'hp'];
|
|
if (!this.format.debug) {
|
|
if (set.level > 1 && evLimit !== 0 && totalEV === 0) {
|
|
problems.push(`${name} has exactly 0 EVs - did you forget to EV it? (If this was intentional, add exactly 1 to one of your EVs, which won't change its stats but will tell us that it wasn't a mistake).`);
|
|
} else if (![508, 510].includes(evLimit!) && [508, 510].includes(totalEV)) {
|
|
problems.push(`${name} has exactly ${totalEV} EVs, but this format does not restrict you to 510 EVs (If this was intentional, add exactly 1 to one of your EVs, which won't change its stats but will tell us that it wasn't a mistake).`);
|
|
}
|
|
// Check for level import errors from user in VGC -> DOU, etc.
|
|
// Note that in VGC etc (Adjust Level Down = 50), `set.level` will be 100 here for validation purposes
|
|
if (set.level === 50 && ruleTable.maxLevel !== 50 && !ruleTable.maxTotalLevel && evLimit !== 0 && totalEV % 4 === 0) {
|
|
problems.push(`${name} is level 50, but this format allows level ${ruleTable.maxLevel} Pokémon. (If this was intentional, add exactly 1 to one of your EVs, which won't change its stats but will tell us that it wasn't a mistake).`);
|
|
}
|
|
}
|
|
|
|
if (evLimit !== null && totalEV > evLimit) {
|
|
if (!evLimit) {
|
|
problems.push(`${name} has EVs, which is not allowed by this format.`);
|
|
} else {
|
|
problems.push(`${name} has ${totalEV} total EVs, which is more than this format's limit of ${evLimit}.`);
|
|
}
|
|
}
|
|
|
|
return problems;
|
|
}
|
|
|
|
/**
|
|
* Not exhaustive, just checks Atk and Spe, which are the only competitively
|
|
* relevant IVs outside of extremely obscure situations.
|
|
*/
|
|
possibleBottleCapHpType(type: string, ivs: StatsTable) {
|
|
if (!type) return true;
|
|
if (['Dark', 'Dragon', 'Grass', 'Ghost', 'Poison'].includes(type)) {
|
|
// Spe must be odd
|
|
if (ivs.spe % 2 === 0) return false;
|
|
}
|
|
if (['Psychic', 'Fire', 'Rock', 'Fighting'].includes(type)) {
|
|
// Spe must be even
|
|
if (ivs.spe !== 31 && ivs.spe % 2 === 1) return false;
|
|
}
|
|
if (type === 'Dark') {
|
|
// Atk must be odd
|
|
if (ivs.atk % 2 === 0) return false;
|
|
}
|
|
if (['Ice', 'Water'].includes(type)) {
|
|
// Spe or Atk must be odd
|
|
if (ivs.spe % 2 === 0 && ivs.atk % 2 === 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
validateSource(
|
|
set: PokemonSet, source: PokemonSource, setSources: PokemonSources, species: Species, because: string
|
|
): string[] | undefined;
|
|
validateSource(
|
|
set: PokemonSet, source: PokemonSource, setSources: PokemonSources, species: Species
|
|
): true | undefined;
|
|
/**
|
|
* Returns array of error messages if invalid, undefined if valid
|
|
*
|
|
* If `because` is not passed, instead returns true if invalid.
|
|
*/
|
|
validateSource(
|
|
set: PokemonSet, source: PokemonSource, setSources: PokemonSources, species: Species, because?: string
|
|
) {
|
|
let eventData: EventInfo | undefined;
|
|
let eventSpecies = species;
|
|
if (source.charAt(1) === 'S') {
|
|
const splitSource = source.substr(source.charAt(2) === 'T' ? 3 : 2).split(' ');
|
|
const dex = (this.dex.gen === 1 ? this.dex.mod('gen2') : this.dex);
|
|
eventSpecies = dex.species.get(splitSource[1]);
|
|
const eventLsetData = this.dex.species.getLearnsetData(eventSpecies.id);
|
|
eventData = eventLsetData.eventData?.[parseInt(splitSource[0])];
|
|
if (!eventData) {
|
|
throw new Error(`${eventSpecies.name} from ${species.name} doesn't have data for event ${source}`);
|
|
}
|
|
} else if (source === '7V') {
|
|
const isMew = species.id === 'mew';
|
|
const isCelebi = species.id === 'celebi';
|
|
const g7speciesName = (species.gen > 2 && species.prevo) ? species.prevo : species.id;
|
|
const isHidden = !!this.dex.mod('gen7').species.get(g7speciesName).abilities['H'];
|
|
eventData = {
|
|
generation: 2,
|
|
level: isMew ? 5 : isCelebi ? 30 : 3, // Level 1/2 Pokémon can't be obtained by transfer from RBY/GSC
|
|
perfectIVs: isMew || isCelebi ? 5 : 3,
|
|
isHidden,
|
|
shiny: isMew ? undefined : 1,
|
|
pokeball: 'pokeball',
|
|
from: 'Gen 1-2 Virtual Console transfer',
|
|
};
|
|
} else if (source === '8V') {
|
|
const isMew = species.id === 'mew';
|
|
eventData = {
|
|
generation: 8,
|
|
perfectIVs: isMew ? 3 : undefined,
|
|
shiny: isMew ? undefined : 1,
|
|
from: 'Gen 7 Let\'s Go! HOME transfer',
|
|
};
|
|
} else if (source.charAt(1) === 'D') {
|
|
eventData = {
|
|
generation: 5,
|
|
level: 10,
|
|
from: 'Gen 5 Dream World',
|
|
isHidden: !!this.dex.mod('gen5').species.get(species.id).abilities['H'],
|
|
};
|
|
} else if (source.charAt(1) === 'E') {
|
|
if (this.findEggMoveFathers(source, species, setSources)) {
|
|
return undefined;
|
|
}
|
|
if (because) throw new Error(`Wrong place to get an egg incompatibility message`);
|
|
return true;
|
|
} else {
|
|
throw new Error(`Unidentified source ${source} passed to validateSource`);
|
|
}
|
|
|
|
// complicated fancy return signature
|
|
return this.validateEvent(set, setSources, eventData, eventSpecies, because as any) as any;
|
|
}
|
|
|
|
findEggMoveFathers(source: PokemonSource, species: Species, setSources: PokemonSources,
|
|
getAll?: false, pokemonBlacklist?: ID[], noRecurse?: true): boolean;
|
|
findEggMoveFathers(source: PokemonSource, species: Species, setSources: PokemonSources, getAll?: true): ID[] | null;
|
|
findEggMoveFathers(source: PokemonSource, species: Species, setSources: PokemonSources,
|
|
getAll?: boolean, pokemonBlacklist?: ID[], noRecurse?: boolean) {
|
|
if (!pokemonBlacklist) pokemonBlacklist = [];
|
|
if (!pokemonBlacklist.includes(species.id)) pokemonBlacklist.push(species.id);
|
|
// tradebacks have an eggGen of 2 even though the source is 1ET
|
|
const eggGen = Math.max(parseInt(source.charAt(0)), 2);
|
|
const fathers: ID[] = [];
|
|
// Gen 6+ don't have egg move incompatibilities
|
|
// (except for certain cases with baby Pokemon not handled here)
|
|
if (!getAll && eggGen >= 6 && !setSources.levelUpEggMoves && !species.mother) return true;
|
|
|
|
let eggMoves = setSources.limitedEggMoves;
|
|
if (eggGen === 3) eggMoves = eggMoves?.filter(eggMove => !setSources.pomegEggMoves?.includes(eggMove));
|
|
// must have 2 or more egg moves to have egg move incompatibilities
|
|
if (!eggMoves) {
|
|
// happens often in gen 1-6 LC if your only egg moves are level-up moves,
|
|
// which aren't limited and so aren't in `limitedEggMoves`
|
|
return getAll ? ['*'] : true;
|
|
}
|
|
if (!getAll && eggMoves.length <= 1 && !setSources.levelUpEggMoves) return true;
|
|
if (setSources.levelUpEggMoves && eggGen >= 6) eggMoves = setSources.levelUpEggMoves;
|
|
|
|
// gen 1 eggs come from gen 2 breeding
|
|
const dex = this.dex.gen === 1 ? this.dex.mod('gen2') : this.dex;
|
|
// In Gen 5 and earlier, egg moves can only be inherited from the father
|
|
// we'll test each possible father separately
|
|
let eggGroups = species.eggGroups;
|
|
if (species.id === 'nidoqueen' || species.id === 'nidorina') {
|
|
eggGroups = dex.species.get('nidoranf').eggGroups;
|
|
} else if (species.id === 'shedinja') {
|
|
// Shedinja and Nincada are different Egg groups; Shedinja itself is genderless
|
|
eggGroups = dex.species.get('nincada').eggGroups;
|
|
} else if (dex !== this.dex) {
|
|
// Gen 1 tradeback; grab the egg groups from Gen 2
|
|
eggGroups = dex.species.get(species.id).eggGroups;
|
|
}
|
|
if (eggGroups[0] === 'Undiscovered') eggGroups = dex.species.get(species.evos[0]).eggGroups;
|
|
if (eggGroups[0] === 'Undiscovered' || !eggGroups.length) {
|
|
throw new Error(`${species.name} has no egg groups for source ${source}`);
|
|
}
|
|
// no chainbreeding necessary if the father can be Smeargle
|
|
if (!getAll && eggGroups.includes('Field')) return true;
|
|
|
|
// try to find a father to inherit the egg move combination from
|
|
for (const father of dex.species.all()) {
|
|
// can't inherit from CAP pokemon
|
|
if (father.isNonstandard) continue;
|
|
// can't breed mons from future gens
|
|
if (father.gen > eggGen) continue;
|
|
// father must be male
|
|
if (father.gender === 'N' || father.gender === 'F') continue;
|
|
// can't inherit from dex entries with no learnsets
|
|
if (!dex.species.getLearnsetData(father.id).learnset) continue;
|
|
// something is clearly wrong if its only possible father is itself
|
|
// (exceptions: ExtremeSpeed Dragonite, Self-destruct Snorlax)
|
|
if (pokemonBlacklist.includes(father.id) && !['dragonite', 'snorlax'].includes(father.id)) continue;
|
|
// don't check NFE Pokémon - their evolutions will know all their moves and more
|
|
// exception: Combee/Salandit, because their evos can't be fathers
|
|
if (father.evos.length) {
|
|
const evolvedFather = dex.species.get(father.evos[0]);
|
|
if (evolvedFather.gen <= eggGen && evolvedFather.gender !== 'F') continue;
|
|
}
|
|
|
|
// must be able to breed with father
|
|
if (!father.eggGroups.some(eggGroup => eggGroups.includes(eggGroup))) continue;
|
|
|
|
// father must be able to learn the move
|
|
if (!this.fatherCanLearn(species, father, eggMoves, eggGen, pokemonBlacklist, noRecurse)) continue;
|
|
|
|
// father found!
|
|
if (!getAll) return true;
|
|
fathers.push(father.id);
|
|
}
|
|
if (!getAll) return false;
|
|
return (!fathers.length && eggGen < 6) ? null : fathers;
|
|
}
|
|
|
|
/**
|
|
* We could, if we wanted, do a complete move validation of the father's
|
|
* moveset to see if it's valid. This would recurse and be NP-Hard so
|
|
* instead we won't. We'll instead use a simplified algorithm: The father
|
|
* is allowed to have multiple egg moves and a maximum of one move from
|
|
* any other restrictive source; recursion is done only if there are less
|
|
* egg moves to validate or if the father has an egg group it doesn't
|
|
* share with the egg Pokemon. Recursion is also limited to two iterations
|
|
* of calling findEggMoveFathers.
|
|
*/
|
|
fatherCanLearn(baseSpecies: Species, species: Species, moves: ID[], eggGen: number, pokemonBlacklist: ID[],
|
|
noRecurse: boolean | undefined) {
|
|
if (!this.dex.species.getLearnsetData(species.id).learnset) return false;
|
|
|
|
if (species.id === 'smeargle') return true;
|
|
const canBreedWithSmeargle = species.eggGroups.includes('Field');
|
|
|
|
const allEggSources = new PokemonSources();
|
|
allEggSources.sourcesBefore = eggGen;
|
|
for (const move of moves) {
|
|
const eggSources = new PokemonSources();
|
|
for (const { learnset, species: curSpecies } of this.dex.species.getFullLearnset(species.id)) {
|
|
const eggPokemon = curSpecies.prevo ? curSpecies.id : '';
|
|
if (learnset[move]) {
|
|
for (const moveSource of learnset[move]) {
|
|
if (eggGen > 8 && parseInt(moveSource.charAt(0)) <= 8) continue;
|
|
if (parseInt(moveSource.charAt(0)) > eggGen) continue;
|
|
const canLearnFromSmeargle = moveSource.charAt(1) === 'E' && canBreedWithSmeargle;
|
|
if (!'ESDV'.includes(moveSource.charAt(1)) || canLearnFromSmeargle) {
|
|
eggSources.addGen(parseInt(moveSource.charAt(0)));
|
|
break;
|
|
} else {
|
|
if (moveSource.charAt(1) === 'E') {
|
|
eggSources.add(moveSource + eggPokemon, move);
|
|
if (eggGen === 2 && this.dex.moves.getByID(move).gen === 1) eggSources.add('1ET' + eggPokemon, move);
|
|
} else {
|
|
eggSources.add(moveSource + eggPokemon);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (eggSources.sourcesBefore === eggGen) break;
|
|
}
|
|
|
|
if (eggSources.sourcesBefore === eggGen) continue;
|
|
if (!eggSources.sourcesBefore && !eggSources.sources.length) return false;
|
|
const onlyEggSources = eggSources.sources.filter(source => source.charAt(1) === 'E');
|
|
if (eggGen >= 3 && onlyEggSources.length && eggSources.limitedEggMoves === null && eggSources.sourcesBefore) {
|
|
eggSources.possiblyLimitedEggMoves = [toID(`${eggSources.sourcesBefore}${move}`)];
|
|
}
|
|
allEggSources.intersectWith(eggSources);
|
|
if (!allEggSources.size()) return false;
|
|
}
|
|
pokemonBlacklist.push(species.id);
|
|
if (allEggSources.limitedEggMoves && allEggSources.limitedEggMoves.length > 1) {
|
|
if (noRecurse) return false;
|
|
let canChainbreed = false;
|
|
for (const fatherEggGroup of species.eggGroups) {
|
|
if (!baseSpecies.eggGroups.includes(fatherEggGroup)) {
|
|
canChainbreed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!canChainbreed && allEggSources.limitedEggMoves.length === moves.length) return false;
|
|
const setSources = new PokemonSources();
|
|
setSources.limitedEggMoves = allEggSources.limitedEggMoves;
|
|
return this.findEggMoveFathers(allEggSources.sources[0], species, setSources, false, pokemonBlacklist, true);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
motherCanLearn(species: ID, move: ID) {
|
|
if (!species) return false;
|
|
const fullLearnset = this.dex.species.getFullLearnset(species);
|
|
for (const { learnset } of fullLearnset) {
|
|
if (learnset[move]) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
validateForme(set: PokemonSet) {
|
|
const dex = this.dex;
|
|
const name = set.name || set.species;
|
|
|
|
const problems = [];
|
|
const item = dex.items.get(set.item);
|
|
const species = dex.species.get(set.species);
|
|
|
|
if (species.name === 'Necrozma-Ultra') {
|
|
const whichMoves = (set.moves.map(toID).includes('sunsteelstrike' as ID) ? 1 : 0) +
|
|
(set.moves.map(toID).includes('moongeistbeam' as ID) ? 2 : 0);
|
|
if (item.name !== 'Ultranecrozium Z') {
|
|
// Necrozma-Ultra transforms from one of two formes, and neither one is the base forme
|
|
problems.push(`Necrozma-Ultra must start the battle holding Ultranecrozium Z.`);
|
|
} else if (whichMoves === 1) {
|
|
set.species = 'Necrozma-Dusk-Mane';
|
|
set.ability = 'Prism Armor';
|
|
} else if (whichMoves === 2) {
|
|
set.species = 'Necrozma-Dawn-Wings';
|
|
set.ability = 'Prism Armor';
|
|
} else {
|
|
problems.push(`Necrozma-Ultra must start the battle as Necrozma-Dusk-Mane or Necrozma-Dawn-Wings holding Ultranecrozium Z. Please specify which Necrozma it should start as.`);
|
|
}
|
|
} else if (species.name === 'Zygarde-Complete') {
|
|
problems.push(`Zygarde-Complete must start the battle as Zygarde or Zygarde-10% with Power Construct. Please specify which Zygarde it should start as.`);
|
|
} else if (species.baseSpecies === 'Terapagos') {
|
|
set.species = 'Terapagos';
|
|
set.ability = 'Tera Shift';
|
|
} else if (species.battleOnly) {
|
|
if (species.requiredAbility && set.ability !== species.requiredAbility) {
|
|
// Darmanitan-Zen
|
|
problems.push(`${species.name} transforms in-battle with ${species.requiredAbility}, please fix its ability.`);
|
|
}
|
|
if (species.requiredItems) {
|
|
if (!species.requiredItems.includes(item.name)) {
|
|
// Mega or Primal
|
|
problems.push(`${species.name} transforms in-battle with ${species.requiredItem}, please fix its item.`);
|
|
}
|
|
}
|
|
if (species.requiredMove && !set.moves.map(toID).includes(toID(species.requiredMove))) {
|
|
// Meloetta-Pirouette, Rayquaza-Mega
|
|
problems.push(`${species.name} transforms in-battle with ${species.requiredMove}, please fix its moves.`);
|
|
}
|
|
if (typeof species.battleOnly !== 'string') {
|
|
// Ultra Necrozma and Complete Zygarde are already checked above
|
|
throw new Error(`${species.name} should have a string battleOnly`);
|
|
}
|
|
// Set to out-of-battle forme
|
|
set.species = species.battleOnly;
|
|
} else {
|
|
if (species.requiredAbility) {
|
|
// Impossible!
|
|
throw new Error(`Species ${species.name} has a required ability despite not being a battle-only forme; it should just be in its abilities table.`);
|
|
}
|
|
if (species.requiredItems && !species.requiredItems.includes(item.name)) {
|
|
if (dex.gen >= 8 && (species.baseSpecies === 'Arceus' || species.baseSpecies === 'Silvally')) {
|
|
// Arceus/Silvally formes in gen 8 only require the item with Multitype/RKS System
|
|
if (set.ability === species.abilities[0]) {
|
|
problems.push(
|
|
`${name} needs to hold ${species.requiredItems.join(' or ')}.`,
|
|
`(It will revert to its Normal forme if you remove the item or give it a different item.)`
|
|
);
|
|
}
|
|
} else {
|
|
// Memory/Drive/Griseous Orb/Plate/Z-Crystal - Forme mismatch
|
|
const baseSpecies = this.dex.species.get(species.changesFrom);
|
|
problems.push(
|
|
`${name} needs to hold ${species.requiredItems.join(' or ')} to be in its ${species.forme} forme.`,
|
|
`(It will revert to its ${baseSpecies.baseForme || 'base'} forme if you remove the item or give it a different item.)`
|
|
);
|
|
}
|
|
}
|
|
if (species.requiredMove && !set.moves.map(toID).includes(toID(species.requiredMove))) {
|
|
const baseSpecies = this.dex.species.get(species.changesFrom);
|
|
problems.push(
|
|
`${name} needs to know the move ${species.requiredMove} to be in its ${species.forme} forme.`,
|
|
`(It will revert to its ${baseSpecies.baseForme} forme if it forgets the move.)`
|
|
);
|
|
}
|
|
|
|
// Mismatches between the set forme (if not base) and the item signature forme will have been rejected already.
|
|
// It only remains to assign the right forme to a set with the base species (Arceus/Genesect/Giratina/Silvally).
|
|
if (item.forcedForme && species.name === dex.species.get(item.forcedForme).baseSpecies) {
|
|
set.species = item.forcedForme;
|
|
}
|
|
}
|
|
|
|
if (species.name === 'Pikachu-Cosplay') {
|
|
const cosplay: { [k: string]: string } = {
|
|
meteormash: 'Pikachu-Rock-Star', iciclecrash: 'Pikachu-Belle', drainingkiss: 'Pikachu-Pop-Star',
|
|
electricterrain: 'Pikachu-PhD', flyingpress: 'Pikachu-Libre',
|
|
};
|
|
for (const moveid of set.moves) {
|
|
if (moveid in cosplay) {
|
|
set.species = cosplay[moveid];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (species.name === 'Keldeo' && set.moves.map(toID).includes('secretsword' as ID) && dex.gen >= 8) {
|
|
set.species = 'Keldeo-Resolute';
|
|
}
|
|
|
|
const crowned: { [k: string]: string } = {
|
|
'Zacian-Crowned': 'behemothblade', 'Zamazenta-Crowned': 'behemothbash',
|
|
};
|
|
if (species.name in crowned) {
|
|
const behemothMove = set.moves.map(toID).indexOf(crowned[species.name] as ID);
|
|
if (behemothMove >= 0) {
|
|
set.moves[behemothMove] = 'ironhead';
|
|
}
|
|
}
|
|
if (species.baseSpecies === "Hoopa" && dex.gen >= 9) {
|
|
const moves = set.moves.map(toID);
|
|
const hyperspaceHole = moves.indexOf('hyperspacehole' as ID);
|
|
const hyperspaceFury = moves.indexOf('hyperspacefury' as ID);
|
|
if (species.name === "Hoopa" && hyperspaceFury >= 0) {
|
|
problems.push(`In Generation 9, Hoopa cannot run Hyperspace Fury because it gets replaced with Hyperspace Hole upon changing forme.`);
|
|
} else if (species.name === "Hoopa-Unbound" && hyperspaceHole >= 0) {
|
|
problems.push(`In Generation 9, Hoopa-Unbound cannot run Hyperspace Hole because it gets replaced with Hyperspace Fury upon changing forme.`);
|
|
}
|
|
}
|
|
|
|
if (species.baseSpecies === "Greninja" && toID(set.ability) === 'battlebond') {
|
|
set.species = "Greninja-Bond";
|
|
}
|
|
if (species.baseSpecies === "Rockruff" && toID(set.ability) === 'owntempo') {
|
|
set.species = "Rockruff-Dusk";
|
|
}
|
|
|
|
if (species.baseSpecies === "Unown" && dex.gen === 2) {
|
|
let resultBinary = '';
|
|
for (const iv of ['atk', 'def', 'spe', 'spa'] as const) {
|
|
resultBinary += set.ivs[iv].toString(2).padStart(5, '0').slice(1, 3);
|
|
}
|
|
const resultDecimal = Math.floor(parseInt(resultBinary, 2) / 10);
|
|
const expectedLetter = String.fromCharCode(resultDecimal + 65);
|
|
const unownLetter = species.forme || "A";
|
|
if (unownLetter !== expectedLetter) {
|
|
problems.push(`Unown has forme ${unownLetter}, but its DVs give it the forme ${expectedLetter}.`);
|
|
}
|
|
}
|
|
return problems;
|
|
}
|
|
|
|
checkSpecies(set: PokemonSet, species: Species, tierSpecies: Species, setHas: { [k: string]: true }) {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
// https://www.smogon.com/forums/posts/8659168
|
|
if (
|
|
(tierSpecies.id === 'zamazentacrowned' && species.id === 'zamazenta') ||
|
|
(tierSpecies.id === 'zaciancrowned' && species.id === 'zacian')
|
|
) {
|
|
species = tierSpecies;
|
|
}
|
|
|
|
setHas['pokemon:' + species.id] = true;
|
|
setHas['basepokemon:' + toID(species.baseSpecies)] = true;
|
|
|
|
let isMega = false;
|
|
if (tierSpecies !== species) {
|
|
setHas['pokemon:' + tierSpecies.id] = true;
|
|
if (tierSpecies.isMega || tierSpecies.isPrimal) {
|
|
setHas['pokemontag:mega'] = true;
|
|
isMega = true;
|
|
}
|
|
}
|
|
|
|
let isGmax = false;
|
|
if (tierSpecies.canGigantamax && set.gigantamax) {
|
|
setHas['pokemon:' + tierSpecies.id + 'gmax'] = true;
|
|
isGmax = true;
|
|
}
|
|
if (tierSpecies.baseSpecies === 'Greninja' && toID(set.ability) === 'battlebond') {
|
|
setHas['pokemon:greninjabond'] = true;
|
|
}
|
|
if (tierSpecies.baseSpecies === 'Rockruff' && toID(set.ability) === 'owntempo') {
|
|
setHas['pokemon:rockruffdusk'] = true;
|
|
}
|
|
|
|
const tier = tierSpecies.tier === '(PU)' ? 'ZU' : tierSpecies.tier === '(NU)' ? 'PU' : tierSpecies.tier;
|
|
const tierTag = 'pokemontag:' + toID(tier);
|
|
setHas[tierTag] = true;
|
|
|
|
const doublesTier = tierSpecies.doublesTier === '(DUU)' ? 'DNU' : tierSpecies.doublesTier;
|
|
const doublesTierTag = 'pokemontag:' + toID(doublesTier);
|
|
setHas[doublesTierTag] = true;
|
|
|
|
const ndTier = tierSpecies.natDexTier === '(PU)' ? 'ZU' :
|
|
tierSpecies.natDexTier === '(NU)' ? 'PU' : tierSpecies.natDexTier;
|
|
const ndTierTag = 'pokemontag:nd' + toID(ndTier);
|
|
setHas[ndTierTag] = true;
|
|
|
|
// Only pokemon that can gigantamax should have the Gmax flag
|
|
if (!tierSpecies.canGigantamax && set.gigantamax) {
|
|
return `${tierSpecies.name} cannot Gigantamax but is flagged as being able to.`;
|
|
}
|
|
|
|
let banReason = ruleTable.check('pokemon:' + species.id);
|
|
if (banReason) {
|
|
return `${species.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
if (tierSpecies !== species) {
|
|
banReason = ruleTable.check('pokemon:' + tierSpecies.id);
|
|
if (banReason) {
|
|
return `${tierSpecies.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
if (isMega) {
|
|
banReason = ruleTable.check('pokemontag:mega', setHas);
|
|
if (banReason) {
|
|
return `Mega evolutions are ${banReason}.`;
|
|
}
|
|
}
|
|
|
|
if (isGmax) {
|
|
banReason = ruleTable.check('pokemon:' + tierSpecies.id + 'gmax');
|
|
if (banReason) {
|
|
return `Gigantamaxing ${species.name} is ${banReason}.`;
|
|
}
|
|
}
|
|
|
|
banReason = ruleTable.check('basepokemon:' + toID(species.baseSpecies));
|
|
if (banReason) {
|
|
return `${species.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') {
|
|
// don't allow nonstandard speciess when whitelisting standard base species
|
|
// i.e. unbanning Pichu doesn't mean allowing Pichu-Spiky-Eared outside of Gen 4
|
|
const baseSpecies = dex.species.get(species.baseSpecies);
|
|
if (baseSpecies.isNonstandard === species.isNonstandard) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// We can't return here because the `-nonexistent` rule is a bit
|
|
// complicated in terms of what trumps it. We don't want e.g.
|
|
// +Mythical to unban Shaymin in Gen 1, for instance.
|
|
let nonexistentCheck = Tags.nonexistent.genericFilter!(tierSpecies) && ruleTable.check('nonexistent');
|
|
|
|
const EXISTENCE_TAG = ['past', 'future', 'lgpe', 'unobtainable', 'cap', 'custom', 'nonexistent'];
|
|
|
|
for (const ruleid of ruleTable.tagRules) {
|
|
if (ruleid.startsWith('*')) continue;
|
|
const tagid = ruleid.slice(12) as ID;
|
|
const tag = Tags[tagid];
|
|
if ((tag.speciesFilter || tag.genericFilter)!(tierSpecies)) {
|
|
const existenceTag = EXISTENCE_TAG.includes(tagid);
|
|
if (ruleid.startsWith('+')) {
|
|
// we want rules like +CAP to trump -Nonexistent, but most tags shouldn't
|
|
if (!existenceTag && nonexistentCheck) continue;
|
|
return null;
|
|
}
|
|
if (existenceTag) {
|
|
// for a nicer error message
|
|
nonexistentCheck = 'banned';
|
|
break;
|
|
}
|
|
return `${species.name} is tagged ${tag.name}, which is ${ruleTable.check(ruleid.slice(1)) || "banned"}.`;
|
|
}
|
|
}
|
|
|
|
if (nonexistentCheck) {
|
|
if (tierSpecies.isNonstandard === 'Past' || tierSpecies.isNonstandard === 'Future') {
|
|
return `${tierSpecies.name} does not exist in Gen ${dex.gen}.`;
|
|
}
|
|
if (tierSpecies.isNonstandard === 'LGPE') {
|
|
return `${tierSpecies.name} does not exist in this game, only in Let's Go Pikachu/Eevee.`;
|
|
}
|
|
if (tierSpecies.isNonstandard === 'CAP') {
|
|
return `${tierSpecies.name} is a CAP and does not exist in this game.`;
|
|
}
|
|
if (tierSpecies.isNonstandard === 'Unobtainable') {
|
|
return `${tierSpecies.name} is not possible to obtain in this game.`;
|
|
}
|
|
if (tierSpecies.isNonstandard === 'Gigantamax') {
|
|
return `${tierSpecies.name} is a placeholder for a Gigantamax sprite, not a real Pokémon. (This message is likely to be a validator bug.)`;
|
|
}
|
|
return `${tierSpecies.name} does not exist in this game.`;
|
|
}
|
|
if (nonexistentCheck === '') return null;
|
|
|
|
// Special casing for Pokemon that can Gmax, but their Gmax factor cannot be legally obtained
|
|
if (tierSpecies.gmaxUnreleased && set.gigantamax) {
|
|
banReason = ruleTable.check('pokemontag:unobtainable');
|
|
if (banReason) {
|
|
return `${tierSpecies.name} is flagged as gigantamax, but it cannot gigantamax without hacking or glitches.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
banReason = ruleTable.check('pokemontag:allpokemon');
|
|
if (banReason) {
|
|
return `${species.name} is not in the list of allowed pokemon.`;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
checkItem(set: PokemonSet, item: Item, setHas: { [k: string]: true }) {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
setHas['item:' + item.id] = true;
|
|
|
|
let banReason = ruleTable.check('item:' + (item.id || 'noitem'));
|
|
if (banReason) {
|
|
if (!item.id) {
|
|
return `${set.name} not holding an item is ${banReason}.`;
|
|
}
|
|
return `${set.name}'s item ${item.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
if (!item.id) return null;
|
|
|
|
banReason = ruleTable.check('pokemontag:allitems');
|
|
if (banReason) {
|
|
return `${set.name}'s item ${item.name} is not in the list of allowed items.`;
|
|
}
|
|
|
|
// obtainability
|
|
if (item.isNonstandard) {
|
|
banReason = ruleTable.check('pokemontag:' + toID(item.isNonstandard));
|
|
if (banReason) {
|
|
if (item.isNonstandard === 'Unobtainable') {
|
|
return `${item.name} is not obtainable without hacking or glitches.`;
|
|
}
|
|
return `${set.name}'s item ${item.name} is tagged ${item.isNonstandard}, which is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
if (item.isNonstandard && item.isNonstandard !== 'Unobtainable') {
|
|
banReason = ruleTable.check('nonexistent', setHas);
|
|
if (banReason) {
|
|
if (['Past', 'Future'].includes(item.isNonstandard)) {
|
|
return `${set.name}'s item ${item.name} does not exist in Gen ${dex.gen}.`;
|
|
}
|
|
return `${set.name}'s item ${item.name} does not exist in this game.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
checkMove(set: PokemonSet, move: Move, setHas: { [k: string]: true }) {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
setHas['move:' + move.id] = true;
|
|
|
|
let banReason = ruleTable.check('move:' + move.id);
|
|
if (banReason) {
|
|
return `${set.name}'s move ${move.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
banReason = ruleTable.check('pokemontag:allmoves');
|
|
if (banReason) {
|
|
return `${set.name}'s move ${move.name} is not in the list of allowed moves.`;
|
|
}
|
|
|
|
// obtainability
|
|
if (move.isNonstandard) {
|
|
banReason = ruleTable.check('pokemontag:' + toID(move.isNonstandard));
|
|
if (banReason) {
|
|
if (move.isNonstandard === 'Unobtainable') {
|
|
return `${move.name} is not obtainable without hacking or glitches${dex.gen >= 9 && move.gen < dex.gen ? ` in Gen ${dex.gen}` : ``}.`;
|
|
}
|
|
if (move.isNonstandard === 'Gigantamax') {
|
|
return `${move.name} is not usable without Gigantamaxing its user, ${move.isMax}.`;
|
|
}
|
|
return `${set.name}'s move ${move.name} is tagged ${move.isNonstandard}, which is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
if (move.isNonstandard && move.isNonstandard !== 'Unobtainable') {
|
|
banReason = ruleTable.check('nonexistent', setHas);
|
|
if (banReason) {
|
|
if (['Past', 'Future'].includes(move.isNonstandard)) {
|
|
return `${set.name}'s move ${move.name} does not exist in Gen ${dex.gen}.`;
|
|
}
|
|
return `${set.name}'s move ${move.name} does not exist in this game.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
checkAbility(set: PokemonSet, ability: Ability, setHas: { [k: string]: true }) {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
setHas['ability:' + ability.id] = true;
|
|
|
|
if (this.format.id.startsWith('gen9pokebilities')) {
|
|
const species = dex.species.get(set.species);
|
|
const unSeenAbilities = Object.keys(species.abilities)
|
|
.filter(key => key !== 'S' && (key !== 'H' || !species.unreleasedHidden))
|
|
.map(key => species.abilities[key as "0" | "1" | "H" | "S"]);
|
|
|
|
if (ability.id !== this.toID(species.abilities['S'])) {
|
|
for (const abilityName of unSeenAbilities) {
|
|
setHas['ability:' + toID(abilityName)] = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
let banReason = ruleTable.check('ability:' + ability.id);
|
|
if (banReason) {
|
|
return `${set.name}'s ability ${ability.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
banReason = ruleTable.check('pokemontag:allabilities');
|
|
if (banReason) {
|
|
return `${set.name}'s ability ${ability.name} is not in the list of allowed abilities.`;
|
|
}
|
|
|
|
// obtainability
|
|
if (ability.isNonstandard) {
|
|
banReason = ruleTable.check('pokemontag:' + toID(ability.isNonstandard));
|
|
if (banReason) {
|
|
return `${set.name}'s ability ${ability.name} is tagged ${ability.isNonstandard}, which is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
banReason = ruleTable.check('nonexistent', setHas);
|
|
if (banReason) {
|
|
if (['Past', 'Future'].includes(ability.isNonstandard)) {
|
|
return `${set.name}'s ability ${ability.name} does not exist in Gen ${dex.gen}.`;
|
|
}
|
|
return `${set.name}'s ability ${ability.name} does not exist in this game.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
checkNature(set: PokemonSet, nature: Nature, setHas: { [k: string]: true }) {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
setHas['nature:' + nature.id] = true;
|
|
|
|
let banReason = ruleTable.check('nature:' + nature.id);
|
|
if (banReason) {
|
|
return `${set.name}'s nature ${nature.name} is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
banReason = ruleTable.check('allnatures');
|
|
if (banReason) {
|
|
return `${set.name}'s nature ${nature.name} is not in the list of allowed natures.`;
|
|
}
|
|
|
|
// obtainability
|
|
if (nature.isNonstandard) {
|
|
banReason = ruleTable.check('pokemontag:' + toID(nature.isNonstandard));
|
|
if (banReason) {
|
|
return `${set.name}'s nature ${nature.name} is tagged ${nature.isNonstandard}, which is ${banReason}.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
|
|
banReason = ruleTable.check('nonexistent', setHas);
|
|
if (banReason) {
|
|
if (['Past', 'Future'].includes(nature.isNonstandard)) {
|
|
return `${set.name}'s nature ${nature.name} does not exist in Gen ${dex.gen}.`;
|
|
}
|
|
return `${set.name}'s nature ${nature.name} does not exist in this game.`;
|
|
}
|
|
if (banReason === '') return null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
validateEvent(
|
|
set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species
|
|
): true | undefined;
|
|
validateEvent(
|
|
set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species,
|
|
because: string, from?: string
|
|
): string[] | undefined;
|
|
/**
|
|
* Returns array of error messages if invalid, undefined if valid
|
|
*
|
|
* If `because` is not passed, instead returns true if invalid.
|
|
*/
|
|
validateEvent(
|
|
set: PokemonSet, setSources: PokemonSources, eventData: EventInfo, eventSpecies: Species,
|
|
because = ``, from = `from an event`
|
|
) {
|
|
const dex = this.dex;
|
|
let name = set.species;
|
|
const species = dex.species.get(set.species);
|
|
const maxSourceGen = this.ruleTable.has('allowtradeback') ? Utils.clampIntRange(dex.gen + 1, 1, 8) : dex.gen;
|
|
if (!eventSpecies) eventSpecies = species;
|
|
if (set.name && set.species !== set.name && species.baseSpecies !== set.name) name = `${set.name} (${set.species})`;
|
|
|
|
const fastReturn = !because;
|
|
if (eventData.from) from = `from ${eventData.from}`;
|
|
const etc = `${because} ${from}`;
|
|
|
|
const problems = [];
|
|
|
|
if (dex.gen < 8 && this.minSourceGen > eventData.generation) {
|
|
if (fastReturn) return true;
|
|
problems.push(`This format requires Pokemon from gen ${this.minSourceGen} or later and ${name} is from gen ${eventData.generation}${etc}.`);
|
|
}
|
|
if (maxSourceGen < eventData.generation) {
|
|
if (fastReturn) return true;
|
|
problems.push(`This format is in gen ${dex.gen} and ${name} is from gen ${eventData.generation}${etc}.`);
|
|
}
|
|
|
|
if (eventData.japan && dex.currentMod !== 'gen1jpn') {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} has moves from Japan-only events, but this format simulates International Yellow/Crystal which can't trade with Japanese games.`);
|
|
}
|
|
|
|
if (eventData.level && (set.level || 0) < eventData.level) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must be at least level ${eventData.level}${etc}.`);
|
|
}
|
|
if ((eventData.shiny === true && !set.shiny) || (!eventData.shiny && set.shiny)) {
|
|
if (fastReturn) return true;
|
|
const shinyReq = eventData.shiny ? ` be shiny` : ` not be shiny`;
|
|
problems.push(`${name} must${shinyReq}${etc}.`);
|
|
}
|
|
if (eventData.gender) {
|
|
if (set.gender && eventData.gender !== set.gender) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name}'s gender must be ${eventData.gender}${etc}.`);
|
|
}
|
|
}
|
|
const canMint = dex.gen > 7;
|
|
if (eventData.nature && eventData.nature !== set.nature && !canMint) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must have a ${eventData.nature} nature${etc} - Mints are only available starting gen 8.`);
|
|
}
|
|
let requiredIVs = 0;
|
|
if (eventData.ivs) {
|
|
/** In Gen 7+, IVs can be changed to 31 */
|
|
const canBottleCap = dex.gen >= 7 && set.level >= (dex.gen < 9 ? 100 : 50);
|
|
|
|
if (!set.ivs) set.ivs = { hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31 };
|
|
let statName: StatID;
|
|
for (statName in eventData.ivs) {
|
|
if (canBottleCap && set.ivs[statName] === 31) continue;
|
|
if (set.ivs[statName] !== eventData.ivs[statName]) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must have ${eventData.ivs[statName]} ${Dex.stats.names[statName]} IVs${etc}.`);
|
|
}
|
|
}
|
|
|
|
if (canBottleCap) {
|
|
// IVs can be overridden but Hidden Power type can't
|
|
if (Object.keys(eventData.ivs).length >= 6) {
|
|
const requiredHpType = dex.getHiddenPower(eventData.ivs as StatsTable).type;
|
|
if (set.hpType && set.hpType !== requiredHpType) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} can only have Hidden Power ${requiredHpType}${etc}.`);
|
|
}
|
|
set.hpType = requiredHpType;
|
|
}
|
|
}
|
|
} else {
|
|
requiredIVs = eventData.perfectIVs || 0;
|
|
}
|
|
if (requiredIVs && set.ivs) {
|
|
// Legendary Pokemon must have at least 3 perfect IVs in gen 6
|
|
// Events can also have a certain amount of guaranteed perfect IVs
|
|
let perfectIVs = 0;
|
|
let statName: StatID;
|
|
for (statName in set.ivs) {
|
|
if (set.ivs[statName] >= 31) perfectIVs++;
|
|
}
|
|
if (perfectIVs < requiredIVs) {
|
|
if (fastReturn) return true;
|
|
if (eventData.perfectIVs) {
|
|
problems.push(`${name} must have at least ${requiredIVs} perfect IVs${etc}.`);
|
|
}
|
|
}
|
|
// The perfect IV count affects Hidden Power availability
|
|
if (dex.gen >= 3 && requiredIVs >= 3 && set.hpType === 'Fighting') {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} can't use Hidden Power Fighting because it must have at least three perfect IVs${etc}.`);
|
|
} else if (
|
|
dex.gen >= 3 && requiredIVs >= 5 && set.hpType &&
|
|
!['Dark', 'Dragon', 'Electric', 'Steel', 'Ice'].includes(set.hpType)
|
|
) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} can only use Hidden Power Dark/Dragon/Electric/Steel/Ice because it must have at least 5 perfect IVs${etc}.`);
|
|
}
|
|
}
|
|
const ruleTable = this.ruleTable;
|
|
if (ruleTable.has('obtainablemoves')) {
|
|
const ssMaxSourceGen = setSources.maxSourceGen();
|
|
const tradebackEligible = dex.gen === 2 && (species.gen === 1 || eventSpecies.gen === 1);
|
|
if (ssMaxSourceGen && eventData.generation > ssMaxSourceGen && !tradebackEligible) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must not have moves only learnable in gen ${ssMaxSourceGen}${etc}.`);
|
|
}
|
|
|
|
if (eventData.from === "Gen 5 Dream World" && setSources.dreamWorldMoveCount > 1) {
|
|
problems.push(`${name} can only have one Dream World move.`);
|
|
}
|
|
}
|
|
if (ruleTable.has('obtainableabilities')) {
|
|
if (dex.gen <= 5 && eventData.abilities && eventData.abilities.length === 1 && !eventData.isHidden) {
|
|
if (species.name === eventSpecies.name) {
|
|
// has not evolved, abilities must match
|
|
const requiredAbility = dex.abilities.get(eventData.abilities[0]).name;
|
|
if (set.ability !== requiredAbility) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must have ${requiredAbility}${etc}.`);
|
|
}
|
|
} else {
|
|
// has evolved
|
|
const ability1 = dex.abilities.get(eventSpecies.abilities['1']);
|
|
if (ability1.gen && eventData.generation >= ability1.gen) {
|
|
// pokemon had 2 available abilities in the gen the event happened
|
|
// ability is restricted to a single ability slot
|
|
const requiredAbilitySlot = (toID(eventData.abilities[0]) === ability1.id ? 1 : 0);
|
|
const requiredAbility = dex.abilities.get(species.abilities[requiredAbilitySlot] || species.abilities['0']).name;
|
|
if (set.ability !== requiredAbility) {
|
|
const originalAbility = dex.abilities.get(eventData.abilities[0]).name;
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must have ${requiredAbility}${because} from a ${originalAbility} ${eventSpecies.name} event.`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (species.abilities['H']) {
|
|
const isHidden = (set.ability === species.abilities['H']);
|
|
if (!isHidden && eventData.isHidden && dex.gen <= 8) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must have its Hidden Ability${etc}.`);
|
|
}
|
|
|
|
const canUseAbilityPatch = dex.gen >= 8 && this.format.mod !== 'gen8dlc1';
|
|
if (isHidden && !eventData.isHidden && !canUseAbilityPatch) {
|
|
if (fastReturn) return true;
|
|
problems.push(`${name} must not have its Hidden Ability${etc}.`);
|
|
}
|
|
}
|
|
}
|
|
if (problems.length) return problems;
|
|
if (eventData.gender) set.gender = eventData.gender;
|
|
}
|
|
|
|
allSources(species?: Species) {
|
|
let minSourceGen = this.minSourceGen;
|
|
if (this.dex.gen >= 3 && minSourceGen < 3) minSourceGen = 3;
|
|
if (species) minSourceGen = Math.max(minSourceGen, species.gen);
|
|
const maxSourceGen = this.ruleTable.has('allowtradeback') ? Utils.clampIntRange(this.dex.gen + 1, 1, 8) : this.dex.gen;
|
|
return new PokemonSources(maxSourceGen, minSourceGen);
|
|
}
|
|
|
|
validateMoves(
|
|
species: Species, moves: string[], setSources: PokemonSources, set?: Partial<PokemonSet>,
|
|
name: string = species.name, moveLegalityWhitelist: { [k: string]: true | undefined } = {}
|
|
) {
|
|
const dex = this.dex;
|
|
const ruleTable = this.ruleTable;
|
|
|
|
const problems = [];
|
|
|
|
const checkCanLearn = (ruleTable.checkCanLearn?.[0] || this.checkCanLearn);
|
|
for (const moveName of moves) {
|
|
const move = dex.moves.get(moveName);
|
|
if (moveLegalityWhitelist[move.id]) continue;
|
|
const problem = checkCanLearn.call(this, move, species, setSources, set);
|
|
if (problem) {
|
|
problems.push(`${name}${problem}`);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (setSources.size() && setSources.moveEvoCarryCount > 3) {
|
|
if (setSources.sourcesBefore < 6) setSources.sourcesBefore = 0;
|
|
setSources.sources = setSources.sources.filter(
|
|
source => source.charAt(1) === 'E' && parseInt(source.charAt(0)) >= 6
|
|
);
|
|
if (!setSources.size()) {
|
|
problems.push(`${name} needs to know ${species.evoMove || 'a Fairy-type move'} to evolve, so it can only know 3 other moves from ${species.prevo}.`);
|
|
}
|
|
}
|
|
|
|
if (problems.length) return problems;
|
|
|
|
if (setSources.isHidden) {
|
|
setSources.sources = setSources.sources.filter(
|
|
source => parseInt(source.charAt(0)) >= 5
|
|
);
|
|
if (setSources.sourcesBefore < 5) setSources.sourcesBefore = 0;
|
|
const canUseAbilityPatch = dex.gen >= 8 && this.format.mod !== 'gen8dlc1';
|
|
if (!setSources.size() && !canUseAbilityPatch) {
|
|
problems.push(`${name} has a hidden ability - it can't have moves only learned before gen 5.`);
|
|
return problems;
|
|
}
|
|
}
|
|
|
|
if (setSources.babyOnly && setSources.sources.length) {
|
|
const baby = dex.species.get(setSources.babyOnly);
|
|
const babyEvo = toID(baby.evos[0]);
|
|
setSources.sources = setSources.sources.filter(source => {
|
|
if (source.charAt(1) === 'S') {
|
|
const sourceId = source.split(' ')[1];
|
|
if (sourceId !== baby.id) return false;
|
|
}
|
|
if (source.charAt(1) === 'E') {
|
|
if (babyEvo && source.slice(2) === babyEvo) return false;
|
|
}
|
|
if (source.charAt(1) === 'D') {
|
|
if (babyEvo && source.slice(2) === babyEvo) return false;
|
|
}
|
|
return true;
|
|
});
|
|
if (!setSources.size()) {
|
|
problems.push(`${name}'s event/egg moves are from an evolution, and are incompatible with its moves from ${baby.name}.`);
|
|
}
|
|
}
|
|
if (setSources.babyOnly && setSources.size() && this.gen > 2) {
|
|
// there do theoretically exist evo/tradeback incompatibilities in
|
|
// gen 2, but those are very complicated to validate and should be
|
|
// handled separately anyway, so for now we just treat them all as
|
|
// legal (competitively relevant ones can be manually banned)
|
|
const baby = dex.species.get(setSources.babyOnly);
|
|
setSources.sources = setSources.sources.filter(source => {
|
|
if (baby.gen > parseInt(source.charAt(0)) && !source.startsWith('1ST')) return false;
|
|
if (baby.gen > 2 && source === '7V') return false;
|
|
return true;
|
|
});
|
|
if (setSources.sourcesBefore < baby.gen) setSources.sourcesBefore = 0;
|
|
if (!setSources.size()) {
|
|
problems.push(`${name} has moves from before Gen ${baby.gen}, which are incompatible with its moves from ${baby.name}.`);
|
|
}
|
|
}
|
|
|
|
return problems;
|
|
}
|
|
/**
|
|
* Returns a list of problems regarding a Pokemon's availability in Pokemon GO (empty list if no problems)
|
|
* If the Pokemon cannot be obtained from Pokemon GO, returns null
|
|
*/
|
|
validatePokemonGo(
|
|
species: Species, set: PokemonSet, setSources: PokemonSources, name: string = species.name,
|
|
): string[] | null {
|
|
let problems = [];
|
|
let minLevel = 50; // maximum level a Pokemon can be in Pokemon GO
|
|
let minIVs = 15; // IVs range from 0 to 15 in Pokemon GO
|
|
const dex = this.dex;
|
|
const pokemonGoData = dex.species.getPokemonGoData(species.id);
|
|
if (dex.gen < 8 || this.format.mod === 'gen8dlc1') return null;
|
|
if (!pokemonGoData) {
|
|
// Handles forms and evolutions not obtainable from Pokemon GO
|
|
const otherSpecies = this.dex.species.learnsetParent(species);
|
|
// If a Pokemon is somehow not obtainable from Pokemon GO and it must be leveled up to be evolved,
|
|
// validation for the game should stop because it's more optimal to get the Pokemon outside of the game
|
|
if (otherSpecies && !species.evoLevel) {
|
|
const otherProblems = this.validatePokemonGo(otherSpecies, set, setSources, name);
|
|
if (otherProblems) {
|
|
problems = otherProblems;
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
} else {
|
|
const pokemonGoSources = pokemonGoData.encounters;
|
|
// should never happen
|
|
if (!pokemonGoSources) throw new Error(`Species with no Pokemon GO data: ${species.id}`);
|
|
if (set.shiny) name = "Shiny " + name;
|
|
if (set.shiny && pokemonGoSources.includes('noshiny')) {
|
|
problems.push(`${name} is not obtainable from Pokemon GO.`);
|
|
} else {
|
|
if (pokemonGoSources.includes('wild')) {
|
|
minLevel = 1;
|
|
minIVs = 0;
|
|
}
|
|
if (pokemonGoSources.includes('egg')) {
|
|
/**
|
|
* A Pokemon's level when hatched is determined by the trainer's level when it is obtained
|
|
* It is no longer possible for new accounts to obtain eggs at level 1 because they will have reached
|
|
* level 2 by the time they can spin a PokeStop. However, it might be possible for a sleeper account
|
|
* from before XP changes to get a level 1 egg from spinning a PokeStop that sends the account to
|
|
* level 2, but this needs research
|
|
*/
|
|
minLevel = Math.min(minLevel, 2);
|
|
minIVs = Math.min(minIVs, 10);
|
|
}
|
|
if (pokemonGoSources.includes('12kmegg')) {
|
|
minLevel = Math.min(minLevel, 8);
|
|
minIVs = Math.min(minIVs, 10);
|
|
}
|
|
if (pokemonGoSources.includes('raid')) {
|
|
minLevel = Math.min(minLevel, 20);
|
|
minIVs = Math.min(minIVs, 10);
|
|
}
|
|
if (species.id === 'mewtwo' && set.level >= 20) {
|
|
// A bug allowed Mewtwo to be encountered with an IV floor of 0 from GO Battle League
|
|
minIVs = Math.min(minIVs, 0);
|
|
}
|
|
if (pokemonGoSources.includes('research')) {
|
|
if (species.id === 'cresselia') {
|
|
// For some reason, Cresselia from research has a possible level 10 source
|
|
minLevel = Math.min(minLevel, 10);
|
|
} else {
|
|
minLevel = Math.min(minLevel, 15);
|
|
}
|
|
minIVs = Math.min(minIVs, 10);
|
|
}
|
|
if (pokemonGoSources.includes('giovanni') && !set.shiny) {
|
|
/**
|
|
* Purified Pokemon can be leveled down to level 8 after trading; they are forced to
|
|
* special trades, but currently all Giovanni Shadow Pokemon are already forced special trades
|
|
*/
|
|
minLevel = Math.min(minLevel, 8);
|
|
minIVs = Math.min(minIVs, 1);
|
|
if (set.level < 12) setSources.pokemonGoSource = "purified";
|
|
}
|
|
// Attempt to trade the Pokemon to reduce level and IVs
|
|
if (!pokemonGoSources.includes('notrade')) {
|
|
// Special trades require a good friend
|
|
// Trading with a friend of this level has an IV floor of 1
|
|
// Note that (non-shiny) Deoxys could be traded for a short time when it was introduced
|
|
if (!set.shiny || species.id !== 'deoxys') {
|
|
const specialTrade = pokemonGoSources.includes('specialtrade') || set.shiny;
|
|
minLevel = Math.min(minLevel, 12);
|
|
minIVs = Math.min(minIVs, specialTrade ? 1 : 0);
|
|
}
|
|
}
|
|
if (set.level < minLevel) {
|
|
problems.push(`${name} must be at least level ${minLevel} to be from Pokemon GO.`);
|
|
}
|
|
const ivs = set.ivs || TeamValidator.fillStats(null, 31);
|
|
const postTransferMinIVs = minIVs * 2 + 1;
|
|
let IVsTooLow = false;
|
|
let hasEvenIVs = false;
|
|
for (const stat in ivs) {
|
|
if (stat === 'spe') continue;
|
|
if (ivs[stat as 'hp'] < postTransferMinIVs) IVsTooLow = true;
|
|
if (ivs[stat as 'hp'] % 2 === 0) hasEvenIVs = true;
|
|
}
|
|
if (IVsTooLow) {
|
|
problems.push(`${name} must have at least ${postTransferMinIVs} ` +
|
|
(postTransferMinIVs === 1 ? `IV` : `IVs`) + ` in non-Speed stats to be from Pokemon GO.`);
|
|
}
|
|
if (hasEvenIVs) {
|
|
problems.push(`${name} must have odd non-Speed IVs to be from Pokemon GO.`);
|
|
}
|
|
const canBottleCap = dex.gen >= 7 && set.level >= (dex.gen < 9 ? 100 : 50);
|
|
if (ivs.atk !== ivs.spa && !(canBottleCap && (ivs.atk === 31 || ivs.spa === 31))) {
|
|
problems.push(`${name}'s Atk and Sp. Atk IVs must match to be from Pokemon GO.`);
|
|
}
|
|
if (ivs.def !== ivs.spd && !(canBottleCap && (ivs.def === 31 || ivs.spd === 31))) {
|
|
problems.push(`${name}'s Def and Sp. Def IVs must match to be from Pokemon GO.`);
|
|
}
|
|
}
|
|
}
|
|
return problems;
|
|
}
|
|
|
|
omCheckCanLearn(
|
|
move: Move,
|
|
s: Species,
|
|
setSources = this.allSources(s),
|
|
set: Partial<PokemonSet> = {},
|
|
problem = `${set.name || s.name} can't learn ${move.name}`,
|
|
): string | null {
|
|
if (!this.ruleTable.checkCanLearn?.[0]) return problem;
|
|
const baseCheckCanLearn = this.checkCanLearn;
|
|
// tell the custom move legality check that the move is illegal by default
|
|
this.checkCanLearn = () => problem;
|
|
const omVerdict = this.ruleTable.checkCanLearn[0].call(this, move, s, setSources, set);
|
|
this.checkCanLearn = baseCheckCanLearn;
|
|
return omVerdict;
|
|
}
|
|
|
|
/** Returns null if you can learn the move, or a string explaining why you can't learn it */
|
|
checkCanLearn(
|
|
move: Move,
|
|
originalSpecies: Species,
|
|
setSources = this.allSources(originalSpecies),
|
|
set: Partial<PokemonSet> = {}
|
|
): string | null {
|
|
const dex = this.dex;
|
|
if (!setSources.size()) throw new Error(`Bad sources passed to checkCanLearn`);
|
|
|
|
move = dex.moves.get(move);
|
|
const moveid = move.id;
|
|
const baseSpecies = dex.species.get(originalSpecies);
|
|
|
|
const format = this.format;
|
|
const ruleTable = this.ruleTable;
|
|
const level = set.level || 100;
|
|
const canLearnSpecies: ID[] = [];
|
|
|
|
let cantLearnReason = null;
|
|
|
|
let limit1 = true;
|
|
let sketch = false;
|
|
let blockedHM = false;
|
|
|
|
let babyOnly = '';
|
|
let minLearnGen = dex.gen;
|
|
|
|
// This is a pretty complicated algorithm
|
|
|
|
// Abstractly, what it does is construct the union of sets of all
|
|
// possible ways this pokemon could be obtained, and then intersect
|
|
// it with a the pokemon's existing set of all possible ways it could
|
|
// be obtained. If this intersection is non-empty, the move is legal.
|
|
|
|
// set of possible sources of a pokemon with this move
|
|
const moveSources = new PokemonSources();
|
|
|
|
/**
|
|
* The format doesn't allow Pokemon traded from the future
|
|
* (This is everything except in Gen 1 Tradeback)
|
|
*/
|
|
const noFutureGen = !ruleTable.has('allowtradeback');
|
|
/**
|
|
* The format allows Sketch to copy moves in Gen 8
|
|
*/
|
|
const canSketchPostGen7Moves = ruleTable.has('sketchpostgen7moves') || this.dex.currentMod === 'gen8bdsp';
|
|
|
|
let tradebackEligible = false;
|
|
const fullLearnset = dex.species.getFullLearnset(originalSpecies.id);
|
|
if (!fullLearnset.length) {
|
|
// It's normal for a nonstandard species not to have learnset data
|
|
|
|
// Formats should replace the `Obtainable Moves` rule if they want to
|
|
// allow pokemon without learnsets.
|
|
return ` can't learn any moves at all.`;
|
|
}
|
|
|
|
for (const { species, learnset } of fullLearnset) {
|
|
if (dex.gen <= 2 && species.gen === 1) tradebackEligible = true;
|
|
const checkingPrevo = species.baseSpecies !== originalSpecies.baseSpecies;
|
|
if (checkingPrevo && !moveSources.size()) {
|
|
if (!setSources.babyOnly || !species.prevo) {
|
|
babyOnly = species.id;
|
|
}
|
|
}
|
|
|
|
const formeCantInherit = dex.species.eggMovesOnly(species, baseSpecies);
|
|
if (formeCantInherit && dex.gen < 9) break;
|
|
|
|
let sources = learnset[moveid] || [];
|
|
if (moveid === 'sketch') {
|
|
sketch = true;
|
|
} else if (learnset['sketch']) {
|
|
if (move.flags['nosketch'] || move.isZ || move.isMax) {
|
|
cantLearnReason = `can't be Sketched.`;
|
|
} else if (move.gen > 7 && !canSketchPostGen7Moves &&
|
|
(dex.gen === 8 ||
|
|
(dex.gen === 9 && ['gen9dlc1', 'gen9predlc'].includes(format.mod)))) {
|
|
cantLearnReason = `can't be Sketched because it's a Gen ${move.gen} move and Sketch isn't available in Gen ${move.gen}.`;
|
|
} else {
|
|
if (!sources.length || !moveSources.size()) sketch = true;
|
|
sources = [...learnset['sketch'], ...sources];
|
|
}
|
|
}
|
|
|
|
for (let learned of sources) {
|
|
// Every `learned` represents a single way a pokemon might
|
|
// learn a move. This can be handled one of several ways:
|
|
// `continue`
|
|
// means we can't learn it
|
|
// `return null`
|
|
// means we can learn it with no restrictions
|
|
// (there's a way to just teach any pokemon of this species
|
|
// the move in the current gen, like a TM.)
|
|
// `moveSources.add(source)`
|
|
// means we can learn it only if obtained that exact way described
|
|
// in source
|
|
// `moveSources.addGen(learnedGen)`
|
|
// means we can learn it only if obtained at or before learnedGen
|
|
// (i.e. get the pokemon however you want, transfer to that gen,
|
|
// teach it, and transfer it to the current gen.)
|
|
|
|
const learnedGen = parseInt(learned.charAt(0));
|
|
if (formeCantInherit && (learned.charAt(1) !== 'E' || learnedGen < 9)) continue;
|
|
if (setSources.learnsetDomain && !setSources.learnsetDomain.includes(`${learnedGen}${toID(species.baseSpecies)}`) &&
|
|
(learned.charAt(1) !== 'E' || learnedGen < 8)
|
|
) {
|
|
if (!cantLearnReason) {
|
|
cantLearnReason = `is incompatible with ${(setSources.restrictiveMoves || []).join(', ')}.`;
|
|
}
|
|
continue;
|
|
}
|
|
if (learnedGen < this.minSourceGen) {
|
|
if (!cantLearnReason) {
|
|
cantLearnReason = `can't be transferred from Gen ${learnedGen} to ${this.minSourceGen}.`;
|
|
}
|
|
continue;
|
|
}
|
|
if (noFutureGen && learnedGen > dex.gen) {
|
|
if (!cantLearnReason) {
|
|
cantLearnReason = `can't be transferred from Gen ${learnedGen} to ${dex.gen}.`;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (
|
|
baseSpecies.evoRegion === 'Alola' && checkingPrevo && learnedGen >= 8 &&
|
|
(dex.gen < 9 || learned.charAt(1) !== 'E')
|
|
) {
|
|
cantLearnReason = `is from a ${species.name} that can't be transferred to USUM to evolve into ${baseSpecies.name}.`;
|
|
continue;
|
|
}
|
|
|
|
const canUseAbilityPatch = dex.gen >= 8 && format.mod !== 'gen8dlc1';
|
|
if (
|
|
learnedGen < 7 && setSources.isHidden && !canUseAbilityPatch &&
|
|
!dex.mod(`gen${learnedGen}`).species.get(baseSpecies.name).abilities['H']
|
|
) {
|
|
cantLearnReason = `can only be learned in gens without Hidden Abilities.`;
|
|
continue;
|
|
}
|
|
|
|
const ability = dex.abilities.get(set.ability);
|
|
if (dex.gen < 6 && ability.gen > learnedGen && !checkingPrevo) {
|
|
// You can evolve a transferred mon to reroll for its new Ability.
|
|
cantLearnReason = `is learned in gen ${learnedGen}, but the Ability ${ability.name} did not exist then.`;
|
|
continue;
|
|
}
|
|
|
|
if (species.isNonstandard !== 'CAP') {
|
|
// HMs can't be transferred
|
|
if (dex.gen >= 4 && learnedGen <= 3 && [
|
|
'cut', 'fly', 'surf', 'strength', 'flash', 'rocksmash', 'waterfall', 'dive',
|
|
].includes(moveid)) {
|
|
cantLearnReason = `can't be transferred from Gen 3 to 4 because it's an HM move.`;
|
|
continue;
|
|
}
|
|
if (dex.gen >= 5 && learnedGen <= 4 && [
|
|
'cut', 'fly', 'surf', 'strength', 'rocksmash', 'waterfall', 'rockclimb',
|
|
].includes(moveid)) {
|
|
cantLearnReason = `can't be transferred from Gen 4 to 5 because it's an HM move.`;
|
|
continue;
|
|
}
|
|
// Defog and Whirlpool can't be transferred together
|
|
if (dex.gen >= 5 && ['defog', 'whirlpool'].includes(moveid) && learnedGen <= 4) blockedHM = true;
|
|
}
|
|
|
|
if (learned.charAt(1) === 'L') {
|
|
// special checking for level-up moves
|
|
if (level >= parseInt(learned.substr(2)) || learnedGen === 7) {
|
|
// we're past the required level to learn it
|
|
// (gen 7 level-up moves can be relearnered at any level)
|
|
// falls through to LMT check below
|
|
} else if (level >= 5 && learnedGen === 3 && species.canHatch) {
|
|
// Pomeg Glitch
|
|
learned = `${learnedGen}Epomeg` as MoveSource;
|
|
} else if (species.gender !== 'N' &&
|
|
learnedGen >= 2 && species.canHatch && !setSources.isFromPokemonGo) {
|
|
// available as egg move
|
|
if (species.gender === 'M' && !this.motherCanLearn(toID(species.mother), moveid)) {
|
|
// male-only Pokemon can have level-up egg moves if it can have a mother that learns the move
|
|
cantLearnReason = `is learned at level ${parseInt(learned.substr(2))}.`;
|
|
continue;
|
|
}
|
|
learned = `${learnedGen}Eany` as MoveSource;
|
|
// falls through to E check below
|
|
} else {
|
|
// this move is unavailable, skip it
|
|
cantLearnReason = `is learned at level ${parseInt(learned.substr(2))}.`;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Gen 8+ egg moves can be taught to any pokemon from any source
|
|
if (learnedGen >= 8 && learned.charAt(1) === 'E' && learned.slice(1) !== 'Eany' &&
|
|
learned.slice(1) !== 'Epomeg' || 'LMTR'.includes(learned.charAt(1))) {
|
|
if (learnedGen === dex.gen && learned.charAt(1) !== 'R') {
|
|
// current-gen level-up, TM or tutor moves:
|
|
// always available
|
|
if (!(learnedGen >= 8 && learned.charAt(1) === 'E') && babyOnly &&
|
|
setSources.isFromPokemonGo && species.evoLevel) {
|
|
cantLearnReason = `is from a prevo, which is incompatible with its Pokemon GO origin.`;
|
|
continue;
|
|
}
|
|
if (!moveSources.moveEvoCarryCount && !babyOnly) return null;
|
|
}
|
|
// past-gen level-up, TM, or tutor moves:
|
|
// available as long as the source gen was or was before this gen
|
|
if (learned.charAt(1) === 'R') {
|
|
moveSources.restrictedMove = moveid;
|
|
}
|
|
limit1 = false;
|
|
moveSources.addGen(learnedGen);
|
|
} else if (learned.charAt(1) === 'E') {
|
|
// egg moves:
|
|
// only if hatched from an egg
|
|
let limitedEggMove: ID | null | undefined = undefined;
|
|
if (learned.slice(1) === 'Eany') {
|
|
if (species.gender === 'F') {
|
|
limitedEggMove = move.id;
|
|
moveSources.levelUpEggMoves = [move.id];
|
|
} else {
|
|
limitedEggMove = null;
|
|
}
|
|
} else if (learned.slice(1) === 'Epomeg') {
|
|
// Pomeg glitched moves have to be from an egg but since they aren't true egg moves,
|
|
// there should be no breeding restrictions
|
|
moveSources.pomegEggMoves = [move.id];
|
|
} else if (learnedGen < 6 || (species.mother && !this.motherCanLearn(toID(species.mother), moveid))) {
|
|
limitedEggMove = move.id;
|
|
}
|
|
learned = `${learnedGen}E${species.prevo ? species.id : ''}` as MoveSource;
|
|
if (tradebackEligible && learnedGen === 2 && move.gen <= 1) {
|
|
// can tradeback
|
|
moveSources.add(`1ET${learned.slice(2)}`, limitedEggMove);
|
|
}
|
|
moveSources.add(learned, limitedEggMove);
|
|
} else if (learned.charAt(1) === 'S') {
|
|
// event moves:
|
|
// only if that was the source
|
|
// Event Pokémon:
|
|
// Available as long as the past gen can get the Pokémon and then trade it back.
|
|
if (tradebackEligible && learnedGen === 2 && move.gen <= 1) {
|
|
// can tradeback
|
|
moveSources.add(`1ST${learned.slice(2)} ${species.id}`);
|
|
}
|
|
moveSources.add(`${learned} ${species.id}`);
|
|
const eventLearnset = dex.species.getLearnsetData(species.id);
|
|
if (eventLearnset.eventData?.[parseInt(learned.charAt(2))].emeraldEventEgg && learnedGen === 3) {
|
|
moveSources.pomegEventEgg = `${learned} ${species.id}`;
|
|
}
|
|
} else if (learned.charAt(1) === 'D') {
|
|
// DW moves:
|
|
// only if that was the source
|
|
moveSources.add(`${learned}${species.id}`);
|
|
// If a DW move can be learned through some means other than DW,
|
|
// it should not be treated as a DW move
|
|
if (!moveSources.sourcesBefore) moveSources.dreamWorldMoveCount++;
|
|
} else if (learned.charAt(1) === 'V' && this.minSourceGen < learnedGen) {
|
|
// Virtual Console or Let's Go transfer moves:
|
|
// only if that was the source
|
|
if (learned === '8V' && setSources.isFromPokemonGo && babyOnly && species.evoLevel) {
|
|
cantLearnReason = `is from a prevo, which is incompatible with its Pokemon GO origin.`;
|
|
continue;
|
|
}
|
|
moveSources.add(learned);
|
|
}
|
|
if (learned.charAt(1) === 'E' && learnedGen >= 8 && !canLearnSpecies.includes(toID(baseSpecies.baseSpecies))) {
|
|
canLearnSpecies.push(toID(baseSpecies.baseSpecies));
|
|
}
|
|
if (!canLearnSpecies.includes(toID(species.baseSpecies))) canLearnSpecies.push(toID(species.baseSpecies));
|
|
minLearnGen = Math.min(minLearnGen, learnedGen);
|
|
}
|
|
if (ruleTable.has('mimicglitch') && species.gen < 5) {
|
|
// include the Mimic Glitch when checking this mon's learnset
|
|
const glitchMoves = ['metronome', 'copycat', 'transform', 'mimic', 'assist'];
|
|
let getGlitch = false;
|
|
for (const i of glitchMoves) {
|
|
if (learnset[i]) {
|
|
if (!(i === 'mimic' && dex.abilities.get(set.ability).gen === 4 && !species.prevo)) {
|
|
getGlitch = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (getGlitch) {
|
|
moveSources.addGen(4);
|
|
if (move.gen < 5) {
|
|
limit1 = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!moveSources.size()) {
|
|
if (
|
|
(species.evoType === 'levelMove' && species.evoMove !== move.name) ||
|
|
(species.id === 'sylveon' && move.type !== 'Fairy')
|
|
) {
|
|
moveSources.moveEvoCarryCount = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (limit1 && sketch) {
|
|
// limit 1 sketch move
|
|
if (setSources.sketchMove) {
|
|
return ` can't Sketch ${move.name} and ${setSources.sketchMove} because it can only Sketch 1 move.`;
|
|
}
|
|
setSources.sketchMove = move.name;
|
|
}
|
|
|
|
if (blockedHM) {
|
|
// Limit one of Defog/Whirlpool to be transferred
|
|
if (setSources.hm) return ` can't simultaneously transfer Defog and Whirlpool from Gen 4 to 5.`;
|
|
setSources.hm = moveid;
|
|
}
|
|
|
|
if (!setSources.restrictiveMoves) {
|
|
setSources.restrictiveMoves = [];
|
|
}
|
|
if (!setSources.restrictiveMoves.includes(move.name)) {
|
|
setSources.restrictiveMoves.push(move.name);
|
|
}
|
|
|
|
const checkedSpecies = babyOnly ? fullLearnset[fullLearnset.length - 1].species : baseSpecies;
|
|
if (checkedSpecies && setSources.isFromPokemonGo &&
|
|
(setSources.pokemonGoSource === 'purified' || checkedSpecies.id === 'mew')) {
|
|
// Pokemon that cannot be sent from Pokemon GO to Let's Go can only access Let's Go moves through HOME
|
|
// It can only obtain a chain of four level up moves and cannot have TM moves
|
|
const pokemonGoData = dex.species.getPokemonGoData(checkedSpecies.id);
|
|
if (pokemonGoData.LGPERestrictiveMoves) {
|
|
let levelUpMoveCount = 0;
|
|
const restrictiveMovesToID = [];
|
|
for (const moveName of setSources.restrictiveMoves) {
|
|
restrictiveMovesToID.push(toID(moveName));
|
|
}
|
|
for (const restrictiveMove in pokemonGoData.LGPERestrictiveMoves) {
|
|
const moveLevel = pokemonGoData.LGPERestrictiveMoves[restrictiveMove];
|
|
if (toID(move) === restrictiveMove) {
|
|
if (!moveLevel) {
|
|
return `'s move ${move.name} is incompatible with its Pokemon GO origin.`;
|
|
} else if (set.level && set.level < moveLevel) {
|
|
return ` must be at least level ${moveLevel} to learn ${move.name} due to its Pokemon GO origin.`;
|
|
}
|
|
}
|
|
if (levelUpMoveCount) levelUpMoveCount++;
|
|
if (restrictiveMovesToID.includes(restrictiveMove)) {
|
|
if (!levelUpMoveCount) {
|
|
levelUpMoveCount++;
|
|
} else if (levelUpMoveCount > 4) {
|
|
return `'s moves ${(setSources.restrictiveMoves || []).join(', ')} are incompatible with its Pokemon GO origin.`;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let nextSpecies;
|
|
nextSpecies = baseSpecies;
|
|
let speciesCount = 0;
|
|
if (!tradebackEligible) {
|
|
if (!dex.species.getLearnsetData(nextSpecies.id).learnset) {
|
|
nextSpecies = dex.species.get(nextSpecies.changesFrom || nextSpecies.baseSpecies);
|
|
}
|
|
while (nextSpecies) {
|
|
for (let gen = nextSpecies.gen; gen <= dex.gen; gen++) {
|
|
/**
|
|
* Case 1: The species can learn the move - allow moves of the species from all gens
|
|
* Case 2: Both prevo and evo can learn the move - same as case 1
|
|
* Case 3: Prevo-only move - allow moves of the species from the min gen and later
|
|
* Case 4: Evo-only move - allow moves of the species from the max gen and before
|
|
*/
|
|
const baseSpeciesID = toID(nextSpecies.baseSpecies);
|
|
if (canLearnSpecies.includes(baseSpeciesID) ||
|
|
(0 < speciesCount && speciesCount < canLearnSpecies.length) ||
|
|
(speciesCount === 0 && gen >= minLearnGen) ||
|
|
(speciesCount === canLearnSpecies.length && gen <= moveSources.sourcesBefore)
|
|
) {
|
|
if (!moveSources.learnsetDomain) moveSources.learnsetDomain = [];
|
|
moveSources.learnsetDomain.push(`${gen}${baseSpeciesID}`);
|
|
}
|
|
}
|
|
if (canLearnSpecies.includes(nextSpecies.id)) speciesCount++;
|
|
nextSpecies = dex.species.learnsetParent(nextSpecies);
|
|
}
|
|
}
|
|
|
|
// Now that we have our list of possible sources, intersect it with the current list
|
|
if (!moveSources.size()) {
|
|
if (cantLearnReason) return `'s move ${move.name} ${cantLearnReason}`;
|
|
return ` can't learn ${move.name}.`;
|
|
}
|
|
const eggSources = moveSources.sources.filter(source => source.charAt(1) === 'E');
|
|
if (dex.gen >= 3 && eggSources.length && moveSources.limitedEggMoves === null && moveSources.sourcesBefore) {
|
|
moveSources.possiblyLimitedEggMoves = [toID(`${moveSources.sourcesBefore}${move.id}`)];
|
|
}
|
|
const backupSources = setSources.sources;
|
|
const backupSourcesBefore = setSources.sourcesBefore;
|
|
setSources.intersectWith(moveSources);
|
|
if (!setSources.size()) {
|
|
// pretend this pokemon didn't have this move:
|
|
// prevents a crash if OMs override `checkCanLearn` to keep validating after an error
|
|
setSources.sources = backupSources;
|
|
setSources.sourcesBefore = backupSourcesBefore;
|
|
if (setSources.isFromPokemonGo) return `'s move ${move.name} is incompatible with its Pokemon GO origin.`;
|
|
return `'s moves ${(setSources.restrictiveMoves || []).join(', ')} are incompatible.`;
|
|
}
|
|
|
|
if (babyOnly) setSources.babyOnly = babyOnly;
|
|
return null;
|
|
}
|
|
|
|
static fillStats(stats: SparseStatsTable | null, fillNum = 0): StatsTable {
|
|
const filledStats: StatsTable = { hp: fillNum, atk: fillNum, def: fillNum, spa: fillNum, spd: fillNum, spe: fillNum };
|
|
if (stats) {
|
|
let statName: StatID;
|
|
for (statName in filledStats) {
|
|
const stat = stats[statName];
|
|
if (typeof stat === 'number') filledStats[statName] = stat;
|
|
}
|
|
}
|
|
return filledStats;
|
|
}
|
|
|
|
static get(format: string | Format) {
|
|
return new TeamValidator(format);
|
|
}
|
|
}
|