isaacscript-common 4.0.2 → 4.0.5

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);
-  }
-}

package/callbacks/postItemDischarged.ts

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

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

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

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

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

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

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

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

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

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