isaacscript-common 2.3.0 → 3.0.0

package/functions/math.lua

@@ -0,0 +1,118 @@
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local Direction = ____isaac_2Dtypescript_2Ddefinitions.Direction
+local ____direction = require("functions.direction")
+local directionToVector = ____direction.directionToVector
+--- Helper function to normalize an integer.
+-- 
+-- - If `x` is less than `min`, then it will be clamped to `min`.
+-- - If `x` is greater than `max`, then it will be clamped to `max`.
+function ____exports.clamp(self, x, min, max)
+    return math.max(
+        min,
+        math.min(x, max)
+    )
+end
+function ____exports.getAngleDifference(self, angle1, angle2)
+    local subtractedAngle = angle1 - angle2
+    return (subtractedAngle + 180) % 360 - 180
+end
+--- Helper function to get an array of equidistant points on the circumference around a circle.
+-- Useful for equally distributing things in a circle pattern.
+-- 
+-- @param centerPos A position that represents the center of the center to get the points from.
+-- @param radius The radius of the circle.
+-- @param numPoints The number of points on the circumference of the circle to get.
+-- @param xMultiplier An optional multiplier to get the points around an oval. Default is 1.
+-- @param yMultiplier An optional multiplier to get the points around an oval. Default is 1.
+-- @param initialDirection By default, the first point on the circle will be on the top center, but
+-- this can be optionally changed by specifying this argument.
+function ____exports.getCircleDiscretizedPoints(self, centerPos, radius, numPoints, xMultiplier, yMultiplier, initialDirection)
+    if xMultiplier == nil then
+        xMultiplier = 1
+    end
+    if yMultiplier == nil then
+        yMultiplier = 1
+    end
+    if initialDirection == nil then
+        initialDirection = Direction.UP
+    end
+    local vector = directionToVector(nil, initialDirection)
+    local initialPosition = vector * radius
+    local positions = {}
+    do
+        local i = 0
+        while i < numPoints do
+            local rotatedPosition = initialPosition:Rotated(i * 360 / numPoints)
+            rotatedPosition.X = rotatedPosition.X * xMultiplier
+            rotatedPosition.Y = rotatedPosition.Y * yMultiplier
+            local positionFromCenter = centerPos + rotatedPosition
+            positions[#positions + 1] = positionFromCenter
+            i = i + 1
+        end
+    end
+    return positions
+end
+--- Helper function to check if a given position is within a given rectangle.
+-- 
+-- This is an inclusive check, meaning that it will return true if the position is on the border of
+-- the rectangle.
+function ____exports.inRectangle(self, position, topLeft, bottomRight)
+    return position.X >= topLeft.X and position.X <= bottomRight.X and position.Y >= topLeft.Y and position.Y <= bottomRight.Y
+end
+--- From: https://www.geeksforgeeks.org/check-if-any-point-overlaps-the-given-circle-and-rectangle/
+function ____exports.isCircleIntersectingRectangle(self, circleCenter, circleRadius, rectangleTopLeft, rectangleBottomRight)
+    local nearestX = math.max(
+        rectangleTopLeft.X,
+        math.min(circleCenter.X, rectangleBottomRight.X)
+    )
+    local nearestY = math.max(
+        rectangleTopLeft.Y,
+        math.min(circleCenter.Y, rectangleBottomRight.Y)
+    )
+    local nearestPointToCircleOnRectangle = Vector(nearestX, nearestY)
+    local distanceToCenterOfCircle = nearestPointToCircleOnRectangle:Distance(circleCenter)
+    return distanceToCenterOfCircle <= circleRadius
+end
+function ____exports.isEven(self, num)
+    return num & 1 == 0
+end
+function ____exports.isOdd(self, num)
+    return num & 1 == 1
+end
+function ____exports.lerp(self, a, b, pos)
+    return a + (b - a) * pos
+end
+function ____exports.lerpAngleDegrees(self, aStart, aEnd, percent)
+    return aStart + ____exports.getAngleDifference(nil, aStart, aEnd) * percent
+end
+--- If rounding fails, this function returns 0.
+-- From: http://lua-users.org/wiki/SimpleRound
+-- 
+-- @param num The number to round.
+-- @param numDecimalPlaces Default is 0.
+function ____exports.round(self, num, numDecimalPlaces)
+    if numDecimalPlaces == nil then
+        numDecimalPlaces = 0
+    end
+    local roundedNum = tonumber(string.format(
+        ("%." .. tostring(numDecimalPlaces)) .. "f",
+        num
+    ))
+    return roundedNum == nil and 0 or roundedNum
+end
+---
+-- @returns 1 if n is positive, -1 if n is negative, or 0 if n is 0.
+function ____exports.sign(self, n)
+    if n > 0 then
+        return 1
+    end
+    if n < 0 then
+        return -1
+    end
+    return 0
+end
+function ____exports.tanh(self, x)
+    return (math.exp(x) - math.exp(-x)) / (math.exp(x) + math.exp(-x))
+end
+return ____exports

package/functions/mergeTests.d.ts

@@ -0,0 +1 @@
+export declare function mergeTests(): void;

package/functions/mergeTests.lua

@@ -0,0 +1,182 @@
+local ____exports = {}
+local oldTableHasUpdatedValue, newTableHasSameValue, oldTableHasUpdatedValueFromNull, oldTableHasSerializedIsaacAPIClass, oldTableHasFilledInterface, oldTableHasVector, oldTableHasVectorSerialized, oldTableHasRNG, oldTableHasRNGSerialized
+local ____SerializationType = require("enums.SerializationType")
+local SerializationType = ____SerializationType.SerializationType
+local ____merge = require("features.saveDataManager.merge")
+local merge = ____merge.merge
+local ____deepCopy = require("functions.deepCopy")
+local deepCopy = ____deepCopy.deepCopy
+local ____log = require("functions.log")
+local log = ____log.log
+local ____rng = require("functions.rng")
+local isRNG = ____rng.isRNG
+local newRNG = ____rng.newRNG
+local ____serialization = require("functions.serialization")
+local isSerializedIsaacAPIClass = ____serialization.isSerializedIsaacAPIClass
+local ____vector = require("functions.vector")
+local copyVector = ____vector.copyVector
+local isVector = ____vector.isVector
+function oldTableHasUpdatedValue(self)
+    local key = "foo"
+    local oldValue = "bar"
+    local newValue = "baz"
+    local oldTable = {foo = oldValue}
+    local newTable = {foo = newValue}
+    merge(nil, oldTable, newTable, "oldTableHasUpdatedValue")
+    local oldTableValue = oldTable[key]
+    if oldTableValue ~= newValue then
+        error("The old table does not have a value of: " .. newValue)
+    end
+end
+function newTableHasSameValue(self)
+    local key = "foo"
+    local oldValue = "bar"
+    local newValue = "baz"
+    local oldTable = {foo = oldValue}
+    local newTable = {foo = newValue}
+    merge(nil, oldTable, newTable, "newTableHasSameValue")
+    local newTableValue = newTable[key]
+    if newTableValue ~= newValue then
+        error("The new table does not have a value of: " .. newValue)
+    end
+end
+function oldTableHasUpdatedValueFromNull(self)
+    local key = "foo"
+    local newValue = "baz"
+    local oldTable = {foo = nil}
+    local newTable = {foo = newValue}
+    merge(nil, oldTable, newTable, "oldTableHasUpdatedValueFromNull")
+    local oldTableValue = oldTable[key]
+    if oldTableValue ~= newValue then
+        error("The old table does not have a value of: " .. newValue)
+    end
+end
+function oldTableHasSerializedIsaacAPIClass(self)
+    local x = 50
+    local y = 60
+    local vector = Vector(x, y)
+    local vectorSerialized = copyVector(nil, vector, SerializationType.SERIALIZE)
+    if not isSerializedIsaacAPIClass(nil, vectorSerialized) then
+        error("The \"isSerializedIsaacAPIClass\" function says that a serialized vector is not serialized.")
+    end
+end
+function oldTableHasFilledInterface(self)
+    local key = "foo"
+    local newValue = "baz"
+    local oldTable = {foo = nil}
+    local foo = {bar = newValue}
+    local newTable = {foo = foo}
+    merge(nil, oldTable, newTable, "oldTableHasFilledInterface")
+    local oldTableValue = oldTable[key]
+    if oldTableValue == nil then
+        error(("The old table's key of \"" .. key) .. "\" was not filled.")
+    end
+    if oldTableValue.bar ~= newValue then
+        error("The old table's key of \"bar\" was not filled.")
+    end
+end
+function oldTableHasVector(self)
+    log("Starting test: oldTableHasVector")
+    local key = "foo"
+    local x = 50
+    local y = 60
+    local newValue = Vector(x, y)
+    local oldTable = {foo = nil}
+    local foo = {bar = newValue}
+    local newTable = {foo = foo}
+    merge(nil, oldTable, newTable, "oldTableHasVector")
+    local oldTableValue = oldTable[key]
+    if oldTableValue == nil then
+        error(("The old table's key of \"" .. key) .. "\" was not filled.")
+    end
+    if oldTableValue.bar.X ~= x then
+        error("The old table's value for \"x\" does not match: " .. tostring(x))
+    end
+    if oldTableValue.bar.Y ~= y then
+        error("The old table's value for \"y\" does not match: " .. tostring(y))
+    end
+    if not isVector(nil, oldTableValue.bar) then
+        error("The old table's value is not a Vector object.")
+    end
+end
+function oldTableHasVectorSerialized(self)
+    log("Starting test: oldTableHasVectorSerialized")
+    local key = "foo"
+    local x = 50
+    local y = 60
+    local newValue = Vector(x, y)
+    local oldTable = {foo = nil}
+    local foo = {bar = newValue}
+    local newTable = {foo = foo}
+    local newTableSerialized = deepCopy(nil, newTable, SerializationType.SERIALIZE)
+    merge(nil, oldTable, newTableSerialized, "oldTableHasVectorSerialized")
+    local oldTableValue = oldTable[key]
+    if oldTableValue == nil then
+        error(("The old table's key of \"" .. key) .. "\" was not filled.")
+    end
+    if oldTableValue.bar.X ~= x then
+        error("The old table's value for \"x\" does not match: " .. tostring(x))
+    end
+    if oldTableValue.bar.Y ~= y then
+        error("The old table's value for \"y\" does not match: " .. tostring(y))
+    end
+    if not isVector(nil, oldTableValue.bar) then
+        error("The old table's value is not a Vector object (during the serialized test).")
+    end
+end
+function oldTableHasRNG(self)
+    log("Starting test: oldTableHasRNG")
+    local key = "foo"
+    local seed = 50
+    local newValue = newRNG(nil, seed)
+    local oldTable = {foo = nil}
+    local foo = {bar = newValue}
+    local newTable = {foo = foo}
+    merge(nil, oldTable, newTable, "oldTableHasRNG")
+    local oldTableValue = oldTable[key]
+    if oldTableValue == nil then
+        error(("The old table's key of \"" .. key) .. "\" was not filled.")
+    end
+    if not isRNG(nil, oldTableValue.bar) then
+        error("The old table's value is not an RNG object.")
+    end
+    local newSeed = oldTableValue.bar:GetSeed()
+    if newSeed ~= seed then
+        error("The old table's seed not match: " .. tostring(seed))
+    end
+end
+function oldTableHasRNGSerialized(self)
+    log("Starting test: oldTableHasRNGSerialized")
+    local key = "foo"
+    local seed = 50
+    local newValue = newRNG(nil, seed)
+    local oldTable = {foo = nil}
+    local foo = {bar = newValue}
+    local newTable = {foo = foo}
+    local newTableSerialized = deepCopy(nil, newTable, SerializationType.SERIALIZE)
+    merge(nil, oldTable, newTableSerialized, "oldTableHasRNGSerialized")
+    local oldTableValue = oldTable[key]
+    if oldTableValue == nil then
+        error(("The old table's key of \"" .. key) .. "\" was not filled.")
+    end
+    if not isRNG(nil, oldTableValue.bar) then
+        error("The old table's value is not an RNG object (during the serialized test).")
+    end
+    local newSeed = oldTableValue.bar:GetSeed()
+    if newSeed ~= seed then
+        error("The old table's seed not match: " .. tostring(seed))
+    end
+end
+function ____exports.mergeTests(self)
+    oldTableHasUpdatedValue(nil)
+    newTableHasSameValue(nil)
+    oldTableHasUpdatedValueFromNull(nil)
+    oldTableHasSerializedIsaacAPIClass(nil)
+    oldTableHasFilledInterface(nil)
+    oldTableHasVector(nil)
+    oldTableHasVectorSerialized(nil)
+    oldTableHasRNG(nil)
+    oldTableHasRNGSerialized(nil)
+    log("All merge tests passed!")
+end
+return ____exports

package/functions/npc.d.ts

@@ -0,0 +1,40 @@
+import { EntityType, ProjectilesMode } from "isaac-typescript-definitions";
+/**
+ * Helper function to make an NPC fire a projectile. Returns the fired projectile. Use this function
+ * instead of the `EntityNPC.FireProjectiles` method, since that returns void.
+ *
+ * @param npc The NPC to fire the projectile from.
+ * @param position The staring position of the projectile.
+ * @param velocity The starting velocity of the projectile.
+ * @param projectilesMode The mode of the projectile. Optional. Default is
+ *                        `ProjectilesMode.ONE_PROJECTILE`.
+ * @param projectileParams The parameters of the projectile. Optional. Default is
+ *                         `ProjectileParams()`.
+ * @returns The fired projectile.
+ */
+export declare function fireProjectiles(npc: EntityNPC, position: Vector, velocity: Vector, projectilesMode?: ProjectilesMode, projectileParams?: ProjectileParams): EntityProjectile[];
+/**
+ * Helper function to get all of the non-dead NPCs in the room.
+ *
+ * This function will not include NPCs on an internal blacklist, such as Death's scythes or Big Horn
+ * holes.
+ */
+export declare function getAliveNPCs(matchingEntityType?: EntityType, matchingVariant?: int, matchingSubType?: int, ignoreFriendly?: boolean): EntityNPC[];
+/**
+ * Checks for specific NPCs that have "CanShutDoors" set to true naturally by the game, but should
+ * not actually keep the doors closed (like Death's scythes).
+ */
+export declare function isAliveExceptionNPC(npc: EntityNPC): boolean;
+/**
+ * Helper function to detect the custom death state of an Eggy. Eggies are never actually marked
+ * dead by the game. Instead, when Eggies take fatal damage, they go into NpcState.STATE_SUICIDE and
+ * spawn 14 Swarm Spiders while their StateFrame ticks upwards.
+ */
+export declare function isDyingEggyWithNoSpidersLeft(npc: EntityNPC): boolean;
+/**
+ * Helper function to detect the custom death state of a Rag Man Ragling. When Rag Man Raglings die,
+ * they turn into a patch on the ground and can be revived by Rag Man at a later time. This causes
+ * them to show up as an "alive" enemy, so they should usually be filtered out of lists of alive
+ * enemies.
+ */
+export declare function isRaglingDeathPatch(npc: EntityNPC): boolean;

package/functions/npc.lua

@@ -0,0 +1,128 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local ____exports = {}
+local NON_ALIVE_NPCS_TYPE_VARIANT, NON_ALIVE_NPCS_TYPE_VARIANT_SUBTYPE
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local BegottenVariant = ____isaac_2Dtypescript_2Ddefinitions.BegottenVariant
+local BigHornVariant = ____isaac_2Dtypescript_2Ddefinitions.BigHornVariant
+local ChargerSubType = ____isaac_2Dtypescript_2Ddefinitions.ChargerSubType
+local ChargerVariant = ____isaac_2Dtypescript_2Ddefinitions.ChargerVariant
+local DarkEsauVariant = ____isaac_2Dtypescript_2Ddefinitions.DarkEsauVariant
+local DeathVariant = ____isaac_2Dtypescript_2Ddefinitions.DeathVariant
+local EntityType = ____isaac_2Dtypescript_2Ddefinitions.EntityType
+local MamaGurdyVariant = ____isaac_2Dtypescript_2Ddefinitions.MamaGurdyVariant
+local MotherSubType = ____isaac_2Dtypescript_2Ddefinitions.MotherSubType
+local MotherVariant = ____isaac_2Dtypescript_2Ddefinitions.MotherVariant
+local NpcState = ____isaac_2Dtypescript_2Ddefinitions.NpcState
+local PeepVariant = ____isaac_2Dtypescript_2Ddefinitions.PeepVariant
+local ProjectilesMode = ____isaac_2Dtypescript_2Ddefinitions.ProjectilesMode
+local RaglingVariant = ____isaac_2Dtypescript_2Ddefinitions.RaglingVariant
+local VisVariant = ____isaac_2Dtypescript_2Ddefinitions.VisVariant
+local ____constants = require("constants")
+local EGGY_STATE_FRAME_OF_FINAL_SPIDER = ____constants.EGGY_STATE_FRAME_OF_FINAL_SPIDER
+local ____entity = require("functions.entity")
+local getFilteredNewEntities = ____entity.getFilteredNewEntities
+local ____entitySpecific = require("functions.entitySpecific")
+local getNPCs = ____entitySpecific.getNPCs
+local getProjectiles = ____entitySpecific.getProjectiles
+--- Checks for specific NPCs that have "CanShutDoors" set to true naturally by the game, but should
+-- not actually keep the doors closed (like Death's scythes).
+function ____exports.isAliveExceptionNPC(self, npc)
+    local entityTypeVariant = (tostring(npc.Type) .. ".") .. tostring(npc.Variant)
+    if NON_ALIVE_NPCS_TYPE_VARIANT:has(entityTypeVariant) then
+        return true
+    end
+    local entityTypeVariantSubType = (((tostring(npc.Type) .. ".") .. tostring(npc.Variant)) .. ".") .. tostring(npc.SubType)
+    if NON_ALIVE_NPCS_TYPE_VARIANT_SUBTYPE:has(entityTypeVariantSubType) then
+        return true
+    end
+    if ____exports.isRaglingDeathPatch(nil, npc) then
+        return true
+    end
+    if ____exports.isDyingEggyWithNoSpidersLeft(nil, npc) then
+        return true
+    end
+    return false
+end
+--- Helper function to detect the custom death state of an Eggy. Eggies are never actually marked
+-- dead by the game. Instead, when Eggies take fatal damage, they go into NpcState.STATE_SUICIDE and
+-- spawn 14 Swarm Spiders while their StateFrame ticks upwards.
+function ____exports.isDyingEggyWithNoSpidersLeft(self, npc)
+    return npc.State == NpcState.SUICIDE and npc.StateFrame >= EGGY_STATE_FRAME_OF_FINAL_SPIDER
+end
+--- Helper function to detect the custom death state of a Rag Man Ragling. When Rag Man Raglings die,
+-- they turn into a patch on the ground and can be revived by Rag Man at a later time. This causes
+-- them to show up as an "alive" enemy, so they should usually be filtered out of lists of alive
+-- enemies.
+function ____exports.isRaglingDeathPatch(self, npc)
+    return npc.Type == EntityType.RAGLING and npc.Variant == RaglingVariant.RAG_MANS_RAGLING and npc.State == NpcState.SPECIAL
+end
+NON_ALIVE_NPCS_TYPE_VARIANT = __TS__New(
+    Set,
+    {
+        (tostring(EntityType.VIS) .. ".") .. tostring(VisVariant.CHUBBER_PROJECTILE),
+        (tostring(EntityType.DEATH) .. ".") .. tostring(DeathVariant.DEATH_SCYTHE),
+        (tostring(EntityType.PEEP) .. ".") .. tostring(PeepVariant.PEEP_EYE),
+        (tostring(EntityType.PEEP) .. ".") .. tostring(PeepVariant.BLOAT_EYE),
+        (tostring(EntityType.BEGOTTEN) .. ".") .. tostring(BegottenVariant.BEGOTTEN_CHAIN),
+        (tostring(EntityType.MAMA_GURDY) .. ".") .. tostring(MamaGurdyVariant.LEFT_HAND),
+        (tostring(EntityType.MAMA_GURDY) .. ".") .. tostring(MamaGurdyVariant.RIGHT_HAND),
+        (tostring(EntityType.BIG_HORN) .. ".") .. tostring(BigHornVariant.SMALL_HOLE),
+        (tostring(EntityType.BIG_HORN) .. ".") .. tostring(BigHornVariant.BIG_HOLE),
+        (tostring(EntityType.DARK_ESAU) .. ".") .. tostring(DarkEsauVariant.DARK_ESAU),
+        (tostring(EntityType.DARK_ESAU) .. ".") .. tostring(DarkEsauVariant.PIT)
+    }
+)
+NON_ALIVE_NPCS_TYPE_VARIANT_SUBTYPE = __TS__New(
+    Set,
+    {
+        (((tostring(EntityType.CHARGER) .. ".") .. tostring(ChargerVariant.CHARGER)) .. ".") .. tostring(ChargerSubType.MY_SHADOW),
+        (((tostring(EntityType.MOTHER) .. ".") .. tostring(MotherVariant.MOTHER_1)) .. ".") .. tostring(MotherSubType.PHASE_2)
+    }
+)
+--- Helper function to make an NPC fire a projectile. Returns the fired projectile. Use this function
+-- instead of the `EntityNPC.FireProjectiles` method, since that returns void.
+-- 
+-- @param npc The NPC to fire the projectile from.
+-- @param position The staring position of the projectile.
+-- @param velocity The starting velocity of the projectile.
+-- @param projectilesMode The mode of the projectile. Optional. Default is
+-- `ProjectilesMode.ONE_PROJECTILE`.
+-- @param projectileParams The parameters of the projectile. Optional. Default is
+-- `ProjectileParams()`.
+-- @returns The fired projectile.
+function ____exports.fireProjectiles(self, npc, position, velocity, projectilesMode, projectileParams)
+    if projectilesMode == nil then
+        projectilesMode = ProjectilesMode.ONE_PROJECTILE
+    end
+    if projectileParams == nil then
+        projectileParams = ProjectileParams()
+    end
+    local oldProjectiles = getProjectiles(nil, projectileParams.Variant)
+    npc:FireProjectiles(position, velocity, projectilesMode, projectileParams)
+    local newProjectiles = getProjectiles(nil, projectileParams.Variant)
+    return getFilteredNewEntities(nil, oldProjectiles, newProjectiles)
+end
+--- Helper function to get all of the non-dead NPCs in the room.
+-- 
+-- This function will not include NPCs on an internal blacklist, such as Death's scythes or Big Horn
+-- holes.
+function ____exports.getAliveNPCs(self, matchingEntityType, matchingVariant, matchingSubType, ignoreFriendly)
+    if ignoreFriendly == nil then
+        ignoreFriendly = false
+    end
+    local npcs = getNPCs(
+        nil,
+        matchingEntityType,
+        matchingVariant,
+        matchingSubType,
+        ignoreFriendly
+    )
+    return __TS__ArrayFilter(
+        npcs,
+        function(____, npc) return not npc:IsDead() and not ____exports.isAliveExceptionNPC(nil, npc) end
+    )
+end
+return ____exports

package/functions/pickupVariants.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="isaac-typescript-definitions" />
+/** For `PickupVariant.HEART` (10) */
+export declare function isHeart(pickup: EntityPickup): pickup is EntityPickupHeart;
+/** For `PickupVariant.COIN` (20) */
+export declare function isCoin(pickup: EntityPickup): pickup is EntityPickupCoin;
+/** For `PickupVariant.KEY` (30) */
+export declare function isKey(pickup: EntityPickup): pickup is EntityPickupKey;
+/** For `PickupVariant.BOMB` (40) */
+export declare function isBomb(pickup: EntityPickup): pickup is EntityPickupBomb;
+/** For `PickupVariant.POOP` (42) */
+export declare function isPoop(pickup: EntityPickup): pickup is EntityPickupPoop;
+/** For `PickupVariant.SACK` (69) */
+export declare function isSack(pickup: EntityPickup): pickup is EntityPickupSack;
+/** For `PickupVariant.PILL` (70) */
+export declare function isPill(pickup: EntityPickup): pickup is EntityPickupPill;
+/** For `PickupVariant.LIL_BATTERY` (90) */
+export declare function isBattery(pickup: EntityPickup): pickup is EntityPickupBattery;
+/** For `PickupVariant.COLLECTIBLE` (100) */
+export declare function isCollectible(pickup: EntityPickup): pickup is EntityPickupCollectible;
+/** For `PickupVariant.TAROT_CARD` (300) */
+export declare function isCardPickup(pickup: EntityPickup): pickup is EntityPickupCard;
+/** For `PickupVariant.TRINKET` (350) */
+export declare function isTrinket(pickup: EntityPickup): pickup is EntityPickupTrinket;

package/functions/pickupVariants.lua

@@ -0,0 +1,48 @@
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local PickupVariant = ____isaac_2Dtypescript_2Ddefinitions.PickupVariant
+--- For `PickupVariant.HEART` (10)
+function ____exports.isHeart(self, pickup)
+    return pickup.Variant == PickupVariant.HEART
+end
+--- For `PickupVariant.COIN` (20)
+function ____exports.isCoin(self, pickup)
+    return pickup.Variant == PickupVariant.COIN
+end
+--- For `PickupVariant.KEY` (30)
+function ____exports.isKey(self, pickup)
+    return pickup.Variant == PickupVariant.KEY
+end
+--- For `PickupVariant.BOMB` (40)
+function ____exports.isBomb(self, pickup)
+    return pickup.Variant == PickupVariant.BOMB
+end
+--- For `PickupVariant.POOP` (42)
+function ____exports.isPoop(self, pickup)
+    return pickup.Variant == PickupVariant.POOP
+end
+--- For `PickupVariant.SACK` (69)
+function ____exports.isSack(self, pickup)
+    return pickup.Variant == PickupVariant.SACK
+end
+--- For `PickupVariant.PILL` (70)
+function ____exports.isPill(self, pickup)
+    return pickup.Variant == PickupVariant.PILL
+end
+--- For `PickupVariant.LIL_BATTERY` (90)
+function ____exports.isBattery(self, pickup)
+    return pickup.Variant == PickupVariant.LIL_BATTERY
+end
+--- For `PickupVariant.COLLECTIBLE` (100)
+function ____exports.isCollectible(self, pickup)
+    return pickup.Variant == PickupVariant.COLLECTIBLE
+end
+--- For `PickupVariant.TAROT_CARD` (300)
+function ____exports.isCardPickup(self, pickup)
+    return pickup.Variant == PickupVariant.TAROT_CARD
+end
+--- For `PickupVariant.TRINKET` (350)
+function ____exports.isTrinket(self, pickup)
+    return pickup.Variant == PickupVariant.TRINKET
+end
+return ____exports