isaacscript-common 7.4.3 → 7.6.0

package/src/features/customStage/versusScreen.ts

@@ -9,7 +9,7 @@ import {
 import { game, sfxManager } from "../../core/cachedClasses";
 import { arrayRemove } from "../../functions/array";
 import { getBosses } from "../../functions/bosses";
-import { getEntityID } from "../../functions/entities";
+import { getRoomSubType } from "../../functions/roomData";
 import { erange } from "../../functions/utils";
 import { CustomStage } from "../../interfaces/private/CustomStage";
 import { BOSS_NAME_PNG_FILE_NAMES } from "../../objects/bossNamePNGFileNames";
@@ -26,7 +26,7 @@ import {
   DEFAULT_BASE_STAGE_TYPE,
   INVALID_STAGE_VALUE,
 } from "./exports";
-import v, { customBossPNGPaths } from "./v";
+import v from "./v";
 
 const DEFAULT_CHARACTER = PlayerType.ISAAC;
 const DEFAULT_STAGE_ID = StageID.BASEMENT;
@@ -137,22 +137,25 @@ export function playVersusScreenAnimation(customStage: CustomStage): void {
   pause();
   hud.SetVisible(false);
 
-  const [playerNamePNGPath, playerPortraitPNGPath] = getPlayerPNGPaths();
-  versusScreenSprite.ReplaceSpritesheet(
-    PLAYER_NAME_ANM2_LAYER,
-    playerNamePNGPath,
-  );
-  versusScreenSprite.ReplaceSpritesheet(
-    PLAYER_PORTRAIT_ANM2_LAYER,
-    playerPortraitPNGPath,
-  );
+  // Player
+  {
+    const { namePNGPath, portraitPNGPath } = getPlayerPNGPaths();
+    versusScreenSprite.ReplaceSpritesheet(PLAYER_NAME_ANM2_LAYER, namePNGPath);
+    versusScreenSprite.ReplaceSpritesheet(
+      PLAYER_PORTRAIT_ANM2_LAYER,
+      portraitPNGPath,
+    );
+  }
 
-  const [bossNamePNGPath, bossPortraitPNGPath] = getBossPNGPaths();
-  versusScreenSprite.ReplaceSpritesheet(BOSS_NAME_ANM2_LAYER, bossNamePNGPath);
-  versusScreenSprite.ReplaceSpritesheet(
-    BOSS_PORTRAIT_ANM2_LAYER,
-    bossPortraitPNGPath,
-  );
+  // Boss
+  {
+    const { namePNGPath, portraitPNGPath } = getBossPNGPaths(customStage);
+    versusScreenSprite.ReplaceSpritesheet(BOSS_NAME_ANM2_LAYER, namePNGPath);
+    versusScreenSprite.ReplaceSpritesheet(
+      BOSS_PORTRAIT_ANM2_LAYER,
+      portraitPNGPath,
+    );
+  }
 
   versusScreenSprite.LoadGraphics();
 
@@ -186,67 +189,81 @@ function willVanillaVersusScreenPlay() {
 }
 
 /** Use the character of the 0th player. */
-function getPlayerPNGPaths(): [
-  playerNamePNGPath: string,
-  playerPortraitPNGPath: string,
-] {
+function getPlayerPNGPaths(): {
+  namePNGPath: string;
+  portraitPNGPath: string;
+} {
   const player = Isaac.GetPlayer();
   const character = player.GetPlayerType();
 
-  let playerNamePNGFileName = PLAYER_NAME_PNG_FILE_NAMES[character];
-  if (playerNamePNGFileName === undefined) {
-    playerNamePNGFileName = PLAYER_NAME_PNG_FILE_NAMES[DEFAULT_CHARACTER];
+  let namePNGFileName = PLAYER_NAME_PNG_FILE_NAMES[character];
+  if (namePNGFileName === undefined) {
+    namePNGFileName = PLAYER_NAME_PNG_FILE_NAMES[DEFAULT_CHARACTER];
   }
 
-  const playerNamePNGPath = `${PNG_PATH_PREFIX}/${playerNamePNGFileName}`;
+  const namePNGPath = `${PNG_PATH_PREFIX}/${namePNGFileName}`;
 
-  let playerPortraitFileName = PLAYER_PORTRAIT_PNG_FILE_NAMES[character];
-  if (playerNamePNGFileName === undefined) {
-    playerPortraitFileName = PLAYER_PORTRAIT_PNG_FILE_NAMES[DEFAULT_CHARACTER];
+  let portraitFileName = PLAYER_PORTRAIT_PNG_FILE_NAMES[character];
+  if (namePNGFileName === undefined) {
+    portraitFileName = PLAYER_PORTRAIT_PNG_FILE_NAMES[DEFAULT_CHARACTER];
   }
 
-  const playerPortraitPNGPath = `${PLAYER_PORTRAIT_PNG_PATH_PREFIX}/${playerPortraitFileName}`;
+  const portraitPNGPath = `${PLAYER_PORTRAIT_PNG_PATH_PREFIX}/${portraitFileName}`;
 
-  return [playerNamePNGPath, playerPortraitPNGPath];
+  return { namePNGPath, portraitPNGPath };
 }
 
 /** Use the boss of the first boss found. */
-function getBossPNGPaths(): [
-  bossNamePNGPath: string,
-  bossPortraitPNGPath: string,
-] {
-  const bosses = getBosses();
-  const firstBoss = bosses[0];
-
+function getBossPNGPaths(customStage: CustomStage): {
+  namePNGPath: string;
+  portraitPNGPath: string;
+} {
   // Prefer the PNG paths specified by the end-user, if any.
-  if (firstBoss !== undefined) {
-    const entityID = getEntityID(firstBoss);
-    const pngPaths = customBossPNGPaths.get(entityID);
-    if (pngPaths !== undefined) {
-      return pngPaths;
-    }
+  const paths = getBossPNGPathsCustom(customStage);
+  if (paths !== undefined) {
+    return paths;
   }
 
   // If this is not a vanilla boss, default to showing question marks.
+  const bosses = getBosses();
+  const firstBoss = bosses[0];
   const bossID = firstBoss === undefined ? 0 : firstBoss.GetBossID();
   if (bossID === 0) {
     const questionMarkSprite = `${PNG_PATH_PREFIX}/${
       BOSS_NAME_PNG_FILE_NAMES[BossID.BLUE_BABY]
     }`;
-    const bossNamePNGPath = questionMarkSprite;
-    const bossPortraitPNGPath = questionMarkSprite;
-    return [bossNamePNGPath, bossPortraitPNGPath];
+    const namePNGPath = questionMarkSprite;
+    const portraitPNGPath = questionMarkSprite;
+    return { namePNGPath, portraitPNGPath };
   }
 
   // If this is a vanilla boss, it will have a boss ID, and we can use the corresponding vanilla
   // files.
-  const bossNamePNGFileName = BOSS_NAME_PNG_FILE_NAMES[bossID];
-  const bossNamePNGPath = `${PNG_PATH_PREFIX}/${bossNamePNGFileName}`;
+  const namePNGFileName = BOSS_NAME_PNG_FILE_NAMES[bossID];
+  const namePNGPath = `${PNG_PATH_PREFIX}/${namePNGFileName}`;
 
-  const bossPortraitPNGFileName = BOSS_PORTRAIT_PNG_FILE_NAMES[bossID];
-  const bossPortraitPNGPath = `${PNG_PATH_PREFIX}/${bossPortraitPNGFileName}`;
+  const portraitPNGFileName = BOSS_PORTRAIT_PNG_FILE_NAMES[bossID];
+  const portraitPNGPath = `${PNG_PATH_PREFIX}/${portraitPNGFileName}`;
 
-  return [bossNamePNGPath, bossPortraitPNGPath];
+  return { namePNGPath, portraitPNGPath };
+}
+
+function getBossPNGPathsCustom(
+  customStage: CustomStage,
+): { namePNGPath: string; portraitPNGPath: string } | undefined {
+  if (customStage.bossPool === undefined) {
+    return undefined;
+  }
+
+  const roomSubType = getRoomSubType();
+  const matchingBossEntry = customStage.bossPool.find(
+    (bossEntry) => bossEntry.subType === roomSubType,
+  );
+  if (matchingBossEntry === undefined) {
+    return undefined;
+  }
+
+  return matchingBossEntry.versusScreen;
 }
 
 function finishVersusScreenAnimation() {
@@ -267,10 +284,8 @@ export function versusScreenPostRender(): void {
     return;
   }
 
-  const isPaused = game.IsPaused();
-  if (isPaused) {
-    return;
-  }
+  // We do not want to early return when the game is paused because we need to start displaying the
+  // black screen as soon as the slide animation starts.
 
   if (versusScreenSprite.IsFinished(VERSUS_SCREEN_ANIMATION_NAME)) {
     finishVersusScreenAnimation();

package/src/features/customTrapdoor/exports.ts

@@ -1,45 +1,28 @@
-import {
-  GridCollisionClass,
-  LevelStage,
-  StageType,
-} from "isaac-typescript-definitions";
-import { game } from "../../core/cachedClasses";
-import { TrapdoorAnimation } from "../../enums/private/TrapdoorAnimation";
+import { LevelStage, StageType } from "isaac-typescript-definitions";
 import { errorIfFeaturesNotInitialized } from "../../featuresInitialized";
 import { getNextStage, getNextStageType } from "../../functions/nextStage";
-import { getRoomListIndex } from "../../functions/roomData";
-import { isVector } from "../../functions/vector";
-import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
-import { TrapdoorDestination } from "../../types/TrapdoorDestination";
-import { spawnCustomGridEntity } from "../customGridEntity";
-import {
-  CUSTOM_TRAPDOOR_FEATURE_NAME,
-  GridEntityTypeCustom,
-} from "./customTrapdoorConstants";
-import { shouldTrapdoorSpawnOpen } from "./openClose";
-import v from "./v";
+import { CustomTrapdoorDestination } from "../../interfaces/private/CustomTrapdoorDestination";
+import { CUSTOM_TRAPDOOR_FEATURE_NAME } from "./customTrapdoorConstants";
+import { spawnCustomTrapdoorToDestination } from "./spawn";
 
 /**
- * Helper function to spawn a trapdoor grid entity that will have one or more of the following
- * attributes:
+ * Helper function to spawn a trapdoor grid entity that will take a player to a custom stage. If you
+ * want to create a custom trapdoor that goes to a vanilla stage instead, use the
+ * `spawnCustomTrapdoorToVanilla` helper function.
+ *
+ * Custom trapdoors can have one or more of the following attributes:
  *
  * - custom destination (or custom logic for after the player enters)
  * - custom graphics
  * - custom logic for opening/closing
  *
- * You can use this function to take the player to your custom stage.
- *
  * Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
  * respawned every time the player re-enters the room.
  *
  * @param gridIndexOrPosition The location in the room to spawn the trapdoor.
- * @param destination Optional. Used to specify where the player will go after jumping into the
- *                    trapdoor. Can either be a vanilla stage tuple, a custom stage tuple, or
- *                    undefined. For example, a destination of `[LevelStage.CAVES_1,
- *                    StageType.ORIGINAL]` corresponds to Caves 1, and a destination of
- *                    `["Slaughterhouse", 1]` corresponds to a custom stage of Slaughterhouse 1. If
- *                    the destination is undefined, then the "normal" destination corresponding to
- *                    the current stage and room will be used (e.g. the next floor, in most cases).
+ * @param customStageName The name of the custom stage.
+ * @param customStageFloorNum The floor of the custom stage. For most purposes, you should use 1 or
+ *                            2.
  * @param anm2Path Optional. The path to the anm2 file to use. By default, the vanilla trapdoor anm2
  *                 of "gfx/grid/door_11_trapdoor.anm2" will be used. The specified anm2 file must
  *                 have animations called "Opened", "Closed", and "Open Animation".
@@ -48,54 +31,65 @@ import v from "./v";
  */
 export function spawnCustomTrapdoor(
   gridIndexOrPosition: int | Vector,
-  destination?: TrapdoorDestination,
+  customStageName: string,
+  customStageFloorNum: int,
   anm2Path = "gfx/grid/door_11_trapdoor.anm2",
   spawnOpen?: boolean,
 ): GridEntity {
   errorIfFeaturesNotInitialized(CUSTOM_TRAPDOOR_FEATURE_NAME);
 
-  const room = game.GetRoom();
-  const roomFrameCount = room.GetFrameCount();
-  const roomListIndex = getRoomListIndex();
-  const gridIndex = isVector(gridIndexOrPosition)
-    ? room.GetGridIndex(gridIndexOrPosition)
-    : gridIndexOrPosition;
+  const destination: CustomTrapdoorDestination = {
+    customStageName,
+    customStageFloorNum,
+  };
 
-  const gridEntity = spawnCustomGridEntity(
-    GridEntityTypeCustom.TRAPDOOR_CUSTOM,
+  return spawnCustomTrapdoorToDestination(
     gridIndexOrPosition,
-    GridCollisionClass.NONE,
+    destination,
     anm2Path,
-    TrapdoorAnimation.OPENED,
+    spawnOpen,
   );
+}
 
-  const firstSpawn = roomFrameCount !== 0;
-  const open =
-    spawnOpen === undefined
-      ? shouldTrapdoorSpawnOpen(gridEntity, firstSpawn)
-      : spawnOpen;
-  const destinationToUse =
-    destination === undefined ? getDefaultDestination() : destination;
-
-  const roomTrapdoorMap = v.level.trapdoors.getAndSetDefault(roomListIndex);
-  const customTrapdoorDescription: CustomTrapdoorDescription = {
-    open,
-    destination: destinationToUse,
-    firstSpawn,
-  };
-  roomTrapdoorMap.set(gridIndex, customTrapdoorDescription);
-
-  if (!open) {
-    const sprite = gridEntity.GetSprite();
-    sprite.Play(TrapdoorAnimation.CLOSED, true);
-  }
+/**
+ * This is the same thing as the `spawnCustomTrapdoor` function, but instead of having a destination
+ * of a custom stage, it has a destination of a vanilla stage.
+ *
+ * For more information, see the `spawnCustomTrapdoor` function.
+ *
+ * @param gridIndexOrPosition The location in the room to spawn the trapdoor.
+ * @param stage Optional. The number of the vanilla stage to go to. If not provided, the "normal"
+ *              next stage will be selected.
+ * @param stageType The stage type of the vanilla stage to go to. If not provided, the "normal" next
+ *                  stage type will be selected.
+ * @param anm2Path Optional. The path to the anm2 file to use. By default, the vanilla trapdoor anm2
+ *                 of "gfx/grid/door_11_trapdoor.anm2" will be used. The specified anm2 file must
+ *                 have animations called "Opened", "Closed", and "Open Animation".
+ * @param spawnOpen Optional. Whether or not to spawn the trapdoor in an open state. By default,
+ *                  behavior will be used that emulates a vanilla trapdoor.
+ */
+export function spawnCustomTrapdoorToVanilla(
+  gridIndexOrPosition: int | Vector,
+  stage?: LevelStage,
+  stageType?: StageType,
+  anm2Path = "gfx/grid/door_11_trapdoor.anm2",
+  spawnOpen?: boolean,
+): GridEntity {
+  errorIfFeaturesNotInitialized(CUSTOM_TRAPDOOR_FEATURE_NAME);
 
-  return gridEntity;
-}
+  const vanillaStage = stage === undefined ? getNextStage() : stage;
+  const vanillaStageType =
+    stageType === undefined ? getNextStageType() : stageType;
 
-function getDefaultDestination(): [stage: LevelStage, stageType: StageType] {
-  const nextStage = getNextStage();
-  const nextStageType = getNextStageType();
+  const destination: CustomTrapdoorDestination = {
+    vanillaStage,
+    vanillaStageType,
+  };
 
-  return [nextStage, nextStageType];
+  return spawnCustomTrapdoorToDestination(
+    gridIndexOrPosition,
+    destination,
+    anm2Path,
+    spawnOpen,
+  );
 }

package/src/features/customTrapdoor/init.ts

@@ -4,7 +4,6 @@ import {
   EntityGridCollisionClass,
   ModCallback,
   RoomTransitionAnim,
-  StageType,
 } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../../classes/ModUpgraded";
 import { game } from "../../core/cachedClasses";
@@ -15,7 +14,6 @@ import { getAllPlayers } from "../../functions/playerIndex";
 import { getRoomGridIndex, getRoomListIndex } from "../../functions/roomData";
 import { teleport } from "../../functions/roomTransition";
 import { setStage } from "../../functions/stage";
-import { isString } from "../../functions/types";
 import { disableCustomStage, setCustomStage } from "../customStage/exports";
 import { topStreakTextStart } from "../customStage/streakText";
 import { enableAllInputs } from "../disableInputs";
@@ -119,7 +117,7 @@ function checkPixelationToBlackComplete() {
       StageTravelState.WAITING_FOR_SECOND_PIXELATION_TO_GET_HALF_WAY;
     v.run.stateRenderFrame = futureRenderFrameCount;
 
-    goToCustomDestination();
+    goToCustomTrapdoorDestination();
 
     // Start another pixelation effect. This time, we will keep the screen black with the sprite,
     // and then remove the black sprite once the pixelation effect is halfway complete.
@@ -193,21 +191,24 @@ function checkAllPlayersLayingDownComplete() {
   enableAllInputs(CUSTOM_TRAPDOOR_FEATURE_NAME);
 }
 
-function goToCustomDestination() {
+function goToCustomTrapdoorDestination() {
   if (v.run.destination === null) {
     return;
   }
 
-  const [arg1, arg2] = v.run.destination;
+  const {
+    customStageName,
+    customStageFloorNum,
+    vanillaStage,
+    vanillaStageType,
+  } = v.run.destination;
 
-  if (isString(arg1)) {
-    // A string represents a custom stage.
-    const firstFloor = arg2 === 1;
+  if (customStageName !== undefined && customStageFloorNum !== undefined) {
+    const firstFloor = customStageFloorNum === 1;
     setCustomStage("Slaughterhouse", firstFloor);
-  } else {
-    // A number represents a vanilla `LevelStage`.
+  } else if (vanillaStage !== undefined && vanillaStageType !== undefined) {
     disableCustomStage();
-    setStage(arg1, arg2 as StageType);
+    setStage(vanillaStage, vanillaStageType);
   }
 }
 

package/src/features/customTrapdoor/spawn.ts

@@ -0,0 +1,54 @@
+import { GridCollisionClass } from "isaac-typescript-definitions";
+import { game } from "../../core/cachedClasses";
+import { TrapdoorAnimation } from "../../enums/private/TrapdoorAnimation";
+import { getRoomListIndex } from "../../functions/roomData";
+import { isVector } from "../../functions/vector";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
+import { CustomTrapdoorDestination } from "../../interfaces/private/CustomTrapdoorDestination";
+import { spawnCustomGridEntity } from "../customGridEntity";
+import { GridEntityTypeCustom } from "./customTrapdoorConstants";
+import { shouldTrapdoorSpawnOpen } from "./openClose";
+import v from "./v";
+
+export function spawnCustomTrapdoorToDestination(
+  gridIndexOrPosition: int | Vector,
+  destination: CustomTrapdoorDestination,
+  anm2Path: string,
+  spawnOpen?: boolean,
+): GridEntity {
+  const room = game.GetRoom();
+  const roomFrameCount = room.GetFrameCount();
+  const roomListIndex = getRoomListIndex();
+  const gridIndex = isVector(gridIndexOrPosition)
+    ? room.GetGridIndex(gridIndexOrPosition)
+    : gridIndexOrPosition;
+
+  const gridEntity = spawnCustomGridEntity(
+    GridEntityTypeCustom.TRAPDOOR_CUSTOM,
+    gridIndexOrPosition,
+    GridCollisionClass.NONE,
+    anm2Path,
+    TrapdoorAnimation.OPENED,
+  );
+
+  const firstSpawn = roomFrameCount !== 0;
+  const open =
+    spawnOpen === undefined
+      ? shouldTrapdoorSpawnOpen(gridEntity, firstSpawn)
+      : spawnOpen;
+
+  const roomTrapdoorMap = v.level.trapdoors.getAndSetDefault(roomListIndex);
+  const customTrapdoorDescription: CustomTrapdoorDescription = {
+    open,
+    destination,
+    firstSpawn,
+  };
+  roomTrapdoorMap.set(gridIndex, customTrapdoorDescription);
+
+  if (!open) {
+    const sprite = gridEntity.GetSprite();
+    sprite.Play(TrapdoorAnimation.CLOSED, true);
+  }
+
+  return gridEntity;
+}

package/src/features/customTrapdoor/v.ts

@@ -1,7 +1,7 @@
 import { DefaultMap } from "../../classes/DefaultMap";
 import { StageTravelState } from "../../enums/private/StageTravelState";
 import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
-import { TrapdoorDestination } from "../../types/TrapdoorDestination";
+import { CustomTrapdoorDestination } from "../../interfaces/private/CustomTrapdoorDestination";
 
 const v = {
   run: {
@@ -10,7 +10,7 @@ const v = {
     /** The render frame that this state was reached. */
     stateRenderFrame: null as int | null,
 
-    destination: null as TrapdoorDestination | null,
+    destination: null as CustomTrapdoorDestination | null,
   },
 
   level: {

package/src/functions/dev.ts

@@ -0,0 +1,31 @@
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { enableExtraConsoleCommands } from "../features/extraConsoleCommands/exports";
+import { removeFadeIn } from "../features/fadeInRemover";
+import { enableFastReset } from "../features/fastReset";
+import { saveDataManagerSetGlobal } from "../features/saveDataManager/exports";
+import { setLogFunctionsGlobal } from "./log";
+
+/**
+ * Helper function to enable some IsaacScript features that are useful when developing a mod. They
+ * shouldn't be enabled when your mod goes to production (i.e. it is uploaded to the Steam
+ * Workshop).
+ *
+ * The list of development features that are enabled are as follows:
+ *
+ * - `saveDataManagerSetGlobal` - Sets your local variables registered with the save data manager as
+ *   global variables so you can access them from the in-game console.
+ * - `setLogFunctionsGlobal` - Sets the various log functions global so that you can access them
+ *   from the in-game console.
+ * - `enableExtraConsoleCommands` - Enables many extra in-game console commands that make warping
+ *   around easier (like e.g. `angel` to warp to the Angel Room).
+ * - `enableFastReset` - Makes it so that the r key resets the game instantaneously.
+ * - `removeFadeIn` - Removes the slow fade in that occurs at the beginning of the run, so that you
+ *   can immediately start playing or testing.
+ */
+export function enableDevFeatures(mod: ModUpgraded): void {
+  saveDataManagerSetGlobal();
+  setLogFunctionsGlobal();
+  enableExtraConsoleCommands(mod);
+  enableFastReset();
+  removeFadeIn();
+}

package/src/functions/doors.ts

@@ -21,6 +21,7 @@ import { ROOM_SHAPE_TO_DOOR_SLOTS } from "../objects/roomShapeToDoorSlots";
 import { arrayToBitFlags } from "./bitwise";
 import { directionToVector } from "./direction";
 import { getEnumValues } from "./enums";
+import { hasFlag } from "./flag";
 import { isTSTLSet } from "./tstlClass";
 import { asNumber } from "./types";
 
@@ -53,6 +54,21 @@ export function doorSlotFlagToDoorSlot(doorSlotFlag: DoorSlotFlag): DoorSlot {
   return doorSlot === undefined ? DEFAULT_DOOR_SLOT : doorSlot;
 }
 
+export function doorSlotFlagsToDoorSlots(
+  doorSlotFlags: BitFlags<DoorSlotFlag>,
+): DoorSlot[] {
+  const doorSlots: DoorSlot[] = [];
+
+  for (const doorSlotFlag of getEnumValues(DoorSlotFlag)) {
+    if (hasFlag(doorSlotFlags, doorSlotFlag)) {
+      const doorSlot = doorSlotFlagToDoorSlot(doorSlotFlag);
+      doorSlots.push(doorSlot);
+    }
+  }
+
+  return doorSlots;
+}
+
 export function doorSlotToDirection(doorSlot: DoorSlot): Direction {
   return DOOR_SLOT_TO_DIRECTION[doorSlot];
 }
@@ -61,6 +77,27 @@ export function doorSlotToDoorSlotFlag(doorSlot: DoorSlot): DoorSlotFlag {
   return DOOR_SLOT_TO_DOOR_SLOT_FLAG[doorSlot];
 }
 
+/**
+ * Helper function to convert an array of door slots or a set of door slots to the resulting bit
+ * flag number.
+ */
+export function doorSlotsToDoorSlotFlags(
+  doorSlots:
+    | DoorSlot[]
+    | readonly DoorSlot[]
+    | Set<DoorSlot>
+    | ReadonlySet<DoorSlot>,
+): BitFlags<DoorSlotFlag> {
+  const doorSlotArray = isTSTLSet(doorSlots)
+    ? [...doorSlots.values()]
+    : (doorSlots as DoorSlot[]);
+  const doorSlotFlagArray = doorSlotArray.map((doorSlot) =>
+    doorSlotToDoorSlotFlag(doorSlot),
+  );
+
+  return arrayToBitFlags(doorSlotFlagArray);
+}
+
 export function getAngelRoomDoor(): GridEntityDoor | undefined {
   const angelRoomDoors = getDoors(RoomType.ANGEL);
   return angelRoomDoors.length === 0 ? undefined : angelRoomDoors[0];
@@ -113,27 +150,6 @@ export function getDoorSlotEnterPositionOffset(
   return oppositeVector.mul(ROOM_ENTRY_OFFSET_FROM_DOOR);
 }
 
-/**
- * Helper function to convert an array of door slots or a set of door slots to the resulting bit
- * flag number.
- */
-export function getDoorSlotFlags(
-  doorSlots:
-    | DoorSlot[]
-    | readonly DoorSlot[]
-    | Set<DoorSlot>
-    | ReadonlySet<DoorSlot>,
-): BitFlags<DoorSlotFlag> {
-  const doorSlotArray = isTSTLSet(doorSlots)
-    ? [...doorSlots.values()]
-    : (doorSlots as DoorSlot[]);
-  const doorSlotFlagArray = doorSlotArray.map((doorSlot) =>
-    doorSlotToDoorSlotFlag(doorSlot),
-  );
-
-  return arrayToBitFlags(doorSlotFlagArray);
-}
-
 /** Helper function to get the possible door slots that can exist for a given room shape. */
 export function getDoorSlotsForRoomShape(
   roomShape: RoomShape,

package/src/functions/enums.ts

@@ -18,7 +18,7 @@ import { irange } from "./utils";
  * Also see the `getEnumKeys` and `getEnumValues` helper functions.
  *
  * For a more in depth explanation, see:
- * https://isaacscript.github.io/gotchas#iterating-over-enums
+ * https://isaacscript.github.io/main/gotchas#iterating-over-enums
  */
 export function getEnumEntries<T>(
   transpiledEnum: T,
@@ -57,7 +57,7 @@ export function getEnumEntries<T>(
  * Also see the `getEnumEntries` and `getEnumValues` helper functions.
  *
  * For a more in depth explanation, see:
- * https://isaacscript.github.io/gotchas#iterating-over-enums
+ * https://isaacscript.github.io/main/gotchas#iterating-over-enums
  */
 export function getEnumKeys<T>(transpiledEnum: T): string[] {
   const enumEntries = getEnumEntries(transpiledEnum);
@@ -84,7 +84,7 @@ export function getEnumLength<T>(transpiledEnum: T): int {
  * Also see the `getEnumEntries` and `getEnumKeys` helper functions.
  *
  * For a more in depth explanation, see:
- * https://isaacscript.github.io/gotchas#iterating-over-enums
+ * https://isaacscript.github.io/main/gotchas#iterating-over-enums
  */
 export function getEnumValues<T>(transpiledEnum: T): Array<T[keyof T]> {
   const enumEntries = getEnumEntries(transpiledEnum);

package/src/functions/playerStats.ts

@@ -21,5 +21,6 @@ export function getPlayerStat<T extends StatType>(
     [StatType.TEAR_COLOR]: player.TearColor, // 1 << 6
     [StatType.FLYING]: player.CanFly, // 1 << 7
     [StatType.LUCK]: player.Luck, // 1 << 10
+    [StatType.SIZE]: player.SpriteScale, // 1 << 11
   }[statType];
 }

package/src/functions/players.ts

@@ -21,7 +21,11 @@ import {
 import { getCollectibleMaxCharges } from "./collectibles";
 import { getCollectibleArray } from "./collectibleSet";
 import { getEnumValues } from "./enums";
-import { getPlayerIndexVanilla, getPlayers } from "./playerIndex";
+import {
+  getAllPlayers,
+  getPlayerIndexVanilla,
+  getPlayers,
+} from "./playerIndex";
 import { addTearsStat } from "./tears";
 import { isNumber } from "./types";
 import { repeat } from "./utils";
@@ -127,12 +131,12 @@ export function addTrinketCostume(
 export function anyPlayerHasCollectible(
   collectibleType: CollectibleType,
 ): boolean {
-  const players = getPlayers();
+  const players = getAllPlayers();
   return players.some((player) => player.HasCollectible(collectibleType));
 }
 
 export function anyPlayerHasTrinket(trinketType: TrinketType): boolean {
-  const players = getPlayers();
+  const players = getAllPlayers();
   return players.some((player) => player.HasTrinket(trinketType));
 }