isaacscript-common 87.9.6 → 87.9.7

package/src/classes/callbacks/PostSlotRender.ts

@@ -4,11 +4,10 @@ import { shouldFireSlot } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostSlotRender extends CustomCallback<ModCallbackCustom.POST_SLOT_RENDER> {
+  protected override shouldFire = shouldFireSlot;
   constructor() {
     super();
 
     this.featuresUsed = [ISCFeature.SLOT_RENDER_DETECTION];
   }
-
-  protected override shouldFire = shouldFireSlot;
 }

package/src/classes/callbacks/PostSlotUpdate.ts

@@ -4,11 +4,10 @@ import { shouldFireSlot } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostSlotUpdate extends CustomCallback<ModCallbackCustom.POST_SLOT_UPDATE> {
+  protected override shouldFire = shouldFireSlot;
   constructor() {
     super();
 
     this.featuresUsed = [ISCFeature.SLOT_UPDATE_DETECTION];
   }
-
-  protected override shouldFire = shouldFireSlot;
 }

package/src/classes/callbacks/PostSpikesRender.ts

@@ -5,6 +5,15 @@ import { shouldFireSpikes } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostSpikesRender extends CustomCallback<ModCallbackCustom.POST_SPIKES_RENDER> {
+  // ModCallback.POST_RENDER (2)
+  private readonly postRender = (): void => {
+    for (const spikes of getSpikes()) {
+      this.fire(spikes);
+    }
+  };
+
+  protected override shouldFire = shouldFireSpikes;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostSpikesRender extends CustomCallback<ModCallbackCustom.POST_SPIK
       [ModCallback.POST_RENDER, this.postRender],
     ];
   }
-
-  protected override shouldFire = shouldFireSpikes;
-
-  // ModCallback.POST_RENDER (2)
-  private readonly postRender = (): void => {
-    for (const spikes of getSpikes()) {
-      this.fire(spikes);
-    }
-  };
 }

package/src/classes/callbacks/PostSpikesUpdate.ts

@@ -5,6 +5,15 @@ import { shouldFireSpikes } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostSpikesUpdate extends CustomCallback<ModCallbackCustom.POST_SPIKES_RENDER> {
+  // ModCallback.POST_UPDATE (1)
+  private readonly postUpdate = (): void => {
+    for (const spikes of getSpikes()) {
+      this.fire(spikes);
+    }
+  };
+
+  protected override shouldFire = shouldFireSpikes;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostSpikesUpdate extends CustomCallback<ModCallbackCustom.POST_SPIK
       [ModCallback.POST_UPDATE, this.postUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireSpikes;
-
-  // ModCallback.POST_UPDATE (1)
-  private readonly postUpdate = (): void => {
-    for (const spikes of getSpikes()) {
-      this.fire(spikes);
-    }
-  };
 }

package/src/classes/callbacks/PostTNTRender.ts

@@ -5,6 +5,15 @@ import { shouldFireTNT } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostTNTRender extends CustomCallback<ModCallbackCustom.POST_TNT_RENDER> {
+  // ModCallback.POST_RENDER (2)
+  private readonly postRender = (): void => {
+    for (const tnt of getTNT()) {
+      this.fire(tnt);
+    }
+  };
+
+  protected override shouldFire = shouldFireTNT;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostTNTRender extends CustomCallback<ModCallbackCustom.POST_TNT_REN
       [ModCallback.POST_RENDER, this.postRender],
     ];
   }
-
-  protected override shouldFire = shouldFireTNT;
-
-  // ModCallback.POST_RENDER (2)
-  private readonly postRender = (): void => {
-    for (const tnt of getTNT()) {
-      this.fire(tnt);
-    }
-  };
 }

package/src/classes/callbacks/PostTNTUpdate.ts

