warscript 0.0.1-dev.bb34489 → 0.0.1-dev.bc4cd10

package/engine/internal/unit/equipment-inventory.lua

@@ -0,0 +1,233 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local UnitTriggerEvent = ____unit.UnitTriggerEvent
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____event = require("event")
+local IgnoreEvent = ____event.IgnoreEvent
+local ____dummy = require("objutil.dummy")
+local dummyUnitId = ____dummy.dummyUnitId
+local ____ignore_2Devents_2Ditems = require("engine.internal.unit.ignore-events-items")
+local ignoreEventsItemTypeIds = ____ignore_2Devents_2Ditems.ignoreEventsItemTypeIds
+local isItemIgnoredInEvents = ____ignore_2Devents_2Ditems.isItemIgnoredInEvents
+local ____blank = require("engine.object-data.entry.item-type.blank")
+local BlankItemType = ____blank.BlankItemType
+local convertEquipmentType = ConvertEquipmentType
+local convertLoadoutSlot = ConvertLoadoutSlot
+local getEquippedItem = GetEquippedItem
+local getStackingItemSource = BlzGetStackingItemSource
+local getStackingItemTarget = BlzGetStackingItemTarget
+local getStackingItemTargetPreviousCharges = BlzGetStackingItemTargetPreviousCharges
+local getTriggerUnit = GetTriggerUnit
+local getUnequippedItem = GetUnequippedItem
+local getUnitTypeId = GetUnitTypeId
+local unitCanEquipItemOfEquipmentType = UnitCanEquipItemOfEquipmentType
+local unitEquipItem = UnitEquipItem
+local unitHasAnyItemEquiped = UnitHasAnyItemEquiped
+local unitHasItemEquipmentOfType = UnitHasItemEquipmentOfType
+local unitHasItemEquipped = UnitHasItemEquipped
+local unitHasLoadoutSlotEmpty = UnitHasLoadoutSlotEmpty
+local unitItemInEquipmentSlot = UnitItemInEquipmentSlot
+local setItemVisible = SetItemVisible
+local unitAddItem = UnitAddItem
+local unitRemoveItem = UnitRemoveItem
+local unitUnequipItem = UnitUnequipItem
+local unitUnequipItemFromSlot = UnitUnequipItemFromSlot
+local ____rawget = _G.rawget
+local rawset = _G.rawset
+local ____type = _G.type
+local EQUIPMENT_INVENTORY_SLOT_COUNT = bj_MAX_EQUIPMENT_INVENTORY
+---
+-- @internal For use by internal systems only.
+____exports.RING_FILLER_ITEM_TYPE_ID = compiletime(function()
+    local itemType = BlankItemType:create()
+    itemType.name = "[Warscript/Dummy] Ring Filler"
+    itemType.itemClass = "Equipment"
+    itemType.equipmentType = 5
+    return itemType.id
+end)
+ignoreEventsItemTypeIds[____exports.RING_FILLER_ITEM_TYPE_ID] = true
+--- Occupies the RING slot while a ring is being equipped into ALTERNATE_RING, since the engine fills the
+-- RING slot first.
+local ringFillerItem = (function()
+    local item = CreateItem(____exports.RING_FILLER_ITEM_TYPE_ID, 0, 0)
+    setItemVisible(item, false)
+    return item
+end)()
+--- Equips an item the unit may not be carrying yet; the engine picks the slot.
+local function unitEquip(unit, item)
+    return unitEquipItem(unit, item) or unitAddItem(unit, item) and unitEquipItem(unit, item)
+end
+local handleByUnitEquipmentInventory = setmetatable({}, {__mode = "k"})
+local function unitEquipmentInventoryNext(handle, slot)
+    if slot >= EQUIPMENT_INVENTORY_SLOT_COUNT then
+        return nil, nil
+    end
+    return slot + 1, Item:of(unitItemInEquipmentSlot(
+        handle,
+        convertLoadoutSlot(slot)
+    ))
+end
+--- A live view of a unit's equipment inventory, indexed by {@link EquipmentSlot}.
+-- 
+-- Equipment slots are typed, so the engine picks the slot itself when equipping: slot assignment frees
+-- the requested slot and then equips the item. The only type with two slots is the ring; equipping into
+-- ALTERNATE_RING temporarily occupies RING with a filler ring, mirroring the regular inventory's approach.
+____exports.UnitEquipmentInventory = __TS__Class()
+local UnitEquipmentInventory = ____exports.UnitEquipmentInventory
+UnitEquipmentInventory.name = "UnitEquipmentInventory"
+function UnitEquipmentInventory.prototype.____constructor(self, handle)
+    handleByUnitEquipmentInventory[self] = handle
+end
+function UnitEquipmentInventory.prototype.equip(self, item)
+    return unitEquipItem(handleByUnitEquipmentInventory[self], item.handle)
+end
+function UnitEquipmentInventory.prototype.unequip(self, item)
+    unitUnequipItem(handleByUnitEquipmentInventory[self], item.handle)
+end
+function UnitEquipmentInventory.prototype.unequipSlot(self, slot)
+    return Item:of(unitUnequipItemFromSlot(
+        handleByUnitEquipmentInventory[self],
+        convertLoadoutSlot(slot)
+    ))
+end
+function UnitEquipmentInventory.prototype.has(self, item)
+    return unitHasItemEquipped(handleByUnitEquipmentInventory[self], item.handle)
+end
+function UnitEquipmentInventory.prototype.hasAny(self)
+    return unitHasAnyItemEquiped(handleByUnitEquipmentInventory[self])
+end
+function UnitEquipmentInventory.prototype.isSlotEmpty(self, slot)
+    return unitHasLoadoutSlotEmpty(
+        handleByUnitEquipmentInventory[self],
+        convertLoadoutSlot(slot)
+    )
+end
+function UnitEquipmentInventory.prototype.hasType(self, ____type)
+    return unitHasItemEquipmentOfType(
+        handleByUnitEquipmentInventory[self],
+        convertEquipmentType(____type)
+    )
+end
+function UnitEquipmentInventory.prototype.canEquipType(self, ____type)
+    return unitCanEquipItemOfEquipmentType(
+        handleByUnitEquipmentInventory[self],
+        convertEquipmentType(____type)
+    )
+end
+function UnitEquipmentInventory.prototype.findSlot(self, item)
+    local handle = handleByUnitEquipmentInventory[self]
+    for slot = 0, EQUIPMENT_INVENTORY_SLOT_COUNT - 1 do
+        if unitItemInEquipmentSlot(
+            handle,
+            convertLoadoutSlot(slot)
+        ) == item.handle then
+            return slot
+        end
+    end
+    return nil
+end
+function UnitEquipmentInventory.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitEquipmentInventory[self]
+    if slot < 1 or slot > EQUIPMENT_INVENTORY_SLOT_COUNT then
+        return
+    end
+    local loadoutSlot = convertLoadoutSlot(slot - 1)
+    local previousItem = unitItemInEquipmentSlot(handle, loadoutSlot)
+    if previousItem ~= nil and previousItem ~= (item and item.handle) then
+        unitUnequipItemFromSlot(handle, loadoutSlot)
+        unitRemoveItem(handle, previousItem)
+    end
+    if item ~= nil then
+        local itemHandle = item.handle
+        local ringLoadoutSlot = convertLoadoutSlot(4)
+        if slot - 1 == 5 and unitHasLoadoutSlotEmpty(handle, ringLoadoutSlot) then
+            unitEquip(handle, ringFillerItem)
+            unitEquip(handle, itemHandle)
+            unitUnequipItemFromSlot(handle, ringLoadoutSlot)
+            unitRemoveItem(handle, ringFillerItem)
+            setItemVisible(ringFillerItem, false)
+        else
+            unitEquip(handle, itemHandle)
+        end
+    end
+end
+function UnitEquipmentInventory.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInEquipmentSlot(
+            handleByUnitEquipmentInventory[self],
+            convertLoadoutSlot(key - 1)
+        ))
+    end
+    return ____rawget(____exports.UnitEquipmentInventory.prototype, key)
+end
+function UnitEquipmentInventory.prototype.__len(self)
+    return EQUIPMENT_INVENTORY_SLOT_COUNT
+end
+function UnitEquipmentInventory.prototype.__ipairs(self)
+    return unitEquipmentInventoryNext, handleByUnitEquipmentInventory[self], 0
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "equipmentInventory",
+    {get = function(self)
+        local equipmentInventory = __TS__New(____exports.UnitEquipmentInventory, self.handle)
+        rawset(self, "equipmentInventory", equipmentInventory)
+        return equipmentInventory
+    end}
+)
+rawset(
+    Unit,
+    "itemEquippedEvent",
+    __TS__New(
+        UnitTriggerEvent,
+        EVENT_PLAYER_UNIT_EQUIP_ITEM,
+        function()
+            local unit = getTriggerUnit()
+            local item = getEquippedItem()
+            if getUnitTypeId(unit) ~= dummyUnitId and not isItemIgnoredInEvents(item) then
+                return Unit:of(unit), Item:of(item)
+            end
+            return IgnoreEvent
+        end
+    )
+)
+rawset(
+    Unit,
+    "itemUnequippedEvent",
+    __TS__New(
+        UnitTriggerEvent,
+        EVENT_PLAYER_UNIT_UNEQUIP_ITEM,
+        function()
+            local unit = getTriggerUnit()
+            local item = getUnequippedItem()
+            if getUnitTypeId(unit) ~= dummyUnitId and not isItemIgnoredInEvents(item) then
+                return Unit:of(unit), Item:of(item)
+            end
+            return IgnoreEvent
+        end
+    )
+)
+rawset(
+    Unit,
+    "itemStackedEvent",
+    __TS__New(
+        UnitTriggerEvent,
+        EVENT_PLAYER_UNIT_STACK_ITEM,
+        function()
+            local unit = getTriggerUnit()
+            local target = getStackingItemTarget()
+            local source = getStackingItemSource()
+            if getUnitTypeId(unit) ~= dummyUnitId and not isItemIgnoredInEvents(target) and not isItemIgnoredInEvents(source) then
+                return Unit:of(unit), Item:of(target), Item:of(source), getStackingItemTargetPreviousCharges()
+            end
+            return IgnoreEvent
+        end
+    )
+)
+return ____exports

