isaacscript-common 2.3.0 → 2.3.1

package/features/extraConsoleCommands/v.d.ts

@@ -0,0 +1,13 @@
+declare const v: {
+    persistent: {
+        disableCurses: boolean;
+    };
+    run: {
+        chaosCardTears: boolean;
+        spamBloodRights: boolean;
+        maxDamage: boolean;
+        maxSpeed: boolean;
+        maxTears: boolean;
+    };
+};
+export default v;

package/features/extraConsoleCommands/v.lua

@@ -0,0 +1,10 @@
+local ____exports = {}
+local v = {persistent = {disableCurses = false}, run = {
+    chaosCardTears = false,
+    spamBloodRights = false,
+    maxDamage = false,
+    maxSpeed = false,
+    maxTears = false
+}}
+____exports.default = v
+return ____exports

package/features/fadeInRemover.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Removes the fade-in that occurs at the beginning of a run. If this behavior is desired, call this
+ * function once at the beginning of your mod.
+ *
+ * This is useful for debugging, when you are resetting the game often.
+ *
+ * You can restore the vanilla behavior with the `restoreFadeIn` function.
+ */
+export declare function removeFadeIn(): void;
+/**
+ * Disables the fade-in remover. Only useful if you have previously called the `removeFadeIn`
+ * function.
+ */
+export declare function restoreFadeIn(): void;

package/features/fadeInRemover.lua

@@ -0,0 +1,45 @@
+local ____exports = {}
+local postRender, shouldRemoveFadeIn, FADE_IN_SPEED, enabled, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function postRender(self)
+    if not enabled then
+        return
+    end
+    if shouldRemoveFadeIn(nil) then
+        v.run.removedFadeIn = true
+        game:Fadein(FADE_IN_SPEED)
+    end
+end
+function shouldRemoveFadeIn(self)
+    local gameFrameCount = game:GetFrameCount()
+    return not v.run.removedFadeIn and gameFrameCount == 0
+end
+local FEATURE_NAME = "fade-in remover"
+FADE_IN_SPEED = 1
+enabled = false
+v = {run = {removedFadeIn = false}}
+function ____exports.fadeInRemoverInit(self, mod)
+    saveDataManager(
+        nil,
+        "fadeInRemover",
+        v,
+        function() return false end
+    )
+    mod:AddCallback(ModCallback.POST_RENDER, postRender)
+end
+function ____exports.removeFadeIn(self)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    enabled = true
+end
+function ____exports.restoreFadeIn(self)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    enabled = false
+end
+return ____exports

package/features/fastReset.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Enables the fast-reset feature, which allows you to restart the game instantaneously. If this
+ * behavior is desired, call this function once at the beginning of your mod.
+ *
+ * This is useful for debugging, when you are resetting the game often.
+ *
+ * You can disable the fast-reset feature with the `disableFastReset` function.
+ */
+export declare function enableFastReset(): void;
+/**
+ * Disables the fast-reset feature. Only useful if you have previously called the `enableFastReset`
+ * function.
+ */
+export declare function disableFastReset(): void;

package/features/fastReset.lua

@@ -0,0 +1,49 @@
+local ____exports = {}
+local postRender, checkResetInput, enabled
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ButtonAction = ____isaac_2Dtypescript_2Ddefinitions.ButtonAction
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____input = require("functions.input")
+local isActionTriggeredOnAnyInput = ____input.isActionTriggeredOnAnyInput
+local isModifierKeyPressed = ____input.isModifierKeyPressed
+local ____run = require("functions.run")
+local restart = ____run.restart
+function postRender(self)
+    if not enabled then
+        return
+    end
+    checkResetInput(nil)
+end
+function checkResetInput(self)
+    local isPaused = game:IsPaused()
+    if isPaused then
+        return
+    end
+    if AwaitingTextInput then
+        return
+    end
+    if isModifierKeyPressed(nil) then
+        return
+    end
+    if isActionTriggeredOnAnyInput(nil, ButtonAction.RESTART) then
+        restart(nil)
+    end
+end
+local FEATURE_NAME = "fast reset"
+enabled = false
+function ____exports.fastResetInit(self, mod)
+    mod:AddCallback(ModCallback.POST_RENDER, postRender)
+end
+function ____exports.enableFastReset(self)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    enabled = true
+end
+function ____exports.disableFastReset(self)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    enabled = false
+end
+return ____exports

