warscript 0.0.1-dev.2bde093 → 0.0.1-dev.2fcfd45

package/engine/internal/unit.lua

@@ -58,13 +58,14 @@ local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
 local nativeToAttackType = ____attack_2Dtype.nativeToAttackType
 local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
 local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
+local ____attributes = require("attributes")
+local isAttribute = ____attributes.isAttribute
+local ____ability = require("engine.internal.item.ability")
+local doUnitAbilityAction = ____ability.doUnitAbilityAction
 local match = string.match
 local ____tostring = _G.tostring
 local setUnitAnimation = SetUnitAnimation
-local setUnitAnimationWithRarity = SetUnitAnimationWithRarity
 local setUnitAnimationByIndex = SetUnitAnimationByIndex
-local resetUnitAnimation = ResetUnitAnimation
-local queueUnitAnimation = QueueUnitAnimation
 local getUnitIntegerField = BlzGetUnitIntegerField
 local getUnitRealField = BlzGetUnitRealField
 local getHeroStr = GetHeroStr
@@ -124,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
@@ -140,6 +137,7 @@ do
     UnitClassification.GROUND = UNIT_TYPE_GROUND
     UnitClassification.SUMMONED = UNIT_TYPE_SUMMONED
     UnitClassification.MECHANICAL = UNIT_TYPE_MECHANICAL
+    UnitClassification.WORKER = UNIT_TYPE_PEON
     UnitClassification.ANCIENT = UNIT_TYPE_ANCIENT
     UnitClassification.SUICIDAL = UNIT_TYPE_SAPPER
     UnitClassification.TAUREN = UNIT_TYPE_TAUREN
@@ -347,6 +345,9 @@ local function dispatchAbility(event)
         }
     )
 end
+local function damagingEventPreventRetaliation(self)
+    self[0] = true
+end
 local function damageEventPreventDeath(self, callback, ...)
     if self[0] ~= nil then
         return
@@ -409,6 +410,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",
@@ -443,6 +457,19 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    UnitWeapon.prototype,
+    "allowedTargetCombatClassifications",
+    {
+        get = function(self)
+            return BlzGetUnitWeaponIntegerField(self.unit.handle, UNIT_WEAPON_IF_ATTACK_TARGETS_ALLOWED, self.index)
+        end,
+        set = function(self, allowedTargetCombatClassifications)
+            BlzSetUnitWeaponIntegerField(self.unit.handle, UNIT_WEAPON_IF_ATTACK_TARGETS_ALLOWED, self.index, allowedTargetCombatClassifications)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     UnitWeapon.prototype,
     "damageBase",
@@ -649,15 +676,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))
@@ -758,17 +794,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)
@@ -777,13 +813,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(
@@ -801,16 +837,27 @@ function Unit.prototype.playAnimation(self, animation, rarity)
     if type(animation) == "number" then
         setUnitAnimationByIndex(self.handle, animation)
     elseif rarity then
-        setUnitAnimationWithRarity(self.handle, animation, rarity)
+        SetUnitAnimationWithRarity(self.handle, animation, rarity)
     else
         setUnitAnimation(self.handle, animation)
     end
 end
 function Unit.prototype.resetAnimation(self)
-    resetUnitAnimation(self.handle)
+    ResetUnitAnimation(self.handle)
 end
 function Unit.prototype.queueAnimation(self, animation)
-    queueUnitAnimation(self.handle, animation)
+    QueueUnitAnimation(self.handle, animation)
+end
+function Unit.prototype.chooseWeapon(self, target)
+    local firstWeapon = self.firstWeapon
+    if firstWeapon.isEnabled and target:isAllowedTarget(self, firstWeapon.allowedTargetCombatClassifications) then
+        return firstWeapon
+    end
+    local secondWeapon = self.secondWeapon
+    if secondWeapon.isEnabled and target:isAllowedTarget(target, secondWeapon.allowedTargetCombatClassifications) then
+        return secondWeapon
+    end
+    return nil
 end
 function Unit.prototype.delayHealthChecks(self)
     self[103] = (self[103] or 0) + 1
@@ -830,14 +877,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
@@ -880,17 +927,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)
@@ -904,31 +950,21 @@ end
 function Unit.prototype.hasAbility(self, abilityId)
     return getUnitAbilityLevel(self.handle, abilityId) > 0
 end
