isaacscript-common 84.0.1 → 84.1.1

package/dist/functions/bitSet128.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeBitSet128 = exports.isSerializedBitSet128 = exports.isBitSet128 = exports.deserializeBitSet128 = exports.copyBitSet128 = void 0;
+const SerializationBrand_1 = require("../enums/private/SerializationBrand");
+const isaacAPIClass_1 = require("./isaacAPIClass");
+const table_1 = require("./table");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const OBJECT_NAME = "BitSet128";
+const KEYS = ["l", "h"];
+/** Helper function to copy a `BitSet128` Isaac API class. */
+function copyBitSet128(bitSet128) {
+    if (!isBitSet128(bitSet128)) {
+        error(`Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`);
+    }
+    const lowBits = bitSet128.l;
+    const highBits = bitSet128.h;
+    return BitSet128(lowBits, highBits);
+}
+exports.copyBitSet128 = copyBitSet128;
+/**
+ * Helper function to convert a `SerializedBitSet128` object to a normal `BitSet128` object. (This
+ * is used by the save data manager when reading data from the "save#.dat" file.)
+ */
+function deserializeBitSet128(bitSet128) {
+    if (!(0, types_1.isTable)(bitSet128)) {
+        error(`Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`);
+    }
+    const [l, h] = (0, table_1.getNumbersFromTable)(bitSet128, OBJECT_NAME, ...KEYS);
+    (0, utils_1.assertDefined)(l, `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: l`);
+    (0, utils_1.assertDefined)(h, `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: h`);
+    return BitSet128(l, h);
+}
+exports.deserializeBitSet128 = deserializeBitSet128;
+/** Helper function to check if something is an instantiated `BitSet128` object. */
+function isBitSet128(object) {
+    return (0, isaacAPIClass_1.isIsaacAPIClassOfType)(object, OBJECT_NAME);
+}
+exports.isBitSet128 = isBitSet128;
+/**
+ * Used to determine is the given table is a serialized `BitSet128` object created by the `deepCopy`
+ * function.
+ */
+function isSerializedBitSet128(object) {
+    if (!(0, types_1.isTable)(object)) {
+        return false;
+    }
+    return ((0, table_1.tableHasKeys)(object, ...KEYS) && object.has(SerializationBrand_1.SerializationBrand.BIT_SET_128));
+}
+exports.isSerializedBitSet128 = isSerializedBitSet128;
+/**
+ * Helper function to convert a `BitSet128` object to a `SerializedBitSet128` object. (This is used
+ * by the save data manager when writing data from the "save#.dat" file.)
+ */
+function serializeBitSet128(bitSet128) {
+    if (!isBitSet128(bitSet128)) {
+        error(`Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`);
+    }
+    const bitSet128Table = new LuaMap();
+    (0, table_1.copyUserdataValuesToTable)(bitSet128, KEYS, bitSet128Table);
+    bitSet128Table.set(SerializationBrand_1.SerializationBrand.BIT_SET_128, "");
+    return bitSet128Table;
+}
+exports.serializeBitSet128 = serializeBitSet128;

