isaacscript-common 87.9.6 → 87.9.8

package/dist/classes/features/callbackLogic/PlayerCollectibleDetection.js

@@ -1,95 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayerCollectibleDetection = void 0;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const cachedEnumValues_1 = require("../../../cachedEnumValues");
-const ISCFeature_1 = require("../../../enums/ISCFeature");
-const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
-const array_1 = require("../../../functions/array");
-const flag_1 = require("../../../functions/flag");
-const playerDataStructures_1 = require("../../../functions/playerDataStructures");
-const players_1 = require("../../../functions/players");
-const sort_1 = require("../../../functions/sort");
-const utils_1 = require("../../../functions/utils");
-const DefaultMap_1 = require("../../DefaultMap");
-const Feature_1 = require("../../private/Feature");
+import { CollectibleType, DamageFlag, ItemType, ModCallback, PlayerType, } from "isaac-typescript-definitions";
+import { ACTIVE_SLOT_VALUES } from "../../../cachedEnumValues";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
+import { arrayEquals } from "../../../functions/array";
+import { hasFlag } from "../../../functions/flag";
+import { defaultMapGetPlayer, mapSetPlayer, } from "../../../functions/playerDataStructures";
+import { getPlayerFromPtr } from "../../../functions/players";
+import { sortNormal } from "../../../functions/sort";
+import { repeat } from "../../../functions/utils";
+import { DefaultMap } from "../../DefaultMap";
+import { Feature } from "../../private/Feature";
 const v = {
     run: {
-        playersCollectibleCount: new DefaultMap_1.DefaultMap(0),
-        playersCollectibleMap: new DefaultMap_1.DefaultMap(() => new Map()),
-        playersActiveItemMap: new DefaultMap_1.DefaultMap(() => new Map()),
+        playersCollectibleCount: new DefaultMap(0),
+        playersCollectibleMap: new DefaultMap(() => new Map()),
+        playersActiveItemMap: new DefaultMap(() => new Map()),
     },
 };
