isaacscript-common 7.17.4 → 8.0.0

package/src/enums/ModCallbackCustom.ts

@@ -353,6 +353,9 @@ export enum ModCallbackCustom {
    * the broken state for the respective grid entity type. (For example, this will fire for a
    * `GridEntityType.ROCK` (2) when its state changes to `RockState.BROKEN` (2).)
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the
+   * `POST_GRID_ENTITY_CUSTOM_BROKEN` callback instead.
+   *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if it matches the `GridEntityType` provided.
    *
@@ -367,6 +370,9 @@ export enum ModCallbackCustom {
    * this, the callback will not continue to fire. It will only fire again once the entity moves out
    * of range and then moves back into range.)
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the
+   * `POST_GRID_ENTITY_CUSTOM_COLLISION` callback instead.
+   *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if it matches the `GridEntityType` provided.
    *
@@ -502,6 +508,9 @@ export enum ModCallbackCustom {
    * - in the `POST_UPDATE` callback (if the entity appeared mid-way through the room, like when the
    *   trapdoor appears after defeating It Lives!)
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the `POST_GRID_ENTITY_CUSTOM_INIT`
+   * callback instead.
+   *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if it matches the `GridEntityType` provided.
    *
@@ -519,6 +528,9 @@ export enum ModCallbackCustom {
    *
    * This will fire when a Polty/Kineti picks up a grid entity.
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the
+   * `POST_GRID_ENTITY_CUSTOM_REMOVE` callback instead.
+   *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if it matches the `GridEntityType` provided.
    *
@@ -539,6 +551,9 @@ export enum ModCallbackCustom {
    * - When registering the callback, takes an optional third argument that will make the callback
    *   only fire if it matches the variant provided.
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the
+   * `POST_GRID_ENTITY_CUSTOM_RENDER` callback instead.
+   *
    * ```ts
    * function postGridEntityRender(gridEntity: GridEntity): void {}
    * ```
@@ -552,6 +567,9 @@ export enum ModCallbackCustom {
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if it matches the `GridEntityType` provided.
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the
+   * `POST_GRID_ENTITY_CUSTOM_STATE_CHANGED` callback instead.
+   *
    * ```ts
    * function postGridEntityStateChanged(
    *   gridEntity: GridEntity,
@@ -570,6 +588,9 @@ export enum ModCallbackCustom {
    * - When registering the callback, takes an optional third argument that will make the callback
    *   only fire if it matches the variant provided.
    *
+   * For grid entities created with `spawnCustomGridEntity`, use the
+   * `POST_GRID_ENTITY_CUSTOM_UPDATE` callback instead.
+   *
    * ```ts
    * function postGridEntityUpdate(gridEntity: GridEntity): void {}
    * ```

package/src/features/characterStats.ts

@@ -10,8 +10,8 @@ import {
   PlayerType,
 } from "isaac-typescript-definitions";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
-import { getDefaultPlayerStat } from "../functions/cacheFlag";
 import { addStat } from "../functions/players";
+import { getDefaultPlayerStat } from "../functions/stats";
 
 const FEATURE_NAME = "characterStats";
 

package/src/features/extraConsoleCommands/listCommands.ts

@@ -47,8 +47,6 @@ import {
   FIRST_PILL_EFFECT,
   FIRST_ROOM_TYPE,
   FIRST_STAGE,
-  LAST_CARD,
-  LAST_PILL_EFFECT,
   LAST_ROOM_TYPE,
   LAST_STAGE,
   LAST_VANILLA_CHARACTER,
@@ -95,6 +93,7 @@ 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 {
   addHeart,
   devilAngel,
@@ -337,7 +336,8 @@ export function card(params: string): void {
 
     cardNum = match[1];
   } else {
-    if (num < FIRST_CARD || num > LAST_CARD) {
+    const lastCard = getLastCard();
+    if (num < FIRST_CARD || num > lastCard) {
       printConsole(`Invalid card sub-type: ${num}`);
       return;
     }
@@ -352,10 +352,12 @@ export function card(params: string): void {
 
 /** Spawns every card on the ground, starting at the top-left-most tile. */
 export function cards(): void {
+  const lastCard = getLastCard();
+
   let cardType = 1;
   for (let y = 0; y <= 6; y++) {
     for (let x = 0; x <= 12; x++) {
-      if (asCard(cardType) === LAST_CARD) {
+      if (asCard(cardType) === lastCard) {
         return;
       }
 
@@ -876,7 +878,8 @@ export function pill(params: string): void {
 
     pillEffect = match[1];
   } else {
-    if (num < FIRST_PILL_EFFECT || num > LAST_PILL_EFFECT) {
+    const lastPillEffect = getLastPillEffect();
+    if (num < FIRST_PILL_EFFECT || num > lastPillEffect) {
       printConsole(`Invalid pill effect ID: ${num}`);
       return;
     }

package/src/features/firstLast.ts

@@ -0,0 +1,429 @@
+import {
+  Card,
+  CollectibleType,
+  PillEffect,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { itemConfig } from "../core/cachedClasses";
+import {
+  FIRST_CARD,
+  FIRST_PILL_EFFECT,
+  FIRST_TRINKET_TYPE,
+  LAST_VANILLA_CARD,
+  LAST_VANILLA_COLLECTIBLE_TYPE,
+  LAST_VANILLA_PILL_EFFECT,
+  LAST_VANILLA_TRINKET_TYPE,
+  NUM_VANILLA_CARDS,
+  NUM_VANILLA_COLLECTIBLE_TYPES,
+  NUM_VANILLA_PILL_EFFECTS,
+  NUM_VANILLA_TRINKET_TYPES,
+} from "../core/constantsFirstLast";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import {
+  asCard,
+  asCollectibleType,
+  asNumber,
+  asPillEffect,
+  asTrinketType,
+} from "../functions/types";
+import { irange } from "../functions/utils";
+
+const FEATURE_NAME = "firstLast";
+
+let atLeastOneCallbackFired = false;
+
+/** @internal */
+export function firstLastInit(mod: ModUpgraded): void {
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_EARLY,
+    postNewRoomEarly,
+  );
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_EARLY
+function postNewRoomEarly() {
+  atLeastOneCallbackFired = true;
+}
+
+function errorIfNoCallbacksFired(constantType: string) {
+  if (!atLeastOneCallbackFired) {
+    error(
+      `Failed to retrieve a ${constantType} constant. Since not all mods have been loaded yet, any constants of this type will be inaccurate. Thus, you must wait until at least one callback fires before retrieving these types of constants.`,
+    );
+  }
+}
+
+// ------------
+// Collectibles
+// ------------
+
+/**
+ * Returns the first modded collectible type, or undefined if there are no modded collectibles.
+ *
+ * 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).
+ */
+export function getFirstModdedCollectibleType(): CollectibleType | undefined {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("collectible");
+
+  const firstModdedCollectibleType = asCollectibleType(
+    asNumber(LAST_VANILLA_COLLECTIBLE_TYPE) + 1,
+  );
+  const itemConfigItem = itemConfig.GetCollectible(firstModdedCollectibleType);
+  return itemConfigItem === undefined ? undefined : firstModdedCollectibleType;
+}
+
+/**
+ * Will change depending on how many modded collectibles there are.
+ *
+ * Equal to `itemConfig.GetCollectibles().Size - 1`. (`Size` includes invalid collectibles, like
+ * 666. We subtract one to account for `CollectibleType.NULL`.)
+ *
+ * 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).
+ */
+export function getLastCollectibleType(): CollectibleType {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("collectible");
+
+  return itemConfig.GetCollectibles().Size - 1;
+}
+
+/**
+ * Helper function to get an array that represents the all modded collectible types.
+ *
+ * This function is only useful when building collectible type objects. For most purposes, you
+ * should use the `getModdedCollectibleSet` helper function instead.
+ *
+ * Returns an empty array if there are no modded collectible types.
+ *
+ * (This function is named differently from the `getVanillaCollectibleTypeRange` function because
+ * all modded collectible types are contiguous. Thus, each value represents a real
+ * `CollectibleType`.)
+ *
+ * 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).
+ */
+export function getModdedCollectibleTypes(): CollectibleType[] {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("collectible");
+
+  const firstModdedCollectibleType = getFirstModdedCollectibleType();
+  if (firstModdedCollectibleType === undefined) {
+    return [];
+  }
+
+  const lastCollectibleType = getLastCollectibleType();
+  return irange(firstModdedCollectibleType, lastCollectibleType);
+}
+
+/**
+ * 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).
+ */
+export function getNumCollectibleTypes(): int {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("collectible");
+
+  const numModdedCollectibleTypes = getNumModdedCollectibleTypes();
+  return NUM_VANILLA_COLLECTIBLE_TYPES + numModdedCollectibleTypes;
+}
+
+/**
+ * Unlike vanilla collectible types, modded collectible types are always contiguous.
+ *
+ * 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).
+ */
+export function getNumModdedCollectibleTypes(): int {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("collectible");
+
+  const lastCollectibleType = getLastCollectibleType();
+  return lastCollectibleType - LAST_VANILLA_COLLECTIBLE_TYPE;
+}
+
+// --------
+// Trinkets
+// --------
+
+/**
+ * Returns the first modded trinket type, or undefined if there are no modded trinkets.
+ *
+ * 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 getFirstModdedTrinketType(): TrinketType | undefined {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("trinket");
+
+  const firstModdedTrinketType = asTrinketType(
+    asNumber(LAST_VANILLA_TRINKET_TYPE) + 1,
+  );
+  const itemConfigItem = itemConfig.GetTrinket(firstModdedTrinketType);
+  return itemConfigItem === undefined ? undefined : firstModdedTrinketType;
+}
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * This is equal to the number of trinket types, since all trinket types are contiguous (unlike
+ * collectibles).
+ *
+ * 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 getLastTrinketType(): TrinketType {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("trinket");
+
+  const numTrinketTypes = getNumTrinketTypes();
+  return asTrinketType(numTrinketTypes);
+}
+
+/**
+ * Helper function to get an array that represents every modded trinket type.
+ *
+ * Returns an empty array if there are no modded trinket types.
+ *
+ * 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 getModdedTrinketTypes(): TrinketType[] {
+  const firstModdedTrinketType = getFirstModdedTrinketType();
+  if (firstModdedTrinketType === undefined) {
+    return [];
+  }
+
+  const lastTrinketType = getLastTrinketType();
+  return irange(firstModdedTrinketType, lastTrinketType);
+}
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * Equal to `itemConfig.GetTrinkets().Size - 1`. (We subtract one to account for
+ * `TrinketType.NULL`.)
+ *
+ * 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 getNumTrinketTypes(): int {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("trinket");
+
+  return itemConfig.GetTrinkets().Size - 1;
+}
+
+/**
+ * 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 getNumModdedTrinketTypes(): int {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("trinket");
+
+  const numTrinketTypes = getNumTrinketTypes();
+  return numTrinketTypes - NUM_VANILLA_TRINKET_TYPES;
+}
+
+/**
+ * Helper function to get an array that contains every trinket type.
+ *
+ * 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 getTrinketTypes(): TrinketType[] {
+  const lastTrinketType = getLastTrinketType();
+  return irange(FIRST_TRINKET_TYPE, lastTrinketType);
+}
+
+// -----
+// Cards
+// -----
+
+/**
+ * Helper function to get an array with every valid card sub-type. This includes modded cards.
+ *
+ * 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);
+}
+
+/**
+ * Returns the first modded card sub-type, or undefined if there are no modded cards.
+ *
+ * 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 {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("card");
+
+  const firstModdedCard = asCard(asNumber(LAST_VANILLA_CARD) + 1);
+  const itemConfigCard = itemConfig.GetCard(firstModdedCard);
+  return itemConfigCard === undefined ? undefined : firstModdedCard;
+}
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * This is equal to the number of cards, since all card sub-types are contiguous (unlike
+ * collectibles).
+ *
+ * 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 {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("card");
+
+  const numCards = getNumCards();
+  return asCard(numCards);
+}
+
+/**
+ * Helper function to get an array with every modded card sub-type.
+ *
+ * Returns an empty array if there are no modded cards.
+ *
+ * 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) {
+    return [];
+  }
+
+  const lastCard = getLastCard();
+  return irange(firstModdedCard, lastCard);
+}
+
+/**
+ * Will change depending on how many modded cards there are.
+ *
+ * Equal to `itemConfig.GetCards().Size - 1`. (We subtract one to account for `Card.NULL`.)
+ *
+ * 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 {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("card");
+
+  return itemConfig.GetCards().Size - 1;
+}
+
+/**
+ * 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 {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("card");
+
+  const numCards = getNumCards();
+  return numCards - NUM_VANILLA_CARDS;
+}
+
+// ------------
+// Pill Effects
+// ------------
+
+/**
+ * Helper function to get an array with every valid pill effect. This includes modded pill effects.
+ *
+ * This function can only be called if at least one callback has been executed. This is because not
+ * all pill effects will necessarily be present when a mod first loads (due to mod load order).
+ */
+export function getAllPillEffects(): PillEffect[] {
+  const lastPillEffect = getLastPillEffect();
+  return irange(FIRST_PILL_EFFECT, lastPillEffect);
+}
+
+/**
+ * Returns the first modded pill effect, or undefined if there are no modded pill effects.
+ *
+ * This function can only be called if at least one callback has been executed. This is because not
+ * all pill effects will necessarily be present when a mod first loads (due to mod load order).
+ */
+export function getFirstModdedPillEffect(): PillEffect | undefined {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("pill");
+
+  const firstModdedPillEffect = asPillEffect(
+    asNumber(LAST_VANILLA_PILL_EFFECT) + 1,
+  );
+  const itemConfigPillEffect = itemConfig.GetPillEffect(firstModdedPillEffect);
+  return itemConfigPillEffect === undefined ? undefined : firstModdedPillEffect;
+}
+
+/**
+ * Will change depending on how many modded pill effects there are.
+ *
+ * This is equal to the number of pill effects, since all pill effects are contiguous (unlike
+ * collectibles).
+ *
+ * This function can only be called if at least one callback has been executed. This is because not
+ * all pill effects will necessarily be present when a mod first loads (due to mod load order).
+ */
+export function getLastPillEffect(): PillEffect {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("pill");
+
+  const numPillEffects = getNumPillEffects();
+  return asPillEffect(numPillEffects);
+}
+
+/**
+ * Helper function to get an array with every modded pill effect.
+ *
+ * Returns an empty array if there are no modded pill effects.
+ *
+ * This function can only be called if at least one callback has been executed. This is because not
+ * all pill effects will necessarily be present when a mod first loads (due to mod load order).
+ */
+export function getModdedPillEffects(): PillEffect[] {
+  const firstModdedPillEffect = getFirstModdedPillEffect();
+  if (firstModdedPillEffect === undefined) {
+    return [];
+  }
+
+  const lastPillEffect = getLastPillEffect();
+  return irange(firstModdedPillEffect, lastPillEffect);
+}
+
+/**
+ * Will change depending on how many modded pill effects there are.
+ *
+ * Equal to `itemConfig.GetPillEffects().Size`. (We do not have to subtract one, because the first
+ * pill effect has an ID of 0 and there is no `PillEffect.NULL`.)
+ *
+ * This function can only be called if at least one callback has been executed. This is because not
+ * all pill effects will necessarily be present when a mod first loads (due to mod load order).
+ */
+export function getNumPillEffects(): int {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("pill");
+
+  return itemConfig.GetPillEffects().Size;
+}
+
+/**
+ * This function can only be called if at least one callback has been executed. This is because not
+ * all pill effects will necessarily be present when a mod first loads (due to mod load order).
+ */
+export function getNumModdedPillEffects(): int {
+  errorIfFeaturesNotInitialized(FEATURE_NAME);
+  errorIfNoCallbacksFired("pill");
+
+  const numPillEffects = getNumPillEffects();
+  return numPillEffects - NUM_VANILLA_PILL_EFFECTS;
+}

package/src/functions/array.ts

@@ -399,15 +399,7 @@ export function getRandomArrayIndex<T>(
   return getRandomInt(0, array.length - 1, seedOrRNG, exceptions);
 }
 
-/**
- * Initializes an array with all elements containing the specified default value.
- *
- * For example:
- *
- * ```ts
- * const playerTransformations = initArray(false, PlayerForm.NUM_PLAYER_FORMS - 1);
- * ```
- */
+/** Initializes an array with all elements containing the specified default value. */
 export function initArray<T>(defaultValue: T, size: int): T[] {
   const array: T[] = [];
   repeat(size, () => {

package/src/functions/cards.ts

@@ -1,11 +1,6 @@
 import { Card, ItemConfigCardType } from "isaac-typescript-definitions";
 import { itemConfig } from "../core/cachedClasses";
-import {
-  FIRST_CARD,
-  FIRST_MODDED_CARD,
-  LAST_CARD,
-  MAX_VANILLA_CARD,
-} from "../core/constantsFirstLast";
+import { FIRST_CARD, LAST_VANILLA_CARD } from "../core/constantsFirstLast";
 import {
   CARD_DESCRIPTIONS,
   DEFAULT_CARD_DESCRIPTION,
@@ -28,14 +23,14 @@ const CARD_TYPE_TO_CARDS_MAP = new Map<ItemConfigCardType, Set<Card>>();
  */
 const CARD_SET = new Set<Card>();
 
-function initCardObjects() {
+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>());
   }
 
-  for (const card of getAllCards()) {
+  for (const card of getVanillaCards()) {
     const cardType = getCardType(card);
     const cardTypeSet = CARD_TYPE_TO_CARDS_MAP.get(cardType);
     if (cardTypeSet === undefined) {
@@ -57,11 +52,6 @@ function initCardObjects() {
   addSetsToSet(CARD_SET, cards);
 }
 
-/** Helper function to get an array with every valid card sub-type. This includes modded cards. */
-export function getAllCards(): Card[] {
-  return irange(FIRST_CARD, LAST_CARD);
-}
-
 /**
  * Helper function to get a card description from a Card enum value.
  *
@@ -131,7 +121,7 @@ export function getCardType(card: Card): ItemConfigCardType {
  */
 export function getCardsOfType(...cardTypes: ItemConfigCardType[]): Set<Card> {
   if (CARD_TYPE_TO_CARDS_MAP.size === 0) {
-    initCardObjects();
+    lazyInitCardMapsSets();
   }
 
   const matchingCards = new Set<Card>();
@@ -149,19 +139,6 @@ export function getCardsOfType(...cardTypes: ItemConfigCardType[]): Set<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(): Card[] {
-  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.).
  *
@@ -216,7 +193,7 @@ export function getRandomRune(
 
 /** Helper function to get an array with every valid vanilla card sub-type. */
 export function getVanillaCards(): Card[] {
-  return irange(FIRST_CARD, MAX_VANILLA_CARD);
+  return irange(FIRST_CARD, LAST_VANILLA_CARD);
 }
 
 /**