isaacscript-common 6.10.2 → 6.11.2

package/src/callbacks/postPlayerInitFirst.ts

@@ -0,0 +1,57 @@
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { getPlayers, isChildPlayer } from "../functions/playerIndex";
+import { inGenesisRoom } from "../functions/rooms";
+import {
+  postPlayerInitFirstFire,
+  postPlayerInitFirstHasSubscriptions,
+} from "./subscriptions/postPlayerInitFirst";
+
+/** @internal */
+export function postPlayerInitFirstInit(mod: ModUpgraded): void {
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
+    postNewRoomReordered,
+  );
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PLAYER_INIT_LATE,
+    postPlayerInitLate,
+  );
+}
+
+function hasSubscriptions() {
+  return postPlayerInitFirstHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // When a player uses the Genesis collectible, they will lose all of their collectibles, trinkets,
+  // pocket items, and stats, so they will need to be re-initialized like they would be at the
+  // beginning of a run. However, in this case, the `POST_PLAYER_INIT_FIRST` callback will not fire,
+  // because that only fires once per run. Thus, we explicitly handle this special case.
+  if (!inGenesisRoom()) {
+    return;
+  }
+
+  for (const player of getPlayers()) {
+    postPlayerInitFirstFire(player);
+  }
+}
+
+// ModCallback.POST_PEFFECT_UPDATE (4)
+function postPlayerInitLate(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // We want to exclude non-real players like the Strawman keeper.
+  if (isChildPlayer(player)) {
+    return;
+  }
+
+  postPlayerInitFirstFire(player);
+}

package/src/callbacks/postPlayerInitLate.ts

@@ -1,4 +1,5 @@
-import { ModCallback } from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { saveDataManager } from "../features/saveDataManager/exports";
 import { setAddPlayer, setHasPlayer } from "../functions/playerDataStructures";
 import { PlayerIndex } from "../types/PlayerIndex";
@@ -14,18 +15,21 @@ const v = {
 };
 
 /** @internal */