package/features/forgottenSwitch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * When used on The Forgotten, switches to The Soul. When used on The Soul, switches to The
+ * Forgotten. This takes 1 game frame to take effect.
+ */
+export declare function forgottenSwitch(): void;

package/features/forgottenSwitch.lua

@@ -0,0 +1,28 @@
+local ____exports = {}
+local isActionTriggered, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ButtonAction = ____isaac_2Dtypescript_2Ddefinitions.ButtonAction
+local InputHook = ____isaac_2Dtypescript_2Ddefinitions.InputHook
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function isActionTriggered(self, _entity, _inputHook, buttonAction)
+    if buttonAction == ButtonAction.DROP and v.run.shouldSwitch then
+        v.run.shouldSwitch = false
+        return true
+    end
+    return nil
+end
+local FEATURE_NAME = "forgotten switcher"
+v = {run = {shouldSwitch = false}}
+function ____exports.forgottenSwitchInit(self, mod)
+    saveDataManager(nil, "forgottenSwitch", v)
+    mod:AddCallback(ModCallback.INPUT_ACTION, isActionTriggered, InputHook.IS_ACTION_TRIGGERED)
+end
+function ____exports.forgottenSwitch(self)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    v.run.shouldSwitch = true
+end
+return ____exports

package/features/getCollectibleItemPoolType.d.ts

@@ -0,0 +1,7 @@
+import { ItemPoolType } from "isaac-typescript-definitions";
+/**
+ * Helper function to get the item pool type that a given collectible came from. Since there is no
+ * native method in the API to get this, we listen in the PreGetCollectible callback for item pool
+ * types, and then assume that the next spawned collectible will match.
+ */
+export declare function getCollectibleItemPoolType(collectible: EntityPickup): ItemPoolType;

package/features/getCollectibleItemPoolType.lua

@@ -0,0 +1,43 @@
+local ____lualib = require("lualib_bundle")
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local postPickupInitCollectible, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____entity = require("functions.entity")
+local getEntityID = ____entity.getEntityID
+local ____pickupVariants = require("functions.pickupVariants")
+local isCollectible = ____pickupVariants.isCollectible
+local ____rooms = require("functions.rooms")
+local getRoomItemPoolType = ____rooms.getRoomItemPoolType
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function postPickupInitCollectible(self, pickup)
+    local itemPool = game:GetItemPool()
+    local ptrHash = GetPtrHash(pickup)
+    local lastItemPoolType = itemPool:GetLastPool()
+    v.run.collectibleItemPoolTypeMap:set(ptrHash, lastItemPoolType)
+end
+local FEATURE_NAME = "get collectible item pool type"
+v = {run = {collectibleItemPoolTypeMap = __TS__New(Map)}}
+function ____exports.getCollectibleItemPoolTypeInit(self, mod)
+    saveDataManager(nil, "getCollectibleItemPoolType", v)
+    mod:AddCallback(ModCallback.POST_PICKUP_INIT, postPickupInitCollectible, PickupVariant.COLLECTIBLE)
+end
+function ____exports.getCollectibleItemPoolType(self, collectible)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    if not isCollectible(nil, collectible) then
+        local entityID = getEntityID(nil, collectible)
+        error("The \"getCollectibleItemPoolType\" function was given a non-collectible: " .. entityID)
+    end
+    local ptrHash = GetPtrHash(collectible)
+    local itemPoolType = v.run.collectibleItemPoolTypeMap:get(ptrHash)
+    return itemPoolType == nil and getRoomItemPoolType(nil) or itemPoolType
+end
+return ____exports

package/features/playerInventory.d.ts

