isaacscript-common 27.10.1 → 27.12.0

package/src/callbackClasses.ts

@@ -17,12 +17,18 @@ export { PostCustomRevive } from "./classes/callbacks/PostCustomRevive";
 export { PostDiceRoomActivated } from "./classes/callbacks/PostDiceRoomActivated";
 export { PostDoorRender } from "./classes/callbacks/PostDoorRender";
 export { PostDoorUpdate } from "./classes/callbacks/PostDoorUpdate";
+export { PostEffectInitFilter } from "./classes/callbacks/PostEffectInitFilter";
 export { PostEffectInitLate } from "./classes/callbacks/PostEffectInitLate";
+export { PostEffectRenderFilter } from "./classes/callbacks/PostEffectRenderFilter";
 export { PostEffectStateChanged } from "./classes/callbacks/PostEffectStateChanged";
+export { PostEffectUpdateFilter } from "./classes/callbacks/PostEffectUpdateFilter";
 export { PostEntityKillFilter } from "./classes/callbacks/PostEntityKillFilter";
 export { PostEsauJr } from "./classes/callbacks/PostEsauJr";
+export { PostFamiliarInitFilter } from "./classes/callbacks/PostFamiliarInitFilter";
 export { PostFamiliarInitLate } from "./classes/callbacks/PostFamiliarInitLate";
+export { PostFamiliarRenderFilter } from "./classes/callbacks/PostFamiliarRenderFilter";
 export { PostFamiliarStateChanged } from "./classes/callbacks/PostFamiliarStateChanged";
+export { PostFamiliarUpdateFilter } from "./classes/callbacks/PostFamiliarUpdateFilter";
 export { PostFirstEsauJr } from "./classes/callbacks/PostFirstEsauJr";
 export { PostFirstFlip } from "./classes/callbacks/PostFirstFlip";
 export { PostFlip } from "./classes/callbacks/PostFlip";
@@ -48,7 +54,10 @@ export { PostItemDischarge } from "./classes/callbacks/PostItemDischarge";
 export { PostItemPickup } from "./classes/callbacks/PostItemPickup";
 export { PostKeyboardChanged as PostKeyboardPressed } from "./classes/callbacks/PostKeyboardChanged";
 export { PostKnifeInitLate } from "./classes/callbacks/PostKnifeInitLate";
+export { PostLaserInitFilter } from "./classes/callbacks/PostLaserInitFilter";
 export { PostLaserInitLate } from "./classes/callbacks/PostLaserInitLate";
+export { PostLaserRenderFilter } from "./classes/callbacks/PostLaserRenderFilter";
+export { PostLaserUpdateFilter } from "./classes/callbacks/PostLaserUpdateFilter";
 export { PostNewLevelReordered } from "./classes/callbacks/PostNewLevelReordered";
 export { PostNewRoomEarly } from "./classes/callbacks/PostNewRoomEarly";
 export { PostNewRoomReordered } from "./classes/callbacks/PostNewRoomReordered";
@@ -107,6 +116,7 @@ export { PostTrinketBreak } from "./classes/callbacks/PostTrinketBreak";
 export { PreBerserkDeath } from "./classes/callbacks/PreBerserkDeath";
 export { PreCustomRevive } from "./classes/callbacks/PreCustomRevive";
 export { PreEntitySpawnFilter } from "./classes/callbacks/PreEntitySpawnFilter";
+export { PreFamiliarCollisionFilter } from "./classes/callbacks/PreFamiliarCollisionFilter";
 export { PreGetPedestal } from "./classes/callbacks/PreGetPedestal";
 export { PreItemPickup } from "./classes/callbacks/PreItemPickup";
 export { PreNewLevel } from "./classes/callbacks/PreNewLevel";

package/src/callbacks.ts

