isaacscript-common 14.2.0 → 15.0.0

package/src/enums/private/GridEntityTypeCustom.ts

@@ -0,0 +1,9 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export const GridEntityTypeCustom = {
+  /**
+   * We arbitrarily choose 1000 as to not conflict with end-user mods. (The expectation is that
+   * end-user mods will begin their enums with values of 0 and increment upwards.)
+   */
+  TRAPDOOR_CUSTOM: 1000 as GridEntityType,
+} as const;

package/src/enums/private/UIStreakAnimation.ts

@@ -0,0 +1,6 @@
+/** Corresponds to "resources/gfx/ui/ui_streak.anm2". */
+export enum UIStreakAnimation {
+  NONE,
+  TEXT,
+  TEXT_STAY,
+}

package/src/features.ts

@@ -12,14 +12,52 @@ import { PlayerCollectibleDetection } from "./classes/features/callbackLogic/Pla
 import { PlayerReorderedCallbacks } from "./classes/features/callbackLogic/PlayerReorderedCallbacks";
 import { SlotRenderDetection } from "./classes/features/callbackLogic/SlotRenderDetection";
 import { SlotUpdateDetection } from "./classes/features/callbackLogic/SlotUpdateDetection";
+import { CharacterHealthConversion } from "./classes/features/other/CharacterHealthConversion";
+import { CharacterStats } from "./classes/features/other/CharacterStats";
+import { CollectibleItemPoolType } from "./classes/features/other/CollectibleItemPoolType";
+import { CustomHotkeys } from "./classes/features/other/CustomHotkeys";
+import { CustomItemPools } from "./classes/features/other/CustomItemPools";
+import { CustomPickups } from "./classes/features/other/CustomPickups";
+import { CustomStages } from "./classes/features/other/CustomStages";
+import { CustomTrapdoors } from "./classes/features/other/CustomTrapdoors";
+import { DebugDisplay } from "./classes/features/other/DebugDisplay";
+import { DeployJSONRoom } from "./classes/features/other/DeployJSONRoom";
+import { DisableAllSound } from "./classes/features/other/DisableAllSound";
+import { DisableInputs } from "./classes/features/other/DisableInputs";
+import { ExtraConsoleCommands } from "./classes/features/other/ExtraConsoleCommands";
+import { FadeInRemover } from "./classes/features/other/FadeInRemover";
+import { FastReset } from "./classes/features/other/FastReset";
+import { FlyingDetection } from "./classes/features/other/FlyingDetection";
+import { ForgottenSwitch } from "./classes/features/other/ForgottenSwitch";
+import { ItemPoolDetection } from "./classes/features/other/ItemPoolDetection";
+import { ModdedElementDetection } from "./classes/features/other/ModdedElementDetection";
+import { ModdedElementSets } from "./classes/features/other/ModdedElementSets";
+import { NoSirenSteal } from "./classes/features/other/NoSirenSteal";
+import { Pause } from "./classes/features/other/Pause";
+import { PersistentEntities } from "./classes/features/other/PersistentEntities";
+import { PickupIndexCreation } from "./classes/features/other/PickupIndexCreation";
+import { PlayerInventory } from "./classes/features/other/PlayerInventory";
+import { PonyDetection } from "./classes/features/other/PonyDetection";
+import { PreventChildEntities } from "./classes/features/other/PreventChildEntities";
+import { PreventCollectibleRotation } from "./classes/features/other/PreventCollectibleRotation";
+import { PreventGridEntityRespawn } from "./classes/features/other/PreventGridEntityRespawn";
+import { RoomClearFrame } from "./classes/features/other/RoomClearFrame";
+import { RoomHistory } from "./classes/features/other/RoomHistory";
 import { RunInNFrames } from "./classes/features/other/RunInNFrames";
+import { RunNextRoom } from "./classes/features/other/RunNextRoom";
 import { SaveDataManager } from "./classes/features/other/SaveDataManager";
