isaacscript-common 9.18.4 → 9.19.2

package/dist/src/enums/SerializationType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerializationType.d.ts","sourceRoot":"","sources":["../../../src/enums/SerializationType.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,oBAAY,iBAAiB;IAC3B,IAAI,IAAA;IACJ,SAAS,IAAA;IACT,WAAW,IAAA;CACZ"}

package/dist/src/enums/SlotDestructionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlotDestructionType.d.ts","sourceRoot":"","sources":["../../../src/enums/SlotDestructionType.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oBAAY,mBAAmB;IAC7B,MAAM,IAAA;IACN,kBAAkB,IAAA;CACnB"}

package/dist/src/enums/StatType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StatType.d.ts","sourceRoot":"","sources":["../../../src/enums/StatType.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oBAAY,QAAQ;IAClB,4EAA4E;IAC5E,MAAM,IAAA;IAEN,sFAAsF;IACtF,UAAU,IAAA;IAEV,mFAAmF;IACnF,UAAU,IAAA;IAEV,+EAA+E;IAC/E,WAAW,IAAA;IAEX,8EAA8E;IAC9E,UAAU,IAAA;IAEV,4FAA4F;IAC5F,yBAAyB,IAAA;IAEzB,qFAAqF;IACrF,kBAAkB,IAAA;IAElB,8EAA8E;IAC9E,UAAU,IAAA;IAEV,kFAAkF;IAClF,SAAS,IAAA;IAET,mFAAmF;IACnF,UAAU,IAAA;IAEV,4EAA4E;IAC5E,MAAM,KAAA;IAKN,yEAAyE;IACzE,IAAI,KAAA;IAEJ,gFAAgF;IAChF,IAAI,KAAA;CAIL"}

package/dist/src/enums/private/CopyableIsaacAPIClassType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CopyableIsaacAPIClassType.d.ts","sourceRoot":"","sources":["../../../../src/enums/private/CopyableIsaacAPIClassType.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,yBAAyB;IACnC,WAAW,cAAc;IACzB,KAAK,UAAU;IACf,OAAO,WAAW;IAClB,GAAG,QAAQ;IACX,MAAM,WAAW;CAClB"}

package/dist/src/enums/private/SerializationBrand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerializationBrand.d.ts","sourceRoot":"","sources":["../../../../src/enums/private/SerializationBrand.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,oBAAY,kBAAkB;IAE5B,WAAW,uBAAuB;IAClC,GAAG,eAAe;IAClB,GAAG,eAAe;IAGlB,WAAW,kBAAkB;IAC7B,KAAK,YAAY;IACjB,OAAO,cAAc;IACrB,GAAG,UAAU;IACb,MAAM,aAAa;IAEnB;;;OAGG;IACH,iBAAiB,6BAA6B;IAE9C;;;;;;;;;;OAUG;IACH,uBAAuB,mCAAmC;CAC3D"}

package/dist/src/enums/private/StageTravelState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StageTravelState.d.ts","sourceRoot":"","sources":["../../../../src/enums/private/StageTravelState.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB;IAC1B,IAAI,IAAA;IACJ,oBAAoB,IAAA;IACpB,mBAAmB,IAAA;IACnB,mCAAmC,IAAA;IACnC,6CAA6C,IAAA;IAC7C,kBAAkB,IAAA;IAClB,mBAAmB,IAAA;CACpB"}

package/dist/src/enums/private/TrapdoorAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrapdoorAnimation.d.ts","sourceRoot":"","sources":["../../../../src/enums/private/TrapdoorAnimation.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,cAAc,mBAAmB;CAClC"}

package/dist/src/features/characterHealthConversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"characterHealthConversion.d.ts","sourceRoot":"","sources":["../../../src/features/characterHealthConversion.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,YAAY,EAGZ,UAAU,EACX,MAAM,8BAA8B,CAAC;AAMtC,oBAAY,sBAAsB,GAAG,YAAY,CAAC,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC;AAuF5E;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,UAAU,EACtB,sBAAsB,EAAE,sBAAsB,GAC7C,IAAI,CAUN"}

