isaacscript-common 4.0.0 → 4.0.1-dev.0

package/callbacks/postCursedTeleport.ts

@@ -0,0 +1,183 @@
+import {
+  CollectibleType,
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  PlayerVariant,
+  RoomType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { hasFlag } from "../functions/flag";
+import { getPlayerNumHitsRemaining } from "../functions/player";
+import { mapGetPlayer, mapSetPlayer } from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postCursedTeleportFire,
+  postCursedTeleportHasSubscriptions,
+} from "./subscriptions/postCursedTeleport";
+
+const v = {
+  run: {
+    playersDamageFrameMap: new Map<
+      PlayerIndex,
+      [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
+    >(),
+  },
+
+  level: {
+    numSacrifices: 0,
+  },
+};
+
+/** @internal */
+export function postCursedTeleportInit(mod: Mod): void {
+  saveDataManager("postCursedTeleport", v, hasSubscriptions);
+
+  mod.AddCallback(
+    ModCallback.ENTITY_TAKE_DMG,
+    entityTakeDmgPlayer,
+    EntityType.PLAYER,
+  ); // 11
+
+  mod.AddCallback(
+    ModCallback.POST_PLAYER_RENDER,
+    postPlayerRenderPlayer,
+    PlayerVariant.PLAYER, // Co-op babies cannot perform Cursed Eye teleports
+  ); // 32
+}
+
+function hasSubscriptions() {
+  return postCursedTeleportHasSubscriptions();
+}
+
+// ModCallback.ENTITY_TAKE_DMG (11)
+// EntityType.PLAYER (1)
+function entityTakeDmgPlayer(
+  tookDamage: Entity,
+  _damageAmount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  _damageSource: EntityRef,
+  _damageCountdownFrames: int,
+) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame
+  setDamageFrame(tookDamage, damageFlags);
+}
+
+function setDamageFrame(tookDamage: Entity, damageFlags: BitFlags<DamageFlag>) {
+  const gameFrameCount = game.GetFrameCount();
+
+  const player = tookDamage.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  // Don't do anything if we already activated the callback on this frame.
+  const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
+  if (trackingArray !== undefined) {
+    const [lastDamageFrame, callbackFiredOnThisFrame] = trackingArray;
+    if (lastDamageFrame === gameFrameCount && callbackFiredOnThisFrame) {
+      return;
+    }
+  }
+
+  // Don't do anything if this could be a Sacrifice Room teleport.
+  if (isPotentialNaturalTeleportFromSacrificeRoom(damageFlags)) {
+    return;
+  }
+
+  const newTrackingArray = [gameFrameCount, false];
+  mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
+}
+
+function isPotentialNaturalTeleportFromSacrificeRoom(
+  damageFlags: BitFlags<DamageFlag>,
+) {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+  // Don't record the frame if we are potentially going to the Angel Room or the Dark Room from a
+  // Sacrifice Room.
+  return (
+    roomType === RoomType.SACRIFICE &&
+    isSpikeDamage &&
+    (v.level.numSacrifices === 6 || v.level.numSacrifices >= 12)
+  );
+}
+
+function incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>) {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+  if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+    v.level.numSacrifices += 1;
+  }
+}
+
+// ModCallback.POST_PLAYER_RENDER (32)
+// PlayerVariant.PLAYER (0)
+function postPlayerRenderPlayer(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // Retrieve information about this player.
+  const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
+  if (trackingArray === undefined) {
+    return;
+  }
+  const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
+
+  if (!playerIsTeleportingFromCursedTeleport(player, lastDamageFrame)) {
+    return;
+  }
+
+  // Do nothing if the callback already fired on this frame.
+  if (callbackActivatedOnThisFrame) {
+    return;
+  }
+
+  const gameFrameCount = game.GetFrameCount();
+  const newTrackingArray = [gameFrameCount, true];
+  mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
+
+  postCursedTeleportFire(player);
+}
+
+function playerIsTeleportingFromCursedTeleport(
+  player: EntityPlayer,
+  lastDamageFrame: int,
+) {
+  // Check to see if this is the frame that we last took damage.
+  const gameFrameCount = game.GetFrameCount();
+  if (gameFrameCount !== lastDamageFrame) {
+    return false;
+  }
+
+  // Check to see if this is the 1st frame that we are teleporting.
+  const sprite = player.GetSprite();
+  if (
+    !sprite.IsPlaying("TeleportUp") ||
+    sprite.GetFrame() !== 1 // The 0th frame never fires
+  ) {
+    return false;
+  }
+
+  if (player.HasCollectible(CollectibleType.CURSED_EYE)) {
+    return true;
+  }
+
+  const numHitsRemaining = getPlayerNumHitsRemaining(player);
+  if (player.HasTrinket(TrinketType.CURSED_SKULL) && numHitsRemaining === 1) {
+    return true;
+  }
+
+  return false;
+}