package/engine/internal/unit/expiration-timer.lua

@@ -29,7 +29,7 @@ Unit.prototype.removeExpirationTimer = function(self)
     cancelTimedLife(handle)
     setWidgetLife(handle, life)
 end
-Unit.onImmediateOrder[orderId("phoenixmorph")]:addListener(
+Unit.onImmediateOrder[852482]:addListener(
     4,
     function(unit)
         unitRemoveAbility(unit.handle, dummyPhoenixMorphAbilityTypeId)

package/engine/internal/unit/extended-inventory.d.ts

@@ -0,0 +1,25 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+import type { UnitItemContainer } from "./item-container";
+export interface UnitExtendedInventory extends UnitItemContainer {
+}
+/**
+ * A live, zero-based view of a unit's extended inventory.
+ *
+ * Slot assignment works like the regular inventory's, see {@link unitAddItemToSlot}.
+ */
+export declare class UnitExtendedInventory {
+    constructor(handle: junit);
+    has(item: Item): boolean;
+    findSlot(item: Item): number | undefined;
+    isSlotEmpty(slot: number): boolean;
+    protected __newindex(slot: number, item: Item | undefined): void;
+    protected __index(key: string | number): unknown;
+    protected __len(): number;
+    protected __ipairs(): LuaIterator<LuaMultiReturn<[number, Item | undefined]>, junit>;
+}
+declare module "../unit" {
+    interface Unit {
+        readonly extendedInventory: UnitExtendedInventory;
+    }
+}

package/engine/internal/unit/extended-inventory.lua

@@ -0,0 +1,99 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____item_2Dcontainer = require("engine.internal.unit.item-container")
+local unitOwnsItem = ____item_2Dcontainer.unitOwnsItem
+local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slot")
+local unitAddItemToSlot = ____add_2Ditem_2Dto_2Dslot.unitAddItemToSlot
+local unitExtendedInventorySize = UnitExtendedInventorySize
+local unitHasItemBagged = UnitHasItemBagged
+local unitItemInBagSlot = UnitItemInBagSlot
+local unitRemoveItem = UnitRemoveItem
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local ____rawget = _G.rawget
+local rawset = _G.rawset
+local ____type = _G.type
+local handleByUnitExtendedInventory = setmetatable({}, {__mode = "k"})
+local function unitExtendedInventoryNext(handle, slot)
+    if slot >= unitExtendedInventorySize(handle) then
+        return nil, nil
+    end
+    return slot + 1, Item:of(unitItemInBagSlot(handle, slot))
+end
+--- A live, zero-based view of a unit's extended inventory.
+-- 
+-- Slot assignment works like the regular inventory's, see {@link unitAddItemToSlot}.
+____exports.UnitExtendedInventory = __TS__Class()
+local UnitExtendedInventory = ____exports.UnitExtendedInventory
+UnitExtendedInventory.name = "UnitExtendedInventory"
+function UnitExtendedInventory.prototype.____constructor(self, handle)
+    handleByUnitExtendedInventory[self] = handle
+end
+function UnitExtendedInventory.prototype.has(self, item)
+    return unitHasItemBagged(handleByUnitExtendedInventory[self], item.handle)
+end
+function UnitExtendedInventory.prototype.findSlot(self, item)
+    local handle = handleByUnitExtendedInventory[self]
+    for slot = 0, unitExtendedInventorySize(handle) - 1 do
+        if unitItemInBagSlot(handle, slot) == item.handle then
+            return slot
+        end
+    end
+    return nil
+end
+function UnitExtendedInventory.prototype.isSlotEmpty(self, slot)
+    return unitItemInBagSlot(handleByUnitExtendedInventory[self], slot) == nil
+end
+function UnitExtendedInventory.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitExtendedInventory[self]
+    if slot < 1 or slot > unitExtendedInventorySize(handle) then
+        return
+    end
+    local previousItem = unitItemInBagSlot(handle, slot - 1)
+    if previousItem ~= nil and previousItem ~= (item and item.handle) then
+        unitRemoveItem(handle, previousItem)
+    end
+    if item ~= nil then
+        local itemHandle = item.handle
+        if unitOwnsItem(handle, itemHandle) then
+            unitRemoveItem(handle, itemHandle)
+        end
+        local isPowerup = isItemPowerup(itemHandle)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        end
+        unitAddItemToSlot(handle, itemHandle, slot - 1, 1)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+end
+function UnitExtendedInventory.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInBagSlot(handleByUnitExtendedInventory[self], key - 1))
+    end
+    return ____rawget(____exports.UnitExtendedInventory.prototype, key)
+end
+function UnitExtendedInventory.prototype.__len(self)
+    return unitExtendedInventorySize(handleByUnitExtendedInventory[self])
+end
+function UnitExtendedInventory.prototype.__ipairs(self)
+    return unitExtendedInventoryNext, handleByUnitExtendedInventory[self], 0
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "extendedInventory",
+    {get = function(self)
+        local extendedInventory = __TS__New(____exports.UnitExtendedInventory, self.handle)
+        rawset(self, "extendedInventory", extendedInventory)
+        return extendedInventory
+    end}
+)
+return ____exports

