warscript 0.0.1-dev.85b1c63 → 0.0.1-dev.870376f

package/engine/internal/unit.lua

@@ -62,6 +62,10 @@ 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
@@ -71,16 +75,12 @@ 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
@@ -108,7 +108,6 @@ local getUnitWeaponStringField = BlzGetUnitWeaponStringField
 local setUnitWeaponStringField = BlzSetUnitWeaponStringField
 local getUnitAbilityLevel = GetUnitAbilityLevel
 local unitDisableAbility = BlzUnitDisableAbility
-local unitInterruptAttack = BlzUnitInterruptAttack
 local isUnitInvisible = IsUnitInvisible
 local isUnitVisible = IsUnitVisible
 local getUnitX = GetUnitX
@@ -384,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 = {
@@ -410,6 +421,19 @@ 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",
@@ -633,26 +657,30 @@ 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[103] or 0) - 1
+    local counter = (unit[104] or 0) - 1
     if counter ~= 0 then
-        unit[103] = counter
+        unit[104] = counter
         return
     end
-    unit[103] = nil
-    local healthBonus = unit[104]
+    unit[104] = nil
+    local healthBonus = unit[105]
     if healthBonus ~= nil then
-        unit[104] = nil
+        unit[105] = nil
         local handle = unit.handle
         BlzSetUnitMaxHP(
             handle,
@@ -682,41 +710,57 @@ function Unit.prototype.____constructor(self, handle)
     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
-    self[107] = getUnitX(handle)
-    self[108] = getUnitY(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()
@@ -752,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
@@ -836,16 +884,18 @@ function Unit.prototype.queueAnimation(self, animation)
     QueueUnitAnimation(self.handle, animation)
 end
 function Unit.prototype.chooseWeapon(self, target)
-    if target:isAllowedTarget(self, self.firstWeapon.allowedTargetCombatClassifications) then
-        return self.firstWeapon
+    local firstWeapon = self.firstWeapon
+    if firstWeapon.isEnabled and target:isAllowedTarget(self, firstWeapon.allowedTargetCombatClassifications) then
+        return firstWeapon
     end
-    if target:isAllowedTarget(target, self.secondWeapon.allowedTargetCombatClassifications) then
-        return self.secondWeapon
+    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[103] = (self[103] or 0) + 1
+    self[104] = (self[104] or 0) + 1
     Timer:run(delayHealthChecksCallback, self)
 end
 function Unit.prototype.setPosition(self, x, y)
@@ -935,20 +985,21 @@ end
 function Unit.prototype.hasAbility(self, abilityId)
     return getUnitAbilityLevel(self.handle, abilityId) > 0
 end
-function Unit.prototype.getAbilityById(self, abilityId)
+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)
+function Unit.prototype.removeAbility(self, abilityTypeId)
     local abilities = self.abilities
     for i = 1, #abilities do
-        if abilities[i].typeId == abilityId then
-            abilities[i]:destroy()
+        if abilities[i].typeId == abilityTypeId then
+            local ability = abilities[i]
             tremove(abilities, i)
+            ability:destroy()
             return true
         end
     end
-    return false
+    return doUnitAbilityAction(self.handle, abilityTypeId, unitRemoveAbility, abilityTypeId)
 end
 function Unit.prototype.hideAbility(self, abilityId, flag)
     BlzUnitHideAbility(self.handle, abilityId, flag)
@@ -962,24 +1013,6 @@ end
 function Unit.prototype.endAbilityCooldown(self, abilityId)
     BlzEndUnitAbilityCooldown(self.handle, abilityId)
 end
-function Unit.prototype.interruptMovement(self)
-    local handle = self.handle
-    unitDisableAbility(
-        handle,
-        fourCC("Amov"),
-        true,
-        false
-    )
-    unitDisableAbility(
-        handle,
-        fourCC("Amov"),
-        false,
-        false
-    )
-end
-function Unit.prototype.interruptAttack(self)
-    unitInterruptAttack(self.handle)
-end
 function Unit.prototype.interruptCast(self, abilityId)
     local handle = self.handle
     unitDisableAbility(handle, abilityId, true, false)
@@ -1050,18 +1083,44 @@ function Unit.prototype.unpauseEx(self)
 end
 function Unit.prototype.incrementStunCounter(self)
     local stunCounter = self[102] or 0
-    if not self[101] or stunCounter >= 0 then
+    if not self[101] and (self[103] or 0) <= 0 or stunCounter >= 0 then
         BlzPauseUnitEx(self.handle, true)
     end
     self[102] = stunCounter + 1
 end
 function Unit.prototype.decrementStunCounter(self)
     local stunCounter = self[102] or 0
-    if not self[101] or stunCounter >= 1 then
+    if not self[101] and (self[103] or 0) <= 0 or stunCounter >= 1 then
         BlzPauseUnitEx(self.handle, false)
     end
     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(
         owner.handle,
@@ -1348,19 +1407,6 @@ __TS__SetDescriptor(
     },
     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",
@@ -1378,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",
@@ -1408,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",
@@ -1469,7 +1489,7 @@ __TS__SetDescriptor(
     "isTeamGlowVisible",
     {
         get = function(self)
-            return not self[106]
+            return not self[107]
         end,
         set = function(self, isTeamGlowVisible)
             BlzShowUnitTeamGlow(self.handle, isTeamGlowVisible)
@@ -1479,7 +1499,7 @@ __TS__SetDescriptor(
             else
                 ____temp_7 = nil
             end
-            self[106] = ____temp_7
+            self[107] = ____temp_7
         end
     },
     true
@@ -1489,7 +1509,7 @@ __TS__SetDescriptor(
     "color",
     {set = function(self, color)
         SetUnitColor(self.handle, color.handle)
-        if self[106] then
+        if self[107] then
             BlzShowUnitTeamGlow(self.handle, false)
         end
     end},
@@ -1513,14 +1533,14 @@ __TS__SetDescriptor(
     "maxHealth",
     {
         get = function(self)
-            return BlzGetUnitMaxHP(self.handle) - (self[104] or 0) - (self[105] or 0)
+            return BlzGetUnitMaxHP(self.handle) - (self[105] or 0) - (self[106] or 0)
         end,
         set = function(self, maxHealth)
-            if maxHealth < 1 and self[103] ~= nil then
-                self[104] = (self[104] or 0) + (1 - maxHealth)
+            if maxHealth < 1 and self[104] ~= nil then
+                self[105] = (self[105] or 0) + (1 - maxHealth)
                 maxHealth = 1
             end
-            BlzSetUnitMaxHP(self.handle, maxHealth + (self[105] or 0))
+            BlzSetUnitMaxHP(self.handle, maxHealth + (self[106] or 0))
         end
     },
     true
@@ -1562,10 +1582,10 @@ __TS__SetDescriptor(
     "health",
     {
         get = function(self)
-            return GetWidgetLife(self.handle) - (self[105] or 0)
+            return GetWidgetLife(self.handle) - (self[106] or 0)
         end,
         set = function(self, health)
-            SetWidgetLife(self.handle, health + (self[105] or 0))
+            SetWidgetLife(self.handle, health + (self[106] or 0))
         end
     },
     true
@@ -1641,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 self[107] or getUnitX(self.handle)
+            return self[108] or getUnitX(self.handle)
         end,
         set = function(self, v)
             SetUnitX(self.handle, v)
@@ -1672,7 +1679,7 @@ __TS__SetDescriptor(
     "y",
     {
         get = function(self)
-            return self[108] or getUnitY(self.handle)
+            return self[109] or getUnitY(self.handle)
         end,
         set = function(self, v)
             SetUnitY(self.handle, v)
@@ -1777,14 +1784,18 @@ __TS__SetDescriptor(
             local handle = self.handle
             if isPaused and not IsUnitPaused(handle) then
                 self[101] = true
-                for _ = self[102] or 0, -1 do
-                    BlzPauseUnitEx(handle, 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[102] 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[101] = nil
             end
@@ -1842,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",
@@ -1992,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",
@@ -2151,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,
@@ -2467,12 +2445,7 @@ Unit.onDamaging = (function()
                 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(
@@ -2617,7 +2590,7 @@ Unit.onDamage = __TS__New(
                 invoke(event, source, target, evData)
                 if evData[0] ~= nil and target.health - evData.amount < 0.405 then
                     local bonusHealth = math.ceil(evData.amount)
-                    target[105] = (target[105] or 0) + bonusHealth
+                    target[106] = (target[106] or 0) + bonusHealth
                     BlzSetUnitMaxHP(
                         target.handle,
                         BlzGetUnitMaxHP(target.handle) + bonusHealth
@@ -2631,7 +2604,7 @@ Unit.onDamage = __TS__New(
                             evData[0],
                             table.unpack(evData, 1 + 1, 1 + (evData[1] or 0))
                         )
-                        target[105] = (target[105] or 0) - bonusHealth
+                        target[106] = (target[106] or 0) - bonusHealth
                         SetWidgetLife(
                             target.handle,
                             GetWidgetLife(target.handle) - bonusHealth
@@ -2781,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()
@@ -2810,7 +2787,8 @@ __TS__ObjectDefineProperty(
                     return
                 end
             end
-            unit:destroy()
+            unit:saveData()
+            Timer:run(unit, "destroy")
         end)
     end
 end)(Unit)

package/engine/local-client.d.ts

@@ -3,6 +3,7 @@ import { Unit } from "../core/types/unit";
 import { Async } from "../core/types/async";
 import { Event, TriggerEvent } from "../event";
 import { GraphicsMode } from "./index";
+import { Color } from "../core/types/color";
 export declare class LocalClient {
     private constructor();
     static readonly locale: string;
@@ -11,6 +12,7 @@ export declare class LocalClient {
     static get isHD(): boolean;
     static get graphicsMode(): GraphicsMode;
     static get isActive(): boolean;
+    static pingMinimap(x: number, y: number, duration: number, ...parameters: [] | [red: number, green: number, blue: number, flashy?: boolean] | [color: Color, flashy?: boolean]): void;
     static get mouseFocusUnit(): Async<Unit> | undefined;
     static get mainSelectedUnit(): Async<Unit> | undefined;
     static get mainSelectedUnitChangeEvent(): Event<[