@pkmn/sim 0.4.20 → 0.4.24

package/build/data/rulesets.js

@@ -1104,7 +1104,9 @@ exports.Rulesets = {
             if (!nonstandard && !move.isZ && !move.isMax && !this.ruleTable.isRestricted(`move:${move.id}`)) {
                 const speciesTypes = [];
                 const moveTypes = [];
-                for (let i = this.dex.gen; i >= species.gen && i >= move.gen; i--) {
+                // BDSP can't import Pokemon from Home, so it shouldn't grant moves from archaic species types
+                const minObtainableSpeciesGen = this.dex.currentMod === 'gen8bdsp' ? this.dex.gen : species.gen;
+                for (let i = this.dex.gen; i >= minObtainableSpeciesGen && i >= move.gen; i--) {
                     const dex = this.dex.forGen(i);
                     moveTypes.push(dex.moves.get(move.name).type);
                     const pokemon = dex.species.get(species.name);
@@ -1641,5 +1643,223 @@ exports.Rulesets = {
             this.lose(target.side);
         },
     },
+    tiershiftmod: {
+        effectType: "Rule",
+        name: "Tier Shift Mod",
+        desc: `Pokémon below OU get their stats, excluding HP, boosted. UU/RUBL get +10, RU/NUBL get +20, NU/PUBL get +30, and PU or lower get +40.`,
+        ruleset: ['Overflow Stat Mod'],
+        onBegin() {
+            this.add('rule', 'Tier Shift Mod: Pok\u00e9mon get stat buffs depending on their tier, excluding HP.');
+        },
+        onModifySpecies(species, target, source, effect) {
+            if (!species.baseStats)
+                return;
+            const boosts = {
+                uu: 10,
+                rubl: 10,
+                ru: 20,
+                nubl: 20,
+                nu: 30,
+                publ: 30,
+                pu: 40,
+                nfe: 40,
+                lc: 40,
+            };
+            let tier = this.toID(species.tier);
+            if (!(tier in boosts))
+                return;
+            // Non-Pokemon bans in lower tiers
+            if (target) {
+                if (target.set.item === 'lightclay')
+                    return;
+                if (['drizzle', 'drought', 'snowwarning'].includes(target.set.ability) && boosts[tier] > 20)
+                    tier = 'nubl';
+            }
+            const pokemon = this.dex.deepClone(species);
+            pokemon.bst = pokemon.baseStats['hp'];
+            const boost = boosts[tier];
+            let statName;
+            for (statName in pokemon.baseStats) {
+                if (statName === 'hp')
+                    continue;
+                pokemon.baseStats[statName] = this.clampIntRange(pokemon.baseStats[statName] + boost, 1, 255);
+                pokemon.bst += pokemon.baseStats[statName];
+            }
+            return pokemon;
+        },
+    },
+    crossevolutionmod: {
+        effectType: "Rule",
+        name: "Cross Evolution Mod",
+        desc: "Give a Pokémon a Pokémon name of the next evolution stage as a nickname to inherit stat changes, typing, abilities, and up to 2 moves from the next stage Pokémon.",
+        ruleset: ['Overflow Stat Mod'],
+        onValidateTeam(team) {
+            const names = new Set();
+            for (const set of team) {
+                const name = set.name;
+                if (names.has(this.dex.toID(name))) {
+                    return [
+                        `Your Pok\u00e9mon must have different nicknames.`,
+                        `(You have more than one Pok\u00e9mon named '${name}')`,
+                    ];
+                }
+                names.add(this.dex.toID(name));
+            }
+            if (!names.size) {
+                return [
+                    `${this.format.name} works using nicknames; your team has 0 nicknamed Pok\u00e9mon.`,
+                    `(If this was intentional, add a nickname to one Pok\u00e9mon that isn't the name of a Pok\u00e9mon species.)`,
+                ];
+            }
+        },
+        checkCanLearn(move, species, lsetData, set) {
+            // @ts-ignore
+            if (!set.sp?.exists || !set.crossSpecies?.exists) {
+                return this.checkCanLearn(move, species, lsetData, set);
+            }
+            // @ts-ignore
+            const problem = this.checkCanLearn(move, set.sp);
+            if (!problem)
+                return null;
+            // @ts-ignore
+            if (!set.crossMovesLeft)
+                return problem;
+            // @ts-ignore
+            if (this.checkCanLearn(move, set.crossSpecies))
+                return problem;
+            // @ts-ignore
+            set.crossMovesLeft--;
+            return null;
+        },
+        validateSet(set, teamHas) {
+            const crossSpecies = this.dex.species.get(set.name);
+            const onChangeSet = this.dex.formats.get('Pokemon').onChangeSet;
+            let problems = onChangeSet?.call(this, set, this.format) || null;
+            if (Array.isArray(problems) && problems.length)
+                return problems;
+            const crossNonstandard = !this.ruleTable.has('standardnatdex') && crossSpecies.isNonstandard === 'Past';
+            const crossIsCap = !this.ruleTable.has('+pokemontag:cap') && crossSpecies.isNonstandard === 'CAP';
+            if (!crossSpecies.exists || crossNonstandard || crossIsCap)
+                return this.validateSet(set, teamHas);
+            const species = this.dex.species.get(set.species);
+            const check = this.checkSpecies(set, species, species, {});
+            if (check)
+                return [check];
+            const nonstandard = !this.ruleTable.has('standardnatdex') && species.isNonstandard === 'Past';
+            const isCap = !this.ruleTable.has('+pokemontag:cap') && species.isNonstandard === 'CAP';
+            if (!species.exists || nonstandard || isCap || species === crossSpecies)
+                return this.validateSet(set, teamHas);
+            if (!species.nfe)
+                return [`${species.name} cannot cross evolve because it doesn't evolve.`];
+            const crossIsUnreleased = (crossSpecies.tier === "Unreleased" && crossSpecies.isNonstandard === "Unobtainable");
+            if (crossSpecies.battleOnly || crossIsUnreleased || !crossSpecies.prevo) {
+                return [`${species.name} cannot cross evolve into ${crossSpecies.name} because it isn't an evolution.`];
+            }
+            if (this.ruleTable.isRestrictedSpecies(crossSpecies)) {
+                return [`${species.name} cannot cross evolve into ${crossSpecies.name} because it is banned.`];
+            }
+            const crossPrevoSpecies = this.dex.species.get(crossSpecies.prevo);
+            if (!crossPrevoSpecies.prevo !== !species.prevo) {
+                return [
+                    `${species.name} cannot cross evolve into ${crossSpecies.name} because they are not consecutive evolution stages.`,
+                ];
+            }
+            const ability = this.dex.abilities.get(set.ability);
+            if (!this.ruleTable.isRestricted(`ability:${ability.id}`) || Object.values(species.abilities).includes(ability.name)) {
+                set.species = crossSpecies.name;
+            }
+            // @ts-ignore
+            set.sp = species;
+            // @ts-ignore
+            set.crossSpecies = crossSpecies;
+            // @ts-ignore
+            set.crossMovesLeft = 2;
+            problems = this.validateSet(set, teamHas);
+            set.name = crossSpecies.name;
+            set.species = species.name;
+            return problems;
+        },
+        onModifySpecies(species, target, source, effect) {
+            if (!target)
+                return; // chat
+            if (effect && ['imposter', 'transform'].includes(effect.id))
+                return;
+            if (target.set.name === target.set.species)
+                return;
+            const crossSpecies = this.dex.species.get(target.set.name);
+            if (!crossSpecies.exists)
+                return;
+            if (species.battleOnly || !species.nfe)
+                return;
+            const crossIsUnreleased = (crossSpecies.tier === "Unreleased" && crossSpecies.isNonstandard === "Unobtainable");
+            if (crossSpecies.battleOnly || crossIsUnreleased || !crossSpecies.prevo)
+                return;
+            const crossPrevoSpecies = this.dex.species.get(crossSpecies.prevo);
+            if (!crossPrevoSpecies.prevo !== !species.prevo)
+                return;
+            const mixedSpecies = this.dex.deepClone(species);
+            mixedSpecies.baseSpecies = mixedSpecies.name = `${species.name}-${crossSpecies.name}`;
+            mixedSpecies.weightkg =
+                Math.max(0.1, +(species.weightkg + crossSpecies.weightkg - crossPrevoSpecies.weightkg)).toFixed(1);
+            mixedSpecies.nfe = false;
+            mixedSpecies.evos = [];
+            mixedSpecies.eggGroups = crossSpecies.eggGroups;
+            mixedSpecies.abilities = crossSpecies.abilities;
+            mixedSpecies.bst = 0;
+            let i;
+            for (i in species.baseStats) {
+                const statChange = crossSpecies.baseStats[i] - crossPrevoSpecies.baseStats[i];
+                mixedSpecies.baseStats[i] = this.clampIntRange(species.baseStats[i] + statChange, 1, 255);
+                mixedSpecies.bst += mixedSpecies.baseStats[i];
+            }
+            if (crossSpecies.types[0] !== crossPrevoSpecies.types[0])
+                mixedSpecies.types[0] = crossSpecies.types[0];
+            if (crossSpecies.types[1] !== crossPrevoSpecies.types[1]) {
+                mixedSpecies.types[1] = crossSpecies.types[1] || crossSpecies.types[0];
+            }
+            if (mixedSpecies.types[0] === mixedSpecies.types[1])
+                mixedSpecies.types = [mixedSpecies.types[0]];
+            return mixedSpecies;
+        },
+        onBegin() {
+            for (const pokemon of this.getAllPokemon()) {
+                pokemon.baseSpecies = pokemon.species;
+            }
+        },
+    },
+    revelationmonsmod: {
+        effectType: "Rule",
+        name: "Revelationmons Mod",
+        desc: `The moves in the first slot(s) of a Pokémon's set have their types changed to match the Pokémon's type(s).`,
+        onBegin() {
+            this.add('rule', 'Revelationmons Mod: The first moveslots have their types changed to match the Pokémon\'s types');
+        },
+        onValidateSet(set) {
+            const species = this.dex.species.get(set.species);
+            const slotIndex = species.types.length - 1;
+            const problems = [];
+            for (const [i, moveid] of set.moves.entries()) {
+                const move = this.dex.moves.get(moveid);
+                if (!this.ruleTable.isRestricted(`move:${move.id}`))
+                    continue;
+                if (i <= slotIndex) {
+                    problems.push(`${move.name} can't be in moveslot ${i + 1} because it's restricted from being in the first ${slotIndex + 1 > 1 ? `${slotIndex + 1} slots` : 'slot'}.`);
+                }
+            }
+            return problems;
+        },
+        onModifyMove(move, pokemon, target) {
+            const types = pokemon.getTypes(true);
+            const noModifyType = [
+                'judgment', 'multiattack', 'naturalgift', 'revelationdance', 'technoblast', 'terrainpulse', 'weatherball',
+            ];
+            if (noModifyType.includes(move.id))
+                return;
+            for (const [i, type] of types.entries()) {
+                if (pokemon.moveSlots[i] && move.id === pokemon.moveSlots[i].id)
+                    move.type = type;
+            }
+        },
+    },
 };
 //# sourceMappingURL=rulesets.js.map