isaacscript-common 14.1.3 → 14.2.0

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

@@ -0,0 +1,138 @@
+// The save data manager has a feature where certain variables will automatically be rolled back
+// when the Glowing Hour Glass is used.
+
+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";
+
+/**
+ * When the Glowing Hour Glass is used, certain save data keys will automatically be restored to a
+ * backup.
+ */
+const GLOWING_HOUR_GLASS_BACKUP_KEYS: readonly SaveDataKey[] = [
+  SaveDataKey.RUN,
+  SaveDataKey.LEVEL,
+];
+
+const IGNORE_GLOWING_HOUR_GLASS_KEY = "__ignoreGlowingHourGlass";
+
+export function makeGlowingHourGlassBackup(
+  saveDataMap: LuaMap<string, SaveData>,
+  saveDataConditionalFuncMap: LuaMap<string, () => boolean>,
+  saveDataGlowingHourGlassMap: LuaMap<string, SaveData>,
+): void {
+  iterateTableInOrder(
+    saveDataMap,
+    (subscriberName, saveData) => {
+      // We make the Glowing Hour Glass backup using `SerializationType.SERIALIZE`, which means that
+      // we cannot operate on unserializable data, such as functions. Save data that utilizes
+      // unserializable data will typically be marked using a conditional function that evaluates to
+      // false, so we skip all save data that matches this criteria.
+      const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+      if (conditionalFunc !== undefined) {
+        const shouldSave = conditionalFunc();
+        if (!shouldSave) {
+          return;
+        }
+      }
+
+      for (const saveDataKey of GLOWING_HOUR_GLASS_BACKUP_KEYS) {
+        const childTable = saveData[saveDataKey];
+        if (childTable === undefined) {
+          // This feature does not happen to store any variables on this particular child table.
+          continue;
+        }
+
+        // Ignore child tables that the end-user has explicitly annotated.
+        const childTableLuaMap = childTable as LuaMap<AnyNotNil, unknown>;
+        if (childTableLuaMap.has(IGNORE_GLOWING_HOUR_GLASS_KEY)) {
+          continue;
+        }
+
+        let saveDataGlowingHourGlass =
+          saveDataGlowingHourGlassMap.get(subscriberName);
+        if (saveDataGlowingHourGlass === undefined) {
+          saveDataGlowingHourGlass = new LuaMap<string, unknown>() as SaveData;
+          saveDataGlowingHourGlassMap.set(
+            subscriberName,
+            saveDataGlowingHourGlass,
+          );
+        }
+
+        // We serialize the table so that we can use the `merge` function later on with no other
+        // modifications.
+        const copiedChildTable = deepCopy(
+          childTable,
+          SerializationType.SERIALIZE,
+        ) as Record<string, unknown>;
+        saveDataGlowingHourGlass[saveDataKey] = copiedChildTable;
+      }
+    },
+    SAVE_DATA_MANAGER_DEBUG,
+  );
+}
+
+export function restoreGlowingHourGlassBackup(
+  saveDataMap: LuaMap<string, SaveData>,
+  saveDataConditionalFuncMap: LuaMap<string, () => boolean>,
+  saveDataGlowingHourGlassMap: LuaMap<string, SaveData>,
+  classConstructors: LuaMap<string, AnyClass>,
+): void {
+  iterateTableInOrder(
+    saveDataMap,
+    (subscriberName, saveData) => {
+      // We make the Glowing Hour Glass backup using `SerializationType.SERIALIZE`, which means that
+      // we cannot operate on unserializable data, such as functions. Save data that utilizes
+      // unserializable data will typically be marked using a conditional function that evaluates to
+      // false, so we skip all save data that matches this criteria.
+      const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+      if (conditionalFunc !== undefined) {
+        const shouldSave = conditionalFunc();
+        if (!shouldSave) {
+          return;
+        }
+      }
+
+      for (const saveDataKey of GLOWING_HOUR_GLASS_BACKUP_KEYS) {
+        const childTable = saveData[saveDataKey];
+        if (childTable === undefined) {
+          // This feature does not happen to store any variables on this particular child table.
+          continue;
+        }
+
+        // Ignore child tables that the end-user has explicitly annotated.
+        const childTableLuaMap = childTable as LuaMap<AnyNotNil, unknown>;
+        if (childTableLuaMap.has(IGNORE_GLOWING_HOUR_GLASS_KEY)) {
+          continue;
+        }
+
+        const saveDataGlowingHourGlass =
+          saveDataGlowingHourGlassMap.get(subscriberName);
+        if (saveDataGlowingHourGlass === undefined) {
+          // This should never happen.
+          continue;
+        }
+
+        const childTableBackup = saveDataGlowingHourGlass[saveDataKey];
+        if (childTableBackup === undefined) {
+          // This should never happen.
+          continue;
+        }
+
+        merge(
+          childTable as LuaMap<AnyNotNil, unknown>,
+          childTableBackup as LuaMap<AnyNotNil, unknown>,
+          // Append an arbitrary suffix for better error messages.
+          `${subscriberName}__glowingHourGlass`,
+          classConstructors,
+        );
+      }
+    },
+    SAVE_DATA_MANAGER_DEBUG,
+  );
+}

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