package/callbacks/postCustomDoorEnter.lua

@@ -25,8 +25,6 @@ local getEffects = ____entitySpecific.getEffects
 local spawnEffect = ____entitySpecific.spawnEffect
 local ____player = require("functions.player")
 local getClosestPlayer = ____player.getClosestPlayer
-local ____utils = require("functions.utils")
-local ensureAllCases = ____utils.ensureAllCases
 local ____postCustomDoorEnter = require("callbacks.subscriptions.postCustomDoorEnter")
 local postCustomDoorEnterFire = ____postCustomDoorEnter.postCustomDoorEnterFire
 local postCustomDoorEnterHasSubscriptions = ____postCustomDoorEnter.postCustomDoorEnterHasSubscriptions
@@ -130,11 +128,6 @@ function isPlayerPastDoorThreshold(self, effect, player, direction)
                 return player.Position.X <= effect.Position.X
             end
         end
-        do
-            do
-                return ensureAllCases(nil, direction)
-            end
-        end
     until true
 end
 function postRoomClearChanged(self, roomClear, effectVariant)

package/callbacks/postCustomDoorEnter.ts

@@ -0,0 +1,292 @@
+/* eslint-disable sort-exports/sort-exports */
+
+import {
+  Direction,
+  DoorSlot,
+  DoorState,
+  EffectVariant,
+  GridCollisionClass,
+  GridEntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { directionToVector } from "../functions/direction";
+import { doorSlotToDirection } from "../functions/doors";
+import { getEffects, spawnEffect } from "../functions/entitySpecific";
+import { getClosestPlayer } from "../functions/player";
+import {
+  postCustomDoorEnterFire,
+  postCustomDoorEnterHasSubscriptions,
+} from "./subscriptions/postCustomDoorEnter";
+
+interface CustomDoorData {
+  slot: DoorSlot;
+  state: DoorState;
+}
+
+const POSITION_OFFSET_MULTIPLIER = -23;
+
+const initializedEffectVariants = new Set<int>();
+
+const v = {
+  room: {
+    customDoors: new Map<PtrHash, CustomDoorData>(),
+    customDoorSlots: new Set<DoorSlot>(),
+  },
+};
+
+/** @internal */
+export function postCustomDoorEnterInit(): void {
+  saveDataManager("postCustomDoorEnter", v, hasSubscriptions);
+}
+
+function hasSubscriptions() {
+  return postCustomDoorEnterHasSubscriptions();
+}
+
+/**
+ * `isaacscript-common` provides custom doors that can be spawned where any wall segment is. If you
+ * use this feature, you must first call this initialization function at the beginning of your mod.
+ *
+ * Each kind of custom door that you create must have an entry in the "content/entities2.xml" file,
+ * like so:
+ *
+ * ```xml
+ * <entity id="1000" name="Foo Custom Door" anm2path="grid/door_foo.anm2" />
+ * ```
+ *
+ * (Custom door entities must have an id of "1000", which corresponds to an effect. If you do not
+ * specify the variant, then the game will automatically assign it.)
+ *
+ * Next, pass the variant into this function:
+ *
+ * ```ts
+ * const modVanilla = RegisterMod("My Mod", 1);
+ * const mod = upgradeMod(modVanilla);
+ * const fooEffectVariant = Isaac.GetEntityVariantByName("Foo Custom Door");
+ * initCustomDoor(mod, fooEffectVariant);
+ * ```
+ *
+ * Also see the `spawnCustomDoor` function.
+ */
+export function initCustomDoor(
+  mod: ModUpgraded,
+  effectVariant: EffectVariant,
+): void {
+  initializedEffectVariants.add(effectVariant);
+
+  mod.AddCallback(
+    ModCallback.POST_EFFECT_UPDATE,
+    postEffectUpdaterCustomEntity,
+    effectVariant,
+  ); // 55
+
+  mod.AddCallback(
+    ModCallback.POST_EFFECT_RENDER,
+    postEffectRenderCustomEntity,
+    effectVariant,
+  ); // 56
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_ROOM_CLEAR_CHANGED,
+    (roomClear: boolean) => {
+      postRoomClearChanged(roomClear, effectVariant);
+    },
+  );
+}
+
+// ModCallback.POST_EFFECT_UPDATE (55)
+function postEffectUpdaterCustomEntity(effect: EntityEffect) {
+  const ptrHash = GetPtrHash(effect);
+  const doorData = v.room.customDoors.get(ptrHash);
+  if (doorData === undefined) {
+    return;
+  }
+
+  if (doorData.state === (effect.State as DoorState)) {
+    return;
+  }
+  doorData.state = effect.State as DoorState;
+
+  doorChangedState(effect);
+}
+
+function doorChangedState(effect: EntityEffect) {
+  const room = game.GetRoom();
+
+  const sprite = effect.GetSprite();
+  const animation = getAnimationForCustomDoor(effect);
+  sprite.Play(animation, true);
+
+  const gridIndex = room.GetGridIndex(effect.Position);
+  const wall = room.GetGridEntity(gridIndex);
+  if (wall !== undefined) {
+    wall.CollisionClass =
+      (effect.State as DoorState) === DoorState.OPEN
+        ? GridCollisionClass.WALL_EXCEPT_PLAYER
+        : GridCollisionClass.WALL;
+  }
+}
+
+function getAnimationForCustomDoor(effect: EntityEffect): string {
+  const freshlySpawned = effect.FrameCount === 0;
+
+  switch (effect.State as DoorState) {
+    case DoorState.OPEN: {
+      return freshlySpawned ? "Opened" : "Open";
+    }
+
+    case DoorState.CLOSED: {
+      return freshlySpawned ? "Closed" : "Close";
+    }
+
+    default: {
+      return "Opened";
+    }
+  }
+}
+
+// ModCallback.POST_EFFECT_RENDER (56)
+function postEffectRenderCustomEntity(effect: EntityEffect) {
+  const ptrHash = GetPtrHash(effect);
+  const doorData = v.room.customDoors.get(ptrHash);
+  if (doorData === undefined) {
+    return;
+  }
+
+  const direction = doorSlotToDirection(doorData.slot);
+  const player = getClosestPlayer(effect.Position);
+  if (isPlayerPastDoorThreshold(effect, player, direction)) {
+    postCustomDoorEnterFire(player, effect.Variant, doorData.slot, direction);
+  }
+}
+
+function isPlayerPastDoorThreshold(
+  effect: EntityEffect,
+  player: EntityPlayer,
+  direction: Direction,
+) {
+  switch (direction) {
+    case Direction.NO_DIRECTION: {
+      return false;
+    }
+
+    // 1
+    case Direction.UP: {
+      return player.Position.Y <= effect.Position.Y;
+    }
+
+    // 2
+    case Direction.RIGHT: {
+      return player.Position.X >= effect.Position.X;
+    }
+
+    // 3
+    case Direction.DOWN: {
+      return player.Position.Y >= effect.Position.Y;
+    }
+
+    // 4
+    case Direction.LEFT: {
+      return player.Position.X <= effect.Position.X;
+    }
+  }
+}
+
+// ModCallbackCustom.POST_ROOM_CLEAR_CHANGED
+function postRoomClearChanged(
+  roomClear: boolean,
+  effectVariant: EffectVariant,
+) {
+  const state = roomClear ? DoorState.OPEN : DoorState.CLOSED;
+  const customDoors = getEffects(effectVariant);
+  for (const customDoor of customDoors) {
+    customDoor.State = state;
+  }
+}
+
+/**
+ * Helper function to spawn a custom door. This is intended to be called from the `POST_NEW_ROOM`
+ * callback when the player enters a room that should have a custom door. (You could also call it
+ * from another callback if you want the door to appear e.g. after clearing all enemies.)
+ *
+ * Like other entities, the door is not persistent, so you must spawn it every time when re-entering
+ * the room.
+ *
+ * Handle when a player enters the door by hooking the custom `POST_CUSTOM_DOOR_ENTER` callback.
+ *
+ * The custom door is an `EntityEffect`. You can manually open or close the door by modifying its
+ * state. (The values to use correspond to the `DoorState` enum.)
+ *
+ * This function will throw a runtime error if:
+ * - the door slot already has a vanilla door
+ * - the door slot already has a custom door
+ * - the tile at the door slot does not have a wall
+ *
+ * Before using this function, you must first initialize the effect/door variant with the
+ * `initCustomDoor` function.
+ */
+export function spawnCustomDoor(
+  effectVariant: EffectVariant,
+  doorSlot: DoorSlot,
+): EntityEffect {
+  if (!initializedEffectVariants.has(effectVariant)) {
+    error(
+      'In order to spawn custom doors, you must first initialize them with the "initCustomDoor" function at the beginning of your mod.',
+    );
+  }
+
+  if (v.room.customDoorSlots.has(doorSlot)) {
+    error(
+      `There is already a custom door initialized on door slot: ${doorSlot}`,
+    );
+  }
+
+  const room = game.GetRoom();
+  const roomClear = room.IsClear();
+  const position = room.GetDoorSlotPosition(doorSlot);
+  const gridEntity = room.GetGridEntityFromPos(position);
+  if (gridEntity === undefined) {
+    error(
+      `Failed to initialize a custom door at slot ${doorSlot} because the wall on that tile does not exist.`,
+    );
+  }
+
+  const gridEntityType = gridEntity.GetType();
+  if (gridEntityType !== GridEntityType.WALL) {
+    error(
+      `Failed to initialize a custom door at slot ${doorSlot} because there is another grid entity on that tile with a type of: ${gridEntityType}`,
+    );
+  }
+
+  const effect = spawnEffect(effectVariant, 0, position);
+
+  // Do initial setup for the door.
+  effect.State = roomClear ? DoorState.OPEN : DoorState.CLOSED;
+  effect.RenderZOffset = -10000;
+  effect.PositionOffset = getPositionOffset(doorSlot);
+  const sprite = effect.GetSprite();
+  sprite.Rotation = (doorSlot as int) * 90 - 90;
+
+  // Keep track of metadata about this door.
+  const ptrHash = GetPtrHash(effect);
+  const doorData: CustomDoorData = {
+    slot: doorSlot,
+    state: effect.State,
+  };
+  v.room.customDoors.set(ptrHash, doorData);
+  v.room.customDoorSlots.add(doorSlot);
+
+  doorChangedState(effect);
+
+  return effect;
+}
+
+function getPositionOffset(doorSlot: DoorSlot) {
+  const direction = doorSlotToDirection(doorSlot);
+  const vector = directionToVector(direction);
+  return vector.mul(POSITION_OFFSET_MULTIPLIER);
+}