package/dist/src/features/characterHealthConversion.lua

@@ -0,0 +1,87 @@
+local ____lualib = require("lualib_bundle")
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local postPEffectUpdate, convertRedHeartContainers, removeRedHearts, prePickupCollisionHeart, characterHealthReplacementMap
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local HeartSubType = ____isaac_2Dtypescript_2Ddefinitions.HeartSubType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
+local ____featuresInitialized = require("src.featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____pickups = require("src.functions.pickups")
+local isRedHeart = ____pickups.isRedHeart
+function postPEffectUpdate(self, player)
+    local character = player:GetPlayerType()
+    local conversionHeartSubType = characterHealthReplacementMap:get(character)
+    if conversionHeartSubType == nil then
+        return
+    end
+    convertRedHeartContainers(nil, player, conversionHeartSubType)
+    removeRedHearts(nil, player)
+end
+function convertRedHeartContainers(self, player, heartSubType)
+    local maxHearts = player:GetMaxHearts()
+    if maxHearts == 0 then
+        return
+    end
+    player:AddMaxHearts(maxHearts * -1, false)
+    repeat
+        local ____switch7 = heartSubType
+        local ____cond7 = ____switch7 == HeartSubType.SOUL
+        if ____cond7 then
+            do
+                player:AddSoulHearts(maxHearts)
+                break
+            end
+        end
+        ____cond7 = ____cond7 or ____switch7 == HeartSubType.BLACK
+        if ____cond7 then
+            do
+                player:AddBlackHearts(maxHearts)
+                break
+            end
+        end
+    until true
+end
+function removeRedHearts(self, player)
+    local hearts = player:GetHearts()
+    if hearts > 0 then
+        player:AddHearts(hearts * -1)
+    end
+end
+function prePickupCollisionHeart(self, pickup, collider)
+    if not isRedHeart(nil, pickup) then
+        return nil
+    end
+    local player = collider:ToPlayer()
+    if player == nil then
+        return nil
+    end
+    local character = player:GetPlayerType()
+    local conversionHeartSubType = characterHealthReplacementMap:get(character)
+    if conversionHeartSubType == nil then
+        return nil
+    end
+    return false
+end
+local FEATURE_NAME = "characterHealthConversion"
+characterHealthReplacementMap = __TS__New(Map)
+---
+-- @internal
+function ____exports.characterHealthConversionInit(self, mod)
+    mod:AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate)
+    mod:AddCallback(ModCallback.PRE_PICKUP_COLLISION, prePickupCollisionHeart, PickupVariant.HEART)
+end
+--- Helper function to make a character that has the same health mechanic as Blue Baby (red heart
+-- containers --> soul hearts) or Dark Judas (red heart containers --> black hearts).
+-- 
+-- Call this function once at the beginning of your mod to declare the health conversion type.
+function ____exports.registerCharacterHealthConversion(self, playerType, conversionHeartSubType)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    if characterHealthReplacementMap:has(playerType) then
+        error(("Failed to register a character of type " .. tostring(playerType)) .. " because there is already an existing registered character with that type.")
+    end
+    characterHealthReplacementMap:set(playerType, conversionHeartSubType)
+end
+return ____exports

package/dist/src/features/characterStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"characterStats.d.ts","sourceRoot":"","sources":["../../../src/features/characterStats.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,SAAS,EAET,UAAU,EACX,MAAM,8BAA8B,CAAC;AAgCtC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,GAC/D,IAAI,CAGN"}

package/dist/src/features/characterStats.lua