@@ -0,0 +1,99 @@
+import { SAVE_DATA_MANAGER_DEBUG } from "../../../../features/saveDataManager/constants";
+import { jsonDecode } from "../../../../functions/jsonHelpers";
+import { log } from "../../../../functions/log";
+import { logError } from "../../../../functions/logMisc";
+import { merge } from "../../../../functions/merge";
+import { iterateTableInOrder } from "../../../../functions/table";
+import { isString, isTable } from "../../../../functions/types";
+import { SaveData } from "../../../../interfaces/SaveData";
+import { AnyClass } from "../../../../types/AnyClass";
+
+const DEFAULT_MOD_DATA = "{}";
+
+export function loadFromDisk(
+  mod: Mod,
+  oldSaveData: LuaMap<string, SaveData>,
+  classConstructors: LuaMap<string, AnyClass>,
+): void {
+  if (!mod.HasData()) {
+    // There is no "save#.dat" file for this save slot.
+    return;
+  }
+
+  // First, read the "save#.dat" file into a Lua table.
+  const jsonString = readSaveDatFile(mod);
+  const newSaveData = jsonDecode(jsonString);
+
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log('Converted data from the "save#.dat" to a Lua table.');
+  }
+
+  // Second, iterate over all the fields of the new table.)
+  iterateTableInOrder(
+    newSaveData,
+    (subscriberName, saveData) => {
+      // All elements of loaded save data should have keys that are strings equal to the name of the
+      // subscriber/feature. Ignore elements with other types of keys.
+      if (!isString(subscriberName)) {
+        return;
+      }
+
+      // All elements of loaded save data should be tables that contain fields corresponding to the
+      // `SaveData` interface. Ignore elements that are not tables.
+      if (!isTable(saveData)) {
+        return;
+      }
+
+      // Ignore elements that represent subscriptions that no longer exist in the current save data.
+      const oldSaveDataForSubscriber = oldSaveData.get(subscriberName);
+      if (oldSaveDataForSubscriber === undefined) {
+        return;
+      }
+
+      if (SAVE_DATA_MANAGER_DEBUG) {
+        log(`Merging in stored data for feature: ${subscriberName}`);
+      }
+
+      // We do not want to blow away the child tables of the existing map, because save data could
+      // contain out-of-date fields. Instead, merge it one field at a time in a recursive way (and
+      // convert Lua tables back to TypeScriptToLua Maps, if necessary).
+      merge(
+        oldSaveDataForSubscriber as LuaMap<AnyNotNil, unknown>,
+        saveData,
+        subscriberName,
+        classConstructors,
+      );
+    },
+    SAVE_DATA_MANAGER_DEBUG,
+  );
+
+  log('The save data manager loaded data from the "save#.dat" file.');
+}
+
+function readSaveDatFile(mod: Mod) {
+  const renderFrameCount = Isaac.GetFrameCount();
+
+  const [ok, jsonStringOrErrMsg] = pcall(tryLoadModData, mod);
+  if (!ok) {
+    logError(
+      `Failed to read from the "save#.dat" file on render frame ${renderFrameCount}: ${jsonStringOrErrMsg}`,
+    );
+    return DEFAULT_MOD_DATA;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  if (jsonStringOrErrMsg === undefined) {
+    return DEFAULT_MOD_DATA;
+  }
+
+  const jsonStringTrimmed = jsonStringOrErrMsg.trim();
+  if (jsonStringTrimmed === "") {
+    return DEFAULT_MOD_DATA;
+  }
+
+  return jsonStringTrimmed;
+}
+
+function tryLoadModData(this: void, mod: Mod) {
+  return mod.LoadData();
+}

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

@@ -0,0 +1,116 @@
+// The save data manager has a feature where certain variables are automatically restored to default
+// values at certain times.
+
+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";
+
+const RESETTABLE_SAVE_DATA_KEYS: ReadonlySet<SaveDataKey> = new Set([
+  SaveDataKey.RUN,
+  SaveDataKey.LEVEL,
+  SaveDataKey.ROOM,
+]);
+
+export function restoreDefaultsForAllFeaturesAndKeys(
+  saveDataMap: LuaMap<string, SaveData>,
+  saveDataDefaultsMap: LuaMap<string, SaveData>,
+): void {
+  for (const saveDataKey of RESETTABLE_SAVE_DATA_KEYS.values()) {
+    restoreDefaultsForAllFeaturesKey(
+      saveDataMap,
+      saveDataDefaultsMap,
+      saveDataKey,
+    );
+  }
+}
+
+export function restoreDefaultsForAllFeaturesKey(
+  saveDataMap: LuaMap<string, SaveData>,
+  saveDataDefaultsMap: LuaMap<string, SaveData>,
+  saveDataKey: SaveDataKey,
+): void {
+  iterateTableInOrder(
+    saveDataMap,
+    (subscriberName, saveData) => {
+      restoreDefaultForFeatureKey(
+        saveDataDefaultsMap,
+        subscriberName,
+        saveData,
+        saveDataKey,
+      );
+    },
+    SAVE_DATA_MANAGER_DEBUG,
+  );
+}
+
+export function restoreDefaultForFeatureKey(
+  saveDataDefaultsMap: LuaMap<string, SaveData>,
+  subscriberName: string,
+  saveData: SaveData,
+  saveDataKey: SaveDataKey,
+): void {
+  // Only allow certain save data keys to be reset.
+  if (!RESETTABLE_SAVE_DATA_KEYS.has(saveDataKey)) {
+    error(
+      `Failed to restore default values for a save data key of "${saveDataKey}", since it is not on the allowed list of resettable save data keys.`,
+    );
+  }
+
+  const childTable = saveData[saveDataKey];
+  if (childTable === undefined) {
+    // This feature does not happen to store any variables on this particular child table.
+    return;
+  }
+
+  // Get the default values for this feature.
+  const saveDataDefaults = saveDataDefaultsMap.get(subscriberName);
+  if (saveDataDefaults === undefined) {
+    logError(
+      `Failed to find the default copy of the save data for subscriber: ${subscriberName}`,
+    );
+    return;
+  }
+
+  // Get the default values for the specific sub-table of this feature.
+  const childTableDefaults = saveDataDefaults[saveDataKey];
+  if (childTableDefaults === undefined) {
+    logError(
+      `Failed to find the default copy of the child table "${saveDataKey}" for subscriber "${subscriberName}". This error usually means that your save data is out of date. You can try purging all of your save data by deleting the following directory: C:\\Program Files (x86)\\Steam\\steamapps\\common\\The Binding of Isaac Rebirth\\data`,
+    );
+    return;
+  }
+
+  // Make a new copy of the default child table.
+  const childTableDefaultsCopy = deepCopy(
+    childTableDefaults,
+    SerializationType.NONE,
+    `${subscriberName} --> ${saveDataKey}`,
+  ) as LuaMap<AnyNotNil, unknown>;
+
+  // We do not want to blow away the existing child table because we do not want to break any
+  // existing references. Instead, empty the table and copy all of the elements from the copy of the
+  // defaults table.
+  clearAndCopyAllElements(
+    childTable as unknown as LuaMap<AnyNotNil, unknown>,
+    childTableDefaultsCopy,
+  );
+}
+
+/**
+ * Will empty the old table of all elements, and then shallow copy all the elements from the new
+ * table to the old table.
+ */
+function clearAndCopyAllElements(
+  oldTable: LuaMap<AnyNotNil, unknown>,
+  newTable: LuaMap<AnyNotNil, unknown>,
+) {
+  clearTable(oldTable);
+
+  for (const [key, value] of newTable) {
+    oldTable.set(key, value);
+  }
+}

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

@@ -0,0 +1,70 @@
+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";
+
+export function saveToDisk(
+  mod: Mod,
+  saveDataMap: LuaMap<string, SaveData>,
+  saveDataConditionalFuncMap: LuaMap<string, () => boolean>,
+): void {
+  const allSaveData = getAllSaveDataToWriteToDisk(
+    saveDataMap,
+    saveDataConditionalFuncMap,
+  );
+  const jsonString = jsonEncode(allSaveData);
+  mod.SaveData(jsonString); // Write it to the "save#.dat" file
+  log('The save data manager wrote data to the "save#.dat" file.');
+}
+
+function getAllSaveDataToWriteToDisk(
+  saveDataMap: LuaMap<string, SaveData>,
+  saveDataConditionalFuncMap: LuaMap<string, () => boolean>,
+) {
+  const allSaveData = new LuaMap<AnyNotNil, unknown>();
+
+  iterateTableInOrder(
+    saveDataMap,
+    (subscriberName, saveData) => {
+      // Handle the feature of the save data manager where certain mod features can conditionally
+      // write their data to disk.
+      const conditionalFunc = saveDataConditionalFuncMap.get(subscriberName);
+      if (conditionalFunc !== undefined) {
+        const shouldSave = conditionalFunc();
+        if (!shouldSave) {
+          return;
+        }
+      }
+
+      // Strip out the room part of the save data (and any other arbitrary fields that they might
+      // have added).
+      const saveDataWithoutRoom: SaveData = {
+        persistent: saveData.persistent,
+        run: saveData.run,
+        level: saveData.level,
+      };
+
+      // If there is no data, then we can move on to the next feature.
+      if (isTableEmpty(saveDataWithoutRoom as LuaTable<AnyNotNil, unknown>)) {
+        return;
+      }
+
+      // If we encode TypeScriptToLua Maps into JSON, it will result in a lot of extraneous data
+      // that is unnecessary. Make a copy of the data and recursively convert all TypeScriptToLua
+      // Maps into Lua tables.
+      const saveDataCopy = deepCopy(
+        saveDataWithoutRoom,
+        SerializationType.SERIALIZE,
+        subscriberName,
+      );
+
+      allSaveData.set(subscriberName, saveDataCopy);
+    },
+    SAVE_DATA_MANAGER_DEBUG,
+  );
+
+  return allSaveData;
+}

package/src/classes/private/CustomCallback.ts

@@ -19,11 +19,7 @@ export abstract class CustomCallback<
 > extends Feature {
   private subscriptions: Array<AddCallbackParametersCustom2[T]> = [];
 
-  public hasSubscriptions(): boolean {
-    return this.subscriptions.length > 0;
-  }
-
-  public add(...args: AddCallbackParametersCustom2[T]): void {
+  public addSubscriber(...args: AddCallbackParametersCustom2[T]): void {
     this.subscriptions.push(args);
   }
 
@@ -31,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 remove(callback: AddCallbackParametersCustom2[T][0]): void {
+  public removeSubscriber(callback: AddCallbackParametersCustom2[T][0]): void {
     const subscriptionIndexMatchingCallback = this.subscriptions.findIndex(
       (subscription) => {
         const subscriptionCallback = subscription[0];

package/src/classes/private/Feature.ts

@@ -14,6 +14,7 @@ import {
  */
 export class Feature {
   public initialized = false;
+  public numConsumers = 0;
 
   public v?: SaveData;
   public featuresUsed?: ISCFeature[];

package/src/core/upgradeMod.ts

@@ -16,6 +16,7 @@ import { initCustomCallbacks } from "../initCustomCallbacks";
 import { initFeatures } from "../initFeatures";
 import { patchErrorFunction } from "../patchErrorFunctions";
 import { loadShaderCrashFix } from "../shaderCrashFix";
+import { AnyFunction } from "../types/AnyFunction";
 import { UnionToIntersection } from "../types/UnionToIntersection";
 
 /**
@@ -82,10 +83,7 @@ export function upgradeMod<T extends ISCFeature = never>(
 
     // If the optional feature provides helper functions, attach them to the base mod object. (This
     // provides a convenient API for end-users.)
-    const modRecord = mod as unknown as Record<
-      string,
-      (...args: unknown[]) => unknown
-    >;
+    const modRecord = mod as unknown as Record<string, AnyFunction>;
     for (const [funcName, func] of exportedMethodTuples) {
       modRecord[funcName] = func;
     }

package/src/decorators.ts

@@ -8,24 +8,22 @@ export const EXPORTED_METHOD_NAMES_KEY = "__exportedMethodNames";
  *
  * This is only meant to be used internally.
  */
-export function Exported() {
-  return <Class extends Feature>(
-    target: Class,
-    propertyKey: keyof Class,
-  ): void => {
-    // Since the decorator runs prior to instantiation, we only have access to get and set static
-    // properties, which are located on the "constructor" table.
-    const constructor = target.constructor as unknown as LuaTable<
-      AnyNotNil,
-      unknown
-    >;
-    if (!constructor.has(EXPORTED_METHOD_NAMES_KEY)) {
-      constructor.set(EXPORTED_METHOD_NAMES_KEY, []);
-    }
+export function Exported<Class extends Feature>(
+  target: Class,
+  propertyKey: keyof Class,
+): void {
+  // Since the decorator runs prior to instantiation, we only have access to get and set static
+  // properties, which are located on the "constructor" table.
+  const constructor = target.constructor as unknown as LuaTable<
+    AnyNotNil,
+    unknown
+  >;
+  if (!constructor.has(EXPORTED_METHOD_NAMES_KEY)) {
+    constructor.set(EXPORTED_METHOD_NAMES_KEY, []);
+  }
 
-    const exportedMethodNames = constructor.get(
-      EXPORTED_METHOD_NAMES_KEY,
-    ) as string[];
-    exportedMethodNames.push(propertyKey as string);
-  };
+  const exportedMethodNames = constructor.get(
+    EXPORTED_METHOD_NAMES_KEY,
+  ) as string[];
+  exportedMethodNames.push(propertyKey as string);
 }

package/src/enums/ISCFeature.ts

@@ -3,45 +3,50 @@
 
 export enum ISCFeature {
   // Callback logic
-  CUSTOM_REVIVE = "CustomRevive",
-  ESAU_JR_DETECTION = "EsauJrDetection",
-  FLIP_DETECTION = "FlipDetection",
-  GRID_ENTITY_COLLISION_DETECTION = "GridEntityCollisionDetection",
-  GRID_ENTITY_DETECTION = "GridEntityDetection",
-  GAME_REORDERED_CALLBACKS = "GameReorderedCallbacks",
-  PLAYER_REORDERED_CALLBACKS = "PlayerReorderedCallbacks",
+  CUSTOM_REVIVE,
+  ESAU_JR_DETECTION,
+  FLIP_DETECTION,
+  GRID_ENTITY_COLLISION_DETECTION,
+  GRID_ENTITY_RENDER_DETECTION,
+  GRID_ENTITY_UPDATE_DETECTION,
+  GAME_REORDERED_CALLBACKS,
+  ITEM_PICKUP_DETECTION,
+  PLAYER_COLLECTIBLE_DETECTION,
+  PLAYER_REORDERED_CALLBACKS,
+  SLOT_RENDER_DETECTION,
+  SLOT_UPDATE_DETECTION,
 
   // Extra features
-  // CHARACTER_HEALTH_CONVERSION = "characterHealthConversion",
-  // CHARACTER_STATS = "characterStats",
-  // COLLECTIBLE_ITEM_POOL_TYPE = "collectibleItemPoolType",
-  CUSTOM_GRID_ENTITIES = "CustomGridEntities",
-  // CUSTOM_HOTKEYS = "customHotkeys",
-  // CUSTOM_PICKUP = "customPickup",
-  // CUSTOM_STAGE = "customStage",
-  // CUSTOM_TRAPDOOR = "customTrapdoor",
-  // DEBUG_DISPLAY = "debugDisplay",
-  // DEPLOY_JSON_ROOM = "deployJSONRoom",
-  // DISABLE_ALL_SOUND = "displayAllSound",
-  // DISABLE_INPUTS = "disableInputs",
-  // FADE_IN_REMOVER = "fadeInRemover",
-  // FAST_RESET = "fastReset",
-  // FIRST_LAST = "firstLast",
-  // FORGOTTEN_SWITCH = "forgottenSwitch",
-  // EXTRA_CONSOLE_COMMANDS = "extraConsoleCommands",
-  // PAUSE = "pause",
-  // PERSISTENT_ENTITIES = "persistentEntities",
-  // PICKUP_INDEX = "pickupIndex",
-  // PLAYER_INVENTORY = "playerInventory",
-  // PONY_DETECTION = "ponyDetection",
-  // PREVENT_CHILD_ENTITIES = "preventChildEntities",
-  // PREVENT_COLLECTIBLE_ROTATION = "preventCollectibleRotation",
-  // ROOM_CLEAR_FRAME = "roomClearFrame",
-  // ROOM_HISTORY = "roomHistory",
-  RUN_IN_N_FRAMES = "runInNFrames",
-  // RUN_NEXT_ROOM = "runNextRoom",
-  // SAVE_DATA_MANAGER = "saveDataManager",
-  // SIREN_HELPERS = "sirenHelpers",
-  // STAGE_HISTORY = "stageHistory",
-  // TAINTED_LAZARUS_PLAYERS = "taintedLazarusPlayers",
+  // 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,
+  RUN_IN_N_FRAMES,
+  // RUN_NEXT_ROOM,
+  SAVE_DATA_MANAGER,
+  // SIREN_HELPERS,
+  // STAGE_HISTORY,
+  // TAINTED_LAZARUS_PLAYERS,
 }