isaacscript-common 2.2.0 → 2.3.0

package/src/callbacks/itemPickup.ts

@@ -0,0 +1,101 @@
+// This provides the logic for:
+// - PreItemPickup
+// - PostItemPickup
+
+import {
+  CollectibleType,
+  ItemType,
+  TrinketType,
+} 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 } from "../functions/playerDataStructures";
+import {
+  newPickingUpItem,
+  PickingUpItem,
+  resetPickingUpItem,
+} from "../types/PickingUpItem";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postItemPickupFire,
+  postItemPickupHasSubscriptions,
+} from "./subscriptions/postItemPickup";
+import {
+  preItemPickupFire,
+  preItemPickupHasSubscriptions,
+} from "./subscriptions/preItemPickup";
+
+const v = {
+  run: {
+    playersPickingUpItemMap: new DefaultMap<PlayerIndex, PickingUpItem>(() =>
+      newPickingUpItem(),
+    ),
+  },
+};
+
+/** @internal */
+export function itemPickupCallbacksInit(mod: ModUpgraded): void {
+  saveDataManager("itemPickup", v, hasSubscriptions);
+
+  mod.AddCallbackCustom(
+    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+    postPEffectUpdateReordered,
+  );
+}
+
+function hasSubscriptions() {
+  return preItemPickupHasSubscriptions() || postItemPickupHasSubscriptions();
+}
+
+// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+function postPEffectUpdateReordered(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const pickingUpItem = defaultMapGetPlayer(
+    v.run.playersPickingUpItemMap,
+    player,
+  );
+
+  if (player.IsItemQueueEmpty()) {
+    queueEmpty(player, pickingUpItem);
+    // If a player enters a room with a trinket next to the entrance, the player will pick up the
+    // trinket, but it will not become queued (it will be deposited into their inventory
+    // immediately). Since we don't know what type of item the player is holding, don't account for
+    // this bug.
+  } else {
+    queueNotEmpty(player, pickingUpItem);
+  }
+}
+
+function queueEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
+  // eslint-disable-next-line isaacscript/strict-enums
+  if (pickingUpItem.itemType === ItemType.NULL || pickingUpItem.subType === 0) {
+    return;
+  }
+
+  postItemPickupFire(player, pickingUpItem);
+  resetPickingUpItem(pickingUpItem);
+}
+
+function queueNotEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
+  const queuedItem = player.QueuedItem.Item;
+  if (queuedItem === undefined || queuedItem.Type === ItemType.NULL) {
+    // This should never happen, since the `EntityPlayer.IsItemQueueEmpty` method returned true.
+    return;
+  }
+
+  if (
+    queuedItem.Type !== pickingUpItem.itemType ||
+    queuedItem.ID !== pickingUpItem.subType
+  ) {
+    // Record which item we are picking up.
+    pickingUpItem.itemType = queuedItem.Type;
+    pickingUpItem.subType = queuedItem.ID as CollectibleType | TrinketType;
+
+    preItemPickupFire(player, pickingUpItem);
+  }
+}

package/src/callbacks/postBombInitLate.ts

@@ -0,0 +1,36 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postBombInitLateFire,
+  postBombInitLateHasSubscriptions,
+} from "./subscriptions/postBombInitLate";
+
+const v = {
+  room: {
+    firedSet: new Set<PtrHash>(),
+  },
+};
+
+/** @internal */
+export function postBombInitLateCallbackInit(mod: Mod): void {
+  saveDataManager("postBombInitLate", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_BOMB_UPDATE, postBombUpdate); // 58
+}
+
+function hasSubscriptions() {
+  return postBombInitLateHasSubscriptions();
+}
+
+// ModCallback.POST_BOMB_UPDATE (58)
+function postBombUpdate(bomb: EntityBomb) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const index = GetPtrHash(bomb);
+  if (!v.room.firedSet.has(index)) {
+    v.room.firedSet.add(index);
+    postBombInitLateFire(bomb);
+  }
+}

package/src/callbacks/postBoneSwing.ts

