isaacscript-common 84.0.0 → 84.1.0

package/dist/classes/features/other/customStages/streakText.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topStreakTextStart = exports.streakTextGetShaderParams = exports.streakTextPostRender = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedEnumValues_1 = require("../../../../arrays/cachedEnumValues");
+const cachedClasses_1 = require("../../../../core/cachedClasses");
+const constants_1 = require("../../../../core/constants");
+const UIStreakAnimation_1 = require("../../../../enums/private/UIStreakAnimation");
+const frames_1 = require("../../../../functions/frames");
+const ui_1 = require("../../../../functions/ui");
+const v_1 = require("./v");
+/** Corresponds to "resources/gfx/ui/ui_streak.anm2". */
+const UI_STREAK_ANIMATION_END_FRAMES = {
+    [UIStreakAnimation_1.UIStreakAnimation.NONE]: 0,
+    [UIStreakAnimation_1.UIStreakAnimation.TEXT]: 69,
+    [UIStreakAnimation_1.UIStreakAnimation.TEXT_STAY]: 1,
+};
+/** This must match the name of the shader in "shaders.xml". */
+const EMPTY_SHADER_NAME = "IsaacScript-RenderAboveHUD";
+/**
+ * The frame of the "Text" animation that corresponds to when it reaches the center of the screen
+ * and stays put.
+ */
+const TEXT_STAY_FRAME = 8;
+/** The frame of the "Text" animation that corresponds to when it starts to move right. */
+const TEXT_OUT_FRAME = 60;
+/** This matches the offset that the vanilla game uses; determined via trial and error. */
+const STREAK_SPRITE_TOP_OFFSET = Vector(0, 47);
+/** This matches the offset that the vanilla game uses; determined via trial and error. */
+const STREAK_SPRITE_BOTTOM_OFFSET = Vector(0, -48.25);
+/**
+ * The offset from the bottom of the sprite that the rendered text should go; determined via trial
+ * and error.
+ */
+const STREAK_TEXT_BOTTOM_Y_OFFSET = -9;
+/**
+ * Corresponds to the vanilla value; determined via trial and error.
+ *
+ * 8 is too little and 9 has the vanilla text come out just slightly ahead, so we go with 9.
+ */
+const NUM_RENDER_FRAMES_MAP_HELD_BEFORE_STREAK_TEXT = 11;
+/** Taken from StageAPI. */
+const TEXT_IN_ADJUSTMENTS = [-800, -639, -450, -250, -70, 10, 6, 3];
+/** Taken from StageAPI. */
+const TEXT_OUT_ADJUSTMENTS = [
+    0, -5, -10, -15, -20, 144, 308, 472, 636, 800,
+];
+/** Taken from StageAPI. */
+const TEXT_IN_SCALES = [
+    Vector(3, 0.2),
+    Vector(2.6, 0.36),
+    Vector(2.2, 0.52),
+    Vector(1.8, 0.68),
+    Vector(1.4, 0.84),
+    Vector(0.95, 1.05),
+    Vector(0.97, 1.03),
+    Vector(0.98, 1.02),
+];
+/** Taken from StageAPI. */
+const TEXT_OUT_SCALES = [
+    Vector(1, 1),
+    Vector(0.99, 1.03),
+    Vector(0.98, 1.05),
+    Vector(0.96, 1.08),
+    Vector(0.95, 1.1),
+    Vector(1.36, 0.92),
+    Vector(1.77, 0.74),
+    Vector(2.18, 0.56),
+    Vector(2.59, 0.38),
+    Vector(3, 0.2),
+];
+// ModCallback.POST_RENDER (2)
+function streakTextPostRender() {
+    // The top streak only plays when the player arrives on the floor (or continues a game from the
+    // main menu.)
+    checkEndTopStreakText();
+    // The bottom streak only plays when the player holds down the map button.
+    trackMapInputPressed();
+    checkStartBottomStreakText();
+    checkEndBottomStreakText();
+}
+exports.streakTextPostRender = streakTextPostRender;
+function checkEndTopStreakText() {
+    if (v_1.v.run.topStreakTextStartedRenderFrame === null ||
+        v_1.v.run.topStreakText.animation !== UIStreakAnimation_1.UIStreakAnimation.TEXT_STAY) {
+        return;
+    }
+    const elapsedFrames = (0, frames_1.getElapsedRenderFramesSince)(v_1.v.run.topStreakTextStartedRenderFrame);
+    if (elapsedFrames >= 115) {
+        v_1.v.run.topStreakText.animation = UIStreakAnimation_1.UIStreakAnimation.TEXT;
+        // We adjust by the frame backwards by an arbitrary amount to roughly align with the speed of
+        // the vanilla animation.
+        v_1.v.run.topStreakText.frame = TEXT_OUT_FRAME - 2;
+    }
+}
+function trackMapInputPressed() {
+    const gameFrameCount = cachedClasses_1.game.GetFrameCount();
+    for (const controllerIndex of cachedEnumValues_1.CONTROLLER_INDEX_VALUES) {
+        const oldPushedMapFrame = v_1.v.run.controllerIndexPushingMapRenderFrame.get(controllerIndex);
+        const isPushingMap = Input.IsActionPressed(isaac_typescript_definitions_1.ButtonAction.MAP, controllerIndex);
+        if (isPushingMap) {
+            if (oldPushedMapFrame === undefined) {
+                v_1.v.run.controllerIndexPushingMapRenderFrame.set(controllerIndex, gameFrameCount);
+            }
+        }
+        else {
+            v_1.v.run.controllerIndexPushingMapRenderFrame.delete(controllerIndex);
+        }
+    }
+}
+/**
+ * If the map input has been pressed down for long enough, play the animation where the level streak
+ * slides in from the left.
+ */
+function checkStartBottomStreakText() {
+    if (v_1.v.run.bottomStreakText.animation !== UIStreakAnimation_1.UIStreakAnimation.NONE) {
+        return;
+    }
+    const pushedMapFrames = [
+        ...v_1.v.run.controllerIndexPushingMapRenderFrame.values(),
+    ];
+    if (pushedMapFrames.length === 0) {
+        return;
+    }
+    const earliestFrame = Math.min(...pushedMapFrames);
+    const elapsedFrames = (0, frames_1.getElapsedGameFramesSince)(earliestFrame);
+    if (elapsedFrames >= NUM_RENDER_FRAMES_MAP_HELD_BEFORE_STREAK_TEXT) {
+        v_1.v.run.bottomStreakText.animation = UIStreakAnimation_1.UIStreakAnimation.TEXT;
+        v_1.v.run.bottomStreakText.frame = 0;
+    }
+}
+/**
+ * If the map input has been released, play the animation where the level streak slides out to the
+ * right.
+ */
+function checkEndBottomStreakText() {
+    if (v_1.v.run.bottomStreakText.animation !== UIStreakAnimation_1.UIStreakAnimation.TEXT_STAY) {
+        return;
+    }
+    const pushedMapFrames = [
+        ...v_1.v.run.controllerIndexPushingMapRenderFrame.values(),
+    ];
+    if (pushedMapFrames.length === 0) {
+        v_1.v.run.bottomStreakText.animation = UIStreakAnimation_1.UIStreakAnimation.TEXT;
+        // We adjust by the frame backwards by an arbitrary amount to roughly align with the speed of
+        // the vanilla animation.
+        v_1.v.run.bottomStreakText.frame = TEXT_OUT_FRAME - 2;
+    }
+}
+// ModCallback.GET_SHADER_PARAMS (22)
+function streakTextGetShaderParams(customStage, shaderName) {
+    if (shaderName !== EMPTY_SHADER_NAME) {
+        return;
+    }
+    const topCenterPos = (0, ui_1.getScreenTopCenterPos)();
+    const topStreakPosition = topCenterPos.add(STREAK_SPRITE_TOP_OFFSET);
+    renderStreakText(customStage, v_1.v.run.topStreakText, topStreakPosition);
+    const bottomCenterPos = (0, ui_1.getScreenBottomCenterPos)();
+    const bottomStreakPosition = bottomCenterPos.add(STREAK_SPRITE_BOTTOM_OFFSET);
+    renderStreakText(customStage, v_1.v.run.bottomStreakText, bottomStreakPosition);
+}
+exports.streakTextGetShaderParams = streakTextGetShaderParams;
+function renderStreakText(customStage, streakText, position) {
+    if (streakText.animation === UIStreakAnimation_1.UIStreakAnimation.NONE) {
+        return;
+    }
+    if (streakText.animation !== UIStreakAnimation_1.UIStreakAnimation.TEXT_STAY) {
+        const { pauseFrame } = streakText;
+        streakText.pauseFrame = !streakText.pauseFrame;
+        if (!pauseFrame) {
+            streakText.frame++;
+        }
+    }
+    const endFrame = UI_STREAK_ANIMATION_END_FRAMES[streakText.animation];
+    if (streakText.frame > endFrame) {
+        streakText.animation = UIStreakAnimation_1.UIStreakAnimation.NONE;
+        streakText.frame = 0;
+        return;
+    }
+    if (streakText.animation === UIStreakAnimation_1.UIStreakAnimation.TEXT &&
+        streakText.frame === TEXT_STAY_FRAME) {
+        streakText.animation = UIStreakAnimation_1.UIStreakAnimation.TEXT_STAY;
+        streakText.frame = 0;
+    }
+    const isPaused = cachedClasses_1.game.IsPaused();
+    if (isPaused) {
+        return;
+    }
+    const font = cachedClasses_1.fonts.upheaval;
+    const { name } = customStage;
+    const numberSuffix = v_1.v.run.firstFloor ? "I" : "II";
+    const nameWithNumberSuffix = `${name} ${numberSuffix}`;
+    const length = font.GetStringWidthUTF8(nameWithNumberSuffix);
+    const centeredX = position.X - length / 2;
+    let adjustment = 0;
+    let scale = constants_1.VectorOne;
+    if (streakText.animation === UIStreakAnimation_1.UIStreakAnimation.TEXT) {
+        if (streakText.frame < TEXT_STAY_FRAME) {
+            adjustment = TEXT_IN_ADJUSTMENTS[streakText.frame] ?? 0;
+            scale = TEXT_IN_SCALES[streakText.frame] ?? constants_1.VectorOne;
+        }
+        else {
+            const adjustedFrame = streakText.frame - TEXT_OUT_FRAME;
+            adjustment = TEXT_OUT_ADJUSTMENTS[adjustedFrame] ?? 0;
+            scale = TEXT_OUT_SCALES[adjustedFrame] ?? constants_1.VectorOne;
+        }
+    }
+    const adjustedX = centeredX + adjustment;
+    const adjustedY = position.Y + STREAK_TEXT_BOTTOM_Y_OFFSET;
+    font.DrawStringScaled(nameWithNumberSuffix, adjustedX, adjustedY, scale.X, scale.Y, constants_1.KColorDefault);
+}
+function topStreakTextStart() {
+    const level = cachedClasses_1.game.GetLevel();
+    const renderFrameCount = Isaac.GetFrameCount();
+    // Show the vanilla streak text, which will have a blank name because of the -1 floor.
+    level.ShowName(false);
+    // Initiate the animation for the custom text.
+    v_1.v.run.topStreakText.animation = UIStreakAnimation_1.UIStreakAnimation.TEXT;
+    v_1.v.run.topStreakText.frame = 0;
+    v_1.v.run.topStreakTextStartedRenderFrame = renderFrameCount;
+}
+exports.topStreakTextStart = topStreakTextStart;

