warscript 0.0.1-dev.d30161d → 0.0.1-dev.d63794c

package/engine/internal/ability.lua

@@ -2,7 +2,6 @@ local ____lualib = require("lualib_bundle")
 local __TS__ArrayMap = ____lualib.__TS__ArrayMap
 local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
 local __TS__Class = ____lualib.__TS__Class
-local __TS__New = ____lualib.__TS__New
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
 local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
@@ -11,7 +10,9 @@ local ____exports = {}
 local ____handle = require("core.types.handle")
 local Handle = ____handle.Handle
 local ____ability = require("engine.internal.item.ability")
+local abilityActionDummy = ____ability.abilityActionDummy
 local doAbilityAction = ____ability.doAbilityAction
+local doAbilityActionForceDummy = ____ability.doAbilityActionForceDummy
 local getUnitAbilityLevel = GetUnitAbilityLevel
 local setUnitAbilityLevel = SetUnitAbilityLevel
 local setAbilityIntegerField = BlzSetAbilityIntegerField
@@ -33,7 +34,7 @@ local getAbilityStringLevelField = BlzGetAbilityStringLevelField
 local getUnitAbilityCooldownRemaining = BlzGetUnitAbilityCooldownRemaining
 local startUnitAbilityCooldown = BlzStartUnitAbilityCooldown
 local getHandleId = GetHandleId
-local getItemAbility = BlzGetItemAbility
+local unitHideAbility = BlzUnitHideAbility
 local match = string.match
 local ____type = _G.type
 local ____tostring = _G.tostring
@@ -151,55 +152,6 @@ local orders = postcompile(function()
     end
     return orders
 end)
-local RealFields = __TS__Class()
-RealFields.name = "RealFields"
-function RealFields.prototype.____constructor(self, handle)
-    self.handle = handle
-end
-function RealFields.prototype.set(self, field, value)
-    return BlzSetAbilityRealField(self.handle, field, value)
-end
-function RealFields.prototype.get(self, field)
-    return BlzGetAbilityRealField(self.handle, field)
-end
-function RealFields.prototype.has(self, field)
-    local handle = self.handle
-    return BlzSetAbilityRealField(
-        handle,
-        field,
-        BlzGetAbilityRealField(handle, field)
-    )
-end
-local RealLevelFields = __TS__Class()
-RealLevelFields.name = "RealLevelFields"
-function RealLevelFields.prototype.____constructor(self, handle, level)
-    self.handle = handle
-    self.level = level
-end
-function RealLevelFields.prototype.set(self, field, value)
-    return BlzSetAbilityRealLevelField(self.handle, field, self.level, value)
-end
-function RealLevelFields.prototype.get(self, field)
-    return BlzGetAbilityRealLevelField(self.handle, field, self.level)
-end
-function RealLevelFields.prototype.has(self, field)
-    local handle = self.handle
-    return BlzSetAbilityRealLevelField(
-        handle,
-        field,
-        0,
-        BlzGetAbilityRealLevelField(handle, field, 0)
-    )
-end
-local realLevelMetatable = {__index = self}
-local levelDescriptors = {realFields = function(self, handle, level)
-    return __TS__New(RealLevelFields, handle, level)
-end}
-local levelMetatable = {__index = function(self, key)
-    local fields = levelDescriptors[key](levelDescriptors, self.handle, self.level)
-    rawset(self, key, fields)
-    return fields
-end}
 local fieldGetters = {
     abilityintegerfield = function(ability, field)
         return getAbilityIntegerField(ability.handle, field)
@@ -346,43 +298,26 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Ability.prototype,
-    "orderId",
+    "orderTypeStringId",
     {get = function(self)
         local field = orderIdFieldByParentTypeId[self.parentTypeId]
-        return order2orderId(field ~= nil and getAbilityStringLevelField(self.handle, ABILITY_SLF_BASE_ORDER_ID_NCL6, self.level) or (orders[self.parentTypeId] or ""))
+        return field ~= nil and getAbilityStringLevelField(self.handle, field, self.level) or (orders[self.parentTypeId] or "")
     end},
     true
 )
 __TS__SetDescriptor(
     Ability.prototype,
-    "realFields",
+    "orderTypeId",
     {get = function(self)
-        local realFields = __TS__New(RealFields, self.handle)
-        rawset(self, "realFields", realFields)
-        return realFields
+        return order2orderId(self.orderTypeStringId)
     end},
     true
 )
 __TS__SetDescriptor(
     Ability.prototype,
-    "levels",
+    "levelCount",
     {get = function(self)
-        local handle = self.handle
-        local levels = setmetatable(
-            {},
-            {
-                __len = function(self)
-                    return BlzGetAbilityIntegerField(handle, ABILITY_IF_LEVELS)
-                end,
-                __index = function(self, i)
-                    local level = setmetatable({handle = handle, level = i - 1}, levelMetatable)
-                    self[i] = level
-                    return level
-                end
-            }
-        )
-        rawset(self, "levels", levels)
-        return levels
+        return self:getField(ABILITY_IF_LEVELS)
     end},
     true
 )
