warscript 0.0.1-dev.2ae9956 → 0.0.1-dev.2b3f95e

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

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+import { Event } from "../../../event";
+declare module "../unit" {
+    interface Unit {
+        readonly unitInRangeEvent: Record<number, Event<[unit: Unit, range: number, unitInRange: Unit]>>;
+    }
+}
+declare module "../unit" {
+    interface Unit {
+        readonly unitOutOfRangeEvent: Record<number, Event<[unit: Unit, range: number, unitOutOfRange: Unit]>>;
+    }
+}

package/engine/internal/unit/range-event.lua

@@ -0,0 +1,90 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____event = require("event")
+local Event = ____event.Event
+local InitializingEvent = ____event.InitializingEvent
+local TriggerEvent = ____event.TriggerEvent
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____attributes = require("attributes")
+local attribute = ____attributes.attribute
+local ____linked_2Dmap = require("utility.linked-map")
+local mutableLinkedMap = ____linked_2Dmap.mutableLinkedMap
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local mutableLinkedSet = ____linked_2Dset.mutableLinkedSet
+local getTriggerUnit = GetTriggerUnit
+local triggerRegisterUnitInRange = TriggerRegisterUnitInRange
+local eventInvoke = Event.invoke
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "unitInRangeEvent",
+    {get = function(self)
+        local unit = self
+        local handle = self.handle
+        local unitInRangeEvent = setmetatable(
+            {},
+            {__index = function(self, value)
+                local event = __TS__New(
+                    TriggerEvent,
+                    function(trigger)
+                        triggerRegisterUnitInRange(trigger, handle, value, nil)
+                    end,
+                    function() return unit, value, Unit:of(getTriggerUnit()) end
+                )
+                rawset(self, value, event)
+                return event
+            end}
+        )
+        rawset(self, "unitInRangeEvent", unitInRangeEvent)
+        return unitInRangeEvent
+    end}
+)
+local units = __TS__New(LinkedSet)
+local unitsInRangeByRangeAttribute = attribute()
+local function registerUnitOfRangeEvent(unit, range, unitInRange)
+    units:add(unit)
+    unit:getOrPut(unitsInRangeByRangeAttribute, mutableLinkedMap):getOrPut(range, mutableLinkedSet):add(unitInRange)
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "unitOutOfRangeEvent",
+    {get = function(self)
+        local unit = self
+        local unitOutOfRangeEvent = setmetatable(
+            {},
+            {__index = function(self, value)
+                local event = __TS__New(
+                    InitializingEvent,
+                    function()
+                        unit.unitInRangeEvent[value]:addListener(999999, registerUnitOfRangeEvent)
+                    end
+                )
+                rawset(self, value, event)
+                return event
+            end}
+        )
+        rawset(self, "unitOutOfRangeEvent", unitOutOfRangeEvent)
+        return unitOutOfRangeEvent
+    end}
+)
+Timer.onPeriod[1]:addListener(function()
+    for unit in pairs(units) do
+        local unitsInRangeByRange = unit[unitsInRangeByRangeAttribute]
+        if unitsInRangeByRange ~= nil then
+            for range, unitsInRange in pairs(unitsInRangeByRange) do
+                for unitInRange in pairs(unitsInRange) do
+                    if unit:getDistanceTo(unitInRange) > range then
+                        unitsInRange:remove(unitInRange)
+                        eventInvoke(unit.unitOutOfRangeEvent[range], unit, range, unitInRange)
+                    end
+                end
+            end
+        end
+    end
+end)
+return ____exports

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

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

