isaacscript-common 2.2.0 → 2.3.0

package/functions/playerDataStructures.lua

@@ -1,38 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local Map = ____lualib.Map
-local Set = ____lualib.Set
-local ____exports = {}
-local ____playerIndex = require("functions.playerIndex")
-local getPlayerIndex = ____playerIndex.getPlayerIndex
-function ____exports.mapSetPlayer(self, map, player, value)
-    local playerIndex = getPlayerIndex(nil, player)
-    map:set(playerIndex, value)
-end
-function ____exports.defaultMapGetPlayer(self, map, player, ...)
-    local playerIndex = getPlayerIndex(nil, player)
-    return map:getAndSetDefault(playerIndex, ...)
-end
-function ____exports.defaultMapSetPlayer(self, map, player, value)
-    ____exports.mapSetPlayer(nil, map, player, value)
-end
-function ____exports.mapGetPlayer(self, map, player)
-    local playerIndex = getPlayerIndex(nil, player)
-    return map:get(playerIndex)
-end
-function ____exports.mapHasPlayer(self, map, player)
-    local playerIndex = getPlayerIndex(nil, player)
-    return map:has(playerIndex)
-end
-function ____exports.setAddPlayer(self, set, player)
-    local playerIndex = getPlayerIndex(nil, player)
-    return set:add(playerIndex)
-end
-function ____exports.setDeletePlayer(self, set, player)
-    local playerIndex = getPlayerIndex(nil, player)
-    return set:delete(playerIndex)
-end
-function ____exports.setHasPlayer(self, set, player)
-    local playerIndex = getPlayerIndex(nil, player)
-    return set:has(playerIndex)
-end
-return ____exports

package/functions/playerHealth.d.ts

@@ -1,22 +0,0 @@
-/// <reference types="isaac-typescript-definitions" />
-import { HealthType } from "../enums/HealthType";
-import { PlayerHealth } from "../interfaces/PlayerHealth";
-export declare function addPlayerHealthType(player: EntityPlayer, healthType: HealthType, numHearts: int): void;
-/**
- * Helper function to get an object representing the player's health. You can use this in
- * combination with the `setPlayerHealth` function to restore the player's health back to a certain
- * configuration at a later time.
- *
- * This is based on the `REVEL.StoreHealth` function in the Revelations mod.
- */
-export declare function getPlayerHealth(player: EntityPlayer): PlayerHealth;
-export declare function getPlayerHealthType(player: EntityPlayer, healthType: HealthType): int;
-export declare function removeAllPlayerHealth(player: EntityPlayer): void;
-/**
- * Helper function to set a player's health to a specific state. You can use this in combination
- * with the `getPlayerHealth` function to restore the player's health back to a certain
- * configuration at a later time.
- *
- * Based on the `REVEL.LoadHealth` function in the Revelations mod.
- */
-export declare function setPlayerHealth(player: EntityPlayer, playerHealth: PlayerHealth): void;

package/functions/playerHealth.lua

