isaacscript-common 84.0.1 → 84.1.1

package/dist/classes/callbacks/PostTearKill.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTearKill = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    room: {
+        firedSet: new Set(),
+    },
+};
+class PostTearKill extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 40
+            [isaac_typescript_definitions_1.ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
+            // 42
+            [isaac_typescript_definitions_1.ModCallback.PRE_TEAR_COLLISION, this.preTearCollision],
+            // 67
+            [isaac_typescript_definitions_1.ModCallback.POST_ENTITY_REMOVE, this.postEntityRemove],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTear;
+    // ModCallback.POST_PROJECTILE_UPDATE (40)
+    postTearUpdate = (tear) => {
+        const ptrHash = GetPtrHash(tear);
+        if (tear.CollidesWithGrid() || tear.IsDead()) {
+            v.room.firedSet.add(ptrHash);
+        }
+    };
+    // ModCallback.PRE_TEAR_COLLISION (42)
+    preTearCollision = (tear) => {
+        const ptrHash = GetPtrHash(tear);
+        v.room.firedSet.add(ptrHash);
+        return undefined;
+    };
+    // ModCallback.POST_ENTITY_REMOVE (67)
+    postEntityRemove = (entity) => {
+        const tear = entity.ToTear();
+        if (tear === undefined) {
+            return;
+        }
+        const ptrHash = GetPtrHash(tear);
+        if (v.room.firedSet.has(ptrHash)) {
+            v.room.firedSet.add(ptrHash);
+            this.fire(tear);
+        }
+    };
+}
+exports.PostTearKill = PostTearKill;

package/dist/classes/callbacks/PostTearRenderFilter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTearRenderFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostTearRenderFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 41
+            [isaac_typescript_definitions_1.ModCallback.POST_TEAR_RENDER, this.postTearRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTear;
+    // ModCallback.POST_TEAR_RENDER (41)
+    postTearRender = (tear, renderOffset) => {
+        this.fire(tear, renderOffset);
+    };
+}
+exports.PostTearRenderFilter = PostTearRenderFilter;

package/dist/classes/callbacks/PostTearUpdateFilter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTearUpdateFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostTearUpdateFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 40
+            [isaac_typescript_definitions_1.ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTear;
+    // ModCallback.POST_TEAR_UPDATE (40)
+    postTearUpdate = (tear) => {
+        this.fire(tear);
+    };
+}
+exports.PostTearUpdateFilter = PostTearUpdateFilter;

package/dist/classes/callbacks/PostTransformation.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTransformation = void 0;
+const cachedEnumValues_1 = require("../../arrays/cachedEnumValues");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        // We cannot use a nested `DefaultMap` here.
+        playersTransformationsMap: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+};
+class PostTransformation extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_player, playerForm] = fireArgs;
+        const [callbackPlayerForm] = optionalArgs;
+        return (callbackPlayerForm === undefined || callbackPlayerForm === playerForm);
+    };
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        const playerTransformationsMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersTransformationsMap, player);
+        for (const playerForm of cachedEnumValues_1.PLAYER_FORM_VALUES) {
+            const hasForm = player.HasPlayerForm(playerForm);
+            let storedForm = playerTransformationsMap.get(playerForm);
+            if (storedForm === undefined) {
+                storedForm = false;
+            }
+            if (hasForm !== storedForm) {
+                playerTransformationsMap.set(playerForm, hasForm);
+                this.fire(player, playerForm, hasForm);
+            }
+        }
+    };
+}
+exports.PostTransformation = PostTransformation;

package/dist/classes/callbacks/PostTrinketBreak.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTrinketBreak = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const shouldFire_1 = require("../../shouldFire");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const TRINKETS_THAT_CAN_BREAK = [
+    isaac_typescript_definitions_1.TrinketType.WISH_BONE,
+    isaac_typescript_definitions_1.TrinketType.WALNUT,
+];
+const v = {
+    run: {
+        // We cannot use a nested `DefaultMap` here.
+        playersTrinketMap: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+};
+class PostTrinketBreak extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTrinketType;
+    // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
+    entityTakeDmgPlayer = (player, _amount, _damageFlags, _source, _countdownFrames) => {
+        const trinketMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersTrinketMap, player);
+        for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
+            const numTrinketsHeld = player.GetTrinketMultiplier(trinketType);
+            let oldNumTrinketsHeld = trinketMap.get(trinketType);
+            if (oldNumTrinketsHeld === undefined) {
+                oldNumTrinketsHeld = 0;
+            }
+            if (numTrinketsHeld >= oldNumTrinketsHeld) {
+                continue;
+            }
+            trinketMap.set(trinketType, numTrinketsHeld);
+            // Ensure that the trinket was not dropped on the ground.
+            const numTrinketsOnGround = Isaac.CountEntities(undefined, isaac_typescript_definitions_1.EntityType.PICKUP, isaac_typescript_definitions_1.PickupVariant.TRINKET, trinketType);
+            if (numTrinketsOnGround > 0) {
+                continue;
+            }
+            this.fire(player, trinketType);
+        }
+        return undefined;
+    };
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        // On every frame, keep track of how many trinkets we have.
+        const trinketMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersTrinketMap, player);
+        for (const trinketType of TRINKETS_THAT_CAN_BREAK) {
+            const numTrinkets = player.GetTrinketMultiplier(trinketType);
+            if (numTrinkets === 0) {
+                trinketMap.delete(trinketType);
+            }
+            else {
+                trinketMap.set(trinketType, numTrinkets);
+            }
+        }
+    };
+}
+exports.PostTrinketBreak = PostTrinketBreak;

