@pkmn/sim 0.7.45 → 0.7.47

package/build/esm/sim/team-validator.mjs

@@ -571,9 +571,6 @@ export class TeamValidator {
             problems.push(`${name} has ${set.moves.length} moves, which is more than the limit of ${ruleTable.maxMoveCount}.`);
             return problems;
         }
-        if (ruleTable.isBanned('nonexistent')) {
-            problems.push(...this.validateStats(set, species, setSources));
-        }
         const moveLegalityWhitelist = {};
         for (const moveName of set.moves) {
             if (!moveName)
@@ -597,10 +594,56 @@ export class TeamValidator {
                 }
             }
         }
+        const pokemonGoProblems = this.validatePokemonGo(outOfBattleSpecies, set, setSources);
+        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;
+            }
+        }
+        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)) {
+                    if (!pokemonGoProblems || (pokemonGoProblems && pokemonGoProblems.length)) {
+                        problems.push(`${name} must be at least level ${evoSpecies.evoLevel} to be evolved.`);
+                        if (pokemonGoProblems && pokemonGoProblems.length) {
+                            problems.push(`It failed to validate as a Pokemon from Pokemon GO because:`);
+                            for (const pokemonGoProblem of pokemonGoProblems) {
+                                problems.push(pokemonGoProblem);
+                            }
+                        }
+                    }
+                    else {
+                        // Pokemon from Pokemon GO can be transferred to LGPE
+                        setSources.isFromPokemonGo = true;
+                        setSources.sources.push('8V');
+                        setSources.sourcesBefore = 0;
+                    }
+                    break;
+                }
+                evoSpecies = dex.species.get(evoSpecies.prevo);
+            }
+        }
+        const moveProblems = this.validateMoves(outOfBattleSpecies, set.moves, setSources, set, name, moveLegalityWhitelist);
         if (ruleTable.has('obtainablemoves')) {
-            problems.push(...this.validateMoves(outOfBattleSpecies, set.moves, setSources, set, name, moveLegalityWhitelist));
+            problems.push(...moveProblems);
         }
-        const learnsetSpecies = dex.species.getLearnsetData(outOfBattleSpecies.id);
         let eventOnlyData;
         if (!setSources.sourcesBefore && setSources.sources.length) {
             let legal = false;
@@ -624,12 +667,24 @@ export class TeamValidator {
                     problems.push(`(Is this incorrect? If so, post the chainbreeding instructions in Bug Reports)`);
                 }
                 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):`);
+                    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 && pokemonGoProblems.length) {
+                            problems.push(`Additionally, it failed to validate as a Pokemon from Pokemon GO because:`);
+                            for (const pokemonGoProblem of pokemonGoProblems) {
+                                problems.push(pokemonGoProblem);
+                            }
+                        }
                     }
-                    const eventProblems = this.validateSource(set, nonEggSource, setSources, outOfBattleSpecies, ` because it has a move only available`);
-                    if (eventProblems)
-                        problems.push(...eventProblems);
                 }
             }
         }
@@ -646,54 +701,58 @@ export class TeamValidator {
                 legal = true;
             }
             if (!legal) {
-                if (eventData.length === 1) {
-                    problems.push(`${species.name} is only obtainable from an event - it needs to match its event:`);
+                if (!pokemonGoProblems || (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) {
+                            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 && 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 {
-                    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) {
-                        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);
-                    }
+                    setSources.isFromPokemonGo = true;
                 }
             }
         }
-        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;
+        // Attempt move validation again after verifying Pokemon GO origin
+        if (setSources.isFromPokemonGo) {
+            setSources.restrictiveMoves = [];
+            setSources.sources = ['8V'];
+            setSources.sourcesBefore = 0;
+            if (!moveProblems.length && ruleTable.has('obtainablemoves')) {
+                problems.push(...this.validateMoves(outOfBattleSpecies, set.moves, setSources, set, name, moveLegalityWhitelist));
             }
         }
-        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)) {
-                    problems.push(`${name} must be at least level ${evoSpecies.evoLevel} to be evolved.`);
-                    break;
+        // Hardcoded forced validation for Pokemon GO
+        const pokemonGoOnlySpecies = ['meltan', 'melmetal', 'gimmighoulroaming'];
+        if (ruleTable.has('obtainablemisc') && (pokemonGoOnlySpecies.includes(species.id))) {
+            setSources.isFromPokemonGo = true;
+            if (pokemonGoProblems && pokemonGoProblems.length) {
+                problems.push(`${name} is only obtainable from Pokemon GO, and failed to validate because:`);
+                for (const pokemonGoProblem of pokemonGoProblems) {
+                    problems.push(pokemonGoProblem);
                 }
-                evoSpecies = dex.species.get(evoSpecies.prevo);
             }
         }
+        if (ruleTable.isBanned('nonexistent')) {
+            problems.push(...this.validateStats(set, species, setSources, pokemonGoProblems));
+        }
         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.`);
