isaacscript-common 73.1.1 → 75.0.0

package/dist/objects/itemPoolTypeToCollectibleTypesSet.lua

@@ -0,0 +1,43 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayFind = ____lualib.__TS__ArrayFind
+local ____exports = {}
+local getItemPoolJSON
+local ____cachedEnumValues = require("arrays.cachedEnumValues")
+local ITEM_POOL_TYPE_VALUES = ____cachedEnumValues.ITEM_POOL_TYPE_VALUES
+local itemPoolsJSON = require("data.itempools")
+local ____types = require("functions.types")
+local asCollectibleType = ____types.asCollectibleType
+local ____itemPoolTypeToItemPoolName = require("maps.itemPoolTypeToItemPoolName")
+local ITEM_POOL_TYPE_TO_ITEM_POOL_NAME = ____itemPoolTypeToItemPoolName.ITEM_POOL_TYPE_TO_ITEM_POOL_NAME
+function getItemPoolJSON(self, itemPoolType)
+    local itemPoolName = ITEM_POOL_TYPE_TO_ITEM_POOL_NAME[itemPoolType]
+    local itemPoolsJSONArray = itemPoolsJSON.ItemPools.Pool
+    return __TS__ArrayFind(
+        itemPoolsJSONArray,
+        function(____, itemPoolJSON) return itemPoolJSON["$"].Name == itemPoolName end
+    )
+end
+____exports.ITEM_POOL_TYPE_TO_COLLECTIBLE_TYPES_SET = (function()
+    local itemPoolTypeToCollectibleTypes = {}
+    for ____, itemPoolType in ipairs(ITEM_POOL_TYPE_VALUES) do
+        local itemPoolJSON = getItemPoolJSON(nil, itemPoolType)
+        if itemPoolJSON == nil then
+            itemPoolTypeToCollectibleTypes[itemPoolType] = __TS__New(Set)
+        else
+            local collectibleTypesSet = __TS__New(Set)
+            for ____, itemPoolJSONElement in ipairs(itemPoolJSON.Item) do
+                local collectibleTypeNumber = tonumber(itemPoolJSONElement["$"].Id)
+                if collectibleTypeNumber == nil then
+                    error("Failed to parse a collectible type in the \"itempools.json\" file: " .. itemPoolJSONElement["$"].Id)
+                end
+                local collectibleType = asCollectibleType(nil, collectibleTypeNumber)
+                collectibleTypesSet:add(collectibleType)
+            end
+            itemPoolTypeToCollectibleTypes[itemPoolType] = collectibleTypesSet
+        end
+    end
+    return itemPoolTypeToCollectibleTypes
+end)(nil)
+return ____exports

package/dist/objects/kColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kColors.d.ts","sourceRoot":"","sources":["../../src/objects/kColors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;CAeX,CAAC"}

package/dist/objects/keyNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyNames.d.ts","sourceRoot":"","sources":["../../src/objects/keyNames.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAE1C,kCAAkC;AAClC,eAAO,MAAM,SAAS;;;;;;CAMyB,CAAC"}

package/dist/objects/languageNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageNames.d.ts","sourceRoot":"","sources":["../../src/objects/languageNames.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc;;;;;;;;CAQ8B,CAAC"}

package/dist/objects/levelNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levelNames.d.ts","sourceRoot":"","sources":["../../src/objects/levelNames.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkI0C,CAAC"}

package/dist/objects/oppositeDoorSlots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oppositeDoorSlots.d.ts","sourceRoot":"","sources":["../../src/objects/oppositeDoorSlots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAExD,eAAO,MAAM,mBAAmB;;;;;;;;;;CAU2B,CAAC"}

package/dist/objects/pillEffectClasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pillEffectClasses.d.ts","sourceRoot":"","sources":["../../src/objects/pillEffectClasses.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EAE1B,MAAM,8BAA8B,CAAC;AAEtC,eAAO,MAAM,yBAAyB,mCAAmC,CAAC;AAE1E,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDkC,CAAC"}