package/dist/functions/bitwise.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setToBitFlags = exports.getNumBitsOfN = exports.getKBitOfN = exports.countSetBits = exports.convertDecimalToBinary = exports.convertBinaryToDecimal = exports.arrayToBitFlags = void 0;
+const flag_1 = require("./flag");
+const utils_1 = require("./utils");
+/** Helper function to convert a set of flags to a single `BitFlags` object. */
+function arrayToBitFlags(array) {
+    let flags = 0;
+    for (const flag of array) {
+        flags = (0, flag_1.addFlag)(flags, flag);
+    }
+    return flags;
+}
+exports.arrayToBitFlags = arrayToBitFlags;
+/** Helper function to convert an array of bits to the resulting decimal number. */
+function convertBinaryToDecimal(bits) {
+    const bitsString = bits.join("");
+    return Number.parseInt(bitsString, 2);
+}
+exports.convertBinaryToDecimal = convertBinaryToDecimal;
+/**
+ * Helper function to convert a number to an array of bits.
+ *
+ * @param num The number to convert.
+ * @param minLength Optional. Equal to the minimum amount of bits that should be returned. If the
+ *                  converted number of bits is below this number, 0's will be padded to the left
+ *                  side until the minimum length is met. Default is undefined (which will not cause
+ *                  any padding).
+ */
+function convertDecimalToBinary(num, minLength) {
+    const bits = [];
+    const bitsString = num.toString(2);
+    for (const bitString of bitsString) {
+        const bit = tonumber(bitString);
+        (0, utils_1.assertDefined)(bit, `Failed to convert the following number to binary: ${num}`);
+        bits.push(bit);
+    }
+    if (minLength !== undefined) {
+        while (bits.length < minLength) {
+            bits.unshift(0);
+        }
+    }
+    return bits;
+}
+exports.convertDecimalToBinary = convertDecimalToBinary;
+/**
+ * Helper function to count the number of bits that are set to 1 in a binary representation of a
+ * number.
+ */
+function countSetBits(num) {
+    let count = 0;
+    while (num > 0) {
+        num &= num - 1;
+        count++;
+    }
+    return count;
+}
+exports.countSetBits = countSetBits;
+/** Helper function to get the value of a specific but in a binary representation of a number. */
+function getKBitOfN(k, n) {
+    return (n >>> k) & 1;
+}
+exports.getKBitOfN = getKBitOfN;
+/** Helper function to get the number of bits in a binary representation of a number. */
+function getNumBitsOfN(n) {
+    let numBits = 0;
+    while (n > 0) {
+        numBits++;
+        n >>>= 1;
+    }
+    return numBits;
+}
+exports.getNumBitsOfN = getNumBitsOfN;
+/** Helper function to convert a set of flags to a single `BitFlags` object. */
+function setToBitFlags(set) {
+    let flags = 0;
+    for (const flag of set) {
+        flags = (0, flag_1.addFlag)(flags, flag);
+    }
+    return flags;
+}
+exports.setToBitFlags = setToBitFlags;

package/dist/functions/bombs.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBombRadiusFromDamage = void 0;
+/** Helper function to find out how large a bomb explosion is based on the damage inflicted. */
+function getBombRadiusFromDamage(damage) {
+    if (damage > 175) {
+        return 105;
+    }
+    if (damage <= 140) {
+        return 75;
+    }
+    return 90;
+}
+exports.getBombRadiusFromDamage = getBombRadiusFromDamage;

