isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/features/callbackLogic/CustomGridEntities.js

@@ -0,0 +1,359 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomGridEntities = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const decorators_1 = require("../../../decorators");
+const ISCFeature_1 = require("../../../enums/ISCFeature");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const gridEntities_1 = require("../../../functions/gridEntities");
+const players_1 = require("../../../functions/players");
+const roomData_1 = require("../../../functions/roomData");
+const types_1 = require("../../../functions/types");
+const utils_1 = require("../../../functions/utils");
+const vector_1 = require("../../../functions/vector");
+const DefaultMap_1 = require("../../DefaultMap");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    level: {
+        /** Indexed by room list index and grid index. */
+        customGridEntities: new DefaultMap_1.DefaultMap(() => new Map()),
+    },
+    room: {
+        genericPropPtrHashes: new Set(),
+        manuallyUsingShovel: false,
+    },
+};
+class CustomGridEntities extends Feature_1.Feature {
+    /** @internal */
+    v = v;
+    runInNFrames;
+    /** @internal */
+    constructor(runInNFrames) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.RUN_IN_N_FRAMES];
+        this.callbacksUsed = [
+            // 23
+            [
+                isaac_typescript_definitions_1.ModCallback.PRE_USE_ITEM,
+                this.preUseItemWeNeedToGoDeeper,
+                [isaac_typescript_definitions_1.CollectibleType.WE_NEED_TO_GO_DEEPER],
+            ],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+        ];
+        this.runInNFrames = runInNFrames;
+    }
+    // ModCallback.PRE_USE_ITEM (23)
+    // CollectibleType.WE_NEED_TO_GO_DEEPER (84)
+    preUseItemWeNeedToGoDeeper = (_collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData) => {
+        // If a player uses We Need to Go Deeper on top of a custom grid entity, then they will always
+        // get a crawlspace, due to how custom grids are implemented with decorations. Thus, remove the
+        // custom grid entity to prevent this from happening if needed.
+        const room = cachedClasses_1.game.GetRoom();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+        if (roomCustomGridEntities === undefined) {
+            return undefined;
+        }
+        const gridIndex = room.GetGridIndex(player.Position);
+        const customGridEntity = roomCustomGridEntities.get(gridIndex);
+        if (customGridEntity === undefined) {
+            return undefined;
+        }
+        // If the custom grid entity has collision, then the player should not be able to be standing on
+        // top of it.
+        if (customGridEntity.gridCollisionClass !== isaac_typescript_definitions_1.GridCollisionClass.NONE) {
+            return undefined;
+        }
+        (0, gridEntities_1.removeGridEntity)(customGridEntity.gridIndex, false);
+        const entityPtr = EntityPtr(player);
+        this.runInNFrames.runNextGameFrame(() => {
+            const futurePlayer = (0, players_1.getPlayerFromPtr)(entityPtr);
+            if (futurePlayer === undefined) {
+                return;
+            }
+            v.room.manuallyUsingShovel = true;
+            futurePlayer.UseActiveItem(isaac_typescript_definitions_1.CollectibleType.WE_NEED_TO_GO_DEEPER);
+            v.room.manuallyUsingShovel = false;
+        });
+        // Cancel the original effect.
+        return true;
+    };
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        // When we re-enter a room, the graphics for any custom entities will be reverted back to that
+        // of a normal decoration. Thus, we must re-apply the anm2.
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+        if (roomCustomGridEntities === undefined) {
+            return;
+        }
+        const room = cachedClasses_1.game.GetRoom();
+        for (const [gridIndex, data] of roomCustomGridEntities) {
+            const decoration = room.GetGridEntity(gridIndex);
+            if (decoration === undefined) {
+                roomCustomGridEntities.delete(gridIndex);
+                continue;
+            }
+            if (data.anm2Path !== undefined) {
+                const sprite = decoration.GetSprite();
+                sprite.Load(data.anm2Path, true);
+                const animationToPlay = data.defaultAnimation ?? sprite.GetDefaultAnimation();
+                sprite.Play(animationToPlay, true);
+            }
+        }
+    };
+    /**
+     * Helper function to spawn a custom grid entity. Custom grid entities are persistent in that they
+     * will reappear if the player leaves and re-enters the room. (It will be manually respawned in
+     * the `POST_NEW_ROOM` callback.)
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
+     *
+     * Custom grid entities are built on top of real grid entities. You can use any existing grid
+     * entity type as a base. For example, if you want to create a custom rock that would be breakable
+     * like a normal rock, then you should specify `GridEntityType.ROCK` as the base grid entity type.
+     *
+     * Once a custom grid entity is spawned, you can take advantage of the custom grid callbacks such
+     * as `POST_GRID_ENTITY_CUSTOM_UPDATE`. Note that the "normal" grid entities callbacks will not
+     * fire for custom entities. For example, if you had a custom grid entity based on
+     * `GridEntityType.ROCK`, and you also had a subscription to the `POST_GRID_ENTITY_UPDATE`
+     * callback, the callback would only fire for normal rocks and not the custom entity.
+     *
+     * Custom grid entities are an IsaacScript feature because the vanilla game does not support any
+     * custom grid entities.
+     *
+     * For example, this would be code to create a custom rock called a "Silver Rock" that produces a
+     * dime when destroyed:
+     *
+     * ```ts
+     * // This is local to the mod and can safely overlap with the values of `GridEntityType` (or
+     * // values chosen by other mods).
+     * const GridEntityTypeCustom = {
+     *   SILVER_ROCK: 0 as GridEntityType,
+     * } as const;
+     *
+     * // This is copied from "gfx/grid/grid_rock.anm2" with some tweaks to make it look special.
+     * const SILVER_ROCK_ANM2_PATH = "gfx/grid/grid_rock_silver.anm2";
+     *
+     * export function silverRockInit(mod: ModUpgraded): void {
+     *   mod.AddCallbackCustom(
+     *     ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN,
+     *     postGridEntityCustomBrokenSilverRock,
+     *     GridEntityTypeCustom.SILVER_ROCK,
+     *   );
+     * }
+     *
+     * function postGridEntityCustomBrokenSilverRock(gridEntity: GridEntity) {
+     *   spawnCoin(CoinSubType.DIME, gridEntity.Position);
+     * }
+     *
+     * export function spawnSilverRock(mod: ModUpgraded, gridIndex: int): GridEntity {
+     *   return mod.spawnCustomGridEntity(
+     *     GridEntityTypeCustom.SILVER_ROCK,
+     *     gridIndex,
+     *     undefined,
+     *     SILVER_ROCK_ANM2_PATH,
+     *     undefined,
+     *     GridEntityType.ROCK,
+     *   );
+     * }
+     * ```
+     *
+     * @param gridEntityTypeCustom An integer that identifies what kind of grid entity you are
+     *                             creating. It should correspond to a local enum value created in
+     *                             your mod. The integer can be any unique value and will not
+     *                             correspond to the actual grid entity type used. (This integer is
+     *                             used in the various custom grid entity callbacks.)
+     * @param gridIndexOrPosition The grid index or position in the room that you want to spawn the
+     *                            grid entity at. If a position is specified, the closest grid index
+     *                            will be used.
+     * @param gridCollisionClass Optional. The collision class that you want the custom grid entity to
+     *                           have. If not specified, the grid collision class from the base grid
+     *                           entity will be used.
+     * @param anm2Path Optional. The path to the ANM2 file to use for the sprite. If not specified,
+     *                 the normal sprite from the base grid entity will be used.
+     * @param defaultAnimation Optional. The name of the animation to play after the sprite is
+     *                         initialized and after the player re-enters a room with this grid entity
+     *                         in it. If not specified, the default animation in the anm2 will be
+     *                         used.
+     * @param baseGridEntityType Optional. The type of the grid entity to use as a "base" for this
+     *                           custom grid entity. Default is `GridEntityType.DECORATION`.
+     * @param baseGridEntityVariant Optional. The variant of the grid entity to use as a "base" for
+     *                              this custom grid entity. Default is 0.
+     * @public
+     */
+    spawnCustomGridEntity(gridEntityTypeCustom, gridIndexOrPosition, gridCollisionClass, anm2Path, defaultAnimation, baseGridEntityType = isaac_typescript_definitions_1.GridEntityType.DECORATION, baseGridEntityVariant = 0) {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const gridIndex = (0, vector_1.isVector)(gridIndexOrPosition)
+            ? room.GetGridIndex(gridIndexOrPosition)
+            : gridIndexOrPosition;
+        const customGridEntity = (0, gridEntities_1.spawnGridEntityWithVariant)(baseGridEntityType, baseGridEntityVariant, gridIndexOrPosition);
+        (0, utils_1.assertDefined)(customGridEntity, "Failed to spawn a custom grid entity.");
+        if (gridCollisionClass !== undefined) {
+            customGridEntity.CollisionClass = gridCollisionClass;
+        }
+        if (anm2Path !== undefined) {
+            const sprite = customGridEntity.GetSprite();
+            sprite.Load(anm2Path, true);
+            const animationToPlay = defaultAnimation ?? sprite.GetDefaultAnimation();
+            sprite.Play(animationToPlay, true);
+        }
+        const customGridEntityData = {
+            gridEntityTypeCustom,
+            roomListIndex,
+            gridIndex,
+            anm2Path,
+            defaultAnimation,
+            gridCollisionClass,
+        };
+        const roomCustomGridEntities = v.level.customGridEntities.getAndSetDefault(roomListIndex);
+        roomCustomGridEntities.set(gridIndex, customGridEntityData);
+        return customGridEntity;
+    }
+    /**
+     * Helper function to remove a custom grid entity created by the `spawnCustomGrid` function.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
+     *
+     * @param gridIndexOrPositionOrGridEntity You can specify the custom grid entity to remove by
+     *                                providing the grid index, the room position, or the grid entity
+     *                                itself.
+     * @param updateRoom Optional. Whether to update the room after the grid entity is removed.
+     *                   Default is true. This is generally a good idea because if the room is not
+     *                   updated, you will be unable to spawn another grid entity on the same tile
+     *                   until a frame has passed. However, doing this is expensive, since it involves
+     *                   a call to `Isaac.GetRoomEntities`, so set it to false if you need to run this
+     *                   function multiple times.
+     * @returns The grid entity that was removed. Returns undefined if no grid entity was found at the
+     *          given location or if the given grid entity was not a custom grid entity.
+     * @public
+     */
+    removeCustomGridEntity(gridIndexOrPositionOrGridEntity, updateRoom = true) {
+        const room = cachedClasses_1.game.GetRoom();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        let decoration;
+        if (typeof gridIndexOrPositionOrGridEntity === "number") {
+            const gridIndex = gridIndexOrPositionOrGridEntity;
+            const gridEntity = room.GetGridEntity(gridIndex);
+            if (gridEntity === undefined) {
+                return undefined;
+            }
+            decoration = gridEntity;
+        }
+        else if ((0, vector_1.isVector)(gridIndexOrPositionOrGridEntity)) {
+            const position = gridIndexOrPositionOrGridEntity;
+            const gridEntity = room.GetGridEntityFromPos(position);
+            if (gridEntity === undefined) {
+                return undefined;
+            }
+            decoration = gridEntity;
+        }
+        else {
+            decoration = gridIndexOrPositionOrGridEntity;
+        }
+        const gridIndex = decoration.GetGridIndex();
+        const roomCustomGridEntities = v.level.customGridEntities.getAndSetDefault(roomListIndex);
+        const exists = roomCustomGridEntities.has(gridIndex);
+        if (!exists) {
+            return undefined;
+        }
+        roomCustomGridEntities.delete(gridIndex);
+        (0, gridEntities_1.removeGridEntity)(decoration, updateRoom);
+        return decoration;
+    }
+    /**
+     * Helper function to get the custom grid entities in the current room. Returns an array of tuples
+     * containing the raw decoration grid entity and the associated entity data.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
+     *
+     * @public
+     */
+    getCustomGridEntities() {
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+        if (roomCustomGridEntities === undefined) {
+            return [];
+        }
+        const room = cachedClasses_1.game.GetRoom();
+        const customGridEntities = [];
+        for (const [gridIndex, data] of roomCustomGridEntities) {
+            const gridEntity = room.GetGridEntity(gridIndex);
+            if (gridEntity !== undefined) {
+                customGridEntities.push({ gridEntity, data });
+            }
+        }
+        return customGridEntities;
+    }
+    /**
+     * Helper function to get the custom `GridEntityType` from a `GridEntity` or grid index. Returns
+     * undefined if the provided `GridEntity` is not a custom grid entity, or if there was not a grid
+     * entity on the provided grid index.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
+     *
+     * @public
+     */
+    getCustomGridEntityType(gridEntityOrGridIndex) {
+        if (!this.initialized) {
+            return undefined;
+        }
+        const gridIndex = (0, types_1.isInteger)(gridEntityOrGridIndex)
+            ? gridEntityOrGridIndex
+            : gridEntityOrGridIndex.GetGridIndex();
+        const roomListIndex = (0, roomData_1.getRoomListIndex)();
+        const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+        if (roomCustomGridEntities === undefined) {
+            return undefined;
+        }
+        for (const [_gridIndex, data] of roomCustomGridEntities) {
+            if (data.gridIndex === gridIndex) {
+                return data.gridEntityTypeCustom;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Helper function to check if a `GridEntity` is a custom grid entity or if a grid index has a
+     * custom grid entity.
+     *
+     * In order to use this function, you must upgrade your mod with
+     * `ISCFeature.CUSTOM_GRID_ENTITIES`.
+     *
+     * @public
+     */
+    isCustomGridEntity(gridEntityOrGridIndex) {
+        const gridEntityTypeCustom = this.getCustomGridEntityType(gridEntityOrGridIndex);
+        return gridEntityTypeCustom !== undefined;
+    }
+}
+exports.CustomGridEntities = CustomGridEntities;
+__decorate([
+    decorators_1.Exported
+], CustomGridEntities.prototype, "spawnCustomGridEntity", null);
+__decorate([
+    decorators_1.Exported
+], CustomGridEntities.prototype, "removeCustomGridEntity", null);
+__decorate([
+    decorators_1.Exported
+], CustomGridEntities.prototype, "getCustomGridEntities", null);
+__decorate([
+    decorators_1.Exported
+], CustomGridEntities.prototype, "getCustomGridEntityType", null);
+__decorate([
+    decorators_1.Exported
+], CustomGridEntities.prototype, "isCustomGridEntity", null);

package/dist/classes/features/callbackLogic/CustomRevive.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomRevive = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const ISCFeature_1 = require("../../../enums/ISCFeature");
+const ModCallbackCustom_1 = require("../../../enums/ModCallbackCustom");
+const external_1 = require("../../../functions/external");
+const log_1 = require("../../../functions/log");
+const playerIndex_1 = require("../../../functions/playerIndex");
+const players_1 = require("../../../functions/players");
+const Feature_1 = require("../../private/Feature");
+const DEBUG = false;
+var CustomReviveState;
+(function (CustomReviveState) {
+    CustomReviveState[CustomReviveState["DISABLED"] = 0] = "DISABLED";
+    /**
+     * We can't immediately jump to waiting for an item animation because it is possible for a player
+     * to be holding an item above their head as they are dying (e.g. with Razor Blade).
+     */
+    CustomReviveState[CustomReviveState["WAITING_FOR_ROOM_TRANSITION"] = 1] = "WAITING_FOR_ROOM_TRANSITION";
+    CustomReviveState[CustomReviveState["WAITING_FOR_ITEM_ANIMATION"] = 2] = "WAITING_FOR_ITEM_ANIMATION";
+})(CustomReviveState || (CustomReviveState = {}));
+const v = {
+    run: {
+        state: CustomReviveState.DISABLED,
+        revivalType: null,
+        dyingPlayerIndex: null,
+    },
+};
+class CustomRevive extends Feature_1.Feature {
+    v = v;
+    preCustomRevive;
+    postCustomRevive;
+    runInNFrames;
+    constructor(preCustomRevive, postCustomRevive, runInNFrames) {
+        super();
+        this.featuresUsed = [ISCFeature_1.ISCFeature.RUN_IN_N_FRAMES];
+        this.callbacksUsed = [
+            // 2
+            [isaac_typescript_definitions_1.ModCallback.POST_RENDER, this.postRender],
+            // 7
+            [
+                isaac_typescript_definitions_1.ModCallback.POST_FAMILIAR_INIT,
+                this.postFamiliarInitOneUp,
+                [isaac_typescript_definitions_1.FamiliarVariant.ONE_UP],
+            ],
+        ];
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_NEW_ROOM_REORDERED, this.postNewRoomReordered],
+            [
+                ModCallbackCustom_1.ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+                this.postPEffectUpdateReordered,
+            ],
+            [ModCallbackCustom_1.ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE, this.postPlayerFatalDamage],
+            [ModCallbackCustom_1.ModCallbackCustom.PRE_BERSERK_DEATH, this.preBerserkDeath],
+        ];
+        this.preCustomRevive = preCustomRevive;
+        this.postCustomRevive = postCustomRevive;
+        this.runInNFrames = runInNFrames;
+    }
+    // ModCallback.POST_RENDER (2)
+    postRender = () => {
+        if (v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
+            return;
+        }
+        // The 1-up sound will fire before the item holding animation begins, so we mute it on every
+        // render frame.
+        cachedClasses_1.sfxManager.Stop(isaac_typescript_definitions_1.SoundEffect.ONE_UP);
+    };
+    // ModCallback.POST_FAMILIAR_INIT (7)
+    // FamiliarVariant.ONE_UP (41)
+    postFamiliarInitOneUp = (familiar) => {
+        if (v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
+            return;
+        }
+        familiar.Remove();
+    };
+    // ModCallbackCustom.POST_NEW_ROOM_REORDERED
+    postNewRoomReordered = () => {
+        if (v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
+            return;
+        }
+        v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION;
+        this.logStateChanged();
+    };
+    // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+    postPEffectUpdateReordered = (player) => {
+        this.checkWaitingForItemAnimation(player);
+    };
+    checkWaitingForItemAnimation(player) {
+        if (v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
+            return;
+        }
+        if (v.run.dyingPlayerIndex === null) {
+            return;
+        }
+        const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+        if (playerIndex !== v.run.dyingPlayerIndex) {
+            return;
+        }
+        let playerToCheckHoldingItem = player;
+        if ((0, players_1.isCharacter)(player, isaac_typescript_definitions_1.PlayerType.SOUL_B)) {
+            const forgottenBody = player.GetOtherTwin();
+            if (forgottenBody !== undefined) {
+                playerToCheckHoldingItem = forgottenBody;
+            }
+        }
+        if (!playerToCheckHoldingItem.IsHoldingItem()) {
+            return;
+        }
+        // The player is now playing the animation where they hold the 1-Up item overhead. The
+        // `EntityPlayer.StopExtraAnimation` method will not work to stop this animation. End-users are
+        // expected to play a new animation in the PostCustomRevive callback, which will overwrite the
+        // 1-Up animation.
+        if (v.run.revivalType !== null) {
+            this.postCustomRevive.fire(playerToCheckHoldingItem, v.run.revivalType);
+        }
+        v.run.state = CustomReviveState.DISABLED;
+        v.run.revivalType = null;
+        v.run.dyingPlayerIndex = null;
+        this.logStateChanged();
+    }
+    // ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE
+    postPlayerFatalDamage = (player) => {
+        this.playerIsAboutToDie(player);
+        return undefined;
+    };
+    // ModCallbackCustom.PRE_BERSERK_DEATH
+    preBerserkDeath = (player) => {
+        this.playerIsAboutToDie(player);
+    };
+    /**
+     * The player is about to die, which will immediately delete the save data for the run. To prevent
+     * this from happening, we grant the 1-Up item.
+     */
+    playerIsAboutToDie(player) {
+        const revivalType = this.preCustomRevive.fire(player);
+        if (revivalType === undefined) {
+            return;
+        }
+        v.run.state = CustomReviveState.WAITING_FOR_ROOM_TRANSITION;
+        v.run.revivalType = revivalType;
+        v.run.dyingPlayerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+        this.logStateChanged();
+        player.AddCollectible(isaac_typescript_definitions_1.CollectibleType.ONE_UP, 0, false);
+        (0, external_1.rebirthItemTrackerRemoveCollectible)(isaac_typescript_definitions_1.CollectibleType.ONE_UP);
+        // The player should always be dead one frame from now. If they are not, then something has gone
+        // wrong, probably with the `isDamageToPlayerFatal` function. Since end-user code is already
+        // assuming that a custom revive is occurring, explicitly kill the player.
+        const playerIndex = (0, playerIndex_1.getPlayerIndex)(player);
+        this.runInNFrames.runNextGameFrame(() => {
+            const futurePlayer = (0, playerIndex_1.getPlayerFromIndex)(playerIndex);
+            if (futurePlayer === undefined) {
+                return;
+            }
+            if (futurePlayer.IsDead()) {
+                return;
+            }
+            (0, log_1.logError)("The player is still alive after initializing a custom revive. Explicitly killing the player.");
+            futurePlayer.Kill();
+        });
+    }
+    logStateChanged() {
+        if (DEBUG) {
+            (0, log_1.log)(`Custom revive state changed: ${CustomReviveState[v.run.state]} (${v.run.state})`);
+        }
+    }
+}
+exports.CustomRevive = CustomRevive;

