isaacscript-common 6.11.1 → 6.11.2

package/src/features/customTrapdoor/touched.ts

@@ -0,0 +1,175 @@
+import {
+  EntityCollisionClass,
+  EntityPartition,
+  PlayerType,
+} from "isaac-typescript-definitions";
+import { VectorZero } from "../../constants";
+import { StageTravelState } from "../../enums/private/StageTravelState";
+import {
+  getOtherPlayers,
+  getPlayers,
+  isChildPlayer,
+} from "../../functions/playerIndex";
+import { isCharacter } from "../../functions/players";
+import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
+import { disableAllInputs } from "../disableInputs";
+import { isPlayerUsingPony } from "../ponyDetection";
+import { runInNGameFrames, runNextGameFrame } from "../runInNFrames";
+import {
+  ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL,
+  CUSTOM_TRAPDOOR_FEATURE_NAME,
+  OTHER_PLAYER_TRAPDOOR_JUMP_DELAY_GAME_FRAMES,
+  OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES,
+  TRAPDOOR_TOUCH_DISTANCE,
+} from "./customTrapdoorConstants";
+import v from "./v";
+
+export function checkCustomTrapdoorPlayerTouched(
+  gridEntity: GridEntity,
+  trapdoorDescription: CustomTrapdoorDescription,
+): void {
+  if (v.run.state !== StageTravelState.NONE) {
+    return;
+  }
+
+  if (!trapdoorDescription.open) {
+    return;
+  }
+
+  const playersTouching = Isaac.FindInRadius(
+    gridEntity.Position,
+    TRAPDOOR_TOUCH_DISTANCE,
+    EntityPartition.PLAYER,
+  );
+  for (const playerEntity of playersTouching) {
+    const player = playerEntity.ToPlayer();
+    if (player === undefined) {
+      continue;
+    }
+
+    if (
+      // We don't want a Pony dash to transition to a new floor or a crawl space.
+      !isPlayerUsingPony(player) &&
+      !isChildPlayer(player) &&
+      canPlayerInteractWithTrapdoor(player)
+    ) {
+      playerTouchedCustomTrapdoor(gridEntity, trapdoorDescription, player);
+      return; // Prevent two players from touching the same entity.
+    }
+  }
+}
+
+function canPlayerInteractWithTrapdoor(player: EntityPlayer) {
+  // Players cannot interact with stage travel entities when items are queued or while playing
+  // certain animations.
+  const sprite = player.GetSprite();
+  const animation = sprite.GetAnimation();
+  return (
+    !player.IsHoldingItem() &&
+    !ANIMATIONS_THAT_PREVENT_STAGE_TRAVEL.has(animation)
+  );
+}
+
+function playerTouchedCustomTrapdoor(
+  gridEntity: GridEntity,
+  trapdoorDescription: CustomTrapdoorDescription,
+  player: EntityPlayer,
+) {
+  v.run.state = StageTravelState.PLAYERS_JUMPING_DOWN;
+  v.run.destination = trapdoorDescription.destination;
+
+  disableAllInputs(CUSTOM_TRAPDOOR_FEATURE_NAME);
+  setPlayerAttributes(player, gridEntity.Position);
+  dropTaintedForgotten(player);
+
+  player.PlayExtraAnimation("Trapdoor");
+
+  const otherPlayers = getOtherPlayers(player);
+  otherPlayers.forEach((otherPlayer, i) => {
+    const gameFramesToWaitBeforeJumping =
+      OTHER_PLAYER_TRAPDOOR_JUMP_DELAY_GAME_FRAMES * (i + 1);
+    const otherPlayerPtr = EntityPtr(otherPlayer);
+    runInNGameFrames(() => {
+      startDelayedJump(otherPlayerPtr, gridEntity.Position);
+    }, gameFramesToWaitBeforeJumping);
+  });
+}
+
+function startDelayedJump(entityPtr: EntityPtr, trapdoorPosition: Vector) {
+  const entity = entityPtr.Ref;
+  if (entity === undefined) {
+    return;
+  }
+
+  const player = entity.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  player.PlayExtraAnimation("Trapdoor");
+
+  adjustPlayerVelocityToTrapdoor(entityPtr, player.Position, trapdoorPosition);
+}
+
+function adjustPlayerVelocityToTrapdoor(
+  entityPtr: EntityPtr,
+  startPos: Vector,
+  endPos: Vector,
+) {
+  const entity = entityPtr.Ref;
+  if (entity === undefined) {
+    return;
+  }
+
+  const player = entity.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  const sprite = player.GetSprite();
+  if (sprite.IsFinished("Trapdoor")) {
+    return;
+  }
+
+  const frame = sprite.GetFrame();
+  if (frame > OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES) {
+    // We have already arrived at the trapdoor.
+    return;
+  }
+
+  const totalDifference = endPos.sub(startPos);
+  const differencePerFrame = totalDifference.div(
+    OTHER_PLAYER_TRAPDOOR_JUMP_DURATION_GAME_FRAMES,
+  );
+  const differenceForThisFrame = differencePerFrame.mul(frame + 1);
+  const targetPosition = startPos.add(differenceForThisFrame);
+  const calculatedVelocity = player.Position.sub(targetPosition);
+
+  player.Velocity = calculatedVelocity;
+
+  runNextGameFrame(() => {
+    adjustPlayerVelocityToTrapdoor(entityPtr, startPos, endPos);
+  });
+}
+
+function setPlayerAttributes(trapdoorPlayer: EntityPlayer, position: Vector) {
+  // Snap the player to the exact position of the trapdoor so that they cleanly jump down the hole.
+  trapdoorPlayer.Position = position;
+
+  for (const player of getPlayers()) {
+    // Freeze all players.
+    player.Velocity = VectorZero;
+
+    // We don't want enemy attacks to move the players.
+    player.EntityCollisionClass = EntityCollisionClass.NONE;
+  }
+}
+
+function dropTaintedForgotten(player: EntityPlayer) {
+  if (isCharacter(player, PlayerType.THE_FORGOTTEN_B)) {
+    const taintedSoul = player.GetOtherTwin();
+    if (taintedSoul !== undefined) {
+      taintedSoul.ThrowHeldEntity(VectorZero);
+    }
+  }
+}

