isaacscript-common 6.15.0 → 6.16.2

package/src/functions/mergeTests.ts

@@ -5,7 +5,7 @@ import { deepCopy } from "./deepCopy";
 import { log } from "./log";
 import { isRNG, newRNG } from "./rng";
 import { isSerializedIsaacAPIClass } from "./serialization";
-import { copyVector, isVector } from "./vector";
+import { isVector, serializeVector } from "./vector";
 
 /**
  * Run the suite of tests that prove that the "merge" function works properly. (This function is not
@@ -92,7 +92,7 @@ function oldTableHasSerializedIsaacAPIClass() {
   const y = 60;
   const vector = Vector(x, y);
 
-  const vectorSerialized = copyVector(vector, SerializationType.SERIALIZE);
+  const vectorSerialized = serializeVector(vector);
   if (!isSerializedIsaacAPIClass(vectorSerialized)) {
     error(
       'The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.',

package/src/functions/npcs.ts

@@ -11,13 +11,11 @@ import {
   MotherVariant,
   NpcState,
   PeepVariant,
-  ProjectilesMode,
   RaglingVariant,
   VisVariant,
 } from "isaac-typescript-definitions";
 import { EGGY_STATE_FRAME_OF_FINAL_SPIDER } from "../constants";
-import { getFilteredNewEntities } from "./entities";
-import { getNPCs, getProjectiles } from "./entitiesSpecific";
+import { getNPCs } from "./entitiesSpecific";
 
 /**
  * Used to filter out certain NPCs when determining of an NPC is "alive" and/or should keep the
@@ -46,33 +44,6 @@ const NON_ALIVE_NPCS_TYPE_VARIANT_SUBTYPE: ReadonlySet<string> = new Set([
   `${EntityType.MOTHER}.${MotherVariant.MOTHER_1}.${MotherSubType.PHASE_2}`, // 912
 ]);
 
-/**
- * Helper function to make an NPC fire a projectile. Returns the fired projectile. Use this function
- * instead of the `EntityNPC.FireProjectiles` method, since that returns void.
- *
- * @param npc The NPC to fire the projectile from.
- * @param position The staring position of the projectile.
- * @param velocity The starting velocity of the projectile.
- * @param projectilesMode The mode of the projectile. Optional. Default is
- *                        `ProjectilesMode.ONE_PROJECTILE`.
- * @param projectileParams The parameters of the projectile. Optional. Default is
- *                         `ProjectileParams()`.
- * @returns The fired projectile.
- */
-export function fireProjectiles(
-  npc: EntityNPC,
-  position: Vector,
-  velocity: Vector,
-  projectilesMode: ProjectilesMode = ProjectilesMode.ONE_PROJECTILE,
-  projectileParams: ProjectileParams = ProjectileParams(),
-): EntityProjectile[] {
-  const oldProjectiles = getProjectiles(projectileParams.Variant);
-  npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
-  const newProjectiles = getProjectiles(projectileParams.Variant);
-
-  return getFilteredNewEntities(oldProjectiles, newProjectiles);
-}
-
 /**
  * Helper function to get all of the non-dead NPCs in the room.
  *
@@ -149,31 +120,3 @@ export function isRaglingDeathPatch(npc: EntityNPC): boolean {
     npc.State === NpcState.SPECIAL
   );
 }
-
-/**
- * The base game `EntityNPC.FireProjectiles` method does not return anything, which is a problem in
- * situations where you need to work with the fired projectiles. This function runs that method, and
- * then returns the projectiles that were spawned.
- *
- * @param npc The EntityNPC firing projectiles.
- * @param position The starting position of the projectiles.
- * @param velocity The starting velocity of the projectiles.
- * @param projectilesMode A ProjectilesMode enum value defining how to fire the projectiles.
- * @param projectileParams A ProjectileParams object containing various parameters for the
- *                         projectiles.
- * @returns An array of EntityProjectiles containing all fired projectiles.
- */
-export function npcFireProjectiles(
-  npc: EntityNPC,
-  position: Vector,
-  velocity: Vector,
-  projectilesMode: ProjectilesMode,
-  projectileParams: ProjectileParams,
-): EntityProjectile[] {
-  const oldEntities = getProjectiles();
-  npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
-  const newEntities = getProjectiles();
-  const filteredNewEntities = getFilteredNewEntities(oldEntities, newEntities);
-
-  return filteredNewEntities;
-}