package/dist/objects/pillEffectNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pillEffectNames.d.ts","sourceRoot":"","sources":["../../src/objects/pillEffectNames.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAElD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDiB,CAAC"}

package/dist/objects/pillEffectTypeToPillEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pillEffectTypeToPillEffects.d.ts","sourceRoot":"","sources":["../../src/objects/pillEffectTypeToPillEffects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAM/D,eAAO,MAAM,gCAAgC;;;;;CAoB+B,CAAC"}

package/dist/objects/pillEffectTypeToPillEffects.lua

@@ -0,0 +1,27 @@
+local ____exports = {}
+local getPillEffectsOfType
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ItemConfigPillEffectType = ____isaac_2Dtypescript_2Ddefinitions.ItemConfigPillEffectType
+local ____constantsVanilla = require("core.constantsVanilla")
+local VANILLA_PILL_EFFECTS = ____constantsVanilla.VANILLA_PILL_EFFECTS
+local ____array = require("functions.array")
+local filterMap = ____array.filterMap
+local ____pillEffectTypes = require("objects.pillEffectTypes")
+local PILL_EFFECT_TYPES = ____pillEffectTypes.PILL_EFFECT_TYPES
+function getPillEffectsOfType(self, matchingPillEffectType)
+    return filterMap(
+        nil,
+        VANILLA_PILL_EFFECTS,
+        function(____, pillEffect)
+            local pillEffectType = PILL_EFFECT_TYPES[pillEffect]
+            return pillEffectType == matchingPillEffectType and pillEffect or nil
+        end
+    )
+end
+____exports.PILL_EFFECT_TYPE_TO_PILL_EFFECTS = {
+    [ItemConfigPillEffectType.POSITIVE] = getPillEffectsOfType(nil, ItemConfigPillEffectType.POSITIVE),
+    [ItemConfigPillEffectType.NEGATIVE] = getPillEffectsOfType(nil, ItemConfigPillEffectType.NEGATIVE),
+    [ItemConfigPillEffectType.NEUTRAL] = getPillEffectsOfType(nil, ItemConfigPillEffectType.NEUTRAL),
+    [ItemConfigPillEffectType.MODDED] = getPillEffectsOfType(nil, ItemConfigPillEffectType.MODDED)
+}
+return ____exports

package/dist/objects/pillEffectTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pillEffectTypes.d.ts","sourceRoot":"","sources":["../../src/objects/pillEffectTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAEzB,MAAM,8BAA8B,CAAC;AAEtC,eAAO,MAAM,wBAAwB,kCAAkC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDmC,CAAC"}

package/dist/objects/playerNamePNGFileNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playerNamePNGFileNames.d.ts","sourceRoot":"","sources":["../../src/objects/playerNamePNGFileNames.ts"],"names":[],"mappings":"AAIA,0DAA0D;AAC1D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDoB,CAAC"}

package/dist/objects/playerPortraitPNGFileNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playerPortraitPNGFileNames.d.ts","sourceRoot":"","sources":["../../src/objects/playerPortraitPNGFileNames.ts"],"names":[],"mappings":"AAIA,0DAA0D;AAC1D,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CgB,CAAC"}

package/dist/objects/roomShapeBounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeBounds.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeBounds.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;CA6C6B,CAAC"}

package/dist/objects/roomShapeBounds.lua

