isaacscript-common 4.0.0 → 4.0.3

package/callbacks/postItemDischarged.ts

@@ -0,0 +1,154 @@
+import {
+  ActiveSlot,
+  CollectibleType,
+  EntityType,
+  ModCallback,
+  SuckerVariant,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getTotalCharge } from "../functions/charge";
+import { getEnumValues } from "../functions/enums";
+import {
+  defaultMapGetPlayer,
+  mapGetPlayer,
+  mapSetPlayer,
+} from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postItemDischargeFire,
+  postItemDischargeHasSubscriptions,
+} from "./subscriptions/postItemDischarged";
+
+type ActiveSlotToCollectibleTypeMap = DefaultMap<
+  ActiveSlot,
+  CollectibleType,
+  [int]
+>;
+type ActiveSlotToChargeMap = DefaultMap<ActiveSlot, int, [int]>;
+
+const v = {
+  run: {
+    playersActiveItemMap: new DefaultMap<
+      PlayerIndex,
+      ActiveSlotToCollectibleTypeMap
+    >(() => new DefaultMap((collectibleType) => collectibleType)),
+    playersActiveChargeMap: new DefaultMap<PlayerIndex, ActiveSlotToChargeMap>(
+      () => new DefaultMap((charge) => charge),
+    ),
+  },
+
+  room: {
+    playersBulbLastCollisionFrame: new Map<PlayerIndex, int>(),
+  },
+};
+
+export function postItemDischargeInit(mod: ModUpgraded): void {
+  saveDataManager("postItemDischarge", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
+  mod.AddCallback(
+    ModCallback.PRE_NPC_COLLISION,
+    preNPCCollisionSucker,
+    EntityType.SUCKER,
+  ); // 30
+}
+
+function hasSubscriptions(): boolean {
+  return postItemDischargeHasSubscriptions();
+}
+
+// ModCallback.POST_PEFFECT_UPDATE (4)
+function postPEffectUpdate(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const activeItemMap = defaultMapGetPlayer(v.run.playersActiveItemMap, player);
+  const chargeMap = defaultMapGetPlayer(v.run.playersActiveChargeMap, player);
+
+  for (const activeSlot of getEnumValues(ActiveSlot)) {
+    const currentActiveItem = player.GetActiveItem();
+    const previousActiveItem = activeItemMap.getAndSetDefault(
+      activeSlot,
+      currentActiveItem,
+    );
+    activeItemMap.set(activeSlot, currentActiveItem);
+
+    if (currentActiveItem !== previousActiveItem) {
+      // The player swapped out their active item for something else, so it should be impossible for
+      // the discharge callback to fire on this frame.
+      continue;
+    }
+
+    const currentCharge = getTotalCharge(player, activeSlot);
+    const previousCharge = chargeMap.getAndSetDefault(
+      activeSlot,
+      currentCharge,
+    );
+    chargeMap.set(activeSlot, currentCharge);
+
+    if (playerRecentlyCollidedWithBulb(player)) {
+      continue;
+    }
+
+    if (currentCharge < previousCharge) {
+      const collectibleType = player.GetActiveItem(activeSlot);
+      postItemDischargeFire(player, collectibleType, activeSlot);
+    }
+  }
+}
+
+/**
+ * If the player collided with a Bulb on either this frame or the last frame, then assume a zap has
+ * occurred. (We do not want to fire the discharge callback if this is the case.)
+ */
+function playerRecentlyCollidedWithBulb(player: EntityPlayer) {
+  const gameFrameCount = game.GetFrameCount();
+  const bulbLastCollisionFrame = mapGetPlayer(
+    v.room.playersBulbLastCollisionFrame,
+    player,
+  );
+  const collidedOnThisFrame = gameFrameCount === bulbLastCollisionFrame;
+  const collidedOnLastFrame = gameFrameCount - 1 === bulbLastCollisionFrame;
+  return collidedOnThisFrame || collidedOnLastFrame;
+}
+
+/**
+ * ModCallback.PRE_NPC_COLLISION (30)
+ * EntityType.SUCKER (61)
+ *
+ * The algorithm for detecting a discharge is checking if the current charge is less than the charge
+ * on the previous frame. Thus, when a Bulb zaps a player and drains their charge, this will be a
+ * false position, so Bulbs have to be handled.
+ *
+ * When Bulbs zap a player, they go to `NpcState.STATE_JUMP` for a frame. However, this only happens
+ * on the frame after the player is discharged, which is too late to be of any use.
+ *
+ * Instead, we track the frames that Bulbs collide with players and assume that a collision means a
+ * zap has occurred.
+ */
+function preNPCCollisionSucker(
+  npc: EntityNPC,
+  collider: Entity,
+): boolean | undefined {
+  if (!hasSubscriptions()) {
+    return undefined;
+  }
+
+  if (npc.Variant !== (SuckerVariant.BULB as int)) {
+    return undefined;
+  }
+
+  const player = collider.ToPlayer();
+  if (player === undefined) {
+    return undefined;
+  }
+
+  const gameFrameCount = game.GetFrameCount();
+  mapSetPlayer(v.room.playersBulbLastCollisionFrame, player, gameFrameCount);
+
+  return undefined;
+}

package/callbacks/postKnifeInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postKnifeInitLateFire,
+  postKnifeInitLateHasSubscriptions,
+} from "./subscriptions/postKnifeInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postKnifeInitLateInit(mod: Mod): void {
+  saveDataManager("postKnifeInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_KNIFE_UPDATE, postKnifeUpdate); // 51
+}
+
+function hasSubscriptions() {
+  return postKnifeInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_KNIFE_UPDATE (51)
+function postKnifeUpdate(knife: EntityKnife) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(knife);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postKnifeInitLateFire(knife);
+  }
+}

