isaacscript-common 84.0.0 → 84.1.0

package/dist/functions/characters.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVanillaCharacter = exports.isModdedCharacter = exports.isMainCharacter = exports.isFlyingCharacter = exports.getCharacterStartingTrinketType = exports.getCharacterStartingCollectibleTypes = exports.getCharacterSpritePNGFilePath = exports.getCharacterName = exports.getCharacterMaxHeartContainers = exports.getCharacterDeathAnimationName = exports.getCharacterDamageMultiplier = exports.characterStartsWithActiveItem = exports.characterGetsBlackHeartFromEternalHeart = exports.characterCanTakeFreeDevilDeals = exports.characterCanHaveSoulHearts = exports.characterCanHaveRedHearts = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const constants_1 = require("../core/constants");
+const constantsFirstLast_1 = require("../core/constantsFirstLast");
+const characterDamageMultipliers_1 = require("../objects/characterDamageMultipliers");
+const characterNames_1 = require("../objects/characterNames");
+const characterSpritePNGFileNames_1 = require("../objects/characterSpritePNGFileNames");
+const characterStartingCollectibleTypes_1 = require("../objects/characterStartingCollectibleTypes");
+const characterStartingTrinketTypes_1 = require("../objects/characterStartingTrinketTypes");
+const charactersThatStartWithAnActiveItemSet_1 = require("../sets/charactersThatStartWithAnActiveItemSet");
+const charactersWithBlackHeartFromEternalHeartSet_1 = require("../sets/charactersWithBlackHeartFromEternalHeartSet");
+const charactersWithFreeDevilDealsSet_1 = require("../sets/charactersWithFreeDevilDealsSet");
+const charactersWithNoRedHeartsSet_1 = require("../sets/charactersWithNoRedHeartsSet");
+const charactersWithNoSoulHeartsSet_1 = require("../sets/charactersWithNoSoulHeartsSet");
+const lostStyleCharactersSet_1 = require("../sets/lostStyleCharactersSet");
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const FLYING_CHARACTERS_SET = new ReadonlySet_1.ReadonlySet(constants_1.FLYING_CHARACTERS);
+const MAIN_CHARACTERS_SET = new ReadonlySet_1.ReadonlySet(constants_1.MAIN_CHARACTERS);
+const PNG_PATH_PREFIX = "characters/costumes";
+/**
+ * Helper function to determine if the given character can have red heart containers. Returns true
+ * for characters like Isaac, Magdalene, or Cain. Returns true for Keeper and Tainted Keeper, even
+ * though coin containers are not technically the same as red heart containers. Returns false for
+ * characters like Blue Baby. Returns false for The Lost and Tainted Lost.
+ */
+function characterCanHaveRedHearts(character) {
+    return !charactersWithNoRedHeartsSet_1.CHARACTERS_WITH_NO_RED_HEARTS_SET.has(character);
+}
+exports.characterCanHaveRedHearts = characterCanHaveRedHearts;
+/**
+ * Helper function to determine if the given character can have soul hearts. Returns true for
+ * characters like Isaac, Magdalene, or Cain. Returns false for characters like Bethany. Returns
+ * false for The Lost and Tainted Lost.
+ */
+function characterCanHaveSoulHearts(character) {
+    return !charactersWithNoSoulHeartsSet_1.CHARACTERS_WITH_NO_SOUL_HEARTS_SET.has(character);
+}
+exports.characterCanHaveSoulHearts = characterCanHaveSoulHearts;
+/**
+ * Helper function for determining whether the given character can take free Devil Deals. (e.g. The
+ * Lost, Tainted Lost, etc.)
+ */
+function characterCanTakeFreeDevilDeals(character) {
+    return charactersWithFreeDevilDealsSet_1.CHARACTERS_WITH_FREE_DEVIL_DEALS_SET.has(character);
+}
+exports.characterCanTakeFreeDevilDeals = characterCanTakeFreeDevilDeals;
+/**
+ * Normally, characters get a red heart container upon reaching a new floor with an eternal heart,
+ * but some characters grant a black heart instead. Returns true for Dark Judas and Tainted Judas.
+ * Otherwise, returns false.
+ */
+function characterGetsBlackHeartFromEternalHeart(character) {
+    return charactersWithBlackHeartFromEternalHeartSet_1.CHARACTERS_WITH_BLACK_HEART_FROM_ETERNAL_HEART_SET.has(character);
+}
+exports.characterGetsBlackHeartFromEternalHeart = characterGetsBlackHeartFromEternalHeart;
+/**
+ * Helper function to determine if the specified character starts with an active item.
+ *
+ * For the purposes of this function, the save file is considered to be fully unlocked (e.g. Isaac
+ * is considered to starts with the D6, but this is not the case on a brand new save file).
+ */
+function characterStartsWithActiveItem(character) {
+    return charactersThatStartWithAnActiveItemSet_1.CHARACTERS_THAT_START_WITH_AN_ACTIVE_ITEM_SET.has(character);
+}
+exports.characterStartsWithActiveItem = characterStartsWithActiveItem;
+/**
+ * Helper function to get the numerical damage multiplier for a character.
+ *
+ * @param character The character to get.
+ * @param hasWhoreOfBabylon Optional. Whether the character has the Whore of Babylon effect
+ *                          currently active. Defaults to false. This is necessary because Eve's
+ *                          damage multiplier changes from 0.75 to 1 when she has Whore of Babylon
+ *                          active.
+ */
+function getCharacterDamageMultiplier(character, hasWhoreOfBabylon = false) {
+    if (character === isaac_typescript_definitions_1.PlayerType.EVE && hasWhoreOfBabylon) {
+        return 1;
+    }
+    return characterDamageMultipliers_1.CHARACTER_DAMAGE_MULTIPLIERS[character];
+}
+exports.getCharacterDamageMultiplier = getCharacterDamageMultiplier;
+/**
+ * - Most characters have a 56 frame death animation (i.e. the "Death" animation).
+ * - The Lost and Tainted Lost have a 38 frame death animation (i.e. the "LostDeath" animation).
+ * - Tainted Forgotten have a 20 frame death animation (i.e. the "ForgottenDeath" animation).
+ */
+function getCharacterDeathAnimationName(character) {
+    if (lostStyleCharactersSet_1.LOST_STYLE_CHARACTERS_SET.has(character)) {
+        return "LostDeath";
+    }
+    if (character === isaac_typescript_definitions_1.PlayerType.FORGOTTEN_B) {
+        return "ForgottenDeath";
+    }
+    return "Death";
+}
+exports.getCharacterDeathAnimationName = getCharacterDeathAnimationName;
+/**
+ * Returns the maximum heart containers that the provided character can have. Normally, this is 12,
+ * but with Keeper it is 3, and with Tainted Keeper it is 2. This does not account for Birthright or
+ * Mother's Kiss; use the `getPlayerMaxHeartContainers` helper function for that.
+ */
+function getCharacterMaxHeartContainers(character) {
+    // 14
+    if (character === isaac_typescript_definitions_1.PlayerType.KEEPER) {
+        return 3;
+    }
+    // 16
+    if (character === isaac_typescript_definitions_1.PlayerType.FORGOTTEN) {
+        return 6;
+    }
+    // 17
+    if (character === isaac_typescript_definitions_1.PlayerType.SOUL) {
+        return 6;
+    }
+    // 33
+    if (character === isaac_typescript_definitions_1.PlayerType.KEEPER_B) {
+        return 2;
+    }
+    return 12;
+}
+exports.getCharacterMaxHeartContainers = getCharacterMaxHeartContainers;
+/** Helper function to get the name of a character. Returns "Unknown" for modded characters. */
+function getCharacterName(character) {
+    if (isModdedCharacter(character)) {
+        return "Unknown";
+    }
+    return characterNames_1.CHARACTER_NAMES[character];
+}
+exports.getCharacterName = getCharacterName;
+/**
+ * Helper function to get the path to the sprite for a particular character.
+ *
+ * For example, the file path for `PlayerType.ISAAC` is
+ * "characters/costumes/character_001_isaac.png".
+ */
+function getCharacterSpritePNGFilePath(character) {
+    const fileName = characterSpritePNGFileNames_1.CHARACTER_SPRITE_PNG_FILE_NAMES[character];
+    return `${PNG_PATH_PREFIX}/${fileName}`;
+}
+exports.getCharacterSpritePNGFilePath = getCharacterSpritePNGFilePath;
+/**
+ * Helper function to get the collectibles that are granted to a particular character at the
+ * beginning of a run.
+ *
+ * Note that this will return an empty array for Eden and Tainted Eden.
+ */
+function getCharacterStartingCollectibleTypes(character) {
+    return characterStartingCollectibleTypes_1.CHARACTER_STARTING_COLLECTIBLE_TYPES[character];
+}
+exports.getCharacterStartingCollectibleTypes = getCharacterStartingCollectibleTypes;
+/**
+ * Helper function to get the trinket that is granted to a particular character at the beginning of
+ * a run. Returns undefined if the character does not start with a trinket.
+ *
+ * Note that this will return undefined for Eden and Tainted Eden.
+ */
+function getCharacterStartingTrinketType(character) {
+    return characterStartingTrinketTypes_1.CHARACTER_STARTING_TRINKET_TYPE[character];
+}
+exports.getCharacterStartingTrinketType = getCharacterStartingTrinketType;
+function isFlyingCharacter(character) {
+    return FLYING_CHARACTERS_SET.has(character);
+}
+exports.isFlyingCharacter = isFlyingCharacter;
+/**
+ * Helper function to check if the provided character is one of the characters that are selectable
+ * from the main menu (and have achievements related to completing the various bosses and so on).
+ */
+function isMainCharacter(character) {
+    return MAIN_CHARACTERS_SET.has(character);
+}
+exports.isMainCharacter = isMainCharacter;
+function isModdedCharacter(character) {
+    return !isVanillaCharacter(character);
+}
+exports.isModdedCharacter = isModdedCharacter;
+function isVanillaCharacter(character) {
+    return character <= constantsFirstLast_1.LAST_VANILLA_CHARACTER;
+}
+exports.isVanillaCharacter = isVanillaCharacter;

