isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/callbacks/PostProjectileKill.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostProjectileKill = 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 PostProjectileKill extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 44
+            [isaac_typescript_definitions_1.ModCallback.POST_PROJECTILE_UPDATE, this.postProjectileUpdate],
+            // 46
+            [isaac_typescript_definitions_1.ModCallback.PRE_PROJECTILE_COLLISION, this.preProjectileCollision],
+            // 67
+            [isaac_typescript_definitions_1.ModCallback.POST_ENTITY_REMOVE, this.postEntityRemove],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireProjectile;
+    // ModCallback.POST_PROJECTILE_UPDATE (44)
+    postProjectileUpdate = (projectile) => {
+        const ptrHash = GetPtrHash(projectile);
+        if (projectile.CollidesWithGrid() || projectile.IsDead()) {
+            v.room.firedSet.add(ptrHash);
+        }
+    };
+    // ModCallback.PRE_PROJECTILE_COLLISION (46)
+    preProjectileCollision = (projectile) => {
+        const ptrHash = GetPtrHash(projectile);
+        v.room.firedSet.add(ptrHash);
+        return undefined;
+    };
+    // ModCallback.POST_ENTITY_REMOVE (67)
+    postEntityRemove = (entity) => {
+        const projectile = entity.ToProjectile();
+        if (projectile === undefined) {
+            return;
+        }
+        const ptrHash = GetPtrHash(projectile);
+        if (v.room.firedSet.has(ptrHash)) {
+            v.room.firedSet.add(ptrHash);
+            this.fire(projectile);
+        }
+    };
+}
+exports.PostProjectileKill = PostProjectileKill;

package/dist/classes/callbacks/PostProjectileRenderFilter.js

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

package/dist/classes/callbacks/PostProjectileUpdateFilter.js

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

package/dist/classes/callbacks/PostPurchase.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPurchase = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../core/cachedClasses");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const entitiesSpecific_1 = require("../../functions/entitiesSpecific");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    room: {
+        playersHoldingItemOnLastFrameMap: new DefaultMap_1.DefaultMap(false),
+        playersUsedItemOnFrame: new DefaultMap_1.DefaultMap(0),
+    },
+};
+class PostPurchase extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 3
+            [isaac_typescript_definitions_1.ModCallback.POST_USE_ITEM, this.postUseItem],
+            // 5
+            [isaac_typescript_definitions_1.ModCallback.POST_USE_CARD, this.postUseCard],
+            // 10
+            [isaac_typescript_definitions_1.ModCallback.POST_USE_PILL, this.postUsePill],
+        ];
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_player, pickup] = fireArgs;
+        const [callbackPickupVariant, callbackPickupSubType] = optionalArgs;
+        return ((callbackPickupVariant === undefined ||
+            callbackPickupVariant === pickup.Variant) &&
+            (callbackPickupSubType === undefined ||
+                callbackPickupSubType === pickup.SubType));
+    };
+    // ModCallback.POST_USE_ITEM (3)
+    postUseItem = (_collectibleType, _rng, player) => {
+        markUsedItemOnThisFrame(player);
+        return undefined;
+    };
+    // ModCallback.POST_USE_CARD (5)
+    postUseCard = (_cardType, player) => {
+        markUsedItemOnThisFrame(player);
+        return undefined;
+    };
+    // ModCallback.POST_USE_PILL (10)
+    postUsePill = (_pillEffect, player) => {
+        markUsedItemOnThisFrame(player);
+        return undefined;
+    };
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        const isHoldingItem = player.IsHoldingItem();
+        const wasHoldingItemOnLastFrame = (0, playerDataStructures_1.defaultMapGetPlayer)(v.room.playersHoldingItemOnLastFrameMap, player);
+        (0, playerDataStructures_1.mapSetPlayer)(v.room.playersHoldingItemOnLastFrameMap, player, isHoldingItem);
+        // Assume that if the player did not use an active item, card, or pill recently, then they
+        // purchased an item.
+        if (!wasHoldingItemOnLastFrame &&
+            isHoldingItem &&
+            !this.playerUsedItemRecently(player)) {
+            this.playerPickedUpNewItem(player);
+        }
+    };
+    playerUsedItemRecently(player) {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const usedCollectibleOnFrame = (0, playerDataStructures_1.defaultMapGetPlayer)(v.room.playersUsedItemOnFrame, player);
+        return (gameFrameCount === usedCollectibleOnFrame ||
+            gameFrameCount === usedCollectibleOnFrame + 1);
+    }
+    playerPickedUpNewItem(player) {
+        const pickups = (0, entitiesSpecific_1.getPickups)();
+        const disappearingPickup = pickups.find((pickup) => !pickup.Exists() && pickup.Price !== 0);
+        if (disappearingPickup !== undefined) {
+            this.fire(player, disappearingPickup);
+        }
+    }
+}
+exports.PostPurchase = PostPurchase;
+function markUsedItemOnThisFrame(player) {
+    const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+    (0, playerDataStructures_1.mapSetPlayer)(v.room.playersUsedItemOnFrame, player, gameFrameCount);
+}

package/dist/classes/callbacks/PostRockRender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostRockRender = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntitiesSpecific_1 = require("../../functions/gridEntitiesSpecific");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostRockRender extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireRock;
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        for (const rock of (0, gridEntitiesSpecific_1.getRocks)()) {
+            this.fire(rock);
+        }
+    };
+}
+exports.PostRockRender = PostRockRender;

