isaacscript-common 6.11.1 → 6.11.2

package/src/features/customTrapdoor/exports.ts

@@ -1,23 +1,22 @@
 import {
   GridCollisionClass,
   LevelStage,
-  RoomType,
   StageType,
 } from "isaac-typescript-definitions";
 import { game } from "../../cachedClasses";
+import { TrapdoorAnimation } from "../../enums/private/TrapdoorAnimation";
 import { errorIfFeaturesNotInitialized } from "../../featuresInitialized";
 import { getNextStage, getNextStageType } from "../../functions/nextStage";
-import { anyPlayerCloserThan } from "../../functions/positionVelocity";
+import { getRoomListIndex } from "../../functions/roomData";
+import { isVector } from "../../functions/vector";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
 import { spawnCustomGridEntity } from "../customGridEntity";
-import { getRoomClearGameFrame } from "../roomClearFrame";
 import {
   CUSTOM_TRAPDOOR_FEATURE_NAME,
   GridEntityTypeCustom,
-  TRAPDOOR_BOSS_REACTION_FRAMES,
-  TRAPDOOR_OPEN_DISTANCE,
-  TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS,
 } from "./customTrapdoorConstants";
-import { getCustomTrapdoorDescription } from "./v";
+import { shouldTrapdoorSpawnOpen } from "./openClose";
+import v from "./v";
 
 /**
  * Helper function to spawn a trapdoor grid entity that will have one or more of the following
@@ -26,7 +25,7 @@ import { getCustomTrapdoorDescription } from "./v";
  * - custom destination (or custom logic for after the player enters)
  * - custom graphics
  * - custom logic for opening/closing
- * - TODO: animation
+ * - TODO: player jumping animation?
  *
  * You can use this function to take the player to your custom stage.
  *
@@ -34,135 +33,67 @@ import { getCustomTrapdoorDescription } from "./v";
  * respawned every time the player re-enters the room.
  *
  * @param gridIndexOrPosition The location in the room to spawn the trapdoor.
- * @param _destination Used to specify where the player will go after jumping into the trapdoor. Can
- *                     either be a tuple containing the stage and stage type, a string containing
- *                     the name of a custom stage, or undefined. If undefined, nothing will happen
- *                     after the player jumps in the trapdoor. (Use undefined to perform some custom
- *                     behavior and/or handle the traveling part yourself.) You can also specify a
- *                     function that returns one of these things. By default, the destination will
- *                     be set to the next floor like that of a vanilla trapdoor.
+ * @param destination Optional. Used to specify where the player will go after jumping into the
+ *                    trapdoor. Can either be a tuple containing the stage and stage type, or a
+ *                    string containing the name of a custom stage. If not specified at all, then
+ *                    the "normal" destination corresponding to the current stage and room will be
+ *                    used (e.g. the next floor).
  * @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.
- * @param _shouldOpenFunc Optional. If the trapdoor is currently closed, this function will run on
- *                        every frame to determine if it should open. By default, a function that
- *                        emulates a vanilla trapdoor will be used.
- * @param _shouldCloseFunc Optional. If the trapdoor is currently open, this function will run on
- *                         every frame to determine if it should close. By default, a function that
- *                         emulates a vanilla trapdoor will be used.
- * @param _spawnOpen Optional. Whether or not to spawn the trapdoor in an open state. Can either be
- *                   a boolean or a function returning a boolean. By default, a function that
- *                   emulates a vanilla trapdoor will be used.
+ *                 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 spawnCustomTrapdoor(
   gridIndexOrPosition: int | Vector,
-  _destination:
-    | [stage: LevelStage, stageType: StageType]
-    | string
-    | ((
-        gridEntity: GridEntity,
-      ) =>
-        | [stage: LevelStage, stageType: StageType]
-        | string
-        | undefined) = defaultDestinationFunc,
+  destination?: [stage: LevelStage, stageType: StageType] | string,
   anm2Path = "gfx/grid/door_11_trapdoor.anm2",
-  _shouldOpenFunc: (gridEntity: GridEntity) => boolean = defaultShouldOpenFunc,
-  _shouldCloseFunc: (
-    gridEntity: GridEntity,
-  ) => boolean = defaultShouldCloseFunc,
-  _spawnOpen:
-    | boolean
-    | ((gridEntity: GridEntity) => boolean) = defaultShouldSpawnOpenFunc,
+  spawnOpen?: boolean,
 ): GridEntity {
   errorIfFeaturesNotInitialized(CUSTOM_TRAPDOOR_FEATURE_NAME);
 
-  // TODO
-  return spawnCustomGridEntity(
+  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,
-    anm2Path,
-    "Closed",
     GridCollisionClass.NONE,
+    anm2Path,
+    TrapdoorAnimation.OPENED,
   );
-}
-
-function defaultDestinationFunc(): [stage: LevelStage, stageType: StageType] {
-  const nextStage = getNextStage();
-  const nextStageType = getNextStageType();
-
-  return [nextStage, nextStageType];
-}
-
-function defaultShouldOpenFunc(gridEntity: GridEntity): boolean {
-  const trapdoorDescription = getCustomTrapdoorDescription(gridEntity);
-  if (trapdoorDescription === undefined) {
-    return false;
-  }
-
-  const room = game.GetRoom();
-  const roomClear = room.IsClear();
-
-  return (
-    !anyPlayerCloserThan(gridEntity.Position, TRAPDOOR_OPEN_DISTANCE) &&
-    !isPlayerCloseAfterBoss(gridEntity.Position) &&
-    !shouldBeClosedFromStartingInRoomWithEnemies(
-      trapdoorDescription.firstSpawn,
-      roomClear,
-    )
-  );
-}
 
-function isPlayerCloseAfterBoss(position: Vector) {
-  const gameFrameCount = game.GetFrameCount();
-  const room = game.GetRoom();
-  const roomType = room.GetType();
-  const roomClearGameFrame = getRoomClearGameFrame();
-
-  // In order to prevent a player from accidentally entering a freshly-spawned trapdoor after
-  // killing the boss of the floor, we use a wider open distance for a short amount of frames.
-  if (
-    roomType !== RoomType.BOSS ||
-    roomClearGameFrame === undefined ||
-    gameFrameCount >= roomClearGameFrame + TRAPDOOR_BOSS_REACTION_FRAMES
-  ) {
-    return false;
+  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);
   }
 
-  return anyPlayerCloserThan(position, TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS);
+  return gridEntity;
 }
 
-function shouldBeClosedFromStartingInRoomWithEnemies(
-  firstSpawn: boolean,
-  roomClear: boolean,
-) {
-  return firstSpawn && !roomClear;
-}
-
-/** By default, trapdoors will never close if they are already open. */
-function defaultShouldCloseFunc(): boolean {
-  return false;
-}
-
-function defaultShouldSpawnOpenFunc(gridEntity: GridEntity): boolean {
-  const room = game.GetRoom();
-  const roomFrameCount = room.GetFrameCount();
-  const roomClear = room.IsClear();
-
-  // Trapdoors created after a room has already initialized should spawn closed by default:
-  // - Trapdoors created after bosses should spawn closed so that players do not accidentally jump
-  //   into them.
-  // - Trapdoors created by We Need to Go Deeper should spawn closed because the player will be
-  //   standing on top of them.
-  if (roomFrameCount > 0) {
-    return false;
-  }
-
-  // If we just entered a new room with enemies in it, spawn the trapdoor closed so that the player
-  // has to defeat the enemies first before using the trapdoor.
-  if (!roomClear) {
-    return false;
-  }
+function getDefaultDestination(): [stage: LevelStage, stageType: StageType] {
+  const nextStage = getNextStage();
+  const nextStageType = getNextStageType();
 
-  // If we just entered a new room that is already cleared, spawn the trapdoor closed if we are
-  // standing close to it, and open otherwise.
-  return defaultShouldOpenFunc(gridEntity);
+  return [nextStage, nextStageType];
 }

package/src/features/customTrapdoor/init.ts

@@ -0,0 +1,215 @@
+import {
+  Direction,
+  ModCallback,
+  RoomTransitionAnim,
+} from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { ModUpgraded } from "../../classes/ModUpgraded";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { StageTravelState } from "../../enums/private/StageTravelState";
+import { movePlayersToCenter } from "../../functions/playerCenter";
+import { getAllPlayers } from "../../functions/playerIndex";
+import { getRoomGridIndex, getRoomListIndex } from "../../functions/roomData";
+import { setStage } from "../../functions/stage";
+import { isString } from "../../functions/types";
+import { setCustomStage } from "../customStage/exports";
+import { topStreakTextStart } from "../customStage/streakText";
+import { enableAllInputs } from "../disableInputs";
+import { runNextGameFrame } from "../runInNFrames";
+import { runNextRoom } from "../runNextRoom";
+import { saveDataManager } from "../saveDataManager/exports";
+import { drawBlackSprite } from "./blackSprite";
+import {
+  CUSTOM_TRAPDOOR_FEATURE_NAME,
+  PIXELATION_TO_BLACK_FRAMES,
+} from "./customTrapdoorConstants";
+import { checkCustomTrapdoorOpenClose } from "./openClose";
+import { checkCustomTrapdoorPlayerTouched } from "./touched";
+import v from "./v";
+
+export function customTrapdoorInit(mod: ModUpgraded): void {
+  saveDataManager(CUSTOM_TRAPDOOR_FEATURE_NAME, v);
+
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+  mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_GRID_ENTITY_UPDATE,
+    postGridEntityUpdateTrapdoor,
+  );
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  checkAllPlayersJumpComplete();
+  checkPixelationToBlackComplete();
+  checkPausingOnBlackComplete();
+  checkAllPlayersLayingDownComplete();
+  drawBlackSprite();
+}
+
+function checkAllPlayersJumpComplete() {
+  if (v.run.state !== StageTravelState.PLAYERS_JUMPING_DOWN) {
+    return;
+  }
+
+  if (anyPlayerPlayingExtraAnimation()) {
+    return;
+  }
+
+  const renderFrameCount = Isaac.GetFrameCount();
+  const roomGridIndex = getRoomGridIndex();
+
+  v.run.state = StageTravelState.PIXELATION_TO_BLACK;
+  v.run.stateRenderFrame = renderFrameCount;
+
+  // In order to display the pixelation effect that should happen when we go to a new floor, we need
+  // to start a room transition. We arbitrarily pick the current room for this purpose.
+  game.StartRoomTransition(
+    roomGridIndex,
+    Direction.NO_DIRECTION,
+    RoomTransitionAnim.PIXELATION,
+  );
+}
+
+function checkPixelationToBlackComplete() {
+  if (
+    v.run.state !== StageTravelState.PIXELATION_TO_BLACK ||
+    v.run.stateRenderFrame === null
+  ) {
+    return;
+  }
+
+  const hud = game.GetHUD();
+  const renderFrameCount = Isaac.GetFrameCount();
+  const roomGridIndex = getRoomGridIndex();
+
+  const renderFrameScreenBlack =
+    v.run.stateRenderFrame + PIXELATION_TO_BLACK_FRAMES;
+  if (renderFrameCount < renderFrameScreenBlack) {
+    return;
+  }
+
+  v.run.state = StageTravelState.PAUSING_ON_BLACK;
+  v.run.stateRenderFrame = renderFrameCount;
+
+  hud.SetVisible(false);
+  goToCustomDestination();
+
+  // 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.
+  game.StartRoomTransition(
+    roomGridIndex,
+    Direction.NO_DIRECTION,
+    RoomTransitionAnim.PIXELATION,
+  );
+}
+
+function checkPausingOnBlackComplete() {
+  if (
+    v.run.state !== StageTravelState.PAUSING_ON_BLACK ||
+    v.run.stateRenderFrame === null
+  ) {
+    return;
+  }
+
+  const hud = game.GetHUD();
+  const renderFrameCount = Isaac.GetFrameCount();
+
+  const renderFrameScreenBlack =
+    v.run.stateRenderFrame + PIXELATION_TO_BLACK_FRAMES;
+  if (renderFrameCount < renderFrameScreenBlack) {
+    return;
+  }
+
+  v.run.state = StageTravelState.PIXELATION_TO_ROOM;
+
+  hud.SetVisible(true);
+
+  runNextRoom(() => {
+    // 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();
+
+    v.run.state = StageTravelState.PLAYERS_LAYING_DOWN;
+
+    for (const player of getAllPlayers()) {
+      player.AnimateAppear();
+    }
+  });
+
+  // In vanilla, the streak text appears about when the pixelation has faded and while Isaac is
+  // still laying on the ground. Unfortunately, we cannot exactly replicate the vanilla timing,
+  // because the level text will bug out and smear the background if we play it from a `POST_RENDER`
+  // callback. Thus, we run it on the next game frame as a workaround.
+  runNextGameFrame(() => {
+    topStreakTextStart();
+  });
+}
+
+function checkAllPlayersLayingDownComplete() {
+  if (v.run.state !== StageTravelState.PLAYERS_LAYING_DOWN) {
+    return;
+  }
+
+  if (anyPlayerPlayingExtraAnimation()) {
+    return;
+  }
+
+  v.run.state = StageTravelState.NONE;
+
+  enableAllInputs(CUSTOM_TRAPDOOR_FEATURE_NAME);
+}
+
+function goToCustomDestination() {
+  if (v.run.destination === null) {
+    return;
+  }
+
+  if (isString(v.run.destination)) {
+    setCustomStage("Slaughterhouse");
+  } else {
+    const [stage, stageType] = v.run.destination;
+    setStage(stage, stageType);
+  }
+}
+
+function anyPlayerPlayingExtraAnimation() {
+  const players = getAllPlayers();
+  return players.some((player) => !player.IsExtraAnimationFinished());
+}
+
+// ModCallback.POST_PEFFECT_UPDATE (4)
+function postPEffectUpdate(player: EntityPlayer) {
+  checkJumpComplete(player);
+}
+
+function checkJumpComplete(player: EntityPlayer) {
+  if (v.run.state !== StageTravelState.PLAYERS_JUMPING_DOWN) {
+    return;
+  }
+
+  // In this state, the players are jumping down the hole (i.e. playing the "Trapdoor" animation).
+  // When it completes, they will return to normal (i.e. just standing on top of the trapdoor).
+  // Thus, make them invisible at the end of the animation. (They will automatically be set to
+  // visible again once we travel to the next floor.)
+  const sprite = player.GetSprite();
+  if (sprite.IsFinished("Trapdoor")) {
+    player.Visible = false;
+  }
+}
+
+// ModCallbackCustom.POST_GRID_ENTITY_UPDATE
+// GridEntityType.TRAPDOOR (17)
+function postGridEntityUpdateTrapdoor(gridEntity: GridEntity) {
+  const roomListIndex = getRoomListIndex();
+  const gridIndex = gridEntity.GetGridIndex();
+
+  const roomTrapdoorMap = v.level.trapdoors.getAndSetDefault(roomListIndex);
+  const trapdoorDescription = roomTrapdoorMap.get(gridIndex);
+  if (trapdoorDescription === undefined) {
+    return;
+  }
+
+  checkCustomTrapdoorOpenClose(gridEntity, trapdoorDescription);
+  checkCustomTrapdoorPlayerTouched(gridEntity, trapdoorDescription);
+}

