isaacscript-common 40.0.0 → 41.0.0

package/src/classes/features/other/ModdedElementSets.ts

@@ -1,3 +1,4 @@
+import type { PillEffect } from "isaac-typescript-definitions";
 import {
   CacheFlag,
   CardType,
@@ -14,16 +15,18 @@ import {
 } from "../../../arrays/cachedEnumValues";
 import { itemConfig } from "../../../core/cachedClasses";
 import { FIRST_GLITCHED_COLLECTIBLE_TYPE } from "../../../core/constants";
+import {
+  VANILLA_CARD_TYPES,
+  VANILLA_COLLECTIBLE_TYPES,
+  VANILLA_PILL_EFFECTS,
+  VANILLA_TRINKET_TYPES,
+} from "../../../core/constantsVanilla";
 import { Exported } from "../../../decorators";
 import { ISCFeature } from "../../../enums/ISCFeature";
-import {
-  getItemConfigCardType,
-  getVanillaCardTypes,
-} from "../../../functions/cards";
+import { getItemConfigCardType } from "../../../functions/cards";
 import { collectibleHasTag } from "../../../functions/collectibleTag";
 import {
   collectibleHasCacheFlag,
-  getVanillaCollectibleTypeRange,
   isActiveCollectible,
   isHiddenCollectible,
   isPassiveCollectible,
@@ -36,11 +39,14 @@ import {
   getRandomSetElement,
   getSortedSetValues,
 } from "../../../functions/set";
+import { trinketHasCacheFlag } from "../../../functions/trinkets";
 import {
-  getVanillaTrinketTypeRange,
-  trinketHasCacheFlag,
-} from "../../../functions/trinkets";
-import { assertDefined, repeat } from "../../../functions/utils";
+  asCardType,
+  asCollectibleType,
+  asPillEffect,
+  asTrinketType,
+} from "../../../functions/types";
+import { assertDefined, iRange, repeat } from "../../../functions/utils";
 import { ITEM_CONFIG_CARD_TYPES_FOR_CARDS_SET } from "../../../sets/itemConfigCardTypesForCardsSet";
 import { ReadonlyMap } from "../../../types/ReadonlyMap";
 import { ReadonlySet } from "../../../types/ReadonlySet";
@@ -71,40 +77,40 @@ const TRANSFORMATION_TO_TAG_MAP = new ReadonlyMap<PlayerForm, ItemConfigTag>([
   // PlayerForm.STOMPY (13) is based on size.
 ]);
 
+/**
+ * A feature that lazy-inits and caches various arrays and sets that include both vanilla and modded
+ * elements. This is useful for performance purposes (so that we do not have to reconstruct the
+ * arrays/sets multiple times).
+ *
+ * The modded arrays/sets are created using the functions from
+ * `ISCFeature.MODDED_ELEMENT_DETECTION`.
+ */
 export class ModdedElementSets extends Feature {
   private arraysInitialized = false;
 
   private readonly allCollectibleTypesArray: CollectibleType[] = [];
   private readonly allCollectibleTypesSet = new Set<CollectibleType>();
 
-  private readonly vanillaCollectibleTypesArray: CollectibleType[] = [];
-  private readonly vanillaCollectibleTypesSet = new Set<CollectibleType>();
-
   private readonly moddedCollectibleTypesArray: CollectibleType[] = [];
   private readonly moddedCollectibleTypesSet = new Set<CollectibleType>();
 
   private readonly allTrinketTypesArray: TrinketType[] = [];
   private readonly allTrinketTypesSet = new Set<TrinketType>();
 
-  private readonly vanillaTrinketTypesArray: TrinketType[] = [];
-  private readonly vanillaTrinketTypesSet = new Set<TrinketType>();
-
   private readonly moddedTrinketTypesArray: TrinketType[] = [];
   private readonly moddedTrinketTypesSet = new Set<TrinketType>();
 
   private readonly allCardTypesArray: CardType[] = [];
   private readonly allCardTypesSet = new Set<CardType>();
 
-  private readonly vanillaCardTypesArray: CardType[] = [];
-  private readonly vanillaCardTypesSet = new Set<CardType>();
-
   private readonly moddedCardTypesArray: CardType[] = [];
   private readonly moddedCardTypesSet = new Set<CardType>();
 
-  private readonly tagToCollectibleTypesMap = new Map<
-    ItemConfigTag,
-    Set<CollectibleType>
-  >();
+  private readonly allPillEffectsArray: PillEffect[] = [];
+  private readonly allPillEffectsSet = new Set<PillEffect>();
+
+  private readonly moddedPillEffectsArray: PillEffect[] = [];
+  private readonly moddedPillEffectsSet = new Set<PillEffect>();
 
   private readonly cacheFlagToCollectibleTypesMap = new Map<
     CacheFlag,
@@ -121,6 +127,12 @@ export class ModdedElementSets extends Feature {
     new Set<CollectibleType>();
 
   private flyingTrinketTypesSet = new Set<TrinketType>();
+
+  private readonly tagToCollectibleTypesMap = new Map<
+    ItemConfigTag,
+    Set<CollectibleType>
+  >();
+
   private readonly edenActiveCollectibleTypesSet = new Set<CollectibleType>();
   private readonly edenPassiveCollectibleTypesSet = new Set<CollectibleType>();
 
@@ -130,7 +142,7 @@ export class ModdedElementSets extends Feature {
   >();
 
   /**
-   * The set of cards that are not:
+   * The set of card types that are not:
    *
    * - ItemConfigCardType.RUNE
    * - ItemConfigCardType.SPECIAL_OBJECT
@@ -154,12 +166,10 @@ export class ModdedElementSets extends Feature {
     }
     this.arraysInitialized = true;
 
-    this.lazyInitVanillaCollectibleTypes();
     this.lazyInitModdedCollectibleTypes();
-    this.lazyInitVanillaTrinketTypes();
     this.lazyInitModdedTrinketTypes();
-    this.lazyInitVanillaCardTypes();
     this.lazyInitModdedCardTypes();
+    this.lazyInitModdedPillEffects();
     this.lazyInitTagToCollectibleTypesMap();
     this.lazyInitCacheFlagToCollectibleTypesMap();
     this.lazyInitCacheFlagToTrinketTypesMap();
@@ -169,33 +179,28 @@ export class ModdedElementSets extends Feature {
     this.lazyInitCardTypes();
   }
 
-  private lazyInitVanillaCollectibleTypes() {
-    if (this.vanillaCollectibleTypesArray.length > 0) {
-      return;
-    }
-
-    const vanillaCollectibleTypeRange = getVanillaCollectibleTypeRange();
-    for (const collectibleType of vanillaCollectibleTypeRange) {
-      // Vanilla collectible types are not contiguous, so we must check every value. (There are
-      // several gaps, e.g. 666.)
-      const itemConfigItem = itemConfig.GetCollectible(collectibleType);
-      if (itemConfigItem !== undefined) {
-        this.vanillaCollectibleTypesArray.push(collectibleType);
-        this.vanillaCollectibleTypesSet.add(collectibleType);
-      }
-    }
-  }
-
   private lazyInitModdedCollectibleTypes() {
-    for (const collectibleType of this.vanillaCollectibleTypesArray) {
+    for (const collectibleType of VANILLA_COLLECTIBLE_TYPES) {
       this.allCollectibleTypesArray.push(collectibleType);
       this.allCollectibleTypesSet.add(collectibleType);
     }
 
-    const moddedCollectibleTypes =
-      this.moddedElementDetection.getModdedCollectibleTypes();
-    for (const collectibleType of moddedCollectibleTypes) {
+    const firstModdedCollectibleType =
+      this.moddedElementDetection.getFirstModdedCollectibleType();
+    if (firstModdedCollectibleType === undefined) {
+      return;
+    }
+
+    const lastCollectibleType =
+      this.moddedElementDetection.getLastCollectibleType();
+    const moddedCollectibleTypes = iRange(
+      firstModdedCollectibleType,
+      lastCollectibleType,
+    );
+
+    for (const collectibleTypeInt of moddedCollectibleTypes) {
       // Modded collectible types are contiguous, but we check every value just in case.
+      const collectibleType = asCollectibleType(collectibleTypeInt);
       const itemConfigItem = itemConfig.GetCollectible(collectibleType);
       if (itemConfigItem !== undefined) {
         this.moddedCollectibleTypesArray.push(collectibleType);
@@ -207,33 +212,24 @@ export class ModdedElementSets extends Feature {
     }
   }
 
-  private lazyInitVanillaTrinketTypes() {
-    if (this.vanillaTrinketTypesArray.length > 0) {
-      return;
-    }
-
-    const vanillaTrinketTypeRange = getVanillaTrinketTypeRange();
-    for (const trinketType of vanillaTrinketTypeRange) {
-      // Vanilla trinket types are not contiguous, so we must check every value. (The only gap is 47
-      // for `POLAROID_OBSOLETE`.)
-      const itemConfigItem = itemConfig.GetTrinket(trinketType);
-      if (itemConfigItem !== undefined) {
-        this.vanillaTrinketTypesArray.push(trinketType);
-        this.vanillaTrinketTypesSet.add(trinketType);
-      }
-    }
-  }
-
   private lazyInitModdedTrinketTypes() {
-    for (const trinketType of this.vanillaTrinketTypesArray) {
+    for (const trinketType of VANILLA_TRINKET_TYPES) {
       this.allTrinketTypesArray.push(trinketType);
       this.allTrinketTypesSet.add(trinketType);
     }
 
-    const moddedTrinketTypes =
-      this.moddedElementDetection.getModdedTrinketTypes();
-    for (const trinketType of moddedTrinketTypes) {
+    const firstModdedTrinketType =
+      this.moddedElementDetection.getFirstModdedTrinketType();
+    if (firstModdedTrinketType === undefined) {
+      return;
+    }
+
+    const lastTrinketType = this.moddedElementDetection.getLastTrinketType();
+    const moddedTrinketTypes = iRange(firstModdedTrinketType, lastTrinketType);
+
+    for (const trinketTypeInt of moddedTrinketTypes) {
       // Modded trinket types are contiguous, but we check every value just in case.
+      const trinketType = asTrinketType(trinketTypeInt);
       const itemConfigItem = itemConfig.GetTrinket(trinketType);
       if (itemConfigItem !== undefined) {
         this.moddedTrinketTypesArray.push(trinketType);
@@ -245,33 +241,24 @@ export class ModdedElementSets extends Feature {
     }
   }
 
-  private lazyInitVanillaCardTypes() {
-    if (this.vanillaCardTypesArray.length > 0) {
-      return;
-    }
-
-    const vanillaCardTypes = getVanillaCardTypes();
-    for (const cardType of vanillaCardTypes) {
-      // Vanilla card types are contiguous, but we check every value just to be safe (and so that
-      // the code is similar to the collectible and trinket functions above).
-      const itemConfigCard = itemConfig.GetCard(cardType);
-      if (itemConfigCard !== undefined) {
-        this.vanillaCardTypesArray.push(cardType);
-        this.vanillaCardTypesSet.add(cardType);
-      }
-    }
-  }
-
   private lazyInitModdedCardTypes() {
-    for (const cardType of this.vanillaCardTypesArray) {
+    for (const cardType of VANILLA_CARD_TYPES) {
       this.allCardTypesArray.push(cardType);
       this.allCardTypesSet.add(cardType);
     }
 
-    const moddedCardTypes = this.moddedElementDetection.getModdedCardTypes();
-    for (const cardType of moddedCardTypes) {
-      // Modded card types are contiguous, but we check every value just to be safe (and so that the
-      // code is similar to the collectible and trinket functions above).
+    const firstModdedCardType =
+      this.moddedElementDetection.getFirstModdedCardType();
+    if (firstModdedCardType === undefined) {
+      return;
+    }
+
+    const lastCardType = this.moddedElementDetection.getLastCardType();
+    const moddedCardTypes = iRange(firstModdedCardType, lastCardType);
+
+    for (const cardTypeInt of moddedCardTypes) {
+      // Modded card types are contiguous, but we check every value just in case.
+      const cardType = asCardType(cardTypeInt);
       const itemConfigCard = itemConfig.GetCard(cardType);
       if (itemConfigCard !== undefined) {
         this.moddedCardTypesArray.push(cardType);
@@ -283,6 +270,35 @@ export class ModdedElementSets extends Feature {
     }
   }
 
+  private lazyInitModdedPillEffects() {
+    for (const pillEffect of VANILLA_PILL_EFFECTS) {
+      this.allPillEffectsArray.push(pillEffect);
+      this.allPillEffectsSet.add(pillEffect);
+    }
+
+    const firstModdedPillEffect =
+      this.moddedElementDetection.getFirstModdedPillEffect();
+    if (firstModdedPillEffect === undefined) {
+      return;
+    }
+
+    const lastPillEffect = this.moddedElementDetection.getLastPillEffect();
+    const moddedPillEffects = iRange(firstModdedPillEffect, lastPillEffect);
+
+    for (const pillEffectInt of moddedPillEffects) {
+      // Modded pill effects are contiguous, but we check every value just in case.
+      const pillEffect = asPillEffect(pillEffectInt);
+      const itemConfigPillEffect = itemConfig.GetPillEffect(pillEffect);
+      if (itemConfigPillEffect !== undefined) {
+        this.moddedPillEffectsArray.push(pillEffect);
+        this.moddedPillEffectsSet.add(pillEffect);
+
+        this.allPillEffectsArray.push(pillEffect);
+        this.allPillEffectsSet.add(pillEffect);
+      }
+    }
+  }
+
   private lazyInitTagToCollectibleTypesMap() {
     // The tag to collectible types map should be valid for every tag, so we initialize it with
     // empty sets.
@@ -290,7 +306,7 @@ export class ModdedElementSets extends Feature {
       this.tagToCollectibleTypesMap.set(itemConfigTag, new Set());
     }
 
-    for (const collectibleType of this.getCollectibleArray()) {
+    for (const collectibleType of this.getCollectibleTypes()) {
       for (const itemConfigTag of ITEM_CONFIG_TAG_VALUES) {
         if (!collectibleHasTag(collectibleType, itemConfigTag)) {
           continue;
@@ -313,7 +329,7 @@ export class ModdedElementSets extends Feature {
     for (const cacheFlag of CACHE_FLAG_VALUES) {
       const collectiblesSet = new Set<CollectibleType>();
 
-      for (const collectibleType of this.getCollectibleArray()) {
+      for (const collectibleType of this.getCollectibleTypes()) {
         if (collectibleHasCacheFlag(collectibleType, cacheFlag)) {
           collectiblesSet.add(collectibleType);
         }
@@ -327,7 +343,7 @@ export class ModdedElementSets extends Feature {
     for (const cacheFlag of CACHE_FLAG_VALUES) {
       const trinketsSet = new Set<TrinketType>();
 
-      for (const trinketType of this.getTrinketArray()) {
+      for (const trinketType of this.getTrinketTypes()) {
         if (trinketHasCacheFlag(trinketType, cacheFlag)) {
           trinketsSet.add(trinketType);
         }
@@ -341,13 +357,13 @@ export class ModdedElementSets extends Feature {
     // Instead of manually compiling a list of collectibles that grant flying, we can instead
     // dynamically look for collectibles that have `CacheFlag.FLYING`.
     this.flyingCollectibleTypesSet = copySet(
-      this.getCollectiblesWithCacheFlag(CacheFlag.FLYING),
+      this.getCollectibleTypesWithCacheFlag(CacheFlag.FLYING),
     );
 
     // None of the collectibles with a cache of "all" grant flying (including all of the 3 Dollar
     // Bill collectibles and all of the Birthright effects), so we can safely remove them from the
     // list.
-    const collectiblesWithAllCacheFlag = this.getCollectiblesWithCacheFlag(
+    const collectiblesWithAllCacheFlag = this.getCollectibleTypesWithCacheFlag(
       CacheFlag.ALL,
     );
     deleteSetsFromSet(
@@ -372,20 +388,20 @@ export class ModdedElementSets extends Feature {
     // Instead of manually compiling a list of trinkets that grant flying, we can instead
     // dynamically look for collectibles that have `CacheFlag.FLYING`.
     this.flyingTrinketTypesSet = copySet(
-      this.getTrinketsWithCacheFlag(CacheFlag.FLYING),
+      this.getTrinketsTypesWithCacheFlag(CacheFlag.FLYING),
     );
 
-    // None of the collectibles with a cache of "all" grant flying except for Azazel's Stump, so we
-    // can safely remove them from the list.
+    // None of the trinkets with `CacheFlag.ALL` grant flying except for Azazel's Stump, so we can
+    // safely remove them from the list.
     const trinketsWithAllCacheFlag = copySet(
-      this.getTrinketsWithCacheFlag(CacheFlag.ALL),
+      this.getTrinketsTypesWithCacheFlag(CacheFlag.ALL),
     );
     trinketsWithAllCacheFlag.delete(TrinketType.AZAZELS_STUMP);
     deleteSetsFromSet(this.flyingTrinketTypesSet, trinketsWithAllCacheFlag);
   }
 
   private lazyInitEdenCollectibleTypesSet() {
-    for (const collectibleType of this.getCollectibleArray()) {
+    for (const collectibleType of this.getCollectibleTypes()) {
       if (
         isHiddenCollectible(collectibleType) ||
         collectibleHasTag(collectibleType, ItemConfigTag.NO_EDEN)
@@ -413,7 +429,7 @@ export class ModdedElementSets extends Feature {
       );
     }
 
-    for (const cardType of this.getCardArray()) {
+    for (const cardType of this.getCardTypes()) {
       const itemConfigCardType = getItemConfigCardType(cardType);
       if (itemConfigCardType !== undefined) {
         const cardTypeSet =
@@ -432,292 +448,262 @@ export class ModdedElementSets extends Feature {
     }
   }
 
-  // --------------
-  // Public Methods
-  // --------------
-
-  /**
-   * Returns an array containing every valid card type in the game, including modded cards.
-   *
-   * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-   * use the `getCardSet` helper function instead.
-   *
-   * 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).
-   *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getCardArray(): readonly CardType[] {
-    this.lazyInit();
-    return this.allCardTypesArray;
-  }
+  // ------------
+  // Collectibles
+  // ------------
 
   /**
-   * Returns a set containing every valid card type in the game, including modded cards.
+   * Returns an array containing every valid collectible type in the game, including modded
+   * collectibles.
    *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-   * use the `getCardArray` helper function instead.
+   * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
+   * then use the `getCollectibleTypesSet` helper function instead.
    *
    * 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).
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCardSet(): ReadonlySet<CardType> {
+  public getCollectibleTypes(): readonly CollectibleType[] {
     this.lazyInit();
-    return this.allCardTypesSet;
+    return this.allCollectibleTypesArray;
   }
 
   /**
-   * Helper function to get a set of card types matching the `ItemConfigCardType`.
+   * Returns a set containing every valid collectible type in the game, including modded
+   * collectibles.
    *
-   * 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.
+   * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
+   * then use the `getCollectibleTypes` helper function instead.
    *
    * 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).
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCardTypesOfType(
-    ...itemConfigCardTypes: ItemConfigCardType[]
-  ): Set<CardType> {
+  public getCollectibleTypeSet(): ReadonlySet<CollectibleType> {
     this.lazyInit();
-
-    const matchingCardTypes = new Set<CardType>();
-    for (const itemConfigCardType of itemConfigCardTypes) {
-      const cardTypeSet =
-        this.itemConfigCardTypeToCardTypeMap.get(itemConfigCardType);
-      assertDefined(
-        cardTypeSet,
-        `Failed to get the card type set for item config type: ${itemConfigCardType}`,
-      );
-
-      for (const cardType of cardTypeSet) {
-        matchingCardTypes.add(cardType);
-      }
-    }
-
-    return matchingCardTypes;
+    return this.allCollectibleTypesSet;
   }
 
   /**
-   * Returns an array containing every valid collectible type in the game, including modded
-   * collectibles.
+   * Returns an array containing every modded collectible type in the game.
    *
    * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-   * then use the `getCollectibleSet` helper function instead.
+   * then use the `getModdedCollectibleTypesSet` helper function instead.
    *
    * 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
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCollectibleArray(): readonly CollectibleType[] {
+  public getModdedCollectibleTypes(): readonly CollectibleType[] {
     this.lazyInit();
-    return this.allCollectibleTypesArray;
+    return this.moddedCollectibleTypesArray;
   }
 
   /**
-   * Returns a set containing every valid collectible type in the game, including modded
-   * collectibles.
+   * Returns a set containing every modded collectible type in the game.
    *
    * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-   * then use the `getCollectibleArray` helper function instead.
+   * then use the `getModdedCollectibleTypes` helper function instead.
    *
    * 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
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCollectibleSet(): ReadonlySet<CollectibleType> {
+  public getModdedCollectibleTypesSet(): ReadonlySet<CollectibleType> {
     this.lazyInit();
-    return this.allCollectibleTypesSet;
+    return this.moddedCollectibleTypesSet;
   }
 
   /**
-   * Helper function to get all of the collectible types in the game that count towards a particular
-   * transformation.
+   * Iterates over every collectible in the game and returns a map containing the number of each
+   * item that the player has.
    *
-   * For example, to get all of the collectible types that count towards Guppy:
-   *
-   * ```ts
-   * const guppyCollectibleTypes = getCollectiblesForTransformation(PlayerForm.GUPPY);
-   * ```
+   * Note that this will filter out non-real collectibles 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
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCollectiblesForTransformation(
-    playerForm: PlayerForm,
-  ): ReadonlySet<CollectibleType> {
-    const itemConfigTag = TRANSFORMATION_TO_TAG_MAP.get(playerForm);
-    assertDefined(
-      itemConfigTag,
-      `Failed to get the collectible types for the transformation of ${playerForm} because that transformation is not based on collectibles.`,
-    );
+  public getPlayerCollectibleMap(
+    player: EntityPlayer,
+  ): Map<CollectibleType, int> {
+    const collectibleArray = this.getCollectibleTypes();
+
+    const collectibleMap = new Map<CollectibleType, int>();
+    for (const collectibleType of collectibleArray) {
+      // We specify "true" as the second argument to filter out things like Lilith's Incubus.
+      const numCollectibles = player.GetCollectibleNum(collectibleType, true);
+      if (numCollectibles > 0) {
+        collectibleMap.set(collectibleType, numCollectibles);
+      }
+    }
+
+    // If the player has TMTRAINER, they might also have glitched items.
+    if (player.HasCollectible(CollectibleType.TMTRAINER)) {
+      let collectibleType = FIRST_GLITCHED_COLLECTIBLE_TYPE;
+      let itemConfigItem: Readonly<ItemConfigItem> | undefined;
+      do {
+        itemConfigItem = itemConfig.GetCollectible(collectibleType);
 
-    return this.getCollectiblesWithTag(itemConfigTag);
+        if (itemConfigItem !== undefined) {
+          // The `EntityPlayer.GetCollectibleNum` method is bugged with TMTrainer items and will
+          // always return 0. To work around this, we simply assume that if the player has the
+          // collectible, then they have one copy of the item.
+          const hasCollectibles = player.HasCollectible(collectibleType, true);
+          if (hasCollectibles) {
+            collectibleMap.set(collectibleType, 1);
+          }
+        }
+
+        collectibleType--; // eslint-disable-line isaacscript/strict-enums
+      } while (itemConfigItem !== undefined);
+    }
+
+    return collectibleMap;
   }
 
+  // --------
+  // Trinkets
+  // --------
+
   /**
-   * Returns a set containing every collectible type with the given cache flag, including modded
-   * collectibles.
+   * Returns an array containing every modded trinket type in the game.
    *
-   * 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).
+   * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
+   * then use the `getModdedTrinketTypesSet` helper function instead.
    *
    * 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
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCollectiblesWithCacheFlag(
-    cacheFlag: CacheFlag,
-  ): ReadonlySet<CollectibleType> {
+  public getTrinketTypes(): readonly TrinketType[] {
     this.lazyInit();
-
-    const collectiblesSet = this.cacheFlagToCollectibleTypesMap.get(cacheFlag);
-    if (collectiblesSet === undefined) {
-      return new ReadonlySet();
-    }
-
-    return collectiblesSet;
+    return this.allTrinketTypesArray;
   }
 
   /**
-   * Returns a set containing every collectible type with the given tag.
-   *
-   * For example, to get all of the collectible types that count as offensive for the purposes of
-   * Tainted Lost:
+   * Returns a set containing every modded trinket type in the game.
    *
-   * ```ts
-   * const offensiveCollectibleTypes = getCollectibleTypesWithTag(ItemConfigTag.OFFENSIVE);
-   * ```
+   * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
+   * then use the `getModdedTrinketTypes` helper function instead.
    *
    * 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
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getCollectiblesWithTag(
-    itemConfigTag: ItemConfigTag,
-  ): ReadonlySet<CollectibleType> {
+  public getTrinketTypesSet(): ReadonlySet<TrinketType> {
     this.lazyInit();
-
-    const collectibleTypes = this.tagToCollectibleTypesMap.get(itemConfigTag);
-    assertDefined(
-      collectibleTypes,
-      `The item config tag of ${itemConfigTag} is not a valid value of the "ItemConfigTag" enum.`,
-    );
-
-    return collectibleTypes;
+    return this.allTrinketTypesSet;
   }
 
   /**
-   * Returns a set containing every valid passive item that can be randomly granted to Eden as a
-   * starting item.
+   * Returns an array containing every modded trinket type in the game.
+   *
+   * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
+   * then use the `getModdedTrinketTypesSet` helper function instead.
    *
    * 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
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getEdenActiveCollectibles(): ReadonlySet<CollectibleType> {
+  public getModdedTrinketTypes(): readonly TrinketType[] {
     this.lazyInit();
-    return this.edenActiveCollectibleTypesSet;
+    return this.moddedTrinketTypesArray;
   }
 
   /**
-   * Returns a set containing every valid passive item that can be randomly granted to Eden as a
-   * starting item.
+   * Returns a set containing every modded trinket type in the game.
+   *
+   * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
+   * then use the `getModdedTrinketTypes` helper function instead.
    *
    * 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
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getEdenPassiveCollectibles(): ReadonlySet<CollectibleType> {
+  public getModdedTrinketTypesSet(): ReadonlySet<TrinketType> {
     this.lazyInit();
-    return this.edenPassiveCollectibleTypesSet;
+    return this.moddedTrinketTypesSet;
   }
 
+  // -----
+  // Cards
+  // -----
+
   /**
-   * Returns a set of all of the collectibles that grant flight. This is derived from collectibles
-   * that have `CacheFlag.FLYING` set in the "items.xml" file.
+   * Returns an array containing every valid card type in the game, including modded cards.
    *
-   * Collectibles that only grant flight conditionally are manually pruned. Collectibles such as
-   * Empty Vessel should be checked for via the `hasFlyingTemporaryEffect` function.
+   * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
+   * use the `getCardTypesSet` helper function instead.
    *
    * 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).
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   *
-   * @param includeConditionalItems Whether collectibles that only grant flight conditionally should
-   *                                be included in the set (like Empty Vessel).
    */
   @Exported
-  public getFlyingCollectibles(
-    includeConditionalItems: boolean,
-  ): ReadonlySet<CollectibleType> {
+  public getCardTypes(): readonly CardType[] {
     this.lazyInit();
-
-    return includeConditionalItems
-      ? this.flyingCollectibleTypesSet
-      : this.permanentFlyingCollectibleTypesSet;
+    return this.allCardTypesArray;
   }
 
   /**
-   * Returns a set of all of the trinkets that grant flight. (All trinkets that grant flight do so
-   * conditionally, like Bat Wing and Azazel's Stump.)
+   * Returns a set containing every valid card type in the game, including modded cards.
+   *
+   * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
+   * use the `getCardTypes` helper function instead.
    *
    * 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).
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getFlyingTrinkets(): ReadonlySet<TrinketType> {
+  public getCardTypesSet(): ReadonlySet<CardType> {
     this.lazyInit();
-
-    return this.flyingTrinketTypesSet;
+    return this.allCardTypesSet;
   }
 
   /**
    * Returns an array containing every modded card type in the game.
    *
    * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-   * use the `getModdedCardSet` helper function instead.
+   * use the `getModdedCardTypesSet` helper function instead.
    *
    * 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).
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getModdedCardArray(): readonly CardType[] {
+  public getModdedCardTypes(): readonly CardType[] {
     this.lazyInit();
     return this.moddedCardTypesArray;
   }
@@ -726,134 +712,145 @@ export class ModdedElementSets extends Feature {
    * Returns a set containing every modded card type in the game.
    *
    * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-   * use the `getModdedCardArray` helper function instead.
+   * use the `getModdedCardTypes` helper function instead.
    *
    * 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).
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getModdedCardSet(): ReadonlySet<CardType> {
+  public getModdedCardTypesSet(): ReadonlySet<CardType> {
     this.lazyInit();
     return this.moddedCardTypesSet;
   }
 
+  // ------------
+  // Pill Effects
+  // ------------
+
   /**
-   * Returns an array containing every modded collectible type in the game.
+   * Returns an array containing every valid pill effect in the game, including modded pill effects.
    *
-   * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-   * then use the `getModdedCollectibleSet` helper function instead.
+   * Use this if you need to iterate over the pill effects in order. If you need to do O(1) lookups,
+   * then use the `getPillEffectSet` helper function instead.
    *
    * 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
+   * not all pill effects will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getModdedCollectibleArray(): readonly CollectibleType[] {
+  public getPillEffects(): readonly PillEffect[] {
     this.lazyInit();
-    return this.moddedCollectibleTypesArray;
+    return this.allPillEffectsArray;
   }
 
   /**
-   * Returns a set containing every modded collectible type in the game.
+   * Returns a set containing every valid pill effect in the game, including modded pill effects.
    *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-   * then use the `getModdedCollectibleArray` helper function instead.
+   * Use this if you need to do O(1) lookups. If you need to iterate over the pill effects in order,
+   * then use the `getPillEffects` helper function instead.
    *
    * 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
+   * not all pill effects will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getModdedCollectibleSet(): ReadonlySet<CollectibleType> {
+  public getPillEffectsSet(): ReadonlySet<PillEffect> {
     this.lazyInit();
-    return this.moddedCollectibleTypesSet;
+    return this.allPillEffectsSet;
   }
 
   /**
-   * Returns an array containing every modded trinket type in the game.
+   * Returns an array containing every modded pill effect in the game.
    *
-   * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-   * then use the `getModdedTrinketSet` helper function instead.
+   * Use this if you need to iterate over the pill effects in order. If you need to do O(1) lookups,
+   * then use the `getModdedPillEffectsSet` helper function instead.
    *
    * 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).
+   * not all pill effects will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getModdedTrinketArray(): readonly TrinketType[] {
+  public getModdedPillEffects(): readonly PillEffect[] {
     this.lazyInit();
-    return this.moddedTrinketTypesArray;
+    return this.moddedPillEffectsArray;
   }
 
   /**
-   * Returns a set containing every modded trinket type in the game.
+   * Returns a set containing every modded pill effect in the game.
    *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-   * then use the `getModdedTrinketArray` helper function instead.
+   * Use this if you need to do O(1) lookups. If you need to iterate over the pill effects in order,
+   * then use the `getModdedPillEffects` helper function instead.
    *
    * 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).
+   * not all pill effects will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getModdedTrinketSet(): ReadonlySet<TrinketType> {
+  public getModdedPillEffectsSet(): ReadonlySet<PillEffect> {
     this.lazyInit();
-    return this.moddedTrinketTypesSet;
+    return this.moddedPillEffectsSet;
   }
 
+  // -----------
+  // Cache Flags
+  // -----------
+
   /**
-   * Iterates over every item in the game and returns a map containing the number of each item that
-   * the player has.
+   * Returns a set containing every collectible type with the given cache flag, including modded
+   * collectibles.
    *
-   * Note that this will filter out non-real collectibles like Lilith's Incubus.
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getPlayerCollectibleMap(
-    player: EntityPlayer,
-  ): Map<CollectibleType, int> {
-    const collectibleArray = this.getCollectibleArray();
+  public getCollectibleTypesWithCacheFlag(
+    cacheFlag: CacheFlag,
+  ): ReadonlySet<CollectibleType> {
+    this.lazyInit();
 
-    const collectibleMap = new Map<CollectibleType, int>();
-    for (const collectibleType of collectibleArray) {
-      // We specify "true" as the second argument to filter out things like Lilith's Incubus.
-      const numCollectibles = player.GetCollectibleNum(collectibleType, true);
-      if (numCollectibles > 0) {
-        collectibleMap.set(collectibleType, numCollectibles);
-      }
+    const collectiblesSet = this.cacheFlagToCollectibleTypesMap.get(cacheFlag);
+    if (collectiblesSet === undefined) {
+      return new ReadonlySet();
     }
 
-    // If the player has TMTRAINER, they might also have glitched items.
-    if (player.HasCollectible(CollectibleType.TMTRAINER)) {
-      let collectibleType = FIRST_GLITCHED_COLLECTIBLE_TYPE;
-      let itemConfigItem: Readonly<ItemConfigItem> | undefined;
-      do {
-        itemConfigItem = itemConfig.GetCollectible(collectibleType);
+    return collectiblesSet;
+  }
 
-        if (itemConfigItem !== undefined) {
-          // The `EntityPlayer.GetCollectibleNum` method is bugged with TMTrainer items and will
-          // always return 0. To work around this, we simply assume that if the player has the
-          // collectible, then they have one copy of the item.
-          const hasCollectibles = player.HasCollectible(collectibleType, true);
-          if (hasCollectibles) {
-            collectibleMap.set(collectibleType, 1);
-          }
-        }
+  /**
+   * Returns a set containing every trinket type with the given cache flag, including modded
+   * trinkets.
+   *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
+   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   */
+  @Exported
+  public getTrinketsTypesWithCacheFlag(
+    cacheFlag: CacheFlag,
+  ): ReadonlySet<TrinketType> {
+    this.lazyInit();
 
-        collectibleType--; // eslint-disable-line isaacscript/strict-enums
-      } while (itemConfigItem !== undefined);
+    const trinketsSet = this.cacheFlagToTrinketTypesMap.get(cacheFlag);
+    if (trinketsSet === undefined) {
+      return new ReadonlySet();
     }
 
-    return collectibleMap;
+    return trinketsSet;
   }
 
   /**
@@ -875,7 +872,7 @@ export class ModdedElementSets extends Feature {
    * 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
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
@@ -886,7 +883,7 @@ export class ModdedElementSets extends Feature {
     cacheFlag: CacheFlag,
   ): CollectibleType[] {
     const collectiblesWithCacheFlag =
-      this.getCollectiblesWithCacheFlag(cacheFlag);
+      this.getCollectibleTypesWithCacheFlag(cacheFlag);
 
     const playerCollectibles: CollectibleType[] = [];
     for (const collectibleType of getSortedSetValues(
@@ -902,9 +899,129 @@ export class ModdedElementSets extends Feature {
     return playerCollectibles;
   }
 
+  /**
+   * Returns a map containing every trinket type that the player has that matches the provided
+   * `CacheFlag`. The values of the map correspond to the multiplier for that trinket.
+   *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
+   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   */
+  @Exported
+  public getPlayerTrinketsWithCacheFlag(
+    player: EntityPlayer,
+    cacheFlag: CacheFlag,
+  ): Map<TrinketType, int> {
+    const trinketTypesWithCacheFlag =
+      this.getTrinketsTypesWithCacheFlag(cacheFlag);
+
+    const playerTrinkets = new Map<TrinketType, int>();
+    for (const trinketType of trinketTypesWithCacheFlag) {
+      const trinketMultiplier = player.GetTrinketMultiplier(trinketType);
+      if (trinketMultiplier > 0) {
+        playerTrinkets.set(trinketType, trinketMultiplier);
+      }
+    }
+
+    return playerTrinkets;
+  }
+
+  /**
+   * Returns a set of all of the collectibles that grant flight. This is derived from collectibles
+   * that have `CacheFlag.FLYING` set in the "items.xml" file.
+   *
+   * Vanilla collectibles that only grant flight conditionally are manually pruned. Collectibles
+   * such as Empty Vessel should be checked for via the `hasFlyingTemporaryEffect` function.
+   *
+   * Under the hood, this is determined by looking at the collectibles that have `CacheFlag.FLYING`
+   * and excluding the ones that have `CacheFlag.ALL`. (None of the collectibles with
+   * `CacheFlag.ALL` grant flying, including all of the 3 Dollar Bill collectibles and all of the
+   * Birthright effects.)
+   *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
+   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   *
+   * @param includeConditionalItems Whether collectibles that only grant flight conditionally should
+   *                                be included in the set (like Empty Vessel).
+   */
+  @Exported
+  public getFlyingCollectibleTypes(
+    includeConditionalItems: boolean,
+  ): ReadonlySet<CollectibleType> {
+    this.lazyInit();
+
+    return includeConditionalItems
+      ? this.flyingCollectibleTypesSet
+      : this.permanentFlyingCollectibleTypesSet;
+  }
+
+  /**
+   * Returns a set of all of the trinkets that grant flight. (All vanilla trinkets that grant flight
+   * do so conditionally, like Bat Wing and Azazel's Stump.)
+   *
+   * Under the hood, this is determined by looking at the trinkets that have `CacheFlag.FLYING` and
+   * excluding the ones that have `CacheFlag.ALL`. (None of the trinket with `CacheFlag.ALL` grant
+   * flying except for Azazel's Stump.)
+   *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all trinket types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
+   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   */
+  @Exported
+  public getFlyingTrinketTypes(): ReadonlySet<TrinketType> {
+    this.lazyInit();
+    return this.flyingTrinketTypesSet;
+  }
+
+  // ----------------
+  // Collectible Tags
+  // ----------------
+
+  /**
+   * Returns a set containing every collectible type with the given tag.
+   *
+   * For example, to get all of the collectible types that count as offensive for the purposes of
+   * Tainted Lost:
+   *
+   * ```ts
+   * const offensiveCollectibleTypes = getCollectibleTypesWithTag(ItemConfigTag.OFFENSIVE);
+   * ```
+   *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
+   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   */
+  @Exported
+  public getCollectibleTypesWithTag(
+    itemConfigTag: ItemConfigTag,
+  ): ReadonlySet<CollectibleType> {
+    this.lazyInit();
+
+    const collectibleTypes = this.tagToCollectibleTypesMap.get(itemConfigTag);
+    assertDefined(
+      collectibleTypes,
+      `The item config tag of ${itemConfigTag} is not a valid value of the "ItemConfigTag" enum.`,
+    );
+
+    return collectibleTypes;
+  }
+
   /**
    * Returns the number of items that a player has towards a particular transformation.
    *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
@@ -912,10 +1029,11 @@ export class ModdedElementSets extends Feature {
     player: EntityPlayer,
     itemConfigTag: ItemConfigTag,
   ): CollectibleType[] {
-    const collectiblesWithTag = this.getCollectiblesWithTag(itemConfigTag);
+    const collectibleTypesWithTag =
+      this.getCollectibleTypesWithTag(itemConfigTag);
 
     const playerCollectibles: CollectibleType[] = [];
-    for (const collectibleType of getSortedSetValues(collectiblesWithTag)) {
+    for (const collectibleType of getSortedSetValues(collectibleTypesWithTag)) {
       // We specify "true" as the second argument to filter out things like Lilith's Incubus.
       const numCollectibles = player.GetCollectibleNum(collectibleType, true);
       repeat(numCollectibles, () => {
@@ -926,9 +1044,42 @@ export class ModdedElementSets extends Feature {
     return playerCollectibles;
   }
 
+  /**
+   * Helper function to get all of the collectible types in the game that count towards a particular
+   * transformation.
+   *
+   * For example, to get all of the collectible types that count towards Guppy:
+   *
+   * ```ts
+   * const guppyCollectibleTypes = getCollectiblesForTransformation(PlayerForm.GUPPY);
+   * ```
+   *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
+   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   */
+  @Exported
+  public getCollectibleTypesForTransformation(
+    playerForm: PlayerForm,
+  ): ReadonlySet<CollectibleType> {
+    const itemConfigTag = TRANSFORMATION_TO_TAG_MAP.get(playerForm);
+    assertDefined(
+      itemConfigTag,
+      `Failed to get the collectible types for the transformation of ${playerForm} because that transformation is not based on collectibles.`,
+    );
+
+    return this.getCollectibleTypesWithTag(itemConfigTag);
+  }
+
   /**
    * Returns the number of items that a player has towards a particular transformation.
    *
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
@@ -937,7 +1088,7 @@ export class ModdedElementSets extends Feature {
     playerForm: PlayerForm,
   ): CollectibleType[] {
     const collectibleForTransformation =
-      this.getCollectiblesForTransformation(playerForm);
+      this.getCollectibleTypesForTransformation(playerForm);
 
     const playerCollectibles: CollectibleType[] = [];
     for (const collectibleType of getSortedSetValues(
@@ -954,100 +1105,46 @@ export class ModdedElementSets extends Feature {
   }
 
   /**
-   * Returns a map containing every trinket type that the player has that matches the provided
-   * `CacheFlag`. The values of the map correspond to the multiplier for that trinket.
-   *
-   * 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).
+   * Returns a set containing every valid passive item that can be randomly granted to Eden as a
+   * starting item.
    *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getPlayerTrinketsWithCacheFlag(
-    player: EntityPlayer,
-    cacheFlag: CacheFlag,
-  ): Map<TrinketType, int> {
-    const trinketsWithCacheFlag = this.getTrinketsWithCacheFlag(cacheFlag);
-
-    const playerTrinkets = new Map<TrinketType, int>();
-    for (const trinketType of trinketsWithCacheFlag) {
-      const trinketMultiplier = player.GetTrinketMultiplier(trinketType);
-      if (trinketMultiplier > 0) {
-        playerTrinkets.set(trinketType, trinketMultiplier);
-      }
-    }
-
-    return playerTrinkets;
-  }
-
-  /**
-   * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
+   * Under the hood, this is determined by looking at the "noeden" tag in "items_metadata.xml".
    *
-   * This will not return:
-   * - any runes
-   * - any objects like Dice Shard
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   *
-   * @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.
    */
   @Exported
-  public getRandomCard(
-    seedOrRNG: Seed | RNG = getRandomSeed(),
-    exceptions: CardType[] = [],
-  ): CardType {
+  public getEdenActiveCollectibleTypes(): ReadonlySet<CollectibleType> {
     this.lazyInit();
-    return getRandomSetElement(this.cardSet, seedOrRNG, exceptions);
+    return this.edenActiveCollectibleTypesSet;
   }
 
   /**
-   * Helper function to get a random card type that matches the provided `ItemConfigCardType`.
+   * Returns a set containing every valid passive item that can be randomly granted to Eden as a
+   * starting item.
    *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   * Under the hood, this is determined by looking at the "noeden" tag in "items_metadata.xml".
    *
-   * @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.
-   */
-  @Exported
-  public getRandomCardTypeOfType(
-    itemConfigCardType: ItemConfigCardType,
-    seedOrRNG: Seed | RNG = getRandomSeed(),
-    exceptions: CardType[] = [],
-  ): CardType {
-    const cardTypeSet = this.getCardTypesOfType(itemConfigCardType);
-    return getRandomSetElement(cardTypeSet, 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.
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
+   * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   *
-   * @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.
    */
   @Exported
-  public getRandomRune(
-    seedOrRNG: Seed | RNG = getRandomSeed(),
-    exceptions: CardType[] = [],
-  ): CardType {
-    const runesSet = this.getCardTypesOfType(ItemConfigCardType.RUNE);
-    runesSet.delete(CardType.RUNE_SHARD);
-    return getRandomSetElement(runesSet, seedOrRNG, exceptions);
+  public getEdenPassiveCollectibleTypes(): ReadonlySet<CollectibleType> {
+    this.lazyInit();
+    return this.edenPassiveCollectibleTypesSet;
   }
 
   /**
    * Returns a random active collectible type that that is a valid starting item for Eden.
    *
    * 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
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
@@ -1057,7 +1154,7 @@ export class ModdedElementSets extends Feature {
    * @param exceptions Optional. An array of runes to not select.
    */
   @Exported
-  public getRandomEdenActiveCollectible(
+  public getRandomEdenActiveCollectibleType(
     seedOrRNG: Seed | RNG = getRandomSeed(),
     exceptions: CollectibleType[] | readonly CollectibleType[] = [],
   ): CollectibleType {
@@ -1073,7 +1170,7 @@ export class ModdedElementSets extends Feature {
    * Returns a random passive collectible type that that is a valid starting item for Eden.
    *
    * 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
+   * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
@@ -1083,7 +1180,7 @@ export class ModdedElementSets extends Feature {
    * @param exceptions Optional. An array of runes to not select.
    */
   @Exported
-  public getRandomEdenPassiveCollectible(
+  public getRandomEdenPassiveCollectibleType(
     seedOrRNG: Seed | RNG = getRandomSeed(),
     exceptions: CollectibleType[] | readonly CollectibleType[] = [],
   ): CollectibleType {
@@ -1095,144 +1192,113 @@ export class ModdedElementSets extends Feature {
     );
   }
 
-  /**
-   * Returns an array containing every modded trinket type in the game.
-   *
-   * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-   * then use the `getModdedTrinketSet` helper function instead.
-   *
-   * 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).
-   *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getTrinketArray(): readonly TrinketType[] {
-    this.lazyInit();
-    return this.allTrinketTypesArray;
-  }
+  // ----------------------
+  // Item Config Card Types
+  // ----------------------
 
   /**
-   * Returns a set containing every modded trinket type in the game.
+   * Helper function to get a set of card types matching the `ItemConfigCardType`.
    *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-   * then use the `getModdedTrinketArray` helper function instead.
+   * 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.
    *
    * 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).
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    */
   @Exported
-  public getTrinketSet(): ReadonlySet<TrinketType> {
+  public getCardTypesOfType(
+    ...itemConfigCardTypes: ItemConfigCardType[]
+  ): Set<CardType> {
     this.lazyInit();
-    return this.allTrinketTypesSet;
-  }
 
-  /**
-   * Returns a set containing every trinket type with the given cache flag, including 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).
-   *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getTrinketsWithCacheFlag(
-    cacheFlag: CacheFlag,
-  ): ReadonlySet<TrinketType> {
-    this.lazyInit();
+    const matchingCardTypes = new Set<CardType>();
+    for (const itemConfigCardType of itemConfigCardTypes) {
+      const cardTypeSet =
+        this.itemConfigCardTypeToCardTypeMap.get(itemConfigCardType);
+      assertDefined(
+        cardTypeSet,
+        `Failed to get the card type set for item config type: ${itemConfigCardType}`,
+      );
 
-    const trinketsSet = this.cacheFlagToTrinketTypesMap.get(cacheFlag);
-    if (trinketsSet === undefined) {
-      return new ReadonlySet();
+      for (const cardType of cardTypeSet) {
+        matchingCardTypes.add(cardType);
+      }
     }
 
-    return trinketsSet;
+    return matchingCardTypes;
   }
 
   /**
-   * Returns an array containing every valid vanilla card type in the game.
+   * Helper function to get a random card type that matches the provided `ItemConfigCardType`.
    *
-   * Use this if you need to iterate over the cards in order. If you need to do O(1) lookups, then
-   * use the `getVanillaCardSet` helper function instead.
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getVanillaCardArray(): readonly CardType[] {
-    this.lazyInitVanillaCardTypes();
-    return this.vanillaCardTypesArray;
-  }
-
-  /**
-   * Returns a set containing every valid vanilla card type in the game.
-   *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the cards in order, then
-   * use the `getVanillaCardArray` helper function instead.
    *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   * @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.
    */
   @Exported
-  public getVanillaCardSet(): ReadonlySet<CardType> {
-    this.lazyInitVanillaCardTypes();
-    return this.vanillaCardTypesSet;
+  public getRandomCardTypeOfType(
+    itemConfigCardType: ItemConfigCardType,
+    seedOrRNG: Seed | RNG = getRandomSeed(),
+    exceptions: CardType[] = [],
+  ): CardType {
+    const cardTypeSet = this.getCardTypesOfType(itemConfigCardType);
+    return getRandomSetElement(cardTypeSet, seedOrRNG, exceptions);
   }
 
   /**
-   * Returns an array containing every valid vanilla collectible type in the game.
-   *
-   * Use this if you need to iterate over the collectibles in order. If you need to do O(1) lookups,
-   * then use the `getVanillaCollectibleSet` helper function instead.
+   * Has an equal chance of returning any card (e.g. Fool, Reverse Fool, Wild Card, etc.).
    *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getVanillaCollectibleArray(): readonly CollectibleType[] {
-    this.lazyInitVanillaCollectibleTypes();
-    return this.vanillaCollectibleTypesArray;
-  }
-
-  /**
-   * Returns a set containing every valid vanilla collectible type in the game.
+   * This will not return:
+   * - any runes
+   * - any objects like Dice Shard
    *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the collectibles in order,
-   * then use the `getVanillaCollectibleArray` helper function instead.
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
-   */
-  @Exported
-  public getVanillaCollectibleSet(): ReadonlySet<CollectibleType> {
-    this.lazyInitVanillaCollectibleTypes();
-    return this.vanillaCollectibleTypesSet;
-  }
-
-  /**
-   * Returns an array containing every valid vanilla trinket type in the game.
    *
-   * Use this if you need to iterate over the trinkets in order. If you need to do O(1) lookups,
-   * then use the `getVanillaTrinketSet` helper function instead.
-   *
-   * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   * @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.
    */
   @Exported
-  public getVanillaTrinketArray(): readonly TrinketType[] {
-    this.lazyInitVanillaTrinketTypes();
-    return this.vanillaTrinketTypesArray;
+  public getRandomCard(
+    seedOrRNG: Seed | RNG = getRandomSeed(),
+    exceptions: CardType[] = [],
+  ): CardType {
+    this.lazyInit();
+    return getRandomSetElement(this.cardSet, seedOrRNG, exceptions);
   }
 
   /**
-   * Returns a set containing every valid vanilla trinket type in the game.
+   * 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.
    *
-   * Use this if you need to do O(1) lookups. If you need to iterate over the trinkets in order,
-   * then use the `getVanillaTrinketArray` helper function instead.
+   * This function can only be called if at least one callback has been executed. This is because
+   * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
+   *
+   * @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.
    */
   @Exported
-  public getVanillaTrinketSet(): ReadonlySet<TrinketType> {
-    this.lazyInitVanillaTrinketTypes();
-    return this.vanillaTrinketTypesSet;
+  public getRandomRune(
+    seedOrRNG: Seed | RNG = getRandomSeed(),
+    exceptions: CardType[] = [],
+  ): CardType {
+    const runesSet = this.getCardTypesOfType(ItemConfigCardType.RUNE);
+    runesSet.delete(CardType.RUNE_SHARD);
+    return getRandomSetElement(runesSet, seedOrRNG, exceptions);
   }
 }