isaacscript-common 87.9.7 → 87.10.0

package/dist/functions/playerHealth.js

@@ -1,69 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addPlayerHealthType = addPlayerHealthType;
-exports.canPickEternalHearts = canPickEternalHearts;
-exports.doesPlayerHaveAllBlackHearts = doesPlayerHaveAllBlackHearts;
-exports.doesPlayerHaveAllSoulHearts = doesPlayerHaveAllSoulHearts;
-exports.getPlayerAvailableHeartSlots = getPlayerAvailableHeartSlots;
-exports.getPlayerBlackHearts = getPlayerBlackHearts;
-exports.getPlayerHealth = getPlayerHealth;
-exports.getPlayerHealthType = getPlayerHealthType;
-exports.getPlayerHearts = getPlayerHearts;
-exports.getPlayerLastHeart = getPlayerLastHeart;
-exports.getPlayerMaxHeartContainers = getPlayerMaxHeartContainers;
-exports.getPlayerSoulHearts = getPlayerSoulHearts;
-exports.getTaintedMagdaleneNonTemporaryMaxHearts = getTaintedMagdaleneNonTemporaryMaxHearts;
-exports.newPlayerHealth = newPlayerHealth;
-exports.playerConvertBlackHeartsToSoulHearts = playerConvertBlackHeartsToSoulHearts;
-exports.playerConvertSoulHeartsToBlackHearts = playerConvertSoulHeartsToBlackHearts;
-exports.playerHasHealthLeft = playerHasHealthLeft;
-exports.removeAllPlayerHealth = removeAllPlayerHealth;
-exports.setPlayerHealth = setPlayerHealth;
-exports.wouldDamageTaintedMagdaleneNonTemporaryHeartContainers = wouldDamageTaintedMagdaleneNonTemporaryHeartContainers;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const constants_1 = require("../core/constants");
-const HealthType_1 = require("../enums/HealthType");
-const bitwise_1 = require("./bitwise");
-const characters_1 = require("./characters");
-const charge_1 = require("./charge");
-const playerCollectibles_1 = require("./playerCollectibles");
-const players_1 = require("./players");
-const utils_1 = require("./utils");
-function addPlayerHealthType(player, healthType, numHearts) {
+import { CollectibleType, HeartSubType, PlayerType, TrinketType, } from "isaac-typescript-definitions";
+import { MAX_PLAYER_HEART_CONTAINERS } from "../core/constants";
+import { HealthType } from "../enums/HealthType";
+import { countSetBits, getKBitOfN, getNumBitsOfN } from "./bitwise";
+import { getCharacterMaxHeartContainers } from "./characters";
+import { getTotalCharge } from "./charge";
+import { getActiveItemSlots, setActiveItem } from "./playerCollectibles";
+import { isCharacter, isKeeper } from "./players";
+import { repeat } from "./utils";
+export function addPlayerHealthType(player, healthType, numHearts) {
     switch (healthType) {
-        case HealthType_1.HealthType.RED: {
+        case HealthType.RED: {
             player.AddHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.SOUL: {
+        case HealthType.SOUL: {
             player.AddSoulHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.ETERNAL: {
+        case HealthType.ETERNAL: {
             player.AddEternalHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.BLACK: {
+        case HealthType.BLACK: {
             player.AddBlackHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.GOLDEN: {
+        case HealthType.GOLDEN: {
             player.AddGoldenHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.BONE: {
+        case HealthType.BONE: {
             player.AddBoneHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.ROTTEN: {
+        case HealthType.ROTTEN: {
             player.AddRottenHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.BROKEN: {
+        case HealthType.BROKEN: {
             player.AddBrokenHearts(numHearts);
             break;
         }
-        case HealthType_1.HealthType.MAX_HEARTS: {
+        case HealthType.MAX_HEARTS: {
             player.AddMaxHearts(numHearts, false);
             break;
         }
@@ -76,7 +54,7 @@ function addPlayerHealthType(player, healthType, numHearts) {
  *
  * This function's name matches the existing `EntityPlayer` methods.
  */
-function canPickEternalHearts(player) {
+export function canPickEternalHearts(player) {
     const eternalHearts = player.GetEternalHearts();
     const maxHearts = player.GetMaxHearts();
     const heartLimit = player.GetHeartLimit();
@@ -95,7 +73,7 @@ function canPickEternalHearts(player) {
  * - If the player has one red heart container and three black hearts, this function would return
  *   true.
  */
-function doesPlayerHaveAllBlackHearts(player) {
+export function doesPlayerHaveAllBlackHearts(player) {
     const soulHearts = getPlayerSoulHearts(player);
     const blackHearts = getPlayerBlackHearts(player);
     return blackHearts > 0 && soulHearts === 0;
@@ -112,7 +90,7 @@ function doesPlayerHaveAllBlackHearts(player) {
  * - If the player has one red heart container and three soul hearts, this function would return
  *   true.
  */
-function doesPlayerHaveAllSoulHearts(player) {
+export function doesPlayerHaveAllSoulHearts(player) {
     const soulHearts = getPlayerSoulHearts(player);
     const blackHearts = getPlayerBlackHearts(player);
     return soulHearts > 0 && blackHearts === 0;
@@ -122,7 +100,7 @@ function doesPlayerHaveAllSoulHearts(player) {
  * for broken hearts. For example, if the player is Judas and has 1 red heart containers and 2 full
  * soul hearts and 3 broken hearts, then this function would return 6 (i.e. 12 - 1 - 2 - 3).
  */
-function getPlayerAvailableHeartSlots(player) {
+export function getPlayerAvailableHeartSlots(player) {
     const maxHeartContainers = getPlayerMaxHeartContainers(player);
     const effectiveMaxHearts = player.GetEffectiveMaxHearts();
     const normalAndBoneHeartContainers = effectiveMaxHearts / 2;
@@ -140,9 +118,9 @@ function getPlayerAvailableHeartSlots(player) {
  *
  * This is different from the `EntityPlayer.GetBlackHearts` method, since that returns a bitmask.
  */
-function getPlayerBlackHearts(player) {
+export function getPlayerBlackHearts(player) {
     const blackHeartsBitmask = player.GetBlackHearts();
-    const blackHeartBits = (0, bitwise_1.countSetBits)(blackHeartsBitmask);
+    const blackHeartBits = countSetBits(blackHeartsBitmask);
     return blackHeartBits * 2;
 }
 /**
@@ -152,7 +130,7 @@ function getPlayerBlackHearts(player) {
  *
  * This is based on the `REVEL.StoreHealth` function in the Revelations mod.
  */
-function getPlayerHealth(player) {
+export function getPlayerHealth(player) {
     const character = player.GetPlayerType();
     let maxHearts = player.GetMaxHearts();
     let hearts = getPlayerHearts(player); // We use the helper function to remove rotten hearts
@@ -166,7 +144,7 @@ function getPlayerHealth(player) {
     const soulCharges = player.GetEffectiveSoulCharge();
     const bloodCharges = player.GetEffectiveBloodCharge();
     // The Forgotten and The Soul has special health, so we need to account for this.
-    if (subPlayer !== undefined && character === isaac_typescript_definitions_1.PlayerType.FORGOTTEN) {
+    if (subPlayer !== undefined && character === PlayerType.FORGOTTEN) {
         // The Forgotten does not have red heart containers.
         maxHearts = boneHearts * 2;
         boneHearts = 0;
@@ -174,7 +152,7 @@ function getPlayerHealth(player) {
         // sub player.
         soulHearts = subPlayer.GetSoulHearts();
     }
-    else if (subPlayer !== undefined && character === isaac_typescript_definitions_1.PlayerType.SOUL) {
+    else if (subPlayer !== undefined && character === PlayerType.SOUL) {
         // The Soul will always have 0 bone hearts; we need to get the bone heart amount from the sub
         // player. We need to store it as "maxHearts" instead of "boneHearts".
         maxHearts = subPlayer.GetBoneHearts() * 2;
@@ -188,23 +166,23 @@ function getPlayerHealth(player) {
     const soulHeartTypes = [];
     for (let i = 0; i < extraHearts; i++) {
         let isBoneHeart = player.IsBoneHeart(i);
-        if (subPlayer !== undefined && character === isaac_typescript_definitions_1.PlayerType.FORGOTTEN) {
+        if (subPlayer !== undefined && character === PlayerType.FORGOTTEN) {
             isBoneHeart = subPlayer.IsBoneHeart(i);
         }
         if (isBoneHeart) {
-            soulHeartTypes.push(isaac_typescript_definitions_1.HeartSubType.BONE);
+            soulHeartTypes.push(HeartSubType.BONE);
         }
         else {
             // We need to add 1 here because only the second half of a black heart is considered black.
             let isBlackHeart = player.IsBlackHeart(currentSoulHeart + 1);
-            if (subPlayer !== undefined && character === isaac_typescript_definitions_1.PlayerType.FORGOTTEN) {
+            if (subPlayer !== undefined && character === PlayerType.FORGOTTEN) {
                 isBlackHeart = subPlayer.IsBlackHeart(currentSoulHeart + 1);
             }
             if (isBlackHeart) {
-                soulHeartTypes.push(isaac_typescript_definitions_1.HeartSubType.BLACK);
+                soulHeartTypes.push(HeartSubType.BLACK);
             }
             else {
-                soulHeartTypes.push(isaac_typescript_definitions_1.HeartSubType.SOUL);
+                soulHeartTypes.push(HeartSubType.SOUL);
             }
             // Move to the next heart.
             currentSoulHeart += 2;
@@ -224,46 +202,46 @@ function getPlayerHealth(player) {
         soulHeartTypes,
     };
 }
-function getPlayerHealthType(player, healthType) {
+export function getPlayerHealthType(player, healthType) {
     switch (healthType) {
         // 5.10.1
-        case HealthType_1.HealthType.RED: {
+        case HealthType.RED: {
             // We use the standard library helper function since the `EntityPlayer.GetHearts` method
             // returns a value that includes rotten hearts.
             return getPlayerHearts(player);
         }
         // 5.10.3
-        case HealthType_1.HealthType.SOUL: {
+        case HealthType.SOUL: {
             // We use the standard library helper function since the `EntityPlayer.GetSoulHearts` method
             // returns a value that includes black hearts.
             return getPlayerSoulHearts(player);
         }
         // 5.10.4
-        case HealthType_1.HealthType.ETERNAL: {
+        case HealthType.ETERNAL: {
             return player.GetEternalHearts();
         }
         // 5.10.6
-        case HealthType_1.HealthType.BLACK: {
+        case HealthType.BLACK: {
             // We use the standard library helper function since the `EntityPlayer.GetBlackHearts` method
             // returns a bit mask.
             return getPlayerBlackHearts(player);
         }
         // 5.10.7
-        case HealthType_1.HealthType.GOLDEN: {
+        case HealthType.GOLDEN: {
             return player.GetGoldenHearts();
         }
         // 5.10.11
-        case HealthType_1.HealthType.BONE: {
+        case HealthType.BONE: {
             return player.GetBoneHearts();
         }
         // 5.10.12
-        case HealthType_1.HealthType.ROTTEN: {
+        case HealthType.ROTTEN: {
             return player.GetRottenHearts();
         }
-        case HealthType_1.HealthType.BROKEN: {
+        case HealthType.BROKEN: {
             return player.GetBrokenHearts();
         }
-        case HealthType_1.HealthType.MAX_HEARTS: {
+        case HealthType.MAX_HEARTS: {
             return player.GetMaxHearts();
         }
     }
@@ -276,7 +254,7 @@ function getPlayerHealthType(player, healthType) {
  * This is different from the `EntityPlayer.GetHearts` method, since that returns a value that
  * includes rotten hearts.
  */
-function getPlayerHearts(player) {
+export function getPlayerHearts(player) {
     const rottenHearts = player.GetRottenHearts();
     const hearts = player.GetHearts();
     return hearts - rottenHearts * 2;
@@ -285,7 +263,7 @@ function getPlayerHearts(player) {
  * Helper function that returns the type of the rightmost heart. This does not including golden
  * hearts or broken hearts, since they cannot be damaged directly.
  */
-function getPlayerLastHeart(player) {
+export function getPlayerLastHeart(player) {
     const hearts = player.GetHearts();
     const effectiveMaxHearts = player.GetEffectiveMaxHearts();
     const soulHearts = player.GetSoulHearts();
@@ -299,33 +277,33 @@ function getPlayerLastHeart(player) {
     if (isLastHeartBone) {
         const isLastContainerEmpty = hearts <= effectiveMaxHearts - 2;
         if (isLastContainerEmpty) {
-            return HealthType_1.HealthType.BONE;
+            return HealthType.BONE;
         }
         if (rottenHearts > 0) {
-            return HealthType_1.HealthType.ROTTEN;
+            return HealthType.ROTTEN;
         }
         if (eternalHearts > 0) {
-            return HealthType_1.HealthType.ETERNAL;
+            return HealthType.ETERNAL;
         }
-        return HealthType_1.HealthType.RED;
+        return HealthType.RED;
     }
     if (soulHearts > 0) {
-        const numBits = (0, bitwise_1.getNumBitsOfN)(blackHearts);
-        const finalBit = (0, bitwise_1.getKBitOfN)(numBits - 1, blackHearts);
+        const numBits = getNumBitsOfN(blackHearts);
+        const finalBit = getKBitOfN(numBits - 1, blackHearts);
         const isBlack = finalBit === 1;
         if (isBlack) {
-            return HealthType_1.HealthType.BLACK;
+            return HealthType.BLACK;
         }
         // If it is not a black heart, it must be a soul heart.
-        return HealthType_1.HealthType.SOUL;
+        return HealthType.SOUL;
     }
     if (eternalHearts > 0) {
-        return HealthType_1.HealthType.ETERNAL;
+        return HealthType.ETERNAL;
     }
     if (rottenHearts > 0) {
-        return HealthType_1.HealthType.ROTTEN;
+        return HealthType.ROTTEN;
     }
-    return HealthType_1.HealthType.RED;
+    return HealthType.RED;
 }
 /**
  * Returns the maximum heart containers that the provided player can have. Normally, this is 12, but
@@ -333,22 +311,22 @@ function getPlayerLastHeart(player) {
  * This function does not account for Broken Hearts; use the `getPlayerAvailableHeartSlots` helper
  * function for that.
  */
-function getPlayerMaxHeartContainers(player) {
+export function getPlayerMaxHeartContainers(player) {
     const character = player.GetPlayerType();
-    const characterMaxHeartContainers = (0, characters_1.getCharacterMaxHeartContainers)(character);
+    const characterMaxHeartContainers = getCharacterMaxHeartContainers(character);
     // 1
     // Magdalene can increase her maximum heart containers with Birthright.
-    if (character === isaac_typescript_definitions_1.PlayerType.MAGDALENE
-        && player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.BIRTHRIGHT)) {
+    if (character === PlayerType.MAGDALENE
+        && player.HasCollectible(CollectibleType.BIRTHRIGHT)) {
         const extraMaxHeartContainersFromBirthright = 6;
         return characterMaxHeartContainers + extraMaxHeartContainersFromBirthright;
     }
     // 14, 33
     // Keeper and Tainted Keeper can increase their coin containers with Mother's Kiss and Greed's
     // Gullet.
-    if ((0, players_1.isKeeper)(player)) {
-        const numMothersKisses = player.GetTrinketMultiplier(isaac_typescript_definitions_1.TrinketType.MOTHERS_KISS);
-        const hasGreedsGullet = player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.GREEDS_GULLET);
+    if (isKeeper(player)) {
+        const numMothersKisses = player.GetTrinketMultiplier(TrinketType.MOTHERS_KISS);
+        const hasGreedsGullet = player.HasCollectible(CollectibleType.GREEDS_GULLET);
         const coins = player.GetNumCoins();
         const greedsGulletCoinContainers = hasGreedsGullet
             ? Math.floor(coins / 25)
@@ -367,7 +345,7 @@ function getPlayerMaxHeartContainers(player) {
  * This is different from the `EntityPlayer.GetSoulHearts` method, since that returns the combined
  * number of soul hearts and black hearts.
  */
-function getPlayerSoulHearts(player) {
+export function getPlayerSoulHearts(player) {
     const soulHearts = player.GetSoulHearts();
     const blackHearts = getPlayerBlackHearts(player);
     return soulHearts - blackHearts;
@@ -382,14 +360,14 @@ function getPlayerSoulHearts(player) {
  * This function does not validate whether the provided player is Tainted Magdalene; that should be
  * accomplished before invoking this function.
  */
-function getTaintedMagdaleneNonTemporaryMaxHearts(player) {
+export function getTaintedMagdaleneNonTemporaryMaxHearts(player) {
     const maxHearts = player.GetMaxHearts();
-    const hasBirthright = player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.BIRTHRIGHT);
+    const hasBirthright = player.HasCollectible(CollectibleType.BIRTHRIGHT);
     const maxNonTemporaryMaxHearts = hasBirthright ? 6 : 4;
     return Math.min(maxHearts, maxNonTemporaryMaxHearts);
 }
 /** Returns a `PlayerHealth` object with all zeros. */
-function newPlayerHealth() {
+export function newPlayerHealth() {
     return {
         maxHearts: 0,
         hearts: 0,
@@ -408,10 +386,10 @@ function newPlayerHealth() {
  * Helper function to remove all of a player's black hearts and add the corresponding amount of soul
  * hearts.
  */
-function playerConvertBlackHeartsToSoulHearts(player) {
+export function playerConvertBlackHeartsToSoulHearts(player) {
     const playerHealth = getPlayerHealth(player);
     removeAllPlayerHealth(player);
-    const newSoulHeartTypes = playerHealth.soulHeartTypes.map((soulHeartType) => soulHeartType === isaac_typescript_definitions_1.HeartSubType.BLACK ? isaac_typescript_definitions_1.HeartSubType.SOUL : soulHeartType);
+    const newSoulHeartTypes = playerHealth.soulHeartTypes.map((soulHeartType) => soulHeartType === HeartSubType.BLACK ? HeartSubType.SOUL : soulHeartType);
     const playerHealthWithSoulHearts = {
         ...playerHealth,
         soulHeartTypes: newSoulHeartTypes,
@@ -422,10 +400,10 @@ function playerConvertBlackHeartsToSoulHearts(player) {
  * Helper function to remove all of a player's soul hearts and add the corresponding amount of black
  * hearts.
  */
-function playerConvertSoulHeartsToBlackHearts(player) {
+export function playerConvertSoulHeartsToBlackHearts(player) {
     const playerHealth = getPlayerHealth(player);
     removeAllPlayerHealth(player);
-    const newSoulHeartTypes = playerHealth.soulHeartTypes.map((soulHeartType) => soulHeartType === isaac_typescript_definitions_1.HeartSubType.SOUL ? isaac_typescript_definitions_1.HeartSubType.BLACK : soulHeartType);
+    const newSoulHeartTypes = playerHealth.soulHeartTypes.map((soulHeartType) => soulHeartType === HeartSubType.SOUL ? HeartSubType.BLACK : soulHeartType);
     const playerHealthWithBlackHearts = {
         ...playerHealth,
         soulHeartTypes: newSoulHeartTypes,
@@ -438,13 +416,13 @@ function playerConvertSoulHeartsToBlackHearts(player) {
  * Specifically, this function will return false if the player has 0 red hearts, 0 soul/black
  * hearts, and 0 bone hearts.
  */
-function playerHasHealthLeft(player) {
+export function playerHasHealthLeft(player) {
     const hearts = player.GetHearts();
     const soulHearts = player.GetSoulHearts();
     const boneHearts = player.GetBoneHearts();
     return hearts > 0 || soulHearts > 0 || boneHearts > 0;
 }
-function removeAllPlayerHealth(player) {
+export function removeAllPlayerHealth(player) {
     const goldenHearts = player.GetGoldenHearts();
     const eternalHearts = player.GetEternalHearts();
     const boneHearts = player.GetBoneHearts();
@@ -455,11 +433,11 @@ function removeAllPlayerHealth(player) {
     player.AddEternalHearts(-eternalHearts);
     player.AddBoneHearts(-boneHearts);
     player.AddBrokenHearts(-brokenHearts);
-    player.AddMaxHearts(constants_1.MAX_PLAYER_HEART_CONTAINERS * -2, true);
-    player.AddSoulHearts(constants_1.MAX_PLAYER_HEART_CONTAINERS * -2);
+    player.AddMaxHearts(MAX_PLAYER_HEART_CONTAINERS * -2, true);
+    player.AddSoulHearts(MAX_PLAYER_HEART_CONTAINERS * -2);
     // If we are The Soul, the `EntityPlayer.AddBoneHearts` method will not remove Forgotten's bone
     // hearts, so we need to explicitly handle this.
-    if ((0, players_1.isCharacter)(player, isaac_typescript_definitions_1.PlayerType.SOUL)) {
+    if (isCharacter(player, PlayerType.SOUL)) {
         const forgotten = player.GetSubPlayer();
         if (forgotten !== undefined) {
             const forgottenBoneHearts = forgotten.GetBoneHearts();
@@ -474,16 +452,16 @@ function removeAllPlayerHealth(player) {
  *
  * Based on the `REVEL.LoadHealth` function in the Revelations mod.
  */
-function setPlayerHealth(player, playerHealth) {
+export function setPlayerHealth(player, playerHealth) {
     const character = player.GetPlayerType();
     const subPlayer = player.GetSubPlayer();
     // Before we add or remove any health, we have to take away Alabaster Box, if present. (Removing
     // soul hearts from the player will remove Alabaster Box charges.)
     const alabasterBoxDescriptions = [];
-    const alabasterBoxActiveSlots = (0, playerCollectibles_1.getActiveItemSlots)(player, isaac_typescript_definitions_1.CollectibleType.ALABASTER_BOX);
+    const alabasterBoxActiveSlots = getActiveItemSlots(player, CollectibleType.ALABASTER_BOX);
     for (const activeSlot of alabasterBoxActiveSlots) {
-        const totalCharge = (0, charge_1.getTotalCharge)(player, activeSlot);
-        (0, playerCollectibles_1.setActiveItem)(player, isaac_typescript_definitions_1.CollectibleType.NULL, activeSlot);
+        const totalCharge = getTotalCharge(player, activeSlot);
+        setActiveItem(player, CollectibleType.NULL, activeSlot);
         alabasterBoxDescriptions.push({
             activeSlot,
             totalCharge,
@@ -491,7 +469,7 @@ function setPlayerHealth(player, playerHealth) {
     }
     removeAllPlayerHealth(player);
     // Add the red heart containers.
-    if (subPlayer !== undefined && character === isaac_typescript_definitions_1.PlayerType.SOUL) {
+    if (subPlayer !== undefined && character === PlayerType.SOUL) {
         // Adding health to The Soul is a special case.
         subPlayer.AddMaxHearts(playerHealth.maxHearts, false);
     }
@@ -508,20 +486,20 @@ function setPlayerHealth(player, playerHealth) {
          * Fix the bug where a half soul heart to the left of a bone heart will be treated as a full
          * soul heart.
          */
-        const shouldAddOneSoulHeart = isHalf || soulHeartType === isaac_typescript_definitions_1.HeartSubType.BONE || soulHeartsRemaining < 2;
+        const shouldAddOneSoulHeart = isHalf || soulHeartType === HeartSubType.BONE || soulHeartsRemaining < 2;
         const numSoulHearts = shouldAddOneSoulHeart ? 1 : 2;
         switch (soulHeartType) {
-            case isaac_typescript_definitions_1.HeartSubType.SOUL: {
+            case HeartSubType.SOUL: {
                 player.AddSoulHearts(numSoulHearts);
                 soulHeartsRemaining -= numSoulHearts;
                 break;
             }
-            case isaac_typescript_definitions_1.HeartSubType.BLACK: {
+            case HeartSubType.BLACK: {
                 player.AddBlackHearts(numSoulHearts);
                 soulHeartsRemaining -= numSoulHearts;
                 break;
             }
-            case isaac_typescript_definitions_1.HeartSubType.BONE: {
+            case HeartSubType.BONE: {
                 player.AddBoneHearts(numSoulHearts);
                 break;
             }
@@ -538,9 +516,9 @@ function setPlayerHealth(player, playerHealth) {
      * functions in that a value of 1 is equivalent to a half-heart.
      */
     player.AddRottenHearts(playerHealth.rottenHearts * 2);
-    if (character === isaac_typescript_definitions_1.PlayerType.MAGDALENE_B) {
+    if (character === PlayerType.MAGDALENE_B) {
         // Adding 1 heart to Tainted Magdalene will actually add two hearts.
-        (0, utils_1.repeat)(playerHealth.hearts, () => {
+        repeat(playerHealth.hearts, () => {
             if (player.HasFullHearts()) {
                 return;
             }
@@ -560,15 +538,15 @@ function setPlayerHealth(player, playerHealth) {
     player.AddGoldenHearts(playerHealth.goldenHearts);
     player.AddBrokenHearts(playerHealth.brokenHearts);
     // Set the Bethany / Tainted Bethany charges.
-    if (character === isaac_typescript_definitions_1.PlayerType.BETHANY) {
+    if (character === PlayerType.BETHANY) {
         player.SetSoulCharge(playerHealth.soulCharges);
     }
-    else if (character === isaac_typescript_definitions_1.PlayerType.BETHANY_B) {
+    else if (character === PlayerType.BETHANY_B) {
         player.SetBloodCharge(playerHealth.bloodCharges);
     }
     // Re-add the Alabaster Box, if present.
     for (const { activeSlot, totalCharge } of alabasterBoxDescriptions) {
-        (0, playerCollectibles_1.setActiveItem)(player, isaac_typescript_definitions_1.CollectibleType.ALABASTER_BOX, activeSlot, totalCharge);
+        setActiveItem(player, CollectibleType.ALABASTER_BOX, activeSlot, totalCharge);
     }
 }
 /**
@@ -581,7 +559,7 @@ function setPlayerHealth(player, playerHealth) {
  * Before using this function, it is expected that you check to see if the player is Tainted
  * Magdalene first, or else it will give a nonsensical result.
  */
-function wouldDamageTaintedMagdaleneNonTemporaryHeartContainers(player, damageAmount) {
+export function wouldDamageTaintedMagdaleneNonTemporaryHeartContainers(player, damageAmount) {
     // Regardless of the damage amount, damage to a player cannot remove a soul heart and a red heart
     // at the same time.
     const soulHearts = player.GetSoulHearts();

package/dist/functions/playerIndex.js

@@ -1,21 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllPlayers = getAllPlayers;
-exports.getOtherPlayers = getOtherPlayers;
-exports.getPlayerFromIndex = getPlayerFromIndex;
-exports.getPlayerIndex = getPlayerIndex;
-exports.getPlayerIndexVanilla = getPlayerIndexVanilla;
-exports.getPlayers = getPlayers;
-exports.getSubPlayerParent = getSubPlayerParent;
-exports.isChildPlayer = isChildPlayer;
-exports.isFoundSoul = isFoundSoul;
-const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
-const cachedClasses_1 = require("../core/cachedClasses");
-const ReadonlySet_1 = require("../types/ReadonlySet");
-const DEFAULT_COLLECTIBLE_TYPE = isaac_typescript_definitions_1.CollectibleType.SAD_ONION;
-const EXCLUDED_CHARACTERS = new ReadonlySet_1.ReadonlySet([
-    isaac_typescript_definitions_1.PlayerType.ESAU, // 20
-    isaac_typescript_definitions_1.PlayerType.SOUL_B, // 40
+import { BabySubType, CollectibleType, PlayerType, PlayerVariant, } from "isaac-typescript-definitions";
+import { game } from "../core/cachedClasses";
+import { ReadonlySet } from "../types/ReadonlySet";
+const DEFAULT_COLLECTIBLE_TYPE = CollectibleType.SAD_ONION;
+const EXCLUDED_CHARACTERS = new ReadonlySet([
+    PlayerType.ESAU, // 20
+    PlayerType.SOUL_B, // 40
 ]);
 /**
  * Helper function to get every player with no restrictions, by using `Game.GetNumPlayers` and
@@ -24,8 +13,8 @@ const EXCLUDED_CHARACTERS = new ReadonlySet_1.ReadonlySet([
  * 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.
  */
-function getAllPlayers() {
-    const numPlayers = cachedClasses_1.game.GetNumPlayers();
+export function getAllPlayers() {
+    const numPlayers = game.GetNumPlayers();
     const players = [];
     for (let i = 0; i < numPlayers; i++) {
         const player = Isaac.GetPlayer(i);
@@ -37,7 +26,7 @@ function getAllPlayers() {
  * Helper function to get all of the other players in the room besides the one provided. (This
  * includes "child" players.)
  */
-function getOtherPlayers(player) {
+export function getOtherPlayers(player) {
     const playerPtrHash = GetPtrHash(player);
     const players = getAllPlayers();
     return players.filter((otherPlayer) => GetPtrHash(otherPlayer) !== playerPtrHash);
@@ -46,7 +35,7 @@ function getOtherPlayers(player) {
  * Helper function to get the corresponding `EntityPlayer` object that corresponds to a
  * `PlayerIndex`.
  */
-function getPlayerFromIndex(playerIndex) {
+export function getPlayerFromIndex(playerIndex) {
     const players = getAllPlayers();
     return players.find((player) => getPlayerIndex(player) === playerIndex);
 }
@@ -80,7 +69,7 @@ function getPlayerFromIndex(playerIndex) {
  * 4. With that said, in almost all cases, you should be lazy-initializing your data structures in
  * other callbacks, so this should not be an issue.
  */
-function getPlayerIndex(player, differentiateForgottenAndSoul = false) {
+export function getPlayerIndex(player, differentiateForgottenAndSoul = false) {
     // Sub-players use separate RNG values for some reason, so we need to always use the main player:
     // https://github.com/Meowlala/RepentanceAPIIssueTracker/issues/443
     // We can safely ignore the player's character because regardless of whether the main player ends
@@ -111,8 +100,8 @@ function getPlayerIndex(player, differentiateForgottenAndSoul = false) {
  * Note that if you storing information about a player in a data structure, you never want to use
  * this index; use the `getPlayerIndex` function instead.
  */
-function getPlayerIndexVanilla(playerToFind) {
-    const numPlayers = cachedClasses_1.game.GetNumPlayers();
+export function getPlayerIndexVanilla(playerToFind) {
+    const numPlayers = game.GetNumPlayers();
     const playerToFindHash = GetPtrHash(playerToFind);
     for (let i = 0; i < numPlayers; i++) {
         const player = Isaac.GetPlayer(i);
@@ -132,7 +121,7 @@ function getPlayerIndexVanilla(playerToFind) {
  * @param performCharacterExclusions Whether to exclude characters that are not directly controlled
  *                                 by the player (i.e. Esau & Tainted Soul). Default is false.
  */
-function getPlayers(performCharacterExclusions = false) {
+export function getPlayers(performCharacterExclusions = false) {
     const players = getAllPlayers();
     const nonChildPlayers = players.filter((player) => !isChildPlayer(player));
     const nonChildPlayersFiltered = nonChildPlayers.filter((player) => {
@@ -146,7 +135,7 @@ function getPlayers(performCharacterExclusions = false) {
  * is useful because calling the `EntityPlayer.GetSubPlayer` method on a sub-player object will
  * return undefined.
  */
-function getSubPlayerParent(subPlayer) {
+export function getSubPlayerParent(subPlayer) {
     const subPlayerPtrHash = GetPtrHash(subPlayer);
     const players = getPlayers();
     return players.find((player) => {
@@ -162,23 +151,23 @@ function getSubPlayerParent(subPlayer) {
  * Helper function to detect if a particular player is a "child" player, meaning that they have a
  * non-undefined `EntityPlayer.Parent` field. (For example, the Strawman Keeper.)
  */
-function isChildPlayer(player) {
+export function isChildPlayer(player) {
     return player.Parent !== undefined;
 }
 /**
  * Helper function to detect if a particular player is the Found Soul player provided by the
  * trinket.
  */
-function isFoundSoul(player) {
+export function isFoundSoul(player) {
     return (isChildPlayer(player)
-        && player.Variant === isaac_typescript_definitions_1.PlayerVariant.COOP_BABY
-        && player.SubType === isaac_typescript_definitions_1.BabySubType.FOUND_SOUL);
+        && player.Variant === PlayerVariant.COOP_BABY
+        && player.SubType === BabySubType.FOUND_SOUL);
 }
 function getPlayerIndexCollectibleType(player, differentiateForgottenAndSoul) {
     const character = player.GetPlayerType();
-    if (character === isaac_typescript_definitions_1.PlayerType.SOUL) {
+    if (character === PlayerType.SOUL) {
         return differentiateForgottenAndSoul
-            ? isaac_typescript_definitions_1.CollectibleType.INNER_EYE
+            ? CollectibleType.INNER_EYE
             : DEFAULT_COLLECTIBLE_TYPE;
     }
     return DEFAULT_COLLECTIBLE_TYPE;