warscript 0.0.1-dev.8bfb72f → 0.0.1-dev.8d8d605

package/engine/internal/unit/buff.lua

@@ -1,7 +1,3 @@
-local ____lualib = require("lualib_bundle")
-local __TS__SparseArrayNew = ____lualib.__TS__SparseArrayNew
-local __TS__SparseArrayPush = ____lualib.__TS__SparseArrayPush
-local __TS__SparseArraySpread = ____lualib.__TS__SparseArraySpread
 local ____exports = {}
 local ____buff = require("engine.buff")
 local checkBuff = ____buff.checkBuff
@@ -19,7 +15,7 @@ Unit.prototype.hasBuff = function(self, buffTypeId)
 end
 Unit.prototype.removeBuff = function(self, buffTypeId)
     if removeBuff(self.handle, buffTypeId) then
-        checkBuff(self, buffTypeId)
+        checkBuff(self, buffTypeId, false)
         return true
     end
     return false
@@ -46,36 +42,55 @@ Unit.prototype.countBuffs = function(self, polarity, resistanceType, includeExpi
     )
 end
 Unit.prototype.removeBuffs = function(self, polarityOrBuffTypeIds, resistanceType, includeExpirationTimers, includeAuras, autoDispel)
+    local handle = self.handle
+    local cnt
     if type(polarityOrBuffTypeIds) == "table" then
-        local handle = self.handle
+        cnt = 0
         for i = 1, #polarityOrBuffTypeIds do
-            unitRemoveAbility(handle, polarityOrBuffTypeIds[i])
+            cnt = cnt + (unitRemoveAbility(handle, polarityOrBuffTypeIds[i]) and 1 or 0)
         end
     else
-        local ____array_3 = __TS__SparseArrayNew(
-            self.handle,
-            (polarityOrBuffTypeIds or 3) & 1 ~= 0,
-            (polarityOrBuffTypeIds or 3) & 2 ~= 0,
-            (resistanceType or 0) & 1 ~= 0,
-            (resistanceType or 0) & 2 ~= 0
-        )
+        local positive = (polarityOrBuffTypeIds or 3) & 1 ~= 0
+        local negative = (polarityOrBuffTypeIds or 3) & 2 ~= 0
+        local magic = (resistanceType or 0) & 1 ~= 0
+        local physical = (resistanceType or 0) & 2 ~= 0
         local ____includeExpirationTimers_0 = includeExpirationTimers
         if ____includeExpirationTimers_0 == nil then
             ____includeExpirationTimers_0 = true
         end
-        __TS__SparseArrayPush(____array_3, ____includeExpirationTimers_0)
+        includeExpirationTimers = ____includeExpirationTimers_0
         local ____includeAuras_1 = includeAuras
         if ____includeAuras_1 == nil then
             ____includeAuras_1 = true
         end
-        __TS__SparseArrayPush(____array_3, ____includeAuras_1)
+        includeAuras = ____includeAuras_1
         local ____autoDispel_2 = autoDispel
         if ____autoDispel_2 == nil then
             ____autoDispel_2 = false
         end
-        __TS__SparseArrayPush(____array_3, ____autoDispel_2)
-        unitRemoveBuffsEx(__TS__SparseArraySpread(____array_3))
+        autoDispel = ____autoDispel_2
+        cnt = unitCountBuffsEx(
+            handle,
+            positive,
+            negative,
+            magic,
+            physical,
+            includeExpirationTimers,
+            includeAuras,
+            autoDispel
+        )
+        unitRemoveBuffsEx(
+            handle,
+            positive,
+            negative,
+            magic,
+            physical,
+            includeExpirationTimers,
+            includeAuras,
+            autoDispel
+        )
     end
-    checkBuffs(self)
+    checkBuffs(self, false)
+    return cnt
 end
 return ____exports

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