+import { SpawnCollectible } from "./classes/features/other/SpawnCollectible";
+import { SpawnRockAltRewards } from "./classes/features/other/SpawnRockAltRewards";
+import { StageHistory } from "./classes/features/other/StageHistory";
+import { StartAmbush } from "./classes/features/other/StartAmbush";
+import { TaintedLazarusPlayers } from "./classes/features/other/TaintedLazarusPlayers";
 import { ISCFeature } from "./enums/ISCFeature";
-import { ModCallbackCustom2 } from "./enums/ModCallbackCustom2";
+import { ModCallbackCustom } from "./enums/ModCallbackCustom";
 import {
   newObjectWithEnumKeys,
   validateInterfaceMatchesEnum,
 } from "./functions/utils";
+import { ModUpgradedInterface } from "./interfaces/private/ModUpgradedInterface";
 
 export interface ISCFeatureToClass {
   // Callback logic
@@ -37,89 +75,207 @@ export interface ISCFeatureToClass {
   [ISCFeature.SLOT_UPDATE_DETECTION]: SlotUpdateDetection;
 
   // Extra features
+  [ISCFeature.CHARACTER_HEALTH_CONVERSION]: CharacterHealthConversion;
+  [ISCFeature.CHARACTER_STATS]: CharacterStats;
+  [ISCFeature.COLLECTIBLE_ITEM_POOL_TYPE]: CollectibleItemPoolType;
   [ISCFeature.CUSTOM_GRID_ENTITIES]: CustomGridEntities;
+  [ISCFeature.CUSTOM_ITEM_POOLS]: CustomItemPools;
+  [ISCFeature.CUSTOM_HOTKEYS]: CustomHotkeys;
+  [ISCFeature.CUSTOM_PICKUPS]: CustomPickups;
+  [ISCFeature.CUSTOM_STAGES]: CustomStages;
+  [ISCFeature.CUSTOM_TRAPDOORS]: CustomTrapdoors;
+  [ISCFeature.DEBUG_DISPLAY]: DebugDisplay;
+  [ISCFeature.DEPLOY_JSON_ROOM]: DeployJSONRoom;
+  [ISCFeature.DISABLE_ALL_SOUND]: DisableAllSound;
+  [ISCFeature.DISABLE_INPUTS]: DisableInputs;
+  [ISCFeature.FADE_IN_REMOVER]: FadeInRemover;
+  [ISCFeature.FAST_RESET]: FastReset;
+  [ISCFeature.FLYING_DETECTION]: FlyingDetection;
+  [ISCFeature.FORGOTTEN_SWITCH]: ForgottenSwitch;
+  [ISCFeature.EXTRA_CONSOLE_COMMANDS]: ExtraConsoleCommands;
+  [ISCFeature.ITEM_POOL_DETECTION]: ItemPoolDetection;
+  [ISCFeature.MODDED_ELEMENT_DETECTION]: ModdedElementDetection;
+  [ISCFeature.MODDED_ELEMENT_SETS]: ModdedElementSets;
+  [ISCFeature.NO_SIREN_STEAL]: NoSirenSteal;
+  [ISCFeature.PAUSE]: Pause;
+  [ISCFeature.PERSISTENT_ENTITIES]: PersistentEntities;
+  [ISCFeature.PICKUP_INDEX]: PickupIndexCreation;
+  [ISCFeature.PLAYER_INVENTORY]: PlayerInventory;
+  [ISCFeature.PONY_DETECTION]: PonyDetection;
+  [ISCFeature.PREVENT_CHILD_ENTITIES]: PreventChildEntities;
+  [ISCFeature.PREVENT_COLLECTIBLE_ROTATION]: PreventCollectibleRotation;
+  [ISCFeature.PREVENT_GRID_ENTITY_RESPAWN]: PreventGridEntityRespawn;
+  [ISCFeature.ROOM_CLEAR_FRAME]: RoomClearFrame;
+  [ISCFeature.ROOM_HISTORY]: RoomHistory;
   [ISCFeature.RUN_IN_N_FRAMES]: RunInNFrames;
+  [ISCFeature.RUN_NEXT_ROOM]: RunNextRoom;
   [ISCFeature.SAVE_DATA_MANAGER]: SaveDataManager;
+  [ISCFeature.SPAWN_ALT_ROCK_REWARDS]: SpawnRockAltRewards;
+  [ISCFeature.SPAWN_COLLECTIBLE]: SpawnCollectible;
+  [ISCFeature.STAGE_HISTORY]: StageHistory;
+  [ISCFeature.START_AMBUSH]: StartAmbush;
+  [ISCFeature.TAINTED_LAZARUS_PLAYERS]: TaintedLazarusPlayers;
 }
 
 validateInterfaceMatchesEnum<ISCFeatureToClass, ISCFeature>();
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function getFeatures(mod: Mod, callbacks: ModCallbackCustomToClass) {
+export function getFeatures(
+  mod: ModUpgradedInterface,
+  callbacks: ModCallbackCustomToClass,
+) {
   // Some features rely on other features; we must initialize those first.
+  const gameReorderedCallbacks = new GameReorderedCallbacks(
+    callbacks[ModCallbackCustom.POST_GAME_STARTED_REORDERED],
+    callbacks[ModCallbackCustom.POST_NEW_LEVEL_REORDERED],
+    callbacks[ModCallbackCustom.POST_NEW_ROOM_REORDERED],
+    callbacks[ModCallbackCustom.POST_GAME_STARTED_REORDERED_LAST],
+  );
+
+  const disableAllSound = new DisableAllSound();
+  const disableInputs = new DisableInputs();
+  const moddedElementDetection = new ModdedElementDetection();
+  const ponyDetection = new PonyDetection();
+  const preventCollectibleRotation = new PreventCollectibleRotation();
+  const roomClearFrame = new RoomClearFrame();
+  const roomHistory = new RoomHistory();
   const runInNFrames = new RunInNFrames();
+  const runNextRoom = new RunNextRoom();
+  const stageHistory = new StageHistory();
+
   const customGridEntities = new CustomGridEntities(runInNFrames);
+  const moddedElementSets = new ModdedElementSets(moddedElementDetection);
+  const itemPoolDetection = new ItemPoolDetection(moddedElementSets);
+  const pause = new Pause(disableInputs);
+  const preventGridEntityRespawn = new PreventGridEntityRespawn(runInNFrames);
+  const spawnCollectible = new SpawnCollectible(preventCollectibleRotation);
+
+  const customTrapdoors = new CustomTrapdoors(
+    customGridEntities,
+    disableInputs,
+    ponyDetection,
+    roomClearFrame,
+    runInNFrames,
+    runNextRoom,
+    stageHistory,
+  );
 
   return newObjectWithEnumKeys(ISCFeature, {
     // Callback logic
     [ISCFeature.CUSTOM_REVIVE]: new CustomRevive(
-      callbacks[ModCallbackCustom2.PRE_CUSTOM_REVIVE],
-      callbacks[ModCallbackCustom2.POST_CUSTOM_REVIVE],
+      callbacks[ModCallbackCustom.PRE_CUSTOM_REVIVE],
+      callbacks[ModCallbackCustom.POST_CUSTOM_REVIVE],
+      runInNFrames,
     ),
     [ISCFeature.ESAU_JR_DETECTION]: new EsauJrDetection(
-      callbacks[ModCallbackCustom2.POST_ESAU_JR],
-      callbacks[ModCallbackCustom2.POST_FIRST_ESAU_JR],
+      callbacks[ModCallbackCustom.POST_ESAU_JR],
+      callbacks[ModCallbackCustom.POST_FIRST_ESAU_JR],
     ),
     [ISCFeature.FLIP_DETECTION]: new FlipDetection(
-      callbacks[ModCallbackCustom2.POST_FLIP],
-      callbacks[ModCallbackCustom2.POST_FIRST_FLIP],
+      callbacks[ModCallbackCustom.POST_FLIP],
+      callbacks[ModCallbackCustom.POST_FIRST_FLIP],
     ),
     [ISCFeature.GRID_ENTITY_COLLISION_DETECTION]:
       new GridEntityCollisionDetection(
-        callbacks[ModCallbackCustom2.POST_GRID_ENTITY_COLLISION],
-        callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_COLLISION],
+        callbacks[ModCallbackCustom.POST_GRID_ENTITY_COLLISION],
+        callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_COLLISION],
         customGridEntities,
       ),
     [ISCFeature.GRID_ENTITY_UPDATE_DETECTION]: new GridEntityUpdateDetection(
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_INIT],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_INIT],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_UPDATE],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_UPDATE],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_REMOVE],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_REMOVE],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_STATE_CHANGED],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_BROKEN],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_BROKEN],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_INIT],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_INIT],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_UPDATE],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_UPDATE],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_REMOVE],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_REMOVE],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_STATE_CHANGED],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_STATE_CHANGED],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_BROKEN],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_BROKEN],
       customGridEntities,
     ),
     [ISCFeature.GRID_ENTITY_RENDER_DETECTION]: new GridEntityRenderDetection(
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_RENDER],
-      callbacks[ModCallbackCustom2.POST_GRID_ENTITY_CUSTOM_RENDER],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_RENDER],
+      callbacks[ModCallbackCustom.POST_GRID_ENTITY_CUSTOM_RENDER],
       customGridEntities,
     ),
