warscript 0.0.1-dev.404878c

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

@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+import { Unit } from "./unit";
+declare module "./item" {
+    interface Item {
+        readonly owner?: Unit;
+    }
+}

package/engine/internal/item+owner.lua

@@ -0,0 +1,22 @@
+local ____lualib = require("lualib_bundle")
+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 ownerByItem = setmetatable({}, {__mode = "kv"})
+Unit.onItemPickup:addListener(function(unit, item)
+    ownerByItem[item] = unit
+end)
+Unit.onItemDrop:addListener(function(unit, item)
+    ownerByItem[item] = nil
+end)
+__TS__ObjectDefineProperty(
+    Item.prototype,
+    "owner",
+    {get = function(self)
+        return ownerByItem[self]
+    end}
+)
+return ____exports

package/engine/internal/item.d.ts

@@ -0,0 +1,86 @@
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "../../core/types/handle";
+import { Color } from "../../core/types/color";
+import { Event } from "../../event";
+import { ReadonlyRect } from "../../core/types/rect";
+import { ItemAbility } from "./ability";
+import { AbilityTypeId } from "../object-data/entry/ability-type";
+type DefenseType = 0 | 1 | 2 | 3 | 4 | 5;
+export declare const addAndGetAbility: (handle: jitem, abilityTypeId: AbilityTypeId) => jability | null;
+declare const enum ItemPropertyKey {
+    ABILITIES = 100,
+    LUA_INDEX_BY_ABILITY_TYPE_ID = 101
+}
+export declare class Item extends Handle<jitem> {
+    private readonly [ItemPropertyKey.ABILITIES];
+    private readonly [ItemPropertyKey.LUA_INDEX_BY_ABILITY_TYPE_ID];
+    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;
+    get typeId(): number;
+    set skinId(v: number);
+    get skinId(): number;
+    set name(v: string);
+    get name(): string;
+    set description(v: string);
+    get description(): string;
+    set tooltip(v: string);
+    get tooltip(): string;
+    set extendedTooltip(v: string);
+    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;
+    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);
+    get level(): number;
+    set priority(v: number);
+    get priority(): number;
+    set health(v: number);
+    get health(): number;
+    set maxHealth(v: number);
+    get maxHealth(): number;
+    set defenseType(v: DefenseType);
+    get defenseType(): DefenseType;
+    set cooldownId(v: number);
+    get cooldownId(): number;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    set scale(v: number);
+    get scale(): number;
+    set vertexColor(v: Color);
+    get vertexColor(): Color;
+    get model(): string;
+    get position(): Vec2;
+    set position(v: Vec2);
+    set charges(v: number);
+    get charges(): number;
+    addAbility(abilityTypeId: AbilityTypeId): ItemAbility | undefined;
+    removeAbility(abilityTypeId: AbilityTypeId): boolean;
+    hasAbility(abilityTypeId: AbilityTypeId): boolean;
+    getAbility(abilityTypeId: AbilityTypeId): ItemAbility | undefined;
+    get abilities(): readonly ItemAbility[];
+    static getInRange(pos: Vec2, range: number): Item[];
+    static getInRect(rect: ReadonlyRect): Item[];
+    static get onCreate(): Event<[Item]>;
+    static get onDestroy(): Event<[Item]>;
+}
+export {};

package/engine/internal/item.lua