package/src/features/customTrapdoor/openClose.ts

@@ -0,0 +1,103 @@
+import { RoomType } from "isaac-typescript-definitions";
+import { game } from "../../cachedClasses";
+import { TrapdoorAnimation } from "../../enums/private/TrapdoorAnimation";
+import { anyPlayerCloserThan } from "../../functions/positionVelocity";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
+import { getRoomClearGameFrame } from "../roomClearFrame";
+import {
+  TRAPDOOR_BOSS_REACTION_FRAMES,
+  TRAPDOOR_OPEN_DISTANCE,
+  TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS,
+} from "./customTrapdoorConstants";
+
+export function checkCustomTrapdoorOpenClose(
+  gridEntity: GridEntity,
+  trapdoorDescription: CustomTrapdoorDescription,
+): void {
+  /** By default, trapdoors will never close if they are already open. */
+  if (trapdoorDescription.open) {
+    return;
+  }
+
+  if (shouldTrapdoorOpen(gridEntity, trapdoorDescription.firstSpawn)) {
+    open(gridEntity, trapdoorDescription);
+  }
+}
+
+function shouldTrapdoorOpen(
+  gridEntity: GridEntity,
+  firstSpawn: boolean,
+): boolean {
+  const room = game.GetRoom();
+  const roomClear = room.IsClear();
+
+  return (
+    !anyPlayerCloserThan(gridEntity.Position, TRAPDOOR_OPEN_DISTANCE) &&
+    !isPlayerCloseAfterBoss(gridEntity.Position) &&
+    !shouldBeClosedFromStartingInRoomWithEnemies(firstSpawn, roomClear)
+  );
+}
+
+function isPlayerCloseAfterBoss(position: Vector) {
+  const gameFrameCount = game.GetFrameCount();
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const roomClearGameFrame = getRoomClearGameFrame();
+
+  // In order to prevent a player from accidentally entering a freshly-spawned trapdoor after
+  // killing the boss of the floor, we use a wider open distance for a short amount of frames.
+  if (
+    roomType !== RoomType.BOSS ||
+    roomClearGameFrame === undefined ||
+    gameFrameCount >= roomClearGameFrame + TRAPDOOR_BOSS_REACTION_FRAMES
+  ) {
+    return false;
+  }
+
+  return anyPlayerCloserThan(position, TRAPDOOR_OPEN_DISTANCE_AFTER_BOSS);
+}
+
+function shouldBeClosedFromStartingInRoomWithEnemies(
+  firstSpawn: boolean,
+  roomClear: boolean,
+) {
+  return firstSpawn && !roomClear;
+}
+
+function open(
+  gridEntity: GridEntity,
+  trapdoorDescription: CustomTrapdoorDescription,
+) {
+  trapdoorDescription.open = true;
+
+  const sprite = gridEntity.GetSprite();
+  sprite.Play(TrapdoorAnimation.OPEN_ANIMATION, true);
+}
+
+export function shouldTrapdoorSpawnOpen(
+  gridEntity: GridEntity,
+  firstSpawn: boolean,
+): boolean {
+  const room = game.GetRoom();
+  const roomFrameCount = room.GetFrameCount();
+  const roomClear = room.IsClear();
+
+  // Trapdoors created after a room has already initialized should spawn closed by default:
+  // - Trapdoors created after bosses should spawn closed so that players do not accidentally jump
+  //   into them.
+  // - Trapdoors created by We Need to Go Deeper should spawn closed because the player will be
+  //   standing on top of them.
+  if (roomFrameCount > 0) {
+    return false;
+  }
+
+  // If we just entered a new room with enemies in it, spawn the trapdoor closed so that the player
+  // has to defeat the enemies first before using the trapdoor.
+  if (!roomClear) {
+    return false;
+  }
+
+  // If we just entered a new room that is already cleared, spawn the trapdoor closed if we are
+  // standing close to it, and open otherwise.
+  return shouldTrapdoorOpen(gridEntity, firstSpawn);
+}