isaacscript-common 2.3.0 → 2.3.1

package/functions/globals.lua

@@ -0,0 +1,230 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__ArraySort = ____lualib.__TS__ArraySort
+local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
+local ____exports = {}
+local twoDimensionalSort
+local ____debug = require("functions.debug")
+local isLuaDebugEnabled = ____debug.isLuaDebugEnabled
+local ____log = require("functions.log")
+local log = ____log.log
+local ____set = require("functions.set")
+local addSetsToSet = ____set.addSetsToSet
+local copySet = ____set.copySet
+function twoDimensionalSort(self, a, b)
+    if a[1] == nil or b[1] == nil then
+        error("Failed to two-dimensional sort since the first element of the array was undefined.")
+    end
+    if a[1] == b[1] then
+        return 0
+    end
+    return a[1] < b[1] and -1 or 1
+end
+local DEFAULT_GLOBALS = __TS__New(Set, {
+    "ActionTriggers",
+    "ActiveSlot",
+    "BabySubType",
+    "BackdropType",
+    "BatterySubType",
+    "BedSubType",
+    "BitSet128",
+    "BombSubType",
+    "BombVariant",
+    "ButtonAction",
+    "CacheFlag",
+    "Card",
+    "Challenge",
+    "ChampionColor",
+    "ChestSubType",
+    "CoinSubType",
+    "CollectibleType",
+    "Color",
+    "CppContainer",
+    "DamageFlag",
+    "Difficulty",
+    "Direction",
+    "DoorSlot",
+    "DoorState",
+    "DoorVariant",
+    "EffectVariant",
+    "Entity",
+    "EntityBomb",
+    "EntityCollisionClass",
+    "EntityEffect",
+    "EntityFamiliar",
+    "EntityFlag",
+    "EntityGridCollisionClass",
+    "EntityKnife",
+    "EntityLaser",
+    "EntityNPC",
+    "EntityPartition",
+    "EntityPickup",
+    "EntityPlayer",
+    "EntityProjectile",
+    "EntityPtr",
+    "EntityRef",
+    "EntityTear",
+    "EntityType",
+    "FamiliarVariant",
+    "Font",
+    "Game",
+    "GameStateFlag",
+    "GetPtrHash",
+    "GridCollisionClass",
+    "GridEntity",
+    "GridEntityDesc",
+    "GridEntityDoor",
+    "GridEntityPit",
+    "GridEntityPoop",
+    "GridEntityPressurePlate",
+    "GridEntityRock",
+    "GridEntitySpikes",
+    "GridEntityTNT",
+    "GridEntityType",
+    "GridRooms",
+    "HUD",
+    "HeartSubType",
+    "Input",
+    "InputHook",
+    "Isaac",
+    "ItemConfig",
+    "ItemPool",
+    "ItemPoolType",
+    "ItemType",
+    "KColor",
+    "KeySubType",
+    "Keyboard",
+    "LaserOffset",
+    "LaserSubType",
+    "Level",
+    "LevelCurse",
+    "LevelStage",
+    "LevelStateFlag",
+    "LocustSubtypes",
+    "ModCallbacks",
+    "Mouse",
+    "Music",
+    "MusicManager",
+    "NpcState",
+    "NullItemID",
+    "Options",
+    "PathFinder",
+    "PickupPrice",
+    "PickupVariant",
+    "PillColor",
+    "PillEffect",
+    "PlayerForm",
+    "PlayerSpriteLayer",
+    "PlayerType",
+    "PlayerTypes",
+    "PoopPickupSubType",
+    "PoopSpellType",
+    "ProjectileFlags",
+    "ProjectileParams",
+    "ProjectileVariant",
+    "QueueItemData",
+    "REPENTANCE",
+    "RNG",
+    "Random",
+    "RandomVector",
+    "RegisterMod",
+    "RenderMode",
+    "Room",
+    "RoomConfig",
+    "RoomDescriptor",
+    "RoomShape",
+    "RoomTransitionAnim",
+    "RoomType",
+    "SFXManager",
+    "SackSubType",
+    "SeedEffect",
+    "Seeds",
+    "ShockwaveParams",
+    "SkinColor",
+    "SortingLayer",
+    "SoundEffect",
+    "Sprite",
+    "StageType",
+    "StartDebug",
+    "TearFlags",
+    "TearParams",
+    "TearVariant",
+    "TemporaryEffect",
+    "TemporaryEffects",
+    "TrinketType",
+    "UseFlag",
+    "Vector",
+    "WeaponType",
+    "_G",
+    "_VERSION",
+    "assert",
+    "collectgarbage",
+    "coroutine",
+    "dofile",
+    "error",
+    "getmetatable",
+    "include",
+    "ipairs",
+    "load",
+    "loadfile",
+    "math",
+    "next",
+    "pairs",
+    "pcall",
+    "print",
+    "rawequal",
+    "rawget",
+    "rawlen",
+    "rawset",
+    "require",
+    "select",
+    "setmetatable",
+    "string",
+    "table",
+    "tonumber",
+    "tostring",
+    "type",
+    "utf8",
+    "xpcall"
+})
+local LUA_DEBUG_ADDED_GLOBALS = __TS__New(Set, {"debug", "io", "os", "package"})
+local RACING_PLUS_SANDBOX_ADDED_GLOBALS = __TS__New(Set, {"sandboxTraceback", "sandboxGetTraceback", "getParentFunctionDescription"})
+function ____exports.getDefaultGlobals(self)
+    local defaultGlobals = copySet(nil, DEFAULT_GLOBALS)
+    if isLuaDebugEnabled(nil) then
+        addSetsToSet(nil, defaultGlobals, LUA_DEBUG_ADDED_GLOBALS)
+    end
+    addSetsToSet(nil, defaultGlobals, RACING_PLUS_SANDBOX_ADDED_GLOBALS)
+    return defaultGlobals
+end
+function ____exports.getNewGlobals(self)
+    local defaultGlobals = ____exports.getDefaultGlobals(nil)
+    local newGlobals = {}
+    for key, value in pairs(_G) do
+        if not defaultGlobals:has(key) then
+            local keyValueTuple = {key, value}
+            newGlobals[#newGlobals + 1] = keyValueTuple
+        end
+    end
+    __TS__ArraySort(newGlobals, twoDimensionalSort)
+    return newGlobals
+end
+function ____exports.logNewGlobals(self)
+    local newGlobals = ____exports.getNewGlobals(nil)
+    log("List of added global variables in the Isaac environment:")
+    if #newGlobals == 0 then
+        log("- n/a (no extra global variables found)")
+    end
+    __TS__ArrayForEach(
+        newGlobals,
+        function(____, ____bindingPattern0, i)
+            local value
+            local key
+            key = ____bindingPattern0[1]
+            value = ____bindingPattern0[2]
+            log((((tostring(i + 1) .. ") ") .. tostring(key)) .. " - ") .. tostring(value))
+        end
+    )
+end
+return ____exports

package/functions/gridEntity.d.ts

@@ -0,0 +1,155 @@
+import { GridEntityType, GridEntityXMLType } from "isaac-typescript-definitions";
+/**
+ * Helper function to convert the grid entity type found in a room XML file to the corresponding
+ * grid entity type and variant normally used by the game. For example, a rock is represented as
+ * 1000.0 in a room XML file, but `GridEntityType.ROCK` is equal to 2.
+ */
+export declare function convertXMLGridEntityType(gridEntityXMLType: GridEntityXMLType, gridEntityXMLVariant: int): [GridEntityType, int] | undefined;
+/**
+ * Gets the entities that have a hitbox that overlaps with any part of the square that the grid
+ * entity is on.
+ *
+ * Note that this function will not work properly in the PostNewRoom callback, since entities do not
+ * have collision yet in that callback.
+ */
+export declare function getCollidingEntitiesWithGridEntity(gridEntity: GridEntity): Entity[];
+/**
+ * Helper function to get every grid entity in the current room.
+ *
+ * Use this function with no arguments to get every grid entity, or specify a variadic amount of
+ * arguments to match specific grid entity types.
+ *
+ * For example:
+ *
+ * ```ts
+ * for (const gridEntity of getGridEntities()) {
+ *   print(gridEntity.GetType())
+ * }
+ * ```
+ *
+ * For example:
+ *
+ * ```ts
+ * const rocks = getGridEntities(
+ *   GridEntityType.ROCK,
+ *   GridEntityType.BLOCK,
+ *   GridEntityType.ROCK_TINTED,
+ * );
+ * ```
+ */
+export declare function getGridEntities(...gridEntityTypes: GridEntityType[]): GridEntity[];
+/**
+ * Helper function to get a map of every grid entity in the current room. The indexes of the map are
+ * equal to the grid index. The values of the map are equal to the grid entities.
+ *
+ * Use this function with no arguments to get every grid entity, or specify a variadic amount of
+ * arguments to match specific grid entity types.
+ */
+export declare function getGridEntitiesMap(...gridEntityTypes: GridEntityType[]): Map<int, GridEntity>;
+/** Helper function to return a string containing the grid entity's type and variant. */
+export declare function getGridEntityID(gridEntity: GridEntity): string;
+export declare function getSurroundingGridEntities(gridEntity: GridEntity): GridEntity[];
+export declare function getTopLeftWall(): GridEntity | undefined;
+/**
+ * Helper function to get the grid index of the top left wall. (This will depend on what the current
+ * room shape is.)
+ */
+export declare function getTopLeftWallGridIndex(): int;
+export declare function isGridEntityBreakableByExplosion(gridEntity: GridEntity): boolean;
+/**
+ * Helper function to see if the provided gridEntity is in its respective broken state. See the
+ * `GRID_ENTITY_TYPE_TO_BROKEN_STATE_MAP` constant for more details.
+ *
+ * Note that in the case of `GridEntityType.LOCK` (11), the state will turn to being broken before
+ * the actual collision for the entity is removed.
+ */
+export declare function isGridEntityBroken(gridEntity: GridEntity): boolean;
+/**
+ * Helper function to detect whether a given Void Portal is one that randomly spawns after a boss is
+ * defeated or is one that naturally spawns in the room after Hush. (This is determined by looking
+ * at the VarData of the entity.)
+ */
+export declare function isPostBossVoidPortal(gridEntity: GridEntity): boolean;
+/**
+ * Helper function to all grid entities in the room except for ones matching the grid entity types
+ * provided.
+ *
+ * For example:
+ *
+ * ```ts
+ * removeAllGridEntitiesExceptFor(
+ *   GridEntityType.WALL,
+ *   GridEntityType.DOOR,
+ * );
+ * ```
+ *
+ * @returns True if one or more grid entities were removed, false otherwise.
+ */
+export declare function removeAllGridExcept(...gridEntityTypes: GridEntityType[]): boolean;
+/**
+ * Helper function to remove all of the grid entities in the room that match the grid entity types
+ * provided.
+ *
+ * For example:
+ *
+ * ```ts
+ * removeAllMatchingGridEntities(
+ *   GridEntityType.ROCK,
+ *   GridEntityType.BLOCK,
+ *   GridEntityType.ROCK_TINTED,
+ * );
+ * ```
+ *
+ * @returns True if one or more grid entities were removed, false otherwise.
+ */
+export declare function removeAllMatchingGridEntities(...gridEntityType: GridEntityType[]): boolean;
+/**
+ * Helper function to remove a grid entity simply by providing the grid entity object.
+ *
+ * @param gridEntity The grid entity to remove.
+ * @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 invoke this
+ *                   function multiple times.
+ */
+export declare function removeGrid(gridEntity: GridEntity, updateRoom?: boolean): void;
+/**
+ * Helper function to make a grid entity invisible. This is accomplished by setting its sprite to an
+ * empty/missing PNG file.
+ *
+ * For more information, see the documentation for the `clearSprite` helper function.
+ */
+export declare function setGridEntityInvisible(gridEntity: GridEntity): void;
+/**
+ * Helper function to spawn a giant poop. This is performed by spawning each of the four quadrant
+ * grid entities in the appropriate positions.
+ */
+export declare function spawnGiantPoop(topLeftGridIndex: int): void;
+/**
+ * Helper function to spawn a grid entity.
+ *
+ * This function assumes you want to give the grid entity a variant of 0. If you want to specify a
+ * variant, use the `spawnGridWithVariant` helper function instead.
+ *
+ * Use this instead of the `Isaac.GridSpawn` method since it:
+ * - handles giving pits collision
+ * - removes existing grid entities on the same tile, if any
+ * - allows you to specify either the grid index or the position
+ */
+export declare function spawnGrid(gridEntityType: GridEntityType, gridIndexOrPosition: int | Vector): GridEntity | undefined;
+/**
+ * Helper function to spawn a grid entity with a specific variant.
+ *
+ * Use this instead of the `Isaac.GridSpawn` method since it:
+ * - handles giving pits collision
+ * - removes existing grid entities on the same tile, if any
+ * - allows you to specify the grid index or the position
+ */
+export declare function spawnGridWithVariant(gridEntityType: GridEntityType, variant: int, gridIndexOrPosition: int | Vector): GridEntity | undefined;
+/**
+ * Helper function to spawn a Void Portal. This is more complicated than simply spawning a trapdoor
+ * with the appropriate variant, as the game does not give it the correct sprite automatically.
+ */
+export declare function spawnVoidPortal(gridIndex: int): GridEntity | undefined;

package/functions/gridEntity.lua

@@ -0,0 +1,263 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local Map = ____lualib.Map
+local ____exports = {}
+local getAllGridEntities
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local GridCollisionClass = ____isaac_2Dtypescript_2Ddefinitions.GridCollisionClass
+local GridEntityType = ____isaac_2Dtypescript_2Ddefinitions.GridEntityType
+local PoopGridEntityVariant = ____isaac_2Dtypescript_2Ddefinitions.PoopGridEntityVariant
+local StatueVariant = ____isaac_2Dtypescript_2Ddefinitions.StatueVariant
+local TrapdoorVariant = ____isaac_2Dtypescript_2Ddefinitions.TrapdoorVariant
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____constants = require("constants")
+local DISTANCE_OF_GRID_TILE = ____constants.DISTANCE_OF_GRID_TILE
+local ____gridEntityTypeToBrokenStateMap = require("maps.gridEntityTypeToBrokenStateMap")
+local GRID_ENTITY_TYPE_TO_BROKEN_STATE_MAP = ____gridEntityTypeToBrokenStateMap.GRID_ENTITY_TYPE_TO_BROKEN_STATE_MAP
+local ____gridEntityXMLMap = require("maps.gridEntityXMLMap")
+local GRID_ENTITY_XML_MAP = ____gridEntityXMLMap.GRID_ENTITY_XML_MAP
+local ____roomShapeToTopLeftWallGridIndexMap = require("maps.roomShapeToTopLeftWallGridIndexMap")
+local DEFAULT_TOP_LEFT_WALL_GRID_INDEX = ____roomShapeToTopLeftWallGridIndexMap.DEFAULT_TOP_LEFT_WALL_GRID_INDEX
+local ROOM_SHAPE_TO_TOP_LEFT_WALL_GRID_INDEX_MAP = ____roomShapeToTopLeftWallGridIndexMap.ROOM_SHAPE_TO_TOP_LEFT_WALL_GRID_INDEX_MAP
+local ____math = require("functions.math")
+local isCircleIntersectingRectangle = ____math.isCircleIntersectingRectangle
+local ____rooms = require("functions.rooms")
+local roomUpdateSafe = ____rooms.roomUpdateSafe
+local ____sprite = require("functions.sprite")
+local clearSprite = ____sprite.clearSprite
+local ____utils = require("functions.utils")
+local erange = ____utils.erange
+local ____vector = require("functions.vector")
+local isVector = ____vector.isVector
+function getAllGridEntities(self)
+    local room = game:GetRoom()
+    local gridSize = room:GetGridSize()
+    local gridEntities = {}
+    for ____, gridIndex in ipairs(erange(nil, gridSize)) do
+        local gridEntity = room:GetGridEntity(gridIndex)
+        if gridEntity ~= nil then
+            gridEntities[#gridEntities + 1] = gridEntity
+        end
+    end
+    return gridEntities
+end
+function ____exports.getTopLeftWallGridIndex(self)
+    local room = game:GetRoom()
+    local roomShape = room:GetRoomShape()
+    local topLeftWallGridIndex = ROOM_SHAPE_TO_TOP_LEFT_WALL_GRID_INDEX_MAP:get(roomShape)
+    return topLeftWallGridIndex == nil and DEFAULT_TOP_LEFT_WALL_GRID_INDEX or topLeftWallGridIndex
+end
+function ____exports.removeGrid(self, gridEntity, updateRoom)
+    if updateRoom == nil then
+        updateRoom = true
+    end
+    local room = game:GetRoom()
+    local gridIndex = gridEntity:GetGridIndex()
+    room:RemoveGridEntity(gridIndex, 0, false)
+    if updateRoom then
+        roomUpdateSafe(nil)
+    end
+end
+function ____exports.spawnGridWithVariant(self, gridEntityType, variant, gridIndexOrPosition)
+    local room = game:GetRoom()
+    local ____isVector_result_0
+    if isVector(nil, gridIndexOrPosition) then
+        ____isVector_result_0 = room:GetGridEntityFromPos(gridIndexOrPosition)
+    else
+        ____isVector_result_0 = room:GetGridEntity(gridIndexOrPosition)
+    end
+    local existingGridEntity = ____isVector_result_0
+    if existingGridEntity ~= nil then
+        ____exports.removeGrid(nil, existingGridEntity)
+    end
+    local position = isVector(nil, gridIndexOrPosition) and gridIndexOrPosition or room:GetGridPosition(gridIndexOrPosition)
+    local gridEntity = Isaac.GridSpawn(gridEntityType, variant, position)
+    if gridEntity == nil then
+        return gridEntity
+    end
+    if gridEntityType == GridEntityType.PIT then
+        local pit = gridEntity:ToPit()
+        if pit ~= nil then
+            pit:UpdateCollision()
+        end
+    elseif gridEntityType == GridEntityType.WALL then
+        gridEntity.CollisionClass = GridCollisionClass.WALL
+    end
+    return gridEntity
+end
+local BREAKABLE_GRID_ENTITY_TYPES_BY_EXPLOSIONS = __TS__New(Set, {
+    GridEntityType.ROCK,
+    GridEntityType.ROCK_TINTED,
+    GridEntityType.ROCK_BOMB,
+    GridEntityType.ROCK_ALT,
+    GridEntityType.SPIDER_WEB,
+    GridEntityType.TNT,
+    GridEntityType.POOP,
+    GridEntityType.ROCK_SUPER_SPECIAL,
+    GridEntityType.ROCK_SPIKED,
+    GridEntityType.ROCK_ALT_2,
+    GridEntityType.ROCK_GOLD
+})
+local BREAKABLE_GRID_ENTITY_TYPES_VARIANTS_BY_EXPLOSIONS = __TS__New(
+    Set,
+    {(tostring(GridEntityType.STATUE) .. ".") .. tostring(StatueVariant.ANGEL)}
+)
+function ____exports.convertXMLGridEntityType(self, gridEntityXMLType, gridEntityXMLVariant)
+    local gridEntityArray = GRID_ENTITY_XML_MAP:get(gridEntityXMLType)
+    if gridEntityArray == nil then
+        error("Failed to find an entry in the grid entity map for XML entity type: " .. tostring(gridEntityXMLType))
+    end
+    local gridEntityType = gridEntityArray[1]
+    local gridEntityVariant = gridEntityArray[2]
+    if gridEntityType == GridEntityType.SPIKES_ON_OFF or gridEntityType == GridEntityType.PRESSURE_PLATE or gridEntityType == GridEntityType.TELEPORTER then
+        gridEntityVariant = gridEntityXMLVariant
+    end
+    return {gridEntityType, gridEntityVariant}
+end
+function ____exports.getCollidingEntitiesWithGridEntity(self, gridEntity)
+    local gridEntityCollisionTopLeft = Vector(gridEntity.Position.X - DISTANCE_OF_GRID_TILE / 2, gridEntity.Position.Y - DISTANCE_OF_GRID_TILE / 2)
+    local gridEntityCollisionBottomRight = Vector(gridEntity.Position.X + DISTANCE_OF_GRID_TILE / 2, gridEntity.Position.Y + DISTANCE_OF_GRID_TILE / 2)
+    local closeEntities = Isaac.FindInRadius(gridEntity.Position, DISTANCE_OF_GRID_TILE * 2)
+    return __TS__ArrayFilter(
+        closeEntities,
+        function(____, entity) return entity:CollidesWithGrid() and isCircleIntersectingRectangle(
+            nil,
+            entity.Position,
+            entity.Size + 0.1,
+            gridEntityCollisionTopLeft,
+            gridEntityCollisionBottomRight
+        ) end
+    )
+end
+function ____exports.getGridEntities(self, ...)
+    local gridEntityTypes = {...}
+    local gridEntities = getAllGridEntities(nil)
+    if #gridEntityTypes == 0 then
+        return gridEntities
+    end
+    local gridEntityTypesSet = __TS__New(Set, gridEntityTypes)
+    return __TS__ArrayFilter(
+        gridEntities,
+        function(____, gridEntity)
+            local gridEntityType = gridEntity:GetType()
+            return gridEntityTypesSet:has(gridEntityType)
+        end
+    )
+end
+function ____exports.getGridEntitiesMap(self, ...)
+    local gridEntities = ____exports.getGridEntities(nil, ...)
+    local gridEntityMap = __TS__New(Map)
+    for ____, gridEntity in ipairs(gridEntities) do
+        local gridIndex = gridEntity:GetGridIndex()
+        gridEntityMap:set(gridIndex, gridEntity)
+    end
+    return gridEntityMap
+end
+function ____exports.getGridEntityID(self, gridEntity)
+    local gridEntityType = gridEntity:GetType()
+    local gridEntityVariant = gridEntity:GetVariant()
+    return (tostring(gridEntityType) .. ".") .. tostring(gridEntityVariant)
+end
+function ____exports.getSurroundingGridEntities(self, gridEntity)
+    local room = game:GetRoom()
+    local gridWidth = room:GetGridWidth()
+    local gridIndex = gridEntity:GetGridIndex()
+    local surroundingGridIndexes = {
+        gridIndex - 1,
+        gridIndex + 1,
+        gridIndex - gridWidth - 1,
+        gridIndex - gridWidth,
+        gridIndex - gridWidth + 1,
+        gridIndex + gridWidth - 1,
+        gridIndex + gridWidth,
+        gridIndex + gridWidth + 1
+    }
+    local surroundingGridEntities = {}
+    for ____, surroundingGridIndex in ipairs(surroundingGridIndexes) do
+        local surroundingGridEntity = room:GetGridEntity(surroundingGridIndex)
+        if surroundingGridEntity ~= nil then
+            surroundingGridEntities[#surroundingGridEntities + 1] = surroundingGridEntity
+        end
+    end
+    return surroundingGridEntities
+end
+function ____exports.getTopLeftWall(self)
+    local room = game:GetRoom()
+    local topLeftWallGridIndex = ____exports.getTopLeftWallGridIndex(nil)
+    return room:GetGridEntity(topLeftWallGridIndex)
+end
+function ____exports.isGridEntityBreakableByExplosion(self, gridEntity)
+    local gridEntityType = gridEntity:GetType()
+    local gridEntityVariant = gridEntity:GetVariant()
+    local gridEntityTypeVariant = (tostring(gridEntityType) .. ".") .. tostring(gridEntityVariant)
+    return BREAKABLE_GRID_ENTITY_TYPES_BY_EXPLOSIONS:has(gridEntityType) or BREAKABLE_GRID_ENTITY_TYPES_VARIANTS_BY_EXPLOSIONS:has(gridEntityTypeVariant)
+end
+function ____exports.isGridEntityBroken(self, gridEntity)
+    local gridEntityType = gridEntity:GetType()
+    local brokenState = GRID_ENTITY_TYPE_TO_BROKEN_STATE_MAP:get(gridEntityType)
+    return gridEntity.State == brokenState
+end
+function ____exports.isPostBossVoidPortal(self, gridEntity)
+    local saveState = gridEntity:GetSaveState()
+    return saveState.VarData == 1
+end
+function ____exports.removeAllGridExcept(self, ...)
+    local gridEntityTypes = {...}
+    local gridEntityTypeExceptions = __TS__New(Set, gridEntityTypes)
+    local gridEntities = ____exports.getGridEntities(nil)
+    local removedOneOrMoreGridEntities = false
+    for ____, gridEntity in ipairs(gridEntities) do
+        local gridEntityType = gridEntity:GetType()
+        if not gridEntityTypeExceptions:has(gridEntityType) then
+            ____exports.removeGrid(nil, gridEntity, false)
+            removedOneOrMoreGridEntities = true
+        end
+    end
+    if removedOneOrMoreGridEntities then
+        roomUpdateSafe(nil)
+    end
+    return removedOneOrMoreGridEntities
+end
+function ____exports.removeAllMatchingGridEntities(self, ...)
+    local gridEntities = ____exports.getGridEntities(nil, ...)
+    if #gridEntities == 0 then
+        return false
+    end
+    for ____, gridEntity in ipairs(gridEntities) do
+        ____exports.removeGrid(nil, gridEntity, false)
+    end
+    roomUpdateSafe(nil)
+    return true
+end
+function ____exports.setGridEntityInvisible(self, gridEntity)
+    local sprite = gridEntity:GetSprite()
+    clearSprite(nil, sprite)
+end
+function ____exports.spawnGiantPoop(self, topLeftGridIndex)
+    local room = game:GetRoom()
+    local gridWidth = room:GetGridWidth()
+    local topRightGridIndex = topLeftGridIndex + 1
+    local bottomLeftGridIndex = topLeftGridIndex + gridWidth
+    local bottomRightGridIndex = bottomLeftGridIndex + 1
+    ____exports.spawnGridWithVariant(nil, GridEntityType.POOP, PoopGridEntityVariant.GIGA_TOP_LEFT, topLeftGridIndex)
+    ____exports.spawnGridWithVariant(nil, GridEntityType.POOP, PoopGridEntityVariant.GIGA_TOP_RIGHT, topRightGridIndex)
+    ____exports.spawnGridWithVariant(nil, GridEntityType.POOP, PoopGridEntityVariant.GIGA_BOTTOM_LEFT, bottomLeftGridIndex)
+    ____exports.spawnGridWithVariant(nil, GridEntityType.POOP, PoopGridEntityVariant.GIGA_BOTTOM_RIGHT, bottomRightGridIndex)
+end
+function ____exports.spawnGrid(self, gridEntityType, gridIndexOrPosition)
+    return ____exports.spawnGridWithVariant(nil, gridEntityType, 0, gridIndexOrPosition)
+end
+function ____exports.spawnVoidPortal(self, gridIndex)
+    local voidPortal = ____exports.spawnGridWithVariant(nil, GridEntityType.TRAPDOOR, TrapdoorVariant.VOID_PORTAL, gridIndex)
+    if voidPortal == nil then
+        return voidPortal
+    end
+    voidPortal.VarData = 1
+    local sprite = voidPortal:GetSprite()
+    sprite:Load("gfx/grid/voidtrapdoor.anm2", true)
+    return voidPortal
+end
+return ____exports

package/functions/gridEntitySpecific.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="isaac-typescript-definitions" />
+/** Helper function to get all of the `GridEntityPit` in the room. */
+export declare function getPits(): GridEntityPit[];
+/** Helper function to get all of the `GridEntityPoop` in the room. */
+export declare function getPoops(): GridEntityPoop[];
+/** Helper function to get all of the `GridEntityPressurePlate` in the room. */
+export declare function getPressurePlates(): GridEntityPressurePlate[];
+/** Helper function to get all of the `GridEntityRock` in the room. */
+export declare function getRocks(): GridEntityRock[];
+/** Helper function to get all of the `GridEntitySpikes` in the room. */
+export declare function getSpikes(): GridEntitySpikes[];
+/** Helper function to get all of the `GridEntityTNT` in the room. */
+export declare function getTNT(): GridEntityTNT[];
+/**
+ * Helper function to determine if all of the pressure plates in the current room are pushed.
+ * Returns true if there are no pressure plates in the room.
+ */
+export declare function isAllPressurePlatesPushed(): boolean;