package/callbacks/postLaserInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postLaserInitLateFire,
+  postLaserInitLateHasSubscriptions,
+} from "./subscriptions/postLaserInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postLaserInitLateInit(mod: Mod): void {
+  saveDataManager("postLaserInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_LASER_UPDATE, postLaserUpdate); // 35
+}
+
+function hasSubscriptions() {
+  return postLaserInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_LASER_UPDATE (48)
+function postLaserUpdate(laser: EntityLaser) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(laser);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postLaserInitLateFire(laser);
+  }
+}

package/callbacks/postNPCInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postNPCInitLateFire,
+  postNPCInitLateHasSubscriptions,
+} from "./subscriptions/postNPCInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postNPCInitLateInit(mod: Mod): void {
+  saveDataManager("postNPCInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_NPC_UPDATE, postNPCUpdate); // 0
+}
+
+function hasSubscriptions() {
+  return postNPCInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_NPC_UPDATE (0)
+function postNPCUpdate(npc: EntityNPC) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(npc);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postNPCInitLateFire(npc);
+  }
+}

package/callbacks/postNPCStateChanged.ts

@@ -0,0 +1,42 @@
+import { ModCallback, NpcState } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postNPCStateChangedFire,
+  postNPCStateChangedHasSubscriptions,
+} from "./subscriptions/postNPCStateChanged";
+
+const v = {
+  run: {
+    npcStateMap: new DefaultMap<PtrHash, NpcState, [NpcState]>(
+      (state) => state, // eslint-disable-line isaacscript/strict-enums
+    ),
+  },
+};
+
+/** @internal */
+export function postNPCStateChangedInit(mod: Mod): void {
+  saveDataManager("postNPCStateChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_NPC_UPDATE, postNPCUpdate); // 0
+}
+
+function hasSubscriptions() {
+  return postNPCStateChangedHasSubscriptions();
+}
+
+// ModCallback.POST_NPC_UPDATE (0)
+function postNPCUpdate(npc: EntityNPC) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const ptrHash = GetPtrHash(npc);
+  const previousState = v.run.npcStateMap.getAndSetDefault(ptrHash, npc.State);
+  const currentState = npc.State;
+  v.run.npcStateMap.set(ptrHash, currentState);
+
+  if (previousState !== currentState) {
+    postNPCStateChangedFire(npc, previousState, currentState);
+  }
+}

package/callbacks/postNewRoomEarly.lua

@@ -24,9 +24,10 @@ function postNewRoom(self)
 end
 function preEntitySpawn(self)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     checkRoomChanged(nil)
+    return nil
 end
 function checkRoomChanged(self)
     local room = game:GetRoom()

package/callbacks/postNewRoomEarly.ts