@@ -5,6 +5,15 @@ import { shouldFireTNT } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostTNTUpdate extends CustomCallback<ModCallbackCustom.POST_TNT_UPDATE> {
+  // ModCallback.POST_UPDATE (1)
+  private readonly postUpdate = (): void => {
+    for (const tnt of getTNT()) {
+      this.fire(tnt);
+    }
+  };
+
+  protected override shouldFire = shouldFireTNT;
+
   constructor() {
     super();
 
@@ -13,13 +22,4 @@ export class PostTNTUpdate extends CustomCallback<ModCallbackCustom.POST_TNT_UPD
       [ModCallback.POST_UPDATE, this.postUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireTNT;
-
-  // ModCallback.POST_UPDATE (1)
-  private readonly postUpdate = (): void => {
-    for (const tnt of getTNT()) {
-      this.fire(tnt);
-    }
-  };
 }

package/src/classes/callbacks/PostTearInitFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireTear } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostTearInitFilter extends CustomCallback<ModCallbackCustom.POST_TEAR_INIT_FILTER> {
+  // ModCallback.POST_TEAR_INIT (39)
+  private readonly postTearInit = (tear: EntityTear) => {
+    this.fire(tear);
+  };
+
+  protected override shouldFire = shouldFireTear;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostTearInitFilter extends CustomCallback<ModCallbackCustom.POST_TE
       [ModCallback.POST_TEAR_INIT, this.postTearInit],
     ];
   }
-
-  protected override shouldFire = shouldFireTear;
-
-  // ModCallback.POST_TEAR_INIT (39)
-  private readonly postTearInit = (tear: EntityTear) => {
-    this.fire(tear);
-  };
 }

package/src/classes/callbacks/PostTearInitLate.ts

@@ -10,8 +10,19 @@ const v = {
 };
 
 export class PostTearInitLate extends CustomCallback<ModCallbackCustom.POST_TEAR_INIT_LATE> {
+  // ModCallback.POST_TEAR_UPDATE (40)
+  private readonly postTearUpdate = (tear: EntityTear): void => {
+    const ptrHash = GetPtrHash(tear);
+    if (!v.room.firedSet.has(ptrHash)) {
+      v.room.firedSet.add(ptrHash);
+      this.fire(tear);
+    }
+  };
+
   public override v = v;
 
+  protected override shouldFire = shouldFireTear;
+
   constructor() {
     super();
 
@@ -20,15 +31,4 @@ export class PostTearInitLate extends CustomCallback<ModCallbackCustom.POST_TEAR
       [ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireTear;
-
-  // ModCallback.POST_TEAR_UPDATE (40)
-  private readonly postTearUpdate = (tear: EntityTear): void => {
-    const ptrHash = GetPtrHash(tear);
-    if (!v.room.firedSet.has(ptrHash)) {
-      v.room.firedSet.add(ptrHash);
-      this.fire(tear);
-    }
-  };
 }

package/src/classes/callbacks/PostTearInitVeryLate.ts

@@ -10,19 +10,6 @@ const v = {
 };
 
 export class PostTearInitVeryLate extends CustomCallback<ModCallbackCustom.POST_TEAR_INIT_VERY_LATE> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 40
-      [ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
-    ];
-  }
-
-  protected override shouldFire = shouldFireTear;
-
   // ModCallback.POST_TEAR_UPDATE (40)
   private readonly postTearUpdate = (tear: EntityTear): void => {
     // This callback fires on frame 1.
@@ -36,4 +23,17 @@ export class PostTearInitVeryLate extends CustomCallback<ModCallbackCustom.POST_
       this.fire(tear);
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = shouldFireTear;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 40
+      [ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
+    ];
+  }
 }

package/src/classes/callbacks/PostTearKill.ts

@@ -10,25 +10,6 @@ const v = {
 };
 
 export class PostTearKill extends CustomCallback<ModCallbackCustom.POST_TEAR_KILL> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 40
-      [ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
-
-      // 42
-      [ModCallback.PRE_TEAR_COLLISION, this.preTearCollision],
-
-      // 67
-      [ModCallback.POST_ENTITY_REMOVE, this.postEntityRemove],
-    ];
-  }
-
-  protected override shouldFire = shouldFireTear;
-
   // ModCallback.POST_PROJECTILE_UPDATE (40)
   private readonly postTearUpdate = (tear: EntityTear) => {
     const ptrHash = GetPtrHash(tear);
@@ -63,4 +44,23 @@ export class PostTearKill extends CustomCallback<ModCallbackCustom.POST_TEAR_KIL
       this.fire(tear);
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = shouldFireTear;
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 40
+      [ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
+
+      // 42
+      [ModCallback.PRE_TEAR_COLLISION, this.preTearCollision],
+
+      // 67
+      [ModCallback.POST_ENTITY_REMOVE, this.postEntityRemove],
+    ];
+  }
 }

package/src/classes/callbacks/PostTearRenderFilter.ts