package/engine/internal/unit/fly-height.d.ts

@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+declare module "../unit" {
+    interface Unit {
+        flyHeight: number;
+    }
+}
+export {};

package/engine/internal/unit/fly-height.lua

@@ -0,0 +1,20 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____unit = require("engine.standard.fields.unit")
+local FLY_HEIGHT_UNIT_FIELD = ____unit.FLY_HEIGHT_UNIT_FIELD
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "flyHeight",
+    {
+        get = function(self)
+            return FLY_HEIGHT_UNIT_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            FLY_HEIGHT_UNIT_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports

package/engine/internal/unit/ignore-events-items.d.ts

@@ -0,0 +1,2 @@
+/** @noSelfInFile */
+export {};

package/engine/internal/unit/ignore-events-items.lua

@@ -0,0 +1,14 @@
+local ____exports = {}
+local getItemTypeId = GetItemTypeId
+--- Items that are temporarily excluded from item events (e.g. while an internal system juggles them).
+-- 
+-- @internal For use by internal systems only.
+____exports.ignoreEventsItems = {}
+--- Item types that are always excluded from item events (technical items such as slot fillers).
+-- 
+-- @internal For use by internal systems only.
+____exports.ignoreEventsItemTypeIds = {}
+---
+-- @internal For use by internal systems only.
+____exports.isItemIgnoredInEvents = function(item) return item ~= nil and (____exports.ignoreEventsItems[item] ~= nil or ____exports.ignoreEventsItemTypeIds[getItemTypeId(item)] ~= nil) end
+return ____exports

package/engine/internal/unit/interrupts.d.ts

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+declare module "../unit" {
+    interface Unit {
+        interruptAttack(this: Unit): void;
+    }
+}
+declare module "../unit" {
+    interface Unit {
+        interruptMovement(this: Unit): void;
+    }
+}
+export {};

package/engine/internal/unit/interrupts.lua

@@ -0,0 +1,28 @@
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____unit_2Dmissile_2Dlaunch = require("engine.internal.unit-missile-launch")
+local resetAutoAttackTimer = ____unit_2Dmissile_2Dlaunch.resetAutoAttackTimer
+local unitDisableAbility = BlzUnitDisableAbility
+local unitInterruptAttack = BlzUnitInterruptAttack
+Unit.prototype.interruptAttack = function(self)
+    unitInterruptAttack(self.handle)
+    resetAutoAttackTimer(self)
+end
+Unit.prototype.interruptMovement = function(self)
+    local handle = self.handle
+    unitDisableAbility(
+        handle,
+        fourCC("Amov"),
+        true,
+        false
+    )
+    unitDisableAbility(
+        handle,
+        fourCC("Amov"),
+        false,
+        false
+    )
+    resetAutoAttackTimer(self)
+end
+return ____exports

package/engine/internal/unit/inventory.d.ts

@@ -0,0 +1,28 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+import type { UnitItemContainer } from "./item-container";
+export interface UnitInventory extends UnitItemContainer {
+    readonly length: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    [0]: Item | undefined;
+    [1]: Item | undefined;
+    [2]: Item | undefined;
+    [3]: Item | undefined;
+    [4]: Item | undefined;
+    [5]: Item | undefined;
+}
+/** A live, zero-based view of a unit's (regular) inventory. */
+export declare class UnitInventory {
+    constructor(handle: junit);
+    has(item: Item): boolean;
+    findSlot(item: Item): 0 | 1 | 2 | 3 | 4 | 5 | undefined;
+    isSlotEmpty(slot: 0 | 1 | 2 | 3 | 4 | 5): boolean;
+    protected __newindex(slot: number, item: Item | undefined): void;
+    protected __index(key: string | number): unknown;
+    protected __len(): number;
+    protected __ipairs(): LuaIterator<LuaMultiReturn<[number, Item | undefined]>, junit>;
+}
+declare module "../unit" {
+    interface Unit {
+        readonly inventory: UnitInventory;
+    }
+}

package/engine/internal/unit/inventory.lua

@@ -0,0 +1,87 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____utility = require("engine.internal.utility")
+local findUnitItemSlot = ____utility.findUnitItemSlot
+local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slot")
+local unitAddItemToSlot = ____add_2Ditem_2Dto_2Dslot.unitAddItemToSlot
+local rawset = _G.rawset
+local ____type = _G.type
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local unitHasItem = UnitHasItem
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local unitRemoveItem = UnitRemoveItem
+local unitRemoveItemFromSlot = UnitRemoveItemFromSlot
+local handleByUnitInventory = setmetatable({}, {__mode = "k"})
+local function unitInventoryNext(handle, slot)
+    if slot >= unitInventorySize(handle) then
+        return nil, nil
+    end
+    return slot + 1, Item:of(unitItemInSlot(handle, slot))
+end
+--- A live, zero-based view of a unit's (regular) inventory.
+____exports.UnitInventory = __TS__Class()
+local UnitInventory = ____exports.UnitInventory
+UnitInventory.name = "UnitInventory"
+function UnitInventory.prototype.____constructor(self, handle)
+    handleByUnitInventory[self] = handle
+end
+function UnitInventory.prototype.has(self, item)
+    return unitHasItem(handleByUnitInventory[self], item.handle)
+end
+function UnitInventory.prototype.findSlot(self, item)
+    return findUnitItemSlot(handleByUnitInventory[self], item.handle)
+end
+function UnitInventory.prototype.isSlotEmpty(self, slot)
+    return unitItemInSlot(handleByUnitInventory[self], slot) == nil
+end
+function UnitInventory.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitInventory[self]
+    if slot < 1 or slot > unitInventorySize(handle) then
+        return
+    end
+    unitRemoveItemFromSlot(handle, slot - 1)
+    if item ~= nil then
+        local itemHandle = item.handle
+        unitRemoveItem(handle, itemHandle)
+        local isPowerup = isItemPowerup(itemHandle)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        end
+        unitAddItemToSlot(handle, itemHandle, slot - 1)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+end
+function UnitInventory.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInSlot(handleByUnitInventory[self], key - 1))
+    end
+    return rawget(____exports.UnitInventory.prototype, key)
+end
+function UnitInventory.prototype.__len(self)
+    return unitInventorySize(handleByUnitInventory[self])
+end
+function UnitInventory.prototype.__ipairs(self)
+    local handle = handleByUnitInventory[self]
+    return unitInventoryNext, handle, 0
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "inventory",
+    {get = function(self)
+        local inventory = __TS__New(____exports.UnitInventory, self.handle)
+        rawset(self, "inventory", inventory)
+        return inventory
+    end}
+)
+return ____exports