-    [ISCFeature.GAME_REORDERED_CALLBACKS]: new GameReorderedCallbacks(
-      callbacks[ModCallbackCustom2.POST_GAME_STARTED_REORDERED],
-      callbacks[ModCallbackCustom2.POST_NEW_LEVEL_REORDERED],
-      callbacks[ModCallbackCustom2.POST_NEW_ROOM_REORDERED],
-      callbacks[ModCallbackCustom2.POST_GAME_STARTED_REORDERED_LAST],
-    ),
+    [ISCFeature.GAME_REORDERED_CALLBACKS]: gameReorderedCallbacks,
     [ISCFeature.ITEM_PICKUP_DETECTION]: new ItemPickupDetection(
-      callbacks[ModCallbackCustom2.POST_ITEM_PICKUP],
-      callbacks[ModCallbackCustom2.PRE_ITEM_PICKUP],
+      callbacks[ModCallbackCustom.POST_ITEM_PICKUP],
+      callbacks[ModCallbackCustom.PRE_ITEM_PICKUP],
     ),
     [ISCFeature.PLAYER_COLLECTIBLE_DETECTION]: new PlayerCollectibleDetection(
-      callbacks[ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_ADDED],
-      callbacks[ModCallbackCustom2.POST_PLAYER_COLLECTIBLE_REMOVED],
+      callbacks[ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED],
+      callbacks[ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED],
+      moddedElementSets,
       runInNFrames,
     ),
     [ISCFeature.PLAYER_REORDERED_CALLBACKS]: new PlayerReorderedCallbacks(
-      callbacks[ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED],
-      callbacks[ModCallbackCustom2.POST_PLAYER_RENDER_REORDERED],
-      callbacks[ModCallbackCustom2.POST_PEFFECT_UPDATE_REORDERED],
+      callbacks[ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED],
+      callbacks[ModCallbackCustom.POST_PLAYER_RENDER_REORDERED],
+      callbacks[ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED],
     ),
     [ISCFeature.SLOT_RENDER_DETECTION]: new SlotRenderDetection(
-      callbacks[ModCallbackCustom2.POST_SLOT_RENDER],
-      callbacks[ModCallbackCustom2.POST_SLOT_ANIMATION_CHANGED],
+      callbacks[ModCallbackCustom.POST_SLOT_RENDER],
+      callbacks[ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED],
     ),
     [ISCFeature.SLOT_UPDATE_DETECTION]: new SlotUpdateDetection(
-      callbacks[ModCallbackCustom2.POST_SLOT_INIT],
-      callbacks[ModCallbackCustom2.POST_SLOT_UPDATE],
+      callbacks[ModCallbackCustom.POST_SLOT_INIT],
+      callbacks[ModCallbackCustom.POST_SLOT_UPDATE],
     ),
 
     // Extra features