package/dist/functions/charge.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playChargeSoundEffect = exports.isActiveSlotDoubleCharged = exports.getUsableActiveItemSlots = exports.getTotalCharge = exports.getChargesAwayFromMax = exports.addRoomClearCharges = exports.addRoomClearChargeToSlot = exports.addRoomClearCharge = exports.addCharge = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const collectibles_1 = require("./collectibles");
+const playerCollectibles_1 = require("./playerCollectibles");
+const playerIndex_1 = require("./playerIndex");
+const roomShape_1 = require("./roomShape");
+/**
+ * Helper function to add a charge to the player's active item. Will flash the HUD and play the
+ * appropriate sound effect, depending on whether the charge is partially full or completely full.
+ *
+ * If the player's active item is already fully charged, then this function will return 0 and not
+ * flash the HUD or play a sound effect.
+ *
+ * This function will take the following things into account:
+ * - The Battery
+ * - AAA Battery
+ *
+ * @param player The player to grant the charges to.
+ * @param activeSlot Optional. The slot to grant the charges to. Default is `ActiveSlot.PRIMARY`.
+ * @param numCharges Optional. The amount of charges to grant. Default is 1.
+ * @param playSoundEffect Optional. Whether to play a charge-related sound effect. Default is true.
+ * @returns The amount of charges that were actually granted. For example, if the active item was
+ *          only one away from a full charge, but the `numCharges` provided to this function was 2,
+ *          then this function would return 1.
+ */
+function addCharge(player, activeSlot = isaac_typescript_definitions_1.ActiveSlot.PRIMARY, numCharges = 1, playSoundEffect = true) {
+    const hud = cachedClasses_1.game.GetHUD();
+    // Ensure that there is enough space on the active item to store these amount of charges. (If we
+    // add too many charges, it will grant orange "battery" charges, even if the player does not have
+    // The Battery.)
+    const chargesAwayFromMax = getChargesAwayFromMax(player, activeSlot);
+    const chargesToAdd = numCharges > chargesAwayFromMax ? chargesAwayFromMax : numCharges;
+    // The AAA Battery trinket might grant an additional charge.
+    const modifiedChargesToAdd = getChargesToAddWithAAAModifier(player, activeSlot, chargesToAdd);
+    const totalCharge = getTotalCharge(player, activeSlot);
+    const newCharge = totalCharge + modifiedChargesToAdd;
+    if (newCharge === totalCharge) {
+        return 0;
+    }
+    player.SetActiveCharge(newCharge, activeSlot);
+    hud.FlashChargeBar(player, activeSlot);
+    if (playSoundEffect) {
+        playChargeSoundEffect(player, activeSlot);
+    }
+    return modifiedChargesToAdd;
+}
+exports.addCharge = addCharge;
+/**
+ * Helper function to add a charge to a player's active item(s), emulating what happens when a room
+ * is cleared.
+ *
+ * This function will take the following things into account:
+ * - 2x2 rooms and L rooms granting a double charge
+ * - The Battery
+ * - AAA Battery
+ * - Not charging active items with `chargetype="special"`
+ *
+ * @param player The player to grant the charges to.
+ * @param bigRoomDoubleCharge Optional. If set to false, it will treat the current room as a 1x1
+ *                            room for the purposes of calculating how much charge to grant. Default
+ *                            is true.
+ * @param playSoundEffect Optional. Whether to play a charge-related sound effect. Default is true.
+ */
+function addRoomClearCharge(player, bigRoomDoubleCharge = true, playSoundEffect = true) {
+    for (const activeSlot of [
+        isaac_typescript_definitions_1.ActiveSlot.PRIMARY,
+        isaac_typescript_definitions_1.ActiveSlot.SECONDARY,
+        isaac_typescript_definitions_1.ActiveSlot.POCKET,
+    ]) {
+        addRoomClearChargeToSlot(player, activeSlot, bigRoomDoubleCharge, playSoundEffect);
+    }
+}
+exports.addRoomClearCharge = addRoomClearCharge;
+/**
+ * Helper function to add a charge to one of a player's active items, emulating what happens when a
+ * room is cleared.
+ *
+ * This function will take the following things into account:
+ * - L rooms and 2x2 rooms granting a double charge
+ * - The Battery
+ * - AAA Battery
+ * - Not charging active items with `chargetype="special"`
+ *
+ * @param player The player to grant the charges to.
+ * @param activeSlot Optional. The active item slot to grant the charges to. Default is
+ *                   `ActiveSlot.PRIMARY`.
+ * @param bigRoomDoubleCharge Optional. If set to false, it will treat the current room as a 1x1
+ *                            room for the purposes of calculating how much charge to grant. Default
+ *                            is true.
+ * @param playSoundEffect Optional. Whether to play a charge-related sound effect. Default is true.
+ */
+function addRoomClearChargeToSlot(player, activeSlot = isaac_typescript_definitions_1.ActiveSlot.PRIMARY, bigRoomDoubleCharge = true, playSoundEffect = true) {
+    const activeItem = player.GetActiveItem(activeSlot);
+    if (activeItem === isaac_typescript_definitions_1.CollectibleType.NULL) {
+        return;
+    }
+    // Certain collectibles have special charge mechanisms and are not charged upon a room being
+    // cleared.
+    const chargeType = (0, collectibles_1.getCollectibleChargeType)(activeItem);
+    if (chargeType === isaac_typescript_definitions_1.ItemConfigChargeType.SPECIAL) {
+        return;
+    }
+    const room = cachedClasses_1.game.GetRoom();
+    const roomShape = room.GetRoomShape();
+    // Big rooms grant two charges and normal rooms grant one charge.
+    let numCharges = bigRoomDoubleCharge ? (0, roomShape_1.getRoomShapeCharges)(roomShape) : 1;
+    // Handle the special case of a timed item. When clearing a room with a timed item, it should
+    // become fully charged.
+    if (chargeType === isaac_typescript_definitions_1.ItemConfigChargeType.TIMED) {
+        // The charges will become clamped to the proper amount in the `addCharge` function. (If the
+        // item is at 50% charge and the player has The Battery, it should go to 150% charged.)
+        numCharges = (0, collectibles_1.getCollectibleMaxCharges)(activeItem);
+    }
+    addCharge(player, activeSlot, numCharges, playSoundEffect);
+}
+exports.addRoomClearChargeToSlot = addRoomClearChargeToSlot;
+/**
+ * The AAA Battery should grant an extra charge when the active item is one away from being fully
+ * charged.
+ */
+function getChargesToAddWithAAAModifier(player, activeSlot, chargesToAdd) {
+    const hasAAABattery = player.HasTrinket(isaac_typescript_definitions_1.TrinketType.AAA_BATTERY);
+    if (!hasAAABattery) {
+        return chargesToAdd;
+    }
+    const chargesAwayFromMax = getChargesAwayFromMax(player, activeSlot);
+    const AAABatteryShouldApply = chargesToAdd === chargesAwayFromMax - 1;
+    return AAABatteryShouldApply ? chargesToAdd + 1 : chargesToAdd;
+}
+/**
+ * Helper function to add a charge to every player's active item, emulating what happens when a room
+ * is cleared.
+ *
+ * This function will take the following things into account:
+ * - L rooms and 2x2 rooms granting a double charge
+ * - The Battery
+ * - AAA Battery
+ *
+ * @param bigRoomDoubleCharge Optional. If set to false, it will treat the current room as a 1x1
+ *                            room for the purposes of calculating how much charge to grant. Default
+ *                            is true.
+ */
+function addRoomClearCharges(bigRoomDoubleCharge = true) {
+    for (const player of (0, playerIndex_1.getPlayers)()) {
+        addRoomClearCharge(player, bigRoomDoubleCharge);
+    }
+}
+exports.addRoomClearCharges = addRoomClearCharges;
+/**
+ * Helper function to get the amount of charges away from the maximum charge that a particular
+ * player is.
+ *
+ * This function accounts for The Battery. For example, if the player has 2/6 charges on a D6, this
+ * function will return 10 (because there are 4 charges remaining on the base charge and 6 charges
+ * remaining on The Battery charge).
+ *
+ * @param player The player to get the charges from.
+ * @param activeSlot Optional. The slot to get the charges from. Default is `ActiveSlot.PRIMARY`.
+ */
+function getChargesAwayFromMax(player, activeSlot = isaac_typescript_definitions_1.ActiveSlot.PRIMARY) {
+    const totalCharge = getTotalCharge(player, activeSlot);
+    const activeItem = player.GetActiveItem(activeSlot);
+    const hasBattery = player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.BATTERY);
+    const maxCharges = (0, collectibles_1.getCollectibleMaxCharges)(activeItem);
+    const effectiveMaxCharges = hasBattery ? maxCharges * 2 : maxCharges;
+    return effectiveMaxCharges - totalCharge;
+}
+exports.getChargesAwayFromMax = getChargesAwayFromMax;
+/**
+ * Helper function to get the combined normal charge and the battery charge for the player's active
+ * item. This is useful because you have to add these two values together when setting the active
+ * charge.
+ *
+ * @param player The player to get the charges from.
+ * @param activeSlot Optional. The slot to get the charges from. Default is `ActiveSlot.PRIMARY`.
+ */
+function getTotalCharge(player, activeSlot = isaac_typescript_definitions_1.ActiveSlot.PRIMARY) {
+    const activeCharge = player.GetActiveCharge(activeSlot);
+    const batteryCharge = player.GetBatteryCharge(activeSlot);
+    return activeCharge + batteryCharge;
+}
+exports.getTotalCharge = getTotalCharge;
+/**
+ * Helper function to find the active slots that the player has the corresponding collectible type
+ * in and have enough charge to be used. Returns an empty array if the player does not have the
+ * collectible in any active slot or does not have enough charges.
+ */
+function getUsableActiveItemSlots(player, collectibleType) {
+    const maxCharges = (0, collectibles_1.getCollectibleMaxCharges)(collectibleType);
+    const activeSlots = (0, playerCollectibles_1.getActiveItemSlots)(player, collectibleType);
+    return activeSlots.filter((activeSlot) => {
+        const totalCharge = getTotalCharge(player, activeSlot);
+        return totalCharge >= maxCharges;
+    });
+}
+exports.getUsableActiveItemSlots = getUsableActiveItemSlots;
+/**
+ * Helper function to check if a player's active item is "double charged", meaning that it has both
+ * a full normal charge and a full charge from The Battery.
+ *
+ * @param player The player to check.
+ * @param activeSlot Optional. The slot to check. Default is `ActiveSlot.PRIMARY`.
+ */
+function isActiveSlotDoubleCharged(player, activeSlot = isaac_typescript_definitions_1.ActiveSlot.PRIMARY) {
+    const collectibleType = player.GetActiveItem(activeSlot);
+    const batteryCharge = player.GetBatteryCharge(activeSlot);
+    const maxCharges = (0, collectibles_1.getCollectibleMaxCharges)(collectibleType);
+    return batteryCharge >= maxCharges;
+}
+exports.isActiveSlotDoubleCharged = isActiveSlotDoubleCharged;
+/**
+ * Helper function to play the appropriate sound effect for a player after getting one or more
+ * charges on their active item. (There is a different sound depending on whether the item is fully
+ * charged.)
+ *
+ * @param player The player to play the sound effect for.
+ * @param activeSlot Optional. The slot that was just charged. Default is `ActiveSlot.PRIMARY`.
+ */
+function playChargeSoundEffect(player, activeSlot = isaac_typescript_definitions_1.ActiveSlot.PRIMARY) {
+    for (const soundEffect of [
+        isaac_typescript_definitions_1.SoundEffect.BATTERY_CHARGE,
+        isaac_typescript_definitions_1.SoundEffect.BEEP, // 171
+    ]) {
+        cachedClasses_1.sfxManager.Stop(soundEffect);
+    }
+    const chargeSoundEffect = shouldPlayFullRechargeSound(player, activeSlot)
+        ? isaac_typescript_definitions_1.SoundEffect.BATTERY_CHARGE
+        : isaac_typescript_definitions_1.SoundEffect.BEEP;
+    cachedClasses_1.sfxManager.Play(chargeSoundEffect);
+}
+exports.playChargeSoundEffect = playChargeSoundEffect;
+function shouldPlayFullRechargeSound(player, activeSlot) {
+    const activeItem = player.GetActiveItem(activeSlot);
+    const activeCharge = player.GetActiveCharge(activeSlot);
+    const batteryCharge = player.GetBatteryCharge(activeSlot);
+    const hasBattery = player.HasCollectible(isaac_typescript_definitions_1.CollectibleType.BATTERY);
+    const maxCharges = (0, collectibles_1.getCollectibleMaxCharges)(activeItem);
+    // If we do not have The Battery, play the full recharge sound if we are now fully charged.
+    if (!hasBattery) {
+        // We cannot use the `EntityPlayer.NeedsCharge` method because it does not work properly for
+        // items with `chargetype="special"`.
+        return activeCharge === maxCharges;
+    }
+    // If we do have The Battery, play the full recharge sound if we are exactly double charged or
+    // exactly single charged.
+    return (batteryCharge === maxCharges ||
+        (activeCharge === maxCharges && batteryCharge === 0));
+}

