@pkmn/sim 0.9.26 → 0.9.28

package/build/cjs/sim/battle.js

@@ -26,7 +26,7 @@ const side_1 = require("./side");
 const state_1 = require("./state");
 const battle_queue_1 = require("./battle-queue");
 const battle_actions_1 = require("./battle-actions");
-const lib_1 = require("../lib");
+const utils_1 = require("../lib/utils");
 const splitRegex = /^\|split\|p([1234])\n(.*)\n(.*)|.+/gm;
 function extractChannelMessages(message, channelIds) {
     const channelIdSet = new Set(channelIds);
@@ -63,7 +63,7 @@ class Battle {
         this.gen = this.dex.gen;
         this.ruleTable = this.dex.formats.getRuleTable(format);
         this.trunc = this.dex.trunc;
-        this.clampIntRange = lib_1.Utils.clampIntRange;
+        this.clampIntRange = utils_1.Utils.clampIntRange;
         // Object.assign(this, this.dex.data.Scripts);
         for (const i in this.dex.data.Scripts) {
             const entry = this.dex.data.Scripts[i];
@@ -79,7 +79,7 @@ class Battle {
             options.forceRandomChance : null;
         this.deserialized = !!options.deserialized;
         this.strictChoices = !!options.strictChoices;
-        this.formatData = { id: format.id };
+        this.formatData = this.initEffectState({ id: format.id });
         this.gameType = (format.gameType || 'singles');
         this.field = new field_1.Field(this);
         this.sides = Array(format.playerCount).fill(null);
@@ -87,7 +87,7 @@ class Battle {
             (format.playerCount > 2 || this.gameType === 'doubles') ? 2 :
                 1;
         this.prng = options.prng || new prng_1.PRNG(options.seed || undefined);
-        this.prngSeed = this.prng.startingSeed.slice();
+        this.prngSeed = this.prng.startingSeed;
         this.rated = options.rated || !!options.rated;
         this.reportExactHP = !!format.debug;
         this.reportPercentages = false;
@@ -105,7 +105,7 @@ class Battle {
         this.started = false;
         this.ended = false;
         this.effect = { id: '' };
-        this.effectState = { id: '' };
+        this.effectState = this.initEffectState({ id: '' });
         this.event = { id: '' };
         this.events = null;
         this.eventDepth = 0;
@@ -116,8 +116,12 @@ class Battle {
         this.lastMoveLine = -1;
         this.lastSuccessfulMoveThisTurn = null;
         this.lastDamage = 0;
-        this.abilityOrder = 0;
+        this.effectOrder = 0;
         this.quickClawRoll = false;
+        this.speedOrder = [];
+        for (let i = 0; i < this.activePerHalf * 2; i++) {
+            this.speedOrder.push(i);
+        }
         this.teamGenerator = null;
         this.hints = new Set();
         this.NOT_FAIL = '';
@@ -126,7 +130,7 @@ class Battle {
         this.SILENT_FAIL = null;
         this.send = options.send || (() => { });
         const inputOptions = {
-            formatid: options.formatid, seed: this.prng.seed,
+            formatid: options.formatid, seed: this.prngSeed,
         };
         if (this.rated)
             inputOptions.rated = this.rated;
@@ -184,7 +188,7 @@ class Battle {
         return `Battle: ${this.format}`;
     }
     random(m, n) {
-        return this.prng.next(m, n);
+        return this.prng.random(m, n);
     }
     randomChance(numerator, denominator) {
         if (this.forceRandomChance !== null)
@@ -195,7 +199,7 @@ class Battle {
         return this.prng.sample(items);
     }
     /** Note that passing `undefined` resets to the starting seed, but `null` will roll a new seed */
-    resetRNG(seed = this.prng.startingSeed) {
+    resetRNG(seed = this.prngSeed) {
         this.prng = new prng_1.PRNG(seed);
         this.add('message', "The battle's RNG was reset.");
     }
@@ -230,6 +234,7 @@ class Battle {
      * 2. Priority, high to low (default 0)
      * 3. Speed, high to low (default 0)
      * 4. SubOrder, low to high (default 0)
+     * 5. EffectOrder, low to high (default 0)
      *
      * Doesn't reference `this` so doesn't need to be bound.
      */
@@ -238,12 +243,14 @@ class Battle {
             ((b.priority || 0) - (a.priority || 0)) ||
             ((b.speed || 0) - (a.speed || 0)) ||
             -((b.subOrder || 0) - (a.subOrder || 0)) ||
+            -((b.effectOrder || 0) - (a.effectOrder || 0)) ||
             0;
     }
     static compareRedirectOrder(a, b) {
         return ((b.priority || 0) - (a.priority || 0)) ||
             ((b.speed || 0) - (a.speed || 0)) ||
-            ((a.effectHolder && b.effectHolder) ? -(b.effectHolder.abilityOrder - a.effectHolder.abilityOrder) : 0) ||
+            ((a.effectHolder?.abilityState && b.effectHolder?.abilityState) ?
+                -(b.effectHolder.abilityState.effectOrder - a.effectHolder.abilityState.effectOrder) : 0) ||
             0;
     }
     static compareLeftToRightOrder(a, b) {
@@ -308,22 +315,32 @@ class Battle {
     /**
      * Runs an event with no source on each effect on the field, in Speed order.
      *
-     * Unlike `eachEvent`, this contains a lot of other handling and is intended only for the residual step.
+     * Unlike `eachEvent`, this contains a lot of other handling and is only intended for
+     * the 'Residual' and 'SwitchIn' events.
      */
-    residualEvent(eventid, relayVar) {
+    fieldEvent(eventid, targets) {
         const callbackName = `on${eventid}`;
-        let handlers = this.findBattleEventHandlers(callbackName, 'duration');
-        handlers = handlers.concat(this.findFieldEventHandlers(this.field, `onField${eventid}`, 'duration'));
+        let getKey;
+        if (eventid === 'Residual') {
+            getKey = 'duration';
+        }
+        let handlers = this.findFieldEventHandlers(this.field, `onField${eventid}`, getKey);
         for (const side of this.sides) {
             if (side.n < 2 || !side.allySide) {
-                handlers = handlers.concat(this.findSideEventHandlers(side, `onSide${eventid}`, 'duration'));
+                handlers = handlers.concat(this.findSideEventHandlers(side, `onSide${eventid}`, getKey));
             }
             for (const active of side.active) {
                 if (!active)
                     continue;
-                handlers = handlers.concat(this.findPokemonEventHandlers(active, callbackName, 'duration'));
+                if (eventid === 'SwitchIn') {
+                    handlers = handlers.concat(this.findPokemonEventHandlers(active, `onAny${eventid}`));
+                }
+                if (targets && !targets.includes(active))
+                    continue;
+                handlers = handlers.concat(this.findPokemonEventHandlers(active, callbackName, getKey));
                 handlers = handlers.concat(this.findSideEventHandlers(side, callbackName, undefined, active));
                 handlers = handlers.concat(this.findFieldEventHandlers(this.field, callbackName, undefined, active));
+                handlers = handlers.concat(this.findBattleEventHandlers(callbackName, getKey, active));
             }
         }
         this.speedSort(handlers);
@@ -331,9 +348,11 @@ class Battle {
             const handler = handlers[0];
             handlers.shift();
             const effect = handler.effect;
-            if (handler.effectHolder.fainted)
-                continue;
-            if (handler.end && handler.state && handler.state.duration) {
+            if (handler.effectHolder.fainted) {
+                if (!(handler.state?.isSlotCondition))
+                    continue;
+            }
+            if (eventid === 'Residual' && handler.end && handler.state && handler.state.duration) {
                 handler.state.duration--;
                 if (!handler.state.duration) {
                     const endCallArgs = handler.endCallArgs || [handler.effectHolder, effect.id];
@@ -349,7 +368,7 @@ class Battle {
             if (handler.effectHolder.pseudoWeather)
                 handlerEventid = `Field${eventid}`;
             if (handler.callback) {
-                this.singleEvent(handlerEventid, effect, handler.state, handler.effectHolder, null, null, relayVar, handler.callback);
+                this.singleEvent(handlerEventid, effect, handler.state, handler.effectHolder, null, null, undefined, handler.callback);
             }
             this.faintMessages();
             if (this.ended)
@@ -383,8 +402,8 @@ class Battle {
             // it's changed; call it off
             return relayVar;
         }
-        if (eventid !== 'Start' && eventid !== 'TakeItem' && eventid !== 'Primal' &&
-            effect.effectType === 'Item' && (target instanceof pokemon_1.Pokemon) && target.ignoringItem()) {
+        if (eventid !== 'Start' && eventid !== 'TakeItem' && effect.effectType === 'Item' &&
+            (target instanceof pokemon_1.Pokemon) && target.ignoringItem()) {
             this.debug(eventid + ' handler suppressed by Embargo, Klutz or Magic Room');
             return relayVar;
         }
@@ -404,7 +423,7 @@ class Battle {
         const parentEffectState = this.effectState;
         const parentEvent = this.event;
         this.effect = effect;
-        this.effectState = state || {};
+        this.effectState = state || this.initEffectState({});
         this.event = { id: eventid, target, source, effect: sourceEffect };
         this.eventDepth++;
         const args = [target, source, sourceEffect];
@@ -555,7 +574,7 @@ class Battle {
                 if (Array.isArray(target))
                     throw new Error("");
                 handlers.unshift(this.resolvePriority({
-                    effect: sourceEffect, callback, state: {}, end: null, effectHolder: target,
+                    effect: sourceEffect, callback, state: this.initEffectState({}), end: null, effectHolder: target,
                 }, `on${eventid}`));
             }
         }
@@ -674,7 +693,7 @@ class Battle {
                 const parentEffect = this.effect;
                 const parentEffectState = this.effectState;
                 this.effect = handler.effect;
-                this.effectState = handler.state || {};
+                this.effectState = handler.state || this.initEffectState({});
                 this.effectState.target = effectHolder;
                 returnVal = handler.callback.apply(this, args);
                 this.effect = parentEffect;
@@ -716,15 +735,74 @@ class Battle {
     priorityEvent(eventid, target, source, effect, relayVar, onEffect) {
         return this.runEvent(eventid, target, source, effect, relayVar, onEffect, true);
     }
-    resolvePriority(handler, callbackName) {
+    resolvePriority(h, callbackName) {
+        const handler = h;
         // @ts-ignore
         handler.order = handler.effect[`${callbackName}Order`] || false;
         // @ts-ignore
         handler.priority = handler.effect[`${callbackName}Priority`] || 0;
         // @ts-ignore
         handler.subOrder = handler.effect[`${callbackName}SubOrder`] || 0;
+        if (!handler.subOrder) {
+            // https://www.smogon.com/forums/threads/sword-shield-battle-mechanics-research.3655528/page-59#post-8685465
+            const effectTypeOrder = {
+                // Z-Move: 1,
+                Condition: 2,
+                // Slot Condition: 3,
+                // Side Condition: 4,
+                // Field Condition: 5, (includes weather but also terrains and pseudoweathers)
+                Weather: 5,
+                Format: 5,
+                Rule: 5,
+                Ruleset: 5,
+                // Poison Touch: 6, (also includes Perish Body)
+                Ability: 7,
+                Item: 8,
+                // Stall: 9,
+            };
+            handler.subOrder = effectTypeOrder[handler.effect.effectType] || 0;
+            if (handler.effect.effectType === 'Condition') {
+                if (handler.state?.target instanceof side_1.Side) {
+                    if (handler.state.isSlotCondition) {
+                        // slot condition
+                        handler.subOrder = 3;
+                    }
+                    else {
+                        // side condition
+                        handler.subOrder = 4;
+                    }
+                }
+                else if (handler.state?.target instanceof field_1.Field) {
+                    // field condition
+                    handler.subOrder = 5;
+                }
+            }
+            else if (handler.effect.effectType === 'Ability') {
+                if (handler.effect.name === 'Poison Touch' || handler.effect.name === 'Perish Body') {
+                    handler.subOrder = 6;
+                }
+                else if (handler.effect.name === 'Stall') {
+                    handler.subOrder = 9;
+                }
+            }
+        }
+        if (callbackName.endsWith('SwitchIn') || callbackName.endsWith('RedirectTarget')) {
+            // If multiple hazards are present on one side, their event handlers all perfectly tie in speed, priority,
+            // and subOrder. They should activate in the order they were created, which is where effectOrder comes in.
+            // This also applies to speed ties for which ability like Lightning Rod redirects moves.
+            // TODO: In-game, other events are also sorted this way, but that's an implementation for another refactor
+            handler.effectOrder = handler.state?.effectOrder;
+        }
         if (handler.effectHolder && handler.effectHolder.getStat) {
-            handler.speed = handler.effectHolder.speed;
+            const pokemon = handler.effectHolder;
+            handler.speed = pokemon.speed;
+            if (callbackName.endsWith('SwitchIn')) {
+                // Pokemon speeds including ties are resolved before all onSwitchIn handlers and aren't re-sorted in-between
+                // so we subtract a fractional speed from each Pokemon's respective event handlers by using the index of their
+                // unique field position in a pre-sorted-by-speed array
+                const fieldPositionValue = pokemon.side.n * this.sides.length + pokemon.position;
+                handler.speed -= this.speedOrder.indexOf(fieldPositionValue) / (this.activePerHalf * 2);
+            }
         }
         return handler;
     }
@@ -799,7 +877,22 @@ class Battle {
                     effect: volatile, callback, state: volatileState, end: pokemon.removeVolatile, effectHolder: pokemon,
                 }, callbackName));
             }
+            else if (['ability', 'item'].includes(volatile.id.split(':')[0])) {
+                // Innate abilities/items; see comment below
+                // @ts-ignore - dynamic lookup
+                if (this.gen >= 5 && callbackName === 'onSwitchIn' && !volatile.onAnySwitchIn) {
+                    callback = volatile.onStart;
+                    if (callback !== undefined || (getKey && volatileState[getKey])) {
+                        handlers.push(this.resolvePriority({
+                            effect: volatile, callback, state: volatileState, end: pokemon.removeVolatile, effectHolder: pokemon,
+                        }, callbackName));
+                    }
+                }
+            }
         }
+        // Abilities and items Start at different times during the SwitchIn event, so we run their onStart handlers
+        // during the SwitchIn event instead of running the Start event during switch-ins
+        // gens 4 and before still use the old system, though
         const ability = pokemon.getAbility();
         // @ts-ignore - dynamic lookup
         callback = ability[callbackName];
@@ -807,6 +900,16 @@ class Battle {
             handlers.push(this.resolvePriority({
                 effect: ability, callback, state: pokemon.abilityState, end: pokemon.clearAbility, effectHolder: pokemon,
             }, callbackName));
+            // @ts-ignore - dynamic lookup
+        }
+        else if (this.gen >= 5 && callbackName === 'onSwitchIn' && !ability.onAnySwitchIn) {
+            // @ts-ignore - dynamic lookup
+            callback = ability.onStart;
+            if (callback !== undefined || (getKey && pokemon.abilityState[getKey])) {
+                handlers.push(this.resolvePriority({
+                    effect: ability, callback, state: pokemon.abilityState, end: pokemon.clearAbility, effectHolder: pokemon,
+                }, callbackName));
+            }
         }
         const item = pokemon.getItem();
         // @ts-ignore - dynamic lookup
@@ -815,6 +918,16 @@ class Battle {
             handlers.push(this.resolvePriority({
                 effect: item, callback, state: pokemon.itemState, end: pokemon.clearItem, effectHolder: pokemon,
             }, callbackName));
+            // @ts-ignore - dynamic lookup
+        }
+        else if (this.gen >= 5 && callbackName === 'onSwitchIn' && !item.onAnySwitchIn) {
+            // @ts-ignore - dynamic lookup
+            callback = item.onStart;
+            if (callback !== undefined || (getKey && pokemon.itemState[getKey])) {
+                handlers.push(this.resolvePriority({
+                    effect: item, callback, state: pokemon.itemState, end: pokemon.clearItem, effectHolder: pokemon,
+                }, callbackName));
+            }
         }
         const species = pokemon.baseSpecies;
         // @ts-ignore - dynamic lookup
@@ -837,13 +950,13 @@ class Battle {
                     state: slotConditionState,
                     end: side.removeSlotCondition,
                     endCallArgs: [side, pokemon, slotCondition.id],
-                    effectHolder: side,
+                    effectHolder: pokemon,
                 }, callbackName));
             }
         }
         return handlers;
     }
-    findBattleEventHandlers(callbackName, getKey) {
+    findBattleEventHandlers(callbackName, getKey, customHolder) {
         const handlers = [];
         let callback;
         const format = this.format;
@@ -851,15 +964,15 @@ class Battle {
         callback = format[callbackName];
         if (callback !== undefined || (getKey && this.formatData[getKey])) {
             handlers.push(this.resolvePriority({
-                effect: format, callback, state: this.formatData, end: null, effectHolder: this,
+                effect: format, callback, state: this.formatData, end: null, effectHolder: customHolder || this,
             }, callbackName));
         }
         if (this.events && (callback = this.events[callbackName]) !== undefined) {
             for (const handler of callback) {
                 const state = (handler.target.effectType === 'Format') ? this.formatData : null;
                 handlers.push({
-                    effect: handler.target, callback: handler.callback, state, end: null,
-                    effectHolder: this, priority: handler.priority, order: handler.order, subOrder: handler.subOrder,
+                    effect: handler.target, callback: handler.callback, state, end: null, effectHolder: customHolder || this,
+                    priority: handler.priority, order: handler.order, subOrder: handler.subOrder,
                 });
             }
         }
@@ -1002,11 +1115,11 @@ class Battle {
         }
         return pokemonList;
     }
-    getAllActive() {
+    getAllActive(includeFainted) {
         const pokemonList = [];
         for (const side of this.sides) {
             for (const pokemon of side.active) {
-                if (pokemon && !pokemon.fainted) {
+                if (pokemon && (includeFainted || !pokemon.fainted)) {
                     pokemonList.push(pokemon);
                 }
             }
@@ -1401,24 +1514,6 @@ class Battle {
             this.quickClawRoll = this.randomChance(60, 256);
         if (this.gen === 3)
             this.quickClawRoll = this.randomChance(1, 5);
-        // Crazyhouse Progress checker because sidebars has trouble keeping track of Pokemon.
-        // Please remove me once there is client support.
-        if (this.ruleTable.has('crazyhouserule')) {
-            for (const side of this.sides) {
-                let buf = `raw|${lib_1.Utils.escapeHTML(side.name)}'s team:<br />`;
-                for (const pokemon of side.pokemon) {
-                    if (!buf.endsWith('<br />'))
-                        buf += '/</span>&#8203;';
-                    if (pokemon.fainted) {
-                        buf += `<span style="white-space:nowrap;"><span style="opacity:.3"><psicon pokemon="${pokemon.species.id}" /></span>`;
-                    }
-                    else {
-                        buf += `<span style="white-space:nowrap"><psicon pokemon="${pokemon.species.id}" />`;
-                    }
-                }
-                this.add(`${buf}</span>`);
-            }
-        }
         this.makeRequest('move');
     }
     maybeTriggerEndlessBattleClause(trappedBySide, stalenessBySide) {
@@ -1823,14 +1918,16 @@ class Battle {
             this.lastDamage = damage;
             if (target.volatiles['substitute']) {
                 const hint = "In Gen 1, if a Pokemon with a Substitute hurts itself due to confusion or Jump Kick/Hi Jump Kick recoil and the target";
-                if (source?.volatiles['substitute']) {
-                    source.volatiles['substitute'].hp -= damage;
-                    if (source.volatiles['substitute'].hp <= 0) {
-                        source.removeVolatile('substitute');
-                        source.subFainted = true;
+                // if the move was a self-targeting move, the source is the same as the target. We need to check the opposing substitute
+                const foe = target.side.foe.active[0];
+                if (foe?.volatiles['substitute']) {
+                    foe.volatiles['substitute'].hp -= damage;
+                    if (foe.volatiles['substitute'].hp <= 0) {
+                        foe.removeVolatile('substitute');
+                        foe.subFainted = true;
                     }
                     else {
-                        this.add('-activate', source, 'Substitute', '[damage]');
+                        this.add('-activate', foe, 'Substitute', '[damage]');
                     }
                     this.hint(hint + " has a Substitute, the target's Substitute takes the damage.");
                     return damage;
@@ -2147,12 +2244,23 @@ class Battle {
                     pokemon.side.totalFainted++;
                 this.runEvent('Faint', pokemon, faintData.source, faintData.effect);
                 this.singleEvent('End', pokemon.getAbility(), pokemon.abilityState, pokemon);
+                this.singleEvent('End', pokemon.getItem(), pokemon.itemState, pokemon);
+                if (pokemon.regressionForme) {
+                    // before clearing volatiles
+                    pokemon.baseSpecies = this.dex.species.get(pokemon.set.species || pokemon.set.name);
+                    pokemon.baseAbility = (0, dex_1.toID)(pokemon.set.ability);
+                }
                 pokemon.clearVolatile(false);
                 pokemon.fainted = true;
                 pokemon.illusion = null;
                 pokemon.isActive = false;
                 pokemon.isStarted = false;
                 delete pokemon.terastallized;
+                if (pokemon.regressionForme) {
+                    // after clearing volatiles
+                    pokemon.details = pokemon.getUpdatedDetails();
+                    pokemon.regressionForme = false;
+                }
                 pokemon.side.faintedThisTurn = pokemon;
                 if (this.faintQueue.length >= faintQueueLeft)
                     checkWin = true;
@@ -2272,8 +2380,7 @@ class Battle {
                     if (!species)
                         continue;
                     pokemon.baseSpecies = rawSpecies;
-                    pokemon.details = species.name + (pokemon.level === 100 ? '' : ', L' + pokemon.level) +
-                        (pokemon.gender === '' ? '' : ', ' + pokemon.gender) + (pokemon.set.shiny ? ', shiny' : '');
+                    pokemon.details = pokemon.getUpdatedDetails();
                     pokemon.setAbility(species.abilities['0'], null, true);
                     pokemon.baseAbility = pokemon.ability;
                     const behemothMove = {
@@ -2426,17 +2533,9 @@ class Battle {
                 this.add('-heal', action.target, action.target.getHealth, '[from] move: Revival Blessing');
                 action.pokemon.side.removeSlotCondition(action.pokemon, 'revivalblessing');
                 break;
-            case 'runUnnerve':
-                this.singleEvent('PreStart', action.pokemon.getAbility(), action.pokemon.abilityState, action.pokemon);
-                break;
             case 'runSwitch':
                 this.actions.runSwitch(action.pokemon);
                 break;
-            case 'runPrimal':
-                if (!action.pokemon.transformed) {
-                    this.singleEvent('Primal', action.pokemon.getItem(), action.pokemon.itemState, action.pokemon);
-                }
-                break;
             case 'shift':
                 if (!action.pokemon.isActive)
                     return false;
@@ -2452,7 +2551,7 @@ class Battle {
                 this.clearActiveMove(true);
                 this.updateSpeed();
                 residualPokemon = this.getAllActive().map(pokemon => [pokemon, pokemon.getUndynamaxedHP()]);
-                this.residualEvent('Residual');
+                this.fieldEvent('Residual');
                 this.add('upkeep');
                 break;
         }
@@ -2493,7 +2592,7 @@ class Battle {
         else if (this.queue.peek()?.choice === 'instaswitch') {
             return false;
         }
-        if (this.gen >= 5) {
+        if (this.gen >= 5 && action.choice !== 'start') {
             this.eachEvent('Update');
             for (const [pokemon, originalHP] of residualPokemon) {
                 const maxhp = pokemon.getUndynamaxedHP(pokemon.maxhp);
@@ -2918,6 +3017,34 @@ class Battle {
     getOverflowedTurnCount() {
         return this.gen >= 8 ? (this.turn - 1) % 256 : this.turn - 1;
     }
+    initEffectState(obj, effectOrder) {
+        if (!obj.id)
+            obj.id = '';
+        if (effectOrder !== undefined) {
+            obj.effectOrder = effectOrder;
+        }
+        else if (obj.id && obj.target && (!(obj.target instanceof pokemon_1.Pokemon) || obj.target.isActive)) {
+            obj.effectOrder = this.effectOrder++;
+        }
+        else {
+            obj.effectOrder = 0;
+        }
+        return obj;
+    }
+    clearEffectState(state) {
+        state.id = '';
+        for (const k in state) {
+            if (k === 'id' || k === 'target') {
+                continue;
+            }
+            else if (k === 'effectOrder') {
+                state.effectOrder = 0;
+            }
+            else {
+                delete state[k];
+            }
+        }
+    }
     destroy() {
         // deallocate ourself
         // deallocate children and get rid of references to them