isaacscript-common 6.14.0 → 6.15.0

package/src/functions/rockAlt.ts

@@ -1,11 +1,27 @@
 import {
+  Card,
   CoinSubType,
   CollectibleType,
+  EffectVariant,
+  EntityType,
+  HeartSubType,
+  ItemPoolType,
+  PillColor,
+  RoomType,
   TrinketType,
 } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
 import { DISTANCE_OF_GRID_TILE } from "../constants";
 import { RockAltType } from "../enums/RockAltType";
-import { spawnCoinWithSeed, spawnTrinketWithSeed } from "./pickupsSpecific";
+import { spawnEffectWithSeed, spawnNPCWithSeed } from "./entitiesSpecific";
+import { isCollectibleInItemPool } from "./itemPool";
+import {
+  spawnCardWithSeed,
+  spawnCoinWithSeed,
+  spawnHeartWithSeed,
+  spawnPillWithSeed,
+  spawnTrinketWithSeed,
+} from "./pickupsSpecific";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
 import { spawnCollectible } from "./spawnCollectible";
@@ -19,10 +35,6 @@ import { getRandomVector } from "./vector";
  * 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.
  *
- * For the purposes of spawning collectibles, this function assumes that the player has not seen the
- * collectible yet in the current run. In vanilla, it is only possible to get a e.g. Quarter if the
- * collectible still exists in the Treasure Room pool.
- *
  * The logic in this function is based on the rewards listed on the wiki:
  * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
  *
