warscript 0.0.1-dev.ee2345e → 0.0.1-dev.ee6e396

package/engine/internal/unit.lua

@@ -5,9 +5,12 @@ local __TS__ArrayMap = ____lualib.__TS__ArrayMap
 local __TS__New = ____lualib.__TS__New
 local __TS__Class = ____lualib.__TS__Class
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
 local __TS__ArraySetLength = ____lualib.__TS__ArraySetLength
+local __TS__SparseArrayNew = ____lualib.__TS__SparseArrayNew
+local __TS__SparseArrayPush = ____lualib.__TS__SparseArrayPush
+local __TS__SparseArraySpread = ____lualib.__TS__SparseArraySpread
 local __TS__InstanceOf = ____lualib.__TS__InstanceOf
-local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
 local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
 local Set = ____lualib.Set
 local __TS__Spread = ____lualib.__TS__Spread
@@ -48,33 +51,42 @@ local ____arrays = require("utility.arrays")
 local forEach = ____arrays.forEach
 local ____math = require("math")
 local min = ____math.min
+local ____ignore_2Devents_2Ditems = require("engine.internal.unit.ignore-events-items")
+local ignoreEventsItems = ____ignore_2Devents_2Ditems.ignoreEventsItems
+local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
+local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local nativeToAttackType = ____attack_2Dtype.nativeToAttackType
+local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
+local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
+local ____attributes = require("attributes")
+local isAttribute = ____attributes.isAttribute
+local ____ability = require("engine.internal.item.ability")
+local doUnitAbilityAction = ____ability.doUnitAbilityAction
+local ____synchronization = require("engine.synchronization")
+local synchronizer = ____synchronization.synchronizer
+local ____linked_2Dmap = require("utility.linked-map")
+local LinkedMap = ____linked_2Dmap.LinkedMap
 local match = string.match
 local ____tostring = _G.tostring
 local setUnitAnimation = SetUnitAnimation
-local setUnitAnimationWithRarity = SetUnitAnimationWithRarity
 local setUnitAnimationByIndex = SetUnitAnimationByIndex
-local queueUnitAnimation = QueueUnitAnimation
 local getUnitIntegerField = BlzGetUnitIntegerField
 local getUnitRealField = BlzGetUnitRealField
 local getHeroStr = GetHeroStr
 local getHeroAgi = GetHeroAgi
 local getHeroInt = GetHeroInt
-local setHeroStr = SetHeroStr
-local setHeroAgi = SetHeroAgi
-local setHeroInt = SetHeroInt
 local getUnitBooleanField = BlzGetUnitBooleanField
 local getUnitStringField = BlzGetUnitStringField
 local setUnitIntegerField = BlzSetUnitIntegerField
 local setUnitRealField = BlzSetUnitRealField
 local setUnitBooleanField = BlzSetUnitBooleanField
 local setUnitStringField = BlzSetUnitStringField
-local setUnitScale = SetUnitScale
 local setUnitPosition = SetUnitPosition
 local setUnitTimeScale = SetUnitTimeScale
 local getHandleId = GetHandleId
+local getUnitCurrentOrder = GetUnitCurrentOrder
 local createUnit = CreateUnit
 local killUnit = KillUnit
-local setUnitExploded = SetUnitExploded
 local removeUnit = RemoveUnit
 local getUnitTypeId = GetUnitTypeId
 local isHeroUnitId = IsHeroUnitId
@@ -90,11 +102,12 @@ local getSpellTargetItem = GetSpellTargetItem
 local getSpellTargetDestructable = GetSpellTargetDestructable
 local isUnitInRangeXY = IsUnitInRangeXY
 local isUnitInRange = IsUnitInRange
-local setResourceAmount = SetResourceAmount
-local getResourceAmount = GetResourceAmount
+local getUnitWeaponRealField = BlzGetUnitWeaponRealField
+local setUnitWeaponRealField = BlzSetUnitWeaponRealField
+local getUnitWeaponStringField = BlzGetUnitWeaponStringField
+local setUnitWeaponStringField = BlzSetUnitWeaponStringField
 local getUnitAbilityLevel = GetUnitAbilityLevel
 local unitDisableAbility = BlzUnitDisableAbility
-local unitInterruptAttack = BlzUnitInterruptAttack
 local isUnitInvisible = IsUnitInvisible
 local isUnitVisible = IsUnitVisible
 local getUnitX = GetUnitX
@@ -111,15 +124,9 @@ local getOrderedUnit = GetOrderedUnit
 local getIssuedOrderId = GetIssuedOrderId
 local isUnitInvulnerable = BlzIsUnitInvulnerable
 local unitAlive = UnitAlive
-local unitAddType = UnitAddType
-local unitRemoveType = UnitRemoveType
-local isUnitIllusion = IsUnitIllusion
-local isUnitType = IsUnitType
 local isUnitAlly = IsUnitAlly
 local isUnitEnemy = IsUnitEnemy
 local getOwningPlayer = GetOwningPlayer
-local setUnitColor = SetUnitColor
-local showUnitTeamGlow = BlzShowUnitTeamGlow
 ____exports.UnitClassification = {}
 local UnitClassification = ____exports.UnitClassification
 do
@@ -129,6 +136,7 @@ do
     UnitClassification.GROUND = UNIT_TYPE_GROUND
     UnitClassification.SUMMONED = UNIT_TYPE_SUMMONED
     UnitClassification.MECHANICAL = UNIT_TYPE_MECHANICAL
+    UnitClassification.WORKER = UNIT_TYPE_PEON
     UnitClassification.ANCIENT = UNIT_TYPE_ANCIENT
     UnitClassification.SUICIDAL = UNIT_TYPE_SAPPER
     UnitClassification.TAUREN = UNIT_TYPE_TAUREN
@@ -275,16 +283,14 @@ function UnitTriggerEvent.prototype.____constructor(self, eventType, c)
 end
 local function dispatch(event, idGetter, argsGetter)
     local initialized = false