+    [ISCFeature.CHARACTER_HEALTH_CONVERSION]: new CharacterHealthConversion(),
+    [ISCFeature.CHARACTER_STATS]: new CharacterStats(),
+    [ISCFeature.COLLECTIBLE_ITEM_POOL_TYPE]: new CollectibleItemPoolType(),
     [ISCFeature.CUSTOM_GRID_ENTITIES]: customGridEntities,
+    [ISCFeature.CUSTOM_ITEM_POOLS]: new CustomItemPools(),
+    [ISCFeature.CUSTOM_HOTKEYS]: new CustomHotkeys(),
+    [ISCFeature.CUSTOM_PICKUPS]: new CustomPickups(),
+    [ISCFeature.CUSTOM_STAGES]: new CustomStages(
+      customGridEntities,
+      customTrapdoors,
+      disableAllSound,
+      gameReorderedCallbacks,
+      pause,
+      runInNFrames,
+    ),
+    [ISCFeature.CUSTOM_TRAPDOORS]: customTrapdoors,
+    [ISCFeature.DEBUG_DISPLAY]: new DebugDisplay(mod),
+    [ISCFeature.DEPLOY_JSON_ROOM]: new DeployJSONRoom(
+      preventGridEntityRespawn,
+      spawnCollectible,
+    ),
+    [ISCFeature.DISABLE_ALL_SOUND]: disableAllSound,
+    [ISCFeature.DISABLE_INPUTS]: disableInputs,
+    [ISCFeature.FADE_IN_REMOVER]: new FadeInRemover(),
+    [ISCFeature.FAST_RESET]: new FastReset(),
+    [ISCFeature.FLYING_DETECTION]: new FlyingDetection(moddedElementSets),
+    [ISCFeature.FORGOTTEN_SWITCH]: new ForgottenSwitch(),
+    [ISCFeature.EXTRA_CONSOLE_COMMANDS]: new ExtraConsoleCommands(),
+    [ISCFeature.ITEM_POOL_DETECTION]: itemPoolDetection,
+    [ISCFeature.MODDED_ELEMENT_DETECTION]: moddedElementDetection,
+    [ISCFeature.MODDED_ELEMENT_SETS]: moddedElementSets,
+    [ISCFeature.NO_SIREN_STEAL]: new NoSirenSteal(),
+    [ISCFeature.PAUSE]: pause,
+    [ISCFeature.PERSISTENT_ENTITIES]: new PersistentEntities(roomHistory),
+    [ISCFeature.PICKUP_INDEX]: new PickupIndexCreation(roomHistory),
+    [ISCFeature.PLAYER_INVENTORY]: new PlayerInventory(),
+    [ISCFeature.PONY_DETECTION]: ponyDetection,
+    [ISCFeature.PREVENT_CHILD_ENTITIES]: new PreventChildEntities(),
+    [ISCFeature.PREVENT_COLLECTIBLE_ROTATION]: preventCollectibleRotation,
+    [ISCFeature.PREVENT_GRID_ENTITY_RESPAWN]: preventGridEntityRespawn,
+    [ISCFeature.ROOM_CLEAR_FRAME]: roomClearFrame,
+    [ISCFeature.ROOM_HISTORY]: roomHistory,
     [ISCFeature.RUN_IN_N_FRAMES]: runInNFrames,
