isaacscript-common 13.3.4 → 14.1.0

package/dist/src/classes/features/callbackLogic/CustomGridEntities.d.ts

@@ -0,0 +1,134 @@
+import { GridCollisionClass, GridEntityType } from "isaac-typescript-definitions";
+import { GridEntityCustomData } from "../../../interfaces/GridEntityCustomData";
+import { DefaultMap } from "../../DefaultMap";
+import { Feature } from "../../private/Feature";
+import { RunInNFrames } from "../other/RunInNFrames";
+export declare class CustomGridEntities extends Feature {
+    v: {
+        level: {
+            /** Indexed by room list index and grid index. */
+            customGridEntities: DefaultMap<number, Map<number, GridEntityCustomData>, []>;
+        };
+        room: {
+            genericPropPtrHashes: Set<PtrHash>;
+            manuallyUsingShovel: boolean;
+        };
+    };
+    private runInNFrames;
+    constructor(runInNFrames: RunInNFrames);
+    private preUseItemWeNeedToGoDeeper;
+    private postNewRoomReordered;
+    /**
+     * 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.)
+     *
+     * 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`.
+     * 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.
+     */
+    spawnCustomGridEntity(gridEntityTypeCustom: GridEntityType, gridIndexOrPosition: int | Vector, gridCollisionClass?: GridCollisionClass, anm2Path?: string, defaultAnimation?: string, baseGridEntityType?: GridEntityType, baseGridEntityVariant?: number): GridEntity;
+    /**
+     * Helper function to remove a custom grid entity created by the `spawnCustomGrid` function.
+     *
+     * @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 or not 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.
+     */
+    removeCustomGridEntity(gridIndexOrPositionOrGridEntity: int | Vector | GridEntity, updateRoom?: boolean): GridEntity | undefined;
+    /**
+     * 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.
+     */
+    getCustomGridEntities(): Array<[
+        gridEntity: GridEntity,
+        data: GridEntityCustomData
+    ]>;
+    /**
+     * 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.
+     */
+    getCustomGridEntityType(gridEntityOrGridIndex: GridEntity | int): GridEntityType | undefined;
+    /**
+     * Helper function to check if a `GridEntity` is a custom grid entity or if a grid index has a
+     * custom grid entity.
+     */
+    isCustomGridEntity(gridEntityOrGridIndex: GridEntity | int): boolean;
+}
+//# sourceMappingURL=CustomGridEntities.d.ts.map

package/dist/src/classes/features/callbackLogic/CustomGridEntities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomGridEntities.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/callbackLogic/CustomGridEntities.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAClB,cAAc,EAGf,MAAM,8BAA8B,CAAC;AAYtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,qBAAa,kBAAmB,SAAQ,OAAO;IAC7B,CAAC;;YAEb,iDAAiD;;;;;;;MAUnD;IAEF,OAAO,CAAC,YAAY,CAAe;gBAEvB,YAAY,EAAE,YAAY;IAqBtC,OAAO,CAAC,0BAA0B,CA+ChC;IAGF,OAAO,CAAC,oBAAoB,CA4B1B;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2EG;IACI,qBAAqB,CAC1B,oBAAoB,EAAE,cAAc,EACpC,mBAAmB,EAAE,GAAG,GAAG,MAAM,EACjC,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,QAAQ,CAAC,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,kBAAkB,iBAA4B,EAC9C,qBAAqB,SAAI,GACxB,UAAU;IA8Cb;;;;;;;;;;;;;;OAcG;IACI,sBAAsB,CAC3B,+BAA+B,EAAE,GAAG,GAAG,MAAM,GAAG,UAAU,EAC1D,UAAU,UAAO,GAChB,UAAU,GAAG,SAAS;IAuCzB;;;OAGG;IACI,qBAAqB,IAAI,KAAK,CACnC;QAAC,UAAU,EAAE,UAAU;QAAE,IAAI,EAAE,oBAAoB;KAAC,CACrD;IAoBD;;;;OAIG;IACI,uBAAuB,CAC5B,qBAAqB,EAAE,UAAU,GAAG,GAAG,GACtC,cAAc,GAAG,SAAS;IAyB7B;;;OAGG;IACI,kBAAkB,CAAC,qBAAqB,EAAE,UAAU,GAAG,GAAG,GAAG,OAAO;CAM5E"}