-    local x = {}
     return setmetatable(
-        x,
+        {},
         {
             __index = function(self, id)
                 if type(id) ~= "number" then
                     return event[id]
                 end
                 if not initialized then
-                    local invoke = Event.invoke
                     event:addListener(function(...)
                         local id = idGetter(...)
                         local dispatched = rawget(self, id)
@@ -322,7 +328,6 @@ local function dispatchAbility(event)
                     return event[id]
                 end
                 if not initialized then
-                    local invoke = Event.invoke
                     event:addListener(function(unit, ability, ...)
                         local dispatched = rawget(self, ability.typeId)
                         if dispatched ~= nil then
@@ -339,6 +344,9 @@ local function dispatchAbility(event)
         }
     )
 end
+local function damagingEventPreventRetaliation(self)
+    self[0] = true
+end
 local function damageEventPreventDeath(self, callback, ...)
     if self[0] ~= nil then
         return
@@ -350,7 +358,14 @@ local function damageEventPreventDeath(self, callback, ...)
         rawset(self, 1 + i, (select(i, ...)))
     end
 end
-local damageSetters = {amount = BlzSetEventDamage, attackType = BlzSetEventAttackType, damageType = BlzSetEventDamageType, weaponType = BlzSetEventWeaponType}
+local damageSetters = {
+    amount = BlzSetEventDamage,
+    attackType = function(attackType)
+        return BlzSetEventAttackType(attackTypeToNative(attackType))
+    end,
+    damageType = BlzSetEventDamageType,
+    weaponType = BlzSetEventWeaponType
+}
 local jlimitopByOperator = {
     [0] = LESS_THAN_OR_EQUAL,
     [1] = LESS_THAN_OR_EQUAL,
@@ -368,15 +383,27 @@ local modifiers = {
     end,
     armor = function(unit, value)
         if UnitAddAbility(unit, armorBonusAbilityId) then
-            assert(UnitMakeAbilityPermanent(unit, true, armorBonusAbilityId))
+            assert(
+                UnitMakeAbilityPermanent(unit, true, armorBonusAbilityId),
+                "armor bonus ability must be made permanent",
+                unit
+            )
         end
-        local ability = assert(BlzGetUnitAbility(unit, armorBonusAbilityId))
-        assert(BlzSetAbilityRealLevelField(
-            ability,
-            armorBonusField,
-            0,
-            BlzGetAbilityRealLevelField(ability, armorBonusField, 0) + value
-        ))
+        local ability = assert(
+            BlzGetUnitAbility(unit, armorBonusAbilityId),
+            "armor bonus ability must be existing",
+            unit
+        )
+        assert(
+            BlzSetAbilityRealLevelField(
+                ability,
+                armorBonusField,
+                0,
+                BlzGetAbilityRealLevelField(ability, armorBonusField, 0) + value
+            ),
+            "armor bonus ability field must be set",
+            unit
+        )
     end
 }
 local getters = {
@@ -387,51 +414,184 @@ local getters = {
         return BlzGetUnitArmor(unit)
     end
 }
-local weaponGetters = {
-    index = function(self, handle, index)
-        return index
-    end,
-    cooldown = function(self, handle, index)
-        return BlzGetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_BASE_COOLDOWN, index)
-    end,
-    projectileArc = function(self, handle, index)
-        return BlzGetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_ARC, index)
-    end,
-    projectileArt = function(self, handle, index)
-        return BlzGetUnitWeaponStringField(handle, UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART, index)
-    end,
-    projectileSpeed = function(self, handle, index)
-        return BlzGetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_SPEED, index)
-    end,
-    attackPoint = function(self, handle, index)
-        return BlzGetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_DAMAGE_POINT, index)
-    end
-}
-local weaponSetters = {
-    cooldown = function(self, handle, index, value)
-        assert(BlzSetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_BASE_COOLDOWN, index, value))
-    end,
-    projectileArc = function(self, handle, index, value)
-        assert(BlzSetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_ARC, index, value))
-    end,
-    projectileArt = function(self, handle, index, value)
-        assert(BlzSetUnitWeaponStringField(handle, UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART, index, value))
-    end,
-    projectileSpeed = function(self, handle, index, value)
-        assert(BlzSetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_SPEED, index, value))
-    end,
-    attackPoint = function(self, handle, index, value)
-        assert(BlzSetUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_DAMAGE_POINT, index, value))
-    end
-}
-local weaponMetatable = {
-    __index = function(self, key)
-        return weaponGetters[key](weaponGetters, self.h, self.i)
-    end,
-    __newindex = function(self, key, value)
-        weaponSetters[key](weaponSetters, self.h, self.i, value)
-    end
-}
+____exports.UnitWeapon = __TS__Class()
+local UnitWeapon = ____exports.UnitWeapon
+UnitWeapon.name = "UnitWeapon"
+function UnitWeapon.prototype.____constructor(self, unit, index)
+    self.unit = unit
+    self.index = index
+end
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "isEnabled",
+    {
+        get = function(self)
+            return BlzGetUnitWeaponBooleanField(self.unit.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, self.index)
+        end,
+        set = function(self, isEnabled)
+            BlzSetUnitWeaponBooleanField(self.unit.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, self.index, isEnabled)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "cooldown",
+    {
+        get = function(self)
+            return getUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_BASE_COOLDOWN, self.index)
+        end,
+        set = function(self, cooldown)
+            setUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_BASE_COOLDOWN, self.index, cooldown)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "damage",
+    {
+        get = function(self)
+            local minimumDamage = self.damageBase + self.damageDiceCount
+            local maximumDamage = self.damageBase + self.damageDiceCount * self.damageDiceSideCount
+            return {minimumDamage, maximumDamage}
+        end,
+        set = function(self, ____bindingPattern0)
+            local maximumDamage
+            local minimumDamage
+            minimumDamage = ____bindingPattern0[1]
+            maximumDamage = ____bindingPattern0[2]
+            self.damageBase = minimumDamage - 1
+            self.damageDiceCount = 1
+            self.damageDiceSideCount = maximumDamage - minimumDamage + 1
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "allowedTargetCombatClassifications",
+    {
+        get = function(self)
+            return BlzGetUnitWeaponIntegerField(self.unit.handle, UNIT_WEAPON_IF_ATTACK_TARGETS_ALLOWED, self.index)
+        end,
+        set = function(self, allowedTargetCombatClassifications)
+            BlzSetUnitWeaponIntegerField(self.unit.handle, UNIT_WEAPON_IF_ATTACK_TARGETS_ALLOWED, self.index, allowedTargetCombatClassifications)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "damageBase",
+    {
+        get = function(self)
+            return BlzGetUnitBaseDamage(self.unit.handle, self.index)
+        end,
+        set = function(self, damageBase)
+            BlzSetUnitBaseDamage(self.unit.handle, self.index, damageBase)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "damageDiceCount",
+    {
+        get = function(self)
+            return BlzGetUnitDiceNumber(self.unit.handle, self.index)
+        end,
+        set = function(self, damageDiceCount)
+            BlzSetUnitDiceNumber(self.unit.handle, self.index, damageDiceCount)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "damageDiceSideCount",
+    {
+        get = function(self)
+            return BlzGetUnitDiceSides(self.unit.handle, self.index)
+        end,
+        set = function(self, damageDiceSideCount)
+            BlzSetUnitDiceSides(self.unit.handle, self.index, damageDiceSideCount)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "range",
+    {
+        get = function(self)
+            return getUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_RANGE, self.index)
+        end,
+        set = function(self, range)
+            local handle = self.unit.handle
+            local index = self.index
+            setUnitWeaponRealField(
+                handle,
+                UNIT_WEAPON_RF_ATTACK_RANGE,
+                index + 1,
+                getUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_RANGE, index + 1) + (range - getUnitWeaponRealField(handle, UNIT_WEAPON_RF_ATTACK_RANGE, index))
+            )
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "impactDelay",
+    {
+        get = function(self)
+            return getUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_DAMAGE_POINT, self.index)
+        end,
+        set = function(self, impactDelay)
+            setUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_DAMAGE_POINT, self.index, impactDelay)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "missileArc",
+    {
+        get = function(self)
+            return getUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_ARC, self.index)
+        end,
+        set = function(self, missileArc)
+            setUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_ARC, self.index, missileArc)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "missileModelPath",
+    {
+        get = function(self)
+            return getUnitWeaponStringField(self.unit.handle, UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART, self.index)
+        end,
+        set = function(self, missileModelPath)
+            setUnitWeaponStringField(self.unit.handle, UNIT_WEAPON_SF_ATTACK_PROJECTILE_ART, self.index, missileModelPath)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "missileSpeed",
+    {
+        get = function(self)
+            return getUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_SPEED, self.index)
+        end,
+        set = function(self, missileSpeed)
+            setUnitWeaponRealField(self.unit.handle, UNIT_WEAPON_RF_ATTACK_PROJECTILE_SPEED, self.index, missileSpeed)
+        end
+    },
+    true
+)
 local unitInventorySize = UnitInventorySize
 local unitItemInSlot = UnitItemInSlot
 local getItemAbility = BlzGetItemAbility
@@ -442,8 +602,6 @@ local getAbilityName = GetAbilityName
 local unitAddAbility = UnitAddAbility
 local getUnitGoldCost = GetUnitGoldCost
 local getUnitLumberCost = GetUnitWoodCost
-local unitMakeAbilityPermanent = UnitMakeAbilityPermanent
-local unitAddItem = UnitAddItem
 local unitRemoveAbility = UnitRemoveAbility
 local function retrieveAbility(unit, ability, abilityId)
     if ability == nil then
@@ -453,17 +611,6 @@ local function retrieveAbility(unit, ability, abilityId)
             ____exports.Unit:of(unit)
         )
     end