package/dist/classes/callbacks/PostUsePillFilter.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostUsePillFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const PocketItemType_1 = require("../../enums/PocketItemType");
+const pills_1 = require("../../functions/pills");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const pocketItems_1 = require("../../functions/pocketItems");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        pillColorToPillEffect: new Map(),
+        playerPocketItems: new Map(),
+    },
+};
+/**
+ * The vanilla `POST_USE_PILL` callback does not pass the `PillColor` of the used pill. We can
+ * resolve pill effect to pill color by using the `ItemPool.GetPillEffect` method. However, this
+ * does not tell us whether the pill used was a horse pill. Thus, we must keep track of the pills
+ * that the player is holding on every frame to account for this.
+ *
+ * In some cases, pills can be used without a corresponding pocket item slot, like in the case of
+ * the reverse Temperance card. In this case, we fall back to looking up the color using the
+ * `ItemPool.GetPillEffect` method.
+ */
+class PostUsePillFilter extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 10
+            [isaac_typescript_definitions_1.ModCallback.POST_USE_PILL, this.postUsePill],
+        ];
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    // ModCallback.POST_USE_PILL (10)
+    postUsePill = (pillEffect, player, useFlags) => {
+        const pillColor = this.getPillColorOfCurrentlyUsedPill(player, pillEffect);
+        this.fire(pillEffect, pillColor, player, useFlags);
+    };
+    getPillColorOfCurrentlyUsedPill(player, pillEffect) {
+        // First, check to see if the pocket items have changed in some way, which indicates that a real
+        // pill was used.
+        const oldPocketItems = (0, playerDataStructures_1.mapGetPlayer)(v.run.playerPocketItems, player);
+        if (oldPocketItems !== undefined) {
+            const pocketItems = (0, pocketItems_1.getPocketItems)(player);
+            if (!(0, pocketItems_1.pocketItemsEquals)(oldPocketItems, pocketItems)) {
+                const oldPocketItemSlot1 = oldPocketItems.find((pocketItem) => pocketItem.slot === isaac_typescript_definitions_1.PocketItemSlot.SLOT_1);
+                if (oldPocketItemSlot1 !== undefined &&
+                    oldPocketItemSlot1.type === PocketItemType_1.PocketItemType.PILL) {
+                    return oldPocketItemSlot1.subType;
+                }
+            }
+        }
+        // At this point, either the pocket items have not changed, or we were not able to find a pill
+        // in the old pocket items. The player might be using a reverse Temperance card, so we revert to
+        // assuming that a non-horse pill was used and look up the color using the
+        // `ItemPool.GetPillEffect` method.
+        return (0, pills_1.getPillColorFromEffect)(pillEffect);
+    }
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        this.updateCurrentPocketItems(player);
+    };
+    updateCurrentPocketItems(player) {
+        const pocketItems = (0, pocketItems_1.getPocketItems)(player);
+        (0, playerDataStructures_1.mapSetPlayer)(v.run.playerPocketItems, player, pocketItems);
+    }
+}
+exports.PostUsePillFilter = PostUsePillFilter;

package/dist/classes/callbacks/PreBerserkDeath.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreBerserkDeath = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const playerIndex_1 = require("../../functions/playerIndex");
+const players_1 = require("../../functions/players");
+const revive_1 = require("../../functions/revive");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreBerserkDeath extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        // This callback should not trigger for the Strawman Keeper and other players that are "child"
+        // players.
+        if ((0, playerIndex_1.isChildPlayer)(player)) {
+            return;
+        }
+        const effects = player.GetEffects();
+        const berserkEffect = effects.GetCollectibleEffect(isaac_typescript_definitions_1.CollectibleType.BERSERK);
+        const numHitsRemaining = (0, players_1.getPlayerNumHitsRemaining)(player);
+        // If the Berserk effect will end on the next frame and we have no hearts left.
+        if (berserkEffect !== undefined &&
+            berserkEffect.Cooldown === 1 &&
+            numHitsRemaining === 0 &&
+            !(0, revive_1.willPlayerRevive)(player)) {
+            this.fire(player);
+        }
+    };
+}
+exports.PreBerserkDeath = PreBerserkDeath;