-function Unit.prototype.getAbilityById(self, abilityId)
-    local handle = self.handle
-    if unitAddAbility(handle, abilityId) then
-        assert(unitRemoveAbility(handle, abilityId))
-        return nil
-    end
-    return UnitAbility:of(
-        getUnitAbility(self.handle, abilityId),
-        abilityId,
-        self
-    )
+function Unit.prototype.getAbility(self, abilityId)
+    local ability = doUnitAbilityAction(self.handle, abilityId, getUnitAbility, abilityId)
+    return UnitAbility:of(ability, abilityId, self)
 end
-function Unit.prototype.removeAbility(self, abilityId)
-    if unitRemoveAbility(self.handle, abilityId) then
-        local abilities = self.abilities
-        for i = 1, #abilities do
-            if abilities[i].typeId == abilityId then
-                abilities[i]:destroy()
-                tremove(abilities, i)
-                return true
-            end
+function Unit.prototype.removeAbility(self, abilityTypeId)
+    local abilities = self.abilities
+    for i = 1, #abilities do
+        if abilities[i].typeId == abilityTypeId then
+            local ability = abilities[i]
+            tremove(abilities, i)
+            ability:destroy()
+            return true
         end
-        return true
     end
-    return false
+    return doUnitAbilityAction(self.handle, abilityTypeId, unitRemoveAbility, abilityTypeId)
 end
 function Unit.prototype.hideAbility(self, abilityId, flag)
     BlzUnitHideAbility(self.handle, abilityId, flag)
@@ -942,6 +978,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
@@ -1215,7 +1266,7 @@ __TS__SetDescriptor(
     Unit.prototype,
     "isIllusion",
     {get = function(self)
-        return isUnitIllusion(self.handle)
+        return IsUnitIllusion(self.handle)
     end},
     true
 )
@@ -1438,13 +1489,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
@@ -2048,6 +2099,14 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    Unit.prototype,
+    "targetAcquiredEvent",
+    {get = function(self)
+        return self:getEvent(EVENT_UNIT_ACQUIRED_TARGET)
+    end},
+    true
+)
 __TS__SetDescriptor(
     Unit.prototype,
     "onSelect",
@@ -2183,25 +2242,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
@@ -2420,15 +2479,11 @@ Unit.onDamaging = (function()
                 metadata = metadata,
                 isAttack = BlzGetEventIsAttack(),
                 originalAmount = GetEventDamage(),
-                originalMetadata = metadata
+                originalMetadata = metadata,
+                preventRetaliation = damagingEventPreventRetaliation
             }
             if data.isAttack and source then
-                local weapon = BlzGetUnitWeaponBooleanField(source.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, 1) and (BlzGetUnitWeaponBooleanField(source.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, 0) and -1 or 1) or 0
-                if weapon == -1 then
-                    local targetsAllowed = BlzGetUnitWeaponIntegerField(source.handle, UNIT_WEAPON_IF_ATTACK_TARGETS_ALLOWED, 0)
-                    weapon = 0
-                end
-                data.weapon = assert(source.weapons[weapon + 1])
+                data.weapon = source:chooseWeapon(target)
             end
             if not data.isAttack or not source or not source._attackHandlers then
                 invoke(
@@ -2449,6 +2504,20 @@ Unit.onDamaging = (function()
                         }
                     )
                 )
+                if data[0] and source then
+                    local sourceOwner = source.owner.handle
+                    data[1] = sourceOwner
+                    local targetOwner = target.owner.handle
+                    data[2] = targetOwner
+                    if not GetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE) then
+                        SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, true)
+                        data[3] = true
+                    end
+                    if not GetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE) then
+                        SetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE, true)
+                        data[4] = true
+                    end
+                end
                 damagingEventByTarget[target] = data
                 return
             end
@@ -2526,12 +2595,32 @@ Unit.onDamage = __TS__New(
                     originalMetadata = damagingEvent and damagingEvent.originalMetadata,
                     preventDeath = damageEventPreventDeath
                 }
