isaacscript-common 4.0.0 → 4.0.1-dev.0

package/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 postPurchaseInit(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/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/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/callbacks/postRoomClearChanged.ts

@@ -0,0 +1,57 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postRoomClearChangedFire,
+  postRoomClearChangedHasSubscriptions,
+} from "./subscriptions/postRoomClearChanged";
+
+const v = {
+  room: {
+    cleared: false,
+  },
+};
+
+/** @internal */
+export function postRoomClearChangedInit(mod: ModUpgraded): void {
+  saveDataManager("postRoomClearChanged", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
+    postNewRoomReordered,
+  );
+}
+
+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);
+  }
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const room = game.GetRoom();
+  const roomClear = room.IsClear();
+
+  v.room.cleared = roomClear;
+}

package/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 postSacrificeInit(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/callbacks/postSlotDestroyed.ts

@@ -0,0 +1,92 @@
+// Normally, when a slot is destroyed, the grid collision class changes to
+// `EntityGridCollisionClass.GROUND` and sticks around in the room. Thus, checking for this case is
+// simple.
+
+// The special case is when a slot pays out with a collectible item. In this case, it will not stay
+// in the room. Instead, it will play the "Prize" animation for 3 game frames, and then despawn (to
+// be replaced by a collectible entity). Subsequently, we handle this case by assuming that if the
+// slot disappeared 3 frames after it changed to a prize animation, it was a destruction pay-out.
+
+import {
+  EntityGridCollisionClass,
+  EntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+import { SlotDestructionType } from "../enums/SlotDestructionType";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postSlotDestroyedFire,
+  postSlotDestroyedHasSubscriptions,
+} from "./subscriptions/postSlotDestroyed";
+
+const PRIZE_GAME_FRAME_DELAY_UNTIL_REMOVAL = 3;
+
+const v = {
+  room: {
+    brokenSlots: new Set<PtrHash>(),
+    slotPrizeAnimationGameFrame: new Map<PtrHash, int>(),
+  },
+};
+
+/** @internal */
+export function postSlotDestroyedInit(mod: ModUpgraded): void {
+  saveDataManager("postSlotDestroyed", v, hasSubscriptions);
+
+  mod.AddCallback(
+    ModCallback.POST_ENTITY_REMOVE,
+    postEntityRemove,
+    EntityType.SLOT,
+  ); // 67
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED,
+    postSlotAnimationChanged,
+  );
+}
+
+function hasSubscriptions() {
+  return postSlotDestroyedHasSubscriptions();
+}
+
+// ModCallback.POST_ENTITY_REMOVE (67)
+function postEntityRemove(entity: Entity) {
+  const slot = entity as EntitySlot;
+  const ptrHash = GetPtrHash(slot);
+  const gameFrameCount = game.GetFrameCount();
+
+  const prizeFrame = v.room.slotPrizeAnimationGameFrame.get(ptrHash);
+  if (prizeFrame === undefined) {
+    return;
+  }
+
+  if (prizeFrame + PRIZE_GAME_FRAME_DELAY_UNTIL_REMOVAL === gameFrameCount) {
+    postSlotDestroyedFire(slot, SlotDestructionType.COLLECTIBLE_PAYOUT);
+  }
+}
+
+// ModCallbackCustom.POST_SLOT_ANIMATION_CHANGED
+function postSlotAnimationChanged(slot: EntitySlot) {
+  const ptrHash = GetPtrHash(slot);
+  const gameFrameCount = game.GetFrameCount();
+
+  const alreadyBroken = v.room.brokenSlots.has(ptrHash);
+  if (alreadyBroken) {
+    return;
+  }
+
+  if (slot.GridCollisionClass === EntityGridCollisionClass.GROUND) {
+    v.room.brokenSlots.add(ptrHash);
+    postSlotDestroyedFire(slot, SlotDestructionType.NORMAL);
+  }
+
+  const sprite = slot.GetSprite();
+  const animation = sprite.GetAnimation();
+  if (animation === "Prize") {
+    v.room.slotPrizeAnimationGameFrame.set(ptrHash, gameFrameCount);
+  } else {
+    v.room.slotPrizeAnimationGameFrame.delete(ptrHash);
+  }
+}

package/callbacks/postSlotInitUpdate.ts

@@ -0,0 +1,68 @@
+// 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 { ModUpgraded } from "../classes/ModUpgraded";
+import { ModCallbackCustom } from "../enums/ModCallbackCustom";
+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: ModUpgraded): void {
+  saveDataManager("postSlotInitUpdate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
+    postNewRoomReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return postSlotInitHasSubscriptions() || postSlotUpdateHasSubscriptions();
+}
+
+// ModCallback.POST_UPDATE (1)
+function postUpdate() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const slot of getSlots()) {
+    checkNewEntity(slot);
+    postSlotUpdateFire(slot);
+  }
+}
+
+// ModCallbackCustom.POST_NEW_ROOM_REORDERED
+function postNewRoomReordered() {
+  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/callbacks/postSlotRender.ts

@@ -0,0 +1,69 @@
+// This provides the logic for the following callbacks:
+// - PostSlotRender
+// - PostSlotAnimationChanged
+
+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 {
+  postSlotRenderFire,
+  postSlotRenderHasSubscriptions,
+} from "./subscriptions/postSlotRender";
+
+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() ||
+    postSlotAnimationChangedHasSubscriptions()
+  );
+}
+
+// ModCallback.POST_UPDATE (1)
+function postRender() {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  for (const slot of getSlots()) {
+    postSlotRenderFire(slot);
+    checkSlotAnimationChanged(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);
+  }
+}

package/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/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/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/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/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 postTearInitLateInit(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/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 postTearInitVeryLateInit(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);
+  }
+}