isaacscript-common 20.9.1 → 20.11.0

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

@@ -1,43 +1,56 @@
 import { ModCallback, PlayerType } from "isaac-typescript-definitions";
 import { game } from "../../../core/cachedClasses";
 import { Exported } from "../../../decorators";
+import { ISCFeature } from "../../../enums/ISCFeature";
 import { arrayRemoveInPlace } from "../../../functions/array";
 import { restart } from "../../../functions/run";
 import { Feature } from "../../private/Feature";
+import { RoomHistory } from "./RoomHistory";
 
 /** Used for `runInNFrames` functions. */
-type QueuedFunctionTuple = [frameCountToFire: int, func: () => void];
+interface QueuedFunction {
+  func: () => void;
+  frameCountToFire: int;
+  numRoomsEntered: int;
+  cancelIfRoomChanges: boolean;
+}
 
 /**
  * Used for `setInterval` functions.
  *
  * The return value is whether or not to continue the function from firing.
  */
-type IntervalFunctionTuple = [
-  frameCountToFire: int,
-  func: () => boolean,
-  numIntervalFrames: int,
-];
+interface IntervalFunction {
+  func: () => boolean;
+  frameCountToFire: int;
+  numRoomsEntered: int;
+  cancelIfRoomChanges: boolean;
+  numIntervalFrames: int;
+}
 
 export class RunInNFrames extends Feature {
   /** @internal */
   public override v = {
     run: {
-      queuedGameFunctionTuples: [] as QueuedFunctionTuple[],
-      queuedRenderFunctionTuples: [] as QueuedFunctionTuple[],
+      queuedGameFunctions: [] as QueuedFunction[],
+      queuedRenderFunctions: [] as QueuedFunction[],
 
-      intervalGameFunctionTuples: [] as IntervalFunctionTuple[],
-      intervalRenderFunctionTuples: [] as IntervalFunctionTuple[],
+      intervalGameFunctions: [] as IntervalFunction[],
+      intervalRenderFunctions: [] as IntervalFunction[],
     },
   };
 
   // eslint-disable-next-line class-methods-use-this
   public override vConditionalFunc = (): boolean => false;
 
+  private roomHistory: RoomHistory;
+
   /** @internal */
-  constructor() {
+  constructor(roomHistory: RoomHistory) {
     super();
 
+    this.featuresUsed = [ISCFeature.ROOM_HISTORY];
+
     this.callbacksUsed = [
       // 1
       [ModCallback.POST_UPDATE, this.postUpdate],
@@ -45,33 +58,41 @@ export class RunInNFrames extends Feature {
       // 2
       [ModCallback.POST_RENDER, this.postRender],
     ];
+
+    this.roomHistory = roomHistory;
   }
 
   // ModCallback.POST_UPDATE (1)
   private postUpdate = (): void => {
     const gameFrameCount = game.GetFrameCount();
+    const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
 
     checkExecuteQueuedFunctions(
+      this.v.run.queuedGameFunctions,
       gameFrameCount,
-      this.v.run.queuedGameFunctionTuples,
+      numRoomsEntered,
     );
     checkExecuteIntervalFunctions(
+      this.v.run.intervalGameFunctions,
       gameFrameCount,
-      this.v.run.intervalGameFunctionTuples,
+      numRoomsEntered,
     );
   };
 
   // ModCallback.POST_RENDER (2)
   private postRender = (): void => {
     const renderFrameCount = Isaac.GetFrameCount();
+    const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
 
     checkExecuteQueuedFunctions(
+      this.v.run.queuedRenderFunctions,
       renderFrameCount,
-      this.v.run.queuedRenderFunctionTuples,
+      numRoomsEntered,
     );
     checkExecuteIntervalFunctions(
+      this.v.run.intervalRenderFunctions,
       renderFrameCount,
-      this.v.run.intervalRenderFunctionTuples,
+      numRoomsEntered,
     );
   };
 
@@ -102,13 +123,29 @@ export class RunInNFrames extends Feature {
    * deferred functions manually using serializable data.
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+   *
+   * @param func The function to run.
+   * @param gameFrames The amount of game frames to wait before running the function.
+   * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
+   *                            room is loaded in the interim. Default is false.
    */
   @Exported
-  public runInNGameFrames(func: () => void, gameFrames: int): void {
+  public runInNGameFrames(
+    func: () => void,
+    gameFrames: int,
+    cancelIfRoomChanges = false,
+  ): void {
     const gameFrameCount = game.GetFrameCount();
-    const functionFireFrame = gameFrameCount + gameFrames;
-    const tuple: QueuedFunctionTuple = [functionFireFrame, func];
-    this.v.run.queuedGameFunctionTuples.push(tuple);
+    const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+
+    const frameCountToFire = gameFrameCount + gameFrames;
+    const queuedFunction: QueuedFunction = {
+      func,
+      frameCountToFire,
+      numRoomsEntered,
+      cancelIfRoomChanges,
+    };
+    this.v.run.queuedGameFunctions.push(queuedFunction);
   }
 
   /**
@@ -122,13 +159,29 @@ export class RunInNFrames extends Feature {
    * deferred functions manually using serializable data.
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+   *
+   * @param func The function to run.
+   * @param renderFrames The amount of render frames to wait before running the function.
+   * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
+   *                            room is loaded in the interim. Default is false.
    */
   @Exported
-  public runInNRenderFrames(func: () => void, renderFrames: int): void {
+  public runInNRenderFrames(
+    func: () => void,
+    renderFrames: int,
+    cancelIfRoomChanges = false,
+  ): void {
     const renderFrameCount = Isaac.GetFrameCount();
-    const functionFireFrame = renderFrameCount + renderFrames;
-    const tuple: QueuedFunctionTuple = [functionFireFrame, func];
-    this.v.run.queuedRenderFunctionTuples.push(tuple);
+    const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+
+    const frameCountToFire = renderFrameCount + renderFrames;
+    const queuedFunction: QueuedFunction = {
+      func,
+      frameCountToFire,
+      numRoomsEntered,
+      cancelIfRoomChanges,
+    };
+    this.v.run.queuedRenderFunctions.push(queuedFunction);
   }
 
   /**
@@ -160,10 +213,14 @@ export class RunInNFrames extends Feature {
    * deferred functions manually using serializable data.
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+   *
+   * @param func The function to run.
+   * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
+   *                            room is loaded in the interim. Default is false.
    */
   @Exported
-  public runNextGameFrame(func: () => void): void {
-    this.runInNGameFrames(func, 1);
+  public runNextGameFrame(func: () => void, cancelIfRoomChanges = false): void {
+    this.runInNGameFrames(func, 1, cancelIfRoomChanges);
   }
 
   /**
@@ -175,10 +232,17 @@ export class RunInNFrames extends Feature {
    * Note that this function will not handle saving and quitting.
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
+   *
+   * @param func The function to run.
+   * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
+   *                            room is loaded in the interim. Default is false.
    */
   @Exported
-  public runNextRenderFrame(func: () => void): void {
-    this.runInNRenderFrames(func, 1);
+  public runNextRenderFrame(
+    func: () => void,
+    cancelIfRoomChanges = false,
+  ): void {
+    this.runInNRenderFrames(func, 1, cancelIfRoomChanges);
   }
 
   /**
@@ -198,17 +262,27 @@ export class RunInNFrames extends Feature {
    * @param gameFrames The amount of game frames to wait between each run.
    * @param runImmediately Whether or not to execute the function right now before waiting for the
    *                       interval.
+   * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
+   *                            room is loaded in the interim. Default is false.
    */
   @Exported
   public setIntervalGameFrames(
     func: () => boolean,
     gameFrames: int,
     runImmediately: boolean,
+    cancelIfRoomChanges = false,
   ): void {
     const gameFrameCount = game.GetFrameCount();
-    const functionFireFrame = gameFrameCount + gameFrames;
-    const tuple: IntervalFunctionTuple = [functionFireFrame, func, gameFrames];
-    this.v.run.intervalGameFunctionTuples.push(tuple);
+    const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+
+    const intervalFunction: IntervalFunction = {
+      func,
+      frameCountToFire: gameFrameCount + gameFrames,
+      numRoomsEntered,
+      cancelIfRoomChanges,
+      numIntervalFrames: gameFrames,
+    };
+    this.v.run.intervalGameFunctions.push(intervalFunction);
 
     if (runImmediately) {
       func();
@@ -232,21 +306,27 @@ export class RunInNFrames extends Feature {
    * @param renderFrames The amount of game frames to wait between each run.
    * @param runImmediately Whether or not to execute the function right now before waiting for the
    *                       interval.
+   * @param cancelIfRoomChanges Optional. Whether or not to cancel running the function if a new
+   *                            room is loaded in the interim. Default is false.
    */
   @Exported
   public setIntervalRenderFrames(
     func: () => boolean,
     renderFrames: int,
     runImmediately: boolean,
+    cancelIfRoomChanges = false,
   ): void {
     const renderFrameCount = Isaac.GetFrameCount();
-    const functionFireFrame = renderFrameCount + renderFrames;
-    const tuple: IntervalFunctionTuple = [
-      functionFireFrame,
+    const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
+
+    const intervalFunction: IntervalFunction = {
       func,
-      renderFrames,
-    ];
-    this.v.run.intervalGameFunctionTuples.push(tuple);
+      frameCountToFire: renderFrameCount + renderFrames,
+      numRoomsEntered,
+      cancelIfRoomChanges,
+      numIntervalFrames: renderFrames,
+    };
+    this.v.run.intervalGameFunctions.push(intervalFunction);
 
     if (runImmediately) {
       func();
@@ -255,42 +335,55 @@ export class RunInNFrames extends Feature {
 }
 
 function checkExecuteQueuedFunctions(
+  functionTuples: QueuedFunction[],
   frameCount: int,
-  functionTuples: QueuedFunctionTuple[],
+  newNumRoomsEntered: int,
 ) {
   const firingFunctions = functionTuples.filter(
-    ([frameCountToFire]) => frameCount >= frameCountToFire,
+    ({ frameCountToFire }) => frameCount >= frameCountToFire,
   );
 
-  for (const tuple of firingFunctions) {
-    const [_frameCountToFire, func] = tuple;
-    func();
-    arrayRemoveInPlace(functionTuples, tuple);
+  for (const firingFunction of firingFunctions) {
+    const { func, cancelIfRoomChanges, numRoomsEntered } = firingFunction;
+
+    if (!cancelIfRoomChanges || numRoomsEntered === newNumRoomsEntered) {
+      func();
+    }
+
+    arrayRemoveInPlace(functionTuples, firingFunction);
   }
 }
 
 function checkExecuteIntervalFunctions(
+  functionTuples: IntervalFunction[],
   frameCount: int,
-  functionTuples: IntervalFunctionTuple[],
+  newNumRoomsEntered: int,
 ) {
   const firingFunctions = functionTuples.filter(
-    ([frameCountToFire]) => frameCount >= frameCountToFire,
+    ({ frameCountToFire }) => frameCount >= frameCountToFire,
   );
 
-  for (const tuple of firingFunctions) {
-    const [_frameCountToFire, func, numIntervalFrames] = tuple;
-    const returnValue = func();
-    arrayRemoveInPlace(functionTuples, tuple);
+  for (const firingFunction of firingFunctions) {
+    const { func, cancelIfRoomChanges, numRoomsEntered, numIntervalFrames } =
+      firingFunction;
+
+    let returnValue = false;
+    if (!cancelIfRoomChanges || numRoomsEntered === newNumRoomsEntered) {
+      returnValue = func();
+    }
+
+    arrayRemoveInPlace(functionTuples, firingFunction);
 
     // Queue the next interval (as long as the function did not return false).
     if (returnValue) {
-      const nextFireFrame = frameCount + numIntervalFrames;
-      const newTuple: IntervalFunctionTuple = [
-        nextFireFrame,
+      const newIntervalFunction: IntervalFunction = {
         func,
+        frameCountToFire: frameCount + numIntervalFrames,
+        numRoomsEntered,
+        cancelIfRoomChanges,
         numIntervalFrames,
-      ];
-      functionTuples.push(newTuple);
+      };
+      functionTuples.push(newIntervalFunction);
     }
   }
 }

package/src/features.ts

@@ -143,11 +143,12 @@ export function getFeatures(
   const preventCollectibleRotation = new PreventCollectibleRotation();
   const roomClearFrame = new RoomClearFrame();
   const roomHistory = new RoomHistory();
-  const runInNFrames = new RunInNFrames();
   const runNextRoom = new RunNextRoom();
   const saveDataManager = new SaveDataManager(mod);
   const stageHistory = new StageHistory();
 
+  const runInNFrames = new RunInNFrames(roomHistory);
+
   const customGridEntities = new CustomGridEntities(runInNFrames);
   const moddedElementSets = new ModdedElementSets(moddedElementDetection);
   const itemPoolDetection = new ItemPoolDetection(moddedElementSets);