package/dist/classes/features/callbackLogic/EsauJrDetection.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EsauJrDetection = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../core/cachedClasses");
+const players_1 = require("../../../functions/players");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        usedEsauJrFrame: null,
+        usedEsauJrControllerIndex: null,
+        usedEsauJrAtLeastOnce: false,
+    },
+};
+class EsauJrDetection extends Feature_1.Feature {
+    v = v;
+    postEsauJr;
+    postFirstEsauJr;
+    constructor(postEsauJr, postFirstEsauJr) {
+        super();
+        this.callbacksUsed = [
+            // 1
+            [isaac_typescript_definitions_1.ModCallback.POST_UPDATE, this.postUpdate],
+            // 3
+            [
+                isaac_typescript_definitions_1.ModCallback.POST_USE_ITEM,
+                this.postUseItemEsauJr,
+                [isaac_typescript_definitions_1.CollectibleType.ESAU_JR],
+            ],
+        ];
+        this.postEsauJr = postEsauJr;
+        this.postFirstEsauJr = postFirstEsauJr;
+    }
+    // ModCallback.POST_UPDATE (1)
+    postUpdate = () => {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        // Check to see if it is the frame after the player has used Esau Jr.
+        if (v.run.usedEsauJrFrame === null ||
+            gameFrameCount < v.run.usedEsauJrFrame + 1) {
+            return;
+        }
+        v.run.usedEsauJrFrame = null;
+        // Find the player corresponding to the player who used Esau Jr. a frame ago (via matching the
+        // ControllerIndex).
+        if (v.run.usedEsauJrControllerIndex === null) {
+            return;
+        }
+        const players = (0, players_1.getPlayersWithControllerIndex)(v.run.usedEsauJrControllerIndex);
+        v.run.usedEsauJrControllerIndex = null;
+        const player = players[0];
+        if (player === undefined) {
+            return;
+        }
+        if (!v.run.usedEsauJrAtLeastOnce) {
+            v.run.usedEsauJrAtLeastOnce = true;
+            this.postFirstEsauJr.fire(player);
+        }
+        this.postEsauJr.fire(player);
+    };
+    // ModCallback.POST_USE_ITEM (3)
+    // CollectibleType.ESAU_JR (703)
+    postUseItemEsauJr = (_collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData) => {
+        const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+        // The player only changes to Esau Jr. on the frame after the item is used.
+        v.run.usedEsauJrFrame = gameFrameCount + 1;
+        v.run.usedEsauJrControllerIndex = player.ControllerIndex;
+        return undefined;
+    };
+}
+exports.EsauJrDetection = EsauJrDetection;

