warscript 0.0.1-dev.83957b1 → 0.0.1-dev.83ffb73

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

@@ -136,6 +136,36 @@ declare module "../unit" {
         const abilityImpactEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
+declare module "../unit" {
+    namespace Unit {
+        const abilityWidgetTargetImpactEvent: DispatchingEvent<[Unit, Ability, Widget]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const abilityUnitTargetImpactEvent: DispatchingEvent<[Unit, Ability, Unit]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const abilityItemTargetImpactEvent: DispatchingEvent<[Unit, Ability, Item]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const abilityDestructibleTargetImpactEvent: DispatchingEvent<[Unit, Ability, Destructable]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const abilityPointTargetImpactEvent: DispatchingEvent<[Unit, Ability, number, number]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const abilityNoTargetImpactEvent: DispatchingEvent<[Unit, Ability]>;
+    }
+}
 declare module "../unit" {
     namespace Unit {
         const abilityChannelingFinishEvent: DispatchingEvent<[Unit, Ability]>;

package/engine/internal/unit/ability.lua

@@ -359,6 +359,54 @@ rawset(
         extractAbilityTypeId
     )
 )
+rawset(
+    Unit,
+    "abilityWidgetTargetImpactEvent",
+    createDispatchingEvent(
+        createWidgetTargetEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityUnitTargetImpactEvent",
+    createDispatchingEvent(
+        createUnitTargetEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityItemTargetImpactEvent",
+    createDispatchingEvent(
+        createItemTargetEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityDestructibleTargetImpactEvent",
+    createDispatchingEvent(
+        createDestructibleTargetEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityPointTargetImpactEvent",
+    createDispatchingEvent(
+        createPointTargetEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityNoTargetImpactEvent",
+    createDispatchingEvent(
+        createNoTargetEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
 rawset(
     Unit,
     "abilityChannelingFinishEvent",

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

@@ -0,0 +1,20 @@
+/** @noSelfInFile */
+import { Widget } from "../../../core/types/widget";
+export declare const enum OrderType {
+    IMMEDIATE = 0,
+    POINT = 1,
+    TARGET = 2
+}
+declare module "../unit" {
+    interface Unit {
+        readonly currentOrderType: OrderType;
+        readonly currentOrderId: number;
+        readonly currentOrderStartTime: number;
+        readonly currentOrderStartX: number;
+        readonly currentOrderStartY: number;
+        readonly currentOrderTargetX: number;
+        readonly currentOrderTargetY: number;
+        readonly currentOrderTarget?: Widget;
+        issueOrder(...order: [orderType: OrderType.IMMEDIATE, orderId: number] | [orderType: OrderType.POINT, orderId: number, x: number, y: number] | [orderType: OrderType.TARGET, orderId: number, target: Widget]): boolean;
+    }
+}

package/engine/internal/unit/order.lua

@@ -0,0 +1,136 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____attributes = require("attributes")
+local attribute = ____attributes.attribute
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____game = require("core.game")
+local elapsedTime = ____game.elapsedTime
+local getUnitCurrentOrder = GetUnitCurrentOrder
+local issueImmediateOrderById = IssueImmediateOrderById
+local issuePointOrderById = IssuePointOrderById
+local issueTargetOrderById = IssueTargetOrderById
+local unitLastOrderTypeAttribute = attribute()
+local unitLastOrderIdAttribute = attribute()
+local unitLastOrderStartTimeAttribute = attribute()
+local unitLastOrderStartXAttribute = attribute()
+local unitLastOrderStartYAttribute = attribute()
+local unitLastOrderTargetXAttribute = attribute()
+local unitLastOrderTargetYAttribute = attribute()
+local unitLastOrderTargetAttribute = attribute()
+Unit.onImmediateOrder:addListener(
+    4,
+    function(unit, orderId)
+        unit[unitLastOrderTypeAttribute] = 0
+        unit[unitLastOrderIdAttribute] = orderId
+        unit[unitLastOrderStartTimeAttribute] = elapsedTime()
+        unit[unitLastOrderStartXAttribute] = unit.x
+        unit[unitLastOrderStartYAttribute] = unit.y
+        unit[unitLastOrderTargetXAttribute] = nil
+        unit[unitLastOrderTargetYAttribute] = nil
+        unit[unitLastOrderTargetAttribute] = nil
+    end
+)
+Unit.onPointOrder:addListener(
+    4,
+    function(unit, orderId, x, y)
+        unit[unitLastOrderTypeAttribute] = 1
+        unit[unitLastOrderIdAttribute] = orderId
+        unit[unitLastOrderStartTimeAttribute] = elapsedTime()
+        unit[unitLastOrderStartXAttribute] = unit.x
+        unit[unitLastOrderStartYAttribute] = unit.y
+        unit[unitLastOrderTargetXAttribute] = x
+        unit[unitLastOrderTargetYAttribute] = y
+        unit[unitLastOrderTargetAttribute] = nil
+    end
+)
+Unit.onTargetOrder:addListener(
+    4,
+    function(unit, orderId, target)
+        unit[unitLastOrderTypeAttribute] = 2
+        unit[unitLastOrderIdAttribute] = orderId
+        unit[unitLastOrderStartTimeAttribute] = elapsedTime()
+        unit[unitLastOrderStartXAttribute] = unit.x
+        unit[unitLastOrderStartYAttribute] = unit.y
+        unit[unitLastOrderTargetXAttribute] = target.x
+        unit[unitLastOrderTargetYAttribute] = target.y
+        unit[unitLastOrderTargetAttribute] = target
+    end
+)
+local function toUndefinedIfCurrentOrderDoesNotMatchLast(unit, value)
+    local currentOrderId = getUnitCurrentOrder(unit.handle)
+    local lastOrderId = unit[unitLastOrderIdAttribute]
+    local ____temp_0
+    if currentOrderId == lastOrderId or currentOrderId == orderId("patrolAI") and lastOrderId == orderId("patrol") then
+        ____temp_0 = value
+    else
+        ____temp_0 = nil
+    end
+    return ____temp_0
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderType",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTypeAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderId",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderIdAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderStartTime",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderStartTimeAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderStartX",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderStartXAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderStartY",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderStartYAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderTargetX",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetXAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderTargetY",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetYAttribute]) or 0
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrderTarget",
+    {get = function(self)
+        return toUndefinedIfCurrentOrderDoesNotMatchLast(self, self[unitLastOrderTargetAttribute])
+    end}
+)
+local issueOrderByType = {
+    [0] = issueImmediateOrderById,
+    [1] = issuePointOrderById,
+    [2] = function(unitHandle, orderId, widget) return issueTargetOrderById(unitHandle, orderId, widget.handle) end
+}
+Unit.prototype.issueOrder = function(self, orderType, orderId, xOrTarget, y)
+    return issueOrderByType[orderType](self.handle, orderId, xOrTarget, y)
+end
+return ____exports

package/engine/internal/unit.d.ts

@@ -160,8 +160,7 @@ export declare class Unit extends Handle<junit> {
     isInRangeOf(unit: Unit, range: number): boolean;
     isAllyOf(unit: Unit): boolean;
     isEnemyOf(unit: Unit): boolean;
-    playAnimation(animation: string, rarity?: jraritycontrol): void;
-    playAnimation(animation: number): void;
+    playAnimation(...parameters: [animation: number] | [animation: string, rarity?: jraritycontrol]): void;
     resetAnimation(): void;
     queueAnimation(animation: string): void;
     get weapons(): [UnitWeapon, UnitWeapon];
@@ -267,7 +266,7 @@ export declare class Unit extends Handle<junit> {
     dropItemTarget(item: Item, target: Widget): boolean;
     dropItemSlot(item: Item, slot: number): boolean;
     itemInSlot(slot: number): Item | null;
-    addAbility(abilityId: number): UnitAbility | null;
+    addAbility(abilityId: number): UnitAbility | undefined;
     makeAbilityPermanent(abilityId: number, permanent: true): boolean;
     setAbilityLevel(abilityId: number, level: number): number;
     getAbilityLevel(abilityId: number): number;
@@ -278,6 +277,7 @@ 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;

package/engine/internal/unit.lua

@@ -60,6 +60,8 @@ local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage
 local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
 local ____attributes = require("attributes")
 local isAttribute = ____attributes.isAttribute
+local ____ability = require("engine.internal.item.ability")
+local doUnitAbilityAction = ____ability.doUnitAbilityAction
 local match = string.match
 local ____tostring = _G.tostring
 local setUnitAnimation = SetUnitAnimation
@@ -123,10 +125,6 @@ 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
@@ -665,15 +663,24 @@ end
 local nextSyncId = 1
 local unitBySyncId = setmetatable({}, {__mode = "v"})
 local damagingEventByTarget = setmetatable({}, {__mode = "k"})
+local function addAbility(unit, abilityTypeId)
+    local ____unitAddAbility_result_0
+    if unitAddAbility(unit, abilityTypeId) then
+        ____unitAddAbility_result_0 = getUnitAbility(unit, abilityTypeId)
+    else
+        ____unitAddAbility_result_0 = nil
+    end
+    return ____unitAddAbility_result_0
+end
 ____exports.Unit = __TS__Class()
 local Unit = ____exports.Unit
 Unit.name = "Unit"
 __TS__ClassExtends(Unit, Handle)
 function Unit.prototype.____constructor(self, handle)
     Handle.prototype.____constructor(self, handle)
-    local ____nextSyncId_0 = nextSyncId
-    nextSyncId = ____nextSyncId_0 + 1
-    self.syncId = ____nextSyncId_0
+    local ____nextSyncId_1 = nextSyncId
+    nextSyncId = ____nextSyncId_1 + 1
+    self.syncId = ____nextSyncId_1
     self._owner = Player:of(getOwningPlayer(handle))
     assert(unitAddAbility(handle, leaveDetectAbilityId) and UnitMakeAbilityPermanent(handle, true, leaveDetectAbilityId))
     assert(unitAddAbility(handle, morphDetectAbilityId))
@@ -774,17 +781,17 @@ function Unit.prototype.addModifier(self, property, modifier)
     end}
 end
 function Unit.prototype.hasCombatClassification(self, combatClassification)
-    local ____combatClassification_1 = combatClassification
-    return getUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS) & ____combatClassification_1 == ____combatClassification_1
+    local ____combatClassification_2 = combatClassification
+    return getUnitIntegerField(self.handle, UNIT_IF_TARGETED_AS) & ____combatClassification_2 == ____combatClassification_2
 end
 function Unit.prototype.addClassification(self, classification)
-    return unitAddType(self.handle, classification)
+    return UnitAddType(self.handle, classification)
 end
 function Unit.prototype.removeClassification(self, classification)
-    return unitRemoveType(self.handle, classification)
+    return UnitRemoveType(self.handle, classification)
 end
 function Unit.prototype.hasClassification(self, classification)
-    return isUnitType(self.handle, classification)
+    return IsUnitType(self.handle, classification)
 end
 function Unit.prototype.isVisibleTo(self, player)
     return isUnitVisible(self.handle, player.handle)
@@ -793,13 +800,13 @@ function Unit.prototype.isInvisibleTo(self, player)
     return isUnitInvisible(self.handle, player.handle)
 end
 function Unit.prototype.isInRangeOf(self, x, y, range)
-    local ____temp_2
+    local ____temp_3
     if type(x) == "number" then
-        ____temp_2 = isUnitInRangeXY(self.handle, x, y, range)
+        ____temp_3 = isUnitInRangeXY(self.handle, x, y, range)
     else
-        ____temp_2 = isUnitInRange(self.handle, x.handle, y)
+        ____temp_3 = isUnitInRange(self.handle, x.handle, y)
     end
-    return ____temp_2
+    return ____temp_3
 end
 function Unit.prototype.isAllyOf(self, unit)
     return isUnitAlly(
@@ -855,14 +862,14 @@ function Unit.prototype.kill(self)
     killUnit(self.handle)
 end
 function Unit.prototype.revive(self, x, y, doEffect)
-    local ____ReviveHero_5 = ReviveHero
-    local ____array_4 = __TS__SparseArrayNew(self.handle, x, y)
-    local ____doEffect_3 = doEffect
-    if ____doEffect_3 == nil then
-        ____doEffect_3 = false
+    local ____ReviveHero_6 = ReviveHero
+    local ____array_5 = __TS__SparseArrayNew(self.handle, x, y)
+    local ____doEffect_4 = doEffect
+    if ____doEffect_4 == nil then
+        ____doEffect_4 = false
     end
-    __TS__SparseArrayPush(____array_4, ____doEffect_3)
-    ____ReviveHero_5(__TS__SparseArraySpread(____array_4))
+    __TS__SparseArrayPush(____array_5, ____doEffect_4)
+    ____ReviveHero_6(__TS__SparseArraySpread(____array_5))
 end
 function Unit.prototype.healTarget(self, target, amount)
     if __TS__InstanceOf(target, ____exports.Unit) and target:hasAbility(fourCC("BIhm")) then
@@ -905,17 +912,16 @@ 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 ability = UnitAbility:of(
+        doUnitAbilityAction(self.handle, abilityId, addAbility, abilityId),
+        abilityId,
+        self
+    )
+    if ability ~= nil then
         local abilities = self.abilities
         abilities[#abilities + 1] = ability
-        return ability
     end
-    return nil
+    return ability
 end
 function Unit.prototype.makeAbilityPermanent(self, abilityId, permanent)
     return UnitMakeAbilityPermanent(self.handle, permanent, abilityId)
@@ -930,19 +936,11 @@ 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
-    )
+    local ability = doUnitAbilityAction(self.handle, abilityId, getUnitAbility, abilityId)
+    return UnitAbility:of(ability, abilityId, self)
 end
 function Unit.prototype.removeAbility(self, abilityId)
-    if unitRemoveAbility(self.handle, abilityId) then
+    if doUnitAbilityAction(self.handle, abilityId, unitRemoveAbility, abilityId) then
         local abilities = self.abilities
         for i = 1, #abilities do
             if abilities[i].typeId == abilityId then
@@ -967,6 +965,21 @@ 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
@@ -1240,7 +1253,7 @@ __TS__SetDescriptor(
     Unit.prototype,
     "isIllusion",
     {get = function(self)
-        return isUnitIllusion(self.handle)
+        return IsUnitIllusion(self.handle)
     end},
     true
 )
@@ -1463,13 +1476,13 @@ __TS__SetDescriptor(
         end,
         set = function(self, isTeamGlowVisible)
             BlzShowUnitTeamGlow(self.handle, isTeamGlowVisible)
-            local ____temp_6
+            local ____temp_7
             if not isTeamGlowVisible then
-                ____temp_6 = true
+                ____temp_7 = true
             else
-                ____temp_6 = nil
+                ____temp_7 = nil
             end
-            self[106] = ____temp_6
+            self[106] = ____temp_7
         end
     },
     true
@@ -2216,25 +2229,25 @@ Unit.onTargetCast = dispatchId(__TS__New(
     InitializingEvent,
     function(event)
         local function listener(unit, id)
-            local ____GetSpellTargetUnit_result_9
+            local ____GetSpellTargetUnit_result_10
             if GetSpellTargetUnit() then
-                ____GetSpellTargetUnit_result_9 = ____exports.Unit:of(GetSpellTargetUnit())
+                ____GetSpellTargetUnit_result_10 = ____exports.Unit:of(GetSpellTargetUnit())
             else
-                local ____GetSpellTargetItem_result_8
+                local ____GetSpellTargetItem_result_9
                 if GetSpellTargetItem() then
-                    ____GetSpellTargetItem_result_8 = Item:of(GetSpellTargetItem())
+                    ____GetSpellTargetItem_result_9 = Item:of(GetSpellTargetItem())
                 else
-                    local ____GetSpellTargetDestructable_result_7
+                    local ____GetSpellTargetDestructable_result_8
                     if GetSpellTargetDestructable() then
-                        ____GetSpellTargetDestructable_result_7 = Destructable:of(GetSpellTargetDestructable())
+                        ____GetSpellTargetDestructable_result_8 = Destructable:of(GetSpellTargetDestructable())
                     else
-                        ____GetSpellTargetDestructable_result_7 = nil
+                        ____GetSpellTargetDestructable_result_8 = nil
                     end
-                    ____GetSpellTargetItem_result_8 = ____GetSpellTargetDestructable_result_7
+                    ____GetSpellTargetItem_result_9 = ____GetSpellTargetDestructable_result_8
                 end
-                ____GetSpellTargetUnit_result_9 = ____GetSpellTargetItem_result_8
+                ____GetSpellTargetUnit_result_10 = ____GetSpellTargetItem_result_9
             end
-            local target = ____GetSpellTargetUnit_result_9
+            local target = ____GetSpellTargetUnit_result_10
             if target then
                 invoke(event, unit, id, target)
             end

package/engine/object-data/auxiliary/armor-type.d.ts

@@ -0,0 +1,11 @@
+/** @noSelfInFile */
+export declare const enum ArmorType {
+    LIGHT = 0,
+    MEDIUM = 1,
+    HEAVY = 2,
+    FORTIFIED = 3,
+    NORMAL = 4,
+    HERO = 5,
+    DIVINE = 6,
+    UNARMORED = 7
+}

package/engine/object-data/auxiliary/armor-type.lua

@@ -0,0 +1,46 @@
+local ____exports = {}
+local ____records = require("utility.records")
+local invertRecord = ____records.invertRecord
+local stringByArmorType = {
+    [0] = "small",
+    [1] = "medium",
+    [2] = "large",
+    [3] = "fort",
+    [4] = "normal",
+    [5] = "hero",
+    [6] = "divine",
+    [7] = "none"
+}
+local armorTypeByString = invertRecord(stringByArmorType)
+local nativeByArmorType = {
+    [0] = DEFENSE_TYPE_LIGHT,
+    [1] = DEFENSE_TYPE_MEDIUM,
+    [2] = DEFENSE_TYPE_LARGE,
+    [3] = DEFENSE_TYPE_FORT,
+    [4] = DEFENSE_TYPE_NORMAL,
+    [5] = DEFENSE_TYPE_HERO,
+    [6] = DEFENSE_TYPE_DIVINE,
+    [7] = DEFENSE_TYPE_NONE
+}
+local armorTypeByNative = invertRecord(nativeByArmorType)
+---
+-- @internal For use by internal systems only.
+____exports.armorTypeToString = function(armorType)
+    return stringByArmorType[armorType]
+end
+---
+-- @internal For use by internal systems only.
+____exports.stringToArmorType = function(____string)
+    return armorTypeByString[____string] or 7
+end
+---
+-- @internal For use by internal systems only.
+____exports.armorTypeToNative = function(armorType)
+    return nativeByArmorType[armorType]
+end
+---
+-- @internal For use by internal systems only.
+____exports.nativeToArmorType = function(armorType)
+    return armorTypeByNative[armorType]
+end
+return ____exports

package/engine/object-data/entry/ability-type.lua

@@ -979,9 +979,7 @@ for abilityTypeId, animationFQN in pairs(postcompile(function() return castAnima
         4,
         function(caster, ability)
             if ability:getField(ABILITY_RLF_CASTING_TIME) ~= 0 then
-                Timer:run(function()
-                    caster:playAnimation(animationFQN)
-                end)
+                Timer:run(caster, "playAnimation", animationFQN)
             end
         end
     )

package/engine/object-data/entry/unit-type.d.ts

@@ -13,6 +13,7 @@ import type { AbilityTypeId } from "./ability-type";
 import type { UpgradeId } from "./upgrade";
 import { AnimationQualifier } from "../auxiliary/animation-qualifier";
 import { AttackType } from "../auxiliary/attack-type";
+import { ArmorType } from "../auxiliary/armor-type";
 export type UnitTypeId = ObjectDataEntryId & number & {
     readonly __unitTypeId: unique symbol;
 };
@@ -144,6 +145,8 @@ export declare abstract class UnitType<Id extends UnitTypeId = UnitTypeId> exten
     set runSpeedSD(runSpeedSD: number);
     get runSpeedHD(): number;
     set runSpeedHD(runSpeedHD: number);
+    get selectionCircleHeight(): number;
+    set selectionCircleHeight(height: number);
     get selectionCircleScale(): number;
     set selectionCircleScale(selectionCircleScale: number);
     get selectionCircleScaleSD(): number;
@@ -182,16 +185,20 @@ export declare abstract class UnitType<Id extends UnitTypeId = UnitTypeId> exten
     set walkSpeedSD(walkSpeedSD: number);
     get walkSpeedHD(): number;
     set walkSpeedHD(walkSpeedHD: number);
+    get armor(): number;
+    set armor(armor: number);
     get armorSoundType(): ArmorSoundType;
     set armorSoundType(armorSoundType: ArmorSoundType);
     get armorSoundTypeSD(): ArmorSoundType;
     set armorSoundTypeSD(armorSoundTypeSD: ArmorSoundType);
     get armorSoundTypeHD(): ArmorSoundType;
     set armorSoundTypeHD(armorSoundTypeHD: ArmorSoundType);
+    get armorType(): ArmorType;
+    set armorType(armorType: ArmorType);
     get combatClassifications(): CombatClassifications;
     set combatClassifications(combatClassifications: CombatClassifications);
-    get unitClassifications(): UnitClassifications;
-    set unitClassifications(unitClassifications: UnitClassifications);
+    get classifications(): UnitClassifications;
+    set classifications(unitClassifications: UnitClassifications);
     get weapons(): TupleOf<UnitTypeWeapon, 2>;
     get firstWeapon(): UnitTypeWeapon;
     get secondWeapon(): UnitTypeWeapon;
@@ -225,6 +232,8 @@ export declare abstract class UnitType<Id extends UnitTypeId = UnitTypeId> exten
     set goldCost(goldCost: number);
     get healthRegenerationRate(): number;
     set healthRegenerationRate(healthRegenerationRate: number);
+    get level(): number;
+    set level(level: number);
     get manaRegenerationRate(): number;
     set manaRegenerationRate(manaRegenerationRate: number);
     get maximumHealth(): number;