isaacscript-common 71.2.1 → 72.0.1

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 {

package/src/functions/random.ts

@@ -1,14 +1,18 @@
 import { ReadonlySet } from "../types/ReadonlySet";
-import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isRNG, newRNG } from "./rng";
 
 /**
  * Returns a random float between 0 and 1. It is inclusive on the low end, but exclusive on the high
  * end. (This is because the `RNG.RandomFloat` method will never return a value of exactly 1.)
  *
- * @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 number, 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 getRandom(seedOrRNG: Seed | RNG = getRandomSeed()): float {
+export function getRandom(seedOrRNG: Seed | RNG | undefined): float {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
   return rng.RandomFloat();
 }
@@ -19,18 +23,22 @@ export function getRandom(seedOrRNG: Seed | RNG = getRandomSeed()): float {
  * For example:
  *
  * ```ts
- * const realNumberBetweenOneAndThree = getRandomFloat(1, 3);
+ * const realNumberBetweenOneAndThree = getRandomFloat(1, 3, undefined);
  * ```
  *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param min The lower bound for the random number (inclusive).
  * @param max The upper bound for the random number (exclusive).
- * @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 getRandomFloat(
   min: int,
   max: int,
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
 ): float {
   if (min > max) {
     const oldMin = min;
@@ -46,19 +54,20 @@ export function getRandomFloat(
 /**
  * Returns a random integer between min and max. It is inclusive on both ends.
  *
- * Note that this function will run the `Next` method on the `RNG` object before returning the
- * random number.
- *
  * For example:
  *
  * ```ts
  * const oneTwoOrThree = getRandomInt(1, 3);
  * ```
  *
+ * If you want to generate an unseeded number, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param min The lower bound for the random number (inclusive).
  * @param max The upper bound for the random number (inclusive).
- * @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 that will be skipped over when getting the
  *                   random integer. For example, a min of 1, a max of 4, and an exceptions array of
  *                   `[2]` would cause the function to return either 1, 3, or 4. Default is an empty
@@ -67,7 +76,7 @@ export function getRandomFloat(
 export function getRandomInt(
   min: int,
   max: int,
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   exceptions: int[] | readonly int[] = [],
 ): int {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);

package/src/functions/rng.ts

@@ -86,7 +86,7 @@ export function isSerializedRNG(object: unknown): object is SerializedRNG {
 /**
  * Helper function to initialize a new RNG object using Blade's recommended shift index.
  *
- * @param seed The seed to initialize it with. Default is `getRandomSeed()`.
+ * @param seed Optional. The seed to initialize it with. Default is a random seed.
  */
 export function newRNG(seed = getRandomSeed()): RNG {
   const rng = RNG();

package/src/functions/set.ts

@@ -1,6 +1,5 @@
 import { ReadonlySet } from "../types/ReadonlySet";
 import { getArrayCombinations, getRandomArrayElement, sumArray } from "./array";
-import { getRandomSeed } from "./rng";
 import { isPrimitive } from "./types";
 
 /**
@@ -68,14 +67,18 @@ export function deleteSetsFromSet<T>(
 /**
  * Helper function to get a random element from the provided set.
  *
+ * If you want to get an unseeded element, you must explicitly pass `undefined` to the `seedOrRNG`
+ * parameter.
+ *
  * @param set The set 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 getRandomSetElement<T>(
   set: Set<T> | ReadonlySet<T>,
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   exceptions: T[] | readonly T[] = [],
 ): T {
   const array = getSortedSetValues(set);

package/src/functions/spawnCollectible.ts

@@ -20,10 +20,14 @@ import { getRandomSeed, isRNG } from "./rng";
  * Isaac's rotation mechanic. To handle that, use the `spawnCollectible` helper function instead
  * (which is provided by `ISCFeature.SPAWN_COLLECTIBLE`).
  *
+ * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @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
@@ -33,11 +37,15 @@ import { getRandomSeed, isRNG } from "./rng";
 export function spawnCollectibleUnsafe(
   collectibleType: CollectibleType,
   positionOrGridIndex: Vector | int,
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
   options = false,
   forceFreeItem = false,
   spawner?: Entity,
 ): EntityPickupCollectible {
+  if (seedOrRNG === undefined) {
+    seedOrRNG = getRandomSeed();
+  }
+
   const seed = isRNG(seedOrRNG) ? seedOrRNG.Next() : seedOrRNG;
   const collectible = spawnPickupWithSeed(
     PickupVariant.COLLECTIBLE,
@@ -82,13 +90,17 @@ export function spawnCollectibleUnsafe(
  * Onion because it is a quest collectible and quest collectibles will prevent Damocles from
  * duplicating the pedestal.)
  *
+ * If you want to spawn an unseeded collectible, you must explicitly pass `undefined` to the
+ * `seedOrRNG` parameter.
+ *
  * @param positionOrGridIndex The position or grid index to spawn the empty collectible at.
  * @param seedOrRNG The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
- *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ *                  `RNG.Next` method will be called. If `undefined` is provided, it will default to
+ *                  a random seed.
  */
 export function spawnEmptyCollectible(
   positionOrGridIndex: Vector | int,
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
 ): EntityPickup {
   const collectible = spawnCollectibleUnsafe(
     CollectibleType.BROKEN_SHOVEL_1,

package/src/functions/vector.ts

@@ -6,7 +6,7 @@ import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { angleToDirection } from "./direction";
 import { isIsaacAPIClassOfType, isaacAPIClassEquals } from "./isaacAPIClass";
 import { getRandomFloat } from "./random";
-import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isRNG, newRNG } from "./rng";
 import {
   copyUserdataValuesToTable,
   getNumbersFromTable,
@@ -109,11 +109,15 @@ export function getClosestVectorTo(
  *
  * Use this over the `RandomVector` function when you need the vector to be seeded.
  *
- * @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 vector, 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 getRandomVector(
-  seedOrRNG: Seed | RNG = getRandomSeed(),
+  seedOrRNG: Seed | RNG | undefined,
 ): Readonly<Vector> {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);