isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/callbacks/PostPickupUpdateFilter.js

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

package/dist/classes/callbacks/PostPitRender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPitRender = 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 PostPitRender extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePit;
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        for (const pit of (0, gridEntitiesSpecific_1.getPits)()) {
+            this.fire(pit);
+        }
+    };
+}
+exports.PostPitRender = PostPitRender;

package/dist/classes/callbacks/PostPitUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPitUpdate = 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 PostPitUpdate extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePit;
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        for (const pit of (0, gridEntitiesSpecific_1.getPits)()) {
+            this.fire(pit);
+        }
+    };
+}
+exports.PostPitUpdate = PostPitUpdate;

package/dist/classes/callbacks/PostPlayerChangeHealth.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPlayerChangeHealth = void 0;
+const cachedEnumValues_1 = require("../../arrays/cachedEnumValues");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const playerHealth_1 = require("../../functions/playerHealth");
+const playerIndex_1 = require("../../functions/playerIndex");
+const shouldFire_1 = require("../../shouldFire");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        playersHealthMap: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+};
+class PostPlayerChangeHealth extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectReordered,
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectReordered = (player) => {
+        // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If
+        // we don't differentiate between The Forgotten and The Soul, the callback will fire every time
+        // the player switches between the two.
+        const playerIndex = (0, playerIndex_1.getPlayerIndex)(player, true);
+        const playerHealthMap = v.run.playersHealthMap.getAndSetDefault(playerIndex);
+        for (const healthType of cachedEnumValues_1.HEALTH_TYPE_VALUES) {
+            const storedHealthValue = playerHealthMap.get(healthType);
+            const currentHealthValue = (0, playerHealth_1.getPlayerHealthType)(player, healthType);
+            playerHealthMap.set(healthType, currentHealthValue);
+            if (storedHealthValue !== undefined &&
+                storedHealthValue !== currentHealthValue) {
+                const difference = currentHealthValue - storedHealthValue;
+                this.fire(player, healthType, difference, storedHealthValue, currentHealthValue);
+            }
+        }
+    };
+}
+exports.PostPlayerChangeHealth = PostPlayerChangeHealth;

package/dist/classes/callbacks/PostPlayerChangeStat.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPlayerChangeStat = void 0;
+const cachedEnumValues_1 = require("../../arrays/cachedEnumValues");
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const bitSet128_1 = require("../../functions/bitSet128");
+const color_1 = require("../../functions/color");
+const playerIndex_1 = require("../../functions/playerIndex");
+const stats_1 = require("../../functions/stats");
+const types_1 = require("../../functions/types");
+const vector_1 = require("../../functions/vector");
+const shouldFire_1 = require("../../shouldFire");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        playersStatMap: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+};
+class PostPlayerChangeStat extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectReordered,
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectReordered = (player) => {
+        // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If
+        // we don't differentiate between The Forgotten and The Soul, the callback will fire every time
+        // the player switches between the two.
+        const playerIndex = (0, playerIndex_1.getPlayerIndex)(player, true);
+        const playerStatMap = v.run.playersStatMap.getAndSetDefault(playerIndex);
+        for (const statType of cachedEnumValues_1.PLAYER_STAT_VALUES) {
+            const storedStatValue = playerStatMap.get(statType);
+            const currentStatValue = (0, stats_1.getPlayerStat)(player, statType);
+            playerStatMap.set(statType, currentStatValue);
+            if (storedStatValue === undefined) {
+                continue;
+            }
+            if (!statEquals(storedStatValue, currentStatValue)) {
+                const isNumberStat = (0, types_1.isNumber)(storedStatValue) && (0, types_1.isNumber)(currentStatValue);
+                const difference = isNumberStat
+                    ? currentStatValue - storedStatValue
+                    : 0;
+                this.fire(player, statType, difference, storedStatValue, currentStatValue);
+            }
+        }
+    };
+}
+exports.PostPlayerChangeStat = PostPlayerChangeStat;
+function statEquals(oldValue, newValue) {
+    const isNumberStat = (0, types_1.isNumber)(oldValue) && (0, types_1.isNumber)(newValue);
+    if (isNumberStat) {
+        return oldValue === newValue;
+    }
+    const isBooleanStat = (0, types_1.isBoolean)(oldValue) && (0, types_1.isBoolean)(newValue);
+    if (isBooleanStat) {
+        return oldValue === newValue;
+    }
+    const isBitSet128Stat = (0, bitSet128_1.isBitSet128)(oldValue) && (0, bitSet128_1.isBitSet128)(newValue);
+    if (isBitSet128Stat) {
+        return oldValue === newValue; // The class has the "__eq" meta-method.
+    }
+    const isColorStat = (0, color_1.isColor)(oldValue) && (0, color_1.isColor)(newValue);
+    if (isColorStat) {
+        return (0, color_1.colorEquals)(oldValue, newValue);
+    }
+    const isVectorStat = (0, vector_1.isVector)(oldValue) && (0, vector_1.isVector)(newValue);
+    if (isVectorStat) {
+        return (0, vector_1.vectorEquals)(oldValue, newValue);
+    }
+    error('Failed to determine the type of a stat in the "POST_PLAYER_CHANGE_STAT" callback.');
+}