package/dist/functions/bosses.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnBossWithSeed = exports.spawnBoss = exports.isSin = exports.isRepentanceBoss = exports.getEntityTypeVariantFromBossID = exports.getBosses = exports.getBossStageIDs = exports.getBossName = exports.getBossIDsForStageID = exports.getBossIDsForStage = exports.getBossIDFromEntityTypeVariant = exports.getBossID = exports.getAllNonStoryBosses = exports.getAllBosses = exports.getAliveBosses = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../core/cachedClasses");
+const constants_1 = require("../core/constants");
+const entityTypeVariantToBossIDMap_1 = require("../maps/entityTypeVariantToBossIDMap");
+const bossIDToEntityTypeVariant_1 = require("../objects/bossIDToEntityTypeVariant");
+const bossNames_1 = require("../objects/bossNames");
+const bossSets_1 = require("../sets/bossSets");
+const repentanceBossIDsSet_1 = require("../sets/repentanceBossIDsSet");
+const sinEntityTypesSet_1 = require("../sets/sinEntityTypesSet");
+const ReadonlySet_1 = require("../types/ReadonlySet");
+const entities_1 = require("./entities");
+const entitiesSpecific_1 = require("./entitiesSpecific");
+const npcs_1 = require("./npcs");
+const rng_1 = require("./rng");
+const rooms_1 = require("./rooms");
+const utils_1 = require("./utils");
+const BOSSES_THAT_REQUIRE_MULTIPLE_SPAWNS = new ReadonlySet_1.ReadonlySet([
+    isaac_typescript_definitions_1.EntityType.LARRY_JR,
+    isaac_typescript_definitions_1.EntityType.CHUB,
+    isaac_typescript_definitions_1.EntityType.LOKI,
+    isaac_typescript_definitions_1.EntityType.GURGLING,
+    isaac_typescript_definitions_1.EntityType.TURDLET, // 918
+]);
+const DEFAULT_BOSS_MULTI_SEGMENTS = 4;
+/**
+ * Helper function to get all of the non-dead bosses in the room.
+ *
+ * This function will not include bosses on an internal blacklist, such as Death's scythes or Big
+ * Horn holes.
+ *
+ * @param entityType Optional. If specified, will only get the bosses that match the type. Default
+ *                   is -1, which matches every type.
+ * @param variant Optional. If specified, will only get the bosses that match the variant. Default
+ *                is -1, which matches every variant.
+ * @param subType Optional. If specified, will only get the bosses that match the sub-type. Default
+ *                is -1, which matches every sub-type.
+ * @param ignoreFriendly Optional. Default is false.
+ */
+function getAliveBosses(entityType = -1, variant = -1, subType = -1, ignoreFriendly = false) {
+    const aliveNPCs = (0, npcs_1.getAliveNPCs)(entityType, variant, subType, ignoreFriendly);
+    return aliveNPCs.filter((aliveNPC) => aliveNPC.IsBoss());
+}
+exports.getAliveBosses = getAliveBosses;
+/**
+ * Helper function to get an array with every boss in the game. This is derived from the `BossID`
+ * enum.
+ *
+ * This includes:
+ * - Ultra Greed
+ * - Ultra Greedier
+ *
+ * This does not include:
+ * - mini-bosses (e.g. Ultra Pride, Krampus)
+ * - bosses that do not appear in Boss Rooms (e.g. Uriel, Gabriel)
+ * - the second phase of multi-phase bosses (e.g. Mega Satan 2)
+ * - sub-bosses of The Beast fight (e.g. Ultra Famine, Ultra Pestilence, Ultra War, Ultra Death)
+ * - bosses that do not have any Boss Rooms defined due to being unfinished (e.g. Raglich)
+ *
+ * Also see the `getAllNonStoryBosses` function.
+ */
+function getAllBosses() {
+    return bossSets_1.ALL_BOSSES;
+}
+exports.getAllBosses = getAllBosses;
+/**
+ * Helper function to get an array with every boss in the game. This is derived from the `BossID`
+ * enum. This is the same thing as the `getAllBosses` helper function, but with story bosses
+ * filtered out.
+ */
+function getAllNonStoryBosses() {
+    return bossSets_1.NON_STORY_BOSSES;
+}
+exports.getAllNonStoryBosses = getAllNonStoryBosses;
+/**
+ * Helper function to get the boss ID corresponding to the current room. Returns undefined if the
+ * current room is not a Boss Room.
+ *
+ * Use this instead of the vanilla `Room.GetBossID` method since it has a saner return type and it
+ * correctly handles Dogma, The Beast, and Ultra Greedier.
+ */
+function getBossID() {
+    if ((0, rooms_1.inDogmaRoom)()) {
+        return isaac_typescript_definitions_1.BossID.DOGMA;
+    }
+    if ((0, rooms_1.inBeastRoom)()) {
+        return isaac_typescript_definitions_1.BossID.BEAST;
+    }
+    const room = cachedClasses_1.game.GetRoom();
+    // eslint-disable-next-line deprecation/deprecation
+    const bossID = room.GetBossID();
+    if (bossID === 0) {
+        return undefined;
+    }
+    // The Ultra Greed room holds both Ultra Greed and Ultra Greedier.
+    if (bossID === isaac_typescript_definitions_1.BossID.ULTRA_GREED &&
+        (0, entities_1.doesEntityExist)(isaac_typescript_definitions_1.EntityType.ULTRA_GREED, isaac_typescript_definitions_1.UltraGreedVariant.ULTRA_GREEDIER)) {
+        return isaac_typescript_definitions_1.BossID.ULTRA_GREEDIER;
+    }
+    return bossID;
+}
+exports.getBossID = getBossID;
+function getBossIDFromEntityTypeVariant(entityType, variant) {
+    const entityTypeVariant = `${entityType}.${variant}`;
+    return entityTypeVariantToBossIDMap_1.ENTITY_TYPE_VARIANT_TO_BOSS_ID_MAP.get(entityTypeVariant);
+}
+exports.getBossIDFromEntityTypeVariant = getBossIDFromEntityTypeVariant;
+/**
+ * Helper function to get the set of vanilla bosses for a particular stage across all of the stage
+ * types. For example, specifying `LevelStage.BASEMENT_2` will return a set with all of the bosses
+ * for Basement, Cellar, Burning Basement, Downpour, and Dross.
+ *
+ * Also see the `getAllBossesSet` and `getBossIDsForStageID` functions.
+ */
+function getBossIDsForStage(stage) {
+    return bossSets_1.STAGE_TO_COMBINED_BOSS_SET_MAP.get(stage);
+}
+exports.getBossIDsForStage = getBossIDsForStage;
+/**
+ * Helper function to get the set of vanilla bosses that can randomly appear on a particular stage
+ * ID.
+ *
+ * Also see the `getAllBossesSet` and `getBossIDsForStage` functions.
+ */
+function getBossIDsForStageID(stageID) {
+    return bossSets_1.STAGE_ID_TO_BOSS_IDS.get(stageID);
+}
+exports.getBossIDsForStageID = getBossIDsForStageID;
+/**
+ * Helper function to get the proper English name for a boss. For example, the name for
+ * `BossID.WRETCHED` (36) is "The Wretched".
+ */
+function getBossName(bossID) {
+    // Handle modded boss IDs.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return bossNames_1.BOSS_NAMES[bossID] ?? bossNames_1.DEFAULT_BOSS_NAME;
+}
+exports.getBossName = getBossName;
+/** Helper function to get the set of stage IDs that a particular boss naturally appears in. */
+function getBossStageIDs(bossID) {
+    return bossSets_1.BOSS_ID_TO_STAGE_IDS[bossID];
+}
+exports.getBossStageIDs = getBossStageIDs;
+/**
+ * Helper function to get all of the bosses in the room.
+ *
+ * @param entityType Optional. If specified, will only get the bosses that match the type. Default
+ *                   is -1, which matches every type.
+ * @param variant Optional. If specified, will only get the bosses that match the variant. Default
+ *                is -1, which matches every variant.
+ * @param subType Optional. If specified, will only get the bosses that match the sub-type. Default
+ *                is -1, which matches every sub-type.
+ * @param ignoreFriendly Optional. Default is false.
+ */
+function getBosses(entityType, variant, subType, ignoreFriendly = false) {
+    const npcs = (0, entitiesSpecific_1.getNPCs)(entityType, variant, subType, ignoreFriendly);
+    return npcs.filter((npc) => npc.IsBoss());
+}
+exports.getBosses = getBosses;
+function getEntityTypeVariantFromBossID(bossID) {
+    return bossIDToEntityTypeVariant_1.BOSS_ID_TO_ENTITY_TYPE_VARIANT[bossID];
+}
+exports.getEntityTypeVariantFromBossID = getEntityTypeVariantFromBossID;
+/**
+ * Helper function to check if a boss is only found on a Repentance floor such as Dross, Mines, and
+ * so on.
+ *
+ * For example, The Pile is a boss that was added in Repentance, but since it can appear in
+ * Necropolis, it is not considered a Repentance boss for the purposes of this function.
+ */
+function isRepentanceBoss(bossID) {
+    return repentanceBossIDsSet_1.REPENTANCE_ONLY_BOSS_IDS_SET.has(bossID);
+}
+exports.isRepentanceBoss = isRepentanceBoss;
+/** Helper function to check if the provided NPC is a Sin miniboss, such as Sloth or Lust. */
+function isSin(npc) {
+    return sinEntityTypesSet_1.SIN_ENTITY_TYPES_SET.has(npc.Type);
+}
+exports.isSin = isSin;
+function getNumBossSegments(entityType, variant, numSegments) {
+    if (numSegments !== undefined) {
+        return numSegments;
+    }
+    switch (entityType) {
+        // 28
+        case isaac_typescript_definitions_1.EntityType.CHUB: {
+            // Chub is always composed of 3 segments.
+            return 3;
+        }
+        // 69
+        case isaac_typescript_definitions_1.EntityType.LOKI: {
+            return variant === isaac_typescript_definitions_1.LokiVariant.LOKII ? 2 : 1;
+        }
+        // 237
+        case isaac_typescript_definitions_1.EntityType.GURGLING: {
+            // Gurglings & Turdlings are always encountered in groups of 2.
+            return 2;
+        }
+        default: {
+            return DEFAULT_BOSS_MULTI_SEGMENTS;
+        }
+    }
+}
+/**
+ * Helper function to spawn a boss.
+ *
+ * Use this function instead of `spawnNPC` since it handles automatically spawning multiple segments
+ * for multi-segment bosses.
+ *
+ * By default, this will spawn Chub (and his variants) with 3 segments, Lokii with 2 copies,
+ * Gurglings/Turdlings with 2 copies, and other multi-segment bosses with 4 segments. You can
+ * customize this via the "numSegments" argument.
+ */
+function spawnBoss(entityType, variant, subType, positionOrGridIndex, velocity = constants_1.VectorZero, spawner = undefined, seedOrRNG = undefined, numSegments) {
+    const seed = (0, rng_1.isRNG)(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
+    const npc = (0, entitiesSpecific_1.spawnNPC)(entityType, variant, subType, positionOrGridIndex, velocity, spawner, seed);
+    if (BOSSES_THAT_REQUIRE_MULTIPLE_SPAWNS.has(entityType)) {
+        const numBossSegments = getNumBossSegments(entityType, variant, numSegments);
+        const remainingSegmentsToSpawn = numBossSegments - 1;
+        (0, utils_1.repeat)(remainingSegmentsToSpawn, () => {
+            (0, entitiesSpecific_1.spawnNPC)(entityType, variant, subType, positionOrGridIndex, velocity, spawner, seed);
+        });
+    }
+    return npc;
+}
+exports.spawnBoss = spawnBoss;
+/**
+ * Helper function to spawn a boss with a specific seed.
+ *
+ * For more information, see the documentation for the `spawnBoss` function.
+ */
+function spawnBossWithSeed(entityType, variant, subType, positionOrGridIndex, seedOrRNG, velocity = constants_1.VectorZero, spawner = undefined, numSegments) {
+    const seed = (0, rng_1.isRNG)(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
+    return spawnBoss(entityType, variant, subType, positionOrGridIndex, velocity, spawner, seed, numSegments);
+}
+exports.spawnBossWithSeed = spawnBossWithSeed;

package/dist/functions/cards.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCardTemp = exports.isVanillaCardType = exports.isValidCardType = exports.isTarotCard = exports.isSuitCard = exports.isSpecialCard = exports.isRune = exports.isReverseTarotCard = exports.isPocketItemObject = exports.isModdedCardType = exports.isCardType = exports.isCard = exports.hasCard = exports.getItemConfigCardType = exports.getCardName = exports.getCardDescription = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../arrays/cachedEnumValues");
+const cachedClasses_1 = require("../core/cachedClasses");
+const constantsFirstLast_1 = require("../core/constantsFirstLast");
+const cardDescriptions_1 = require("../objects/cardDescriptions");
+const cardNames_1 = require("../objects/cardNames");
+const itemConfigCardTypesForCards_1 = require("../sets/itemConfigCardTypesForCards");
+const flag_1 = require("./flag");
+const types_1 = require("./types");
+/**
+ * Helper function to get a card description from a `CardType` value. Returns "Unknown" if the
+ * provided card type is not valid.
+ *
+ * This function works for both vanilla and modded trinkets.
+ *
+ * For example, `getCardDescription(CardType.FOOL)` would return "Where journey begins".
+ */
+function getCardDescription(cardType) {
+    // "ItemConfigCard.Description" is bugged with vanilla cards on patch v1.7.6, so we use a
+    // hard-coded map as a workaround.
+    const cardDescription = cardDescriptions_1.CARD_DESCRIPTIONS[cardType];
+    // Handle modded cards.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (cardDescription !== undefined) {
+        return cardDescription;
+    }
+    const itemConfigCard = cachedClasses_1.itemConfig.GetCard(cardType);
+    if (itemConfigCard !== undefined) {
+        return itemConfigCard.Description;
+    }
+    return cardDescriptions_1.DEFAULT_CARD_DESCRIPTION;
+}
+exports.getCardDescription = getCardDescription;
+/**
+ * Helper function to get the name of a card. Returns "Unknown" if the provided card type is not
+ * valid.
+ *
+ * This function works for both vanilla and modded trinkets.
+ *
+ * For example, `getCardName(Card.FOOL)` would return "0 - The Fool".
+ */
+function getCardName(cardType) {
+    // "ItemConfigCard.Name" is bugged with vanilla cards on patch v1.7.6, so we use a hard-coded map
+    // as a workaround.
+    const cardName = cardNames_1.CARD_NAMES[cardType];
+    // Handle modded cards.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (cardName !== undefined) {
+        return cardName;
+    }
+    const itemConfigCard = cachedClasses_1.itemConfig.GetCard(cardType);
+    if (itemConfigCard !== undefined) {
+        return itemConfigCard.Name;
+    }
+    return cardNames_1.DEFAULT_CARD_NAME;
+}
+exports.getCardName = getCardName;
+/**
+ * Helper function to get the item config card type of a particular card, rune, or object. For
+ * example, the item config card type of `CardType.FOOL` is equal to `ItemConfigCardType.TAROT`.
+ *
+ * Returns undefined if the provided card type was not valid.
+ */
+function getItemConfigCardType(cardType) {
+    const itemConfigCard = cachedClasses_1.itemConfig.GetCard(cardType);
+    if (itemConfigCard === undefined) {
+        return undefined;
+    }
+    return itemConfigCard.CardType;
+}
+exports.getItemConfigCardType = getItemConfigCardType;
+/**
+ * Helper function to check if a player is holding a specific card in one of their pocket item
+ * slots.
+ *
+ * This function is variadic, meaning that you can pass as many cards as you want to check for. The
+ * function will return true if the player has any of the cards.
+ */
+function hasCard(player, ...cardTypes) {
+    const cardTypesSet = new Set(cardTypes);
+    return cachedEnumValues_1.POCKET_ITEM_SLOT_VALUES.some((pocketItemSlot) => {
+        const cardType = player.GetCard(pocketItemSlot);
+        return cardTypesSet.has(cardType);
+    });
+}
+exports.hasCard = hasCard;
+/**
+ * Returns true for card types that have the following item config card type:
+ *
+ * - `ItemConfigCardType.TAROT` (0)
+ * - `ItemConfigCardType.SUIT` (1)
+ * - `ItemConfigCardType.SPECIAL` (3)
+ * - `ItemConfigCardType.TAROT_REVERSE` (5)
+ */
+function isCard(cardType) {
+    const itemConfigCardType = getItemConfigCardType(cardType);
+    if (itemConfigCardType === undefined) {
+        return false;
+    }
+    return itemConfigCardTypesForCards_1.ITEM_CONFIG_CARD_TYPES_FOR_CARDS.has(itemConfigCardType);
+}
+exports.isCard = isCard;
+/** Returns whether the given card type matches the specified item config card type. */
+function isCardType(cardType, itemConfigCardType) {
+    return itemConfigCardType === getItemConfigCardType(cardType);
+}
+exports.isCardType = isCardType;
+/** Returns true for any card type added by a mod. */
+function isModdedCardType(cardType) {
+    return !isVanillaCardType(cardType);
+}
+exports.isModdedCardType = isModdedCardType;
+/** Returns true for card types that have `ItemConfigCardType.SPECIAL_OBJECT`. */
+function isPocketItemObject(cardType) {
+    return isCardType(cardType, isaac_typescript_definitions_1.ItemConfigCardType.SPECIAL_OBJECT);
+}
+exports.isPocketItemObject = isPocketItemObject;
+/** Returns true for card types that have `ItemConfigCardType.TAROT_REVERSE`. */
+function isReverseTarotCard(cardType) {
+    return isCardType(cardType, isaac_typescript_definitions_1.ItemConfigCardType.TAROT_REVERSE);
+}
+exports.isReverseTarotCard = isReverseTarotCard;
+/** Returns true for card types that have `ItemConfigCardType.RUNE`. */
+function isRune(cardType) {
+    return isCardType(cardType, isaac_typescript_definitions_1.ItemConfigCardType.RUNE);
+}
+exports.isRune = isRune;
+/** Returns true for card types that have `ItemConfigCardType.SPECIAL`. */
+function isSpecialCard(cardType) {
+    return isCardType(cardType, isaac_typescript_definitions_1.ItemConfigCardType.SPECIAL);
+}
+exports.isSpecialCard = isSpecialCard;
+/** Returns true for card types that have `ItemConfigCardType.SUIT`. */
+function isSuitCard(cardType) {
+    return isCardType(cardType, isaac_typescript_definitions_1.ItemConfigCardType.SUIT);
+}
+exports.isSuitCard = isSuitCard;
+/** Returns true for card types that have `ItemConfigCardType.TAROT`. */
+function isTarotCard(cardType) {
+    return isCardType(cardType, isaac_typescript_definitions_1.ItemConfigCardType.TAROT);
+}
+exports.isTarotCard = isTarotCard;
+function isValidCardType(cardType) {
+    const potentialCardType = (0, types_1.asCardType)(cardType);
+    const itemConfigCard = cachedClasses_1.itemConfig.GetCard(potentialCardType);
+    return itemConfigCard !== undefined;
+}
+exports.isValidCardType = isValidCardType;
+function isVanillaCardType(cardType) {
+    return cardType <= constantsFirstLast_1.LAST_VANILLA_CARD_TYPE;
+}
+exports.isVanillaCardType = isVanillaCardType;
+/**
+ * Helper function to use a card without showing an animation and without the announcer voice
+ * playing.
+ */
+function useCardTemp(player, cardType) {
+    const useFlags = (0, flag_1.addFlag)(isaac_typescript_definitions_1.UseFlag.NO_ANIMATION, isaac_typescript_definitions_1.UseFlag.NO_ANNOUNCER_VOICE);
+    player.UseCard(cardType, useFlags);
+}
+exports.useCardTemp = useCardTemp;

