isaacscript-common 2.3.0 → 3.0.0

package/functions/doors.lua

@@ -0,0 +1,284 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local __TS__ArrayFind = ____lualib.__TS__ArrayFind
+local ____exports = {}
+local ROOM_ENTRY_OFFSET_FROM_DOOR
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local DoorSlot = ____isaac_2Dtypescript_2Ddefinitions.DoorSlot
+local DoorState = ____isaac_2Dtypescript_2Ddefinitions.DoorState
+local DoorVariant = ____isaac_2Dtypescript_2Ddefinitions.DoorVariant
+local GridRoom = ____isaac_2Dtypescript_2Ddefinitions.GridRoom
+local RoomType = ____isaac_2Dtypescript_2Ddefinitions.RoomType
+local ____cachedClasses = require("cachedClasses")
+local game = ____cachedClasses.game
+local ____doorSlotFlagToDoorSlot = require("objects.doorSlotFlagToDoorSlot")
+local DEFAULT_DOOR_SLOT = ____doorSlotFlagToDoorSlot.DEFAULT_DOOR_SLOT
+local DOOR_SLOT_FLAG_TO_DOOR_SLOT = ____doorSlotFlagToDoorSlot.DOOR_SLOT_FLAG_TO_DOOR_SLOT
+local ____doorSlotToDirection = require("objects.doorSlotToDirection")
+local DOOR_SLOT_TO_DIRECTION = ____doorSlotToDirection.DOOR_SLOT_TO_DIRECTION
+local ____roomShapeToDoorSlots = require("objects.roomShapeToDoorSlots")
+local ROOM_SHAPE_TO_DOOR_SLOTS = ____roomShapeToDoorSlots.ROOM_SHAPE_TO_DOOR_SLOTS
+local ____direction = require("functions.direction")
+local directionToVector = ____direction.directionToVector
+local ____enums = require("functions.enums")
+local getEnumValues = ____enums.getEnumValues
+function ____exports.doorSlotToDirection(self, doorSlot)
+    return DOOR_SLOT_TO_DIRECTION[doorSlot]
+end
+--- Helper function to help calculate the position that a player will enter a room at.
+-- 
+-- When players enter a room, they do not appear exactly on the location of the door, because then
+-- they would immediately collide with the loading zone. Instead, they are offset by a certain
+-- amount of units.
+function ____exports.getDoorEnterPositionOffset(self, doorSlot)
+    local direction = ____exports.doorSlotToDirection(nil, doorSlot)
+    local vector = directionToVector(nil, direction)
+    return vector * ROOM_ENTRY_OFFSET_FROM_DOOR
+end
+--- Helper function to get all of the doors in the room. By default, it will return every door. You
+-- can optionally specify one or more room types to return only the doors that match the specified
+-- room types.
+function ____exports.getDoors(self, ...)
+    local roomTypes = {...}
+    local room = game:GetRoom()
+    local roomTypesSet = __TS__New(Set, roomTypes)
+    local doorSlots = getEnumValues(nil, DoorSlot)
+    local doors = {}
+    for ____, doorSlot in ipairs(doorSlots) do
+        do
+            local door = room:GetDoor(doorSlot)
+            if door == nil then
+                goto __continue15
+            end
+            if roomTypesSet.size == 0 or roomTypesSet:has(door.TargetRoomType) then
+                doors[#doors + 1] = door
+            end
+        end
+        ::__continue15::
+    end
+    return doors
+end
+function ____exports.isRepentanceDoor(self, door)
+    return door.TargetRoomIndex == GridRoom.SECRET_EXIT
+end
+function ____exports.isSecretRoomDoor(self, door)
+    local sprite = door:GetSprite()
+    local filename = sprite:GetFilename()
+    return filename == "gfx/grid/Door_08_HoleInWall.anm2"
+end
+--- Helper function to remove a single door.
+function ____exports.removeDoor(self, door)
+    local room = game:GetRoom()
+    room:RemoveDoor(door.Slot)
+end
+--- Helper function to remove the doors provided.
+-- 
+-- This function is variadic, meaning that you can specify as many doors as you want to remove.
+function ____exports.removeDoors(self, ...)
+    local doors = {...}
+    for ____, door in ipairs(doors) do
+        ____exports.removeDoor(nil, door)
+    end
+end
+ROOM_ENTRY_OFFSET_FROM_DOOR = 40
+function ____exports.closeAllDoors(self)
+    for ____, door in ipairs(____exports.getDoors(nil)) do
+        door:Close(true)
+    end
+end
+--- Use this instead of the `GridEntityDoor.Close` method if you want the door to immediately close
+-- without an animation.
+function ____exports.closeDoorFast(self, door)
+    door.State = DoorState.CLOSED
+    local sprite = door:GetSprite()
+    sprite:Play("Closed", true)
+end
+function ____exports.doorSlotFlagToDoorSlot(self, doorSlotFlag)
+    local doorSlot = DOOR_SLOT_FLAG_TO_DOOR_SLOT[doorSlotFlag]
+    return doorSlot == nil and DEFAULT_DOOR_SLOT or doorSlot
+end
+function ____exports.getAngelRoomDoor(self)
+    local angelRoomDoors = ____exports.getDoors(nil, RoomType.ANGEL)
+    local ____temp_0
+    if #angelRoomDoors == 0 then
+        ____temp_0 = nil
+    else
+        ____temp_0 = angelRoomDoors[1]
+    end
+    return ____temp_0
+end
+function ____exports.getDevilRoomDoor(self)
+    local devilRoomDoors = ____exports.getDoors(nil, RoomType.DEVIL)
+    local ____temp_1
+    if #devilRoomDoors == 0 then
+        ____temp_1 = nil
+    else
+        ____temp_1 = devilRoomDoors[1]
+    end
+    return ____temp_1
+end
+--- If there is both a Devil Room and an Angel Room door, this function will return door with the
+-- lowest slot number.
+function ____exports.getDevilRoomOrAngelRoomDoor(self)
+    local devilRoomOrAngelRoomDoors = ____exports.getDoors(nil, RoomType.DEVIL, RoomType.ANGEL)
+    local ____temp_2
+    if #devilRoomOrAngelRoomDoors == 0 then
+        ____temp_2 = nil
+    else
+        ____temp_2 = devilRoomOrAngelRoomDoors[1]
+    end
+    return ____temp_2
+end
+--- Helper function to get the position that a player will enter a room at.
+-- 
+-- When players enter a room, they do not appear exactly on the location of the door, because then
+-- they would immediately collide with the loading zone. Instead, they are offset by a certain
+-- amount of units.
+function ____exports.getDoorEnterPosition(self, door)
+    local offset = ____exports.getDoorEnterPositionOffset(nil, door.Slot)
+    return door.Position + offset
+end
+--- Helper function to get the possible door slots that can exist for a given room shape.
+function ____exports.getDoorSlotsForRoomShape(self, roomShape)
+    local doorSlots = ROOM_SHAPE_TO_DOOR_SLOTS[roomShape]
+    return doorSlots == nil and __TS__New(Set) or doorSlots
+end
+--- Helper function to get all of the doors in the room that lead to the provided room index.
+-- 
+-- This function is variadic, meaning that you can specify N arguments to return all of the doors
+-- that match any of the N room grid indexes.
+function ____exports.getDoorsToRoomIndex(self, ...)
+    local roomGridIndex = {...}
+    local roomGridIndexesSet = __TS__New(Set, roomGridIndex)
+    local doors = ____exports.getDoors(nil)
+    return __TS__ArrayFilter(
+        doors,
+        function(____, door) return roomGridIndexesSet:has(door.TargetRoomIndex) end
+    )
+end
+function ____exports.getRepentanceDoor(self)
+    local doors = ____exports.getDoors(nil)
+    return __TS__ArrayFind(
+        doors,
+        function(____, door) return ____exports.isRepentanceDoor(nil, door) end
+    )
+end
+--- Helper function to find unused door slots in the room that can be used to make custom doors.
+function ____exports.getUnusedDoorSlots(self)
+    local room = game:GetRoom()
+    local doorSlots = getEnumValues(nil, DoorSlot)
+    return __TS__ArrayFilter(
+        doorSlots,
+        function(____, doorSlot) return room:IsDoorSlotAllowed(doorSlot) and room:GetDoor(doorSlot) == nil end
+    )
+end
+function ____exports.isAngelRoomDoor(self, door)
+    return door.TargetRoomType == RoomType.ANGEL
+end
+function ____exports.isDevilRoomDoor(self, door)
+    return door.TargetRoomType == RoomType.DEVIL
+end
+--- Helper function to see if a door slot could exist for a given room shape.
+function ____exports.isDoorSlotInRoomShape(self, doorSlot, roomShape)
+    local doorSlots = ____exports.getDoorSlotsForRoomShape(nil, roomShape)
+    return doorSlots:has(doorSlot)
+end
+--- This refers to the Repentance door that spawns in a boss room after defeating the boss. You have
+-- to spend one key to open it. It has a sprite filename of "gfx/grid/Door_Downpour.anm2".
+function ____exports.isDoorToDownpour(self, door)
+    if not ____exports.isRepentanceDoor(nil, door) then
+        return false
+    end
+    local sprite = door:GetSprite()
+    local filename = sprite:GetFilename()
+    return filename == "gfx/grid/Door_Downpour.anm2"
+end
+--- This refers to the Repentance door that spawns in a boss room after defeating the boss. You have
+-- to spend two hearts to open it. It has a sprite filename of "gfx/grid/Door_Mausoleum.anm2".
+function ____exports.isDoorToMausoleum(self, door)
+    if not ____exports.isRepentanceDoor(nil, door) then
+        return false
+    end
+    local sprite = door:GetSprite()
+    local filename = sprite:GetFilename()
+    return filename == "gfx/grid/Door_Mausoleum.anm2"
+end
+--- This refers to the "strange door" located on the first room of Depths 2. You open it with either
+-- a Polaroid or a Negative. It has a sprite filename of "gfx/grid/Door_Mausoleum_Alt.anm2".
+function ____exports.isDoorToMausoleumAscent(self, door)
+    if not ____exports.isRepentanceDoor(nil, door) then
+        return false
+    end
+    local sprite = door:GetSprite()
+    local filename = sprite:GetFilename()
+    return filename == "gfx/grid/Door_Mausoleum_Alt.anm2"
+end
+--- This refers to the Repentance door that spawns in a boss room after defeating the boss. You have
+-- to spend two bombs to open it. It has a sprite filename of "gfx/grid/Door_Mines.anm2".
+function ____exports.isDoorToMines(self, door)
+    if not ____exports.isRepentanceDoor(nil, door) then
+        return false
+    end
+    local sprite = door:GetSprite()
+    local filename = sprite:GetFilename()
+    return filename == "gfx/grid/Door_Mines.anm2"
+end
+--- This refers to the Repentance door that spawns after defeating Mom. You open it with the
+-- completed knife. It has a sprite filename of "gfx/grid/Door_MomsHeart.anm2".
+function ____exports.isDoorToMomsHeart(self, door)
+    if not ____exports.isRepentanceDoor(nil, door) then
+        return false
+    end
+    local sprite = door:GetSprite()
+    local filename = sprite:GetFilename()
+    return filename == "gfx/grid/Door_MomsHeart.anm2"
+end
+function ____exports.isHiddenSecretRoomDoor(self, door)
+    local sprite = door:GetSprite()
+    local animation = sprite:GetAnimation()
+    return ____exports.isSecretRoomDoor(nil, door) and animation == "Hidden"
+end
+--- Helper function to reset an unlocked door back to a locked state. Doing this is non-trivial
+-- because in addition to calling the `GridEntityDoor.SetLocked` method, you must also:
+-- 
+-- - Set the `VisitedCount` of the room's `RoomDescription` to 0.
+-- - Set the variant to `DoorVariant.DOOR_LOCKED`.
+-- - Close the door.
+function ____exports.lockDoor(self, door)
+    local level = game:GetLevel()
+    local roomDescriptor = level:GetRoomByIdx(door.TargetRoomIndex)
+    roomDescriptor.VisitedCount = 0
+    door:SetVariant(DoorVariant.LOCKED)
+    door:SetLocked(true)
+    door:Close(true)
+end
+--- For the purposes of this function, doors to Secret Rooms or Super Secret Rooms that have not been
+-- discovered yet will not be opened.
+function ____exports.openAllDoors(self)
+    for ____, door in ipairs(____exports.getDoors(nil)) do
+        door:Open()
+    end
+end
+--- Use this instead of the `GridEntityDoor.Open` method if you want the door to immediately open
+-- without an animation.
+function ____exports.openDoorFast(self, door)
+    door.State = DoorState.OPEN
+    local sprite = door:GetSprite()
+    sprite:Play("Opened", true)
+end
+--- Helper function to remove all of the doors in the room. By default, it will remove every door.
+-- You can optionally specify one or more room types to remove only the doors that match the
+-- specified room types.
+-- 
+-- @returns The number of doors removed.
+function ____exports.removeAllDoors(self, ...)
+    local doors = ____exports.getDoors(nil, ...)
+    ____exports.removeDoors(
+        nil,
+        table.unpack(doors)
+    )
+    return #doors
+end
+return ____exports

package/functions/easing.d.ts

@@ -0,0 +1,30 @@
+export declare function easeInSine(x: number): number;
+export declare function easeOutSine(x: number): number;
+export declare function easeInOutSine(x: number): number;
+export declare function easeInCubic(x: number): number;
+export declare function easeOutCubic(x: number): number;
+export declare function easeInOutCubic(x: number): number;
+export declare function easeInQuint(x: number): number;
+export declare function easeOutQuint(x: number): number;
+export declare function easeInOutQuint(x: number): number;
+export declare function easeInCirc(x: number): number;
+export declare function easeOutCirc(x: number): number;
+export declare function easeInOutCirc(x: number): number;
+export declare function easeInElastic(x: number): number;
+export declare function easeOutElastic(x: number): number;
+export declare function easeInOutElastic(x: number): number;
+export declare function easeInQuad(x: number): number;
+export declare function easeOutQuad(x: number): number;
+export declare function easeInOutQuad(x: number): number;
+export declare function easeInQuart(x: number): number;
+export declare function easeOutQuart(x: number): number;
+export declare function easeInOutQuart(x: number): number;
+export declare function easeInExpo(x: number): number;
+export declare function easeOutExpo(x: number): number;
+export declare function easeInOutExpo(x: number): number;
+export declare function easeInBack(x: number): number;
+export declare function easeOutBack(x: number): number;
+export declare function easeInOutBack(x: number): number;
+export declare function easeInBounce(x: number): number;
+export declare function easeOutBounce(x: number): number;
+export declare function easeInOutBounce(x: number): number;

package/functions/easing.lua

@@ -0,0 +1,115 @@
+local ____exports = {}
+function ____exports.easeOutBounce(self, x)
+    local n1 = 7.5625
+    local d1 = 2.75
+    if x < 1 / d1 then
+        return n1 * x * x
+    end
+    if x < 2 / d1 then
+        x = x - 1.5 / d1
+        return n1 * x * x + 0.75
+    end
+    if x < 2.5 / d1 then
+        x = x - 2.25 / d1
+        return n1 * x * x + 0.9375
+    end
+    x = x - 2.625 / d1
+    return n1 * x * x + 0.984375
+end
+function ____exports.easeInSine(self, x)
+    return 1 - math.cos(x * math.pi / 2)
+end
+function ____exports.easeOutSine(self, x)
+    return math.sin(x * math.pi / 2)
+end
+function ____exports.easeInOutSine(self, x)
+    return -(math.cos(math.pi * x) - 1) / 2
+end
+function ____exports.easeInCubic(self, x)
+    return x * x * x
+end
+function ____exports.easeOutCubic(self, x)
+    return 1 - (1 - x) ^ 3
+end
+function ____exports.easeInOutCubic(self, x)
+    return x < 0.5 and 4 * x * x * x or 1 - (-2 * x + 2) ^ 3 / 2
+end
+function ____exports.easeInQuint(self, x)
+    return x * x * x * x * x
+end
+function ____exports.easeOutQuint(self, x)
+    return 1 - (1 - x) ^ 5
+end
+function ____exports.easeInOutQuint(self, x)
+    return x < 0.5 and 16 * x * x * x * x * x or 1 - (-2 * x + 2) ^ 5 / 2
+end
+function ____exports.easeInCirc(self, x)
+    return 1 - math.sqrt(1 - x ^ 2)
+end
+function ____exports.easeOutCirc(self, x)
+    return math.sqrt(1 - (x - 1) ^ 2)
+end
+function ____exports.easeInOutCirc(self, x)
+    return x < 0.5 and (1 - math.sqrt(1 - (2 * x) ^ 2)) / 2 or (math.sqrt(1 - (-2 * x + 2) ^ 2) + 1) / 2
+end
+function ____exports.easeInElastic(self, x)
+    local c4 = 2 * math.pi / 3
+    return x == 0 and 0 or (x == 1 and 1 or -2 ^ (10 * x - 10) * math.sin((x * 10 - 10.75) * c4))
+end
+function ____exports.easeOutElastic(self, x)
+    local c4 = 2 * math.pi / 3
+    return x == 0 and 0 or (x == 1 and 1 or 2 ^ (-10 * x) * math.sin((x * 10 - 0.75) * c4) + 1)
+end
+function ____exports.easeInOutElastic(self, x)
+    local c5 = 2 * math.pi / 4.5
+    return x == 0 and 0 or (x == 1 and 1 or (x < 0.5 and -(2 ^ (20 * x - 10) * math.sin((20 * x - 11.125) * c5)) / 2 or 2 ^ (-20 * x + 10) * math.sin((20 * x - 11.125) * c5) / 2 + 1))
+end
+function ____exports.easeInQuad(self, x)
+    return x * x
+end
+function ____exports.easeOutQuad(self, x)
+    return 1 - (1 - x) * (1 - x)
+end
+function ____exports.easeInOutQuad(self, x)
+    return x < 0.5 and 2 * x * x or 1 - (-2 * x + 2) ^ 2 / 2
+end
+function ____exports.easeInQuart(self, x)
+    return x * x * x * x
+end
+function ____exports.easeOutQuart(self, x)
+    return 1 - (1 - x) ^ 4
+end
+function ____exports.easeInOutQuart(self, x)
+    return x < 0.5 and 8 * x * x * x * x or 1 - (-2 * x + 2) ^ 4 / 2
+end
+function ____exports.easeInExpo(self, x)
+    return x == 0 and 0 or 2 ^ (10 * x - 10)
+end
+function ____exports.easeOutExpo(self, x)
+    return x == 1 and 1 or 1 - 2 ^ (-10 * x)
+end
+function ____exports.easeInOutExpo(self, x)
+    return x == 0 and 0 or (x == 1 and 1 or (x < 0.5 and 2 ^ (20 * x - 10) / 2 or (2 - 2 ^ (-20 * x + 10)) / 2))
+end
+function ____exports.easeInBack(self, x)
+    local c1 = 1.70158
+    local c3 = c1 + 1
+    return c3 * x * x * x - c1 * x * x
+end
+function ____exports.easeOutBack(self, x)
+    local c1 = 1.70158
+    local c3 = c1 + 1
+    return 1 + c3 * (x - 1) ^ 3 + c1 * (x - 1) ^ 2
+end
+function ____exports.easeInOutBack(self, x)
+    local c1 = 1.70158
+    local c2 = c1 * 1.525
+    return x < 0.5 and (2 * x) ^ 2 * ((c2 + 1) * 2 * x - c2) / 2 or ((2 * x - 2) ^ 2 * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2
+end
+function ____exports.easeInBounce(self, x)
+    return 1 - ____exports.easeOutBounce(nil, 1 - x)
+end
+function ____exports.easeInOutBounce(self, x)
+    return x < 0.5 and (1 - ____exports.easeOutBounce(nil, 1 - 2 * x)) / 2 or (1 + ____exports.easeOutBounce(nil, 2 * x - 1)) / 2
+end
+return ____exports

package/functions/eden.d.ts

@@ -0,0 +1,3 @@
+import { CollectibleType } from "isaac-typescript-definitions";
+export declare function getEdenPassives(): Set<CollectibleType>;
+export declare function getRandomEdenPassive(seedOrRNG?: Seed | RNG, exceptions?: CollectibleType[] | readonly CollectibleType[]): CollectibleType;

package/functions/eden.lua

@@ -0,0 +1,47 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__Iterator = ____lualib.__TS__Iterator
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ItemConfigTag = ____isaac_2Dtypescript_2Ddefinitions.ItemConfigTag
+local ____collectibles = require("functions.collectibles")
+local isHiddenCollectible = ____collectibles.isHiddenCollectible
+local isPassiveCollectible = ____collectibles.isPassiveCollectible
+local ____collectibleSet = require("functions.collectibleSet")
+local getCollectibleSet = ____collectibleSet.getCollectibleSet
+local ____collectibleTag = require("functions.collectibleTag")
+local collectibleHasTag = ____collectibleTag.collectibleHasTag
+local ____rng = require("functions.rng")
+local getRandomSeed = ____rng.getRandomSeed
+local ____set = require("functions.set")
+local copySet = ____set.copySet
+local getRandomSetElement = ____set.getRandomSetElement
+local EDEN_PASSIVE_COLLECTIBLES_SET = __TS__New(Set)
+local function initCollectibleSet(self)
+    local collectibleSet = getCollectibleSet(nil)
+    for ____, collectibleType in __TS__Iterator(collectibleSet:values()) do
+        if isPassiveCollectible(nil, collectibleType) and not isHiddenCollectible(nil, collectibleType) and not collectibleHasTag(nil, collectibleType, ItemConfigTag.NO_EDEN) then
+            EDEN_PASSIVE_COLLECTIBLES_SET:add(collectibleType)
+        end
+    end
+end
+function ____exports.getEdenPassives(self)
+    if EDEN_PASSIVE_COLLECTIBLES_SET.size == 0 then
+        initCollectibleSet(nil)
+    end
+    return copySet(nil, EDEN_PASSIVE_COLLECTIBLES_SET)
+end
+function ____exports.getRandomEdenPassive(self, seedOrRNG, exceptions)
+    if seedOrRNG == nil then
+        seedOrRNG = getRandomSeed(nil)
+    end
+    if exceptions == nil then
+        exceptions = {}
+    end
+    if EDEN_PASSIVE_COLLECTIBLES_SET.size == 0 then
+        initCollectibleSet(nil)
+    end
+    return getRandomSetElement(nil, EDEN_PASSIVE_COLLECTIBLES_SET, seedOrRNG, exceptions)
+end
+return ____exports

package/functions/entity.d.ts

@@ -0,0 +1,131 @@
+import { EntityType } from "isaac-typescript-definitions";
+import { AnyEntity } from "../types/AnyEntity";
+/**
+ * Helper function to count the number of entities in room. Use this over the vanilla
+ * `Isaac.CountEntities` method to avoid having to specify a spawner and to handle ignoring charmed
+ * enemies.
+ *
+ * @param entityType Default is -1. -1 matches every entity type.
+ * @param variant Default is -1. -1 matches every variant.
+ * @param subType Default is -1. -1 matches every sub-type.
+ * @param ignoreFriendly Default is false.
+ */
+export declare function countEntities(entityType?: EntityType, variant?: number, subType?: number, ignoreFriendly?: boolean): int;
+/**
+ * Given an array of entities, this helper function returns the closest one to a provided reference
+ * entity.
+ *
+ * For example:
+ *
+ * ```ts
+ * const player = Isaac.GetPlayer();
+ * const gapers = getEntities(EntityType.GAPER);
+ * const closestGaper = getClosestEntityTo(player, gapers);
+ * ```
+ */
+export declare function getClosestEntityTo<T extends AnyEntity>(referenceEntity: Entity, entities: T[]): T | undefined;
+/**
+ * Helper function to get all of the entities in the room or all of the entities that match a
+ * specific entity type / variant / sub-type.
+ *
+ * Due to bugs with `Isaac.FindInRadius`, this function uses `Isaac.GetRoomEntities`, which is more
+ * expensive but also more robust. (If a matching entity type is provided, then `Isaac.FindByType`
+ * will be used instead.)
+ *
+ * For example:
+ *
+ * ```ts
+ * // Make all of the entities in the room invisible
+ * for (const entity of getEntities()) {
+ *   entity.Visible = false;
+ * }
+ * ```
+ *
+ * @param entityType Optional. If specified, will only return NPCs that match this entity type.
+ * @param variant Optional. If specified, will only return NPCs that match this variant. Default is
+ *                -1. -1 matches every variant.
+ * @param subType Optional. If specified, will only return NPCs that match this sub-type. Default is
+ *                -1. -1 matches every sub-type.
+ * @param ignoreFriendly Optional. If set to true, it will exclude friendly NPCs from being
+ *                       returned. Default is false. Will only be taken into account if
+ *                       `matchingEntityType` is specified.
+ */
+export declare function getEntities(entityType?: EntityType, variant?: number, subType?: number, ignoreFriendly?: boolean): Entity[];
+/** Helper function to return a string containing the entity's type, variant, and sub-type. */
+export declare function getEntityID(entity: Entity): string;
+/**
+ * Helper function to compare two different arrays of entities. Returns the entities that are in the
+ * second array but not in the first array.
+ */
+export declare function getFilteredNewEntities<T extends AnyEntity>(oldEntities: T[], newEntities: T[]): T[];
+/**
+ * Helper function to measure an entity's velocity to see if it is moving.
+ *
+ * @param entity The entity whose velocity to measure.
+ * @param threshold Optional. The threshold from 0 to consider to be moving. Default is 0.01.
+ */
+export declare function isEntityMoving(entity: Entity, threshold?: number): boolean;
+/**
+ * Helper function to determine if the specified entity type is an end-game story boss, like Isaac,
+ * Blue Baby, Mega Satan, The Beast, and so on. This is useful because certain effects should only
+ * apply to non-story bosses, like Vanishing Twin. Also see the `STORY_BOSSES` constant.
+ */
+export declare function isStoryBoss(entityType: EntityType): boolean;
+/**
+ * Helper function to parse a string that contains an entity type, a variant, and a sub-type,
+ * separated by periods.
+ *
+ * For example, passing "45.0.1" would return an array of [45, 0, 1].
+ *
+ * Returns undefined if the string cannot be parsed.
+ */
+export declare function parseEntityID(entityID: string): [entityType: EntityType, variant: int, subType: int] | undefined;
+/**
+ * Helper function to parse a string that contains an entity type and a variant separated by a
+ * period.
+ *
+ * For example, passing "45.0" would return an array of [45, 0].
+ *
+ * Returns undefined if the string cannot be parsed.
+ */
+export declare function parseEntityTypeVariantString(entityTypeVariantString: string): [entityType: EntityType, variant: int] | undefined;
+/**
+ * Helper function to remove all of the matching entities in the room.
+ *
+ * @param entityType The entity type to match.
+ * @param entityVariant Optional. The variant to match. Default is -1. -1 matches every variant.
+ * @param entitySubType Optional. The sub-type to match. Default is -1. -1 matches every sub-type.
+ * @param cap Optional. If specified, will only remove the given amount of collectibles.
+ * @returns True if one or more entities were removed, false otherwise.
+ */
+export declare function removeAllMatchingEntities(entityType: EntityType, entityVariant?: number, entitySubType?: number, cap?: int | undefined): boolean;
+/**
+ * Helper function to remove all of the entities in the supplied array.
+ *
+ * @param entities The array of entities to remove.
+ * @param cap Optional. If specified, will only remove the given amount of entities.
+ * @returns True if one or more entities were removed, false otherwise.
+ */
+export declare function removeEntities(entities: Entity[], cap?: int): boolean;
+/**
+ * Helper function to reroll an enemy. Use this instead of the vanilla "Game.RerollEnemy" function
+ * if you want the rerolled enemy to be returned.
+ *
+ * @param entity The entity to reroll.
+ * @returns If the game failed to reroll the enemy, returns undefined. Otherwise, returns the
+ *          rerolled entity.
+ */
+export declare function rerollEnemy(entity: Entity): Entity | undefined;
+export declare function setEntityRandomColor(entity: Entity): void;
+/**
+ * Helper function to spawn an entity. Use this instead of the `Isaac.Spawn` method if you do not
+ * need to specify the velocity or spawner.
+ *
+ * Also see the `spawnWithSeed` helper function.
+ */
+export declare function spawn(entityType: EntityType, variant: int, subType: int, position: Vector, velocity?: Readonly<Vector>, spawner?: Entity | undefined, seed?: Seed | undefined): Entity;
+/**
+ * Helper function to spawn an entity. Use this instead of the `Game.Spawn` method if you do not
+ * need to specify the velocity or spawner.
+ */
+export declare function spawnWithSeed(entityType: EntityType, variant: int, subType: int, position: Vector, seed: Seed, velocity?: Readonly<Vector>, spawner?: Entity | undefined): Entity;