isaacscript-common 3.17.0 → 4.0.2

package/callbacks/subscriptions/postPressurePlateRender.ts

@@ -0,0 +1,37 @@
+export type PostPressurePlateRenderRegisterParameters = [
+  callback: (pressurePlate: GridEntityPressurePlate) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostPressurePlateRenderRegisterParameters[] = [];
+
+/** @internal */
+export function postPressurePlateRenderHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPressurePlateRenderRegister(
+  ...args: PostPressurePlateRenderRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPressurePlateRenderFire(
+  pressurePlate: GridEntityPressurePlate,
+): void {
+  const gridEntityVariant = pressurePlate.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(pressurePlate);
+  }
+}

package/callbacks/subscriptions/postPressurePlateUpdate.ts

@@ -0,0 +1,37 @@
+export type PostPressurePlateUpdateRegisterParameters = [
+  callback: (pressurePlate: GridEntityPressurePlate) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostPressurePlateUpdateRegisterParameters[] = [];
+
+/** @internal */
+export function postPressurePlateUpdateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPressurePlateUpdateRegister(
+  ...args: PostPressurePlateUpdateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPressurePlateUpdateFire(
+  pressurePlate: GridEntityPressurePlate,
+): void {
+  const gridEntityVariant = pressurePlate.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(pressurePlate);
+  }
+}

package/callbacks/subscriptions/postProjectileInitLate.ts

@@ -0,0 +1,35 @@
+import { ProjectileVariant } from "isaac-typescript-definitions";
+
+export type PostProjectileInitLateRegisterParameters = [
+  callback: (projectile: EntityProjectile) => void,
+  projectileVariant?: ProjectileVariant,
+];
+
+const subscriptions: PostProjectileInitLateRegisterParameters[] = [];
+
+/** @internal */
+export function postProjectileInitLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postProjectileInitLateRegister(
+  ...args: PostProjectileInitLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postProjectileInitLateFire(projectile: EntityProjectile): void {
+  for (const [callback, projectileVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      projectileVariant !== undefined &&
+      projectileVariant !== projectile.Variant
+    ) {
+      continue;
+    }
+
+    callback(projectile);
+  }
+}

package/callbacks/subscriptions/postPurchase.ts

@@ -0,0 +1,31 @@
+import { PickupVariant } from "isaac-typescript-definitions";
+
+export type PostPurchaseRegisterParameters = [
+  callback: (player: EntityPlayer, pickup: EntityPickup) => void,
+  pickupVariant?: PickupVariant,
+  pickupSubType?: int,
+];
+
+const subscriptions: PostPurchaseRegisterParameters[] = [];
+
+/** @internal */
+export function postPurchaseHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPurchaseRegister(
+  ...args: PostPurchaseRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPurchaseFire(
+  player: EntityPlayer,
+  pickup: EntityPickup,
+): void {
+  for (const [callback] of subscriptions) {
+    callback(player, pickup);
+  }
+}

package/callbacks/subscriptions/postRockRender.ts

@@ -0,0 +1,35 @@
+export type PostRockRenderRegisterParameters = [
+  callback: (rock: GridEntityRock) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostRockRenderRegisterParameters[] = [];
+
+/** @internal */
+export function postRockRenderHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postRockRenderRegister(
+  ...args: PostRockRenderRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postRockRenderFire(rock: GridEntityRock): void {
+  const gridEntityVariant = rock.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(rock);
+  }
+}

package/callbacks/subscriptions/postRockUpdate.ts

@@ -0,0 +1,35 @@
+export type PostRockUpdateRegisterParameters = [
+  callback: (rock: GridEntityRock) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostRockUpdateRegisterParameters[] = [];
+
+/** @internal */
+export function postRockUpdateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postRockUpdateRegister(
+  ...args: PostRockUpdateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postRockUpdateFire(rock: GridEntityRock): void {
+  const gridEntityVariant = rock.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(rock);
+  }
+}

package/callbacks/subscriptions/postRoomClearChanged.ts

@@ -0,0 +1,30 @@
+export type PostRoomClearChangedRegisterParameters = [
+  callback: (roomClear: boolean) => void,
+  roomClear?: boolean,
+];
+
+const subscriptions: PostRoomClearChangedRegisterParameters[] = [];
+
+/** @internal */
+export function postRoomClearChangedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postRoomClearChangedRegister(
+  ...args: PostRoomClearChangedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postRoomClearChangedFire(roomClear: boolean): void {
+  for (const [callback, callbackRoomClear] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (callbackRoomClear !== undefined && callbackRoomClear !== roomClear) {
+      continue;
+    }
+
+    callback(roomClear);
+  }
+}

package/callbacks/subscriptions/postSacrifice.ts

@@ -0,0 +1,43 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+
+export type PostSacrificeRegisterParameters = [
+  callback: (player: EntityPlayer, numSacrifices: int) => void,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostSacrificeRegisterParameters[] = [];
+
+/** @internal */
+export function postSacrificeHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSacrificeRegister(
+  ...args: PostSacrificeRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSacrificeFire(
+  player: EntityPlayer,
+  numSacrifices: int,
+): void {
+  const character = player.GetPlayerType();
+
+  for (const [callback, playerVariant, callbackCharacter] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (playerVariant !== undefined && playerVariant !== player.Variant) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (callbackCharacter !== undefined && callbackCharacter !== character) {
+      continue;
+    }
+
+    callback(player, numSacrifices);
+  }
+}

package/callbacks/subscriptions/postSlotAnimationChanged.ts

@@ -0,0 +1,40 @@
+import { SlotVariant } from "isaac-typescript-definitions";
+
+export type PostSlotAnimationChangedRegisterParameters = [
+  callback: (
+    slot: EntitySlot,
+    previousAnimation: string,
+    currentAnimation: string,
+  ) => void,
+  slotVariant?: SlotVariant,
+];
+
+const subscriptions: PostSlotAnimationChangedRegisterParameters[] = [];
+
+/** @internal */
+export function postSlotAnimationChangedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSlotAnimationChangedRegister(
+  ...args: PostSlotAnimationChangedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSlotAnimationChangedFire(
+  slot: EntitySlot,
+  previousAnimation: string,
+  currentAnimation: string,
+): void {
+  for (const [callback, slotVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (slotVariant !== undefined && slotVariant !== slot.Variant) {
+      continue;
+    }
+
+    callback(slot, previousAnimation, currentAnimation);
+  }
+}

package/callbacks/subscriptions/postSlotDestroyed.ts

@@ -0,0 +1,55 @@
+import { SlotVariant } from "isaac-typescript-definitions";
+import { SlotDestructionType } from "../../enums/SlotDestructionType";
+
+export type PostSlotDestroyedRegisterParameters = [
+  callback: (
+    slot: EntitySlot,
+    slotDestructionType: SlotDestructionType,
+  ) => void,
+  slotVariant?: SlotVariant,
+  slotDestructionType?: SlotDestructionType,
+];
+
+const subscriptions: PostSlotDestroyedRegisterParameters[] = [];
+
+/** @internal */
+export function postSlotDestroyedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSlotDestroyedRegister(
+  ...args: PostSlotDestroyedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSlotDestroyedFire(
+  slot: EntitySlot,
+  slotDestructionType: SlotDestructionType,
+): void {
+  for (const [
+    callback,
+    callbackSlotVariant,
+    callbackSlotDestructionType,
+  ] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackSlotVariant !== undefined &&
+      callbackSlotVariant !== slot.Variant
+    ) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (
+      callbackSlotDestructionType !== undefined &&
+      callbackSlotDestructionType !== slotDestructionType
+    ) {
+      continue;
+    }
+
+    callback(slot, slotDestructionType);
+  }
+}

package/callbacks/subscriptions/postSlotInit.ts

@@ -0,0 +1,32 @@
+import { SlotVariant } from "isaac-typescript-definitions";
+
+export type PostSlotInitRegisterParameters = [
+  callback: (slot: EntitySlot) => void,
+  slotVariant?: SlotVariant,
+];
+
+const subscriptions: PostSlotInitRegisterParameters[] = [];
+
+/** @internal */
+export function postSlotInitHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSlotInitRegister(
+  ...args: PostSlotInitRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSlotInitFire(slot: EntitySlot): void {
+  for (const [callback, slotVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (slotVariant !== undefined && slotVariant !== slot.Variant) {
+      continue;
+    }
+
+    callback(slot);
+  }
+}

package/callbacks/subscriptions/postSlotRender.ts

@@ -0,0 +1,32 @@
+import { SlotVariant } from "isaac-typescript-definitions";
+
+export type PostSlotRenderRegisterParameters = [
+  callback: (slot: EntitySlot) => void,
+  slotVariant?: SlotVariant,
+];
+
+const subscriptions: PostSlotRenderRegisterParameters[] = [];
+
+/** @internal */
+export function postSlotRenderHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSlotRenderRegister(
+  ...args: PostSlotRenderRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSlotRenderFire(slot: EntitySlot): void {
+  for (const [callback, slotVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (slotVariant !== undefined && slotVariant !== slot.Variant) {
+      continue;
+    }
+
+    callback(slot);
+  }
+}

package/callbacks/subscriptions/postSlotUpdate.ts

@@ -0,0 +1,32 @@
+import { SlotVariant } from "isaac-typescript-definitions";
+
+export type PostSlotUpdateRegisterParameters = [
+  callback: (slot: EntitySlot) => void,
+  slotVariant?: SlotVariant,
+];
+
+const subscriptions: PostSlotUpdateRegisterParameters[] = [];
+
+/** @internal */
+export function postSlotUpdateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSlotUpdateRegister(
+  ...args: PostSlotUpdateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSlotUpdateFire(slot: EntitySlot): void {
+  for (const [callback, slotVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (slotVariant !== undefined && slotVariant !== slot.Variant) {
+      continue;
+    }
+
+    callback(slot);
+  }
+}

package/callbacks/subscriptions/postSpikesRender.ts

@@ -0,0 +1,35 @@
+export type PostSpikesRenderRegisterParameters = [
+  callback: (spikes: GridEntitySpikes) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostSpikesRenderRegisterParameters[] = [];
+
+/** @internal */
+export function postSpikesRenderHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSpikesRenderRegister(
+  ...args: PostSpikesRenderRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSpikesRenderFire(spikes: GridEntitySpikes): void {
+  const gridEntityVariant = spikes.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(spikes);
+  }
+}

package/callbacks/subscriptions/postSpikesUpdate.ts

@@ -0,0 +1,35 @@
+export type PostSpikesUpdateRegisterParameters = [
+  callback: (spikes: GridEntitySpikes) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostSpikesUpdateRegisterParameters[] = [];
+
+/** @internal */
+export function postSpikesUpdateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postSpikesUpdateRegister(
+  ...args: PostSpikesUpdateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postSpikesUpdateFire(spikes: GridEntitySpikes): void {
+  const gridEntityVariant = spikes.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(spikes);
+  }
+}

package/callbacks/subscriptions/postTNTRender.ts

@@ -0,0 +1,35 @@
+export type PostTNTRenderRegisterParameters = [
+  callback: (tnt: GridEntityTNT) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostTNTRenderRegisterParameters[] = [];
+
+/** @internal */
+export function postTNTRenderHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postTNTRenderRegister(
+  ...args: PostTNTRenderRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postTNTRenderFire(tnt: GridEntityTNT): void {
+  const gridEntityVariant = tnt.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(tnt);
+  }
+}

package/callbacks/subscriptions/postTNTUpdate.ts

@@ -0,0 +1,35 @@
+export type PostTNTUpdateRegisterParameters = [
+  callback: (tnt: GridEntityTNT) => void,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostTNTUpdateRegisterParameters[] = [];
+
+/** @internal */
+export function postTNTUpdateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postTNTUpdateRegister(
+  ...args: PostTNTUpdateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postTNTUpdateFire(tnt: GridEntityTNT): void {
+  const gridEntityVariant = tnt.GetVariant();
+
+  for (const [callback, callbackGridEntityVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(tnt);
+  }
+}

package/callbacks/subscriptions/postTearInitLate.ts

@@ -0,0 +1,32 @@
+import { TearVariant } from "isaac-typescript-definitions";
+
+export type PostTearInitLateRegisterParameters = [
+  callback: (tear: EntityTear) => void,
+  tearVariant?: TearVariant,
+];
+
+const subscriptions: PostTearInitLateRegisterParameters[] = [];
+
+/** @internal */
+export function postTearInitLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postTearInitLateRegister(
+  ...args: PostTearInitLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postTearInitLateFire(tear: EntityTear): void {
+  for (const [callback, tearVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (tearVariant !== undefined && tearVariant !== tear.Variant) {
+      continue;
+    }
+
+    callback(tear);
+  }
+}

package/callbacks/subscriptions/postTearInitVeryLate.ts

@@ -0,0 +1,32 @@
+import { TearVariant } from "isaac-typescript-definitions";
+
+export type PostTearInitVeryLateRegisterParameters = [
+  callback: (tear: EntityTear) => void,
+  tearVariant?: TearVariant,
+];
+
+const subscriptions: PostTearInitVeryLateRegisterParameters[] = [];
+
+/** @internal */
+export function postTearInitVeryLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postTearInitVeryLateRegister(
+  ...args: PostTearInitVeryLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postTearInitVeryLateFire(tear: EntityTear): void {
+  for (const [callback, tearVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (tearVariant !== undefined && tearVariant !== tear.Variant) {
+      continue;
+    }
+
+    callback(tear);
+  }
+}