@@ -0,0 +1,64 @@
+import { KnifeVariant, ModCallback } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import {
+  postBoneSwingFire,
+  postBoneSwingHasSubscriptions,
+} from "./subscriptions/postBoneSwing";
+
+const BONE_SWING_ANIMATIONS: ReadonlySet<string> = new Set([
+  "Swing",
+  "Swing2",
+  "Spin",
+]);
+
+const v = {
+  room: {
+    boneClubAnimations: new Map<PtrHash, string>(),
+  },
+};
+
+/** @internal */
+export function postBoneSwingCallbackInit(mod: Mod): void {
+  saveDataManager("postBoneSwing", v, hasSubscriptions);
+
+  mod.AddCallback(ModCallback.POST_KNIFE_RENDER, postKnifeRender); // 52
+}
+
+function hasSubscriptions() {
+  return postBoneSwingHasSubscriptions();
+}
+
+// ModCallback.POST_KNIFE_RENDER (52)
+function postKnifeRender(knife: EntityKnife) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // The PostKnifeRender callback cannot be registered with knife variants for some reason.
+  if (knife.Variant !== KnifeVariant.BONE_CLUB) {
+    return;
+  }
+
+  postKnifeRenderBoneClub(knife);
+}
+
+function postKnifeRenderBoneClub(boneClub: EntityKnife) {
+  const sprite = boneClub.GetSprite();
+  const animation = sprite.GetAnimation();
+  const ptrHash = GetPtrHash(boneClub);
+  const animationOnLastFrame = v.room.boneClubAnimations.get(ptrHash);
+  v.room.boneClubAnimations.set(ptrHash, animation);
+
+  if (
+    animationOnLastFrame !== undefined &&
+    animation !== animationOnLastFrame
+  ) {
+    boneClubAnimationChanged(boneClub, animation);
+  }
+}
+
+function boneClubAnimationChanged(boneClub: EntityKnife, animation: string) {
+  if (BONE_SWING_ANIMATIONS.has(animation)) {
+    postBoneSwingFire(boneClub);
+  }
+}

package/src/callbacks/postCollectibleInitFirst.ts

@@ -0,0 +1,39 @@
+import { ModCallback, PickupVariant } from "isaac-typescript-definitions";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { getCollectibleIndex } from "../functions/collectibles";
+import { CollectibleIndex } from "../types/CollectibleIndex";
+import {
+  postCollectibleInitFirstFire,
+  postCollectibleInitFirstHasSubscriptions,
+} from "./subscriptions/postCollectibleInitFirst";
+
+const v = {
+  run: {
+    seenCollectibles: new Set<CollectibleIndex>(),
+  },
+};
+
+/** @internal */
+export function postCollectibleInitFirstCallbackInit(mod: Mod): void {
+  saveDataManager("postCollectibleInitFirst", v, hasSubscriptions);
+
+  mod.AddCallback(
+    ModCallback.POST_PICKUP_INIT,
+    postPickupInitCollectible,
+    PickupVariant.COLLECTIBLE,
+  ); // 34
+}
+
+function hasSubscriptions() {
+  return postCollectibleInitFirstHasSubscriptions();
+}
+
+function postPickupInitCollectible(collectible: EntityPickupCollectible) {
+  const collectibleIndex = getCollectibleIndex(collectible);
+  if (v.run.seenCollectibles.has(collectibleIndex)) {
+    return;
+  }
+
+  v.run.seenCollectibles.add(collectibleIndex);
+  postCollectibleInitFirstFire(collectible);
+}

package/src/callbacks/postCursedTeleport.ts

