isaacscript-common 6.13.0 → 6.16.0

package/src/functions/color.ts

@@ -1,19 +1,14 @@
 import { SerializationBrand } from "../enums/private/SerializationBrand";
-import { SerializationType } from "../enums/SerializationType";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
+import { getRandom } from "./random";
+import { getRandomSeed, isRNG, newRNG } from "./rng";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedColor = LuaMap<string, unknown> & {
+export type SerializedColor = LuaMap<string, unknown> & {
   readonly __serializedColorBrand: symbol;
 };
 
-interface CopyColorReturn {
-  [SerializationType.NONE]: Color;
-  [SerializationType.SERIALIZE]: SerializedColor;
-  [SerializationType.DESERIALIZE]: Color;
-}
-
 const KEYS = ["R", "G", "B", "A", "RO", "GO", "BO"];
 const OBJECT_NAME = "Color";
 
@@ -21,88 +16,79 @@ export function colorEquals(color1: Color, color2: Color): boolean {
   return isaacAPIClassEquals(color1, color2, KEYS);
 }
 
+/** Helper function to copy a `Color` Isaac API class. */
+export function copyColor(color: Color): Color {
+  if (!isColor(color)) {
+    error(
+      `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  return Color(
+    color.R,
+    color.G,
+    color.B,
+    color.A,
+    color.RO,
+    color.GO,
+    color.BO,
+  );
+}
+
 /**
- * Helper function to copy a `Color` object.
- *
- * @param color The Color object to copy. In the case of deserialization, this will actually be a
- *              Lua table instead of an instantiated Color class.
- * @param serializationType Default is `SerializationType.NONE`.
+ * Helper function to convert a `SerializedColor` object to a normal `Color` object. (This is used
+ * by the save data manager when reading data from the "save#.dat" file.)
  */
-export function copyColor<
-  C extends Color | SerializedColor,
-  S extends SerializationType,
->(color: C, serializationType: S): CopyColorReturn[S];
-export function copyColor<C extends Color | SerializedColor>(
-  color: C,
-): CopyColorReturn[SerializationType.NONE];
-export function copyColor(
-  color: Color | SerializedColor,
-  serializationType = SerializationType.NONE,
-): CopyColorReturn[keyof CopyColorReturn] {
-  switch (serializationType) {
-    case SerializationType.NONE: {
-      if (!isColor(color)) {
-        error(
-          `Failed to copy a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      return Color(
-        color.R,
-        color.G,
-        color.B,
-        color.A,
-        color.RO,
-        color.GO,
-        color.BO,
-      );
-    }
-
-    case SerializationType.SERIALIZE: {
-      if (!isColor(color)) {
-        error(
-          `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
-        );
-      }
-
-      const colorTable = new LuaMap<string, unknown>();
-      copyValuesToTable(color, KEYS, colorTable);
-      colorTable.set(SerializationBrand.COLOR, "");
-      return colorTable as SerializedColor;
-    }
-
-    case SerializationType.DESERIALIZE: {
-      if (!isTable(color)) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
-        );
-      }
-
-      const [r, g, b, a, ro, go, bo] = getNumbersFromTable(
-        color as LuaMap<string, unknown>,
-        OBJECT_NAME,
-        ...KEYS,
-      );
-
-      if (r === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: r`,
-        );
-      }
-      if (g === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: g`,
-        );
-      }
-      if (b === undefined) {
-        error(
-          `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: b`,
-        );
-      }
-
-      return Color(r, g, b, a, ro, go, bo);
-    }
+export function deserializeColor(color: SerializedColor): Color {
+  if (!isTable(color)) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object was not a Lua table.`,
+    );
   }
+
+  const [r, g, b, a, ro, go, bo] = getNumbersFromTable(
+    color as LuaMap<string, unknown>,
+    OBJECT_NAME,
+    ...KEYS,
+  );
+
+  if (r === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: R`,
+    );
+  }
+  if (g === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: G`,
+    );
+  }
+  if (b === undefined) {
+    error(
+      `Failed to deserialize a ${OBJECT_NAME} object since the provided object did not have a value for: B`,
+    );
+  }
+
+  return Color(r, g, b, a, ro, go, bo);
+}
+
+/**
+ * Helper function to get a random color.
+ *
+ * @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 alpha Optional. The alpha value to use. Default is 1.
+ */
+export function getRandomColor(
+  seedOrRNG: Seed | RNG = getRandomSeed(),
+  alpha = 1,
+): Color {
+  const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
+
+  const r = getRandom(rng);
+  const g = getRandom(rng);
+  const b = getRandom(rng);
+
+  return Color(r, g, b, alpha);
 }
 
 /** Helper function to check if something is an instantiated Color object. */
@@ -121,3 +107,19 @@ export function isSerializedColor(object: unknown): object is SerializedColor {
 
   return tableHasKeys(object, ...KEYS) && object.has(SerializationBrand.COLOR);
 }
+/**
+ * Helper function to convert a `Color` object to a `SerializedColor` object. (This is used by the
+ * save data manager when writing data from the "save#.dat" file.)
+ */
+export function serializeColor(color: Color): SerializedColor {
+  if (!isColor(color)) {
+    error(
+      `Failed to serialize a ${OBJECT_NAME} object since the provided object was not a userdata ${OBJECT_NAME} class.`,
+    );
+  }
+
+  const colorTable = new LuaMap<string, unknown>();
+  copyValuesToTable(color, KEYS, colorTable);
+  colorTable.set(SerializationBrand.COLOR, "");
+  return colorTable as SerializedColor;
+}

package/src/functions/deepCopy.ts

@@ -4,7 +4,7 @@ import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
 import { SAVE_DATA_MANAGER_DEBUG } from "../features/saveDataManager/saveDataManagerConstants";
 import { isSerializationBrand } from "../features/saveDataManager/serializationBrands";
-import { TSTLClass } from "../types/private/TSTLClass";
+import { TSTLClass } from "../types/TSTLClass";
 import { isArray } from "./array";
 import { getEnumValues } from "./enums";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
@@ -13,6 +13,7 @@ import {
   copyIsaacAPIClass,
   deserializeIsaacAPIClass,
   isSerializedIsaacAPIClass,
+  serializeIsaacAPIClass,
 } from "./serialization";
 import {
   getTSTLClassName,
@@ -664,5 +665,17 @@ function deepCopyUserdata(
     );
   }
 
-  return copyIsaacAPIClass(value, serializationType);
+  switch (serializationType) {
+    case SerializationType.NONE: {
+      return copyIsaacAPIClass(value);
+    }
+
+    case SerializationType.SERIALIZE: {
+      return serializeIsaacAPIClass(value);
+    }
+
+    case SerializationType.DESERIALIZE: {
+      return deserializeIsaacAPIClass(value);
+    }
+  }
 }