package/dist/classes/callbacks/PreBombCollisionFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreBombCollisionFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreBombCollisionFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 60
+            [isaac_typescript_definitions_1.ModCallback.PRE_BOMB_COLLISION, this.preBombCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireBomb;
+    // ModCallback.PRE_BOMB_COLLISION (60)
+    preBombCollision = (bomb, collider, low) => this.fire(bomb, collider, low);
+}
+exports.PreBombCollisionFilter = PreBombCollisionFilter;

package/dist/classes/callbacks/PreCustomRevive.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreCustomRevive = void 0;
+const ISCFeature_1 = require("../../enums/ISCFeature");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreCustomRevive extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.CUSTOM_REVIVE];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+}
+exports.PreCustomRevive = PreCustomRevive;

package/dist/classes/callbacks/PreEntitySpawnFilter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreEntitySpawnFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreEntitySpawnFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 24
+            [isaac_typescript_definitions_1.ModCallback.PRE_ENTITY_SPAWN, this.preEntitySpawn],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [entityType, variant, subType] = fireArgs;
+        const [callbackEntityType, callbackVariant, callbackSubType] = optionalArgs;
+        return ((callbackEntityType === undefined || callbackEntityType === entityType) &&
+            (callbackVariant === undefined || callbackVariant === variant) &&
+            (callbackSubType === undefined || callbackSubType === subType));
+    };
+    // ModCallback.PRE_ENTITY_SPAWN (24)
+    preEntitySpawn = (entityType, variant, subType, position, velocity, spawner, initSeed) => this.fire(entityType, variant, subType, position, velocity, spawner, initSeed);
+}
+exports.PreEntitySpawnFilter = PreEntitySpawnFilter;

package/dist/classes/callbacks/PreFamiliarCollisionFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreFamiliarCollisionFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreFamiliarCollisionFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 26
+            [isaac_typescript_definitions_1.ModCallback.PRE_FAMILIAR_COLLISION, this.preFamiliarCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireFamiliar;
+    // ModCallback.PRE_FAMILIAR_COLLISION (26)
+    preFamiliarCollision = (familiar, collider, low) => this.fire(familiar, collider, low);
+}
+exports.PreFamiliarCollisionFilter = PreFamiliarCollisionFilter;

package/dist/classes/callbacks/PreGetPedestal.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreGetPedestal = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreGetPedestal extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 38
+            [
+                isaac_typescript_definitions_1.ModCallback.PRE_PICKUP_COLLISION,
+                this.prePickupCollision,
+                [isaac_typescript_definitions_1.PickupVariant.COLLECTIBLE],
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallback.PRE_PICKUP_COLLISION (35)
+    prePickupCollision = (pickup, collider, _low) => {
+        const collectible = pickup;
+        if (collectible.SubType === isaac_typescript_definitions_1.CollectibleType.NULL) {
+            return undefined;
+        }
+        const player = collider.ToPlayer();
+        if (player === undefined) {
+            return undefined;
+        }
+        const numCoins = player.GetNumCoins();
+        if (collectible.Price > numCoins) {
+            return undefined;
+        }
+        // Collectibles have a special variable to prevent them from being picked up for a certain time.
+        // Players have special variable to prevent them from picking up a collectible for a certain
+        // time.
+        if (collectible.Wait > 0 || player.ItemHoldCooldown > 0) {
+            return undefined;
+        }
+        if (player.IsHoldingItem()) {
+            return undefined;
+        }
+        return this.fire(player, collectible);
+    };
+}
+exports.PreGetPedestal = PreGetPedestal;

package/dist/classes/callbacks/PreItemPickup.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreItemPickup = void 0;
+const ISCFeature_1 = require("../../enums/ISCFeature");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreItemPickup extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.ITEM_PICKUP_DETECTION];
+    }
+    shouldFire = shouldFire_1.shouldFireItemPickup;
+}
+exports.PreItemPickup = PreItemPickup;

package/dist/classes/callbacks/PreKnifeCollisionFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreKnifeCollisionFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreKnifeCollisionFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 53
+            [isaac_typescript_definitions_1.ModCallback.PRE_KNIFE_COLLISION, this.preKnifeCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireKnife;
+    // ModCallback.PRE_KNIFE_COLLISION (53)
+    preKnifeCollision = (knife, collider, low) => this.fire(knife, collider, low);
+}
+exports.PreKnifeCollisionFilter = PreKnifeCollisionFilter;