@@ -4,6 +4,16 @@ import { shouldFireTear } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostTearRenderFilter extends CustomCallback<ModCallbackCustom.POST_TEAR_RENDER_FILTER> {
+  // ModCallback.POST_TEAR_RENDER (41)
+  private readonly postTearRender = (
+    tear: EntityTear,
+    renderOffset: Vector,
+  ) => {
+    this.fire(tear, renderOffset);
+  };
+
+  protected override shouldFire = shouldFireTear;
+
   constructor() {
     super();
 
@@ -12,14 +22,4 @@ export class PostTearRenderFilter extends CustomCallback<ModCallbackCustom.POST_
       [ModCallback.POST_TEAR_RENDER, this.postTearRender],
     ];
   }
-
-  protected override shouldFire = shouldFireTear;
-
-  // ModCallback.POST_TEAR_RENDER (41)
-  private readonly postTearRender = (
-    tear: EntityTear,
-    renderOffset: Vector,
-  ) => {
-    this.fire(tear, renderOffset);
-  };
 }

package/src/classes/callbacks/PostTearUpdateFilter.ts

@@ -4,6 +4,13 @@ import { shouldFireTear } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PostTearUpdateFilter extends CustomCallback<ModCallbackCustom.POST_TEAR_UPDATE_FILTER> {
+  // ModCallback.POST_TEAR_UPDATE (40)
+  private readonly postTearUpdate = (tear: EntityTear) => {
+    this.fire(tear);
+  };
+
+  protected override shouldFire = shouldFireTear;
+
   constructor() {
     super();
 
@@ -12,11 +19,4 @@ export class PostTearUpdateFilter extends CustomCallback<ModCallbackCustom.POST_
       [ModCallback.POST_TEAR_UPDATE, this.postTearUpdate],
     ];
   }
-
-  protected override shouldFire = shouldFireTear;
-
-  // ModCallback.POST_TEAR_UPDATE (40)
-  private readonly postTearUpdate = (tear: EntityTear) => {
-    this.fire(tear);
-  };
 }

package/src/classes/callbacks/PostTransformation.ts

@@ -20,31 +20,6 @@ const v = {
 };
 
 export class PostTransformation extends CustomCallback<T> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.customCallbacksUsed = [
-      [
-        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-        this.postPEffectUpdateReordered,
-      ],
-    ];
-  }
-
-  protected override shouldFire = (
-    fireArgs: FireArgs<T>,
-    optionalArgs: OptionalArgs<T>,
-  ): boolean => {
-    const [_player, playerForm] = fireArgs;
-    const [callbackPlayerForm] = optionalArgs;
-
-    return (
-      callbackPlayerForm === undefined || callbackPlayerForm === playerForm
-    );
-  };
-
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private readonly postPEffectUpdateReordered = (player: EntityPlayer) => {
     const playerTransformationsMap = defaultMapGetPlayer(
@@ -63,4 +38,29 @@ export class PostTransformation extends CustomCallback<T> {
       }
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = (
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean => {
+    const [_player, playerForm] = fireArgs;
+    const [callbackPlayerForm] = optionalArgs;
+
+    return (
+      callbackPlayerForm === undefined || callbackPlayerForm === playerForm
+    );
+  };
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        this.postPEffectUpdateReordered,
+      ],
+    ];
+  }
 }

package/src/classes/callbacks/PostTrinketBreak.ts

@@ -26,22 +26,6 @@ const v = {
 };
 
 export class PostTrinketBreak extends CustomCallback<ModCallbackCustom.POST_TRINKET_BREAK> {
-  public override v = v;
-
-  constructor() {
-    super();
-
-    this.customCallbacksUsed = [
-      [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
-      [
-        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-        this.postPEffectUpdateReordered,
-      ],
-    ];
-  }
-
-  protected override shouldFire = shouldFireTrinketType;
-
   // ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER
   private readonly entityTakeDmgPlayer = (
     player: EntityPlayer,
@@ -94,4 +78,20 @@ export class PostTrinketBreak extends CustomCallback<ModCallbackCustom.POST_TRIN
       }
     }
   };
+
+  public override v = v;
+
+  protected override shouldFire = shouldFireTrinketType;
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [ModCallbackCustom.ENTITY_TAKE_DMG_PLAYER, this.entityTakeDmgPlayer],
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        this.postPEffectUpdateReordered,
+      ],
+    ];
+  }
 }