-class PlayerCollectibleDetection extends Feature_1.Feature {
-    v = v;
+export class PlayerCollectibleDetection extends Feature {
     postPlayerCollectibleAdded;
     postPlayerCollectibleRemoved;
     moddedElementSets;
     runInNFrames;
-    constructor(postPlayerCollectibleAdded, postPlayerCollectibleRemoved, moddedElementSets, runInNFrames) {
-        super();
-        this.featuresUsed = [
-            ISCFeature_1.ISCFeature.MODDED_ELEMENT_SETS,
-            ISCFeature_1.ISCFeature.RUN_IN_N_FRAMES,
-        ];
-        this.callbacksUsed = [
-            // 3
-            [isaac_typescript_definitions_1.ModCallback.POST_USE_ITEM, this.postUseItemD4, [isaac_typescript_definitions_1.CollectibleType.D4]],
-        ];
-        this.customCallbacksUsed = [
-            [ModCallbackCustom_1.ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
-            [ModCallbackCustom_1.ModCallbackCustom.POST_ITEM_PICKUP, this.postItemPickup],
-            [
-                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-                this.postPEffectUpdateReordered,
-            ],
-        ];
-        this.postPlayerCollectibleAdded = postPlayerCollectibleAdded;
-        this.postPlayerCollectibleRemoved = postPlayerCollectibleRemoved;
-        this.moddedElementSets = moddedElementSets;
-        this.runInNFrames = runInNFrames;
-    }
-    /**
-     * This is called when the collectible count changes and in situations where the entire build is
-     * rerolled.
-     *
-     * Since getting a new player collectible map is expensive, we want to only run this function when
-     * necessary, and not on e.g. every frame. Unfortunately, this has the side effect of missing out
-     * on collectible changes from mods that add and remove a collectible on the same frame.
-     *
-     * @param player The player to update.
-     * @param numCollectiblesChanged Pass undefined for situations where the entire build was
-     *                               rerolled.
-     */
-    updateCollectibleMapAndFire(player, numCollectiblesChanged) {
-        const oldCollectibleMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersCollectibleMap, player);
-        const newCollectibleMap = this.moddedElementSets.getPlayerCollectibleMap(player);
-        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersCollectibleMap, player, newCollectibleMap);
-        const collectibleTypesSet = new Set([
-            ...oldCollectibleMap.keys(),
-            ...newCollectibleMap.keys(),
-        ]);
-        let numFired = 0;
-        for (const collectibleType of collectibleTypesSet) {
-            const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
-            const newNum = newCollectibleMap.get(collectibleType) ?? 0;
-            const difference = newNum - oldNum;
-            const increased = difference > 0;
-            const absoluteDifference = Math.abs(difference);
-            (0, utils_1.repeat)(absoluteDifference, () => {
-                if (increased) {
-                    this.postPlayerCollectibleAdded.fire(player, collectibleType);
-                }
-                else {
-                    this.postPlayerCollectibleRemoved.fire(player, collectibleType);
-                }
-                numFired++;
-            });
-            if (numFired === numCollectiblesChanged) {
-                return;
-            }
-        }
-    }
     // ModCallback.POST_USE_ITEM (3)
     // CollectibleType.D4 (284)
     postUseItemD4 = (_collectibleType, _rng, player) => {
@@ -112,17 +44,17 @@ class PlayerCollectibleDetection extends Feature_1.Feature {
     // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
     entityTakeDmgPlayer = (player, _amount, damageFlags, _source, _countdownFrames) => {
         // Tainted Eden's mechanic does not apply if she e.g. uses Dull Razor.
-        if ((0, flag_1.hasFlag)(damageFlags, isaac_typescript_definitions_1.DamageFlag.FAKE)) {
+        if (hasFlag(damageFlags, DamageFlag.FAKE)) {
             return undefined;
         }
         const character = player.GetPlayerType();
-        if (character !== isaac_typescript_definitions_1.PlayerType.EDEN_B) {
+        if (character !== PlayerType.EDEN_B) {
             return undefined;
         }
         // The items will only be rerolled after the damage is successfully applied.
         const entityPtr = EntityPtr(player);
         this.runInNFrames.runNextGameFrame(() => {
-            const futurePlayer = (0, players_1.getPlayerFromPtr)(entityPtr);
+            const futurePlayer = getPlayerFromPtr(entityPtr);
             if (futurePlayer !== undefined) {
                 this.updateCollectibleMapAndFire(player, undefined);
             }
@@ -135,30 +67,95 @@ class PlayerCollectibleDetection extends Feature_1.Feature {
      */
     // ModCallbackCustom.POST_ITEM_PICKUP
     postItemPickup = (player, pickingUpItem) => {
-        if (pickingUpItem.itemType === isaac_typescript_definitions_1.ItemType.TRINKET
-            || pickingUpItem.itemType === isaac_typescript_definitions_1.ItemType.NULL) {
+        if (pickingUpItem.itemType === ItemType.TRINKET
+            || pickingUpItem.itemType === ItemType.NULL) {
             return;
         }
         const newCollectibleCount = player.GetCollectibleCount();
-        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersCollectibleCount, player, newCollectibleCount);
+        mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
         this.updateCollectibleMapAndFire(player, 1);
     };
     // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
     postPEffectUpdateReordered = (player) => {
-        const oldCollectibleCount = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersCollectibleCount, player);
+        const oldCollectibleCount = defaultMapGetPlayer(v.run.playersCollectibleCount, player);
         const newCollectibleCount = player.GetCollectibleCount();
-        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersCollectibleCount, player, newCollectibleCount);
+        mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
         const difference = newCollectibleCount - oldCollectibleCount;
         if (difference > 0) {
             this.updateCollectibleMapAndFire(player, difference);
         }
         else if (difference < 0) {
-            this.updateCollectibleMapAndFire(player, difference * -1);
+            this.updateCollectibleMapAndFire(player, -difference);
         }
         else if (difference === 0) {
             this.checkActiveItemsChanged(player);
         }
     };
+    v = v;
+    constructor(postPlayerCollectibleAdded, postPlayerCollectibleRemoved, moddedElementSets, runInNFrames) {
+        super();
+        this.featuresUsed = [
+            ISCFeature.MODDED_ELEMENT_SETS,
+            ISCFeature.RUN_IN_N_FRAMES,
+        ];
+        this.callbacksUsed = [
+            // 3
+            [ModCallback.POST_USE_ITEM, this.postUseItemD4, [CollectibleType.D4]],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+            [ModCallbackCustom.POST_ITEM_PICKUP, this.postItemPickup],
+            [
+                ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+        this.postPlayerCollectibleAdded = postPlayerCollectibleAdded;
+        this.postPlayerCollectibleRemoved = postPlayerCollectibleRemoved;
+        this.moddedElementSets = moddedElementSets;
+        this.runInNFrames = runInNFrames;
+    }
+    /**
+     * This is called when the collectible count changes and in situations where the entire build is
+     * rerolled.
+     *
+     * Since getting a new player collectible map is expensive, we want to only run this function when
+     * necessary, and not on e.g. every frame. Unfortunately, this has the side effect of missing out
+     * on collectible changes from mods that add and remove a collectible on the same frame.
+     *
+     * @param player The player to update.
+     * @param numCollectiblesChanged Pass undefined for situations where the entire build was
+     *                               rerolled.
+     */
+    updateCollectibleMapAndFire(player, numCollectiblesChanged) {
+        const oldCollectibleMap = defaultMapGetPlayer(v.run.playersCollectibleMap, player);
+        const newCollectibleMap = this.moddedElementSets.getPlayerCollectibleMap(player);
+        mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
+        const collectibleTypesSet = new Set([
+            ...oldCollectibleMap.keys(),
+            ...newCollectibleMap.keys(),
+        ]);
+        let numFired = 0;
+        for (const collectibleType of collectibleTypesSet) {
+            const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
+            const newNum = newCollectibleMap.get(collectibleType) ?? 0;
+            const difference = newNum - oldNum;
+            const increased = difference > 0;
+            const absoluteDifference = Math.abs(difference);
+            repeat(absoluteDifference, () => {
+                if (increased) {
+                    this.postPlayerCollectibleAdded.fire(player, collectibleType);
+                }
+                else {
+                    this.postPlayerCollectibleRemoved.fire(player, collectibleType);
+                }
+                numFired++;
+            });
+            if (numFired === numCollectiblesChanged) {
+                return;
+            }
+        }
+    }
     /**
      * Checking for collectible count will work to detect when a player swaps their active item for
      * another active item. This is because the collectible count will decrement by 1 when the item is
@@ -169,11 +166,11 @@ class PlayerCollectibleDetection extends Feature_1.Feature {
      * collectible on the same frame, since doing so is cheap.
      */
     checkActiveItemsChanged(player) {
-        const activeItemMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersActiveItemMap, player);
+        const activeItemMap = defaultMapGetPlayer(v.run.playersActiveItemMap, player);
         const oldCollectibleTypes = [];
         const newCollectibleTypes = [];
-        for (const activeSlot of cachedEnumValues_1.ACTIVE_SLOT_VALUES) {
-            const oldCollectibleType = activeItemMap.get(activeSlot) ?? isaac_typescript_definitions_1.CollectibleType.NULL;
+        for (const activeSlot of ACTIVE_SLOT_VALUES) {
+            const oldCollectibleType = activeItemMap.get(activeSlot) ?? CollectibleType.NULL;
             const newCollectibleType = player.GetActiveItem(activeSlot);
             activeItemMap.set(activeSlot, newCollectibleType);
             oldCollectibleTypes.push(oldCollectibleType);
@@ -182,13 +179,12 @@ class PlayerCollectibleDetection extends Feature_1.Feature {
         // For example, it is possible for the player to switch Schoolbag items, which will cause the
         // collectibles in the array to be the same, but in a different order. Thus, we sort both arrays
         // before comparing them.
-        oldCollectibleTypes.sort(sort_1.sortNormal);
-        newCollectibleTypes.sort(sort_1.sortNormal);
-        if (!(0, array_1.arrayEquals)(oldCollectibleTypes, newCollectibleTypes)) {
+        oldCollectibleTypes.sort(sortNormal);
+        newCollectibleTypes.sort(sortNormal);
+        if (!arrayEquals(oldCollectibleTypes, newCollectibleTypes)) {
             // One or more active items have changed (with the player's total collectible count remaining
             // the same).
             this.updateCollectibleMapAndFire(player, undefined);
         }
     }
 }
-exports.PlayerCollectibleDetection = PlayerCollectibleDetection;

package/dist/classes/features/callbackLogic/PlayerCollectibleDetection.lua

@@ -57,7 +57,6 @@ PlayerCollectibleDetection.name = "PlayerCollectibleDetection"
 __TS__ClassExtends(PlayerCollectibleDetection, Feature)
 function PlayerCollectibleDetection.prototype.____constructor(self, postPlayerCollectibleAdded, postPlayerCollectibleRemoved, moddedElementSets, runInNFrames)
     Feature.prototype.____constructor(self)
-    self.v = v
     self.postUseItemD4 = function(____, _collectibleType, _rng, player)
         self:updateCollectibleMapAndFire(player, nil)
         return nil
@@ -95,11 +94,12 @@ function PlayerCollectibleDetection.prototype.____constructor(self, postPlayerCo
         if difference > 0 then
             self:updateCollectibleMapAndFire(player, difference)
         elseif difference < 0 then
-            self:updateCollectibleMapAndFire(player, difference * -1)
+            self:updateCollectibleMapAndFire(player, -difference)
         elseif difference == 0 then
             self:checkActiveItemsChanged(player)
         end
     end
+    self.v = v
     self.featuresUsed = {ISCFeature.MODDED_ELEMENT_SETS, ISCFeature.RUN_IN_N_FRAMES}
     self.callbacksUsed = {{ModCallback.POST_USE_ITEM, self.postUseItemD4, {CollectibleType.D4}}}
     self.customCallbacksUsed = {{ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, self.entityTakeDmgPlayer}, {ModCallbackCustom.POST_ITEM_PICKUP, self.postItemPickup}, {ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED, self.postPEffectUpdateReordered}}

package/dist/classes/features/callbackLogic/PlayerReorderedCallbacks.d.ts

@@ -4,10 +4,17 @@ import type { PostPlayerRenderReordered } from "../../callbacks/PostPlayerRender
 import type { PostPlayerUpdateReordered } from "../../callbacks/PostPlayerUpdateReordered";
 import { Feature } from "../../private/Feature";
 interface QueueElement {
-    playerIndex: PlayerIndex;
-    renderOffset: Vector;
+    readonly playerIndex: PlayerIndex;
+    readonly renderOffset: Readonly<Vector>;
 }
 export declare class PlayerReorderedCallbacks extends Feature {
+    private readonly postPEffectUpdateReordered;
+    private readonly postPlayerRenderReordered;
+    private readonly postPlayerUpdateReordered;
+    private readonly postPEffectUpdate;
+    private readonly postPlayerUpdate;
+    private readonly postPlayerRender;
+    private readonly postGameStartedReorderedLast;
     v: {
         run: {
             postGameStartedFiredOnThisRun: boolean;
@@ -16,14 +23,7 @@ export declare class PlayerReorderedCallbacks extends Feature {
             postPlayerRenderQueue: QueueElement[];
         };
     };
-    private readonly postPEffectUpdateReordered;
-    private readonly postPlayerRenderReordered;
-    private readonly postPlayerUpdateReordered;
     constructor(postPEffectUpdateReordered: PostPEffectUpdateReordered, postPlayerRenderReordered: PostPlayerRenderReordered, postPlayerUpdateReordered: PostPlayerUpdateReordered);
-    private readonly postPEffectUpdate;
-    private readonly postPlayerUpdate;
-    private readonly postPlayerRender;
-    private readonly postGameStartedReorderedLast;
 }
 export {};
 //# sourceMappingURL=PlayerReorderedCallbacks.d.ts.map

package/dist/classes/features/callbackLogic/PlayerReorderedCallbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlayerReorderedCallbacks.d.ts","sourceRoot":"","sources":["../../../../src/classes/features/callbackLogic/PlayerReorderedCallbacks.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAC3F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAC3F,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,UAAU,YAAY;IACpB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB;AAYD,qBAAa,wBAAyB,SAAQ,OAAO;IACnC,CAAC;;;oCAPe,YAAY,EAAE;mCACf,YAAY,EAAE;mCACd,YAAY,EAAE;;MAKvB;IAEtB,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAA6B;IACxE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;IACtE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;gBAGpE,0BAA0B,EAAE,0BAA0B,EACtD,yBAAyB,EAAE,yBAAyB,EACpD,yBAAyB,EAAE,yBAAyB;IA+BtD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAWhC;IAGF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAW/B;IAGF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAW/B;IAGF,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAM3C;CACH"}
+{"version":3,"file":"PlayerReorderedCallbacks.d.ts","sourceRoot":"","sources":["../../../../src/classes/features/callbackLogic/PlayerReorderedCallbacks.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAC3F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AAC3F,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,UAAU,YAAY;IACpB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CACzC;AAYD,qBAAa,wBAAyB,SAAQ,OAAO;IACnD,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAA6B;IACxE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;IACtE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAA4B;IAGtE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAWhC;IAGF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAW/B;IAGF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAc/B;IAGF,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAM3C;IAEc,CAAC;;;oCAjEe,YAAY,EAAE;mCACf,YAAY,EAAE;mCACd,YAAY,EAAE;;MA+DvB;gBAGpB,0BAA0B,EAAE,0BAA0B,EACtD,yBAAyB,EAAE,yBAAyB,EACpD,yBAAyB,EAAE,yBAAyB;CA6BvD"}

package/dist/classes/features/callbackLogic/PlayerReorderedCallbacks.js

@@ -1,16 +1,13 @@
-"use strict";
 // This handles logic for the following callbacks:
 // - POST_PEFFECT_UPDATE_REORDERED
 // - POST_PLAYER_RENDER_REORDERED
 // - POST_PLAYER_UPDATE_REORDERED
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayerReorderedCallbacks = void 0;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const constants_1 = require("../../../core/constants");
-const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
-const array_1 = require("../../../functions/array");
-const playerIndex_1 = require("../../../functions/playerIndex");
-const Feature_1 = require("../../private/Feature");
+import { ModCallback } from "isaac-typescript-definitions";
+import { VectorZero } from "../../../core/constants";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
+import { emptyArray } from "../../../functions/array";
+import { getPlayerFromIndex, getPlayerIndex, } from "../../../functions/playerIndex";
+import { Feature } from "../../private/Feature";
 const v = {
     run: {
         postGameStartedFiredOnThisRun: false,
@@ -19,34 +16,10 @@ const v = {
         postPlayerRenderQueue: [],
     },
 };
-class PlayerReorderedCallbacks extends Feature_1.Feature {
-    v = v;
+export class PlayerReorderedCallbacks extends Feature {
     postPEffectUpdateReordered;
     postPlayerRenderReordered;
     postPlayerUpdateReordered;
-    constructor(postPEffectUpdateReordered, postPlayerRenderReordered, postPlayerUpdateReordered) {
-        super();
-        this.callbacksUsed = [
-            // 4
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            [isaac_typescript_definitions_1.ModCallback.POST_PEFFECT_UPDATE, this.postPEffectUpdate],
-            // 31
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            [isaac_typescript_definitions_1.ModCallback.POST_PLAYER_UPDATE, this.postPlayerUpdate],
-            // 32
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            [isaac_typescript_definitions_1.ModCallback.POST_PLAYER_RENDER, this.postPlayerRender],
-        ];
-        this.customCallbacksUsed = [
-            [
-                ModCallbackCustom_1.ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST,
-                this.postGameStartedReorderedLast,
-            ],
-        ];
-        this.postPEffectUpdateReordered = postPEffectUpdateReordered;
-        this.postPlayerRenderReordered = postPlayerRenderReordered;
-        this.postPlayerUpdateReordered = postPlayerUpdateReordered;
-    }
     // ModCallback.POST_PEFFECT_UPDATE (4)
     postPEffectUpdate = (player) => {
         if (v.run.postGameStartedFiredOnThisRun) {
@@ -54,10 +27,10 @@ class PlayerReorderedCallbacks extends Feature_1.Feature {
         }
         else {
             // Defer callback execution until the `POST_GAME_STARTED` callback fires.
-            const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+            const playerIndex = getPlayerIndex(player);
             v.run.postPEffectUpdateQueue.push({
                 playerIndex,
-                renderOffset: constants_1.VectorZero,
+                renderOffset: VectorZero,
             });
         }
     };
@@ -68,10 +41,10 @@ class PlayerReorderedCallbacks extends Feature_1.Feature {
         }
         else {
             // Defer callback execution until the `POST_GAME_STARTED` callback fires.
-            const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+            const playerIndex = getPlayerIndex(player);
             v.run.postPlayerUpdateQueue.push({
                 playerIndex,
-                renderOffset: constants_1.VectorZero,
+                renderOffset: VectorZero,
             });
         }
     };
@@ -82,8 +55,11 @@ class PlayerReorderedCallbacks extends Feature_1.Feature {
         }
         else {
             // Defer callback execution until the `POST_GAME_STARTED` callback fires.
-            const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
-            v.run.postPlayerRenderQueue.push({ playerIndex, renderOffset });
+            const playerIndex = getPlayerIndex(player);
+            v.run.postPlayerRenderQueue.push({
+                playerIndex,
+                renderOffset,
+            });
         }
     };
     // ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST
@@ -93,17 +69,40 @@ class PlayerReorderedCallbacks extends Feature_1.Feature {
         dequeue(v.run.postPlayerUpdateQueue, this.postPlayerUpdateReordered.fire);
         dequeue(v.run.postPlayerRenderQueue, this.postPlayerRenderReordered.fire);
     };
+    v = v;
+    constructor(postPEffectUpdateReordered, postPlayerRenderReordered, postPlayerUpdateReordered) {
+        super();
+        this.callbacksUsed = [
+            // 4
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            [ModCallback.POST_PEFFECT_UPDATE, this.postPEffectUpdate],
+            // 31
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            [ModCallback.POST_PLAYER_UPDATE, this.postPlayerUpdate],
+            // 32
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            [ModCallback.POST_PLAYER_RENDER, this.postPlayerRender],
+        ];
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST,
+                this.postGameStartedReorderedLast,
+            ],
+        ];
+        this.postPEffectUpdateReordered = postPEffectUpdateReordered;
+        this.postPlayerRenderReordered = postPlayerRenderReordered;
+        this.postPlayerUpdateReordered = postPlayerUpdateReordered;
+    }
 }
-exports.PlayerReorderedCallbacks = PlayerReorderedCallbacks;
 function dequeue(
 // eslint-disable-next-line complete/prefer-readonly-parameter-types
 queue, fireFunc) {
     for (const element of queue) {
         const { playerIndex, renderOffset } = element;
-        const player = (0, playerIndex_1.getPlayerFromIndex)(playerIndex);
+        const player = getPlayerFromIndex(playerIndex);
         if (player !== undefined) {
             fireFunc(player, renderOffset);
         }
     }
-    (0, array_1.emptyArray)(queue);
+    emptyArray(queue);
 }

package/dist/classes/features/callbackLogic/PlayerReorderedCallbacks.lua

@@ -34,7 +34,6 @@ PlayerReorderedCallbacks.name = "PlayerReorderedCallbacks"
 __TS__ClassExtends(PlayerReorderedCallbacks, Feature)
 function PlayerReorderedCallbacks.prototype.____constructor(self, postPEffectUpdateReordered, postPlayerRenderReordered, postPlayerUpdateReordered)
     Feature.prototype.____constructor(self)
-    self.v = v
     self.postPEffectUpdate = function(____, player)
         if v.run.postGameStartedFiredOnThisRun then
             self.postPEffectUpdateReordered:fire(player)
@@ -68,6 +67,7 @@ function PlayerReorderedCallbacks.prototype.____constructor(self, postPEffectUpd
         dequeue(nil, v.run.postPlayerUpdateQueue, self.postPlayerUpdateReordered.fire)
         dequeue(nil, v.run.postPlayerRenderQueue, self.postPlayerRenderReordered.fire)
     end
+    self.v = v
     self.callbacksUsed = {{ModCallback.POST_PEFFECT_UPDATE, self.postPEffectUpdate}, {ModCallback.POST_PLAYER_UPDATE, self.postPlayerUpdate}, {ModCallback.POST_PLAYER_RENDER, self.postPlayerRender}}
     self.customCallbacksUsed = {{ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST, self.postGameStartedReorderedLast}}
     self.postPEffectUpdateReordered = postPEffectUpdateReordered

package/dist/classes/features/callbackLogic/SlotDestroyedDetection.d.ts

@@ -2,18 +2,18 @@ import type { PostSlotDestroyed } from "../../callbacks/PostSlotDestroyed";
 import { Feature } from "../../private/Feature";
 import type { RoomHistory } from "../other/RoomHistory";
 export declare class SlotDestroyedDetection extends Feature {
+    private readonly postSlotDestroyed;
+    private readonly roomHistory;
+    private readonly postEntityRemoveSlot;
+    private readonly postSlotUpdate;
     v: {
         room: {
             destroyedSlotSet: Set<PtrHash>;
         };
     };
-    private readonly postSlotDestroyed;
-    private readonly roomHistory;
     constructor(postSlotDestroyed: PostSlotDestroyed, roomHistory: RoomHistory);
-    private readonly postEntityRemoveSlot;
     private postEntityRemoveSlotMachine;
     private postEntityRemoveBeggar;
-    private readonly postSlotUpdate;
     /**
      * Slots normally have an entity collision class of `EntityCollisionClass.ALL` (4) and a grid
      * collision class of `EntityGridCollisionClass.NONE` (0). When they are destroyed with a bomb,

package/dist/classes/features/callbackLogic/SlotDestroyedDetection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SlotDestroyedDetection.d.ts","sourceRoot":"","sources":["../../../../src/classes/features/callbackLogic/SlotDestroyedDetection.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAQxD,qBAAa,sBAAuB,SAAQ,OAAO;IACjC,CAAC;;;;MAAK;IAEtB,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;gBAE9B,iBAAiB,EAAE,iBAAiB,EAAE,WAAW,EAAE,WAAW;IAwB1E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAcnC;IAEF,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAS7B;IAEF;;;;;OAKG;IACH,OAAO,CAAC,gCAAgC;CAOzC"}
+{"version":3,"file":"SlotDestroyedDetection.d.ts","sourceRoot":"","sources":["../../../../src/classes/features/callbackLogic/SlotDestroyedDetection.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAQxD,qBAAa,sBAAuB,SAAQ,OAAO;IACjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAI1C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAcnC;IAGF,OAAO,CAAC,QAAQ,CAAC,cAAc,CAS7B;IAEc,CAAC;;;;MAAK;gBAEV,iBAAiB,EAAE,iBAAiB,EAAE,WAAW,EAAE,WAAW;IAsB1E,OAAO,CAAC,2BAA2B;IAInC,OAAO,CAAC,sBAAsB;IAU9B;;;;;OAKG;IACH,OAAO,CAAC,gCAAgC;CASzC"}

package/dist/classes/features/callbackLogic/SlotDestroyedDetection.js

@@ -1,7 +1,4 @@
-"use strict";
 // For machines, destruction is detected in two ways:
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlotDestroyedDetection = void 0;
 // 1) The main way is via a change in grid entity class. This happens when the machine is destroyed
 //    with a bomb, for example. For this case, the slot will remain until the player leaves the
 //    room.
@@ -10,65 +7,36 @@ exports.SlotDestroyedDetection = void 0;
 // For beggars, destruction is detected by monitoring for when a beggar despawns mid-room. Beggars
 // that are paying out with a collectible will always be playing the "Teleport" animation.
 // Otherwise, the beggar won't be playing any animation in particular.
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const ISCFeature_1 = require("../../../enums/ISCFeature");
-const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
-const SlotDestructionType_1 = require("../../../enums/SlotDestructionType");
-const slots_1 = require("../../../functions/slots");
-const Feature_1 = require("../../private/Feature");
+import { EntityGridCollisionClass, EntityType, ModCallback, } from "isaac-typescript-definitions";
+import { ISCFeature } from "../../../enums/ISCFeature";
+import { ModCallbackCustom } from "../../../enums/ModCallbackCustom";
+import { SlotDestructionType } from "../../../enums/SlotDestructionType";
+import { isSlotMachine } from "../../../functions/slots";
+import { Feature } from "../../private/Feature";
 const v = {
     room: {
         destroyedSlotSet: new Set(),
     },
 };
-class SlotDestroyedDetection extends Feature_1.Feature {
-    v = v;
+export class SlotDestroyedDetection extends Feature {
     postSlotDestroyed;
     roomHistory;
-    constructor(postSlotDestroyed, roomHistory) {
-        super();
-        this.featuresUsed = [ISCFeature_1.ISCFeature.ROOM_HISTORY];
-        this.callbacksUsed = [
-            // 67
-            [
-                isaac_typescript_definitions_1.ModCallback.POST_ENTITY_REMOVE,
-                this.postEntityRemoveSlot,
-                [isaac_typescript_definitions_1.EntityType.SLOT],
-            ],
-        ];
-        this.customCallbacksUsed = [
-            [ModCallbackCustom_1.ModCallbackCustom.POST_SLOT_UPDATE, this.postSlotUpdate],
-        ];
-        this.postSlotDestroyed = postSlotDestroyed;
-        this.roomHistory = roomHistory;
-    }
     // ModCallback.POST_ENTITY_REMOVE (67)
     // EntityType.SLOT (6)
     postEntityRemoveSlot = (entity) => {
-        const slot = entity;
         // The `POST_ENTITY_REMOVE` callback will fire for slots that are naturally despawning as a
         // player leaves a room. We want to ignore all slots that despawn for this reason.
         if (this.roomHistory.isLeavingRoom()) {
             return;
         }
-        if ((0, slots_1.isSlotMachine)(slot)) {
+        const slot = entity;
+        if (isSlotMachine(slot)) {
             this.postEntityRemoveSlotMachine(slot);
         }
         else {
             this.postEntityRemoveBeggar(slot);
         }
     };
-    postEntityRemoveSlotMachine(slot) {
-        this.postSlotDestroyed.fire(slot, SlotDestructionType_1.SlotDestructionType.COLLECTIBLE_PAYOUT);
-    }
-    postEntityRemoveBeggar(slot) {
-        const sprite = slot.GetSprite();
-        const animation = sprite.GetAnimation();
-        const slotDestructionType = animation === "Teleport"
-            ? SlotDestructionType_1.SlotDestructionType.COLLECTIBLE_PAYOUT
-            : SlotDestructionType_1.SlotDestructionType.NORMAL;
-        this.postSlotDestroyed.fire(slot, slotDestructionType);
-    }
     // ModCallbackCustom.POST_SLOT_UPDATE
     postSlotUpdate = (slot) => {
         const ptrHash = GetPtrHash(slot);
@@ -78,6 +46,35 @@ class SlotDestroyedDetection extends Feature_1.Feature {
         }
         this.checkDestroyedFromCollisionClass(slot);
     };
+    v = v;
+    constructor(postSlotDestroyed, roomHistory) {
+        super();
+        this.featuresUsed = [ISCFeature.ROOM_HISTORY];
+        this.callbacksUsed = [
+            // 67
+            [
+                ModCallback.POST_ENTITY_REMOVE,
+                this.postEntityRemoveSlot,
+                [EntityType.SLOT],
+            ],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom.POST_SLOT_UPDATE, this.postSlotUpdate],
+        ];
+        this.postSlotDestroyed = postSlotDestroyed;
+        this.roomHistory = roomHistory;
+    }
+    postEntityRemoveSlotMachine(slot) {
+        this.postSlotDestroyed.fire(slot, SlotDestructionType.COLLECTIBLE_PAYOUT);
+    }
+    postEntityRemoveBeggar(slot) {
+        const sprite = slot.GetSprite();
+        const animation = sprite.GetAnimation();
+        const slotDestructionType = animation === "Teleport"
+            ? SlotDestructionType.COLLECTIBLE_PAYOUT
+            : SlotDestructionType.NORMAL;
+        this.postSlotDestroyed.fire(slot, slotDestructionType);
+    }
     /**
      * Slots normally have an entity collision class of `EntityCollisionClass.ALL` (4) and a grid
      * collision class of `EntityGridCollisionClass.NONE` (0). When they are destroyed with a bomb,
@@ -85,11 +82,11 @@ class SlotDestroyedDetection extends Feature_1.Feature {
      * `EntityGridCollisionClass.GROUND` (5).
      */
     checkDestroyedFromCollisionClass(slot) {
-        if (slot.GridCollisionClass === isaac_typescript_definitions_1.EntityGridCollisionClass.GROUND) {
-            const ptrHash = GetPtrHash(slot);
-            v.room.destroyedSlotSet.add(ptrHash);
-            this.postSlotDestroyed.fire(slot, SlotDestructionType_1.SlotDestructionType.NORMAL);
+        if (slot.GridCollisionClass !== EntityGridCollisionClass.GROUND) {
+            return;
         }
+        const ptrHash = GetPtrHash(slot);
+        v.room.destroyedSlotSet.add(ptrHash);
+        this.postSlotDestroyed.fire(slot, SlotDestructionType.NORMAL);
     }
 }
-exports.SlotDestroyedDetection = SlotDestroyedDetection;