package/dist/classes/callbacks/PreNPCCollisionFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreNPCCollisionFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreNPCCollisionFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 30
+            [isaac_typescript_definitions_1.ModCallback.PRE_NPC_COLLISION, this.preNPCCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireNPC;
+    // ModCallback.PRE_NPC_COLLISION (30)
+    preNPCCollision = (npc, collider, low) => this.fire(npc, collider, low);
+}
+exports.PreNPCCollisionFilter = PreNPCCollisionFilter;

package/dist/classes/callbacks/PreNPCUpdateFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreNPCUpdateFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreNPCUpdateFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 69
+            [isaac_typescript_definitions_1.ModCallback.PRE_NPC_UPDATE, this.preNPCUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireNPC;
+    // ModCallback.PRE_NPC_UPDATE (69)
+    preNPCUpdate = (npc) => this.fire(npc);
+}
+exports.PreNPCUpdateFilter = PreNPCUpdateFilter;

package/dist/classes/callbacks/PreNewLevel.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreNewLevel = void 0;
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const sprites_1 = require("../../functions/sprites");
+const stage_1 = require("../../functions/stage");
+const ReadonlySet_1 = require("../../types/ReadonlySet");
+const CustomCallback_1 = require("../private/CustomCallback");
+const TRAVELING_TO_NEXT_FLOOR_ANIMATIONS = new ReadonlySet_1.ReadonlySet([
+    "Trapdoor",
+    "LightTravel",
+]);
+const v = {
+    run: {
+        firedOnStage: null,
+    },
+};
+class PreNewLevel extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PLAYER_RENDER_REORDERED,
+                this.postPlayerRenderReordered,
+            ],
+        ];
+    }
+    // ModCallbackCustom.POST_PLAYER_RENDER_REORDERED
+    postPlayerRenderReordered = (player) => {
+        const effectiveStage = (0, stage_1.getEffectiveStage)();
+        if (effectiveStage === v.run.firedOnStage) {
+            return;
+        }
+        const sprite = player.GetSprite();
+        const animation = sprite.GetAnimation();
+        if (!TRAVELING_TO_NEXT_FLOOR_ANIMATIONS.has(animation)) {
+            return;
+        }
+        // We can't use the `Sprite.IsFinished` method to detect when we are at the end of the animation
+        // because the player will stop rendering at that point. Thus, revert to checking for the final
+        // frame manually.
+        const frame = sprite.GetFrame();
+        const finalFrame = (0, sprites_1.getLastFrameOfAnimation)(sprite);
+        if (frame === finalFrame) {
+            v.run.firedOnStage = effectiveStage;
+            this.fire(player);
+        }
+    };
+}
+exports.PreNewLevel = PreNewLevel;

package/dist/classes/callbacks/PreProjectileCollisionFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreProjectileCollisionFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreProjectileCollisionFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 46
+            [isaac_typescript_definitions_1.ModCallback.PRE_PROJECTILE_COLLISION, this.preProjectileCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireProjectile;
+    // ModCallback.PRE_PROJECTILE_COLLISION (46)
+    preProjectileCollision = (projectile, collider, low) => this.fire(projectile, collider, low);
+}
+exports.PreProjectileCollisionFilter = PreProjectileCollisionFilter;

package/dist/classes/callbacks/PreRoomEntitySpawnFilter.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreRoomEntitySpawnFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreRoomEntitySpawnFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 71
+            [isaac_typescript_definitions_1.ModCallback.PRE_ROOM_ENTITY_SPAWN, this.preRoomEntitySpawn],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [entityTypeOrGridEntityXMLType, variant, subType] = fireArgs;
+        const [callbackEntityTypeOrGridEntityXMLType, callbackVariant, callbackSubType,] = optionalArgs;
+        return ((callbackEntityTypeOrGridEntityXMLType === undefined ||
+            callbackEntityTypeOrGridEntityXMLType ===
+                entityTypeOrGridEntityXMLType) &&
+            (callbackVariant === undefined || callbackVariant === variant) &&
+            (callbackSubType === undefined || callbackSubType === subType));
+    };
+    // ModCallback.PRE_ROOM_ENTITY_SPAWN (71)
+    preRoomEntitySpawn = (entityTypeOrGridEntityXMLType, variant, subType, gridIndex, initSeed) => this.fire(entityTypeOrGridEntityXMLType, variant, subType, gridIndex, initSeed);
+}
+exports.PreRoomEntitySpawnFilter = PreRoomEntitySpawnFilter;

package/dist/classes/callbacks/PreTearCollisionFilter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreTearCollisionFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PreTearCollisionFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 42
+            [isaac_typescript_definitions_1.ModCallback.PRE_TEAR_COLLISION, this.preTearCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTear;
+    // ModCallback.PRE_TEAR_COLLISION (42)
+    preTearCollision = (tear, collider, low) => this.fire(tear, collider, low);
+}
+exports.PreTearCollisionFilter = PreTearCollisionFilter;