package/dist/functions/challenges.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setChallenge = exports.onChallenge = exports.onAnyChallenge = exports.getChallengeTrinketType = exports.getChallengeName = exports.getChallengeCollectibleTypes = exports.getChallengeCharacter = exports.getChallengeBoss = exports.clearChallenge = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const challengeBosses_1 = require("../objects/challengeBosses");
+const challengeCharacters_1 = require("../objects/challengeCharacters");
+const challengeCollectibleTypes_1 = require("../objects/challengeCollectibleTypes");
+const challengeNames_1 = require("../objects/challengeNames");
+const challengeTrinketType_1 = require("../objects/challengeTrinketType");
+const log_1 = require("./log");
+/**
+ * Helper function to clear the current challenge, which will restart the run on a new random
+ * non-challenge seed with the current character.
+ *
+ * If the player is not in a challenge already, this function will do nothing.
+ *
+ * Under the hood, this function executes the `challenge 0` console command.
+ */
+function clearChallenge() {
+    if (onAnyChallenge()) {
+        const command = `challenge ${isaac_typescript_definitions_1.Challenge.NULL}`;
+        (0, log_1.log)(`Restarting the run to clear the current challenge with a console command of: ${command}`);
+        Isaac.ExecuteCommand(command);
+    }
+}
+exports.clearChallenge = clearChallenge;
+/**
+ * Get the final boss of a challenge. This will only work for vanilla challenges.
+ *
+ * For modded challenges, `BossID.MOM` (6) will be returned.
+ *
+ * Note that for `Challenge.BACKASSWARDS` (31), this function will return `BossID.MEGA_SATAN` (55),
+ * but this is not actually the final boss. (There is no final boss for this challenge.)
+ */
+function getChallengeBoss(challenge) {
+    const challengeBossID = challengeBosses_1.CHALLENGE_BOSSES[challenge];
+    // Handle modded challenges.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return challengeBossID ?? challengeBosses_1.DEFAULT_CHALLENGE_BOSS_ID;
+}
+exports.getChallengeBoss = getChallengeBoss;
+/**
+ * Get the starting character of a challenge. This will only work for vanilla challenges.
+ *
+ * For modded challenges, `PlayerType.ISAAC` (0) will be returned.
+ */
+function getChallengeCharacter(challenge) {
+    const challengeCharacter = challengeCharacters_1.CHALLENGE_CHARACTERS[challenge];
+    // Handle modded challenges.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return challengeCharacter ?? challengeCharacters_1.DEFAULT_CHALLENGE_CHARACTER;
+}
+exports.getChallengeCharacter = getChallengeCharacter;
+/**
+ * Get the extra starting collectibles for a challenge. This will only work for vanilla challenges.
+ *
+ * For modded challenges, an empty array will be returned.
+ */
+function getChallengeCollectibleTypes(challenge) {
+    return challengeCollectibleTypes_1.CHALLENGE_COLLECTIBLE_TYPES[challenge];
+}
+exports.getChallengeCollectibleTypes = getChallengeCollectibleTypes;
+/**
+ * Get the proper name for a `Challenge` enum. This will only work for vanilla challenges.
+ *
+ * For modded challenges, "Unknown" will be returned.
+ */
+function getChallengeName(challenge) {
+    const challengeName = challengeNames_1.CHALLENGE_NAMES[challenge];
+    // Handle modded challenges.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return challengeName ?? challengeNames_1.DEFAULT_CHALLENGE_NAME;
+}
+exports.getChallengeName = getChallengeName;
+/**
+ * Get the extra starting trinket for a challenge. This will only work for vanilla challenges.
+ *
+ * If a challenge does not grant a starting trinket, `undefined` will be returned.
+ *
+ * For modded challenges, `undefined` will be returned.
+ */
+function getChallengeTrinketType(challenge) {
+    return challengeTrinketType_1.CHALLENGE_TRINKET_TYPE[challenge];
+}
+exports.getChallengeTrinketType = getChallengeTrinketType;
+/** Helper function to see if the player is playing any challenge. */
+function onAnyChallenge() {
+    const challenge = Isaac.GetChallenge();
+    return challenge !== isaac_typescript_definitions_1.Challenge.NULL;
+}
+exports.onAnyChallenge = onAnyChallenge;
+/**
+ * Helper function to check to see if the player is playing a particular challenge.
+ *
+ * This function is variadic, meaning that you can specify as many challenges as you want to check
+ * for.
+ */
+function onChallenge(...challenges) {
+    const challenge = Isaac.GetChallenge();
+    return challenges.includes(challenge);
+}
+exports.onChallenge = onChallenge;
+/**
+ * Helper function to restart the run on a particular challenge.
+ *
+ * If the player is already in the particular challenge, this function will do nothing.
+ *
+ * Under the hood, this function executes the `challenge 0` console command.
+ */
+function setChallenge(challenge) {
+    if (!onChallenge(challenge)) {
+        const command = `challenge ${challenge}`;
+        (0, log_1.log)(`Restarting the run to set a challenge with a console command of: ${command}`);
+        Isaac.ExecuteCommand(command);
+    }
+}
+exports.setChallenge = setChallenge;