warscript 0.0.1-dev.959b9a7 → 0.0.1-dev.987b772

package/engine/game-map.lua

@@ -0,0 +1,32 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____rect = require("core.types.rect")
+local Rect = ____rect.Rect
+local ____region = require("core.types.region")
+local Region = ____region.Region
+____exports.GameMap = __TS__Class()
+local GameMap = ____exports.GameMap
+GameMap.name = "GameMap"
+function GameMap.prototype.____constructor(self)
+end
+__TS__ObjectDefineProperty(
+    GameMap,
+    "worldBoundsRect",
+    {get = function(self)
+        local rect = Rect:of(GetWorldBounds())
+        rawset(self, "worldBoundsRect", rect)
+        return rect
+    end}
+)
+__TS__ObjectDefineProperty(
+    GameMap,
+    "worldBoundsRegion",
+    {get = function(self)
+        local region = Region:create(self.worldBoundsRect)
+        rawset(self, "worldBoundsRegion", region)
+        return region
+    end}
+)
+return ____exports

package/engine/internal/ability.d.ts

@@ -4,14 +4,6 @@ import { Event } from "../../event";
 import type { Item } from "../../core/types/item";
 import type { Unit } from "./unit";
 import type { AbilityTypeId } from "../object-data/entry/ability-type";
-interface Fields<K, V> {
-    set(field: K, value: V): boolean;
-    get(field: K): V;
-    has(field: K): boolean;
-}
-interface AbilityLevel {
-    realFields: Fields<jabilityreallevelfield, number>;
-}
 export type jabilityfield = jabilityintegerfield | jabilityrealfield | jabilitybooleanfield | jabilitystringfield | jabilityintegerlevelfield | jabilityreallevelfield | jabilitybooleanlevelfield | jabilitystringlevelfield;
 export declare class AbilitySnapshot {
 }
