warscript 0.0.1-dev.87b6c38 → 0.0.1-dev.8895725

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

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

package/engine/internal/unit/scale.lua

@@ -4,16 +4,16 @@ local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____unit = require("engine.standard.fields.unit")
-local SCALING_VALUE_UNIT_FLOAT_FIELD = ____unit.SCALING_VALUE_UNIT_FLOAT_FIELD
+local SCALING_VALUE_UNIT_FIELD = ____unit.SCALING_VALUE_UNIT_FIELD
 __TS__ObjectDefineProperty(
     Unit.prototype,
     "scale",
     {
         get = function(self)
-            return SCALING_VALUE_UNIT_FLOAT_FIELD:getValue(self)
+            return SCALING_VALUE_UNIT_FIELD:getValue(self)
         end,
         set = function(self, value)
-            SCALING_VALUE_UNIT_FLOAT_FIELD:setValue(self, value)
+            SCALING_VALUE_UNIT_FIELD:setValue(self, value)
         end
     }
 )

package/engine/internal/unit+bonus.lua

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

package/engine/internal/unit-missile-launch.lua

@@ -36,11 +36,18 @@ local instantOrderIds = luaSetOf(
     orderId("undivineshield"),
     orderId("unimmolation")
 )
-local function reset(source, orderId)
-    if not (instantOrderIds[orderId] ~= nil) and units:remove(source) then
-        source[targetAttribute] = nil
-        source[impactDelayAttribute] = nil
-        source[passedTimeAttribute] = nil
+---
+-- @internal For use by internal systems only.
+____exports.resetAutoAttackTimer = function(unit)
+    if units:remove(unit) then
+        unit[targetAttribute] = nil
+        unit[impactDelayAttribute] = nil
+        unit[passedTimeAttribute] = nil
+    end
+end
+local function reset(unit, orderId)
+    if not (instantOrderIds[orderId] ~= nil) then
+        ____exports.resetAutoAttackTimer(unit)
     end
 end
 Unit.onImmediateOrder:addListener(reset)

package/engine/internal/unit.d.ts