package/callbacks/postDiceRoomActivated.ts

@@ -0,0 +1,60 @@
+import {
+  DiceFloorSubType,
+  EffectVariant,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { isCloseEnoughToTriggerDiceFloor } from "../functions/effects";
+import { getClosestPlayer } from "../functions/player";
+import {
+  postDiceRoomActivatedFire,
+  postDiceRoomActivatedHasSubscriptions,
+} from "./subscriptions/postDiceRoomActivated";
+
+const v = {
+  room: {
+    diceRoomActivated: false,
+  },
+};
+
+/** @internal */
+export function postDiceRoomActivatedInit(mod: Mod): void {
+  saveDataManager("postDiceRoomActivated", v, hasSubscriptions);
+
+  mod.AddCallback(
+    ModCallback.POST_EFFECT_UPDATE,
+    postEffectUpdateDiceFloor,
+    EffectVariant.DICE_FLOOR,
+  ); // 55
+}
+
+function hasSubscriptions() {
+  return postDiceRoomActivatedHasSubscriptions();
+}
+
+// ModCallback.POST_EFFECT_UPDATE (55)
+// EffectVariant.DICE_FLOOR (76)
+function postEffectUpdateDiceFloor(effect: EntityEffect) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  if (v.room.diceRoomActivated) {
+    return;
+  }
+
+  // When using the debug console to go to a dice room, the player can appear on top of the dice
+  // floor before they snap to the door.
+  if (effect.FrameCount === 0) {
+    return;
+  }
+
+  const closestPlayer = getClosestPlayer(effect.Position);
+  if (isCloseEnoughToTriggerDiceFloor(closestPlayer, effect)) {
+    v.room.diceRoomActivated = true;
+    postDiceRoomActivatedFire(
+      closestPlayer,
+      effect.SubType as DiceFloorSubType,
+    );
+  }
+}

