isaacscript-common 6.20.2 → 6.22.1

package/src/functions/rockAlt.ts

@@ -10,8 +10,8 @@ import {
   RoomType,
   TrinketType,
 } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { DISTANCE_OF_GRID_TILE } from "../constants";
+import { game } from "../core/cachedClasses";
+import { DISTANCE_OF_GRID_TILE } from "../core/constants";
 import { RockAltType } from "../enums/RockAltType";
 import { BACKDROP_TYPE_TO_ROCK_ALT_TYPE } from "../objects/backdropTypeToRockAltType";
 import { spawnEffectWithSeed, spawnNPCWithSeed } from "./entitiesSpecific";
@@ -40,6 +40,7 @@ const ROCK_ALT_CHANCES = {
   COLLECTIBLE: 0.005,
 } as const;
 
+const COIN_VELOCITY_MULTIPLIER = 2;
 const POLYP_PROJECTILE_SPEED = 10;
 const POLYP_NUM_PROJECTILES = 6;
 
@@ -76,16 +77,17 @@ export function getRockAltType(): RockAltType {
  * trinket is still in the pool. Thus, it will always have a chance to spawn the respective trinket
  * (e.g. Swallowed Penny from urns).
  *
+ * When filled buckets are destroyed, 6 projectiles will always spawn in a random pattern (in
+ * addition to any other rewards that are spawned). This function does not account for this, so if
+ * you want to specifically emulate destroying a filled bucket, you have to account for the
+ * projectiles yourself.
+ *
  * The logic in this function is based on the rewards listed on the wiki:
  * https://bindingofisaacrebirth.fandom.com/wiki/Rocks
  *
  * @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.
@@ -94,7 +96,6 @@ export function getRockAltType(): RockAltType {
 export function spawnRockAltReward(
   position: Vector,
   rockAltType: RockAltType,
-  variant = 0,
   seedOrRNG: Seed | RNG = getRandomSeed(),
 ): boolean {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
@@ -116,8 +117,12 @@ export function spawnRockAltReward(
       return spawnRockAltRewardPolyp(position, rng);
     }
 
-    case RockAltType.BUCKET: {
-      return spawnRockAltRewardBucket(position, rng, variant);
+    case RockAltType.BUCKET_DOWNPOUR: {
+      return spawnRockAltRewardBucketDownpour(position, rng);
+    }
+
+    case RockAltType.BUCKET_DROSS: {
+      return spawnRockAltRewardBucketDross(position, rng);
     }
   }
 }
@@ -135,10 +140,9 @@ function spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean {
   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);
+      const velocity = randomVector.mul(COIN_VELOCITY_MULTIPLIER);
       spawnCoinWithSeed(CoinSubType.NULL, position, rng, velocity);
     });
     return true;
@@ -165,10 +169,10 @@ function spawnRockAltRewardUrn(position: Vector, rng: RNG): boolean {
   }
 
   // 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 numEnemiesChance = getRandom(rng);
+  const numEnemies = numEnemiesChance < 0.5 ? 1 : 2;
   const length = DISTANCE_OF_GRID_TILE * 3;
