isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/callbacks/PostBoneSwing.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostBoneSwing = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const ReadonlySet_1 = require("../../types/ReadonlySet");
+const CustomCallback_1 = require("../private/CustomCallback");
+const BONE_SWING_ANIMATIONS = new ReadonlySet_1.ReadonlySet([
+    "Swing",
+    "Swing2",
+    "Spin",
+]);
+const v = {
+    room: {
+        boneClubAnimations: new Map(),
+    },
+};
+class PostBoneSwing extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 52
+            [isaac_typescript_definitions_1.ModCallback.POST_KNIFE_RENDER, this.postKnifeRender],
+        ];
+    }
+    // ModCallback.POST_KNIFE_RENDER (52)
+    postKnifeRender = (knife) => {
+        // The tertiary argument of the `POST_KNIFE_RENDER` callback takes sub-types instead of knife
+        // variants.
+        if (knife.Variant === isaac_typescript_definitions_1.KnifeVariant.BONE_CLUB) {
+            this.postKnifeRenderBoneClub(knife);
+        }
+    };
+    // ModCallback.POST_KNIFE_RENDER (52)
+    // KnifeVariant.BONE_CLUB (1)
+    postKnifeRenderBoneClub(knife) {
+        const sprite = knife.GetSprite();
+        const animation = sprite.GetAnimation();
+        const ptrHash = GetPtrHash(knife);
+        const animationOnLastFrame = v.room.boneClubAnimations.get(ptrHash);
+        v.room.boneClubAnimations.set(ptrHash, animation);
+        if (animationOnLastFrame !== undefined &&
+            animation !== animationOnLastFrame) {
+            this.boneClubAnimationChanged(knife, animation);
+        }
+    }
+    boneClubAnimationChanged(knife, animation) {
+        if (BONE_SWING_ANIMATIONS.has(animation)) {
+            this.fire(knife);
+        }
+    }
+}
+exports.PostBoneSwing = PostBoneSwing;

package/dist/classes/callbacks/PostCollectibleEmpty.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostCollectibleEmpty = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    room: {
+        collectibleTypeMap: new Map(),
+    },
+};
+class PostCollectibleEmpty extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 35
+            [
+                isaac_typescript_definitions_1.ModCallback.POST_PICKUP_UPDATE,
+                this.postPickupUpdateCollectible,
+                [isaac_typescript_definitions_1.PickupVariant.COLLECTIBLE],
+            ],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_collectible, oldCollectibleType] = fireArgs;
+        const [callbackCollectibleType] = optionalArgs;
+        return (callbackCollectibleType === undefined ||
+            callbackCollectibleType === oldCollectibleType);
+    };
+    // ModCallback.POST_PICKUP_UPDATE (35)
+    // PickupVariant.COLLECTIBLE (100)
+    postPickupUpdateCollectible = (pickup) => {
+        const collectible = pickup;
+        const ptrHash = GetPtrHash(collectible);
+        let oldCollectibleType = v.room.collectibleTypeMap.get(ptrHash);
+        if (oldCollectibleType === undefined) {
+            oldCollectibleType = collectible.SubType;
+        }
+        v.room.collectibleTypeMap.set(ptrHash, collectible.SubType);
+        if (oldCollectibleType !== collectible.SubType) {
+            this.collectibleTypeChanged(collectible, oldCollectibleType);
+        }
+    };
+    collectibleTypeChanged(collectible, oldCollectibleType) {
+        if (collectible.SubType === isaac_typescript_definitions_1.CollectibleType.NULL) {
+            this.fire(collectible, oldCollectibleType);
+        }
+    }
+}
+exports.PostCollectibleEmpty = PostCollectibleEmpty;