package/dist/classes/callbacks/PostRockUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostRockUpdate = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntitiesSpecific_1 = require("../../functions/gridEntitiesSpecific");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostRockUpdate extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireRock;
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        for (const rock of (0, gridEntitiesSpecific_1.getRocks)()) {
+            this.fire(rock);
+        }
+    };
+}
+exports.PostRockUpdate = PostRockUpdate;

package/dist/classes/callbacks/PostRoomClearChanged.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostRoomClearChanged = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../core/cachedClasses");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    room: {
+        cleared: false,
+    },
+};
+class PostRoomClearChanged extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [roomClear] = fireArgs;
+        const [callbackRoomClear] = optionalArgs;
+        return callbackRoomClear === undefined || callbackRoomClear === roomClear;
+    };
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomClear = room.IsClear();
+        if (roomClear !== v.room.cleared) {
+            v.room.cleared = roomClear;
+            this.fire(roomClear);
+        }
+    };
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomClear = room.IsClear();
+        v.room.cleared = roomClear;
+    };
+}
+exports.PostRoomClearChanged = PostRoomClearChanged;

package/dist/classes/callbacks/PostSacrifice.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostSacrifice = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../core/cachedClasses");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const flag_1 = require("../../functions/flag");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    level: {
+        numSacrifices: 0,
+    },
+};
+class PostSacrifice extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.ENTITY_TAKE_DMG
+    entityTakeDmgPlayer = (player, _amount, damageFlags, _source, _countdownFrames) => {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomType = room.GetType();
+        const isSpikeDamage = (0, flag_1.hasFlag)(damageFlags, isaac_typescript_definitions_1.DamageFlag.SPIKES);
+        if (roomType === isaac_typescript_definitions_1.RoomType.SACRIFICE && isSpikeDamage) {
+            v.level.numSacrifices++;
+            this.fire(player, v.level.numSacrifices);
+        }
+        return undefined;
+    };
+}
+exports.PostSacrifice = PostSacrifice;

package/dist/classes/callbacks/PostSlotAnimationChanged.js

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

package/dist/classes/callbacks/PostSlotCollision.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostSlotCollision = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const entityTypes_1 = require("../../functions/entityTypes");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostSlotCollision extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 33
+            [isaac_typescript_definitions_1.ModCallback.PRE_PLAYER_COLLISION, this.prePlayerCollision],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireSlot;
+    // ModCallback.PRE_PLAYER_COLLISION (33)
+    prePlayerCollision = (player, collider) => {
+        if ((0, entityTypes_1.isSlot)(collider)) {
+            this.fire(collider, player);
+        }
+        return undefined;
+    };
+}
+exports.PostSlotCollision = PostSlotCollision;

package/dist/classes/callbacks/PostSlotDestroyed.js

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

package/dist/classes/callbacks/PostSlotInit.js

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

package/dist/classes/callbacks/PostSlotRender.js

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

package/dist/classes/callbacks/PostSlotUpdate.js

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

package/dist/classes/callbacks/PostSpikesRender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostSpikesRender = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntitiesSpecific_1 = require("../../functions/gridEntitiesSpecific");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostSpikesRender extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireSpikes;
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        for (const spikes of (0, gridEntitiesSpecific_1.getSpikes)()) {
+            this.fire(spikes);
+        }
+    };
+}
+exports.PostSpikesRender = PostSpikesRender;

package/dist/classes/callbacks/PostSpikesUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostSpikesUpdate = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntitiesSpecific_1 = require("../../functions/gridEntitiesSpecific");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostSpikesUpdate extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireSpikes;
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        for (const spikes of (0, gridEntitiesSpecific_1.getSpikes)()) {
+            this.fire(spikes);
+        }
+    };
+}
+exports.PostSpikesUpdate = PostSpikesUpdate;

package/dist/classes/callbacks/PostTNTRender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTNTRender = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntitiesSpecific_1 = require("../../functions/gridEntitiesSpecific");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostTNTRender extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTNT;
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        for (const tnt of (0, gridEntitiesSpecific_1.getTNT)()) {
+            this.fire(tnt);
+        }
+    };
+}
+exports.PostTNTRender = PostTNTRender;

package/dist/classes/callbacks/PostTNTUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTNTUpdate = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const gridEntitiesSpecific_1 = require("../../functions/gridEntitiesSpecific");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostTNTUpdate extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireTNT;
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        for (const tnt of (0, gridEntitiesSpecific_1.getTNT)()) {
+            this.fire(tnt);
+        }
+    };
+}
+exports.PostTNTUpdate = PostTNTUpdate;

package/dist/classes/callbacks/PostTearInitFilter.js

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

package/dist/classes/callbacks/PostTearInitLate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTearInitLate = 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 PostTearInitLate extends CustomCallback_1.CustomCallback {
+    v = v;
+    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) => {
+        const ptrHash = GetPtrHash(tear);
+        if (!v.room.firedSet.has(ptrHash)) {
+            v.room.firedSet.add(ptrHash);
+            this.fire(tear);
+        }
+    };
+}
+exports.PostTearInitLate = PostTearInitLate;

package/dist/classes/callbacks/PostTearInitVeryLate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostTearInitVeryLate = 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 PostTearInitVeryLate extends CustomCallback_1.CustomCallback {
+    v = v;
+    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 callback fires on frame 1.
+        if (tear.FrameCount === 0) {
+            return;
+        }
+        const index = GetPtrHash(tear);
+        if (!v.room.firedSet.has(index)) {
+            v.room.firedSet.add(index);
+            this.fire(tear);
+        }
+    };
+}
+exports.PostTearInitVeryLate = PostTearInitVeryLate;