package/dist/src/classes/features/callbackLogic/CustomGridEntities.lua

@@ -0,0 +1,220 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local Set = ____lualib.Set
+local __TS__Iterator = ____lualib.__TS__Iterator
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local GridCollisionClass = ____isaac_2Dtypescript_2Ddefinitions.GridCollisionClass
+local GridEntityType = ____isaac_2Dtypescript_2Ddefinitions.GridEntityType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____ISCFeature = require("src.enums.ISCFeature")
+local ISCFeature = ____ISCFeature.ISCFeature
+local ____ModCallbackCustom2 = require("src.enums.ModCallbackCustom2")
+local ModCallbackCustom2 = ____ModCallbackCustom2.ModCallbackCustom2
+local ____gridEntities = require("src.functions.gridEntities")
+local removeGridEntity = ____gridEntities.removeGridEntity
+local spawnGridEntityWithVariant = ____gridEntities.spawnGridEntityWithVariant
+local ____players = require("src.functions.players")
+local getPlayerFromPtr = ____players.getPlayerFromPtr
+local ____roomData = require("src.functions.roomData")
+local getRoomListIndex = ____roomData.getRoomListIndex
+local ____types = require("src.functions.types")
+local isNumber = ____types.isNumber
+local ____vector = require("src.functions.vector")
+local isVector = ____vector.isVector
+local ____DefaultMap = require("src.classes.DefaultMap")
+local DefaultMap = ____DefaultMap.DefaultMap
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+____exports.CustomGridEntities = __TS__Class()
+local CustomGridEntities = ____exports.CustomGridEntities
+CustomGridEntities.name = "CustomGridEntities"
+__TS__ClassExtends(CustomGridEntities, Feature)
+function CustomGridEntities.prototype.____constructor(self, runInNFrames)
+    Feature.prototype.____constructor(self)
+    self.v = {
+        level = {customGridEntities = __TS__New(
+            DefaultMap,
+            function() return __TS__New(Map) end
+        )},
+        room = {
+            genericPropPtrHashes = __TS__New(Set),
+            manuallyUsingShovel = false
+        }
+    }
+    self.preUseItemWeNeedToGoDeeper = function(____, _collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData)
+        local room = game:GetRoom()
+        local roomListIndex = getRoomListIndex(nil)
+        local roomCustomGridEntities = self.v.level.customGridEntities:get(roomListIndex)
+        if roomCustomGridEntities == nil then
+            return nil
+        end
+        local gridIndex = room:GetGridIndex(player.Position)
+        local customGridEntity = roomCustomGridEntities:get(gridIndex)
+        if customGridEntity == nil then
+            return nil
+        end
+        if customGridEntity.gridCollisionClass ~= GridCollisionClass.NONE then
+            return nil
+        end
+        removeGridEntity(nil, customGridEntity.gridIndex, false)
+        local entityPtr = EntityPtr(player)
+        self.runInNFrames:runNextGameFrame(function()
+            local futurePlayer = getPlayerFromPtr(nil, entityPtr)
+            if futurePlayer == nil then
+                return
+            end
+            self.v.room.manuallyUsingShovel = true
+            futurePlayer:UseActiveItem(CollectibleType.WE_NEED_TO_GO_DEEPER)
+            self.v.room.manuallyUsingShovel = false
+        end)
+        return true
+    end
+    self.postNewRoomReordered = function()
+        local roomListIndex = getRoomListIndex(nil)
+        local roomCustomGridEntities = self.v.level.customGridEntities:get(roomListIndex)
+        if roomCustomGridEntities == nil then
+            return
+        end
+        local room = game:GetRoom()
+        for ____, ____value in __TS__Iterator(roomCustomGridEntities:entries()) do
+            local gridIndex = ____value[1]
+            local data = ____value[2]
+            do
+                local decoration = room:GetGridEntity(gridIndex)
+                if decoration == nil then
+                    roomCustomGridEntities:delete(gridIndex)
+                    goto __continue12
+                end
+                if data.anm2Path ~= nil then
+                    local sprite = decoration:GetSprite()
+                    sprite:Load(data.anm2Path, true)
+                    local animationToPlay = data.defaultAnimation == nil and sprite:GetDefaultAnimation() or data.defaultAnimation
+                    sprite:Play(animationToPlay, true)
+                end
+            end
+            ::__continue12::
+        end
+    end
+    self.featuresUsed = {ISCFeature.RUN_IN_N_FRAMES}
+    self.callbacksUsed = {{ModCallback.PRE_USE_ITEM, {self.preUseItemWeNeedToGoDeeper, CollectibleType.WE_NEED_TO_GO_DEEPER}}}
+    self.customCallbacksUsed = {{ModCallbackCustom2.POST_NEW_ROOM_REORDERED, {self.postNewRoomReordered}}}
+    self.runInNFrames = runInNFrames
+end
+function CustomGridEntities.prototype.spawnCustomGridEntity(self, gridEntityTypeCustom, gridIndexOrPosition, gridCollisionClass, anm2Path, defaultAnimation, baseGridEntityType, baseGridEntityVariant)
+    if baseGridEntityType == nil then
+        baseGridEntityType = GridEntityType.DECORATION
+    end
+    if baseGridEntityVariant == nil then
+        baseGridEntityVariant = 0
+    end
+    local room = game:GetRoom()
+    local roomListIndex = getRoomListIndex(nil)
+    local gridIndex = isVector(nil, gridIndexOrPosition) and room:GetGridIndex(gridIndexOrPosition) or gridIndexOrPosition
+    local customGridEntity = spawnGridEntityWithVariant(nil, baseGridEntityType, baseGridEntityVariant, gridIndexOrPosition)
+    if customGridEntity == nil then
+        error("Failed to spawn a custom grid entity.")
+    end
+    if gridCollisionClass ~= nil then
+        customGridEntity.CollisionClass = gridCollisionClass
+    end
+    if anm2Path ~= nil then
+        local sprite = customGridEntity:GetSprite()
+        sprite:Load(anm2Path, true)
+        local animationToPlay = defaultAnimation == nil and sprite:GetDefaultAnimation() or defaultAnimation
+        sprite:Play(animationToPlay, true)
+    end
+    local customGridEntityData = {
+        gridEntityTypeCustom = gridEntityTypeCustom,
+        roomListIndex = roomListIndex,
+        gridIndex = gridIndex,
+        anm2Path = anm2Path,
+        defaultAnimation = defaultAnimation,
+        gridCollisionClass = gridCollisionClass
+    }
+    local roomCustomGridEntities = self.v.level.customGridEntities:getAndSetDefault(roomListIndex)
+    roomCustomGridEntities:set(gridIndex, customGridEntityData)
+    return customGridEntity
+end
+function CustomGridEntities.prototype.removeCustomGridEntity(self, gridIndexOrPositionOrGridEntity, updateRoom)
+    if updateRoom == nil then
+        updateRoom = true
+    end
+    local room = game:GetRoom()
+    local roomListIndex = getRoomListIndex(nil)
+    local decoration
+    if type(gridIndexOrPositionOrGridEntity) == "number" then
+        local gridIndex = gridIndexOrPositionOrGridEntity
+        local gridEntity = room:GetGridEntity(gridIndex)
+        if gridEntity == nil then
+            return nil
+        end
+        decoration = gridEntity
+    elseif isVector(nil, gridIndexOrPositionOrGridEntity) then
+        local position = gridIndexOrPositionOrGridEntity
+        local gridEntity = room:GetGridEntityFromPos(position)
+        if gridEntity == nil then
+            return nil
+        end
+        decoration = gridEntity
+    else
+        decoration = gridIndexOrPositionOrGridEntity
+    end
+    local gridIndex = decoration:GetGridIndex()
+    local roomCustomGridEntities = self.v.level.customGridEntities:getAndSetDefault(roomListIndex)
+    local exists = roomCustomGridEntities:has(gridIndex)
+    if not exists then
+        return nil
+    end
+    roomCustomGridEntities:delete(gridIndex)
+    removeGridEntity(nil, decoration, updateRoom)
+    return decoration
+end
+function CustomGridEntities.prototype.getCustomGridEntities(self)
+    local roomListIndex = getRoomListIndex(nil)
+    local roomCustomGridEntities = self.v.level.customGridEntities:get(roomListIndex)
+    if roomCustomGridEntities == nil then
+        return {}
+    end
+    local room = game:GetRoom()
+    local customGridEntities = {}
+    for ____, ____value in __TS__Iterator(roomCustomGridEntities:entries()) do
+        local gridIndex = ____value[1]
+        local data = ____value[2]
+        local gridEntity = room:GetGridEntity(gridIndex)
+        if gridEntity ~= nil then
+            customGridEntities[#customGridEntities + 1] = {gridEntity, data}
+        end
+    end
+    return customGridEntities
+end
+function CustomGridEntities.prototype.getCustomGridEntityType(self, gridEntityOrGridIndex)
+    if not self.initialized then
+        return nil
+    end
+    local gridIndex = isNumber(nil, gridEntityOrGridIndex) and gridEntityOrGridIndex or gridEntityOrGridIndex:GetGridIndex()
+    local roomListIndex = getRoomListIndex(nil)
+    local roomCustomGridEntities = self.v.level.customGridEntities:get(roomListIndex)
+    if roomCustomGridEntities == nil then
+        return nil
+    end
+    for ____, ____value in __TS__Iterator(roomCustomGridEntities:entries()) do
+        local _gridIndex = ____value[1]
+        local data = ____value[2]
+        if data.gridIndex == gridIndex then
+            return data.gridEntityTypeCustom
+        end
+    end
+    return nil
+end
+function CustomGridEntities.prototype.isCustomGridEntity(self, gridEntityOrGridIndex)
+    local gridEntityTypeCustom = self:getCustomGridEntityType(gridEntityOrGridIndex)
+    return gridEntityTypeCustom ~= nil
+end
+return ____exports

package/dist/src/classes/features/callbackLogic/CustomRevive.d.ts

@@ -0,0 +1,39 @@
+import { PlayerIndex } from "../../../types/PlayerIndex";
+import { PostCustomRevive } from "../../callbacks/PostCustomRevive";
+import { PreCustomRevive } from "../../callbacks/PreCustomRevive";
+import { Feature } from "../../private/Feature";
+declare enum CustomReviveState {
+    DISABLED = 0,
+    /**
+     * 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).
+     */
+    WAITING_FOR_ROOM_TRANSITION = 1,
+    WAITING_FOR_ITEM_ANIMATION = 2
+}
+export declare class CustomRevive extends Feature {
+    v: {
+        run: {
+            state: CustomReviveState;
+            revivalType: number | null;
+            dyingPlayerIndex: PlayerIndex | null;
+        };
+    };
+    private preCustomRevive;
+    private postCustomRevive;
+    constructor(preCustomRevive: PreCustomRevive, postCustomRevive: PostCustomRevive);
+    private postRender;
+    private postNewRoomReordered;
+    private postPEffectUpdateReordered;
+    private checkWaitingForItemAnimation;
+    private postPlayerFatalDamage;
+    private preBerserkDeath;
+    /**
+     * 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.
+     */
+    private playerIsAboutToDie;
+    private logStateChanged;
+}
+export {};
+//# sourceMappingURL=CustomRevive.d.ts.map

package/dist/src/classes/features/callbackLogic/CustomRevive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomRevive.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/callbackLogic/CustomRevive.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAIhD,aAAK,iBAAiB;IACpB,QAAQ,IAAA;IAER;;;OAGG;IACH,2BAA2B,IAAA;IAE3B,0BAA0B,IAAA;CAC3B;AAED,qBAAa,YAAa,SAAQ,OAAO;IACvB,CAAC;;;;;;MAMf;IAEF,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,gBAAgB,CAAmB;gBAGzC,eAAe,EAAE,eAAe,EAChC,gBAAgB,EAAE,gBAAgB;IA0BpC,OAAO,CAAC,UAAU,CAQhB;IAGF,OAAO,CAAC,oBAAoB,CAO1B;IAGF,OAAO,CAAC,0BAA0B,CAEhC;IAEF,OAAO,CAAC,4BAA4B;IA6CpC,OAAO,CAAC,qBAAqB,CAK3B;IAGF,OAAO,CAAC,eAAe,CAErB;IAEF;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAoC1B,OAAO,CAAC,eAAe;CASxB"}

package/dist/src/classes/features/callbackLogic/CustomRevive.lua

@@ -0,0 +1,140 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local FamiliarVariant = ____isaac_2Dtypescript_2Ddefinitions.FamiliarVariant
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
+local SoundEffect = ____isaac_2Dtypescript_2Ddefinitions.SoundEffect
+local ____cachedClasses = require("src.core.cachedClasses")
+local sfxManager = ____cachedClasses.sfxManager
+local ____ModCallbackCustom2 = require("src.enums.ModCallbackCustom2")
+local ModCallbackCustom2 = ____ModCallbackCustom2.ModCallbackCustom2
+local ____runInNFrames = require("src.features.runInNFrames")
+local runNextGameFrame = ____runInNFrames.runNextGameFrame
+local ____collectibles = require("src.functions.collectibles")
+local removeCollectibleFromItemTracker = ____collectibles.removeCollectibleFromItemTracker
+local ____entitiesSpecific = require("src.functions.entitiesSpecific")
+local removeAllFamiliars = ____entitiesSpecific.removeAllFamiliars
+local ____log = require("src.functions.log")
+local log = ____log.log
+local ____logMisc = require("src.functions.logMisc")
+local logError = ____logMisc.logError
+local ____playerIndex = require("src.functions.playerIndex")
+local getPlayerFromIndex = ____playerIndex.getPlayerFromIndex
+local getPlayerIndex = ____playerIndex.getPlayerIndex
+local ____players = require("src.functions.players")
+local isCharacter = ____players.isCharacter
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+local DEBUG = false
+local CustomReviveState = {}
+CustomReviveState.DISABLED = 0
+CustomReviveState[CustomReviveState.DISABLED] = "DISABLED"
+CustomReviveState.WAITING_FOR_ROOM_TRANSITION = 1
+CustomReviveState[CustomReviveState.WAITING_FOR_ROOM_TRANSITION] = "WAITING_FOR_ROOM_TRANSITION"
+CustomReviveState.WAITING_FOR_ITEM_ANIMATION = 2
+CustomReviveState[CustomReviveState.WAITING_FOR_ITEM_ANIMATION] = "WAITING_FOR_ITEM_ANIMATION"
+____exports.CustomRevive = __TS__Class()
+local CustomRevive = ____exports.CustomRevive
+CustomRevive.name = "CustomRevive"
+__TS__ClassExtends(CustomRevive, Feature)
+function CustomRevive.prototype.____constructor(self, preCustomRevive, postCustomRevive)
+    Feature.prototype.____constructor(self)
+    self.v = {run = {state = CustomReviveState.DISABLED, revivalType = nil, dyingPlayerIndex = nil}}
+    self.postRender = function()
+        if self.v.run.state ~= CustomReviveState.WAITING_FOR_ITEM_ANIMATION then
+            return
+        end
+        sfxManager:Stop(SoundEffect.ONE_UP)
+    end
+    self.postNewRoomReordered = function()
+        if self.v.run.state ~= CustomReviveState.WAITING_FOR_ROOM_TRANSITION then
+            return
+        end
+        self.v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION
+        self:logStateChanged()
+    end
+    self.postPEffectUpdateReordered = function(____, player)
+        self:checkWaitingForItemAnimation(player)
+    end
+    self.postPlayerFatalDamage = function(____, player)
+        self:playerIsAboutToDie(player)
+        return nil
+    end
+    self.preBerserkDeath = function(____, player)
+        self:playerIsAboutToDie(player)
+    end
+    self.callbacksUsed = {{ModCallback.POST_RENDER, {self.postRender}}}
+    self.customCallbacksUsed = {{ModCallbackCustom2.POST_NEW_ROOM_REORDERED, {self.postNewRoomReordered}}, {ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED, {self.postPEffectUpdateReordered}}, {ModCallbackCustom2.POST_PLAYER_FATAL_DAMAGE, {self.postPlayerFatalDamage}}, {ModCallbackCustom2.PRE_BERSERK_DEATH, {self.preBerserkDeath}}}
+    self.preCustomRevive = preCustomRevive
+    self.postCustomRevive = postCustomRevive
+end
+function CustomRevive.prototype.checkWaitingForItemAnimation(self, player)
+    if self.v.run.state ~= CustomReviveState.WAITING_FOR_ITEM_ANIMATION then
+        return
+    end
+    if self.v.run.dyingPlayerIndex == nil then
+        return
+    end
+    local playerIndex = getPlayerIndex(nil, player)
+    if playerIndex ~= self.v.run.dyingPlayerIndex then
+        return
+    end
+    local playerToCheckHoldingItem = player
+    if isCharacter(nil, player, PlayerType.SOUL_B) then
+        local forgottenBody = player:GetOtherTwin()
+        if forgottenBody ~= nil then
+            playerToCheckHoldingItem = forgottenBody
+        end
+    end
+    if not playerToCheckHoldingItem:IsHoldingItem() then
+        return
+    end
+    if self.v.run.revivalType ~= nil then
+        self.postCustomRevive:fire(playerToCheckHoldingItem, self.v.run.revivalType)
+    end
+    self.v.run.state = CustomReviveState.DISABLED
+    self.v.run.revivalType = nil
+    self.v.run.dyingPlayerIndex = nil
+    self:logStateChanged()
+end
+function CustomRevive.prototype.playerIsAboutToDie(self, player)
+    local revivalType = self.preCustomRevive:fire(player)
+    if revivalType == nil then
+        return
+    end
+    self.v.run.state = CustomReviveState.WAITING_FOR_ROOM_TRANSITION
+    self.v.run.revivalType = revivalType
+    self.v.run.dyingPlayerIndex = getPlayerIndex(nil, player)
+    self:logStateChanged()
+    player:AddCollectible(CollectibleType.ONE_UP, 0, false)
+    removeAllFamiliars(nil, FamiliarVariant.ONE_UP)
+    removeCollectibleFromItemTracker(nil, CollectibleType.ONE_UP)
+    local playerIndex = getPlayerIndex(nil, player)
+    runNextGameFrame(
+        nil,
+        function()
+            local futurePlayer = getPlayerFromIndex(nil, playerIndex)
+            if futurePlayer == nil then
+                return
+            end
+            if futurePlayer:IsDead() then
+                return
+            end
+            logError(nil, "The player is still alive after initializing a custom revive. Explicitly killing the player.")
+            futurePlayer:Kill()
+        end
+    )
+end
+function CustomRevive.prototype.logStateChanged(self)
+    if DEBUG then
+        log(
+            nil,
+            ((("Custom revive state changed: " .. tostring(CustomReviveState[self.v.run.state])) .. " (") .. tostring(self.v.run.state)) .. ")"
+        )
+    end
+end
+return ____exports

package/dist/src/classes/features/callbackLogic/EsauJrDetection.d.ts

@@ -0,0 +1,19 @@
+import { ControllerIndex } from "isaac-typescript-definitions";
+import { PostEsauJr } from "../../callbacks/PostEsauJr";
+import { PostFirstEsauJr } from "../../callbacks/PostFirstEsauJr";
+import { Feature } from "../../private/Feature";
+export declare class EsauJrDetection extends Feature {
+    v: {
+        run: {
+            usedEsauJrFrame: number | null;
+            usedEsauJrControllerIndex: ControllerIndex | null;
+            usedEsauJrAtLeastOnce: boolean;
+        };
+    };
+    private postEsauJr;
+    private postFirstEsauJr;
+    constructor(postEsauJr: PostEsauJr, postFirstEsauJr: PostFirstEsauJr);
+    private postUpdate;
+    private useItemEsauJr;
+}
+//# sourceMappingURL=EsauJrDetection.d.ts.map

package/dist/src/classes/features/callbackLogic/EsauJrDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EsauJrDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/callbackLogic/EsauJrDetection.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,eAAe,EAGhB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,qBAAa,eAAgB,SAAQ,OAAO;IAC1B,CAAC;;;;;;MAMf;IAEF,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,eAAe,CAAkB;gBAE7B,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,eAAe;IAgBpE,OAAO,CAAC,UAAU,CAiChB;IAIF,OAAO,CAAC,aAAa,CAenB;CACH"}

package/dist/src/classes/features/callbackLogic/EsauJrDetection.lua

@@ -0,0 +1,52 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____players = require("src.functions.players")
+local getPlayersWithControllerIndex = ____players.getPlayersWithControllerIndex
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+____exports.EsauJrDetection = __TS__Class()
+local EsauJrDetection = ____exports.EsauJrDetection
+EsauJrDetection.name = "EsauJrDetection"
+__TS__ClassExtends(EsauJrDetection, Feature)
+function EsauJrDetection.prototype.____constructor(self, postEsauJr, postFirstEsauJr)
+    Feature.prototype.____constructor(self)
+    self.v = {run = {usedEsauJrFrame = nil, usedEsauJrControllerIndex = nil, usedEsauJrAtLeastOnce = false}}
+    self.postUpdate = function()
+        local gameFrameCount = game:GetFrameCount()
+        if self.v.run.usedEsauJrFrame == nil or gameFrameCount < self.v.run.usedEsauJrFrame + 1 then
+            return
+        end
+        self.v.run.usedEsauJrFrame = nil
+        if self.v.run.usedEsauJrControllerIndex == nil then
+            return
+        end
+        local players = getPlayersWithControllerIndex(nil, self.v.run.usedEsauJrControllerIndex)
+        self.v.run.usedEsauJrControllerIndex = nil
+        local player = players[1]
+        if player == nil then
+            return
+        end
+        if not self.v.run.usedEsauJrAtLeastOnce then
+            self.v.run.usedEsauJrAtLeastOnce = true
+            self.postFirstEsauJr:fire(player)
+        end
+        self.postEsauJr:fire(player)
+    end
+    self.useItemEsauJr = function(____, _collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData)
+        local gameFrameCount = game:GetFrameCount()
+        self.v.run.usedEsauJrFrame = gameFrameCount + 1
+        self.v.run.usedEsauJrControllerIndex = player.ControllerIndex
+        return nil
+    end
+    self.callbacksUsed = {{ModCallback.POST_UPDATE, {self.postUpdate}}, {ModCallback.POST_USE_ITEM, {self.useItemEsauJr, CollectibleType.ESAU_JR}}}
+    self.postEsauJr = postEsauJr
+    self.postFirstEsauJr = postFirstEsauJr
+end
+return ____exports

package/dist/src/classes/features/callbackLogic/FlipDetection.d.ts

@@ -0,0 +1,16 @@
+import { PostFirstFlip } from "../../callbacks/PostFirstFlip";
+import { PostFlip } from "../../callbacks/PostFlip";
+import { Feature } from "../../private/Feature";
+export declare class FlipDetection extends Feature {
+    v: {
+        run: {
+            /** We don't consider the case of a multiplayer game with more than one Tainted Lazarus. */
+            usedFlipAtLeastOnce: boolean;
+        };
+    };
+    private postFlip;
+    private postFirstFlip;
+    constructor(postFlip: PostFlip, postFirstFlip: PostFirstFlip);
+    private useItemFlip;
+}
+//# sourceMappingURL=FlipDetection.d.ts.map

package/dist/src/classes/features/callbackLogic/FlipDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlipDetection.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/callbackLogic/FlipDetection.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,qBAAa,aAAc,SAAQ,OAAO;IACxB,CAAC;;YAEb,2FAA2F;;;MAG7F;IAEF,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,aAAa,CAAgB;gBAEzB,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa;IAa5D,OAAO,CAAC,WAAW,CA2BjB;CACH"}