package/src/functions/projectiles.ts

@@ -0,0 +1,78 @@
+import {
+  EntityFlag,
+  EntityType,
+  ProjectilesMode,
+} from "isaac-typescript-definitions";
+import { getFilteredNewEntities } from "./entities";
+import { getProjectiles, spawnNPC } from "./entitiesSpecific";
+
+/**
+ * Helper function to make an NPC fire one or more projectiles. Returns the fired projectile(s).
+ *
+ * Use this function instead of the `EntityNPC.FireProjectiles` method if you need to modify or
+ * access the `EntityProjectile` objects after they are fired, since this function returns the
+ * objects in an array.
+ *
+ * @param npc The NPC to fire the projectile(s) from. You can also pass undefined if you do not want
+ *            the projectile(s) to come from anything in particular.
+ * @param position The staring position of the projectile(s).
+ * @param velocity The starting velocity of the projectile(s).
+ * @param projectilesMode Optional. The mode of the projectile(s). Default is
+ *                        `ProjectilesMode.ONE_PROJECTILE`.
+ * @param projectileParams Optional. The parameters of the projectile(s). Default is
+ *                         `ProjectileParams()`.
+ * @returns The fired projectile(s).
+ */
+export function fireProjectiles(
+  npc: EntityNPC | undefined,
+  position: Vector,
+  velocity: Vector,
+  projectilesMode: ProjectilesMode = ProjectilesMode.ONE_PROJECTILE,
+  projectileParams: ProjectileParams = ProjectileParams(),
+): EntityProjectile[] {
+  const oldProjectiles = getProjectiles(projectileParams.Variant);
+
+  let spawnedFly = false;
+  if (npc === undefined) {
+    // Since the `EntityNPC.FireProjectiles` method is not static, we arbitrarily spawn a fly.
+    spawnedFly = true;
+    npc = spawnNPC(EntityType.FLY, 0, 0, position);
+    npc.Visible = false;
+    npc.ClearEntityFlags(EntityFlag.APPEAR);
+  }
+
+  npc.FireProjectiles(position, velocity, projectilesMode, projectileParams);
+  const newProjectiles = getProjectiles(projectileParams.Variant);
+
+  if (spawnedFly) {
+    npc.Remove();
+  }
+
+  return getFilteredNewEntities(oldProjectiles, newProjectiles);
+}
+
+/**
+ * Helper function to spawn projectiles in a circle around a position. Under the hood, this
+ * leverages `ProjectileMode.N_PROJECTILES_IN_CIRCLE`.
+ *
+ * @param npc The NPC to fire the projectile(s) from. You can also pass undefined if you do not want
+ *            the projectile(s) to come from anything in particular.
+ * @param position The staring position of the projectile(s).
+ * @param speed The speed of the projectile(s).
+ * @param numProjectiles The amount of projectiles to spawn.
+ * @returns The fired projectile(s).
+ */
+export function fireProjectilesInCircle(
+  npc: EntityNPC | undefined,
+  position: Vector,
+  speed: float,
+  numProjectiles: int,
+): EntityProjectile[] {
+  const velocity = Vector(speed, numProjectiles);
+  return fireProjectiles(
+    npc,
+    position,
+    velocity,
+    ProjectilesMode.N_PROJECTILES_IN_CIRCLE,
+  );
+}

package/src/functions/rng.ts

@@ -1,20 +1,13 @@
 import { game } from "../cachedClasses";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
