isaacscript-common 30.4.0 → 30.4.2

package/dist/src/interfaces/StageHistoryEntry.d.ts

@@ -0,0 +1,7 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+/** This is used by the `StageHistory` feature. */
+export interface StageHistoryEntry {
+    readonly stage: LevelStage;
+    readonly stageType: StageType;
+}
+//# sourceMappingURL=StageHistoryEntry.d.ts.map

package/dist/src/interfaces/StageHistoryEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StageHistoryEntry.d.ts","sourceRoot":"","sources":["../../../src/interfaces/StageHistoryEntry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAErE,kDAAkD;AAClD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B"}

package/dist/src/interfaces/StageHistoryEntry.lua

@@ -0,0 +1,2 @@
+local ____exports = {}
+return ____exports

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "30.4.0",
+  "version": "30.4.2",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",

package/src/classes/features/callbackLogic/CustomGridEntities.ts

@@ -351,9 +351,10 @@ export class CustomGridEntities extends Feature {
    * `ISCFeature.CUSTOM_GRID_ENTITIES`.
    */
   @Exported
-  public getCustomGridEntities(): Array<
-    [gridEntity: GridEntity, data: GridEntityCustomData]
-  > {
+  public getCustomGridEntities(): Array<{
+    gridEntity: GridEntity;
+    data: GridEntityCustomData;
+  }> {
     const roomListIndex = getRoomListIndex();
     const roomCustomGridEntities =
       v.level.customGridEntities.get(roomListIndex);
@@ -362,11 +363,14 @@ export class CustomGridEntities extends Feature {
     }
 
     const room = game.GetRoom();
-    const customGridEntities: Array<[GridEntity, GridEntityCustomData]> = [];
+    const customGridEntities: Array<{
+      gridEntity: GridEntity;
+      data: GridEntityCustomData;
+    }> = [];
     for (const [gridIndex, data] of roomCustomGridEntities) {
       const gridEntity = room.GetGridEntity(gridIndex);
       if (gridEntity !== undefined) {
-        customGridEntities.push([gridEntity, data]);
+        customGridEntities.push({ gridEntity, data });
       }
     }
 

package/src/classes/features/other/PressInput.ts

@@ -10,7 +10,10 @@ import { Feature } from "../../private/Feature";
 
 const v = {
   run: {
-    buttonActionTuples: [] as Array<[PlayerIndex, ButtonAction]>,
+    buttonActionPairs: [] as Array<{
+      playerIndex: PlayerIndex;
+      buttonAction: ButtonAction;
+    }>,
   },
 };
 
@@ -50,16 +53,15 @@ export class PressInput extends Feature {
 
     const playerIndex = getPlayerIndex(player);
 
-    for (let i = v.run.buttonActionTuples.length - 1; i >= 0; i--) {
+    for (let i = v.run.buttonActionPairs.length - 1; i >= 0; i--) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      const tuple = v.run.buttonActionTuples[i]!;
-      const [tuplePlayerIndex, tupleButtonAction] = tuple;
+      const pair = v.run.buttonActionPairs[i]!;
 
       if (
-        tuplePlayerIndex === playerIndex &&
-        tupleButtonAction === buttonAction
+        pair.playerIndex === playerIndex &&
+        pair.buttonAction === buttonAction
       ) {
-        v.run.buttonActionTuples.splice(i);
+        v.run.buttonActionPairs.splice(i);
         return true;
       }
     }
@@ -77,6 +79,6 @@ export class PressInput extends Feature {
   @Exported
   public pressInput(player: EntityPlayer, buttonAction: ButtonAction): void {
     const playerIndex = getPlayerIndex(player);
-    v.run.buttonActionTuples.push([playerIndex, buttonAction]);
+    v.run.buttonActionPairs.push({ playerIndex, buttonAction });
   }
 }

package/src/classes/features/other/StageHistory.ts

@@ -12,11 +12,12 @@ import {
   onRepentanceStage,
 } from "../../../functions/stage";
 import { asNumber } from "../../../functions/types";
+import { StageHistoryEntry } from "../../../interfaces/StageHistoryEntry";
 import { Feature } from "../../private/Feature";
 
 const v = {
   run: {
-    stageHistory: [] as Array<[stage: LevelStage, stageType: StageType]>,
+    stageHistory: [] as StageHistoryEntry[],
   },
 };
 
@@ -39,7 +40,7 @@ export class StageHistory extends Feature {
     const stage = level.GetStage();
     const stageType = level.GetStageType();
 
-    v.run.stageHistory.push([stage, stageType]);
+    v.run.stageHistory.push({ stage, stageType });
   };
 
   /**
@@ -296,9 +297,7 @@ export class StageHistory extends Feature {
    * In order to use this function, you must upgrade your mod with `ISCFeature.STAGE_HISTORY`.
    */
   @Exported
-  public getStageHistory(): ReadonlyArray<
-    [stage: LevelStage, stageType: StageType]
-  > {
+  public getStageHistory(): readonly StageHistoryEntry[] {
     return v.run.stageHistory;
   }
 
@@ -316,13 +315,14 @@ export class StageHistory extends Feature {
   public hasVisitedStage(stage: LevelStage, stageType?: StageType): boolean {
     if (stageType === undefined) {
       return v.run.stageHistory.some(
-        ([previousStage]) => previousStage === stage,
+        (stageHistoryEntry) => stageHistoryEntry.stage === stage,
       );
     }
 
     return v.run.stageHistory.some(
-      ([previousStage, previousStageType]) =>
-        previousStage === stage && previousStageType === stageType,
+      (stageHistoryEntry) =>
+        stageHistoryEntry.stage === stage &&
+        stageHistoryEntry.stageType === stageType,
     );
   }
 }

package/src/functions/levelGrid.ts

@@ -53,7 +53,9 @@ const ADJACENT_ROOM_GRID_INDEX_DELTAS = [LEFT, UP, RIGHT, DOWN] as const;
  * This is just a filtering of the results of the `getAdjacentExistingRoomGridIndexes` function. See
  * that function for more information.
  */
-export function getAdjacentExistingRoomGridIndexes(roomGridIndex?: int): int[] {
+export function getAdjacentExistingRoomGridIndexes(
+  roomGridIndex?: int,
+): readonly int[] {
   const adjacentRoomGridIndexes = getAdjacentRoomGridIndexes(roomGridIndex);
   return adjacentRoomGridIndexes.filter(
     (adjacentRoomGridIndex) => getRoomData(adjacentRoomGridIndex) !== undefined,
@@ -69,7 +71,7 @@ export function getAdjacentExistingRoomGridIndexes(roomGridIndex?: int): int[] {
  */
 export function getAdjacentNonExistingRoomGridIndexes(
   roomGridIndex?: int,
-): int[] {
+): readonly int[] {
   const adjacentRoomGridIndexes = getAdjacentRoomGridIndexes(roomGridIndex);
   return adjacentRoomGridIndexes.filter(
     (adjacentRoomGridIndex) => getRoomData(adjacentRoomGridIndex) === undefined,
@@ -91,7 +93,9 @@ export function getAdjacentNonExistingRoomGridIndexes(
  *
  * @param roomGridIndex Optional. Default is the current room index.
  */
-export function getAdjacentRoomGridIndexes(roomGridIndex?: int): int[] {
+export function getAdjacentRoomGridIndexes(
+  roomGridIndex?: int,
+): readonly int[] {
   const roomGridIndexToUse =
     roomGridIndex === undefined ? getRoomGridIndex() : roomGridIndex;
 
@@ -109,7 +113,7 @@ export function getAdjacentRoomGridIndexes(roomGridIndex?: int): int[] {
 }
 
 /** Helper function to get the room safe grid index for every room on the entire floor. */
-export function getAllRoomGridIndexes(): int[] {
+export function getAllRoomGridIndexes(): readonly int[] {
   const rooms = getRooms();
   return rooms.map((roomDescriptor) => roomDescriptor.SafeGridIndex);
 }
@@ -124,10 +128,12 @@ export function getAllRoomGridIndexes(): int[] {
  * @returns Either a tuple of adjacent room grid index, `DoorSlot`, and new room grid index, or
  *          undefined.
  */
-export function getNewRoomCandidate(
-  seedOrRNG: Seed | RNG = getRandomSeed(),
-):
-  | [adjacentRoomGridIndex: int, doorSlot: DoorSlot, newRoomGridIndex: int]
+export function getNewRoomCandidate(seedOrRNG: Seed | RNG = getRandomSeed()):
+  | {
+      readonly adjacentRoomGridIndex: int;
+      readonly doorSlot: DoorSlot;
+      readonly newRoomGridIndex: int;
+    }
   | undefined {
   const newRoomCandidatesForLevel = getNewRoomCandidatesForLevel();
   if (newRoomCandidatesForLevel.length === 0) {
@@ -147,7 +153,7 @@ export function getNewRoomCandidate(
  */
 export function getNewRoomCandidatesBesideRoom(
   roomGridIndex?: int,
-): Array<[doorSlot: DoorSlot, roomGridIndex: int]> {
+): ReadonlyArray<{ readonly doorSlot: DoorSlot; readonly roomGridIndex: int }> {
   const roomDescriptor = getRoomDescriptor(roomGridIndex);
 
   // First, handle the case of rooms outside of the grid, which obviously cannot have any possible
@@ -168,7 +174,10 @@ export function getNewRoomCandidatesBesideRoom(
     roomData.Shape,
   );
 
-  const roomCandidates: Array<[DoorSlot, int]> = [];
+  const roomCandidates: Array<{
+    readonly doorSlot: DoorSlot;
+    readonly roomGridIndex: int;
+  }> = [];
 
   for (const [doorSlot, adjacentRoomGridIndex] of doorSlotToRoomGridIndexes) {
     // The "getRoomShapeAdjacentNonExistingGridIndexes" returns grid indexes for every possible
@@ -186,7 +195,10 @@ export function getNewRoomCandidatesBesideRoom(
       continue;
     }
 
-    roomCandidates.push([doorSlot, adjacentRoomGridIndex]);
+    roomCandidates.push({
+      doorSlot,
+      roomGridIndex: adjacentRoomGridIndex,
+    });
   }
 
   return roomCandidates;
@@ -199,9 +211,11 @@ export function getNewRoomCandidatesBesideRoom(
  * @returns A array of tuples containing the adjacent room grid index, the `DoorSlot`, and the new
  *          room grid index.
  */
-export function getNewRoomCandidatesForLevel(): Array<
-  [adjacentRoomGridIndex: int, doorSlot: DoorSlot, newRoomGridIndex: int]
-> {
+export function getNewRoomCandidatesForLevel(): ReadonlyArray<{
+  readonly adjacentRoomGridIndex: int;
+  readonly doorSlot: DoorSlot;
+  readonly newRoomGridIndex: int;
+}> {
   // We want to iterate over every room on the floor and search for potential new room spots.
   const rooms = getRoomsInsideGrid();
 
@@ -216,14 +230,22 @@ export function getNewRoomCandidatesForLevel(): Array<
       room.Data.Subtype !== asNumber(MinesRoomSubType.MINESHAFT_ENTRANCE),
   );
 
-  const newRoomCandidates: Array<[int, DoorSlot, int]> = [];
+  const newRoomCandidates: Array<{
+    readonly adjacentRoomGridIndex: int;
+    readonly doorSlot: DoorSlot;
+    readonly newRoomGridIndex: int;
+  }> = [];
 
   for (const room of normalRooms) {
     const newRoomCandidatesBesideRoom = getNewRoomCandidatesBesideRoom(
       room.SafeGridIndex,
     );
-    for (const [doorSlot, newRoomGridIndex] of newRoomCandidatesBesideRoom) {
-      newRoomCandidates.push([room.SafeGridIndex, doorSlot, newRoomGridIndex]);
+    for (const { doorSlot, roomGridIndex } of newRoomCandidatesBesideRoom) {
+      newRoomCandidates.push({
+        adjacentRoomGridIndex: room.SafeGridIndex,
+        doorSlot,
+        newRoomGridIndex: roomGridIndex,
+      });
     }
   }
 
@@ -291,7 +313,9 @@ export function getRoomDescriptorsForType(
  * This function is variadic, meaning that you can specify N arguments to get the combined grid
  * indexes for N room types.
  */
-export function getRoomGridIndexesForType(...roomTypes: RoomType[]): int[] {
+export function getRoomGridIndexesForType(
+  ...roomTypes: RoomType[]
+): readonly int[] {
   const roomDescriptors = getRoomDescriptorsForType(...roomTypes);
   return roomDescriptors.map((roomDescriptor) => roomDescriptor.SafeGridIndex);
 }
@@ -492,7 +516,8 @@ export function newRoom(seedOrRNG?: Seed | RNG): int | undefined {
   if (newRoomCandidate === undefined) {
     return undefined;
   }
-  const [adjacentRoomGridIndex, doorSlot, newRoomGridIndex] = newRoomCandidate;
+  const { adjacentRoomGridIndex, doorSlot, newRoomGridIndex } =
+    newRoomCandidate;
 
   level.MakeRedRoomDoor(adjacentRoomGridIndex, doorSlot);
 
@@ -552,7 +577,7 @@ export function roomExists(roomGridIndex: int): boolean {
  * - The bottom-left grid index of 156 is equal to coordinates of: (0, 12)
  * - The bottom-right grid index of 168 is equal to coordinates of: (12, 12)
  */
-export function roomGridIndexToVector(roomGridIndex: int): Vector {
+export function roomGridIndexToVector(roomGridIndex: int): Readonly<Vector> {
   const x = roomGridIndex % LEVEL_GRID_ROW_WIDTH;
   const y = Math.floor(roomGridIndex / LEVEL_GRID_ROW_WIDTH);
 

package/src/functions/playerHealth.ts

@@ -5,14 +5,18 @@ import {
   PlayerType,
   TrinketType,
 } from "isaac-typescript-definitions";
-import { ACTIVE_SLOT_VALUES } from "../arrays/cachedEnumValues";
 import { MAX_PLAYER_HEART_CONTAINERS } from "../core/constants";
 import { HealthType } from "../enums/HealthType";
 import { PlayerHealth, SoulHeartType } from "../interfaces/PlayerHealth";
 import { countSetBits, getKBitOfN, getNumBitsOfN } from "./bitwise";
 import { getCharacterMaxHeartContainers } from "./characters";
 import { getTotalCharge } from "./charge";
-import { isCharacter, isKeeper, setActiveItem } from "./players";
+import {
+  getActiveItemSlots,
+  isCharacter,
+  isKeeper,
+  setActiveItem,
+} from "./players";
 import { repeat } from "./utils";
 
 export function addPlayerHealthType(
@@ -543,21 +547,24 @@ export function setPlayerHealth(
   const character = player.GetPlayerType();
   const subPlayer = player.GetSubPlayer();
 
-  removeAllPlayerHealth(player);
-
-  // Before we add any health, we have to take away Alabaster Box, if present.
-  const alabasterBoxes: Array<[slot: ActiveSlot, totalCharge: int]> = [];
-  if (player.HasCollectible(CollectibleType.ALABASTER_BOX)) {
-    for (const activeSlot of ACTIVE_SLOT_VALUES) {
-      const activeItem = player.GetActiveItem();
-      if (activeItem === CollectibleType.ALABASTER_BOX) {
-        const totalCharge = getTotalCharge(player, activeSlot);
-        setActiveItem(player, CollectibleType.NULL, activeSlot);
-        alabasterBoxes.push([activeSlot, totalCharge]);
-      }
-    }
+  // Before we add or remove any health, we have to take away Alabaster Box, if present. (Removing
+  // soul hearts from the player will remove Alabaster Box charges.)
+  const alabasterBoxDescriptions: Array<{
+    activeSlot: ActiveSlot;
+    totalCharge: int;
+  }> = [];
+  const alabasterBoxActiveSlots = getActiveItemSlots(
+    player,
+    CollectibleType.ALABASTER_BOX,
+  );
+  for (const activeSlot of alabasterBoxActiveSlots) {
+    const totalCharge = getTotalCharge(player, activeSlot);
+    setActiveItem(player, CollectibleType.NULL, activeSlot);
+    alabasterBoxDescriptions.push({ activeSlot, totalCharge });
   }
 
+  removeAllPlayerHealth(player);
+
   // Add the red heart containers.
   if (character === PlayerType.SOUL && subPlayer !== undefined) {
     // Adding health to The Soul is a special case.
@@ -608,14 +615,14 @@ export function setPlayerHealth(
   /**
    * Fill in the red heart containers.
    *
-   * (Rotten Hearts must be filled in first in order for this to work properly, since they conflict
-   * with half red hearts.)
+   * Rotten Hearts must be filled in first in order for this to work properly, since they conflict
+   * with half red hearts.
    *
-   * The `EntityPlayer.AddRottenHearts` method is not like actually picking up a rotten heart, since
-   * it will only grant one rotten heart to Tainted Magdalene (whereas picking up a rotten heart
-   * would grant two).
+   * We multiply by two because the `EntityPlayer.GetRottenHearts` function returns the actual
+   * number of rotten hearts, but the `EntityPlayer.AddRottenHearts` works like the other heart
+   * functions in that a value of 1 is equivalent to a half-heart.
    */
-  player.AddRottenHearts(playerHealth.rottenHearts);
+  player.AddRottenHearts(playerHealth.rottenHearts * 2);
 
   if (character === PlayerType.MAGDALENE_B) {
     // Adding 1 heart to Tainted Magdalene will actually add two hearts.
@@ -649,7 +656,7 @@ export function setPlayerHealth(
   }
 
   // Re-add the Alabaster Box, if present.
-  for (const [activeSlot, totalCharge] of alabasterBoxes) {
+  for (const { activeSlot, totalCharge } of alabasterBoxDescriptions) {
     setActiveItem(
       player,
       CollectibleType.ALABASTER_BOX,

package/src/interfaces/StageHistoryEntry.ts

@@ -0,0 +1,7 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+
+/** This is used by the `StageHistory` feature. */
+export interface StageHistoryEntry {
+  readonly stage: LevelStage;
+  readonly stageType: StageType;
+}