package/dist/classes/features/other/customStages/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomBossRoomFromPool = exports.getRandomCustomStageRoom = void 0;
+const array_1 = require("../../../../functions/array");
+const log_1 = require("../../../../functions/log");
+const random_1 = require("../../../../functions/random");
+/**
+ * Helper function to get a random custom stage room from an array of custom stage rooms.
+ *
+ * Note that this function does not simply choose a random element in the provided array; it will
+ * properly account for each room weight using the algorithm from:
+ * https://stackoverflow.com/questions/1761626/weighted-random-numbers
+ */
+function getRandomCustomStageRoom(roomsMetadata, seedOrRNG, verbose = false) {
+    const totalWeight = getTotalWeightOfCustomStageRooms(roomsMetadata);
+    if (verbose) {
+        (0, log_1.log)(`Total weight of the custom stage rooms provided: ${totalWeight}`);
+    }
+    const chosenWeight = (0, random_1.getRandomFloat)(0, totalWeight, seedOrRNG);
+    if (verbose) {
+        (0, log_1.log)(`Randomly chose weight for custom stage room: ${chosenWeight}`);
+    }
+    return getCustomStageRoomWithChosenWeight(roomsMetadata, chosenWeight);
+}
+exports.getRandomCustomStageRoom = getRandomCustomStageRoom;
+function getTotalWeightOfCustomStageRooms(roomsMetadata) {
+    const weights = roomsMetadata.map((roomMetadata) => roomMetadata.weight);
+    return (0, array_1.sumArray)(weights);
+}
+function getCustomStageRoomWithChosenWeight(roomsMetadata, chosenWeight) {
+    for (const roomMetadata of roomsMetadata) {
+        if (chosenWeight < roomMetadata.weight) {
+            return roomMetadata;
+        }
+        chosenWeight -= roomMetadata.weight;
+    }
+    error(`Failed to get a custom stage room with chosen weight: ${chosenWeight}`);
+}
+function getRandomBossRoomFromPool(roomsMetadata, bossPool, seedOrRNG, verbose = false) {
+    const totalWeight = getTotalWeightOfBossPool(bossPool);
+    if (verbose) {
+        (0, log_1.log)(`Total weight of the custom stage boss pool provided: ${totalWeight}`);
+    }
+    const chosenWeight = (0, random_1.getRandomFloat)(0, totalWeight, seedOrRNG);
+    if (verbose) {
+        (0, log_1.log)(`Randomly chose weight for custom stage boss pool: ${chosenWeight}`);
+    }
+    const bossEntry = getBossEntryWithChosenWeight(bossPool, chosenWeight);
+    const roomsMetadataForBoss = roomsMetadata.filter((roomMetadata) => roomMetadata.subType === bossEntry.subType);
+    return getRandomCustomStageRoom(roomsMetadataForBoss, seedOrRNG, verbose);
+}
+exports.getRandomBossRoomFromPool = getRandomBossRoomFromPool;
+function getTotalWeightOfBossPool(bossPool) {
+    const weights = bossPool.map((bossEntry) => bossEntry.weight);
+    return (0, array_1.sumArray)(weights);
+}
+function getBossEntryWithChosenWeight(bossPool, chosenWeight) {
+    for (const bossEntry of bossPool) {
+        if (chosenWeight < bossEntry.weight) {
+            return bossEntry;
+        }
+        chosenWeight -= bossEntry.weight;
+    }
+    error(`Failed to get a custom stage boss entry with chosen weight: ${chosenWeight}`);
+}