package/engine/internal/unit/item-container.d.ts

@@ -0,0 +1,25 @@
+/** @noSelfInFile */
+import type { Item } from "../item";
+/** Which of a unit's item containers a slot belongs to. */
+export declare const enum UnitItemContainerType {
+    INVENTORY = 0,
+    EXTENDED_INVENTORY = 1,
+    EQUIPMENT_INVENTORY = 2
+}
+export declare const UNIT_INVENTORY_SLOT_COUNT = 6;
+export declare const UNIT_EXTENDED_INVENTORY_SLOT_COUNT = 30;
+export declare const UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT: number;
+/**
+ * The API shared by all live views of a unit's item containers: {@link UnitInventory},
+ * {@link UnitExtendedInventory} and {@link UnitEquipmentInventory}.
+ *
+ * Slots are zero-based. Reading `container[slot]` returns the item in the slot, if any; assigning
+ * `container[slot] = item` drops whatever the slot held and places the item there (picking it up from
+ * wherever it is first), and assigning `undefined` just drops the slot's item.
+ */
+export interface UnitItemContainer extends ReadonlyArray<Item | undefined> {
+    readonly length: number;
+    has(item: Item): boolean;
+    findSlot(item: Item): number | undefined;
+    isSlotEmpty(slot: number): boolean;
+}

