isaacscript-common 2.0.34 → 2.3.0

package/src/callbacks/postPoopUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPoops } from "../functions/gridEntitySpecific";
+import {
+  postPoopUpdateFire,
+  postPoopUpdateHasSubscriptions,
+} from "./subscriptions/postPoopUpdate";
+
+/** @internal */
+export function postPoopUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postPoopUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const poop of getPoops()) {
+    postPoopUpdateFire(poop);
+  }
+}

package/src/callbacks/postPressurePlateRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPressurePlates } from "../functions/gridEntitySpecific";
+import {
+  postPressurePlateRenderFire,
+  postPressurePlateRenderHasSubscriptions,
+} from "./subscriptions/postPressurePlateRender";
+
+/** @internal */
+export function postPressurePlateRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postPressurePlateRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pressurePlate of getPressurePlates()) {
+    postPressurePlateRenderFire(pressurePlate);
+  }
+}

package/src/callbacks/postPressurePlateUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getPressurePlates } from "../functions/gridEntitySpecific";
+import {
+  postPressurePlateUpdateFire,
+  postPressurePlateUpdateHasSubscriptions,
+} from "./subscriptions/postPressurePlateUpdate";
+
+/** @internal */
+export function postPressurePlateUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postPressurePlateUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const pressurePlate of getPressurePlates()) {
+    postPressurePlateUpdateFire(pressurePlate);
+  }
+}

package/src/callbacks/postProjectileInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postProjectileInitLateFire,
+  postProjectileInitLateHasSubscriptions,
+} from "./subscriptions/postProjectileInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postProjectileInitLateCallbackInit(mod: Mod): void {
+  saveDataManager("postProjectileInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_PROJECTILE_UPDATE, postProjectileUpdate); // 44
+}
+
+function hasSubscriptions() {
+  return postProjectileInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_PROJECTILE_UPDATE (44)
+function postProjectileUpdate(projectile: EntityProjectile) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(projectile);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postProjectileInitLateFire(projectile);
+  }
+}

package/src/callbacks/postPurchase.ts

@@ -0,0 +1,64 @@
+import { DefaultMap } from "../classes/DefaultMap";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getPickups } from "../functions/entitySpecific";
+import {
+  defaultMapGetPlayer,
+  mapSetPlayer,
+} from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postPurchaseFire,
+  postPurchaseHasSubscriptions,
+} from "./subscriptions/postPurchase";
+
+const v = {
+  room: {
+    playersHoldingItemOnLastFrameMap: new DefaultMap<PlayerIndex, boolean>(
+      false,
+    ),
+  },
+};
+
+/** @internal */
+export function postPurchaseCallbackInit(mod: ModUpgraded): void {
+  saveDataManager("postPurchase", v, hasSubscriptions);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return postPurchaseHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const isHoldingItem = player.IsHoldingItem();
+  const wasHoldingItemOnLastFrame = defaultMapGetPlayer(
+    v.room.playersHoldingItemOnLastFrameMap,
+    player,
+  );
+  mapSetPlayer(v.room.playersHoldingItemOnLastFrameMap, player, isHoldingItem);
+
+  if (!wasHoldingItemOnLastFrame && isHoldingItem) {
+    playerPickedUpNewItem(player);
+  }
+}
+
+function playerPickedUpNewItem(player: EntityPlayer) {
+  const pickups = getPickups();
+  const disappearingPickup = pickups.find(
+    (pickup) => !pickup.Exists() && pickup.Price !== 0,
+  );
+  if (disappearingPickup !== undefined) {
+    postPurchaseFire(player, disappearingPickup);
+  }
+}

package/src/callbacks/postRockRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getRocks } from "../functions/gridEntitySpecific";
+import {
+  postRockRenderFire,
+  postRockRenderHasSubscriptions,
+} from "./subscriptions/postRockRender";
+
+/** @internal */
+export function postRockRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postRockRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const rock of getRocks()) {
+    postRockRenderFire(rock);
+  }
+}

package/src/callbacks/postRockUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getRocks } from "../functions/gridEntitySpecific";
+import {
+  postRockUpdateFire,
+  postRockUpdateHasSubscriptions,
+} from "./subscriptions/postRockUpdate";
+
+/** @internal */
+export function postRockUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postRockUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const rock of getRocks()) {
+    postRockUpdateFire(rock);
+  }
+}

package/src/callbacks/postRoomClearChanged.ts