package/dist/classes/features/other/customStages/v.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v = void 0;
+const UIStreakAnimation_1 = require("../../../../enums/private/UIStreakAnimation");
+// This is registered in "CustomStages.ts".
+// eslint-disable-next-line isaacscript/require-v-registration
+exports.v = {
+    run: {
+        currentCustomStage: null,
+        /** Whether we are on e.g. Caves 1 or Caves 2. */
+        firstFloor: true,
+        showingBossVersusScreen: false,
+        /** Values are the render frame that the controller first pressed the map button. */
+        controllerIndexPushingMapRenderFrame: new Map(),
+        topStreakTextStartedRenderFrame: null,
+        topStreakText: {
+            animation: UIStreakAnimation_1.UIStreakAnimation.NONE,
+            frame: 0,
+            pauseFrame: false,
+        },
+        bottomStreakText: {
+            animation: UIStreakAnimation_1.UIStreakAnimation.NONE,
+            frame: 0,
+            pauseFrame: false,
+        },
+    },
+};

package/dist/classes/features/other/customStages/versusScreen.js

@@ -0,0 +1,227 @@
+"use strict";
+// This emulates the vanilla versus screen that shows up when you enter a boss room.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versusScreenPostRender = exports.playVersusScreenAnimation = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const cachedClasses_1 = require("../../../../core/cachedClasses");
+const array_1 = require("../../../../functions/array");
+const bosses_1 = require("../../../../functions/bosses");
+const roomData_1 = require("../../../../functions/roomData");
+const string_1 = require("../../../../functions/string");
+const ui_1 = require("../../../../functions/ui");
+const utils_1 = require("../../../../functions/utils");
+const versusScreen_1 = require("../../../../functions/versusScreen");
+const versusScreenBackgroundColors_1 = require("../../../../objects/versusScreenBackgroundColors");
+const versusScreenDirtSpotColors_1 = require("../../../../objects/versusScreenDirtSpotColors");
+const constants_1 = require("./constants");
+const v_1 = require("./v");
+const DEFAULT_STAGE_ID = isaac_typescript_definitions_1.StageID.BASEMENT;
+const VERSUS_SCREEN_ANIMATION_NAME = "Scene";
+/** The layers range from 0 to 13. */
+const NUM_VERSUS_SCREEN_ANM2_LAYERS = 14;
+/** Corresponds to "resources/gfx/ui/boss/versusscreen.anm2". */
+var VersusScreenLayer;
+(function (VersusScreenLayer) {
+    VersusScreenLayer[VersusScreenLayer["BACKGROUND"] = 0] = "BACKGROUND";
+    VersusScreenLayer[VersusScreenLayer["FRAME"] = 1] = "FRAME";
+    /** The boss dirt spot. */
+    VersusScreenLayer[VersusScreenLayer["BOSS_SPOT"] = 2] = "BOSS_SPOT";
+    /** The player dirt spot. */
+    VersusScreenLayer[VersusScreenLayer["PLAYER_SPOT"] = 3] = "PLAYER_SPOT";
+    VersusScreenLayer[VersusScreenLayer["BOSS_PORTRAIT"] = 4] = "BOSS_PORTRAIT";
+    VersusScreenLayer[VersusScreenLayer["PLAYER_PORTRAIT"] = 5] = "PLAYER_PORTRAIT";
+    VersusScreenLayer[VersusScreenLayer["PLAYER_NAME"] = 6] = "PLAYER_NAME";
+    VersusScreenLayer[VersusScreenLayer["BOSS_NAME"] = 7] = "BOSS_NAME";
+    VersusScreenLayer[VersusScreenLayer["VS_TEXT"] = 8] = "VS_TEXT";
+    VersusScreenLayer[VersusScreenLayer["BOSS_DOUBLE"] = 9] = "BOSS_DOUBLE";
+    VersusScreenLayer[VersusScreenLayer["DT_TEXT"] = 10] = "DT_TEXT";
+    VersusScreenLayer[VersusScreenLayer["OVERLAY"] = 11] = "OVERLAY";
+    /**
+     * We only need to render either the normal player portrait layer or the alternate player portrait
+     * layer. Rendering both will cause the player not to shake.
+     */
+    VersusScreenLayer[VersusScreenLayer["PLAYER_PORTRAIT_ALT"] = 12] = "PLAYER_PORTRAIT_ALT";
+    VersusScreenLayer[VersusScreenLayer["BOSS_PORTRAIT_GROUND"] = 13] = "BOSS_PORTRAIT_GROUND";
+    VersusScreenLayer[VersusScreenLayer["BOSS_PORTRAIT_2_GROUND"] = 14] = "BOSS_PORTRAIT_2_GROUND";
+})(VersusScreenLayer || (VersusScreenLayer = {}));
+/** These are the non-special layers that we will render last. */
+const OTHER_ANM2_LAYERS = (0, array_1.arrayRemove)((0, utils_1.eRange)(NUM_VERSUS_SCREEN_ANM2_LAYERS), VersusScreenLayer.BACKGROUND, VersusScreenLayer.BOSS_SPOT, VersusScreenLayer.PLAYER_SPOT, VersusScreenLayer.OVERLAY, VersusScreenLayer.PLAYER_PORTRAIT_ALT);
+const VANILLA_VERSUS_PLAYBACK_SPEED = 0.5;
+/** We lazy load the sprite when first needed. */
+const versusScreenSprite = Sprite();
+/**
+ * We lazy load the sprite when first needed.
+ *
+ * Unfortunately, we must split the background layer into an entirely different sprite so that we
+ * can color it with the `Color` field.
+ */
+const versusScreenBackgroundSprite = Sprite();
+/**
+ * We lazy load the sprite when first needed.
+ *
+ * Unfortunately, we must split the dirt layer into an entirely different sprite so that we can
+ * color it with the `Color` field.
+ */
+const versusScreenDirtSpotSprite = Sprite();
+function playVersusScreenAnimation(customStage, disableAllSound, pause, runInNFrames) {
+    const room = cachedClasses_1.game.GetRoom();
+    const roomType = room.GetType();
+    const roomCleared = room.IsClear();
+    const hud = cachedClasses_1.game.GetHUD();
+    if (roomType !== isaac_typescript_definitions_1.RoomType.BOSS) {
+        return;
+    }
+    if (roomCleared) {
+        return;
+    }
+    if (willVanillaVersusScreenPlay()) {
+        // Since we are on an invalid stage, the versus screen will have a completely black background.
+        // Revert to using the background from the default stage.
+        const level = cachedClasses_1.game.GetLevel();
+        level.SetStage(constants_1.DEFAULT_BASE_STAGE, constants_1.DEFAULT_BASE_STAGE_TYPE);
+        runInNFrames.runNextGameFrame(() => {
+            const futureLevel = cachedClasses_1.game.GetLevel();
+            futureLevel.SetStage(constants_1.CUSTOM_FLOOR_STAGE, constants_1.CUSTOM_FLOOR_STAGE_TYPE);
+        });
+        return;
+    }
+    v_1.v.run.showingBossVersusScreen = true;
+    pause.pause();
+    hud.SetVisible(false);
+    disableAllSound.disableAllSound(constants_1.CUSTOM_STAGE_FEATURE_NAME);
+    // In vanilla, the "overlay.png" file has a white background. We must convert it to a PNG that
+    // uses a transparent background in order for the background behind it to be visible. We use the
+    // same "overlay.png" file as StageAPI uses for this purpose.
+    if (!versusScreenSprite.IsLoaded()) {
+        versusScreenSprite.Load("gfx/ui/boss/versusscreen.anm2", false);
+        versusScreenSprite.ReplaceSpritesheet(VersusScreenLayer.OVERLAY, `${constants_1.ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH}/overlay.png`);
+    }
+    // Player
+    {
+        const { namePNGPath, portraitPNGPath } = getPlayerPNGPaths();
+        versusScreenSprite.ReplaceSpritesheet(VersusScreenLayer.PLAYER_NAME, namePNGPath);
+        versusScreenSprite.ReplaceSpritesheet(VersusScreenLayer.PLAYER_PORTRAIT, portraitPNGPath);
+    }
+    // Boss
+    {
+        const { namePNGPath, portraitPNGPath } = getBossPNGPaths(customStage);
+        const trimmedNamePNGPath = (0, string_1.removeCharactersBefore)(namePNGPath, "gfx/");
+        versusScreenSprite.ReplaceSpritesheet(VersusScreenLayer.BOSS_NAME, trimmedNamePNGPath);
+        const trimmedPortraitPNGPath = (0, string_1.removeCharactersBefore)(portraitPNGPath, "gfx/");
+        versusScreenSprite.ReplaceSpritesheet(VersusScreenLayer.BOSS_PORTRAIT, trimmedPortraitPNGPath);
+    }
+    versusScreenSprite.LoadGraphics();
+    if (!versusScreenBackgroundSprite.IsLoaded()) {
+        versusScreenBackgroundSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
+    }
+    let backgroundColor = versusScreenBackgroundColors_1.VERSUS_SCREEN_BACKGROUND_COLORS[DEFAULT_STAGE_ID];
+    if (customStage.versusScreen?.backgroundColor !== undefined) {
+        const { r, g, b, a } = customStage.versusScreen.backgroundColor;
+        backgroundColor = Color(r, g, b, a);
+    }
+    versusScreenBackgroundSprite.Color = backgroundColor;
+    if (!versusScreenDirtSpotSprite.IsLoaded()) {
+        versusScreenDirtSpotSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
+    }
+    let dirtSpotColor = versusScreenDirtSpotColors_1.VERSUS_SCREEN_DIRT_SPOT_COLORS[DEFAULT_STAGE_ID];
+    if (customStage.versusScreen?.dirtSpotColor !== undefined) {
+        const { r, g, b } = customStage.versusScreen.dirtSpotColor;
+        dirtSpotColor = Color(r, g, b);
+    }
+    versusScreenDirtSpotSprite.Color = dirtSpotColor;
+    for (const sprite of [
+        versusScreenBackgroundSprite,
+        versusScreenDirtSpotSprite,
+        versusScreenSprite,
+    ]) {
+        sprite.Play(VERSUS_SCREEN_ANIMATION_NAME, true);
+        sprite.PlaybackSpeed = VANILLA_VERSUS_PLAYBACK_SPEED;
+    }
+}
+exports.playVersusScreenAnimation = playVersusScreenAnimation;
+function willVanillaVersusScreenPlay() {
+    const bosses = (0, bosses_1.getBosses)();
+    return bosses.some((boss) => boss.GetBossID() !== 0);
+}
+/** Use the character of the 0th player. */
+function getPlayerPNGPaths() {
+    const player = Isaac.GetPlayer();
+    const character = player.GetPlayerType();
+    if (character === isaac_typescript_definitions_1.PlayerType.POSSESSOR) {
+        error("Failed to get the player PNG paths since they are a possessor.");
+    }
+    const namePNGPath = (0, versusScreen_1.getCharacterNamePNGFilePath)(character);
+    const portraitPNGPath = (0, versusScreen_1.getCharacterPortraitPNGFilePath)(character);
+    return { namePNGPath, portraitPNGPath };
+}
+/** Use the boss of the first boss found. */
+function getBossPNGPaths(customStage) {
+    // Prefer the PNG paths specified by the end-user, if any.
+    const paths = getBossPNGPathsCustom(customStage);
+    if (paths !== undefined) {
+        return paths;
+    }
+    // If this is not a vanilla boss, default to showing question marks.
+    const bosses = (0, bosses_1.getBosses)();
+    const firstBoss = bosses[0];
+    const bossID = firstBoss === undefined ? 0 : firstBoss.GetBossID();
+    if (bossID === 0) {
+        const questionMarkPath = (0, versusScreen_1.getBossNamePNGFilePath)(isaac_typescript_definitions_1.BossID.BLUE_BABY);
+        const namePNGPath = questionMarkPath;
+        const portraitPNGPath = questionMarkPath;
+        return { namePNGPath, portraitPNGPath };
+    }
+    // If this is a vanilla boss, it will have a boss ID, and we can use the corresponding vanilla
+    // files.
+    const namePNGPath = (0, versusScreen_1.getBossNamePNGFilePath)(bossID);
+    const portraitPNGPath = (0, versusScreen_1.getBossPortraitPNGFilePath)(bossID);
+    return { namePNGPath, portraitPNGPath };
+}
+function getBossPNGPathsCustom(customStage) {
+    if (customStage.bossPool === undefined) {
+        return undefined;
+    }
+    const roomSubType = (0, roomData_1.getRoomSubType)();
+    const matchingBossEntry = customStage.bossPool.find((bossEntry) => bossEntry.subType === roomSubType);
+    if (matchingBossEntry === undefined) {
+        return undefined;
+    }
+    return matchingBossEntry.versusScreen;
+}
+function finishVersusScreenAnimation(pause, disableAllSound) {
+    const hud = cachedClasses_1.game.GetHUD();
+    v_1.v.run.showingBossVersusScreen = false;
+    pause.unpause();
+    hud.SetVisible(true);
+    disableAllSound.enableAllSound(constants_1.CUSTOM_STAGE_FEATURE_NAME);
+    // The sound effect only plays once the versus cutscene is over.
+    cachedClasses_1.sfxManager.Play(isaac_typescript_definitions_1.SoundEffect.CASTLE_PORTCULLIS);
+}
+// ModCallback.POST_RENDER (2)
+function versusScreenPostRender(pause, disableAllSound) {
+    if (!v_1.v.run.showingBossVersusScreen) {
+        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(pause, disableAllSound);
+        return;
+    }
+    const position = (0, ui_1.getScreenCenterPos)();
+    // First, we render the background.
+    versusScreenBackgroundSprite.RenderLayer(VersusScreenLayer.BACKGROUND, position);
+    versusScreenBackgroundSprite.Update();
+    // Second, we render the overlay.
+    versusScreenSprite.RenderLayer(VersusScreenLayer.OVERLAY, position);
+    // Third, we render the dirt.
+    versusScreenDirtSpotSprite.RenderLayer(VersusScreenLayer.BOSS_SPOT, position);
+    versusScreenDirtSpotSprite.RenderLayer(VersusScreenLayer.PLAYER_SPOT, position);
+    versusScreenDirtSpotSprite.Update();
+    // Lastly, we render everything else.
+    for (const layerID of OTHER_ANM2_LAYERS) {
+        versusScreenSprite.RenderLayer(layerID, position);
+    }
+    versusScreenSprite.Update();
+}
+exports.versusScreenPostRender = versusScreenPostRender;