package/src/classes/callbacks/PostUsePillFilter.ts

@@ -34,6 +34,21 @@ const v = {
  * `ItemPool.GetPillEffect` method.
  */
 export class PostUsePillFilter extends CustomCallback<ModCallbackCustom.POST_USE_PILL_FILTER> {
+  // ModCallback.POST_USE_PILL (10)
+  private readonly postUsePill = (
+    pillEffect: PillEffect,
+    player: EntityPlayer,
+    useFlags: BitFlags<UseFlag>,
+  ) => {
+    const pillColor = this.getPillColorOfCurrentlyUsedPill(player, pillEffect);
+    this.fire(pillEffect, pillColor, player, useFlags);
+  };
+
+  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
+  private readonly postPEffectUpdateReordered = (player: EntityPlayer) => {
+    this.updateCurrentPocketItems(player);
+  };
+
   public override v = v;
 
   constructor() {
@@ -52,16 +67,6 @@ export class PostUsePillFilter extends CustomCallback<ModCallbackCustom.POST_USE
     ];
   }
 
-  // ModCallback.POST_USE_PILL (10)
-  private readonly postUsePill = (
-    pillEffect: PillEffect,
-    player: EntityPlayer,
-    useFlags: BitFlags<UseFlag>,
-  ) => {
-    const pillColor = this.getPillColorOfCurrentlyUsedPill(player, pillEffect);
-    this.fire(pillEffect, pillColor, player, useFlags);
-  };
-
   private getPillColorOfCurrentlyUsedPill(
     player: EntityPlayer,
     pillEffect: PillEffect,
@@ -91,11 +96,6 @@ export class PostUsePillFilter extends CustomCallback<ModCallbackCustom.POST_USE
     return getPillColorFromEffect(pillEffect);
   }
 
-  // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-  private readonly postPEffectUpdateReordered = (player: EntityPlayer) => {
-    this.updateCurrentPocketItems(player);
-  };
-
   private updateCurrentPocketItems(player: EntityPlayer) {
     const pocketItems = getPocketItems(player);
     mapSetPlayer(v.run.playerPocketItems, player, pocketItems);

package/src/classes/callbacks/PreBerserkDeath.ts

@@ -7,19 +7,6 @@ import { shouldFirePlayer } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PreBerserkDeath extends CustomCallback<ModCallbackCustom.PRE_BERSERK_DEATH> {
-  constructor() {
-    super();
-
-    this.customCallbacksUsed = [
-      [
-        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-        this.postPEffectUpdateReordered,
-      ],
-    ];
-  }
-
-  protected override shouldFire = shouldFirePlayer;
-
   // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
   private readonly postPEffectUpdateReordered = (
     player: EntityPlayer,
@@ -36,12 +23,25 @@ export class PreBerserkDeath extends CustomCallback<ModCallbackCustom.PRE_BERSER
 
     // If the Berserk effect will end on the next frame and we have no hearts left.
     if (
-      berserkEffect !== undefined
+      numHitsRemaining === 0
+      && berserkEffect !== undefined
       && berserkEffect.Cooldown === 1
-      && numHitsRemaining === 0
       && !willPlayerRevive(player)
     ) {
       this.fire(player);
     }
   };
+
+  protected override shouldFire = shouldFirePlayer;
+
+  constructor() {
+    super();
+
+    this.customCallbacksUsed = [
+      [
+        ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
+        this.postPEffectUpdateReordered,
+      ],
+    ];
+  }
 }

package/src/classes/callbacks/PreBombCollisionFilter.ts

@@ -4,6 +4,15 @@ import { shouldFireBomb } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PreBombCollisionFilter extends CustomCallback<ModCallbackCustom.PRE_BOMB_COLLISION_FILTER> {
+  // ModCallback.PRE_BOMB_COLLISION (60)
+  private readonly preBombCollision = (
+    bomb: EntityBomb,
+    collider: Entity,
+    low: boolean,
+  ): boolean | undefined => this.fire(bomb, collider, low);
+
+  protected override shouldFire = shouldFireBomb;
+
   constructor() {
     super();
 
@@ -12,13 +21,4 @@ export class PreBombCollisionFilter extends CustomCallback<ModCallbackCustom.PRE
       [ModCallback.PRE_BOMB_COLLISION, this.preBombCollision],
     ];
   }
-
-  protected override shouldFire = shouldFireBomb;
-
-  // ModCallback.PRE_BOMB_COLLISION (60)
-  private readonly preBombCollision = (
-    bomb: EntityBomb,
-    collider: Entity,
-    low: boolean,
-  ): boolean | undefined => this.fire(bomb, collider, low);
 }