@@ -0,0 +1,36 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+import { EquipmentSlot } from "../../object-data/auxiliary/equipment-slot";
+import { EquipmentType } from "../../object-data/auxiliary/equipment-type";
+export interface UnitEquipment extends ReadonlyArray<Item | undefined> {
+}
+/** A live view indexed by EquipmentSlot. Equip operations let the engine choose the slot. */
+export declare class UnitEquipment {
+    constructor(handle: junit);
+    equip(item: Item): boolean;
+    unequip(item: Item): void;
+    unequipSlot(slot: EquipmentSlot): Item | undefined;
+    has(item: Item): boolean;
+    hasAny(): boolean;
+    isSlotEmpty(slot: EquipmentSlot): boolean;
+    hasType(type: EquipmentType): boolean;
+    canEquipType(type: EquipmentType): boolean;
+    findSlot(item: Item): EquipmentSlot | undefined;
+    protected __index(key: string | number): unknown;
+    protected __len(): number;
+    protected __ipairs(): LuaIterator<LuaMultiReturn<[number, Item | undefined]>, junit>;
+}
+declare module "../unit" {
+    interface Unit {
+        readonly equipment: UnitEquipment;
+    }
+    namespace Unit {
+        const itemEquippedEvent: UnitTriggerEvent<[item: Item]>;
+        const itemUnequippedEvent: UnitTriggerEvent<[item: Item]>;
+        let itemStackedEvent: UnitTriggerEvent<[
+            target: Item,
+            source: Item,
+            previousTargetCharges: number
+        ]>;
+    }
+}

package/engine/internal/unit/equipment.lua