-export function postPlayerInitLateInit(mod: Mod): void {
+export function postPlayerInitLateInit(mod: ModUpgraded): void {
   saveDataManager("postPlayerInitLate", v, hasSubscriptions);
 
-  mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
 }
 
 function hasSubscriptions() {
   return postPlayerInitLateHasSubscriptions();
 }
 
-// ModCallback.POST_PLAYER_UPDATE (31)
-function postPlayerUpdate(player: EntityPlayer) {
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
   if (!hasSubscriptions()) {
     return;
   }

package/src/callbacks/{postPlayerReordered.ts → postPlayerReorderedCallbacks.ts}

@@ -1,3 +1,8 @@
+// This handles logic for the following callbacks:
+// - POST_PEFFECT_UPDATE_REORDERED
+// - POST_PLAYER_RENDER_REORDERED
+// - POST_PLAYER_UPDATE_REORDERED
+
 import { ModCallback } from "isaac-typescript-definitions";
 import { saveDataManager } from "../features/saveDataManager/exports";
 import { emptyArray } from "../functions/array";
@@ -7,10 +12,6 @@ import {
   postPEffectUpdateReorderedFire,
   postPEffectUpdateReorderedHasSubscriptions,
 } from "./subscriptions/postPEffectUpdateReordered";
-import {
-  postPlayerInitReorderedFire,
-  postPlayerInitReorderedHasSubscriptions,
-} from "./subscriptions/postPlayerInitReordered";
 import {
   postPlayerRenderReorderedFire,
   postPlayerRenderReorderedHasSubscriptions,
@@ -24,7 +25,6 @@ const v = {
   run: {
     postGameStartedFiredOnThisRun: false,
 
-    postPlayerInitQueue: [] as PlayerIndex[],
     postPEffectUpdateQueue: [] as PlayerIndex[],
     postPlayerUpdateQueue: [] as PlayerIndex[],
     postPlayerRenderQueue: [] as PlayerIndex[],
@@ -36,16 +36,13 @@ export function postPlayerReorderedCallbacksInit(mod: Mod): void {
   saveDataManager("postPlayerReordered", v, hasSubscriptions);
 
   mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
-  mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit); // 9
+  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
   mod.AddCallback(ModCallback.POST_PLAYER_UPDATE, postPlayerUpdate); // 31
   mod.AddCallback(ModCallback.POST_PLAYER_RENDER, postPlayerRender); // 32
-
-  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
 }
 
 function hasSubscriptions() {
   return (
-    postPlayerInitReorderedHasSubscriptions() ||
     postPEffectUpdateReorderedHasSubscriptions() ||
     postPlayerUpdateReorderedHasSubscriptions() ||
     postPlayerRenderReorderedHasSubscriptions()
@@ -67,21 +64,6 @@ function postPEffectUpdate(player: EntityPlayer) {
   }
 }
 
-// ModCallback.POST_PLAYER_INIT (9)
-function postPlayerInit(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (v.run.postGameStartedFiredOnThisRun) {
-    postPlayerInitReorderedFire(player);
-  } else {
-    // Defer callback execution until the PostGameStarted callback fires.
-    const playerIndex = getPlayerIndex(player);
-    v.run.postPlayerInitQueue.push(playerIndex);
-  }
-}
-
 // ModCallback.POST_PLAYER_UPDATE (31)
 function postPlayerUpdate(player: EntityPlayer) {
   if (!hasSubscriptions()) {
@@ -120,7 +102,7 @@ function postGameStarted() {
 
   v.run.postGameStartedFiredOnThisRun = true;
 
-  dequeue(v.run.postPlayerInitQueue, postPlayerInitReorderedFire);
+  dequeue(v.run.postPEffectUpdateQueue, postPEffectUpdateReorderedFire);
   dequeue(v.run.postPlayerUpdateQueue, postPlayerUpdateReorderedFire);
   dequeue(v.run.postPlayerRenderQueue, postPlayerRenderReorderedFire);
 }
@@ -131,11 +113,9 @@ function dequeue(
 ) {
   for (const playerIndex of playerIndexes) {
     const player = getPlayerFromIndex(playerIndex);
-    if (player === undefined) {
-      continue;
+    if (player !== undefined) {
+      fireFunction(player);
     }
-
-    fireFunction(player);
   }
 
   emptyArray(playerIndexes);

package/src/callbacks/postSlotInitUpdate.ts

@@ -1,5 +1,8 @@
-// This provides the logic for the PostSlotInit and PostSlotUpdate callbacks. (The other slot
-// callbacks are handled in a different file.)
+// This provides the logic for the following callbacks:
+// - `POST_SLOT_INIT`
+// - `POST_SLOT_UPDATE`
+
+// (The other slot callbacks are handled in a different file.)
 
 import { ModCallback } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../classes/ModUpgraded";

package/src/callbacks/postSlotRender.ts

@@ -1,6 +1,6 @@
 // This provides the logic for the following callbacks:
-// - PostSlotRender
-// - PostSlotAnimationChanged
+// - `POST_SLOT_RENDER`
+// - `POST_SLOT_ANIMATION_CHANGED`
 
 import { ModCallback } from "isaac-typescript-definitions";
 import { DefaultMap } from "../classes/DefaultMap";

package/src/callbacks/reorderedCallbacks.ts

@@ -1,4 +1,4 @@
-// This provides the logic for:
+// This provides the logic for the following callbacks:
 // - `POST_GAME_STARTED_REORDERED`
 // - `POST_NEW_LEVEL_REORDERED`
 // - `POST_NEW_ROOM_REORDERED`

package/src/callbacks/subscriptions/postFirstFlip.ts

@@ -1,5 +1,5 @@
 export type PostFirstFlipRegisterParameters = [
-  callback: (player: EntityPlayer) => void,
+  callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void,
 ];
 
 const subscriptions: PostFirstFlipRegisterParameters[] = [];
@@ -17,8 +17,11 @@ export function postFirstFlipRegister(
 }
 
 /** @internal */
-export function postFirstFlipFire(player: EntityPlayer): void {
+export function postFirstFlipFire(
+  newLazarus: EntityPlayer,
+  oldLazarus: EntityPlayer,
+): void {
   for (const [callback] of subscriptions) {
-    callback(player);
+    callback(newLazarus, oldLazarus);
   }
 }

package/src/callbacks/subscriptions/postFlip.ts

@@ -1,5 +1,5 @@
 export type PostFlipRegisterParameters = [
-  callback: (player: EntityPlayer) => void,
+  callback: (newLazarus: EntityPlayer, oldLazarus: EntityPlayer) => void,
 ];
 
 const subscriptions: PostFlipRegisterParameters[] = [];
@@ -15,8 +15,11 @@ export function postFlipRegister(...args: PostFlipRegisterParameters): void {
 }
 
 /** @internal */
-export function postFlipFire(player: EntityPlayer): void {
+export function postFlipFire(
+  newLazarus: EntityPlayer,
+  oldLazarus: EntityPlayer,
+): void {
   for (const [callback] of subscriptions) {
-    callback(player);
+    callback(newLazarus, oldLazarus);
   }
 }

package/src/callbacks/subscriptions/{postPlayerInitReordered.ts → postPlayerInitFirst.ts}

@@ -1,27 +1,27 @@
 import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
 
-export type PostPlayerInitReorderedRegisterParameters = [
+export type PostPlayerInitFirstRegisterParameters = [
   callback: (player: EntityPlayer) => void,
   playerVariant?: PlayerVariant,
   character?: PlayerType,
 ];
 
-const subscriptions: PostPlayerInitReorderedRegisterParameters[] = [];
+const subscriptions: PostPlayerInitFirstRegisterParameters[] = [];
 
 /** @internal */
-export function postPlayerInitReorderedHasSubscriptions(): boolean {
+export function postPlayerInitFirstHasSubscriptions(): boolean {
   return subscriptions.length > 0;
 }
 
 /** @internal */
-export function postPlayerInitReorderedRegister(
-  ...args: PostPlayerInitReorderedRegisterParameters
+export function postPlayerInitFirstRegister(
+  ...args: PostPlayerInitFirstRegisterParameters
 ): void {
   subscriptions.push(args);
 }
 
 /** @internal */
-export function postPlayerInitReorderedFire(player: EntityPlayer): void {
+export function postPlayerInitFirstFire(player: EntityPlayer): void {
   const character = player.GetPlayerType();
 
   for (const [callback, playerVariant, callbackCharacter] of subscriptions) {

package/src/enums/ModCallbackCustom.ts

@@ -295,7 +295,7 @@ export enum ModCallbackCustom {
    * before the player has actually used the Flip item.
    *
    * ```ts
-   * function postFirstFlip(player: EntityPlayer): void {}
+   * function postFirstFlip(newLazarus: EntityPlayer, oldLazarus: EntityPlayer): void {}
    * ```
    */
   POST_FIRST_FLIP,
@@ -309,7 +309,7 @@ export enum ModCallbackCustom {
    * before the player has actually used the Flip item.
    *
    * ```ts
-   * function postFlip(player: EntityPlayer): void {}
+   * function postFlip(newLazarus: EntityPlayer, oldLazarus: EntityPlayer): void {}
    * ```
    */
   POST_FLIP,
@@ -825,10 +825,15 @@ export enum ModCallbackCustom {
   POST_PLAYER_FATAL_DAMAGE,
 
   /**
-   * Fires on the first `POST_PLAYER_UPDATE` frame for each player.
+   * Fires on the first `POST_PEFFECT_UPDATE_REORDERED` frame for each player, similar to the
+   * `POST_PLAYER_INIT_LATE` callback, with two changes:
    *
-   * This callback is useful because many attributes cannot be set or retrieved properly in the
-   * normal `POST_PLAYER_INIT` callback.
+   * - This will not fire for "child" players (e.g. non-real players like the Strawman Keeper).
+   * - This will fire when the player enters a Genesis room and all of their items are taken away.
+   *
+   * You should use this callback for any player-related initialization logic, like giving the
+   * character their starting items for the run. (You do not want to use the vanilla
+   * `POST_PLAYER_INIT` callback for this because it fires when a run is continued.)
    *
    * - When registering the callback, takes an optional second argument that will make the callback
    *   only fire if the player matches the `PlayerVariant` provided.
@@ -836,22 +841,19 @@ export enum ModCallbackCustom {
    *   only fire if the player matches the `PlayerType` provided.
    *
    * ```ts
-   * function postPlayerInitLate(pickup: EntityPickup): void {}
+   * function postPlayerInitFirst(player: EntityPlayer): void {}
    * ```
    */
-  POST_PLAYER_INIT_LATE,
+  POST_PLAYER_INIT_FIRST,
 
   /**
-   * Similar to the vanilla callback of the same name, but fires after the `POST_GAME_STARTED`
-   * callback fires (if the player is spawning on the 0th game frame of the run).
+   * Fires on the first `POST_PEFFECT_UPDATE_REORDERED` frame for each player.
    *
-   * This callback is useful for two reasons:
+   * This callback is useful because many attributes cannot be set or retrieved properly in the
+   * normal `POST_PLAYER_INIT` callback.
    *
-   * 1. Normally, `POST_PLAYER_INIT` fires before `POST_GAME_STARTED`. Since mod variables are often
-   *    initialized at the beginning of the `POST_GAME_STARTED` callback, this can cause problems.
-   * 1. Some functions do not work (or crash the game) when called before the `POST_NEW_ROOM`
-   *    callback. For example, since the level is not generated yet, you will not be able to access
-   *    any rooms.
+   * For initializing a player with custom items and so forth, use the `POST_PLAYER_INIT_FIRST`
+   * callback instead to handle the case of a Genesis room.
    *
    * - When registering the callback, takes an optional second argument that will make the callback
    *   only fire if the player matches the `PlayerVariant` provided.
@@ -859,10 +861,10 @@ export enum ModCallbackCustom {
    *   only fire if the player matches the `PlayerType` provided.
    *
    * ```ts
-   * function postPlayerInitReordered(player: EntityPlayer): void {}
+   * function postPlayerInitLate(pickup: EntityPickup): void {}
    * ```
    */
-  POST_PLAYER_INIT_REORDERED,
+  POST_PLAYER_INIT_LATE,
 
   /**
    * Similar to the vanilla callback of the same name, but fires after the `POST_GAME_STARTED`

package/src/enums/private/StageTravelState.ts

@@ -0,0 +1,8 @@
+export enum StageTravelState {
+  NONE,
+  PLAYERS_JUMPING_DOWN,
+  PIXELATION_TO_BLACK,
+  PAUSING_ON_BLACK,
+  PIXELATION_TO_ROOM,
+  PLAYERS_LAYING_DOWN,
+}

package/src/enums/private/TrapdoorAnimation.ts

@@ -0,0 +1,5 @@
+export enum TrapdoorAnimation {
+  OPENED = "Opened",
+  CLOSED = "Closed",
+  OPEN_ANIMATION = "Open Animation",
+}

package/src/features/customGridEntity.ts

@@ -1,6 +1,10 @@
 import {
+  ActiveSlot,
+  CollectibleType,
   GridCollisionClass,
   GridEntityType,
+  ModCallback,
+  UseFlag,
 } from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { DefaultMap } from "../classes/DefaultMap";
@@ -15,6 +19,7 @@ import {
 import { getRoomListIndex } from "../functions/roomData";
 import { isVector } from "../functions/vector";
 import { CustomGridEntityData } from "../interfaces/CustomGridEntityData";
+import { runNextGameFrame } from "./runInNFrames";
 import { saveDataManager } from "./saveDataManager/exports";
 
 const FEATURE_NAME = "customGridEntity";
@@ -26,18 +31,83 @@ const v = {
       () => new Map(),
     ),
   },
+
+  room: {
+    manuallyUsingShovel: false,
+  },
 };
 
 /** @internal */
 export function customGridEntityInit(mod: ModUpgraded): void {
   saveDataManager(FEATURE_NAME, v);
 
+  mod.AddCallback(
+    ModCallback.PRE_USE_ITEM,
+    preUseItemWeNeedToGoDeeper,
+    CollectibleType.WE_NEED_TO_GO_DEEPER,
+  ); // 23
+
   mod.AddCallbackCustom(
     ModCallbackCustom.POST_NEW_ROOM_REORDERED,
     postNewRoomReordered,
   );
 }
 
+// ModCallback.PRE_USE_ITEM (23)
+// CollectibleType.WE_NEED_TO_GO_DEEPER (84)
+function preUseItemWeNeedToGoDeeper(
+  _collectibleType: CollectibleType,
+  _rng: RNG,
+  player: EntityPlayer,
+  _useFlags: BitFlags<UseFlag>,
+  _activeSlot: ActiveSlot,
+  _customVarData: int,
+): boolean | undefined {
+  // If a player uses We Need to Go Deeper on top of a custom grid entity, then they will always get
+  // a crawlspace, due to how custom grids are implemented with decorations. Thus, remove the custom
+  // grid entity to prevent this from happening if needed.
+  const room = game.GetRoom();
+  const roomListIndex = getRoomListIndex();
+  const roomCustomGridEntities = v.level.customGridEntities.get(roomListIndex);
+  if (roomCustomGridEntities === undefined) {
+    return undefined;
+  }
+
+  const gridIndex = room.GetGridIndex(player.Position);
+  const customGridEntity = roomCustomGridEntities.get(gridIndex);
+  if (customGridEntity === undefined) {
+    return undefined;
+  }
+
+  // If the custom grid entity has collision, then the player should not be able to be standing on
+  // top of it.
+  if (customGridEntity.gridCollisionClass !== GridCollisionClass.NONE) {
+    return undefined;
+  }
+
+  removeGridEntity(customGridEntity.gridIndex, false);
+
+  const playerPtr = EntityPtr(player);
+  runNextGameFrame(() => {
+    const futureEntity = playerPtr.Ref;
+    if (futureEntity === undefined) {
+      return;
+    }
+
+    const futurePlayer = futureEntity.ToPlayer();
+    if (futurePlayer === undefined) {
+      return;
+    }
+
+    v.room.manuallyUsingShovel = true;
+    futurePlayer.UseActiveItem(CollectibleType.WE_NEED_TO_GO_DEEPER);
+    v.room.manuallyUsingShovel = false;
+  });
+
+  // Cancel the original effect.
+  return true;
+}
+
 // ModCallbackCustom.POST_NEW_ROOM_REORDERED
 function postNewRoomReordered() {
   // When we re-enter a room, the graphics for any custom entities will be reverted back to that of
@@ -57,13 +127,19 @@ function postNewRoomReordered() {
     }
 
     const sprite = decoration.GetSprite();
-    sprite.Load(data.anm2, true);
-    sprite.Play(data.defaultAnimation, true);
+    sprite.Load(data.anm2Path, true);
+    const animationToPlay =
+      data.defaultAnimation === undefined
+        ? sprite.GetDefaultAnimation()
+        : data.defaultAnimation;
+    sprite.Play(animationToPlay, true);
   }
 }
 
 /**
- * Helper function to spawn a custom grid entity.
+ * Helper function to spawn a custom grid entity. Custom grid entities are persistent in that they
+ * will reappear if the player leaves and re-enters the room. (It will be manually respawned in the
+ * `POST_NEW_ROOM` callback.)
  *
  * This is an IsaacScript feature because the vanilla game does not support any custom grid
  * entities. Under the hood, IsaacScript accomplishes this by using decorations with an arbitrary
@@ -80,17 +156,18 @@ function postNewRoomReordered() {
  * @param gridIndexOrPosition The grid index or position in the room that you want to spawn the grid
  *                            entity at. If a position is specified, the closest grid index will be
  *                            used.
- * @param anm2 The path to the ANM2 file to use for the sprite.
- * @param defaultAnimation The name of the animation to play after the sprite is initialized and
- *                         after the player re-enters a room with this grid entity in it.
  * @param gridCollisionClass The collision class that you want the custom grid entity to have.
+ * @param anm2Path The path to the ANM2 file to use for the sprite.
+ * @param defaultAnimation Optional. The name of the animation to play after the sprite is
+ *                         initialized and after the player re-enters a room with this grid entity
+ *                         in it. If not specified, the default animation in the anm2 will be used.
  */
-export function spawnCustomGrid(
+export function spawnCustomGridEntity(
   gridEntityTypeCustom: GridEntityType,
   gridIndexOrPosition: int | Vector,
-  anm2: string,
-  defaultAnimation: string,
   gridCollisionClass: GridCollisionClass,
+  anm2Path: string,
+  defaultAnimation?: string,
 ): GridEntity {
   errorIfFeaturesNotInitialized(FEATURE_NAME);
 
@@ -118,14 +195,18 @@ export function spawnCustomGrid(
   }
 
   const sprite = decoration.GetSprite();
-  sprite.Load(anm2, true);
-  sprite.Play(defaultAnimation, true);
+  sprite.Load(anm2Path, true);
+  const animationToPlay =
+    defaultAnimation === undefined
+      ? sprite.GetDefaultAnimation()
+      : defaultAnimation;
+  sprite.Play(animationToPlay, true);
 
   const customGridEntityData: CustomGridEntityData = {
     gridEntityTypeCustom,
     roomListIndex,
     gridIndex,
-    anm2,
+    anm2Path,
     defaultAnimation,
     gridCollisionClass,
   };

package/src/features/customStage/exports.ts

@@ -1,10 +1,8 @@
 import {
-  Direction,
   EntityType,
   GridRoom,
   LevelStage,
   RoomShape,
-  RoomTransitionAnim,
   RoomType,
   StageType,
 } from "isaac-typescript-definitions";
@@ -12,12 +10,10 @@ import { game } from "../../cachedClasses";
 import { reorderedCallbacksSetStage } from "../../callbacks/reorderedCallbacks";
 import { getEntityIDFromConstituents } from "../../functions/entities";
 import { log, logError } from "../../functions/log";
-import { movePlayersToCenter } from "../../functions/playerCenter";
 import { newRNG } from "../../functions/rng";
 import { getRoomData } from "../../functions/roomData";
 import { getRooms } from "../../functions/rooms";
 import { getGotoCommand, setStage } from "../../functions/stage";
-import { runNextRoom } from "../runNextRoom";
 import { getRandomCustomStageRoom } from "./customStageUtils";
 import { topStreakTextStart } from "./streakText";
 import v, {
@@ -136,24 +132,9 @@ export function setCustomStage(name: string, verbose = false): void {
 
   // We must reload the current room in order for the `Level.SetStage` method to take effect.
   // Furthermore, we need to cancel the queued warp to the `GridRoom.DEBUG` room. We can accomplish
-  // both of these things by initiating a room transition to the starting room of the floor. (We
-  // assume that since we just warped to a new floor, we are already in the starting room.)
-  game.StartRoomTransition(
-    startingRoomGridIndex,
-    Direction.NO_DIRECTION,
-    RoomTransitionAnim.FADE,
-  );
-
-  // We do more setup once the room is reloaded from the transition.
-  runNextRoom(postRoomTransition);
-}
-
-function postRoomTransition() {
-  // After the room transition, the players will be placed next to a door, but they should be in the
-  // center of the room to emulate what happens on a vanilla stage.
-  movePlayersToCenter();
-
-  topStreakTextStart();
+  // both of these things by initiating a room transition to an arbitrary room. However, we rely on
+  // the parent function to do this, since for normal purposes, we need to initiate a room
+  // transition for pixelation purposes.
 }
 
 export function setCustomStageDebug(): void {

package/src/features/customStage/init.ts

@@ -1,6 +1,7 @@
 import {
   DoorSlotFlag,
   GridEntityType,
+  LevelCurse,
   ModCallback,
   RoomShape,
   RoomType,
@@ -8,6 +9,7 @@ import {
 import { ModUpgraded } from "../../classes/ModUpgraded";
 import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
 import { isArray } from "../../functions/array";
+import { hasFlag, removeFlag } from "../../functions/flag";
 import { CustomStage, RoomTypeMap } from "../../interfaces/CustomStage";
 import {
   CustomStageLua,
@@ -26,20 +28,30 @@ import * as metadataJSON from "./metadata.json"; // This will correspond to "met
 import { setShadows } from "./shadows";
 import {
   streakTextGetShaderParams,
+  streakTextInit,
   streakTextPostGameStarted,
   streakTextPostRender,
 } from "./streakText";
 import v, { customStagesMap } from "./v";
 import {
   playVersusScreenAnimation,
+  versusScreenInit,
   versusScreenPostRender,
 } from "./versusScreen";
 
 export function customStageInit(mod: ModUpgraded): void {
-  saveDataManager("customStage", v);
   initRoomTypeMaps();
+  if (customStagesMap.size === 0) {
+    // If the end-user has no custom stages, we don't have to initialize any of the callbacks.
+    return;
+  }
+
+  saveDataManager("customStage", v);
+  streakTextInit();
+  versusScreenInit();
 
   mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+  mod.AddCallback(ModCallback.POST_CURSE_EVAL, postCurseEval); // 12
   mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
   mod.AddCallback(ModCallback.GET_SHADER_PARAMS, getShaderParams); // 21
   mod.AddCallbackCustom(
@@ -128,6 +140,23 @@ function postRender() {
   versusScreenPostRender();
 }
 
+// ModCallback.POST_CURSE_EVAL (12)
+function postCurseEval(
+  curses: BitFlags<LevelCurse>,
+): BitFlags<LevelCurse> | undefined {
+  const customStage = v.run.currentCustomStage;
+  if (customStage === null) {
+    return undefined;
+  }
+
+  // Prevent XL floors on custom stages, since the streak text will not work properly.
+  if (hasFlag(curses, LevelCurse.MAZE)) {
+    return removeFlag(curses, LevelCurse.MAZE);
+  }
+
+  return undefined;
+}
+
 // ModCallback.POST_GAME_STARTED (15)
 function postGameStarted() {
   // We don't early return here because we need to unconditionally reset the sprites.