@@ -40,8 +32,7 @@ export declare abstract class Ability extends Handle<jability> {
     setField(field: jabilityintegerlevelfield | jabilityreallevelfield, level: number, value: number): boolean;
     setField(field: jabilitybooleanlevelfield, level: number, value: boolean): boolean;
     setField(field: jabilitystringlevelfield, level: number, value: string): boolean;
-    get realFields(): Fields<jabilityrealfield, number>;
-    get levels(): readonly AbilityLevel[];
+    get levelCount(): number;
     abstract get level(): number;
     static get onCreate(): Event<[Ability]>;
     static get destroyEvent(): Event<[Ability]>;
@@ -88,4 +79,3 @@ export declare class ItemAbility extends Ability {
     static get onCreate(): Event<[ItemAbility]>;
     static get onDestroy(): Event<[ItemAbility]>;
 }
-export {};

package/engine/internal/ability.lua

@@ -2,7 +2,6 @@ local ____lualib = require("lualib_bundle")
 local __TS__ArrayMap = ____lualib.__TS__ArrayMap
 local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
 local __TS__Class = ____lualib.__TS__Class
-local __TS__New = ____lualib.__TS__New
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
 local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
@@ -33,7 +32,6 @@ local getAbilityStringLevelField = BlzGetAbilityStringLevelField
 local getUnitAbilityCooldownRemaining = BlzGetUnitAbilityCooldownRemaining
 local startUnitAbilityCooldown = BlzStartUnitAbilityCooldown
 local getHandleId = GetHandleId
-local getItemAbility = BlzGetItemAbility
 local match = string.match
 local ____type = _G.type
 local ____tostring = _G.tostring
@@ -151,55 +149,6 @@ local orders = postcompile(function()
     end
     return orders
 end)
-local RealFields = __TS__Class()
-RealFields.name = "RealFields"
-function RealFields.prototype.____constructor(self, handle)
-    self.handle = handle
-end
-function RealFields.prototype.set(self, field, value)
-    return BlzSetAbilityRealField(self.handle, field, value)
-end
-function RealFields.prototype.get(self, field)
-    return BlzGetAbilityRealField(self.handle, field)
-end
-function RealFields.prototype.has(self, field)
-    local handle = self.handle
-    return BlzSetAbilityRealField(
-        handle,
-        field,
-        BlzGetAbilityRealField(handle, field)
-    )
-end
-local RealLevelFields = __TS__Class()
-RealLevelFields.name = "RealLevelFields"
-function RealLevelFields.prototype.____constructor(self, handle, level)
-    self.handle = handle
-    self.level = level
-end
-function RealLevelFields.prototype.set(self, field, value)
-    return BlzSetAbilityRealLevelField(self.handle, field, self.level, value)
-end
-function RealLevelFields.prototype.get(self, field)
-    return BlzGetAbilityRealLevelField(self.handle, field, self.level)
-end
-function RealLevelFields.prototype.has(self, field)
-    local handle = self.handle
-    return BlzSetAbilityRealLevelField(
-        handle,
-        field,
-        0,
-        BlzGetAbilityRealLevelField(handle, field, 0)
-    )
-end
-local realLevelMetatable = {__index = self}
-local levelDescriptors = {realFields = function(self, handle, level)
-    return __TS__New(RealLevelFields, handle, level)
-end}
-local levelMetatable = {__index = function(self, key)
-    local fields = levelDescriptors[key](levelDescriptors, self.handle, self.level)
-    rawset(self, key, fields)
-    return fields
-end}
 local fieldGetters = {
     abilityintegerfield = function(ability, field)
         return getAbilityIntegerField(ability.handle, field)
@@ -355,34 +304,9 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Ability.prototype,
-    "realFields",
+    "levelCount",
     {get = function(self)
-        local realFields = __TS__New(RealFields, self.handle)
-        rawset(self, "realFields", realFields)
-        return realFields
-    end},
-    true
-)
-__TS__SetDescriptor(
-    Ability.prototype,
-    "levels",
-    {get = function(self)
-        local handle = self.handle
-        local levels = setmetatable(
-            {},
-            {
-                __len = function(self)
-                    return BlzGetAbilityIntegerField(handle, ABILITY_IF_LEVELS)
-                end,
-                __index = function(self, i)
-                    local level = setmetatable({handle = handle, level = i - 1}, levelMetatable)
-                    self[i] = level
-                    return level
-                end
-            }
-        )
-        rawset(self, "levels", levels)
-        return levels
+        return self:getField(ABILITY_IF_LEVELS)
     end},
     true
 )

package/engine/internal/item+owner.lua

@@ -6,10 +6,10 @@ local Item = ____item.Item
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ownerByItem = setmetatable({}, {__mode = "kv"})
-Unit.onItemPickup:addListener(function(unit, item)
+Unit.itemPickedUpEvent:addListener(function(unit, item)
     ownerByItem[item] = unit
 end)
-Unit.onItemDrop:addListener(function(unit, item)
+Unit.itemDroppedEvent:addListener(function(unit, item)
     ownerByItem[item] = nil
 end)
 __TS__ObjectDefineProperty(

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

@@ -1,4 +1,3 @@
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 import { Unit } from "../unit";
 import { AbilityTypeId } from "../../object-data/entry/ability-type";
@@ -9,7 +8,8 @@ export type UnitBonusId<Brand extends string = any> = number & {
 export type UnitArmorBonusId = UnitBonusId<"armor">;
 export type UnitAttackSpeedFactorBonusId = UnitBonusId<"attackSpeedFactor">;
 export type UnitMovementSpeedFactorBonusId = UnitBonusId<"movementSpeedFactor">;
-export type UnitDamageBonusId = UnitBonusId<"damage">;
+export type UnitAutoAttackDamageBonusId = UnitBonusId<"autoAttackDamage">;
+export type UnitDamageFactorBonusId = UnitBonusId<"damageFactor">;
 export type UnitReceivedDamageFactorBonusId = UnitBonusId<"receivedDamageFactor">;
 export type UnitBonusType<Id extends UnitBonusId = UnitBonusId> = ({
     abilityTypeId: AbilityTypeId;
@@ -31,11 +31,12 @@ export declare namespace UnitBonusType {
     const ARMOR: UnitBonusType<UnitArmorBonusId>;
     const ATTACK_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
     const MOVEMENT_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
-    const DAMAGE: UnitBonusType<UnitDamageBonusId>;
+    const AUTO_ATTACK_DAMAGE: UnitBonusType<UnitAutoAttackDamageBonusId>;
+    const DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
     const RECEIVED_DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
 }
-export declare const addUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, value: number) => Id;
-export declare const removeUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => boolean;
-export declare const updateUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id, value: number) => boolean;
-export declare const addOrUpdateOrRemoveUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id | undefined, value: number) => Id | undefined;
-export declare const getUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => number;
+export declare const addUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, value: number) => Id;
+export declare const removeUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => boolean;
+export declare const updateUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id, value: number) => boolean;
+export declare const addOrUpdateOrRemoveUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id | undefined, value: number) => Id | undefined;
+export declare const getUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => number;

package/engine/internal/unit/bonus.lua

@@ -21,6 +21,7 @@ local AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID = ____auto_2Dattack_2Dda
 local ____movement_2Dspeed_2Dincrease_2Dfactor = require("engine.internal.object-data.movement-speed-increase-factor")
 local MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD
 local MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID
+local damageFactorByUnit = {}
 local receivedDamageFactorByUnit = {}
 ____exports.UnitBonusType = {}
 local UnitBonusType = ____exports.UnitBonusType
@@ -46,13 +47,14 @@ do
         reduce = sum,
         initialValue = 0
     }