+                if damagingEvent then
+                    for key, value in pairs(damagingEvent) do
+                        if isAttribute(key) then
+                            data[key] = value
+                        end
+                    end
+                    local sourceOwner = damagingEvent[1]
+                    if sourceOwner then
+                        local targetOwner = damagingEvent[2]
+                        if damagingEvent[3] then
+                            SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, false)
+                        end
+                        if damagingEvent[4] then
+                            SetPlayerAlliance(targetOwner, sourceOwner, ALLIANCE_PASSIVE, false)
+                        end
+                    end
+                end
                 local evData = setmetatable(
                     {},
                     {
                         __index = data,
                         __newindex = function(self, key, value)
-                            damageSetters[key](value)
+                            local damageSetter = damageSetters[key]
+                            if damageSetter ~= nil then
+                                damageSetter(value)
+                            end
                             data[key] = value
                         end
                     }
@@ -2589,10 +2678,14 @@ Unit.itemPickedUpEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_PICKUP_ITEM,
     function()
-        local unit = getTriggerUnit()
-        local item = getManipulatedItem()
-        if getUnitTypeId(unit) ~= dummyUnitId and not (ignoreEventsItems[item] ~= nil) then
-            return ____exports.Unit:of(unit), Item:of(item)
+        local unitHandle = getTriggerUnit()
+        local itemHandle = getManipulatedItem()
+        if getUnitTypeId(unitHandle) ~= dummyUnitId and not (ignoreEventsItems[itemHandle] ~= nil) then
+            local unit = ____exports.Unit:of(unitHandle)
+            local item = Item:of(itemHandle)
+            if item.owner ~= unit then
+                return unit, item
+            end
         end
         return IgnoreEvent
     end
@@ -2612,7 +2705,22 @@ Unit.itemUsedEvent = __TS__New(
 Unit.itemStackedEvent = __TS__New(
     ____exports.UnitTriggerEvent,
     EVENT_PLAYER_UNIT_STACK_ITEM,
-    function() return ____exports.Unit:of(getTriggerUnit()), Item:of(getManipulatedItem()) end
+    function() return ____exports.Unit:of(getTriggerUnit()), Item:of(BlzGetStackingItemTarget()), Item:of(BlzGetStackingItemSource()) end
+)
+__TS__ObjectDefineProperty(
+    Unit,
+    "itemChargesChangedEvent",
+    {get = function(self)
+        local event = __TS__New(Event)
+        Item.chargesChangedEvent:addListener(function(item)
+            local unit = item.owner
+            if unit ~= nil then
+                invoke(event, unit, item)
+            end
+        end)
+        rawset(self, "itemChargesChangedEvent", event)
+        return event
+    end}
 )
 __TS__ObjectDefineProperty(
     Unit,

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/permanent-invisibility.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class PermanentInvisibilityAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    get shouldAutoAcquireAttackTargets(): boolean[];
+    set shouldAutoAcquireAttackTargets(shouldAutoAcquireAttackTargets: ObjectDataEntryLevelFieldValueSupplier<boolean>);
+}

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

@@ -0,0 +1,26 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.PermanentInvisibilityAbilityType = __TS__Class()
+local PermanentInvisibilityAbilityType = ____exports.PermanentInvisibilityAbilityType
+PermanentInvisibilityAbilityType.name = "PermanentInvisibilityAbilityType"
+__TS__ClassExtends(PermanentInvisibilityAbilityType, AbilityType)
+PermanentInvisibilityAbilityType.BASE_ID = fourCC("Apiv")
+__TS__SetDescriptor(
+    PermanentInvisibilityAbilityType.prototype,
+    "shouldAutoAcquireAttackTargets",
+    {
+        get = function(self)
+            return self:getBooleanLevelField("Gho1")
+        end,
+        set = function(self, shouldAutoAcquireAttackTargets)
+            self:setBooleanLevelField("Gho1", shouldAutoAcquireAttackTargets)
+        end
+    },
+    true
+)
+return ____exports

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

@@ -38,6 +38,8 @@ local ____sound = require("core.types.sound")
 local isSoundLabelCustom = ____sound.isSoundLabelCustom
 local Sound3D = ____sound.Sound3D
 local SoundSettings = ____sound.SoundSettings
+local ____lua_2Dsets = require("utility.lua-sets")
+local luaSetOf = ____lua_2Dsets.luaSetOf
 local castAnimationFQNByAbilityTypeId = {}
 local isButtonVisibleFalseAbilityTypes = {}
 local casterCastingEffectPresetsByAbilityTypeId = {}
@@ -979,9 +981,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
     )
@@ -1006,9 +1006,10 @@ for abilityTypeId, soundPresetId in pairs(postcompile(function() return targetEf
         )
     end
 end
+local unsupportedEffectSoundAbilityTypeIds = luaSetOf(fourCC("AAns"))
 Unit.abilityChannelingStartEvent:addListener(function(caster, ability)
     local soundPresetId = ability:getField(ABILITY_SF_EFFECT_SOUND)
-    if isSoundLabelCustom(soundPresetId) then
+    if isSoundLabelCustom(soundPresetId) or soundPresetId ~= "" and unsupportedEffectSoundAbilityTypeIds[ability.parentTypeId] ~= nil then
         Sound3D:playFromLabel(soundPresetId, SoundSettings.Ability, caster)
     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;