isaacscript-common 4.0.1-dev.0 → 4.0.4

package/callbacks/postCursedTeleport.lua

@@ -30,10 +30,11 @@ function hasSubscriptions(self)
 end
 function entityTakeDmgPlayer(self, tookDamage, _damageAmount, damageFlags, _damageSource, _damageCountdownFrames)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     incrementNumSacrifices(nil, damageFlags)
     setDamageFrame(nil, tookDamage, damageFlags)
+    return nil
 end
 function setDamageFrame(self, tookDamage, damageFlags)
     local gameFrameCount = game:GetFrameCount()

package/callbacks/postEsauJr.lua

@@ -52,11 +52,12 @@ function getPlayerWithControllerIndex(self, controllerIndex)
 end
 function useItemEsauJr(self, _collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     local gameFrameCount = game:GetFrameCount()
     v.run.usedEsauJrFrame = gameFrameCount + 1
     v.run.usedEsauJrControllerIndex = player.ControllerIndex
+    return nil
 end
 v = {run = {usedEsauJrFrame = nil, usedEsauJrControllerIndex = nil, usedEsauJrAtLeastOnce = false}}
 ---

package/callbacks/postFlip.lua

@@ -22,20 +22,21 @@ function hasSubscriptions(self)
 end
 function useItemFlip(self, _collectibleType, _rng, player, _useFlags, _activeSlot, _customVarData)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     if not isTaintedLazarus(nil, player) then
-        return
+        return nil
     end
     local newLazarus = getNewLazarus(nil, player)
     if newLazarus == nil then
-        return
+        return nil
     end
     if not v.run.usedFlipAtLeastOnce then
         v.run.usedFlipAtLeastOnce = true
         postFirstFlipFire(nil, newLazarus)
     end
     postFlipFire(nil, newLazarus)
+    return nil
 end
 function getNewLazarus(self, oldLazarus)
     local oldCharacter = oldLazarus:GetPlayerType()

package/callbacks/postItemDischarged.lua

@@ -65,17 +65,18 @@ function playerRecentlyCollidedWithBulb(self, player)
 end
 function preNPCCollisionSucker(self, npc, collider)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     if npc.Variant ~= SuckerVariant.BULB then
-        return
+        return nil
     end
     local player = collider:ToPlayer()
     if player == nil then
-        return
+        return nil
     end
     local gameFrameCount = game:GetFrameCount()
     mapSetPlayer(nil, v.room.playersBulbLastCollisionFrame, player, gameFrameCount)
+    return nil
 end
 v = {
     run = {

package/callbacks/postNewRoomEarly.lua

@@ -24,9 +24,10 @@ function postNewRoom(self)
 end
 function preEntitySpawn(self)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     checkRoomChanged(nil)
+    return nil
 end
 function checkRoomChanged(self)
     local room = game:GetRoom()

package/callbacks/postSacrifice.lua

@@ -19,11 +19,11 @@ function hasSubscriptions(self)
 end
 function entityTakeDmgPlayer(self, tookDamage, _damageAmount, damageFlags, _damageSource, _damageCountdownFrames)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     local player = tookDamage:ToPlayer()
     if player == nil then
-        return
+        return nil
     end
     local room = game:GetRoom()
     local roomType = room:GetType()
@@ -33,6 +33,7 @@ function entityTakeDmgPlayer(self, tookDamage, _damageAmount, damageFlags, _dama
         ____v_level_0[____numSacrifices_1] = ____v_level_0[____numSacrifices_1] + 1
         postSacrificeFire(nil, player, v.level.numSacrifices)
     end
+    return nil
 end
 v = {level = {numSacrifices = 0}}
 ---

package/callbacks/postTrinketBreak.lua

@@ -23,11 +23,11 @@ function hasSubscriptions(self)
 end
 function entityTakeDmgPlayer(self, tookDamage, _damageAmount, _damageFlags, _damageSource, _damageCountdownFrames)
     if not hasSubscriptions(nil) then
-        return
+        return nil
     end
     local player = tookDamage:ToPlayer()
     if player == nil then
-        return
+        return nil
     end
     local trinketMap = defaultMapGetPlayer(nil, v.run.playersTrinketMap, player)
     for ____, trinketType in ipairs(TRINKETS_THAT_CAN_BREAK) do
@@ -46,6 +46,7 @@ function entityTakeDmgPlayer(self, tookDamage, _damageAmount, _damageFlags, _dam
         end
         ::__continue8::
     end
+    return nil
 end
 function postPEffectUpdateReordered(self, player)
     if not hasSubscriptions(nil) then

package/callbacks/reorderedCallbacks.lua

@@ -19,6 +19,7 @@ function hasSubscriptions(self)
 end
 function useItemGlowingHourGlass(self)
     usedGlowingHourGlass = true
+    return nil
 end
 function postGameStartedVanilla(self, isContinued)
     if not hasSubscriptions(nil) then

package/classes/ModUpgraded.d.ts

@@ -16,7 +16,11 @@ export declare class ModUpgraded implements Mod {
     AddCallback<T extends ModCallback>(modCallback: T, ...args: AddCallbackParameter[T]): void;
     HasData(): boolean;
     LoadData(): string;
-    RemoveCallback(callbackID: ModCallback, callback: () => void): void;
+    /**
+     * This method does not care about the tertiary argument. Regardless of the conditions of how you
+     * registered the callback, it will be removed.
+     */
+    RemoveCallback<T extends ModCallback>(modCallback: T, callback: AddCallbackParameter[T][0]): void;
     RemoveData(): void;
     SaveData(data: string): void;
     AddCallbackCustom<T extends ModCallbackCustom>(modCallbackCustom: T, ...args: AddCallbackParameterCustom[T]): void;

package/classes/ModUpgraded.lua

@@ -24,8 +24,8 @@ end
 function ModUpgraded.prototype.LoadData(self)
     return self.Mod:LoadData()
 end
-function ModUpgraded.prototype.RemoveCallback(self, callbackID, callback)
-    self.Mod:RemoveCallback(callbackID, callback)
+function ModUpgraded.prototype.RemoveCallback(self, modCallback, callback)
+    self.Mod:RemoveCallback(modCallback, callback)
 end
 function ModUpgraded.prototype.RemoveData(self)
     self.Mod:RemoveData()

package/features/playerInventory.lua

@@ -51,6 +51,7 @@ function resetInventory(self, player)
 end
 function useItemD4(self, _collectibleType, _rng, player)
     resetInventory(nil, player)
+    return nil
 end
 function postGameStarted(self)
     for ____, player in ipairs(getAllPlayers(nil)) do

package/functions/player.lua

@@ -203,11 +203,6 @@ function ____exports.addStat(self, player, cacheFlag, amount)
                 break
             end
         end
-        do
-            do
-                break
-            end
-        end
     until true
 end
 function ____exports.addTrinketCostume(self, player, trinketType)
@@ -749,9 +744,9 @@ function ____exports.setActiveItem(self, player, collectibleType, activeSlot, ch
         itemPool:RemoveCollectible(collectibleType)
     end
     repeat
-        local ____switch124 = activeSlot
-        local ____cond124 = ____switch124 == ActiveSlot.PRIMARY
-        if ____cond124 then
+        local ____switch123 = activeSlot
+        local ____cond123 = ____switch123 == ActiveSlot.PRIMARY
+        if ____cond123 then
             do
                 if primaryCollectibleType ~= CollectibleType.NULL then
                     player:RemoveCollectible(primaryCollectibleType)
@@ -760,8 +755,8 @@ function ____exports.setActiveItem(self, player, collectibleType, activeSlot, ch
                 break
             end
         end
-        ____cond124 = ____cond124 or ____switch124 == ActiveSlot.SECONDARY
-        if ____cond124 then
+        ____cond123 = ____cond123 or ____switch123 == ActiveSlot.SECONDARY
+        if ____cond123 then
             do
                 if primaryCollectibleType ~= CollectibleType.NULL then
                     player:RemoveCollectible(primaryCollectibleType)
@@ -776,16 +771,16 @@ function ____exports.setActiveItem(self, player, collectibleType, activeSlot, ch
                 break
             end
         end
-        ____cond124 = ____cond124 or ____switch124 == ActiveSlot.POCKET
-        if ____cond124 then
+        ____cond123 = ____cond123 or ____switch123 == ActiveSlot.POCKET
+        if ____cond123 then
             do
                 player:SetPocketActiveItem(collectibleType, activeSlot, keepInPools)
                 player:SetActiveCharge(charge, activeSlot)
                 break
             end
         end
-        ____cond124 = ____cond124 or ____switch124 == ActiveSlot.POCKET_SINGLE_USE
-        if ____cond124 then
+        ____cond123 = ____cond123 or ____switch123 == ActiveSlot.POCKET_SINGLE_USE
+        if ____cond123 then
             do
                 player:SetPocketActiveItem(collectibleType, activeSlot, keepInPools)
                 break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "4.0.1-dev.0",
+  "version": "4.0.4",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",
@@ -22,6 +22,6 @@
   "main": "index",
   "types": "index.d.ts",
   "dependencies": {
-    "isaac-typescript-definitions": "^3.0.3"
+    "isaac-typescript-definitions": "^3.0.6"
   }
 }

package/cachedClasses.ts

@@ -1,39 +0,0 @@
-/**
- * A cached version of the class returned from the `Game()` constructor.
- *
- * Use this instead of invoking the constructor again for a miniscule performance increase.
- *
- * Caching the results of this constructor is safe, but caching other classes (like `Level` or
- * `Room`) is not safe and can lead to the game crashing in certain situations.
- */
-export const game = Game();
-
-/**
- * A cached version of the class returned from the `Isaac.GetItemConfig()` constructor.
- *
- * Use this instead of invoking the constructor again for a miniscule performance increase.
- *
- * Caching the results of this constructor is safe, but caching other classes (like `Level` or
- * `Room`) is not safe and can lead to the game crashing in certain situations.
- */
-export const itemConfig = Isaac.GetItemConfig();
-
-/**
- * A cached version of the class returned from the `MusicManager()` constructor.
- *
- * Use this instead of invoking the constructor again for a miniscule performance increase.
- *
- * Caching the results of this constructor is safe, but caching other classes (like `Level` or
- * `Room`) is not safe and can lead to the game crashing in certain situations.
- */
-export const musicManager = MusicManager();
-
-/**
- * A cached version of the class returned from the `SFXManager()` constructor.
- *
- * Use this instead of invoking the constructor again for a miniscule performance increase.
- *
- * Caching the results of this constructor is safe, but caching other classes (like `Level` or
- * `Room`) is not safe and can lead to the game crashing in certain situations.
- */
-export const sfxManager = SFXManager();

package/callbacks/customRevive.ts

@@ -1,215 +0,0 @@
-// This provides the logic for:
-// - PRE_CUSTOM_REVIVE
-// - POST_CUSTOM_REVIVE
-
-import {
-  CollectibleType,
-  FamiliarVariant,
-  ModCallback,
-  PlayerType,
-  SoundEffect,
-} from "isaac-typescript-definitions";
-import { sfxManager } from "../cachedClasses";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { runNextGameFrame } from "../features/runInNFrames";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { removeCollectibleFromItemTracker } from "../functions/collectibles";
-import { removeAllFamiliars } from "../functions/entitySpecific";
-import { log, logError } from "../functions/log";
-import { isCharacter } from "../functions/player";
-import { getPlayerFromIndex, getPlayerIndex } from "../functions/playerIndex";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postCustomReviveFire,
-  postCustomReviveHasSubscriptions,
-} from "./subscriptions/postCustomRevive";
-import {
-  preCustomReviveFire,
-  preCustomReviveHasSubscriptions,
-} from "./subscriptions/preCustomRevive";
-
-const DEBUG = false;
-
-enum CustomReviveState {
-  DISABLED,
-
-  /**
-   * We can't immediately jump to waiting for an item animation because it is possible for a player
-   * to be holding an item above their head as they are dying (e.g. with Razor Blade).
-   */
-  WAITING_FOR_ROOM_TRANSITION,
-
-  WAITING_FOR_ITEM_ANIMATION,
-}
-
-const v = {
-  run: {
-    state: CustomReviveState.DISABLED,
-    revivalType: null as int | null,
-    dyingPlayerIndex: null as PlayerIndex | null,
-  },
-};
-
-/** @internal */
-export function customReviveCallbacksInit(mod: ModUpgraded): void {
-  saveDataManager("customRevive", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_NEW_ROOM_REORDERED,
-    postNewRoomReordered,
-  );
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE,
-    postPlayerFatalDamage,
-  );
-  mod.AddCallbackCustom(ModCallbackCustom.PRE_BERSERK_DEATH, preBerserkDeath);
-}
-
-function hasSubscriptions() {
-  return (
-    preCustomReviveHasSubscriptions() || postCustomReviveHasSubscriptions()
-  );
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
-    return;
-  }
-
-  // The 1-up sound will fire before the item holding animation begins, so we mute it on every
-  // render frame.
-  sfxManager.Stop(SoundEffect.ONE_UP);
-}
-
-// ModCallbackCustom.POST_NEW_ROOM_REORDERED
-function postNewRoomReordered() {
-  if (v.run.state !== CustomReviveState.WAITING_FOR_ROOM_TRANSITION) {
-    return;
-  }
-
-  v.run.state = CustomReviveState.WAITING_FOR_ITEM_ANIMATION;
-  logStateChanged();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  checkWaitingForItemAnimation(player);
-}
-
-function checkWaitingForItemAnimation(player: EntityPlayer) {
-  if (v.run.state !== CustomReviveState.WAITING_FOR_ITEM_ANIMATION) {
-    return;
-  }
-
-  if (v.run.dyingPlayerIndex === null) {
-    return;
-  }
-
-  const playerIndex = getPlayerIndex(player);
-  if (playerIndex !== v.run.dyingPlayerIndex) {
-    return;
-  }
-
-  let playerToCheckHoldingItem = player;
-  if (isCharacter(player, PlayerType.THE_SOUL_B)) {
-    const forgottenBody = player.GetOtherTwin();
-    if (forgottenBody !== undefined) {
-      playerToCheckHoldingItem = forgottenBody;
-    }
-  }
-
-  if (!playerToCheckHoldingItem.IsHoldingItem()) {
-    return;
-  }
-
-  // The player is now playing the animation where they hold the 1-Up item overhead. The
-  // `EntityPlayer.StopExtraAnimation` method will not work to stop this animation. End-users are
-  // expected to play a new animation in the PostCustomRevive callback, which will overwrite the
-  // 1-Up animation.
-
-  if (v.run.revivalType !== null) {
-    postCustomReviveFire(playerToCheckHoldingItem, v.run.revivalType);
-  }
-
-  v.run.state = CustomReviveState.DISABLED;
-  v.run.revivalType = null;
-  v.run.dyingPlayerIndex = null;
-  logStateChanged();
-}
-
-// ModCallbackCustom.POST_PLAYER_FATAL_DAMAGE
-function postPlayerFatalDamage(player: EntityPlayer): boolean | undefined {
-  if (!hasSubscriptions()) {
-    return undefined;
-  }
-
-  playerIsAboutToDie(player);
-  return undefined;
-}
-
-// ModCallbackCustom.PRE_BERSERK_DEATH
-function preBerserkDeath(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  playerIsAboutToDie(player);
-}
-
-/**
- * The player is about to die, which will immediately delete the save data for the run. To prevent
- * this from happening, we grant the 1-Up item.
- */
-function playerIsAboutToDie(player: EntityPlayer) {
-  const revivalType = preCustomReviveFire(player);
-  if (revivalType === undefined) {
-    return;
-  }
-
-  v.run.state = CustomReviveState.WAITING_FOR_ROOM_TRANSITION;
-  v.run.revivalType = revivalType;
-  v.run.dyingPlayerIndex = getPlayerIndex(player);
-  logStateChanged();
-
-  player.AddCollectible(CollectibleType.ONE_UP, 0, false);
-  removeAllFamiliars(FamiliarVariant.ONE_UP);
-  removeCollectibleFromItemTracker(CollectibleType.ONE_UP);
-
-  // The player should always be dead one frame from now. If they are not, then something has gone
-  // wrong, probably with the `isDamageToPlayerFatal` function. Since end-user code is already
-  // assuming that a custom revive is occurring, explicitly kill the player.
-  const playerIndex = getPlayerIndex(player);
-  runNextGameFrame(() => {
-    const futurePlayer = getPlayerFromIndex(playerIndex);
-    if (futurePlayer === undefined) {
-      return;
-    }
-
-    if (futurePlayer.IsDead()) {
-      return;
-    }
-
-    logError(
-      "The player is still alive after initializing a custom revive. Explicitly killing the player.",
-    );
-    futurePlayer.Kill();
-  });
-}
-
-function logStateChanged() {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (DEBUG) {
-    log(
-      `Custom revive state changed: ${CustomReviveState[v.run.state]} (${
-        v.run.state
-      })`,
-    );
-  }
-}

package/callbacks/itemPickup.ts

@@ -1,101 +0,0 @@
-// This provides the logic for:
-// - PRE_ITEM_PICKUP
-// - POST_ITEM_PICKUP
-
-import {
-  CollectibleType,
-  ItemType,
-  TrinketType,
-} from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { defaultMapGetPlayer } from "../functions/playerDataStructures";
-import {
-  newPickingUpItem,
-  PickingUpItem,
-  resetPickingUpItem,
-} from "../types/PickingUpItem";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postItemPickupFire,
-  postItemPickupHasSubscriptions,
-} from "./subscriptions/postItemPickup";
-import {
-  preItemPickupFire,
-  preItemPickupHasSubscriptions,
-} from "./subscriptions/preItemPickup";
-
-const v = {
-  run: {
-    playersPickingUpItemMap: new DefaultMap<PlayerIndex, PickingUpItem>(() =>
-      newPickingUpItem(),
-    ),
-  },
-};
-
-/** @internal */
-export function itemPickupCallbacksInit(mod: ModUpgraded): void {
-  saveDataManager("itemPickup", v, hasSubscriptions);
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return preItemPickupHasSubscriptions() || postItemPickupHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const pickingUpItem = defaultMapGetPlayer(
-    v.run.playersPickingUpItemMap,
-    player,
-  );
-
-  if (player.IsItemQueueEmpty()) {
-    queueEmpty(player, pickingUpItem);
-    // If a player enters a room with a trinket next to the entrance, the player will pick up the
-    // trinket, but it will not become queued (it will be deposited into their inventory
-    // immediately). Since we don't know what type of item the player is holding, don't account for
-    // this bug.
-  } else {
-    queueNotEmpty(player, pickingUpItem);
-  }
-}
-
-function queueEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
-  // eslint-disable-next-line isaacscript/strict-enums
-  if (pickingUpItem.itemType === ItemType.NULL || pickingUpItem.subType === 0) {
-    return;
-  }
-
-  postItemPickupFire(player, pickingUpItem);
-  resetPickingUpItem(pickingUpItem);
-}
-
-function queueNotEmpty(player: EntityPlayer, pickingUpItem: PickingUpItem) {
-  const queuedItem = player.QueuedItem.Item;
-  if (queuedItem === undefined || queuedItem.Type === ItemType.NULL) {
-    // This should never happen, since the `EntityPlayer.IsItemQueueEmpty` method returned true.
-    return;
-  }
-
-  if (
-    queuedItem.Type !== pickingUpItem.itemType ||
-    queuedItem.ID !== pickingUpItem.subType
-  ) {
-    // Record which item we are picking up.
-    pickingUpItem.itemType = queuedItem.Type;
-    pickingUpItem.subType = queuedItem.ID as CollectibleType | TrinketType;
-
-    preItemPickupFire(player, pickingUpItem);
-  }
-}

package/callbacks/postAmbush.ts

@@ -1,73 +0,0 @@
-// This provides the logic for:
-// - POST_AMBUSH_STARTED
-// - POST_AMBUSH_FINISHED
-
-import { ModCallback, RoomType } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { AmbushType } from "../enums/AmbushType";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getRoomType } from "../functions/roomData";
-import {
-  postAmbushFinishedFire,
-  postAmbushFinishedHasSubscriptions,
-} from "./subscriptions/postAmbushFinished";
-import {
-  postAmbushStartedFire,
-  postAmbushStartedHasSubscriptions,
-} from "./subscriptions/postAmbushStarted";
-
-const v = {
-  room: {
-    ambushActive: false,
-    ambushDone: false,
-  },
-};
-
-/** @internal */
-export function postAmbushCallbacksInit(mod: Mod): void {
-  saveDataManager("postAmbushCallbacks", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-}
-
-function hasSubscriptions() {
-  return (
-    postAmbushStartedHasSubscriptions() || postAmbushFinishedHasSubscriptions()
-  );
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const room = game.GetRoom();
-
-  if (!v.room.ambushActive) {
-    const ambushActive = room.IsAmbushActive();
-    if (ambushActive) {
-      v.room.ambushActive = true;
-
-      const ambushType = getAmbushType();
-      postAmbushStartedFire(ambushType);
-    }
-  }
-
-  if (!v.room.ambushDone) {
-    const ambushDone = room.IsAmbushDone();
-    if (ambushDone) {
-      v.room.ambushDone = true;
-
-      const ambushType = getAmbushType();
-      postAmbushFinishedFire(ambushType);
-    }
-  }
-}
-
-function getAmbushType(): AmbushType {
-  const roomType = getRoomType();
-  return roomType === RoomType.BOSS_RUSH
-    ? AmbushType.BOSS_RUSH
-    : AmbushType.CHALLENGE_ROOM;
-}