@@ -0,0 +1,23 @@
+import { ActiveSlot, CollectibleType } from "isaac-typescript-definitions";
+/**
+ * Helper function to get all of the collectibles that the player has gotten so far on this run, in
+ * order.
+ *
+ * Note that this does not include active collectibles that have since been dropped for other
+ * collectibles.
+ *
+ * In the case of inventory initialization or the case where the player rerolls their build in the
+ * middle of the run (e.g. with D4), the order of the inventory will not correspond to the order
+ * that the items were actually given to the player. In this case, the inventory will be in the
+ * order of the lowest `CollectibleType` to the highest.
+ */
+export declare function getPlayerInventory(player: EntityPlayer, includeActiveCollectibles?: boolean): CollectibleType[];
+/**
+ * Helper function to add a collectible to a player. Use this instead of the
+ * `EntityPlayer.AddCollectible` method if you want the collectible that is added to be
+ * automatically tracked by the player inventory tracker feature.
+ *
+ * You only need to use this function if you are using the inventory feature from the standard
+ * library.
+ */
+export declare function addCollectible(player: EntityPlayer, collectibleType: CollectibleType, charge?: int, firstTimePickingUp?: boolean, activeSlot?: ActiveSlot, varData?: int): void;

package/features/playerInventory.lua

@@ -0,0 +1,129 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local Set = ____lualib.Set
+local __TS__Iterator = ____lualib.__TS__Iterator
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local ____exports = {}
+local newPlayerInventory, useItemD4, postGameStarted, postItemPickup, addCollectibleToInventory, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____DefaultMap = require("classes.DefaultMap")
+local DefaultMap = ____DefaultMap.DefaultMap
+local ____ModCallbackCustom = require("enums.ModCallbackCustom")
+local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____array = require("functions.array")
+local arrayRemoveInPlace = ____array.arrayRemoveInPlace
+local copyArray = ____array.copyArray
+local ____collectibles = require("functions.collectibles")
+local isActiveCollectible = ____collectibles.isActiveCollectible
+local ____collectibleSet = require("functions.collectibleSet")
+local getCollectibleSet = ____collectibleSet.getCollectibleSet
+local ____playerIndex = require("functions.playerIndex")
+local getAllPlayers = ____playerIndex.getAllPlayers
+local getPlayerIndex = ____playerIndex.getPlayerIndex
+local ____utils = require("functions.utils")
+local ____repeat = ____utils["repeat"]
+local ____PickingUpItem = require("types.PickingUpItem")
+local pickingUpItemIsCollectible = ____PickingUpItem.pickingUpItemIsCollectible
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function newPlayerInventory(self, player)
+    local inventory = {}
+    local collectibleSet = getCollectibleSet(nil)
+    for ____, collectibleType in __TS__Iterator(collectibleSet:values()) do
+        local numCollectibles = player:GetCollectibleNum(collectibleType, true)
+        ____repeat(
+            nil,
+            numCollectibles,
+            function()
+                inventory[#inventory + 1] = collectibleType
+            end
+        )
+    end
+    return inventory
+end
+function useItemD4(self, _collectibleType, _rng, player)
+    local playerIndex = getPlayerIndex(nil, player)
+    local inventory = newPlayerInventory(nil, player)
+    v.run.playersInventory:set(playerIndex, inventory)
+end
+function postGameStarted(self)
+    for ____, player in ipairs(getAllPlayers(nil)) do
+        local playerIndex = getPlayerIndex(nil, player)
+        if not v.run.playersInventory:has(playerIndex) then
+            local inventory = newPlayerInventory(nil, player)
+            v.run.playersInventory:set(playerIndex, inventory)
+        end
+    end
+end
+function postItemPickup(self, player, pickingUpItem)
+    if not pickingUpItemIsCollectible(nil, pickingUpItem) then
+        return
+    end
+    addCollectibleToInventory(nil, player, pickingUpItem.subType)
+end
+function addCollectibleToInventory(self, player, collectibleType)
+    local playerIndex = getPlayerIndex(nil, player)
+    local inventory = v.run.playersInventory:getAndSetDefault(playerIndex, player)
+    inventory[#inventory + 1] = collectibleType
+    if not isActiveCollectible(nil, collectibleType) then
+        return
+    end
+    local activeCollectibleTypes = v.run.playersActiveCollectibleTypes:getAndSetDefault(playerIndex)
+    activeCollectibleTypes[#activeCollectibleTypes + 1] = collectibleType
+    local droppedActiveCollectibleTypes = __TS__ArrayFilter(
+        activeCollectibleTypes,
+        function(____, activeCollectibleType) return not player:HasCollectible(activeCollectibleType) end
+    )
+    for ____, activeCollectibleType in ipairs(droppedActiveCollectibleTypes) do
+        arrayRemoveInPlace(nil, inventory, activeCollectibleType)
+        arrayRemoveInPlace(nil, activeCollectibleTypes, activeCollectibleType)
+    end
+end
+local FEATURE_NAME = "player inventory tracker"
+v = {run = {
+    playersInventory = __TS__New(
+        DefaultMap,
+        function(____, player) return newPlayerInventory(nil, player) end
+    ),
+    playersActiveCollectibleTypes = __TS__New(
+        DefaultMap,
+        function() return {} end
+    )
+}}
+function ____exports.playerInventoryInit(self, mod)
+    saveDataManager(nil, "playerInventory", v)
+    mod:AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4)
+    mod:AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted)
+    mod:AddCallbackCustom(ModCallbackCustom.POST_ITEM_PICKUP, postItemPickup)
+end
+function ____exports.getPlayerInventory(self, player, includeActiveCollectibles)
+    if includeActiveCollectibles == nil then
+        includeActiveCollectibles = true
+    end
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    local playerIndex = getPlayerIndex(nil, player)
+    local inventory = v.run.playersInventory:getAndSetDefault(playerIndex, player)
+    local copiedInventory = copyArray(nil, inventory)
+    if includeActiveCollectibles then
+        return copiedInventory
+    end
+    return __TS__ArrayFilter(
+        copiedInventory,
+        function(____, collectibleType) return not isActiveCollectible(nil, collectibleType) end
+    )
+end
+function ____exports.addCollectible(self, player, collectibleType, charge, firstTimePickingUp, activeSlot, varData)
+    player:AddCollectible(
+        collectibleType,
+        charge,
+        firstTimePickingUp,
+        activeSlot,
+        varData
+    )
+    addCollectibleToInventory(nil, player, collectibleType)
+end
+return ____exports

package/features/ponyDetection.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="isaac-typescript-definitions" />
+/**
+ * Helper function to see if the player is under the effects of A Pony or White Pony charge.
+ * Detecting this is difficult, as the temporary effect will disappear upon entering a new room.
+ */
+export declare function isPonyActive(player: EntityPlayer): boolean;

package/features/ponyDetection.lua

@@ -0,0 +1,49 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local postPEffectUpdateReordered, FLAGS_WHEN_PONY_IS_ACTIVE, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local EntityFlag = ____isaac_2Dtypescript_2Ddefinitions.EntityFlag
+local ____ModCallbackCustom = require("enums.ModCallbackCustom")
+local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____flag = require("functions.flag")
+local hasFlag = ____flag.hasFlag
+local ____playerDataStructures = require("functions.playerDataStructures")
+local setAddPlayer = ____playerDataStructures.setAddPlayer
+local setDeletePlayer = ____playerDataStructures.setDeletePlayer
+local setHasPlayer = ____playerDataStructures.setHasPlayer
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function postPEffectUpdateReordered(self, player)
+    local effects = player:GetEffects()
+    local entityFlags = player:GetEntityFlags()
+    local hasPonyCollectibleEffect = effects:HasCollectibleEffect(CollectibleType.PONY) or effects:HasCollectibleEffect(CollectibleType.WHITE_PONY)
+    local isPonyActiveOnPreviousFrame = setHasPlayer(nil, v.run.playersIsPonyActive, player)
+    local hasPonyFlags = hasFlag(
+        nil,
+        entityFlags,
+        table.unpack(FLAGS_WHEN_PONY_IS_ACTIVE)
+    )
+    local isPonyActiveNow = hasPonyCollectibleEffect or isPonyActiveOnPreviousFrame and hasPonyFlags
+    if isPonyActiveNow then
+        setAddPlayer(nil, v.run.playersIsPonyActive, player)
+    else
+        setDeletePlayer(nil, v.run.playersIsPonyActive, player)
+    end
+end
+local FEATURE_NAME = "pony activation detector"
+FLAGS_WHEN_PONY_IS_ACTIVE = {EntityFlag.NO_KNOCKBACK, EntityFlag.NO_PHYSICS_KNOCKBACK, EntityFlag.NO_DAMAGE_BLINK}
+v = {run = {playersIsPonyActive = __TS__New(Set)}}
+function ____exports.ponyDetectionInit(self, mod)
+    saveDataManager(nil, "ponyDetection", v)
+    mod:AddCallbackCustom(ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED, postPEffectUpdateReordered)
+end
+function ____exports.isPonyActive(self, player)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    return setHasPlayer(nil, v.run.playersIsPonyActive, player)
+end
+return ____exports

package/features/preventCollectibleRotation.d.ts

@@ -0,0 +1,11 @@
+import { CollectibleType } from "isaac-typescript-definitions";
+/**
+ * Helper function to prevent a collectible from being affected by Tainted Isaac's rotation
+ * mechanic. (This mechanic also happens from Glitched Crown and Binge Eater.) This is useful
+ * because quest items that are manually spawned by mods will be automatically be affected by this
+ * mechanic.
+ *
+ * It is required to pass the intended collectible type to this function since it is possible for
+ * collectibles to rotate on the first frame that they are spawned.
+ */
+export declare function preventCollectibleRotation(collectible: EntityPickup, collectibleType: CollectibleType): void;

package/features/preventCollectibleRotation.lua

@@ -0,0 +1,58 @@
+local ____lualib = require("lualib_bundle")
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local useCardSoulOfIsaac, postPickupUpdateCollectible, getMapIndex, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local Card = ____isaac_2Dtypescript_2Ddefinitions.Card
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____collectibles = require("functions.collectibles")
+local setCollectibleSubType = ____collectibles.setCollectibleSubType
+local ____entity = require("functions.entity")
+local getEntityID = ____entity.getEntityID
+local ____pickupVariants = require("functions.pickupVariants")
+local isCollectible = ____pickupVariants.isCollectible
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function useCardSoulOfIsaac(self)
+    v.room.trackedCollectibles:clear()
+end
+function postPickupUpdateCollectible(self, collectible)
+    if collectible.SubType == CollectibleType.NULL then
+        return
+    end
+    local index = getMapIndex(nil, collectible)
+    local trackedCollectibleType = v.room.trackedCollectibles:get(index)
+    if trackedCollectibleType ~= nil and collectible.SubType ~= trackedCollectibleType then
+        setCollectibleSubType(nil, collectible, trackedCollectibleType)
+    end
+end
+function getMapIndex(self, collectible)
+    local room = game:GetRoom()
+    local gridIndex = room:GetGridIndex(collectible.Position)
+    return (tostring(gridIndex) .. ",") .. tostring(collectible.InitSeed)
+end
+local FEATURE_NAME = "prevent collectible rotation"
+v = {room = {trackedCollectibles = __TS__New(Map)}}
+function ____exports.preventCollectibleRotationInit(self, mod)
+    saveDataManager(nil, "preventCollectibleRotation", v)
+    mod:AddCallback(ModCallback.POST_USE_CARD, useCardSoulOfIsaac, Card.SOUL_ISAAC)
+    mod:AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdateCollectible, PickupVariant.COLLECTIBLE)
+end
+function ____exports.preventCollectibleRotation(self, collectible, collectibleType)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    if not isCollectible(nil, collectible) then
+        local entityID = getEntityID(nil, collectible)
+        error("The \"preventCollectibleRotate\" function was given a non-collectible: " .. entityID)
+    end
+    local index = getMapIndex(nil, collectible)
+    v.room.trackedCollectibles:set(index, collectibleType)
+    postPickupUpdateCollectible(nil, collectible)
+end
+return ____exports

