isaacscript-common 9.1.0 → 9.1.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":"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;;;;;;;;;;;;;OAaG;IACH,6BAA6B,KAAA;IAE7B;;;;;;;;;;;;;OAaG;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"}
+{"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/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/index.d.ts

@@ -7583,7 +7583,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 +7599,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "9.1.0",
+  "version": "9.1.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/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),
   );
 }