isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/callbacks/PostFirstFlip.js

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

package/dist/classes/callbacks/PostFlip.js

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

package/dist/classes/callbacks/PostGameEndFilter.js

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

package/dist/classes/callbacks/PostGameStartedReordered.js

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

package/dist/classes/callbacks/PostGameStartedReorderedLast.js

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

package/dist/classes/callbacks/PostGreedModeWave.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGreedModeWave = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../core/cachedClasses");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        currentGreedWave: 0,
+    },
+};
+class PostGreedModeWave extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        if (!cachedClasses_1.game.IsGreedMode()) {
+            return;
+        }
+        const level = cachedClasses_1.game.GetLevel();
+        const newWave = level.GreedModeWave;
+        const oldWave = v.run.currentGreedWave;
+        v.run.currentGreedWave = newWave;
+        if (newWave > oldWave) {
+            this.fire(oldWave, newWave);
+        }
+    };
+}
+exports.PostGreedModeWave = PostGreedModeWave;

package/dist/classes/callbacks/PostGridEntityBroken.js

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

package/dist/classes/callbacks/PostGridEntityCollision.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGridEntityCollision = void 0;
+const ISCFeature_1 = require("../../enums/ISCFeature");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostGridEntityCollision extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.GRID_ENTITY_COLLISION_DETECTION];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [gridEntity, entity] = fireArgs;
+        const [callbackGridEntityType, callbackGridEntityVariant, callbackEntityType, callbackEntityVariant, callbackEntitySubType,] = optionalArgs;
+        const gridEntityType = gridEntity.GetType();
+        const gridEntityVariant = gridEntity.GetVariant();
+        return ((callbackGridEntityType === undefined ||
+            callbackGridEntityType === gridEntityType) &&
+            (callbackGridEntityVariant === undefined ||
+                callbackGridEntityVariant === gridEntityVariant) &&
+            (callbackEntityType === undefined ||
+                callbackEntityType === entity.Type) &&
+            (callbackEntityVariant === undefined ||
+                callbackEntityVariant === entity.Variant) &&
+            (callbackEntitySubType === undefined ||
+                callbackEntitySubType === entity.SubType));
+    };
+}
+exports.PostGridEntityCollision = PostGridEntityCollision;

package/dist/classes/callbacks/PostGridEntityCustomBroken.js

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

package/dist/classes/callbacks/PostGridEntityCustomCollision.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGridEntityCustomCollision = void 0;
+const ISCFeature_1 = require("../../enums/ISCFeature");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostGridEntityCustomCollision extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.GRID_ENTITY_COLLISION_DETECTION];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_gridEntity, gridEntityTypeCustom, entity] = fireArgs;
+        const [callbackGridEntityTypeCustom, callbackEntityType, callbackEntityVariant, callbackEntitySubType,] = optionalArgs;
+        return ((callbackGridEntityTypeCustom === undefined ||
+            callbackGridEntityTypeCustom === gridEntityTypeCustom) &&
+            (callbackEntityType === undefined ||
+                callbackEntityType === entity.Type) &&
+            (callbackEntityVariant === undefined ||
+                callbackEntityVariant === entity.Variant) &&
+            (callbackEntitySubType === undefined ||
+                callbackEntitySubType === entity.SubType));
+    };
+}
+exports.PostGridEntityCustomCollision = PostGridEntityCustomCollision;

package/dist/classes/callbacks/PostGridEntityCustomInit.js

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

package/dist/classes/callbacks/PostGridEntityCustomRemove.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGridEntityCustomRemove = void 0;
+const ISCFeature_1 = require("../../enums/ISCFeature");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostGridEntityCustomRemove extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.GRID_ENTITY_UPDATE_DETECTION];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_gridIndex, gridEntityTypeCustom] = fireArgs;
+        const [callbackGridEntityTypeCustom] = optionalArgs;
+        return (callbackGridEntityTypeCustom === undefined ||
+            callbackGridEntityTypeCustom === gridEntityTypeCustom);
+    };
+}
+exports.PostGridEntityCustomRemove = PostGridEntityCustomRemove;

package/dist/classes/callbacks/PostGridEntityCustomRender.js

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

package/dist/classes/callbacks/PostGridEntityCustomStateChanged.js

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

package/dist/classes/callbacks/PostGridEntityCustomUpdate.js

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