package/engine/internal/unit/scale.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 SCALING_VALUE_UNIT_FIELD = ____unit.SCALING_VALUE_UNIT_FIELD
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "scale",
+    {
+        get = function(self)
+            return SCALING_VALUE_UNIT_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            SCALING_VALUE_UNIT_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports

package/engine/internal/unit/shared-vision-counter.d.ts

@@ -0,0 +1,18 @@
+/** @noSelfInFile */
+import { Player } from "../../../core/types/player";
+declare module "../unit" {
+    interface Unit {
+        /**
+         * Shares this unit with the player (`UnitShareVision`) until the matching
+         * `decrementSharedVisionCounter`. Verified in game with an enemy unit: the player, and
+         * the players the player shares vision with (one step, like alliance vision), see the
+         * unit itself but not the area it sees.
+         */
+        incrementSharedVisionCounter(player: Player): void;
+    }
+}
+declare module "../unit" {
+    interface Unit {
+        decrementSharedVisionCounter(player: Player): void;
+    }
+}

package/engine/internal/unit/shared-vision-counter.lua

@@ -0,0 +1,31 @@
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local unitShareVision = UnitShareVision
+local sharedVisionCounterByPlayerByUnit = setmetatable({}, {__mode = "k"})
+Unit.prototype.incrementSharedVisionCounter = function(self, player)
+    local sharedVisionCounterByPlayer = sharedVisionCounterByPlayerByUnit[self]
+    if sharedVisionCounterByPlayer == nil then
+        sharedVisionCounterByPlayer = {}
+        sharedVisionCounterByPlayerByUnit[self] = sharedVisionCounterByPlayer
+    end
+    local sharedVisionCounter = sharedVisionCounterByPlayer[player] or 0
+    if sharedVisionCounter == 0 then
+        unitShareVision(self.handle, player.handle, true)
+    end
+    sharedVisionCounterByPlayer[player] = sharedVisionCounter + 1
+end
+Unit.prototype.decrementSharedVisionCounter = function(self, player)
+    local sharedVisionCounterByPlayer = sharedVisionCounterByPlayerByUnit[self]
+    local sharedVisionCounter = sharedVisionCounterByPlayer and sharedVisionCounterByPlayer[player] or 0
+    if sharedVisionCounterByPlayer == nil or sharedVisionCounter == 0 then
+        return
+    end
+    if sharedVisionCounter == 1 then
+        unitShareVision(self.handle, player.handle, false)
+        sharedVisionCounterByPlayer[player] = nil
+    else
+        sharedVisionCounterByPlayer[player] = sharedVisionCounter - 1
+    end
+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

@@ -7,8 +7,12 @@ local UnitAbility = ____ability.UnitAbility
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
-local Event = ____event.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)
@@ -40,8 +111,17 @@ ItemAbility.onCreate:addListener(
         end
     end
 )