@@ -0,0 +1,580 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local __TS__Delete = ____lualib.__TS__Delete
+local ____exports = {}
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____color = require("core.types.color")
+local Color = ____color.Color
+local ____rect = require("core.types.rect")
+local Rect = ____rect.Rect
+local ____ability = require("engine.internal.ability")
+local ItemAbility = ____ability.ItemAbility
+local ____ability = require("engine.internal.item.ability")
+local doAbilityAction = ____ability.doAbilityAction
+local itemAddAbility = BlzItemAddAbility
+local itemRemoveAbility = BlzItemRemoveAbility
+local getItemAbility = BlzGetItemAbility
+local isItemPowerup = IsItemPowerup
+local getItemAbilityByIndex = BlzGetItemAbilityByIndex
+local getAbilityId = BlzGetAbilityId
+local getWidgetLife = GetWidgetLife
+local removeItem = RemoveItem
+local getHandleId = GetHandleId
+local getItemIntegerField = BlzGetItemIntegerField
+local setItemBooleanField = BlzSetItemBooleanField
+local getItemBooleanField = BlzGetItemBooleanField
+local enumRect = Rect:create(0, 0, 0, 0).handle
+____exports.addAndGetAbility = function(handle, abilityTypeId)
+    if itemAddAbility(handle, abilityTypeId) then
+        return getItemAbility(handle, abilityTypeId)
+    end
+    return nil
+end
+local function getItemAbilities(handle, item)
+    local abilities = {}
+    do
+        local i = 0
+        local ability = getItemAbilityByIndex(handle, i)
+        while ability ~= nil do
+            abilities[i + 1] = ItemAbility:of(
+                ability,
+                getAbilityId(ability),
+                item
+            )
+            do
+                i = i + 1
+                ability = getItemAbilityByIndex(handle, i)
+            end
+        end
+    end
+    return abilities
+end
+____exports.Item = __TS__Class()
+local Item = ____exports.Item
+Item.name = "Item"
+__TS__ClassExtends(Item, Handle)
+function Item.prototype.____constructor(self, handle)
+    Handle.prototype.____constructor(self, handle)
+    local abilities = doAbilityAction(handle, getItemAbilities, self)
+    self[100] = abilities
+    local luaIndexByAbilityTypeId = {}
+    for i = 1, #abilities do
+        luaIndexByAbilityTypeId[abilities[i].typeId] = i
+    end
+    self[101] = luaIndexByAbilityTypeId
+end
+function Item.prototype.onDestroy(self)
+    local abilities = self[100]
+    for i = 1, #abilities do
+        abilities[i]:destroy()
+    end
+    removeItem(self.handle)
+    return Handle.prototype.onDestroy(self)
+end
+function Item.create(self, id, x, y, skinId)
+    return self:of(BlzCreateItemWithSkin(id, x, y, skinId or id))
+end
+function Item.prototype.addAbility(self, abilityTypeId)
+    local nativeAbility = doAbilityAction(self.handle, ____exports.addAndGetAbility, abilityTypeId)
+    if nativeAbility ~= nil then
+        local ability = ItemAbility:of(nativeAbility, abilityTypeId, self)
+        local abilities = self[100]
+        local luaIndex = #abilities + 1
+        abilities[luaIndex] = ability
+        self[101][abilityTypeId] = luaIndex
+        return ability
+    end
+    return nil
+end
+function Item.prototype.removeAbility(self, abilityTypeId)
+    local luaIndexByAbilityTypeId = self[101]
+    local luaIndex = luaIndexByAbilityTypeId[abilityTypeId]
+    if luaIndex ~= nil and doAbilityAction(self.handle, itemRemoveAbility, abilityTypeId) then
+        luaIndexByAbilityTypeId[abilityTypeId] = nil
+        local abilities = self[100]
+        abilities[luaIndex]:destroy()
+        local abilityTypeIdsLength = #abilities
+        for j = luaIndex, abilityTypeIdsLength do
+            abilities[j] = abilities[j + 1]
+        end
+    end
+    return false
+end
+function Item.prototype.hasAbility(self, abilityTypeId)
+    return self[101][abilityTypeId] ~= nil
+end
+function Item.prototype.getAbility(self, abilityTypeId)
+    local ability = self[101][abilityTypeId] ~= nil and doAbilityAction(self.handle, getItemAbility, abilityTypeId)
+    return ability and ItemAbility:of(ability, abilityTypeId, self) or nil
+end
+function Item.getInRange(self, pos, range)
+    local collection = {}
+    SetRect(
+        enumRect,
+        pos.x - range,
+        pos.y - range,
+        pos.x + range,
+        pos.y + range
+    )
+    EnumItemsInRect(
+        enumRect,
+        nil,
+        function()
+            collection[#collection + 1] = self:of(GetEnumItem())
+        end
+    )
+    return collection
+end
+function Item.getInRect(self, rect)
+    local collection = {}
+    EnumItemsInRect(
+        rect.handle,
+        nil,
+        function()
+            collection[#collection + 1] = self:of(GetEnumItem())
+        end
+    )
+    return collection
+end
+__TS__SetDescriptor(
+    Item.prototype,
+    "typeId",
+    {get = function(self)
+        return GetItemTypeId(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "skinId",
+    {
+        get = function(self)
+            return BlzGetItemSkin(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemSkin(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "name",
+    {
+        get = function(self)
+            return GetItemName(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemName(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "description",
+    {
+        get = function(self)
+            return BlzGetItemDescription(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemDescription(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "tooltip",
+    {
+        get = function(self)
+            return BlzGetItemTooltip(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemTooltip(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "extendedTooltip",
+    {
+        get = function(self)
+            return BlzGetItemExtendedTooltip(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemExtendedTooltip(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "iconPath",
+    {
+        get = function(self)
+            return BlzGetItemIconPath(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemIconPath(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "dropOnDeath",
+    {
+        get = function(self)
+            return BlzGetItemBooleanField(self.handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
+        end,
+        set = function(self, v)
+            SetItemDropOnDeath(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "droppable",
+    {
+        get = function(self)
+            return BlzGetItemBooleanField(self.handle, ITEM_BF_CAN_BE_DROPPED)
+        end,
+        set = function(self, v)
+            SetItemDroppable(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "pawnable",
+    {
+        get = function(self)
+            return IsItemPawnable(self.handle)
+        end,
+        set = function(self, v)
+            SetItemPawnable(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "perishable",
+    {
+        get = function(self)
+            return BlzGetItemBooleanField(self.handle, ITEM_BF_PERISHABLE)
+        end,
+        set = function(self, v)
+            BlzSetItemBooleanField(self.handle, ITEM_BF_PERISHABLE, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "powerup",
+    {
+        get = function(self)
+            return isItemPowerup(self.handle)
+        end,
+        set = function(self, v)
+            setItemBooleanField(self.handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "isAlive",
+    {get = function(self)
+        return getWidgetLife(self.handle) > 0
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "isDead",
+    {get = function(self)
+        return getWidgetLife(self.handle) <= 0
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "isInvulnerable",
+    {
+        get = function(self)
+            return IsItemInvulnerable(self.handle)
+        end,
+        set = function(self, isInvulnerable)
+            SetItemInvulnerable(self.handle, isInvulnerable)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "usable",
+    {
+        get = function(self)
+            return getItemBooleanField(self.handle, ITEM_BF_ACTIVELY_USED)
+        end,
+        set = function(self, v)
+            local handle = self.handle
+            local powerup = isItemPowerup(handle)
+            setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, v)
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerup)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "visible",
+    {
+        get = function(self)
+            return IsItemVisible(self.handle)
+        end,
+        set = function(self, v)
+            SetItemVisible(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "level",
+    {
+        get = function(self)
+            return GetItemLevel(self.handle)
+        end,
+        set = function(self, v)
+            BlzSetItemIntegerField(self.handle, ITEM_IF_LEVEL, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "priority",
+    {
+        get = function(self)
+            return BlzGetItemIntegerField(self.handle, ITEM_IF_PRIORITY)
+        end,
+        set = function(self, v)
+            BlzSetItemIntegerField(self.handle, ITEM_IF_PRIORITY, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "health",
+    {
+        get = function(self)
+            return GetWidgetLife(self.handle)
+        end,
+        set = function(self, v)
+            SetWidgetLife(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "maxHealth",
+    {
+        get = function(self)
+            return BlzGetItemIntegerField(self.handle, ITEM_IF_MAX_HIT_POINTS)
+        end,
+        set = function(self, v)
+            BlzSetItemIntegerField(self.handle, ITEM_IF_MAX_HIT_POINTS, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "defenseType",
+    {
+        get = function(self)
+            return BlzGetItemIntegerField(self.handle, ITEM_IF_ARMOR_TYPE)
+        end,
+        set = function(self, v)
+            BlzSetItemIntegerField(self.handle, ITEM_IF_ARMOR_TYPE, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "cooldownId",
+    {
+        get = function(self)
+            return BlzGetItemIntegerField(self.handle, ITEM_IF_COOLDOWN_GROUP)
+        end,
+        set = function(self, v)
+            BlzSetItemIntegerField(self.handle, ITEM_IF_COOLDOWN_GROUP, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "x",
+    {
+        get = function(self)
+            return GetItemX(self.handle)
+        end,
+        set = function(self, v)
+            SetItemPosition(
+                self.handle,
+                v,
+                GetItemY(self.handle)
+            )
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "y",
+    {
+        get = function(self)
+            return GetItemY(self.handle)
+        end,
+        set = function(self, v)
+            SetItemPosition(
+                self.handle,
+                GetItemX(self.handle),
+                v
+            )
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "scale",
+    {
+        get = function(self)
+            return BlzGetItemRealField(self.handle, ITEM_RF_SCALING_VALUE)
+        end,
+        set = function(self, v)
+            BlzSetItemRealField(self.handle, ITEM_RF_SCALING_VALUE, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "vertexColor",
+    {
+        get = function(self)
+            local handle = self.handle
+            return Color:of(
+                getItemIntegerField(handle, ITEM_IF_TINTING_COLOR_RED),
+                getItemIntegerField(handle, ITEM_IF_TINTING_COLOR_GREEN),
+                getItemIntegerField(handle, ITEM_IF_TINTING_COLOR_BLUE),
+                getItemIntegerField(handle, ITEM_IF_TINTING_COLOR_ALPHA)
+            )
+        end,
+        set = function(self, v)
+            local handle = self.handle
+            BlzSetItemIntegerField(handle, ITEM_IF_TINTING_COLOR_RED, v.r)
+            BlzSetItemIntegerField(handle, ITEM_IF_TINTING_COLOR_GREEN, v.g)
+            BlzSetItemIntegerField(handle, ITEM_IF_TINTING_COLOR_BLUE, v.b)
+            BlzSetItemIntegerField(handle, ITEM_IF_TINTING_COLOR_ALPHA, v.a)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "model",
+    {get = function(self)
+        return BlzGetItemStringField(self.handle, ITEM_SF_MODEL_USED)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "position",
+    {
+        get = function(self)
+            return vec2(
+                GetItemX(self.handle),
+                GetItemY(self.handle)
+            )
+        end,
+        set = function(self, v)
+            SetItemPosition(self.handle, v.x, v.y)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "charges",
+    {
+        get = function(self)
+            return GetItemCharges(self.handle)
+        end,
+        set = function(self, v)
+            SetItemCharges(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Item.prototype,
+    "abilities",
+    {get = function(self)
+        return self[100]
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    Item,
+    "onCreate",
+    {get = function(self)
+        return self.onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Item,
+    "onDestroy",
+    {get = function(self)
+        return self.onDestroyEvent
+    end}
+)
+local getManipulatedItem = GetManipulatedItem
+local trigger = CreateTrigger()
+TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_PICKUP_ITEM)
+TriggerAddAction(
+    trigger,
+    function()
+        local item = getManipulatedItem()
+        local abilities = ____exports.Item:of(item)[100]
+        local memoized = ItemAbility.memoized
+        for ____, ability in ipairs(abilities) do
+            local newHandle = getItemAbility(item, ability.typeId)
+            if newHandle ~= nil then
+                local oldId = getHandleId(ability.handle)
+                local newId = getHandleId(newHandle)
+                __TS__Delete(memoized, oldId)
+                memoized[newId] = ability
+                ability.handle = newHandle
+            end
+        end
+    end
+)
+return ____exports

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

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

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

@@ -0,0 +1,11 @@
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+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
+____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)
+end
+return ____exports

package/engine/internal/mechanics/area-damage.d.ts

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