package/dist/classes/callbacks/PostCursedTeleport.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostCursedTeleport = 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 frames_1 = require("../../functions/frames");
+const playerDataStructures_1 = require("../../functions/playerDataStructures");
+const players_1 = require("../../functions/players");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        playersDamageFrameMap: new Map(),
+    },
+    level: {
+        numSacrifices: 0,
+    },
+};
+class PostCursedTeleport extends CustomCallback_1.CustomCallback {
+    v = v;
+    shouldFire = shouldFire_1.shouldFirePlayer;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PLAYER_RENDER_REORDERED,
+                this.postPlayerRenderReorderedPlayer,
+                [isaac_typescript_definitions_1.PlayerVariant.PLAYER], // Co-op babies cannot perform Cursed Eye teleports.
+            ],
+        ];
+    }
+    // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
+    entityTakeDmgPlayer = (player, _amount, damageFlags, _source, _countdownFrames) => {
+        this.incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame.
+        this.setDamageFrame(player, damageFlags);
+        return undefined;
+    };
+    incrementNumSacrifices(damageFlags) {
+        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++;
+        }
+    }
+    setDamageFrame(player, damageFlags) {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        // Don't do anything if we already activated the callback on this frame.
+        const trackingArray = (0, playerDataStructures_1.mapGetPlayer)(v.run.playersDamageFrameMap, player);
+        if (trackingArray !== undefined) {
+            const [lastDamageFrame, callbackFiredOnThisFrame] = trackingArray;
+            if (lastDamageFrame === gameFrameCount && callbackFiredOnThisFrame) {
+                return;
+            }
+        }
+        // Don't do anything if this could be a Sacrifice Room teleport.
+        if (this.isPotentialNaturalTeleportFromSacrificeRoom(damageFlags)) {
+            return;
+        }
+        const newTrackingArray = [gameFrameCount, false];
+        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersDamageFrameMap, player, newTrackingArray);
+    }
+    isPotentialNaturalTeleportFromSacrificeRoom(damageFlags) {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomType = room.GetType();
+        const isSpikeDamage = (0, flag_1.hasFlag)(damageFlags, isaac_typescript_definitions_1.DamageFlag.SPIKES);
+        // Don't record the frame if we are potentially going to the Angel Room or the Dark Room from a
+        // Sacrifice Room.
+        return (roomType === isaac_typescript_definitions_1.RoomType.SACRIFICE &&
+            isSpikeDamage &&
+            (v.level.numSacrifices === 6 || v.level.numSacrifices >= 12));
+    }
+    // ModCallbackCustom.POST_PLAYER_RENDER_REORDERED
+    // PlayerVariant.PLAYER (0)
+    postPlayerRenderReorderedPlayer = (player, _renderOffset) => {
+        // Retrieve information about this player.
+        const trackingArray = (0, playerDataStructures_1.mapGetPlayer)(v.run.playersDamageFrameMap, player);
+        if (trackingArray === undefined) {
+            return;
+        }
+        const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
+        if (!this.playerIsTeleportingFromCursedTeleport(player, lastDamageFrame)) {
+            return;
+        }
+        // Do nothing if the callback already fired on this frame.
+        if (callbackActivatedOnThisFrame) {
+            return;
+        }
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        const newTrackingArray = [gameFrameCount, true];
+        (0, playerDataStructures_1.mapSetPlayer)(v.run.playersDamageFrameMap, player, newTrackingArray);
+        this.fire(player);
+    };
+    playerIsTeleportingFromCursedTeleport(player, lastDamageFrame) {
+        // Check to see if this is the frame that we last took damage.
+        if (!(0, frames_1.onGameFrame)(lastDamageFrame)) {
+            return false;
+        }
+        // Check to see if this is the 1st frame that we are teleporting.
+        const sprite = player.GetSprite();
+        if (!sprite.IsPlaying("TeleportUp") ||
+            sprite.GetFrame() !== 1 // The 0th frame never fires
+        ) {
+            return false;
+        }
+        if (player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.CURSED_EYE)) {
+            return true;
+        }
+        const numHitsRemaining = (0, players_1.getPlayerNumHitsRemaining)(player);
+        if (player.HasTrinket(isaac_typescript_definitions_1.TrinketType.CURSED_SKULL) && numHitsRemaining === 1) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.PostCursedTeleport = PostCursedTeleport;

package/dist/classes/callbacks/PostCustomRevive.js

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

package/dist/classes/callbacks/PostDiceRoomActivated.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostDiceRoomActivated = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const effects_1 = require("../../functions/effects");
+const players_1 = require("../../functions/players");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    room: {
+        diceRoomActivated: false,
+    },
+};
+class PostDiceRoomActivated extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 55
+            [
+                isaac_typescript_definitions_1.ModCallback.POST_EFFECT_UPDATE,
+                this.postEffectUpdateDiceFloor,
+                [isaac_typescript_definitions_1.EffectVariant.DICE_FLOOR],
+            ],
+        ];
+    }
+    shouldFire = (fireArgs, optionalArgs) => {
+        const [_player, diceFloorSubType] = fireArgs;
+        const [callbackDiceFloorSubType] = optionalArgs;
+        return (callbackDiceFloorSubType === undefined ||
+            diceFloorSubType === callbackDiceFloorSubType);
+    };
+    // ModCallback.POST_EFFECT_UPDATE (55)
+    // EffectVariant.DICE_FLOOR (76)
+    postEffectUpdateDiceFloor = (effect) => {
+        if (v.room.diceRoomActivated) {
+            return;
+        }
+        // When using the debug console to go to a dice room, the player can appear on top of the dice
+        // floor before they snap to the door.
+        if (effect.FrameCount === 0) {
+            return;
+        }
+        const closestPlayer = (0, players_1.getClosestPlayer)(effect.Position);
+        if ((0, effects_1.isCloseEnoughToTriggerDiceFloor)(closestPlayer, effect)) {
+            v.room.diceRoomActivated = true;
+            this.fire(closestPlayer, effect.SubType);
+        }
+    };
+}
+exports.PostDiceRoomActivated = PostDiceRoomActivated;

