isaacscript-common 4.0.3 → 4.0.4

package/callbacks/postEsauJr.ts

@@ -1,109 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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.ts

@@ -1,90 +0,0 @@
-// 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

@@ -1,41 +0,0 @@
-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

@@ -1,164 +0,0 @@
-// 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

@@ -1,69 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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);
-  }
-}