package/dist/classes/callbacks/PostPlayerChangeType.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPlayerChangeType = void 0;
+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 v = {
+    run: {
+        playersCharacterMap: new DefaultMap_1.DefaultMap((character) => character), // eslint-disable-line isaacscript/strict-enums
+    },
+};
+class PostPlayerChangeType extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectReordered,
+            ],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectReordered = (player) => {
+        const character = player.GetPlayerType();
+        const storedCharacter = (0, playerDataStructures_1.defaultMapGetPlayer)(v.run.playersCharacterMap, player, character);
+        if (character !== storedCharacter) {
+            (0, playerDataStructures_1.mapSetPlayer)(v.run.playersCharacterMap, player, character);
+            this.fire(player, storedCharacter, character);
+        }
+    };
+}
+exports.PostPlayerChangeType = PostPlayerChangeType;

package/dist/classes/callbacks/PostPlayerCollectibleAdded.js

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

package/dist/classes/callbacks/PostPlayerCollectibleRemoved.js

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

package/dist/classes/callbacks/PostPlayerFatalDamage.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPlayerFatalDamage = 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 playerDataStructures_1 = require("../../functions/playerDataStructures");
+const playerIndex_1 = require("../../functions/playerIndex");
+const revive_1 = require("../../functions/revive");
+const rooms_1 = require("../../functions/rooms");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        /** Needed to detect if Glass Cannon will kill the player. */
+        playersLastDamageGameFrame: new Map(),
+    },
+};
+class PostPlayerFatalDamage extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 23
+            [isaac_typescript_definitions_1.ModCallback.PRE_USE_ITEM, this.preUseItemBible, [isaac_typescript_definitions_1.CollectibleType.BIBLE]],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    /**
+     * Using The Bible on Satan is one of the few ways to die without taking damage, so we need to
+     * handle this case.
+     */
+    // ModCallback.PRE_USE_ITEM (23)
+    // CollectibleType.BIBLE (33)
+    preUseItemBible = (_collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData) => {
+        if (!(0, rooms_1.inBossRoomOf)(isaac_typescript_definitions_1.BossID.SATAN)) {
+            return undefined;
+        }
+        if ((0, revive_1.willPlayerRevive)(player)) {
+            return undefined;
+        }
+        const shouldSustainDeath = this.fire(player, 0, isaac_typescript_definitions_1.DamageFlagZero, EntityRef(player), 0);
+        if (shouldSustainDeath !== undefined) {
+            // End-users will return false to stop the damage from being fatal. We have to return true to
+            // prevent the Bible from firing.
+            return !shouldSustainDeath;
+        }
+        return undefined;
+    };
+    // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
+    entityTakeDmgPlayer = (player, amount, damageFlags, source, countdownFrames) => {
+        // This callback should not trigger for the Strawman Keeper and other players that are "child"
+        // players.
+        if ((0, playerIndex_1.isChildPlayer)(player)) {
+            return undefined;
+        }
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const lastDamageGameFrame = (0, playerDataStructures_1.mapGetPlayer)(v.run.playersLastDamageGameFrame, player);
+        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersLastDamageGameFrame, player, gameFrameCount);
+        // If the damage has the damage flag of `DamageFlag.NO_KILL` (1 << 0), this will not be fatal
+        // damage. (This is present on things like the Bad Trip pill.)
+        if ((0, flag_1.hasFlag)(damageFlags, isaac_typescript_definitions_1.DamageFlag.NO_KILL)) {
+            return undefined;
+        }
+        // If the player has a revival item such as Dead Cat, this will not be fatal damage.
+        if ((0, revive_1.willPlayerRevive)(player)) {
+            return undefined;
+        }
+        if (!(0, revive_1.isDamageToPlayerFatal)(player, amount, source, lastDamageGameFrame)) {
+            return undefined;
+        }
+        const shouldSustainDeath = this.fire(player, amount, damageFlags, source, countdownFrames);
+        if (shouldSustainDeath !== undefined) {
+            return shouldSustainDeath;
+        }
+        return undefined;
+    };
+}
+exports.PostPlayerFatalDamage = PostPlayerFatalDamage;