@@ -0,0 +1,52 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postRoomClearChangedFire,
+  postRoomClearChangedHasSubscriptions,
+} from "./subscriptions/postRoomClearChanged";
+
+const v = {
+  room: {
+    cleared: false,
+  },
+};
+
+/** @internal */
+export function postRoomClearChangedCallbackInit(mod: Mod): void {
+  saveDataManager("postRoomClearChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+  mod.AddCallback(ModCallback.POST_NEW_ROOM, postNewRoom); // 19
+}
+
+function hasSubscriptions() {
+  return postRoomClearChangedHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomClear = room.IsClear();
+
+  if (roomClear !== v.room.cleared) {
+    v.room.cleared = roomClear;
+    postRoomClearChangedFire(roomClear);
+  }
+}
+
+// ModCallback.POST_NEW_ROOM (19)
+function postNewRoom() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomClear = room.IsClear();
+
+  v.room.cleared = roomClear;
+}

package/src/callbacks/postSacrifice.ts

@@ -0,0 +1,62 @@
+import {
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  RoomType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { hasFlag } from "../functions/flag";
+import {
+  postSacrificeFire,
+  postSacrificeHasSubscriptions,
+} from "./subscriptions/postSacrifice";
+
+const v = {
+  level: {
+    numSacrifices: 0,
+  },
+};
+
+/** @internal */
+export function postSacrificeCallbackInit(mod: Mod): void {
+  saveDataManager("postSacrifice", v, hasSubscriptions);
+
+  mod.AddCallback(
+    ModCallback.ENTITY_TAKE_DMG,
+    entityTakeDmgPlayer,
+    EntityType.PLAYER,
+  ); // 11
+}
+
+function hasSubscriptions() {
+  return postSacrificeHasSubscriptions();
+}
+
+// ModCallback.ENTITY_TAKE_DMG (11)
+// EntityType.PLAYER (1)
+function entityTakeDmgPlayer(
+  tookDamage: Entity,
+  _damageAmount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  _damageSource: EntityRef,
+  _damageCountdownFrames: int,
+) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const player = tookDamage.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+  if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+    v.level.numSacrifices += 1;
+    postSacrificeFire(player, v.level.numSacrifices);
+  }
+}

package/src/callbacks/postSlotInitUpdate.ts

@@ -0,0 +1,63 @@
+// This provides the logic for the PostSlotInit and PostSlotUpdate callbacks. (The other slot
+// callbacks are handled in a different file.)
+
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getSlots } from "../functions/entitySpecific";
+import {
+  postSlotInitFire,
+  postSlotInitHasSubscriptions,
+} from "./subscriptions/postSlotInit";
+import {
+  postSlotUpdateFire,
+  postSlotUpdateHasSubscriptions,
+} from "./subscriptions/postSlotUpdate";
+
+const v = {
+  room: {
+    initializedSlots: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postSlotInitUpdateCallbacksInit(mod: Mod): void {
+  saveDataManager("postSlotInitUpdate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+  mod.AddCallback(ModCallback.POST_NEW_ROOM, postNewRoom); // 9
+}
+
+function hasSubscriptions() {
+  return postSlotInitHasSubscriptions() || postSlotUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const slot of getSlots()) {
+    checkNewEntity(slot);
+    postSlotUpdateFire(slot);
+  }
+}
+
+// ModCallback.POST_NEW_ROOM (9)
+function postNewRoom() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const slot of getSlots()) {
+    checkNewEntity(slot);
+  }
+}
+
+function checkNewEntity(slot: EntitySlot) {
+  const ptrHash = GetPtrHash(slot);
+  if (!v.room.initializedSlots.has(ptrHash)) {
+    v.room.initializedSlots.add(ptrHash);
+    postSlotInitFire(slot);
+  }
+}

package/src/callbacks/postSlotRender.ts

