@pkmn/sim 0.5.20 → 0.5.23

package/build/data/rulesets.js

@@ -405,6 +405,30 @@ exports.Rulesets = {
             }
         },
     },
+    forceselect: {
+        effectType: 'ValidatorRule',
+        name: 'Force Select',
+        desc: `Forces a Pokemon to be on the team and selected at Team Preview. Usage: Force Select = [Pokemon], e.g. "Force Select = Magikarp"`,
+        hasValue: true,
+        onValidateRule(value) {
+            if (!this.dex.species.get(value).exists)
+                throw new Error(`Misspelled Pokemon "${value}"`);
+        },
+        onValidateTeam(team) {
+            let hasSelection = false;
+            const species = this.dex.species.get(this.ruleTable.valueRules.get('forceselect'));
+            for (const set of team) {
+                if (species.name === set.species) {
+                    hasSelection = true;
+                    break;
+                }
+            }
+            if (!hasSelection) {
+                return [`Your team must contain ${species.name}.`];
+            }
+        },
+        // hardcoded in sim/side
+    },
     evlimits: {
         effectType: 'ValidatorRule',
         name: 'EV Limits',
@@ -1288,6 +1312,21 @@ exports.Rulesets = {
             }
         },
     },
+    gemsclause: {
+        effectType: 'ValidatorRule',
+        name: 'Gems Clause',
+        desc: "Bans all Gems",
+        onValidateSet(set) {
+            if (!set.item)
+                return;
+            const item = this.dex.items.get(set.item);
+            if (item.isGem) {
+                if (this.ruleTable.has(`+item:${item.id}`))
+                    return;
+                return [`${item.name} is banned due to Gems Clause.`];
+            }
+        },
+    },
     'sketchgen8moves': {
         effectType: 'ValidatorRule',
         name: 'Sketch Gen 8 Moves',
@@ -1611,6 +1650,12 @@ exports.Rulesets = {
         desc: "Prevents Pok\u00e9mon from having moves that would only be obtainable in Pok\u00e9mon Crystal.",
         // Implemented in mods/gen2/rulesets.ts
     },
+    aptclause: {
+        effectType: 'ValidatorRule',
+        name: 'APT Clause',
+        desc: "Bans the combination of Agility and partial trapping moves like Wrap.",
+        banlist: ['Agility + Wrap', 'Agility + Fire Spin', 'Agility + Bind', 'Agility + Clamp'],
+    },
     nintendocup1997movelegality: {
         effectType: 'ValidatorRule',
         name: "Nintendo Cup 1997 Move Legality",
@@ -1860,5 +1905,135 @@ exports.Rulesets = {
             }
         },
     },
+    reevolutionmod: {
+        effectType: "Rule",
+        name: "Re-Evolution Mod",
+        desc: "Pokémon gain the stat changes they would gain from evolving again.",
+        ruleset: ['Overflow Stat Mod'],
+        onBegin() {
+            this.add('rule', 'Re-Evolution Mod: Pok\u00e9mon gain the boosts they would gain from evolving again');
+        },
+        onModifySpecies(species, target) {
+            const newSpecies = this.dex.deepClone(species);
+            if (!newSpecies.prevo)
+                return;
+            const prevoSpecies = this.dex.species.get(newSpecies.prevo);
+            let statid;
+            newSpecies.bst = 0;
+            for (statid in prevoSpecies.baseStats) {
+                const change = newSpecies.baseStats[statid] - prevoSpecies.baseStats[statid];
+                newSpecies.baseStats[statid] = this.clampIntRange(newSpecies.baseStats[statid] + change, 1, 255);
+                newSpecies.bst += newSpecies.baseStats[statid];
+            }
+            return newSpecies;
+        },
+    },
+    brokenrecordmod: {
+        effectType: "Rule",
+        name: "Broken Record Mod",
+        desc: `Pokémon can hold a TR to use that move in battle.`,
+        onValidateSet(set) {
+            if (!set.item)
+                return;
+            const item = this.dex.items.get(set.item);
+            if (!/^tr\d\d/i.test(item.name))
+                return;
+            const moveName = item.desc.split('move ')[1].split('.')[0];
+            if (set.moves.map(this.toID).includes(this.toID(moveName))) {
+                return [
+                    `${set.species} can't run ${item.name} (${moveName}) as its item because it already has that move in its moveset.`,
+                ];
+            }
+        },
+        onValidateTeam(team) {
+            const trs = new Set();
+            for (const set of team) {
+                if (!set.item)
+                    continue;
+                const item = this.dex.items.get(set.item).name;
+                if (!/^tr\d\d/i.test(item))
+                    continue;
+                if (trs.has(item)) {
+                    return [`Your team already has a Pok\u00e9mon with ${item}.`];
+                }
+                trs.add(item);
+            }
+        },
+        onTakeItem(item) {
+            return !/^tr\d\d/i.test(item.name);
+        },
+        onModifyMove(move) {
+            if (move.id === 'knockoff') {
+                move.onBasePower = function (basePower, source, target, m) {
+                    const item = target.getItem();
+                    if (!this.singleEvent('TakeItem', item, target.itemState, target, target, m, item))
+                        return;
+                    // Very hardcode but I'd prefer to not make a mod for one damage calculation change
+                    if (item.id && !/^tr\d\d/i.test(item.id)) {
+                        return this.chainModify(1.5);
+                    }
+                };
+            }
+            else if (move.id === 'fling') {
+                move.onPrepareHit = function (target, source, m) {
+                    if (source.ignoringItem())
+                        return false;
+                    const item = source.getItem();
+                    if (!this.singleEvent('TakeItem', item, source.itemState, source, source, m, item))
+                        return false;
+                    if (!item.fling)
+                        return false;
+                    if (/^tr\d\d/i.test(item.id))
+                        return false;
+                    m.basePower = item.fling.basePower;
+                    if (item.isBerry) {
+                        m.onHit = function (foe) {
+                            if (this.singleEvent('Eat', item, null, foe, null, null)) {
+                                this.runEvent('EatItem', foe, null, null, item);
+                                if (item.id === 'leppaberry')
+                                    foe.staleness = 'external';
+                            }
+                            if (item.onEat)
+                                foe.ateBerry = true;
+                        };
+                    }
+                    else if (item.fling.effect) {
+                        m.onHit = item.fling.effect;
+                    }
+                    else {
+                        if (!m.secondaries)
+                            m.secondaries = [];
+                        if (item.fling.status) {
+                            m.secondaries.push({ status: item.fling.status });
+                        }
+                        else if (item.fling.volatileStatus) {
+                            m.secondaries.push({ volatileStatus: item.fling.volatileStatus });
+                        }
+                    }
+                    source.addVolatile('fling');
+                };
+            }
+        },
+        onBegin() {
+            for (const pokemon of this.getAllPokemon()) {
+                const item = pokemon.getItem();
+                if (/^tr\d\d/i.test(item.name)) {
+                    const move = this.dex.moves.get(item.desc.split('move ')[1].split('.')[0]);
+                    pokemon.moveSlots = pokemon.baseMoveSlots = [
+                        ...pokemon.baseMoveSlots, {
+                            id: move.id,
+                            move: move.name,
+                            pp: move.pp * 8 / 5,
+                            maxpp: move.pp * 8 / 5,
+                            target: move.target,
+                            disabled: false,
+                            disabledSource: '',
+                            used: false,
+                        },
+                    ];
+                }
+            }
+        },
+    },
 };
 //# sourceMappingURL=rulesets.js.map