package/dist/functions/chargeBar.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderChargeBar = exports.newChargeBarSprites = void 0;
+const CHARGE_BAR_ANM2 = "gfx/ui/ui_chargebar.anm2";
+/**
+ * Constructor for a `ChargeBarSprites` object. For more information, see the `renderChargeBar`
+ * helper function.
+ *
+ * Note that this is for the vertical charge bar that represents the number of charges that an
+ * active item has, not the circular charge bar that shows e.g. the charge rate of Brimstone.
+ */
+function newChargeBarSprites(maxCharges) {
+    const back = Sprite();
+    back.Load(CHARGE_BAR_ANM2, true);
+    back.Play("BarEmpty", true);
+    const meter = Sprite();
+    meter.Load(CHARGE_BAR_ANM2, true);
+    meter.Play("BarFull", true);
+    const meterBattery = Sprite();
+    meterBattery.Load(CHARGE_BAR_ANM2, true);
+    meterBattery.Play("BarFull", true);
+    const lines = Sprite();
+    lines.Load(CHARGE_BAR_ANM2, true);
+    lines.Play(`BarOverlay${maxCharges}`, true);
+    return {
+        back,
+        meter,
+        meterBattery,
+        lines,
+        maxCharges,
+    };
+}
+exports.newChargeBarSprites = newChargeBarSprites;
+/**
+ * Helper function to render a charge bar on the screen. First, call the `newChargeBarSprites`
+ * function to initialize the sprites, and then call this function on every render frame.
+ *
+ * Note that this is for the vertical charge bar that represents the number of charges that an
+ * active item has, not the circular charge bar that shows e.g. the charge rate of Brimstone.
+ */
+function renderChargeBar(sprites, position, normalCharges, batteryCharges) {
+    sprites.back.Render(position);
+    const normalChargesClamp = getChargeBarClamp(normalCharges, sprites.maxCharges);
+    sprites.meter.Render(position, normalChargesClamp);
+    const batteryChargesClamp = getChargeBarClamp(batteryCharges, sprites.maxCharges);
+    sprites.meterBattery.Render(position, batteryChargesClamp);
+    sprites.lines.Render(position);
+}
+exports.renderChargeBar = renderChargeBar;
+function getChargeBarClamp(charges, maxCharges) {
+    const meterMultiplier = 24 / maxCharges;
+    const meterClip = 26 - charges * meterMultiplier;
+    return Vector(0, meterClip);
+}

package/dist/functions/collectibleTag.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isQuestCollectible = exports.collectibleHasTag = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const types_1 = require("./types");
+function collectibleHasTag(collectibleOrCollectibleType, tag) {
+    const collectibleType = (0, types_1.isInteger)(collectibleOrCollectibleType)
+        ? collectibleOrCollectibleType
+        : collectibleOrCollectibleType.SubType;
+    const itemConfigItem = cachedClasses_1.itemConfig.GetCollectible(collectibleType);
+    if (itemConfigItem === undefined) {
+        return false;
+    }
+    return itemConfigItem.HasTags(tag);
+}
+exports.collectibleHasTag = collectibleHasTag;
+function isQuestCollectible(collectibleOrCollectibleType) {
+    const collectibleType = (0, types_1.isInteger)(collectibleOrCollectibleType)
+        ? collectibleOrCollectibleType
+        : collectibleOrCollectibleType.SubType;
+    return collectibleHasTag(collectibleType, isaac_typescript_definitions_1.ItemConfigTag.QUEST);
+}
+exports.isQuestCollectible = isQuestCollectible;