package/dist/classes/features/other/debugDisplay/DebugDisplayBomb.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugDisplayBomb = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const render_1 = require("../../../../functions/render");
+const Feature_1 = require("../../../private/Feature");
+const utils_1 = require("./utils");
+class DebugDisplayBomb extends Feature_1.Feature {
+    textCallback = utils_1.defaultEntityDisplayCallback;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 59
+            [isaac_typescript_definitions_1.ModCallback.POST_BOMB_RENDER, this.postBombRender],
+        ];
+    }
+    // ModCallback.POST_BOMB_RENDER (59)
+    postBombRender = (bomb) => {
+        const text = this.textCallback(bomb);
+        (0, render_1.renderTextOnEntity)(bomb, text);
+    };
+}
+exports.DebugDisplayBomb = DebugDisplayBomb;

package/dist/classes/features/other/debugDisplay/DebugDisplayDoor.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugDisplayDoor = void 0;
+const ModCallbackCustom_1 = require("../../../../enums/ModCallbackCustom");
+const render_1 = require("../../../../functions/render");
+const Feature_1 = require("../../../private/Feature");
+const utils_1 = require("./utils");
+class DebugDisplayDoor extends Feature_1.Feature {
+    textCallback = utils_1.defaultGridEntityDisplayCallback;
+    constructor() {
+        super();
+        this.customCallbacksUsed = [
+            [ModCallbackCustom_1.ModCallbackCustom.POST_DOOR_RENDER, this.postDoorRender],
+        ];
+    }
+    // ModCallbackCustom.POST_DOOR_RENDER
+    postDoorRender = (door) => {
+        const text = this.textCallback(door);
+        (0, render_1.renderTextOnEntity)(door, text);
+    };
+}
+exports.DebugDisplayDoor = DebugDisplayDoor;

