isaacscript-common 9.1.0 → 9.2.1

package/dist/callbacks/postPlayerCollectible.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postPlayerCollectible.d.ts","sourceRoot":"","sources":["../../src/callbacks/postPlayerCollectible.ts"],"names":[],"mappings":";AA4CA,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAIjE"}
+{"version":3,"file":"postPlayerCollectible.d.ts","sourceRoot":"","sources":["../../src/callbacks/postPlayerCollectible.ts"],"names":[],"mappings":";AAgDA,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAUjE"}

package/dist/callbacks/postPlayerCollectible.lua

@@ -1,6 +1,6 @@
 local ____lualib = require("lualib_bundle")
-local Map = ____lualib.Map
 local __TS__New = ____lualib.__TS__New
+local Map = ____lualib.Map
 local Set = ____lualib.Set
 local __TS__Spread = ____lualib.__TS__Spread
 local __TS__SparseArrayNew = ____lualib.__TS__SparseArrayNew
@@ -9,22 +9,28 @@ local __TS__SparseArraySpread = ____lualib.__TS__SparseArraySpread
 local __TS__Iterator = ____lualib.__TS__Iterator
 local __TS__ArraySort = ____lualib.__TS__ArraySort
 local ____exports = {}
-local hasSubscriptions, postPEffectUpdate, collectibleCountChanged, checkActiveItemsChanged, activeItemsChanged, v
+local hasSubscriptions, updateCollectibleMapAndFire, useItemD4, postPEffectUpdate, checkActiveItemsChanged, entityTakeDmgPlayer, v
 local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
 local ActiveSlot = ____isaac_2Dtypescript_2Ddefinitions.ActiveSlot
 local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local DamageFlag = ____isaac_2Dtypescript_2Ddefinitions.DamageFlag
+local EntityType = ____isaac_2Dtypescript_2Ddefinitions.EntityType
 local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local PlayerType = ____isaac_2Dtypescript_2Ddefinitions.PlayerType
 local ____DefaultMap = require("classes.DefaultMap")
 local DefaultMap = ____DefaultMap.DefaultMap
+local ____runInNFrames = require("features.runInNFrames")
+local runNextGameFrame = ____runInNFrames.runNextGameFrame
 local ____exports = require("features.saveDataManager.exports")
 local saveDataManager = ____exports.saveDataManager
 local ____array = require("functions.array")
 local arrayEquals = ____array.arrayEquals
 local ____enums = require("functions.enums")
 local getEnumValues = ____enums.getEnumValues
+local ____flag = require("functions.flag")
+local hasFlag = ____flag.hasFlag
 local ____playerDataStructures = require("functions.playerDataStructures")
 local defaultMapGetPlayer = ____playerDataStructures.defaultMapGetPlayer
-local mapGetPlayer = ____playerDataStructures.mapGetPlayer
 local mapSetPlayer = ____playerDataStructures.mapSetPlayer
 local ____players = require("functions.players")
 local getPlayerCollectibleMap = ____players.getPlayerCollectibleMap
@@ -39,26 +45,7 @@ local postPlayerCollectibleRemovedHasSubscriptions = ____postPlayerCollectibleRe
 function hasSubscriptions(self)
     return postPlayerCollectibleAddedHasSubscriptions(nil) or postPlayerCollectibleRemovedHasSubscriptions(nil)
 end
-function postPEffectUpdate(self, player)
-    if not hasSubscriptions(nil) then
-        return
-    end
-    local oldCollectibleCount = mapGetPlayer(nil, v.run.playersCollectibleCount, player)
-    local newCollectibleCount = player:GetCollectibleCount()
-    mapSetPlayer(nil, v.run.playersCollectibleCount, player, newCollectibleCount)
-    if oldCollectibleCount == nil then
-        return
-    end
-    local difference = newCollectibleCount - oldCollectibleCount
-    if difference > 0 then
-        collectibleCountChanged(nil, player, difference)
-    elseif difference < 0 then
-        collectibleCountChanged(nil, player, difference * -1)
-    elseif difference == 0 then
-        checkActiveItemsChanged(nil, player)
-    end
-end
-function collectibleCountChanged(self, player, numCollectiblesChanged)
+function updateCollectibleMapAndFire(self, player, numCollectiblesChanged)
     local oldCollectibleMap = defaultMapGetPlayer(nil, v.run.playersCollectibleMap, player)
     local newCollectibleMap = getPlayerCollectibleMap(nil, player)
     mapSetPlayer(nil, v.run.playersCollectibleMap, player, newCollectibleMap)
@@ -68,12 +55,12 @@ function collectibleCountChanged(self, player, numCollectiblesChanged)
         ____array_0,
         __TS__Spread(newCollectibleMap:keys())
     )