@@ -0,0 +1,26 @@
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local RoomShape = ____isaac_2Dtypescript_2Ddefinitions.RoomShape
+local ____roomShapeVolumes = require("objects.roomShapeVolumes")
+local NARROW_CONTENTS_HEIGHT = ____roomShapeVolumes.NARROW_CONTENTS_HEIGHT
+local NARROW_CONTENTS_WIDTH = ____roomShapeVolumes.NARROW_CONTENTS_WIDTH
+local ONE_BY_ONE_CONTENTS_HEIGHT = ____roomShapeVolumes.ONE_BY_ONE_CONTENTS_HEIGHT
+local ONE_BY_ONE_CONTENTS_WIDTH = ____roomShapeVolumes.ONE_BY_ONE_CONTENTS_WIDTH
+local TWO_BY_TWO_BOUNDS = {ONE_BY_ONE_CONTENTS_WIDTH * 2, ONE_BY_ONE_CONTENTS_HEIGHT * 2}
+--- The size of a room shape's contents. This does not include the tiles that the walls are on. L
+-- rooms use the same bounds as a 2x2 room.
+____exports.ROOM_SHAPE_BOUNDS = {
+    [RoomShape.SHAPE_1x1] = {ONE_BY_ONE_CONTENTS_WIDTH, ONE_BY_ONE_CONTENTS_HEIGHT},
+    [RoomShape.IH] = {ONE_BY_ONE_CONTENTS_WIDTH, NARROW_CONTENTS_HEIGHT},
+    [RoomShape.IV] = {NARROW_CONTENTS_WIDTH, ONE_BY_ONE_CONTENTS_HEIGHT},
+    [RoomShape.SHAPE_1x2] = {ONE_BY_ONE_CONTENTS_WIDTH, ONE_BY_ONE_CONTENTS_HEIGHT * 2},
+    [RoomShape.IIV] = {NARROW_CONTENTS_WIDTH, ONE_BY_ONE_CONTENTS_HEIGHT * 2},
+    [RoomShape.SHAPE_2x1] = {ONE_BY_ONE_CONTENTS_WIDTH * 2, ONE_BY_ONE_CONTENTS_HEIGHT},
+    [RoomShape.IIH] = {ONE_BY_ONE_CONTENTS_WIDTH * 2, NARROW_CONTENTS_HEIGHT},
+    [RoomShape.SHAPE_2x2] = TWO_BY_TWO_BOUNDS,
+    [RoomShape.LTL] = TWO_BY_TWO_BOUNDS,
+    [RoomShape.LTR] = TWO_BY_TWO_BOUNDS,
+    [RoomShape.LBL] = TWO_BY_TWO_BOUNDS,
+    [RoomShape.LBR] = TWO_BY_TWO_BOUNDS
+}
+return ____exports

package/dist/objects/roomShapeCorners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeCorners.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeCorners.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAIjD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwU0B,CAAC"}

package/dist/objects/roomShapeCorners.lua

