isaacscript-common 14.2.0 → 15.0.0

package/src/classes/features/other/customStages/versusScreen.ts

@@ -0,0 +1,378 @@
+// This emulates the vanilla versus screen that shows up when you enter a boss room.
+
+import {
+  BossID,
+  PlayerType,
+  RoomType,
+  SoundEffect,
+  StageID,
+} from "isaac-typescript-definitions";
+import { game, sfxManager } from "../../../../core/cachedClasses";
+import { arrayRemove } from "../../../../functions/array";
+import { getBosses } from "../../../../functions/bosses";
+import { getRoomSubType } from "../../../../functions/roomData";
+import { removeCharactersBefore } from "../../../../functions/string";
+import { eRange } from "../../../../functions/utils";
+import { CustomStage } from "../../../../interfaces/private/CustomStage";
+import { BOSS_NAME_PNG_FILE_NAMES } from "../../../../objects/bossNamePNGFileNames";
+import { BOSS_PORTRAIT_PNG_FILE_NAMES } from "../../../../objects/bossPortraitPNGFileNames";
+import { PLAYER_NAME_PNG_FILE_NAMES } from "../../../../objects/playerNamePNGFileNames";
+import { PLAYER_PORTRAIT_PNG_FILE_NAMES } from "../../../../objects/playerPortraitPNGFileNames";
+import { VERSUS_SCREEN_BACKGROUND_COLORS } from "../../../../objects/versusScreenBackgroundColors";
+import { VERSUS_SCREEN_DIRT_SPOT_COLORS } from "../../../../objects/versusScreenDirtSpotColors";
+import { DisableAllSound } from "../DisableAllSound";
+import { Pause } from "../Pause";
+import { RunInNFrames } from "../RunInNFrames";
+import {
+  CUSTOM_FLOOR_STAGE,
+  CUSTOM_FLOOR_STAGE_TYPE,
+  CUSTOM_STAGE_FEATURE_NAME,
+  DEFAULT_BASE_STAGE,
+  DEFAULT_BASE_STAGE_TYPE,
+  ISAACSCRIPT_CUSTOM_STAGE_GFX_PATH,
+} from "./constants";
+
+interface VersusScreenVars {
+  run: {
+    showingBossVersusScreen: boolean;
+  };
+}
+
+const DEFAULT_CHARACTER = PlayerType.ISAAC;
+const DEFAULT_STAGE_ID = 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". */
+enum VersusScreenLayer {
+  BACKGROUND = 0,
+  FRAME = 1,
+
+  /** The boss dirt spot. */
+  BOSS_SPOT = 2,
+
+  /** The player dirt spot. */
+  PLAYER_SPOT = 3,
+
+  BOSS_PORTRAIT = 4,
+  PLAYER_PORTRAIT = 5,
+  PLAYER_NAME = 6,
+  BOSS_NAME = 7,
+  VS_TEXT = 8,
+  BOSS_DOUBLE = 9,
+  DT_TEXT = 10,
+  OVERLAY = 11,
+
+  /**
+   * 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.
+   */
+  PLAYER_PORTRAIT_ALT = 12,
+
+  BOSS_PORTRAIT_GROUND = 13,
+  BOSS_PORTRAIT_2_GROUND = 14,
+}
+
+/** These are the non-special layers that we will render last. */
+const OTHER_ANM2_LAYERS: readonly int[] = arrayRemove(
+  eRange(NUM_VERSUS_SCREEN_ANM2_LAYERS),
+  VersusScreenLayer.BACKGROUND,
+  VersusScreenLayer.BOSS_SPOT,
+  VersusScreenLayer.PLAYER_SPOT,
+  VersusScreenLayer.OVERLAY,
+  VersusScreenLayer.PLAYER_PORTRAIT_ALT,
+);
+
+/** Most of the PNG files related to the versus screen are located in this directory. */
+const PNG_PATH_PREFIX = "gfx/ui/boss";
+
+/**
+ * Player portraits are not located in the same directory as everything else, since they are re-used
+ * from the animation where the player travels to a new stage.
+ */
+const PLAYER_PORTRAIT_PNG_PATH_PREFIX = "gfx/ui/stage";
+
+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();
+
+export function playVersusScreenAnimation(
+  v: VersusScreenVars,
+  customStage: CustomStage,
+  disableAllSound: DisableAllSound,
+  pause: Pause,
+  runInNFrames: RunInNFrames,
+): void {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const roomCleared = room.IsClear();
+  const hud = game.GetHUD();
+
+  if (roomType !== 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 = game.GetLevel();
+    level.SetStage(DEFAULT_BASE_STAGE, DEFAULT_BASE_STAGE_TYPE);
+    runInNFrames.runNextGameFrame(() => {
+      const futureLevel = game.GetLevel();
+      futureLevel.SetStage(CUSTOM_FLOOR_STAGE, CUSTOM_FLOOR_STAGE_TYPE);
+    });
+    return;
+  }
+
+  v.run.showingBossVersusScreen = true;
+
+  pause.pause();
+  hud.SetVisible(false);
+  disableAllSound.disableAllSound(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,
+      `${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 = removeCharactersBefore(namePNGPath, "gfx/");
+    versusScreenSprite.ReplaceSpritesheet(
+      VersusScreenLayer.BOSS_NAME,
+      trimmedNamePNGPath,
+    );
+    const trimmedPortraitPNGPath = removeCharactersBefore(
+      portraitPNGPath,
+      "gfx/",
+    );
+    versusScreenSprite.ReplaceSpritesheet(
+      VersusScreenLayer.BOSS_PORTRAIT,
+      trimmedPortraitPNGPath,
+    );
+  }
+
+  versusScreenSprite.LoadGraphics();
+
+  if (!versusScreenBackgroundSprite.IsLoaded()) {
+    versusScreenBackgroundSprite.Load("gfx/ui/boss/versusscreen.anm2", true);
+  }
+
+  let backgroundColor = 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 = 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;
+  }
+}
+
+function willVanillaVersusScreenPlay() {
+  const bosses = getBosses();
+  return bosses.some((boss) => boss.GetBossID() !== 0);
+}
+
+/** Use the character of the 0th player. */
+function getPlayerPNGPaths(): {
+  namePNGPath: string;
+  portraitPNGPath: string;
+} {
+  const player = Isaac.GetPlayer();
+  const character = player.GetPlayerType();
+
+  let namePNGFileName = PLAYER_NAME_PNG_FILE_NAMES[character];
+  if (namePNGFileName === undefined) {
+    namePNGFileName = PLAYER_NAME_PNG_FILE_NAMES[DEFAULT_CHARACTER];
+  }
+
+  const namePNGPath = `${PNG_PATH_PREFIX}/${namePNGFileName}`;
+
+  let portraitFileName = PLAYER_PORTRAIT_PNG_FILE_NAMES[character];
+  if (namePNGFileName === undefined) {
+    portraitFileName = PLAYER_PORTRAIT_PNG_FILE_NAMES[DEFAULT_CHARACTER];
+  }
+
+  const portraitPNGPath = `${PLAYER_PORTRAIT_PNG_PATH_PREFIX}/${portraitFileName}`;
+
+  return { namePNGPath, portraitPNGPath };
+}
+
+/** Use the boss of the first boss found. */
+function getBossPNGPaths(customStage: CustomStage): {
+  namePNGPath: string;
+  portraitPNGPath: string;
+} {
+  // 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 = 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 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 namePNGFileName = BOSS_NAME_PNG_FILE_NAMES[bossID];
+  const namePNGPath = `${PNG_PATH_PREFIX}/${namePNGFileName}`;
+
+  const portraitPNGFileName = BOSS_PORTRAIT_PNG_FILE_NAMES[bossID];
+  const portraitPNGPath = `${PNG_PATH_PREFIX}/${portraitPNGFileName}`;
+
+  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(
+  v: VersusScreenVars,
+  pause: Pause,
+  disableAllSound: DisableAllSound,
+) {
+  const hud = game.GetHUD();
+
+  v.run.showingBossVersusScreen = false;
+
+  pause.unpause();
+  hud.SetVisible(true);
+  disableAllSound.enableAllSound(CUSTOM_STAGE_FEATURE_NAME);
+
+  // The sound effect only plays once the versus cutscene is over.
+  sfxManager.Play(SoundEffect.CASTLE_PORTCULLIS);
+}
+
+// ModCallback.POST_RENDER (2)
+export function versusScreenPostRender(
+  v: VersusScreenVars,
+  pause: Pause,
+  disableAllSound: DisableAllSound,
+): void {
+  if (!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(v, pause, disableAllSound);
+    return;
+  }
+
+  const room = game.GetRoom();
+  const centerPos = room.GetCenterPos();
+  const position = Isaac.WorldToRenderPosition(centerPos);
+
+  // 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();
+}

package/src/classes/features/other/debugDisplay/DebugDisplayBomb.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayBomb extends Feature {
+  public textCallback: (bomb: EntityBomb) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_BOMB_RENDER, [this.postBombRender]], // 59
+    ];
+  }
+
+  // ModCallback.POST_BOMB_RENDER (59)
+  private postBombRender = (bomb: EntityBomb) => {
+    const text = this.textCallback(bomb);
+    renderTextOnEntity(bomb, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayDoor.ts

@@ -0,0 +1,22 @@
+import { ModCallbackCustom } from "../../../../enums/ModCallbackCustom";
+import { Feature } from "../../../private/Feature";
+import { defaultGridEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayDoor extends Feature {
+  public textCallback: (door: GridEntityDoor) => string =
+    defaultGridEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom.POST_DOOR_RENDER, [this.postDoorRender]],
+    ];
+  }
+
+  // ModCallbackCustom.POST_DOOR_RENDER
+  private postDoorRender = (door: GridEntityDoor) => {
+    const text = this.textCallback(door);
+    renderTextOnEntity(door, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayEffect.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayEffect extends Feature {
+  public textCallback: (effect: EntityEffect) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_EFFECT_RENDER, [this.postEffectRender]], // 56
+    ];
+  }
+
+  // ModCallback.POST_EFFECT_RENDER (56)
+  private postEffectRender = (effect: EntityEffect) => {
+    const text = this.textCallback(effect);
+    renderTextOnEntity(effect, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayFamiliar.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayFamiliar extends Feature {
+  public textCallback: (familiar: EntityFamiliar) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_FAMILIAR_RENDER, [this.postFamiliarRender]], // 25
+    ];
+  }
+
+  // ModCallback.POST_FAMILIAR_RENDER (25)
+  private postFamiliarRender = (familiar: EntityFamiliar) => {
+    const text = this.textCallback(familiar);
+    renderTextOnEntity(familiar, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayKnife.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayKnife extends Feature {
+  public textCallback: (knife: EntityKnife) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_KNIFE_RENDER, [this.postKnifeRender]], // 52
+    ];
+  }
+
+  // ModCallback.POST_KNIFE_RENDER (52)
+  private postKnifeRender = (knife: EntityKnife) => {
+    const text = this.textCallback(knife);
+    renderTextOnEntity(knife, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayLaser.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayLaser extends Feature {
+  public textCallback: (laser: EntityLaser) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_LASER_RENDER, [this.postLaserRender]], // 49
+    ];
+  }
+
+  // ModCallback.POST_LASER_RENDER (49)
+  private postLaserRender = (laser: EntityLaser) => {
+    const text = this.textCallback(laser);
+    renderTextOnEntity(laser, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayNPC.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayNPC extends Feature {
+  public textCallback: (npc: EntityNPC) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_NPC_RENDER, [this.postNPCRender]], // 28
+    ];
+  }
+
+  // ModCallback.POST_NPC_RENDER (28)
+  private postNPCRender = (npc: EntityNPC) => {
+    const text = this.textCallback(npc);
+    renderTextOnEntity(npc, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayPickup.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayPickup extends Feature {
+  public textCallback: (pickup: EntityPickup) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PICKUP_RENDER, [this.postPickupRender]], // 36
+    ];
+  }
+
+  // ModCallback.POST_PICKUP_RENDER (36)
+  private postPickupRender = (pickup: EntityPickup) => {
+    const text = this.textCallback(pickup);
+    renderTextOnEntity(pickup, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayPit.ts

@@ -0,0 +1,22 @@
+import { ModCallbackCustom } from "../../../../enums/ModCallbackCustom";
+import { Feature } from "../../../private/Feature";
+import { defaultGridEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayPit extends Feature {
+  public textCallback: (pit: GridEntityPit) => string =
+    defaultGridEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom.POST_PIT_RENDER, [this.postPitRender]],
+    ];
+  }
+
+  // ModCallbackCustom.POST_PIT_RENDER
+  private postPitRender = (pit: GridEntityPit) => {
+    const text = this.textCallback(pit);
+    renderTextOnEntity(pit, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayPlayer.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayPlayer extends Feature {
+  public textCallback: (player: EntityPlayer) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PLAYER_RENDER, [this.postPlayerRender]], // 32
+    ];
+  }
+
+  // ModCallback.POST_PLAYER_RENDER (32)
+  private postPlayerRender = (player: EntityPlayer) => {
+    const text = this.textCallback(player);
+    renderTextOnEntity(player, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayPoop.ts

@@ -0,0 +1,22 @@
+import { ModCallbackCustom } from "../../../../enums/ModCallbackCustom";
+import { Feature } from "../../../private/Feature";
+import { defaultGridEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayPoop extends Feature {
+  public textCallback: (poop: GridEntityPoop) => string =
+    defaultGridEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom.POST_POOP_RENDER, [this.postPoopRender]],
+    ];
+  }
+
+  // ModCallbackCustom.POST_POOP_RENDER
+  private postPoopRender = (poop: GridEntityPoop) => {
+    const text = this.textCallback(poop);
+    renderTextOnEntity(poop, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayPressurePlate.ts

@@ -0,0 +1,27 @@
+import { ModCallbackCustom } from "../../../../enums/ModCallbackCustom";
+import { Feature } from "../../../private/Feature";
+import { defaultGridEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayPressurePlate extends Feature {
+  public textCallback: (pressurePlate: GridEntityPressurePlate) => string =
+    defaultGridEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_PRESSURE_PLATE_RENDER,
+        [this.postPressurePlateRender],
+      ],
+    ];
+  }
+
+  // ModCallbackCustom.POST_PRESSURE_PLATE_RENDER
+  private postPressurePlateRender = (
+    pressurePlate: GridEntityPressurePlate,
+  ) => {
+    const text = this.textCallback(pressurePlate);
+    renderTextOnEntity(pressurePlate, text);
+  };
+}

package/src/classes/features/other/debugDisplay/DebugDisplayProjectile.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { Feature } from "../../../private/Feature";
+import { defaultEntityDisplayCallback, renderTextOnEntity } from "./utils";
+
+export class DebugDisplayProjectile extends Feature {
+  public textCallback: (projectile: EntityProjectile) => string =
+    defaultEntityDisplayCallback;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      [ModCallback.POST_PROJECTILE_RENDER, [this.postProjectileRender]], // 45
+    ];
+  }
+
+  // ModCallback.POST_PROJECTILE_RENDER (45)
+  private postProjectileRender = (projectile: EntityProjectile) => {
+    const text = this.textCallback(projectile);
+    renderTextOnEntity(projectile, text);
+  };
+}