package/src/features/customTrapdoor/v.ts

@@ -1,20 +1,26 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+import { DefaultMap } from "../../classes/DefaultMap";
 import { StageTravelState } from "../../enums/private/StageTravelState";
 import { CustomTrapdoorDescription } from "../../interfaces/private/CustomTrapdoorDescription";
 
 const v = {
   run: {
     state: StageTravelState.NONE,
+
+    /** The render frame that this state was reached. */
+    stateRenderFrame: null as int | null,
+
+    destination: null as
+      | [stage: LevelStage, stageType: StageType]
+      | string
+      | null,
   },
 
-  room: {
-    /** Indexed by grid index. */
-    trapdoors: new Map<int, CustomTrapdoorDescription>(),
+  level: {
+    /** Indexed by room list index and grid index. */
+    trapdoors: new DefaultMap<int, Map<int, CustomTrapdoorDescription>>(
+      () => new Map(),
+    ),
   },
 };
-
-export function getCustomTrapdoorDescription(
-  gridEntity: GridEntity,
-): CustomTrapdoorDescription | undefined {
-  const gridIndex = gridEntity.GetGridIndex();
-  return v.room.trapdoors.get(gridIndex);
-}
+export default v;

package/src/features/deployJSONRoom.ts

@@ -161,7 +161,7 @@ function preUseItemWeNeedToGoDeeper(
     fillRoomWithDecorations();
   });
 
-  // Cancel the effect.
+  // Cancel the original effect.
   return true;
 }
 

package/src/features/extraConsoleCommands/init.ts

@@ -8,6 +8,7 @@ import {
 } from "isaac-typescript-definitions";
 import { ModUpgraded } from "../../classes/ModUpgraded";
 import { MAX_SPEED_STAT } from "../../constants";
