warscript 0.0.1-dev.aefeacb → 0.0.1-dev.b1ce140

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.lua

@@ -1,5 +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/{item.d.ts → inventory.d.ts}

@@ -1,6 +1,7 @@
 /** @noSelfInFile */
 import { Item } from "../item";
-export interface UnitItems extends ReadonlyArray<Item | undefined> {
+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;
@@ -9,9 +10,12 @@ export interface UnitItems extends ReadonlyArray<Item | undefined> {
     [4]: Item | undefined;
     [5]: Item | undefined;
 }
-export declare class UnitItems {
+/** 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;
@@ -19,6 +23,6 @@ export declare class UnitItems {
 }
 declare module "../unit" {
     interface Unit {
-        readonly items: UnitItems;
+        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
+        ]>;
+    }
+}

package/engine/internal/unit/item-order-events.lua

@@ -0,0 +1,67 @@
+local ____lualib = require("lualib_bundle")
+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 ____event = require("event")
+local Event = ____event.Event
+local ____item_2Dslot = require("engine.internal.unit.item-slot")
+local UnitItemSlot = ____item_2Dslot.UnitItemSlot
+local invoke = Event.invoke
+__TS__ObjectDefineProperty(
+    Unit,
+    "itemUseOrderEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        local function addListeners(firstOrderType, lastOrderType, containerType)
+            for orderType = firstOrderType, lastOrderType do
+                local slot = UnitItemSlot:get(containerType, orderType - firstOrderType)
+                local function listener(unit)
+                    local item = slot:getItem(unit)
+                    if item ~= nil then
+                        invoke(event, unit, item)
+                    end
+                end
+                Unit.onImmediateOrder[orderType]:addListener(listener)
+                Unit.onTargetOrder[orderType]:addListener(listener)
+                Unit.onPointOrder[orderType]:addListener(listener)
+            end
+        end
+        addListeners(852008, 852013, 0)
+        addListeners(852771, 852800, 1)
+        addListeners(852801, 852809, 2)
+        rawset(Unit, "itemUseOrderEvent", event)
+        return event
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "itemMoveOrderEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        local function addListeners(firstOrderType, lastOrderType, containerType)
+            for orderType = firstOrderType, lastOrderType do
+                local slotTo = UnitItemSlot:get(containerType, orderType - firstOrderType)
+                Unit.onTargetOrder[orderType]:addListener(function(unit, item)
+                    local slotFrom = UnitItemSlot:find(unit, item)
+                    if slotFrom ~= nil then
+                        invoke(
+                            event,
+                            unit,
+                            item,
+                            slotFrom,
+                            slotTo
+                        )
+                    end
+                end)
+            end
+        end
+        addListeners(852002, 852007, 0)
+        addListeners(852714, 852743, 1)
+        addListeners(852744, 852752, 2)
+        rawset(Unit, "itemMoveOrderEvent", event)
+        return event
+    end}
+)
+return ____exports

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

@@ -0,0 +1,27 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+import { Unit } from "../unit";
+import { EquipmentSlot } from "../../object-data/auxiliary/equipment-slot";
+import { UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT, UNIT_EXTENDED_INVENTORY_SLOT_COUNT, UNIT_INVENTORY_SLOT_COUNT, UnitItemContainerType } from "./item-container";
+export { UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT, UNIT_EXTENDED_INVENTORY_SLOT_COUNT, UNIT_INVENTORY_SLOT_COUNT, UnitItemContainerType, };
+/**
+ * A slot of one of a unit's item containers (the inventory, the extended inventory or the equipment inventory).
+ *
+ * There is exactly one instance per (container type, index) pair, so slots can be compared by identity.
+ */
+export declare class UnitItemSlot {
+    readonly containerType: UnitItemContainerType;
+    readonly index: number;
+    private static readonly inventorySlots;
+    private static readonly extendedInventorySlots;
+    private static readonly equipmentInventorySlots;
+    private constructor();
+    static inventory(index: 0 | 1 | 2 | 3 | 4 | 5): UnitItemSlot;
+    static extendedInventory(index: number): UnitItemSlot;
+    static equipmentInventory(slot: EquipmentSlot): UnitItemSlot;
+    static get(containerType: UnitItemContainerType, index: number): UnitItemSlot;
+    /** Returns the slot the item currently occupies in the unit's inventory, extended inventory or equipment inventory, if any. */
+    static find(unit: Readonly<Unit>, item: Item): UnitItemSlot | undefined;
+    getItem(unit: Readonly<Unit>): Item | undefined;
+    private static readonly slotsByContainerType;
+}

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

@@ -0,0 +1,92 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local itemInSlotByContainerType
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____item_2Dcontainer = require("engine.internal.unit.item-container")
+local UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT = ____item_2Dcontainer.UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT
+local UNIT_EXTENDED_INVENTORY_SLOT_COUNT = ____item_2Dcontainer.UNIT_EXTENDED_INVENTORY_SLOT_COUNT
+local UNIT_INVENTORY_SLOT_COUNT = ____item_2Dcontainer.UNIT_INVENTORY_SLOT_COUNT
+____exports.UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT = UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT
+____exports.UNIT_EXTENDED_INVENTORY_SLOT_COUNT = UNIT_EXTENDED_INVENTORY_SLOT_COUNT
+____exports.UNIT_INVENTORY_SLOT_COUNT = UNIT_INVENTORY_SLOT_COUNT
+local convertLoadoutSlot = ConvertLoadoutSlot
+local unitExtendedInventorySize = UnitExtendedInventorySize
+local unitInventorySize = UnitInventorySize
+local unitItemInBagSlot = UnitItemInBagSlot
+local unitItemInEquipmentSlot = UnitItemInEquipmentSlot
+local unitItemInSlot = UnitItemInSlot
+--- A slot of one of a unit's item containers (the inventory, the extended inventory or the equipment inventory).
+-- 
+-- There is exactly one instance per (container type, index) pair, so slots can be compared by identity.
+____exports.UnitItemSlot = __TS__Class()
+local UnitItemSlot = ____exports.UnitItemSlot
+UnitItemSlot.name = "UnitItemSlot"
+function UnitItemSlot.prototype.____constructor(self, containerType, index)
+    self.containerType = containerType
+    self.index = index
+end
+function UnitItemSlot.inventory(self, index)
+    return ____exports.UnitItemSlot.inventorySlots[index + 1]
+end
+function UnitItemSlot.extendedInventory(self, index)
+    return ____exports.UnitItemSlot.extendedInventorySlots[index + 1]
+end
+function UnitItemSlot.equipmentInventory(self, slot)
+    return ____exports.UnitItemSlot.equipmentInventorySlots[slot + 1]
+end
+function UnitItemSlot.get(self, containerType, index)
+    return ____exports.UnitItemSlot.slotsByContainerType[containerType][index + 1]
+end
+function UnitItemSlot.find(self, unit, item)
+    local unitHandle = unit.handle
+    local itemHandle = item.handle
+    for index = 0, unitInventorySize(unitHandle) - 1 do
+        if unitItemInSlot(unitHandle, index) == itemHandle then
+            return ____exports.UnitItemSlot.inventorySlots[index + 1]
+        end
+    end
+    for index = 0, unitExtendedInventorySize(unitHandle) - 1 do
+        if unitItemInBagSlot(unitHandle, index) == itemHandle then
+            return ____exports.UnitItemSlot.extendedInventorySlots[index + 1]
+        end
+    end
+    for index = 0, UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT - 1 do
+        if unitItemInEquipmentSlot(
+            unitHandle,
+            convertLoadoutSlot(index)
+        ) == itemHandle then
+            return ____exports.UnitItemSlot.equipmentInventorySlots[index + 1]
+        end
+    end
+    return nil
+end
+function UnitItemSlot.prototype.getItem(self, unit)
+    return Item:of(itemInSlotByContainerType[self.containerType](unit.handle, self.index))
+end
+UnitItemSlot.inventorySlots = {}
+UnitItemSlot.extendedInventorySlots = {}
+UnitItemSlot.equipmentInventorySlots = {};
+(function(self)
+    for index = 0, UNIT_INVENTORY_SLOT_COUNT - 1 do
+        ____exports.UnitItemSlot.inventorySlots[index + 1] = __TS__New(____exports.UnitItemSlot, 0, index)
+    end
+    for index = 0, UNIT_EXTENDED_INVENTORY_SLOT_COUNT - 1 do
+        ____exports.UnitItemSlot.extendedInventorySlots[index + 1] = __TS__New(____exports.UnitItemSlot, 1, index)
+    end
+    for index = 0, UNIT_EQUIPMENT_INVENTORY_SLOT_COUNT - 1 do
+        ____exports.UnitItemSlot.equipmentInventorySlots[index + 1] = __TS__New(____exports.UnitItemSlot, 2, index)
+    end
+end)(UnitItemSlot)
+UnitItemSlot.slotsByContainerType = {[0] = ____exports.UnitItemSlot.inventorySlots, [1] = ____exports.UnitItemSlot.extendedInventorySlots, [2] = ____exports.UnitItemSlot.equipmentInventorySlots}
+itemInSlotByContainerType = {
+    [0] = unitItemInSlot,
+    [1] = unitItemInBagSlot,
+    [2] = function(unitHandle, index) return unitItemInEquipmentSlot(
+        unitHandle,
+        convertLoadoutSlot(index)
+    ) 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 OrderKind {
+    IMMEDIATE = 0,
+    POINT = 1,
+    TARGET = 2
+}
+declare module "../unit" {
+    interface Unit {
+        readonly currentOrderKind: OrderKind;
+        readonly currentOrderId: number;
+        readonly currentOrderStartTime: number;
+        readonly currentOrderStartX: number;
+        readonly currentOrderStartY: number;
+        readonly currentOrderTargetX: number;
+        readonly currentOrderTargetY: number;
+        readonly currentOrderTarget?: Widget;
+        issueOrder(...order: [orderType: OrderKind.IMMEDIATE, orderId: number] | [orderType: OrderKind.POINT, orderId: number, x: number, y: number] | [orderType: OrderKind.TARGET, orderId: number, target: Widget]): boolean;
+    }
+}

package/engine/internal/unit/order.lua

@@ -0,0 +1,136 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____attributes = require("attributes")
+local attribute = ____attributes.attribute
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____game = require("core.game")
+local elapsedTime = ____game.elapsedTime
+local getUnitCurrentOrder = GetUnitCurrentOrder
+local issueImmediateOrderById = IssueImmediateOrderById
+local issuePointOrderById = IssuePointOrderById
+local issueTargetOrderById = IssueTargetOrderById
+local unitLastOrderKindAttribute = attribute()
+local unitLastOrderIdAttribute = attribute()
+local unitLastOrderStartTimeAttribute = attribute()
+local unitLastOrderStartXAttribute = attribute()
+local unitLastOrderStartYAttribute = attribute()
+local unitLastOrderTargetXAttribute = attribute()
+local unitLastOrderTargetYAttribute = attribute()
+local unitLastOrderTargetAttribute = attribute()
+Unit.onImmediateOrder:addListener(
+    4,
+    function(unit, orderId)
+        unit[unitLastOrderKindAttribute] = 0
+        unit[unitLastOrderIdAttribute] = orderId
+        unit[unitLastOrderStartTimeAttribute] = elapsedTime()
+        unit[unitLastOrderStartXAttribute] = unit.x
+        unit[unitLastOrderStartYAttribute] = unit.y
+        unit[unitLastOrderTargetXAttribute] = nil
+        unit[unitLastOrderTargetYAttribute] = nil
+        unit[unitLastOrderTargetAttribute] = nil
+    end
+)
+Unit.onPointOrder:addListener(
+    4,
+    function(unit, orderId, x, y)
+        unit[unitLastOrderKindAttribute] = 1
+        unit[unitLastOrderIdAttribute] = orderId
+        unit[unitLastOrderStartTimeAttribute] = elapsedTime()
+        unit[unitLastOrderStartXAttribute] = unit.x
+        unit[unitLastOrderStartYAttribute] = unit.y
+        unit[unitLastOrderTargetXAttribute] = x
+        unit[unitLastOrderTargetYAttribute] = y
+        unit[unitLastOrderTargetAttribute] = nil
+    end
+)
+Unit.onTargetOrder:addListener(
+    4,
+    function(unit, orderId, target)
+        unit[unitLastOrderKindAttribute] = 2
+        unit[unitLastOrderIdAttribute] = orderId
+        unit[unitLastOrderStartTimeAttribute] = elapsedTime()
+        unit[unitLastOrderStartXAttribute] = unit.x
+        unit[unitLastOrderStartYAttribute] = unit.y
+        unit[unitLastOrderTargetXAttribute] = target.x
+        unit[unitLastOrderTargetYAttribute] = target.y
+        unit[unitLastOrderTargetAttribute] = target
+    end
+)
+local function toUndefinedIfCurrentOrderDoesNotMatchLast(unit, value)
+    local currentOrderId = getUnitCurrentOrder(unit.handle)
+    local lastOrderId = unit[unitLastOrderIdAttribute]
+    local ____temp_0
+    if currentOrderId == lastOrderId or currentOrderId == 851991 and lastOrderId == 851990 then
+        ____temp_0 = value
+    else
+        ____temp_0 = nil
+    end
+    return ____temp_0
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderKind",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderKindAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderId",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderIdAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderStartTime",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderStartTimeAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderStartX",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderStartXAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderStartY",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderStartYAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderTargetX",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetXAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderTargetY",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetYAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderTarget",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetAttribute])
+    end}
+)
+local issueOrderByKind = {
+    [0] = issueImmediateOrderById,
+    [1] = issuePointOrderById,
+    [2] = function(unitHandle, orderId, widget) return issueTargetOrderById(unitHandle, orderId, widget.handle) end
+}
+Unit.prototype.issueOrder = function(self, orderKind, orderId, xOrTarget, y)
+    return issueOrderByKind[orderKind](self.handle, orderId, xOrTarget, y)
+end
+return ____exports

package/engine/internal/unit/pseudo-passive-abilities.d.ts

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