@@ -0,0 +1,318 @@
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local RoomShape = ____isaac_2Dtypescript_2Ddefinitions.RoomShape
+local ____CornerType = require("enums.CornerType")
+local CornerType = ____CornerType.CornerType
+local ____readOnly = require("functions.readOnly")
+local newReadonlyVector = ____readOnly.newReadonlyVector
+--- The locations of the corners for each room shape.
+-- 
+-- Note that these corner locations are not accurate for the Mother Boss Room and the Home closet
+-- rooms. (Those rooms have custom shapes.)
+____exports.ROOM_SHAPE_CORNERS = {
+    [RoomShape.SHAPE_1x1] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 14,
+            position = newReadonlyVector(nil, 580, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 120,
+            position = newReadonlyVector(nil, 60, 420)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 134,
+            position = newReadonlyVector(nil, 580, 420)
+        }
+    },
+    [RoomShape.IH] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 30,
+            position = newReadonlyVector(nil, 60, 220)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 44,
+            position = newReadonlyVector(nil, 580, 220)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 90,
+            position = newReadonlyVector(nil, 60, 340)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 104,
+            position = newReadonlyVector(nil, 580, 340)
+        }
+    },
+    [RoomShape.IV] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 4,
+            position = newReadonlyVector(nil, 220, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 10,
+            position = newReadonlyVector(nil, 420, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 124,
+            position = newReadonlyVector(nil, 220, 420)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 130,
+            position = newReadonlyVector(nil, 420, 420)
+        }
+    },
+    [RoomShape.SHAPE_1x2] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 14,
+            position = newReadonlyVector(nil, 580, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 225,
+            position = newReadonlyVector(nil, 60, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 239,
+            position = newReadonlyVector(nil, 580, 700)
+        }
+    },
+    [RoomShape.IIV] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 4,
+            position = newReadonlyVector(nil, 220, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 10,
+            position = newReadonlyVector(nil, 420, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 229,
+            position = newReadonlyVector(nil, 220, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 235,
+            position = newReadonlyVector(nil, 420, 700)
+        }
+    },
+    [RoomShape.SHAPE_2x1] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 27,
+            position = newReadonlyVector(nil, 1100, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 224,
+            position = newReadonlyVector(nil, 60, 420)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 251,
+            position = newReadonlyVector(nil, 1100, 420)
+        }
+    },
+    [RoomShape.IIH] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 56,
+            position = newReadonlyVector(nil, 60, 220)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 83,
+            position = newReadonlyVector(nil, 1100, 220)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 168,
+            position = newReadonlyVector(nil, 60, 340)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 195,
+            position = newReadonlyVector(nil, 1100, 340)
+        }
+    },
+    [RoomShape.SHAPE_2x2] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 27,
+            position = newReadonlyVector(nil, 1100, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 420,
+            position = newReadonlyVector(nil, 60, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 447,
+            position = newReadonlyVector(nil, 1100, 700)
+        }
+    },
+    [RoomShape.LTL] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 13,
+            position = newReadonlyVector(nil, 580, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 27,
+            position = newReadonlyVector(nil, 1100, 140)
+        },
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 196,
+            position = newReadonlyVector(nil, 60, 420)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 209,
+            position = newReadonlyVector(nil, 580, 420)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 420,
+            position = newReadonlyVector(nil, 60, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 447,
+            position = newReadonlyVector(nil, 1100, 700)
+        }
+    },
+    [RoomShape.LTR] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 14,
+            position = newReadonlyVector(nil, 580, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 210,
+            position = newReadonlyVector(nil, 580, 420)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 223,
+            position = newReadonlyVector(nil, 1100, 420)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 420,
+            position = newReadonlyVector(nil, 60, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 447,
+            position = newReadonlyVector(nil, 1100, 700)
+        }
+    },
+    [RoomShape.LBL] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 27,
+            position = newReadonlyVector(nil, 1100, 140)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 224,
+            position = newReadonlyVector(nil, 580, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 237,
+            position = newReadonlyVector(nil, 580, 420)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 433,
+            position = newReadonlyVector(nil, 580, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 447,
+            position = newReadonlyVector(nil, 1100, 700)
+        }
+    },
+    [RoomShape.LBR] = {
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 0,
+            position = newReadonlyVector(nil, 60, 140)
+        },
+        {
+            type = CornerType.TOP_RIGHT,
+            gridIndex = 27,
+            position = newReadonlyVector(nil, 1100, 140)
+        },
+        {
+            type = CornerType.TOP_LEFT,
+            gridIndex = 238,
+            position = newReadonlyVector(nil, 580, 420)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 251,
+            position = newReadonlyVector(nil, 1100, 420)
+        },
+        {
+            type = CornerType.BOTTOM_LEFT,
+            gridIndex = 420,
+            position = newReadonlyVector(nil, 60, 700)
+        },
+        {
+            type = CornerType.BOTTOM_RIGHT,
+            gridIndex = 434,
+            position = newReadonlyVector(nil, 580, 700)
+        }
+    }
+}
+return ____exports

package/dist/objects/roomShapeLayoutSizes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeLayoutSizes.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeLayoutSizes.ts"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;CAauB,CAAC"}

package/dist/objects/roomShapeLayoutSizes.lua

