@pkmn/sim 0.9.34 → 0.9.35

package/build/esm/sim/battle.mjs

@@ -837,6 +837,19 @@ export class Battle {
         }
         return handler;
     }
+    getCallback(target, effect, callbackName) {
+        let callback = effect[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
+        if (callback === undefined && target instanceof Pokemon && this.gen >= 5 && callbackName === 'onSwitchIn' &&
+            !effect.onAnySwitchIn && (['Ability', 'Item'].includes(effect.effectType) || (
+        // Innate abilities/items
+        effect.effectType === 'Status' && ['ability', 'item'].includes(effect.id.split(':')[0])))) {
+            callback = effect.onStart;
+        }
+        return callback;
+    }
     findEventHandlers(target, eventName, source) {
         let handlers = [];
         if (Array.isArray(target)) {
@@ -891,8 +904,7 @@ export class Battle {
     findPokemonEventHandlers(pokemon, callbackName, getKey) {
         const handlers = [];
         const status = pokemon.getStatus();
-        // @ts-expect-error dynamic lookup
-        let callback = status[callbackName];
+        let callback = this.getCallback(pokemon, status, callbackName);
         if (callback !== undefined || (getKey && pokemon.statusState[getKey])) {
             handlers.push(this.resolvePriority({
                 effect: status, callback, state: pokemon.statusState, end: pokemon.clearStatus, effectHolder: pokemon,
@@ -901,67 +913,29 @@ export class Battle {
         for (const id in pokemon.volatiles) {
             const volatileState = pokemon.volatiles[id];
             const volatile = this.dex.conditions.getByID(id);
-            // @ts-expect-error dynamic lookup
-            callback = volatile[callbackName];
+            callback = this.getCallback(pokemon, volatile, callbackName);
             if (callback !== undefined || (getKey && volatileState[getKey])) {
                 handlers.push(this.resolvePriority({
                     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-expect-error 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-expect-error dynamic lookup
-        callback = ability[callbackName];
+        callback = this.getCallback(pokemon, ability, callbackName);
         if (callback !== undefined || (getKey && pokemon.abilityState[getKey])) {
             handlers.push(this.resolvePriority({
                 effect: ability, callback, state: pokemon.abilityState, end: pokemon.clearAbility, effectHolder: pokemon,
             }, callbackName));
-            // @ts-expect-error dynamic lookup
-        }
-        else if (this.gen >= 5 && callbackName === 'onSwitchIn' && !ability.onAnySwitchIn) {
-            // @ts-expect-error 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-expect-error dynamic lookup
-        callback = item[callbackName];
+        callback = this.getCallback(pokemon, item, callbackName);
         if (callback !== undefined || (getKey && pokemon.itemState[getKey])) {
             handlers.push(this.resolvePriority({
                 effect: item, callback, state: pokemon.itemState, end: pokemon.clearItem, effectHolder: pokemon,
             }, callbackName));
-            // @ts-expect-error dynamic lookup
-        }
-        else if (this.gen >= 5 && callbackName === 'onSwitchIn' && !item.onAnySwitchIn) {
-            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-expect-error dynamic lookup
-        callback = species[callbackName];
+        callback = this.getCallback(pokemon, species, callbackName);
         if (callback !== undefined) {
             handlers.push(this.resolvePriority({
                 effect: species, callback, state: pokemon.speciesState, end() { }, effectHolder: pokemon,
@@ -971,8 +945,7 @@ export class Battle {
         for (const conditionid in side.slotConditions[pokemon.position]) {
             const slotConditionState = side.slotConditions[pokemon.position][conditionid];
             const slotCondition = this.dex.conditions.getByID(conditionid);
-            // @ts-expect-error dynamic lookup
-            callback = slotCondition[callbackName];
+            callback = this.getCallback(pokemon, slotCondition, callbackName);
             if (callback !== undefined || (getKey && slotConditionState[getKey])) {
                 handlers.push(this.resolvePriority({
                     effect: slotCondition,
@@ -990,8 +963,7 @@ export class Battle {
         const handlers = [];
         let callback;
         const format = this.format;
-        // @ts-expect-error dynamic lookup
-        callback = format[callbackName];
+        callback = this.getCallback(this, format, callbackName);
         if (callback !== undefined || (getKey && this.formatData[getKey])) {
             handlers.push(this.resolvePriority({
                 effect: format, callback, state: this.formatData, end: null, effectHolder: customHolder || this,
@@ -1014,8 +986,7 @@ export class Battle {
         for (const id in field.pseudoWeather) {
             const pseudoWeatherState = field.pseudoWeather[id];
             const pseudoWeather = this.dex.conditions.getByID(id);
-            // @ts-expect-error dynamic lookup
-            callback = pseudoWeather[callbackName];
+            callback = this.getCallback(field, pseudoWeather, callbackName);
             if (callback !== undefined || (getKey && pseudoWeatherState[getKey])) {
                 handlers.push(this.resolvePriority({
                     effect: pseudoWeather, callback, state: pseudoWeatherState,
@@ -1024,8 +995,7 @@ export class Battle {
             }
         }
         const weather = field.getWeather();
-        // @ts-expect-error dynamic lookup
-        callback = weather[callbackName];
+        callback = this.getCallback(field, weather, callbackName);
         if (callback !== undefined || (getKey && this.field.weatherState[getKey])) {
             handlers.push(this.resolvePriority({
                 effect: weather, callback, state: this.field.weatherState,
@@ -1033,8 +1003,7 @@ export class Battle {
             }, callbackName));
         }
         const terrain = field.getTerrain();
-        // @ts-expect-error dynamic lookup
-        callback = terrain[callbackName];
+        callback = this.getCallback(field, terrain, callbackName);
         if (callback !== undefined || (getKey && field.terrainState[getKey])) {
             handlers.push(this.resolvePriority({
                 effect: terrain, callback, state: field.terrainState,
@@ -1048,8 +1017,7 @@ export class Battle {
         for (const id in side.sideConditions) {
             const sideConditionData = side.sideConditions[id];
             const sideCondition = this.dex.conditions.getByID(id);
-            // @ts-expect-error dynamic lookup
-            const callback = sideCondition[callbackName];
+            const callback = this.getCallback(side, sideCondition, callbackName);
             if (callback !== undefined || (getKey && sideConditionData[getKey])) {
                 handlers.push(this.resolvePriority({
                     effect: sideCondition, callback, state: sideConditionData,