-import { SerializationType } from "../enums/SerializationType";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedRNG = LuaMap<string, unknown> & {
+export type SerializedRNG = LuaMap<string, unknown> & {
   readonly __serializedRNGBrand: symbol;
 };
 
-interface CopyRNGReturn {
-  [SerializationType.NONE]: RNG;
-  [SerializationType.SERIALIZE]: SerializedRNG;
-  [SerializationType.DESERIALIZE]: RNG;
-}
-
 /**
  * This is the ShiftIdx that Blade recommended after having reviewing the game's internal functions.
  * Any value between 0 and 80 should work equally well.
@@ -25,66 +18,35 @@ const RECOMMENDED_SHIFT_IDX = 35;
 const KEYS = ["seed"];
 const OBJECT_NAME = "RNG";
 
-/**
- * Helper function to copy an `RNG` object.
- *
- * @param rng The RNG object to copy. In the case of deserialization, this will actually be a Lua
- *            table instead of an instantiated RNG class.
- * @param serializationType Default is `SerializationType.NONE`.
- */
-export function copyRNG<
-  R extends RNG | SerializedRNG,
-  S extends SerializationType,
->(rng: R, serializationType: S): CopyRNGReturn[S];
-export function copyRNG<R extends RNG | SerializedRNG>(
-  rng: R,
-): CopyRNGReturn[SerializationType.NONE];
-export function copyRNG(
-  rng: RNG | SerializedRNG,
-  serializationType = SerializationType.NONE,
-): CopyRNGReturn[keyof CopyRNGReturn] {
-  switch (serializationType) {
-    case SerializationType.NONE: {
-      if (!isRNG(rng)) {
-        error(
-          `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      const seed = rng.GetSeed();
-      return newRNG(seed);
-    }
+/** Helper function to copy an `RNG` Isaac API class. */
+export function copyRNG(rng: RNG): RNG {
+  if (!isRNG(rng)) {
+    error(
+      `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
 
-    case SerializationType.SERIALIZE: {
-      if (!isRNG(rng)) {
-        error(
-          `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      const seed = rng.GetSeed();
-      const rngTable = new LuaMap<string, unknown>();
-      rngTable.set("seed", seed);
-      rngTable.set(SerializationBrand.RNG, "");
-      return rngTable as SerializedRNG;
-    }
+  const seed = rng.GetSeed();
+  return newRNG(seed);
+}
 
-    case SerializationType.DESERIALIZE: {
-      if (!isTable(rng)) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
-        );
-      }
-
-      const [seedNumber] = getNumbersFromTable(
-        rng as LuaMap<string, unknown>,
-        OBJECT_NAME,
-        ...KEYS,
-      );
-      const seed = seedNumber as Seed;
-      return newRNG(seed);
-    }
+/**
+ * Helper function to convert a `SerializedRNG` object to a normal `RNG` object. (This is used by
+ * the save data manager when reading data from the "save#.dat" file.)
+ */
+export function deserializeRNG(rng: SerializedRNG): RNG {
+  if (!isTable(rng)) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+    );
   }
+
+  const [seed] = getNumbersFromTable(
+    rng as LuaMap<string, unknown>,
+    OBJECT_NAME,
+    ...KEYS,
+  );
+  return newRNG(seed as Seed);
 }
 
 /**
@@ -130,6 +92,24 @@ export function rngEquals(rng1: RNG, rng2: RNG): boolean {
   return isaacAPIClassEquals(rng1, rng2, KEYS);
 }
 
+/**
+ * Helper function to convert a `RNG` object to a `SerializedRNG` object. (This is used by the save
+ * data manager when writing data from the "save#.dat" file.)
+ */
+export function serializeRNG(rng: RNG): SerializedRNG {
+  if (!isRNG(rng)) {
+    error(
+      `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const seed = rng.GetSeed();
+  const rngTable = new LuaMap<string, unknown>();
+  rngTable.set("seed", seed);
+  rngTable.set(SerializationBrand.RNG, "");
+  return rngTable as SerializedRNG;
+}
+
 /**
  * Helper function to iterate over the provided object and set the seed for all of the values that
  * are RNG objects equal to a particular seed.

package/src/functions/rockAlt.ts

@@ -13,6 +13,7 @@ import {
 import { game } from "../cachedClasses";
 import { DISTANCE_OF_GRID_TILE } from "../constants";
 import { RockAltType } from "../enums/RockAltType";
+import { BACKDROP_TYPE_TO_ROCK_ALT_TYPE } from "../objects/backdropTypeToRockAltType";
 import { spawnEffectWithSeed, spawnNPCWithSeed } from "./entitiesSpecific";
 import { isCollectibleInItemPool } from "./itemPool";
 import {
@@ -22,18 +23,58 @@ import {
   spawnPillWithSeed,
   spawnTrinketWithSeed,
 } from "./pickupsSpecific";
+import { fireProjectilesInCircle } from "./projectiles";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
 import { spawnCollectible } from "./spawnCollectible";
 import { repeat } from "./utils";
 import { getRandomVector } from "./vector";
 
+const ROCK_ALT_CHANCES = {
+  Nothing: 0.68,
+  BasicDrop: 0.0967,
+
+  /** Also used for e.g. black hearts from skulls. */
+  Trinket: 0.025,
+
+  Collectible: 0.005,
+} as const;
+
+const POLYP_PROJECTILE_SPEED = 10;
+const POLYP_NUM_PROJECTILES = 6;
+
+/**
+ * Helper function to get the alternate rock type (i.e. urn, mushroom, etc.) that the current room
+ * will have.
+ *
+ * The rock type is based on the backdrop of the room.
+ *
+ * For example, if you change the backdrop of the starting room of the run to `BackdropType.CAVES`,
+ * and then spawn `GridEntityType.ROCK_ALT`, it will be a mushroom instead of an urn. Additionally,
+ * if it is destroyed, it will generate mushroom-appropriate rewards.
+ *
+ * On the other hand, if an urn is spawned first before the backdrop is changed to
+ * `BackdropType.CAVES`, the graphic of the urn will not switch to a mushroom. However, when
+ * destroyed, the urn will still generate mushroom-appropriate rewards.
+ */
+export function getRockAltType(): RockAltType {
+  const room = game.GetRoom();
+  const backdropType = room.GetBackdropType();
+
+  return BACKDROP_TYPE_TO_ROCK_ALT_TYPE[backdropType];
+}
+
 /**
  * Helper function for emulating what happens when a vanilla `GridEntityType.ROCK_ALT` grid entity
  * breaks.
  *
- * Note that most of the time, this function will do nothing, similar to how most of the time, when
- * an individual urn is destroyed, nothing will spawn.
+ * Most of the time, this function will do nothing, similar to how most of the time, when an
+ * individual urn is destroyed, nothing will spawn.
+ *
+ * Note that in vanilla, trinkets will not spawn if they have already been removed from the trinket
+ * pool. This function cannot replicate that behavior because there is no way to check to see if a
+ * trinket is still in the pool. Thus, it will always have a chance to spawn the respective trinket
+ * (e.g. Swallowed Penny from urns).
  *
  * The logic in this function is based on the rewards listed on the wiki:
  * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
@@ -41,6 +82,10 @@ import { getRandomVector } from "./vector";
  * @param position The place 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 variant Optional. The variant of the grid entity to emulate. Default is 0, which
+ *                corresponds to a "normal" grid entity or an empty bucket. This only matters when
+ *                spawning the reward for buckets. (Empty buckets have different rewards than full
+ *                buckets.)
  * @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.
@@ -49,6 +94,7 @@ import { getRandomVector } from "./vector";
 export function spawnRockAltReward(
   position: Vector,
   rockAltType: RockAltType,
+  variant = 0,
   seedOrRNG: Seed | RNG = getRandomSeed(),
 ): boolean {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
@@ -71,7 +117,7 @@ export function spawnRockAltReward(
     }
 
     case RockAltType.BUCKET: {
-      return spawnRockAltRewardBucket(position, rng);
+      return spawnRockAltRewardBucket(position, rng, variant);
     }
   }
 }
@@ -80,14 +126,12 @@ function spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean {
   const chance = getRandom(rng);
   let totalChance = 0;
 
-  // Nothing (68.00%).
-  totalChance += 0.68;
+  totalChance += ROCK_ALT_CHANCES.Nothing;
   if (chance < totalChance) {
     return false;
   }
 
-  // One or two random coins (9.44%).
-  totalChance += 0.0944;
+  totalChance += ROCK_ALT_CHANCES.BasicDrop;
   if (chance < totalChance) {
     const numCoinsChance = getRandom(rng);
     const numCoins = numCoinsChance < 0.5 ? 1 : 2;
@@ -100,15 +144,13 @@ function spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean {
     return true;
   }
 
-  // Swallowed Penny (2.50%).
-  totalChance += 0.025;
+  totalChance += ROCK_ALT_CHANCES.Trinket;
   if (chance < totalChance) {
     spawnTrinketWithSeed(TrinketType.SWALLOWED_PENNY, position, rng);
     return true;
   }
 
-  // A Quarter (0.50%).
-  totalChance += 0.005;
+  totalChance += ROCK_ALT_CHANCES.Collectible;
   if (chance < totalChance) {
     const stillInPools = isCollectibleInItemPool(
       CollectibleType.QUARTER,
@@ -122,8 +164,7 @@ function spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean {
     return false;
   }
 
-  // One or two spiders (19.48%). (Since this is the final option, so we don't need to check the
-  // chance.)
+  // Since the detrimental effect is the final option, we don't need to check the chance.
   const numSpidersChance = getRandom(rng);
   const numSpiders = numSpidersChance < 0.5 ? 1 : 2;
   const length = DISTANCE_OF_GRID_TILE * 3;
@@ -143,28 +184,24 @@ function spawnRockAltRewardMushroom(position: Vector, rng: RNG): boolean {
   const chance = getRandom(rng);
   let totalChance = 0;
 
-  // Nothing (68.00%).
-  totalChance += 0.68;
+  totalChance += ROCK_ALT_CHANCES.Nothing;
   if (chance < totalChance) {
     return false;
   }
 
-  // One pill (9.82%).
-  totalChance += 0.0982;
+  totalChance += ROCK_ALT_CHANCES.BasicDrop;
   if (chance < totalChance) {
     spawnPillWithSeed(PillColor.NULL, position, rng);
     return true;
   }
 
-  // Liberty Cap (2.50%).
-  totalChance += 0.025;
+  totalChance += ROCK_ALT_CHANCES.Trinket;
   if (chance < totalChance) {
     spawnTrinketWithSeed(TrinketType.LIBERTY_CAP, position, rng);
     return true;
   }
 
-  // Collectible (0.50%).
-  totalChance += 0.005;
+  totalChance += ROCK_ALT_CHANCES.Collectible;
   if (chance < totalChance) {
     if (roomType === RoomType.SECRET) {
       const wavyCapChance = getRandom(rng);
@@ -211,8 +248,7 @@ function spawnRockAltRewardMushroom(position: Vector, rng: RNG): boolean {
     return false;
   }
 
-  // One poisonous gas effect (19.24%). (Since this is the final option, so we don't need to check
-  // the chance.)
+  // Since the detrimental effect is the final option, we don't need to check the chance.
   spawnEffectWithSeed(EffectVariant.FART, 0, position, rng);
   return true;
 }
@@ -221,28 +257,24 @@ function spawnRockAltRewardSkull(position: Vector, rng: RNG): boolean {
   const chance = getRandom(rng);
   let totalChance = 0;
 
-  // Nothing (68.00%).
-  totalChance += 0.68;
+  totalChance += ROCK_ALT_CHANCES.Nothing;
   if (chance < totalChance) {
     return false;
   }
 
-  // One card / rune (9.52%).
-  totalChance += 0.095;
+  totalChance += ROCK_ALT_CHANCES.BasicDrop;
   if (chance < totalChance) {
     spawnCardWithSeed(Card.NULL, position, rng);
     return true;
   }
 
-  // Black heart (2.50%).
-  totalChance += 0.025;
+  totalChance += ROCK_ALT_CHANCES.Trinket;
   if (chance < totalChance) {
     spawnHeartWithSeed(HeartSubType.BLACK, position, rng);
     return true;
   }
 
-  // Collectible (0.50%).
-  totalChance += 0.005;
+  totalChance += ROCK_ALT_CHANCES.Collectible;
   if (chance < totalChance) {
     const ghostBabyStillInPools = isCollectibleInItemPool(
       CollectibleType.GHOST_BABY,
@@ -275,31 +307,86 @@ function spawnRockAltRewardSkull(position: Vector, rng: RNG): boolean {
     return false;
   }
 
-  // One Host (19.30%). (Since this is the final option, so we don't need to check the chance.)
+  // Since the detrimental effect is the final option, we don't need to check the chance.
   spawnNPCWithSeed(EntityType.HOST, 0, 0, position, rng);
   return true;
 }
 
-function spawnRockAltRewardPolyp(_position: Vector, rng: RNG): boolean {
+function spawnRockAltRewardPolyp(position: Vector, rng: RNG): boolean {
   const chance = getRandom(rng);
   let totalChance = 0;
 
-  // Nothing (68.00%).
-  totalChance += 0.68;
+  totalChance += ROCK_ALT_CHANCES.Nothing;
   if (chance < totalChance) {
     return false;
   }
 
-  // TODO
-  return false;
+  totalChance += ROCK_ALT_CHANCES.BasicDrop;
+  if (chance < totalChance) {
+    spawnHeartWithSeed(HeartSubType.NULL, position, rng);
+    return true;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.Trinket;
+  if (chance < totalChance) {
+    spawnTrinketWithSeed(TrinketType.UMBILICAL_CORD, position, rng);
+    return true;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.Collectible;
+  if (chance < totalChance) {
+    const placentaStillInPools = isCollectibleInItemPool(
+      CollectibleType.PLACENTA,
+      ItemPoolType.BOSS,
+    );
+    const bloodClotStillInPools = isCollectibleInItemPool(
+      CollectibleType.BLOOD_CLOT,
+      ItemPoolType.BOSS,
+    );
+    if (bloodClotStillInPools && placentaStillInPools) {
+      const collectibleChance = getRandom(rng);
+      const collectibleType =
+        collectibleChance < 0.5
+          ? CollectibleType.PLACENTA // 218
+          : CollectibleType.BLOOD_CLOT; // 254
+      spawnCollectible(collectibleType, position, rng);
+      return true;
+    }
+
+    if (bloodClotStillInPools) {
+      spawnCollectible(CollectibleType.MINI_MUSH, position, rng);
+      return true;
+    }
+
+    if (placentaStillInPools) {
+      spawnCollectible(CollectibleType.MAGIC_MUSHROOM, position, rng);
+      return true;
+    }
+
+    return false;
+  }
+
+  // Since the detrimental effect is the final option, we don't need to check the chance.
+  spawnEffectWithSeed(EffectVariant.CREEP_RED, 0, position, rng);
+  fireProjectilesInCircle(
+    undefined,
+    position,
+    POLYP_PROJECTILE_SPEED,
+    POLYP_NUM_PROJECTILES,
+  );
+
+  return true;
 }
 
-function spawnRockAltRewardBucket(_position: Vector, rng: RNG): boolean {
+function spawnRockAltRewardBucket(
+  _position: Vector,
+  rng: RNG,
+  _variant: int,
+): boolean {
   const chance = getRandom(rng);
   let totalChance = 0;
 
-  // Nothing (68.00%).
-  totalChance += 0.68;
+  totalChance += ROCK_ALT_CHANCES.Nothing;
   if (chance < totalChance) {
     return false;
   }

package/src/functions/saveFile.ts

@@ -1,4 +1,5 @@
 import { CollectibleType, ItemPoolType } from "isaac-typescript-definitions";
+import { isCollectibleInItemPool } from "./itemPool";
 import { anyPlayerHasCollectible } from "./players";
 
 /**
@@ -23,5 +24,5 @@ export function isCollectibleUnlocked(
     return true;
   }
 
-  return isCollectibleUnlocked(collectibleType, itemPoolType);
+  return isCollectibleInItemPool(collectibleType, itemPoolType);
 }