@@ -0,0 +1,96 @@
+// This provides the logic for the following callbacks:
+// - PostSlotRender
+// - PostSlotAnimationChanged
+// - PostSlotBroken
+
+import { ModCallback } from "isaac-typescript-definitions";
+import { DefaultMap } from "../classes/DefaultMap";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getSlots } from "../functions/entitySpecific";
+import {
+  postSlotAnimationChangedFire,
+  postSlotAnimationChangedHasSubscriptions,
+} from "./subscriptions/postSlotAnimationChanged";
+import {
+  postSlotDestroyedFire,
+  postSlotDestroyedHasSubscriptions,
+} from "./subscriptions/postSlotDestroyed";
+import {
+  postSlotRenderFire,
+  postSlotRenderHasSubscriptions,
+} from "./subscriptions/postSlotRender";
+
+const BROKEN_ANIMATIONS: ReadonlySet<string> = new Set([
+  "Broken", // Normal machines
+  "Death", // Restock machines
+]);
+
+const v = {
+  room: {
+    slotAnimations: new DefaultMap<PtrHash, string, [slot: Entity]>(
+      (slot: Entity) => {
+        const sprite = slot.GetSprite();
+        return sprite.GetAnimation();
+      },
+    ),
+    brokenSlots: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postSlotRenderCallbacksInit(mod: Mod): void {
+  saveDataManager("postSlotRender", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return (
+    postSlotRenderHasSubscriptions() ||
+    postSlotDestroyedHasSubscriptions() ||
+    postSlotAnimationChangedHasSubscriptions()
+  );
+}
+
+// ModCallback.POST_UPDATE (1)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const slot of getSlots()) {
+    postSlotRenderFire(slot);
+    checkSlotAnimationChanged(slot);
+    checkSlotBroken(slot);
+  }
+}
+
+function checkSlotAnimationChanged(slot: EntitySlot) {
+  const sprite = slot.GetSprite();
+  const currentAnimation = sprite.GetAnimation();
+  const ptrHash = GetPtrHash(slot);
+  const previousAnimation = v.room.slotAnimations.getAndSetDefault(
+    ptrHash,
+    slot,
+  );
+  v.room.slotAnimations.set(ptrHash, currentAnimation);
+
+  if (currentAnimation !== previousAnimation) {
+    postSlotAnimationChangedFire(slot, previousAnimation, currentAnimation);
+  }
+}
+
+function checkSlotBroken(slot: EntitySlot) {
+  const ptrHash = GetPtrHash(slot);
+  const alreadyBroken = v.room.brokenSlots.has(ptrHash);
+  if (alreadyBroken) {
+    return;
+  }
+
+  const sprite = slot.GetSprite();
+  const animation = sprite.GetAnimation();
+  if (BROKEN_ANIMATIONS.has(animation)) {
+    v.room.brokenSlots.add(ptrHash);
+    postSlotDestroyedFire(slot);
+  }
+}

package/src/callbacks/postSpikesRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getSpikes } from "../functions/gridEntitySpecific";
+import {
+  postSpikesRenderFire,
+  postSpikesRenderHasSubscriptions,
+} from "./subscriptions/postSpikesRender";
+
+/** @internal */
+export function postSpikesRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postSpikesRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const spikes of getSpikes()) {
+    postSpikesRenderFire(spikes);
+  }
+}

package/src/callbacks/postSpikesUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getSpikes } from "../functions/gridEntitySpecific";
+import {
+  postSpikesUpdateFire,
+  postSpikesUpdateHasSubscriptions,
+} from "./subscriptions/postSpikesUpdate";
+
+/** @internal */
+export function postSpikesUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postSpikesUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const spikes of getSpikes()) {
+    postSpikesUpdateFire(spikes);
+  }
+}

package/src/callbacks/postTNTRender.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getTNT } from "../functions/gridEntitySpecific";
+import {
+  postTNTRenderFire,
+  postTNTRenderHasSubscriptions,
+} from "./subscriptions/postTNTRender";
+
+/** @internal */
+export function postTNTRenderInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
+}
+
+function hasSubscriptions() {
+  return postTNTRenderHasSubscriptions();
+}
+
+// ModCallback.POST_RENDER (2)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const tnt of getTNT()) {
+    postTNTRenderFire(tnt);
+  }
+}

package/src/callbacks/postTNTUpdate.ts

@@ -0,0 +1,26 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { getTNT } from "../functions/gridEntitySpecific";
+import {
+  postTNTUpdateFire,
+  postTNTUpdateHasSubscriptions,
+} from "./subscriptions/postTNTUpdate";
+
+/** @internal */
+export function postTNTUpdateInit(mod: Mod): void {
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+}
+
+function hasSubscriptions() {
+  return postTNTUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const tnt of getTNT()) {
+    postTNTUpdateFire(tnt);
+  }
+}

package/src/callbacks/postTearInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postTearInitLateFire,
+  postTearInitLateHasSubscriptions,
+} from "./subscriptions/postTearInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postTearInitLateCallbackInit(mod: Mod): void {
+  saveDataManager("postTearInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_TEAR_UPDATE, postTearUpdate); // 40
+}
+
+function hasSubscriptions() {
+  return postTearInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_TEAR_UPDATE (40)
+function postTearUpdate(tear: EntityTear) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(tear);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postTearInitLateFire(tear);
+  }
+}

package/src/callbacks/postTearInitVeryLate.ts

@@ -0,0 +1,41 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postTearInitVeryLateFire,
+  postTearInitVeryLateHasSubscriptions,
+} from "./subscriptions/postTearInitVeryLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postTearInitVeryLateCallbackInit(mod: Mod): void {
+  saveDataManager("postTearInitVeryLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_TEAR_UPDATE, postTearUpdate); // 40
+}
+
+function hasSubscriptions() {
+  return postTearInitVeryLateHasSubscriptions();
+}
+
+// ModCallback.POST_TEAR_UPDATE (40)
+function postTearUpdate(tear: EntityTear) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // This callback fires on frame 1.
+  if (tear.FrameCount === 0) {
+    return;
+  }
+
+  const index = GetPtrHash(tear);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postTearInitVeryLateFire(tear);
+  }
+}