-    if not unitAddAbility(unit, abilityId) then
-        if getUnitAbility(unit, abilityId) == ability then
-            return UnitAbility:of(
-                ability,
-                abilityId,
-                ____exports.Unit:of(unit)
-            )
-        end
-    else
-        unitRemoveAbility(unit, abilityId)
-    end
     for i = 0, unitInventorySize(unit) - 1 do
         local item = unitItemInSlot(unit, i)
         if getItemAbility(item, abilityId) == ability then
@@ -510,55 +657,110 @@ local fieldSetters = {
 }
 local dummies = {}
 for ____, player in ipairs(Player.all) do
-    local dummy = assert(createUnit(
-        player.handle,
-        dummyUnitId,
-        0,
-        0,
-        270
-    ))
+    local dummy = assert(
+        createUnit(
+            player.handle,
+            dummyUnitId,
+            0,
+            0,
+            270
+        ),
+        "dummy must be created",
+        player
+    )
     ShowUnit(dummy, false)
     dummies[player] = dummy
 end
+local function delayHealthChecksCallback(unit)
+    local counter = (unit[104] or 0) - 1
+    if counter ~= 0 then
+        unit[104] = counter
+        return
+    end
+    unit[104] = nil
+    local healthBonus = unit[105]
+    if healthBonus ~= nil then
+        unit[105] = nil
+        local handle = unit.handle
+        BlzSetUnitMaxHP(
+            handle,
+            BlzGetUnitMaxHP(handle) - healthBonus
+        )
+    end
+end
+local nextSyncId = 1
+local unitBySyncId = setmetatable({}, {__mode = "v"})
+local damagingEventByTarget = setmetatable({}, {__mode = "k"})
+local function addAbility(unit, abilityTypeId)
+    local ____unitAddAbility_result_0
+    if unitAddAbility(unit, abilityTypeId) then
+        ____unitAddAbility_result_0 = getUnitAbility(unit, abilityTypeId)
+    else
+        ____unitAddAbility_result_0 = nil
+    end
+    return ____unitAddAbility_result_0
+end
 ____exports.Unit = __TS__Class()
 local Unit = ____exports.Unit
 Unit.name = "Unit"
 __TS__ClassExtends(Unit, Handle)
 function Unit.prototype.____constructor(self, handle)
     Handle.prototype.____constructor(self, handle)
+    local ____nextSyncId_1 = nextSyncId
+    nextSyncId = ____nextSyncId_1 + 1
+    self.syncId = ____nextSyncId_1
     self._owner = Player:of(getOwningPlayer(handle))
-    assert(unitAddAbility(handle, leaveDetectAbilityId) and UnitMakeAbilityPermanent(handle, true, leaveDetectAbilityId))
-    assert(unitAddAbility(handle, morphDetectAbilityId))
+    assert(
+        unitAddAbility(handle, leaveDetectAbilityId) and UnitMakeAbilityPermanent(handle, true, leaveDetectAbilityId),
+        "leave detection ability must be added",
+        self
+    )
+    assert(
+        unitAddAbility(handle, morphDetectAbilityId),
+        "morph detection ability must be added",
+        self
+    )
     if unitAddAbility(
         handle,
         fourCC("Amrf")
     ) then
-        assert(unitRemoveAbility(
-            handle,
-            fourCC("Amrf")
-        ))
+        assert(
+            unitRemoveAbility(
+                handle,
+                fourCC("Amrf")
+            ),
+            "fly ability must be removed after addition",
+            self
+        )
     end
+    unitBySyncId[self.syncId] = self
     local ____ = self.abilities
 end
-function Unit.prototype.getEvent(self, event, collector)
-    self.events = self.events or ({})
-    local eventId = GetHandleId(event)
-    if not self.events[eventId] then
-        self.events[eventId] = __TS__New(
+function Unit.prototype.getEvent(self, jevent, collector)
+    self.events = self.events or __TS__New(LinkedMap)
+    local eventId = GetHandleId(jevent)
+    local event = self.events:get(eventId)
+    if event == nil then
+        event = __TS__New(
             TriggerEvent,
             function(trigger)
-                TriggerRegisterUnitEvent(trigger, self.handle, event)
+                TriggerRegisterUnitEvent(trigger, self.handle, jevent)
             end,
             collector or (function() return {} end)
         )
+        self.events:put(eventId, event)
     end
-    return self.events[eventId]
+    return event
+end
+function Unit.prototype.saveData(self)
+    local handle = self.handle
+    self[108] = self[108] or getUnitX(handle)
+    self[109] = self[109] or getUnitY(handle)
+    self._owner = self._owner or Player:of(getOwningPlayer(handle))
 end
 function Unit.prototype.onDestroy(self)
     local handle = self.handle
-    if not self._owner then
-        self._owner = Player:of(getOwningPlayer(handle))
-    end
+    self:saveData()
     local abilities = self.abilities
     for ____, ability in ipairs(abilities) do
         ability:destroy()
@@ -594,7 +796,11 @@ function Unit.prototype.addAttackHandler(self, condition, action)
     self._attackHandlers = handlers
     if #handlers == 1 then
         local handle = self.handle
-        assert(unitAddAbility(handle, attackHandlerAbilityId) and UnitMakeAbilityPermanent(handle, true, attackHandlerAbilityId))
+        assert(
+            unitAddAbility(handle, attackHandlerAbilityId) and UnitMakeAbilityPermanent(handle, true, attackHandlerAbilityId),
+            "attack handler ability must be added",
+            self
+        )
     end
     return handler
 end
@@ -623,17 +829,17 @@ function Unit.prototype.addModifier(self, property, modifier)
     end}
 end
 function Unit.prototype.hasCombatClassification(self, combatClassification)
-    local ____combatClassification_0 = combatClassification
-    return getUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS) & ____combatClassification_0 == ____combatClassification_0
+    local ____combatClassification_2 = combatClassification
+    return getUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS) & ____combatClassification_2 == ____combatClassification_2
 end
 function Unit.prototype.addClassification(self, classification)