-    local collectibleTypeSet = __TS__New(
+    local collectibleTypesSet = __TS__New(
         ____Set_1,
         {__TS__SparseArraySpread(____array_0)}
     )
     local numFired = 0
-    for ____, collectibleType in __TS__Iterator(collectibleTypeSet:values()) do
+    for ____, collectibleType in __TS__Iterator(collectibleTypesSet:values()) do
         local oldNum = oldCollectibleMap:get(collectibleType) or 0
         local newNum = newCollectibleMap:get(collectibleType) or 0
         local difference = newNum - oldNum
@@ -96,6 +83,26 @@ function collectibleCountChanged(self, player, numCollectiblesChanged)
         end
     end
 end
+function useItemD4(self, _collectibleType, _rng, player)
+    updateCollectibleMapAndFire(nil, player, nil)
+    return nil
+end
+function postPEffectUpdate(self, player)
+    if not hasSubscriptions(nil) then
+        return
+    end
+    local oldCollectibleCount = defaultMapGetPlayer(nil, v.run.playersCollectibleCount, player)
+    local newCollectibleCount = player:GetCollectibleCount()
+    mapSetPlayer(nil, v.run.playersCollectibleCount, player, newCollectibleCount)
+    local difference = newCollectibleCount - oldCollectibleCount
+    if difference > 0 then
+        updateCollectibleMapAndFire(nil, player, difference)
+    elseif difference < 0 then
+        updateCollectibleMapAndFire(nil, player, difference * -1)
+    elseif difference == 0 then
+        checkActiveItemsChanged(nil, player)
+    end
+end
 function checkActiveItemsChanged(self, player)
     local activeItemMap = defaultMapGetPlayer(nil, v.run.playersActiveItemMap, player)
     local oldCollectibleTypes = {}
@@ -110,44 +117,40 @@ function checkActiveItemsChanged(self, player)
     __TS__ArraySort(oldCollectibleTypes)
     __TS__ArraySort(newCollectibleTypes)
     if not arrayEquals(nil, oldCollectibleTypes, newCollectibleTypes) then
-        local ____Set_3 = Set
-        local ____array_2 = __TS__SparseArrayNew(table.unpack(oldCollectibleTypes))
-        __TS__SparseArrayPush(
-            ____array_2,
-            table.unpack(newCollectibleTypes)
-        )
-        local collectibleTypeSet = __TS__New(
-            ____Set_3,
-            {__TS__SparseArraySpread(____array_2)}
-        )
-        activeItemsChanged(nil, player, collectibleTypeSet)
+        updateCollectibleMapAndFire(nil, player, nil)
     end
 end
-function activeItemsChanged(self, player, collectibleTypesSet)
-    local oldCollectibleMap = defaultMapGetPlayer(nil, v.run.playersCollectibleMap, player)
-    local newCollectibleMap = getPlayerCollectibleMap(nil, player)
-    mapSetPlayer(nil, v.run.playersCollectibleMap, player, newCollectibleMap)
-    for ____, collectibleType in __TS__Iterator(collectibleTypesSet:values()) do
-        local oldNum = oldCollectibleMap:get(collectibleType) or 0
-        local newNum = newCollectibleMap:get(collectibleType) or 0
-        local difference = newNum - oldNum
-        local increased = difference > 0
-        local absoluteDifference = math.abs(difference)
-        ____repeat(
-            nil,
-            absoluteDifference,
-            function()
-                if increased then
-                    postPlayerCollectibleAddedFire(nil, player, collectibleType)
-                else
-                    postPlayerCollectibleRemovedFire(nil, player, collectibleType)
-                end
-            end
-        )
+function entityTakeDmgPlayer(self, entity, _amount, damageFlags, _source, _countdownFrames)
+    if hasFlag(nil, damageFlags, DamageFlag.FAKE) then
+        return nil
+    end
+    local player = entity:ToPlayer()
+    if player == nil then
+        return nil
     end
+    local character = player:GetPlayerType()
+    if character ~= PlayerType.EDEN_B then
+        return nil
+    end
+    local ptr = EntityPtr(player)
+    runNextGameFrame(
+        nil,
+        function()
+            local futureEntity = ptr.Ref
+            if futureEntity == nil then
+                return
+            end
+            local futurePlayer = futureEntity:ToPlayer()
+            if futurePlayer == nil then
+                return
+            end
+            updateCollectibleMapAndFire(nil, player, nil)
+        end
+    )
+    return nil
 end
 v = {run = {
-    playersCollectibleCount = __TS__New(Map),
+    playersCollectibleCount = __TS__New(DefaultMap, 0),
     playersCollectibleMap = __TS__New(
         DefaultMap,
         function() return __TS__New(Map) end
@@ -159,6 +162,8 @@ v = {run = {
 }}
 function ____exports.postPlayerCollectibleCallbacksInit(self, mod)
     saveDataManager(nil, "postPlayerCollectible", v, hasSubscriptions)
+    mod:AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4)
     mod:AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate)
+    mod:AddCallback(ModCallback.ENTITY_TAKE_DMG, entityTakeDmgPlayer, EntityType.PLAYER)
 end
 return ____exports

package/dist/enums/ModCallbackCustom.d.ts

@@ -892,7 +892,8 @@ export declare enum ModCallbackCustom {
     POST_PLAYER_CHANGE_TYPE = 57,
     /**
      * Fires from the `POST_PEFFECT_UPDATE` callback when a player's collectible count is higher than
-     * what it was on the previous frame or when a new active collectible is acquired.
+     * what it was on the previous frame, or when the active items change, or when the build is
+     * rerolled.
      *
      * When registering the callback, takes an optional second argument that will make the callback
      * only fire if the collectible matches the `CollectibleType` provided.
@@ -907,7 +908,8 @@ export declare enum ModCallbackCustom {
     POST_PLAYER_COLLECTIBLE_ADDED = 58,
     /**
      * Fires from the `POST_PEFFECT_UPDATE` callback when a player's collectible count is lower than
-     * what it was on the previous frame or when an active collectible is no longer present.
+     * what it was on the previous frame, or when the active items change, or when the build is
+     * rerolled.
      *
      * When registering the callback, takes an optional second argument that will make the callback
      * only fire if the collectible matches the `CollectibleType` provided.

package/dist/enums/ModCallbackCustom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModCallbackCustom.d.ts","sourceRoot":"","sources":["../../src/enums/ModCallbackCustom.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ModCallbackCustom.d.ts","sourceRoot":"","sources":["../../src/enums/ModCallbackCustom.ts"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,oBAAY,iBAAiB;IAC3B;;;;;;;;;;OAUG;IACH,oBAAoB,IAAA;IAEpB;;;;;;;;;;OAUG;IACH,mBAAmB,IAAA;IAEnB;;;;;;;;;OASG;IACH,kBAAkB,IAAA;IAElB;;;;;;;;;;;;OAYG;IACH,mBAAmB,IAAA;IAEnB;;;;;;OAMG;IACH,eAAe,IAAA;IAEf;;;;;;;;;;;;;OAaG;IACH,sBAAsB,IAAA;IAEtB;;;;;;;;;;;;;;;OAeG;IACH,2BAA2B,IAAA;IAE3B;;;;;;;;OAQG;IACH,oBAAoB,IAAA;IAEpB;;;;;;;;;;;;;;;OAeG;IACH,sBAAsB,IAAA;IAEtB;;;;;;;;;;;;;;;OAeG;IACH,kBAAkB,IAAA;IAElB;;;;;;;;;;;;;OAaG;IACH,wBAAwB,KAAA;IAExB;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;;;;OAYG;IACH,qBAAqB,KAAA;IAErB;;;;;;;;;;;;;;OAcG;IACH,yBAAyB,KAAA;IAEzB;;;;;;;OAOG;IACH,YAAY,KAAA;IAEZ;;;;;;;;;;;;OAYG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;;OAeG;IACH,2BAA2B,KAAA;IAE3B;;;;;;;;;;OAUG;IACH,kBAAkB,KAAA;IAElB;;;;;;;;;;;OAWG;IACH,eAAe,KAAA;IAEf;;;;;;;;;;;OAWG;IACH,SAAS,KAAA;IAET;;;;;;;;;OASG;IACH,2BAA2B,KAAA;IAE3B;;;;;;;;;OASG;IACH,gCAAgC,KAAA;IAEhC;;;;;;OAMG;IACH,oBAAoB,KAAA;IAEpB;;;;;;;;;;;;;;OAcG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;;;;OAiBG;IACH,0BAA0B,KAAA;IAE1B;;;;;;;;;;;;;OAaG;IACH,8BAA8B,KAAA;IAE9B;;;;;;;;;;;;;;OAcG;IACH,iCAAiC,KAAA;IAEjC;;;;;;;;;;;;;OAaG;IACH,4BAA4B,KAAA;IAE5B;;;;;;;;;;;;;OAaG;IACH,8BAA8B,KAAA;IAE9B;;;;;;;;;;;;;OAaG;IACH,8BAA8B,KAAA;IAE9B;;;;;;;;;;;;;;;OAeG;IACH,qCAAqC,KAAA;IAErC;;;;;;;;;;;;;OAaG;IACH,8BAA8B,KAAA;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAAqB,KAAA;IAErB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;OAcG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;;;;OAiBG;IACH,8BAA8B,KAAA;IAE9B;;;;;;;;;;;;;;OAcG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,wBAAwB,KAAA;IAExB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;;;;;;;OAkBG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;;;;OAYG;IACH,oBAAoB,KAAA;IAEpB;;;;;;;;;;;;OAYG;IACH,oBAAoB,KAAA;IAEpB;;;;;;;;;;;;;;;OAeG;IACH,wBAAwB,KAAA;IAExB;;;;;;;;;OASG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;OAYG;IACH,kBAAkB,KAAA;IAElB;;;;;;;;;;;;;;;;OAgBG;IACH,sBAAsB,KAAA;IAEtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAA6B,KAAA;IAE7B;;;;;;;;;;;OAWG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;;OAaG;IACH,sBAAsB,KAAA;IAEtB;;;;;;;;;;;;OAYG;IACH,qBAAqB,KAAA;IAErB;;;;;;;;;;;;;;OAcG;IACH,yBAAyB,KAAA;IAEzB;;;;;;;;;OASG;IACH,eAAe,KAAA;IAEf;;;;;;;;;OASG;IACH,eAAe,KAAA;IAEf;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAAyB,KAAA;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;;;OAgBG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;;;OAcG;IACH,6BAA6B,KAAA;IAE7B;;;;;;;;;;;;;;OAcG;IACH,+BAA+B,KAAA;IAE/B;;;;;;;;;;;;;;;OAeG;IACH,wBAAwB,KAAA;IAExB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,sBAAsB,KAAA;IAEtB;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAAqB,KAAA;IAErB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,4BAA4B,KAAA;IAE5B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,4BAA4B,KAAA;IAE5B;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;OASG;IACH,0BAA0B,KAAA;IAE1B;;;;;;;;;OASG;IACH,0BAA0B,KAAA;IAE1B;;;;;;;;;;;;OAYG;IACH,yBAAyB,KAAA;IAEzB;;;;;;;;;;;;OAYG;IACH,aAAa,KAAA;IAEb;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;;OAUG;IACH,uBAAuB,KAAA;IAEvB;;;;;;;;;;;;OAYG;IACH,cAAc,KAAA;IAEd;;;;;;;;;OASG;IACH,2BAA2B,KAAA;IAE3B;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;OAYG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;;;OAcG;IACH,cAAc,KAAA;IAEd;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;OASG;IACH,gBAAgB,KAAA;IAEhB;;;;;;;;;OASG;IACH,kBAAkB,KAAA;IAElB;;;;;;;;;OASG;IACH,kBAAkB,KAAA;IAElB;;;;;;;;;;;;;OAaG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;OAYG;IACH,wBAAwB,KAAA;IAExB;;;;;;;;;OASG;IACH,eAAe,KAAA;IAEf;;;;;;;;;OASG;IACH,eAAe,KAAA;IAEf;;;;;;;;;;;;;;;;OAgBG;IACH,mBAAmB,KAAA;IAEnB;;;;;;;;;;;;OAYG;IACH,kBAAkB,KAAA;IAElB;;;;;;;;;;;;;OAaG;IACH,iBAAiB,KAAA;IAEjB;;;;;;;;;;;;;;;;OAgBG;IACH,iBAAiB,KAAA;IAEjB;;;;;;;;;;;;;;;;;OAiBG;IACH,eAAe,KAAA;IAEf;;;;;;;;;;;;OAYG;IACH,aAAa,KAAA;CACd"}

package/dist/features/customTrapdoor/exports.d.ts

@@ -4,12 +4,6 @@ import { LevelStage, StageType } from "isaac-typescript-definitions";
  * want to create a custom trapdoor that goes to a vanilla stage instead, use the
  * `spawnCustomTrapdoorToVanilla` helper function.
  *
- * Custom trapdoors can have one or more of the following attributes:
- *
- * - custom destination (or custom logic for after the player enters)
- * - custom graphics
- * - custom logic for opening/closing
- *
  * Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
  * respawned every time the player re-enters the room.
  *

package/dist/features/customTrapdoor/exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../../src/features/customTrapdoor/exports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAOrE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,CACjC,mBAAmB,EAAE,GAAG,GAAG,MAAM,EACjC,eAAe,EAAE,MAAM,EACvB,mBAAmB,EAAE,GAAG,EACxB,QAAQ,SAAmC,EAC3C,SAAS,CAAC,EAAE,OAAO,GAClB,UAAU,CAcZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,mBAAmB,EAAE,GAAG,GAAG,MAAM,EACjC,KAAK,CAAC,EAAE,UAAU,EAClB,SAAS,CAAC,EAAE,SAAS,EACrB,QAAQ,SAAmC,EAC3C,SAAS,CAAC,EAAE,OAAO,GAClB,UAAU,CAkBZ"}
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../../../src/features/customTrapdoor/exports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAOrE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,mBAAmB,EAAE,GAAG,GAAG,MAAM,EACjC,eAAe,EAAE,MAAM,EACvB,mBAAmB,EAAE,GAAG,EACxB,QAAQ,SAAmC,EAC3C,SAAS,CAAC,EAAE,OAAO,GAClB,UAAU,CAcZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,mBAAmB,EAAE,GAAG,GAAG,MAAM,EACjC,KAAK,CAAC,EAAE,UAAU,EAClB,SAAS,CAAC,EAAE,SAAS,EACrB,QAAQ,SAAmC,EAC3C,SAAS,CAAC,EAAE,OAAO,GAClB,UAAU,CAkBZ"}

package/dist/features/customTrapdoor/exports.lua

@@ -12,12 +12,6 @@ local spawnCustomTrapdoorToDestination = ____spawn.spawnCustomTrapdoorToDestinat
 -- want to create a custom trapdoor that goes to a vanilla stage instead, use the
 -- `spawnCustomTrapdoorToVanilla` helper function.
 -- 
--- Custom trapdoors can have one or more of the following attributes:
--- 
--- - custom destination (or custom logic for after the player enters)
--- - custom graphics
--- - custom logic for opening/closing
--- 
 -- Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
 -- respawned every time the player re-enters the room.
 -- 

package/dist/features/extraConsoleCommands/listCommands.lua

@@ -1054,7 +1054,7 @@ end
 -- "debug 10".
 function ____exports.spam(self)
     v.run.spamBloodRights = not v.run.spamBloodRights
-    printEnabled(nil, v.run.maxSpeed, "spamming Blood Rights")
+    printEnabled(nil, v.run.spamBloodRights, "spamming Blood Rights")
 end
 --- Spawns a golden version of the specified trinket type.
 function ____exports.spawnGoldenTrinket(self, params)

package/dist/features/playerInventory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playerInventory.d.ts","sourceRoot":"","sources":["../../src/features/playerInventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAe,MAAM,8BAA8B,CAAC;AAkH5E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,yBAAyB,UAAO,GAC/B,eAAe,EAAE,CAanB;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,YAAY,GACnB,eAAe,GAAG,SAAS,CAK7B"}
+{"version":3,"file":"playerInventory.d.ts","sourceRoot":"","sources":["../../src/features/playerInventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AA2D/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,yBAAyB,UAAO,GAC/B,eAAe,EAAE,CAYnB;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,YAAY,GACnB,eAAe,GAAG,SAAS,CAK7B"}

package/dist/features/playerInventory.lua

@@ -2,10 +2,7 @@ local ____lualib = require("lualib_bundle")
 local __TS__New = ____lualib.__TS__New
 local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
 local ____exports = {}
-local newPlayerInventory, resetInventory, useItemD4, postGameStarted, postCollectibleAdded, postCollectibleRemoved, v
-local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
-local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
-local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local postCollectibleAdded, postCollectibleRemoved, v
 local ____DefaultMap = require("classes.DefaultMap")
 local DefaultMap = ____DefaultMap.DefaultMap
 local ____ModCallbackCustom = require("enums.ModCallbackCustom")
@@ -18,48 +15,10 @@ local copyArray = ____array.copyArray
 local getLastElement = ____array.getLastElement
 local ____collectibles = require("functions.collectibles")
 local isActiveCollectible = ____collectibles.isActiveCollectible
-local ____collectibleSet = require("functions.collectibleSet")
-local getCollectibleArray = ____collectibleSet.getCollectibleArray
 local ____playerDataStructures = require("functions.playerDataStructures")
 local defaultMapGetPlayer = ____playerDataStructures.defaultMapGetPlayer
-local mapSetPlayer = ____playerDataStructures.mapSetPlayer
-local ____playerIndex = require("functions.playerIndex")
-local getAllPlayers = ____playerIndex.getAllPlayers
-local getPlayerIndex = ____playerIndex.getPlayerIndex
-local ____utils = require("functions.utils")
-local ____repeat = ____utils["repeat"]
 local ____exports = require("features.saveDataManager.exports")
 local saveDataManager = ____exports.saveDataManager
-function newPlayerInventory(self, player)
-    local inventory = {}
-    for ____, collectibleType in ipairs(getCollectibleArray(nil)) do
-        local numCollectibles = player:GetCollectibleNum(collectibleType, true)
-        ____repeat(
-            nil,
-            numCollectibles,
-            function()
-                inventory[#inventory + 1] = collectibleType
-            end
-        )
-    end
-    return inventory
-end
-function resetInventory(self, player)
-    local inventory = newPlayerInventory(nil, player)
-    mapSetPlayer(nil, v.run.playersInventory, player, inventory)
-end
-function useItemD4(self, _collectibleType, _rng, player)
-    resetInventory(nil, player)
-    return nil
-end
-function postGameStarted(self)
-    for ____, player in ipairs(getAllPlayers(nil)) do
-        local playerIndex = getPlayerIndex(nil, player)
-        if not v.run.playersInventory:has(playerIndex) then
-            resetInventory(nil, player)
-        end
-    end
-end
 function postCollectibleAdded(self, player, collectibleType)
     local inventory = defaultMapGetPlayer(nil, v.run.playersInventory, player, player)
     inventory[#inventory + 1] = collectibleType
@@ -71,14 +30,12 @@ end
 local FEATURE_NAME = "playerInventory"
 v = {run = {playersInventory = __TS__New(
     DefaultMap,
-    function(____, player) return newPlayerInventory(nil, player) end
+    function() return {} end
 )}}
 ---
 -- @internal
 function ____exports.playerInventoryInit(self, mod)
     saveDataManager(nil, FEATURE_NAME, v)
-    mod:AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4)
-    mod:AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted)
     mod:AddCallbackCustom(ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED, postCollectibleAdded)
     mod:AddCallbackCustom(ModCallbackCustom.POST_PLAYER_COLLECTIBLE_REMOVED, postCollectibleRemoved)
 end
@@ -106,12 +63,11 @@ function ____exports.getPlayerInventory(self, player, includeActiveCollectibles)
     end
     errorIfFeaturesNotInitialized(nil, FEATURE_NAME)
     local inventory = defaultMapGetPlayer(nil, v.run.playersInventory, player, player)
-    local copiedInventory = copyArray(nil, inventory)
     if includeActiveCollectibles then
-        return copiedInventory
+        return copyArray(nil, inventory)
     end
     return __TS__ArrayFilter(
-        copiedInventory,
+        inventory,
         function(____, collectibleType) return not isActiveCollectible(nil, collectibleType) end
     )
 end

package/dist/features/saveDataManager/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/features/saveDataManager/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAKtD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAsBrD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAUlE;AAuED,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,WAAW,GACvB,IAAI,CA4CN;AAiBD,wBAAgB,wBAAwB,IAAI,IAAI,CAM/C;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAM/C"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/features/saveDataManager/main.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAGxD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAMtD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAsBrD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAUlE;AAqFD,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,WAAW,GACvB,IAAI,CA4CN;AAiBD,wBAAgB,wBAAwB,IAAI,IAAI,CAM/C;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAM/C"}

package/dist/features/saveDataManager/main.lua

@@ -17,6 +17,8 @@ local ____deepCopy = require("functions.deepCopy")
 local deepCopy = ____deepCopy.deepCopy
 local ____log = require("functions.log")
 local logError = ____log.logError
+local ____stage = require("functions.stage")
+local onFirstFloor = ____stage.onFirstFloor
 local ____table = require("functions.table")
 local clearTable = ____table.clearTable
 local iterateTableInOrder = ____table.iterateTableInOrder
@@ -55,7 +57,13 @@ function preGameExit(self)
     loadedDataOnThisRun = false
 end
 function postNewLevel(self)
+    if mod == nil then
+        error(("The mod for the " .. SAVE_DATA_MANAGER_FEATURE_NAME) .. " was not initialized.")
+    end
     restoreDefaults(nil, SaveDataKey.LEVEL)
+    if not onFirstFloor(nil) then
+        saveToDisk(nil, mod, saveDataMap, saveDataConditionalFuncMap)
+    end
 end
 function postNewRoomEarly(self)
     restoreDefaults(nil, SaveDataKey.ROOM)

package/dist/functions/rooms.d.ts

@@ -127,6 +127,7 @@ export declare function inDoubleTrouble(): boolean;
 export declare function inGenesisRoom(): boolean;
 /** Helper function to determine if the current room shape is one of the four L room shapes. */
 export declare function inLRoom(): boolean;
+/** Helper function to determine if the current room index is equal to `GridRoom.MEGA_SATAN`. */
 export declare function inMegaSatanRoom(): boolean;
 /**
  * Helper function to determine if the current room is part of the Repentance "escape sequence" in

package/dist/functions/rooms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rooms.d.ts","sourceRoot":"","sources":["../../src/functions/rooms.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EACZ,MAAM,EACN,SAAS,EAMT,YAAY,EACZ,UAAU,EAGV,QAAQ,EAGT,MAAM,8BAA8B,CAAC;AAkCtC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,aAAa,EAAE,GAAG,GAAG,IAAI,CAenD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,GAAG,CAGjC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAiBlE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,GAAG,EAChB,oBAAoB,UAAO,GAC1B,QAAQ,CAAC,UAAU,CAAC,GAAG,SAAS,CAUlC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,CAOlD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,4BAA4B,UAAQ,GACnC,cAAc,EAAE,CAOlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,4BAA4B,UAAQ,GACnC,cAAc,EAAE,CAqBlB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,EAAE,CAe1E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,EAAE,CAWtD;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC;AAED,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAWpD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAStC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAShD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAGnD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAMzC;AAED,wBAAgB,aAAa,IAAI,OAAO,CAIvC;AAED,+FAA+F;AAC/F,wBAAgB,OAAO,IAAI,OAAO,CAUjC;AAED,wBAAgB,eAAe,IAAI,OAAO,CAIzC;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAWhE;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAWtC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAItC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAMxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,kBAAkB,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAcxE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAWrC;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAG5D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,IAAI,CA8BrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC"}
+{"version":3,"file":"rooms.d.ts","sourceRoot":"","sources":["../../src/functions/rooms.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EACZ,MAAM,EACN,SAAS,EAMT,YAAY,EACZ,UAAU,EAGV,QAAQ,EAGT,MAAM,8BAA8B,CAAC;AAkCtC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,aAAa,EAAE,GAAG,GAAG,IAAI,CAenD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,GAAG,CAGjC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,KAAK,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAiBlE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,GAAG,EAChB,oBAAoB,UAAO,GAC1B,QAAQ,CAAC,UAAU,CAAC,GAAG,SAAS,CAUlC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,CAOlD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,4BAA4B,UAAQ,GACnC,cAAc,EAAE,CAOlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,4BAA4B,UAAQ,GACnC,cAAc,EAAE,CAqBlB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,EAAE,CAe1E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,EAAE,CAWtD;AAED;;;GAGG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAKnC;AAED,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAWpD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAStC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAShD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,IAAI,OAAO,CAGnD;AAED,wBAAgB,eAAe,IAAI,OAAO,CAMzC;AAED,wBAAgB,aAAa,IAAI,OAAO,CAIvC;AAED,+FAA+F;AAC/F,wBAAgB,OAAO,IAAI,OAAO,CAUjC;AAED,gGAAgG;AAChG,wBAAgB,eAAe,IAAI,OAAO,CAIzC;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAWhE;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAWtC;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAItC;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAMxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,kBAAkB,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAcxE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAWrC;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAG5D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,IAAI,CA8BrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC"}

package/dist/functions/rooms.lua

@@ -305,6 +305,7 @@ function ____exports.inLRoom(self)
     local roomShape = room:GetRoomShape()
     return roomShape == RoomShape.LTL or roomShape == RoomShape.LTR or roomShape == RoomShape.LBL or roomShape == RoomShape.LBR
 end
+--- Helper function to determine if the current room index is equal to `GridRoom.MEGA_SATAN`.
 function ____exports.inMegaSatanRoom(self)
     local roomGridIndex = getRoomGridIndex(nil)
     return roomGridIndex == asNumber(nil, GridRoom.MEGA_SATAN)

package/dist/functions/stage.d.ts

@@ -26,6 +26,10 @@ export declare function getStage(): LevelStage;
 export declare function getStageType(): StageType;
 /** Helper function to directly warp to a specific stage using the "stage" console command. */
 export declare function goToStage(stage: LevelStage, stageType: StageType): void;
+/**
+ * Helper function to check if the provided stage type is equal to `StageType.REPENTANCE` or
+ * `StageType.REPENTANCE_B`.
+ */
 export declare function isRepentanceStage(stageType: StageType): boolean;
 export declare function onAscent(): boolean;
 export declare function onCathedral(): boolean;
@@ -40,6 +44,17 @@ export declare function onDarkRoom(): boolean;
  * I AM ERROR room is never entered into the list of possibilities.
  */
 export declare function onFinalFloor(): boolean;
+/**
+ * Returns whether or not the player is on the first floor of the particular run.
+ *
+ * This is tricky to determine because we have to handle the cases of Downpour/Dross 1 not being the
+ * first floor and The Ascent.
+ */
+export declare function onFirstFloor(): boolean;
+/**
+ * Helper function to check if the current stage type is equal to `StageType.REPENTANCE` or
+ * `StageType.REPENTANCE_B`.
+ */
 export declare function onRepentanceStage(): boolean;
 export declare function onSheol(): boolean;
 /**

package/dist/functions/stage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../../src/functions/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EACV,QAAQ,EACR,SAAS,EACV,MAAM,8BAA8B,CAAC;AAOtC;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CA6B/D;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAmBzE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,GAAG,CASvC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,GAAG,MAAM,CAG3E;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,IAAI,UAAU,CAIrC;AAED,iDAAiD;AACjD,wBAAgB,YAAY,IAAI,SAAS,CAIxC;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,CAIvE;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAI/D;AAED,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAED,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED,wBAAgB,OAAO,IAAI,OAAO,CASjC;AAED,wBAAgB,UAAU,IAAI,OAAO,CAQpC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAUtC;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAK3C;AAED,wBAAgB,OAAO,IAAI,OAAO,CAQjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,UAAQ,GACb,IAAI,CAUN;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAE9D"}
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../../src/functions/stage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EACV,QAAQ,EACR,SAAS,EACV,MAAM,8BAA8B,CAAC;AAOtC;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CA6B/D;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAmBzE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,GAAG,CASvC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,GAAG,MAAM,CAG3E;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,IAAI,UAAU,CAIrC;AAED,iDAAiD;AACjD,wBAAgB,YAAY,IAAI,SAAS,CAIxC;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,CAIvE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAI/D;AAED,wBAAgB,QAAQ,IAAI,OAAO,CAElC;AAED,wBAAgB,WAAW,IAAI,OAAO,CASrC;AAED,wBAAgB,OAAO,IAAI,OAAO,CASjC;AAED,wBAAgB,UAAU,IAAI,OAAO,CAQpC;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAUtC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAKtC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAK3C;AAED,wBAAgB,OAAO,IAAI,OAAO,CAQjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,UAAQ,GACb,IAAI,CAUN;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,GAAG,MAAM,CAE9D"}

package/dist/functions/stage.lua

@@ -14,9 +14,13 @@ local STAGE_TYPE_TO_LETTER = ____stageTypeToLetter.STAGE_TYPE_TO_LETTER
 local ____types = require("functions.types")
 local asLevelStage = ____types.asLevelStage
 local asNumber = ____types.asNumber
+--- Helper function to check if the provided stage type is equal to `StageType.REPENTANCE` or
+-- `StageType.REPENTANCE_B`.
 function ____exports.isRepentanceStage(self, stageType)
     return stageType == StageType.REPENTANCE or stageType == StageType.REPENTANCE_B
 end
+--- Helper function to check if the current stage type is equal to `StageType.REPENTANCE` or
+-- `StageType.REPENTANCE_B`.
 function ____exports.onRepentanceStage(self)
     local level = game:GetLevel()
     local stageType = level:GetStageType()
@@ -125,6 +129,15 @@ function ____exports.onFinalFloor(self)
     local stage = level:GetStage()
     return stage == LevelStage.DARK_ROOM_CHEST or stage == LevelStage.THE_VOID or stage == LevelStage.HOME or stage == LevelStage.WOMB_2 and ____exports.onRepentanceStage(nil)
 end
+--- Returns whether or not the player is on the first floor of the particular run.
+-- 
+-- This is tricky to determine because we have to handle the cases of Downpour/Dross 1 not being the
+-- first floor and The Ascent.
+function ____exports.onFirstFloor(self)
+    local effectiveStage = ____exports.getEffectiveStage(nil)
+    local isOnAscent = ____exports.onAscent(nil)
+    return effectiveStage == 1 and not isOnAscent
+end
 function ____exports.onSheol(self)
     local level = game:GetLevel()
     local stage = level:GetStage()

package/dist/index.d.ts

@@ -5433,6 +5433,7 @@ export declare function initCustomDoor(mod: ModUpgraded, effectVariant: EffectVa
 /** Helper function to determine if the current room shape is one of the four L room shapes. */
 export declare function inLRoom(): boolean;
 
+/** Helper function to determine if the current room index is equal to `GridRoom.MEGA_SATAN`. */
 export declare function inMegaSatanRoom(): boolean;
 
 /**
@@ -6049,6 +6050,10 @@ export declare function isReflectionRender(): boolean;
  */
 export declare function isRepentanceDoor(door: GridEntityDoor): boolean;
 
+/**
+ * Helper function to check if the provided stage type is equal to `StageType.REPENTANCE` or
+ * `StageType.REPENTANCE_B`.
+ */
 export declare function isRepentanceStage(stageType: StageType): boolean;
 
 /** Returns true for cards that have `ItemConfigCardType.TAROT_REVERSE`. */
@@ -7583,7 +7588,8 @@ export declare enum ModCallbackCustom {
     POST_PLAYER_CHANGE_TYPE = 57,
     /**
      * Fires from the `POST_PEFFECT_UPDATE` callback when a player's collectible count is higher than
-     * what it was on the previous frame or when a new active collectible is acquired.
+     * what it was on the previous frame, or when the active items change, or when the build is
+     * rerolled.
      *
      * When registering the callback, takes an optional second argument that will make the callback
      * only fire if the collectible matches the `CollectibleType` provided.
@@ -7598,7 +7604,8 @@ export declare enum ModCallbackCustom {
     POST_PLAYER_COLLECTIBLE_ADDED = 58,
     /**
      * Fires from the `POST_PEFFECT_UPDATE` callback when a player's collectible count is lower than
-     * what it was on the previous frame or when an active collectible is no longer present.
+     * what it was on the previous frame, or when the active items change, or when the build is
+     * rerolled.
      *
      * When registering the callback, takes an optional second argument that will make the callback
      * only fire if the collectible matches the `CollectibleType` provided.
@@ -8253,6 +8260,18 @@ export declare const ONE_BY_ONE_ROOM_GRID_SIZE = 135;
  */
 export declare function onFinalFloor(): boolean;
 
+/**
+ * Returns whether or not the player is on the first floor of the particular run.
+ *
+ * This is tricky to determine because we have to handle the cases of Downpour/Dross 1 not being the
+ * first floor and The Ascent.
+ */
+export declare function onFirstFloor(): boolean;
+
+/**
+ * Helper function to check if the current stage type is equal to `StageType.REPENTANCE` or
+ * `StageType.REPENTANCE_B`.
+ */
 export declare function onRepentanceStage(): boolean;
 
 /**
@@ -10861,12 +10880,6 @@ export declare function spawnCustomGridEntity(gridEntityTypeCustom: GridEntityTy
  * want to create a custom trapdoor that goes to a vanilla stage instead, use the
  * `spawnCustomTrapdoorToVanilla` helper function.
  *
- * Custom trapdoors can have one or more of the following attributes:
- *
- * - custom destination (or custom logic for after the player enters)
- * - custom graphics
- * - custom logic for opening/closing
- *
  * Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
  * respawned every time the player re-enters the room.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "9.1.0",
+  "version": "9.2.1",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",

package/src/callbacks/postPlayerCollectible.ts

@@ -5,15 +5,19 @@
 import {
   ActiveSlot,
   CollectibleType,
+  DamageFlag,
+  EntityType,
   ModCallback,
+  PlayerType,
 } from "isaac-typescript-definitions";
 import { DefaultMap } from "../classes/DefaultMap";
+import { runNextGameFrame } from "../features/runInNFrames";
 import { saveDataManager } from "../features/saveDataManager/exports";
 import { arrayEquals } from "../functions/array";
 import { getEnumValues } from "../functions/enums";
+import { hasFlag } from "../functions/flag";
 import {
   defaultMapGetPlayer,
-  mapGetPlayer,
   mapSetPlayer,
 } from "../functions/playerDataStructures";
 import { getPlayerCollectibleMap } from "../functions/players";
@@ -30,7 +34,7 @@ import {
 
 const v = {
   run: {
-    playersCollectibleCount: new Map<PlayerIndex, int>(),
+    playersCollectibleCount: new DefaultMap<PlayerIndex, int>(0),
     playersCollectibleMap: new DefaultMap<
       PlayerIndex,
       Map<CollectibleType, int>
@@ -45,7 +49,13 @@ const v = {
 export function postPlayerCollectibleCallbacksInit(mod: Mod): void {
   saveDataManager("postPlayerCollectible", v, hasSubscriptions);
 
+  mod.AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4); // 3
   mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
+  mod.AddCallback(
+    ModCallback.ENTITY_TAKE_DMG,
+    entityTakeDmgPlayer,
+    EntityType.PLAYER,
+  ); // 11
 }
 
 function hasSubscriptions() {
@@ -55,37 +65,20 @@ function hasSubscriptions() {
   );
 }
 
-// ModCallback.POST_PEFFECT_UPDATE (4)
-function postPEffectUpdate(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const oldCollectibleCount = mapGetPlayer(
-    v.run.playersCollectibleCount,
-    player,
-  );
-  const newCollectibleCount = player.GetCollectibleCount();
-  mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
-
-  if (oldCollectibleCount === undefined) {
-    return;
-  }
-
-  const difference = newCollectibleCount - oldCollectibleCount;
-
-  if (difference > 0) {
-    collectibleCountChanged(player, difference);
-  } else if (difference < 0) {
-    collectibleCountChanged(player, difference * -1);
-  } else if (difference === 0) {
-    checkActiveItemsChanged(player);
-  }
-}
-
-function collectibleCountChanged(
+/**
+ * This is called when the collectible count changes and in situations where the entire build is
+ * rerolled.
+ *
+ * Since getting a new player collectible map is expensive, we want to only run this function when
+ * necessary, and not on e.g. every frame. Unfortunately, this has the side effect of missing out on
+ * collectible changes from mods that add and remove a collectible on the same frame.
+ *
+ * @param player The player to update.
+ * @param numCollectiblesChanged Pass undefined for situations where the entire build was rerolled.
+ */
+function updateCollectibleMapAndFire(
   player: EntityPlayer,
-  numCollectiblesChanged: int,
+  numCollectiblesChanged: int | undefined,
 ) {
   const oldCollectibleMap = defaultMapGetPlayer(
     v.run.playersCollectibleMap,
@@ -94,13 +87,13 @@ function collectibleCountChanged(
   const newCollectibleMap = getPlayerCollectibleMap(player);
   mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
 
-  const collectibleTypeSet = new Set<CollectibleType>([
+  const collectibleTypesSet = new Set<CollectibleType>([
     ...oldCollectibleMap.keys(),
     ...newCollectibleMap.keys(),
   ]);
 
   let numFired = 0;
-  for (const collectibleType of collectibleTypeSet.values()) {
+  for (const collectibleType of collectibleTypesSet.values()) {
     const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
     const newNum = newCollectibleMap.get(collectibleType) ?? 0;
     const difference = newNum - oldNum;
@@ -122,9 +115,63 @@ function collectibleCountChanged(
   }
 }
 
+// ModCallback.POST_USE_ITEM (3)
+// CollectibleType.D4 (284)
+function useItemD4(
+  _collectibleType: CollectibleType,
+  _rng: RNG,
+  player: EntityPlayer,
+): boolean | undefined {
+  // This function is also triggered for:
+  // - D100
+  // - D Infinity copying D4 or D100
+  // - 1-pip dice room
+  // - 6-pip dice room
+  // - Reverse Wheel of Fortune copying 1-pip or 6-pip dice room
+  // - First getting Missing No.
+  // - Arriving on a new floor with Missing No.
+
+  // This function is not triggered for:
+  // - Tainted Eden getting hit (this is explicitly handled elsewhere)
+  // - Genesis (which is automatically handled by the collectibles being removed in the normal
+  //   `POST_PLAYER_COLLECTIBLE_REMOVED` callback)
+  updateCollectibleMapAndFire(player, undefined);
+
+  return undefined;
+}
+
+// ModCallback.POST_PEFFECT_UPDATE (4)
+function postPEffectUpdate(player: EntityPlayer) {
+  if (!hasSubscriptions()) {
+    return;
+  }
+
+  const oldCollectibleCount = defaultMapGetPlayer(
+    v.run.playersCollectibleCount,
+    player,
+  );
+  const newCollectibleCount = player.GetCollectibleCount();
+  mapSetPlayer(v.run.playersCollectibleCount, player, newCollectibleCount);
+
+  const difference = newCollectibleCount - oldCollectibleCount;
+
+  if (difference > 0) {
+    updateCollectibleMapAndFire(player, difference);
+  } else if (difference < 0) {
+    updateCollectibleMapAndFire(player, difference * -1);
+  } else if (difference === 0) {
+    checkActiveItemsChanged(player);
+  }
+}
+
 /**
- * The special case is when a player swaps their active item for another active item. In this
- * situation, their overall collectible count will not change. Thus, we explicitly check for this.
+ * Checking for collectible count will work to detect when a player swaps their active item for
+ * another active item. This is because the collectible count will decrement by 1 when the item is
+ * swapped onto the pedestal and the hold animation begins, and increment by 1 when the item is
+ * dequeued and the hold animation ends.
+ *
+ * However, we also want to explicitly check for the case where a mod swaps in a custom active
+ * collectible on the same frame, since doing so is cheap.
  */
 function checkActiveItemsChanged(player: EntityPlayer) {
   const activeItemMap = defaultMapGetPlayer(v.run.playersActiveItemMap, player);
@@ -143,48 +190,58 @@ function checkActiveItemsChanged(player: EntityPlayer) {
   }
 
   // For example, it is possible for the player to switch Schoolbag items, which will cause the
-  // collectibles in the array to be the same, but in a different order. Thus, sort both arrays
+  // collectibles in the array to be the same, but in a different order. Thus, we sort both arrays
   // before comparing them.
   oldCollectibleTypes.sort();
   newCollectibleTypes.sort();
 
   if (!arrayEquals(oldCollectibleTypes, newCollectibleTypes)) {
-    const collectibleTypeSet = new Set<CollectibleType>([
-      ...oldCollectibleTypes,
-      ...newCollectibleTypes,
-    ]);
-    activeItemsChanged(player, collectibleTypeSet);
+    // One or more active items have changed (with the player's total collectible count remaining
+    // the same).
+    updateCollectibleMapAndFire(player, undefined);
   }
 }
 
-/**
- * One or more active items have changed (with the player's total collectible count remaining the
- * same).
- */
-function activeItemsChanged(
-  player: EntityPlayer,
-  collectibleTypesSet: Set<CollectibleType>,
-) {
-  const oldCollectibleMap = defaultMapGetPlayer(
-    v.run.playersCollectibleMap,
-    player,
-  );
-  const newCollectibleMap = getPlayerCollectibleMap(player);
-  mapSetPlayer(v.run.playersCollectibleMap, player, newCollectibleMap);
+// ModCallback.ENTITY_TAKE_DMG (11)
+// EntityType.PLAYER (1)
+// We need to handle the case of Tainted Eden taking damage.
+function entityTakeDmgPlayer(
+  entity: Entity,
+  _amount: float,
+  damageFlags: BitFlags<DamageFlag>,
+  _source: EntityRef,
+  _countdownFrames: int,
+): boolean | undefined {
+  // Tainted Eden's mechanic does not apply if she e.g. uses Dull Razor.
+  if (hasFlag(damageFlags, DamageFlag.FAKE)) {
+    return undefined;
+  }
 
-  for (const collectibleType of collectibleTypesSet.values()) {
-    const oldNum = oldCollectibleMap.get(collectibleType) ?? 0;
-    const newNum = newCollectibleMap.get(collectibleType) ?? 0;
-    const difference = newNum - oldNum;
-    const increased = difference > 0;
-    const absoluteDifference = Math.abs(difference);
+  const player = entity.ToPlayer();
+  if (player === undefined) {
+    return undefined;
+  }
 
-    repeat(absoluteDifference, () => {
-      if (increased) {
-        postPlayerCollectibleAddedFire(player, collectibleType);
-      } else {
-        postPlayerCollectibleRemovedFire(player, collectibleType);
-      }
-    });
+  const character = player.GetPlayerType();
+  if (character !== PlayerType.EDEN_B) {
+    return undefined;
   }
+
+  // The items will only be rerolled after the damage is successfully applied.
+  const ptr = EntityPtr(player);
+  runNextGameFrame(() => {
+    const futureEntity = ptr.Ref;
+    if (futureEntity === undefined) {
+      return;
+    }
+
+    const futurePlayer = futureEntity.ToPlayer();
+    if (futurePlayer === undefined) {
+      return;
+    }
+
+    updateCollectibleMapAndFire(player, undefined);
+  });
+
+  return undefined;
 }

package/src/enums/ModCallbackCustom.ts

@@ -959,7 +959,8 @@ export enum ModCallbackCustom {
 
   /**
    * Fires from the `POST_PEFFECT_UPDATE` callback when a player's collectible count is higher than
-   * what it was on the previous frame or when a new active collectible is acquired.
+   * what it was on the previous frame, or when the active items change, or when the build is
+   * rerolled.
    *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if the collectible matches the `CollectibleType` provided.
@@ -975,7 +976,8 @@ export enum ModCallbackCustom {
 
   /**
    * Fires from the `POST_PEFFECT_UPDATE` callback when a player's collectible count is lower than
-   * what it was on the previous frame or when an active collectible is no longer present.
+   * what it was on the previous frame, or when the active items change, or when the build is
+   * rerolled.
    *
    * When registering the callback, takes an optional second argument that will make the callback
    * only fire if the collectible matches the `CollectibleType` provided.

package/src/features/customTrapdoor/exports.ts

@@ -10,12 +10,6 @@ import { spawnCustomTrapdoorToDestination } from "./spawn";
  * want to create a custom trapdoor that goes to a vanilla stage instead, use the
  * `spawnCustomTrapdoorToVanilla` helper function.
  *
- * Custom trapdoors can have one or more of the following attributes:
- *
- * - custom destination (or custom logic for after the player enters)
- * - custom graphics
- * - custom logic for opening/closing
- *
  * Under the hood, the custom trapdoor is represented by a decoration grid entity and is manually
  * respawned every time the player re-enters the room.
  *

package/src/features/extraConsoleCommands/listCommands.ts

@@ -1249,7 +1249,7 @@ export function sounds(): void {
  */
 export function spam(): void {
   v.run.spamBloodRights = !v.run.spamBloodRights;
-  printEnabled(v.run.maxSpeed, "spamming Blood Rights");
+  printEnabled(v.run.spamBloodRights, "spamming Blood Rights");
 }
 
 /** Spawns a golden version of the specified trinket type. */

package/src/features/playerInventory.ts

@@ -1,4 +1,4 @@
-import { CollectibleType, ModCallback } from "isaac-typescript-definitions";
+import { CollectibleType } from "isaac-typescript-definitions";
 import { DefaultMap } from "../classes/DefaultMap";
 import { ModUpgraded } from "../classes/ModUpgraded";
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
@@ -9,13 +9,7 @@ import {
   getLastElement,
 } from "../functions/array";
 import { isActiveCollectible } from "../functions/collectibles";
-import { getCollectibleArray } from "../functions/collectibleSet";
-import {
-  defaultMapGetPlayer,
-  mapSetPlayer,
-} from "../functions/playerDataStructures";
-import { getAllPlayers, getPlayerIndex } from "../functions/playerIndex";
-import { repeat } from "../functions/utils";
+import { defaultMapGetPlayer } from "../functions/playerDataStructures";
 import { PlayerIndex } from "../types/PlayerIndex";
 import { saveDataManager } from "./saveDataManager/exports";
 
@@ -27,36 +21,14 @@ const v = {
       PlayerIndex,
       CollectibleType[],
       [player: EntityPlayer]
-    >((player: EntityPlayer) => newPlayerInventory(player)),
+    >(() => []),
   },
 };
 
-function newPlayerInventory(player: EntityPlayer) {
-  const inventory: CollectibleType[] = [];
-
-  for (const collectibleType of getCollectibleArray()) {
-    // We need to specify "true" as the second argument here to filter out things like Lilith's
-    // Incubus.
-    const numCollectibles = player.GetCollectibleNum(collectibleType, true);
-    repeat(numCollectibles, () => {
-      inventory.push(collectibleType);
-    });
-  }
-
-  return inventory;
-}
-
-function resetInventory(player: EntityPlayer) {
-  const inventory = newPlayerInventory(player);
-  mapSetPlayer(v.run.playersInventory, player, inventory);
-}
-
 /** @internal */
 export function playerInventoryInit(mod: ModUpgraded): void {
   saveDataManager(FEATURE_NAME, v);
 
-  mod.AddCallback(ModCallback.POST_USE_ITEM, useItemD4, CollectibleType.D4); // 3
-  mod.AddCallback(ModCallback.POST_GAME_STARTED, postGameStarted); // 15
   mod.AddCallbackCustom(
     ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED,
     postCollectibleAdded,
@@ -67,33 +39,6 @@ export function playerInventoryInit(mod: ModUpgraded): void {
   );
 }
 
-// ModCallback.POST_USE_ITEM (3)
-// CollectibleType.D4 (284)
-function useItemD4(
-  _collectibleType: CollectibleType,
-  _rng: RNG,
-  player: EntityPlayer,
-): boolean | undefined {
-  // This function is also triggered when the player uses D100, D Infinity, a 1-pip dice room, or a
-  // 6-pip dice room. (Genesis should be automatically handled by the
-  // `POST_PLAYER_COLLECTIBLE_REMOVED` callback.)
-  resetInventory(player);
-
-  return undefined;
-}
-
-// ModCallback.POST_GAME_STARTED (15)
-function postGameStarted() {
-  // We don't use the `POST_PLAYER_INIT` callback because some items are not given to the player at
-  // that point.
-  for (const player of getAllPlayers()) {
-    const playerIndex = getPlayerIndex(player);
-    if (!v.run.playersInventory.has(playerIndex)) {
-      resetInventory(player);
-    }
-  }
-}
-
 // ModCallbackCustom.POST_PLAYER_COLLECTIBLE_ADDED
 function postCollectibleAdded(
   player: EntityPlayer,
@@ -140,12 +85,11 @@ export function getPlayerInventory(
 
   const inventory = defaultMapGetPlayer(v.run.playersInventory, player, player);
 
-  const copiedInventory = copyArray(inventory);
   if (includeActiveCollectibles) {
-    return copiedInventory;
+    return copyArray(inventory);
   }
 
-  return copiedInventory.filter(
+  return inventory.filter(
     (collectibleType) => !isActiveCollectible(collectibleType),
   );
 }

package/src/features/saveDataManager/main.ts

@@ -6,6 +6,7 @@ import { SaveDataKey } from "../../enums/SaveDataKey";
 import { SerializationType } from "../../enums/SerializationType";
 import { deepCopy } from "../../functions/deepCopy";
 import { logError } from "../../functions/log";
+import { onFirstFloor } from "../../functions/stage";
 import { clearTable, iterateTableInOrder } from "../../functions/table";
 import { SaveData } from "../../interfaces/SaveData";
 import { loadFromDisk } from "./load";
@@ -49,6 +50,8 @@ function postPlayerInit() {
     );
   }
 
+  // We want to only load data once per run to handle the case of a player using Genesis, a second
+  // player joining the run, and so on.
   if (loadedDataOnThisRun) {
     return;
   }
@@ -86,7 +89,19 @@ function preGameExit() {
 
 // ModCallback.POST_NEW_LEVEL (18)
 function postNewLevel() {
+  if (mod === null) {
+    error(
+      `The mod for the ${SAVE_DATA_MANAGER_FEATURE_NAME} was not initialized.`,
+    );
+  }
+
   restoreDefaults(SaveDataKey.LEVEL);
+
+  // We save data to disk at the beginning of every floor (for the 2nd floor and beyond) to emulate
+  // what the game does internally. (This mitigates data loss in the event of a crash).
+  if (!onFirstFloor()) {
+    saveToDisk(mod, saveDataMap, saveDataConditionalFuncMap);
+  }
 }
 
 // ModCallbackCustom.POST_NEW_ROOM_EARLY

package/src/functions/rooms.ts

@@ -388,6 +388,7 @@ export function inLRoom(): boolean {
   );
 }
 
+/** Helper function to determine if the current room index is equal to `GridRoom.MEGA_SATAN`. */
 export function inMegaSatanRoom(): boolean {
   const roomGridIndex = getRoomGridIndex();
 

package/src/functions/stage.ts

@@ -116,6 +116,10 @@ export function goToStage(stage: LevelStage, stageType: StageType): void {
   Isaac.ExecuteCommand(command);
 }
 
+/**
+ * Helper function to check if the provided stage type is equal to `StageType.REPENTANCE` or
+ * `StageType.REPENTANCE_B`.
+ */
 export function isRepentanceStage(stageType: StageType): boolean {
   return (
     stageType === StageType.REPENTANCE || stageType === StageType.REPENTANCE_B
@@ -178,6 +182,23 @@ export function onFinalFloor(): boolean {
   );
 }
 
+/**
+ * Returns whether or not the player is on the first floor of the particular run.
+ *
+ * This is tricky to determine because we have to handle the cases of Downpour/Dross 1 not being the
+ * first floor and The Ascent.
+ */
+export function onFirstFloor(): boolean {
+  const effectiveStage = getEffectiveStage();
+  const isOnAscent = onAscent();
+
+  return effectiveStage === 1 && !isOnAscent;
+}
+
+/**
+ * Helper function to check if the current stage type is equal to `StageType.REPENTANCE` or
+ * `StageType.REPENTANCE_B`.
+ */
 export function onRepentanceStage(): boolean {
   const level = game.GetLevel();
   const stageType = level.GetStageType();