@@ -0,0 +1,29 @@
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local RoomShape = ____isaac_2Dtypescript_2Ddefinitions.RoomShape
+local ____roomShapeVolumes = require("objects.roomShapeVolumes")
+local ONE_BY_ONE_CONTENTS_HEIGHT = ____roomShapeVolumes.ONE_BY_ONE_CONTENTS_HEIGHT
+local ONE_BY_ONE_CONTENTS_WIDTH = ____roomShapeVolumes.ONE_BY_ONE_CONTENTS_WIDTH
+local ONE_BY_ONE_LAYOUT_SIZE = {ONE_BY_ONE_CONTENTS_WIDTH, ONE_BY_ONE_CONTENTS_HEIGHT}
+local TWO_BY_ONE_VERTICAL_LAYOUT_SIZE = {ONE_BY_ONE_CONTENTS_WIDTH, ONE_BY_ONE_CONTENTS_HEIGHT * 2}
+local TWO_BY_ONE_HORIZONTAL_LAYOUT_SIZE = {ONE_BY_ONE_CONTENTS_WIDTH * 2, ONE_BY_ONE_CONTENTS_HEIGHT}
+local TWO_BY_TWO_LAYOUT_SIZE = {ONE_BY_ONE_CONTENTS_WIDTH * 2, ONE_BY_ONE_CONTENTS_HEIGHT * 2}
+--- The dimensions of a room shape's layout. This is NOT the size of the room's actual contents! For
+-- that, use `ROOM_SHAPE_BOUNDS`.
+-- 
+-- For example, a horizontal narrow room has a layout size of equal to that of a 1x1 room.
+____exports.ROOM_SHAPE_LAYOUT_SIZES = {
+    [RoomShape.SHAPE_1x1] = ONE_BY_ONE_LAYOUT_SIZE,
+    [RoomShape.IH] = ONE_BY_ONE_LAYOUT_SIZE,
+    [RoomShape.IV] = ONE_BY_ONE_LAYOUT_SIZE,
+    [RoomShape.SHAPE_1x2] = TWO_BY_ONE_VERTICAL_LAYOUT_SIZE,
+    [RoomShape.IIV] = TWO_BY_ONE_VERTICAL_LAYOUT_SIZE,
+    [RoomShape.SHAPE_2x1] = TWO_BY_ONE_HORIZONTAL_LAYOUT_SIZE,
+    [RoomShape.IIH] = TWO_BY_ONE_HORIZONTAL_LAYOUT_SIZE,
+    [RoomShape.SHAPE_2x2] = TWO_BY_TWO_LAYOUT_SIZE,
+    [RoomShape.LTL] = TWO_BY_TWO_LAYOUT_SIZE,
+    [RoomShape.LTR] = TWO_BY_TWO_LAYOUT_SIZE,
+    [RoomShape.LBL] = TWO_BY_TWO_LAYOUT_SIZE,
+    [RoomShape.LBR] = TWO_BY_TWO_LAYOUT_SIZE
+}
+return ____exports

package/dist/objects/roomShapeToBottomRightPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeToBottomRightPosition.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeToBottomRightPosition.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;CAaQ,CAAC"}

package/dist/objects/roomShapeToBottomRightPosition.lua

@@ -0,0 +1,24 @@
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local RoomShape = ____isaac_2Dtypescript_2Ddefinitions.RoomShape
+local ____readOnly = require("functions.readOnly")
+local newReadonlyVector = ____readOnly.newReadonlyVector
+local TWO_BY_TWO_BOTTOM_RIGHT_POSITION = newReadonlyVector(nil, 25, 13)
+local ONE_BY_TWO_VERTICAL_BOTTOM_RIGHT_POSITION = newReadonlyVector(nil, 12, 13)
+--- "Vector(0, 0)" corresponds to the top left tile of a room, not including the walls. (The top-left
+-- wall would be at "Vector(-1, -1)".)
+____exports.ROOM_SHAPE_TO_BOTTOM_RIGHT_POSITION = {
+    [RoomShape.SHAPE_1x1] = newReadonlyVector(nil, 12, 6),
+    [RoomShape.IH] = newReadonlyVector(nil, 12, 4),
+    [RoomShape.IV] = newReadonlyVector(nil, 8, 6),
+    [RoomShape.SHAPE_1x2] = ONE_BY_TWO_VERTICAL_BOTTOM_RIGHT_POSITION,
+    [RoomShape.IIV] = newReadonlyVector(nil, 8, 13),
+    [RoomShape.SHAPE_2x1] = newReadonlyVector(nil, 25, 6),
+    [RoomShape.IIH] = newReadonlyVector(nil, 25, 4),
+    [RoomShape.SHAPE_2x2] = TWO_BY_TWO_BOTTOM_RIGHT_POSITION,
+    [RoomShape.LTL] = TWO_BY_TWO_BOTTOM_RIGHT_POSITION,
+    [RoomShape.LTR] = TWO_BY_TWO_BOTTOM_RIGHT_POSITION,
+    [RoomShape.LBL] = TWO_BY_TWO_BOTTOM_RIGHT_POSITION,
+    [RoomShape.LBR] = ONE_BY_TWO_VERTICAL_BOTTOM_RIGHT_POSITION
+}
+return ____exports