@@ -20,12 +20,18 @@ const MOD_CALLBACK_CUSTOM_TO_CLASS = {
   [ModCallbackCustom.POST_DICE_ROOM_ACTIVATED]: cc.PostDiceRoomActivated,
   [ModCallbackCustom.POST_DOOR_RENDER]: cc.PostDoorRender,
   [ModCallbackCustom.POST_DOOR_UPDATE]: cc.PostDoorUpdate,
+  [ModCallbackCustom.POST_EFFECT_INIT_FILTER]: cc.PostEffectInitFilter,
   [ModCallbackCustom.POST_EFFECT_INIT_LATE]: cc.PostEffectInitLate,
+  [ModCallbackCustom.POST_EFFECT_RENDER_FILTER]: cc.PostEffectRenderFilter,
   [ModCallbackCustom.POST_EFFECT_STATE_CHANGED]: cc.PostEffectStateChanged,
+  [ModCallbackCustom.POST_EFFECT_UPDATE_FILTER]: cc.PostEffectUpdateFilter,
   [ModCallbackCustom.POST_ENTITY_KILL_FILTER]: cc.PostEntityKillFilter,
   [ModCallbackCustom.POST_ESAU_JR]: cc.PostEsauJr,
+  [ModCallbackCustom.POST_FAMILIAR_INIT_FILTER]: cc.PostFamiliarInitFilter,
   [ModCallbackCustom.POST_FAMILIAR_INIT_LATE]: cc.PostFamiliarInitLate,
+  [ModCallbackCustom.POST_FAMILIAR_RENDER_FILTER]: cc.PostFamiliarRenderFilter,
   [ModCallbackCustom.POST_FAMILIAR_STATE_CHANGED]: cc.PostFamiliarStateChanged,
+  [ModCallbackCustom.POST_FAMILIAR_UPDATE_FILTER]: cc.PostFamiliarUpdateFilter,
   [ModCallbackCustom.POST_FIRST_FLIP]: cc.PostFirstFlip,
   [ModCallbackCustom.POST_FIRST_ESAU_JR]: cc.PostFirstEsauJr,
   [ModCallbackCustom.POST_FLIP]: cc.PostFlip,
@@ -59,7 +65,10 @@ const MOD_CALLBACK_CUSTOM_TO_CLASS = {
   [ModCallbackCustom.POST_ITEM_PICKUP]: cc.PostItemPickup,
   [ModCallbackCustom.POST_KEYBOARD_CHANGED]: cc.PostKeyboardPressed,
   [ModCallbackCustom.POST_KNIFE_INIT_LATE]: cc.PostKnifeInitLate,
+  [ModCallbackCustom.POST_LASER_INIT_FILTER]: cc.PostLaserInitFilter,
   [ModCallbackCustom.POST_LASER_INIT_LATE]: cc.PostLaserInitLate,
+  [ModCallbackCustom.POST_LASER_RENDER_FILTER]: cc.PostLaserRenderFilter,
+  [ModCallbackCustom.POST_LASER_UPDATE_FILTER]: cc.PostLaserUpdateFilter,
   [ModCallbackCustom.POST_NEW_LEVEL_REORDERED]: cc.PostNewLevelReordered,
   [ModCallbackCustom.POST_NEW_ROOM_EARLY]: cc.PostNewRoomEarly,
   [ModCallbackCustom.POST_NEW_ROOM_REORDERED]: cc.PostNewRoomReordered,
@@ -124,6 +133,8 @@ const MOD_CALLBACK_CUSTOM_TO_CLASS = {
   [ModCallbackCustom.PRE_BERSERK_DEATH]: cc.PreBerserkDeath,
   [ModCallbackCustom.PRE_CUSTOM_REVIVE]: cc.PreCustomRevive,
   [ModCallbackCustom.PRE_ENTITY_SPAWN_FILTER]: cc.PreEntitySpawnFilter,
+  [ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER]:
+    cc.PreFamiliarCollisionFilter,
   [ModCallbackCustom.PRE_GET_PEDESTAL]: cc.PreGetPedestal,
   [ModCallbackCustom.PRE_ITEM_PICKUP]: cc.PreItemPickup,
   [ModCallbackCustom.PRE_NEW_LEVEL]: cc.PreNewLevel,

package/src/classes/callbacks/PostEffectInitFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireEffect } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostEffectInitFilter extends CustomCallback<ModCallbackCustom.POST_EFFECT_INIT_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 54
+      [ModCallback.POST_EFFECT_INIT, this.postEffectInit],
+    ];
+  }
+
+  protected override shouldFire = shouldFireEffect;
+
+  // ModCallback.POST_EFFECT_INIT (54)
+  private postEffectInit = (effect: EntityEffect) => {
+    this.fire(effect);
+  };
+}