-  repeat(numSpiders, () => {
+  repeat(numEnemies, () => {
     const randomVector = getRandomVector(rng);
     const offset = randomVector.mul(length);
     const targetPos = position.add(offset);
@@ -378,11 +382,79 @@ function spawnRockAltRewardPolyp(position: Vector, rng: RNG): boolean {
   return true;
 }
 
-function spawnRockAltRewardBucket(
-  _position: Vector,
-  rng: RNG,
-  _variant: int,
-): boolean {
+function spawnRockAltRewardBucketDownpour(position: Vector, rng: RNG): boolean {
+  const chance = getRandom(rng);
+  let totalChance = 0;
+
+  totalChance += ROCK_ALT_CHANCES.NOTHING;
+  if (chance < totalChance) {
+    return false;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.BASIC_DROP;
+  if (chance < totalChance) {
+    const numCoinsChance = getRandom(rng);
+    const numCoins = numCoinsChance < 0.5 ? 1 : 2;
+    repeat(numCoins, () => {
+      const randomVector = getRandomVector(rng);
+      const velocity = randomVector.mul(COIN_VELOCITY_MULTIPLIER);
+      spawnCoinWithSeed(CoinSubType.NULL, position, rng, velocity);
+    });
+    return true;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.TRINKET;
+  if (chance < totalChance) {
+    spawnTrinketWithSeed(TrinketType.SWALLOWED_PENNY, position, rng);
+    return true;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.COLLECTIBLE;
+  if (chance < totalChance) {
+    const stillInPools = isCollectibleInItemPool(
+      CollectibleType.LEECH,
+      ItemPoolType.TREASURE,
+    );
+    if (stillInPools) {
+      spawnCollectible(CollectibleType.LEECH, position, rng);
+      return true;
+    }
+
+    return false;
+  }
+
+  // Since the detrimental effect is the final option, we don't need to check the chance.
+  const enemiesChance = getRandom(rng);
+  const entityType =
+    enemiesChance < 0.5 ? EntityType.SPIDER : EntityType.SMALL_LEECH;
+
+  const numEnemiesChance = getRandom(rng);
+  const numEnemies = numEnemiesChance < 0.5 ? 1 : 2;
+  const jumpDistance = DISTANCE_OF_GRID_TILE * 3;
+  repeat(numEnemies, () => {
+    const randomVector = getRandomVector(rng);
+    const offset = randomVector.mul(jumpDistance);
+    const targetPos = position.add(offset);
+    // If the room has water, Spiders will automatically be replaced with Striders.
+    const spider = EntityNPC.ThrowSpider(
+      position,
+      undefined,
+      targetPos,
+      false,
+      0,
+    );
+
+    // There is no `ThrowLeech` function exposed in the API, so we can piggyback off of the
+    // `ThrowSpider` method.
+    if (entityType === EntityType.SMALL_LEECH && spider.Type !== entityType) {
+      spider.Morph(entityType, 0, 0, -1);
+    }
+  });
+
+  return true;
+}
+
+function spawnRockAltRewardBucketDross(position: Vector, rng: RNG): boolean {
   const chance = getRandom(rng);
   let totalChance = 0;
 
@@ -391,6 +463,62 @@ function spawnRockAltRewardBucket(
     return false;
   }
 
-  // TODO
-  return false;
+  totalChance += ROCK_ALT_CHANCES.BASIC_DROP;
+  if (chance < totalChance) {
+    const numCoinsChance = getRandom(rng);
+    const numCoins = numCoinsChance < 0.5 ? 1 : 2;
+    repeat(numCoins, () => {
+      const randomVector = getRandomVector(rng);
+      const velocity = randomVector.mul(COIN_VELOCITY_MULTIPLIER);
+      spawnCoinWithSeed(CoinSubType.NULL, position, rng, velocity);
+    });
+    return true;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.TRINKET;
+  if (chance < totalChance) {
+    spawnTrinketWithSeed(TrinketType.BUTT_PENNY, position, rng);
+    return true;
+  }
+
+  totalChance += ROCK_ALT_CHANCES.COLLECTIBLE;
+  if (chance < totalChance) {
+    const stillInPools = isCollectibleInItemPool(
+      CollectibleType.POOP,
+      ItemPoolType.TREASURE,
+    );
+    if (stillInPools) {
+      spawnCollectible(CollectibleType.POOP, position, rng);
+      return true;
+    }
+
+    return false;
+  }
+
+  // Since the detrimental effect is the final option, we don't need to check the chance.
+  const enemiesChance = getRandom(rng);
+  const entityType =
+    enemiesChance < 0.5 ? EntityType.DRIP : EntityType.SMALL_LEECH;
+
+  const numEnemiesChance = getRandom(rng);
+  const numEnemies = numEnemiesChance < 0.5 ? 1 : 2;
+  const jumpDistance = DISTANCE_OF_GRID_TILE * 3;
+  repeat(numEnemies, () => {
+    const randomVector = getRandomVector(rng);
+    const offset = randomVector.mul(jumpDistance);
+    const targetPos = position.add(offset);
+    const spider = EntityNPC.ThrowSpider(
+      position,
+      undefined,
+      targetPos,
+      false,
+      0,
+    );
+
+    // There is no `ThrowLeech` or `ThrowDrip` functions exposed in the API, so we can piggyback off
+    // of the `ThrowSpider` method.
+    spider.Morph(entityType, 0, 0, -1);
+  });
+
+  return true;
 }

package/src/functions/roomData.ts

@@ -5,7 +5,7 @@ import {
   RoomType,
   StageID,
 } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
+import { game } from "../core/cachedClasses";
 import { doorSlotFlagToDoorSlot } from "./doors";
 import { getEnumValues } from "./enums";
 import { hasFlag } from "./flag";

package/src/functions/roomTransition.ts

@@ -0,0 +1,78 @@
+import {
+  Direction,
+  DoorSlot,
+  LevelCurse,
+  RoomTransitionAnim,
+} from "isaac-typescript-definitions";
+import { game } from "../core/cachedClasses";
+import { runNextRoom } from "../features/runNextRoom";
+import { hasCurse } from "./curses";
+import { getRoomData, getRoomGridIndex } from "./roomData";
+
+/**
+ * Helper function to reload the current room using `Game.StartRoomTransition`.
+ *
+ * This is useful for canceling the "goto" console command or to make the `Level.SetStage` method
+ * take effect.
+ */
+export function reloadRoom(): void {
+  const roomGridIndex = getRoomGridIndex();
+  teleport(
+    roomGridIndex,
+    Direction.NO_DIRECTION,
+    RoomTransitionAnim.FADE,
+    true,
+  );
+}
+
+/**
+ * Helper function to change the current room. It can be used for both teleportation and "normal"
+ * room transitions, depending on what is passed for the `direction` and `roomTransitionAnim`
+ * arguments.
+ *
+ * Use this function instead of invoking the `Game.StartRoomTransition` method directly so that:
+ * - you do not forget to set `Level.LeaveDoor` property
+ * - to prevent crashing on invalid room grid indexes
+ * - to automatically handle Curse of the Maze
+ *
+ * @param roomGridIndex The room grid index of the destination room.
+ * @param direction Optional. Default is `Direction.NO_DIRECTION`.
+ * @param roomTransitionAnim Optional. Default is `RoomTransitionAnim.TELEPORT`.
+ * @param force Optional. Whether to temporarily disable Curse of the Maze. Default is false. If set
+ *              to false, then this function may not go to the provided room grid index.
+ */
+export function teleport(
+  roomGridIndex: int,
+  direction = Direction.NO_DIRECTION,
+  roomTransitionAnim = RoomTransitionAnim.TELEPORT,
+  force = false,
+): void {
+  const level = game.GetLevel();
+
+  // Before starting a room transition, we must ensure that Curse of the Maze is not in effect, or
+  // else the room transition might send us to the wrong room.
+  const shouldTempDisableCurse = force && hasCurse(LevelCurse.MAZE);
+  if (shouldTempDisableCurse) {
+    level.RemoveCurses(LevelCurse.MAZE);
+  }
+
+  const roomData = getRoomData(roomGridIndex);
+  if (roomData === undefined) {
+    error(
+      `Failed to change the room to grid index ${roomGridIndex} because that room does not exist.`,
+    );
+  }
+
+  // This must be set before every `Game.StartRoomTransition` method invocation or else the function
+  // can send you to the wrong room.
+  level.LeaveDoor = DoorSlot.NO_DOOR_SLOT;
+
+  game.StartRoomTransition(roomGridIndex, direction, roomTransitionAnim);
+
+  if (shouldTempDisableCurse) {
+    runNextRoom(() => {
+      const futureLevel = game.GetLevel();
+      futureLevel.AddCurse(LevelCurse.MAZE, false);
+    });
+  }
+}

package/src/functions/rooms.ts

@@ -3,26 +3,22 @@ import {
   BackdropType,
   BossID,
   Dimension,
-  Direction,
   DoorSlot,
   DungeonSubType,
   GridRoom,
   HomeRoomSubType,
   ItemPoolType,
-  LevelCurse,
   MinibossID,
   RoomDescriptorFlag,
   RoomShape,
-  RoomTransitionAnim,
   RoomType,
   SoundEffect,
   StageID,
 } from "isaac-typescript-definitions";
-import { game, sfxManager } from "../cachedClasses";
-import { MAX_LEVEL_GRID_INDEX, NUM_DIMENSIONS } from "../constants";
+import { game, sfxManager } from "../core/cachedClasses";
+import { MAX_LEVEL_GRID_INDEX, NUM_DIMENSIONS } from "../core/constants";
 import { ROOM_TYPE_NAMES } from "../objects/roomTypeNames";
 import { MINE_SHAFT_ROOM_SUB_TYPE_SET } from "../sets/mineShaftRoomSubTypesSet";
-import { hasCurse } from "./curses";
 import { inDimension } from "./dimensions";
 import {
   closeAllDoors,
@@ -47,6 +43,7 @@ import {
   getRoomStageID,
   getRoomSubType,
 } from "./roomData";
+import { reloadRoom } from "./roomTransition";
 import { getGotoCommand } from "./stage";
 import { erange, irange } from "./utils";
 
@@ -142,13 +139,7 @@ export function getRoomDataForTypeVariant(
   const newRoomData = getRoomData(GridRoom.DEBUG);
 
   if (cancelRoomTransition) {
-    const roomGridIndex = getRoomGridIndex();
-    teleport(
-      roomGridIndex,
-      Direction.NO_DIRECTION,
-      RoomTransitionAnim.FADE,
-      true,
-    );
+    reloadRoom();
   }
 
   return newRoomData;
@@ -556,52 +547,3 @@ export function setRoomUncleared(): void {
   room.SetClear(false);
   closeAllDoors();
 }
-
-/**
- * Helper function to change the current room. It can be used for both teleportation and "normal"
- * room transitions, depending on what is passed for the `direction` and `roomTransitionAnim`
- * arguments.
- *
- * Use this function instead of invoking the `Game.StartRoomTransition` method directly so that:
- * - you do not forget to set `Level.LeaveDoor` property
- * - to prevent crashing on invalid room grid indexes
- * - to automatically handle Curse of the Maze
- *
- * @param roomGridIndex The room grid index of the destination room.
- * @param direction Optional. Default is `Direction.NO_DIRECTION`.
- * @param roomTransitionAnim Optional. Default is `RoomTransitionAnim.TELEPORT`.
- * @param force Optional. Whether to temporarily disable Curse of the Maze. Default is false. If set
- *              to false, then this function may not go to the provided room grid index.
- */
-export function teleport(
-  roomGridIndex: int,
-  direction = Direction.NO_DIRECTION,
-  roomTransitionAnim = RoomTransitionAnim.TELEPORT,
-  force = false,
-): void {
-  const level = game.GetLevel();
-
-  // Before starting a room transition, we must ensure that Curse of the Maze is not in effect, or
-  // else the room transition might send us to the wrong room.
-  const shouldTempDisableCurse = force && hasCurse(LevelCurse.MAZE);
-  if (shouldTempDisableCurse) {
-    level.RemoveCurses(LevelCurse.MAZE);
-  }
-
-  const roomData = getRoomData(roomGridIndex);
-  if (roomData === undefined) {
-    error(
-      `Failed to change the room to grid index ${roomGridIndex} because that room does not exist.`,
-    );
-  }
-
-  // This must be set before every `Game.StartRoomTransition` method invocation or else the function
-  // can send you to the wrong room.
-  level.LeaveDoor = DoorSlot.NO_DOOR_SLOT;
-
-  game.StartRoomTransition(roomGridIndex, direction, roomTransitionAnim);
-
-  if (shouldTempDisableCurse) {
-    level.AddCurse(LevelCurse.MAZE, false);
-  }
-}

package/src/functions/run.ts

@@ -1,6 +1,6 @@
 import { Challenge, PlayerType } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { FIRST_CHARACTER } from "../constantsFirstLast";
+import { game } from "../core/cachedClasses";
+import { FIRST_CHARACTER } from "../core/constantsFirstLast";
 import { runNextRenderFrame } from "../features/runInNFrames";
 import { log } from "./log";
 

package/src/functions/seeds.ts

@@ -1,4 +1,4 @@
-import { game } from "../cachedClasses";
+import { game } from "../core/cachedClasses";
 import { newRNG } from "./rng";
 
 /** Alias for the `Seeds.GetStartSeedString` method. */

package/src/functions/sound.ts

@@ -1,5 +1,5 @@
 import { SoundEffect } from "isaac-typescript-definitions";
-import { sfxManager } from "../cachedClasses";
+import { sfxManager } from "../core/cachedClasses";
 import { getEnumValues } from "./enums";
 
 export function stopAllSoundEffects(): void {

package/src/functions/spawnCollectible.ts

@@ -4,7 +4,7 @@ import {
   PickupVariant,
   PlayerType,
 } from "isaac-typescript-definitions";
-import { VectorZero } from "../constants";
+import { VectorZero } from "../core/constants";
 import { preventCollectibleRotation } from "../features/preventCollectibleRotation";
 import { areFeaturesInitialized } from "../featuresInitialized";
 import { setCollectibleEmpty } from "./collectibles";

package/src/functions/sprites.ts

@@ -1,4 +1,4 @@
-import { EMPTY_PNG_PATH, VectorZero } from "../constants";
+import { EMPTY_PNG_PATH, VectorZero } from "../core/constants";
 import { kColorEquals } from "./kColor";
 import { erange } from "./utils";
 

package/src/functions/stage.ts

@@ -4,7 +4,7 @@ import {
   RoomType,
   StageType,
 } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
+import { game } from "../core/cachedClasses";
 import { ROOM_TYPE_GOTO_PREFIXES } from "../objects/roomTypeGotoPrefixes";
 import { STAGE_TYPE_SUFFIXES } from "../objects/stageTypeSuffixes";
 import { STAGE_TYPE_TO_LETTER } from "../objects/stageTypeToLetter";

package/src/functions/trinkets.ts

@@ -4,13 +4,13 @@ import {
   TrinketSlot,
   TrinketType,
 } from "isaac-typescript-definitions";
-import { itemConfig } from "../cachedClasses";
+import { itemConfig } from "../core/cachedClasses";
 import {
   FIRST_MODDED_TRINKET_TYPE,
   FIRST_TRINKET_TYPE,
   LAST_TRINKET_TYPE,
   LAST_VANILLA_TRINKET_TYPE,
-} from "../constantsFirstLast";
+} from "../core/constantsFirstLast";
 import {
   DEFAULT_TRINKET_DESCRIPTION,
   TRINKET_DESCRIPTION_MAP,

package/src/functions/ui.ts

@@ -1,6 +1,6 @@
 import { CollectibleType, LevelCurse } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { UI_HEART_WIDTH, VectorZero } from "../constants";
+import { game } from "../core/cachedClasses";
+import { UI_HEART_WIDTH, VectorZero } from "../core/constants";
 import { copyVector } from "./vector";
 
 /**

package/src/functions/utils.ts

@@ -1,5 +1,5 @@
 import { RenderMode } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
+import { game } from "../core/cachedClasses";
 import { CONSOLE_COMMANDS_SET } from "../sets/consoleCommandsSet";
 
 const HEX_STRING_LENGTH = 6;