package/dist/classes/features/callbackLogic/FlipDetection.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlipDetection = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const players_1 = require("../../../functions/players");
+const Feature_1 = require("../../private/Feature");
+const v = {
+    run: {
+        /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
+        usedFlipAtLeastOnce: false,
+    },
+};
+class FlipDetection extends Feature_1.Feature {
+    v = v;
+    postFlip;
+    postFirstFlip;
+    constructor(postFlip, postFirstFlip) {
+        super();
+        this.callbacksUsed = [
+            // 3
+            [isaac_typescript_definitions_1.ModCallback.POST_USE_ITEM, this.postUseItemFlip, [isaac_typescript_definitions_1.CollectibleType.FLIP]],
+        ];
+        this.postFlip = postFlip;
+        this.postFirstFlip = postFirstFlip;
+    }
+    // ModCallback.POST_USE_ITEM (3)
+    // CollectibleType.FLIP (711)
+    postUseItemFlip = (_collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData) => {
+        if (!(0, players_1.isTaintedLazarus)(player)) {
+            return undefined;
+        }
+        // The player passed as part of the callback will be the old Lazarus that used the Flip item. We
+        // pass the new Lazarus to the callback subscribers.
+        const newLazarus = getNewLazarus(player);
+        if (newLazarus === undefined) {
+            return undefined;
+        }
+        if (!v.run.usedFlipAtLeastOnce) {
+            v.run.usedFlipAtLeastOnce = true;
+            this.postFirstFlip.fire(newLazarus, player);
+        }
+        this.postFlip.fire(newLazarus, player);
+        return undefined;
+    };
+}
+exports.FlipDetection = FlipDetection;
+function getNewLazarus(oldLazarus) {
+    const oldCharacter = oldLazarus.GetPlayerType();
+    let newCharacter;
+    if (oldCharacter === isaac_typescript_definitions_1.PlayerType.LAZARUS_B) {
+        newCharacter = isaac_typescript_definitions_1.PlayerType.LAZARUS_2_B;
+    }
+    else if (oldCharacter === isaac_typescript_definitions_1.PlayerType.LAZARUS_2_B) {
+        newCharacter = isaac_typescript_definitions_1.PlayerType.LAZARUS_B;
+    }
+    else {
+        return undefined;
+    }
+    const playersOfType = (0, players_1.getPlayersOfType)(newCharacter);
+    return playersOfType.find((player) => player.FrameCount === oldLazarus.FrameCount);
+}