warscript 0.0.1-dev.008d8ef

package/engine/internal/item/ability.lua

@@ -0,0 +1,48 @@
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____dummy = require("objutil.dummy")
+local dummyUnitId = ____dummy.dummyUnitId
+local isItemOwned = IsItemOwned
+local isItemPowerup = IsItemPowerup
+local getItemX = GetItemX
+local getItemY = GetItemY
+local setItemBooleanField = BlzSetItemBooleanField
+local setItemPosition = SetItemPosition
+local unitAddItem = UnitAddItem
+local unitRemoveItem = UnitRemoveItem
+local dummy = assert(CreateUnit(
+    Player.neutralVictim.handle,
+    dummyUnitId,
+    0,
+    0,
+    270
+))
+ShowUnit(dummy, false)
+---
+-- @internal For use by internal systems only.
+____exports.doAbilityAction = function(handle, action, ...)
+    local isOwned = isItemOwned(handle)
+    local isPowerup
+    local x
+    local y
+    if not isOwned then
+        if isItemPowerup(handle) then
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+            isPowerup = true
+        end
+        x = getItemX(handle)
+        y = getItemY(handle)
+        unitAddItem(dummy, handle)
+    end
+    local result = action(handle, ...)
+    if not isOwned then
+        unitRemoveItem(dummy, handle)
+        setItemPosition(handle, x, y)
+        if isPowerup then
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+    return result
+end
+return ____exports

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 {};