package/engine/internal/unit/item-container.lua

@@ -0,0 +1,11 @@
+local ____exports = {}
+local unitHasItem = UnitHasItem
+local unitHasItemBagged = UnitHasItemBagged
+local unitHasItemEquipped = UnitHasItemEquipped
+____exports.UNIT_INVENTORY_SLOT_COUNT = 6
+____exports.UNIT_EXTENDED_INVENTORY_SLOT_COUNT = 30
+____exports.UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT = bj_MAX_EQUIPMENT_INVENTORY
+---
+-- @internal For use by internal systems only.
+____exports.unitOwnsItem = function(unitHandle, itemHandle) return unitHasItem(unitHandle, itemHandle) or unitHasItemBagged(unitHandle, itemHandle) or unitHasItemEquipped(unitHandle, itemHandle) end
+return ____exports

package/engine/internal/unit/item-order-events.d.ts

@@ -0,0 +1,17 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+import { Event } from "../../../event";
+import { UnitItemSlot } from "./item-slot";
+declare module "../unit" {
+    namespace Unit {
+        /** A unit was ordered to use the item in a slot of any of its item containers. */
+        const itemUseOrderEvent: Event<[unit: Unit, item: Item]>;
+        /** A unit was ordered to move an item between slots of its item containers. */
+        const itemMoveOrderEvent: Event<[
+            unit: Unit,
+            item: Item,
+            slotFrom: UnitItemSlot,
+            slotTo: UnitItemSlot
+        ]>;
+    }
+}