@@ -1,286 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__ArrayForEach = ____lualib.__TS__ArrayForEach
-local ____exports = {}
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local HeartSubType = ____isaac_2Dtypescript_2Ddefinitions.HeartSubType
-local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
-local ____constants = require("constants")
-local MAX_PLAYER_HEART_CONTAINERS = ____constants.MAX_PLAYER_HEART_CONTAINERS
-local ____HealthType = require("enums.HealthType")
-local HealthType = ____HealthType.HealthType
-local ____player = require("functions.player")
-local getPlayerBlackHearts = ____player.getPlayerBlackHearts
-local getPlayerHearts = ____player.getPlayerHearts
-local getPlayerSoulHearts = ____player.getPlayerSoulHearts
-local isCharacter = ____player.isCharacter
-local ____utils = require("functions.utils")
-local ensureAllCases = ____utils.ensureAllCases
-local ____repeat = ____utils["repeat"]
-function ____exports.addPlayerHealthType(self, player, healthType, numHearts)
-    repeat
-        local ____switch3 = healthType
-        local ____cond3 = ____switch3 == HealthType.RED
-        if ____cond3 then
-            do
-                player:AddHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.SOUL
-        if ____cond3 then
-            do
-                player:AddSoulHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.ETERNAL
-        if ____cond3 then
-            do
-                player:AddEternalHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.BLACK
-        if ____cond3 then
-            do
-                player:AddBlackHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.GOLDEN
-        if ____cond3 then
-            do
-                player:AddGoldenHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.BONE
-        if ____cond3 then
-            do
-                player:AddBoneHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.ROTTEN
-        if ____cond3 then
-            do
-                player:AddRottenHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.BROKEN
-        if ____cond3 then
-            do
-                player:AddBrokenHearts(numHearts)
-                return
-            end
-        end
-        ____cond3 = ____cond3 or ____switch3 == HealthType.MAX_HEARTS
-        if ____cond3 then
-            do
-                player:AddMaxHearts(numHearts, false)
-                return
-            end
-        end
-        do
-            do
-                ensureAllCases(nil, healthType)
-            end
-        end
-    until true
-end
-function ____exports.getPlayerHealth(self, player)
-    local character = player:GetPlayerType()
-    local soulHeartTypes = {}
-    local maxHearts = player:GetMaxHearts()
-    local hearts = getPlayerHearts(nil, player)
-    local soulHearts = player:GetSoulHearts()
-    local boneHearts = player:GetBoneHearts()
-    local goldenHearts = player:GetGoldenHearts()
-    local eternalHearts = player:GetEternalHearts()
-    local rottenHearts = player:GetRottenHearts()
-    local brokenHearts = player:GetBrokenHearts()
-    local subPlayer = player:GetSubPlayer()
-    local soulCharges = player:GetEffectiveSoulCharge()
-    local bloodCharges = player:GetEffectiveBloodCharge()
-    if character == PlayerType.THE_FORGOTTEN and subPlayer ~= nil then
-        maxHearts = boneHearts * 2
-        boneHearts = 0
-        soulHearts = subPlayer:GetSoulHearts()
-    elseif character == PlayerType.THE_SOUL and subPlayer ~= nil then
-        maxHearts = subPlayer:GetBoneHearts() * 2
-        hearts = subPlayer:GetHearts()
-    end
-    local extraHearts = math.ceil(soulHearts / 2) + boneHearts
-    local currentSoulHeart = 0
-    do
-        local i = 0
-        while i < extraHearts do
-            local isBoneHeart = player:IsBoneHeart(i)
-            if character == PlayerType.THE_FORGOTTEN and subPlayer ~= nil then
-                isBoneHeart = subPlayer:IsBoneHeart(i)
-            end
-            if isBoneHeart then
-                soulHeartTypes[#soulHeartTypes + 1] = HeartSubType.BONE
-            else
-                local isBlackHeart = player:IsBlackHeart(currentSoulHeart + 1)
-                if character == PlayerType.THE_FORGOTTEN and subPlayer ~= nil then
-                    isBlackHeart = subPlayer:IsBlackHeart(currentSoulHeart + 1)
-                end
-                if isBlackHeart then
-                    soulHeartTypes[#soulHeartTypes + 1] = HeartSubType.BLACK
-                else
-                    soulHeartTypes[#soulHeartTypes + 1] = HeartSubType.SOUL
-                end
-                currentSoulHeart = currentSoulHeart + 2
-            end
-            i = i + 1
-        end
-    end
-    return {
-        maxHearts = maxHearts,
-        hearts = hearts,
-        eternalHearts = eternalHearts,
-        soulHearts = soulHearts,
-        boneHearts = boneHearts,
-        goldenHearts = goldenHearts,
-        rottenHearts = rottenHearts,
-        brokenHearts = brokenHearts,
-        soulCharges = soulCharges,
-        bloodCharges = bloodCharges,
-        soulHeartTypes = soulHeartTypes
-    }
-end
-function ____exports.getPlayerHealthType(self, player, healthType)
-    repeat
-        local ____switch25 = healthType
-        local ____cond25 = ____switch25 == HealthType.RED
-        if ____cond25 then
-            do
-                return getPlayerHearts(nil, player)
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.SOUL
-        if ____cond25 then
-            do
-                return getPlayerSoulHearts(nil, player)
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.ETERNAL
-        if ____cond25 then
-            do
-                return player:GetEternalHearts()
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.BLACK
-        if ____cond25 then
-            do
-                return getPlayerBlackHearts(nil, player)
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.GOLDEN
-        if ____cond25 then
-            do
-                return player:GetGoldenHearts()
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.BONE
-        if ____cond25 then
-            do
-                return player:GetBoneHearts()
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.ROTTEN
-        if ____cond25 then
-            do
-                return player:GetRottenHearts()
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.BROKEN
-        if ____cond25 then
-            do
-                return player:GetBrokenHearts()
-            end
-        end
-        ____cond25 = ____cond25 or ____switch25 == HealthType.MAX_HEARTS
-        if ____cond25 then
-            do
-                return player:GetMaxHearts()
-            end
-        end
-        do
-            do
-                return ensureAllCases(nil, healthType)
-            end
-        end
-    until true
-end
-function ____exports.removeAllPlayerHealth(self, player)
-    local goldenHearts = player:GetGoldenHearts()
-    local eternalHearts = player:GetEternalHearts()
-    local boneHearts = player:GetBoneHearts()
-    local brokenHearts = player:GetBrokenHearts()
-    player:AddGoldenHearts(goldenHearts * -1)
-    player:AddEternalHearts(eternalHearts * -1)
-    player:AddBoneHearts(boneHearts * -1)
-    player:AddBrokenHearts(brokenHearts * -1)
-    player:AddMaxHearts(MAX_PLAYER_HEART_CONTAINERS * -2, true)
-    player:AddSoulHearts(MAX_PLAYER_HEART_CONTAINERS * -2)
-    if isCharacter(nil, player, PlayerType.THE_SOUL) then
-        local forgotten = player:GetSubPlayer()
-        if forgotten ~= nil then
-            local forgottenBoneHearts = forgotten:GetBoneHearts()
-            forgotten:AddBoneHearts(forgottenBoneHearts * -1)
-        end
-    end
-end
-function ____exports.setPlayerHealth(self, player, playerHealth)
-    local character = player:GetPlayerType()
-    local subPlayer = player:GetSubPlayer()
-    ____exports.removeAllPlayerHealth(nil, player)
-    if character == PlayerType.THE_SOUL and subPlayer ~= nil then
-        subPlayer:AddMaxHearts(playerHealth.maxHearts, false)
-    else
-        player:AddMaxHearts(playerHealth.maxHearts, false)
-    end
-    player:AddEternalHearts(playerHealth.eternalHearts)
-    local soulHeartsRemaining = playerHealth.soulHearts
-    __TS__ArrayForEach(
-        playerHealth.soulHeartTypes,
-        function(____, heartType, i)
-            local isHalf = playerHealth.soulHearts + playerHealth.boneHearts * 2 < (i + 1) * 2
-            local addAmount = 2
-            if isHalf or heartType == HeartSubType.BONE or soulHeartsRemaining < 2 then
-                addAmount = 1
-            end
-            if heartType == HeartSubType.SOUL then
-                player:AddSoulHearts(addAmount)
-                soulHeartsRemaining = soulHeartsRemaining - addAmount
-            elseif heartType == HeartSubType.BLACK then
-                player:AddBlackHearts(addAmount)
-                soulHeartsRemaining = soulHeartsRemaining - addAmount
-            elseif heartType == HeartSubType.BONE then
-                player:AddBoneHearts(addAmount)
-            end
-        end
-    )
-    player:AddRottenHearts(playerHealth.rottenHearts)
-    ____repeat(
-        nil,
-        playerHealth.hearts,
-        function()
-            player:AddHearts(1)
-            if character == PlayerType.MAGDALENE_B then
-                player:AddHearts(-1)
-            end
-        end
-    )
-    player:AddGoldenHearts(playerHealth.goldenHearts)
-    player:AddBrokenHearts(playerHealth.brokenHearts)
-    if character == PlayerType.BETHANY then
-        player:SetSoulCharge(playerHealth.soulCharges)
-    elseif character == PlayerType.BETHANY_B then
-        player:SetBloodCharge(playerHealth.bloodCharges)
-    end
-end
-return ____exports

package/functions/playerIndex.d.ts

@@ -1,68 +0,0 @@
-/// <reference types="isaac-typescript-definitions" />
-import { PlayerIndex } from "../types/PlayerIndex";
-/**
- * Helper function to get every player with no restrictions, by using `Game.GetNumPlayers` and
- * `Isaac.GetPlayer`.
- *
- * This function is almost never what you want to use. For most purposes, use the `getPlayers`
- * helper function instead to get a filtered list of players.
- */
-export declare function getAllPlayers(): EntityPlayer[];
-export declare function getPlayerFromIndex(playerIndex: PlayerIndex): EntityPlayer | undefined;
-/**
- * Mods often have to track variables relating to the player. In naive mods, information will only
- * be stored about the first player. However, in order to be robust, mods must handle up to 4
- * players playing at the same time. This means that information must be stored on a map data
- * structure. Finding a good index for these types of map data structures is difficult:
- *
- * - We cannot use the index from `Isaac.GetPlayer(i)` since this fails in the case where there are
- *   two players and the first player leaves the run.
- * - We cannot use `EntityPlayer.ControllerIndex` as an index because it fails in the case of Jacob
- *   & Esau or Tainted Forgotten. It also fails in the case of a player changing their controls
- *   mid-run.
- * - We cannot use `EntityPlayer.GetData().index` because it does not persist across saving and
- *   continuing.
- * - We cannot use `GetPtrHash()` as an index because it does not persist across exiting and
- *   relaunching the game.
- * - We cannot use `EntityPlayer.InitSeed` because it is not consistent with additional players
- *   beyond the first.
- *
- * Instead, we use the `EntityPlayer.GetCollectibleRNG` method with an arbitrary value of Sad Onion
- * (1). This works even if the player does not have any Sad Onions.
- *
- * Since the RNG value is the same for both Tainted Lazarus and Dead Tainted Lazarus, we revert to
- * using the RNG of The Inner Eye (2) for Dead Tainted Lazarus.
- *
- * Note that by default, this returns the same index for both The Forgotten and The Soul. (Even
- * though they are technically different characters, they share the same inventory and InitSeed.) If
- * this is not desired, pass true for the `differentiateForgottenAndSoul` argument, and the RNG of
- * Spoon Bender (3) will be used for The Soul.
- */
-export declare function getPlayerIndex(player: EntityPlayer, differentiateForgottenAndSoul?: boolean): PlayerIndex;
-/**
- * Helper function to return the index of this player with respect to the output of the
- * `Isaac.GetPlayer` method.
- */
-export declare function getPlayerIndexVanilla(playerToFind: EntityPlayer): int | undefined;
-/**
- * This function always excludes players with a non-undefined parent, since they are not real
- * players (e.g. the Strawman Keeper).
- *
- * If this is not desired, use the `getAllPlayers` helper function instead.
- *
- * @param performCharacterExclusions Whether or not to exclude characters that are not directly
- *                                 controlled by the player (i.e. Esau & Tainted Soul). Default is
- *                                 false.
- */
-export declare function getPlayers(performCharacterExclusions?: boolean): EntityPlayer[];
-/**
- * Helper function to get a parent `EntityPlayer` object for a given `EntitySubPlayer` object. This
- * is useful because calling the `EntityPlayer.GetSubPlayer` method on a sub-player object will
- * return undefined.
- */
-export declare function getSubPlayerParent(subPlayer: EntitySubPlayer): EntityPlayer | undefined;
-/**
- * Some players are "child" players, meaning that they have a non-undefined Parent property. (For
- * example, the Strawman Keeper.)
- */
-export declare function isChildPlayer(player: EntityPlayer): boolean;

package/functions/playerIndex.lua

@@ -1,127 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local Set = ____lualib.Set
-local __TS__New = ____lualib.__TS__New
-local __TS__ArrayFind = ____lualib.__TS__ArrayFind
-local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
-local ____exports = {}
-local getPlayerIndexCollectibleType, DEFAULT_COLLECTIBLE_TYPE, EXCLUDED_CHARACTERS
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
-local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
-local ____cachedClasses = require("cachedClasses")
-local game = ____cachedClasses.game
-function ____exports.getAllPlayers(self)
-    local numPlayers = game:GetNumPlayers()
-    local players = {}
-    do
-        local i = 0
-        while i < numPlayers do
-            local player = Isaac.GetPlayer(i)
-            players[#players + 1] = player
-            i = i + 1
-        end
-    end
-    return players
-end
-function ____exports.getPlayerIndex(self, player, differentiateForgottenAndSoul)
-    if differentiateForgottenAndSoul == nil then
-        differentiateForgottenAndSoul = false
-    end
-    local playerToUse = player
-    local isSubPlayer = player:IsSubPlayer()
-    if isSubPlayer then
-        local playerParent = ____exports.getSubPlayerParent(nil, player)
-        if playerParent ~= nil then
-            playerToUse = playerParent
-        end
-    end
-    local collectibleType = getPlayerIndexCollectibleType(nil, player, differentiateForgottenAndSoul)
-    local collectibleRNG = playerToUse:GetCollectibleRNG(collectibleType)
-    local seed = collectibleRNG:GetSeed()
-    return seed
-end
-function getPlayerIndexCollectibleType(self, player, differentiateForgottenAndSoul)
-    local character = player:GetPlayerType()
-    repeat
-        local ____switch10 = character
-        local ____cond10 = ____switch10 == PlayerType.THE_SOUL
-        if ____cond10 then
-            do
-                return differentiateForgottenAndSoul and CollectibleType.SPOON_BENDER or DEFAULT_COLLECTIBLE_TYPE
-            end
-        end
-        ____cond10 = ____cond10 or ____switch10 == PlayerType.LAZARUS_2_B
-        if ____cond10 then
-            do
-                return CollectibleType.INNER_EYE
-            end
-        end
-        do
-            do
-                return DEFAULT_COLLECTIBLE_TYPE
-            end
-        end
-    until true
-end
-function ____exports.getPlayers(self, performCharacterExclusions)
-    if performCharacterExclusions == nil then
-        performCharacterExclusions = false
-    end
-    local players = ____exports.getAllPlayers(nil)
-    local nonChildPlayers = __TS__ArrayFilter(
-        players,
-        function(____, player) return not ____exports.isChildPlayer(nil, player) end
-    )
-    local nonChildPlayersFiltered = __TS__ArrayFilter(
-        nonChildPlayers,
-        function(____, player)
-            local character = player:GetPlayerType()
-            return not EXCLUDED_CHARACTERS:has(character)
-        end
-    )
-    return performCharacterExclusions and nonChildPlayersFiltered or nonChildPlayers
-end
-function ____exports.getSubPlayerParent(self, subPlayer)
-    local subPlayerPtrHash = GetPtrHash(subPlayer)
-    local players = ____exports.getPlayers(nil)
-    return __TS__ArrayFind(
-        players,
-        function(____, player)
-            local thisPlayerSubPlayer = player:GetSubPlayer()
-            if thisPlayerSubPlayer == nil then
-                return false
-            end
-            local thisPlayerSubPlayerPtrHash = GetPtrHash(thisPlayerSubPlayer)
-            return thisPlayerSubPlayerPtrHash == subPlayerPtrHash
-        end
-    )
-end
-function ____exports.isChildPlayer(self, player)
-    return player.Parent ~= nil
-end
-DEFAULT_COLLECTIBLE_TYPE = CollectibleType.SAD_ONION
-EXCLUDED_CHARACTERS = __TS__New(Set, {PlayerType.ESAU, PlayerType.THE_SOUL_B})
-function ____exports.getPlayerFromIndex(self, playerIndex)
-    local players = ____exports.getPlayers(nil)
-    return __TS__ArrayFind(
-        players,
-        function(____, player) return ____exports.getPlayerIndex(nil, player) == playerIndex end
-    )
-end
-function ____exports.getPlayerIndexVanilla(self, playerToFind)
-    local numPlayers = game:GetNumPlayers()
-    local playerToFindHash = GetPtrHash(playerToFind)
-    do
-        local i = 0
-        while i < numPlayers do
-            local player = Isaac.GetPlayer(i)
-            local playerHash = GetPtrHash(player)
-            if playerHash == playerToFindHash then
-                return i
-            end
-            i = i + 1
-        end
-    end
-    return nil
-end
-return ____exports

package/functions/pocketItems.d.ts

@@ -1,33 +0,0 @@
-import { PocketItemSlot } from "isaac-typescript-definitions";
-import { PocketItemDescription } from "../interfaces/PocketItemDescription";
-/**
- * Helper function to get the `PocketItemSlot` that the player's pocket active collectible item is
- * in, if any. Returns undefined if the player does not have a pocket active item.
- */
-export declare function getActivePocketItemSlot(player: EntityPlayer): PocketItemSlot | undefined;
-export declare function getFirstCardOrPill(player: EntityPlayer): PocketItemDescription | undefined;
-/**
- * Use this helper function as a workaround for the `EntityPlayer.GetPocketItem` method not working
- * correctly.
- *
- * Note that due to API limitations, there is no way to determine the location of a Dice Bag trinket
- * dice. Furthermore, when the player has a Dice Bag trinket dice and a pocket active at the same
- * time, there is no way to determine the location of the pocket active item. If this function
- * cannot determine the identity of a particular slot, it will mark the type of the slot as
- * `PocketItemType.UNDETERMINABLE`.
- */
-export declare function getPocketItems(player: EntityPlayer): PocketItemDescription[];
-/**
- * Returns whether or not the player can hold an additional pocket item, beyond what they are
- * currently carrying. This takes into account items that modify the max number of pocket items,
- * like Starter Deck.
- *
- * If the player is the Tainted Soul, this always returns false, since that character cannot pick up
- * items. (Only Tainted Forgotten can pick up items.)
- */
-export declare function hasOpenPocketItemSlot(player: EntityPlayer): boolean;
-/**
- * Helper function to determine whether or not the player's "active" pocket item slot is set to
- * their pocket active item.
- */
-export declare function isFirstSlotPocketActiveItem(player: EntityPlayer): boolean;

package/functions/pocketItems.lua

@@ -1,86 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__ArrayFind = ____lualib.__TS__ArrayFind
-local __TS__ArraySome = ____lualib.__TS__ArraySome
-local ____exports = {}
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local ActiveSlot = ____isaac_2Dtypescript_2Ddefinitions.ActiveSlot
-local Card = ____isaac_2Dtypescript_2Ddefinitions.Card
-local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
-local PillColor = ____isaac_2Dtypescript_2Ddefinitions.PillColor
-local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
-local PocketItemSlot = ____isaac_2Dtypescript_2Ddefinitions.PocketItemSlot
-local ____PocketItemType = require("enums.PocketItemType")
-local PocketItemType = ____PocketItemType.PocketItemType
-local ____enums = require("functions.enums")
-local getEnumValues = ____enums.getEnumValues
-local ____player = require("functions.player")
-local isCharacter = ____player.isCharacter
-function ____exports.getPocketItems(self, player)
-    local pocketItem = player:GetActiveItem(ActiveSlot.POCKET)
-    local hasPocketItem = pocketItem ~= CollectibleType.NULL
-    local pocketItem2 = player:GetActiveItem(ActiveSlot.POCKET_SINGLE_USE)
-    local hasPocketItem2 = pocketItem2 ~= CollectibleType.NULL
-    local maxPocketItems = player:GetMaxPocketItems()
-    local pocketItemSlots = getEnumValues(nil, PocketItemSlot)
-    local pocketItems = {}
-    local pocketItemIdentified = false
-    local pocketItem2Identified = false
-    for ____, slot in ipairs(pocketItemSlots) do
-        local card = player:GetCard(slot)
-        local pillColor = player:GetPill(slot)
-        if card ~= Card.NULL then
-            pocketItems[#pocketItems + 1] = {slot = slot, type = PocketItemType.CARD, subType = card}
-        elseif pillColor ~= PillColor.NULL then
-            pocketItems[#pocketItems + 1] = {slot = slot, type = PocketItemType.PILL, subType = pillColor}
-        elseif hasPocketItem and not hasPocketItem2 and not pocketItemIdentified then
-            pocketItemIdentified = true
-            pocketItems[#pocketItems + 1] = {slot = slot, type = PocketItemType.ACTIVE_ITEM, subType = pocketItem}
-        elseif not hasPocketItem and hasPocketItem2 and not pocketItem2Identified then
-            pocketItem2Identified = true
-            pocketItems[#pocketItems + 1] = {slot = slot, type = PocketItemType.DICE_BAG_DICE, subType = pocketItem2}
-        elseif hasPocketItem and hasPocketItem2 then
-            pocketItems[#pocketItems + 1] = {slot = slot, type = PocketItemType.UNDETERMINABLE, subType = 0}
-        else
-            pocketItems[#pocketItems + 1] = {slot = slot, type = PocketItemType.EMPTY, subType = 0}
-        end
-        if slot + 1 == maxPocketItems then
-            break
-        end
-    end
-    return pocketItems
-end
-function ____exports.getActivePocketItemSlot(self, player)
-    local pocketItems = ____exports.getPocketItems(nil, player)
-    for ____, pocketItem in ipairs(pocketItems) do
-        if pocketItem.type == PocketItemType.ACTIVE_ITEM then
-            return pocketItem.slot
-        end
-    end
-    return nil
-end
-function ____exports.getFirstCardOrPill(self, player)
-    local pocketItems = ____exports.getPocketItems(nil, player)
-    return __TS__ArrayFind(
-        pocketItems,
-        function(____, pocketItem) return pocketItem.type == PocketItemType.CARD or pocketItem.type == PocketItemType.PILL end
-    )
-end
-function ____exports.hasOpenPocketItemSlot(self, player)
-    if isCharacter(nil, player, PlayerType.THE_SOUL_B) then
-        return false
-    end
-    local pocketItems = ____exports.getPocketItems(nil, player)
-    return __TS__ArraySome(
-        pocketItems,
-        function(____, pocketItem) return pocketItem.type == PocketItemType.EMPTY end
-    )
-end
-function ____exports.isFirstSlotPocketActiveItem(self, player)
-    local pocketItems = ____exports.getPocketItems(nil, player)
-    local firstPocketItem = pocketItems[1]
-    if firstPocketItem == nil then
-        return false
-    end
-    return firstPocketItem.type == PocketItemType.ACTIVE_ITEM
-end
-return ____exports