warscript 0.0.1-dev.5abc199 → 0.0.1-dev.5bc80ec

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/order.d.ts

@@ -1,13 +1,13 @@
 /** @noSelfInFile */
 import { Widget } from "../../../core/types/widget";
-export declare const enum OrderType {
+export declare const enum OrderKind {
     IMMEDIATE = 0,
     POINT = 1,
     TARGET = 2
 }
 declare module "../unit" {
     interface Unit {
-        readonly currentOrderType: OrderType;
+        readonly currentOrderKind: OrderKind;
         readonly currentOrderId: number;
         readonly currentOrderStartTime: number;
         readonly currentOrderStartX: number;
@@ -15,6 +15,6 @@ declare module "../unit" {
         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;
+        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

@@ -11,7 +11,7 @@ local getUnitCurrentOrder = GetUnitCurrentOrder
 local issueImmediateOrderById = IssueImmediateOrderById
 local issuePointOrderById = IssuePointOrderById
 local issueTargetOrderById = IssueTargetOrderById
-local unitLastOrderTypeAttribute = attribute()
+local unitLastOrderKindAttribute = attribute()
 local unitLastOrderIdAttribute = attribute()
 local unitLastOrderStartTimeAttribute = attribute()
 local unitLastOrderStartXAttribute = attribute()
@@ -22,7 +22,7 @@ local unitLastOrderTargetAttribute = attribute()
 Unit.onImmediateOrder:addListener(
     4,
     function(unit, orderId)
-        unit[unitLastOrderTypeAttribute] = 0
+        unit[unitLastOrderKindAttribute] = 0
         unit[unitLastOrderIdAttribute] = orderId
         unit[unitLastOrderStartTimeAttribute] = elapsedTime()
         unit[unitLastOrderStartXAttribute] = unit.x
@@ -35,7 +35,7 @@ Unit.onImmediateOrder:addListener(
 Unit.onPointOrder:addListener(
     4,
     function(unit, orderId, x, y)
-        unit[unitLastOrderTypeAttribute] = 1
+        unit[unitLastOrderKindAttribute] = 1
         unit[unitLastOrderIdAttribute] = orderId
         unit[unitLastOrderStartTimeAttribute] = elapsedTime()
         unit[unitLastOrderStartXAttribute] = unit.x
@@ -48,7 +48,7 @@ Unit.onPointOrder:addListener(
 Unit.onTargetOrder:addListener(
     4,
     function(unit, orderId, target)
-        unit[unitLastOrderTypeAttribute] = 2
+        unit[unitLastOrderKindAttribute] = 2
         unit[unitLastOrderIdAttribute] = orderId
         unit[unitLastOrderStartTimeAttribute] = elapsedTime()
         unit[unitLastOrderStartXAttribute] = unit.x
@@ -62,7 +62,7 @@ local function toUndefinedIfCurrentOrderDoesNotMatchLast(unit, value)
     local currentOrderId = getUnitCurrentOrder(unit.handle)
     local lastOrderId = unit[unitLastOrderIdAttribute]
     local ____temp_0
-    if currentOrderId == lastOrderId or currentOrderId == orderId("patrolAI") and lastOrderId == orderId("patrol") then
+    if currentOrderId == lastOrderId or currentOrderId == 851991 and lastOrderId == 851990 then
         ____temp_0 = value
     else
         ____temp_0 = nil
@@ -71,9 +71,9 @@ local function toUndefinedIfCurrentOrderDoesNotMatchLast(unit, value)
 end
 __TS__ObjectDefineProperty(
     Unit.prototype,
-    "currentOrderType",
+    "currentOrderKind",
     {get = function(self)
-        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTypeAttribute]) or 0
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderKindAttribute]) or 0
     end}
 )
 __TS__ObjectDefineProperty(
@@ -125,12 +125,12 @@ __TS__ObjectDefineProperty(
         return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetAttribute])
     end}
 )
-local issueOrderByType = {
+local issueOrderByKind = {
     [0] = issueImmediateOrderById,
     [1] = issuePointOrderById,
     [2] = function(unitHandle, orderId, widget) return issueTargetOrderById(unitHandle, orderId, widget.handle) end
 }
-Unit.prototype.issueOrder = function(self, orderType, orderId, xOrTarget, y)
-    return issueOrderByType[orderType](self.handle, orderId, xOrTarget, y)
+Unit.prototype.issueOrder = function(self, orderKind, orderId, xOrTarget, y)
+    return issueOrderByKind[orderKind](self.handle, orderId, xOrTarget, y)
 end
 return ____exports

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

@@ -1,9 +1,10 @@
 /** @noSelfInFile */
-import { Ability } from "./ability";
+import { Ability, UnitAbility } from "./ability";
 import { DispatchingEvent } from "../../event";
 declare module "./unit" {
     namespace Unit {
         const abilityGainedEvent: DispatchingEvent<[Unit, Ability]>;
         const abilityLostEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityLevelChangedEvent: DispatchingEvent<[Unit, UnitAbility]>;
     }
 }

package/engine/internal/unit+ability.lua

@@ -9,6 +9,10 @@ local Unit = ____unit.Unit
 local ____event = require("event")
 local createDispatchingEvent = ____event.createDispatchingEvent
 local Event = ____event.Event
+local ____unit_2Dability_2Dlevel_2Dnatives = require("engine.internal.misc.unit-ability-level-natives")
+local rawDecUnitAbilityLevel = ____unit_2Dability_2Dlevel_2Dnatives.rawDecUnitAbilityLevel
+local rawIncUnitAbilityLevel = ____unit_2Dability_2Dlevel_2Dnatives.rawIncUnitAbilityLevel
+local rawSetUnitAbilityLevel = ____unit_2Dability_2Dlevel_2Dnatives.rawSetUnitAbilityLevel
 local abilityGainedEvent = createDispatchingEvent(
     __TS__New(Event),
     function(unit, ability) return ability.typeId end
@@ -19,12 +23,79 @@ local abilityLostEvent = createDispatchingEvent(
     function(unit, ability) return ability.typeId end
 )
 rawset(Unit, "abilityLostEvent", abilityLostEvent)
+local abilityLevelChangedEvent = createDispatchingEvent(
+    __TS__New(Event),
+    function(unit, ability) return ability.typeId end
+)
+rawset(Unit, "abilityLevelChangedEvent", abilityLevelChangedEvent)
+local getUnitAbilityLevel = GetUnitAbilityLevel
+local unitDisableAbility = BlzUnitDisableAbility
+local function invokeAbilityLevelChangedEvent(unitHandle, abilityTypeId)
+    local unit = Unit:of(unitHandle)
+    if unit ~= nil then
+        local ability = unit:getAbility(abilityTypeId)
+        if ability ~= nil then
+            Event.invoke(abilityLevelChangedEvent, unit, ability)
+        end
+    end
+end
+local function invokeAbilityLevelChangedEventIfChanged(unitHandle, abilityTypeId, previousLevel)
+    if previousLevel ~= 0 then
+        local level = getUnitAbilityLevel(unitHandle, abilityTypeId)
+        if level ~= 0 and level ~= previousLevel then
+            invokeAbilityLevelChangedEvent(unitHandle, abilityTypeId)
+        end
+    end
+end
+_G.SetUnitAbilityLevel = function(whichUnit, abilcode, level)
+    local previousLevel = getUnitAbilityLevel(whichUnit, abilcode)
+    local result = rawSetUnitAbilityLevel(whichUnit, abilcode, level)
+    invokeAbilityLevelChangedEventIfChanged(whichUnit, abilcode, previousLevel)
+    return result
+end
+_G.IncUnitAbilityLevel = function(whichUnit, abilcode)
+    local previousLevel = getUnitAbilityLevel(whichUnit, abilcode)
+    local result = rawIncUnitAbilityLevel(whichUnit, abilcode)
+    invokeAbilityLevelChangedEventIfChanged(whichUnit, abilcode, previousLevel)
+    return result
+end
+_G.DecUnitAbilityLevel = function(whichUnit, abilcode)
+    local previousLevel = getUnitAbilityLevel(whichUnit, abilcode)
+    local result = rawDecUnitAbilityLevel(whichUnit, abilcode)
+    invokeAbilityLevelChangedEventIfChanged(whichUnit, abilcode, previousLevel)
+    return result
+end
+local heroSkillTrigger = CreateTrigger()
+TriggerRegisterAnyUnitEventBJ(heroSkillTrigger, EVENT_PLAYER_HERO_SKILL)
+TriggerAddCondition(
+    heroSkillTrigger,
+    Condition(function()
+        if GetLearnedSkillLevel() > 1 then
+            local unitHandle = GetTriggerUnit()
+            if unitHandle ~= nil then
+                invokeAbilityLevelChangedEvent(
+                    unitHandle,
+                    GetLearnedSkill()
+                )
+            end
+        end
+    end)
+)
 UnitAbility.onCreate:addListener(
     0,
     function(ability)
         Event.invoke(abilityGainedEvent, ability.owner, ability)
     end
 )
+UnitAbility.onDestroy:addListener(
+    999999,
+    function(ability)
+        local owner = ability.owner
+        if owner.state ~= 2 then
+            unitDisableAbility(owner.handle, ability.typeId, true, false)
+        end
+    end
+)
 UnitAbility.destroyEvent:addListener(
     4,
     function(ability)
@@ -50,7 +121,7 @@ ItemAbility.destroyEvent:addListener(
     end
 )
 Unit.itemPickedUpEvent:addListener(
-    0,
+    -999999,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do
             Event.invoke(abilityGainedEvent, unit, ability)
@@ -58,7 +129,7 @@ Unit.itemPickedUpEvent:addListener(
     end
 )
 Unit.itemDroppedEvent:addListener(
-    4,
+    999999,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do
             Event.invoke(abilityLostEvent, unit, ability)

package/engine/internal/unit+bonus.lua

@@ -3,9 +3,9 @@ local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
 local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
-local ____armor_2Dincrease = require("engine.internal.object-data.armor-increase")
-local ARMOR_BONUS_DUMMY_ABILITY_FIELD = ____armor_2Dincrease.ARMOR_BONUS_DUMMY_ABILITY_FIELD
-local ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID = ____armor_2Dincrease.ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID
+local ____armor_2Dbonus = require("engine.internal.object-data.armor-bonus")
+local ARMOR_BONUS_DUMMY_ABILITY_FIELD = ____armor_2Dbonus.ARMOR_BONUS_DUMMY_ABILITY_FIELD
+local ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID = ____armor_2Dbonus.ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID
 local getUnitAbility = BlzGetUnitAbility
 local setAbilityRealLevelField = BlzSetAbilityRealLevelField
 local unitAddAbility = UnitAddAbility

package/engine/internal/unit+damage.d.ts

@@ -1,6 +1,8 @@
 /** @noSelfInFile */
+import "./unit/allowed-targets";
 import { Widget } from "../../core/types/widget";
 import { AttackType } from "../object-data/auxiliary/attack-type";
+import { CombatClassifications } from "../object-data/auxiliary/combat-classification";
 export type DamageType = jdamagetype;
 export declare namespace DamageType {
     const UNKNOWN: jdamagetype;
@@ -56,5 +58,12 @@ export declare namespace WeaponType {
 declare module "./unit" {
     interface Unit {
         damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType, metadata?: unknown): boolean;
+        /**
+         * Deals amount to each allowed unit in collision range of (x, y).
+         * A positive maximumDamage caps the total requested damage, shared equally
+         * between the targets. Zero or omitted means unlimited; damage mitigation
+         * and damage-event modifiers are applied afterward by damageTarget.
+         */
+        damageArea(x: number, y: number, range: number, allowedTargetCombatClassifications: CombatClassifications, amount: number, maximumDamage?: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType, metadata?: unknown): void;
     }
 }

package/engine/internal/unit+damage.lua

@@ -3,6 +3,7 @@ local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
+require("engine.internal.unit.allowed-targets")
 local ____player = require("core.types.player")
 local Player = ____player.Player
 local ____dummy = require("objutil.dummy")
@@ -11,6 +12,8 @@ local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
 local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
 local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
 local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
+local ____math = require("math")
+local min = ____math.min
 local createUnit = CreateUnit
 local getOwningPlayer = GetOwningPlayer
 local showUnit = ShowUnit
@@ -116,4 +119,34 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
         weaponType
     )
 end
+Unit.prototype.damageArea = function(self, x, y, range, allowedTargetCombatClassifications, amount, maximumDamage, attack, ranged, attackType, damageType, weaponType, metadata)
+    if maximumDamage == nil then
+        maximumDamage = 0
+    end
+    local targets = Unit.getAllowedTargetsInCollisionRange(
+        self,
+        allowedTargetCombatClassifications,
+        x,
+        y,
+        range
+    )
+    if #targets == 0 then
+        return
+    end
+    if maximumDamage > 0 then
+        amount = min(amount, maximumDamage / #targets)
+    end
+    for ____, target in ipairs(targets) do
+        self:damageTarget(
+            target,
+            amount,
+            attack,
+            ranged,
+            attackType,
+            damageType,
+            weaponType,
+            metadata
+        )
+    end
+end
 return ____exports

package/engine/internal/unit+rally.lua

@@ -23,22 +23,22 @@ local issueTargetOrderById = IssueTargetOrderById
 local queuePointOrderById = BlzQueuePointOrderById
 local queueTargetOrderById = BlzQueueTargetOrderById
 local rallyRouteByUnit = setmetatable({}, {__mode = "k"})
-Unit.onPointOrder[orderId("setrally")]:addListener(function(unit, x, y)
+Unit.onPointOrder[851980]:addListener(function(unit, x, y)
     processPoint(unit, x, y)
 end)
-Unit.onPointOrder[orderId("smart")]:addListener(function(unit, x, y)
+Unit.onPointOrder[851971]:addListener(function(unit, x, y)
     if unit:hasAbility(fourCC("ARal")) then
         processPoint(unit, x, y)
     end
 end)
-Unit.onTargetOrder[orderId("setrally")]:addListener(function(unit, target)
+Unit.onTargetOrder[851980]:addListener(function(unit, target)
     if __TS__InstanceOf(target, Unit) then
         processUnit(unit, target)
     elseif __TS__InstanceOf(target, Destructable) then
         processDestructible(unit, target)
     end
 end)
-Unit.onTargetOrder[orderId("smart")]:addListener(function(unit, target)
+Unit.onTargetOrder[851971]:addListener(function(unit, target)
     if unit:hasAbility(fourCC("ARal")) then
         if __TS__InstanceOf(target, Unit) then
             processUnit(unit, target)
@@ -116,41 +116,19 @@ __TS__ObjectDefineProperty(
             do
                 local rallyPoint = rallyRoute[1]
                 if __TS__InstanceOf(rallyPoint, Handle) then
-                    issueTargetOrderById(
-                        handle,
-                        orderId("setrally"),
-                        rallyPoint.handle
-                    )
+                    issueTargetOrderById(handle, 851980, rallyPoint.handle)
                 elseif rallyPoint ~= nil then
-                    issuePointOrderById(
-                        handle,
-                        orderId("setrally"),
-                        rallyPoint[1],
-                        rallyPoint[2]
-                    )
+                    issuePointOrderById(handle, 851980, rallyPoint[1], rallyPoint[2])
                 else
-                    issueTargetOrderById(
-                        handle,
-                        orderId("setrally"),
-                        handle
-                    )
+                    issueTargetOrderById(handle, 851980, handle)
                 end
             end
             for i = 2, #rallyRoute do
                 local rallyPoint = rallyRoute[i]
                 if __TS__InstanceOf(rallyPoint, Handle) then
-                    queueTargetOrderById(
-                        handle,
-                        orderId("setrally"),
-                        rallyPoint.handle
-                    )
+                    queueTargetOrderById(handle, 851980, rallyPoint.handle)
                 else
-                    queuePointOrderById(
-                        handle,
-                        orderId("setrally"),
-                        rallyPoint[1],
-                        rallyPoint[2]
-                    )
+                    queuePointOrderById(handle, 851980, rallyPoint[1], rallyPoint[2])
                 end
             end
         end