@@ -139,6 +139,7 @@ export declare class Unit extends Handle<junit> {
     private _fields?;
     private getEvent;
     constructor(handle: junit);
+    private saveData;
     protected onDestroy(): HandleDestructor;
     addAttackHandler(condition: AttackHandlerCondition, action: AttackHandlerAction): AttackHandler;
     removeAttackHandler(handler: AttackHandler): boolean;
@@ -177,16 +178,10 @@ export declare class Unit extends Handle<junit> {
     set xp(v: number);
     get primaryAttribute(): UnitAttribute;
     set primaryAttribute(primaryAttribute: UnitAttribute);
-    get strengthBase(): number;
-    set strengthBase(strengthBase: number);
     get strengthBonus(): number;
     get strength(): number;
-    get agilityBase(): number;
-    set agilityBase(agilityBase: number);
     get agilityBonus(): number;
     get agility(): number;
-    get intelligenceBase(): number;
-    set intelligenceBase(intelligenceBase: number);
     get intelligenceBonus(): number;
     get intelligence(): number;
     get name(): string;
@@ -277,8 +272,6 @@ export declare class Unit extends Handle<junit> {
     getAbilityRemainingCooldown(abilityId: number): number;
     startAbilityCooldown(abilityId: number, cooldown: number): void;
     endAbilityCooldown(abilityId: number): void;
-    interruptMovement(): void;
-    interruptAttack(): void;
     interruptCast(abilityId: number): void;
     getDistanceTo(target: Unit | Vec2): number;
     getCollisionDistanceTo(...target: [Unit] | [targetX: number, targetY: number]): number;
@@ -299,7 +292,6 @@ export declare class Unit extends Handle<junit> {
     set waygateDestination(v: Vec2);
     get waygateDestination(): Vec2;
     get abilities(): ReadonlyArray<UnitAbility>;
-    get onUnitInRange(): Record<number, Event<[Unit]>>;
     get onManaEqual(): Record<number, Event<[Unit, number]>>;
     get manaEvent(): Record<Operator, Record<number, Event<[Unit]>>>;
     get targetAcquiredEvent(): Event;
@@ -318,6 +310,7 @@ export declare class Unit extends Handle<junit> {
     static getInCollisionRange(x: number, y: number, range: number, predicate?: (unit: Unit) => boolean): Unit[];
     static getInSector(pos: Vec2, range: number, offsetAngle: number, centralAngle: number): Unit[];
     static getSelectionOf(player: Player, target?: Unit[]): Unit[];
+    static readonly levelChangedEvent: UnitTriggerEvent<[]>;
     static readonly deathEvent: UnitTriggerEvent<[Unit]>;
     static readonly onDecay: UnitTriggerEvent<[]>;
     static readonly onResurrect: InitializingEvent<[Unit], void>;

package/engine/internal/unit.lua

@@ -64,6 +64,8 @@ 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
@@ -73,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
@@ -110,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
@@ -386,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 = {
@@ -648,13 +657,17 @@ 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
@@ -697,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[108] = getUnitX(handle)
-    self[109] = 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()
@@ -767,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
@@ -980,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)
@@ -1392,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",
@@ -1422,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",
@@ -1452,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",
@@ -2013,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",
@@ -2172,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,
@@ -2830,7 +2787,8 @@ Unit.synchronize = synchronizer(
                     return
                 end
             end
-            unit:destroy()
+            unit:saveData()
+            Timer:run(unit, "destroy")
         end)
     end
 end)(Unit)

package/engine/local-client.d.ts

@@ -12,12 +12,17 @@ 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, extraEffects?: boolean] | [color: Color, extraEffects?: boolean]): void;
+    static get isMinimized(): 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<[
         previousMainSelectedUnit: Unit | undefined,
         newMainSelectedUnit: Unit | undefined
     ]>;
+    static get isInTargetingMode(): boolean;
+    static readonly targetingModeEnterEvent: Event<[]>;
+    static readonly targetingModeLeaveEvent: Event<[]>;
+    static readonly targetingModeStateChangeEvent: Event<[]>;
     static readonly onDisconnect: TriggerEvent<[]>;
 }

package/engine/local-client.lua

@@ -1,10 +1,11 @@
 local ____lualib = require("lualib_bundle")
 local __TS__ArrayMap = ____lualib.__TS__ArrayMap
+local __TS__New = ____lualib.__TS__New
 local __TS__Class = ____lualib.__TS__Class
 local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
-local __TS__New = ____lualib.__TS__New
 local ____exports = {}
+local actualizeTargetingModeState
 local ____unit = require("core.types.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
@@ -18,6 +19,8 @@ local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
 local ____color = require("core.types.color")
 local Color = ____color.Color
+local ____arrays = require("utility.arrays")
+local array = ____arrays.array
 local loadTOCFile = BlzLoadTOCFile
 local getLocalClientWidth = BlzGetLocalClientWidth
 local getLocalClientHeight = BlzGetLocalClientHeight
@@ -62,12 +65,16 @@ local function compareUnitsSelectionPriority(a, b)
 end
 local mainSelectedUnitChangeEvent
 local previousMainSelectedUnit
+local lastTargetingModeState = false
+local targetingModeEnterEvent = __TS__New(Event)
+local targetingModeLeaveEvent = __TS__New(Event)
+local targetingModeStateChangeEvent = __TS__New(Event)
 ____exports.LocalClient = __TS__Class()
 local LocalClient = ____exports.LocalClient
 LocalClient.name = "LocalClient"
 function LocalClient.prototype.____constructor(self)
 end
-function LocalClient.pingMinimap(self, x, y, duration, redOrColor, greenOrExtraEffects, blue, extraEffects)
+function LocalClient.pingMinimap(self, x, y, duration, redOrColor, greenOrFlashy, blue, flashy)
     if redOrColor == nil then
         pingMinimap(x, y, duration)
     elseif __TS__InstanceOf(redOrColor, Color) then
@@ -78,7 +85,7 @@ function LocalClient.pingMinimap(self, x, y, duration, redOrColor, greenOrExtraE
             redOrColor.r,
             redOrColor.g,
             redOrColor.b,
-            greenOrExtraEffects or false
+            greenOrFlashy or false
         )
     else
         pingMinimapEx(
@@ -86,9 +93,9 @@ function LocalClient.pingMinimap(self, x, y, duration, redOrColor, greenOrExtraE
             y,
             duration,
             redOrColor,
-            greenOrExtraEffects,
+            greenOrFlashy,
             blue,
-            extraEffects or false
+            flashy or false
         )
     end
 end
@@ -128,6 +135,13 @@ __TS__ObjectDefineProperty(
         return isLocalClientActive()
     end}
 )
+__TS__ObjectDefineProperty(
+    LocalClient,
+    "isMinimized",
+    {get = function(self)
+        return getLocalClientHeight() == 0
+    end}
+)
 __TS__ObjectDefineProperty(
     LocalClient,
     "mouseFocusUnit",
@@ -181,6 +195,16 @@ __TS__ObjectDefineProperty(
         return mainSelectedUnitChangeEvent
     end}
 )
+__TS__ObjectDefineProperty(
+    LocalClient,
+    "isInTargetingMode",
+    {get = function(self)
+        return actualizeTargetingModeState()
+    end}
+)
+LocalClient.targetingModeEnterEvent = targetingModeEnterEvent
+LocalClient.targetingModeLeaveEvent = targetingModeLeaveEvent
+LocalClient.targetingModeStateChangeEvent = targetingModeStateChangeEvent
 LocalClient.onDisconnect = __TS__New(
     TriggerEvent,
     function(trigger)
@@ -188,6 +212,37 @@ LocalClient.onDisconnect = __TS__New(
     end,
     function() return  end
 )
+local commandButtons = array(
+    12,
+    function(i) return Frame:byOrigin(ORIGIN_FRAME_COMMAND_BUTTON, i) end
+)
+local function getTargetingModeState()
+    for i = 0, 10 do
+        if commandButtons[i + 1].visible then
+            return false
+        end
+    end
+    return commandButtons[12].visible
+end
+actualizeTargetingModeState = function()
+    if getTargetingModeState() then
+        if not lastTargetingModeState then
+            lastTargetingModeState = true
+            Event.invoke(targetingModeEnterEvent)
+            Event.invoke(targetingModeStateChangeEvent)
+        end
+        return true
+    end
+    if lastTargetingModeState then
+        lastTargetingModeState = false
+        Event.invoke(targetingModeLeaveEvent)
+        Event.invoke(targetingModeStateChangeEvent)
+    end
+    return false
+end
+Timer.onPeriod[1 / 64]:addListener(function()
+    actualizeTargetingModeState()
+end)
 warpack.afterMapInit(function()
     rawset(
         ____exports.LocalClient,

package/engine/object-data/auxiliary/health-regeneration-type.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+export declare const enum HealthRegenerationType {
+    NONE = 0,
+    ALWAYS = 1,
+    BLIGHT = 2,
+    DAY = 3,
+    NIGHT = 4
+}

package/engine/object-data/auxiliary/health-regeneration-type.lua

@@ -0,0 +1,2 @@
+local ____exports = {}
+return ____exports

package/engine/object-data/auxiliary/unit-attribute.lua

@@ -1,5 +1,5 @@
 local ____exports = {}
-____exports.UnitAttribute = UnitAttribute or ({})
+____exports.UnitAttribute = ____exports.UnitAttribute or ({})
 ____exports.UnitAttribute.STRENGTH = 1
 ____exports.UnitAttribute[____exports.UnitAttribute.STRENGTH] = "STRENGTH"
 ____exports.UnitAttribute.INTELLIGENCE = 2