@@ -0,0 +1,169 @@
+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 ignoreEventsItems = ____ignore_2Devents_2Ditems.ignoreEventsItems
+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 unitUnequipItem = UnitUnequipItem
+local unitUnequipItemFromSlot = UnitUnequipItemFromSlot
+local ____rawget = _G.rawget
+local rawset = _G.rawset
+local ____type = _G.type
+local EQUIPMENT_SLOT_COUNT = bj_MAX_EQUIPMENT_INVENTORY
+local handleByUnitEquipment = setmetatable({}, {__mode = "k"})
+local function unitEquipmentNext(handle, slot)
+    if slot >= EQUIPMENT_SLOT_COUNT then
+        return nil, nil
+    end
+    return slot + 1, Item:of(unitItemInEquipmentSlot(
+        handle,
+        convertLoadoutSlot(slot)
+    ))
+end
+--- A live view indexed by EquipmentSlot. Equip operations let the engine choose the slot.
+____exports.UnitEquipment = __TS__Class()
+local UnitEquipment = ____exports.UnitEquipment
+UnitEquipment.name = "UnitEquipment"
+function UnitEquipment.prototype.____constructor(self, handle)
+    handleByUnitEquipment[self] = handle
+end
+function UnitEquipment.prototype.equip(self, item)
+    return unitEquipItem(handleByUnitEquipment[self], item.handle)
+end
+function UnitEquipment.prototype.unequip(self, item)
+    unitUnequipItem(handleByUnitEquipment[self], item.handle)
+end
+function UnitEquipment.prototype.unequipSlot(self, slot)
+    return Item:of(unitUnequipItemFromSlot(
+        handleByUnitEquipment[self],
+        convertLoadoutSlot(slot)
+    ))
+end
+function UnitEquipment.prototype.has(self, item)
+    return unitHasItemEquipped(handleByUnitEquipment[self], item.handle)
+end
+function UnitEquipment.prototype.hasAny(self)
+    return unitHasAnyItemEquiped(handleByUnitEquipment[self])
+end
+function UnitEquipment.prototype.isSlotEmpty(self, slot)
+    return unitHasLoadoutSlotEmpty(
+        handleByUnitEquipment[self],
+        convertLoadoutSlot(slot)
+    )
+end
+function UnitEquipment.prototype.hasType(self, ____type)
+    return unitHasItemEquipmentOfType(
+        handleByUnitEquipment[self],
+        convertEquipmentType(____type)
+    )
+end
+function UnitEquipment.prototype.canEquipType(self, ____type)
+    return unitCanEquipItemOfEquipmentType(
+        handleByUnitEquipment[self],
+        convertEquipmentType(____type)
+    )
+end
+function UnitEquipment.prototype.findSlot(self, item)
+    local handle = handleByUnitEquipment[self]
+    for slot = 0, EQUIPMENT_SLOT_COUNT - 1 do
+        if unitItemInEquipmentSlot(
+            handle,
+            convertLoadoutSlot(slot)
+        ) == item.handle then
+            return slot
+        end
+    end
+    return nil
+end
+function UnitEquipment.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInEquipmentSlot(
+            handleByUnitEquipment[self],
+            convertLoadoutSlot(key - 1)
+        ))
+    end
+    return ____rawget(____exports.UnitEquipment.prototype, key)
+end
+function UnitEquipment.prototype.__len(self)
+    return EQUIPMENT_SLOT_COUNT
+end
+function UnitEquipment.prototype.__ipairs(self)
+    return unitEquipmentNext, handleByUnitEquipment[self], 0
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "equipment",
+    {get = function(self)
+        local equipment = __TS__New(____exports.UnitEquipment, self.handle)
+        rawset(self, "equipment", equipment)
+        return equipment
+    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 (ignoreEventsItems[item] ~= nil) 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 (ignoreEventsItems[item] ~= nil) then
+                return Unit:of(unit), Item:of(item)
+            end
+            return IgnoreEvent
+        end
+    )
+)
+rawset(
+    Unit,
+    "itemStackedEvent",
+    __TS__New(
+        UnitTriggerEvent,
+        EVENT_PLAYER_UNIT_STACK_ITEM,
+        function() return Unit:of(getTriggerUnit()), Item:of(getStackingItemTarget()), Item:of(getStackingItemSource()), getStackingItemTargetPreviousCharges() 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/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/{item.d.ts → inventory.d.ts}

@@ -1,6 +1,6 @@
 /** @noSelfInFile */
 import { Item } from "../item";
-export interface UnitItems extends ReadonlyArray<Item | undefined> {
+export interface UnitInventory extends ReadonlyArray<Item | undefined> {
     readonly length: 0 | 1 | 2 | 3 | 4 | 5 | 6;
     [0]: Item | undefined;
     [1]: Item | undefined;
@@ -9,7 +9,7 @@ export interface UnitItems extends ReadonlyArray<Item | undefined> {
     [4]: Item | undefined;
     [5]: Item | undefined;
 }
-export declare class UnitItems {
+export declare class UnitInventory {
     constructor(handle: junit);
     findSlot(item: Item): 0 | 1 | 2 | 3 | 4 | 5 | undefined;
     protected __newindex(slot: number, item: Item | undefined): void;
@@ -19,6 +19,6 @@ export declare class UnitItems {
 }
 declare module "../unit" {
     interface Unit {
-        readonly items: UnitItems;
+        readonly inventory: UnitInventory;
     }
 }

package/engine/internal/unit/{item.lua → inventory.lua}

@@ -18,25 +18,24 @@ local setItemBooleanField = BlzSetItemBooleanField
 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
+local handleByUnitInventory = setmetatable({}, {__mode = "k"})
+local function unitInventoryNext(handle, slot)
+    if slot >= unitInventorySize(handle) then
         return nil, nil
     end
-    return index + 1, Item:of(unitItemInSlot(handle, slot))
+    return slot + 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
+____exports.UnitInventory = __TS__Class()
+local UnitInventory = ____exports.UnitInventory
+UnitInventory.name = "UnitInventory"
+function UnitInventory.prototype.____constructor(self, handle)
+    handleByUnitInventory[self] = handle
 end
-function UnitItems.prototype.findSlot(self, item)
-    return findUnitItemSlot(handleByUnitItems[self], item.handle)
+function UnitInventory.prototype.findSlot(self, item)
+    return findUnitItemSlot(handleByUnitInventory[self], item.handle)
 end
-function UnitItems.prototype.__newindex(self, slot, item)
-    local handle = handleByUnitItems[self]
+function UnitInventory.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitInventory[self]
     if slot < 1 or slot > unitInventorySize(handle) then
         return
     end
@@ -53,26 +52,26 @@ function UnitItems.prototype.__newindex(self, slot, item)
         end
     end
 end
-function UnitItems.prototype.__index(self, key)
+function UnitInventory.prototype.__index(self, key)
     if ____type(key) == "number" then
-        return Item:of(unitItemInSlot(handleByUnitItems[self], key - 1))
+        return Item:of(unitItemInSlot(handleByUnitInventory[self], key - 1))
     end
-    return rawget(____exports.UnitItems.prototype, key)
+    return rawget(____exports.UnitInventory.prototype, key)
 end
-function UnitItems.prototype.__len(self)
-    return unitInventorySize(handleByUnitItems[self])
+function UnitInventory.prototype.__len(self)
+    return unitInventorySize(handleByUnitInventory[self])
 end
-function UnitItems.prototype.__ipairs(self)
-    local handle = handleByUnitItems[self]
-    return unitItemsNext, handle, unitInventorySize(handle) << 3
+function UnitInventory.prototype.__ipairs(self)
+    local handle = handleByUnitInventory[self]
+    return unitInventoryNext, handle, 0
 end
 __TS__ObjectDefineProperty(
     Unit.prototype,
-    "items",
+    "inventory",
     {get = function(self)
-        local items = __TS__New(____exports.UnitItems, self.handle)
-        rawset(self, "items", items)
-        return items
+        local inventory = __TS__New(____exports.UnitInventory, self.handle)
+        rawset(self, "inventory", inventory)
+        return inventory
     end}
 )
 return ____exports

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

@@ -1,46 +1,31 @@
 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 ____synchronization = require("engine.synchronization")
+local ObjectBus = ____synchronization.ObjectBus
 local mainSelectedUnitChangeEvent = __TS__New(Event)
 rawset(Unit, "mainSelectedUnitChangeEvent", mainSelectedUnitChangeEvent)
 local mainSelectedUnitByPlayer = {}
-local syncSlider = BlzCreateFrameByType(
-    "SLIDER",
-    "UnitSyncId",
-    BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0),
-    "",
-    0
+local unitBus = __TS__New(
+    ObjectBus,
+    function(unit) return unit.syncId end,
+    function(syncId) return Unit:getBySyncId(syncId) end
 )
-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)
+    unitBus:send(LocalClient.mainSelectedUnit)
 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
+unitBus.event:addListener(function(player, unit)
+    if unit ~= mainSelectedUnitByPlayer[player] then
+        mainSelectedUnitByPlayer[player] = unit
+        Event.invoke(mainSelectedUnitChangeEvent, player)
     end
-)
+end)
 rawset(
     Unit,
     "getMainSelectedOf",

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

@@ -0,0 +1,20 @@
+/** @noSelfInFile */
+import { Widget } from "../../../core/types/widget";
+export declare const enum OrderType {
+    IMMEDIATE = 0,
+    POINT = 1,
+    TARGET = 2
+}
+declare module "../unit" {
+    interface Unit {
+        readonly currentOrderType: OrderType;
+        readonly currentOrderId: number;
+        readonly currentOrderStartTime: number;
+        readonly currentOrderStartX: number;
+        readonly currentOrderStartY: number;
+        readonly currentOrderTargetX: number;
+        readonly currentOrderTargetY: number;
+        readonly currentOrderTarget?: Widget;
+        issueOrder(...order: [orderType: OrderType.IMMEDIATE, orderId: number] | [orderType: OrderType.POINT, orderId: number, x: number, y: number] | [orderType: OrderType.TARGET, orderId: number, target: Widget]): boolean;
+    }
+}