@@ -393,6 +328,17 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    Ability.prototype,
+    "cooldownRemaining",
+    {
+        get = function(self)
+        end,
+        set = function(self, cooldownRemaining)
+        end
+    },
+    true
+)
 __TS__ObjectDefineProperty(
     Ability,
     "onCreate",
@@ -416,6 +362,8 @@ function UnrecognizedAbility.prototype.____constructor(self, typeId, owner)
     UnrecognizedAbility.____super.prototype.____constructor(self, nil, typeId)
     self.owner = owner
 end
+function UnrecognizedAbility.prototype.interruptCast(self)
+end
 __TS__SetDescriptor(
     UnrecognizedAbility.prototype,
     "level",
@@ -424,6 +372,18 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    UnrecognizedAbility.prototype,
+    "cooldownRemaining",
+    {
+        get = function(self)
+            return 0
+        end,
+        set = function(self, _)
+        end
+    },
+    true
+)
 ____exports.UnitAbility = __TS__Class()
 local UnitAbility = ____exports.UnitAbility
 UnitAbility.name = "UnitAbility"
@@ -433,6 +393,15 @@ function UnitAbility.prototype.____constructor(self, handle, typeId, owner)
     self.owner = owner
     self.u = owner.handle
 end
+function UnitAbility.prototype.incrementHideCounter(self)
+    unitHideAbility(self.u, self.typeId, true)
+end
+function UnitAbility.prototype.decrementHideCounter(self)
+    unitHideAbility(self.u, self.typeId, false)
+end
+function UnitAbility.prototype.interruptCast(self)
+    self.owner:interruptCast(self.typeId)
+end
 __TS__SetDescriptor(
     UnitAbility.prototype,
     "level",
@@ -453,8 +422,8 @@ __TS__SetDescriptor(
         get = function(self)
             return getUnitAbilityCooldownRemaining(self.u, self.typeId)
         end,
-        set = function(self, v)
-            startUnitAbilityCooldown(self.u, self.typeId, v)
+        set = function(self, cooldownRemaining)
+            startUnitAbilityCooldown(self.u, self.typeId, cooldownRemaining)
         end
     },
     true
@@ -479,6 +448,14 @@ end
 local function setAbilityField(_, ability, field, levelOrValue, value)
     return ____exports.Ability.prototype.setField(ability, field, levelOrValue, value)
 end
+local function getAbilityCooldown(_, abilityTypeId)
+    return getUnitAbilityCooldownRemaining(abilityActionDummy, abilityTypeId)
+end
+local function startAbilityCooldown(_, abilityTypeId, cooldown)
+    startUnitAbilityCooldown(abilityActionDummy, abilityTypeId, cooldown)
+end
+local function doNothing()
+end
 ____exports.ItemAbility = __TS__Class()
 local ItemAbility = ____exports.ItemAbility
 ItemAbility.name = "ItemAbility"
@@ -506,6 +483,13 @@ function ItemAbility.prototype.setField(self, field, levelOrValue, value)
         value
     )
 end
+function ItemAbility.prototype.interruptCast(self)
+    local item = self.owner
+    local ____doAbilityActionForceDummy_4 = doAbilityActionForceDummy
+    local ____item_handle_3 = item.handle
+    local ____opt_1 = item.owner
+    ____doAbilityActionForceDummy_4(____item_handle_3, ____opt_1 and ____opt_1.handle, doNothing)
+end
 __TS__SetDescriptor(
     ItemAbility.prototype,
     "level",
@@ -514,6 +498,33 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    ItemAbility.prototype,
+    "cooldownRemaining",
+    {
+        get = function(self)
+            local item = self.owner
+            local ____doAbilityActionForceDummy_8 = doAbilityActionForceDummy
+            local ____item_handle_7 = item.handle
+            local ____opt_5 = item.owner
+            return ____doAbilityActionForceDummy_8(____item_handle_7, ____opt_5 and ____opt_5.handle, getAbilityCooldown, self.typeId)
+        end,
+        set = function(self, cooldownRemaining)
+            local item = self.owner
+            local ____doAbilityActionForceDummy_12 = doAbilityActionForceDummy
+            local ____item_handle_11 = item.handle
+            local ____opt_9 = item.owner
+            ____doAbilityActionForceDummy_12(
+                ____item_handle_11,
+                ____opt_9 and ____opt_9.handle,
+                startAbilityCooldown,
+                self.typeId,
+                cooldownRemaining
+            )
+        end
+    },
+    true
+)
 __TS__ObjectDefineProperty(
     ItemAbility,
     "onCreate",

package/engine/internal/item/ability.lua

@@ -3,6 +3,8 @@ local ____player = require("core.types.player")
 local Player = ____player.Player
 local ____dummy = require("objutil.dummy")
 local dummyUnitId = ____dummy.dummyUnitId
+local ____utility = require("engine.internal.utility")
+local findUnitItemSlot = ____utility.findUnitItemSlot
 local isItemOwned = IsItemOwned
 local isItemPowerup = IsItemPowerup
 local getItemX = GetItemX
@@ -10,6 +12,7 @@ local getItemY = GetItemY
 local setItemBooleanField = BlzSetItemBooleanField
 local setItemPosition = SetItemPosition
 local unitAddItem = UnitAddItem
+local unitDropItemSlot = UnitDropItemSlot
 local unitRemoveItem = UnitRemoveItem
 local dummy = assert(CreateUnit(
     Player.neutralVictim.handle,
@@ -21,6 +24,9 @@ local dummy = assert(CreateUnit(
 ShowUnit(dummy, false)
 ---
 -- @internal For use by internal systems only.
+____exports.abilityActionDummy = dummy
+---
+-- @internal For use by internal systems only.
 ____exports.doAbilityAction = function(handle, action, ...)
     local isOwned = isItemOwned(handle)
     local isPowerup
@@ -45,4 +51,30 @@ ____exports.doAbilityAction = function(handle, action, ...)
     end
     return result
 end
+---
+-- @internal For use by internal systems only.
+____exports.doAbilityActionForceDummy = function(handle, owner, action, ...)
+    if owner == nil then
+        return ____exports.doAbilityAction(handle, action, ...)
+    end
+    local slot = findUnitItemSlot(owner, handle)
+    if slot == nil then
+        return ____exports.doAbilityAction(handle, action, ...)
+    end
+    local isPowerup
+    if isItemPowerup(handle) then
+        setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        isPowerup = true
+    end
+    unitRemoveItem(owner, handle)
+    unitAddItem(dummy, handle)
+    local result = action(handle, ...)
+    unitRemoveItem(dummy, handle)
+    unitAddItem(owner, handle)
+    unitDropItemSlot(owner, handle, slot)
+    if isPowerup then
+        setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+    end
+    return result
+end
 return ____exports

package/engine/internal/item+owner.lua

@@ -6,10 +6,10 @@ local Item = ____item.Item
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ownerByItem = setmetatable({}, {__mode = "kv"})
-Unit.onItemPickup:addListener(function(unit, item)
+Unit.itemPickedUpEvent:addListener(function(unit, item)
     ownerByItem[item] = unit
 end)
-Unit.onItemDrop:addListener(function(unit, item)
+Unit.itemDroppedEvent:addListener(function(unit, item)
     ownerByItem[item] = nil
 end)
 __TS__ObjectDefineProperty(

package/engine/internal/misc/ability-disable-counter.d.ts

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

package/engine/internal/misc/ability-disable-counter.lua

@@ -0,0 +1,13 @@
+local ____exports = {}
+local disableAbility = BlzUnitDisableAbility
+---
+-- @internal For use by internal systems only.
+____exports.increaseAbilityDisableCounter = function(unit, abilityTypeId, times)
+    for _ = 1, times do
+        disableAbility(unit, abilityTypeId, true, false)
+    end
+    for _ = times, -1 do
+        disableAbility(unit, abilityTypeId, false, false)
+    end
+end
+return ____exports

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

@@ -3,7 +3,7 @@ import { Ability } from "../ability";
 import { Destructable } from "../../../core/types/destructable";
 import { Item } from "../item";
 import { Widget } from "../../../core/types/widget";
-import { DispatchingEvent } from "../../../event";
+import { DispatchingEvent, Event } from "../../../event";
 declare module "../unit" {
     namespace Unit {
         const abilityCastingStartEvent: DispatchingEvent<[Unit, Ability]>;
@@ -141,3 +141,12 @@ declare module "../unit" {
         const abilityStopEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
+declare module "../unit" {
+    namespace Unit {
+        const abilityCommandEvent: {
+            readonly [abilityTypeId: number]: {
+                readonly [orderTypeStringId: string]: Event<[Unit, Ability, string]>;
+            };
+        };
+    }
+}

package/engine/internal/unit/ability.lua

@@ -15,8 +15,15 @@ local UnitTriggerEvent = ____unit.UnitTriggerEvent
 local ____event = require("event")
 local createDispatchingEvent = ____event.createDispatchingEvent
 local DependentInitializingEvent = ____event.DependentInitializingEvent
+local Event = ____event.Event
+local InitializingEvent = ____event.InitializingEvent
 local ____preconditions = require("utility.preconditions")
 local checkNotNull = ____preconditions.checkNotNull
+local ____lazy = require("utility.lazy")
+local lazyRecord = ____lazy.lazyRecord
+local eventInvoke = Event.invoke
+local condition = Condition
+local createTrigger = CreateTrigger
 local getItemAbility = BlzGetItemAbility
 local getSpellAbility = GetSpellAbility
 local getSpellAbilityId = GetSpellAbilityId
@@ -26,11 +33,10 @@ local getSpellTargetUnit = GetSpellTargetUnit
 local getSpellTargetX = GetSpellTargetX
 local getSpellTargetY = GetSpellTargetY
 local getTriggerUnit = GetTriggerUnit
-local getUnitAbility = BlzGetUnitAbility
-local unitAddAbility = UnitAddAbility
+local triggerAddCondition = TriggerAddCondition
+local triggerRegisterCommandEvent = TriggerRegisterCommandEvent
 local unitInventorySize = UnitInventorySize
 local unitItemInSlot = UnitItemInSlot
-local unitRemoveAbility = UnitRemoveAbility
 local function retrieveAbility(unit, ability, abilityId)
     if ability == nil then
         return __TS__New(
@@ -39,17 +45,6 @@ local function retrieveAbility(unit, ability, abilityId)
             Unit:of(unit)
         )
     end
-    if not unitAddAbility(unit, abilityId) then
-        if getUnitAbility(unit, abilityId) == ability then
-            return UnitAbility:of(
-                ability,
-                abilityId,
-                Unit:of(unit)
-            )
-        end
-    else
-        unitRemoveAbility(unit, abilityId)
-    end
     for i = 0, unitInventorySize(unit) - 1 do
         local item = unitItemInSlot(unit, i)
         if getItemAbility(item, abilityId) == ability then
@@ -366,4 +361,31 @@ rawset(
         extractAbilityTypeId
     )
 )
+rawset(
+    Unit,
+    "abilityCommandEvent",
+    lazyRecord(function(abilityTypeId)
+        return lazyRecord(function(orderTypeStringId)
+            return __TS__New(
+                InitializingEvent,
+                function(event)
+                    local trigger = createTrigger()
+                    triggerRegisterCommandEvent(trigger, abilityTypeId, orderTypeStringId)
+                    triggerAddCondition(
+                        trigger,
+                        condition(function()
+                            local unit = Unit:of(getTriggerUnit())
+                            if unit ~= nil then
+                                local ability = unit:getAbilityById(abilityTypeId)
+                                if ability ~= nil then
+                                    eventInvoke(event, unit, ability, orderTypeStringId)
+                                end
+                            end
+                        end)
+                    )
+                end
+            )
+        end)
+    end)
+)
 return ____exports

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

@@ -8,7 +8,8 @@ export type UnitBonusId<Brand extends string = any> = number & {
 export type UnitArmorBonusId = UnitBonusId<"armor">;
 export type UnitAttackSpeedFactorBonusId = UnitBonusId<"attackSpeedFactor">;
 export type UnitMovementSpeedFactorBonusId = UnitBonusId<"movementSpeedFactor">;
-export type UnitDamageBonusId = UnitBonusId<"damage">;
+export type UnitAutoAttackDamageBonusId = UnitBonusId<"autoAttackDamage">;
+export type UnitDamageFactorBonusId = UnitBonusId<"damageFactor">;
 export type UnitReceivedDamageFactorBonusId = UnitBonusId<"receivedDamageFactor">;
 export type UnitBonusType<Id extends UnitBonusId = UnitBonusId> = ({
     abilityTypeId: AbilityTypeId;
@@ -30,7 +31,8 @@ export declare namespace UnitBonusType {
     const ARMOR: UnitBonusType<UnitArmorBonusId>;
     const ATTACK_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
     const MOVEMENT_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
-    const DAMAGE: UnitBonusType<UnitDamageBonusId>;
+    const AUTO_ATTACK_DAMAGE: UnitBonusType<UnitAutoAttackDamageBonusId>;
+    const DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
     const RECEIVED_DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
 }
 export declare const addUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, value: number) => Id;

package/engine/internal/unit/bonus.lua

@@ -21,6 +21,7 @@ local AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID = ____auto_2Dattack_2Dda
 local ____movement_2Dspeed_2Dincrease_2Dfactor = require("engine.internal.object-data.movement-speed-increase-factor")
 local MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD
 local MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID
+local damageFactorByUnit = {}
 local receivedDamageFactorByUnit = {}
 ____exports.UnitBonusType = {}
 local UnitBonusType = ____exports.UnitBonusType
@@ -46,13 +47,14 @@ do
         reduce = sum,
         initialValue = 0
     }
-    UnitBonusType.DAMAGE = {
+    UnitBonusType.AUTO_ATTACK_DAMAGE = {
         abilityTypeId = AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID,
         field = AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD,
         integer = false,
         reduce = sum,
         initialValue = 0
     }
+    UnitBonusType.DAMAGE_FACTOR = {reduce = product, valueByUnit = damageFactorByUnit, initialValue = 1}
     UnitBonusType.RECEIVED_DAMAGE_FACTOR = {reduce = product, valueByUnit = receivedDamageFactorByUnit, initialValue = 1}
 end
 local bonusesByUnitByBonusType = {}
@@ -180,6 +182,9 @@ end
 Unit.onDamage:addListener(
     4,
     function(source, target, event)
+        if source ~= nil and damageFactorByUnit[source] ~= nil then
+            event.amount = event.amount * damageFactorByUnit[source]
+        end
         if receivedDamageFactorByUnit[target] ~= nil then
             event.amount = event.amount * receivedDamageFactorByUnit[target]
         end

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

@@ -0,0 +1,24 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+export interface UnitItems extends ReadonlyArray<Item | undefined> {
+    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;
+}
+export declare class UnitItems {
+    constructor(handle: junit);
+    findSlot(item: Item): 0 | 1 | 2 | 3 | 4 | 5 | undefined;
+    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 items: UnitItems;
+    }
+}

package/engine/internal/unit/item.lua

@@ -0,0 +1,79 @@
+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 rawset = _G.rawset
+local ____type = _G.type
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local unitAddItem = UnitAddItem
+local unitDropItemSlot = UnitDropItemSlot
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local unitRemoveItemFromSlot = UnitRemoveItemFromSlot
+local handleByUnitItems = setmetatable({}, {__mode = "k"})
+local function unitItemsNext(handle, index)
+    local slot = index & 7
+    if index >> 3 == slot then
+        return nil, nil
+    end
+    return index + 1, Item:of(unitItemInSlot(handle, slot))
+end
+____exports.UnitItems = __TS__Class()
+local UnitItems = ____exports.UnitItems
+UnitItems.name = "UnitItems"
+function UnitItems.prototype.____constructor(self, handle)
+    handleByUnitItems[self] = handle
+end
+function UnitItems.prototype.findSlot(self, item)
+    return findUnitItemSlot(handleByUnitItems[self], item.handle)
+end
+function UnitItems.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitItems[self]
+    if slot < 1 or slot > unitInventorySize(handle) then
+        return
+    end
+    unitRemoveItemFromSlot(handle, slot - 1)
+    if item ~= nil then
+        local itemHandle = item.handle
+        local isPowerup = isItemPowerup(itemHandle)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        end
+        unitAddItem(handle, itemHandle)
+        unitDropItemSlot(handle, itemHandle, slot - 1)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+end
+function UnitItems.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInSlot(handleByUnitItems[self], key - 1))
+    end
+    return rawget(____exports.UnitItems.prototype, key)
+end
+function UnitItems.prototype.__len(self)
+    return unitInventorySize(handleByUnitItems[self])
+end
+function UnitItems.prototype.__ipairs(self)
+    local handle = handleByUnitItems[self]
+    return unitItemsNext, handle, unitInventorySize(handle) << 3
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "items",
+    {get = function(self)
+        local items = __TS__New(____exports.UnitItems, self.handle)
+        rawset(self, "items", items)
+        return items
+    end}
+)
+return ____exports

package/engine/internal/unit/main-selected.d.ts

@@ -0,0 +1,13 @@
+/** @noSelfInFile */
+import { Player } from "../../../core/types/player";
+import { Event } from "../../../event";
+declare module "../unit" {
+    namespace Unit {
+        const mainSelectedUnitChangeEvent: Event<[Player]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const getMainSelectedOf: (player: Player) => Unit | undefined;
+    }
+}

package/engine/internal/unit/main-selected.lua

@@ -0,0 +1,51 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local MINIMUM_INTEGER = ____math.MINIMUM_INTEGER
+local ____local_2Dclient = require("engine.local-client")
+local LocalClient = ____local_2Dclient.LocalClient
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____event = require("event")
+local Event = ____event.Event
+local mainSelectedUnitChangeEvent = __TS__New(Event)
+rawset(Unit, "mainSelectedUnitChangeEvent", mainSelectedUnitChangeEvent)
+local mainSelectedUnitByPlayer = {}
+local syncSlider = BlzCreateFrameByType(
+    "SLIDER",
+    "UnitSyncId",
+    BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0),
+    "",
+    0
+)
+BlzFrameSetMinMaxValue(syncSlider, MINIMUM_INTEGER, MAXIMUM_INTEGER)
+LocalClient.mainSelectedUnitChangeEvent:addListener(function()
+    local ____opt_0 = LocalClient.mainSelectedUnit
+    local syncId = ____opt_0 and ____opt_0.syncId
+    BlzFrameSetValue(syncSlider, syncId or 0)
+end)
+local trg = CreateTrigger()
+BlzTriggerRegisterFrameEvent(trg, syncSlider, FRAMEEVENT_SLIDER_VALUE_CHANGED)
+TriggerAddAction(
+    trg,
+    function()
+        local player = Player:of(GetTriggerPlayer())
+        local mainSelectedUnit = Unit:getBySyncId(BlzGetTriggerFrameValue())
+        if mainSelectedUnit ~= mainSelectedUnitByPlayer[player] then
+            mainSelectedUnitByPlayer[player] = mainSelectedUnit
+            Event.invoke(mainSelectedUnitChangeEvent, player)
+        end
+    end
+)
+rawset(
+    Unit,
+    "getMainSelectedOf",
+    function(player)
+        return mainSelectedUnitByPlayer[player]
+    end
+)
+return ____exports