@@ -0,0 +1,96 @@
+import {
+  EntityType,
+  GridEntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { getTopLeftWallGridIndex, spawnGrid } from "../functions/gridEntity";
+import { logError } from "../functions/log";
+import {
+  postNewRoomEarlyFire,
+  postNewRoomEarlyHasSubscriptions,
+} from "./subscriptions/postNewRoomEarly";
+
+let currentRoomTopLeftWallPtrHash: PtrHash | null = null;
+
+/**
+ * The wall entity directly to the right of the top-left wall. We use this as a test to see if it
+ * improves the consistency of the callback firing.
+ */
+let currentRoomTopLeftWallPtrHash2: PtrHash | null = null;
+
+/** @internal */
+export function postNewRoomEarlyCallbackInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_NEW_ROOM, postNewRoom); // 19
+  mod.AddCallback(ModCallback.PRE_ENTITY_SPAWN, preEntitySpawn); // 24
+}
+
+function hasSubscriptions() {
+  return postNewRoomEarlyHasSubscriptions();
+}
+
+// ModCallback.POST_NEW_ROOM (19)
+function postNewRoom() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  checkRoomChanged();
+}
+
+// ModCallback.PRE_ENTITY_SPAWN (24)
+function preEntitySpawn(): [EntityType, int, int, int] | undefined {
+  if (!hasSubscriptions()) {
+    return undefined;
+  }
+
+  checkRoomChanged();
+
+  return undefined;
+}
+
+function checkRoomChanged() {
+  const room = game.GetRoom();
+  const topLeftWallGridIndex = getTopLeftWallGridIndex();
+  const rightOfTopWallGridIndex = topLeftWallGridIndex + 1;
+
+  let topLeftWall = room.GetGridEntity(topLeftWallGridIndex);
+  let topLeftWall2 = room.GetGridEntity(rightOfTopWallGridIndex);
+
+  // Sometimes, the PreEntitySpawn callback can fire before any grid entities in the room have
+  // spawned, which means that the top-left wall will not exist. If ths is the case, then simply
+  // spawn the top-left wall early.
+  if (topLeftWall === undefined) {
+    topLeftWall = spawnGrid(GridEntityType.WALL, topLeftWallGridIndex);
+    if (topLeftWall === undefined) {
+      logError(
+        "Failed to spawn a new wall (1) for the PostNewRoomEarly callback.",
+      );
+      return;
+    }
+  }
+
+  // For some reason, the above check will rarely fail. We duplicate the check with another wall
+  // segment to go from 99% to 100% reliability.
+  if (topLeftWall2 === undefined) {
+    topLeftWall2 = spawnGrid(GridEntityType.WALL, rightOfTopWallGridIndex);
+    if (topLeftWall2 === undefined) {
+      logError(
+        "Failed to spawn a new wall (2) for the PostNewRoomEarly callback.",
+      );
+      return;
+    }
+  }
+
+  const topLeftWallPtrHash = GetPtrHash(topLeftWall);
+  const topLeftWallPtrHash2 = GetPtrHash(topLeftWall2);
+  if (
+    topLeftWallPtrHash !== currentRoomTopLeftWallPtrHash ||
+    topLeftWallPtrHash2 !== currentRoomTopLeftWallPtrHash2
+  ) {
+    currentRoomTopLeftWallPtrHash = topLeftWallPtrHash;
+    currentRoomTopLeftWallPtrHash2 = topLeftWallPtrHash2;
+
+    postNewRoomEarlyFire();
+  }
+}

package/callbacks/postPickupCollect.ts

@@ -0,0 +1,48 @@
+// Some pickup properties cannot be retrieved properly in the PostPickupInit callback and must be
+// checked in the PostPickupUpdate callback. This fires on the first update frame.
+
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getClosestPlayer } from "../functions/player";
+import {
+  postPickupCollectFire,
+  postPickupCollectHasSubscriptions,
+} from "./subscriptions/postPickupCollect";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postPickupCollectInit(mod: Mod): void {
+  saveDataManager("postPickupCollect", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_RENDER, postPickupRender); // 36
+}
+
+function hasSubscriptions() {
+  return postPickupCollectHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_RENDER (36)
+function postPickupRender(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const sprite = pickup.GetSprite();
+  const animation = sprite.GetAnimation();
+  if (animation !== "Collect") {
+    return;
+  }
+
+  const index = GetPtrHash(pickup);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+
+    const player = getClosestPlayer(pickup.Position);
+    postPickupCollectFire(pickup, player);
+  }
+}

