warscript 0.0.1-dev.c37d12c → 0.0.1-dev.c59dd14

package/attributes.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+export type Attribute<T> = {
+    readonly __attribute: unique symbol;
+    readonly __type: T;
+} & symbol;
+export declare namespace Attribute {
+    const create: <T>() => Attribute<T>;
+}
+export declare class AttributesHolder {
+    readonly get: (<T>(attribute: Attribute<T>) => T | undefined) & LuaExtension<"TableGetMethod">;
+    readonly set: (<T>(attribute: Attribute<T>, value: T | undefined) => void) & LuaExtension<"TableSetMethod">;
+}

package/attributes.lua

@@ -0,0 +1,16 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+____exports.Attribute = {}
+local Attribute = ____exports.Attribute
+do
+    Attribute.create = function()
+        return {}
+    end
+end
+____exports.AttributesHolder = __TS__Class()
+local AttributesHolder = ____exports.AttributesHolder
+AttributesHolder.name = "AttributesHolder"
+function AttributesHolder.prototype.____constructor(self)
+end
+return ____exports

package/core/types/handle.d.ts

@@ -1,5 +1,6 @@
 /** @noSelfInFile */
 import { Event } from "../../event";
+import { AttributesHolder } from "../../attributes";
 export type HandleConstructor<H extends jhandle, T extends Handle<H>, Args extends any[]> = new (handle: H, ...args: Args) => T;
 export type HandleDestructor = {
     readonly __handleDestructor: unique symbol;
@@ -11,7 +12,7 @@ type NoOverride = {
 declare const enum HandlePropertyKey {
     STATE = 0
 }
-export declare class Handle<H extends jhandle, DestroyParameters extends any[] = []> implements Destroyable {
+export declare class Handle<H extends jhandle, DestroyParameters extends any[] = []> extends AttributesHolder implements Destroyable {
     readonly handle: H;
     private [HandlePropertyKey.STATE]?;
     private onDestroyEvent?;

package/core/types/handle.lua

@@ -1,5 +1,6 @@
 local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
 local __TS__New = ____lualib.__TS__New
 local __TS__Delete = ____lualib.__TS__Delete
 local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
@@ -12,13 +13,17 @@ local getClass = ____reflection.getClass
 local getSuperclass = ____reflection.getSuperclass
 local ____exception = require("exception")
 local IllegalStateException = ____exception.IllegalStateException
+local ____attributes = require("attributes")
+local AttributesHolder = ____attributes.AttributesHolder
 local getHandleId = GetHandleId
 local onCreateEventByHandleConstructor = {}
 local onDestroyEventByHandleConstructor = {}
 ____exports.Handle = __TS__Class()
 local Handle = ____exports.Handle
 Handle.name = "Handle"
+__TS__ClassExtends(Handle, AttributesHolder)
 function Handle.prototype.____constructor(self, handle)
+    AttributesHolder.prototype.____constructor(self)
     self[0] = 0
     local id = getHandleId(handle)
     local clazz = self.constructor

package/core/types/missile.d.ts

@@ -5,7 +5,7 @@ export declare class Missile implements Destroyable {
     readonly retarget: (this: void, target: Unit | Vec2) => void;
     private readonly update;
     protected constructor(effect: jeffect, retarget: (this: void, target: Unit | Vec2) => void, update: (this: Missile) => boolean);
-    static launch(config: Readonly<{
+    static launch<T extends any[]>(config: Readonly<{
         art: string;
         scale?: number;
         acceleration?: number;
@@ -15,7 +15,7 @@ export declare class Missile implements Destroyable {
         maxSpeed?: number;
         sourceOffset?: Vec2;
         targetOffset?: Vec2;
-    }>, source: Unit | Vec2, target: Unit | Vec2, onArrival: (missile: Missile, success: boolean) => void): Missile;
+    }>, source: Unit | Vec2, target: Unit | Vec2, onArrival: (missile: Missile, success: boolean, ...parameters: T) => void, ...parameters: T): Missile;
     destroy(): void;
 }
 export declare namespace Missile {

package/core/types/missile.lua

@@ -41,7 +41,8 @@ function Missile.prototype.____constructor(self, effect, retarget, update)
     end
     head = self
 end
-function Missile.launch(self, config, source, target, onArrival)
+function Missile.launch(self, config, source, target, onArrival, ...)
+    local parameters = {...}
     local ____opt_0 = config.sourceOffset
     local offsetX = ____opt_0 and ____opt_0.x or 0
     local ____opt_2 = config.sourceOffset
@@ -142,7 +143,12 @@ function Missile.launch(self, config, source, target, onArrival)
             visualPositionArcY = currentVisualTargetY
             visualPositionArcZ = currentVisualTargetZ
             retarget = false
-            safeCall(onArrival, self, true)
+            safeCall(
+                onArrival,
+                self,
+                true,
+                table.unpack(parameters)
+            )
             return not retarget
         end
         if arcVSpeed ~= 0 and (currentTargetX ~= initialTargetX or currentTargetY ~= initialTargetY) then

package/engine/behaviour/ability/apply-unit-behavior.d.ts

@@ -1,12 +1,16 @@
 /** @noSelfInFile */
 import { AbilityBehavior } from "../ability";
 import { Ability } from "../../internal/ability";
-import { UnitBehaviorConstructor } from "../unit";
+import { UnitBehavior } from "../unit";
 import { Unit } from "../../internal/unit";
-export declare class ApplyUnitBehaviorAbilityBehavior<Args extends any[]> extends AbilityBehavior {
-    private readonly createUnitBehavior;
+import { AbilityDependentValue } from "../../object-field/ability";
+export declare class ApplyUnitBehaviorAbilityBehavior<T extends UnitBehavior> extends AbilityBehavior {
+    private readonly unitBehaviorConstructor;
+    private readonly parameters?;
+    private readonly keys?;
     private unitBehavior?;
-    constructor(ability: Ability, unitBehaviorConstructor: UnitBehaviorConstructor<Args>, ...args: Args);
+    constructor(ability: Ability, unitBehaviorConstructor: new (unit: Unit) => T, parameters?: Partial<{ [K in keyof T & { [P in keyof T]-?: (<T_1>() => T_1 extends { [Q in P]: T[P]; } ? 1 : 2) extends <T_2>() => T_2 extends { -readonly [Q_1 in P]: T[P]; } ? 1 : 2 ? P : never; }[keyof T] & KeysOfType<T, string | number | boolean>]: T[K] extends string | number | boolean ? AbilityDependentValue<T[K]> : never; }> | undefined);
+    update(): void;
     onUnitGainAbility(unit: Unit): void;
     onUnitLoseAbility(): void;
 }

package/engine/behaviour/ability/apply-unit-behavior.lua

@@ -1,23 +1,38 @@
 local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
+local __TS__ArraySort = ____lualib.__TS__ArraySort
 local __TS__New = ____lualib.__TS__New
 local ____exports = {}
 local ____ability = require("engine.behaviour.ability")
 local AbilityBehavior = ____ability.AbilityBehavior
+local ____ability = require("engine.object-field.ability")
+local AbilityField = ____ability.AbilityField
+local AbilityLevelField = ____ability.AbilityLevelField
 ____exports.ApplyUnitBehaviorAbilityBehavior = __TS__Class()
 local ApplyUnitBehaviorAbilityBehavior = ____exports.ApplyUnitBehaviorAbilityBehavior
 ApplyUnitBehaviorAbilityBehavior.name = "ApplyUnitBehaviorAbilityBehavior"
 __TS__ClassExtends(ApplyUnitBehaviorAbilityBehavior, AbilityBehavior)
-function ApplyUnitBehaviorAbilityBehavior.prototype.____constructor(self, ability, unitBehaviorConstructor, ...)
-    local args = {...}
+function ApplyUnitBehaviorAbilityBehavior.prototype.____constructor(self, ability, unitBehaviorConstructor, parameters)
     AbilityBehavior.prototype.____constructor(self, ability)
-    self.createUnitBehavior = function(____, unit)
-        return __TS__New(
-            unitBehaviorConstructor,
-            unit,
-            table.unpack(args)
-        )
+    self.unitBehaviorConstructor = unitBehaviorConstructor
+    self.parameters = parameters
+    if parameters ~= nil then
+        self.keys = __TS__ArraySort(__TS__ObjectKeys(parameters))
+    end
+end
+function ApplyUnitBehaviorAbilityBehavior.prototype.update(self)
+    local unitBehavior = self.unitBehavior
+    local parameters = self.parameters
+    local keys = self.keys
+    if unitBehavior ~= nil and parameters ~= nil and keys ~= nil then
+        for ____, key in ipairs(keys) do
+            local value = parameters[key]
+            if value ~= nil then
+                unitBehavior[key] = self:resolveCurrentAbilityDependentValue(value)
+            end
+        end
     end
 end
 function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitGainAbility(self, unit)
@@ -25,7 +40,8 @@ function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitGainAbility(self, unit
     if ____opt_0 ~= nil then
         ____opt_0:destroy()
     end
-    self.unitBehavior = self:createUnitBehavior(unit)
+    self.unitBehavior = __TS__New(self.unitBehaviorConstructor, unit)
+    self:update()
 end
 function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitLoseAbility(self)
     local ____opt_2 = self.unitBehavior
@@ -33,4 +49,10 @@ function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitLoseAbility(self)
         ____opt_2:destroy()
     end
 end
+AbilityField.valueChangeEvent:addListener(function(ability)
+    ____exports.ApplyUnitBehaviorAbilityBehavior:forAll(ability, "update")
+end)
+AbilityLevelField.valueChangeEvent:addListener(function(ability)
+    ____exports.ApplyUnitBehaviorAbilityBehavior:forAll(ability, "update")
+end)
 return ____exports

package/engine/behaviour/ability/instant-impact.lua

@@ -12,8 +12,12 @@ local InstantImpactAbilityBehavior = ____exports.InstantImpactAbilityBehavior
 InstantImpactAbilityBehavior.name = "InstantImpactAbilityBehavior"
 __TS__ClassExtends(InstantImpactAbilityBehavior, AbilityBehavior)
 function InstantImpactAbilityBehavior.prototype.onCastingStart(self, caster)
+    local abilityTypeId = self.ability.typeId
     local manaCost = self:resolveCurrentAbilityDependentValue(MANA_COST_ABILITY_INTEGER_LEVEL_FIELD)
     local cooldown = self:resolveCurrentAbilityDependentValue(COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD)
+    if caster:getAbilityRemainingCooldown(abilityTypeId) ~= 0 or caster.mana < manaCost then
+        return
+    end
     caster.mana = caster.mana - manaCost
     if cooldown == 0 then
         caster:interruptCast(self.ability.typeId)

package/engine/behaviour/ability.d.ts

@@ -9,13 +9,20 @@ import { Destructable } from "../../core/types/destructable";
 import { EffectParameters } from "../../core/types/effect";
 import { AbilityDependentValue } from "../object-field/ability";
 export type AbilityBehaviorConstructor<Args extends any[]> = new (ability: Ability, ...args: Args) => AbilityBehavior;
-export declare abstract class AbilityBehavior<PeriodicActionParameters extends any[] = any[]> extends Behavior<Ability, PeriodicActionParameters> {
+export declare abstract class AbilityBehavior<Parameters extends {
+    periodicActionParameters?: any[];
+    missileParameters?: any[];
+} = {}> extends Behavior<Ability, NonNullable<Parameters["periodicActionParameters"]>> {
     constructor(ability: Ability);
     get ability(): Ability;
     protected resolveCurrentAbilityDependentValue<T extends boolean | number | string>(value: AbilityDependentValue<T>): T;
     protected flashAreaEffect(x: number, y: number, ...parametersOrDuration: [parameters?: EffectParameters] | [duration?: number, parameters?: EffectParameters]): void;
     protected flashEffect(x: number, y: number, ...parametersOrDuration: [parameters?: EffectParameters] | [duration?: number, parameters?: EffectParameters]): void;
     protected flashSpecialEffect(...args: [...pointOrWidget: [x: number, y: number] | [widget: Widget], duration?: number]): void;
+    private static MissileLaunchConfig;
+    private get missileLaunchConfig();
+    protected launchMissile(source: Unit, target: Unit, ...parameters: NonNullable<Parameters["missileParameters"]>): void;
+    onMissileArrival(...parameters: NonNullable<Parameters["missileParameters"]>): void;
     onUnitGainAbility(_unit: Unit): void;
     onUnitLoseAbility(_unit: Unit): void;
     onCastingStart(caster: Unit): void;

package/engine/behaviour/ability.lua

@@ -15,13 +15,52 @@ local Effect = ____effect.Effect
 local ____ability = require("engine.standard.fields.ability")
 local AREA_EFFECT_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD = ____ability.AREA_EFFECT_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD
 local EFFECT_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD = ____ability.EFFECT_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD
+local MISSILE_ARC_ABILITY_FLOAT_FIELD = ____ability.MISSILE_ARC_ABILITY_FLOAT_FIELD
+local MISSILE_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD = ____ability.MISSILE_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD
+local MISSILE_SPEED_ABILITY_INTEGER_FIELD = ____ability.MISSILE_SPEED_ABILITY_INTEGER_FIELD
 local SPECIAL_EFFECT_ATTACHMENT_POINT_STRING_FIELD = ____ability.SPECIAL_EFFECT_ATTACHMENT_POINT_STRING_FIELD
 local SPECIAL_EFFECT_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD = ____ability.SPECIAL_EFFECT_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD
 local ____ability = require("engine.object-field.ability")
 local resolveCurrentAbilityDependentValue = ____ability.resolveCurrentAbilityDependentValue
 local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
+local ____missile = require("core.types.missile")
+local Missile = ____missile.Missile
 local createBehaviorFunctionsByAbilityTypeId = {}
+local function invokeOnMissileArrival(_missile, success, abilityBehavior, ...)
+    if success then
+        abilityBehavior:onMissileArrival(...)
+    end
+end
+local ____class_0 = __TS__Class()
+____class_0.name = ""
+function ____class_0.prototype.____constructor(self, abilityBehavior)
+    self.abilityBehavior = abilityBehavior
+end
+__TS__SetDescriptor(
+    ____class_0.prototype,
+    "art",
+    {get = function(self)
+        return MISSILE_MODEL_PATHS_ABILITY_STRING_ARRAY_FIELD:getValue(self.abilityBehavior.ability, 0)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    ____class_0.prototype,
+    "arc",
+    {get = function(self)
+        return MISSILE_ARC_ABILITY_FLOAT_FIELD:getValue(self.abilityBehavior.ability)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    ____class_0.prototype,
+    "speed",
+    {get = function(self)
+        return MISSILE_SPEED_ABILITY_INTEGER_FIELD:getValue(self.abilityBehavior.ability)
+    end},
+    true
+)
 ____exports.AbilityBehavior = __TS__Class()
 local AbilityBehavior = ____exports.AbilityBehavior
 AbilityBehavior.name = "AbilityBehavior"
@@ -65,6 +104,18 @@ function AbilityBehavior.prototype.flashSpecialEffect(self, xOrWidget, yOrDurati
         )
     end
 end
+function AbilityBehavior.prototype.launchMissile(self, source, target, ...)
+    Missile:launch(
+        self.missileLaunchConfig,
+        source,
+        target,
+        invokeOnMissileArrival,
+        self,
+        ...
+    )
+end
+function AbilityBehavior.prototype.onMissileArrival(self, ...)
+end
 function AbilityBehavior.prototype.onUnitGainAbility(self, _unit)
 end
 function AbilityBehavior.prototype.onUnitLoseAbility(self, _unit)
@@ -127,6 +178,17 @@ __TS__SetDescriptor(
         return self.object
     end},
     true
+)
+AbilityBehavior.MissileLaunchConfig = ____class_0
+__TS__SetDescriptor(
+    AbilityBehavior.prototype,
+    "missileLaunchConfig",
+    {get = function(self)
+        local missileLaunchConfig = __TS__New(____exports.AbilityBehavior.MissileLaunchConfig, self)
+        rawset(self, "missileLaunchConfig", missileLaunchConfig)
+        return missileLaunchConfig
+    end},
+    true
 );
 (function(self)
     local function createUnitEventListener(key)

package/engine/internal/ability.d.ts

@@ -12,7 +12,7 @@ interface Fields<K, V> {
 interface AbilityLevel {
     realFields: Fields<jabilityreallevelfield, number>;
 }
-type jabilityfield = jabilityintegerfield | jabilityrealfield | jabilitybooleanfield | jabilitystringfield | jabilityintegerlevelfield | jabilityreallevelfield | jabilitybooleanlevelfield | jabilitystringlevelfield;
+export type jabilityfield = jabilityintegerfield | jabilityrealfield | jabilitybooleanfield | jabilitystringfield | jabilityintegerlevelfield | jabilityreallevelfield | jabilitybooleanlevelfield | jabilitystringlevelfield;
 export declare class AbilitySnapshot {
 }
 export declare abstract class Ability extends Handle<jability> {

package/engine/internal/mechanics/ability-duration.d.ts

@@ -1,4 +1,2 @@
 /** @noSelfInFile */
-import { Ability } from "../ability";
-import { Unit } from "../unit";
-export declare const getAbilityDuration: (ability: Ability, target?: Unit) => number;
+export {};

package/engine/internal/mechanics/ability-duration.lua

@@ -4,6 +4,8 @@ local UnitClassification = ____unit.UnitClassification
 local ____ability = require("engine.standard.fields.ability")
 local DURATION_HERO_ABILITY_FLOAT_LEVEL_FIELD = ____ability.DURATION_HERO_ABILITY_FLOAT_LEVEL_FIELD
 local DURATION_NORMAL_ABILITY_FLOAT_LEVEL_FIELD = ____ability.DURATION_NORMAL_ABILITY_FLOAT_LEVEL_FIELD
+---
+-- @internal For use by internal systems only.
 ____exports.getAbilityDuration = function(ability, target)
     local level = ability.level
     return target ~= nil and target:hasClassification(UnitClassification.RESISTANT) and DURATION_HERO_ABILITY_FLOAT_LEVEL_FIELD:getValue(ability, level) or DURATION_NORMAL_ABILITY_FLOAT_LEVEL_FIELD:getValue(ability, level)

package/engine/internal/mechanics/cast-ability.d.ts

@@ -0,0 +1,2 @@
+/** @noSelfInFile */
+export {};

package/engine/internal/mechanics/cast-ability.lua

@@ -0,0 +1,86 @@
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+local ____dummy_2Ditem = require("engine.internal.object-data.dummy-item")
+local DUMMY_ITEM_ID = ____dummy_2Ditem.DUMMY_ITEM_ID
+local ____dummy_2Dunits = require("engine.internal.misc.dummy-units")
+local INVENTORY_DUMMY_NATIVE_UNIT = ____dummy_2Dunits.INVENTORY_DUMMY_NATIVE_UNIT
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+local ____dummy_2Dinventory = require("engine.internal.object-data.dummy-inventory")
+local INVENTORY_ABILITY_TYPE_ID = ____dummy_2Dinventory.INVENTORY_ABILITY_TYPE_ID
+local ____arrays = require("utility.arrays")
+local map = ____arrays.map
+local toLuaSet = ____arrays.toLuaSet
+local createItem = CreateItem
+local getAbilityId = BlzGetAbilityId
+local getItemAbility = BlzGetItemAbility
+local getUnitAbilityByIndex = BlzGetUnitAbilityByIndex
+local itemAddAbility = BlzItemAddAbility
+local setItemBooleanField = BlzSetItemBooleanField
+local removeItem = RemoveItem
+local unitAddAbility = UnitAddAbility
+local unitAddItem = UnitAddItem
+local unitDropItemSlot = UnitDropItemSlot
+local unitInventorySize = UnitInventorySize
+local unitRemoveAbility = UnitRemoveAbility
+local unitRemoveItemFromSlot = UnitRemoveItemFromSlot
+local INVENTORY_ABILITY_TYPE_IDS = postcompile(function()
+    return toLuaSet(AbilityType:getAllIdsByBaseIds(map({
+        "AInv",
+        "Aihn",
+        "Aien",
+        "Aion",
+        "Aiun"
+    }, fourCC)))
+end)
+---
+-- @internal For use by internal systems only.
+____exports.castAbility = function(nativeUnit, abilityTypeId, prepareAbility, ...)
+    local nativeItem = createItem(DUMMY_ITEM_ID, 0, 0)
+    unitAddItem(INVENTORY_DUMMY_NATIVE_UNIT, nativeItem)
+    itemAddAbility(nativeItem, abilityTypeId)
+    local nativeAbility = checkNotNull(getItemAbility(nativeItem, abilityTypeId))
+    if prepareAbility ~= nil then
+        prepareAbility(nativeAbility, ...)
+    end
+    setItemBooleanField(nativeItem, ITEM_BF_ACTIVELY_USED, true)
+    setItemBooleanField(nativeItem, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+    local success
+    if unitAddItem(nativeUnit, nativeItem) then
+        success = true
+    else
+        local latestInventoryAbilityTypeId = 0
+        local nativeItemBySlot = {}
+        local inventorySize = unitInventorySize(nativeUnit)
+        if inventorySize ~= 0 then
+            for slot = 0, inventorySize - 1 do
+                nativeItemBySlot[slot] = unitRemoveItemFromSlot(nativeUnit, slot)
+            end
+            local unitNativeAbility = getUnitAbilityByIndex(nativeUnit, 0)
+            local i = 1
+            while unitNativeAbility ~= nil do
+                local abilityTypeId = getAbilityId(unitNativeAbility)
+                if INVENTORY_ABILITY_TYPE_IDS[abilityTypeId] ~= nil then
+                    latestInventoryAbilityTypeId = abilityTypeId
+                end
+                unitNativeAbility = getUnitAbilityByIndex(nativeUnit, i)
+                i = i + 1
+            end
+            unitRemoveAbility(nativeUnit, latestInventoryAbilityTypeId)
+        end
+        unitAddAbility(nativeUnit, INVENTORY_ABILITY_TYPE_ID)
+        success = unitAddItem(nativeUnit, nativeItem)
+        unitRemoveAbility(nativeUnit, INVENTORY_ABILITY_TYPE_ID)
+        if latestInventoryAbilityTypeId ~= 0 then
+            unitAddAbility(nativeUnit, latestInventoryAbilityTypeId)
+            for slot, nativeItem in pairs(nativeItemBySlot) do
+                unitAddItem(nativeUnit, nativeItem)
+                unitDropItemSlot(nativeUnit, nativeItem, slot)
+            end
+        end
+    end
+    removeItem(nativeItem)
+    return success
+end
+return ____exports

package/engine/internal/unit/detach-missiles.d.ts

@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+declare module "../unit" {
+    interface Unit {
+        detachMissiles(this: Unit): void;
+    }
+}
+export {};

package/engine/internal/unit/detach-missiles.lua

@@ -0,0 +1,30 @@
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____cast_2Dability = require("engine.internal.mechanics.cast-ability")
+local castAbility = ____cast_2Dability.castAbility
+local ____blink = require("engine.object-data.entry.ability-type.blink")
+local BlinkAbilityType = ____blink.BlinkAbilityType
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local getUnitX = GetUnitX
+local getUnitY = GetUnitY
+local setUnitX = SetUnitX
+local setUnitY = SetUnitY
+local BLINK_ABILITY_TYPE_ID = compiletime(function()
+    local abilityType = BlinkAbilityType:create()
+    abilityType.minimumRange = 0
+    abilityType.maximumRange = MAXIMUM_INTEGER
+    abilityType.manaCost = 0
+    abilityType.cooldown = 0
+    return abilityType.id
+end)
+Unit.prototype.detachMissiles = function(self)
+    local nativeUnit = self.handle
+    local x = getUnitX(nativeUnit)
+    local y = getUnitY(nativeUnit)
+    castAbility(nativeUnit, BLINK_ABILITY_TYPE_ID)
+    setUnitX(nativeUnit, x)
+    setUnitY(nativeUnit, y)
+end
+return ____exports

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

@@ -25,7 +25,7 @@ local function timerCallback(source, target)
     Event.invoke(autoAttackFinishEvent, source, target)
 end
 Unit.autoAttackStartEvent:addListener(function(source, target)
-    local attackPoint = source.weapons[1].attackPoint
+    local attackPoint = source.weapons[1].impactDelay
     local timer = Timer:simple(attackPoint, timerCallback, source, target)
     eventTimerByUnit[source] = timer
 end)

package/engine/internal/unit.d.ts

@@ -68,23 +68,44 @@ declare const modifiers: {
     speed: (unit: junit, value: number) => void;
     armor: (unit: junit, value: number) => void;
 };
-interface UnitWeapon {
+export declare class UnitWeapon {
+    readonly unit: Unit;
     readonly index: 0 | 1;
-    cooldown: number;
-    projectileArc: number;
-    projectileArt: string;
-    projectileSpeed: number;
-    attackPoint: number;
+    constructor(unit: Unit, index: 0 | 1);
+    get cooldown(): number;
+    set cooldown(cooldown: number);
+    get damage(): [minimumDamage: number, maximumDamage: number];
+    set damage([minimumDamage, maximumDamage]: [number, number]);
+    get damageBase(): number;
+    set damageBase(damageBase: number);
+    get damageDiceCount(): number;
+    set damageDiceCount(damageDiceCount: number);
+    get damageDiceSideCount(): number;
+    set damageDiceSideCount(damageDiceSideCount: number);
+    get range(): number;
+    set range(range: number);
+    get impactDelay(): number;
+    set impactDelay(impactDelay: number);
+    get missileArc(): number;
+    set missileArc(missileArc: number);
+    get missileModelPath(): string;
+    set missileModelPath(missileModelPath: string);
+    get missileSpeed(): number;
+    set missileSpeed(missileSpeed: number);
 }
 declare const enum UnitPropertyKey {
     IS_PAUSED = 100,
     STUN_COUNTER = 101,
-    PREVENT_DEATH_HEALTH_BONUS = 102,
-    IS_TEAM_GLOW_HIDDEN = 103
+    DELAY_HEALTH_CHECKS_COUNTER = 102,
+    DELAY_HEALTH_CHECKS_HEALTH_BONUS = 103,
+    PREVENT_DEATH_HEALTH_BONUS = 104,
+    IS_TEAM_GLOW_HIDDEN = 105
 }
 export declare class Unit extends Handle<junit> {
     private [UnitPropertyKey.IS_PAUSED]?;
     private [UnitPropertyKey.STUN_COUNTER]?;
+    private [UnitPropertyKey.DELAY_HEALTH_CHECKS_COUNTER]?;
+    private [UnitPropertyKey.DELAY_HEALTH_CHECKS_HEALTH_BONUS]?;
     private [UnitPropertyKey.PREVENT_DEATH_HEALTH_BONUS]?;
     private [UnitPropertyKey.IS_TEAM_GLOW_HIDDEN]?;
     private _owner?;
@@ -123,6 +144,8 @@ export declare class Unit extends Handle<junit> {
     playAnimation(animation: number): void;
     queueAnimation(animation: string): void;
     get weapons(): [UnitWeapon, UnitWeapon];
+    get firstWeapon(): UnitWeapon;
+    get secondWeapon(): UnitWeapon;
     get level(): number;
     set level(v: number);
     get xp(): number;
@@ -148,6 +171,10 @@ export declare class Unit extends Handle<junit> {
     set color(color: PlayerColor);
     get acquisitionRange(): number;
     set acquisitionRange(v: number);
+    /**
+     * Keeps this unit alive even if its health becomes negative until the current game thread yields.
+     */
+    delayHealthChecks(): void;
     get maxHealth(): number;
     set maxHealth(maxHealth: number);
     get healthRegenerationRate(): number;
@@ -222,6 +249,7 @@ export declare class Unit extends Handle<junit> {
     getAbilityById(abilityId: number): UnitAbility | undefined;
     removeAbility(abilityId: number): boolean;
     hideAbility(abilityId: number, flag: boolean): void;
+    getAbilityRemainingCooldown(abilityId: number): number;
     startAbilityCooldown(abilityId: number, cooldown: number): void;
     endAbilityCooldown(abilityId: number): void;
     interruptAttack(): void;