@@ -772,7 +831,7 @@ export class TeamValidator {
         }
         return problems;
     }
-    validateStats(set, species, setSources) {
+    validateStats(set, species, setSources, pokemonGoProblems) {
         const ruleTable = this.ruleTable;
         const dex = this.dex;
         const allowAVs = ruleTable.has('allowavs');
@@ -831,8 +890,19 @@ export class TeamValidator {
                     perfectIVs++;
             }
             if (perfectIVs < 3) {
-                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 || (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 && 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) {
@@ -846,6 +916,24 @@ export class TeamValidator {
                 problems.push(`${name} has Hidden Power ${set.hpType}, but its IVs don't allow this even with (Bottle Cap) Hyper Training.`);
             }
         }
+        if (setSources.isFromPokemonGo) {
+            // Pokemon from Pokemon GO must have odd IVs in non-Spe stats
+            // Since the set can be fixed while making minimal changes, it does not force the IVs to be manually fixed
+            for (const stat in set.ivs) {
+                if (set.ivs[stat] % 2 === 0 && stat !== 'spe') {
+                    set.ivs[stat]++;
+                }
+            }
+            if (set.ivs.atk !== set.ivs.spa && !(canBottleCap && (set.ivs.atk === 31 || set.ivs.spa === 31))) {
+                problems.push(`${name}'s Atk and Spa IVs must match because it is from Pokemon GO.`);
+            }
+            if (set.ivs.def !== set.ivs.spd && !(canBottleCap && (set.ivs.def === 31 || set.ivs.spd === 31))) {
+                problems.push(`${name}'s Def and Spd IVs must match because it is from Pokemon GO.`);
+            }
+            if (set.hpType && set.hpType !== 'Dark' && set.hpType !== 'Ice') {
+                problems.push(`${name} must have Hidden Power Dark or Ice because it is from Pokemon GO.`);
+            }
+        }
         if (dex.gen <= 2) {
             // validate DVs
             const ivs = set.ivs;
@@ -1871,6 +1959,114 @@ export class TeamValidator {
         }
         return problems;
     }
+    /**
+     * Returns a list of problems regarding a Pokemon's avilability in Pokemon GO (empty list if no problems)
+     * If the Pokemon cannot be obtained from Pokemon GO, returns null
+     */
+    validatePokemonGo(species, set, setSources, name = species.name) {
+        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.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') && !((set.shiny && pokemonGoSources.includes('nowildshiny')))) {
+                    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 && 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')) {
+                    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 && 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 && 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);
+                for (const stat in ivs) {
+                    if (Math.floor(ivs[stat] / 2) < minIVs && stat !== 'spe') {
+                        problems.push(`${name} must have at least ${minIVs} ` +
+                            (minIVs === 1 ? `IV` : `IVs`) + ` in non-Speed stats to be from Pokemon GO.`);
+                        break;
+                    }
+                }
+            }
+        }
+        return problems;
+    }
     omCheckCanLearn(move, s, setSources = this.allSources(s), set = {}, problem = `${set.name || s.name} can't learn ${move.name}`) {
         if (!this.ruleTable.checkCanLearn?.[0])
             return problem;
@@ -2038,7 +2234,8 @@ export class TeamValidator {
                         else if (level >= 5 && learnedGen === 3 && species.canHatch) {
                             // Pomeg Glitch
                         }
-                        else if ((!species.gender || species.gender === 'F') && learnedGen >= 2 && species.canHatch) {
+                        else if ((!species.gender || species.gender === 'F') &&
+                            learnedGen >= 2 && species.canHatch && !setSources.isFromPokemonGo) {
                             // available as egg move
                             learned = learnedGen + 'Eany';
                             // falls through to E check below
@@ -2054,8 +2251,15 @@ export class TeamValidator {
                         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.babyOnly = babyOnly;
+                            if (!(learnedGen >= 8 && learned.charAt(1) === 'E') && babyOnly) {
+                                if (setSources.isFromPokemonGo && species.evoLevel) {
+                                    cantLearnReason = `is from a prevo, which is incompatible with its Pokemon GO origin.`;
+                                    continue;
+                                }
+                                else {
+                                    setSources.babyOnly = babyOnly;
+                                }
+                            }
                             if (!moveSources.moveEvoCarryCount)
                                 return null;
                         }
@@ -2104,6 +2308,10 @@ export class TeamValidator {
                     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);
                     }
                 }
@@ -2153,6 +2361,41 @@ export class TeamValidator {
             setSources.restrictiveMoves = [];
         }
         setSources.restrictiveMoves.push(move.name);
+        const checkedSpecies = babyOnly ? 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.`;
+                        }
+                    }
+                }
+            }
+        }
         // Now that we have our list of possible sources, intersect it with the current list
         if (!moveSources.size()) {
             if (cantLearnReason)
@@ -2167,6 +2410,8 @@ export class TeamValidator {
             // 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)