package/callbacks/postPickupInitFirst.ts

@@ -0,0 +1,70 @@
+import {
+  GameStateFlag,
+  ModCallback,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getRoomVisitedCount } from "../functions/roomData";
+import {
+  postPickupInitFirstFire,
+  postPickupInitFirstHasSubscriptions,
+} from "./subscriptions/postPickupInitFirst";
+
+const POST_ASCENT_ROOM_TYPES: ReadonlySet<RoomType> = new Set([
+  RoomType.TREASURE,
+  RoomType.BOSS,
+]);
+
+const v = {
+  run: {
+    postAscentPickupInitSeeds: new Set<int>(),
+  },
+};
+
+/** @internal */
+export function postPickupInitFirstInit(mod: Mod): void {
+  saveDataManager("postPickupInitFirst", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_INIT, postPickupInit); // 34
+}
+
+function hasSubscriptions() {
+  return postPickupInitFirstHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_INIT (34)
+function postPickupInit(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const roomFrameCount = room.GetFrameCount();
+
+  // First, keep track of pickups in rooms that could appear again in The Ascent.
+  const previouslySeen = v.run.postAscentPickupInitSeeds.has(pickup.InitSeed);
+  if (POST_ASCENT_ROOM_TYPES.has(roomType)) {
+    v.run.postAscentPickupInitSeeds.add(pickup.InitSeed);
+  }
+
+  if (roomFrameCount > 0) {
+    postPickupInitFirstFire(pickup);
+    return;
+  }
+
+  const roomVisitedCount = getRoomVisitedCount();
+  if (roomVisitedCount > 0) {
+    return;
+  }
+
+  // Handle the special case of a post-Ascent Treasure Room or Boss Room.
+  const onAscent = game.GetStateFlag(GameStateFlag.BACKWARDS_PATH);
+  if (onAscent && POST_ASCENT_ROOM_TYPES.has(roomType) && previouslySeen) {
+    return;
+  }
+
+  // We are entering a brand-new room.
+  postPickupInitFirstFire(pickup);
+}

package/callbacks/postPickupInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postPickupInitLateFire,
+  postPickupInitLateHasSubscriptions,
+} from "./subscriptions/postPickupInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postPickupInitLateInit(mod: Mod): void {
+  saveDataManager("postPickupInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdate); // 35
+}
+
+function hasSubscriptions() {
+  return postPickupInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_UPDATE (35)
+function postPickupUpdate(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(pickup);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postPickupInitLateFire(pickup);
+  }
+}

package/callbacks/postPickupStateChanged.ts

@@ -0,0 +1,43 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postPickupStateChangedFire,
+  postPickupStateChangedHasSubscriptions,
+} from "./subscriptions/postPickupStateChanged";
+
+const v = {
+  run: {
+    pickupStateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
+/** @internal */
+export function postPickupStateChangedInit(mod: Mod): void {
+  saveDataManager("postPickupStateChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdate); // 35
+}
+
+function hasSubscriptions() {
+  return postPickupStateChangedHasSubscriptions();
+}
+
+// ModCallback.POST_PICKUP_UPDATE (35)
+function postPickupUpdate(pickup: EntityPickup) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const ptrHash = GetPtrHash(pickup);
+  const previousState = v.run.pickupStateMap.getAndSetDefault(
+    ptrHash,
+    pickup.State,
+  );
+  const currentState = pickup.State;
+  v.run.pickupStateMap.set(ptrHash, currentState);
+
+  if (previousState !== currentState) {
+    postPickupStateChangedFire(pickup, previousState, currentState);
+  }
+}

package/callbacks/postPitRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPits } from "../functions/gridEntitySpecific";
+import {
+  postPitRenderFire,
+  postPitRenderHasSubscriptions,
+} from "./subscriptions/postPitRender";
+
+/** @internal */
+export function postPitRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postPitRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pit of getPits()) {
+    postPitRenderFire(pit);
+  }
+}

package/callbacks/postPitUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPits } from "../functions/gridEntitySpecific";
+import {
+  postPitUpdateFire,
+  postPitUpdateHasSubscriptions,
+} from "./subscriptions/postPitUpdate";
+
+/** @internal */
+export function postPitUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postPitUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pit of getPits()) {
+    postPitUpdateFire(pit);
+  }
+}