@@ -0,0 +1,53 @@
+local ____lualib = require("lualib_bundle")
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local evaluateCache, charactersStatMap
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____featuresInitialized = require("src.featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____stats = require("src.functions.stats")
+local addStat = ____stats.addStat
+local getDefaultPlayerStat = ____stats.getDefaultPlayerStat
+function evaluateCache(self, player, cacheFlag)
+    local character = player:GetPlayerType()
+    local statMap = charactersStatMap:get(character)
+    if statMap == nil then
+        return
+    end
+    local stat = statMap:get(cacheFlag)
+    local defaultStat = getDefaultPlayerStat(nil, cacheFlag)
+    if stat == nil or defaultStat == nil then
+        return
+    end
+    local delta = stat - defaultStat
+    addStat(nil, player, cacheFlag, delta)
+end
+local FEATURE_NAME = "characterStats"
+charactersStatMap = __TS__New(Map)
+---
+-- @internal
+function ____exports.characterStatsInit(self, mod)
+    mod:AddCallback(ModCallback.EVALUATE_CACHE, evaluateCache)
+end
+--- Helper function to manage the stats for a vanilla or custom character. Call this function once at
+-- the beginning of your mod to declare the starting stats.
+-- 
+-- You must provide this function with a map of CacheFlag to the default stat amount. For example,
+-- the default amount of damage is 3.5. To make a custom character start with 4.5 damage:
+-- 
+-- ```ts
+-- const fooDefaultStats = new Map<CacheFlag, number>([
+--   [CacheFlag.DAMAGE, 4.5],
+-- ])
+-- registerCharacterStats(PlayerTypeCustom.FOO, fooDefaultStats);
+-- ```
+-- 
+-- Note that the format for the `CacheFlag.FIRE_DELAY` value should be in the tears stat format, not
+-- the `MaxFireDelay` format.
+function ____exports.registerCharacterStats(self, playerType, statMap)
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    charactersStatMap:set(playerType, statMap)
+end
+return ____exports

package/dist/src/features/collectibleItemPoolType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectibleItemPoolType.d.ts","sourceRoot":"","sources":["../../../src/features/collectibleItemPoolType.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAGb,MAAM,8BAA8B,CAAC;AAqCtC;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,YAAY,GACxB,YAAY,CAad"}

package/dist/src/features/collectibleItemPoolType.lua

@@ -0,0 +1,48 @@
+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("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____featuresInitialized = require("src.featuresInitialized")
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____entities = require("src.functions.entities")
+local getEntityID = ____entities.getEntityID
+local ____pickupVariants = require("src.functions.pickupVariants")
+local isCollectible = ____pickupVariants.isCollectible
+local ____rooms = require("src.functions.rooms")
+local getRoomItemPoolType = ____rooms.getRoomItemPoolType
+local ____exports = require("src.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 = "collectibleItemPoolType"
+v = {run = {collectibleItemPoolTypeMap = __TS__New(Map)}}
+---
+-- @internal
+function ____exports.collectibleItemPoolTypeInit(self, mod)
+    saveDataManager(nil, FEATURE_NAME, v)
+    mod:AddCallback(ModCallback.POST_PICKUP_INIT, postPickupInitCollectible, PickupVariant.COLLECTIBLE)
+end
+--- 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 `PRE_GET_COLLECTIBLE` callback for item
+-- pool types, and then assume that the next spawned collectible will match.
+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/dist/src/features/customDoor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customDoor.d.ts","sourceRoot":"","sources":["../../../src/features/customDoor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,WAAW,EAChB,aAAa,EAAE,aAAa,GAC3B,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,QAAQ,GACjB,YAAY,CAEd"}

package/dist/src/features/customDoor.lua

@@ -0,0 +1,53 @@
+local ____exports = {}
+local ____postCustomDoorEnter = require("src.callbacks.postCustomDoorEnter")
+local initCustomDoorInternal = ____postCustomDoorEnter.initCustomDoorInternal
+local spawnCustomDoorInternal = ____postCustomDoorEnter.spawnCustomDoorInternal
+--- `isaacscript-common` provides custom doors that can be spawned where any wall segment is. If you
+-- use this feature, you must first call this initialization function at the beginning of your mod.
+-- 
+-- Each kind of custom door that you create must have an entry in the "content/entities2.xml" file,
+-- like so:
+-- 
+-- ```xml
+-- <entity id="1000" name="Foo Custom Door" anm2path="grid/door_foo.anm2" />
+-- ```
+-- 
+-- (Custom door entities must have an id of "1000", which corresponds to an effect. If you do not
+-- specify the variant, then the game will automatically assign it.)
+-- 
+-- Next, pass the variant into this function:
+-- 
+-- ```ts
+-- const modVanilla = RegisterMod("My Mod", 1);
+-- const mod = upgradeMod(modVanilla);
+-- const fooEffectVariant = Isaac.GetEntityVariantByName("Foo Custom Door");
+-- initCustomDoor(mod, fooEffectVariant);
+-- ```
+-- 
+-- Also see the `spawnCustomDoor` function.
+function ____exports.initCustomDoor(self, mod, effectVariant)
+    initCustomDoorInternal(nil, mod, effectVariant)
+end
+--- Helper function to spawn a custom door. This is intended to be called from the `POST_NEW_ROOM`
+-- callback when the player enters a room that should have a custom door. (You could also call it
+-- from another callback if you want the door to appear e.g. after clearing all enemies.)
+-- 
+-- Like other entities, the door is not persistent, so you must spawn it every time when re-entering
+-- the room.
+-- 
+-- Handle when a player enters the door by hooking the custom `POST_CUSTOM_DOOR_ENTER` callback.
+-- 
+-- The custom door is an `EntityEffect`. You can manually open or close the door by modifying its
+-- state. (The values to use correspond to the `DoorState` enum.)
+-- 
+-- This function will throw a run-time error if:
+-- - the door slot already has a vanilla door
+-- - the door slot already has a custom door
+-- - the tile at the door slot does not have a wall
+-- 
+-- Before using this function, you must first initialize the effect/door variant with the
+-- `initCustomDoor` function.
+function ____exports.spawnCustomDoor(self, effectVariant, doorSlot)
+    return spawnCustomDoorInternal(nil, effectVariant, doorSlot)
+end
+return ____exports

package/dist/src/features/customGridEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customGridEntity.d.ts","sourceRoot":"","sources":["../../../src/features/customGridEntity.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAClB,cAAc,EAGf,MAAM,8BAA8B,CAAC;AAgBtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAyH1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAgB,qBAAqB,CACnC,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,CA8CZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,+BAA+B,EAAE,GAAG,GAAG,MAAM,GAAG,UAAU,EAC1D,UAAU,UAAO,GAChB,UAAU,GAAG,SAAS,CAuCxB;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,KAAK,CAC5C;IAAC,UAAU,EAAE,UAAU;IAAE,IAAI,EAAE,oBAAoB;CAAC,CACrD,CAqBA;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,qBAAqB,EAAE,UAAU,GAAG,GAAG,GACtC,cAAc,GAAG,SAAS,CAsB5B;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,qBAAqB,EAAE,UAAU,GAAG,GAAG,GACtC,OAAO,CAOT"}

package/dist/src/features/customGridEntity.lua

@@ -0,0 +1,325 @@
+local ____lualib = require("lualib_bundle")
+local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
+local Set = ____lualib.Set
+local __TS__Iterator = ____lualib.__TS__Iterator
+local ____exports = {}
+local preUseItemWeNeedToGoDeeper, postNewRoomReordered, v
+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 ____DefaultMap = require("src.classes.DefaultMap")
+local DefaultMap = ____DefaultMap.DefaultMap
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____ModCallbackCustom = require("src.enums.ModCallbackCustom")
+local ModCallbackCustom = ____ModCallbackCustom.ModCallbackCustom
+local ____featuresInitialized = require("src.featuresInitialized")
+local areFeaturesInitialized = ____featuresInitialized.areFeaturesInitialized
+local errorIfFeaturesNotInitialized = ____featuresInitialized.errorIfFeaturesNotInitialized
+local ____gridEntities = require("src.functions.gridEntities")
+local removeGridEntity = ____gridEntities.removeGridEntity
+local spawnGridEntityWithVariant = ____gridEntities.spawnGridEntityWithVariant
+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 ____runInNFrames = require("src.features.runInNFrames")
+local runNextGameFrame = ____runInNFrames.runNextGameFrame
+local ____exports = require("src.features.saveDataManager.exports")
+local saveDataManager = ____exports.saveDataManager
+function preUseItemWeNeedToGoDeeper(self, _collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData)
+    local room = game:GetRoom()
+    local roomListIndex = getRoomListIndex(nil)
+    local roomCustomGridEntities = 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 playerPtr = EntityPtr(player)
+    runNextGameFrame(
+        nil,
+        function()
+            local futureEntity = playerPtr.Ref
+            if futureEntity == nil then
+                return
+            end
+            local futurePlayer = futureEntity:ToPlayer()
+            if futurePlayer == nil then
+                return
+            end
+            v.room.manuallyUsingShovel = true
+            futurePlayer:UseActiveItem(CollectibleType.WE_NEED_TO_GO_DEEPER)
+            v.room.manuallyUsingShovel = false
+        end
+    )
+    return true
+end
+function postNewRoomReordered(self)
+    local roomListIndex = getRoomListIndex(nil)
+    local roomCustomGridEntities = 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 __continue13
+            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
+        ::__continue13::
+    end
+end
+local FEATURE_NAME = "customGridEntity"
+v = {
+    level = {customGridEntities = __TS__New(
+        DefaultMap,
+        function() return __TS__New(Map) end
+    )},
+    room = {
+        genericPropPtrHashes = __TS__New(Set),
+        manuallyUsingShovel = false
+    }
+}
+---
+-- @internal
+function ____exports.customGridEntityInit(self, mod)
+    saveDataManager(nil, FEATURE_NAME, v)
+    mod:AddCallback(ModCallback.PRE_USE_ITEM, preUseItemWeNeedToGoDeeper, CollectibleType.WE_NEED_TO_GO_DEEPER)
+    mod:AddCallbackCustom(ModCallbackCustom.POST_NEW_ROOM_REORDERED, postNewRoomReordered)
+end
+--- 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(gridIndex: int): GridEntity {
+--   return 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.
+function ____exports.spawnCustomGridEntity(self, gridEntityTypeCustom, gridIndexOrPosition, gridCollisionClass, anm2Path, defaultAnimation, baseGridEntityType, baseGridEntityVariant)
+    if baseGridEntityType == nil then
+        baseGridEntityType = GridEntityType.DECORATION
+    end
+    if baseGridEntityVariant == nil then
+        baseGridEntityVariant = 0
+    end
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    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 = v.level.customGridEntities:getAndSetDefault(roomListIndex)
+    roomCustomGridEntities:set(gridIndex, customGridEntityData)
+    return customGridEntity
+end
+--- 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.
+function ____exports.removeCustomGridEntity(self, gridIndexOrPositionOrGridEntity, updateRoom)
+    if updateRoom == nil then
+        updateRoom = true
+    end
+    errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
+    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 = 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
+--- 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.
+function ____exports.getCustomGridEntities(self)
+    if not areFeaturesInitialized(nil) then
+        return {}
+    end
+    local roomListIndex = getRoomListIndex(nil)
+    local roomCustomGridEntities = 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
+--- 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.
+function ____exports.getCustomGridEntityType(self, gridEntityOrGridIndex)
+    if not areFeaturesInitialized(nil) then
+        return nil
+    end
+    local gridIndex = isNumber(nil, gridEntityOrGridIndex) and gridEntityOrGridIndex or gridEntityOrGridIndex:GetGridIndex()
+    local roomListIndex = getRoomListIndex(nil)
+    local roomCustomGridEntities = 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
+--- Helper function to check if a `GridEntity` is a custom grid entity or if a grid index has a
+-- custom grid entity.
+function ____exports.isCustomGridEntity(self, gridEntityOrGridIndex)
+    if not areFeaturesInitialized(nil) then
+        return false
+    end
+    local gridEntityTypeCustom = ____exports.getCustomGridEntityType(nil, gridEntityOrGridIndex)
+    return gridEntityTypeCustom ~= nil
+end
+return ____exports