isaacscript-common 4.0.1-dev.0 → 4.0.2

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/postCursedTeleport.ts

@@ -60,13 +60,15 @@ function entityTakeDmgPlayer(
   damageFlags: BitFlags<DamageFlag>,
   _damageSource: EntityRef,
   _damageCountdownFrames: int,
-) {
+): boolean | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   incrementNumSacrifices(damageFlags); // Has to be before setting the damage frame
   setDamageFrame(tookDamage, damageFlags);
+
+  return undefined;
 }
 
 function setDamageFrame(tookDamage: Entity, damageFlags: BitFlags<DamageFlag>) {

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/postEsauJr.ts

@@ -85,7 +85,7 @@ function getPlayerWithControllerIndex(controllerIndex: ControllerIndex) {
   return players.find((player) => player.ControllerIndex === controllerIndex);
 }
 
-// ModCallback.USE_ITEM (3)
+// ModCallback.POST_USE_ITEM (3)
 // CollectibleType.ESAU_JR (703)
 function useItemEsauJr(
   _collectibleType: CollectibleType,
@@ -94,9 +94,9 @@ function useItemEsauJr(
   _useFlags: BitFlags<UseFlag>,
   _activeSlot: int,
   _customVarData: int,
-) {
+): boolean | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   const gameFrameCount = game.GetFrameCount();
@@ -104,4 +104,6 @@ function useItemEsauJr(
   // The player only changes to Esau Jr. on the frame after the item is used.
   v.run.usedEsauJrFrame = gameFrameCount + 1;
   v.run.usedEsauJrControllerIndex = player.ControllerIndex;
+
+  return undefined;
 }

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/postFlip.ts

@@ -36,7 +36,7 @@ function hasSubscriptions() {
   return postFlipHasSubscriptions() || postFirstFlipHasSubscriptions();
 }
 
-// ModCallback.USE_ITEM (3)
+// ModCallback.POST_USE_ITEM (3)
 // CollectibleType.FLIP (711)
 function useItemFlip(
   _collectibleType: CollectibleType,
@@ -45,20 +45,20 @@ function useItemFlip(
   _useFlags: BitFlags<UseFlag>,
   _activeSlot: int,
   _customVarData: int,
-) {
+): boolean | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   if (!isTaintedLazarus(player)) {
-    return;
+    return undefined;
   }
 
   // The player passed as part of the callback will be the old Lazarus that used the Flip item. We
   // pass the new Lazarus to the callback subscribers.
   const newLazarus = getNewLazarus(player);
   if (newLazarus === undefined) {
-    return;
+    return undefined;
   }
 
   if (!v.run.usedFlipAtLeastOnce) {
@@ -67,6 +67,8 @@ function useItemFlip(
   }
 
   postFlipFire(newLazarus);
+
+  return undefined;
 }
 
 function getNewLazarus(oldLazarus: EntityPlayer) {

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/postItemDischarged.ts

@@ -130,20 +130,25 @@ function playerRecentlyCollidedWithBulb(player: EntityPlayer) {
  * Instead, we track the frames that Bulbs collide with players and assume that a collision means a
  * zap has occurred.
  */
-function preNPCCollisionSucker(npc: EntityNPC, collider: Entity) {
+function preNPCCollisionSucker(
+  npc: EntityNPC,
+  collider: Entity,
+): boolean | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   if (npc.Variant !== (SuckerVariant.BULB as int)) {
-    return;
+    return undefined;
   }
 
   const player = collider.ToPlayer();
   if (player === undefined) {
-    return;
+    return undefined;
   }
 
   const gameFrameCount = game.GetFrameCount();
   mapSetPlayer(v.room.playersBulbLastCollisionFrame, player, gameFrameCount);
+
+  return undefined;
 }

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/postNewRoomEarly.ts

@@ -1,4 +1,8 @@
-import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
+import {
+  EntityType,
+  GridEntityType,
+  ModCallback,
+} from "isaac-typescript-definitions";
 import { game } from "../cachedClasses";
 import { getTopLeftWallGridIndex, spawnGrid } from "../functions/gridEntity";
 import { logError } from "../functions/log";
@@ -35,12 +39,14 @@ function postNewRoom() {
 }
 
 // ModCallback.PRE_ENTITY_SPAWN (24)
-function preEntitySpawn() {
+function preEntitySpawn(): [EntityType, int, int, int] | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   checkRoomChanged();
+
+  return undefined;
 }
 
 function checkRoomChanged() {

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/postSacrifice.ts

@@ -41,14 +41,14 @@ function entityTakeDmgPlayer(
   damageFlags: BitFlags<DamageFlag>,
   _damageSource: EntityRef,
   _damageCountdownFrames: int,
-) {
+): boolean | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   const player = tookDamage.ToPlayer();
   if (player === undefined) {
-    return;
+    return undefined;
   }
 
   const room = game.GetRoom();
@@ -59,4 +59,6 @@ function entityTakeDmgPlayer(
     v.level.numSacrifices += 1;
     postSacrificeFire(player, v.level.numSacrifices);
   }
+
+  return undefined;
 }

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/postTrinketBreak.ts

@@ -58,14 +58,14 @@ function entityTakeDmgPlayer(
   _damageFlags: BitFlags<DamageFlag>,
   _damageSource: EntityRef,
   _damageCountdownFrames: int,
-) {
+): boolean | undefined {
   if (!hasSubscriptions()) {
-    return;
+    return undefined;
   }
 
   const player = tookDamage.ToPlayer();
   if (player === undefined) {
-    return;
+    return undefined;
   }
 
   const trinketMap = defaultMapGetPlayer(v.run.playersTrinketMap, player);
@@ -92,6 +92,8 @@ function entityTakeDmgPlayer(
 
     postTrinketBreakFire(player, trinketType);
   }
+
+  return undefined;
 }
 
 // ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED

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/callbacks/reorderedCallbacks.ts

@@ -56,10 +56,12 @@ function hasSubscriptions() {
 
 // ModCallback.POST_USE_ITEM (3)
 // CollectibleType.GLOWING_HOUR_GLASS (422)
-function useItemGlowingHourGlass() {
+function useItemGlowingHourGlass(): boolean | undefined {
   // If Glowing Hour Glass is used on the first room of a floor, it will send the player to the
   // previous floor without triggering the PostNewLevel callback. Manually check for this.
   usedGlowingHourGlass = true;
+
+  return undefined;
 }
 
 // ModCallback.POST_GAME_STARTED (15)

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/classes/ModUpgraded.ts

@@ -49,8 +49,15 @@ export class ModUpgraded implements Mod {
     return this.Mod.LoadData();
   }
 
-  RemoveCallback(callbackID: ModCallback, callback: () => void): void {
-    this.Mod.RemoveCallback(callbackID, callback);
+  /**
+   * 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 {
+    this.Mod.RemoveCallback(modCallback, callback);
   }
 
   RemoveData(): void {

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/features/playerInventory.ts

@@ -68,8 +68,10 @@ function useItemD4(
   _collectibleType: CollectibleType,
   _rng: RNG,
   player: EntityPlayer,
-) {
+): boolean | undefined {
   resetInventory(player);
+
+  return undefined;
 }
 
 // ModCallback.POST_GAME_STARTED (15)

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/functions/player.ts

@@ -108,10 +108,6 @@ export function addStat(
       player.Luck += amount;
       break;
     }
-
-    default: {
-      break;
-    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "4.0.1-dev.0",
+  "version": "4.0.2",
   "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.5"
   }
 }