package/src/classes/callbacks/PreCustomRevive.ts

@@ -4,11 +4,10 @@ import { shouldFirePlayer } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PreCustomRevive extends CustomCallback<ModCallbackCustom.PRE_CUSTOM_REVIVE> {
+  protected override shouldFire = shouldFirePlayer;
   constructor() {
     super();
 
     this.featuresUsed = [ISCFeature.CUSTOM_REVIVE];
   }
-
-  protected override shouldFire = shouldFirePlayer;
 }

package/src/classes/callbacks/PreEntitySpawnFilter.ts

@@ -7,29 +7,6 @@ import { CustomCallback } from "../private/CustomCallback";
 type T = ModCallbackCustom.PRE_ENTITY_SPAWN_FILTER;
 
 export class PreEntitySpawnFilter extends CustomCallback<T> {
-  constructor() {
-    super();
-
-    this.callbacksUsed = [
-      // 24
-      [ModCallback.PRE_ENTITY_SPAWN, this.preEntitySpawn],
-    ];
-  }
-
-  protected override shouldFire = (
-    fireArgs: FireArgs<T>,
-    optionalArgs: OptionalArgs<T>,
-  ): boolean => {
-    const [entityType, variant, subType] = fireArgs;
-    const [callbackEntityType, callbackVariant, callbackSubType] = optionalArgs;
-
-    return (
-      (callbackEntityType === undefined || callbackEntityType === entityType)
-      && (callbackVariant === undefined || callbackVariant === variant)
-      && (callbackSubType === undefined || callbackSubType === subType)
-    );
-  };
-
   // ModCallback.PRE_ENTITY_SPAWN (24)
   private readonly preEntitySpawn = (
     entityType: EntityType,
@@ -49,4 +26,27 @@ export class PreEntitySpawnFilter extends CustomCallback<T> {
       spawner,
       initSeed,
     );
+
+  protected override shouldFire = (
+    fireArgs: FireArgs<T>,
+    optionalArgs: OptionalArgs<T>,
+  ): boolean => {
+    const [entityType, variant, subType] = fireArgs;
+    const [callbackEntityType, callbackVariant, callbackSubType] = optionalArgs;
+
+    return (
+      (callbackEntityType === undefined || callbackEntityType === entityType)
+      && (callbackVariant === undefined || callbackVariant === variant)
+      && (callbackSubType === undefined || callbackSubType === subType)
+    );
+  };
+
+  constructor() {
+    super();
+
+    this.callbacksUsed = [
+      // 24
+      [ModCallback.PRE_ENTITY_SPAWN, this.preEntitySpawn],
+    ];
+  }
 }

package/src/classes/callbacks/PreFamiliarCollisionFilter.ts

@@ -4,6 +4,15 @@ import { shouldFireFamiliar } from "../../shouldFire";
 import { CustomCallback } from "../private/CustomCallback";
 
 export class PreFamiliarCollisionFilter extends CustomCallback<ModCallbackCustom.PRE_FAMILIAR_COLLISION_FILTER> {
+  // ModCallback.PRE_FAMILIAR_COLLISION (26)
+  private readonly preFamiliarCollision = (
+    familiar: EntityFamiliar,
+    collider: Entity,
+    low: boolean,
+  ): boolean | undefined => this.fire(familiar, collider, low);
+
+  protected override shouldFire = shouldFireFamiliar;
+
   constructor() {
     super();
 
@@ -12,13 +21,4 @@ export class PreFamiliarCollisionFilter extends CustomCallback<ModCallbackCustom
       [ModCallback.PRE_FAMILIAR_COLLISION, this.preFamiliarCollision],
     ];
   }
-
-  protected override shouldFire = shouldFireFamiliar;
-
-  // ModCallback.PRE_FAMILIAR_COLLISION (26)
-  private readonly preFamiliarCollision = (
-    familiar: EntityFamiliar,
-    collider: Entity,
-    low: boolean,
-  ): boolean | undefined => this.fire(familiar, collider, low);
 }