isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.2

package/functions/boss.js

@@ -0,0 +1,137 @@
+import { EntityType, LokiVariant, } from "isaac-typescript-definitions";
+import { VectorZero } from "../constants";
+import { ALL_BOSSES_SET, STAGE_TO_COMBINED_BOSS_SET_MAP, STAGE_TO_STAGE_TYPE_TO_BOSS_SET_MAP, } from "../sets/bossSets";
+import { SIN_ENTITY_TYPES_SET } from "../sets/sinEntityTypesSet";
+import { getNPCs, spawnNPC } from "./entitySpecific";
+import { getAliveNPCs } from "./npc";
+import { isRNG } from "./rng";
+import { copySet } from "./set";
+import { repeat } from "./utils";
+const BOSSES_THAT_REQUIRE_MULTIPLE_SPAWNS = new Set([
+    EntityType.LARRY_JR,
+    EntityType.CHUB,
+    EntityType.LOKI,
+    EntityType.GURGLING,
+    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.
+ */
+export function getAliveBosses(matchingEntityType, matchingVariant, matchingSubType, ignoreFriendly = false) {
+    const aliveNPCs = getAliveNPCs(matchingEntityType, matchingVariant, matchingSubType, ignoreFriendly);
+    return aliveNPCs.filter((aliveNPC) => aliveNPC.IsBoss());
+}
+/**
+ * Helper function to get the set of every boss in the game.
+ *
+ * The set contains strings with the entity type and variant, separated by a period.
+ *
+ * Also see the `getBossSet` and `getCombinedBossSet` functions.
+ */
+export function getAllBossesSet() {
+    return copySet(ALL_BOSSES_SET);
+}
+/**
+ * Helper function to get the set of vanilla bosses for a particular stage and stage type
+ * combination.
+ *
+ * The set contains strings with the entity type and variant, separated by a period.
+ *
+ * Also see the `getAllBossesSet` and `getCombinedBossSet` functions.
+ */
+export function getBossSet(stage, stageType) {
+    const stageTypeMap = STAGE_TO_STAGE_TYPE_TO_BOSS_SET_MAP.get(stage);
+    if (stageTypeMap === undefined) {
+        return undefined;
+    }
+    const bossSet = stageTypeMap.get(stageType);
+    if (bossSet === undefined) {
+        return undefined;
+    }
+    return copySet(bossSet);
+}
+/** Helper function to get all of the bosses in the room. */
+export function getBosses(matchingEntityType, matchingVariant, matchingSubType, ignoreFriendly = false) {
+    const npcs = getNPCs(matchingEntityType, matchingVariant, matchingSubType, ignoreFriendly);
+    return npcs.filter((npc) => npc.IsBoss());
+}
+/**
+ * Helper function to get the set of vanilla bosses for a particular stage across all of the stage
+ * types. For example, specifying a stage of 2 will return a set with all of the bosses for
+ * Basement, Cellar, Burning Basement, Downpour, and Dross.
+ *
+ * The set contains strings with the entity type and variant, separated by a period.
+ *
+ * Also see the `getAllBossesSet` and `getBossSet` functions.
+ */
+export function getCombinedBossSet(stage) {
+    const bossSet = STAGE_TO_COMBINED_BOSS_SET_MAP.get(stage);
+    if (bossSet === undefined) {
+        return undefined;
+    }
+    return copySet(bossSet);
+}
+/** Helper function to check if the provided NPC is a Sin miniboss, such as Sloth or Lust. */
+export function isSin(npc) {
+    return SIN_ENTITY_TYPES_SET.has(npc.Type);
+}
+/**
+ * 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.
+ */
+export function spawnBoss(entityType, variant, subType, position, velocity = VectorZero, spawner = undefined, seedOrRNG = undefined, numSegments) {
+    const seed = isRNG(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
+    const npc = spawnNPC(entityType, variant, subType, position, velocity, spawner, seed);
+    if (BOSSES_THAT_REQUIRE_MULTIPLE_SPAWNS.has(entityType)) {
+        const numBossSegments = getNumBossSegments(entityType, variant, numSegments);
+        const remainingSegmentsToSpawn = numBossSegments - 1;
+        repeat(remainingSegmentsToSpawn, () => {
+            spawnNPC(entityType, variant, subType, position, velocity, spawner, seed);
+        });
+    }
+    return npc;
+}
+function getNumBossSegments(entityType, variant, numSegments) {
+    if (numSegments !== undefined) {
+        return numSegments;
+    }
+    switch (entityType) {
+        // 28
+        case EntityType.CHUB: {
+            // Chub is always composed of 3 segments.
+            return 3;
+        }
+        // 69
+        case EntityType.LOKI: {
+            return variant === LokiVariant.LOKII ? 2 : 1;
+        }
+        // 237
+        case 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 with a specific seed.
+ *
+ * For more information, see the documentation for the `spawnBoss` function.
+ */
+export function spawnBossWithSeed(entityType, variant, subType, position, seedOrRNG, velocity = VectorZero, spawner = undefined, numSegments) {
+    const seed = isRNG(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
+    return spawnBoss(entityType, variant, subType, position, velocity, spawner, seed, numSegments);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/cacheFlag.js

@@ -0,0 +1,11 @@
+import { DEFAULT_PLAYER_STAT_MAP } from "../maps/defaultPlayerStatMap";
+/**
+ * Returns the starting stat that Isaac (the default character) starts with. For example, if you
+ * pass this function `CacheFlag.DAMAGE`, it will return 3.5.
+ *
+ * Note that the default fire delay is represented in the tear stat, not the `MaxFireDelay` value.
+ */
+export function getDefaultPlayerStat(cacheFlag) {
+    return DEFAULT_PLAYER_STAT_MAP.get(cacheFlag);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVGbGFnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvY2FjaGVGbGFnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBRXZFOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUFDLFNBQW9CO0lBQ3ZELE9BQU8sdUJBQXVCLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQ2hELENBQUMifQ==

package/functions/cards.js

@@ -0,0 +1,217 @@
+import { Card, ItemConfigCardType } from "isaac-typescript-definitions";
+import { itemConfig } from "../cachedClasses";
+import { FIRST_CARD, FIRST_MODDED_CARD, LAST_CARD, MAX_VANILLA_CARD, } from "../constantsFirstLast";
+import { CARD_DESCRIPTIONS, DEFAULT_CARD_DESCRIPTION, } from "../objects/cardDescriptions";
+import { CARD_NAMES, DEFAULT_CARD_NAME } from "../objects/cardNames";
+import { CARD_TYPES, DEFAULT_CARD_TYPE } from "../objects/cardTypes";
+import { getEnumValues } from "./enums";
+import { getRandomSeed } from "./rng";
+import { addSetsToSet, getRandomSetElement } from "./set";
+import { irange } from "./utils";
+const CARD_TYPE_TO_CARDS_MAP = new Map();
+/**
+ * Contains all of the entries in the `Card` enum with the following types:
+ * - ItemConfigCardType.TAROT
+ * - ItemConfigCardType.SUIT
+ * - ItemConfigCardType.SPECIAL
+ * - ItemConfigCardType.TAROT_REVERSE
+ */
+const CARD_SET = new Set();
+function initCardObjects() {
+    // The card type to cards map should be valid for every card type, so we initialize it with empty
+    // sets.
+    for (const cardType of getEnumValues(ItemConfigCardType)) {
+        CARD_TYPE_TO_CARDS_MAP.set(cardType, new Set());
+    }
+    for (const card of getAllCards()) {
+        const cardType = getCardType(card);
+        const cardTypeSet = CARD_TYPE_TO_CARDS_MAP.get(cardType);
+        if (cardTypeSet === undefined) {
+            error(`Failed to get the card set for card type: ${cardType}`);
+        }
+        cardTypeSet.add(card);
+    }
+    // i.e. everything except for:
+    // - ItemConfigCardType.RUNE
+    // - ItemConfigCardType.SPECIAL_OBJECT
+    // - ItemConfigCardType.MODDED
+    const cards = getCardsOfType(ItemConfigCardType.TAROT, ItemConfigCardType.SUIT, ItemConfigCardType.SPECIAL, ItemConfigCardType.TAROT_REVERSE);
+    addSetsToSet(CARD_SET, cards);
+}
+/** Helper function to get an array with every valid card sub-type. This includes modded cards. */
+export function getAllCards() {
+    return irange(FIRST_CARD, LAST_CARD);
+}
+/**
+ * Helper function to get a card description from a Card enum value.
+ *
+ * For example:
+ *
+ * ```ts
+ * const card = Card.FOOL;
+ * const cardDescription = getCardDescription(card); // cardDescription is "Where journey begins"
+ * ```
+ */
+export function getCardDescription(card) {
+    // "ItemConfigCard.Description" is bugged with vanilla cards on patch v1.7.6, so we use a
+    // hard-coded map as a workaround.
+    const cardDescription = CARD_DESCRIPTIONS[card];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (cardDescription !== undefined) {
+        return cardDescription;
+    }
+    const itemConfigCard = itemConfig.GetCard(card);
+    if (itemConfigCard !== undefined) {
+        return itemConfigCard.Description;
+    }
+    return DEFAULT_CARD_DESCRIPTION;
+}
+/**
+ * Helper function to get a card name from a Card.
+ *
+ * For example:
+ *
+ * ```ts
+ * const card = Card.FOOL;
+ * const cardName = getCardName(card); // cardName is "0 - The Fool"
+ * ```
+ */
+export function getCardName(card) {
+    // "ItemConfigCard.Name" is bugged with vanilla cards on patch v1.7.6, so we use a hard-coded map
+    // as a workaround.
+    const cardName = CARD_NAMES[card];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (cardName !== undefined) {
+        return cardName;
+    }
+    const itemConfigCard = itemConfig.GetCard(card);
+    if (itemConfigCard !== undefined) {
+        return itemConfigCard.Name;
+    }
+    return DEFAULT_CARD_NAME;
+}
+export function getCardType(card) {
+    const cardType = CARD_TYPES[card];
+    // Handle modded cards.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return cardType === undefined ? DEFAULT_CARD_TYPE : cardType;
+}
+/**
+ * Helper function to get a set of cards matching the type. Also see the `CardType` enum.
+ *
+ * This function is variadic, meaning that you can you can specify N card types to get a set
+ * containing cards that match any of the specified types.
+ */
+export function getCardsOfType(...cardTypes) {
+    if (CARD_TYPE_TO_CARDS_MAP.size === 0) {
+        initCardObjects();
+    }
+    const matchingCards = new Set();
+    for (const cardType of cardTypes) {
+        const cardSet = CARD_TYPE_TO_CARDS_MAP.get(cardType);
+        if (cardSet === undefined) {
+            error(`Failed to get the cards for type: ${cardType}`);
+        }
+        for (const card of cardSet.values()) {
+            matchingCards.add(card);
+        }
+    }
+    return matchingCards;
+}
+/**
+ * Helper function to get an array with every modded card sub-type.
+ *
+ * Returns an empty array if there are no modded cards.
+ */
+export function getModdedCards() {
+    if (MAX_VANILLA_CARD === LAST_CARD) {
+        return [];
+    }
+    return irange(FIRST_MODDED_CARD, LAST_CARD);
+}
+/**
+ * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
+ *
+ * This will not return:
+ * - any runes
+ * - any objects like Dice Shard
+ * - any modded cards (since there is not a way to distinguish between modded cards and modded
+ *   runes/objects)
+ *
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of cards to not select.
+ */
+export function getRandomCard(seedOrRNG = getRandomSeed(), exceptions = []) {
+    return getRandomSetElement(CARD_SET, seedOrRNG, exceptions);
+}
+/**
+ * @param cardType The card type that represents the pool of cards to select from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of cards to not select.
+ */
+export function getRandomCardOfType(cardType, seedOrRNG = getRandomSeed(), exceptions = []) {
+    const cardSet = getCardsOfType(cardType);
+    return getRandomSetElement(cardSet, seedOrRNG, exceptions);
+}
+/**
+ * Has an equal chance of returning any rune (e.g. Rune of Hagalaz, Blank Rune, Black Rune, Soul of
+ * Isaac, etc.). This will never return a Rune Shard.
+ *
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of runes to not select.
+ */
+export function getRandomRune(seedOrRNG = getRandomSeed(), exceptions = []) {
+    const runesSet = getCardsOfType(ItemConfigCardType.RUNE);
+    runesSet.delete(Card.RUNE_SHARD);
+    return getRandomSetElement(runesSet, seedOrRNG, exceptions);
+}
+/** Helper function to get an array with every valid vanilla card sub-type. */
+export function getVanillaCards() {
+    return irange(FIRST_CARD, MAX_VANILLA_CARD);
+}
+/**
+ * Returns true for cards that have the following card type:
+ * - CardType.TAROT
+ * - CardType.SUIT
+ * - CardType.SPECIAL
+ * - CardType.TAROT_REVERSE
+ */
+export function isCard(card) {
+    return CARD_SET.has(card);
+}
+/** Returns whether or not the given card matches the specified card type. */
+export function isCardType(card, cardType) {
+    return cardType === getCardType(card);
+}
+/** Returns true for cards that have `CardType.MODDED`. */
+export function isModdedCard(card) {
+    return isCardType(card, ItemConfigCardType.MODDED);
+}
+/** Returns true for cards that have `CardType.SPECIAL_OBJECT`. */
+export function isPocketItemObject(card) {
+    return isCardType(card, ItemConfigCardType.SPECIAL_OBJECT);
+}
+/** Returns true for cards that have `CardType.TAROT_REVERSE`. */
+export function isReverseTarotCard(card) {
+    return isCardType(card, ItemConfigCardType.TAROT_REVERSE);
+}
+/** Returns true for cards that have `CardType.RUNE`. */
+export function isRune(card) {
+    return isCardType(card, ItemConfigCardType.RUNE);
+}
+/** Returns true for cards that have `CardType.SPECIAL`. */
+export function isSpecialCard(card) {
+    return isCardType(card, ItemConfigCardType.SPECIAL);
+}
+/** Returns true for cards that have `CardType.SUIT`. */
+export function isSuitCard(card) {
+    return isCardType(card, ItemConfigCardType.SUIT);
+}
+/** Returns true for cards that have `CardType.TAROT`. */
+export function isTarotCard(card) {
+    return isCardType(card, ItemConfigCardType.TAROT);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/challenges.js

@@ -0,0 +1,9 @@
+import { CHALLENGE_NAMES, DEFAULT_CHALLENGE_NAME, } from "../objects/challengeNames";
+/** Get the proper name for a `Challenge` enum. This will only work for vanilla challenges. */
+export function getChallengeName(challenge) {
+    const challengeName = CHALLENGE_NAMES[challenge];
+    // Handle modded challenges.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return challengeName === undefined ? DEFAULT_CHALLENGE_NAME : challengeName;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbGxlbmdlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2lzYWFjc2NyaXB0LWNvbW1vbi9zcmMvZnVuY3Rpb25zL2NoYWxsZW5nZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLGVBQWUsRUFDZixzQkFBc0IsR0FDdkIsTUFBTSwyQkFBMkIsQ0FBQztBQUVuQyw4RkFBOEY7QUFDOUYsTUFBTSxVQUFVLGdCQUFnQixDQUFDLFNBQW9CO0lBQ25ELE1BQU0sYUFBYSxHQUFHLGVBQWUsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNqRCw0QkFBNEI7SUFDNUIsdUVBQXVFO0lBQ3ZFLE9BQU8sYUFBYSxLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsc0JBQXNCLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQztBQUM5RSxDQUFDIn0=

package/functions/character.js

@@ -0,0 +1,102 @@
+import { PlayerType } from "isaac-typescript-definitions";
+import { LAST_VANILLA_CHARACTER } from "../constantsFirstLast";
+import { CHARACTER_NAMES } from "../objects/characterNames";
+import { CHARACTERS_THAT_START_WITH_AN_ACTIVE_ITEM_SET } from "../sets/charactersThatStartWithAnActiveItemSet";
+import { CHARACTERS_WITH_BLACK_HEART_FROM_ETERNAL_HEART_SET } from "../sets/charactersWithBlackHeartFromEternalHeartSet";
+import { CHARACTERS_WITH_FREE_DEVIL_DEALS_SET } from "../sets/charactersWithFreeDevilDealsSet";
+import { CHARACTERS_WITH_NO_RED_HEARTS_SET } from "../sets/charactersWithNoRedHeartsSet";
+import { CHARACTERS_WITH_NO_SOUL_HEARTS_SET } from "../sets/charactersWithNoSoulHeartsSet";
+import { LOST_STYLE_CHARACTERS_SET } from "../sets/lostStyleCharactersSet";
+/**
+ * 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.
+ */
+export function characterCanHaveRedHearts(character) {
+    return !CHARACTERS_WITH_NO_RED_HEARTS_SET.has(character);
+}
+/**
+ * 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.
+ */
+export function characterCanHaveSoulHearts(character) {
+    return !CHARACTERS_WITH_NO_SOUL_HEARTS_SET.has(character);
+}
+/**
+ * Helper function for determining whether the given character can take free Devil Deals. (e.g. The
+ * Lost, Tainted Lost, etc.)
+ */
+export function characterCanTakeFreeDevilDeals(character) {
+    return CHARACTERS_WITH_FREE_DEVIL_DEALS_SET.has(character);
+}
+/**
+ * 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.
+ */
+export function characterGetsBlackHeartFromEternalHeart(character) {
+    return CHARACTERS_WITH_BLACK_HEART_FROM_ETERNAL_HEART_SET.has(character);
+}
+/**
+ * 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).
+ */
+export function characterStartsWithActiveItem(character) {
+    return CHARACTERS_THAT_START_WITH_AN_ACTIVE_ITEM_SET.has(character);
+}
+/**
+ * - 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).
+ */
+export function getCharacterDeathAnimationName(character) {
+    if (LOST_STYLE_CHARACTERS_SET.has(character)) {
+        return "LostDeath";
+    }
+    if (character === PlayerType.THE_FORGOTTEN_B) {
+        return "ForgottenDeath";
+    }
+    return "Death";
+}
+/**
+ * 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.
+ */
+export function getCharacterMaxHeartContainers(character) {
+    // 14
+    if (character === PlayerType.KEEPER) {
+        return 3;
+    }
+    // 16
+    if (character === PlayerType.THE_FORGOTTEN) {
+        return 6;
+    }
+    // 17
+    if (character === PlayerType.THE_SOUL) {
+        return 6;
+    }
+    // 33
+    if (character === PlayerType.KEEPER_B) {
+        return 2;
+    }
+    return 12;
+}
+/** Helper function to get the name of a character. Returns "Unknown" for modded characters. */
+export function getCharacterName(character) {
+    if (isModdedCharacter(character)) {
+        return "Unknown";
+    }
+    return CHARACTER_NAMES[character];
+}
+export function isModdedCharacter(character) {
+    return !isVanillaCharacter(character);
+}
+export function isVanillaCharacter(character) {
+    return character <= LAST_VANILLA_CHARACTER;
+}
+//# sourceMappingURL=data:application/json;base64,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