@pkmn/sim 0.9.27 → 0.9.28

package/build/esm/sim/battle.mjs

@@ -22,7 +22,7 @@ import { Side } from './side.mjs';
 import { State } from './state.mjs';
 import { BattleQueue } from './battle-queue.mjs';
 import { BattleActions } from './battle-actions.mjs';
-import { Utils } from '../lib/index.mjs';
+import { Utils } from '../lib/utils.mjs';
 const splitRegex = /^\|split\|p([1234])\n(.*)\n(.*)|.+/gm;
 export function extractChannelMessages(message, channelIds) {
     const channelIdSet = new Set(channelIds);
@@ -75,7 +75,7 @@ export 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(this);
         this.sides = Array(format.playerCount).fill(null);
@@ -101,7 +101,7 @@ export 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;
@@ -112,8 +112,12 @@ export 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 = '';
@@ -226,6 +230,7 @@ export 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.
      */
@@ -234,12 +239,14 @@ export 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) {
@@ -304,22 +311,32 @@ export 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);
@@ -327,9 +344,11 @@ export 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];
@@ -345,7 +364,7 @@ export 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)
@@ -379,8 +398,8 @@ export class Battle {
             // it's changed; call it off
             return relayVar;
         }
-        if (eventid !== 'Start' && eventid !== 'TakeItem' && eventid !== 'Primal' &&
-            effect.effectType === 'Item' && (target instanceof Pokemon) && target.ignoringItem()) {
+        if (eventid !== 'Start' && eventid !== 'TakeItem' && effect.effectType === 'Item' &&
+            (target instanceof Pokemon) && target.ignoringItem()) {
             this.debug(eventid + ' handler suppressed by Embargo, Klutz or Magic Room');
             return relayVar;
         }
@@ -400,7 +419,7 @@ export 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];
@@ -551,7 +570,7 @@ export 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}`));
             }
         }
@@ -670,7 +689,7 @@ export 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;
@@ -712,15 +731,74 @@ export 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) {
+                    if (handler.state.isSlotCondition) {
+                        // slot condition
+                        handler.subOrder = 3;
+                    }
+                    else {
+                        // side condition
+                        handler.subOrder = 4;
+                    }
+                }
+                else if (handler.state?.target instanceof 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;
     }
@@ -795,7 +873,22 @@ export 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];
@@ -803,6 +896,16 @@ export 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
@@ -811,6 +914,16 @@ export 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
@@ -833,13 +946,13 @@ export 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;
@@ -847,15 +960,15 @@ export 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,
                 });
             }
         }
@@ -998,11 +1111,11 @@ export 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);
                 }
             }
@@ -1397,24 +1510,6 @@ export 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|${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) {
@@ -2145,12 +2240,23 @@ export 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 = 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;
@@ -2270,8 +2376,7 @@ export 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 = {
@@ -2424,17 +2529,9 @@ export 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;
@@ -2450,7 +2547,7 @@ export 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;
         }
@@ -2491,7 +2588,7 @@ export 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);
@@ -2916,6 +3013,34 @@ export 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) || 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