warscript 0.0.1-dev.404878c

package/engine/internal/unit.lua

@@ -0,0 +1,2430 @@
+local ____lualib = require("lualib_bundle")
+local __TS__StringSplit = ____lualib.__TS__StringSplit
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+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__ArraySetLength = ____lualib.__TS__ArraySetLength
+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
+local ____exports = {}
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____event = require("event")
+local Event = ____event.Event
+local IgnoreEvent = ____event.IgnoreEvent
+local InitializingEvent = ____event.InitializingEvent
+local TriggerEvent = ____event.TriggerEvent
+local ____color = require("core.types.color")
+local Color = ____color.Color
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____destructable = require("core.types.destructable")
+local Destructable = ____destructable.Destructable
+local ____ability = require("objutil.ability")
+local AbilityDefinition = ____ability.AbilityDefinition
+local AbilityDefinitionLightningAttack = ____ability.AbilityDefinitionLightningAttack
+local AbilityDefinitionSpikedCarapace = ____ability.AbilityDefinitionSpikedCarapace
+local ____ability = require("engine.internal.ability")
+local ItemAbility = ____ability.ItemAbility
+local UnitAbility = ____ability.UnitAbility
+local UnrecognizedAbility = ____ability.UnrecognizedAbility
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____dummy = require("objutil.dummy")
+local dummyUnitId = ____dummy.dummyUnitId
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+local ____constants = require("engine.constants")
+local HEALTH_REGENERATION_RATE_BONUS_PER_STRENGTH_POINT = ____constants.HEALTH_REGENERATION_RATE_BONUS_PER_STRENGTH_POINT
+local MANA_REGENERATION_RATE_BONUS_PER_INTELLIGENCE_POINT = ____constants.MANA_REGENERATION_RATE_BONUS_PER_INTELLIGENCE_POINT
+local ____arrays = require("utility.arrays")
+local forEach = ____arrays.forEach
+local ____math = require("math")
+local min = ____math.min
+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 createUnit = CreateUnit
+local killUnit = KillUnit
+local setUnitExploded = SetUnitExploded
+local removeUnit = RemoveUnit
+local getUnitTypeId = GetUnitTypeId
+local isHeroUnitId = IsHeroUnitId
+local getTriggerUnit = GetTriggerUnit
+local getManipulatedItem = GetManipulatedItem
+local getTriggerPlayer = GetTriggerPlayer
+local getSpellAbility = GetSpellAbility
+local getSpellAbilityId = GetSpellAbilityId
+local getSpellTargetUnit = GetSpellTargetUnit
+local getSpellTargetX = GetSpellTargetX
+local getSpellTargetY = GetSpellTargetY
+local getSpellTargetItem = GetSpellTargetItem
+local getSpellTargetDestructable = GetSpellTargetDestructable
+local isUnitInRangeXY = IsUnitInRangeXY
+local isUnitInRange = IsUnitInRange
+local setResourceAmount = SetResourceAmount
+local getResourceAmount = GetResourceAmount
+local getUnitAbilityLevel = GetUnitAbilityLevel
+local unitDisableAbility = BlzUnitDisableAbility
+local unitInterruptAttack = BlzUnitInterruptAttack
+local isUnitInvisible = IsUnitInvisible
+local isUnitVisible = IsUnitVisible
+local getUnitX = GetUnitX
+local getUnitY = GetUnitY
+local getUnitFlyHeight = GetUnitFlyHeight
+local moveLocation = MoveLocation
+local getLocationZ = GetLocationZ
+local groupEnumUnitsInRange = GroupEnumUnitsInRange
+local groupEnumUnitsInRect = GroupEnumUnitsInRect
+local groupEnumUnitsOfPlayer = GroupEnumUnitsOfPlayer
+local getFilterUnit = GetFilterUnit
+local getUnitCollisionSize = BlzGetUnitCollisionSize
+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
+    UnitClassification.STRUCTURE = UNIT_TYPE_STRUCTURE
+    UnitClassification.UNDEAD = UNIT_TYPE_UNDEAD
+    UnitClassification.AIR = UNIT_TYPE_FLYING
+    UnitClassification.GROUND = UNIT_TYPE_GROUND
+    UnitClassification.SUMMONED = UNIT_TYPE_SUMMONED
+    UnitClassification.MECHANICAL = UNIT_TYPE_MECHANICAL
+    UnitClassification.ANCIENT = UNIT_TYPE_ANCIENT
+    UnitClassification.SUICIDAL = UNIT_TYPE_SAPPER
+    UnitClassification.TAUREN = UNIT_TYPE_TAUREN
+    UnitClassification.RESISTANT = UNIT_TYPE_RESISTANT
+end
+local tremove = table.remove
+local loc = Location(0, 0)
+local invoke = Event.invoke
+local stockAbilities = postcompile(function()
+    local abilityData = {}
+    if currentMap then
+        for id, unit in pairs(currentMap.objects.unit.all) do
+            local ids = __TS__ArrayMap(
+                __TS__ArrayFilter(
+                    __TS__StringSplit(
+                        tostring(unit:getField("uabi") or ""),
+                        ","
+                    ),
+                    function(____, id) return id ~= "_" and id ~= "" end
+                ),
+                function(____, id) return fourCC(id) end
+            )
+            if #ids ~= 0 then
+                abilityData[fourCC(id)] = ids
+            end
+        end
+    end
+    return abilityData
+end)
+local attackHandlerAbilityId = compiletime(function()
+    local ability = __TS__New(AbilityDefinitionLightningAttack)
+    ability.graphicDelay = 0
+    ability.graphicDuration = 0
+    ability.lightningEffects = {}
+    ability.missileArt = ""
+    ability.missileSpeed = 0
+    ability.targetArt = ""
+    return fourCC(ability.id)
+end)
+local leaveDetectAbilityId = compiletime(fourCC(__TS__New(AbilityDefinition, "Adef").id))
+for ____, player in ipairs(Player.all) do
+    SetPlayerAbilityAvailable(player.handle, leaveDetectAbilityId, false)
+end
+local morphDetectAbilityId = compiletime(fourCC(__TS__New(AbilityDefinition, "Adef").id))
+for ____, player in ipairs(Player.all) do
+    SetPlayerAbilityAvailable(player.handle, morphDetectAbilityId, false)
+end
+local armorBonusAbilityId = compiletime(function()
+    local ability = __TS__New(AbilityDefinitionSpikedCarapace)
+    ability.levels = 1
+    ability.returnedDamageFactor = 0
+    ability.receivedDamageFactor = 1
+    ability.armorBonus = 0
+    return fourCC(ability.id)
+end)
+local armorBonusField = ABILITY_RLF_DEFENSE_BONUS_UTS3
+local atan = math.atan
+local fmod = math.fmod
+local sqrt = math.sqrt
+local max = math.max
+local rad = math.rad
+local pi2 = 2 * math.pi
+local dummyGroup = CreateGroup()
+local targetCollection
+local targetCollectionNextIndex
+local centerX
+local centerY
+local enumRange
+local enumPredicate
+local collectIntoTarget = Filter(function()
+    local unit = getFilterUnit()
+    if getUnitTypeId(unit) ~= dummyUnitId and getUnitAbilityLevel(unit, leaveDetectAbilityId) > 0 then
+        targetCollection[targetCollectionNextIndex] = ____exports.Unit:of(unit)
+        targetCollectionNextIndex = targetCollectionNextIndex + 1
+    end
+end)
+local collectIntoTargetWithPredicate = Filter(function()
+    local unit = getFilterUnit()
+    if getUnitTypeId(unit) ~= dummyUnitId and getUnitAbilityLevel(unit, leaveDetectAbilityId) > 0 and enumPredicate(____exports.Unit:of(unit)) then
+        targetCollection[targetCollectionNextIndex] = ____exports.Unit:of(unit)
+        targetCollectionNextIndex = targetCollectionNextIndex + 1
+    end
+end)
+local gConsumer
+local message
+local invokeConsumer = Filter(function()
+    local unit = getFilterUnit()
+    if message == nil and getUnitTypeId(unit) ~= dummyUnitId and getUnitAbilityLevel(unit, leaveDetectAbilityId) > 0 then
+        local success, msg = pcall(
+            gConsumer,
+            ____exports.Unit:of(unit)
+        )
+        if not success then
+            message = msg
+        end
+    end
+end)
+local collectIntoTargetCollision = Filter(function()
+    local unit = getFilterUnit()
+    if isUnitInRangeXY(unit, centerX, centerY, enumRange) and getUnitTypeId(unit) ~= dummyUnitId and getUnitAbilityLevel(unit, leaveDetectAbilityId) > 0 then
+        targetCollection[targetCollectionNextIndex] = ____exports.Unit:of(unit)
+        targetCollectionNextIndex = targetCollectionNextIndex + 1
+    end
+end)
+local collectIntoTargetCollisionWithPredicate = Filter(function()
+    local unit = getFilterUnit()
+    if isUnitInRangeXY(unit, centerX, centerY, enumRange) and getUnitTypeId(unit) ~= dummyUnitId and getUnitAbilityLevel(unit, leaveDetectAbilityId) > 0 and enumPredicate(____exports.Unit:of(unit)) then
+        targetCollection[targetCollectionNextIndex] = ____exports.Unit:of(unit)
+        targetCollectionNextIndex = targetCollectionNextIndex + 1
+    end
+end)
+local posX
+local posY
+local startAngle
+local centerAngle
+local collectSectorIntoTarget = Filter(function()
+    local unit = getFilterUnit()
+    if getUnitTypeId(unit) ~= dummyUnitId and getUnitAbilityLevel(unit, leaveDetectAbilityId) > 0 then
+        local angle = atan(
+            getUnitY(unit) - posY,
+            getUnitX(unit) - posX
+        )
+        angle = fmod(angle - startAngle, pi2)
+        if (angle < 0 and angle + pi2 or angle) <= centerAngle then
+            targetCollection[targetCollectionNextIndex] = ____exports.Unit:of(unit)
+            targetCollectionNextIndex = targetCollectionNextIndex + 1
+        end
+    end
+end)
+local function deg2rad(angle)
+    angle = fmod(angle, 360)
+    return rad(angle < 0 and angle + 360 or angle)
+end
+____exports.UnitTriggerEvent = __TS__Class()
+local UnitTriggerEvent = ____exports.UnitTriggerEvent
+UnitTriggerEvent.name = "UnitTriggerEvent"
+__TS__ClassExtends(UnitTriggerEvent, TriggerEvent)
+function UnitTriggerEvent.prototype.____constructor(self, eventType, c)
+    TriggerEvent.prototype.____constructor(
+        self,
+        function(trigger) return TriggerRegisterAnyUnitEventBJ(trigger, eventType) end,
+        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)
+                        if dispatched ~= nil then
+                            invoke(
+                                dispatched,
+                                argsGetter(...)
+                            )
+                        end
+                    end)
+                    initialized = true
+                end
+                local dispatched = __TS__New(Event)
+                rawset(self, id, dispatched)
+                return dispatched
+            end,
+            __newindex = event
+        }
+    )
+end
+local function dispatchId(event)
+    return dispatch(
+        event,
+        function(unit, id, ...) return id end,
+        function(unit, id, ...) return unit, ... end
+    )
+end
+local function dispatchAbility(event)
+    local initialized = false
+    return setmetatable(
+        {},
+        {
+            __index = function(self, id)
+                if type(id) ~= "number" then
+                    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
+                            invoke(dispatched, unit, ability, ...)
+                        end
+                    end)
+                    initialized = true
+                end
+                local dispatched = __TS__New(Event)
+                rawset(self, id, dispatched)
+                return dispatched
+            end,
+            __newindex = event
+        }
+    )
+end
+local function damageEventPreventDeath(self, callback, ...)
+    if self[0] ~= nil then
+        return
+    end
+    rawset(self, 0, callback)
+    local parametersLength = select("#", ...)
+    rawset(self, 1, parametersLength)
+    for i = 1, parametersLength do
+        rawset(self, 1 + i, (select(i, ...)))
+    end
+end
+local damageSetters = {amount = BlzSetEventDamage, attackType = BlzSetEventAttackType, damageType = BlzSetEventDamageType, weaponType = BlzSetEventWeaponType}
+local jlimitopByOperator = {
+    [0] = LESS_THAN_OR_EQUAL,
+    [1] = LESS_THAN_OR_EQUAL,
+    [2] = EQUAL,
+    [3] = GREATER_THAN_OR_EQUAL,
+    [4] = GREATER_THAN_OR_EQUAL,
+    [5] = NOT_EQUAL
+}
+local modifiers = {
+    speed = function(unit, value)
+        SetUnitMoveSpeed(
+            unit,
+            GetUnitMoveSpeed(unit) + value
+        )
+    end,
+    armor = function(unit, value)
+        if UnitAddAbility(unit, armorBonusAbilityId) then
+            assert(UnitMakeAbilityPermanent(unit, true, armorBonusAbilityId))
+        end
+        local ability = assert(BlzGetUnitAbility(unit, armorBonusAbilityId))
+        assert(BlzSetAbilityRealLevelField(
+            ability,
+            armorBonusField,
+            0,
+            BlzGetAbilityRealLevelField(ability, armorBonusField, 0) + value
+        ))
+    end
+}
+local getters = {
+    speed = function(unit, delta)
+        return GetUnitMoveSpeed(unit) + delta
+    end,
+    armor = function(unit)
+        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
+}
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local getItemAbility = BlzGetItemAbility
+local getUnitAbility = BlzGetUnitAbility
+local getUnitAbilityByIndex = BlzGetUnitAbilityByIndex
+local getAbilityId = BlzGetAbilityId
+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
+        return __TS__New(
+            UnrecognizedAbility,
+            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
+            return ItemAbility:of(
+                ability,
+                abilityId,
+                Item:of(item)
+            )
+        end
+    end
+    return UnitAbility:of(
+        ability,
+        abilityId,
+        ____exports.Unit:of(unit)
+    )
+end
+local fieldGetters = {
+    unitintegerfield = function(unit, field)
+        return getUnitIntegerField(unit.handle, field)
+    end,
+    unitrealfield = function(unit, field)
+        return getUnitRealField(unit.handle, field)
+    end,
+    unitbooleanfield = function(unit, field)
+        return getUnitBooleanField(unit.handle, field)
+    end,
+    unitstringfield = function(unit, field)
+        return getUnitStringField(unit.handle, field)
+    end
+}
+local fieldSetters = {
+    unitintegerfield = function(unit, field, value)
+        return setUnitIntegerField(unit.handle, field, value)
+    end,
+    unitrealfield = function(unit, field, value)
+        return setUnitRealField(unit.handle, field, value)
+    end,
+    unitbooleanfield = function(unit, field, value)
+        return setUnitBooleanField(unit.handle, field, value)
+    end,
+    unitstringfield = function(unit, field, value)
+        return setUnitStringField(unit.handle, field, value)
+    end
+}
+local dummies = {}
+for ____, player in ipairs(Player.all) do
+    local dummy = assert(createUnit(
+        player.handle,
+        dummyUnitId,
+        0,
+        0,
+        270
+    ))
+    ShowUnit(dummy, false)
+    dummies[player] = dummy
+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)
+    self._owner = Player:of(getOwningPlayer(handle))
+    assert(unitAddAbility(handle, leaveDetectAbilityId) and UnitMakeAbilityPermanent(handle, true, leaveDetectAbilityId))
+    assert(unitAddAbility(handle, morphDetectAbilityId))
+    if unitAddAbility(
+        handle,
+        fourCC("Amrf")
+    ) then
+        assert(unitRemoveAbility(
+            handle,
+            fourCC("Amrf")
+        ))
+    end
+    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(
+            TriggerEvent,
+            function(trigger)
+                TriggerRegisterUnitEvent(trigger, self.handle, event)
+            end,
+            collector or (function() return {} end)
+        )
+    end
+    return self.events[eventId]
+end
+function Unit.prototype.onDestroy(self)
+    local handle = self.handle
+    if not self._owner then
+        self._owner = Player:of(getOwningPlayer(handle))
+    end
+    local abilities = self.abilities
+    for ____, ability in ipairs(abilities) do
+        ability:destroy()
+    end
+    __TS__ArraySetLength(abilities, 0)
+    for ____, player in ipairs(Player.all) do
+        if self:isSelected(player) then
+            Event.invoke(____exports.Unit.onDeselect, self, player)
+        end
+    end
+    if self.events then
+        for ____, event in pairs(self.events) do
+            event:destroy()
+        end
+    end
+    local eventsToDestroy = self._eventsToDestroy
+    if eventsToDestroy ~= nil then
+        forEach(eventsToDestroy, "destroy")
+    end
+    if getUnitAbilityLevel(handle, leaveDetectAbilityId) > 0 then
+        unitRemoveAbility(handle, leaveDetectAbilityId)
+        removeUnit(handle)
+    end
+    return Handle.prototype.onDestroy(self)
+end
+function Unit.prototype.addAttackHandler(self, condition, action)
+    local handler = {
+        condition,
+        warpack.wrapThread(action)
+    }
+    local handlers = self._attackHandlers or ({})
+    handlers[#handlers + 1] = handler
+    self._attackHandlers = handlers
+    if #handlers == 1 then
+        local handle = self.handle
+        assert(unitAddAbility(handle, attackHandlerAbilityId) and UnitMakeAbilityPermanent(handle, true, attackHandlerAbilityId))
+    end
+    return handler
+end
+function Unit.prototype.removeAttackHandler(self, handler)
+    local handlers = self._attackHandlers
+    if handlers then
+        for i = 1, #handlers do
+            if handlers[i] == handler then
+                tremove(handlers, i)
+                return true
+            end
+        end
+    end
+    return false
+end
+function Unit.prototype.addModifier(self, property, modifier)
+    local handle = self.handle
+    local deltas = self._deltas
+    local delta = deltas[property] or 0
+    local addition = modifier(getters[property](handle, delta))
+    modifiers[property](handle, addition)
+    deltas[property] = delta + addition
+    return {destroy = function()
+        modifiers[property](handle, -addition)
+        deltas[property] = (deltas[property] or 0) - addition
+    end}
+end
+function Unit.prototype.hasCombatClassification(self, combatClassification)
+    local ____combatClassification_0 = combatClassification
+    return getUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS) & ____combatClassification_0 == ____combatClassification_0
+end
+function Unit.prototype.addClassification(self, classification)
+    return unitAddType(self.handle, classification)
+end
+function Unit.prototype.removeClassification(self, classification)
+    return unitRemoveType(self.handle, classification)
+end
+function Unit.prototype.hasClassification(self, classification)
+    return isUnitType(self.handle, classification)
+end
+function Unit.prototype.isVisibleTo(self, player)
+    return isUnitVisible(self.handle, player.handle)
+end
+function Unit.prototype.isInvisibleTo(self, player)
+    return isUnitInvisible(self.handle, player.handle)
+end
+function Unit.prototype.isInRangeOf(self, x, y, range)
+    local ____temp_1
+    if type(x) == "number" then
+        ____temp_1 = isUnitInRangeXY(self.handle, x, y, range)
+    else
+        ____temp_1 = isUnitInRange(self.handle, x.handle, y)
+    end
+    return ____temp_1
+end
+function Unit.prototype.isAllyOf(self, unit)
+    return isUnitAlly(
+        self.handle,
+        getOwningPlayer(unit.handle)
+    )
+end
+function Unit.prototype.isEnemyOf(self, unit)
+    return isUnitEnemy(
+        self.handle,
+        getOwningPlayer(unit.handle)
+    )
+end
+function Unit.prototype.playAnimation(self, animation, rarity)
+    if type(animation) == "number" then
+        setUnitAnimationByIndex(self.handle, animation)
+    elseif rarity then
+        setUnitAnimationWithRarity(self.handle, animation, rarity)
+    else
+        setUnitAnimation(self.handle, animation)
+    end
+end
+function Unit.prototype.queueAnimation(self, animation)
+    queueUnitAnimation(self.handle, animation)
+end
+function Unit.prototype.setPosition(self, x, y)
+    setUnitPosition(self.handle, x, y)
+end
+function Unit.prototype.isSelected(self, player)
+    return IsUnitSelected(self.handle, player.handle)
+end
+function Unit.prototype.explode(self)
+    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)
+end
+function Unit.prototype.healTarget(self, target, amount)
+    if __TS__InstanceOf(target, ____exports.Unit) and target:hasAbility(fourCC("BIhm")) then
+        target.health = target.health + 0.65 * amount
+    else
+        target.health = target.health + amount
+    end
+end
+function Unit.prototype.useItem(self, item)
+    return UnitUseItem(self.handle, item.handle)
+end
+function Unit.prototype.issueImmediateOrder(self, order)
+    return IssueImmediateOrderById(self.handle, order)
+end
+function Unit.prototype.issuePointOrder(self, order, x, y)
+    return IssuePointOrderById(self.handle, order, x, y)
+end
+function Unit.prototype.issueTargetOrder(self, order, target)
+    return IssueTargetOrderById(self.handle, order, target.handle)
+end
+function Unit.prototype.queueImmediateOrder(self, order)
+    return BlzQueueImmediateOrderById(self.handle, order)
+end
+function Unit.prototype.queuePointOrder(self, order, x, y)
+    return BlzQueuePointOrderById(self.handle, order, x, y)
+end
+function Unit.prototype.queueTargetOrder(self, order, target)
+    return BlzQueueTargetOrderById(self.handle, order, target.handle)
+end
+function Unit.prototype.addItem(self, item)
+    return UnitAddItem(self.handle, item.handle)
+end
+function Unit.prototype.dropItemTarget(self, item, target)
+    return UnitDropItemTarget(self.handle, item.handle, target.handle)
+end
+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))
+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 abilities = self.abilities
+        abilities[#abilities + 1] = ability
+        return ability
+    end
+    return nil
+end
+function Unit.prototype.makeAbilityPermanent(self, abilityId, permanent)
+    return UnitMakeAbilityPermanent(self.handle, permanent, abilityId)
+end
+function Unit.prototype.setAbilityLevel(self, abilityId, level)
+    return SetUnitAbilityLevel(self.handle, abilityId, level)
+end
+function Unit.prototype.getAbilityLevel(self, abilityId)
+    return getUnitAbilityLevel(self.handle, abilityId)
+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
+    )
+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
+        end
+        return true
+    end
+    return false
+end
+function Unit.prototype.hideAbility(self, abilityId, flag)
+    BlzUnitHideAbility(self.handle, abilityId, flag)
+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)
+end
+function Unit.prototype.getDistanceTo(self, target)
+    local handle = self.handle
+    local targetHandle = target.handle
+    if targetHandle then
+        local dx = getUnitX(targetHandle) - getUnitX(handle)
+        local dy = getUnitY(targetHandle) - getUnitY(handle)
+        return sqrt(dx * dx + dy * dy)
+    else
+        local dx = target.x - getUnitX(handle)
+        local dy = target.y - getUnitY(handle)
+        return sqrt(dx * dx + dy * dy)
+    end
+end
+function Unit.prototype.getCollisionDistanceTo(self, targetUnitOrX, targetY)
+    local handle = self.handle
+    if targetY == nil then
+        local targetHandle = targetUnitOrX.handle
+        local dx = getUnitX(targetHandle) - getUnitX(handle)
+        local dy = getUnitY(targetHandle) - getUnitY(handle)
+        return max(
+            0,
+            sqrt(dx * dx + dy * dy) - getUnitCollisionSize(targetHandle) - getUnitCollisionSize(handle)
+        )
+    else
+        local dx = targetUnitOrX - getUnitX(handle)
+        local dy = targetY - getUnitY(handle)
+        return max(
+            0,
+            sqrt(dx * dx + dy * dy) - getUnitCollisionSize(handle)
+        )
+    end
+end
+function Unit.prototype.resetCooldown(self)
+    UnitResetCooldown(self.handle)
+end
+function Unit.prototype.incrementDisableAutoAttackCounter(self)
+    unitDisableAbility(
+        self.handle,
+        fourCC("Aatk"),
+        true,
+        false
+    )
+end
+function Unit.prototype.decrementDisableAutoAttackCounter(self)
+    unitDisableAbility(
+        self.handle,
+        fourCC("Aatk"),
+        false,
+        false
+    )
+end
+function Unit.prototype.pauseEx(self)
+    self:incrementStunCounter()
+end
+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
+        BlzPauseUnitEx(self.handle, true)
+    end
+    self[101] = stunCounter + 1
+end
+function Unit.prototype.decrementStunCounter(self)
+    local stunCounter = self[101] or 0
+    if not self[100] or stunCounter >= 1 then
+        BlzPauseUnitEx(self.handle, false)
+    end
+    self[101] = stunCounter - 1
+end
+function Unit.create(self, owner, id, x, y, facing, skinId)
+    local handle = skinId and BlzCreateUnitWithSkin(
+        owner.handle,
+        id,
+        x,
+        y,
+        facing,
+        skinId
+    ) or CreateUnit(
+        owner.handle,
+        id,
+        x,
+        y,
+        facing
+    )
+    return handle and self:of(handle)
+end
+function Unit.forAll(self, consumer)
+    message = nil
+    gConsumer = consumer
+    groupEnumUnitsInRange(
+        dummyGroup,
+        0,
+        0,
+        999999,
+        invokeConsumer
+    )
+    if message then
+        error(message)
+    end
+end
+function Unit.getAll(self, predicate)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    enumPredicate = predicate
+    local collect = predicate and collectIntoTargetWithPredicate or collectIntoTarget
+    for ____, player in ipairs(Player.all) do
+        groupEnumUnitsOfPlayer(dummyGroup, player.handle, collect)
+    end
+    return targetCollection
+end
+function Unit.getOwnedBy(self, player, predicate)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    enumPredicate = predicate
+    groupEnumUnitsOfPlayer(dummyGroup, player.handle, predicate and collectIntoTargetWithPredicate or collectIntoTarget)
+    return targetCollection
+end
+function Unit.getInRect(self, rect, predicate)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    enumPredicate = predicate
+    groupEnumUnitsInRect(dummyGroup, rect.handle, predicate and collectIntoTargetWithPredicate or collectIntoTarget)
+    return targetCollection
+end
+function Unit.getInRange(self, x, y, range, predicate)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    enumPredicate = predicate
+    groupEnumUnitsInRange(
+        dummyGroup,
+        x,
+        y,
+        range,
+        predicate and collectIntoTargetWithPredicate or collectIntoTarget
+    )
+    return targetCollection
+end
+function Unit.getInCollisionRange(self, x, y, range, predicate)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    centerX = x
+    centerY = y
+    enumRange = range
+    enumPredicate = predicate
+    groupEnumUnitsInRange(
+        dummyGroup,
+        centerX,
+        centerY,
+        range + 256,
+        predicate and collectIntoTargetCollisionWithPredicate or collectIntoTargetCollision
+    )
+    return targetCollection
+end
+function Unit.getInSector(self, pos, range, offsetAngle, centralAngle)
+    posX = pos.x
+    posY = pos.y
+    startAngle = deg2rad(offsetAngle)
+    centerAngle = deg2rad(centralAngle)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    groupEnumUnitsInRange(
+        dummyGroup,
+        pos.x,
+        pos.y,
+        range,
+        collectSectorIntoTarget
+    )
+    return targetCollection
+end
+function Unit.getSelectionOf(self, player)
+    targetCollection = {}
+    targetCollectionNextIndex = 1
+    GroupEnumUnitsSelected(dummyGroup, player.handle, collectIntoTarget)
+    return targetCollection
+end
+function Unit.prototype.getField(self, field)
+    local fieldType = match(
+        ____tostring(field),
+        "^(.-):"
+    )
+    return fieldGetters[fieldType](self, field)
+end
+function Unit.prototype.setField(self, field, value)
+    local fieldType = match(
+        ____tostring(field),
+        "^(.-):"
+    )
+    return fieldSetters[fieldType](self, field, value)
+end
+function Unit.prototype.__tostring(self)
+    return (((self.constructor.name .. "$") .. util.id2s(self.typeId)) .. "@") .. tostring(getHandleId(self.handle))
+end
+__TS__SetDescriptor(
+    Unit.prototype,
+    "_deltas",
+    {get = function(self)
+        local deltas = {}
+        rawset(self, "_deltas", deltas)
+        return deltas
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "skinId",
+    {
+        get = function(self)
+            return BlzGetUnitSkin(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetUnitSkin(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "typeId",
+    {get = function(self)
+        return getUnitTypeId(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isHero",
+    {get = function(self)
+        return isHeroUnitId(getUnitTypeId(self.handle))
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isAlive",
+    {get = function(self)
+        return unitAlive(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isDead",
+    {get = function(self)
+        return not unitAlive(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isIllusion",
+    {get = function(self)
+        return isUnitIllusion(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "combatClassifications",
+    {
+        get = function(self)
+            return getUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS)
+        end,
+        set = function(self, combatClassifications)
+            setUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS, combatClassifications)
+        end
+    },
+    true
+)
+__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
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "level",
+    {
+        get = function(self)
+            return GetHeroLevel(self.handle)
+        end,
+        set = function(self, v)
+            local handle = self.handle
+            local level = GetHeroLevel(handle)
+            if v > level then
+                SetHeroLevel(handle, v, false)
+            else
+                UnitStripHeroLevel(handle, level - v)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "xp",
+    {
+        get = function(self)
+            return GetHeroXP(self.handle)
+        end,
+        set = function(self, v)
+            SetHeroXP(self.handle, v, false)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "strengthBase",
+    {
+        get = function(self)
+            return getHeroStr(self.handle, false)
+        end,
+        set = function(self, strengthBase)
+            setHeroStr(self.handle, strengthBase, true)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "strengthBonus",
+    {get = function(self)
+        local handle = self.handle
+        return getHeroStr(handle, true) - getHeroStr(handle, false)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "strength",
+    {get = function(self)
+        return getHeroStr(self.handle, true)
+    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",
+    {get = function(self)
+        local handle = self.handle
+        return getHeroAgi(handle, true) - getHeroAgi(handle, false)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "agility",
+    {get = function(self)
+        return getHeroAgi(self.handle, true)
+    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",
+    {get = function(self)
+        local handle = self.handle
+        return getHeroInt(handle, true) - getHeroInt(handle, false)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "intelligence",
+    {get = function(self)
+        return getHeroInt(self.handle, true)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "name",
+    {
+        get = function(self)
+            return GetUnitName(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetUnitName(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "properName",
+    {
+        get = function(self)
+            return GetHeroProperName(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetHeroProperName(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isTeamGlowVisible",
+    {
+        get = function(self)
+            return not self[103]
+        end,
+        set = function(self, isTeamGlowVisible)
+            showUnitTeamGlow(self.handle, isTeamGlowVisible)
+            local ____temp_2
+            if not isTeamGlowVisible then
+                ____temp_2 = true
+            else
+                ____temp_2 = nil
+            end
+            self[103] = ____temp_2
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "color",
+    {set = function(self, color)
+        setUnitColor(self.handle, color.handle)
+        if self[103] then
+            showUnitTeamGlow(self.handle, false)
+        end
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "acquisitionRange",
+    {
+        get = function(self)
+            return GetUnitAcquireRange(self.handle)
+        end,
+        set = function(self, v)
+            SetUnitAcquireRange(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "maxHealth",
+    {
+        get = function(self)
+            return BlzGetUnitMaxHP(self.handle) - (self[102] or 0)
+        end,
+        set = function(self, maxHealth)
+            BlzSetUnitMaxHP(self.handle, maxHealth + (self[102] or 0))
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "healthRegenerationRate",
+    {
+        get = function(self)
+            local handle = self.handle
+            return getUnitRealField(handle, UNIT_RF_HIT_POINTS_REGENERATION_RATE) + getHeroStr(handle, true) * HEALTH_REGENERATION_RATE_BONUS_PER_STRENGTH_POINT
+        end,
+        set = function(self, healthRegenerationRate)
+            local handle = self.handle
+            setUnitRealField(
+                handle,
+                UNIT_RF_HIT_POINTS_REGENERATION_RATE,
+                healthRegenerationRate - getHeroStr(handle, true) * HEALTH_REGENERATION_RATE_BONUS_PER_STRENGTH_POINT
+            )
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "maxMana",
+    {
+        get = function(self)
+            return BlzGetUnitMaxMana(self.handle)
+        end,
+        set = function(self, maxMana)
+            BlzSetUnitMaxMana(self.handle, maxMana)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "health",
+    {
+        get = function(self)
+            return GetWidgetLife(self.handle) - (self[102] or 0)
+        end,
+        set = function(self, health)
+            SetWidgetLife(self.handle, health + (self[102] or 0))
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "mana",
+    {
+        get = function(self)
+            return GetUnitState(self.handle, UNIT_STATE_MANA)
+        end,
+        set = function(self, mana)
+            SetUnitState(self.handle, UNIT_STATE_MANA, mana)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "manaRegenerationRate",
+    {
+        get = function(self)
+            local handle = self.handle
+            return getUnitRealField(handle, UNIT_RF_MANA_REGENERATION) + getHeroInt(handle, true) * MANA_REGENERATION_RATE_BONUS_PER_INTELLIGENCE_POINT
+        end,
+        set = function(self, manaRegenerationRate)
+            local handle = self.handle
+            setUnitRealField(
+                handle,
+                UNIT_RF_MANA_REGENERATION,
+                manaRegenerationRate - getHeroInt(handle, true) * MANA_REGENERATION_RATE_BONUS_PER_INTELLIGENCE_POINT
+            )
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "armor",
+    {
+        get = function(self)
+            return BlzGetUnitArmor(self.handle)
+        end,
+        set = function(self, armor)
+            BlzSetUnitArmor(self.handle, armor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "facing",
+    {
+        get = function(self)
+            return GetUnitFacing(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetUnitFacingEx(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "speed",
+    {
+        get = function(self)
+            return GetUnitMoveSpeed(self.handle)
+        end,
+        set = function(self, v)
+            SetUnitMoveSpeed(self.handle, v)
+        end
+    },
+    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)
+        end,
+        set = function(self, v)
+            SetUnitX(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "y",
+    {
+        get = function(self)
+            return getUnitY(self.handle)
+        end,
+        set = function(self, v)
+            SetUnitY(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "z",
+    {get = function(self)
+        local handle = self.handle
+        moveLocation(
+            loc,
+            getUnitX(handle),
+            getUnitY(handle)
+        )
+        return getUnitFlyHeight(handle) + getLocationZ(loc)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "xy",
+    {set = function(self, v)
+        SetUnitX(self.handle, v.x)
+        SetUnitY(self.handle, v.y)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "position",
+    {
+        get = function(self)
+            return vec2(
+                getUnitX(self.handle),
+                getUnitY(self.handle)
+            )
+        end,
+        set = function(self, v)
+            SetUnitPosition(self.handle, v.x, v.y)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "owner",
+    {
+        get = function(self)
+            return Player:of(getOwningPlayer(self.handle)) or self._owner or Player.neutralExtra
+        end,
+        set = function(self, v)
+            SetUnitOwner(self.handle, v.handle, false)
+            if self._owner then
+                self._owner = v
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "goldCost",
+    {get = function(self)
+        local typeId = getUnitTypeId(self.handle)
+        return isHeroUnitId(typeId) and 0 or getUnitGoldCost(typeId)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "lumberCost",
+    {get = function(self)
+        local typeId = getUnitTypeId(self.handle)
+        return isHeroUnitId(typeId) and 0 or getUnitLumberCost(typeId)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "gold",
+    {
+        get = function(self)
+            return getResourceAmount(self.handle)
+        end,
+        set = function(self, gold)
+            setResourceAmount(self.handle, gold)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isPaused",
+    {
+        get = function(self)
+            return IsUnitPaused(self.handle)
+        end,
+        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)
+                end
+                PauseUnit(handle, true)
+            elseif not isPaused and IsUnitPaused(handle) then
+                PauseUnit(handle, false)
+                for _ = self[101] or 0, -1 do
+                    BlzPauseUnitEx(handle, false)
+                end
+                self[100] = nil
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "hidden",
+    {
+        get = function(self)
+            return IsUnitHidden(self.handle)
+        end,
+        set = function(self, v)
+            if v then
+                ShowUnitHide(self.handle)
+            else
+                ShowUnitShow(self.handle)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "isInvulnerable",
+    {get = function(self)
+        return isUnitInvulnerable(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "vertexColor",
+    {
+        get = function(self)
+            local handle = self.handle
+            return Color:of(
+                getUnitIntegerField(handle, UNIT_IF_TINTING_COLOR_RED),
+                getUnitIntegerField(handle, UNIT_IF_TINTING_COLOR_GREEN),
+                getUnitIntegerField(handle, UNIT_IF_TINTING_COLOR_BLUE),
+                getUnitIntegerField(handle, UNIT_IF_TINTING_COLOR_ALPHA)
+            )
+        end,
+        set = function(self, v)
+            SetUnitVertexColor(
+                self.handle,
+                v.r,
+                v.g,
+                v.b,
+                v.a
+            )
+        end
+    },
+    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",
+    {
+        get = function(self)
+            return self._timeScale or 1
+        end,
+        set = function(self, v)
+            setUnitTimeScale(self.handle, v)
+            self._timeScale = v ~= 1 and v or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "collisionSize",
+    {get = function(self)
+        return getUnitCollisionSize(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "pathingCollisionRange",
+    {get = function(self)
+        return 16 * (min(
+            getUnitCollisionSize(self.handle) // 16,
+            3
+        ) + 1)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "pathing",
+    {set = function(self, v)
+        SetUnitPathing(self.handle, v)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "buffIds",
+    {get = function(self)
+        local buffIds = {}
+        local buffIdsCount = 0
+        local handle = self.handle
+        do
+            local i = 0
+            local ability = getUnitAbilityByIndex(handle, i)
+            while ability ~= nil do
+                local abilityId = getAbilityId(ability)
+                if getAbilityName(abilityId) == "Default string" and abilityId ~= fourCC("Atrg") then
+                    buffIdsCount = buffIdsCount + 1
+                    buffIds[buffIdsCount] = abilityId
+                end
+                do
+                    i = i + 1
+                    ability = getUnitAbilityByIndex(handle, i)
+                end
+            end
+        end
+        return buffIds
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "waygateActive",
+    {
+        get = function(self)
+            return WaygateIsActive(self.handle)
+        end,
+        set = function(self, v)
+            WaygateActivate(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "waygateDestination",
+    {
+        get = function(self)
+            return vec2(
+                WaygateGetDestinationX(self.handle),
+                WaygateGetDestinationY(self.handle)
+            )
+        end,
+        set = function(self, v)
+            WaygateSetDestination(self.handle, v.x, v.y)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "abilities",
+    {get = function(self)
+        local abilities = {}
+        local stock = stockAbilities[self.typeId]
+        if stock then
+            local handle = self.handle
+            local j = 1
+            for i = 1, #stock do
+                local abilityId = stock[i]
+                local ability = UnitAbility:of(
+                    getUnitAbility(handle, abilityId),
+                    abilityId,
+                    self
+                )
+                if ability then
+                    abilities[j] = ability
+                    j = j + 1
+                end
+            end
+        end
+        rawset(self, "abilities", abilities)
+        return abilities
+    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",
+    {get = function(self)
+        local handle = self.handle
+        local onManaEqual = setmetatable(
+            {},
+            {__index = function(self, value)
+                local event = __TS__New(
+                    TriggerEvent,
+                    function(trigger)
+                        TriggerRegisterUnitManaEvent(trigger, handle, EQUAL, value)
+                    end,
+                    function() return ____exports.Unit:of(handle), value end
+                )
+                rawset(self, value, event)
+                return event
+            end}
+        )
+        rawset(self, "onManaEqual", onManaEqual)
+        return onManaEqual
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "manaEvent",
+    {get = function(self)
+        local unit = self
+        local eventByValueByOperator = setmetatable(
+            {},
+            {__index = function(self, operator)
+                local eventByValue = setmetatable(
+                    {},
+                    {__index = function(self, value)
+                        local actualValue = value
+                        if operator == 4 then
+                            actualValue = value + 0.01
+                        elseif operator == 0 then
+                            actualValue = value - 0.01
+                        end
+                        local event = __TS__New(
+                            TriggerEvent,
+                            function(trigger)
+                                TriggerRegisterUnitManaEvent(trigger, unit.handle, jlimitopByOperator[operator], actualValue)
+                            end,
+                            function() return unit end
+                        )
+                        local eventsToDestroy = unit._eventsToDestroy
+                        if eventsToDestroy == nil then
+                            eventsToDestroy = {}
+                            unit._eventsToDestroy = eventsToDestroy
+                        end
+                        eventsToDestroy[#eventsToDestroy + 1] = event
+                        rawset(self, value, event)
+                        return event
+                    end}
+                )
+                rawset(self, operator, eventByValue)
+                return eventByValue
+            end}
+        )
+        rawset(self, "manaEvent", eventByValueByOperator)
+        return eventByValueByOperator
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "onSelect",
+    {get = function(self)
+        return self:getEvent(EVENT_UNIT_SELECTED)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "onDeselect",
+    {get = function(self)
+        return self:getEvent(EVENT_UNIT_DESELECTED)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "onImmediateOrder",
+    {get = function(self)
+        return self:getEvent(
+            EVENT_UNIT_ISSUED_ORDER,
+            function() return GetIssuedOrderId() end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "onPointOrder",
+    {get = function(self)
+        return self:getEvent(
+            EVENT_UNIT_ISSUED_POINT_ORDER,
+            function() return GetIssuedOrderId() end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "onTargetOrder",
+    {get = function(self)
+        return self:getEvent(
+            EVENT_UNIT_ISSUED_TARGET_ORDER,
+            function() return GetIssuedOrderId(), ____exports.Unit:of(GetOrderTargetUnit()) or Item:of(GetOrderTargetItem()) or checkNotNull(Destructable:of(GetOrderTargetDestructable())) end
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Unit.prototype,
+    "onSpellEffect",
+    {get = function(self)
+        return self:getEvent(
+            EVENT_UNIT_SPELL_EFFECT,
+            function() return GetSpellAbilityId() end
+        )
+    end},
+    true
+)
+Unit.deathEvent = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_DEATH,
+    function() return ____exports.Unit:of(GetDyingUnit()), ____exports.Unit:of(GetKillingUnit()) end
+)
+Unit.onDecay = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_DECAY,
+    function() return ____exports.Unit:of(GetDecayingUnit()) end
+)
+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
+        end)
+        ____exports.Unit.onImmediateOrder[orderId("undefend")]:addListener(function(unit)
+            if dead[unit] and not IsUnitType(unit.handle, UNIT_TYPE_DEAD) then
+                dead[unit] = false
+                invoke(event, unit)
+            end
+        end)
+    end
+)
+Unit.morphEvent = __TS__New(
+    InitializingEvent,
+    function(event)
+        ____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)
+            end
+        end)
+    end
+)
+Unit.onOwnerChange = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_CHANGE_OWNER,
+    function() return ____exports.Unit:of(GetChangingUnit()), Player:of(GetChangingUnitPrevOwner()) end
+)
+Unit.onSelect = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SELECTED,
+    function() return ____exports.Unit:of(getTriggerUnit()), Player:of(getTriggerPlayer()) end
+)
+Unit.onDeselect = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_DESELECTED,
+    function() return ____exports.Unit:of(getTriggerUnit()), Player:of(getTriggerPlayer()) end
+)
+Unit.constructionStartEvent = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_CONSTRUCT_START,
+    function() return ____exports.Unit:of(GetConstructingStructure()) end
+)
+Unit.onUpgradeFinish = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_UPGRADE_FINISH,
+    function() return ____exports.Unit:of(getTriggerUnit()) end
+)
+Unit.onSpellEffect = dispatchId(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SPELL_EFFECT,
+    function() return ____exports.Unit:of(GetTriggerUnit()), GetSpellAbilityId() end
+))
+Unit.onTargetCast = dispatchId(__TS__New(
+    InitializingEvent,
+    function(event)
+        local invoke = Event.invoke
+        local function listener(unit, id)
+            local ____GetSpellTargetUnit_result_5
+            if GetSpellTargetUnit() then
+                ____GetSpellTargetUnit_result_5 = ____exports.Unit:of(GetSpellTargetUnit())
+            else
+                local ____GetSpellTargetItem_result_4
+                if GetSpellTargetItem() then
+                    ____GetSpellTargetItem_result_4 = Item:of(GetSpellTargetItem())
+                else
+                    local ____GetSpellTargetDestructable_result_3
+                    if GetSpellTargetDestructable() then
+                        ____GetSpellTargetDestructable_result_3 = Destructable:of(GetSpellTargetDestructable())
+                    else
+                        ____GetSpellTargetDestructable_result_3 = nil
+                    end
+                    ____GetSpellTargetItem_result_4 = ____GetSpellTargetDestructable_result_3
+                end
+                ____GetSpellTargetUnit_result_5 = ____GetSpellTargetItem_result_4
+            end
+            local target = ____GetSpellTargetUnit_result_5
+            if target then
+                invoke(event, unit, id, target)
+            end
+        end
+        ____exports.Unit.onSpellEffect:addListener(listener)
+        return listener
+    end,
+    function(listener)
+        ____exports.Unit.onSpellEffect:removeListener(listener)
+    end
+))
+Unit.onCastPrepare = dispatchAbility(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SPELL_CHANNEL,
+    function()
+        local unit = getTriggerUnit()
+        return ____exports.Unit:of(unit), retrieveAbility(
+            unit,
+            getSpellAbility(),
+            getSpellAbilityId()
+        )
+    end
+))
+Unit.onCast = dispatchAbility(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SPELL_EFFECT,
+    function()
+        local unit = getTriggerUnit()
+        return ____exports.Unit:of(unit), retrieveAbility(
+            unit,
+            getSpellAbility(),
+            getSpellAbilityId()
+        )
+    end
+))
+Unit.onPointCastPrepare = dispatchAbility(__TS__New(
+    InitializingEvent,
+    function(event)
+        local function listener(unit, ability)
+            local x = getSpellTargetX()
+            local y = getSpellTargetY()
+            if x ~= 0 or y ~= 0 then
+                invoke(
+                    event,
+                    unit,
+                    ability,
+                    x,
+                    y
+                )
+            end
+        end
+        ____exports.Unit.onCastPrepare:addListener(listener)
+        return listener
+    end,
+    function(listener)
+        ____exports.Unit.onCastPrepare:removeListener(listener)
+    end
+))
+Unit.onUnitTargetCastPrepare = dispatchAbility(__TS__New(
+    InitializingEvent,
+    function(event)
+        local function listener(unit, ability)
+            local target = ____exports.Unit:of(getSpellTargetUnit())
+            if target then
+                invoke(event, unit, ability, target)
+            end
+        end
+        ____exports.Unit.onCastPrepare:addListener(listener)
+        return listener
+    end,
+    function(listener)
+        ____exports.Unit.onCastPrepare:removeListener(listener)
+    end
+))
+Unit.onUnitTargetCast = dispatchAbility(__TS__New(
+    InitializingEvent,
+    function(event)
+        local function listener(unit, ability)
+            local target = ____exports.Unit:of(getSpellTargetUnit())
+            if target then
+                invoke(event, unit, ability, target)
+            end
+        end
+        ____exports.Unit.onCast:addListener(listener)
+        return listener
+    end,
+    function(listener)
+        ____exports.Unit.onCast:removeListener(listener)
+    end
+))
+Unit.onPointCast = dispatchAbility(__TS__New(
+    InitializingEvent,
+    function(event)
+        local function listener(unit, ability)
+            if not (getSpellTargetUnit() or getSpellTargetItem() or getSpellTargetDestructable()) then
+                local x = getSpellTargetX()
+                local y = getSpellTargetY()
+                if x ~= 0 or y ~= 0 then
+                    invoke(
+                        event,
+                        unit,
+                        ability,
+                        x,
+                        y
+                    )
+                end
+            end
+        end
+        ____exports.Unit.onCast:addListener(listener)
+        return listener
+    end,
+    function(listener)
+        ____exports.Unit.onCast:removeListener(listener)
+    end
+))
+Unit.onCastStart = dispatchAbility(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SPELL_CAST,
+    function()
+        local unit = getTriggerUnit()
+        return ____exports.Unit:of(unit), retrieveAbility(
+            unit,
+            getSpellAbility(),
+            getSpellAbilityId()
+        )
+    end
+))
+Unit.onUnitTargetCastStart = dispatchAbility(__TS__New(
+    InitializingEvent,
+    function(event)
+        local function listener(unit, ability)
+            local target = ____exports.Unit:of(getSpellTargetUnit())
+            if target then
+                invoke(event, unit, ability, target)
+            end
+        end
+        ____exports.Unit.onCastStart:addListener(listener)
+        return listener
+    end,
+    function(listener)
+        ____exports.Unit.onCastStart:removeListener(listener)
+    end
+))
+Unit.onCastFinish = dispatchAbility(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SPELL_FINISH,
+    function()
+        local unit = getTriggerUnit()
+        return ____exports.Unit:of(unit), retrieveAbility(
+            unit,
+            getSpellAbility(),
+            getSpellAbilityId()
+        )
+    end
+))
+Unit.onCastStop = dispatchAbility(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_SPELL_ENDCAST,
+    function()
+        local unit = getTriggerUnit()
+        return ____exports.Unit:of(unit), retrieveAbility(
+            unit,
+            getSpellAbility(),
+            getSpellAbilityId()
+        )
+    end
+))
+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
+        end
+        return IgnoreEvent
+    end
+))
+Unit.onTargetOrder = dispatchId(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_ISSUED_TARGET_ORDER,
+    function() return ____exports.Unit:of(GetOrderedUnit()), GetIssuedOrderId(), ____exports.Unit:of(GetOrderTargetUnit()) or Item:of(GetOrderTargetItem()) or checkNotNull(Destructable:of(GetOrderTargetDestructable())) end
+))
+Unit.onPointOrder = dispatchId(__TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_ISSUED_POINT_ORDER,
+    function() return ____exports.Unit:of(GetOrderedUnit()), GetIssuedOrderId(), GetOrderPointX(), GetOrderPointY() end
+))
+Unit.autoAttackStartEvent = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_ATTACKED,
+    function() return ____exports.Unit:of(GetAttacker()), ____exports.Unit:of(GetTriggerUnit()) end
+)
+Unit.onDamaging = (function()
+    local event = __TS__New(Event)
+    local invoke = Event.invoke
+    local trigger = CreateTrigger()
+    TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_DAMAGING)
+    TriggerAddCondition(
+        trigger,
+        Condition(warpack.wrapSafeCall(function()
+            local source = ____exports.Unit:of(GetEventDamageSource())
+            if source and source.typeId == dummyUnitId then
+                source = nil
+            end
+            local target = BlzGetEventDamageTarget()
+            local data = {
+                amount = GetEventDamage(),
+                attackType = BlzGetEventAttackType(),
+                damageType = BlzGetEventDamageType(),
+                weaponType = BlzGetEventWeaponType(),
+                isAttack = BlzGetEventIsAttack()
+            }
+            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])
+            end
+            if not data.isAttack or not source or not source._attackHandlers then
+                invoke(
+                    event,
+                    source,
+                    ____exports.Unit:of(target),
+                    setmetatable(
+                        {},
+                        {
+                            __index = data,
+                            __newindex = function(self, key, value)
+                                damageSetters[key](value)
+                                data[key] = value
+                            end
+                        }
+                    )
+                )
+                return
+            end
+            BlzSetEventDamage(0)
+            BlzSetEventAttackType(ATTACK_TYPE_NORMAL)
+            BlzSetEventDamageType(DAMAGE_TYPE_UNKNOWN)
+            BlzSetEventWeaponType(WEAPON_TYPE_WHOKNOWS)
+            local sourceOwner = source.owner.handle
+            local targetOwner = GetOwningPlayer(target)
+            if not GetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE) then
+                SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, true)
+                Timer:run(function()
+                    SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, false)
+                end)
+            end
+            if not GetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE) then
+                SetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE, true)
+                Timer:run(function()
+                    SetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE, false)
+                end)
+            end
+            for ____, ____value in ipairs(source._attackHandlers) do
+                local condition = ____value[1]
+                local action = ____value[2]
+                if condition(
+                    source,
+                    ____exports.Unit:of(target),
+                    data
+                ) then
+                    action(
+                        source,
+                        ____exports.Unit:of(target),
+                        setmetatable(
+                            {fire = function()
+                                UnitDamageTarget(
+                                    source.handle,
+                                    target,
+                                    data.amount,
+                                    true,
+                                    true,
+                                    data.attackType,
+                                    data.damageType,
+                                    data.weaponType
+                                )
+                            end},
+                            {__index = data, __newindex = data}
+                        )
+                    )
+                    return
+                end
+            end
+        end))
+    )
+    return event
+end)()
+Unit.onDamage = __TS__New(
+    InitializingEvent,
+    function(event)
+        local invoke = Event.invoke
+        local trigger = CreateTrigger()
+        TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_DAMAGED)
+        TriggerAddCondition(
+            trigger,
+            Condition(warpack.wrapSafeCall(function()
+                local source = ____exports.Unit:of(GetEventDamageSource())
+                if source and source.typeId == dummyUnitId then
+                    source = nil
+                end
+                local data = {
+                    amount = GetEventDamage(),
+                    attackType = BlzGetEventAttackType(),
+                    damageType = BlzGetEventDamageType(),
+                    weaponType = BlzGetEventWeaponType(),
+                    isAttack = BlzGetEventIsAttack(),
+                    preventDeath = damageEventPreventDeath
+                }
+                local evData = setmetatable(
+                    {},
+                    {
+                        __index = data,
+                        __newindex = function(self, key, value)
+                            damageSetters[key](value)
+                            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
+                    BlzSetUnitMaxHP(
+                        target.handle,
+                        BlzGetUnitMaxHP(target.handle) + bonusHealth
+                    )
+                    SetWidgetLife(
+                        target.handle,
+                        GetWidgetLife(target.handle) + bonusHealth
+                    )
+                    Timer:run(function()
+                        warpack.safeCall(
+                            evData[0],
+                            table.unpack(evData, 1 + 1, 1 + (evData[1] or 0))
+                        )
+                        target[102] = (target[102] or 0) - bonusHealth
+                        SetWidgetLife(
+                            target.handle,
+                            GetWidgetLife(target.handle) - bonusHealth
+                        )
+                        BlzSetUnitMaxHP(
+                            target.handle,
+                            BlzGetUnitMaxHP(target.handle) - bonusHealth
+                        )
+                    end)
+                end
+            end))
+        )
+        return trigger
+    end,
+    function(trigger)
+        TriggerClearConditions(trigger)
+        DestroyTrigger(trigger)
+    end
+)
+Unit.onItemDrop = __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())
+        end
+        return IgnoreEvent
+    end
+)
+Unit.onItemPickup = __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())
+        end
+        return IgnoreEvent
+    end
+)
+Unit.onItemUse = __TS__New(
+    ____exports.UnitTriggerEvent,
+    EVENT_PLAYER_UNIT_USE_ITEM,
+    function() return ____exports.Unit:of(GetTriggerUnit()), Item:of(GetManipulatedItem()) end
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "onCreate",
+    {get = function(self)
+        local onCreate = dispatch(
+            ____exports.Unit.onCreateEvent,
+            function(unit) return unit.typeId end,
+            function(unit) return unit end
+        )
+        rawset(self, "onCreate", onCreate)
+        return onCreate
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "destroyEvent",
+    {get = function(self)
+        local destroyEvent = dispatch(
+            ____exports.Unit.onDestroyEvent,
+            function(unit) return unit.typeId end,
+            function(unit) return unit end
+        )
+        rawset(self, "destroyEvent", destroyEvent)
+        return destroyEvent
+    end}
+);
+(function(self)
+    local leaveAbilityIds = postcompile(function()
+        local parentLeaveAbilityIds = __TS__New(Set, {"Adef", "Amdf", "AEim", "ACim"})
+        local leaveAbilityIds = {__TS__Spread(parentLeaveAbilityIds:values())}
+        if currentMap then
+            for id, ability in pairs(currentMap.objects.ability.all) do
+                if ability.parentId and parentLeaveAbilityIds:has(ability.parentId) then
+                    leaveAbilityIds[#leaveAbilityIds + 1] = id
+                end
+            end
+        end
+        return __TS__ArrayMap(
+            leaveAbilityIds,
+            function(____, id) return fourCC(id) end
+        )
+    end)
+    for ____, leaveOrderId in ipairs({
+        orderId("undefend"),
+        orderId("magicundefense"),
+        orderId("unimmolation")
+    }) do
+        ____exports.Unit.onImmediateOrder[leaveOrderId]:addListener(function(unit)
+            local handle = unit.handle
+            for i = 1, #leaveAbilityIds do
+                if getUnitAbilityLevel(handle, leaveAbilityIds[i]) ~= 0 then
+                    return
+                end
+            end
+            unit:destroy()
+        end)
+    end
+end)(Unit)
+return ____exports