package/dist/classes/features/other/debugDisplay/DebugDisplayEffect.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugDisplayEffect = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const render_1 = require("../../../../functions/render");
+const Feature_1 = require("../../../private/Feature");
+const utils_1 = require("./utils");
+class DebugDisplayEffect extends Feature_1.Feature {
+    textCallback = utils_1.defaultEntityDisplayCallback;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 56
+            [isaac_typescript_definitions_1.ModCallback.POST_EFFECT_RENDER, this.postEffectRender],
+        ];
+    }
+    // ModCallback.POST_EFFECT_RENDER (56)
+    postEffectRender = (effect) => {
+        const text = this.textCallback(effect);
+        (0, render_1.renderTextOnEntity)(effect, text);
+    };
+}
+exports.DebugDisplayEffect = DebugDisplayEffect;

package/dist/classes/features/other/debugDisplay/DebugDisplayFamiliar.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugDisplayFamiliar = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const render_1 = require("../../../../functions/render");
+const Feature_1 = require("../../../private/Feature");
+const utils_1 = require("./utils");
+class DebugDisplayFamiliar extends Feature_1.Feature {
+    textCallback = utils_1.defaultEntityDisplayCallback;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 25
+            [isaac_typescript_definitions_1.ModCallback.POST_FAMILIAR_RENDER, this.postFamiliarRender],
+        ];
+    }
+    // ModCallback.POST_FAMILIAR_RENDER (25)
+    postFamiliarRender = (familiar) => {
+        const text = this.textCallback(familiar);
+        (0, render_1.renderTextOnEntity)(familiar, text);
+    };
+}
+exports.DebugDisplayFamiliar = DebugDisplayFamiliar;

package/dist/classes/features/other/debugDisplay/DebugDisplayKnife.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebugDisplayKnife = void 0;
+const isaac_typescript_definitions_1 = require("isaac-typescript-definitions");
+const render_1 = require("../../../../functions/render");
+const Feature_1 = require("../../../private/Feature");
+const utils_1 = require("./utils");
+class DebugDisplayKnife extends Feature_1.Feature {
+    textCallback = utils_1.defaultEntityDisplayCallback;
+    constructor() {
+        super();
+        this.callbacksUsed = [
+            // 52
+            [isaac_typescript_definitions_1.ModCallback.POST_KNIFE_RENDER, this.postKnifeRender],
+        ];
+    }
+    // ModCallback.POST_KNIFE_RENDER (52)
+    postKnifeRender = (knife) => {
+        const text = this.textCallback(knife);
+        (0, render_1.renderTextOnEntity)(knife, text);
+    };
+}
+exports.DebugDisplayKnife = DebugDisplayKnife;