package/dist/classes/callbacks/PostDoorRender.js

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

package/dist/classes/callbacks/PostDoorUpdate.js

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

package/dist/classes/callbacks/PostEffectInitFilter.js

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

package/dist/classes/callbacks/PostEffectInitLate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostEffectInitLate = 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 PostEffectInitLate extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 55
+            [isaac_typescript_definitions_1.ModCallback.POST_EFFECT_UPDATE, this.postEffectUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireEffect;
+    // ModCallback.POST_EFFECT_UPDATE (55)
+    postEffectUpdate = (effect) => {
+        const index = GetPtrHash(effect);
+        if (!v.room.firedSet.has(index)) {
+            v.room.firedSet.add(index);
+            this.fire(effect);
+        }
+    };
+}
+exports.PostEffectInitLate = PostEffectInitLate;

package/dist/classes/callbacks/PostEffectRenderFilter.js

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

package/dist/classes/callbacks/PostEffectStateChanged.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostEffectStateChanged = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        stateMap: new DefaultMap_1.DefaultMap((state) => state),
+    },
+};
+class PostEffectStateChanged extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 55
+            [isaac_typescript_definitions_1.ModCallback.POST_EFFECT_UPDATE, this.postEffectUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireEffect;
+    // ModCallback.POST_EFFECT_UPDATE (55)
+    postEffectUpdate = (effect) => {
+        const ptrHash = GetPtrHash(effect);
+        const previousState = v.run.stateMap.getAndSetDefault(ptrHash, effect.State);
+        const currentState = effect.State;
+        v.run.stateMap.set(ptrHash, currentState);
+        if (previousState !== currentState) {
+            this.fire(effect, previousState, currentState);
+        }
+    };
+}
+exports.PostEffectStateChanged = PostEffectStateChanged;

package/dist/classes/callbacks/PostEffectUpdateFilter.js

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

package/dist/classes/callbacks/PostEntityKillFilter.js

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

package/dist/classes/callbacks/PostEsauJr.js

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

package/dist/classes/callbacks/PostFamiliarInitFilter.js

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

package/dist/classes/callbacks/PostFamiliarInitLate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostFamiliarInitLate = 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 PostFamiliarInitLate extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 6
+            [isaac_typescript_definitions_1.ModCallback.POST_FAMILIAR_UPDATE, this.postFamiliarUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireFamiliar;
+    // ModCallback.POST_FAMILIAR_UPDATE (6)
+    postFamiliarUpdate = (familiar) => {
+        const index = GetPtrHash(familiar);
+        if (!v.room.firedSet.has(index)) {
+            v.room.firedSet.add(index);
+            this.fire(familiar);
+        }
+    };
+}
+exports.PostFamiliarInitLate = PostFamiliarInitLate;

package/dist/classes/callbacks/PostFamiliarRenderFilter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostFamiliarRenderFilter = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const CustomCallback_1 = require("../private/CustomCallback");
+class PostFamiliarRenderFilter extends CustomCallback_1.CustomCallback {
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 25
+            [isaac_typescript_definitions_1.ModCallback.POST_FAMILIAR_RENDER, this.postFamiliarRender],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireFamiliar;
+    // ModCallback.POST_FAMILIAR_UPDATE (6)
+    postFamiliarRender = (familiar, renderOffset) => {
+        this.fire(familiar, renderOffset);
+    };
+}
+exports.PostFamiliarRenderFilter = PostFamiliarRenderFilter;

package/dist/classes/callbacks/PostFamiliarStateChanged.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostFamiliarStateChanged = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const shouldFire_1 = require("../../shouldFire");
+const DefaultMap_1 = require("../DefaultMap");
+const CustomCallback_1 = require("../private/CustomCallback");
+const v = {
+    run: {
+        stateMap: new DefaultMap_1.DefaultMap((state) => state),
+    },
+};
+class PostFamiliarStateChanged extends CustomCallback_1.CustomCallback {
+    v = v;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 6
+            [isaac_typescript_definitions_1.ModCallback.POST_FAMILIAR_UPDATE, this.postFamiliarUpdate],
+        ];
+    }
+    shouldFire = shouldFire_1.shouldFireFamiliar;
+    // ModCallback.POST_FAMILIAR_UPDATE (6)
+    postFamiliarUpdate = (familiar) => {
+        const ptrHash = GetPtrHash(familiar);
+        const previousState = v.run.stateMap.getAndSetDefault(ptrHash, familiar.State);
+        const currentState = familiar.State;
+        v.run.stateMap.set(ptrHash, currentState);
+        if (previousState !== currentState) {
+            this.fire(familiar, previousState, currentState);
+        }
+    };
+}
+exports.PostFamiliarStateChanged = PostFamiliarStateChanged;

package/dist/classes/callbacks/PostFamiliarUpdateFilter.js

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

package/dist/classes/callbacks/PostFirstEsauJr.js

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