isaacscript-common 8.9.1 → 9.0.0

package/src/features/extraConsoleCommands/listCommands.ts

@@ -24,7 +24,7 @@
 import {
   ActiveSlot,
   CacheFlag,
-  Card,
+  CardType,
   Challenge,
   CollectibleType,
   Direction,
@@ -43,7 +43,7 @@ import {
 import { game, sfxManager } from "../../core/cachedClasses";
 import { MAX_LEVEL_GRID_INDEX } from "../../core/constants";
 import {
-  FIRST_CARD,
+  FIRST_CARD_TYPE,
   FIRST_CHARACTER,
   FIRST_PILL_EFFECT,
   FIRST_ROOM_TYPE,
@@ -88,13 +88,13 @@ import { gridCoordinatesToWorldPosition } from "../../functions/roomGrid";
 import { changeRoom } from "../../functions/rooms";
 import { onSetSeed, restart, setUnseeded } from "../../functions/run";
 import { getGoldenTrinketType } from "../../functions/trinkets";
-import { asCard } from "../../functions/types";
+import { asCardType } from "../../functions/types";
 import { irange, printConsole, printEnabled } from "../../functions/utils";
 import { CARD_MAP } from "../../maps/cardMap";
 import { CHARACTER_MAP } from "../../maps/characterMap";
 import { PILL_EFFECT_MAP } from "../../maps/pillEffectMap";
 import { ROOM_TYPE_MAP } from "../../maps/roomTypeMap";
-import { getLastCard, getLastPillEffect } from "../firstLast";
+import { getLastCardType, getLastPillEffect } from "../firstLast";
 import {
   addHeart,
   devilAngel,
@@ -326,8 +326,8 @@ export function card(params: string): void {
     return;
   }
 
-  let cardNum: Card;
-  const num = tonumber(params) as Card | undefined;
+  let cardType: CardType;
+  const num = tonumber(params) as CardType | undefined;
   if (num === undefined) {
     const match = getMapPartialMatch(params, CARD_MAP);
     if (match === undefined) {
@@ -335,35 +335,35 @@ export function card(params: string): void {
       return;
     }
 
-    cardNum = match[1];
+    cardType = match[1];
   } else {
-    const lastCard = getLastCard();
-    if (num < FIRST_CARD || num > lastCard) {
+    const lastCardType = getLastCardType();
+    if (num < FIRST_CARD_TYPE || num > lastCardType) {
       printConsole(`Invalid card sub-type: ${num}`);
       return;
     }
 
-    cardNum = num;
+    cardType = num;
   }
 
-  const cardName = getCardName(cardNum);
-  Isaac.ExecuteCommand(`g k${cardNum}`);
-  printConsole(`Gave card: ${cardName} (${cardNum})`);
+  const cardName = getCardName(cardType);
+  Isaac.ExecuteCommand(`g k${cardType}`);
+  printConsole(`Gave card: ${cardName} (${cardType})`);
 }
 
 /** Spawns every card on the ground, starting at the top-left-most tile. */
 export function cards(): void {
-  const lastCard = getLastCard();
+  const lastCardType = getLastCardType();
 
   let cardType = 1;
   for (let y = 0; y <= 6; y++) {
     for (let x = 0; x <= 12; x++) {
-      if (asCard(cardType) === lastCard) {
+      if (asCardType(cardType) === lastCardType) {
         return;
       }
 
       const position = gridCoordinatesToWorldPosition(x, y);
-      spawnCard(asCard(cardType), position);
+      spawnCard(asCardType(cardType), position);
       cardType++;
     }
   }

package/src/features/firstLast.ts

@@ -1,5 +1,5 @@
 import {
-  Card,
+  CardType,
   CollectibleType,
   PillEffect,
   TrinketType,
@@ -7,14 +7,14 @@ import {
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { itemConfig } from "../core/cachedClasses";
 import {
-  FIRST_CARD,
+  FIRST_CARD_TYPE,
   FIRST_PILL_EFFECT,
   FIRST_TRINKET_TYPE,
-  LAST_VANILLA_CARD,
+  LAST_VANILLA_CARD_TYPE,
   LAST_VANILLA_COLLECTIBLE_TYPE,
   LAST_VANILLA_PILL_EFFECT,
   LAST_VANILLA_TRINKET_TYPE,
-  NUM_VANILLA_CARDS,
+  NUM_VANILLA_CARD_TYPES,
   NUM_VANILLA_COLLECTIBLE_TYPES,
   NUM_VANILLA_PILL_EFFECTS,
   NUM_VANILLA_TRINKET_TYPES,
@@ -22,7 +22,7 @@ import {
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
 import {
-  asCard,
+  asCardType,
   asCollectibleType,
   asNumber,
   asPillEffect,
@@ -168,7 +168,7 @@ export function getFirstModdedTrinketType(): TrinketType | undefined {
 }
 
 /**
- * Will change depending on how many modded cards there are.
+ * Will change depending on how many modded trinkets there are.
  *
  * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
  * collectibles).
@@ -206,7 +206,7 @@ export function getModdedTrinketTypes(): TrinketType[] {
 }
 
 /**
- * Will change depending on how many modded cards there are.
+ * Will change depending on how many modded trinkets there are.
  *
  * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
  * `TrinketType.NULL`.)
@@ -254,9 +254,9 @@ export function getTrinketTypes(): TrinketType[] {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getAllCards(): Card[] {
-  const lastCard = getLastCard();
-  return irange(FIRST_CARD, lastCard);
+export function getAllCardTypes(): CardType[] {
+  const lastCardType = getLastCardType();
+  return irange(FIRST_CARD_TYPE, lastCardType);
 }
 
 /**
@@ -265,13 +265,13 @@ export function getAllCards(): Card[] {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getFirstModdedCard(): Card | undefined {
+export function getFirstModdedCardType(): CardType | undefined {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
-  const firstModdedCard = asCard(asNumber(LAST_VANILLA_CARD) + 1);
-  const itemConfigCard = itemConfig.GetCard(firstModdedCard);
-  return itemConfigCard === undefined ? undefined : firstModdedCard;
+  const firstModdedCardType = asCardType(asNumber(LAST_VANILLA_CARD_TYPE) + 1);
+  const itemConfigCard = itemConfig.GetCard(firstModdedCardType);
+  return itemConfigCard === undefined ? undefined : firstModdedCardType;
 }
 
 /**
@@ -283,12 +283,12 @@ export function getFirstModdedCard(): Card | undefined {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getLastCard(): Card {
+export function getLastCardType(): CardType {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
-  const numCards = getNumCards();
-  return asCard(numCards);
+  const numCards = getNumCardTypes();
+  return asCardType(numCards);
 }
 
 /**
@@ -299,14 +299,14 @@ export function getLastCard(): Card {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getModdedCards(): Card[] {
-  const firstModdedCard = getFirstModdedCard();
-  if (firstModdedCard === undefined) {
+export function getModdedCardTypes(): CardType[] {
+  const firstModdedCardType = getFirstModdedCardType();
+  if (firstModdedCardType === undefined) {
     return [];
   }
 
-  const lastCard = getLastCard();
-  return irange(firstModdedCard, lastCard);
+  const lastCardType = getLastCardType();
+  return irange(firstModdedCardType, lastCardType);
 }
 
 /**
@@ -317,7 +317,7 @@ export function getModdedCards(): Card[] {
  * This function can only be called if at least one callback has been executed. This is because not
  * all cards will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getNumCards(): int {
+export function getNumCardTypes(): int {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
@@ -328,12 +328,12 @@ export function getNumCards(): int {
  * This function can only be called if at least one callback has been executed. This is because not
  * all trinkets will necessarily be present when a mod first loads (due to mod load order).
  */
-export function getNumModdedCards(): int {
+export function getNumModdedCardTypes(): int {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
   errorIfNoCallbacksFired("card");
 
-  const numCards = getNumCards();
-  return numCards - NUM_VANILLA_CARDS;
+  const numCardTypes = getNumCardTypes();
+  return numCardTypes - NUM_VANILLA_CARD_TYPES;
 }
 
 // ------------

package/src/features/preventCollectibleRotation.ts

@@ -2,7 +2,7 @@
 // switching mechanic.
 
 import {
-  Card,
+  CardType,
   CollectibleType,
   ModCallback,
   PickupVariant,
@@ -39,7 +39,7 @@ export function preventCollectibleRotationInit(mod: Mod): void {
   mod.AddCallback(
     ModCallback.POST_USE_CARD,
     useCardSoulOfIsaac,
-    Card.SOUL_ISAAC,
+    CardType.SOUL_ISAAC,
   ); // 5
 
   mod.AddCallback(

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,18 @@ 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];
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  const cardDescription = CARD_DESCRIPTIONS[cardType];
+
   if (cardDescription !== undefined) {
     return cardDescription;
   }
 
-  const itemConfigCard = itemConfig.GetCard(card);
+  const itemConfigCard = itemConfig.GetCard(cardType);
   if (itemConfigCard !== undefined) {
     return itemConfigCard.Description;
   }
@@ -82,23 +89,18 @@ 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];
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  const cardName = CARD_NAMES[cardType];
+
   if (cardName !== undefined) {
     return cardName;
   }
 
-  const itemConfigCard = itemConfig.GetCard(card);
+  const itemConfigCard = itemConfig.GetCard(cardType);
   if (itemConfigCard !== undefined) {
     return itemConfigCard.Name;
   }
@@ -106,37 +108,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 +164,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 +195,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 +214,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/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/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). */