warscript 0.0.1-dev.effa673 → 0.0.1-dev.f024cc2

package/engine/internal/misc/damage-metadata-by-target.lua

@@ -0,0 +1,5 @@
+local ____exports = {}
+---
+-- @internal For use by internal systems only.
+____exports.damageMetadataByTarget = setmetatable({}, {__mode = "k"})
+return ____exports

package/engine/internal/misc/frame-coordinates.d.ts

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

package/engine/internal/misc/frame-coordinates.lua

@@ -0,0 +1,21 @@
+local ____exports = {}
+local getLocalClientWidth = BlzGetLocalClientWidth
+local getLocalClientHeight = BlzGetLocalClientHeight
+---
+-- @internal For use by internal systems only.
+____exports.getFrameMinXMaxX = function()
+    local w = getLocalClientWidth()
+    local h = getLocalClientHeight()
+    local width4by3 = (w - h / 600 * 800) / 2
+    local pxtodpi = 0.6 / h
+    local minX = -width4by3 * pxtodpi
+    local maxX = minX + w * pxtodpi
+    return minX, maxX
+end
+---
+-- @internal For use by internal systems only.
+____exports.FRAME_MIN_Y = 0
+---
+-- @internal For use by internal systems only.
+____exports.FRAME_MAX_Y = 0.6
+return ____exports

package/engine/internal/misc/get-terrain-z.d.ts

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

package/engine/internal/misc/get-terrain-z.lua

@@ -0,0 +1,11 @@
+local ____exports = {}
+local getLocationZ = GetLocationZ
+local moveLocation = MoveLocation
+local location = Location(0, 0)
+---
+-- @internal For use by internal systems only.
+____exports.getTerrainZ = function(x, y)
+    moveLocation(location, x, y)
+    return getLocationZ(location)
+end
+return ____exports

package/engine/internal/misc/player-local-handle.d.ts

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

package/engine/internal/misc/player-local-handle.lua

@@ -0,0 +1,5 @@
+local ____exports = {}
+---
+-- @internal For use by internal systems only.
+____exports.PLAYER_LOCAL_HANDLE = GetLocalPlayer()
+return ____exports

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