-    return unitAddType(self.handle, classification)
+    return UnitAddType(self.handle, classification)
 end
 function Unit.prototype.removeClassification(self, classification)
-    return unitRemoveType(self.handle, classification)
+    return UnitRemoveType(self.handle, classification)
 end
 function Unit.prototype.hasClassification(self, classification)
-    return isUnitType(self.handle, classification)
+    return IsUnitType(self.handle, classification)
 end
 function Unit.prototype.isVisibleTo(self, player)
     return isUnitVisible(self.handle, player.handle)
@@ -642,13 +848,13 @@ function Unit.prototype.isInvisibleTo(self, player)
     return isUnitInvisible(self.handle, player.handle)
 end
 function Unit.prototype.isInRangeOf(self, x, y, range)
-    local ____temp_1
+    local ____temp_3
     if type(x) == "number" then
-        ____temp_1 = isUnitInRangeXY(self.handle, x, y, range)
+        ____temp_3 = isUnitInRangeXY(self.handle, x, y, range)
     else
-        ____temp_1 = isUnitInRange(self.handle, x.handle, y)
+        ____temp_3 = isUnitInRange(self.handle, x.handle, y)
     end
-    return ____temp_1
+    return ____temp_3
 end
 function Unit.prototype.isAllyOf(self, unit)
     return isUnitAlly(
@@ -666,13 +872,31 @@ function Unit.prototype.playAnimation(self, animation, rarity)
     if type(animation) == "number" then
         setUnitAnimationByIndex(self.handle, animation)
     elseif rarity then
-        setUnitAnimationWithRarity(self.handle, animation, rarity)
+        SetUnitAnimationWithRarity(self.handle, animation, rarity)
     else
         setUnitAnimation(self.handle, animation)
     end
 end
+function Unit.prototype.resetAnimation(self)
+    ResetUnitAnimation(self.handle)
+end
 function Unit.prototype.queueAnimation(self, animation)
-    queueUnitAnimation(self.handle, animation)
+    QueueUnitAnimation(self.handle, animation)
+end
+function Unit.prototype.chooseWeapon(self, target)
+    local firstWeapon = self.firstWeapon
+    if firstWeapon.isEnabled and target:isAllowedTarget(self, firstWeapon.allowedTargetCombatClassifications) then
+        return firstWeapon
+    end
+    local secondWeapon = self.secondWeapon
+    if secondWeapon.isEnabled and target:isAllowedTarget(target, secondWeapon.allowedTargetCombatClassifications) then
+        return secondWeapon
+    end
+    return nil
+end
+function Unit.prototype.delayHealthChecks(self)
+    self[104] = (self[104] or 0) + 1
+    Timer:run(delayHealthChecksCallback, self)
 end
 function Unit.prototype.setPosition(self, x, y)
     setUnitPosition(self.handle, x, y)
@@ -681,14 +905,21 @@ function Unit.prototype.isSelected(self, player)
     return IsUnitSelected(self.handle, player.handle)
 end
 function Unit.prototype.explode(self)
-    setUnitExploded(self.handle, true)
+    SetUnitExploded(self.handle, true)
     killUnit(self.handle)
 end
 function Unit.prototype.kill(self)
     killUnit(self.handle)
 end
-function Unit.prototype.revive(self, pos, doEffect)
-    ReviveHero(self.handle, pos.x, pos.y, doEffect)
+function Unit.prototype.revive(self, x, y, doEffect)
+    local ____ReviveHero_6 = ReviveHero
+    local ____array_5 = __TS__SparseArrayNew(self.handle, x, y)
+    local ____doEffect_4 = doEffect
+    if ____doEffect_4 == nil then
+        ____doEffect_4 = false
+    end
+    __TS__SparseArrayPush(____array_5, ____doEffect_4)
+    ____ReviveHero_6(__TS__SparseArraySpread(____array_5))
 end
 function Unit.prototype.healTarget(self, target, amount)
     if __TS__InstanceOf(target, ____exports.Unit) and target:hasAbility(fourCC("BIhm")) then
@@ -728,20 +959,19 @@ function Unit.prototype.dropItemSlot(self, item, slot)
     return UnitDropItemSlot(self.handle, item.handle, slot)
 end
 function Unit.prototype.itemInSlot(self, slot)
-    return Item:of(UnitItemInSlot(self.handle, slot))
+    return Item:of(unitItemInSlot(self.handle, slot))
 end
 function Unit.prototype.addAbility(self, abilityId)
-    if unitAddAbility(self.handle, abilityId) then
-        local ability = UnitAbility:of(
-            checkNotNull(getUnitAbility(self.handle, abilityId)),
-            abilityId,
-            self
-        )
+    local ability = UnitAbility:of(
+        doUnitAbilityAction(self.handle, abilityId, addAbility, abilityId),
+        abilityId,
+        self
+    )
+    if ability ~= nil then
         local abilities = self.abilities
         abilities[#abilities + 1] = ability
-        return ability
     end
-    return nil
+    return ability
 end
 function Unit.prototype.makeAbilityPermanent(self, abilityId, permanent)
     return UnitMakeAbilityPermanent(self.handle, permanent, abilityId)
@@ -755,47 +985,44 @@ end
 function Unit.prototype.hasAbility(self, abilityId)
     return getUnitAbilityLevel(self.handle, abilityId) > 0
 end
-function Unit.prototype.getAbilityById(self, abilityId)
-    local handle = self.handle
-    if unitAddAbility(handle, abilityId) then
-        assert(unitRemoveAbility(handle, abilityId))
-        return nil
-    end
-    return UnitAbility:of(
-        getUnitAbility(self.handle, abilityId),
-        abilityId,
-        self
-    )
+function Unit.prototype.getAbility(self, abilityId)
+    local ability = doUnitAbilityAction(self.handle, abilityId, getUnitAbility, abilityId)
+    return UnitAbility:of(ability, abilityId, self)
 end
-function Unit.prototype.removeAbility(self, abilityId)
-    if unitRemoveAbility(self.handle, abilityId) then
-        local abilities = self.abilities
-        for i = 1, #abilities do
-            if abilities[i].typeId == abilityId then
-                abilities[i]:destroy()
-                tremove(abilities, i)
-                return true
-            end
+function Unit.prototype.removeAbility(self, abilityTypeId)
+    local abilities = self.abilities
+    for i = 1, #abilities do
+        if abilities[i].typeId == abilityTypeId then
+            local ability = abilities[i]
+            tremove(abilities, i)
+            ability:destroy()
+            return true
         end
-        return true
     end
-    return false
+    return doUnitAbilityAction(self.handle, abilityTypeId, unitRemoveAbility, abilityTypeId)
 end
 function Unit.prototype.hideAbility(self, abilityId, flag)
     BlzUnitHideAbility(self.handle, abilityId, flag)
 end
+function Unit.prototype.getAbilityRemainingCooldown(self, abilityId)
+    return BlzGetUnitAbilityCooldownRemaining(self.handle, abilityId)
+end
 function Unit.prototype.startAbilityCooldown(self, abilityId, cooldown)
     BlzStartUnitAbilityCooldown(self.handle, abilityId, cooldown)
 end
 function Unit.prototype.endAbilityCooldown(self, abilityId)
     BlzEndUnitAbilityCooldown(self.handle, abilityId)
 end
-function Unit.prototype.interruptAttack(self)
-    unitInterruptAttack(self.handle)
-end
 function Unit.prototype.interruptCast(self, abilityId)
-    unitDisableAbility(self.handle, abilityId, true, false)
-    unitDisableAbility(self.handle, abilityId, false, false)
+    local handle = self.handle
+    unitDisableAbility(handle, abilityId, true, false)
+    Timer:run(
+        unitDisableAbility,
+        handle,
+        abilityId,
+        false,
+        false
+    )
 end
 function Unit.prototype.getDistanceTo(self, target)
     local handle = self.handle
@@ -855,18 +1082,44 @@ function Unit.prototype.unpauseEx(self)
     self:decrementStunCounter()
 end
 function Unit.prototype.incrementStunCounter(self)
-    local stunCounter = self[101] or 0
-    if not self[100] or stunCounter >= 0 then
+    local stunCounter = self[102] or 0
+    if not self[101] and (self[103] or 0) <= 0 or stunCounter >= 0 then
         BlzPauseUnitEx(self.handle, true)
     end
-    self[101] = stunCounter + 1
+    self[102] = stunCounter + 1
 end
 function Unit.prototype.decrementStunCounter(self)
-    local stunCounter = self[101] or 0
-    if not self[100] or stunCounter >= 1 then
+    local stunCounter = self[102] or 0
+    if not self[101] and (self[103] or 0) <= 0 or stunCounter >= 1 then
         BlzPauseUnitEx(self.handle, false)
     end
-    self[101] = stunCounter - 1
+    self[102] = stunCounter - 1
+end
+function Unit.prototype.incrementForceStunCounter(self)
+    local forceStunCounter = self[103] or 0
+    if forceStunCounter == 0 then
+        local handle = self.handle
+        if not self[101] then
+            for _ = self[102] or 0, -1 do
+                BlzPauseUnitEx(handle, true)
+            end
+        end
+        BlzPauseUnitEx(handle, true)
+    end
+    self[103] = forceStunCounter + 1
+end
+function Unit.prototype.decrementForceStunCounter(self)
+    local forceStunCounter = self[103] or 0
+    if forceStunCounter == 1 then
+        local handle = self.handle
+        if not self[101] then
+            for _ = self[102] or 0, -1 do
+                BlzPauseUnitEx(handle, false)
+            end
+        end
+        BlzPauseUnitEx(handle, false)
+    end
+    self[103] = forceStunCounter - 1
 end
 function Unit.create(self, owner, id, x, y, facing, skinId)
     local handle = skinId and BlzCreateUnitWithSkin(
@@ -968,8 +1221,11 @@ function Unit.getInSector(self, pos, range, offsetAngle, centralAngle)
     )
     return targetCollection
 end
-function Unit.getSelectionOf(self, player)
-    targetCollection = {}
+function Unit.getSelectionOf(self, player, target)
+    if target == nil then
+        target = {}
+    end
+    targetCollection = target
     targetCollectionNextIndex = 1
     GroupEnumUnitsSelected(dummyGroup, player.handle, collectIntoTarget)
     return targetCollection
@@ -991,6 +1247,9 @@ end
 function Unit.prototype.__tostring(self)
     return (((self.constructor.name .. "$") .. util.id2s(self.typeId)) .. "@") .. tostring(getHandleId(self.handle))
 end
+function Unit.getBySyncId(self, syncId)
+    return unitBySyncId[syncId]
+end
 __TS__SetDescriptor(
     Unit.prototype,
     "_deltas",
@@ -1050,7 +1309,15 @@ __TS__SetDescriptor(
     Unit.prototype,
     "isIllusion",
     {get = function(self)
-        return isUnitIllusion(self.handle)
+        return IsUnitIllusion(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isStunned",
+    {get = function(self)
+        return getUnitCurrentOrder(self.handle) == orderId("stunned")
     end},
     true
 )
@@ -1071,12 +1338,27 @@ __TS__SetDescriptor(
     Unit.prototype,
     "weapons",
     {get = function(self)
-        local weapons = {
-            setmetatable({h = self.handle, i = 0}, weaponMetatable),
-            setmetatable({h = self.handle, i = 1}, weaponMetatable)
-        }
-        rawset(self, "weapons", weapons)
-        return weapons
+        return {self.firstWeapon, self.secondWeapon}
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "firstWeapon",
+    {get = function(self)
+        local weapon = __TS__New(____exports.UnitWeapon, self, 0)
+        rawset(self, "firstWeapon", weapon)
+        return weapon
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "secondWeapon",
+    {get = function(self)
+        local weapon = __TS__New(____exports.UnitWeapon, self, 1)
+        rawset(self, "secondWeapon", weapon)
+        return weapon
     end},
     true
 )
@@ -1114,13 +1396,13 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Unit.prototype,
-    "strengthBase",
+    "primaryAttribute",
     {
         get = function(self)
-            return getHeroStr(self.handle, false)
+            return getUnitIntegerField(self.handle, UNIT_IF_PRIMARY_ATTRIBUTE)
         end,
-        set = function(self, strengthBase)
-            setHeroStr(self.handle, strengthBase, true)
+        set = function(self, primaryAttribute)
+            setUnitIntegerField(self.handle, UNIT_IF_PRIMARY_ATTRIBUTE, primaryAttribute)
         end
     },
     true
@@ -1142,19 +1424,6 @@ __TS__SetDescriptor(
     end},
     true
 )
-__TS__SetDescriptor(
-    Unit.prototype,
-    "agilityBase",
-    {
-        get = function(self)
-            return getHeroAgi(self.handle, false)
-        end,
-        set = function(self, agilityBase)
-            setHeroAgi(self.handle, agilityBase, true)
-        end
-    },
-    true
-)
 __TS__SetDescriptor(
     Unit.prototype,
     "agilityBonus",
@@ -1172,19 +1441,6 @@ __TS__SetDescriptor(
     end},
     true
 )
-__TS__SetDescriptor(
-    Unit.prototype,
-    "intelligenceBase",
-    {
-        get = function(self)
-            return getHeroInt(self.handle, false)
-        end,
-        set = function(self, intelligenceBase)
-            setHeroInt(self.handle, intelligenceBase, true)
-        end
-    },
-    true
-)
 __TS__SetDescriptor(
     Unit.prototype,
     "intelligenceBonus",
@@ -1233,17 +1489,17 @@ __TS__SetDescriptor(
     "isTeamGlowVisible",
     {
         get = function(self)
-            return not self[103]
+            return not self[107]
         end,
         set = function(self, isTeamGlowVisible)
-            showUnitTeamGlow(self.handle, isTeamGlowVisible)
-            local ____temp_2
+            BlzShowUnitTeamGlow(self.handle, isTeamGlowVisible)
+            local ____temp_7
             if not isTeamGlowVisible then
-                ____temp_2 = true
+                ____temp_7 = true
             else
-                ____temp_2 = nil
+                ____temp_7 = nil
             end
-            self[103] = ____temp_2
+            self[107] = ____temp_7
         end
     },
     true
@@ -1252,9 +1508,9 @@ __TS__SetDescriptor(
     Unit.prototype,
     "color",
     {set = function(self, color)
-        setUnitColor(self.handle, color.handle)
-        if self[103] then
-            showUnitTeamGlow(self.handle, false)
+        SetUnitColor(self.handle, color.handle)
+        if self[107] then
+            BlzShowUnitTeamGlow(self.handle, false)
         end
     end},
     true
@@ -1277,10 +1533,14 @@ __TS__SetDescriptor(
     "maxHealth",
     {
         get = function(self)
-            return BlzGetUnitMaxHP(self.handle) - (self[102] or 0)
+            return BlzGetUnitMaxHP(self.handle) - (self[105] or 0) - (self[106] or 0)
         end,
         set = function(self, maxHealth)
-            BlzSetUnitMaxHP(self.handle, maxHealth + (self[102] or 0))
+            if maxHealth < 1 and self[104] ~= nil then
+                self[105] = (self[105] or 0) + (1 - maxHealth)
+                maxHealth = 1
+            end
+            BlzSetUnitMaxHP(self.handle, maxHealth + (self[106] or 0))
         end
     },
     true
@@ -1322,10 +1582,10 @@ __TS__SetDescriptor(
     "health",
     {
         get = function(self)
-            return GetWidgetLife(self.handle) - (self[102] or 0)
+            return GetWidgetLife(self.handle) - (self[106] or 0)
         end,
         set = function(self, health)
-            SetWidgetLife(self.handle, health + (self[102] or 0))
+            SetWidgetLife(self.handle, health + (self[106] or 0))
         end
     },
     true
@@ -1401,25 +1661,12 @@ __TS__SetDescriptor(
     },
     true
 )
-__TS__SetDescriptor(
-    Unit.prototype,
-    "flyHeight",
-    {
-        get = function(self)
-            return getUnitFlyHeight(self.handle)
-        end,
-        set = function(self, v)
-            SetUnitFlyHeight(self.handle, v, 100000)
-        end
-    },
-    true
-)
 __TS__SetDescriptor(
     Unit.prototype,
     "x",
     {
         get = function(self)
-            return getUnitX(self.handle)
+            return self[108] or getUnitX(self.handle)
         end,
         set = function(self, v)
             SetUnitX(self.handle, v)
@@ -1432,7 +1679,7 @@ __TS__SetDescriptor(
     "y",
     {
         get = function(self)
-            return getUnitY(self.handle)
+            return self[109] or getUnitY(self.handle)
         end,
         set = function(self, v)
             SetUnitY(self.handle, v)
@@ -1518,10 +1765,10 @@ __TS__SetDescriptor(
     "gold",
     {
         get = function(self)
-            return getResourceAmount(self.handle)
+            return GetResourceAmount(self.handle)
         end,
         set = function(self, gold)
-            setResourceAmount(self.handle, gold)
+            SetResourceAmount(self.handle, gold)
         end
     },
     true
@@ -1536,17 +1783,21 @@ __TS__SetDescriptor(
         set = function(self, isPaused)
             local handle = self.handle
             if isPaused and not IsUnitPaused(handle) then
-                self[100] = true
-                for _ = self[101] or 0, -1 do
-                    BlzPauseUnitEx(handle, true)
+                self[101] = true
+                if (self[103] or 0) <= 0 then
+                    for _ = self[102] or 0, -1 do
+                        BlzPauseUnitEx(handle, true)
+                    end
                 end
                 PauseUnit(handle, true)
             elseif not isPaused and IsUnitPaused(handle) then
                 PauseUnit(handle, false)
-                for _ = self[101] or 0, -1 do
-                    BlzPauseUnitEx(handle, false)
+                if (self[103] or 0) <= 0 then
+                    for _ = self[102] or 0, -1 do
+                        BlzPauseUnitEx(handle, false)
+                    end
                 end
-                self[100] = nil
+                self[101] = nil
             end
         end
     },
@@ -1602,20 +1853,6 @@ __TS__SetDescriptor(
     },
     true
 )
-__TS__SetDescriptor(
-    Unit.prototype,
-    "scale",
-    {
-        get = function(self)
-            return getUnitRealField(self.handle, UNIT_RF_SCALING_VALUE)
-        end,
-        set = function(self, v)
-            setUnitScale(self.handle, v, v, v)
-            setUnitRealField(self.handle, UNIT_RF_SCALING_VALUE, v)
-        end
-    },
-    true
-)
 __TS__SetDescriptor(
     Unit.prototype,
     "timeScale",
@@ -1649,6 +1886,19 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    Unit.prototype,
+    "movementType",
+    {
+        get = function(self)
+            return getUnitIntegerField(self.handle, UNIT_IF_MOVE_TYPE)
+        end,
+        set = function(self, movementType)
+            setUnitIntegerField(self.handle, UNIT_IF_MOVE_TYPE, movementType)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Unit.prototype,
     "pathing",
@@ -1739,30 +1989,6 @@ __TS__SetDescriptor(
     end},
     true
 )
-__TS__SetDescriptor(
-    Unit.prototype,
-    "onUnitInRange",
-    {get = function(self)
-        local handle = self.handle
-        local onUnitInRange = setmetatable(
-            {},
-            {__index = function(self, value)
-                local event = __TS__New(
-                    TriggerEvent,
-                    function(trigger)
-                        TriggerRegisterUnitInRangeSimple(trigger, value, handle)
-                    end,
-                    function() return ____exports.Unit:of(handle) end
-                )
-                rawset(self, value, event)
-                return event
-            end}
-        )
-        rawset(self, "onUnitInRange", onUnitInRange)
-        return onUnitInRange
-    end},
-    true
-)
 __TS__SetDescriptor(
     Unit.prototype,
     "onManaEqual",
@@ -1830,6 +2056,14 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    Unit.prototype,
+    "targetAcquiredEvent",
+    {get = function(self)
+        return self:getEvent(EVENT_UNIT_ACQUIRED_TARGET)
+    end},
+    true
+)
 __TS__SetDescriptor(
     Unit.prototype,
     "onSelect",
@@ -1890,6 +2124,11 @@ __TS__SetDescriptor(
     end},
     true
 )
+Unit.levelChangedEvent = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_HERO_LEVEL,
+    function() return ____exports.Unit:of(getTriggerUnit()) end
+)
 Unit.deathEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_DEATH,
@@ -1903,7 +2142,6 @@ Unit.onDecay = __TS__New(
 Unit.onResurrect = __TS__New(
     InitializingEvent,
     function(event)
-        local invoke = Event.invoke
         local dead = setmetatable({}, {__mode = "k"})
         ____exports.Unit.deathEvent:addListener(function(unit)
             dead[unit] = true
@@ -1919,10 +2157,15 @@ Unit.onResurrect = __TS__New(
 Unit.morphEvent = __TS__New(
     InitializingEvent,
     function(event)
+        local function ifNotLeft(unit)
+            local handle = unit.handle
+            if getUnitAbilityLevel(handle, leaveDetectAbilityId) ~= 0 and unitAddAbility(handle, morphDetectAbilityId) then
+                invoke(event, unit)
+            end
+        end
         ____exports.Unit.onImmediateOrder[orderId("undefend")]:addListener(function(unit)
             if getUnitAbilityLevel(unit.handle, morphDetectAbilityId) == 0 then
-                assert(unitAddAbility(unit.handle, morphDetectAbilityId))
-                Timer:run(Event.invoke, event, unit)
+                Timer:run(ifNotLeft, unit)
             end
         end)
     end
@@ -1960,27 +2203,26 @@ Unit.onSpellEffect = dispatchId(__TS__New(
 Unit.onTargetCast = dispatchId(__TS__New(
     InitializingEvent,
     function(event)
-        local invoke = Event.invoke
         local function listener(unit, id)
-            local ____GetSpellTargetUnit_result_5
+            local ____GetSpellTargetUnit_result_10
             if GetSpellTargetUnit() then
-                ____GetSpellTargetUnit_result_5 = ____exports.Unit:of(GetSpellTargetUnit())
+                ____GetSpellTargetUnit_result_10 = ____exports.Unit:of(GetSpellTargetUnit())
             else
-                local ____GetSpellTargetItem_result_4
+                local ____GetSpellTargetItem_result_9
                 if GetSpellTargetItem() then
-                    ____GetSpellTargetItem_result_4 = Item:of(GetSpellTargetItem())
+                    ____GetSpellTargetItem_result_9 = Item:of(GetSpellTargetItem())
                 else
-                    local ____GetSpellTargetDestructable_result_3
+                    local ____GetSpellTargetDestructable_result_8
                     if GetSpellTargetDestructable() then
-                        ____GetSpellTargetDestructable_result_3 = Destructable:of(GetSpellTargetDestructable())
+                        ____GetSpellTargetDestructable_result_8 = Destructable:of(GetSpellTargetDestructable())
                     else
-                        ____GetSpellTargetDestructable_result_3 = nil
+                        ____GetSpellTargetDestructable_result_8 = nil
                     end
-                    ____GetSpellTargetItem_result_4 = ____GetSpellTargetDestructable_result_3
+                    ____GetSpellTargetItem_result_9 = ____GetSpellTargetDestructable_result_8
                 end
-                ____GetSpellTargetUnit_result_5 = ____GetSpellTargetItem_result_4
+                ____GetSpellTargetUnit_result_10 = ____GetSpellTargetItem_result_9
             end
-            local target = ____GetSpellTargetUnit_result_5
+            local target = ____GetSpellTargetUnit_result_10
             if target then
                 invoke(event, unit, id, target)
             end
@@ -2152,10 +2394,12 @@ Unit.onImmediateOrder = dispatchId(__TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_ISSUED_ORDER,
     function()
-        local unit = ____exports.Unit:of(getOrderedUnit())
-        local issuedOrderId = getIssuedOrderId()
-        if unit ~= nil and unit.state == 1 then
-            return unit, issuedOrderId
+        local handle = getOrderedUnit()
+        if handle ~= nil and getUnitTypeId(handle) ~= dummyUnitId then
+            local unit = ____exports.Unit:of(handle)
+            if unit.state == 1 then
+                return unit, getIssuedOrderId()
+            end
         end
         return IgnoreEvent
     end
@@ -2177,7 +2421,6 @@ Unit.autoAttackStartEvent = __TS__New(
 )
 Unit.onDamaging = (function()
     local event = __TS__New(Event)
-    local invoke = Event.invoke
     local trigger = CreateTrigger()
     TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_DAMAGING)
     TriggerAddCondition(
@@ -2187,38 +2430,57 @@ Unit.onDamaging = (function()
             if source and source.typeId == dummyUnitId then
                 source = nil
             end
-            local target = BlzGetEventDamageTarget()
+            local target = ____exports.Unit:of(BlzGetEventDamageTarget())
+            local metadata = damageMetadataByTarget[target]
+            damageMetadataByTarget[target] = nil
             local data = {
                 amount = GetEventDamage(),
-                attackType = BlzGetEventAttackType(),
+                attackType = nativeToAttackType(BlzGetEventAttackType()),
                 damageType = BlzGetEventDamageType(),
                 weaponType = BlzGetEventWeaponType(),
-                isAttack = BlzGetEventIsAttack()
+                metadata = metadata,
+                isAttack = BlzGetEventIsAttack(),
+                originalAmount = GetEventDamage(),
+                originalMetadata = metadata,
+                preventRetaliation = damagingEventPreventRetaliation
             }
             if data.isAttack and source then
-                local weapon = BlzGetUnitWeaponBooleanField(source.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, 1) and (BlzGetUnitWeaponBooleanField(source.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, 0) and -1 or 1) or 0
-                if weapon == -1 then
-                    local targetsAllowed = BlzGetUnitWeaponIntegerField(source.handle, UNIT_WEAPON_IF_ATTACK_TARGETS_ALLOWED, 0)
-                    weapon = 0
-                end
-                data.weapon = assert(source.weapons[weapon + 1])
+                data.weapon = source:chooseWeapon(target)
             end
             if not data.isAttack or not source or not source._attackHandlers then
                 invoke(
                     event,
                     source,
-                    ____exports.Unit:of(target),
+                    target,
                     setmetatable(
                         {},
                         {
                             __index = data,
                             __newindex = function(self, key, value)
-                                damageSetters[key](value)
+                                local damageSetter = damageSetters[key]
+                                if damageSetter ~= nil then
+                                    damageSetter(value)
+                                end
                                 data[key] = value
                             end
                         }
                     )
                 )
+                if data[0] and source then
+                    local sourceOwner = source.owner.handle
+                    data[1] = sourceOwner
+                    local targetOwner = target.owner.handle
+                    data[2] = targetOwner
+                    if not GetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE) then
+                        SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, true)
+                        data[3] = true
+                    end
+                    if not GetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE) then
+                        SetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE, true)
+                        data[4] = true
+                    end
+                end
+                damagingEventByTarget[target] = data
                 return
             end
             BlzSetEventDamage(0)
@@ -2226,7 +2488,7 @@ Unit.onDamaging = (function()
             BlzSetEventDamageType(DAMAGE_TYPE_UNKNOWN)
             BlzSetEventWeaponType(WEAPON_TYPE_WHOKNOWS)
             local sourceOwner = source.owner.handle
-            local targetOwner = GetOwningPlayer(target)
+            local targetOwner = target.owner.handle
             if not GetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE) then
                 SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, true)
                 Timer:run(function()
@@ -2242,23 +2504,19 @@ Unit.onDamaging = (function()
             for ____, ____value in ipairs(source._attackHandlers) do
                 local condition = ____value[1]
                 local action = ____value[2]
-                if condition(
-                    source,
-                    ____exports.Unit:of(target),
-                    data
-                ) then
+                if condition(source, target, data) then
                     action(
                         source,
-                        ____exports.Unit:of(target),
+                        target,
                         setmetatable(
                             {fire = function()
                                 UnitDamageTarget(
                                     source.handle,
-                                    target,
+                                    target.handle,
                                     data.amount,
                                     true,
                                     true,
-                                    data.attackType,
+                                    attackTypeToNative(data.attackType),
                                     data.damageType,
                                     data.weaponType
                                 )
@@ -2276,7 +2534,6 @@ end)()
 Unit.onDamage = __TS__New(
     InitializingEvent,
     function(event)
-        local invoke = Event.invoke
         local trigger = CreateTrigger()
         TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_DAMAGED)
         TriggerAddCondition(
@@ -2286,29 +2543,54 @@ Unit.onDamage = __TS__New(
                 if source and source.typeId == dummyUnitId then
                     source = nil
                 end
+                local target = ____exports.Unit:of(BlzGetEventDamageTarget())
+                local damagingEvent = damagingEventByTarget[target]
+                damagingEventByTarget[target] = nil
                 local data = {
                     amount = GetEventDamage(),
-                    attackType = BlzGetEventAttackType(),
+                    attackType = nativeToAttackType(BlzGetEventAttackType()),
                     damageType = BlzGetEventDamageType(),
                     weaponType = BlzGetEventWeaponType(),
+                    metadata = damagingEvent and damagingEvent.metadata,
                     isAttack = BlzGetEventIsAttack(),
+                    originalAmount = damagingEvent and damagingEvent.originalAmount or GetEventDamage(),
+                    originalMetadata = damagingEvent and damagingEvent.originalMetadata,
                     preventDeath = damageEventPreventDeath
                 }
+                if damagingEvent then
+                    for key, value in pairs(damagingEvent) do
+                        if isAttribute(key) then
+                            data[key] = value
+                        end
+                    end
+                    local sourceOwner = damagingEvent[1]
+                    if sourceOwner then
+                        local targetOwner = damagingEvent[2]
+                        if damagingEvent[3] then
+                            SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, false)
+                        end
+                        if damagingEvent[4] then
+                            SetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE, false)
+                        end
+                    end
+                end
                 local evData = setmetatable(
                     {},
                     {
                         __index = data,
                         __newindex = function(self, key, value)
-                            damageSetters[key](value)
+                            local damageSetter = damageSetters[key]
+                            if damageSetter ~= nil then
+                                damageSetter(value)
+                            end
                             data[key] = value
                         end
                     }
                 )
-                local target = ____exports.Unit:of(BlzGetEventDamageTarget())
                 invoke(event, source, target, evData)
                 if evData[0] ~= nil and target.health - evData.amount < 0.405 then
                     local bonusHealth = math.ceil(evData.amount)
-                    target[102] = (target[102] or 0) + bonusHealth
+                    target[106] = (target[106] or 0) + bonusHealth
                     BlzSetUnitMaxHP(
                         target.handle,
                         BlzGetUnitMaxHP(target.handle) + bonusHealth
@@ -2322,7 +2604,7 @@ Unit.onDamage = __TS__New(
                             evData[0],
                             table.unpack(evData, 1 + 1, 1 + (evData[1] or 0))
                         )
-                        target[102] = (target[102] or 0) - bonusHealth
+                        target[106] = (target[106] or 0) - bonusHealth
                         SetWidgetLife(
                             target.handle,
                             GetWidgetLife(target.handle) - bonusHealth
@@ -2342,32 +2624,110 @@ Unit.onDamage = __TS__New(
         DestroyTrigger(trigger)
     end
 )
-Unit.onItemDrop = __TS__New(
+Unit.itemDroppedEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_DROP_ITEM,
     function()
         local unit = getTriggerUnit()
-        if getUnitTypeId(unit) ~= dummyUnitId then
-            return ____exports.Unit:of(unit), Item:of(getManipulatedItem())
+        local item = getManipulatedItem()
+        if getUnitTypeId(unit) ~= dummyUnitId and not (ignoreEventsItems[item] ~= nil) then
+            return ____exports.Unit:of(unit), Item:of(item)
         end
         return IgnoreEvent
     end
 )
-Unit.onItemPickup = __TS__New(
+Unit.itemPickedUpEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_PICKUP_ITEM,
     function()
-        local unit = getTriggerUnit()
-        if getUnitTypeId(unit) ~= dummyUnitId then
-            return ____exports.Unit:of(unit), Item:of(getManipulatedItem())
+        local unitHandle = getTriggerUnit()
+        local itemHandle = getManipulatedItem()
+        if getUnitTypeId(unitHandle) ~= dummyUnitId and not (ignoreEventsItems[itemHandle] ~= nil) then
+            local unit = ____exports.Unit:of(unitHandle)
+            local item = Item:of(itemHandle)
+            if item.owner ~= unit then
+                return unit, item
+            end
         end
         return IgnoreEvent
     end
 )
-Unit.onItemUse = __TS__New(
+Unit.itemUsedEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_USE_ITEM,
-    function() return ____exports.Unit:of(GetTriggerUnit()), Item:of(GetManipulatedItem()) end
+    function()
+        local unit = getTriggerUnit()
+        local item = getManipulatedItem()
+        if getUnitTypeId(unit) ~= dummyUnitId and not (ignoreEventsItems[item] ~= nil) then
+            return ____exports.Unit:of(unit), Item:of(item)
+        end
+        return IgnoreEvent
+    end
+)
+Unit.itemStackedEvent = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_STACK_ITEM,
+    function() return ____exports.Unit:of(getTriggerUnit()), Item:of(BlzGetStackingItemTarget()), Item:of(BlzGetStackingItemSource()) end
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "itemChargesChangedEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        Item.chargesChangedEvent:addListener(function(item)
+            local unit = item.owner
+            if unit ~= nil then
+                invoke(event, unit, item)
+            end
+        end)
+        rawset(self, "itemChargesChangedEvent", event)
+        return event
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "itemUseOrderEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        for order = orderId("useslot0"), orderId("useslot5") do
+            local slot = order - orderId("useslot0")
+            local function listener(unit)
+                local item = unit.items[slot + 1]
+                if item ~= nil then
+                    invoke(event, unit, item)
+                end
+            end
+            self.onImmediateOrder[order]:addListener(listener)
+            self.onTargetOrder[order]:addListener(listener)
+            self.onPointOrder[order]:addListener(listener)
+        end
+        rawset(self, "itemUseOrderEvent", event)
+        return event
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "itemMoveOrderEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        for order = orderId("moveslot0"), orderId("moveslot5") do
+            local slotTo = order - orderId("moveslot0")
+            self.onTargetOrder[order]:addListener(function(unit, item)
+                local slotFrom = unit.items:findSlot(item)
+                if slotFrom ~= nil then
+                    invoke(
+                        event,
+                        unit,
+                        item,
+                        slotFrom,
+                        slotTo
+                    )
+                end
+            end)
+        end
+        rawset(self, "itemMoveOrderEvent", event)
+        return event
+    end}
 )
 __TS__ObjectDefineProperty(
     Unit,
@@ -2394,6 +2754,10 @@ __TS__ObjectDefineProperty(
         rawset(self, "destroyEvent", destroyEvent)
         return destroyEvent
     end}
+)
+Unit.synchronize = synchronizer(
+    function(unit) return unit.syncId end,
+    function(syncId) return unitBySyncId[syncId] end
 );
 (function(self)
     local leaveAbilityIds = postcompile(function()
@@ -2423,7 +2787,8 @@ __TS__ObjectDefineProperty(
                     return
                 end
             end
-            unit:destroy()
+            unit:saveData()
+            Timer:run(unit, "destroy")
         end)
     end
 end)(Unit)