package/callbacks/postDoorRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getDoors } from "../functions/doors";
+import {
+  postDoorRenderFire,
+  postDoorRenderHasSubscriptions,
+} from "./subscriptions/postDoorRender";
+
+/** @internal */
+export function postDoorRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postDoorRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const doors of getDoors()) {
+    postDoorRenderFire(doors);
+  }
+}

package/callbacks/postDoorUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getDoors } from "../functions/doors";
+import {
+  postDoorUpdateFire,
+  postDoorUpdateHasSubscriptions,
+} from "./subscriptions/postDoorUpdate";
+
+/** @internal */
+export function postDoorUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postDoorUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const doors of getDoors()) {
+    postDoorUpdateFire(doors);
+  }
+}

package/callbacks/postEffectInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postEffectInitLateFire,
+  postEffectInitLateHasSubscriptions,
+} from "./subscriptions/postEffectInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postEffectInitLateInit(mod: Mod): void {
+  saveDataManager("postEffectInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_EFFECT_UPDATE, postEffectUpdate); // 55
+}
+
+function hasSubscriptions() {
+  return postEffectInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_EFFECT_UPDATE (55)
+function postEffectUpdate(effect: EntityEffect) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(effect);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postEffectInitLateFire(effect);
+  }
+}

package/callbacks/postEffectStateChanged.ts

@@ -0,0 +1,43 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postEffectStateChangedFire,
+  postEffectStateChangedHasSubscriptions,
+} from "./subscriptions/postEffectStateChanged";
+
+const v = {
+  run: {
+    effectStateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
+/** @internal */
+export function postEffectStateChangedInit(mod: Mod): void {
+  saveDataManager("postEffectStateChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_EFFECT_UPDATE, postEffectUpdate); // 55
+}
+
+function hasSubscriptions() {
+  return postEffectStateChangedHasSubscriptions();
+}
+
+// ModCallback.POST_EFFECT_UPDATE (55)
+function postEffectUpdate(effect: EntityEffect) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const ptrHash = GetPtrHash(effect);
+  const previousState = v.run.effectStateMap.getAndSetDefault(
+    ptrHash,
+    effect.State,
+  );
+  const currentState = effect.State;
+  v.run.effectStateMap.set(ptrHash, currentState);
+
+  if (previousState !== currentState) {
+    postEffectStateChangedFire(effect, previousState, currentState);
+  }
+}