@@ -131,6 +131,41 @@ declare module "../unit" {
         const abilityNoTargetChannelingStartEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
+declare module "../unit" {
+    namespace 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

@@ -21,6 +21,8 @@ local ____preconditions = require("utility.preconditions")
 local checkNotNull = ____preconditions.checkNotNull
 local ____lazy = require("utility.lazy")
 local lazyRecord = ____lazy.lazyRecord
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
 local eventInvoke = Event.invoke
 local condition = Condition
 local createTrigger = CreateTrigger
@@ -345,6 +347,66 @@ rawset(
         extractAbilityTypeId
     )
 )
+local internalAbilityImpactEvent = __TS__New(Event)
+internalAbilityChannelingStartEvent:addListener(function(...)
+    Timer:run(eventInvoke, internalAbilityImpactEvent, ...)
+end)
+rawset(
+    Unit,
+    "abilityImpactEvent",
+    createDispatchingEvent(
+        createCommonEvent(internalAbilityImpactEvent),
+        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/allowed-targets.d.ts

@@ -2,7 +2,7 @@
 import { CombatClassifications } from "../../object-data/auxiliary/combat-classification";
 declare module "../unit" {
     interface Unit {
-        isAllowedTarget(this: Unit, source: Unit, allowedTargetCombatClassifications: CombatClassifications): boolean;
+        isAllowedTarget(this: Unit, source: Unit, allowedTargetCombatClassifications?: CombatClassifications): boolean;
     }
 }
 declare module "../unit" {

package/engine/internal/unit/allowed-targets.lua

@@ -5,7 +5,15 @@ local initializeFilterTargetState = ____combat_2Dclassification.initializeFilter
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 Unit.prototype.isAllowedTarget = function(self, source, allowedTargetCombatClassifications)
-    initializeFilterTargetState(source, allowedTargetCombatClassifications)
+    if allowedTargetCombatClassifications ~= nil then
+        initializeFilterTargetState(source, allowedTargetCombatClassifications)
+        return filterTarget(self)
+    end
+    initializeFilterTargetState(source, source.firstWeapon.allowedTargetCombatClassifications)
+    if filterTarget(self) then
+        return true
+    end
+    initializeFilterTargetState(source, source.secondWeapon.allowedTargetCombatClassifications)
     return filterTarget(self)
 end
 Unit.getAllowedTargetsInRange = function(source, allowedTargetCombatClassifications, x, y, range)

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+ability.lua

@@ -7,8 +7,8 @@ local UnitAbility = ____ability.UnitAbility
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
-local Event = ____event.Event
 local createDispatchingEvent = ____event.createDispatchingEvent
+local Event = ____event.Event
 local abilityGainedEvent = createDispatchingEvent(
     __TS__New(Event),
     function(unit, ability) return ability.typeId end

package/engine/internal/unit+damage.d.ts

@@ -1,15 +1,6 @@
 /** @noSelfInFile */
 import { Widget } from "../../core/types/widget";
-export type AttackType = jattacktype;
-export declare namespace AttackType {
-    const SPELL: jattacktype;
-    const NORMAL: jattacktype;
-    const PIERCE: jattacktype;
-    const SIEGE: jattacktype;
-    const MAGIC: jattacktype;
-    const CHAOS: jattacktype;
-    const HERO: jattacktype;
-}
+import { AttackType } from "../object-data/auxiliary/attack-type";
 export type DamageType = jdamagetype;
 export declare namespace DamageType {
     const UNKNOWN: jdamagetype;
@@ -64,6 +55,6 @@ export declare namespace WeaponType {
 }
 declare module "./unit" {
     interface Unit {
-        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType): boolean;
+        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType, metadata?: unknown): boolean;
     }
 }

package/engine/internal/unit+damage.lua

@@ -7,21 +7,14 @@ local ____player = require("core.types.player")
 local Player = ____player.Player
 local ____dummy = require("objutil.dummy")
 local dummyUnitId = ____dummy.dummyUnitId
+local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
+local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
+local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
 local createUnit = CreateUnit
 local getOwningPlayer = GetOwningPlayer
 local showUnit = ShowUnit
 local unitDamageTarget = UnitDamageTarget
-____exports.AttackType = {}
-local AttackType = ____exports.AttackType
-do
-    AttackType.SPELL = ATTACK_TYPE_NORMAL
-    AttackType.NORMAL = ATTACK_TYPE_MELEE
-    AttackType.PIERCE = ATTACK_TYPE_PIERCE
-    AttackType.SIEGE = ATTACK_TYPE_SIEGE
-    AttackType.MAGIC = ATTACK_TYPE_MAGIC
-    AttackType.CHAOS = ATTACK_TYPE_CHAOS
-    AttackType.HERO = ATTACK_TYPE_HERO
-end
 ____exports.DamageType = {}
 local DamageType = ____exports.DamageType
 do
@@ -88,7 +81,7 @@ for ____, player in ipairs(Player.all) do
     showUnit(dummy, false)
     dummies[player] = dummy
 end
-Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType)
+Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType, metadata)
     if attack == nil then
         attack = false
     end
@@ -96,7 +89,7 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
         ranged = false
     end
     if attackType == nil then
-        attackType = ____exports.AttackType.SPELL
+        attackType = 0
     end
     if damageType == nil then
         damageType = ____exports.DamageType.MAGIC
@@ -109,13 +102,16 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
     if not getOwningPlayer(handle) then
         handle = dummies[__TS__InstanceOf(target, Unit) and target.owner or (self._owner or Player.neutralAggressive)]
     end
+    if __TS__InstanceOf(target, Unit) then
+        damageMetadataByTarget[target] = metadata
+    end
     return unitDamageTarget(
         handle,
         targetHandle,
         amount,
         attack,
         ranged,
-        attackType,
+        attackTypeToNative(attackType),
         damageType,
         weaponType
     )

package/engine/internal/unit+spellSteal.lua

@@ -6,7 +6,6 @@ local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____unit_2Bdamage = require("engine.internal.unit+damage")
-local AttackType = ____unit_2Bdamage.AttackType
 local DamageType = ____unit_2Bdamage.DamageType
 local ____event = require("event")
 local Event = ____event.Event
@@ -33,7 +32,7 @@ local spellStealEventStack = {}
 Unit.onDamaging:addListener(function(source, target, event)
     if event.amount == 0 and source ~= nil then
         local count = countByUnit[source] or 0
-        if count > 0 and event.attackType == AttackType.SPELL then
+        if count > 0 and event.attackType == 0 then
             if event.damageType == DamageType.UNKNOWN then
                 spellStealEventStack[#spellStealEventStack + 1] = {
                     sourceBuffIds = source.buffIds,

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

@@ -9,6 +9,8 @@ local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
 local ____lua_2Dsets = require("utility.lua-sets")
 local luaSetOf = ____lua_2Dsets.luaSetOf
+local ____math = require("math")
+local min = ____math.min
 local autoAttackFinishEvent = __TS__New(Event)
 rawset(Unit, "autoAttackFinishEvent", autoAttackFinishEvent)
 local eventTimerByUnit = {}
@@ -44,8 +46,13 @@ local function timerCallback(source, target)
     Event.invoke(autoAttackFinishEvent, source, target)
 end
 Unit.autoAttackStartEvent:addListener(function(source, target)
-    local attackPoint = source.weapons[1].impactDelay
-    local timer = Timer:simple(attackPoint, timerCallback, source, target)
+    local attackPoint = (source:chooseWeapon(target) or source.firstWeapon).impactDelay
+    local timer = Timer:simple(
+        attackPoint + min(0.001, attackPoint / 2),
+        timerCallback,
+        source,
+        target
+    )
     eventTimerByUnit[source] = timer
 end)
 return ____exports

package/engine/internal/unit.d.ts

@@ -11,6 +11,10 @@ import { Ability, UnitAbility } from "./ability";
 import { Widget } from "../../core/types/widget";
 import type { UnitTypeId } from "../object-data/entry/unit-type";
 import { CombatClassification, CombatClassifications } from "../object-data/auxiliary/combat-classification";
+import { MovementType } from "../object-data/auxiliary/movement-type";
+import { UnitAttribute } from "../object-data/auxiliary/unit-attribute";
+import { AttackType } from "../object-data/auxiliary/attack-type";
+import { AttributesHolder } from "../../attributes";
 export type UnitClassification = junittype;
 export declare namespace UnitClassification {
     const STRUCTURE: junittype;
@@ -19,6 +23,7 @@ export declare namespace UnitClassification {
     const GROUND: junittype;
     const SUMMONED: junittype;
     const MECHANICAL: junittype;
+    const WORKER: junittype;
     const ANCIENT: junittype;
     const SUICIDAL: junittype;
     const TAUREN: junittype;
@@ -36,15 +41,18 @@ type AbilityDispatcherTable<T extends any[] = []> = {
     readonly [id: number]: Event<[Unit, Ability, ...T]>;
 };
 type AbilityEventDispatcher<T extends any[] = []> = Event<[Unit, Ability, ...T]> & AbilityDispatcherTable<T>;
-export interface DamagingEvent {
+export interface DamagingEvent extends AttributesHolder {
     amount: number;
-    attackType: jattacktype;
+    attackType: AttackType;
     damageType: jdamagetype;
     weaponType: jweapontype;
+    metadata: unknown;
     readonly isAttack: boolean;
     readonly originalAmount: number;
+    readonly originalMetadata: unknown;
+    preventRetaliation(this: DamagingEvent): void;
 }
-export type DamageEvent = DamagingEvent & {
+export type DamageEvent = Omit<DamagingEvent, "preventRetaliation"> & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
 };
 export type AttackDamageEvent = DamagingEvent & {
@@ -76,6 +84,8 @@ export declare class UnitWeapon {
     set cooldown(cooldown: number);
     get damage(): [minimumDamage: number, maximumDamage: number];
     set damage([minimumDamage, maximumDamage]: [number, number]);
+    get allowedTargetCombatClassifications(): CombatClassifications;
+    set allowedTargetCombatClassifications(allowedTargetCombatClassifications: CombatClassifications);
     get damageBase(): number;
     set damageBase(damageBase: number);
     get damageDiceCount(): number;
@@ -150,17 +160,19 @@ 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];
     get firstWeapon(): UnitWeapon;
     get secondWeapon(): UnitWeapon;
+    chooseWeapon(target: Unit): UnitWeapon | undefined;
     get level(): number;
     set level(v: number);
     get xp(): number;
     set xp(v: number);
+    get primaryAttribute(): UnitAttribute;
+    set primaryAttribute(primaryAttribute: UnitAttribute);
     get strengthBase(): number;
     set strengthBase(strengthBase: number);
     get strengthBonus(): number;
@@ -235,6 +247,8 @@ export declare class Unit extends Handle<junit> {
     set timeScale(v: number);
     get collisionSize(): number;
     get pathingCollisionRange(): number;
+    get movementType(): MovementType;
+    set movementType(movementType: MovementType);
     set pathing(v: boolean);
     isSelected(player: Player): boolean;
     explode(): void;
@@ -252,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;
@@ -263,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;
@@ -285,6 +300,7 @@ export declare class Unit extends Handle<junit> {
     get onUnitInRange(): Record<number, Event<[Unit]>>;
     get onManaEqual(): Record<number, Event<[Unit, number]>>;
     get manaEvent(): Record<Operator, Record<number, Event<[Unit]>>>;
+    get targetAcquiredEvent(): Event;
     get onSelect(): Event;
     get onDeselect(): Event;
     get onImmediateOrder(): Event<[number]>;
@@ -337,7 +353,8 @@ export declare class Unit extends Handle<junit> {
     static itemDroppedEvent: UnitTriggerEvent<[Item]>;
     static itemPickedUpEvent: UnitTriggerEvent<[Item]>;
     static itemUsedEvent: UnitTriggerEvent<[Item]>;
-    static itemStackedEvent: UnitTriggerEvent<[Item]>;
+    static itemStackedEvent: UnitTriggerEvent<[target: Item, source: Item]>;
+    static get itemChargesChangedEvent(): Event<[unit: Unit, item: Item]>;
     static get itemUseOrderEvent(): Event<[unit: Unit, item: Item]>;
     static get itemMoveOrderEvent(): Event<[
         unit: Unit,