+import { bitFlags } from "../../functions/flag";
 import { getMapPartialMatch } from "../../functions/map";
 import { printConsole } from "../../functions/utils";
 import { debugDisplayInit } from "../debugDisplay/debugDisplay";
@@ -349,8 +350,10 @@ function entityTakeDmgPlayer() {
 }
 
 // ModCallback.POST_CURSE_EVAL (12)
-function postCurseEval(curses: int) {
-  return v.persistent.disableCurses ? LevelCurse.NONE : curses;
+function postCurseEval(
+  curses: BitFlags<LevelCurse>,
+): BitFlags<LevelCurse> | undefined {
+  return v.persistent.disableCurses ? bitFlags(LevelCurse.NONE) : curses;
 }
 
 // ModCallback.EXECUTE_CMD (22)

package/src/features/saveDataManager/main.ts

@@ -171,7 +171,7 @@ function clearAndCopyAllElements(
 ) {
   clearTable(oldTable);
 
-  for (const [key, value] of pairs(newTable)) {
+  for (const [key, value] of newTable) {
     oldTable.set(key, value);
   }
 }

package/src/features/taintedLazarusPlayers.ts

@@ -2,29 +2,39 @@
 // Lazarus.
 
 import { ModCallback, PlayerType } from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
 import { errorIfFeaturesNotInitialized } from "../featuresInitialized";
+import { logError } from "../functions/log";
 import { saveDataManager } from "./saveDataManager/exports";
 
 const FEATURE_NAME = "taintedLazarusPlayers";
 
 const v = {
   run: {
-    queuedTaintedLazarus: [] as EntityPtr[],
-    queuedDeadTaintedLazarus: [] as EntityPtr[],
+    queuedTaintedLazarus: [] as EntityPlayer[],
+    queuedDeadTaintedLazarus: [] as EntityPlayer[],
 
     /**
-     * The PostPlayerInit callback fires for Dead Tainted Lazarus at the beginning of the run.
+     * The `POST_PLAYER_INIT` callback fires for Dead Tainted Lazarus at the beginning of the run.
      * However, the player index for the Dead Tainted Lazarus player object at that time does not
      * actually correspond to the player index for the real player once Flip has been used. Thus, we
      * revert to using PtrHash as an index for our map, which is consistent between the Dead Tainted
-     * Lazarus object in the PostPlayerInit callback and the "real" Dead Tainted Lazarus.
+     * Lazarus object in the `POST_PLAYER_INIT` callback and the "real" Dead Tainted Lazarus.
+     *
+     * We use `EntityPlayer` as the value for the map instead of `EntityPtr` because using the
+     * pointer does not work for some reason. (When we unwrap it after one or more flips have been
+     * used, the pointers no longer point to the original objects, even if we manually update the
+     * pointers in the `POST_FLIP` callback.)
      */
-    subPlayerMap: new Map<PtrHash, EntityPtr>(),
+    subPlayerMap: new Map<PtrHash, EntityPlayer>(),
   },
 };
 
 /** @internal */
-export function taintedLazarusPlayersInit(mod: Mod): void {
+export function taintedLazarusPlayersInit(mod: ModUpgraded): void {
+  // `EntityPtr` is not serializable, so we cannot save data. However, this is inconsequential,
+  // since the `POST_PLAYER_INIT` callback will fire when a run is continued, which will repopulate
+  // the `subPlayerMap`.
   saveDataManager(FEATURE_NAME, v, () => false);
 
   mod.AddCallback(ModCallback.POST_PLAYER_INIT, postPlayerInit);
@@ -32,13 +42,12 @@ export function taintedLazarusPlayersInit(mod: Mod): void {
 
 // ModCallback.POST_PLAYER_INIT (9)
 function postPlayerInit(player: EntityPlayer) {
-  const entityPtr = EntityPtr(player);
   const character = player.GetPlayerType();
 
   if (character === PlayerType.LAZARUS_B) {
-    v.run.queuedTaintedLazarus.push(entityPtr);
+    v.run.queuedTaintedLazarus.push(player);
   } else if (character === PlayerType.LAZARUS_2_B) {
-    v.run.queuedDeadTaintedLazarus.push(entityPtr);
+    v.run.queuedDeadTaintedLazarus.push(player);
   } else {
     return;
   }
@@ -47,6 +56,8 @@ function postPlayerInit(player: EntityPlayer) {
 }
 
 /**
+ * Indexes are the `PtrHash`, values are the `EntityPtr` of the *other* Lazarus.
+ *
  * When starting a run, the PostPlayerInit callback will fire first for Dead Tainted Lazarus, then
  * for Tainted Lazarus. When continuing a run, the PostPlayerInit callback will fire first for the
  * character that is currently active. Thus, since the order of the characters is not certain, we
@@ -61,15 +72,8 @@ function checkDequeue() {
     return;
   }
 
-  const taintedLazarusPtr = v.run.queuedTaintedLazarus.shift();
-  const deadTaintedLazarusPtr = v.run.queuedDeadTaintedLazarus.shift();
-
-  if (taintedLazarusPtr === undefined || deadTaintedLazarusPtr === undefined) {
-    return;
-  }
-
-  const taintedLazarus = taintedLazarusPtr.Ref;
-  const deadTaintedLazarus = deadTaintedLazarusPtr.Ref;
+  const taintedLazarus = v.run.queuedTaintedLazarus.shift();
+  const deadTaintedLazarus = v.run.queuedDeadTaintedLazarus.shift();
 
   if (taintedLazarus === undefined || deadTaintedLazarus === undefined) {
     return;
@@ -78,8 +82,15 @@ function checkDequeue() {
   const taintedLazarusPtrHash = GetPtrHash(taintedLazarus);
   const deadTaintedLazarusPtrHash = GetPtrHash(deadTaintedLazarus);
 
-  v.run.subPlayerMap.set(taintedLazarusPtrHash, deadTaintedLazarusPtr);
-  v.run.subPlayerMap.set(deadTaintedLazarusPtrHash, taintedLazarusPtr);
+  if (taintedLazarusPtrHash === deadTaintedLazarusPtrHash) {
+    logError(
+      "Failed to cache the Tainted Lazarus player objects, since the hash for Tainted Lazarus and Dead Tainted Lazarus were the same.",
+    );
+    return;
+  }
+
+  v.run.subPlayerMap.set(taintedLazarusPtrHash, deadTaintedLazarus);
+  v.run.subPlayerMap.set(deadTaintedLazarusPtrHash, taintedLazarus);
 }
 
 /**
@@ -99,15 +110,5 @@ export function getTaintedLazarusSubPlayer(
   errorIfFeaturesNotInitialized(FEATURE_NAME);
 
   const ptrHash = GetPtrHash(player);
-  const entityPtr = v.run.subPlayerMap.get(ptrHash);
-  if (entityPtr === undefined) {
-    return undefined;
-  }
-
-  const entity = entityPtr.Ref;
-  if (entity === undefined) {
-    return undefined;
-  }
-
-  return entity.ToPlayer();
+  return v.run.subPlayerMap.get(ptrHash);
 }

package/src/functions/deepCopy.ts

@@ -550,8 +550,8 @@ function getCopiedEntries(
   entries: Array<[key: AnyNotNil, value: unknown]>;
   convertedNumberKeysToStrings: boolean;
 } {
-  // First, shallow copy the entries. We cannot use "pairs" to iterate over a Map or Set. We cannot
-  // use "[...pairs(object)]", as it results in a run-time error.
+  // First, shallow copy the entries. We cannot use "pairs" to iterate over a `Map` or `Set`. We
+  // cannot use "[...pairs(object)]", as it results in a run-time error.
   const entries: Array<[key: AnyNotNil, value: unknown]> = [];
   if (isTSTLMap(object) || isTSTLSet(object) || isDefaultMap(object)) {
     for (const [key, value] of object.entries()) {

package/src/functions/entities.ts

@@ -181,7 +181,7 @@ function setPrimitiveEntityFields(
     error('Failed to get the "__propget" table for an entity.');
   }
 
-  for (const [key] of pairs(propGetTable)) {
+  for (const [key] of propGetTable) {
     // The values of this table are functions. Thus, we use the key to index the original entity.
     const indexKey = key as keyof typeof entity;
     const value = entity[indexKey];

package/src/functions/playerIndex.ts

@@ -28,6 +28,18 @@ export function getAllPlayers(): EntityPlayer[] {
   return players;
 }
 
+/**
+ * Helper function to get all of the other players in the room besides the one provided. (This
+ * includes "child" players.)
+ */
+export function getOtherPlayers(player: EntityPlayer): EntityPlayer[] {
+  const playerPtrHash = GetPtrHash(player);
+  const players = getAllPlayers();
+  return players.filter(
+    (otherPlayer) => GetPtrHash(otherPlayer) !== playerPtrHash,
+  );
+}
+
 /**
  * Helper function to get the corresponding `EntityPlayer` object that corresponds to a
  * `PlayerIndex`.

package/src/functions/rng.ts

@@ -142,7 +142,7 @@ export function setAllRNGToSeed(object: unknown, seed: Seed): void {
   }
 
   let setAtLeastOneSeed = false;
-  for (const [_key, value] of pairs(object)) {
+  for (const [_key, value] of object) {
     if (isRNG(value)) {
       setSeed(value, seed);
       setAtLeastOneSeed = true;

package/src/functions/table.ts

@@ -4,8 +4,8 @@ import { isBoolean, isNumber, isString } from "./types";
  * In a `Map`, you can use the `clear` method to delete every element. However, in a `LuaMap`, the
  * `clear` method does not exist. Use this helper function as a drop-in replacement for this.
  */
-export function clearTable(luaMap: LuaMap): void {
-  for (const [key] of pairs(luaMap)) {
+export function clearTable(luaMap: LuaMap<AnyNotNil, unknown>): void {
+  for (const [key] of luaMap) {
     luaMap.delete(key);
   }
 }

package/src/initFeatures.ts

@@ -4,6 +4,7 @@ import { characterStatsInit } from "./features/characterStats";
 import { collectibleItemPoolTypeInit } from "./features/collectibleItemPoolType";
 import { customGridEntityInit } from "./features/customGridEntity";
 import { customStageInit } from "./features/customStage/init";
+import { customTrapdoorInit } from "./features/customTrapdoor/init";
 import { deployJSONRoomInit } from "./features/deployJSONRoom";
 import { disableAllSoundInit } from "./features/disableAllSound";
 import { disableInputsInit } from "./features/disableInputs";
@@ -38,6 +39,7 @@ function initFeaturesMajor(mod: ModUpgraded) {
 }
 
 function initFeaturesMinor(mod: ModUpgraded) {
+  customTrapdoorInit(mod);
   disableAllSoundInit(mod);
   disableInputsInit(mod);
   fadeInRemoverInit(mod);

package/src/interfaces/CustomGridEntityData.ts

@@ -4,10 +4,15 @@ import {
 } from "isaac-typescript-definitions";
 
 export interface CustomGridEntityData {
+  /**
+   * This is not a real `GridEntityType`; rather it is an arbitrary integer selected by end-user
+   * mods.
+   */
   gridEntityTypeCustom: GridEntityType;
+
   roomListIndex: int;
   gridIndex: int;
   anm2Path: string;
-  defaultAnimation: string;
+  defaultAnimation?: string;
   gridCollisionClass: GridCollisionClass;
 }

package/src/interfaces/private/CustomTrapdoorDescription.ts

@@ -1,3 +1,7 @@
+import { LevelStage, StageType } from "isaac-typescript-definitions";
+
 export interface CustomTrapdoorDescription {
+  open: boolean;
+  destination: [stage: LevelStage, stageType: StageType] | string;
   firstSpawn: boolean;
 }