-    UnitBonusType.DAMAGE = {
+    UnitBonusType.AUTO_ATTACK_DAMAGE = {
         abilityTypeId = AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID,
         field = AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD,
         integer = false,
         reduce = sum,
         initialValue = 0
     }
+    UnitBonusType.DAMAGE_FACTOR = {reduce = product, valueByUnit = damageFactorByUnit, initialValue = 1}
     UnitBonusType.RECEIVED_DAMAGE_FACTOR = {reduce = product, valueByUnit = receivedDamageFactorByUnit, initialValue = 1}
 end
 local bonusesByUnitByBonusType = {}
@@ -180,6 +182,9 @@ end
 Unit.onDamage:addListener(
     4,
     function(source, target, event)
+        if source ~= nil and damageFactorByUnit[source] ~= nil then
+            event.amount = event.amount * damageFactorByUnit[source]
+        end
         if receivedDamageFactorByUnit[target] ~= nil then
             event.amount = event.amount * receivedDamageFactorByUnit[target]
         end

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

@@ -0,0 +1,23 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+export interface UnitItems extends ReadonlyArray<Item | undefined> {
+    readonly length: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    [0]: Item | undefined;
+    [1]: Item | undefined;
+    [2]: Item | undefined;
+    [3]: Item | undefined;
+    [4]: Item | undefined;
+    [5]: Item | undefined;
+}
+export declare class UnitItems {
+    constructor(handle: junit);
+    protected __newindex(slot: number, item: Item | undefined): void;
+    protected __index(key: string | number): unknown;
+    protected __len(): number;
+    protected __ipairs(): LuaIterator<LuaMultiReturn<[number, Item | undefined]>, junit>;
+}
+declare module "../unit" {
+    interface Unit {
+        readonly items: UnitItems;
+    }
+}

package/engine/internal/unit/item.lua

@@ -0,0 +1,74 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local rawset = _G.rawset
+local ____type = _G.type
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local unitAddItem = UnitAddItem
+local unitDropItemSlot = UnitDropItemSlot
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local unitRemoveItemFromSlot = UnitRemoveItemFromSlot
+local handleByUnitItems = setmetatable({}, {__mode = "k"})
+local function unitItemsNext(handle, index)
+    local slot = index & 7
+    if index >> 3 == slot then
+        return nil, nil
+    end
+    return index + 1, Item:of(unitItemInSlot(handle, slot))
+end
+____exports.UnitItems = __TS__Class()
+local UnitItems = ____exports.UnitItems
+UnitItems.name = "UnitItems"
+function UnitItems.prototype.____constructor(self, handle)
+    handleByUnitItems[self] = handle
+end
+function UnitItems.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitItems[self]
+    if slot < 1 or slot > unitInventorySize(handle) then
+        return
+    end
+    unitRemoveItemFromSlot(handle, slot - 1)
+    if item ~= nil then
+        local itemHandle = item.handle
+        local isPowerup = isItemPowerup(itemHandle)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        end
+        unitAddItem(handle, itemHandle)
+        unitDropItemSlot(handle, itemHandle, slot - 1)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+end
+function UnitItems.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInSlot(handleByUnitItems[self], key - 1))
+    end
+    return rawget(____exports.UnitItems.prototype, key)
+end
+function UnitItems.prototype.__len(self)
+    return unitInventorySize(handleByUnitItems[self])
+end
+function UnitItems.prototype.__ipairs(self)
+    local handle = handleByUnitItems[self]
+    return unitItemsNext, handle, unitInventorySize(handle) << 3
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "items",
+    {get = function(self)
+        local items = __TS__New(____exports.UnitItems, self.handle)
+        rawset(self, "items", items)
+        return items
+    end}
+)
+return ____exports