package/features/runInNFrames.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="isaac-typescript-definitions" />
+/**
+ * Supply a function to run N game frames from now in the PostUpdate callback.
+ *
+ * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
+ * way.
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export declare function runInNGameFrames(func: () => void, gameFrames: int): void;
+/**
+ * Supply a function to run N render frames from now in the PostRender callback.
+ *
+ * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
+ * way.
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export declare function runInNRenderFrames(func: () => void, renderFrames: int): void;
+/**
+ * Supply a function to run on the next PostUpdate callback.
+ *
+ * For example:
+ *
+ * ```ts
+ * const NUM_EXPLODER_EXPLOSIONS = 5;
+ *
+ * function useItemExploder(player: EntityPlayer) {
+ *   playSound("exploderBegin");
+ *   explode(player, NUM_EXPLODER_EXPLOSIONS);
+ * }
+ *
+ * function explode(player: EntityPlayer, numFramesLeft: int) {
+ *   Isaac.Explode(player, undefined, 1);
+ *   numFramesLeft -= 1;
+ *   if (numFramesLeft === 0) {
+ *     runNextFrame(() => {
+ *       explode(player, numFramesLeft);
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * Note that this function will not handle saving and quitting. If a player saving and quitting
+ * before the deferred function fires would cause a bug in your mod, then you should handle deferred
+ * functions manually using serializable data.
+ */
+export declare function runNextGameFrame(func: () => void): void;
+/**
+ * Supply a function to run on the next PostRender callback.
+ *
+ * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a similar
+ * way.
+ *
+ * Note that this function will not handle saving and quitting.
+ */
+export declare function runNextRenderFrame(func: () => void): void;

