isaacscript-common 3.16.1 → 4.0.1-dev.0

package/callbacks/subscriptions/postPickupInitLate.ts

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

package/callbacks/subscriptions/postPickupStateChanged.ts

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

package/callbacks/subscriptions/postPitRender.ts

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

package/callbacks/subscriptions/postPitUpdate.ts

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

package/callbacks/subscriptions/postPlayerChangeHealth.ts

@@ -0,0 +1,49 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+import { HealthType } from "../../enums/HealthType";
+
+export type PostPlayerChangeHealthRegisterParameters = [
+  callback: (
+    player: EntityPlayer,
+    healthType: HealthType,
+    difference: int,
+  ) => void,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostPlayerChangeHealthRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerChangeHealthHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerChangeHealthRegister(
+  ...args: PostPlayerChangeHealthRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerChangeHealthFire(
+  player: EntityPlayer,
+  healthType: HealthType,
+  difference: 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, healthType, difference);
+  }
+}

package/callbacks/subscriptions/postPlayerChangeType.ts

@@ -0,0 +1,40 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+
+export type PostPlayerChangeTypeRegisterParameters = [
+  callback: (
+    player: EntityPlayer,
+    oldCharacter: PlayerType,
+    newCharacter: PlayerType,
+  ) => void,
+  playerVariant?: PlayerVariant,
+];
+
+const subscriptions: PostPlayerChangeTypeRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerChangeTypeHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerChangeTypeRegister(
+  ...args: PostPlayerChangeTypeRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerChangeTypeFire(
+  player: EntityPlayer,
+  oldCharacter: PlayerType,
+  newCharacter: PlayerType,
+): void {
+  for (const [callback, playerVariant] of subscriptions) {
+    // Handle the optional 2nd callback argument.
+    if (playerVariant !== undefined && playerVariant !== player.Variant) {
+      continue;
+    }
+
+    callback(player, oldCharacter, newCharacter);
+  }
+}

package/callbacks/subscriptions/postPlayerCollectibleAdded.d.ts

@@ -1,6 +1,5 @@
-import { CollectibleType, PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+import { CollectibleType } from "isaac-typescript-definitions";
 export declare type PostPlayerCollectibleAddedRegisterParameters = [
     callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
-    playerVariant?: PlayerVariant,
-    character?: PlayerType
+    collectibleType?: CollectibleType
 ];

package/callbacks/subscriptions/postPlayerCollectibleAdded.lua

@@ -14,16 +14,11 @@ end
 ---
 -- @internal
 function ____exports.postPlayerCollectibleAddedFire(self, player, collectibleType)
-    local character = player:GetPlayerType()
     for ____, ____value in ipairs(subscriptions) do
         local callback = ____value[1]
-        local playerVariant = ____value[2]
-        local callbackCharacter = ____value[3]
+        local callbackCollectibleType = ____value[2]
         do
-            if playerVariant ~= nil and playerVariant ~= player.Variant then
-                goto __continue5
-            end
-            if callbackCharacter ~= nil and callbackCharacter ~= character then
+            if callbackCollectibleType ~= nil and callbackCollectibleType ~= collectibleType then
                 goto __continue5
             end
             callback(nil, player, collectibleType)

package/callbacks/subscriptions/postPlayerCollectibleAdded.ts

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

package/callbacks/subscriptions/postPlayerCollectibleRemoved.d.ts

@@ -1,6 +1,5 @@
-import { CollectibleType, PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+import { CollectibleType } from "isaac-typescript-definitions";
 export declare type PostPlayerCollectibleRemovedRegisterParameters = [
     callback: (player: EntityPlayer, collectibleType: CollectibleType) => void,
-    playerVariant?: PlayerVariant,
-    character?: PlayerType
+    collectibleType?: CollectibleType
 ];

package/callbacks/subscriptions/postPlayerCollectibleRemoved.lua

@@ -14,16 +14,11 @@ end
 ---
 -- @internal
 function ____exports.postPlayerCollectibleRemovedFire(self, player, collectibleType)
-    local character = player:GetPlayerType()
     for ____, ____value in ipairs(subscriptions) do
         local callback = ____value[1]
-        local playerVariant = ____value[2]
-        local callbackCharacter = ____value[3]
+        local callbackCollectibleType = ____value[2]
         do
-            if playerVariant ~= nil and playerVariant ~= player.Variant then
-                goto __continue5
-            end
-            if callbackCharacter ~= nil and callbackCharacter ~= character then
+            if callbackCollectibleType ~= nil and callbackCollectibleType ~= collectibleType then
                 goto __continue5
             end
             callback(nil, player, collectibleType)

package/callbacks/subscriptions/postPlayerCollectibleRemoved.ts

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

package/callbacks/subscriptions/postPlayerFatalDamage.d.ts

@@ -1,6 +1,6 @@
 import { DamageFlag, PlayerType, PlayerVariant } from "isaac-typescript-definitions";
 export declare type PostPlayerFatalDamageRegisterParameters = [
-    callback: (player: EntityPlayer, damageAmount: float, damageFlags: BitFlags<DamageFlag>, damageSource: EntityRef, damageCountdownFrames: int) => boolean | void,
+    callback: (player: EntityPlayer, damageAmount: float, damageFlags: BitFlags<DamageFlag>, damageSource: EntityRef, damageCountdownFrames: int) => boolean | undefined,
     playerVariant?: PlayerVariant,
     character?: PlayerType
 ];

package/callbacks/subscriptions/postPlayerFatalDamage.ts

@@ -0,0 +1,68 @@
+import {
+  DamageFlag,
+  PlayerType,
+  PlayerVariant,
+} from "isaac-typescript-definitions";
+
+export type PostPlayerFatalDamageRegisterParameters = [
+  callback: (
+    player: EntityPlayer,
+    damageAmount: float,
+    damageFlags: BitFlags<DamageFlag>,
+    damageSource: EntityRef,
+    damageCountdownFrames: int,
+  ) => boolean | undefined,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostPlayerFatalDamageRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerFatalDamageHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerFatalDamageRegister(
+  ...args: PostPlayerFatalDamageRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerFatalDamageFire(
+  player: EntityPlayer,
+  damageAmount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  damageSource: EntityRef,
+  damageCountdownFrames: int,
+): boolean | undefined {
+  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;
+    }
+
+    const shouldSustainDeath = callback(
+      player,
+      damageAmount,
+      damageFlags,
+      damageSource,
+      damageCountdownFrames,
+    );
+
+    if (shouldSustainDeath !== undefined) {
+      return shouldSustainDeath;
+    }
+  }
+
+  return undefined;
+}

package/callbacks/subscriptions/postPlayerInitLate.ts

@@ -0,0 +1,40 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+
+export type PostPlayerInitLateRegisterParameters = [
+  callback: (player: EntityPlayer) => void,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostPlayerInitLateRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerInitLateHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerInitLateRegister(
+  ...args: PostPlayerInitLateRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerInitLateFire(player: EntityPlayer): 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);
+  }
+}

package/callbacks/subscriptions/postPlayerInitReordered.ts

@@ -0,0 +1,40 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+
+export type PostPlayerInitReorderedRegisterParameters = [
+  callback: (player: EntityPlayer) => void,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostPlayerInitReorderedRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerInitReorderedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerInitReorderedRegister(
+  ...args: PostPlayerInitReorderedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerInitReorderedFire(player: EntityPlayer): 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);
+  }
+}

package/callbacks/subscriptions/postPlayerRenderReordered.ts

@@ -0,0 +1,40 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+
+export type PostPlayerRenderReorderedRegisterParameters = [
+  callback: (player: EntityPlayer) => void,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostPlayerRenderReorderedRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerRenderReorderedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerRenderReorderedRegister(
+  ...args: PostPlayerRenderReorderedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerRenderReorderedFire(player: EntityPlayer): 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);
+  }
+}

package/callbacks/subscriptions/postPlayerUpdateReordered.ts

@@ -0,0 +1,40 @@
+import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
+
+export type PostPlayerUpdateReorderedRegisterParameters = [
+  callback: (player: EntityPlayer) => void,
+  playerVariant?: PlayerVariant,
+  character?: PlayerType,
+];
+
+const subscriptions: PostPlayerUpdateReorderedRegisterParameters[] = [];
+
+/** @internal */
+export function postPlayerUpdateReorderedHasSubscriptions(): boolean {
+  return subscriptions.length > 0;
+}
+
+/** @internal */
+export function postPlayerUpdateReorderedRegister(
+  ...args: PostPlayerUpdateReorderedRegisterParameters
+): void {
+  subscriptions.push(args);
+}
+
+/** @internal */
+export function postPlayerUpdateReorderedFire(player: EntityPlayer): 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);
+  }
+}

package/callbacks/subscriptions/postPoopRender.ts

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

package/callbacks/subscriptions/postPoopUpdate.ts

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