+    [ISCFeature.RUN_NEXT_ROOM]: runNextRoom,
     [ISCFeature.SAVE_DATA_MANAGER]: new SaveDataManager(mod),
+    [ISCFeature.SPAWN_ALT_ROCK_REWARDS]: new SpawnRockAltRewards(
+      itemPoolDetection,
+    ),
+    [ISCFeature.SPAWN_COLLECTIBLE]: spawnCollectible,
+    [ISCFeature.STAGE_HISTORY]: stageHistory,
+    [ISCFeature.START_AMBUSH]: new StartAmbush(runInNFrames),
+    [ISCFeature.TAINTED_LAZARUS_PLAYERS]: new TaintedLazarusPlayers(),
   } as const);
 }

package/src/functions/ambush.ts

@@ -1,12 +1,6 @@
-import { RoomType, SackSubType } from "isaac-typescript-definitions";
+import { RoomType } from "isaac-typescript-definitions";
 import { game } from "../core/cachedClasses";
 import { AmbushType } from "../enums/AmbushType";
-import { runNextGameFrame } from "../features/runInNFrames";
-import { removeEntities } from "./entities";
-import { getCoins, spawnSackWithSeed } from "./pickupsSpecific";
-
-/** Hard-coding this makes it easier to clean up the pickups afterwards. */
-const SACK_SEED_THAT_SPAWNS_TWO_COINS = 6 as Seed;
 
 /**
  * Helper function to get the corresponding ambush type for the current room. Returns undefined if
@@ -30,41 +24,3 @@ export function getAmbushType(): AmbushType | undefined {
     }
   }
 }
-
-/**
- * Helper function to start a Challenge Room or the Boss Rush.
- *
- * Specifically, this is performed by spawning a sack on top of the player, waiting a game frame,
- * and then removing the sack and the pickups that the sack dropped.
- */
-export function startAmbush(): void {
-  const player = Isaac.GetPlayer();
-  const sack = spawnSackWithSeed(
-    SackSubType.NULL,
-    player.Position,
-    SACK_SEED_THAT_SPAWNS_TWO_COINS,
-  );
-
-  // The sack will play the "Appear" animation and the player will not be able to interact with it
-  // while this is occurring. By stopping the animation, it will transition to the "Idle" animation
-  // and be interactable on the next game frame.
-  const sprite = sack.GetSprite();
-  sprite.Stop();
-  const sackPtr = EntityPtr(sack);
-  runNextGameFrame(() => {
-    const futureSack = sackPtr.Ref;
-    if (futureSack === undefined) {
-      return;
-    }
-
-    futureSack.Remove();
-    const sackPtrHash = GetPtrHash(futureSack);
-    const coins = getCoins();
-    const coinsFromSack = coins.filter(
-      (pickup) =>
-        pickup.SpawnerEntity !== undefined &&
-        GetPtrHash(pickup.SpawnerEntity) === sackPtrHash,
-    );
-    removeEntities(coinsFromSack);
-  });
-}