@@ -0,0 +1,183 @@
+import {
+  CollectibleType,
+  DamageFlag,
+  EntityType,
+  ModCallback,
+  PlayerVariant,
+  RoomType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { saveDataManager } from "../features/saveDataManager/exports";
+import { hasFlag } from "../functions/flag";
+import { getPlayerNumHitsRemaining } from "../functions/player";
+import { mapGetPlayer, mapSetPlayer } from "../functions/playerDataStructures";
+import { PlayerIndex } from "../types/PlayerIndex";
+import {
+  postCursedTeleportFire,
+  postCursedTeleportHasSubscriptions,
+} from "./subscriptions/postCursedTeleport";
+
+const v = {
+  run: {
+    playersDamageFrameMap: new Map<
+      PlayerIndex,
+      [lastDamageFrame: int, callbackFiredOnThisFrame: boolean]
+    >(),
+  },
+
+  level: {
+    numSacrifices: 0,
+  },
+};
+
+/** @internal */
+export function postCursedTeleportCallbackInit(mod: Mod): void {
+  saveDataManager("postCursedTeleport", v, hasSubscriptions);
+
+  mod.AddCallback(
+    ModCallback.ENTITY_TAKE_DMG,
+    entityTakeDmgPlayer,
+    EntityType.PLAYER,
+  ); // 11
+
+  mod.AddCallback(
+    ModCallback.POST_PLAYER_RENDER,
+    postPlayerRenderPlayer,
+    PlayerVariant.PLAYER, // Co-op babies cannot perform Cursed Eye teleports
+  ); // 32
+}
+
+function hasSubscriptions() {
+  return postCursedTeleportHasSubscriptions();
+}
+
+// ModCallback.ENTITY_TAKE_DMG (11)
+// EntityType.PLAYER (1)
+function entityTakeDmgPlayer(
+  tookDamage: Entity,
+  _damageAmount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  _damageSource: EntityRef,
+  _damageCountdownFrames: int,
+) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame
+  setDamageFrame(tookDamage, damageFlags);
+}
+
+function setDamageFrame(tookDamage: Entity, damageFlags: BitFlags<DamageFlag>) {
+  const gameFrameCount = game.GetFrameCount();
+
+  const player = tookDamage.ToPlayer();
+  if (player === undefined) {
+    return;
+  }
+
+  // Don't do anything if we already activated the callback on this frame.
+  const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
+  if (trackingArray !== undefined) {
+    const [lastDamageFrame, callbackFiredOnThisFrame] = trackingArray;
+    if (lastDamageFrame === gameFrameCount && callbackFiredOnThisFrame) {
+      return;
+    }
+  }
+
+  // Don't do anything if this could be a Sacrifice Room teleport.
+  if (isPotentialNaturalTeleportFromSacrificeRoom(damageFlags)) {
+    return;
+  }
+
+  const newTrackingArray = [gameFrameCount, false];
+  mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
+}
+
+function isPotentialNaturalTeleportFromSacrificeRoom(
+  damageFlags: BitFlags<DamageFlag>,
+) {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+  // Don't record the frame if we are potentially going to the Angel Room or the Dark Room from a
+  // Sacrifice Room.
+  return (
+    roomType === RoomType.SACRIFICE &&
+    isSpikeDamage &&
+    (v.level.numSacrifices === 6 || v.level.numSacrifices >= 12)
+  );
+}
+
+function incrementNumSacrifices(damageFlags: BitFlags<DamageFlag>) {
+  const room = game.GetRoom();
+  const roomType = room.GetType();
+  const isSpikeDamage = hasFlag(damageFlags, DamageFlag.SPIKES);
+
+  if (roomType === RoomType.SACRIFICE && isSpikeDamage) {
+    v.level.numSacrifices += 1;
+  }
+}
+
+// ModCallback.POST_PLAYER_RENDER (32)
+// PlayerVariant.PLAYER (0)
+function postPlayerRenderPlayer(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  // Retrieve information about this player.
+  const trackingArray = mapGetPlayer(v.run.playersDamageFrameMap, player);
+  if (trackingArray === undefined) {
+    return;
+  }
+  const [lastDamageFrame, callbackActivatedOnThisFrame] = trackingArray;
+
+  if (!playerIsTeleportingFromCursedTeleport(player, lastDamageFrame)) {
+    return;
+  }
+
+  // Do nothing if the callback already fired on this frame.
+  if (callbackActivatedOnThisFrame) {
+    return;
+  }
+
+  const gameFrameCount = game.GetFrameCount();
+  const newTrackingArray = [gameFrameCount, true];
+  mapSetPlayer(v.run.playersDamageFrameMap, player, newTrackingArray);
+
+  postCursedTeleportFire(player);
+}
+
+function playerIsTeleportingFromCursedTeleport(
+  player: EntityPlayer,
+  lastDamageFrame: int,
+) {
+  // Check to see if this is the frame that we last took damage.
+  const gameFrameCount = game.GetFrameCount();
+  if (gameFrameCount !== lastDamageFrame) {
+    return false;
+  }
+
+  // Check to see if this is the 1st frame that we are teleporting.
+  const sprite = player.GetSprite();
+  if (
+    !sprite.IsPlaying("TeleportUp") ||
+    sprite.GetFrame() !== 1 // The 0th frame never fires
+  ) {
+    return false;
+  }
+
+  if (player.HasCollectible(CollectibleType.CURSED_EYE)) {
+    return true;
+  }
+
+  const numHitsRemaining = getPlayerNumHitsRemaining(player);
+  if (player.HasTrinket(TrinketType.CURSED_SKULL) && numHitsRemaining === 1) {
+    return true;
+  }
+
+  return false;
+}