package/src/functions/gridEntities.ts

@@ -9,17 +9,14 @@ import {
 } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { DISTANCE_OF_GRID_TILE } from "../constants";
-import { RockAltType } from "../enums/RockAltType";
 import { GRID_ENTITY_TYPE_TO_BROKEN_STATE_MAP } from "../maps/gridEntityTypeToBrokenStateMap";
 import { GRID_ENTITY_XML_MAP } from "../maps/gridEntityXMLMap";
 import {
   DEFAULT_TOP_LEFT_WALL_GRID_INDEX,
   ROOM_SHAPE_TO_TOP_LEFT_WALL_GRID_INDEX_MAP,
 } from "../maps/roomShapeToTopLeftWallGridIndexMap";
-import { BACKDROP_TYPE_TO_ROCK_ALT_TYPE } from "../objects/backdropTypeToRockAltType";
 import { AnyGridEntity } from "../types/AnyGridEntity";
 import { isCircleIntersectingRectangle } from "./math";
-import { getRandomSeed } from "./rng";
 import { roomUpdateSafe } from "./rooms";
 import { clearSprite } from "./sprites";
 import { isNumber } from "./types";
@@ -277,27 +274,6 @@ export function getMatchingGridEntities(
   );
 }
 
-/**
- * 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];
-}
-
 export function getSurroundingGridEntities(
   gridEntity: GridEntity,
 ): GridEntity[] {
@@ -488,7 +464,7 @@ export function removeAllMatchingGridEntities(
  *                   generally a good idea because if the room is not updated, you will be unable to
  *                   spawn another grid entity on the same tile until a frame has passed. However,
  *                   doing this is expensive, since it involves a call to `Isaac.GetRoomEntities`,
- *                   so set this to false if you need to invoke this function multiple times.
+ *                   so set this to false if you need to run this function multiple times.
  * @param cap Optional. If specified, will only remove the given amount of entities.
  * @returns An array of the entities that were removed.
  */
