isaacscript-common 8.9.0 → 9.0.1

package/src/functions/cards.ts

@@ -1,40 +1,52 @@
-import { Card, ItemConfigCardType } from "isaac-typescript-definitions";
+import { CardType, ItemConfigCardType } from "isaac-typescript-definitions";
 import { itemConfig } from "../core/cachedClasses";
-import { FIRST_CARD, LAST_VANILLA_CARD } from "../core/constantsFirstLast";
+import {
+  FIRST_CARD_TYPE,
+  LAST_VANILLA_CARD_TYPE,
+} from "../core/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 {
+  CARD_TYPE_TO_ITEM_CONFIG_CARD_TYPE,
+  DEFAULT_CARD_TYPE,
+} from "../objects/cardTypeToItemConfigCardType";
 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<ItemConfigCardType, Set<Card>>();
+const ITEM_CONFIG_CARD_TYPE_TO_CARD_TYPE_MAP = new Map<
+  ItemConfigCardType,
+  Set<CardType>
+>();
 
 /**
- * Contains all of the entries in the `Card` enum with the following types:
+ * Contains all of the entries in the `CardType` enum with the following types:
  * - ItemConfigCardType.TAROT
  * - ItemConfigCardType.SUIT
  * - ItemConfigCardType.SPECIAL
  * - ItemConfigCardType.TAROT_REVERSE
  */
-const CARD_SET = new Set<Card>();
+const CARD_SET = new Set<CardType>();
 
 function lazyInitCardMapsSets() {
   // 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<Card>());
+    ITEM_CONFIG_CARD_TYPE_TO_CARD_TYPE_MAP.set(cardType, new Set<CardType>());
   }
 