package/dist/classes/callbacks/PostGridEntityInit.js

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

package/dist/classes/callbacks/PostGridEntityRemove.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostGridEntityRemove = void 0;
+const ISCFeature_1 = require("../../enums/ISCFeature");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostGridEntityRemove extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.GRID_ENTITY_UPDATE_DETECTION];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_gridIndex, gridEntityType, variant] = fireArgs;
+        const [callbackGridEntityType, callbackVariant] = optionalArgs;
+        return ((callbackGridEntityType === undefined ||
+            callbackGridEntityType === gridEntityType) &&
+            (callbackVariant === undefined || callbackVariant === variant));
+    };
+}
+exports.PostGridEntityRemove = PostGridEntityRemove;

package/dist/classes/callbacks/PostGridEntityRender.js

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

package/dist/classes/callbacks/PostGridEntityStateChanged.js

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

package/dist/classes/callbacks/PostGridEntityUpdate.js

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

package/dist/classes/callbacks/PostHolyMantleRemoved.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostHolyMantleRemoved = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const frames_1 = require("../../functions/frames");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const shouldFire_1 = require("../../shouldFire");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        playersHolyMantleMap: new DefaultMap_1.DefaultMap(0),
+    },
+};
+class PostHolyMantleRemoved extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        const effects = player.GetEffects();
+        const newNumHolyMantles = effects.GetCollectibleEffectNum(isaac_typescript_definitions_1.CollectibleType.HOLY_MANTLE);
+        const oldNumHolyMantles = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersHolyMantleMap, player);
+        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersHolyMantleMap, player, newNumHolyMantles);
+        // We check for being after room frame 0 to prevent the callback from firing when the player
+        // loses a lost curse from a white fire. (In this case, the player will have a Holy Mantle
+        // effect from the lost curse, and then when losing the curse, they will also lose the Holy
+        // Mantle.)
+        if (newNumHolyMantles < oldNumHolyMantles && (0, frames_1.isAfterRoomFrame)(0)) {
+            this.fire(player, oldNumHolyMantles, newNumHolyMantles);
+        }
+    };
+}
+exports.PostHolyMantleRemoved = PostHolyMantleRemoved;