package/src/classes/callbacks/PostEffectRenderFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireEffect } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostEffectRenderFilter extends CustomCallback<ModCallbackCustom.POST_EFFECT_RENDER_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 56
+      [ModCallback.POST_EFFECT_RENDER, this.postEffectRender],
+    ];
+  }
+
+  protected override shouldFire = shouldFireEffect;
+
+  // ModCallback.POST_EFFECT_RENDER (56)
+  private postEffectRender = (effect: EntityEffect, renderOffset: Vector) => {
+    this.fire(effect, renderOffset);
+  };
+}

package/src/classes/callbacks/PostEffectUpdateFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireEffect } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostEffectUpdateFilter extends CustomCallback<ModCallbackCustom.POST_EFFECT_UPDATE_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 55
+      [ModCallback.POST_EFFECT_UPDATE, this.postEffectUpdate],
+    ];
+  }
+
+  protected override shouldFire = shouldFireEffect;
+
+  // ModCallback.POST_EFFECT_UPDATE (55)
+  private postEffectUpdate = (effect: EntityEffect) => {
+    this.fire(effect);
+  };
+}

package/src/classes/callbacks/PostFamiliarInitFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireFamiliar } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostFamiliarInitFilter extends CustomCallback<ModCallbackCustom.POST_FAMILIAR_INIT_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 7
+      [ModCallback.POST_FAMILIAR_INIT, this.postFamiliarInit],
+    ];
+  }
+
+  protected override shouldFire = shouldFireFamiliar;
+
+  // ModCallback.POST_FAMILIAR_INIT (7)
+  private postFamiliarInit = (familiar: EntityFamiliar) => {
+    this.fire(familiar);
+  };
+}

package/src/classes/callbacks/PostFamiliarRenderFilter.ts

@@ -0,0 +1,25 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireFamiliar } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostFamiliarRenderFilter extends CustomCallback<ModCallbackCustom.POST_FAMILIAR_RENDER_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 25
+      [ModCallback.POST_FAMILIAR_RENDER, this.postFamiliarRender],
+    ];
+  }
+
+  protected override shouldFire = shouldFireFamiliar;
+
+  // ModCallback.POST_FAMILIAR_UPDATE (6)
+  private postFamiliarRender = (
+    familiar: EntityFamiliar,
+    renderOffset: Vector,
+  ) => {
+    this.fire(familiar, renderOffset);
+  };
+}

package/src/classes/callbacks/PostFamiliarUpdateFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireFamiliar } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostFamiliarUpdateFilter extends CustomCallback<ModCallbackCustom.POST_FAMILIAR_UPDATE_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 6
+      [ModCallback.POST_FAMILIAR_UPDATE, this.postFamiliarUpdate],
+    ];
+  }
+
+  protected override shouldFire = shouldFireFamiliar;
+
+  // ModCallback.POST_FAMILIAR_UPDATE (6)
+  private postFamiliarUpdate = (familiar: EntityFamiliar) => {
+    this.fire(familiar);
+  };
+}

package/src/classes/callbacks/PostLaserInitFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireLaser } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostLaserInitFilter extends CustomCallback<ModCallbackCustom.POST_LASER_INIT_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 47
+      [ModCallback.POST_LASER_INIT, this.postLaserInit],
+    ];
+  }
+
+  protected override shouldFire = shouldFireLaser;
+
+  // ModCallback.POST_LASER_INIT (47)
+  private postLaserInit = (laser: EntityLaser) => {
+    this.fire(laser);
+  };
+}

