warscript 0.0.1-dev.83ffb73 → 0.0.1-dev.8466737

package/engine/index.d.ts

@@ -1,5 +1,6 @@
 /** @noSelfInFile */
 export declare const enum GraphicsMode {
     SD = 0,
-    HD = 1
+    HD = 1,
+    DE = 2
 }

package/engine/internal/ability.d.ts

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import { Handle } from "../../core/types/handle";
+import { Handle, HandleDestructor } from "../../core/types/handle";
 import { Event } from "../../event";
 import type { Item } from "../../core/types/item";
 import type { Unit } from "./unit";
@@ -37,6 +37,7 @@ export declare abstract class Ability extends Handle<jability> {
     abstract get level(): number;
     abstract get cooldownRemaining(): number;
     abstract set cooldownRemaining(cooldownRemaining: number);
+    abstract startCooldown(cooldown: number): void;
     abstract interruptCast(): void;
     static get onCreate(): Event<[Ability]>;
     static get destroyEvent(): Event<[Ability]>;
@@ -50,6 +51,7 @@ export declare class UnrecognizedAbility extends Ability {
     get level(): number;
     get cooldownRemaining(): number;
     set cooldownRemaining(_: number);
+    startCooldown(_: number): void;
     interruptCast(): void;
 }
 export declare class UnitAbility extends Ability {
@@ -64,9 +66,14 @@ export declare class UnitAbility extends Ability {
     get isDisabled(): boolean;
     get level(): number;
     set level(v: number);
+    /** Uses the native percentage scale. */
+    get cooldownRemainingPercent(): number;
+    set cooldownRemainingPercent(percent: number);
     get cooldownRemaining(): number;
     set cooldownRemaining(cooldownRemaining: number);
+    startCooldown(cooldown: number): void;
     interruptCast(): void;
+    protected onDestroy(): HandleDestructor;
     static get onCreate(): Event<[UnitAbility]>;
     static get onDestroy(): Event<[UnitAbility]>;
 }
@@ -92,7 +99,9 @@ export declare class ItemAbility extends Ability {
     get level(): number;
     get cooldownRemaining(): number;
     set cooldownRemaining(cooldownRemaining: number);
+    startCooldown(cooldown: number): void;
     interruptCast(): void;
+    protected onDestroy(): HandleDestructor;
     static get onCreate(): Event<[ItemAbility]>;
     static get onDestroy(): Event<[ItemAbility]>;
 }

package/engine/internal/ability.lua

@@ -14,31 +14,34 @@ local abilityActionDummy = ____ability.abilityActionDummy
 local doAbilityAction = ____ability.doAbilityAction
 local doAbilityActionForceDummy = ____ability.doAbilityActionForceDummy
 local startItemCooldown = ____ability.startItemCooldown
-local getUnitAbilityLevel = GetUnitAbilityLevel
-local setUnitAbilityLevel = SetUnitAbilityLevel
-local setAbilityIntegerField = BlzSetAbilityIntegerField
-local setAbilityRealField = BlzSetAbilityRealField
-local setAbilityBooleanField = BlzSetAbilityBooleanField
-local setAbilityStringField = BlzSetAbilityStringField
-local setAbilityIntegerLevelField = BlzSetAbilityIntegerLevelField
-local setAbilityRealLevelField = BlzSetAbilityRealLevelField
-local setAbilityBooleanLevelField = BlzSetAbilityBooleanLevelField
-local setAbilityStringLevelField = BlzSetAbilityStringLevelField
-local getAbilityIntegerField = BlzGetAbilityIntegerField
-local getAbilityRealField = BlzGetAbilityRealField
+local ____unit_2Dability_2Dlevel_2Dnatives = require("engine.internal.misc.unit-ability-level-natives")
+local rawSetUnitAbilityLevel = ____unit_2Dability_2Dlevel_2Dnatives.rawSetUnitAbilityLevel
 local getAbilityBooleanField = BlzGetAbilityBooleanField
-local getAbilityStringField = BlzGetAbilityStringField
+local getAbilityBooleanLevelField = BlzGetAbilityBooleanLevelField
+local getAbilityIntegerField = BlzGetAbilityIntegerField
 local getAbilityIntegerLevelField = BlzGetAbilityIntegerLevelField
+local getAbilityRealField = BlzGetAbilityRealField
 local getAbilityRealLevelField = BlzGetAbilityRealLevelField
-local getAbilityBooleanLevelField = BlzGetAbilityBooleanLevelField
+local getAbilityStringField = BlzGetAbilityStringField
 local getAbilityStringLevelField = BlzGetAbilityStringLevelField
+local getHandleId = GetHandleId
+local getUnitAbilityCooldownPercent = BlzGetUnitAbilityCooldownPercent
 local getUnitAbilityCooldownRemaining = BlzGetUnitAbilityCooldownRemaining
+local getUnitAbilityLevel = GetUnitAbilityLevel
+local order2orderId = _G.OrderId
+local setAbilityBooleanField = BlzSetAbilityBooleanField
+local setAbilityBooleanLevelField = BlzSetAbilityBooleanLevelField
+local setAbilityIntegerField = BlzSetAbilityIntegerField
+local setAbilityIntegerLevelField = BlzSetAbilityIntegerLevelField
+local setAbilityRealField = BlzSetAbilityRealField
+local setAbilityRealLevelField = BlzSetAbilityRealLevelField
+local setAbilityStringField = BlzSetAbilityStringField
+local setAbilityStringLevelField = BlzSetAbilityStringLevelField
+local setUnitAbilityCooldownPercent = BlzSetUnitAbilityCooldownPercent
+local setUnitAbilityCooldownRemaining = BlzSetUnitAbilityCooldownRemaining
 local startUnitAbilityCooldown = BlzStartUnitAbilityCooldown
-local getHandleId = GetHandleId
-local getItemBooleanField = BlzGetItemBooleanField
-local setItemBooleanField = BlzSetItemBooleanField
-local unitHideAbility = BlzUnitHideAbility
 local unitDisableAbility = BlzUnitDisableAbility
+local unitHideAbility = BlzUnitHideAbility
 local match = string.match
 local ____type = _G.type
 local ____tostring = _G.tostring
@@ -215,7 +218,6 @@ local levelRefreshFields = {
     [fourCC("Neg1")] = true
 }
 local levelsField = ABILITY_IF_LEVELS
-local order2orderId = _G.OrderId
 local orderIdFieldByParentTypeId = {
     [fourCC("ANcl")] = ABILITY_SLF_BASE_ORDER_ID_NCL6,
     [fourCC("Aspb")] = ABILITY_SLF_BASE_ORDER_ID_SPB5,
@@ -232,6 +234,19 @@ ____exports.getOrderIdByAbilityTypeId = function(abilityTypeId)
     local parentTypeId = availableFields[abilityTypeId]
     return order2orderId(orders[____type(parentTypeId) == "number" and parentTypeId or abilityTypeId] or "")
 end
+---
+-- @internal For use by internal systems only.
+____exports.abilityTypeHasField = function(abilityTypeId, field)
+    field = ____type(field) == "number" and field or getHandleId(field)
+    if commonFields[field] then
+        return true
+    end
+    local id = availableFields[abilityTypeId]
+    if ____type(id) == "number" then
+        id = availableFields[id]
+    end
+    return not not (id and id[field])
+end
 ____exports.Ability = __TS__Class()
 local Ability = ____exports.Ability
 Ability.name = "Ability"
@@ -247,15 +262,7 @@ function Ability.prototype.getSnapshot(self)
     return nil
 end
 function Ability.prototype.hasField(self, field)
-    field = ____type(field) == "number" and field or getHandleId(field)
-    if commonFields[field] then
-        return true
-    end
-    local id = availableFields[self.typeId]
-    if ____type(id) == "number" then
-        id = availableFields[id]
-    end
-    return not not (id and id[field])
+    return ____exports.abilityTypeHasField(self.typeId, field)
 end
 function Ability.prototype.getField(self, field, level)
     local fieldType = match(
@@ -283,8 +290,8 @@ function Ability.prototype.setField(self, field, levelOrValue, value)
         local levels = getAbilityIntegerField(ability, levelsField)
         setAbilityIntegerField(ability, levelsField, levels + 1)
         local level = getUnitAbilityLevel(unit, typeId)
-        setUnitAbilityLevel(unit, typeId, levels + 1)
-        setUnitAbilityLevel(unit, typeId, level)
+        rawSetUnitAbilityLevel(unit, typeId, levels + 1)
+        rawSetUnitAbilityLevel(unit, typeId, level)
         setAbilityIntegerField(ability, levelsField, levels)
     end
     return success
@@ -366,6 +373,8 @@ function UnrecognizedAbility.prototype.____constructor(self, typeId, owner)
     UnrecognizedAbility.____super.prototype.____constructor(self, nil, typeId)
     self.owner = owner
 end
+function UnrecognizedAbility.prototype.startCooldown(self, _)
+end
 function UnrecognizedAbility.prototype.interruptCast(self)
 end
 __TS__SetDescriptor(
@@ -417,9 +426,18 @@ function UnitAbility.prototype.decrementDisableCounter(self)
     unitHideAbility(unit, typeId, true)
     self.d = (self.d or 0) - 1
 end
+function UnitAbility.prototype.startCooldown(self, cooldown)
+    startUnitAbilityCooldown(self.u, self.typeId, cooldown)
+end
 function UnitAbility.prototype.interruptCast(self)
     self.owner:interruptCast(self.typeId)
 end
+function UnitAbility.prototype.onDestroy(self)
+    if self.owner.state ~= 2 then
+        self.owner:removeAbility(self.typeId)
+    end
+    return UnitAbility.____super.prototype.onDestroy(self)
+end
 __TS__SetDescriptor(
     UnitAbility.prototype,
     "isDisabled",
@@ -436,7 +454,20 @@ __TS__SetDescriptor(
             return getUnitAbilityLevel(self.u, self.typeId) - 1
         end,
         set = function(self, v)
-            setUnitAbilityLevel(self.u, self.typeId, v + 1)
+            SetUnitAbilityLevel(self.u, self.typeId, v + 1)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitAbility.prototype,
+    "cooldownRemainingPercent",
+    {
+        get = function(self)
+            return getUnitAbilityCooldownPercent(self.u, self.typeId)
+        end,
+        set = function(self, percent)
+            setUnitAbilityCooldownPercent(self.u, self.typeId, percent)
         end
     },
     true
@@ -449,7 +480,7 @@ __TS__SetDescriptor(
             return getUnitAbilityCooldownRemaining(self.u, self.typeId)
         end,
         set = function(self, cooldownRemaining)
-            startUnitAbilityCooldown(self.u, self.typeId, cooldownRemaining)
+            setUnitAbilityCooldownRemaining(self.u, self.typeId, cooldownRemaining)
         end
     },
     true
@@ -504,13 +535,28 @@ function ItemAbility.prototype.setField(self, field, levelOrValue, value)
         value
     )
 end
+function ItemAbility.prototype.startCooldown(self, cooldown)
+    local item = self.owner
+    local ____startItemCooldown_4 = startItemCooldown
+    local ____item_handle_3 = item.handle
+    local ____opt_1 = item.owner
+    ____startItemCooldown_4(____item_handle_3, ____opt_1 and ____opt_1.handle, cooldown)
+end
 function ItemAbility.prototype.interruptCast(self)
-    local handle = self.owner.handle
-    local activelyUsed = getItemBooleanField(handle, ITEM_BF_ACTIVELY_USED)
-    if activelyUsed then
-        setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, false)
-        setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, true)
+    local item = self.owner
+    local itemHandle = item.handle
+    local ____opt_5 = item.owner
+    local itemOwnerHandle = ____opt_5 and ____opt_5.handle
+    local cooldownRemaining = doAbilityActionForceDummy(itemHandle, itemOwnerHandle, getAbilityCooldown, self.typeId)
+    if cooldownRemaining == 0 then
+        startItemCooldown(itemHandle, itemOwnerHandle, 0.015625)
+    end
+end
+function ItemAbility.prototype.onDestroy(self)
+    if self.owner.state ~= 2 then
+        self.owner:removeAbility(self.typeId)
     end
+    return ItemAbility.____super.prototype.onDestroy(self)
 end
 __TS__SetDescriptor(
     ItemAbility.prototype,
@@ -526,17 +572,17 @@ __TS__SetDescriptor(
     {
         get = function(self)
             local item = self.owner
-            local ____doAbilityActionForceDummy_4 = doAbilityActionForceDummy
-            local ____item_handle_3 = item.handle
-            local ____opt_1 = item.owner
-            return ____doAbilityActionForceDummy_4(____item_handle_3, ____opt_1 and ____opt_1.handle, getAbilityCooldown, self.typeId)
+            local ____doAbilityActionForceDummy_10 = doAbilityActionForceDummy
+            local ____item_handle_9 = item.handle
+            local ____opt_7 = item.owner
+            return ____doAbilityActionForceDummy_10(____item_handle_9, ____opt_7 and ____opt_7.handle, getAbilityCooldown, self.typeId)
         end,
         set = function(self, cooldownRemaining)
             local item = self.owner
-            local ____startItemCooldown_8 = startItemCooldown
-            local ____item_handle_7 = item.handle
-            local ____opt_5 = item.owner
-            ____startItemCooldown_8(____item_handle_7, ____opt_5 and ____opt_5.handle, cooldownRemaining)
+            local ____startItemCooldown_14 = startItemCooldown
+            local ____item_handle_13 = item.handle
+            local ____opt_11 = item.owner
+            ____startItemCooldown_14(____item_handle_13, ____opt_11 and ____opt_11.handle, cooldownRemaining)
         end
     },
     true

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

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+declare module "../item" {
+    interface Item {
+        canBeSold: boolean;
+    }
+}
+declare module "../item" {
+    interface Item {
+        isActivelyUsed: boolean;
+    }
+}
+export {};

package/engine/internal/item/fields.lua

@@ -0,0 +1,33 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____item = require("engine.standard.fields.item")
+local CAN_BE_SOLD_TO_MERCHANTS_ITEM_FIELD = ____item.CAN_BE_SOLD_TO_MERCHANTS_ITEM_FIELD
+local IS_ACTIVELY_USED_ITEM_FIELD = ____item.IS_ACTIVELY_USED_ITEM_FIELD
+__TS__ObjectDefineProperty(
+    Item.prototype,
+    "canBeSold",
+    {
+        get = function(self)
+            return CAN_BE_SOLD_TO_MERCHANTS_ITEM_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            CAN_BE_SOLD_TO_MERCHANTS_ITEM_FIELD:setValue(self, value)
+        end
+    }
+)
+__TS__ObjectDefineProperty(
+    Item.prototype,
+    "isActivelyUsed",
+    {
+        get = function(self)
+            return IS_ACTIVELY_USED_ITEM_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            IS_ACTIVELY_USED_ITEM_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports

package/engine/internal/item/owner-cache.d.ts

@@ -0,0 +1,5 @@
+/** @noSelfInFile */
+import type { Item } from "../item";
+import type { Unit } from "../unit";
+/** The last unit known (from item events) to carry each item; validated against the engine on read. */
+export declare const ownerByItem: LuaMap<Item, Unit>;

package/engine/internal/item/owner-cache.lua

@@ -0,0 +1,4 @@
+local ____exports = {}
+--- The last unit known (from item events) to carry each item; validated against the engine on read.
+____exports.ownerByItem = setmetatable({}, {__mode = "kv"})
+return ____exports

package/engine/internal/item+owner.d.ts

@@ -1,7 +1,9 @@
 /** @noSelfInFile */
 import { Unit } from "./unit";
+import "./unit/equipment-inventory";
 declare module "./item" {
     interface Item {
+        /** The unit carrying the item in any of its inventories (regular, extended or equipment), if any. */
         readonly owner?: Unit;
     }
 }

package/engine/internal/item+owner.lua

@@ -5,18 +5,47 @@ local ____item = require("engine.internal.item")
 local Item = ____item.Item
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
-local ownerByItem = setmetatable({}, {__mode = "kv"})
-Unit.itemPickedUpEvent:addListener(function(unit, item)
-    ownerByItem[item] = unit
-end)
-Unit.itemDroppedEvent:addListener(function(unit, item)
-    ownerByItem[item] = nil
-end)
+require("engine.internal.unit.equipment-inventory")
+local ____owner_2Dcache = require("engine.internal.item.owner-cache")
+local ownerByItem = ____owner_2Dcache.ownerByItem
+local ____item_2Dcontainer = require("engine.internal.unit.item-container")
+local unitOwnsItem = ____item_2Dcontainer.unitOwnsItem
+Unit.itemPickedUpEvent:addListener(
+    999999,
+    function(unit, item)
+        ownerByItem[item] = unit
+    end
+)
+Unit.itemEquippedEvent:addListener(
+    999999,
+    function(unit, item)
+        ownerByItem[item] = unit
+    end
+)
+Unit.itemUnequippedEvent:addListener(
+    999999,
+    function(unit, item)
+        if not unitOwnsItem(unit.handle, item.handle) then
+            ownerByItem[item] = nil
+        end
+    end
+)
+Unit.itemDroppedEvent:addListener(
+    999999,
+    function(unit, item)
+        ownerByItem[item] = nil
+    end
+)
 __TS__ObjectDefineProperty(
     Item.prototype,
     "owner",
     {get = function(self)
-        return ownerByItem[self]
+        local owner = ownerByItem[self]
+        if owner ~= nil and not unitOwnsItem(owner.handle, self.handle) then
+            ownerByItem[self] = nil
+            return nil
+        end
+        return owner
     end}
 )
 return ____exports

package/engine/internal/item.d.ts

@@ -2,6 +2,9 @@
 import { Handle, HandleDestructor } from "../../core/types/handle";
 import { Color } from "../../core/types/color";
 import { Event } from "../../event";
+import { PlayerColor } from "../../core/types/playerColor";
+import { EquipmentType } from "../object-data/auxiliary/equipment-type";
+import { ItemTag } from "../object-data/auxiliary/item-tag";
 import { ReadonlyRect } from "../../core/types/rect";
 import { ItemAbility } from "./ability";
 import { AbilityTypeId } from "../object-data/entry/ability-type";
@@ -9,14 +12,27 @@ import type { ItemTypeId } from "../object-data/entry/item-type";
 type DefenseType = 0 | 1 | 2 | 3 | 4 | 5;
 declare const enum ItemPropertyKey {
     ABILITIES = 100,
-    LUA_INDEX_BY_ABILITY_TYPE_ID = 101
+    DEATH_TRIGGER = 101,
+    COLOR = 102
 }
 export declare class Item extends Handle<jitem> {
     private readonly [ItemPropertyKey.ABILITIES];
-    private readonly [ItemPropertyKey.LUA_INDEX_BY_ABILITY_TYPE_ID];
+    private readonly [ItemPropertyKey.DEATH_TRIGGER];
+    private [ItemPropertyKey.COLOR]?;
     constructor(handle: jitem);
     protected onDestroy(): HandleDestructor;
     static create<T extends Item>(this: typeof Item & (new (handle: jitem) => T), id: number, x: number, y: number, skinId?: number): T;
+    /** Whether the item is owned by a unit, i.e. carried in any of its inventories (regular, extended or equipment). */
+    get isOwned(): boolean;
+    /** Whether the item is carried in a unit's (regular) inventory, as opposed to its extended or equipment inventory. */
+    get isInInventory(): boolean;
+    get isInExtendedInventory(): boolean;
+    get isInEquipmentInventory(): boolean;
+    get equipmentType(): EquipmentType;
+    get tag(): ItemTag;
+    get color(): PlayerColor;
+    set color(color: PlayerColor);
+    static getRandomTypeId(level: number, equipmentType?: EquipmentType | undefined, tag?: ItemTag, itemType?: jitemtype): ItemTypeId | undefined;
     get typeId(): ItemTypeId;
     set skinId(v: number);
     get skinId(): number;
@@ -30,22 +46,18 @@ 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 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 visible(v: boolean);
     get visible(): boolean;
     set level(v: number);
@@ -84,6 +96,7 @@ export declare class Item extends Handle<jitem> {
     static getInRect(rect: ReadonlyRect): Item[];
     static get onCreate(): Event<[Item]>;
     static get destroyEvent(): Event<[Item]>;
+    static readonly deathEvent: Event<[Item]>;
     static readonly chargesChangedEvent: Event<[Item]>;
 }
 export {};