package/dist/objects/roomShapeToDoorSlotCoordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeToDoorSlotCoordinates.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeToDoorSlotCoordinates.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmH/C,CAAC"}

package/dist/objects/roomShapeToDoorSlots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeToDoorSlots.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeToDoorSlots.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAa,MAAM,8BAA8B,CAAC;AAcnE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;CAmEwB,CAAC"}

package/dist/objects/roomShapeToDoorSlots.lua

@@ -0,0 +1,47 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local DoorSlot = ____isaac_2Dtypescript_2Ddefinitions.DoorSlot
+local RoomShape = ____isaac_2Dtypescript_2Ddefinitions.RoomShape
+local ____ReadonlySet = require("types.ReadonlySet")
+local ReadonlySet = ____ReadonlySet.ReadonlySet
+local ALL_DOOR_SLOTS_SET = __TS__New(ReadonlySet, {
+    DoorSlot.LEFT_0,
+    DoorSlot.UP_0,
+    DoorSlot.RIGHT_0,
+    DoorSlot.DOWN_0,
+    DoorSlot.LEFT_1,
+    DoorSlot.UP_1,
+    DoorSlot.RIGHT_1,
+    DoorSlot.DOWN_1
+})
+____exports.ROOM_SHAPE_TO_DOOR_SLOTS = {
+    [RoomShape.SHAPE_1x1] = __TS__New(ReadonlySet, {DoorSlot.LEFT_0, DoorSlot.UP_0, DoorSlot.RIGHT_0, DoorSlot.DOWN_0}),
+    [RoomShape.IH] = __TS__New(ReadonlySet, {DoorSlot.LEFT_0, DoorSlot.RIGHT_0}),
+    [RoomShape.IV] = __TS__New(ReadonlySet, {DoorSlot.UP_0, DoorSlot.DOWN_0}),
+    [RoomShape.SHAPE_1x2] = __TS__New(ReadonlySet, {
+        DoorSlot.LEFT_0,
+        DoorSlot.UP_0,
+        DoorSlot.RIGHT_0,
+        DoorSlot.DOWN_0,
+        DoorSlot.LEFT_1,
+        DoorSlot.RIGHT_1
+    }),
+    [RoomShape.IIV] = __TS__New(ReadonlySet, {DoorSlot.UP_0, DoorSlot.DOWN_0}),
+    [RoomShape.SHAPE_2x1] = __TS__New(ReadonlySet, {
+        DoorSlot.LEFT_0,
+        DoorSlot.UP_0,
+        DoorSlot.RIGHT_0,
+        DoorSlot.DOWN_0,
+        DoorSlot.UP_1,
+        DoorSlot.DOWN_1
+    }),
+    [RoomShape.IIH] = __TS__New(ReadonlySet, {DoorSlot.LEFT_0, DoorSlot.RIGHT_0}),
+    [RoomShape.SHAPE_2x2] = ALL_DOOR_SLOTS_SET,
+    [RoomShape.LTL] = ALL_DOOR_SLOTS_SET,
+    [RoomShape.LTR] = ALL_DOOR_SLOTS_SET,
+    [RoomShape.LBL] = ALL_DOOR_SLOTS_SET,
+    [RoomShape.LBR] = ALL_DOOR_SLOTS_SET
+}
+return ____exports

package/dist/objects/roomShapeToDoorSlotsToGridIndexDelta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roomShapeToDoorSlotsToGridIndexDelta.d.ts","sourceRoot":"","sources":["../../src/objects/roomShapeToDoorSlotsToGridIndexDelta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AASnE;;;GAGG;AAGH,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAiH9C,CAAC"}