-  for (const card of getVanillaCards()) {
-    const cardType = getCardType(card);
-    const cardTypeSet = CARD_TYPE_TO_CARDS_MAP.get(cardType);
+  for (const card of getVanillaCardTypes()) {
+    const itemConfigCardType = getItemConfigCardType(card);
+    const cardTypeSet =
+      ITEM_CONFIG_CARD_TYPE_TO_CARD_TYPE_MAP.get(itemConfigCardType);
     if (cardTypeSet === undefined) {
-      error(`Failed to get the card set for card type: ${cardType}`);
+      error(
+        `Failed to get the card set for item config card type: ${itemConfigCardType}`,
+      );
     }
     cardTypeSet.add(card);
   }
@@ -43,7 +55,7 @@ function lazyInitCardMapsSets() {
   // - ItemConfigCardType.RUNE
   // - ItemConfigCardType.SPECIAL_OBJECT
   // - ItemConfigCardType.MODDED
-  const cards = getCardsOfType(
+  const cards = getCardTypesOfType(
     ItemConfigCardType.TAROT,
     ItemConfigCardType.SUIT,
     ItemConfigCardType.SPECIAL,
@@ -55,23 +67,19 @@ function lazyInitCardMapsSets() {
 /**
  * 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"
- * ```
+ * For example, `getCardDescription(card)` returns "Where journey begins".
  */
-export function getCardDescription(card: Card): string {
+export function getCardDescription(cardType: CardType): string {
   // "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];
+  const cardDescription = CARD_DESCRIPTIONS[cardType];
+  // Handle modded cards.
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (cardDescription !== undefined) {
     return cardDescription;
   }
 
-  const itemConfigCard = itemConfig.GetCard(card);
+  const itemConfigCard = itemConfig.GetCard(cardType);
   if (itemConfigCard !== undefined) {
     return itemConfigCard.Description;
   }
@@ -82,23 +90,19 @@ export function getCardDescription(card: Card): string {
 /**
  * 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"
- * ```
+ * For example, `getCardName(Card.FOOL)` would return "0 - The Fool".
  */
-export function getCardName(card: Card): string {
+export function getCardName(cardType: CardType): string {
   // "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];
+  const cardName = CARD_NAMES[cardType];
+  // Handle modded cards.
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (cardName !== undefined) {
     return cardName;
   }
 
-  const itemConfigCard = itemConfig.GetCard(card);
+  const itemConfigCard = itemConfig.GetCard(cardType);
   if (itemConfigCard !== undefined) {
     return itemConfigCard.Name;
   }
@@ -106,37 +110,45 @@ export function getCardName(card: Card): string {
   return DEFAULT_CARD_NAME;
 }
 
-export function getCardType(card: Card): ItemConfigCardType {
-  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.
+ * Helper function to get a set of card types matching the `ItemConfigCardType`.
  *
  * 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: ItemConfigCardType[]): Set<Card> {
-  if (CARD_TYPE_TO_CARDS_MAP.size === 0) {
+export function getCardTypesOfType(
+  ...itemConfigCardTypes: ItemConfigCardType[]
+): Set<CardType> {
+  if (ITEM_CONFIG_CARD_TYPE_TO_CARD_TYPE_MAP.size === 0) {
     lazyInitCardMapsSets();
   }
 
-  const matchingCards = new Set<Card>();
-  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}`);
+  const matchingCardTypes = new Set<CardType>();
+  for (const itemConfigCardType of itemConfigCardTypes) {
+    const cardTypeSet =
+      ITEM_CONFIG_CARD_TYPE_TO_CARD_TYPE_MAP.get(itemConfigCardType);
+    if (cardTypeSet === undefined) {
+      error(
+        `Failed to get the card type set for item config type: ${itemConfigCardType}`,
+      );
     }
 
-    for (const card of cardSet.values()) {
-      matchingCards.add(card);
+    for (const cardType of cardTypeSet.values()) {
+      matchingCardTypes.add(cardType);
     }
   }
 
-  return matchingCards;
+  return matchingCardTypes;
+}
+
+export function getItemConfigCardType(cardType: CardType): ItemConfigCardType {
+  const itemConfigCardType = CARD_TYPE_TO_ITEM_CONFIG_CARD_TYPE[cardType];
+
+  // Handle modded cards.
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  return itemConfigCardType === undefined
+    ? DEFAULT_CARD_TYPE
+    : itemConfigCardType;
 }
 
 /**
@@ -154,24 +166,25 @@ export function getCardsOfType(...cardTypes: ItemConfigCardType[]): Set<Card> {
  */
 export function getRandomCard(
   seedOrRNG: Seed | RNG = getRandomSeed(),
-  exceptions: Card[] = [],
-): Card {
+  exceptions: CardType[] = [],
+): CardType {
   return getRandomSetElement(CARD_SET, seedOrRNG, exceptions);
 }
 
 /**
- * @param cardType The card type that represents the pool of cards to select from.
+ * @param itemConfigCardType The item config 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: ItemConfigCardType,
+export function getRandomCardTypeOfType(
+  itemConfigCardType: ItemConfigCardType,
   seedOrRNG: Seed | RNG = getRandomSeed(),
-  exceptions: Card[] = [],
-): Card {
-  const cardSet = getCardsOfType(cardType);
-  return getRandomSetElement(cardSet, seedOrRNG, exceptions);
+  exceptions: CardType[] = [],
+): CardType {
+  const cardTypeSet = getCardTypesOfType(itemConfigCardType);
+  return getRandomSetElement(cardTypeSet, seedOrRNG, exceptions);
 }
 
 /**
@@ -184,16 +197,16 @@ export function getRandomCardOfType(
  */
 export function getRandomRune(
   seedOrRNG: Seed | RNG = getRandomSeed(),
-  exceptions: Card[] = [],
-): Card {
-  const runesSet = getCardsOfType(ItemConfigCardType.RUNE);
-  runesSet.delete(Card.RUNE_SHARD);
+  exceptions: CardType[] = [],
+): CardType {
+  const runesSet = getCardTypesOfType(ItemConfigCardType.RUNE);
+  runesSet.delete(CardType.RUNE_SHARD);
   return getRandomSetElement(runesSet, seedOrRNG, exceptions);
 }
 
 /** Helper function to get an array with every valid vanilla card sub-type. */
-export function getVanillaCards(): Card[] {
-  return irange(FIRST_CARD, LAST_VANILLA_CARD);
+export function getVanillaCardTypes(): CardType[] {
+  return irange(FIRST_CARD_TYPE, LAST_VANILLA_CARD_TYPE);
 }
 
 /**
@@ -203,51 +216,54 @@ export function getVanillaCards(): Card[] {
  * - CardType.SPECIAL
  * - CardType.TAROT_REVERSE
  */
-export function isCard(card: Card): boolean {
-  return CARD_SET.has(card);
+export function isCard(cardType: CardType): boolean {
+  return CARD_SET.has(cardType);
 }
 
-/** Returns whether or not the given card matches the specified card type. */
-export function isCardType(card: Card, cardType: ItemConfigCardType): boolean {
-  return cardType === getCardType(card);
+/** Returns whether or not the given card type matches the specified item config card type. */
+export function isCardType(
+  cardType: CardType,
+  itemConfigCardType: ItemConfigCardType,
+): boolean {
+  return itemConfigCardType === getItemConfigCardType(cardType);
 }
 
 /** Returns true for any card or rune added by a mod. */
-export function isModdedCard(card: Card): boolean {
-  return !isVanillaCard(card);
+export function isModdedCardType(cardType: CardType): boolean {
+  return !isVanillaCardType(cardType);
 }
 
-/** Returns true for cards that have `CardType.SPECIAL_OBJECT`. */
-export function isPocketItemObject(card: Card): boolean {
-  return isCardType(card, ItemConfigCardType.SPECIAL_OBJECT);
+/** Returns true for cards that have `ItemConfigCardType.SPECIAL_OBJECT`. */
+export function isPocketItemObject(cardType: CardType): boolean {
+  return isCardType(cardType, ItemConfigCardType.SPECIAL_OBJECT);
 }
 
-/** Returns true for cards that have `CardType.TAROT_REVERSE`. */
-export function isReverseTarotCard(card: Card): boolean {
-  return isCardType(card, ItemConfigCardType.TAROT_REVERSE);
+/** Returns true for cards that have `ItemConfigCardType.TAROT_REVERSE`. */
+export function isReverseTarotCard(cardType: CardType): boolean {
+  return isCardType(cardType, ItemConfigCardType.TAROT_REVERSE);
 }
 
 /** Returns true for cards that have `CardType.RUNE`. */
-export function isRune(card: Card): boolean {
-  return isCardType(card, ItemConfigCardType.RUNE);
+export function isRune(cardType: CardType): boolean {
+  return isCardType(cardType, ItemConfigCardType.RUNE);
 }
 
 /** Returns true for cards that have `CardType.SPECIAL`. */
-export function isSpecialCard(card: Card): boolean {
-  return isCardType(card, ItemConfigCardType.SPECIAL);
+export function isSpecialCard(cardType: CardType): boolean {
+  return isCardType(cardType, ItemConfigCardType.SPECIAL);
 }
 
 /** Returns true for cards that have `CardType.SUIT`. */
-export function isSuitCard(card: Card): boolean {
-  return isCardType(card, ItemConfigCardType.SUIT);
+export function isSuitCard(cardType: CardType): boolean {
+  return isCardType(cardType, ItemConfigCardType.SUIT);
 }
 
 /** Returns true for cards that have `CardType.TAROT`. */
-export function isTarotCard(card: Card): boolean {
-  return isCardType(card, ItemConfigCardType.TAROT);
+export function isTarotCard(cardType: CardType): boolean {
+  return isCardType(cardType, ItemConfigCardType.TAROT);
 }
 
 /** Returns true for any vanilla card or rune. */
-export function isVanillaCard(card: Card): boolean {
-  return card <= LAST_VANILLA_CARD;
+export function isVanillaCardType(cardType: CardType): boolean {
+  return cardType <= LAST_VANILLA_CARD_TYPE;
 }

package/src/functions/collectibleCacheFlag.ts

@@ -64,7 +64,7 @@ export function getCollectiblesForCacheFlag(
 
 /**
  * Returns an array containing every collectible type that the player has that matches the provided
- * CacheFlag.
+ * `CacheFlag`.
  *
  * For example, if the cache flag is `CacheFlag.FLYING`, and the player has one Lord of the Pit and
  * two Dead Doves, then this function would return:
@@ -77,6 +77,9 @@ export function getCollectiblesForCacheFlag(
  * ]
  * ```
  *
+ * Note that this array will not include collectibles that the player does not really have, like
+ * Lilith's Incubus.
+ *
  * This function can only be called if at least one callback has been executed. This is because not
  * all collectibles will necessarily be present when a mod first loads (due to mod load order).
  */
@@ -88,7 +91,8 @@ export function getPlayerCollectiblesForCacheFlag(
 
   const playerCollectibles: CollectibleType[] = [];
   for (const collectibleType of getSortedSetValues(collectiblesForCacheFlag)) {
-    const numCollectibles = player.GetCollectibleNum(collectibleType);
+    // We specify "true" as the second argument to filter out things like Lilith's Incubus.
+    const numCollectibles = player.GetCollectibleNum(collectibleType, true);
     repeat(numCollectibles, () => {
       playerCollectibles.push(collectibleType);
     });

package/src/functions/collectibles.ts

@@ -303,12 +303,7 @@ export function getCollectibleMaxCharges(
  * Helper function to get the name of a collectible. Returns "Unknown" if the provided collectible
  * type is not valid.
  *
- * For example:
- *
- * ```ts
- * const collectibleType = CollectibleType.SAD_ONION;
- * const collectibleName = getCollectibleName(collectibleType); // collectibleName is "Sad Onion"
- * ```
+ * For example, `getCollectibleName(CollectibleType.SAD_ONION)` would return "Sad Onion".
  */
 export function getCollectibleName(collectibleType: CollectibleType): string {
   // "ItemConfigItem.Name" is bugged with vanilla items on patch v1.7.6, so we use a hard-coded map

package/src/functions/familiars.ts

@@ -82,6 +82,7 @@ export function checkFamiliarFromCollectibles(
   familiarVariant: FamiliarVariant,
   familiarSubType?: int,
 ): void {
+  // We need to include non-real collectibles, like Lilith's Incubus.
   const numCollectibles = player.GetCollectibleNum(collectibleType);
   const effects = player.GetEffects();
 

package/src/functions/itemPool.ts

@@ -128,13 +128,12 @@ function removeItemsAndTrinketsThatAffectItemPools(): [
   for (const player of getPlayers()) {
     const removedItems: CollectibleType[] = [];
     for (const itemToRemove of COLLECTIBLES_THAT_AFFECT_ITEM_POOLS) {
-      if (player.HasCollectible(itemToRemove)) {
-        const numCollectibles = player.GetCollectibleNum(itemToRemove);
-        repeat(numCollectibles, () => {
-          player.RemoveCollectible(itemToRemove);
-          removedItems.push(itemToRemove);
-        });
-      }
+      // We need to include non-real collectibles, like Lilith's Incubus.
+      const numCollectibles = player.GetCollectibleNum(itemToRemove);
+      repeat(numCollectibles, () => {
+        player.RemoveCollectible(itemToRemove);
+        removedItems.push(itemToRemove);
+      });
     }
 
     mapSetPlayer(removedItemsMap, player, removedItems);

package/src/functions/pickupsSpecific.ts

@@ -1,7 +1,7 @@
 import {
   BatterySubType,
   BombSubType,
-  Card,
+  CardType,
   CoinSubType,
   CollectibleType,
   HeartSubType,
@@ -45,11 +45,11 @@ export function getBombPickups(
 /**
  * Helper function to get all of the card entities in the room.
  *
- * @param card Optional. If specified, will only get the cards that match the sub-type. Default is
- *             -1, which matches every sub-type.
+ * @param cardType Optional. If specified, will only get the cards that match the sub-type. Default
+ *                 is -1, which matches every sub-type.
  */
-export function getCards(card: Card = -1): EntityPickupCard[] {
-  return getPickups(PickupVariant.TAROT_CARD, card) as EntityPickupCard[];
+export function getCards(cardType: CardType = -1): EntityPickupCard[] {
+  return getPickups(PickupVariant.TAROT_CARD, cardType) as EntityPickupCard[];
 }
 
 /**
@@ -176,15 +176,18 @@ export function removeAllBombPickups(
 /**
  * Helper function to remove all of the cards in the room.
  *
- * @param card Optional. If specified, will only remove cards that match this sub-type. Default is
- *             -1, which matches every sub-type.
+ * @param cardType Optional. If specified, will only remove cards that match this sub-type. Default
+ *                 is -1, which matches every sub-type.
  * @param cap Optional. If specified, will only remove the given amount of cards.
  * @returns The cards that were removed.
  */
-export function removeAllCards(card: Card = -1, cap?: int): EntityPickupCard[] {
+export function removeAllCards(
+  cardType: CardType = -1,
+  cap?: int,
+): EntityPickupCard[] {
   return removeAllPickups(
     PickupVariant.TAROT_CARD,
-    card,
+    cardType,
     cap,
   ) as EntityPickupCard[];
 }
@@ -392,7 +395,7 @@ export function spawnBombPickupWithSeed(
  * Helper function to spawn a `EntityType.PICKUP` (5) with variant `PickupVariant.TAROT_CARD` (300).
  */
 export function spawnCard(
-  card: Card,
+  cardType: CardType,
   position: Vector,
   velocity: Vector = VectorZero,
   spawner: Entity | undefined = undefined,
@@ -400,7 +403,7 @@ export function spawnCard(
 ): EntityPickupCard {
   return spawnPickup(
     PickupVariant.TAROT_CARD,
-    card,
+    cardType,
     position,
     velocity,
     spawner,
@@ -413,13 +416,13 @@ export function spawnCard(
  * and a specific seed.
  */
 export function spawnCardWithSeed(
-  card: Card,
+  cardType: CardType,
   position: Vector,
   seedOrRNG: Seed | RNG,
   velocity: Vector = VectorZero,
   spawner: Entity | undefined = undefined,
 ): EntityPickupCard {
-  return spawnCard(card, position, velocity, spawner, seedOrRNG);
+  return spawnCard(cardType, position, velocity, spawner, seedOrRNG);
 }
 
 /** Helper function to spawn a `EntityType.PICKUP` (5) with variant `PickupVariant.COIN` (20). */

package/src/functions/pills.ts

@@ -128,12 +128,7 @@ export function getPillEffectClass(
 /**
  * Helper function to get a pill effect name from a PillEffect enum value.
  *
- * For example:
- *
- * ```ts
- * const pillEffect = PillEffect.BAD_GAS;
- * const pillEffectName = getPillEffectName(pillEffect); // trinketName is "Bad Gas"
- * ```
+ * For example, `getPillEffectName(PillEffect.BAD_GAS)` would return "Bad Gas".
  */
 export function getPillEffectName(pillEffect: PillEffect): string {
   // `ItemConfigPillEffect.Name` is bugged with vanilla pill effects on patch v1.7.6, so we use a

package/src/functions/players.ts

@@ -223,6 +223,8 @@ export function getPlayerCloserThan(
  * collectible type(s) provided.
  *
  * This function is variadic, meaning that you can specify N collectible types.
+ *
+ * Note that this will filter out non-real collectibles like Lilith's Incubus.
  */
 export function getPlayerCollectibleCount(
   player: EntityPlayer,
@@ -230,6 +232,8 @@ export function getPlayerCollectibleCount(
 ): int {
   let numCollectibles = 0;
   for (const collectibleType of collectibleTypes) {
+    // We need to specify "true" as the second argument here to filter out things like Lilith's
+    // Incubus.
     numCollectibles += player.GetCollectibleNum(collectibleType, true);
   }
 
@@ -239,6 +243,8 @@ export function getPlayerCollectibleCount(
 /**
  * Iterates over every item in the game and returns a map containing the number of each item that
  * the player has.
+ *
+ * Note that this will filter out non-real collectibles like Lilith's Incubus.
  */
 export function getPlayerCollectibleMap(
   player: EntityPlayer,
@@ -247,6 +253,8 @@ export function getPlayerCollectibleMap(
 
   const collectibleMap = new Map<CollectibleType, int>();
   for (const collectibleType of collectibleArray) {
+    // We need to specify "true" as the second argument here to filter out things like Lilith's
+    // Incubus.
     const collectibleNum = player.GetCollectibleNum(collectibleType, true);
     if (collectibleNum > 0) {
       collectibleMap.set(collectibleType, collectibleNum);
@@ -374,14 +382,19 @@ export function getPlayersWithTrinket(
 /**
  * Returns the total number of collectibles amongst all players. For example, if player 1 has 1 Sad
  * Onion and player 2 has 2 Sad Onions, then this function would return 3.
+ *
+ * Note that this will filter out non-real collectibles like Lilith's Incubus.
  */
 export function getTotalPlayerCollectibles(
   collectibleType: CollectibleType,
 ): int {
   const players = getPlayers();
   const numCollectiblesArray = players.map((player) =>
-    player.GetCollectibleNum(collectibleType),
+    // We need to specify "true" as the second argument here to filter out things like Lilith's
+    // Incubus.
+    player.GetCollectibleNum(collectibleType, true),
   );
+
   return sumArray(numCollectiblesArray);
 }
 

package/src/functions/pocketItems.ts

@@ -1,6 +1,6 @@
 import {
   ActiveSlot,
-  Card,
+  CardType,
   CollectibleType,
   PillColor,
   PlayerType,
@@ -64,14 +64,14 @@ export function getPocketItems(player: EntityPlayer): PocketItemDescription[] {
   let pocketItemIdentified = false;
   let pocketItem2Identified = false;
   for (const slot of pocketItemSlots) {
-    const card = player.GetCard(slot);
+    const cardType = player.GetCard(slot);
     const pillColor = player.GetPill(slot);
 
-    if (card !== Card.NULL) {
+    if (cardType !== CardType.NULL) {
       pocketItems.push({
         slot,
         type: PocketItemType.CARD,
-        subType: card,
+        subType: cardType,
       });
     } else if (pillColor !== PillColor.NULL) {
       pocketItems.push({

package/src/functions/rockAlt.ts

@@ -1,5 +1,5 @@
 import {
-  Card,
+  CardType,
   CoinSubType,
   CollectibleType,
   EffectVariant,
@@ -278,7 +278,7 @@ function spawnRockAltRewardSkull(position: Vector, rng: RNG): boolean {
 
   totalChance += ROCK_ALT_CHANCES.BASIC_DROP;
   if (chance < totalChance) {
-    spawnCardWithSeed(Card.NULL, position, rng);
+    spawnCardWithSeed(CardType.NULL, position, rng);
     return true;
   }
 

package/src/functions/trinkets.ts

@@ -118,12 +118,7 @@ export function getTrinketGfxFilename(trinketType: TrinketType): string {
  * Helper function to get the name of a trinket. Returns "Unknown" if the provided trinket type is
  * not valid.
  *
- * For example:
- *
- * ```ts
- * const trinketType = TrinketType.SWALLOWED_PENNY;
- * const trinketName = getTrinketName(trinketType); // trinketName is "Swallowed Penny"
- * ```
+ * For example, `getTrinketName(TrinketType.SWALLOWED_PENNY)` would return "Swallowed Penny".
  */
 export function getTrinketName(trinketType: TrinketType): string {
   // "ItemConfigItem.Name" is bugged with vanilla items on patch v1.7.6, so we use a hard-coded map

package/src/functions/types.ts

@@ -1,5 +1,5 @@
 import {
-  Card,
+  CardType,
   CollectibleType,
   LevelStage,
   NpcState,
@@ -10,12 +10,12 @@ import {
 } from "isaac-typescript-definitions";
 
 /**
- * Helper function to safely cast a `number` to a `Card`. (This is better than using the `as`
+ * Helper function to safely cast a `number` to a `CardType`. (This is better than using the `as`
  * TypeScript keyword to do a type assertion, since that can obfuscate compiler errors. )
  *
  * This is useful to satisfy the "isaacscript/strict-enums" ESLint rule.
  */
-export function asCard(num: number): Card {
+export function asCardType(num: number): CardType {
   return num;
 }