@@ -527,7 +503,7 @@ export function removeGridEntities<T extends AnyGridEntity>(
  *                   generally a good idea because if the room is not updated, you will be unable to
  *                   spawn another grid entity on the same tile until a frame has passed. However,
  *                   doing this is expensive, since it involves a call to `Isaac.GetRoomEntities`,
- *                   so set this to false if you need to invoke this function multiple times.
+ *                   so set this to false if you need to run this function multiple times.
  */
 export function removeGridEntity(
   gridEntityOrGridIndex: GridEntity | int,
@@ -654,57 +630,6 @@ export function spawnGridEntityWithVariant(
   return gridEntity;
 }
 
-/**
- * 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.
- *
- * The logic in this function is based on the rewards listed on the wiki:
- * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
- *
- * @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.
- * @returns Whether or not this function spawned something.
- */
-export function spawnRockAltReward(
-  rockAltType: RockAltType,
-  _seedOrRNG: Seed | RNG = getRandomSeed(),
-): boolean {
-  /// const chance = getRandom(seedOrRNG);
-
-  switch (rockAltType) {
-    case RockAltType.URN: {
-      // TODO
-      return false;
-    }
-
-    case RockAltType.MUSHROOM: {
-      // TODO
-      return false;
-    }
-
-    case RockAltType.SKULL: {
-      // TODO
-      return false;
-    }
-
-    case RockAltType.POLYP: {
-      // TODO
-      return false;
-    }
-
-    case RockAltType.BUCKET: {
-      // TODO
-      return false;
-    }
-  }
-}
-
 /**
  * Helper function to spawn a Void Portal. This is more complicated than simply spawning a trapdoor
  * with the appropriate variant, as the game does not give it the correct sprite automatically.

package/src/functions/isaacAPIClass.ts

@@ -1,4 +1,4 @@
-import { IsaacAPIClass } from "../types/private/IsaacAPIClass";
+import { IsaacAPIClass } from "../types/IsaacAPIClass";
 import { trimPrefix } from "./string";
 import { isString, isUserdata } from "./types";
 

package/src/functions/itemPool.ts

@@ -0,0 +1,153 @@
+import {
+  CollectibleType,
+  ItemConfigTag,
+  ItemPoolType,
+  PlayerType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { PlayerIndex } from "../types/PlayerIndex";
+import { getCollectibleSet } from "./collectibleSet";
+import { collectibleHasTag } from "./collectibleTag";
+import { mapGetPlayer, mapSetPlayer } from "./playerDataStructures";
+import { getPlayers } from "./playerIndex";
+import { getPlayersOfType } from "./players";
+import { repeat } from "./utils";
+
+const COLLECTIBLES_THAT_AFFECT_ITEM_POOLS: readonly CollectibleType[] = [
+  CollectibleType.CHAOS, // 402
+  CollectibleType.SACRED_ORB, // 691
+  CollectibleType.TMTRAINER, // 721
+];
+
+const TRINKETS_THAT_AFFECT_ITEM_POOLS: readonly TrinketType[] = [
+  TrinketType.NO,
+];
+
+/**
+ * Helper function to see if the given collectible is still present in the given item pool.
+ *
+ * If the collectible is non-offensive, any Tainted Losts will be temporarily changed to Isaac and
+ * then changed back. (This is because Tainted Lost is not able to retrieve non-offensive
+ * collectibles from item pools).
+ */
+export function isCollectibleInItemPool(
+  collectibleType: CollectibleType,
+  itemPoolType: ItemPoolType,
+): boolean {
+  // On Tainted Lost, it is impossible to retrieve non-offensive collectibles from pools, so we
+  // temporarily change the character to Isaac.
+  const taintedLosts = getPlayersOfType(PlayerType.THE_LOST_B);
+  const isOffensive = collectibleHasTag(
+    collectibleType,
+    ItemConfigTag.OFFENSIVE,
+  );
+  let changedPlayerTypes = false;
+  if (!isOffensive) {
+    changedPlayerTypes = true;
+    for (const player of taintedLosts) {
+      player.ChangePlayerType(PlayerType.ISAAC);
+    }
+  }
+
+  const [removedItemsMap, removedTrinketsMap] =
+    removeItemsAndTrinketsThatAffectItemPools();
+
+  // Blacklist every collectible in the game except for the provided collectible.
+  const itemPool = game.GetItemPool();
+  const collectibleSet = getCollectibleSet();
+  for (const collectibleTypeInSet of collectibleSet.values()) {
+    if (collectibleTypeInSet !== collectibleType) {
+      itemPool.AddRoomBlacklist(collectibleTypeInSet);
+    }
+  }
+
+  // Get a collectible from the pool and see if it is the intended collectible. (We can use any
+  // arbitrary value as the seed since it should not influence the result.)
+  const retrievedCollectibleType = itemPool.GetCollectible(
+    itemPoolType,
+    false,
+    1 as Seed,
+  );
+
+  const collectibleUnlocked = retrievedCollectibleType === collectibleType;
+
+  // Reset the blacklist
+  itemPool.ResetRoomBlacklist();
+
+  restoreItemsAndTrinketsThatAffectItemPools(
+    removedItemsMap,
+    removedTrinketsMap,
+  );
+
+  // Change any players back to Tainted Lost, if necessary.
+  if (changedPlayerTypes) {
+    for (const player of taintedLosts) {
+      player.ChangePlayerType(PlayerType.THE_LOST_B);
+    }
+  }
+
+  return collectibleUnlocked;
+}
+
+/**
+ * Before checking the item pools, remove any collectibles or trinkets that would affect the
+ * retrieved collectible types.
+ */
+function removeItemsAndTrinketsThatAffectItemPools(): [
+  removedItemsMap: Map<PlayerIndex, CollectibleType[]>,
+  removedTrinketsMap: Map<PlayerIndex, TrinketType[]>,
+] {
+  const removedItemsMap = new Map<PlayerIndex, CollectibleType[]>();
+  const removedTrinketsMap = new Map<PlayerIndex, TrinketType[]>();
+  for (const player of getPlayers()) {
+    const removedItems: CollectibleType[] = [];
+    for (const itemToRemove of COLLECTIBLES_THAT_AFFECT_ITEM_POOLS) {
+      if (player.HasCollectible(itemToRemove)) {
+        const numCollectibles = player.GetCollectibleNum(itemToRemove);
+        repeat(numCollectibles, () => {
+          player.RemoveCollectible(itemToRemove);
+          removedItems.push(itemToRemove);
+        });
+      }
+    }
+
+    mapSetPlayer(removedItemsMap, player, removedItems);
+
+    const removedTrinkets: TrinketType[] = [];
+    for (const trinketToRemove of TRINKETS_THAT_AFFECT_ITEM_POOLS) {
+      if (player.HasTrinket(trinketToRemove)) {
+        const numTrinkets = player.GetTrinketMultiplier(trinketToRemove);
+        repeat(numTrinkets, () => {
+          player.TryRemoveTrinket(trinketToRemove);
+          removedTrinkets.push(trinketToRemove);
+        });
+      }
+    }
+
+    mapSetPlayer(removedTrinketsMap, player, removedTrinkets);
+  }
+
+  return [removedItemsMap, removedTrinketsMap];
+}
+
+function restoreItemsAndTrinketsThatAffectItemPools(
+  removedItemsMap: Map<PlayerIndex, CollectibleType[]>,
+  removedTrinketsMap: Map<PlayerIndex, TrinketType[]>,
+) {
+  for (const player of getPlayers()) {
+    const removedItems = mapGetPlayer(removedItemsMap, player);
+    if (removedItems !== undefined) {
+      for (const collectibleType of removedItems) {
+        player.AddCollectible(collectibleType, 0, false); // Prevent Chaos from spawning pickups
+      }
+    }
+
+    const removedTrinkets = mapGetPlayer(removedTrinketsMap, player);
+    if (removedTrinkets !== undefined) {
+      for (const trinketType of removedTrinkets) {
+        player.AddTrinket(trinketType, false);
+      }
+    }
+  }
+}