isaacscript-common 4.0.0 → 4.0.3

package/callbacks/subscriptions/postGridEntityRemove.ts

@@ -0,0 +1,52 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export type PostGridEntityRemoveRegisterParameters = [
+  callback: (gridIndex: int, gridEntityType: GridEntityType) => void,
+  gridEntityType?: GridEntityType,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostGridEntityRemoveRegisterParameters[] = [];
+
+/** @internal */
+export function postGridEntityRemoveHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postGridEntityRemoveRegister(
+  ...args: PostGridEntityRemoveRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postGridEntityRemoveFire(
+  gridIndex: int,
+  gridEntityType: GridEntityType,
+  gridEntityVariant: int,
+): void {
+  for (const [
+    callback,
+    callbackGridEntityType,
+    callbackGridEntityVariant,
+  ] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(gridIndex, gridEntityType);
+  }
+}

package/callbacks/subscriptions/postGridEntityRender.ts

@@ -0,0 +1,51 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export type PostGridEntityRenderRegisterParameters = [
+  callback: (gridEntity: GridEntity) => void,
+  gridEntityType?: GridEntityType,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostGridEntityRenderRegisterParameters[] = [];
+
+/** @internal */
+export function postGridEntityRenderHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postGridEntityRenderRegister(
+  ...args: PostGridEntityRenderRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postGridEntityRenderFire(gridEntity: GridEntity): void {
+  const gridEntityType = gridEntity.GetType();
+  const gridEntityVariant = gridEntity.GetVariant();
+
+  for (const [
+    callback,
+    callbackGridEntityType,
+    callbackGridEntityVariant,
+  ] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(gridEntity);
+  }
+}

package/callbacks/subscriptions/postGridEntityStateChanged.ts

@@ -0,0 +1,55 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export type PostGridEntityStateChangedRegisterParameters = [
+  callback: (gridEntity: GridEntity, oldState: int, newState: int) => void,
+  gridEntityType?: GridEntityType,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostGridEntityStateChangedRegisterParameters[] = [];
+
+/** @internal */
+export function postGridEntityStateChangedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postGridEntityStateChangedRegister(
+  ...args: PostGridEntityStateChangedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postGridEntityStateChangedFire(
+  gridEntity: GridEntity,
+  oldState: int,
+  newState: int,
+): void {
+  const gridEntityType = gridEntity.GetType();
+  const gridEntityVariant = gridEntity.GetVariant();
+
+  for (const [
+    callback,
+    callbackGridEntityType,
+    callbackGridEntityVariant,
+  ] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(gridEntity, oldState, newState);
+  }
+}

package/callbacks/subscriptions/postGridEntityUpdate.ts

@@ -0,0 +1,51 @@
+import { GridEntityType } from "isaac-typescript-definitions";
+
+export type PostGridEntityUpdateRegisterParameters = [
+  callback: (gridEntity: GridEntity) => void,
+  gridEntityType?: GridEntityType,
+  gridEntityVariant?: int,
+];
+
+const subscriptions: PostGridEntityUpdateRegisterParameters[] = [];
+
+/** @internal */
+export function postGridEntityUpdateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postGridEntityUpdateRegister(
+  ...args: PostGridEntityUpdateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postGridEntityUpdateFire(gridEntity: GridEntity): void {
+  const gridEntityType = gridEntity.GetType();
+  const gridEntityVariant = gridEntity.GetVariant();
+
+  for (const [
+    callback,
+    callbackGridEntityType,
+    callbackGridEntityVariant,
+  ] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackGridEntityType !== undefined &&
+      callbackGridEntityType !== gridEntityType
+    ) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (
+      callbackGridEntityVariant !== undefined &&
+      callbackGridEntityVariant !== gridEntityVariant
+    ) {
+      continue;
+    }
+
+    callback(gridEntity);
+  }
+}

package/callbacks/subscriptions/postHolyMantleRemoved.ts

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

package/callbacks/subscriptions/postItemDischarged.ts

@@ -0,0 +1,43 @@
+import { ActiveSlot, CollectibleType } from "isaac-typescript-definitions";
+
+export type PostItemDischargedRegisterParameters = [
+  callback: (
+    player: EntityPlayer,
+    collectibleType: CollectibleType,
+    activeSlot: ActiveSlot,
+  ) => void,
+  collectibleType?: CollectibleType,
+];
+
+const subscriptions: PostItemDischargedRegisterParameters[] = [];
+
+/** @internal */
+export function postItemDischargeHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postItemDischargeRegister(
+  ...args: PostItemDischargedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postItemDischargeFire(
+  player: EntityPlayer,
+  collectibleType: CollectibleType,
+  activeSlot: ActiveSlot,
+): void {
+  for (const [callback, callbackCollectibleType] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (
+      callbackCollectibleType !== undefined &&
+      callbackCollectibleType !== collectibleType
+    ) {
+      continue;
+    }
+
+    callback(player, collectibleType, activeSlot);
+  }
+}

package/callbacks/subscriptions/postItemPickup.ts

@@ -0,0 +1,64 @@
+import {
+  CollectibleType,
+  ItemType,
+  TrinketType,
+} from "isaac-typescript-definitions";
+import {
+  PickingUpItem,
+  PickingUpItemCollectible,
+  PickingUpItemTrinket,
+} from "../../types/PickingUpItem";
+
+export type PostItemPickupRegisterParameters =
+  | [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void]
+  | [
+      callback: (
+        player: EntityPlayer,
+        pickingUpItem: PickingUpItemCollectible,
+      ) => void,
+      itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
+      collectibleType?: CollectibleType,
+    ]
+  | [
+      callback: (
+        player: EntityPlayer,
+        pickingUpItem: PickingUpItemTrinket,
+      ) => void,
+      itemType: ItemType.TRINKET,
+      trinketType?: TrinketType,
+    ];
+
+const subscriptions: PostItemPickupRegisterParameters[] = [];
+
+/** @internal */
+export function postItemPickupHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postItemPickupRegister(
+  ...args: PostItemPickupRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postItemPickupFire(
+  player: EntityPlayer,
+  pickingUpItem: PickingUpItem,
+): void {
+  for (const [callback, itemType, subType] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (itemType !== undefined && itemType !== pickingUpItem.itemType) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (subType !== undefined && subType !== pickingUpItem.subType) {
+      continue;
+    }
+
+    // @ts-expect-error TypeScript isn't smart enough to treat the above checks as type narrowing.
+    callback(player, pickingUpItem);
+  }
+}

package/callbacks/subscriptions/postKnifeInitLate.ts

@@ -0,0 +1,32 @@
+import { KnifeVariant } from "isaac-typescript-definitions";
+
+export type PostKnifeInitLateRegisterParameters = [
+  callback: (knife: EntityKnife) => void,
+  knifeVariant?: KnifeVariant,
+];
+
+const subscriptions: PostKnifeInitLateRegisterParameters[] = [];
+
+/** @internal */
+export function postKnifeInitLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postKnifeInitLateRegister(
+  ...args: PostKnifeInitLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postKnifeInitLateFire(knife: EntityKnife): void {
+  for (const [callback, knifeVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (knifeVariant !== undefined && knifeVariant !== knife.Variant) {
+      continue;
+    }
+
+    callback(knife);
+  }
+}

package/callbacks/subscriptions/postLaserInitLate.ts

@@ -0,0 +1,32 @@
+import { LaserVariant } from "isaac-typescript-definitions";
+
+export type PostLaserInitLateRegisterParameters = [
+  callback: (laser: EntityLaser) => void,
+  laserVariant?: LaserVariant,
+];
+
+const subscriptions: PostLaserInitLateRegisterParameters[] = [];
+
+/** @internal */
+export function postLaserInitLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postLaserInitLateRegister(
+  ...args: PostLaserInitLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postLaserInitLateFire(laser: EntityLaser): void {
+  for (const [callback, laserVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (laserVariant !== undefined && laserVariant !== laser.Variant) {
+      continue;
+    }
+
+    callback(laser);
+  }
+}

package/callbacks/subscriptions/postNPCInitLate.ts

@@ -0,0 +1,32 @@
+import { EntityType } from "isaac-typescript-definitions";
+
+export type PostNPCInitLateRegisterParameters = [
+  callback: (npc: EntityNPC) => void,
+  entityType?: EntityType,
+];
+
+const subscriptions: PostNPCInitLateRegisterParameters[] = [];
+
+/** @internal */
+export function postNPCInitLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postNPCInitLateRegister(
+  ...args: PostNPCInitLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postNPCInitLateFire(npc: EntityNPC): void {
+  for (const [callback, entityType] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (entityType !== undefined && entityType !== npc.Type) {
+      continue;
+    }
+
+    callback(npc);
+  }
+}

package/callbacks/subscriptions/postNPCStateChanged.ts

@@ -0,0 +1,42 @@
+import { EntityType } from "isaac-typescript-definitions";
+
+export type PostNPCStateChangedRegisterParameters = [
+  callback: (npc: EntityNPC, previousState: int, currentState: int) => void,
+  entityType?: EntityType,
+  variant?: int,
+];
+
+const subscriptions: PostNPCStateChangedRegisterParameters[] = [];
+
+/** @internal */
+export function postNPCStateChangedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postNPCStateChangedRegister(
+  ...args: PostNPCStateChangedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postNPCStateChangedFire(
+  npc: EntityNPC,
+  previousState: int,
+  currentState: int,
+): void {
+  for (const [callback, entityType, variant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (entityType !== undefined && entityType !== npc.Type) {
+      continue;
+    }
+
+    // Handle the optional 3rd callback argument.
+    if (variant !== undefined && variant !== npc.Variant) {
+      continue;
+    }
+
+    callback(npc, previousState, currentState);
+  }
+}

package/callbacks/subscriptions/postNewLevelReordered.ts

@@ -0,0 +1,22 @@
+export type PostNewLevelReorderedRegisterParameters = [callback: () => void];
+
+const subscriptions: PostNewLevelReorderedRegisterParameters[] = [];
+
+/** @internal */
+export function postNewLevelReorderedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postNewLevelReorderedRegister(
+  ...args: PostNewLevelReorderedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postNewLevelReorderedFire(): void {
+  for (const [callback] of subscriptions) {
+    callback();
+  }
+}

package/callbacks/subscriptions/postNewRoomEarly.ts

@@ -0,0 +1,22 @@
+export type PostNewRoomEarlyRegisterParameters = [callback: () => void];
+
+const subscriptions: PostNewRoomEarlyRegisterParameters[] = [];
+
+/** @internal */
+export function postNewRoomEarlyHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postNewRoomEarlyRegister(
+  ...args: PostNewRoomEarlyRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postNewRoomEarlyFire(): void {
+  for (const [callback] of subscriptions) {
+    callback();
+  }
+}

package/callbacks/subscriptions/postNewRoomReordered.ts

@@ -0,0 +1,22 @@
+export type PostNewRoomReorderedRegisterParameters = [callback: () => void];
+
+const subscriptions: PostNewRoomReorderedRegisterParameters[] = [];
+
+/** @internal */
+export function postNewRoomReorderedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postNewRoomReorderedRegister(
+  ...args: PostNewRoomReorderedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postNewRoomReorderedFire(): void {
+  for (const [callback] of subscriptions) {
+    callback();
+  }
+}

package/callbacks/subscriptions/postPEffectUpdateReordered.ts

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

package/callbacks/subscriptions/postPickupCollect.ts

@@ -0,0 +1,35 @@
+import { PickupVariant } from "isaac-typescript-definitions";
+
+export type PostPickupCollectRegisterParameters = [
+  callback: (pickup: EntityPickup, player: EntityPlayer) => void,
+  pickupVariant?: PickupVariant,
+];
+
+const subscriptions: PostPickupCollectRegisterParameters[] = [];
+
+/** @internal */
+export function postPickupCollectHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPickupCollectRegister(
+  ...args: PostPickupCollectRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPickupCollectFire(
+  pickup: EntityPickup,
+  player: EntityPlayer,
+): void {
+  for (const [callback, pickupVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (pickupVariant !== undefined && pickupVariant !== pickup.Variant) {
+      continue;
+    }
+
+    callback(pickup, player);
+  }
+}

package/callbacks/subscriptions/postPickupInitFirst.ts

@@ -0,0 +1,32 @@
+import { PickupVariant } from "isaac-typescript-definitions";
+
+export type PostPickupInitFirstRegisterParameters = [
+  callback: (pickup: EntityPickup) => void,
+  pickupVariant?: PickupVariant,
+];
+
+const subscriptions: PostPickupInitFirstRegisterParameters[] = [];
+
+/** @internal */
+export function postPickupInitFirstHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPickupInitFirstRegister(
+  ...args: PostPickupInitFirstRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPickupInitFirstFire(pickup: EntityPickup): void {
+  for (const [callback, pickupVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (pickupVariant !== undefined && pickupVariant !== pickup.Variant) {
+      continue;
+    }
+
+    callback(pickup);
+  }
+}