package/features/runInNFrames.lua

@@ -0,0 +1,78 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
+local __TS__ArraySplice = ____lualib.__TS__ArraySplice
+local ____exports = {}
+local postUpdate, postRender, checkExecuteQueuedFunctions, v
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____featuresInitialized = require("featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____exports = require("features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function postUpdate(self)
+    local gameFrameCount = game:GetFrameCount()
+    checkExecuteQueuedFunctions(nil, gameFrameCount, v.run.queuedGameFunctionTuples)
+end
+function postRender(self)
+    local renderFrameCount = Isaac.GetFrameCount()
+    checkExecuteQueuedFunctions(nil, renderFrameCount, v.run.queuedRenderFunctionTuples)
+end
+function checkExecuteQueuedFunctions(self, frameCount, functionTuples)
+    local functionsToFire = {}
+    local indexesToRemove = {}
+    __TS__ArrayForEach(
+        functionTuples,
+        function(____, functionTuple, i)
+            local frame, func = table.unpack(functionTuple)
+            if frameCount >= frame then
+                functionsToFire[#functionsToFire + 1] = func
+                indexesToRemove[#indexesToRemove + 1] = i
+            end
+        end
+    )
+    for ____, indexToRemove in ipairs(indexesToRemove) do
+        __TS__ArraySplice(functionTuples, indexToRemove, 1)
+    end
+    for ____, func in ipairs(functionsToFire) do
+        func(nil)
+    end
+end
+local FEATURE_NAME = "run in N frames"
+v = {run = {queuedGameFunctionTuples = {}, queuedRenderFunctionTuples = {}}}
+function ____exports.runInNFramesInit(self, mod)
+    saveDataManager(
+        nil,
+        "runInNFrames",
+        v,
+        function() return false end
+    )
+    mod:AddCallback(ModCallback.POST_UPDATE, postUpdate)
+    mod:AddCallback(ModCallback.POST_RENDER, postRender)
+end
+function ____exports.runInNGameFrames(self, func, gameFrames)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    local gameFrameCount = game:GetFrameCount()
+    local functionFireFrame = gameFrameCount + gameFrames
+    local tuple = {functionFireFrame, func}
+    local ____v_run_queuedGameFunctionTuples_0 = v.run.queuedGameFunctionTuples
+    ____v_run_queuedGameFunctionTuples_0[#____v_run_queuedGameFunctionTuples_0 + 1] = tuple
+end
+function ____exports.runInNRenderFrames(self, func, renderFrames)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    local renderFrameCount = Isaac.GetFrameCount()
+    local functionFireFrame = renderFrameCount + renderFrames
+    local tuple = {functionFireFrame, func}
+    local ____v_run_queuedRenderFunctionTuples_1 = v.run.queuedRenderFunctionTuples
+    ____v_run_queuedRenderFunctionTuples_1[#____v_run_queuedRenderFunctionTuples_1 + 1] = tuple
+end
+function ____exports.runNextGameFrame(self, func)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    ____exports.runInNGameFrames(nil, func, 1)
+end
+function ____exports.runNextRenderFrame(self, func)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    ____exports.runInNRenderFrames(nil, func, 1)
+end
+return ____exports

package/features/saveDataManager/constants.d.ts

@@ -0,0 +1,3 @@
+/** Set this to true to enable more verbosity in the save data manger. */
+export declare const SAVE_DATA_MANAGER_DEBUG = false;
+export declare const SAVE_DATA_MANAGER_FEATURE_NAME = "save data manager";