warscript 0.0.1-dev.b9f7033 → 0.0.1-dev.baa67d8

package/engine/buff.d.ts

@@ -13,6 +13,7 @@ import { UnitBehavior } from "./behaviour/unit";
 import type { Widget } from "../core/types/widget";
 import { Destructor } from "../destroyable";
 import { Event } from "../event";
+import { AbilityBehavior } from "./behaviour/ability";
 export type BuffConstructor<T extends Buff<any> = Buff<any>, Args extends any[] = any> = OmitConstructor<typeof Buff<any>> & (new (...args: Args) => T);
 type EnumParameterValueType<T extends number> = T | AbilityEnumLevelField<T>;
 type NumberParameterValueType = number | AbilityNumberField | AbilityNumberLevelField;
@@ -79,6 +80,7 @@ export type BuffParameters<T extends Buff<any> = Buff> = Buff extends T ? {
     healingOnExpiration?: NumberParameterValueType;
     killsOnExpiration?: BooleanParameterValueType;
     explodesOnExpiration?: BooleanParameterValueType;
+    abilityCooldownFactor?: NumberParameterValueType;
     uniqueGroup?: BuffUniqueGroup;
 } : BuffParameters & (T extends Buff<infer AdditionalParameters> ? AdditionalParameters : object);
 declare const enum BuffPropertyKey {
@@ -124,7 +126,9 @@ declare const enum BuffPropertyKey {
     PROVIDES_INVULNERABILITY = 139,
     KILLS_ON_EXPIRATION = 140,
     EXPLODES_ON_EXPIRATION = 141,
-    MISS_PROBABILITY = 142
+    MISS_PROBABILITY = 142,
+    ABILITY_COOLDOWN_FACTOR = 143,
+    ABILITY_COOLDOWN_MODIFIER = 144
 }
 export declare const enum BuffTypeIdSelectionPolicy {
     LEAST_DURATION = 0
@@ -138,7 +142,7 @@ export type BuffConstructorParameters<AdditionalParameters extends BuffAdditiona
     polarity: BuffPolarityParameterType,
     resistanceType: BuffResistanceTypeParameterType,
     ...abilityOrParameters: [
-        ability?: Ability,
+        ability?: Ability | AbilityBehavior,
         parameters?: BuffParameters & Omit<AdditionalParameters, keyof BuffParameters>
     ] | [parameters?: BuffParameters & Omit<AdditionalParameters, keyof BuffParameters>]
 ];
@@ -187,6 +191,8 @@ export declare class Buff<AdditionalParameters extends Prohibit<Record<string, a
     private [BuffPropertyKey.PROVIDES_INVULNERABILITY]?;
     private [BuffPropertyKey.KILLS_ON_EXPIRATION]?;
     private [BuffPropertyKey.EXPLODES_ON_EXPIRATION]?;
+    private [BuffPropertyKey.ABILITY_COOLDOWN_FACTOR]?;
+    private [BuffPropertyKey.ABILITY_COOLDOWN_MODIFIER]?;
     protected static readonly defaultParameters: BuffParameters;
     get source(): Unit;
     readonly typeId: ApplicableBuffTypeId;
@@ -262,6 +268,10 @@ export declare class Buff<AdditionalParameters extends Prohibit<Record<string, a
     get duration(): number;
     get remainingDuration(): number;
     set remainingDuration(remainingDuration: number);
+    get abilityCooldownFactor(): number;
+    set abilityCooldownFactor(abilityCooldownFactor: number);
+    onAbilityGained(ability: Ability): void;
+    onAbilityLost(ability: Ability): void;
     flashEffect(...parameters: [
         ...widgetOrXY: [] | [Widget] | [x: number, x: number],
         ...parametersOrDuration: [] | [EffectParameters] | [number]

package/engine/buff.lua

@@ -16,6 +16,7 @@ local internalApplyBuff = ____applicable.internalApplyBuff
 local removeBuff = ____applicable.removeBuff
 local ____ability = require("engine.internal.ability")
 local Ability = ____ability.Ability
+local UnitAbility = ____ability.UnitAbility
 local ____ability = require("engine.object-field.ability")
 local AbilityBooleanField = ____ability.AbilityBooleanField
 local AbilityNumberField = ____ability.AbilityNumberField
@@ -50,6 +51,10 @@ local ____item = require("engine.internal.item")
 local Item = ____item.Item
 local ____destructable = require("core.types.destructable")
 local Destructable = ____destructable.Destructable
+local ____ability = require("engine.standard.fields.ability")
+local COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD = ____ability.COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
 local getUnitAbility = BlzGetUnitAbility
 local stringValueByBuffTypeIdByFieldId = postcompile(function()
     local stringValueByBuffTypeIdByFieldId = {}
@@ -121,7 +126,8 @@ local buffParametersKeys = {
     damageOnExpiration = true,
     healingOnExpiration = true,
     killsOnExpiration = true,
-    explodesOnExpiration = true
+    explodesOnExpiration = true,
+    abilityCooldownFactor = true
 }
 local function resolveEnumValue(ability, level, value)
     if value == nil or type(value) == "number" then
@@ -198,7 +204,8 @@ local buffNumberParameters = {
     "healingPerInterval",
     "healingOverDuration",
     "damageOnExpiration",
-    "healingOnExpiration"
+    "healingOnExpiration",
+    "abilityCooldownFactor"
 }
 local unsuccessfulApplicationMarker = {}
 local function selectBuffTypeIdWithLeastDuration(buffTypeIds, unit)
@@ -317,33 +324,38 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
     local polarity
     local resistanceType
     local ability
+    local abilityBehavior
     if type(typeIdOrTypeIds) ~= "number" then
         typeId = selectBuffTypeIdWithLeastDuration(typeIdOrTypeIds, _unit)
         polarity = resistanceTypeOrPolarity
         resistanceType = abilityOrParametersOrResistanceType
-        if __TS__InstanceOf(parametersOrAbility, Ability) or parametersOrAbility == nil then
+        if __TS__InstanceOf(parametersOrAbility, AbilityBehavior) then
+            abilityBehavior = parametersOrAbility
+            ability = abilityBehavior.ability
+        elseif __TS__InstanceOf(parametersOrAbility, Ability) then
             ability = parametersOrAbility
-        else
-            ability = nil
+        elseif parametersOrAbility ~= nil then
             parameters = parametersOrAbility
         end
     else
         typeId = typeIdOrTypeIds
         polarity = polarityOrTypeIdSelectionPolicy
         resistanceType = resistanceTypeOrPolarity
-        if __TS__InstanceOf(abilityOrParametersOrResistanceType, Ability) or abilityOrParametersOrResistanceType == nil then
+        if __TS__InstanceOf(abilityOrParametersOrResistanceType, AbilityBehavior) then
+            abilityBehavior = abilityOrParametersOrResistanceType
+            ability = abilityBehavior.ability
+            parameters = parametersOrAbility
+        elseif __TS__InstanceOf(abilityOrParametersOrResistanceType, Ability) then
             ability = abilityOrParametersOrResistanceType
             parameters = parametersOrAbility
-        else
-            ability = nil
+        elseif abilityOrParametersOrResistanceType ~= nil then
             parameters = abilityOrParametersOrResistanceType
+        else
+            parameters = parametersOrAbility
         end
     end
+    self.sourceAbilityBehavior = abilityBehavior
     self.typeId = typeId
-    if not (__TS__InstanceOf(ability, Ability) or ability == nil) then
-        parameters = ability
-        ability = nil
-    end
     local defaultParameters = self.constructor.defaultParameters
     local level = parameters and parameters.level or defaultParameters.level
     local spellStealPriority = parameters and parameters.spellStealPriority or defaultParameters.spellStealPriority
@@ -506,6 +518,22 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
     self[100] = 1
     Event.invoke(buffCreatedEvent, self)
 end
+function Buff.prototype.onAbilityGained(self, ability)
+    if __TS__InstanceOf(ability, UnitAbility) then
+        local abilityCooldownModifier = self[144]
+        if abilityCooldownModifier then
+            COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:applyModifier(ability, abilityCooldownModifier)
+        end
+    end
+end
+function Buff.prototype.onAbilityLost(self, ability)
+    if __TS__InstanceOf(ability, UnitAbility) then
+        local abilityCooldownModifier = self[144]
+        if abilityCooldownModifier then
+            COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:removeModifier(ability, abilityCooldownModifier)
+        end
+    end
+end
 function Buff.prototype.flashEffect(self, widgetOrXOrParametersOrDuration, yOrParametersOrDuration, parametersOrDuration)
     if type(widgetOrXOrParametersOrDuration) == "number" and type(yOrParametersOrDuration) == "number" then
         Effect:flash(self[105], widgetOrXOrParametersOrDuration, yOrParametersOrDuration, parametersOrDuration)
@@ -580,6 +608,12 @@ function Buff.prototype.onDestroy(self)
             behavior:destroy()
         end
     end
+    local previousAbilityCooldownModifier = self[144]
+    if previousAbilityCooldownModifier then
+        for ____, ability in ipairs(self._unit.abilities) do
+            COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:removeModifier(ability, previousAbilityCooldownModifier)
+        end
+    end
     if self[139] then
         unit:decrementInvulnerabilityCounter()
     end
@@ -588,7 +622,7 @@ function Buff.prototype.onDestroy(self)
     end
     if self[136] then
         if self[137] then
-            unit:decrementStunCounter()
+            unit:decrementForceStunCounter()
         end
         unit:decrementStunCounter()
     end
@@ -987,13 +1021,13 @@ __TS__SetDescriptor(
         set = function(self, stuns)
             if not stuns and self[136] then
                 if self[137] then
-                    self.object:decrementStunCounter()
+                    self.object:decrementForceStunCounter()
                 end
                 self.object:decrementStunCounter()
                 self[136] = nil
             elseif stuns and not self[136] then
                 if self[137] then
-                    self.object:incrementStunCounter()
+                    self.object:incrementForceStunCounter()
                 end
                 self.object:incrementStunCounter()
                 self[136] = true
@@ -1016,12 +1050,12 @@ __TS__SetDescriptor(
         set = function(self, ignoresStunImmunity)
             if not ignoresStunImmunity and self[137] then
                 if self[136] then
-                    self.object:decrementStunCounter()
+                    self.object:decrementForceStunCounter()
                 end
                 self[137] = nil
             elseif ignoresStunImmunity and not self[137] then
                 if self[136] then
-                    self.object:incrementStunCounter()
+                    self.object:incrementForceStunCounter()
                 end
                 self[137] = true
             end
@@ -1269,6 +1303,32 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Buff.prototype,
+    "abilityCooldownFactor",
+    {
+        get = function(self)
+            return self[143] or 1
+        end,
+        set = function(self, abilityCooldownFactor)
+            local previousAbilityCooldownModifier = self[144]
+            if previousAbilityCooldownModifier then
+                for ____, ability in ipairs(self._unit.abilities) do
+                    COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:removeModifier(ability, previousAbilityCooldownModifier)
+                end
+            end
+            local function modifier(ability, level, cooldown)
+                return cooldown * abilityCooldownFactor
+            end
+            for ____, ability in ipairs(self._unit.abilities) do
+                COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:applyModifier(ability, modifier)
+            end
+            self[144] = modifier
+            self[143] = abilityCooldownFactor
+        end
+    },
+    true
+)
 Buff.createdEvent = buffCreatedEvent
 Buff.beingDestroyedEvent = buffBeingDestroyedEvent;
 (function(self)
@@ -1327,5 +1387,8 @@ Buff.beingDestroyedEvent = buffBeingDestroyedEvent;
     buffCreatedEvent:addListener(function(buff)
         UnitBehavior:forAll(buff.unit, "onBuffGained", buff)
     end)
+    buffBeingDestroyedEvent:addListener(function(buff)
+        UnitBehavior:forAll(buff.unit, "onBuffLost", buff)
+    end)
 end)(Buff)
 return ____exports

package/engine/internal/item.d.ts

@@ -28,22 +28,22 @@ export declare class Item extends Handle<jitem> {
     get extendedTooltip(): string;
     set iconPath(v: string);
     get iconPath(): string;
-    set dropOnDeath(v: boolean);
-    get dropOnDeath(): boolean;
-    set droppable(v: boolean);
-    get droppable(): boolean;
-    set pawnable(v: boolean);
-    get pawnable(): boolean;
-    set perishable(v: boolean);
-    get perishable(): boolean;
-    set powerup(v: boolean);
-    get powerup(): boolean;
+    set dropsOnDeath(dropsOnDeath: boolean);
+    get dropsOnDeath(): boolean;
+    set canBeDropped(canBeDropped: boolean);
+    get canBeDropped(): boolean;
+    set canBeSold(canBeSold: boolean);
+    get canBeSold(): boolean;
+    set perishes(perishes: boolean);
+    get perishes(): boolean;
+    set isPowerUp(isPowerUp: boolean);
+    get isPowerUp(): boolean;
     get isAlive(): boolean;
     get isDead(): boolean;
     set isInvulnerable(isInvulnerable: boolean);
     get isInvulnerable(): boolean;
-    set usable(v: boolean);
-    get usable(): boolean;
+    set isActivelyUsed(isActivelyUsed: boolean);
+    get isActivelyUsed(): boolean;
     set visible(v: boolean);
     get visible(): boolean;
     set level(v: number);

package/engine/internal/item.lua

@@ -50,6 +50,13 @@ local unitRemoveItem = UnitRemoveItem
 local unitUseItem = UnitUseItem
 local unitUseItemPoint = UnitUseItemPoint
 local unitUseItemTarget = UnitUseItemTarget
+local setItemDropOnDeath = SetItemDropOnDeath
+local setItemDroppable = SetItemDroppable
+local setItemPawnable = SetItemPawnable
+local isItemPawnable = IsItemPawnable
+local getItemIntegerField = BlzGetItemIntegerField
+local setItemBooleanField = BlzSetItemBooleanField
+local getItemBooleanField = BlzGetItemBooleanField
 local tableRemove = table.remove
 _G.SetItemCharges = function(whichItem, charges)
     setItemCharges(whichItem, charges)
@@ -58,9 +65,6 @@ _G.SetItemCharges = function(whichItem, charges)
         ____exports.Item:of(whichItem)
     )
 end
-local getItemIntegerField = BlzGetItemIntegerField
-local setItemBooleanField = BlzSetItemBooleanField
-local getItemBooleanField = BlzGetItemBooleanField
 invoke = Event.invoke
 local enumRect = Rect:create(0, 0, 0, 0).handle
 ---
@@ -328,65 +332,68 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "dropOnDeath",
+    "dropsOnDeath",
     {
         get = function(self)
-            return BlzGetItemBooleanField(self.handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
+            return getItemBooleanField(self.handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
         end,
-        set = function(self, v)
-            SetItemDropOnDeath(self.handle, v)
+        set = function(self, dropsOnDeath)
+            setItemDropOnDeath(self.handle, dropsOnDeath)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "droppable",
+    "canBeDropped",
     {
         get = function(self)
-            return BlzGetItemBooleanField(self.handle, ITEM_BF_CAN_BE_DROPPED)
+            return getItemBooleanField(self.handle, ITEM_BF_CAN_BE_DROPPED)
         end,
-        set = function(self, v)
-            SetItemDroppable(self.handle, v)
+        set = function(self, canBeDropped)
+            setItemDroppable(self.handle, canBeDropped)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "pawnable",
+    "canBeSold",
     {
         get = function(self)
-            return IsItemPawnable(self.handle)
+            return isItemPawnable(self.handle)
         end,
-        set = function(self, v)
-            SetItemPawnable(self.handle, v)
+        set = function(self, canBeSold)
+            setItemPawnable(self.handle, canBeSold)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "perishable",
+    "perishes",
     {
         get = function(self)
             return getItemBooleanField(self.handle, ITEM_BF_PERISHABLE)
         end,
-        set = function(self, v)
-            BlzSetItemBooleanField(self.handle, ITEM_BF_PERISHABLE, v)
+        set = function(self, perishes)
+            local handle = self.handle
+            local powerUp = isItemPowerup(handle)
+            setItemBooleanField(handle, ITEM_BF_PERISHABLE, perishes)
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerUp)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "powerup",
+    "isPowerUp",
     {
         get = function(self)
             return isItemPowerup(self.handle)
         end,
-        set = function(self, v)
-            setItemBooleanField(self.handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, v)
+        set = function(self, isPowerUp)
+            setItemBooleanField(self.handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, isPowerUp)
         end
     },
     true
@@ -422,16 +429,24 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "usable",
+    "isActivelyUsed",
     {
         get = function(self)
             return getItemBooleanField(self.handle, ITEM_BF_ACTIVELY_USED)
         end,
-        set = function(self, v)
+        set = function(self, isActivelyUsed)
             local handle = self.handle
-            local powerup = isItemPowerup(handle)
-            setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, v)
-            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerup)
+            local powerUp = isItemPowerup(handle)
+            local perishes = getItemBooleanField(handle, ITEM_BF_PERISHABLE)
+            local dropsOnDeath = getItemBooleanField(handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
+            local canBeDropped = getItemBooleanField(handle, ITEM_BF_CAN_BE_DROPPED)
+            local canBeSold = isItemPawnable(handle)
+            setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, isActivelyUsed)
+            setItemPawnable(handle, canBeSold)
+            setItemDroppable(handle, canBeDropped)
+            setItemDropOnDeath(handle, dropsOnDeath)
+            setItemBooleanField(handle, ITEM_BF_PERISHABLE, perishes)
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerUp)
         end
     },
     true

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

@@ -133,55 +133,55 @@ declare module "../unit" {
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityImpactEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityChannelingFinishEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityWidgetTargetImpactEvent: DispatchingEvent<[Unit, Ability, Widget]>;
+        const abilityStopEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityUnitTargetImpactEvent: DispatchingEvent<[Unit, Ability, Unit]>;
+        const abilityCommandEvent: {
+            readonly [abilityTypeId: number]: {
+                readonly [orderTypeStringId: string]: Event<[Unit, Ability, string]>;
+            };
+        };
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityItemTargetImpactEvent: DispatchingEvent<[Unit, Ability, Item]>;
+        const abilityImpactEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityDestructibleTargetImpactEvent: DispatchingEvent<[Unit, Ability, Destructable]>;
+        const abilityWidgetTargetImpactEvent: DispatchingEvent<[Unit, Ability, Widget]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityPointTargetImpactEvent: DispatchingEvent<[Unit, Ability, number, number]>;
+        const abilityUnitTargetImpactEvent: DispatchingEvent<[Unit, Ability, Unit]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityNoTargetImpactEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityItemTargetImpactEvent: DispatchingEvent<[Unit, Ability, Item]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityChannelingFinishEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityDestructibleTargetImpactEvent: DispatchingEvent<[Unit, Ability, Destructable]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityStopEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityPointTargetImpactEvent: DispatchingEvent<[Unit, Ability, number, number]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityCommandEvent: {
-            readonly [abilityTypeId: number]: {
-                readonly [orderTypeStringId: string]: Event<[Unit, Ability, string]>;
-            };
-        };
+        const abilityNoTargetImpactEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }

package/engine/internal/unit/ability.lua

@@ -22,7 +22,12 @@ local checkNotNull = ____preconditions.checkNotNull
 local ____lazy = require("utility.lazy")
 local lazyRecord = ____lazy.lazyRecord
 local ____timer = require("core.types.timer")
+local consumeZeroTimerCallback = ____timer.consumeZeroTimerCallback
 local Timer = ____timer.Timer
+local ____lua_2Dsets = require("utility.lua-sets")
+local luaSetOf = ____lua_2Dsets.luaSetOf
+local ____attributes = require("attributes")
+local attribute = ____attributes.attribute
 local eventInvoke = Event.invoke
 local condition = Condition
 local createTrigger = CreateTrigger
@@ -347,10 +352,65 @@ rawset(
         extractAbilityTypeId
     )
 )
+local internalAbilityChannelingFinishEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_FINISH, collectUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityChannelingFinishEvent",
+    createDispatchingEvent(internalAbilityChannelingFinishEvent, extractAbilityTypeId)
+)
+local internalAbilityStopEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_ENDCAST, collectUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityStopEvent",
+    createDispatchingEvent(internalAbilityStopEvent, extractAbilityTypeId)
+)
+rawset(
+    Unit,
+    "abilityCommandEvent",
+    lazyRecord(function(abilityTypeId)
+        return lazyRecord(function(orderTypeStringId)
+            return __TS__New(
+                InitializingEvent,
+                function(event)
+                    local trigger = createTrigger()
+                    triggerRegisterCommandEvent(trigger, abilityTypeId, orderTypeStringId)
+                    triggerAddCondition(
+                        trigger,
+                        condition(function()
+                            local unit = Unit:of(getTriggerUnit())
+                            if unit ~= nil then
+                                local ability = unit:getAbility(abilityTypeId)
+                                if ability ~= nil then
+                                    eventInvoke(event, unit, ability, orderTypeStringId)
+                                end
+                            end
+                        end)
+                    )
+                end
+            )
+        end)
+    end)
+)
 local internalAbilityImpactEvent = __TS__New(Event)
-internalAbilityChannelingStartEvent:addListener(function(...)
-    Timer:run(eventInvoke, internalAbilityImpactEvent, ...)
-end)
+local impactCallbackIdAttribute = attribute()
+local function invokeImpactEvent(unit, ability, ...)
+    ability[impactCallbackIdAttribute] = nil
+    eventInvoke(internalAbilityImpactEvent, unit, ability, ...)
+end
+internalAbilityChannelingStartEvent:addListener(
+    999999,
+    function(unit, ability, ...)
+        ability[impactCallbackIdAttribute] = Timer:run(invokeImpactEvent, unit, ability, ...)
+    end
+)
+local function consumeImpactCallback(_, ability)
+    local impactCallbackId = ability[impactCallbackIdAttribute]
+    if impactCallbackId ~= nil then
+        consumeZeroTimerCallback(impactCallbackId)
+    end
+end
+internalAbilityChannelingFinishEvent:addListener(999999, consumeImpactCallback)
+internalAbilityStopEvent:addListener(999999, consumeImpactCallback)
 rawset(
     Unit,
     "abilityImpactEvent",
@@ -407,47 +467,14 @@ rawset(
         extractAbilityTypeId
     )
 )
-rawset(
-    Unit,
-    "abilityChannelingFinishEvent",
-    createDispatchingEvent(
-        __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_FINISH, collectUnitAbilityEventParameters),
-        extractAbilityTypeId
-    )
-)
-rawset(
-    Unit,
-    "abilityStopEvent",
-    createDispatchingEvent(
-        __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_ENDCAST, collectUnitAbilityEventParameters),
-        extractAbilityTypeId
-    )
-)
-rawset(
-    Unit,
-    "abilityCommandEvent",
-    lazyRecord(function(abilityTypeId)
-        return lazyRecord(function(orderTypeStringId)
-            return __TS__New(
-                InitializingEvent,
-                function(event)
-                    local trigger = createTrigger()
-                    triggerRegisterCommandEvent(trigger, abilityTypeId, orderTypeStringId)
-                    triggerAddCondition(
-                        trigger,
-                        condition(function()
-                            local unit = Unit:of(getTriggerUnit())
-                            if unit ~= nil then
-                                local ability = unit:getAbility(abilityTypeId)
-                                if ability ~= nil then
-                                    eventInvoke(event, unit, ability, orderTypeStringId)
-                                end
-                            end
-                        end)
-                    )
-                end
-            )
-        end)
-    end)
+local spellEffectOnlyAbilityTypeIds = luaSetOf(fourCC("AAns"))
+internalAbilityChannelingStartEvent:addListener(
+    -999999,
+    function(unit, ability)
+        if spellEffectOnlyAbilityTypeIds[ability.parentTypeId] ~= nil then
+            eventInvoke(internalAbilityChannelingFinishEvent, unit, ability)
+            eventInvoke(internalAbilityStopEvent, unit, ability)
+        end
+    end
 )
 return ____exports

package/engine/internal/unit/fly-height.d.ts

@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+declare module "../unit" {
+    interface Unit {
+        flyHeight: number;
+    }
+}
+export {};

package/engine/internal/unit/fly-height.lua

@@ -0,0 +1,20 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____unit = require("engine.standard.fields.unit")
+local FLY_HEIGHT_UNIT_FLOAT_FIELD = ____unit.FLY_HEIGHT_UNIT_FLOAT_FIELD
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "flyHeight",
+    {
+        get = function(self)
+            return FLY_HEIGHT_UNIT_FLOAT_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            FLY_HEIGHT_UNIT_FLOAT_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports