isaacscript-common 21.8.0 → 21.8.1

package/dist/index.rollup.d.ts

@@ -5922,9 +5922,9 @@ export declare function getRandomIndexFromWeightedArray<T>(weightedArray: Weight
 export declare function getRandomInt(min: int, max: int, seedOrRNG?: Seed | RNG, exceptions?: int[] | readonly int[]): int;
 
 /**
- * Helper function to get a random item pool. This is as simple as getting a random value from the
- * `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the Greed
- * Mode item pools should be excluded if not playing in Greed Mode.
+ * Helper function to get a random item pool. This is not as simple as getting a random value from
+ * the `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the
+ * Greed Mode item pools should be excluded if not playing in Greed Mode.
  */
 export declare function getRandomItemPool(): ItemPoolType;
 
@@ -13553,11 +13553,11 @@ declare class RunInNFrames extends Feature {
      * 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 numGameFrames 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.
      */
-    runInNGameFrames(func: () => void, gameFrames: int, cancelIfRoomChanges?: boolean): void;
+    runInNGameFrames(func: () => void, numGameFrames: int, cancelIfRoomChanges?: boolean): void;
     /**
      * Supply a function to run N render frames from now in the `POST_RENDER` callback.
      *
@@ -13571,11 +13571,11 @@ declare class RunInNFrames extends Feature {
      * 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 numRenderFrames 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.
      */
-    runInNRenderFrames(func: () => void, renderFrames: int, cancelIfRoomChanges?: boolean): void;
+    runInNRenderFrames(func: () => void, numRenderFrames: int, cancelIfRoomChanges?: boolean): void;
     /**
      * Supply a function to run on the next `POST_UPDATE` callback.
      *
@@ -13640,13 +13640,13 @@ declare class RunInNFrames extends Feature {
      * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
      *
      * @param func The function to repeatedly run on an interval.
-     * @param gameFrames The amount of game frames to wait between each run.
+     * @param numGameFrames 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.
      */
-    setIntervalGameFrames(func: () => boolean, gameFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
+    setIntervalGameFrames(func: () => boolean, numGameFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
     /**
      * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
      * callback. The function will continue to be fired until `false` is returned from the function.
@@ -13661,13 +13661,13 @@ declare class RunInNFrames extends Feature {
      * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
      *
      * @param func The function to repeatedly run on an interval.
-     * @param renderFrames The amount of game frames to wait between each run.
+     * @param numRenderFrames 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.
      */
-    setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
+    setIntervalRenderFrames(func: () => boolean, numRenderFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
 }
 
 /**

package/dist/isaacscript-common.lua

@@ -1,6 +1,6 @@
 --[[
 
-isaacscript-common 21.8.0
+isaacscript-common 21.8.1
 
 This is the "isaacscript-common" library, which was created with the IsaacScript tool.
 
@@ -32294,9 +32294,9 @@ local ____run = require("src.functions.run")
 local restart = ____run.restart
 local ____Feature = require("src.classes.private.Feature")
 local Feature = ____Feature.Feature
-function checkExecuteQueuedFunctions(self, functionTuples, frameCount, newNumRoomsEntered)
+function checkExecuteQueuedFunctions(self, queuedFunctions, frameCount, newNumRoomsEntered)
     local firingFunctions = __TS__ArrayFilter(
-        functionTuples,
+        queuedFunctions,
         function(____, ____bindingPattern0)
             local frameCountToFire
             frameCountToFire = ____bindingPattern0.frameCountToFire
@@ -32310,12 +32310,12 @@ function checkExecuteQueuedFunctions(self, functionTuples, frameCount, newNumRoo
         if not cancelIfRoomChanges or numRoomsEntered == newNumRoomsEntered then
             func(nil)
         end
-        arrayRemoveInPlace(nil, functionTuples, firingFunction)
+        arrayRemoveInPlace(nil, queuedFunctions, firingFunction)
     end
 end
-function checkExecuteIntervalFunctions(self, functionTuples, frameCount, newNumRoomsEntered)
+function checkExecuteIntervalFunctions(self, intervalFunctions, frameCount, newNumRoomsEntered)
     local firingFunctions = __TS__ArrayFilter(
-        functionTuples,
+        intervalFunctions,
         function(____, ____bindingPattern0)
             local frameCountToFire
             frameCountToFire = ____bindingPattern0.frameCountToFire
@@ -32331,7 +32331,7 @@ function checkExecuteIntervalFunctions(self, functionTuples, frameCount, newNumR
         if not cancelIfRoomChanges or numRoomsEntered == newNumRoomsEntered then
             returnValue = func(nil)
         end
-        arrayRemoveInPlace(nil, functionTuples, firingFunction)
+        arrayRemoveInPlace(nil, intervalFunctions, firingFunction)
         if returnValue then
             local newIntervalFunction = {
                 func = func,
@@ -32340,7 +32340,7 @@ function checkExecuteIntervalFunctions(self, functionTuples, frameCount, newNumR
                 cancelIfRoomChanges = cancelIfRoomChanges,
                 numIntervalFrames = numIntervalFrames
             }
-            functionTuples[#functionTuples + 1] = newIntervalFunction
+            intervalFunctions[#intervalFunctions + 1] = newIntervalFunction
         end
     end
 end
@@ -32373,24 +32373,24 @@ function RunInNFrames.prototype.restartNextRenderFrame(self, character)
         restart(nil, character)
     end)
 end
-function RunInNFrames.prototype.runInNGameFrames(self, func, gameFrames, cancelIfRoomChanges)
+function RunInNFrames.prototype.runInNGameFrames(self, func, numGameFrames, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
     local gameFrameCount = game:GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
-    local frameCountToFire = gameFrameCount + gameFrames
+    local frameCountToFire = gameFrameCount + numGameFrames
     local queuedFunction = {func = func, frameCountToFire = frameCountToFire, numRoomsEntered = numRoomsEntered, cancelIfRoomChanges = cancelIfRoomChanges}
     local ____self_v_run_queuedGameFunctions_0 = self.v.run.queuedGameFunctions
     ____self_v_run_queuedGameFunctions_0[#____self_v_run_queuedGameFunctions_0 + 1] = queuedFunction
 end
-function RunInNFrames.prototype.runInNRenderFrames(self, func, renderFrames, cancelIfRoomChanges)
+function RunInNFrames.prototype.runInNRenderFrames(self, func, numRenderFrames, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
     local renderFrameCount = Isaac.GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
-    local frameCountToFire = renderFrameCount + renderFrames
+    local frameCountToFire = renderFrameCount + numRenderFrames
     local queuedFunction = {func = func, frameCountToFire = frameCountToFire, numRoomsEntered = numRoomsEntered, cancelIfRoomChanges = cancelIfRoomChanges}
     local ____self_v_run_queuedRenderFunctions_1 = self.v.run.queuedRenderFunctions
     ____self_v_run_queuedRenderFunctions_1[#____self_v_run_queuedRenderFunctions_1 + 1] = queuedFunction
@@ -32407,43 +32407,49 @@ function RunInNFrames.prototype.runNextRenderFrame(self, func, cancelIfRoomChang
     end
     self:runInNRenderFrames(func, 1, cancelIfRoomChanges)
 end
-function RunInNFrames.prototype.setIntervalGameFrames(self, func, gameFrames, runImmediately, cancelIfRoomChanges)
+function RunInNFrames.prototype.setIntervalGameFrames(self, func, numGameFrames, runImmediately, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
+    if runImmediately then
+        local returnValue = func(nil)
+        if not returnValue then
+            return
+        end
+    end
     local gameFrameCount = game:GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
     local intervalFunction = {
         func = func,
-        frameCountToFire = gameFrameCount + gameFrames,
+        frameCountToFire = gameFrameCount + numGameFrames,
         numRoomsEntered = numRoomsEntered,
         cancelIfRoomChanges = cancelIfRoomChanges,
-        numIntervalFrames = gameFrames
+        numIntervalFrames = numGameFrames
     }
     local ____self_v_run_intervalGameFunctions_2 = self.v.run.intervalGameFunctions
     ____self_v_run_intervalGameFunctions_2[#____self_v_run_intervalGameFunctions_2 + 1] = intervalFunction
-    if runImmediately then
-        func(nil)
-    end
 end
-function RunInNFrames.prototype.setIntervalRenderFrames(self, func, renderFrames, runImmediately, cancelIfRoomChanges)
+function RunInNFrames.prototype.setIntervalRenderFrames(self, func, numRenderFrames, runImmediately, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
+    if runImmediately then
+        local returnValue = func(nil)
+        if not returnValue then
+            return
+        end
+    end
     local renderFrameCount = Isaac.GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
     local intervalFunction = {
         func = func,
-        frameCountToFire = renderFrameCount + renderFrames,
+        frameCountToFire = renderFrameCount + numRenderFrames,
         numRoomsEntered = numRoomsEntered,
         cancelIfRoomChanges = cancelIfRoomChanges,
-        numIntervalFrames = renderFrames
+        numIntervalFrames = numRenderFrames
     }
-    local ____self_v_run_intervalGameFunctions_3 = self.v.run.intervalGameFunctions
-    ____self_v_run_intervalGameFunctions_3[#____self_v_run_intervalGameFunctions_3 + 1] = intervalFunction
-    if runImmediately then
-        func(nil)
-    end
+    local ____self_v_run_intervalRenderFunctions_3 = self.v.run.intervalRenderFunctions
+    ____self_v_run_intervalRenderFunctions_3[#____self_v_run_intervalRenderFunctions_3 + 1] = intervalFunction
 end
 __TS__Decorate({Exported}, RunInNFrames.prototype, "restartNextRenderFrame", true)
 __TS__Decorate({Exported}, RunInNFrames.prototype, "runInNGameFrames", true)

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

@@ -28,11 +28,11 @@ export declare class RunInNFrames extends Feature {
      * 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 numGameFrames 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.
      */
-    runInNGameFrames(func: () => void, gameFrames: int, cancelIfRoomChanges?: boolean): void;
+    runInNGameFrames(func: () => void, numGameFrames: int, cancelIfRoomChanges?: boolean): void;
     /**
      * Supply a function to run N render frames from now in the `POST_RENDER` callback.
      *
@@ -46,11 +46,11 @@ export declare class RunInNFrames extends Feature {
      * 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 numRenderFrames 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.
      */
-    runInNRenderFrames(func: () => void, renderFrames: int, cancelIfRoomChanges?: boolean): void;
+    runInNRenderFrames(func: () => void, numRenderFrames: int, cancelIfRoomChanges?: boolean): void;
     /**
      * Supply a function to run on the next `POST_UPDATE` callback.
      *
@@ -115,13 +115,13 @@ export declare class RunInNFrames extends Feature {
      * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
      *
      * @param func The function to repeatedly run on an interval.
-     * @param gameFrames The amount of game frames to wait between each run.
+     * @param numGameFrames 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.
      */
-    setIntervalGameFrames(func: () => boolean, gameFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
+    setIntervalGameFrames(func: () => boolean, numGameFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
     /**
      * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
      * callback. The function will continue to be fired until `false` is returned from the function.
@@ -136,12 +136,12 @@ export declare class RunInNFrames extends Feature {
      * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
      *
      * @param func The function to repeatedly run on an interval.
-     * @param renderFrames The amount of game frames to wait between each run.
+     * @param numRenderFrames 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.
      */
-    setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
+    setIntervalRenderFrames(func: () => boolean, numRenderFrames: int, runImmediately: boolean, cancelIfRoomChanges?: boolean): void;
 }
 //# sourceMappingURL=RunInNFrames.d.ts.map

package/dist/src/classes/features/other/RunInNFrames.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAMvE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAwBhD,qBAAa,YAAa,SAAQ,OAAO;IAYvB,gBAAgB,QAAO,OAAO,CAAU;IAExD,OAAO,CAAC,WAAW,CAAc;IAoBjC,OAAO,CAAC,UAAU,CAchB;IAGF,OAAO,CAAC,UAAU,CAchB;IAEF;;;;;;;;OAQG;IAEI,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI;IAM3D;;;;;;;;;;;;;;;;OAgBG;IAEI,gBAAgB,CACrB,IAAI,EAAE,MAAM,IAAI,EAChB,UAAU,EAAE,GAAG,EACf,mBAAmB,UAAQ,GAC1B,IAAI;IAcP;;;;;;;;;;;;;;;;OAgBG;IAEI,kBAAkB,CACvB,IAAI,EAAE,MAAM,IAAI,EAChB,YAAY,EAAE,GAAG,EACjB,mBAAmB,UAAQ,GAC1B,IAAI;IAcP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,mBAAmB,UAAQ,GAAG,IAAI;IAI5E;;;;;;;;;;;;;OAaG;IAEI,kBAAkB,CACvB,IAAI,EAAE,MAAM,IAAI,EAChB,mBAAmB,UAAQ,GAC1B,IAAI;IAIP;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,OAAO,EACvB,mBAAmB,UAAQ,GAC1B,IAAI;IAkBP;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,uBAAuB,CAC5B,IAAI,EAAE,MAAM,OAAO,EACnB,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,OAAO,EACvB,mBAAmB,UAAQ,GAC1B,IAAI;CAiBR"}
+{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAMvE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAqBhD,qBAAa,YAAa,SAAQ,OAAO;IAYvB,gBAAgB,QAAO,OAAO,CAAU;IAExD,OAAO,CAAC,WAAW,CAAc;IAoBjC,OAAO,CAAC,UAAU,CAchB;IAGF,OAAO,CAAC,UAAU,CAchB;IAEF;;;;;;;;OAQG;IAEI,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI;IAM3D;;;;;;;;;;;;;;;;OAgBG;IAEI,gBAAgB,CACrB,IAAI,EAAE,MAAM,IAAI,EAChB,aAAa,EAAE,GAAG,EAClB,mBAAmB,UAAQ,GAC1B,IAAI;IAcP;;;;;;;;;;;;;;;;OAgBG;IAEI,kBAAkB,CACvB,IAAI,EAAE,MAAM,IAAI,EAChB,eAAe,EAAE,GAAG,EACpB,mBAAmB,UAAQ,GAC1B,IAAI;IAcP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,mBAAmB,UAAQ,GAAG,IAAI;IAI5E;;;;;;;;;;;;;OAaG;IAEI,kBAAkB,CACvB,IAAI,EAAE,MAAM,IAAI,EAChB,mBAAmB,UAAQ,GAC1B,IAAI;IAIP;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,aAAa,EAAE,GAAG,EAClB,cAAc,EAAE,OAAO,EACvB,mBAAmB,UAAQ,GAC1B,IAAI;IAqBP;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,uBAAuB,CAC5B,IAAI,EAAE,MAAM,OAAO,EACnB,eAAe,EAAE,GAAG,EACpB,cAAc,EAAE,OAAO,EACvB,mBAAmB,UAAQ,GAC1B,IAAI;CAoBR"}

package/dist/src/classes/features/other/RunInNFrames.lua

@@ -19,9 +19,9 @@ local ____run = require("src.functions.run")
 local restart = ____run.restart
 local ____Feature = require("src.classes.private.Feature")
 local Feature = ____Feature.Feature
-function checkExecuteQueuedFunctions(self, functionTuples, frameCount, newNumRoomsEntered)
+function checkExecuteQueuedFunctions(self, queuedFunctions, frameCount, newNumRoomsEntered)
     local firingFunctions = __TS__ArrayFilter(
-        functionTuples,
+        queuedFunctions,
         function(____, ____bindingPattern0)
             local frameCountToFire
             frameCountToFire = ____bindingPattern0.frameCountToFire
@@ -35,12 +35,12 @@ function checkExecuteQueuedFunctions(self, functionTuples, frameCount, newNumRoo
         if not cancelIfRoomChanges or numRoomsEntered == newNumRoomsEntered then
             func(nil)
         end
-        arrayRemoveInPlace(nil, functionTuples, firingFunction)
+        arrayRemoveInPlace(nil, queuedFunctions, firingFunction)
     end
 end
-function checkExecuteIntervalFunctions(self, functionTuples, frameCount, newNumRoomsEntered)
+function checkExecuteIntervalFunctions(self, intervalFunctions, frameCount, newNumRoomsEntered)
     local firingFunctions = __TS__ArrayFilter(
-        functionTuples,
+        intervalFunctions,
         function(____, ____bindingPattern0)
             local frameCountToFire
             frameCountToFire = ____bindingPattern0.frameCountToFire
@@ -56,7 +56,7 @@ function checkExecuteIntervalFunctions(self, functionTuples, frameCount, newNumR
         if not cancelIfRoomChanges or numRoomsEntered == newNumRoomsEntered then
             returnValue = func(nil)
         end
-        arrayRemoveInPlace(nil, functionTuples, firingFunction)
+        arrayRemoveInPlace(nil, intervalFunctions, firingFunction)
         if returnValue then
             local newIntervalFunction = {
                 func = func,
@@ -65,7 +65,7 @@ function checkExecuteIntervalFunctions(self, functionTuples, frameCount, newNumR
                 cancelIfRoomChanges = cancelIfRoomChanges,
                 numIntervalFrames = numIntervalFrames
             }
-            functionTuples[#functionTuples + 1] = newIntervalFunction
+            intervalFunctions[#intervalFunctions + 1] = newIntervalFunction
         end
     end
 end
@@ -98,24 +98,24 @@ function RunInNFrames.prototype.restartNextRenderFrame(self, character)
         restart(nil, character)
     end)
 end
-function RunInNFrames.prototype.runInNGameFrames(self, func, gameFrames, cancelIfRoomChanges)
+function RunInNFrames.prototype.runInNGameFrames(self, func, numGameFrames, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
     local gameFrameCount = game:GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
-    local frameCountToFire = gameFrameCount + gameFrames
+    local frameCountToFire = gameFrameCount + numGameFrames
     local queuedFunction = {func = func, frameCountToFire = frameCountToFire, numRoomsEntered = numRoomsEntered, cancelIfRoomChanges = cancelIfRoomChanges}
     local ____self_v_run_queuedGameFunctions_0 = self.v.run.queuedGameFunctions
     ____self_v_run_queuedGameFunctions_0[#____self_v_run_queuedGameFunctions_0 + 1] = queuedFunction
 end
-function RunInNFrames.prototype.runInNRenderFrames(self, func, renderFrames, cancelIfRoomChanges)
+function RunInNFrames.prototype.runInNRenderFrames(self, func, numRenderFrames, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
     local renderFrameCount = Isaac.GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
-    local frameCountToFire = renderFrameCount + renderFrames
+    local frameCountToFire = renderFrameCount + numRenderFrames
     local queuedFunction = {func = func, frameCountToFire = frameCountToFire, numRoomsEntered = numRoomsEntered, cancelIfRoomChanges = cancelIfRoomChanges}
     local ____self_v_run_queuedRenderFunctions_1 = self.v.run.queuedRenderFunctions
     ____self_v_run_queuedRenderFunctions_1[#____self_v_run_queuedRenderFunctions_1 + 1] = queuedFunction
@@ -132,43 +132,49 @@ function RunInNFrames.prototype.runNextRenderFrame(self, func, cancelIfRoomChang
     end
     self:runInNRenderFrames(func, 1, cancelIfRoomChanges)
 end
-function RunInNFrames.prototype.setIntervalGameFrames(self, func, gameFrames, runImmediately, cancelIfRoomChanges)
+function RunInNFrames.prototype.setIntervalGameFrames(self, func, numGameFrames, runImmediately, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
+    if runImmediately then
+        local returnValue = func(nil)
+        if not returnValue then
+            return
+        end
+    end
     local gameFrameCount = game:GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
     local intervalFunction = {
         func = func,
-        frameCountToFire = gameFrameCount + gameFrames,
+        frameCountToFire = gameFrameCount + numGameFrames,
         numRoomsEntered = numRoomsEntered,
         cancelIfRoomChanges = cancelIfRoomChanges,
-        numIntervalFrames = gameFrames
+        numIntervalFrames = numGameFrames
     }
     local ____self_v_run_intervalGameFunctions_2 = self.v.run.intervalGameFunctions
     ____self_v_run_intervalGameFunctions_2[#____self_v_run_intervalGameFunctions_2 + 1] = intervalFunction
-    if runImmediately then
-        func(nil)
-    end
 end
-function RunInNFrames.prototype.setIntervalRenderFrames(self, func, renderFrames, runImmediately, cancelIfRoomChanges)
+function RunInNFrames.prototype.setIntervalRenderFrames(self, func, numRenderFrames, runImmediately, cancelIfRoomChanges)
     if cancelIfRoomChanges == nil then
         cancelIfRoomChanges = false
     end
+    if runImmediately then
+        local returnValue = func(nil)
+        if not returnValue then
+            return
+        end
+    end
     local renderFrameCount = Isaac.GetFrameCount()
     local numRoomsEntered = self.roomHistory:getNumRoomsEntered()
     local intervalFunction = {
         func = func,
-        frameCountToFire = renderFrameCount + renderFrames,
+        frameCountToFire = renderFrameCount + numRenderFrames,
         numRoomsEntered = numRoomsEntered,
         cancelIfRoomChanges = cancelIfRoomChanges,
-        numIntervalFrames = renderFrames
+        numIntervalFrames = numRenderFrames
     }
-    local ____self_v_run_intervalGameFunctions_3 = self.v.run.intervalGameFunctions
-    ____self_v_run_intervalGameFunctions_3[#____self_v_run_intervalGameFunctions_3 + 1] = intervalFunction
-    if runImmediately then
-        func(nil)
-    end
+    local ____self_v_run_intervalRenderFunctions_3 = self.v.run.intervalRenderFunctions
+    ____self_v_run_intervalRenderFunctions_3[#____self_v_run_intervalRenderFunctions_3 + 1] = intervalFunction
 end
 __TS__Decorate({Exported}, RunInNFrames.prototype, "restartNextRenderFrame", true)
 __TS__Decorate({Exported}, RunInNFrames.prototype, "runInNGameFrames", true)

package/dist/src/functions/itemPool.d.ts

@@ -1,8 +1,8 @@
 import { ItemPoolType } from "isaac-typescript-definitions";
 /**
- * Helper function to get a random item pool. This is as simple as getting a random value from the
- * `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the Greed
- * Mode item pools should be excluded if not playing in Greed Mode.
+ * Helper function to get a random item pool. This is not as simple as getting a random value from
+ * the `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the
+ * Greed Mode item pools should be excluded if not playing in Greed Mode.
  */
 export declare function getRandomItemPool(): ItemPoolType;
 //# sourceMappingURL=itemPool.d.ts.map

package/dist/src/functions/itemPool.lua

@@ -53,9 +53,9 @@ __TS__SparseArrayPush(
     table.unpack(FAKE_ITEM_POOL_TYPES)
 )
 local GREED_MODE_ITEM_POOL_TYPES = ____arrayRemove_3(__TS__SparseArraySpread(____array_2))
---- Helper function to get a random item pool. This is as simple as getting a random value from the
--- `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the Greed
--- Mode item pools should be excluded if not playing in Greed Mode.
+--- Helper function to get a random item pool. This is not as simple as getting a random value from
+-- the `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the
+-- Greed Mode item pools should be excluded if not playing in Greed Mode.
 function ____exports.getRandomItemPool(self)
     local itemPoolTypes = isGreedMode(nil) and GREED_MODE_ITEM_POOL_TYPES or NORMAL_MODE_ITEM_POOL_TYPES
     return getRandomArrayElement(nil, itemPoolTypes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "21.8.0",
+  "version": "21.8.1",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",

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

@@ -20,11 +20,8 @@ interface QueuedFunction {
  *
  * The return value is whether or not to continue the function from firing.
  */
-interface IntervalFunction {
+interface IntervalFunction extends QueuedFunction {
   func: () => boolean;
-  frameCountToFire: int;
-  numRoomsEntered: int;
-  cancelIfRoomChanges: boolean;
   numIntervalFrames: int;
 }
 
@@ -124,20 +121,20 @@ export class RunInNFrames extends Feature {
    * 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 numGameFrames 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,
+    numGameFrames: int,
     cancelIfRoomChanges = false,
   ): void {
     const gameFrameCount = game.GetFrameCount();
     const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
 
-    const frameCountToFire = gameFrameCount + gameFrames;
+    const frameCountToFire = gameFrameCount + numGameFrames;
     const queuedFunction: QueuedFunction = {
       func,
       frameCountToFire,
@@ -160,20 +157,20 @@ export class RunInNFrames extends Feature {
    * 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 numRenderFrames 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,
+    numRenderFrames: int,
     cancelIfRoomChanges = false,
   ): void {
     const renderFrameCount = Isaac.GetFrameCount();
     const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
 
-    const frameCountToFire = renderFrameCount + renderFrames;
+    const frameCountToFire = renderFrameCount + numRenderFrames;
     const queuedFunction: QueuedFunction = {
       func,
       frameCountToFire,
@@ -258,7 +255,7 @@ export class RunInNFrames extends Feature {
    * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
    *
    * @param func The function to repeatedly run on an interval.
-   * @param gameFrames The amount of game frames to wait between each run.
+   * @param numGameFrames 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
@@ -267,25 +264,28 @@ export class RunInNFrames extends Feature {
   @Exported
   public setIntervalGameFrames(
     func: () => boolean,
-    gameFrames: int,
+    numGameFrames: int,
     runImmediately: boolean,
     cancelIfRoomChanges = false,
   ): void {
+    if (runImmediately) {
+      const returnValue = func();
+      if (!returnValue) {
+        return;
+      }
+    }
+
     const gameFrameCount = game.GetFrameCount();
     const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
 
     const intervalFunction: IntervalFunction = {
       func,
-      frameCountToFire: gameFrameCount + gameFrames,
+      frameCountToFire: gameFrameCount + numGameFrames,
       numRoomsEntered,
       cancelIfRoomChanges,
-      numIntervalFrames: gameFrames,
+      numIntervalFrames: numGameFrames,
     };
     this.v.run.intervalGameFunctions.push(intervalFunction);
-
-    if (runImmediately) {
-      func();
-    }
   }
 
   /**
@@ -302,7 +302,7 @@ export class RunInNFrames extends Feature {
    * In order to use this function, you must upgrade your mod with `ISCFeature.RUN_IN_N_FRAMES`.
    *
    * @param func The function to repeatedly run on an interval.
-   * @param renderFrames The amount of game frames to wait between each run.
+   * @param numRenderFrames 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
@@ -311,34 +311,37 @@ export class RunInNFrames extends Feature {
   @Exported
   public setIntervalRenderFrames(
     func: () => boolean,
-    renderFrames: int,
+    numRenderFrames: int,
     runImmediately: boolean,
     cancelIfRoomChanges = false,
   ): void {
+    if (runImmediately) {
+      const returnValue = func();
+      if (!returnValue) {
+        return;
+      }
+    }
+
     const renderFrameCount = Isaac.GetFrameCount();
     const numRoomsEntered = this.roomHistory.getNumRoomsEntered();
 
     const intervalFunction: IntervalFunction = {
       func,
-      frameCountToFire: renderFrameCount + renderFrames,
+      frameCountToFire: renderFrameCount + numRenderFrames,
       numRoomsEntered,
       cancelIfRoomChanges,
-      numIntervalFrames: renderFrames,
+      numIntervalFrames: numRenderFrames,
     };
-    this.v.run.intervalGameFunctions.push(intervalFunction);
-
-    if (runImmediately) {
-      func();
-    }
+    this.v.run.intervalRenderFunctions.push(intervalFunction);
   }
 }
 
 function checkExecuteQueuedFunctions(
-  functionTuples: QueuedFunction[],
+  queuedFunctions: QueuedFunction[],
   frameCount: int,
   newNumRoomsEntered: int,
 ) {
-  const firingFunctions = functionTuples.filter(
+  const firingFunctions = queuedFunctions.filter(
     ({ frameCountToFire }) => frameCount >= frameCountToFire,
   );
 
@@ -349,16 +352,16 @@ function checkExecuteQueuedFunctions(
       func();
     }
 
-    arrayRemoveInPlace(functionTuples, firingFunction);
+    arrayRemoveInPlace(queuedFunctions, firingFunction);
   }
 }
 
 function checkExecuteIntervalFunctions(
-  functionTuples: IntervalFunction[],
+  intervalFunctions: IntervalFunction[],
   frameCount: int,
   newNumRoomsEntered: int,
 ) {
-  const firingFunctions = functionTuples.filter(
+  const firingFunctions = intervalFunctions.filter(
     ({ frameCountToFire }) => frameCount >= frameCountToFire,
   );
 
@@ -371,7 +374,7 @@ function checkExecuteIntervalFunctions(
       returnValue = func();
     }
 
-    arrayRemoveInPlace(functionTuples, firingFunction);
+    arrayRemoveInPlace(intervalFunctions, firingFunction);
 
     // Queue the next interval (as long as the function did not return false).
     if (returnValue) {
@@ -382,7 +385,7 @@ function checkExecuteIntervalFunctions(
         cancelIfRoomChanges,
         numIntervalFrames,
       };
-      functionTuples.push(newIntervalFunction);
+      intervalFunctions.push(newIntervalFunction);
     }
   }
 }

package/src/functions/itemPool.ts

@@ -38,9 +38,9 @@ const GREED_MODE_ITEM_POOL_TYPES: readonly ItemPoolType[] = arrayRemove(
 );
 
 /**
- * Helper function to get a random item pool. This is as simple as getting a random value from the
- * `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the Greed
- * Mode item pools should be excluded if not playing in Greed Mode.
+ * Helper function to get a random item pool. This is not as simple as getting a random value from
+ * the `ItemPoolType` enum, since `ItemPoolType.SHELL_GAME` (7) is not a real item pool and the
+ * Greed Mode item pools should be excluded if not playing in Greed Mode.
  */
 export function getRandomItemPool(): ItemPoolType {
   const itemPoolTypes = isGreedMode()