package/src/functions/characters.ts

@@ -9,6 +9,15 @@ import { CHARACTERS_WITH_NO_RED_HEARTS_SET } from "../sets/charactersWithNoRedHe
 import { CHARACTERS_WITH_NO_SOUL_HEARTS_SET } from "../sets/charactersWithNoSoulHeartsSet";
 import { LOST_STYLE_CHARACTERS_SET } from "../sets/lostStyleCharactersSet";
 
+const FLYING_CHARACTERS: ReadonlySet<PlayerType> = new Set([
+  PlayerType.AZAZEL, // 7
+  PlayerType.LOST, // 10
+  PlayerType.SOUL, // 17
+  PlayerType.LOST_B, // 31
+  PlayerType.JACOB_2_B, // 39
+  PlayerType.SOUL_B, // 40
+]);
+
 /**
  * Helper function to determine if the given character can have red heart containers. Returns true
  * for characters like Isaac, Magdalene, or Cain. Returns true for Keeper and Tainted Keeper, even
@@ -124,6 +133,11 @@ export function getCharacterName(character: PlayerType): string {
   return CHARACTER_NAMES[character];
 }
 
+export function isFlyingCharacter(player: EntityPlayer): boolean {
+  const character = player.GetPlayerType();
+  return FLYING_CHARACTERS.has(character);
+}
+
 export function isModdedCharacter(character: PlayerType): boolean {
   return !isVanillaCharacter(character);
 }

package/src/functions/collectibleTag.ts

@@ -1,38 +1,5 @@
 import { CollectibleType, ItemConfigTag } from "isaac-typescript-definitions";
 import { itemConfig } from "../core/cachedClasses";
-import { getCollectibleArray } from "./collectibleSet";
-import { getEnumValues } from "./enums";
-import { getFlagName } from "./flag";
-import { getPlayerCollectibleCount } from "./players";
-
-const TAG_TO_COLLECTIBLE_TYPES_MAP = new Map<
-  ItemConfigTag,
-  Set<CollectibleType>
->();
-
-function initTagMap() {
-  // The tag to collectible types map should be valid for every tag, so we initialize it with empty
-  // sets.
-  for (const itemConfigTag of getEnumValues(ItemConfigTag)) {
-    TAG_TO_COLLECTIBLE_TYPES_MAP.set(itemConfigTag, new Set());
-  }
-
-  for (const collectibleType of getCollectibleArray()) {
-    for (const itemConfigTag of getEnumValues(ItemConfigTag)) {
-      if (!collectibleHasTag(collectibleType, itemConfigTag)) {
-        continue;
-      }
-
-      const collectibleTypesSet =
-        TAG_TO_COLLECTIBLE_TYPES_MAP.get(itemConfigTag);
-      if (collectibleTypesSet === undefined) {
-        const flagName = getFlagName(itemConfigTag, ItemConfigTag);
-        error(`Failed to get the collectible types for item tag: ${flagName}`);
-      }
-      collectibleTypesSet.add(collectibleType);
-    }
-  }
-}
 
 export function collectibleHasTag(
   collectibleType: CollectibleType,
@@ -46,43 +13,6 @@ export function collectibleHasTag(
   return itemConfigItem.HasTags(tag);
 }
 
-/**
- * Helper function to get all of the collectible types in the game that have a certain 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);
- * ```
- */
-export function getCollectibleTypesWithTag(
-  itemConfigTag: ItemConfigTag,
-): ReadonlySet<CollectibleType> {
-  // Lazy initialize the map.
-  if (TAG_TO_COLLECTIBLE_TYPES_MAP.size === 0) {
-    initTagMap();
-  }
-
-  const collectibleTypes = TAG_TO_COLLECTIBLE_TYPES_MAP.get(itemConfigTag);
-  if (collectibleTypes === undefined) {
-    error(
-      `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. */
-export function getPlayerNumCollectiblesWithTag(
-  player: EntityPlayer,
-  itemConfigTag: ItemConfigTag,
-): int {
-  const collectibleTypesSet = getCollectibleTypesWithTag(itemConfigTag);
-  return getPlayerCollectibleCount(player, ...collectibleTypesSet.values());
-}
-
 export function isQuestCollectible(collectibleType: CollectibleType): boolean {
   return collectibleHasTag(collectibleType, ItemConfigTag.QUEST);
 }

package/src/functions/collectibles.ts

@@ -1,4 +1,5 @@
 import {
+  CacheFlag,
   CollectiblePedestalType,
   CollectibleSpriteLayer,
   CollectibleType,
@@ -29,6 +30,7 @@ import {
 import { SINGLE_USE_ACTIVE_COLLECTIBLE_TYPES_SET } from "../sets/singleUseActiveCollectibleTypesSet";
 import { CollectibleIndex } from "../types/CollectibleIndex";
 import { getEntityID } from "./entities";
+import { hasFlag } from "./flag";
 import { isCollectible } from "./pickupVariants";
 import { getRoomListIndex } from "./roomData";
 import { clearSprite, spriteEquals } from "./sprites";
@@ -55,6 +57,19 @@ export function clearCollectibleSprite(collectible: EntityPickup): void {
   setCollectibleSprite(collectible, undefined);
 }
 
+/** Helper function to check in the item config if a given collectible has a given cache flag. */
+export function collectibleHasCacheFlag(
+  collectibleType: CollectibleType,
+  cacheFlag: CacheFlag,
+): boolean {
+  const itemConfigItem = itemConfig.GetCollectible(collectibleType);
+  if (itemConfigItem === undefined) {
+    return false;
+  }
+
+  return hasFlag(itemConfigItem.CacheFlags, cacheFlag);
+}
+
 /** Helper function to check if two collectible sprites have the same sprite sheet loaded. */
 export function collectibleSpriteEquals(
   sprite1: Sprite,

package/src/functions/deepCopy.ts

@@ -1,7 +1,7 @@
 import { DefaultMap } from "../classes/DefaultMap";
+import { SAVE_DATA_MANAGER_DEBUG } from "../classes/features/other/saveDataManager/constants";
 import { SerializationBrand } from "../enums/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
-import { SAVE_DATA_MANAGER_DEBUG } from "../features/saveDataManager/constants";
 import { AnyClass } from "../types/AnyClass";
 import { TSTLClass } from "../types/TSTLClass";
 import { isArray } from "./array";