package/dist/classes/callbacks/PostItemDischarge.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostItemDischarge = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../../arrays/cachedEnumValues");
+const cachedClasses_1 = require("../../core/cachedClasses");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const charge_1 = require("../../functions/charge");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        playersActiveItemMap: new DefaultMap_1.DefaultMap(() => new Map()),
+        playersActiveChargeMap: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+    room: {
+        playersBulbLastCollisionFrame: new Map(),
+    },
+};
+class PostItemDischarge extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 30
+            [
+                isaac_typescript_definitions_1.ModCallback.PRE_NPC_COLLISION,
+                this.preNPCCollisionSucker,
+                [isaac_typescript_definitions_1.EntityType.SUCKER],
+            ],
+        ];
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_player, collectibleType] = fireArgs;
+        const [callbackCollectibleType] = optionalArgs;
+        return (callbackCollectibleType === undefined ||
+            callbackCollectibleType === collectibleType);
+    };
+    // ModCallback.PRE_NPC_COLLISION (30)
+    // EntityType.SUCKER (61)
+    preNPCCollisionSucker = (npc, collider) => {
+        if (npc.Variant === isaac_typescript_definitions_1.SuckerVariant.BULB) {
+            return this.preNPCCollisionBulb(npc, collider);
+        }
+        return undefined;
+    };
+    // ModCallback.PRE_NPC_COLLISION (30)
+    // EntityType.SUCKER (61)
+    preNPCCollisionBulb(_npc, collider) {
+        this.checkPlayerCollidedWithBulb(collider);
+        return undefined;
+    }
+    /**
+     * The algorithm for detecting a discharge is checking if the current charge is less than the
+     * charge on the previous frame. Thus, when a Bulb zaps a player and drains their charge, this
+     * will be a false position, so Bulbs have to be handled.
+     *
+     * When Bulbs zap a player, they go to `NPCState.STATE_JUMP` for a frame. However, this only
+     * happens on the frame after the player is discharged, which is too late to be of any use.
+     *
+     * Instead, we track the frames that Bulbs collide with players and assume that a collision means
+     * a zap has occurred.
+     */
+    checkPlayerCollidedWithBulb(collider) {
+        const player = collider.ToPlayer();
+        if (player === undefined) {
+            return;
+        }
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        (0, playerDataStructures_1.mapSetPlayer)(v.room.playersBulbLastCollisionFrame, player, gameFrameCount);
+    }
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        const activeItemMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersActiveItemMap, player);
+        const chargeMap = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersActiveChargeMap, player);
+        for (const activeSlot of cachedEnumValues_1.ACTIVE_SLOT_VALUES) {
+            const currentActiveItem = player.GetActiveItem();
+            let previousActiveItem = activeItemMap.get(activeSlot);
+            if (previousActiveItem === undefined) {
+                previousActiveItem = currentActiveItem;
+            }
+            activeItemMap.set(activeSlot, currentActiveItem);
+            if (currentActiveItem !== previousActiveItem) {
+                // The player swapped out their active item for something else, so it should be impossible
+                // for the discharge callback to fire on this frame.
+                continue;
+            }
+            const currentCharge = (0, charge_1.getTotalCharge)(player, activeSlot);
+            let previousCharge = chargeMap.get(activeSlot);
+            if (previousCharge === undefined) {
+                previousCharge = currentCharge;
+            }
+            chargeMap.set(activeSlot, currentCharge);
+            if (this.playerRecentlyCollidedWithBulb(player)) {
+                continue;
+            }
+            if (currentCharge < previousCharge) {
+                const collectibleType = player.GetActiveItem(activeSlot);
+                this.fire(player, collectibleType, activeSlot);
+            }
+        }
+    };
+    /**
+     * If the player collided with a Bulb on either this frame or the last frame, then assume a zap
+     * has occurred. (We do not want to fire the discharge callback if this is the case.)
+     */
+    playerRecentlyCollidedWithBulb(player) {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const bulbLastCollisionFrame = (0, playerDataStructures_1.mapGetPlayer)(v.room.playersBulbLastCollisionFrame, player);
+        const collidedOnThisFrame = gameFrameCount === bulbLastCollisionFrame;
+        const collidedOnLastFrame = gameFrameCount - 1 === bulbLastCollisionFrame;
+        return collidedOnThisFrame || collidedOnLastFrame;
+    }
+}
+exports.PostItemDischarge = PostItemDischarge;

package/dist/classes/callbacks/PostItemPickup.js

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

package/dist/classes/callbacks/PostKeyboardChanged.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostKeyboardChanged = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../../arrays/cachedEnumValues");
+const input_1 = require("../../functions/input");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        pressedKeys: new Set(),
+    },
+};
+class PostKeyboardChanged extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [keyboard, pressed] = fireArgs;
+        const [callbackKeyboard, callbackPressed] = optionalArgs;
+        return ((callbackKeyboard === undefined || callbackKeyboard === keyboard) &&
+            (callbackPressed === undefined || callbackPressed === pressed));
+    };
+    postRender = () => {
+        for (const keyboard of v.run.pressedKeys) {
+            if (!(0, input_1.isKeyboardPressed)(keyboard)) {
+                v.run.pressedKeys.delete(keyboard);
+                this.fire(keyboard, false);
+            }
+        }
+        for (const keyboard of cachedEnumValues_1.KEYBOARD_VALUES) {
+            if (v.run.pressedKeys.has(keyboard)) {
+                continue;
+            }
+            if ((0, input_1.isKeyboardPressed)(keyboard)) {
+                v.run.pressedKeys.add(keyboard);
+                this.fire(keyboard, true);
+            }
+        }
+    };
+}
+exports.PostKeyboardChanged = PostKeyboardChanged;

package/dist/classes/callbacks/PostKnifeInitFilter.js

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

package/dist/classes/callbacks/PostKnifeInitLate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostKnifeInitLate = 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 PostKnifeInitLate extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 51
+            [isaac_typescript_definitions_1.ModCallback.POST_KNIFE_UPDATE, this.postKnifeUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireKnife;
+    // ModCallback.POST_KNIFE_UPDATE (51)
+    postKnifeUpdate = (knife) => {
+        const ptrHash = GetPtrHash(knife);
+        if (!v.room.firedSet.has(ptrHash)) {
+            v.room.firedSet.add(ptrHash);
+            this.fire(knife);
+        }
+    };
+}
+exports.PostKnifeInitLate = PostKnifeInitLate;