+ItemAbility.destroyEvent:addListener(
+    4,
+    function(ability)
+        local unit = ability.owner.owner
+        if unit ~= nil then
+            Event.invoke(abilityLostEvent, unit, ability)
+        end
+    end
+)
 Unit.itemPickedUpEvent:addListener(
-    0,
+    -999999,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do
             Event.invoke(abilityGainedEvent, unit, ability)
@@ -49,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,15 +1,9 @@
 /** @noSelfInFile */
+import "./unit/allowed-targets";
 import { Widget } from "../../core/types/widget";
-export type AttackType = jattacktype;
-export declare namespace AttackType {
-    const SPELL: jattacktype;
-    const NORMAL: jattacktype;
-    const PIERCE: jattacktype;
-    const SIEGE: jattacktype;
-    const MAGIC: jattacktype;
-    const CHAOS: jattacktype;
-    const HERO: jattacktype;
-}
+import { AttackType } from "../object-data/auxiliary/attack-type";
+import { WeaponSoundType } from "../object-data/auxiliary/weapon-sound-type";
+import { CombatClassifications } from "../object-data/auxiliary/combat-classification";
 export type DamageType = jdamagetype;
 export declare namespace DamageType {
     const UNKNOWN: jdamagetype;
@@ -35,35 +29,15 @@ export declare namespace DamageType {
     const SHADOW_STRIKE: jdamagetype;
     const UNIVERSAL: jdamagetype;
 }
-export type WeaponType = jweapontype;
-export declare namespace WeaponType {
-    const UNKNOWN: jweapontype;
-    const METAL_LIGHT_CHOP: jweapontype;
-    const METAL_MEDIUM_CHOP: jweapontype;
-    const METAL_HEAVY_CHOP: jweapontype;
-    const METAL_LIGHT_SLICE: jweapontype;
-    const METAL_MEDIUM_SLICE: jweapontype;
-    const METAL_HEAVY_SLICE: jweapontype;
-    const METAL_MEDIUM_BASH: jweapontype;
-    const METAL_HEAVY_BASH: jweapontype;
-    const METAL_MEDIUM_STAB: jweapontype;
-    const METAL_HEAVY_STAB: jweapontype;
-    const WOOD_LIGHT_SLICE: jweapontype;
-    const WOOD_MEDIUM_SLICE: jweapontype;
-    const WOOD_HEAVY_SLICE: jweapontype;
-    const WOOD_LIGHT_BASH: jweapontype;
-    const WOOD_MEDIUM_BASH: jweapontype;
-    const WOOD_HEAVY_BASH: jweapontype;
-    const WOOD_LIGHT_STAB: jweapontype;
-    const WOOD_MEDIUM_STAB: jweapontype;
-    const CLAW_LIGHT_SLICE: jweapontype;
-    const CLAW_MEDIUM_SLICE: jweapontype;
-    const CLAW_HEAVY_SLICE: jweapontype;
-    const AXE_MEDIUM_CHOP: jweapontype;
-    const ROCK_HEAVY_BASH: jweapontype;
-}
 declare module "./unit" {
     interface Unit {
-        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType): boolean;
+        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponSoundType?: WeaponSoundType, 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, weaponSoundType?: WeaponSoundType, metadata?: unknown): void;
     }
 }

package/engine/internal/unit+damage.lua

@@ -3,25 +3,23 @@ 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")
 local dummyUnitId = ____dummy.dummyUnitId
+local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
+local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local ____weapon_2Dsound_2Dtype = require("engine.object-data.auxiliary.weapon-sound-type")
+local weaponSoundTypeToNative = ____weapon_2Dsound_2Dtype.weaponSoundTypeToNative
+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
 local unitDamageTarget = UnitDamageTarget
-____exports.AttackType = {}
-local AttackType = ____exports.AttackType
-do
-    AttackType.SPELL = ATTACK_TYPE_NORMAL
-    AttackType.NORMAL = ATTACK_TYPE_MELEE
-    AttackType.PIERCE = ATTACK_TYPE_PIERCE
-    AttackType.SIEGE = ATTACK_TYPE_SIEGE
-    AttackType.MAGIC = ATTACK_TYPE_MAGIC
-    AttackType.CHAOS = ATTACK_TYPE_CHAOS
-    AttackType.HERO = ATTACK_TYPE_HERO
-end
 ____exports.DamageType = {}
 local DamageType = ____exports.DamageType
 do
@@ -48,34 +46,6 @@ do
     DamageType.SHADOW_STRIKE = DAMAGE_TYPE_SHADOW_STRIKE
     DamageType.UNIVERSAL = DAMAGE_TYPE_UNIVERSAL
 end