package/dist/classes/callbacks/PostPlayerInitFirst.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPlayerInitFirst = void 0;
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const playerIndex_1 = require("../../functions/playerIndex");
+const rooms_1 = require("../../functions/rooms");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostPlayerInitFirst extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+            [ModCallbackCustom_1.ModCallbackCustom.POST_PLAYER_INIT_LATE, this.postPlayerInitLate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        // When a player uses the Genesis collectible, they will lose all of their collectibles,
+        // trinkets, pocket items, and stats, so they will need to be re-initialized like they would be
+        // at the beginning of a run. However, in this case, the `POST_PLAYER_INIT_FIRST` callback will
+        // not fire, because that only fires once per run. Thus, we explicitly handle this special case.
+        // Note that whichever player uses Genesis, items will be removed from all players (at least in
+        // the case of Jacob & Esau).
+        if ((0, rooms_1.inGenesisRoom)()) {
+            for (const player of (0, playerIndex_1.getPlayers)()) {
+                this.fire(player);
+            }
+        }
+    };
+    // ModCallbackCustom.POST_PLAYER_INIT_LATE
+    postPlayerInitLate = (player) => {
+        // We want to exclude non-real players like the Strawman keeper.
+        if ((0, playerIndex_1.isChildPlayer)(player)) {
+            return;
+        }
+        this.fire(player);
+    };
+}
+exports.PostPlayerInitFirst = PostPlayerInitFirst;

package/dist/classes/callbacks/PostPlayerInitLate.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPlayerInitLate = void 0;
+const ModCallbackCustom_1 = require("../../enums/ModCallbackCustom");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        playersFiredSet: new Set(),
+    },
+};
+class PostPlayerInitLate 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) => {
+        if (!(0, playerDataStructures_1.setHasPlayer)(v.run.playersFiredSet, player)) {
+            (0, playerDataStructures_1.setAddPlayer)(v.run.playersFiredSet, player);
+            this.fire(player);
+        }
+    };
+}
+exports.PostPlayerInitLate = PostPlayerInitLate;

package/dist/classes/callbacks/PostPlayerRenderReordered.js

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

package/dist/classes/callbacks/PostPlayerUpdateReordered.js

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

package/dist/classes/callbacks/PostPoopRender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPoopRender = 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 PostPoopRender extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePoop;
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        for (const poop of (0, gridEntitiesSpecific_1.getPoops)()) {
+            this.fire(poop);
+        }
+    };
+}
+exports.PostPoopRender = PostPoopRender;

package/dist/classes/callbacks/PostPoopUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPoopUpdate = 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 PostPoopUpdate extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePoop;
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        for (const poop of (0, gridEntitiesSpecific_1.getPoops)()) {
+            this.fire(poop);
+        }
+    };
+}
+exports.PostPoopUpdate = PostPoopUpdate;

package/dist/classes/callbacks/PostPressurePlateRender.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPressurePlateRender = 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 PostPressurePlateRender extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePressurePlate;
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        for (const pressurePlate of (0, gridEntitiesSpecific_1.getPressurePlates)()) {
+            this.fire(pressurePlate);
+        }
+    };
+}
+exports.PostPressurePlateRender = PostPressurePlateRender;

package/dist/classes/callbacks/PostPressurePlateUpdate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostPressurePlateUpdate = 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 PostPressurePlateUpdate extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFirePressurePlate;
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        for (const pressurePlate of (0, gridEntitiesSpecific_1.getPressurePlates)()) {
+            this.fire(pressurePlate);
+        }
+    };
+}
+exports.PostPressurePlateUpdate = PostPressurePlateUpdate;

package/dist/classes/callbacks/PostProjectileInitFilter.js

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

package/dist/classes/callbacks/PostProjectileInitLate.js

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