isaacscript-common 4.0.0 → 4.0.3

package/callbacks/postEsauJr.ts

@@ -0,0 +1,109 @@
+// This provides the logic for:
+// - POST_ESAU_JR
+// - POST_FIRST_ESAU_JR
+
+import {
+  CollectibleType,
+  ControllerIndex,
+  ModCallback,
+  UseFlag,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getPlayers } from "../functions/playerIndex";
+import {
+  postEsauJrFire,
+  postEsauJrHasSubscriptions,
+} from "./subscriptions/postEsauJr";
+import {
+  postFirstEsauJrFire,
+  postFirstEsauJrHasSubscriptions,
+} from "./subscriptions/postFirstEsauJr";
+
+const v = {
+  run: {
+    usedEsauJrFrame: null as int | null,
+    usedEsauJrControllerIndex: null as ControllerIndex | null,
+    usedEsauJrAtLeastOnce: false,
+  },
+};
+
+/** @internal */
+export function postEsauJrCallbacksInit(mod: Mod): void {
+  saveDataManager("postEsauJr", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+  mod.AddCallback(
+    ModCallback.POST_USE_ITEM,
+    useItemEsauJr,
+    CollectibleType.ESAU_JR,
+  ); // 3
+}
+
+function hasSubscriptions() {
+  return postEsauJrHasSubscriptions() || postFirstEsauJrHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const gameFrameCount = game.GetFrameCount();
+
+  // Check to see if it is the frame after the player has used Esau Jr.
+  if (
+    v.run.usedEsauJrFrame === null ||
+    gameFrameCount < v.run.usedEsauJrFrame + 1
+  ) {
+    return;
+  }
+  v.run.usedEsauJrFrame = null;
+
+  // Find the player corresponding to the player who used Esau Jr. a frame ago (via matching the
+  // ControllerIndex).
+  if (v.run.usedEsauJrControllerIndex === null) {
+    return;
+  }
+  const player = getPlayerWithControllerIndex(v.run.usedEsauJrControllerIndex);
+  v.run.usedEsauJrControllerIndex = null;
+  if (player === undefined) {
+    return;
+  }
+
+  if (!v.run.usedEsauJrAtLeastOnce) {
+    v.run.usedEsauJrAtLeastOnce = true;
+    postFirstEsauJrFire(player);
+  }
+
+  postEsauJrFire(player);
+}
+
+function getPlayerWithControllerIndex(controllerIndex: ControllerIndex) {
+  const players = getPlayers();
+  return players.find((player) => player.ControllerIndex === controllerIndex);
+}
+
+// ModCallback.POST_USE_ITEM (3)
+// CollectibleType.ESAU_JR (703)
+function useItemEsauJr(
+  _collectibleType: CollectibleType,
+  _rng: RNG,
+  player: EntityPlayer,
+  _useFlags: BitFlags<UseFlag>,
+  _activeSlot: int,
+  _customVarData: int,
+): boolean | undefined {
+  if (!hasSubscriptions()) {
+    return undefined;
+  }
+
+  const gameFrameCount = game.GetFrameCount();
+
+  // The player only changes to Esau Jr. on the frame after the item is used.
+  v.run.usedEsauJrFrame = gameFrameCount + 1;
+  v.run.usedEsauJrControllerIndex = player.ControllerIndex;
+
+  return undefined;
+}

package/callbacks/postFamiliarInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postFamiliarInitLateFire,
+  postFamiliarInitLateHasSubscriptions,
+} from "./subscriptions/postFamiliarInitLate";
+
+const v = {
+  run: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postFamiliarInitLateInit(mod: Mod): void {
+  saveDataManager("postFamiliarInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_FAMILIAR_UPDATE, postFamiliarUpdate); // 6
+}
+
+function hasSubscriptions() {
+  return postFamiliarInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_FAMILIAR_UPDATE (6)
+function postFamiliarUpdate(familiar: EntityFamiliar) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(familiar);
+  if (!v.run.firedSet.has(index)) {
+    v.run.firedSet.add(index);
+    postFamiliarInitLateFire(familiar);
+  }
+}

package/callbacks/postFamiliarStateChanged.ts

@@ -0,0 +1,43 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postFamiliarStateChangedFire,
+  postFamiliarStateChangedHasSubscriptions,
+} from "./subscriptions/postFamiliarStateChanged";
+
+const v = {
+  run: {
+    familiarStateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
+  },
+};
+
+/** @internal */
+export function postFamiliarStateChangedInit(mod: Mod): void {
+  saveDataManager("postFamiliarStateChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_FAMILIAR_UPDATE, postFamiliarUpdate); // 6
+}
+
+function hasSubscriptions() {
+  return postFamiliarStateChangedHasSubscriptions();
+}
+
+// ModCallback.POST_FAMILIAR_UPDATE (6)
+function postFamiliarUpdate(familiar: EntityFamiliar) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const ptrHash = GetPtrHash(familiar);
+  const previousState = v.run.familiarStateMap.getAndSetDefault(
+    ptrHash,
+    familiar.State,
+  );
+  const currentState = familiar.State;
+  v.run.familiarStateMap.set(ptrHash, currentState);
+
+  if (previousState !== currentState) {
+    postFamiliarStateChangedFire(familiar, previousState, currentState);
+  }
+}

package/callbacks/postFlip.lua

@@ -22,20 +22,21 @@ function hasSubscriptions(self)
 end
 function useItemFlip(self, _collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     if not isTaintedLazarus(nil, player) then
-        return
+        return nil
     end
     local newLazarus = getNewLazarus(nil, player)
     if newLazarus == nil then
-        return
+        return nil
     end
     if not v.run.usedFlipAtLeastOnce then
         v.run.usedFlipAtLeastOnce = true
         postFirstFlipFire(nil, newLazarus)
     end
     postFlipFire(nil, newLazarus)
+    return nil
 end
 function getNewLazarus(self, oldLazarus)
     local oldCharacter = oldLazarus:GetPlayerType()

package/callbacks/postFlip.ts

@@ -0,0 +1,90 @@
+// This provides the logic for:
+// - POST_FLIP
+// - POST_FIRST_FLIP
+
+import {
+  CollectibleType,
+  ModCallback,
+  PlayerType,
+  UseFlag,
+} from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getPlayersOfType, isTaintedLazarus } from "../functions/player";
+import {
+  postFirstFlipFire,
+  postFirstFlipHasSubscriptions,
+} from "./subscriptions/postFirstFlip";
+import {
+  postFlipFire,
+  postFlipHasSubscriptions,
+} from "./subscriptions/postFlip";
+
+const v = {
+  run: {
+    usedFlipAtLeastOnce: false,
+  },
+};
+
+/** @internal */
+export function postFlipCallbacksInit(mod: Mod): void {
+  saveDataManager("postFlip", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_USE_ITEM, useItemFlip, CollectibleType.FLIP); // 3
+}
+
+function hasSubscriptions() {
+  return postFlipHasSubscriptions() || postFirstFlipHasSubscriptions();
+}
+
+// ModCallback.POST_USE_ITEM (3)
+// CollectibleType.FLIP (711)
+function useItemFlip(
+  _collectibleType: CollectibleType,
+  _rng: RNG,
+  player: EntityPlayer,
+  _useFlags: BitFlags<UseFlag>,
+  _activeSlot: int,
+  _customVarData: int,
+): boolean | undefined {
+  if (!hasSubscriptions()) {
+    return undefined;
+  }
+
+  if (!isTaintedLazarus(player)) {
+    return undefined;
+  }
+
+  // The player passed as part of the callback will be the old Lazarus that used the Flip item. We
+  // pass the new Lazarus to the callback subscribers.
+  const newLazarus = getNewLazarus(player);
+  if (newLazarus === undefined) {
+    return undefined;
+  }
+
+  if (!v.run.usedFlipAtLeastOnce) {
+    v.run.usedFlipAtLeastOnce = true;
+    postFirstFlipFire(newLazarus);
+  }
+
+  postFlipFire(newLazarus);
+
+  return undefined;
+}
+
+function getNewLazarus(oldLazarus: EntityPlayer) {
+  const oldCharacter = oldLazarus.GetPlayerType();
+
+  let newCharacter: PlayerType;
+  if (oldCharacter === PlayerType.LAZARUS_B) {
+    newCharacter = PlayerType.LAZARUS_2_B;
+  } else if (oldCharacter === PlayerType.LAZARUS_2_B) {
+    newCharacter = PlayerType.LAZARUS_B;
+  } else {
+    error("Failed to determine the character in the postFlip callback.");
+  }
+
+  const playersOfType = getPlayersOfType(newCharacter);
+  return playersOfType.find(
+    (player) => player.FrameCount === oldLazarus.FrameCount,
+  );
+}

package/callbacks/postGreedModeWave.ts

@@ -0,0 +1,41 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postGreedModeWaveFire,
+  postGreedModeWaveHasSubscriptions,
+} from "./subscriptions/postGreedModeWave";
+
+const v = {
+  run: {
+    currentGreedWave: 0,
+  },
+};
+
+/** @internal */
+export function postGreedModeWaveInit(mod: ModUpgraded): void {
+  saveDataManager("postModeGreedWave", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postGreedModeWaveHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const level = game.GetLevel();
+  const newWave = level.GreedModeWave;
+  const oldWave = v.run.currentGreedWave;
+  v.run.currentGreedWave = newWave;
+
+  if (newWave > oldWave) {
+    postGreedModeWaveFire(oldWave, newWave);
+  }
+}

package/callbacks/postGridEntity.ts

@@ -0,0 +1,164 @@
+// This provides the logic for the following callbacks:
+// - PostGridEntityInit
+// - PostGridEntityUpdate
+// - PostGridEntityRemove
+// - PostGridEntityStateChanged
+// - PostGridEntityBroken
+
+import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  getGridEntitiesMap,
+  isGridEntityBroken,
+} from "../functions/gridEntity";
+import {
+  postGridEntityBrokenFire,
+  postGridEntityBrokenHasSubscriptions,
+} from "./subscriptions/postGridEntityBroken";
+import {
+  postGridEntityInitFire,
+  postGridEntityInitHasSubscriptions,
+} from "./subscriptions/postGridEntityInit";
+import {
+  postGridEntityRemoveFire,
+  postGridEntityRemoveHasSubscriptions,
+} from "./subscriptions/postGridEntityRemove";
+import {
+  postGridEntityStateChangedFire,
+  postGridEntityStateChangedHasSubscriptions,
+} from "./subscriptions/postGridEntityStateChanged";
+import {
+  postGridEntityUpdateFire,
+  postGridEntityUpdateHasSubscriptions,
+} from "./subscriptions/postGridEntityUpdate";
+
+type GridEntityTuple = [
+  gridEntityType: GridEntityType,
+  gridEntityVariant: int,
+  state: int,
+];
+
+const v = {
+  room: {
+    /** Indexed by grid index. */
+    initializedGridEntities: new Map<int, GridEntityTuple>(),
+  },
+};
+
+/** @internal */
+export function postGridEntityCallbacksInit(mod: ModUpgraded): void {
+  saveDataManager("postGridEntity", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
+    postNewRoomReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return (
+    postGridEntityInitHasSubscriptions() ||
+    postGridEntityUpdateHasSubscriptions() ||
+    postGridEntityRemoveHasSubscriptions() ||
+    postGridEntityStateChangedHasSubscriptions() ||
+    postGridEntityBrokenHasSubscriptions()
+  );
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const gridEntitiesMap = getGridEntitiesMap();
+
+  // We check for removed grid entities first so that grid entities that change type will count as
+  // being removed and fire the PostGridEntityRemoved callback.
+  checkGridEntitiesRemoved(gridEntitiesMap);
+
+  for (const [gridIndex, gridEntity] of gridEntitiesMap.entries()) {
+    checkGridEntityStateChanged(gridIndex, gridEntity);
+    checkNewGridEntity(gridIndex, gridEntity);
+    postGridEntityUpdateFire(gridEntity);
+  }
+}
+
+function checkGridEntitiesRemoved(gridEntitiesMap: Map<int, GridEntity>) {
+  for (const [
+    gridIndex,
+    gridEntityTuple,
+  ] of v.room.initializedGridEntities.entries()) {
+    const [storedGridEntityType, storedGridEntityVariant] = gridEntityTuple;
+    const gridEntity = gridEntitiesMap.get(gridIndex);
+    if (
+      gridEntity === undefined ||
+      gridEntity.GetType() !== storedGridEntityType
+    ) {
+      v.room.initializedGridEntities.delete(gridIndex);
+      postGridEntityRemoveFire(
+        gridIndex,
+        storedGridEntityType,
+        storedGridEntityVariant,
+      );
+    }
+  }
+}
+
+function checkGridEntityStateChanged(gridIndex: int, gridEntity: GridEntity) {
+  const gridEntityTuple = v.room.initializedGridEntities.get(gridIndex);
+  if (gridEntityTuple === undefined) {
+    // This grid entity did not exist a frame ago; we don't want to fire the state changed callback
+    // on the first frame that it exists.
+    return;
+  }
+
+  const [_gridEntityType, _gridEntityVariant, oldState] = gridEntityTuple;
+  const newState = gridEntity.State;
+  if (oldState !== newState) {
+    updateTupleInMap(gridEntity);
+    postGridEntityStateChangedFire(gridEntity, oldState, newState);
+
+    if (isGridEntityBroken(gridEntity)) {
+      postGridEntityBrokenFire(gridEntity);
+    }
+  }
+}
+
+function checkNewGridEntity(gridIndex: int, gridEntity: GridEntity) {
+  const gridEntityType = gridEntity.GetType();
+  const gridEntityTuple = v.room.initializedGridEntities.get(gridIndex);
+
+  if (gridEntityTuple === undefined || gridEntityTuple[0] !== gridEntityType) {
+    updateTupleInMap(gridEntity);
+    postGridEntityInitFire(gridEntity);
+  }
+}
+
+function updateTupleInMap(gridEntity: GridEntity) {
+  const gridEntityType = gridEntity.GetType();
+  const gridEntityVariant = gridEntity.GetVariant();
+  const gridIndex = gridEntity.GetGridIndex();
+  const newTuple: GridEntityTuple = [
+    gridEntityType,
+    gridEntityVariant,
+    gridEntity.State,
+  ];
+  v.room.initializedGridEntities.set(gridIndex, newTuple);
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const gridEntitiesMap = getGridEntitiesMap();
+
+  for (const [gridIndex, gridEntity] of gridEntitiesMap.entries()) {
+    checkNewGridEntity(gridIndex, gridEntity);
+  }
+}

package/callbacks/postGridEntityCollision.ts

@@ -0,0 +1,69 @@
+import { GridCollisionClass, ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  getCollidingEntitiesWithGridEntity,
+  getGridEntities,
+} from "../functions/gridEntity";
+import {
+  postGridEntityCollisionFire,
+  postGridEntityCollisionHasSubscriptions,
+} from "./subscriptions/postGridEntityCollision";
+
+const v = {
+  room: {
+    /** Indexed by grid entity pointer hash. */
+    collidingEntitiesMap: new DefaultMap<PtrHash, Set<PtrHash>>(
+      () => new Set(),
+    ),
+  },
+};
+
+/** @internal */
+export function postGridEntityCollisionInit(mod: Mod): void {
+  saveDataManager("postGridEntityCollision", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postGridEntityCollisionHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const gridEntities = getGridEntities();
+  const gridEntitiesWithCollision = gridEntities.filter(
+    (gridEntity) => gridEntity.CollisionClass !== GridCollisionClass.NONE,
+  );
+  for (const gridEntity of gridEntitiesWithCollision) {
+    const gridEntityPtrHash = GetPtrHash(gridEntity);
+    const oldCollidingEntities =
+      v.room.collidingEntitiesMap.getAndSetDefault(gridEntityPtrHash);
+
+    // Check for new colliding entities.
+    const collidingEntities = getCollidingEntitiesWithGridEntity(gridEntity);
+    for (const entity of collidingEntities) {
+      const entityPtrHash = GetPtrHash(entity);
+      if (!oldCollidingEntities.has(entityPtrHash)) {
+        oldCollidingEntities.add(entityPtrHash);
+        postGridEntityCollisionFire(gridEntity, entity);
+      }
+    }
+
+    // Remove old colliding entities.
+    const collidingEntitiesPtrHashes = collidingEntities.map((entity) =>
+      GetPtrHash(entity),
+    );
+    const collidingEntitiesPtrHashSet = new Set(collidingEntitiesPtrHashes);
+    for (const oldCollidingEntityPtrHash of oldCollidingEntities.values()) {
+      if (!collidingEntitiesPtrHashSet.has(oldCollidingEntityPtrHash)) {
+        oldCollidingEntities.delete(oldCollidingEntityPtrHash);
+      }
+    }
+  }
+}

package/callbacks/postGridEntityRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getGridEntities } from "../functions/gridEntity";
+import {
+  postGridEntityRenderFire,
+  postGridEntityRenderHasSubscriptions,
+} from "./subscriptions/postGridEntityRender";
+
+/** @internal */
+export function postGridEntityRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postGridEntityRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const gridEntity of getGridEntities()) {
+    postGridEntityRenderFire(gridEntity);
+  }
+}