-____exports.WeaponType = {}
-local WeaponType = ____exports.WeaponType
-do
-    WeaponType.UNKNOWN = WEAPON_TYPE_WHOKNOWS
-    WeaponType.METAL_LIGHT_CHOP = WEAPON_TYPE_METAL_LIGHT_CHOP
-    WeaponType.METAL_MEDIUM_CHOP = WEAPON_TYPE_METAL_MEDIUM_CHOP
-    WeaponType.METAL_HEAVY_CHOP = WEAPON_TYPE_METAL_HEAVY_CHOP
-    WeaponType.METAL_LIGHT_SLICE = WEAPON_TYPE_METAL_LIGHT_SLICE
-    WeaponType.METAL_MEDIUM_SLICE = WEAPON_TYPE_METAL_MEDIUM_SLICE
-    WeaponType.METAL_HEAVY_SLICE = WEAPON_TYPE_METAL_HEAVY_SLICE
-    WeaponType.METAL_MEDIUM_BASH = WEAPON_TYPE_METAL_MEDIUM_BASH
-    WeaponType.METAL_HEAVY_BASH = WEAPON_TYPE_METAL_HEAVY_BASH
-    WeaponType.METAL_MEDIUM_STAB = WEAPON_TYPE_METAL_MEDIUM_STAB
-    WeaponType.METAL_HEAVY_STAB = WEAPON_TYPE_METAL_HEAVY_STAB
-    WeaponType.WOOD_LIGHT_SLICE = WEAPON_TYPE_WOOD_LIGHT_SLICE
-    WeaponType.WOOD_MEDIUM_SLICE = WEAPON_TYPE_WOOD_MEDIUM_SLICE
-    WeaponType.WOOD_HEAVY_SLICE = WEAPON_TYPE_WOOD_HEAVY_SLICE
-    WeaponType.WOOD_LIGHT_BASH = WEAPON_TYPE_WOOD_LIGHT_BASH
-    WeaponType.WOOD_MEDIUM_BASH = WEAPON_TYPE_WOOD_MEDIUM_BASH
-    WeaponType.WOOD_HEAVY_BASH = WEAPON_TYPE_WOOD_HEAVY_BASH
-    WeaponType.WOOD_LIGHT_STAB = WEAPON_TYPE_WOOD_LIGHT_STAB
-    WeaponType.WOOD_MEDIUM_STAB = WEAPON_TYPE_WOOD_MEDIUM_STAB
-    WeaponType.CLAW_LIGHT_SLICE = WEAPON_TYPE_CLAW_LIGHT_SLICE
-    WeaponType.CLAW_MEDIUM_SLICE = WEAPON_TYPE_CLAW_MEDIUM_SLICE
-    WeaponType.CLAW_HEAVY_SLICE = WEAPON_TYPE_CLAW_HEAVY_SLICE
-    WeaponType.AXE_MEDIUM_CHOP = WEAPON_TYPE_AXE_MEDIUM_CHOP
-    WeaponType.ROCK_HEAVY_BASH = WEAPON_TYPE_ROCK_HEAVY_BASH
-end
 local dummies = {}
 for ____, player in ipairs(Player.all) do
     local dummy = assert(createUnit(
@@ -88,7 +58,7 @@ for ____, player in ipairs(Player.all) do
     showUnit(dummy, false)
     dummies[player] = dummy
 end
-Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType)
+Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponSoundType, metadata)
     if attack == nil then
         attack = false
     end
@@ -96,28 +66,61 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
         ranged = false
     end
     if attackType == nil then
-        attackType = ____exports.AttackType.SPELL
+        attackType = 0
     end
     if damageType == nil then
         damageType = ____exports.DamageType.MAGIC
     end
-    if weaponType == nil then
-        weaponType = ____exports.WeaponType.UNKNOWN
+    if weaponSoundType == nil then
+        weaponSoundType = 0
     end
     local handle = self.handle
     local targetHandle = target.handle
     if not getOwningPlayer(handle) then
         handle = dummies[__TS__InstanceOf(target, Unit) and target.owner or (self._owner or Player.neutralAggressive)]
     end
+    if __TS__InstanceOf(target, Unit) then
+        damageMetadataByTarget[target] = metadata
+    end
     return unitDamageTarget(
         handle,
         targetHandle,
         amount,
         attack,
         ranged,
-        attackType,
+        attackTypeToNative(attackType),
         damageType,
-        weaponType
+        weaponSoundTypeToNative(weaponSoundType)
     )
 end
+Unit.prototype.damageArea = function(self, x, y, range, allowedTargetCombatClassifications, amount, maximumDamage, attack, ranged, attackType, damageType, weaponSoundType, 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,
+            weaponSoundType,
+            metadata
+        )
+    end
+end
 return ____exports