@@ -40,78 +52,258 @@ export function spawnRockAltReward(
   seedOrRNG: Seed | RNG = getRandomSeed(),
 ): boolean {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
-  const chance = getRandom(rng);
 
   switch (rockAltType) {
     case RockAltType.URN: {
-      let totalChance = 0;
+      return spawnRockAltRewardUrn(position, rng);
+    }
 
-      // Nothing. (68.00%)
-      totalChance += 0.68;
-      if (chance < totalChance) {
-        return false;
-      }
+    case RockAltType.MUSHROOM: {
+      return spawnRockAltRewardMushroom(position, rng);
+    }
 
-      // One or two random coins. (9.44%)
-      totalChance += 0.0944;
-      if (chance < totalChance) {
-        const numCoinsChance = getRandom(rng);
-        const numCoins = numCoinsChance < 0.5 ? 1 : 2;
-        repeat(numCoins, () => {
-          const velocity = getRandomVector(rng);
-          spawnCoinWithSeed(CoinSubType.NULL, position, rng, velocity);
-        });
-        return true;
-      }
+    case RockAltType.SKULL: {
+      return spawnRockAltRewardSkull(position, rng);
+    }
 
-      // Swallowed Penny. (2.50%)
-      totalChance += 0.025;
-      if (chance < totalChance) {
-        spawnTrinketWithSeed(TrinketType.SWALLOWED_PENNY, position, rng);
-      }
+    case RockAltType.POLYP: {
+      return spawnRockAltRewardPolyp(position, rng);
+    }
 
-      // A Quarter. (0.50%)
-      totalChance += 0.005;
-      if (chance < totalChance) {
-        spawnCollectible(CollectibleType.QUARTER, position, rng);
-      }
+    case RockAltType.BUCKET: {
+      return spawnRockAltRewardBucket(position, rng);
+    }
+  }
+}
+
+function spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean {
+  const chance = getRandom(rng);
+  let totalChance = 0;
+
+  // Nothing (68.00%).
+  totalChance += 0.68;
+  if (chance < totalChance) {
+    return false;
+  }
+
+  // One or two random coins (9.44%).
+  totalChance += 0.0944;
+  if (chance < totalChance) {
+    const numCoinsChance = getRandom(rng);
+    const numCoins = numCoinsChance < 0.5 ? 1 : 2;
+    const length = DISTANCE_OF_GRID_TILE;
+    repeat(numCoins, () => {
+      const randomVector = getRandomVector(rng);
+      const velocity = randomVector.mul(length);
+      spawnCoinWithSeed(CoinSubType.NULL, position, rng, velocity);
+    });
+    return true;
+  }
+
+  // Swallowed Penny (2.50%).
+  totalChance += 0.025;
+  if (chance < totalChance) {
+    spawnTrinketWithSeed(TrinketType.SWALLOWED_PENNY, position, rng);
+    return true;
+  }
+
+  // A Quarter (0.50%).
+  totalChance += 0.005;
+  if (chance < totalChance) {
+    const stillInPools = isCollectibleInItemPool(
+      CollectibleType.QUARTER,
+      ItemPoolType.DEVIL,
+    );
+    if (stillInPools) {
+      spawnCollectible(CollectibleType.QUARTER, position, rng);
+      return true;
+    }
+
+    return false;
+  }
+
+  // One or two spiders (19.48%). (Since this is the final option, so 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;
+  repeat(numSpiders, () => {
+    const randomVector = getRandomVector(rng);
+    const offset = randomVector.mul(length);
+    const targetPos = position.add(offset);
+    EntityNPC.ThrowSpider(position, undefined, targetPos, false, 0);
+  });
+  return true;
+}
+
+function spawnRockAltRewardMushroom(position: Vector, rng: RNG): boolean {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+
+  const chance = getRandom(rng);
+  let totalChance = 0;
+
+  // Nothing (68.00%).
+  totalChance += 0.68;
+  if (chance < totalChance) {
+    return false;
+  }
 
-      // One or two spiders. (19.48%)
-      totalChance += 0.1948;
-      if (chance < totalChance) {
-        const numSpidersChance = getRandom(rng);
-        const numSpiders = numSpidersChance < 0.5 ? 1 : 2;
-        repeat(numSpiders, () => {
-          const randomVector = getRandomVector(rng);
-          const length = DISTANCE_OF_GRID_TILE * 3;
-          const offset = randomVector.mul(length);
-          const targetPos = position.add(offset);
-          EntityNPC.ThrowSpider(position, undefined, targetPos, false, 0);
-        });
+  // One pill (9.82%).
+  totalChance += 0.0982;
+  if (chance < totalChance) {
+    spawnPillWithSeed(PillColor.NULL, position, rng);
+    return true;
+  }
+
+  // Liberty Cap (2.50%).
+  totalChance += 0.025;
+  if (chance < totalChance) {
+    spawnTrinketWithSeed(TrinketType.LIBERTY_CAP, position, rng);
+    return true;
+  }
+
+  // Collectible (0.50%).
+  totalChance += 0.005;
+  if (chance < totalChance) {
+    if (roomType === RoomType.SECRET) {
+      const wavyCapChance = getRandom(rng);
+      if (wavyCapChance < 0.0272) {
+        const stillInPools = isCollectibleInItemPool(
+          CollectibleType.WAVY_CAP,
+          ItemPoolType.SECRET,
+        );
+        if (stillInPools) {
+          spawnCollectible(CollectibleType.WAVY_CAP, position, rng);
+          return true;
+        }
       }
+    }
 
-      // TODO
-      return false;
+    const magicMushroomStillInPools = isCollectibleInItemPool(
+      CollectibleType.MAGIC_MUSHROOM,
+      ItemPoolType.TREASURE,
+    );
+    const miniMushStillInPools = isCollectibleInItemPool(
+      CollectibleType.MINI_MUSH,
+      ItemPoolType.TREASURE,
+    );
+    if (magicMushroomStillInPools && miniMushStillInPools) {
+      const collectibleChance = getRandom(rng);
+      const collectibleType =
+        collectibleChance < 0.5
+          ? CollectibleType.MAGIC_MUSHROOM // 12
+          : CollectibleType.MINI_MUSH; // 71
+      spawnCollectible(collectibleType, position, rng);
+      return true;
     }
 
-    case RockAltType.MUSHROOM: {
-      // TODO
-      return false;
+    if (magicMushroomStillInPools) {
+      spawnCollectible(CollectibleType.MINI_MUSH, position, rng);
+      return true;
     }
 
-    case RockAltType.SKULL: {
-      // TODO
-      return false;
+    if (miniMushStillInPools) {
+      spawnCollectible(CollectibleType.MAGIC_MUSHROOM, position, rng);
+      return true;
     }
 
-    case RockAltType.POLYP: {
-      // TODO
-      return false;
+    return false;
+  }
+
+  // One poisonous gas effect (19.24%). (Since this is the final option, so we don't need to check
+  // the chance.)
+  spawnEffectWithSeed(EffectVariant.FART, 0, position, rng);
+  return true;
+}
+
+function spawnRockAltRewardSkull(position: Vector, rng: RNG): boolean {
+  const chance = getRandom(rng);
+  let totalChance = 0;
+
+  // Nothing (68.00%).
+  totalChance += 0.68;
+  if (chance < totalChance) {
+    return false;
+  }
+
+  // One card / rune (9.52%).
+  totalChance += 0.095;
+  if (chance < totalChance) {
+    spawnCardWithSeed(Card.NULL, position, rng);
+    return true;
+  }
+
+  // Black heart (2.50%).
+  totalChance += 0.025;
+  if (chance < totalChance) {
+    spawnHeartWithSeed(HeartSubType.BLACK, position, rng);
+    return true;
+  }
+
+  // Collectible (0.50%).
+  totalChance += 0.005;
+  if (chance < totalChance) {
+    const ghostBabyStillInPools = isCollectibleInItemPool(
+      CollectibleType.GHOST_BABY,
+      ItemPoolType.TREASURE,
+    );
+    const dryBabyStillInPools = isCollectibleInItemPool(
+      CollectibleType.DRY_BABY,
+      ItemPoolType.TREASURE,
+    );
+    if (ghostBabyStillInPools && dryBabyStillInPools) {
+      const collectibleChance = getRandom(rng);
+      const collectibleType =
+        collectibleChance < 0.5
+          ? CollectibleType.GHOST_BABY // 163
+          : CollectibleType.DRY_BABY; // 265
+      spawnCollectible(collectibleType, position, rng);
+      return true;
     }
 
-    case RockAltType.BUCKET: {
-      // TODO
-      return false;
+    if (ghostBabyStillInPools) {
+      spawnCollectible(CollectibleType.DRY_BABY, position, rng);
+      return true;
     }
+
+    if (dryBabyStillInPools) {
+      spawnCollectible(CollectibleType.GHOST_BABY, position, rng);
+      return true;
+    }
+
+    return false;
+  }
+
+  // One Host (19.30%). (Since this is the final option, so we don't need to check the chance.)
+  spawnNPCWithSeed(EntityType.HOST, 0, 0, position, rng);
+  return true;
+}
+
+function spawnRockAltRewardPolyp(_position: Vector, rng: RNG): boolean {
+  const chance = getRandom(rng);
+  let totalChance = 0;
+
+  // Nothing (68.00%).
+  totalChance += 0.68;
+  if (chance < totalChance) {
+    return false;
   }
+
+  // TODO
+  return false;
+}
+
+function spawnRockAltRewardBucket(_position: Vector, rng: RNG): boolean {
+  const chance = getRandom(rng);
+  let totalChance = 0;
+
+  // Nothing (68.00%).
+  totalChance += 0.68;
+  if (chance < totalChance) {
+    return false;
+  }
+
+  // TODO
+  return false;
 }

package/src/functions/saveFile.ts

@@ -1,133 +1,27 @@
-import {
-  CollectibleType,
-  ItemPoolType,
-  PlayerType,
-  TrinketType,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { PlayerIndex } from "../types/PlayerIndex";
-import { getCollectibleSet } from "./collectibleSet";
-import { mapGetPlayer, mapSetPlayer } from "./playerDataStructures";
-import { getPlayers } from "./playerIndex";
-import { anyPlayerHasCollectible, 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,
-];
+import { CollectibleType, ItemPoolType } from "isaac-typescript-definitions";
+import { anyPlayerHasCollectible } from "./players";
 
 /**
- * Helper function to see if the given collectible is unlocked on the player's save file. This
+ * Helper function to see if the given collectible is unlocked on the current save file. This
  * requires providing the corresponding item pool that the collectible is located in.
  *
- * - If any player currently has the item, then it is assumed to be unlocked. (This is because Eden
- *   may have randomly started with the provided collectible, and it will be subsequently removed
- *   from all pools.)
+ * - If any player currently has the collectible, then it is assumed to be unlocked. (This is
+ *   because in almost all cases, when a collectible is added to a player's inventory, it is
+ *   subsequently removed from all pools.)
  * - If the collectible is located in more than one item pool, then any item pool can be provided.
  * - If the collectible is not located in any item pools, then this function will always return
  *   false.
- * - If any player is Tainted Lost, they will be temporarily changed to Isaac and then temporarily
- *   changed back (because Tainted Lost is not able to retrieve some collectibles from item pools).
+ * - 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 isCollectibleUnlocked(
-  collectibleTypeToCheckFor: CollectibleType,
-  itemPoolToCheckFor: ItemPoolType,
+  collectibleType: CollectibleType,
+  itemPoolType: ItemPoolType,
 ): boolean {
-  // If Eden is holding this collectible, then it is obviously unlocked (and it will also be removed
-  // from pools, so the below check won't work).
-  if (anyPlayerHasCollectible(collectibleTypeToCheckFor)) {
+  if (anyPlayerHasCollectible(collectibleType)) {
     return true;
   }
 
-  // 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);
-  for (const player of taintedLosts) {
-    player.ChangePlayerType(PlayerType.ISAAC);
-  }
-
-  // Before checking the item pools, remove any collectibles or trinkets that affect retrieved
-  // collectible types.
-  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);
-  }
-
-  // Blacklist every collectible in the game except for the provided collectible.
-  const itemPool = game.GetItemPool();
-  const collectibleSet = getCollectibleSet();
-  for (const collectibleType of collectibleSet.values()) {
-    if (collectibleType !== collectibleTypeToCheckFor) {
-      itemPool.AddRoomBlacklist(collectibleType);
-    }
-  }
-
-  // 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(
-    itemPoolToCheckFor,
-    false,
-    1 as Seed,
-  );
-
-  const collectibleUnlocked =
-    retrievedCollectibleType === collectibleTypeToCheckFor;
-
-  // Reset the blacklist
-  itemPool.ResetRoomBlacklist();
-
-  // Give back items/trinkets, if necessary.
-  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);
-      }
-    }
-  }
-
-  // Change any players back to Tainted Lost, if necessary.
-  for (const player of taintedLosts) {
-    player.ChangePlayerType(PlayerType.THE_LOST_B);
-  }
-
-  return collectibleUnlocked;
+  return isCollectibleUnlocked(collectibleType, itemPoolType);
 }

package/src/functions/trinketGive.ts

@@ -74,6 +74,27 @@ export function smeltTrinket(
   giveTrinketsBack(player, trinketSituation);
 }
 
+/**
+ * Helper function to smelt two or more different trinkets. If you want to smelt one trinket (or
+ * multiple copies of one trinket), then use the `smeltTrinket` helper function instead.
+ *
+ * This function is variadic, meaning that you can pass as many trinket types as you want to smelt.
+ *
+ * Before smelting, this function will automatically remove the trinkets that the player is holding,
+ * if any, and then give them back after the new trinket is smelted.
+ *
+ * @param player The player to smelt the trinkets to.
+ * @param trinketTypes The trinket types to smelt.
+ */
+export function smeltTrinkets(
+  player: EntityPlayer,
+  ...trinketTypes: TrinketType[]
+): void {
+  for (const trinketType of trinketTypes) {
+    smeltTrinket(player, trinketType);
+  }
+}
+
 /**
  * Helper function to temporarily remove a specific kind of trinket from the player. Use this in
  * combination with the `giveTrinketsBack` function to take away and give back a trinket on the same

package/src/index.ts

@@ -117,6 +117,7 @@ export * from "./functions/gridEntities";
 export * from "./functions/gridEntitiesSpecific";
 export * from "./functions/input";
 export * from "./functions/isaacAPIClass";
+export * from "./functions/itemPool";
 export * from "./functions/jsonHelpers";
 export * from "./functions/jsonRoom";
 export * from "./functions/kColor";