package/src/classes/callbacks/PostLaserRenderFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireLaser } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostLaserRenderFilter extends CustomCallback<ModCallbackCustom.POST_LASER_RENDER_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 49
+      [ModCallback.POST_LASER_RENDER, this.postLaserRender],
+    ];
+  }
+
+  protected override shouldFire = shouldFireLaser;
+
+  // ModCallback.POST_LASER_RENDER (49)
+  private postLaserRender = (laser: EntityLaser, renderOffset: Vector) => {
+    this.fire(laser, renderOffset);
+  };
+}

package/src/classes/callbacks/PostLaserUpdateFilter.ts

@@ -0,0 +1,22 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireLaser } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PostLaserUpdateFilter extends CustomCallback<ModCallbackCustom.POST_LASER_UPDATE_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 48
+      [ModCallback.POST_LASER_UPDATE, this.postLaserUpdate],
+    ];
+  }
+
+  protected override shouldFire = shouldFireLaser;
+
+  // ModCallback.POST_LASER_UPDATE (48)
+  private postLaserUpdate = (laser: EntityLaser) => {
+    this.fire(laser);
+  };
+}

package/src/classes/callbacks/PreFamiliarCollisionFilter.ts

@@ -0,0 +1,24 @@
+import { ModCallback } from "isaac-typescript-definitions";
+import { ModCallbackCustom } from "../../enums/ModCallbackCustom";
+import { shouldFireFamiliar } from "../../shouldFire";
+import { CustomCallback } from "../private/CustomCallback";
+
+export class PreFamiliarCollisionFilter extends CustomCallback<ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER> {
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 26
+      [ModCallback.PRE_FAMILIAR_COLLISION, this.preFamiliarCollision],
+    ];
+  }
+
+  protected override shouldFire = shouldFireFamiliar;
+
+  // ModCallback.PRE_FAMILIAR_COLLISION (26)
+  private preFamiliarCollision = (
+    familiar: EntityFamiliar,
+    collider: Entity,
+    low: boolean,
+  ): boolean | undefined => this.fire(familiar, collider, low);
+}

package/src/enums/ModCallbackCustom.ts