package/engine/internal/unit+ability.lua

@@ -40,7 +40,7 @@ ItemAbility.onCreate:addListener(
         end
     end
 )
-Unit.onItemPickup:addListener(
+Unit.itemPickedUpEvent:addListener(
     0,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do
@@ -48,7 +48,7 @@ Unit.onItemPickup:addListener(
         end
     end
 )
-Unit.onItemDrop:addListener(
+Unit.itemDroppedEvent:addListener(
     4,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do

package/engine/internal/unit+transport.lua

@@ -6,9 +6,8 @@ local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
 local Event = ____event.Event
-local ____mapbounds = require("core.mapbounds")
-local boundMax = ____mapbounds.boundMax
-local boundRegion = ____mapbounds.boundRegion
+local ____game_2Dmap = require("engine.game-map")
+local GameMap = ____game_2Dmap.GameMap
 local eventInvoke = Event.invoke
 local tableRemove = table.remove
 local ____assert = _G.assert
@@ -58,8 +57,8 @@ triggerAddCondition(
             deboard(unit)
         end
         if not unitAlive(handle) then
-            unit.x = boundMax.x
-            unit.y = boundMax.y
+            unit.x = GameMap.worldBoundsRect.maxX
+            unit.y = GameMap.worldBoundsRect.maxY
         end
         local transport = Unit:of(getTransportUnit())
         transportByUnit[unit] = transport
@@ -68,11 +67,6 @@ triggerAddCondition(
         eventInvoke(onBoardEvent, unit, transport)
     end)
 )
-boundRegion.onUnitEnter:addListener(function(unit)
-    if transportByUnit[unit] ~= nil and not isUnitLoaded(unit.handle) then
-        deboard(unit)
-    end
-end)
 Unit.deathEvent:addListener(function(unit)
     if transportByUnit[unit] ~= nil then
         deboard(unit)

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

@@ -7,14 +7,33 @@ local ____event = require("event")
 local Event = ____event.Event
 local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
+local ____lua_2Dsets = require("utility.lua-sets")
+local luaSetOf = ____lua_2Dsets.luaSetOf
 local autoAttackFinishEvent = __TS__New(Event)
 rawset(Unit, "autoAttackFinishEvent", autoAttackFinishEvent)
 local eventTimerByUnit = {}
-local function reset(source)
-    local eventTimer = eventTimerByUnit[source]
-    if eventTimer then
-        eventTimer:destroy()
-        eventTimerByUnit[source] = nil
+local instantOrderIds = luaSetOf(
+    orderId("avatar"),
+    orderId("berserk"),
+    orderId("divineshield"),
+    orderId("immolation"),
+    orderId("moveslot0"),
+    orderId("moveslot1"),
+    orderId("moveslot2"),
+    orderId("moveslot3"),
+    orderId("moveslot4"),
+    orderId("moveslot5"),
+    orderId("unavatar"),
+    orderId("undivineshield"),
+    orderId("unimmolation")
+)
+local function reset(source, orderId)
+    if not (instantOrderIds[orderId] ~= nil) then
+        local eventTimer = eventTimerByUnit[source]
+        if eventTimer then
+            eventTimer:destroy()
+            eventTimerByUnit[source] = nil
+        end
     end
 end
 Unit.onImmediateOrder:addListener(reset)
@@ -25,7 +44,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

@@ -1,4 +1,3 @@
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 import { Handle, HandleDestructor } from "../../core/types/handle";
 import { Player } from "../../core/types/player";
@@ -43,6 +42,7 @@ export interface DamagingEvent {
     damageType: jdamagetype;
     weaponType: jweapontype;
     readonly isAttack: boolean;
+    readonly originalAmount: number;
 }
 export type DamageEvent = DamagingEvent & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
@@ -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;
@@ -201,7 +228,7 @@ export declare class Unit extends Handle<junit> {
     isSelected(player: Player): boolean;
     explode(): void;
     kill(): void;
-    revive(pos: Vec2, doEffect: boolean): void;
+    revive(x: number, y: number, doEffect?: boolean): void;
     healTarget(target: Widget, amount: number): void;
     useItem(item: Item): boolean;
     issueImmediateOrder(order: number): boolean;
@@ -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;
@@ -260,7 +288,7 @@ export declare class Unit extends Handle<junit> {
     static getInRange(x: number, y: number, range: number, predicate?: (unit: Unit) => boolean): Unit[];
     static getInCollisionRange(x: number, y: number, range: number, predicate?: (unit: Unit) => boolean): Unit[];
     static getInSector(pos: Vec2, range: number, offsetAngle: number, centralAngle: number): Unit[];
-    static getSelectionOf(player: Player): Unit[];
+    static getSelectionOf(player: Player, target?: Unit[]): Unit[];
     static readonly deathEvent: UnitTriggerEvent<[Unit]>;
     static readonly onDecay: UnitTriggerEvent<[]>;
     static readonly onResurrect: InitializingEvent<[Unit], void>;
@@ -295,9 +323,10 @@ export declare class Unit extends Handle<junit> {
     static readonly autoAttackStartEvent: UnitTriggerEvent<[Unit]>;
     static readonly onDamaging: Event<[source: Unit | undefined, target: Unit, event: DamagingEvent]>;
     static readonly onDamage: InitializingEvent<[source: Unit | undefined, target: Unit, event: DamageEvent], jtrigger>;
-    static onItemDrop: UnitTriggerEvent<[Item]>;
-    static onItemPickup: UnitTriggerEvent<[Item]>;
-    static onItemUse: UnitTriggerEvent<[Item]>;
+    static itemDroppedEvent: UnitTriggerEvent<[Item]>;
+    static itemPickedUpEvent: UnitTriggerEvent<[Item]>;
+    static itemUsedEvent: UnitTriggerEvent<[Item]>;
+    static itemStackedEvent: UnitTriggerEvent<[Item]>;
     static get onCreate(): EventDispatcher<[Unit], [Unit]>;
     static get destroyEvent(): EventDispatcher<[Unit], [Unit]>;
     getField(field: junitintegerfield | junitrealfield): number;