isaacscript-common 71.2.0 → 72.0.0

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

@@ -36,7 +36,6 @@ import {
   isPassiveOrFamiliarCollectible,
 } from "../../../functions/collectibles";
 import { getFlagName } from "../../../functions/flag";
-import { getRandomSeed } from "../../../functions/rng";
 import {
   copySet,
   deleteSetsFromSet,
@@ -1181,18 +1180,23 @@ export class ModdedElementSets extends Feature {
    * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
+   * If you want to get an unseeded collectible type, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    *
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param exceptions Optional. An array of runes to not select.
    */
   @Exported
   public getRandomEdenActiveCollectibleType(
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     exceptions: CollectibleType[] | readonly CollectibleType[] = [],
   ): CollectibleType {
     this.lazyInit();
+
     return getRandomSetElement(
       this.edenPassiveCollectibleTypesSet,
       seedOrRNG,
@@ -1208,18 +1212,23 @@ export class ModdedElementSets extends Feature {
    * not all collectible types will necessarily be present when a mod first loads (due to mod load
    * order).
    *
+   * If you want to get an unseeded collectible type, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    *
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param exceptions Optional. An array of runes to not select.
    */
   @Exported
   public getRandomEdenPassiveCollectibleType(
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     exceptions: CollectibleType[] | readonly CollectibleType[] = [],
   ): CollectibleType {
     this.lazyInit();
+
     return getRandomSetElement(
       this.edenPassiveCollectibleTypesSet,
       seedOrRNG,
@@ -1330,18 +1339,22 @@ export class ModdedElementSets extends Feature {
    * This function can only be called if at least one callback has been executed. This is because
    * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
+   * If you want to get an unseeded card type, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    *
    * @param itemConfigCardType The item config card type that represents the pool of cards to select
    *                           from.
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param exceptions Optional. An array of cards to not select.
    */
   @Exported
   public getRandomCardTypeOfType(
     itemConfigCardType: ItemConfigCardType,
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     exceptions: CardType[] = [],
   ): CardType {
     const cardTypeSet = this.getCardTypesOfType(itemConfigCardType);
@@ -1358,15 +1371,19 @@ export class ModdedElementSets extends Feature {
    * This function can only be called if at least one callback has been executed. This is because
    * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
+   * If you want to get an unseeded card type, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    *
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param exceptions Optional. An array of cards to not select.
    */
   @Exported
   public getRandomCard(
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     exceptions: CardType[] = [],
   ): CardType {
     this.lazyInit();
@@ -1380,15 +1397,19 @@ export class ModdedElementSets extends Feature {
    * This function can only be called if at least one callback has been executed. This is because
    * not all card types will necessarily be present when a mod first loads (due to mod load order).
    *
+   * If you want to get an unseeded card type, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.MODDED_ELEMENT_SETS`.
    *
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param exceptions Optional. An array of runes to not select.
    */
   @Exported
   public getRandomRune(
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     exceptions: CardType[] = [],
   ): CardType {
     const runesSet = this.getCardTypesOfType(ItemConfigCardType.RUNE);

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

@@ -6,7 +6,6 @@ import { game } from "../../../core/cachedClasses";
 import { Exported } from "../../../decorators";
 import { ISCFeature } from "../../../enums/ISCFeature";
 import { isQuestCollectible } from "../../../functions/collectibleTag";
-import { getRandomSeed } from "../../../functions/rng";
 import { spawnCollectibleUnsafe } from "../../../functions/spawnCollectible";
 import { Feature } from "../../private/Feature";
 import type { PreventCollectibleRotation } from "./PreventCollectibleRotation";
@@ -34,12 +33,16 @@ export class SpawnCollectible extends Feature {
    * to be a quest item), then you can use the `spawnCollectibleUnsafe` helper function instead
    * (which does not require an upgraded mod).
    *
+   * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.SPAWN_COLLECTIBLE`.
    *
    * @param collectibleType The collectible type to spawn.
    * @param positionOrGridIndex The position or grid index to spawn the collectible at.
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param options Optional. Set to true to make the collectible a "There's Options" style
    *                collectible. Default is false.
    * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
@@ -50,7 +53,7 @@ export class SpawnCollectible extends Feature {
   public spawnCollectible(
     collectibleType: CollectibleType,
     positionOrGridIndex: Vector | int,
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     options = false,
     forceFreeItem = false,
     spawner?: Entity,
@@ -81,12 +84,16 @@ export class SpawnCollectible extends Feature {
    * collectibles costing coins and preventing quest items from being rotated by Tainted Isaac's
    * rotation mechanic.
    *
+   * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with `ISCFeature.SPAWN_COLLECTIBLE`.
    *
    * @param itemPoolType The item pool to draw the collectible type from.
    * @param positionOrGridIndex The position or grid index to spawn the collectible at.
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @param options Optional. Set to true to make the collectible a "There's Options" style
    *                collectible. Default is false.
    * @param forceFreeItem Optional. Set to true to disable the logic that gives the item a price for
@@ -97,7 +104,7 @@ export class SpawnCollectible extends Feature {
   public spawnCollectibleFromPool(
     itemPoolType: ItemPoolType,
     positionOrGridIndex: Vector | int,
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
     options = false,
     forceFreeItem = false,
     spawner?: Entity,

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

@@ -28,7 +28,7 @@ import {
 } from "../../../functions/pickupsSpecific";
 import { fireProjectilesInCircle } from "../../../functions/projectiles";
 import { getRandom } from "../../../functions/random";
-import { getRandomSeed, isRNG, newRNG } from "../../../functions/rng";
+import { isRNG, newRNG } from "../../../functions/rng";
 import { spawnCollectibleUnsafe } from "../../../functions/spawnCollectible";
 import { repeat } from "../../../functions/utils";
 import { getRandomVector, isVector } from "../../../functions/vector";
@@ -89,22 +89,26 @@ export class SpawnRockAltRewards extends Feature {
    * The logic in this function is based on the rewards listed on the wiki:
    * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
    *
+   * If you want to spawn an unseeded reward, you must explicitly pass `undefined` to the
+   * `seedOrRNG` parameter.
+   *
    * In order to use this function, you must upgrade your mod with
    * `ISCFeature.SPAWN_ALT_ROCK_REWARDS`.
    *
    * @param positionOrGridIndex The position or grid index to spawn the reward.
    * @param rockAltType The type of reward to spawn. For example, `RockAltType.URN` will have a
    *                    chance at spawning coins and spiders.
-   * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided,
-   *                  the `RNG.Next` method will be called. Default is `getRandomSeed()`. Normally,
-   *                  you should pass the `InitSeed` of the grid entity that was broken.
+   * @param seedOrRNG The `Seed` or `RNG` object to use. Normally, you should pass the `InitSeed` of
+   *                  the grid entity that was broken. If an `RNG` object is provided, the
+   *                  `RNG.Next` method will be called. If `undefined` is provided, it will default
+   *                  to a random seed.
    * @returns Whether this function spawned something.
    */
   @Exported
   public spawnRockAltReward(
     positionOrGridIndex: Vector | int,
     rockAltType: RockAltType,
-    seedOrRNG: Seed | RNG = getRandomSeed(),
+    seedOrRNG: Seed | RNG | undefined,
   ): boolean {
     const room = game.GetRoom();
     const position = isVector(positionOrGridIndex)

package/src/classes/features/other/customStages/utils.ts

@@ -1,7 +1,6 @@
 import { sumArray } from "../../../../functions/array";
 import { log } from "../../../../functions/log";
 import { getRandomFloat } from "../../../../functions/random";
-import { getRandomSeed } from "../../../../functions/rng";
 import type {
   CustomStageBossPoolEntry,
   CustomStageRoomMetadata,
@@ -16,7 +15,7 @@ import type {
  */
 export function getRandomCustomStageRoom(
   roomsMetadata: readonly CustomStageRoomMetadata[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   verbose = false,
 ): CustomStageRoomMetadata {
   const totalWeight = getTotalWeightOfCustomStageRooms(roomsMetadata);
@@ -59,7 +58,7 @@ function getCustomStageRoomWithChosenWeight(
 export function getRandomBossRoomFromPool(
   roomsMetadata: readonly CustomStageRoomMetadata[],
   bossPool: readonly CustomStageBossPoolEntry[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   verbose = false,
 ): CustomStageRoomMetadata {
   const totalWeight = getTotalWeightOfBossPool(bossPool);

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

@@ -1470,7 +1470,7 @@ export function spawnCollectible(params: string): void {
 
   const roomClass = game.GetRoom();
   const centerPos = roomClass.GetCenterPos();
-  spawnCollectibleUnsafe(collectibleType, centerPos);
+  spawnCollectibleUnsafe(collectibleType, centerPos, undefined);
 }
 
 /**
@@ -1515,7 +1515,7 @@ export function spawnCollectibleAt(params: string): void {
   }
 
   const collectibleType = asCollectibleType(collectibleTypeNumber);
-  spawnCollectibleUnsafe(collectibleType, gridIndex);
+  spawnCollectibleUnsafe(collectibleType, gridIndex, undefined);
 }
 
 /** Alias for the `spawnGoldenTrinket` command. */

package/src/functions/array.ts

@@ -1,7 +1,7 @@
 import { ReadonlySet } from "../types/ReadonlySet";
 import type { WidenLiteral } from "../types/WidenLiteral";
 import { getRandomInt } from "./random";
-import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isRNG, newRNG } from "./rng";
 import { isNumber, isTable } from "./types";
 import { assertDefined, eRange } from "./utils";
 
@@ -393,14 +393,18 @@ export function getLowestArrayElement(array: number[]): number | undefined {
 /**
  * Helper function to get a random element from the provided array.
  *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param array The array to get an element from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
 export function getRandomArrayElement<T>(
   array: T[] | readonly T[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   exceptions: T[] | readonly T[] = [],
 ): T {
   if (array.length === 0) {
@@ -425,14 +429,18 @@ export function getRandomArrayElement<T>(
  * Helper function to get a random element from the provided array. Once the random element is
  * decided, it is then removed from the array (in-place).
  *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param array The array to get an element from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
 export function getRandomArrayElementAndRemove<T>(
   array: T[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   exceptions: T[] | readonly T[] = [],
 ): T {
   const randomArrayElement = getRandomArrayElement(
@@ -447,15 +455,19 @@ export function getRandomArrayElementAndRemove<T>(
 /**
  * Helper function to get a random index from the provided array.
  *
+ * If you want to get an unseeded index, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param array The array to get the index from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param exceptions Optional. An array of indexes that will be skipped over when getting the random
  *                   index. Default is an empty array.
  */
 export function getRandomArrayIndex<T>(
   array: T[] | readonly T[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   exceptions: int[] | readonly int[] = [],
 ): int {
   if (array.length === 0) {
@@ -570,15 +582,19 @@ export function setAllArrayElements<T>(array: T[], value: T): void {
 /**
  * Shallow copies and shuffles the array using the Fisher-Yates algorithm. Returns the copied array.
  *
+ * If you want an unseeded shuffle, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
  *
  * @param originalArray The array to shuffle.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
 export function shuffleArray<T>(
   originalArray: T[] | readonly T[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
 ): T[] {
   const array = copyArray(originalArray);
   shuffleArrayInPlace(array, seedOrRNG);
@@ -589,15 +605,19 @@ export function shuffleArray<T>(
 /**
  * Shuffles the provided array in-place using the Fisher-Yates algorithm.
  *
+ * If you want an unseeded shuffle, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
  *
  * @param array The array to shuffle.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
 export function shuffleArrayInPlace<T>(
   array: T[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
 ): void {
   let currentIndex = array.length;
 

package/src/functions/color.ts

@@ -2,7 +2,7 @@ import type { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
-import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isRNG, newRNG } from "./rng";
 import {
   copyUserdataValuesToTable,
   getNumbersFromTable,
@@ -76,14 +76,18 @@ export function deserializeColor(color: SerializedColor): Color {
 }
 
 /**
- * Helper function to get a random color.
+ * Helper function to get a random `Color` object.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to generate an unseeded object, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param alpha Optional. The alpha value to use. Default is 1.
  */
 export function getRandomColor(
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   alpha = 1,
 ): Readonly<Color> {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);

package/src/functions/enums.ts

@@ -1,6 +1,5 @@
 import { ReadonlySet } from "../types/ReadonlySet";
 import { getRandomArrayElement } from "./array";
-import { getRandomSeed } from "./rng";
 import { isNumber, isString } from "./types";
 import { assertDefined, iRange } from "./utils";
 
@@ -176,14 +175,17 @@ export function getLowestEnumValue<T>(transpiledEnum: T): T[keyof T] {
 /**
  * Helper function to get a random value from the provided enum.
  *
+ * If you want an unseeded value, you must explicitly pass `undefined` to the `seedOrRNG` parameter.
+ *
  * @param transpiledEnum The enum to get the value from.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
 export function getRandomEnumValue<T>(
   transpiledEnum: T,
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   exceptions: Array<T[keyof T]> | ReadonlyArray<T[keyof T]> = [],
 ): T[keyof T] {
   const enumValues = getEnumValues(transpiledEnum);

package/src/functions/itemPool.ts

@@ -45,12 +45,21 @@ const GREED_MODE_ITEM_POOL_TYPES: readonly ItemPoolType[] = arrayRemove(
  * 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.
+ *
+ * If you want to get an unseeded item pool, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
-export function getRandomItemPool(): ItemPoolType {
+export function getRandomItemPool(
+  seedOrRNG: Seed | RNG | undefined,
+): ItemPoolType {
   const itemPoolTypes = game.IsGreedMode()
     ? GREED_MODE_ITEM_POOL_TYPES
     : NORMAL_MODE_ITEM_POOL_TYPES;
-  return getRandomArrayElement(itemPoolTypes);
+  return getRandomArrayElement(itemPoolTypes, seedOrRNG);
 }
 
 /**

package/src/functions/jsonRoom.ts

@@ -7,7 +7,6 @@ import { isEnumValue } from "./enums";
 import { addFlag } from "./flag";
 import { log } from "./log";
 import { getRandomFloat } from "./random";
-import { getRandomSeed } from "./rng";
 import { assertDefined } from "./utils";
 
 /** This represents either a `JSONRoom` or a `JSONEntity`. */
@@ -141,15 +140,19 @@ export function getJSONRoomsOfSubType(
  * properly account for each room weight using the algorithm from:
  * https://stackoverflow.com/questions/1761626/weighted-random-numbers
  *
+ * If you want an unseeded entity, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param jsonEntities The array of entities to randomly choose between.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param verbose Optional. If specified, will write entries to the "log.txt" file that describe
  *                what the function is doing. Default is false.
  */
 export function getRandomJSONEntity(
   jsonEntities: JSONEntity[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   verbose = false,
 ): JSONEntity {
   const totalWeight = getTotalWeightOfJSONObject(jsonEntities);
@@ -183,15 +186,18 @@ export function getRandomJSONEntity(
  * properly account for each room weight using the algorithm from:
  * https://stackoverflow.com/questions/1761626/weighted-random-numbers
  *
+ * If you want an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG` parameter.
+ *
  * @param jsonRooms The array of rooms to randomly choose between.
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param verbose Optional. If specified, will write entries to the "log.txt" file that describe
  *                what the function is doing. Default is false.
  */
 export function getRandomJSONRoom(
   jsonRooms: JSONRoom[],
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   verbose = false,
 ): JSONRoom {
   const totalWeight = getTotalWeightOfJSONObject(jsonRooms);

package/src/functions/kColor.ts

@@ -2,7 +2,7 @@ import type { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
-import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isRNG, newRNG } from "./rng";
 import {
   copyUserdataValuesToTable,
   getNumbersFromTable,
@@ -64,14 +64,18 @@ export function deserializeKColor(kColor: SerializedKColor): KColor {
 }
 
 /**
- * Helper function to get a random color.
+ * Helper function to get a random `KColor` object (for use in fonts).
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to generate an unseeded object, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param alpha Optional. The alpha value to use. Default is 1.
  */
 export function getRandomKColor(
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   alpha = 1,
 ): Readonly<KColor> {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);

package/src/functions/levelGrid.ts

@@ -25,7 +25,7 @@ import { getRandomArrayElement } from "./array";
 import { doorSlotToDoorSlotFlag } from "./doors";
 import { addFlag, hasFlag, removeFlag } from "./flag";
 import { copyMap } from "./map";
-import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isRNG, newRNG } from "./rng";
 import {
   getRoomAllowedDoors,
   getRoomData,
@@ -126,8 +126,12 @@ export function getAllRoomGridIndexes(): readonly int[] {
  * some floors will not have any valid spots. If this is the case, this function will return
  * undefined.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * If you want to get an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  * @param ensureDeadEnd Optional. Whether to pick a valid dead end attached to a normal room. If
  *                      false, the function will randomly pick from any valid location that would
  *                      have a red door.
@@ -135,7 +139,7 @@ export function getAllRoomGridIndexes(): readonly int[] {
  *          undefined.
  */
 export function getNewRoomCandidate(
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   ensureDeadEnd = true,
 ):
   | {
@@ -521,9 +525,12 @@ export function isRoomInsideGrid(roomGridIndex?: int): boolean {
 /**
  * Helper function to generate a new room on the floor.
  *
+ * If you want to generate an unseeded room, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * Under the hood, this function uses the `Level.MakeRedRoomDoor` method to create the room.
  *
- * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
  *                  `RNG.Next` method will be called. Default is `Level.GetDungeonPlacementSeed`.
  *                  Note that the RNG is only used to select the random location to put the room on
  *                  the floor; it does not influence the randomly chosen room contents. (That is
@@ -538,7 +545,7 @@ export function isRoomInsideGrid(roomGridIndex?: int): boolean {
  *          place a room.
  */
 export function newRoom(
-  seedOrRNG?: Seed | RNG,
+  seedOrRNG: Seed | RNG | undefined,
   ensureDeadEnd = true,
   customRoomData?: RoomConfig,
 ): int | undefined {