package/callbacks/postHolyMantleRemoved.ts

@@ -0,0 +1,55 @@
+import { CollectibleType } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postHolyMantleRemovedFire,
+  postHolyMantleRemovedHasSubscriptions,
+} from "./subscriptions/postHolyMantleRemoved";
+
+const v = {
+  run: {
+    playersHolyMantleMap: new DefaultMap<PlayerIndex, int>(0),
+  },
+};
+
+/** @internal */
+export function postHolyMantleRemovedInit(mod: ModUpgraded): void {
+  saveDataManager("postHolyMantleRemoved", v, hasSubscriptions);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return postHolyMantleRemovedHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const effects = player.GetEffects();
+  const newNumHolyMantles = effects.GetCollectibleEffectNum(
+    CollectibleType.HOLY_MANTLE,
+  );
+  const oldNumHolyMantles = defaultMapGetPlayer(
+    v.run.playersHolyMantleMap,
+    player,
+  );
+  mapSetPlayer(v.run.playersHolyMantleMap, player, newNumHolyMantles);
+
+  if (newNumHolyMantles < oldNumHolyMantles) {
+    postHolyMantleRemovedFire(player, oldNumHolyMantles, newNumHolyMantles);
+  }
+}

package/callbacks/postItemDischarged.lua

@@ -65,17 +65,18 @@ function playerRecentlyCollidedWithBulb(self, player)
 end
 function preNPCCollisionSucker(self, npc, collider)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     if npc.Variant ~= SuckerVariant.BULB then
-        return
+        return nil
     end
     local player = collider:ToPlayer()
     if player == nil then
-        return
+        return nil
     end
     local gameFrameCount = game:GetFrameCount()
     mapSetPlayer(nil, v.room.playersBulbLastCollisionFrame, player, gameFrameCount)
+    return nil
 end
 v = {
     run = {