@@ -294,6 +294,22 @@ export enum ModCallbackCustom {
    */
   POST_DOOR_UPDATE,
 
+  /**
+   * The exact same thing as the vanilla `POST_EFFECT_INIT` callback, except this callback allows
+   * you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `EffectVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postEffectInitFilter(effect: EntityEffect): void {}
+   * ```
+   */
+  POST_EFFECT_INIT_FILTER,
+
   /**
    * Fires on the first `POST_EFFECT_UPDATE` frame for each effect.
    *
@@ -312,6 +328,22 @@ export enum ModCallbackCustom {
    */
   POST_EFFECT_INIT_LATE,
 
+  /**
+   * The exact same thing as the vanilla `POST_EFFECT_RENDER` callback, except this callback allows
+   * you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `EffectVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postEffectRenderFilter(effect: EntityEffect, renderOffset: Vector): void {}
+   * ```
+   */
+  POST_EFFECT_RENDER_FILTER,
+
   /**
    * Fires from the `POST_EFFECT_UPDATE` callback when an effect's state has changed from what it
    * was on the previous frame. (In this context, "state" refers to the `EntityEffect.State` field.)
@@ -332,6 +364,22 @@ export enum ModCallbackCustom {
    */
   POST_EFFECT_STATE_CHANGED,
 
+  /**
+   * The exact same thing as the vanilla `POST_EFFECT_UPDATE` callback, except this callback allows
+   * you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `EffectVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postEffectUpdateFilter(effect: EntityEffect): void {}
+   * ```
+   */
+  POST_EFFECT_UPDATE_FILTER,
+
   /**
    * The exact same thing as the vanilla `POST_ENTITY_KILL` callback, except this callback allows
    * you to specify extra arguments for additional filtration.
@@ -360,6 +408,22 @@ export enum ModCallbackCustom {
    */
   POST_ESAU_JR,
 
+  /**
+   * The exact same thing as the vanilla `POST_FAMILIAR_INIT` callback, except this callback allows
+   * you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `FamiliarVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postFamiliarInitFilter(familiar: EntityFamiliar): void {}
+   * ```
+   */
+  POST_FAMILIAR_INIT_FILTER,
+
   /**
    * Fires on the first `FAMILIAR_UPDATE` frame for each familiar.
    *
@@ -378,6 +442,22 @@ export enum ModCallbackCustom {
    */
   POST_FAMILIAR_INIT_LATE,
 
+  /**
+   * The exact same thing as the vanilla `POST_FAMILIAR_RENDER` callback, except this callback
+   * allows you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `FamiliarVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postFamiliarRenderFilter(familiar: EntityFamiliar, renderOffset: Vector): void {}
+   * ```
+   */
+  POST_FAMILIAR_RENDER_FILTER,
+
   /**
    * Fires from the `POST_FAMILIAR_UPDATE` callback when a familiar's state has changed from what it
    * was on the previous frame. (In this context, "state" refers to the `EntityFamiliar.State`
@@ -399,6 +479,22 @@ export enum ModCallbackCustom {
    */
   POST_FAMILIAR_STATE_CHANGED,
 
+  /**
+   * The exact same thing as the vanilla `POST_FAMILIAR_UPDATE` callback, except this callback
+   * allows you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `FamiliarVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postFamiliarUpdateFilter(familiar: EntityFamiliar): void {}
+   * ```
+   */
+  POST_FAMILIAR_UPDATE_FILTER,
+
   /**
    * Fires one `POST_UPDATE` frame after the player has first used the Esau Jr. item. (The player is
    * not updated to the new character until a game frame has passed.)
@@ -886,6 +982,22 @@ export enum ModCallbackCustom {
    */
   POST_KNIFE_INIT_LATE,
 
+  /**
+   * The exact same thing as the vanilla `POST_LASER_INIT` callback, except this callback allows you
+   * to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `LaserVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postLaserInitFilter(laser: EntityLaser): void {}
+   * ```
+   */
+  POST_LASER_INIT_FILTER,
+
   /**
    * Fires on the first `POST_LASER_UPDATE` frame for each laser.
    *
@@ -904,6 +1016,38 @@ export enum ModCallbackCustom {
    */
   POST_LASER_INIT_LATE,
 
+  /**
+   * The exact same thing as the vanilla `POST_LASER_RENDER` callback, except this callback allows
+   * you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `LaserVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postLaserRenderFilter(laser: EntityLaser, renderOffset: Vector): void {}
+   * ```
+   */
+  POST_LASER_RENDER_FILTER,
+
+  /**
+   * The exact same thing as the vanilla `POST_LASER_UPDATE` callback, except this callback allows
+   * you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `LaserVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function postLaserUpdateFilter(laser: EntityLaser): void {}
+   * ```
+   */
+  POST_LASER_UPDATE_FILTER,
+
   /**
    * The same as the vanilla callback of the same name, but fires in the correct order with respect
    * to the `POST_GAME_STARTED` and the `POST_NEW_ROOM` callbacks:
@@ -2010,6 +2154,26 @@ export enum ModCallbackCustom {
    */
   PRE_ENTITY_SPAWN_FILTER,
 
+  /**
+   * The exact same thing as the vanilla `PRE_FAMILIAR_COLLISION` callback, except this callback
+   * allows you to specify extra arguments for additional filtration.
+   *
+   * When registering the callback with the `ModUpgraded.AddCallbackCustom` method:
+   * - You can provide an optional third argument that will make the callback only fire if it
+   *   matches the `FamiliarVariant` provided.
+   * - You can provide an optional fourth argument that will make the callback only fire if it
+   *   matches the sub-type provided.
+   *
+   * ```ts
+   * function preFamiliarCollisionFilter(
+   *   familiar: EntityFamiliar,
+   *   collider: Entity,
+   *   low: boolean,
+   * ): void {}
+   * ```
+   */
+  PRE_FAMILIAR_COLLISION_FILTER,
+
   /**
    * Fires from the `PRE_PICKUP_COLLISION` callback when a player touches a collectible pedestal and
    * meets all of the conditions to pick it up.

package/src/interfaces/private/AddCallbackParametersCustom.ts

@@ -158,12 +158,24 @@ export interface AddCallbackParametersCustom {
     doorVariant?: DoorVariant,
   ];
 
+  [ModCallbackCustom.POST_EFFECT_INIT_FILTER]: [
+    callback: (effect: EntityEffect) => void,
+    effectVariant?: EffectVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_EFFECT_INIT_LATE]: [
     callback: (effect: EntityEffect) => void,
     effectVariant?: EffectVariant,
     subType?: int,
   ];
 
+  [ModCallbackCustom.POST_EFFECT_RENDER_FILTER]: [
+    callback: (effect: EntityEffect, renderOffset: Vector) => void,
+    effectVariant?: EffectVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_EFFECT_STATE_CHANGED]: [
     callback: (
       effect: EntityEffect,
@@ -174,6 +186,12 @@ export interface AddCallbackParametersCustom {
     subType?: int,
   ];
 
+  [ModCallbackCustom.POST_EFFECT_UPDATE_FILTER]: [
+    callback: (effect: EntityEffect) => void,
+    effectVariant?: EffectVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_ENTITY_KILL_FILTER]: [
     callback: (entity: Entity) => void,
     entityType?: EntityType,
@@ -187,12 +205,24 @@ export interface AddCallbackParametersCustom {
   //   by character.
   [ModCallbackCustom.POST_ESAU_JR]: [callback: (player: EntityPlayer) => void];
 
+  [ModCallbackCustom.POST_FAMILIAR_INIT_FILTER]: [
+    callback: (familiar: EntityFamiliar) => void,
+    familiarVariant?: FamiliarVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_FAMILIAR_INIT_LATE]: [
     callback: (familiar: EntityFamiliar) => void,
     familiarVariant?: FamiliarVariant,
     subType?: int,
   ];
 
+  [ModCallbackCustom.POST_FAMILIAR_RENDER_FILTER]: [
+    callback: (familiar: EntityFamiliar, renderOffset: Vector) => void,
+    familiarVariant?: FamiliarVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_FAMILIAR_STATE_CHANGED]: [
     callback: (
       familiar: EntityFamiliar,
@@ -203,6 +233,12 @@ export interface AddCallbackParametersCustom {
     subType?: int,
   ];
 
+  [ModCallbackCustom.POST_FAMILIAR_UPDATE_FILTER]: [
+    callback: (familiar: EntityFamiliar) => void,
+    familiarVariant?: FamiliarVariant,
+    subType?: int,
+  ];
+
   // - Co-op babies cannot turn into Esau Jr, so it does not make sense to filter by
   //   `PlayerVariant`.
   // - The character of Esau Jr. is equal to `PlayerType.ISAAC`, so it does not make sense to filter
@@ -393,12 +429,30 @@ export interface AddCallbackParametersCustom {
     subType?: int,
   ];
 
+  [ModCallbackCustom.POST_LASER_INIT_FILTER]: [
+    callback: (laser: EntityLaser) => void,
+    laserVariant?: LaserVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_LASER_INIT_LATE]: [
     callback: (laser: EntityLaser) => void,
     laserVariant?: LaserVariant,
     subType?: int,
   ];
 
+  [ModCallbackCustom.POST_LASER_RENDER_FILTER]: [
+    callback: (laser: EntityLaser, renderOffset: Vector) => void,
+    laserVariant?: LaserVariant,
+    subType?: int,
+  ];
+
+  [ModCallbackCustom.POST_LASER_UPDATE_FILTER]: [
+    callback: (laser: EntityLaser) => void,
+    laserVariant?: LaserVariant,
+    subType?: int,
+  ];
+
   [ModCallbackCustom.POST_NEW_LEVEL_REORDERED]: [
     callback: (stage: LevelStage, stageType: StageType) => void,
     stage?: LevelStage,
@@ -790,6 +844,16 @@ export interface AddCallbackParametersCustom {
     subtype?: int,
   ];
 
+  [ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER]: [
+    callback: (
+      familiar: EntityFamiliar,
+      collider: Entity,
+      low: boolean,
+    ) => boolean | undefined,
+    familiarVariant?: FamiliarVariant,
+    subtype?: int,
+  ];
+
   [ModCallbackCustom.PRE_GET_PEDESTAL]: [
     callback: (
       player: EntityPlayer,