isaacscript-common 14.2.0 → 15.0.0

package/src/classes/features/other/extraConsoleCommands/subroutines.ts

@@ -0,0 +1,164 @@
+import {
+  Direction,
+  EntityType,
+  GridEntityType,
+  GridRoom,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../../../../core/cachedClasses";
+import { HealthType } from "../../../../enums/HealthType";
+import { directionToVector } from "../../../../functions/direction";
+import { spawnGridEntityWithVariant } from "../../../../functions/gridEntities";
+import {
+  getRoomAdjacentGridIndexes,
+  getRoomGridIndexesForType,
+} from "../../../../functions/levelGrid";
+import {
+  logAllEntities,
+  logAllGridEntities,
+} from "../../../../functions/logEntities";
+import { addPlayerHealthType } from "../../../../functions/playerHealth";
+import { getRoomData, getRoomDescriptor } from "../../../../functions/roomData";
+import { changeRoom } from "../../../../functions/rooms";
+import { printConsole } from "../../../../functions/utils";
+import { ROOM_TYPE_NAMES } from "../../../../objects/roomTypeNames";
+
+const DEFAULT_MOVE_UNITS = 0.5;
+
+export function addHeart(params: string, healthType: HealthType): void {
+  let numHearts = healthType === HealthType.MAX_HEARTS ? 2 : 1;
+  if (params !== "") {
+    const num = tonumber(params);
+    if (num === undefined) {
+      printConsole("That is an invalid amount of hearts to add.");
+      return;
+    }
+
+    numHearts = num;
+  }
+
+  const player = Isaac.GetPlayer();
+  addPlayerHealthType(player, healthType, numHearts);
+}
+
+export function devilAngel(useDevil: boolean): void {
+  const level = game.GetLevel();
+
+  const devilAngelRoomData = getRoomData(GridRoom.DEVIL);
+  if (devilAngelRoomData !== undefined) {
+    const roomType = devilAngelRoomData.Type;
+    const conflictingType = useDevil ? RoomType.ANGEL : RoomType.DEVIL;
+    if (roomType === conflictingType) {
+      // Delete the room data, which will allow the `Level.InitializeDevilAngelRoom` method to work.
+      const roomDescriptor = getRoomDescriptor(GridRoom.DEVIL);
+      roomDescriptor.Data = undefined;
+    }
+  }
+
+  if (useDevil) {
+    level.InitializeDevilAngelRoom(false, true);
+  } else {
+    level.InitializeDevilAngelRoom(true, false);
+  }
+
+  changeRoom(GridRoom.DEVIL);
+}
+
+export function listEntities(
+  params: string,
+  includeBackgroundEffects: boolean,
+): void {
+  let entityTypeFilter: EntityType | undefined;
+  if (params !== "") {
+    entityTypeFilter = tonumber(params);
+    if (entityTypeFilter === undefined) {
+      printConsole("That is an invalid entity type to filter by.");
+      return;
+    }
+  }
+
+  logAllEntities(includeBackgroundEffects, entityTypeFilter);
+  printConsole('Logged the entities in the room to the "log.txt" file.');
+}
+
+export function listGridEntities(params: string, includeWalls: boolean): void {
+  let gridEntityTypeFilter: GridEntityType | undefined;
+  if (params !== "") {
+    gridEntityTypeFilter = tonumber(params);
+    if (gridEntityTypeFilter === undefined) {
+      printConsole("That is an invalid grid entity type to filter by.");
+      return;
+    }
+  }
+
+  logAllGridEntities(includeWalls, gridEntityTypeFilter);
+  printConsole('Logged the grid entities in the room to the "log.txt" file.');
+}
+
+export function movePlayer(params: string, direction: Direction): void {
+  let amount = DEFAULT_MOVE_UNITS;
+  if (params !== "") {
+    const num = tonumber(params);
+    if (num === undefined) {
+      printConsole("That is an invalid amount of units to move.");
+      return;
+    }
+
+    amount = num;
+  }
+
+  const player = Isaac.GetPlayer();
+  const vector = directionToVector(direction);
+  const modifiedVector = vector.mul(amount);
+  player.Position = player.Position.add(modifiedVector);
+}
+
+export function spawnTrapdoorOrCrawlSpace(trapdoor: boolean): void {
+  const room = game.GetRoom();
+  const player = Isaac.GetPlayer();
+  const position = room.FindFreeTilePosition(player.Position, 0);
+  const gridIndex = room.GetGridIndex(position);
+  const gridEntityType = trapdoor
+    ? GridEntityType.TRAPDOOR
+    : GridEntityType.CRAWL_SPACE;
+
+  spawnGridEntityWithVariant(gridEntityType, 0, gridIndex);
+}
+
+export function warpToRoomType(roomType: RoomType): void {
+  const roomTypeName = ROOM_TYPE_NAMES[roomType];
+  const gridIndexes = getRoomGridIndexesForType(roomType);
+  const firstGridIndex = gridIndexes[0];
+  if (firstGridIndex === undefined) {
+    printConsole(`There are no ${roomTypeName}s on this floor.`);
+    return;
+  }
+
+  changeRoom(firstGridIndex);
+  printConsole(`Warped to room type: ${roomTypeName} (${roomType})`);
+}
+
+export function warpNextToRoomType(roomType: RoomType): void {
+  const roomTypeName = ROOM_TYPE_NAMES[roomType];
+  const gridIndexes = getRoomGridIndexesForType(roomType);
+  const firstGridIndex = gridIndexes[0];
+  if (firstGridIndex === undefined) {
+    printConsole(`There are no ${roomTypeName}s on this floor.`);
+    return;
+  }
+
+  const adjacentRoomGridIndexes = getRoomAdjacentGridIndexes(firstGridIndex);
+
+  for (const [_doorSlot, roomGridIndex] of adjacentRoomGridIndexes.entries()) {
+    const roomData = getRoomData(roomGridIndex);
+    if (roomData !== undefined && roomData.Type === RoomType.DEFAULT) {
+      changeRoom(roomGridIndex);
+      printConsole(`Warped next to room type: ${roomTypeName} (${roomType})`);
+      return;
+    }
+  }
+
+  printConsole(
+    `Failed to find the room next to room type: ${roomTypeName} (${roomType})`,
+  );
+}

package/src/classes/features/other/extraConsoleCommands/v.ts

@@ -0,0 +1,27 @@
+export const v = {
+  persistent: {
+    // Curses
+    darkness: false, // 1
+    labyrinth: false, // 2
+    lost: false, // 3
+    unknown: false, // 4
+    cursed: false, // 5
+    maze: false, // 6
+    blind: false, // 7
+    giant: false, // 8
+    disableCurses: false,
+
+    // Stats
+    damage: false,
+    damageAmount: 500,
+    speed: false,
+    speedAmount: 2.0,
+    tears: false,
+    tearsAmount: 1, // In tear delay, not tears stat
+    flight: false,
+
+    // Other
+    chaosCardTears: false,
+    spamBloodRights: false,
+  },
+};

package/src/classes/features/other/saveDataManager/constants.ts

@@ -0,0 +1 @@
+export const SAVE_DATA_MANAGER_DEBUG = false as boolean;

package/src/classes/features/other/saveDataManager/glowingHourGlass.ts

@@ -3,12 +3,12 @@
 
 import { SaveDataKey } from "../../../../enums/SaveDataKey";
 import { SerializationType } from "../../../../enums/SerializationType";
-import { SAVE_DATA_MANAGER_DEBUG } from "../../../../features/saveDataManager/constants";
 import { deepCopy } from "../../../../functions/deepCopy";
 import { merge } from "../../../../functions/merge";
 import { iterateTableInOrder } from "../../../../functions/table";
 import { SaveData } from "../../../../interfaces/SaveData";
 import { AnyClass } from "../../../../types/AnyClass";
+import { SAVE_DATA_MANAGER_DEBUG } from "./constants";
 
 /**
  * When the Glowing Hour Glass is used, certain save data keys will automatically be restored to a

package/src/classes/features/other/saveDataManager/loadFromDisk.ts

@@ -1,4 +1,3 @@
-import { SAVE_DATA_MANAGER_DEBUG } from "../../../../features/saveDataManager/constants";
 import { jsonDecode } from "../../../../functions/jsonHelpers";
 import { log } from "../../../../functions/log";
 import { logError } from "../../../../functions/logMisc";
@@ -7,6 +6,7 @@ import { iterateTableInOrder } from "../../../../functions/table";
 import { isString, isTable } from "../../../../functions/types";
 import { SaveData } from "../../../../interfaces/SaveData";
 import { AnyClass } from "../../../../types/AnyClass";
+import { SAVE_DATA_MANAGER_DEBUG } from "./constants";
 
 const DEFAULT_MOD_DATA = "{}";
 

package/src/classes/features/other/saveDataManager/restoreDefaults.ts

@@ -3,11 +3,11 @@
 
 import { SaveDataKey } from "../../../../enums/SaveDataKey";
 import { SerializationType } from "../../../../enums/SerializationType";
-import { SAVE_DATA_MANAGER_DEBUG } from "../../../../features/saveDataManager/constants";
 import { deepCopy } from "../../../../functions/deepCopy";
 import { logError } from "../../../../functions/logMisc";
 import { clearTable, iterateTableInOrder } from "../../../../functions/table";
 import { SaveData } from "../../../../interfaces/SaveData";
+import { SAVE_DATA_MANAGER_DEBUG } from "./constants";
 
 const RESETTABLE_SAVE_DATA_KEYS: ReadonlySet<SaveDataKey> = new Set([
   SaveDataKey.RUN,

package/src/classes/features/other/saveDataManager/saveToDisk.ts

@@ -1,10 +1,10 @@
 import { SerializationType } from "../../../../enums/SerializationType";
-import { SAVE_DATA_MANAGER_DEBUG } from "../../../../features/saveDataManager/constants";
 import { deepCopy } from "../../../../functions/deepCopy";
 import { jsonEncode } from "../../../../functions/jsonHelpers";
 import { log } from "../../../../functions/log";
 import { isTableEmpty, iterateTableInOrder } from "../../../../functions/table";
 import { SaveData } from "../../../../interfaces/SaveData";
+import { SAVE_DATA_MANAGER_DEBUG } from "./constants";
 
 export function saveToDisk(
   mod: Mod,

package/src/classes/private/CustomCallback.ts

@@ -1,13 +1,13 @@
-import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
-import { AddCallbackParametersCustom2 } from "../../interfaces/private/AddCallbackParametersCustom2";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { AddCallbackParametersCustom } from "../../interfaces/private/AddCallbackParametersCustom";
 import { AllButFirst } from "../../types/private/AllButFirst";
 import { Feature } from "./Feature";
 
-export type FireArgs<T extends ModCallbackCustom2> = Parameters<
-  AddCallbackParametersCustom2[T][0]
+export type FireArgs<T extends ModCallbackCustom> = Parameters<
+  AddCallbackParametersCustom[T][0]
 >;
-export type OptionalArgs<T extends ModCallbackCustom2> = AllButFirst<
-  AddCallbackParametersCustom2[T]
+export type OptionalArgs<T extends ModCallbackCustom> = AllButFirst<
+  AddCallbackParametersCustom[T]
 >;
 
 /**
@@ -15,11 +15,11 @@ export type OptionalArgs<T extends ModCallbackCustom2> = AllButFirst<
  * extend from this class.
  */
 export abstract class CustomCallback<
-  T extends ModCallbackCustom2,
+  T extends ModCallbackCustom,
 > extends Feature {
-  private subscriptions: Array<AddCallbackParametersCustom2[T]> = [];
+  private subscriptions: Array<AddCallbackParametersCustom[T]> = [];
 
-  public addSubscriber(...args: AddCallbackParametersCustom2[T]): void {
+  public addSubscriber(...args: AddCallbackParametersCustom[T]): void {
     this.subscriptions.push(args);
   }
 
@@ -27,7 +27,7 @@ export abstract class CustomCallback<
    * If the submitted function does not match any of the existing subscriptions, this method will do
    * nothing.
    */
-  public removeSubscriber(callback: AddCallbackParametersCustom2[T][0]): void {
+  public removeSubscriber(callback: AddCallbackParametersCustom[T][0]): void {
     const subscriptionIndexMatchingCallback = this.subscriptions.findIndex(
       (subscription) => {
         const subscriptionCallback = subscription[0];
@@ -41,7 +41,7 @@ export abstract class CustomCallback<
 
   public fire = (
     ...fireArgs: FireArgs<T>
-  ): ReturnType<AddCallbackParametersCustom2[T][0]> => {
+  ): ReturnType<AddCallbackParametersCustom[T][0]> => {
     for (const [callback, ...optionalArgsArray] of this.subscriptions) {
       // The TypeScript compiler is bugged with the spread operator here, as it converts the
       // optional arguments to an array instead of a tuple.
@@ -52,7 +52,7 @@ export abstract class CustomCallback<
         // signature.
         const callbackCasted = callback as (
           ...args: FireArgs<T>
-        ) => ReturnType<AddCallbackParametersCustom2[T][0]>;
+        ) => ReturnType<AddCallbackParametersCustom[T][0]>;
         const value = callbackCasted(...fireArgs);
         if (value !== undefined) {
           return value;
@@ -60,19 +60,16 @@ export abstract class CustomCallback<
       }
     }
 
-    return undefined as ReturnType<AddCallbackParametersCustom2[T][0]>;
+    return undefined as ReturnType<AddCallbackParametersCustom[T][0]>;
   };
 
   /**
    * This method needs to be overwritten for any callback that has optional filtration arguments.
+   * See "shouldFire.ts" for methods tailored to specific kinds of callbacks.
    */
   // eslint-disable-next-line class-methods-use-this
-  protected shouldFire(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  protected shouldFire: (
     fireArgs: FireArgs<T>,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     optionalArgs: OptionalArgs<T>,
-  ): boolean {
-    return true;
-  }
+  ) => boolean = () => true;
 }

package/src/classes/private/Feature.ts

@@ -12,12 +12,42 @@ import {
  *
  * Additionally, all custom callbacks extend from this class.
  */
-export class Feature {
+export abstract class Feature {
+  /**
+   * All features should only be instantiated once and are passed around to other features using
+   * dependency injection. We provide a run-time check in order to prevent the bug of any feature
+   * accidentally being instantiated twice.
+   */
+  private static constructedClassNames = new Set<string>();
+
+  /** @internal */
   public initialized = false;
+
+  /** @internal */
   public numConsumers = 0;
 
+  /** @internal */
   public v?: SaveData;
+
+  /** @internal */
+  public vConditionalFunc?: () => boolean;
+
+  /** @internal */
   public featuresUsed?: ISCFeature[];
+
+  /** @internal */
   public callbacksUsed?: CallbackTuple[];
+
+  /** @internal */
   public customCallbacksUsed?: CustomCallbackTuple[];
+
+  constructor() {
+    if (Feature.constructedClassNames.has(this.constructor.name)) {
+      error(
+        `Failed to instantiate feature class "${this.constructor.name}" because it has already been instantiated once.`,
+      );
+    }
+
+    Feature.constructedClassNames.add(this.constructor.name);
+  }
 }

package/src/core/constants.ts

@@ -173,19 +173,19 @@ export const TELEPORTER_ACTIVATION_DISTANCE = DISTANCE_OF_GRID_TILE / 2;
 export const UI_HEART_WIDTH = 12;
 
 /**
- * This is a safer version of the `Vector.One` constant. (Other mods can mutate `Vector.One`, so it
+ * This is a safe version of the `Vector.One` constant. (Other mods can mutate `Vector.One`, so it
  * is not safe to use.)
  */
 export const VectorOne: Readonly<Vector> = Vector(1, 1);
 
 /**
- * This is a safer version of the `Vector.Zero` constant. (Other mods can mutate `Vector.Zero`, so
- * it is not safe to use.)
+ * This is a safe version of the `Vector.Zero` constant. (Other mods can mutate `Vector.Zero`, so it
+ * is not safe to use.)
  */
 export const VectorZero: Readonly<Vector> = Vector(0, 0);
 
 /**
- * This is a safer version of the `Color.Default` constant. (Other mods can mutate `Color.Default`,
+ * This is a safe version of the `Color.Default` constant. (Other mods can mutate `Color.Default`,
  * so it is not safe to use.)
  *
  * If you need to mutate this, make a copy first with the `copyColor` helper function.

package/src/core/upgradeMod.ts

@@ -1,34 +1,14 @@
-import { postNewRoomEarlyCallbackInit } from "../callbacks/postNewRoomEarly";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { Feature } from "../classes/private/Feature";
+import { ModUpgradedBase } from "../classes/ModUpgradedBase";
 import { ISCFeature } from "../enums/ISCFeature";
-import { ISCFeatureToClass } from "../features";
-import {
-  saveDataManagerInit,
-  SAVE_DATA_MANAGER_CALLBACKS,
-  SAVE_DATA_MANAGER_CUSTOM_CALLBACKS,
-} from "../features/saveDataManager/main";
-import {
-  areFeaturesInitialized,
-  setFeaturesInitialized,
-} from "../featuresInitialized";
-import { initCustomCallbacks } from "../initCustomCallbacks";
-import { initFeatures } from "../initFeatures";
 import { patchErrorFunction } from "../patchErrorFunctions";
-import { loadShaderCrashFix } from "../shaderCrashFix";
+import { applyShaderCrashFix } from "../shaderCrashFix";
 import { AnyFunction } from "../types/AnyFunction";
-import { UnionToIntersection } from "../types/UnionToIntersection";
+import { ModUpgraded } from "../types/ModUpgraded";
 
-/**
- * By specifying one or more optional features, end-users will get a version of `ModUpgraded` that
- * has extra methods corresponding to the features.
- *
- * We have to explicitly account for the empty array case, since the `never` will mess up the union.
- */
-type ModUpgradedWithFeatures<T extends ISCFeature> = [T] extends [never]
-  ? ModUpgraded
-  : ModUpgraded &
-      Omit<UnionToIntersection<ISCFeatureToClass[T]>, keyof Feature>;
+type ISCFeatureTuple<T extends readonly ISCFeature[]> =
+  ISCFeature extends T["length"]
+    ? 'The list of features must be a tuple. Use the "as const" assertion when declaring the array.'
+    : T;
 
 /**
  * Use this function to enable the custom callbacks and other optional features provided by
@@ -57,29 +37,28 @@ type ModUpgradedWithFeatures<T extends ISCFeature> = [T] extends [never]
  *                      or milliseconds (if the "--luadebug" launch flag is turned off).
  * @returns The upgraded mod object.
  */
-export function upgradeMod<T extends ISCFeature = never>(
+export function upgradeMod<T extends readonly ISCFeature[] = never[]>(
   modVanilla: Mod,
-  features: T[] = [],
+  features: ISCFeatureTuple<T> = [] as unknown as ISCFeatureTuple<T>,
   debug = false,
   timeThreshold?: float,
-): ModUpgradedWithFeatures<T> {
-  const mod = new ModUpgraded(modVanilla, debug, timeThreshold);
-
-  if (areFeaturesInitialized()) {
-    error(
-      "Failed to upgrade the mod since a mod has already been initialized. (You can only upgrade one mod per IsaacScript project.)",
-    );
-  }
-  setFeaturesInitialized();
-
+): ModUpgraded<T> {
   patchErrorFunction();
-  loadShaderCrashFix(modVanilla);
 
-  legacyInit(mod); // TODO: remove
+  const mod = new ModUpgradedBase(modVanilla, debug, timeThreshold);
+  applyShaderCrashFix(mod);
+  initOptionalFeatures(mod, features as ISCFeature[]);
+
+  return mod as ModUpgraded<T>;
+}
 
+/** Initialize every optional feature that the end-user specified. */
+function initOptionalFeatures(mod: ModUpgradedBase, features: ISCFeature[]) {
   for (const feature of features) {
-    // @ts-expect-error We intentionally access the private function here.
-    const exportedMethodTuples = mod.initOptionalFeature(feature);
+    // We intentionally access the private method here, so we use the string index escape hatch:
+    // https://github.com/microsoft/TypeScript/issues/19335
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    const exportedMethodTuples = mod["initOptionalFeature"](feature);
 
     // If the optional feature provides helper functions, attach them to the base mod object. (This
     // provides a convenient API for end-users.)
@@ -88,32 +67,4 @@ export function upgradeMod<T extends ISCFeature = never>(
       modRecord[funcName] = func;
     }
   }
-
-  return mod as ModUpgradedWithFeatures<T>;
-}
-
-/** Initialize features in the old way. */
-function legacyInit(mod: ModUpgraded) {
-  // We initialize the `POST_NEW_ROOM_EARLY` callback first since it is used by the save data
-  // manager.
-  postNewRoomEarlyCallbackInit(mod);
-
-  // We initialized the save data manager second since it is used by the other custom callbacks and
-  // features. We can't pass the instantiated `ModUpgraded` class to the "saveDataManagerInit"
-  // function since it causes a circular dependency. Thus, we emulate the initialization process
-  // that the `ModUpgraded.AddCallbackCustom` method uses.
-  saveDataManagerInit(mod);
-  for (const callbackTuple of SAVE_DATA_MANAGER_CALLBACKS) {
-    const [modCallback, callbackArgs] = callbackTuple;
-    mod.AddCallback(modCallback, ...callbackArgs);
-  }
-  for (const callbackTuple of SAVE_DATA_MANAGER_CUSTOM_CALLBACKS) {
-    const [modCallback, callbackArgs] = callbackTuple;
-    mod.AddCallbackCustom(modCallback, ...callbackArgs);
-  }
-
-  // We initialize custom callbacks next since some features use custom callbacks.
-  initCustomCallbacks(mod);
-
-  initFeatures(mod);
 }

package/src/enums/ISCFeature.ts

@@ -1,6 +1,3 @@
-/* eslint-disable isaacscript/format-line-comments */
-/* eslint-disable isaacscript/complete-sentences-line-comments */
-
 export enum ISCFeature {
   // Callback logic
   CUSTOM_REVIVE,
@@ -17,36 +14,44 @@ export enum ISCFeature {
   SLOT_UPDATE_DETECTION,
 
   // Extra features
-  // CHARACTER_HEALTH_CONVERSION,
-  // CHARACTER_STATS,
-  // COLLECTIBLE_ITEM_POOL_TYPE,
+  CHARACTER_HEALTH_CONVERSION,
+  CHARACTER_STATS,
+  COLLECTIBLE_ITEM_POOL_TYPE,
   CUSTOM_GRID_ENTITIES,
-  // CUSTOM_HOTKEYS,
-  // CUSTOM_PICKUPS,
-  // CUSTOM_STAGES,
-  // CUSTOM_TRAPDOORS,
-  // DEBUG_DISPLAY,
-  // DEPLOY_JSON_ROOM,
-  // DISABLE_ALL_SOUND,
-  // DISABLE_INPUTS,
-  // FADE_IN_REMOVER,
-  // FAST_RESET,
-  // FIRST_LAST,
-  // FORGOTTEN_SWITCH,
-  // EXTRA_CONSOLE_COMMANDS,
-  // PAUSE,
-  // PERSISTENT_ENTITIES,
-  // PICKUP_INDEX,
-  // PLAYER_INVENTORY,
-  // PONY_DETECTION,
-  // PREVENT_CHILD_ENTITIES,
-  // PREVENT_COLLECTIBLE_ROTATION,
-  // ROOM_CLEAR_FRAME,
-  // ROOM_HISTORY,
+  CUSTOM_ITEM_POOLS,
+  CUSTOM_HOTKEYS,
+  CUSTOM_PICKUPS,
+  CUSTOM_STAGES,
+  CUSTOM_TRAPDOORS,
+  DEBUG_DISPLAY,
+  DEPLOY_JSON_ROOM,
+  DISABLE_ALL_SOUND,
+  DISABLE_INPUTS,
+  FADE_IN_REMOVER,
+  FAST_RESET,
+  FLYING_DETECTION,
+  FORGOTTEN_SWITCH,
+  EXTRA_CONSOLE_COMMANDS,
+  ITEM_POOL_DETECTION,
+  MODDED_ELEMENT_DETECTION,
+  MODDED_ELEMENT_SETS,
+  NO_SIREN_STEAL,
+  PAUSE,
+  PERSISTENT_ENTITIES,
+  PICKUP_INDEX,
+  PLAYER_INVENTORY,
+  PONY_DETECTION,
+  PREVENT_CHILD_ENTITIES,
+  PREVENT_COLLECTIBLE_ROTATION,
+  PREVENT_GRID_ENTITY_RESPAWN,
+  ROOM_CLEAR_FRAME,
+  ROOM_HISTORY,
   RUN_IN_N_FRAMES,
-  // RUN_NEXT_ROOM,
+  RUN_NEXT_ROOM,
   SAVE_DATA_MANAGER,
-  // SIREN_HELPERS,
-  // STAGE_HISTORY,
-  // TAINTED_LAZARUS_PLAYERS,
+  SPAWN_ALT_ROCK_REWARDS,
+  SPAWN_COLLECTIBLE,
+  STAGE_HISTORY,
+  START_AMBUSH,
+  TAINTED_LAZARUS_PLAYERS,
 }