warscript 0.0.1-dev.404878c

package/engine/constants.d.ts

@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+export declare const DAMAGE_BONUS_PER_PRIMARY_ATTRIBUTE_POINT = 1;
+export declare const MAX_HEALTH_BONUS_PER_STRENGTH_POINT = 25;
+export declare const HEALTH_REGENERATION_RATE_BONUS_PER_STRENGTH_POINT = 0.05;
+export declare const ARMOR_BONUS_PER_AGILITY_POINT = 0.3;
+export declare const MAX_MANA_BONUS_PER_INTELLIGENCE_POINT = 15;
+export declare const MANA_REGENERATION_RATE_BONUS_PER_INTELLIGENCE_POINT = 0.05;

package/engine/constants.lua

@@ -0,0 +1,8 @@
+local ____exports = {}
+____exports.DAMAGE_BONUS_PER_PRIMARY_ATTRIBUTE_POINT = 1
+____exports.MAX_HEALTH_BONUS_PER_STRENGTH_POINT = 25
+____exports.HEALTH_REGENERATION_RATE_BONUS_PER_STRENGTH_POINT = 0.05
+____exports.ARMOR_BONUS_PER_AGILITY_POINT = 0.3
+____exports.MAX_MANA_BONUS_PER_INTELLIGENCE_POINT = 15
+____exports.MANA_REGENERATION_RATE_BONUS_PER_INTELLIGENCE_POINT = 0.05
+return ____exports

package/engine/index.d.ts

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

package/engine/index.lua

@@ -0,0 +1,2 @@
+local ____exports = {}
+return ____exports

package/engine/internal/ability.d.ts

@@ -0,0 +1,91 @@
+/** @noSelfInFile */
+import { Handle } from "../../core/types/handle";
+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>;
+}
+type jabilityfield = jabilityintegerfield | jabilityrealfield | jabilitybooleanfield | jabilitystringfield | jabilityintegerlevelfield | jabilityreallevelfield | jabilitybooleanlevelfield | jabilitystringlevelfield;
+export declare class AbilitySnapshot {
+}
+export declare abstract class Ability extends Handle<jability> {
+    readonly typeId: AbilityTypeId;
+    protected constructor(handle: jability, typeId: number);
+    toString(): string;
+    get parentTypeId(): number;
+    get orderId(): number;
+    abstract readonly owner: Unit | Item;
+    getSnapshot(): AbilitySnapshot;
+    hasField(field: jabilityfield | number): boolean;
+    getField(field: jabilityintegerfield | jabilityrealfield): number;
+    getField(field: jabilitybooleanfield): boolean;
+    getField(field: jabilitystringfield): string;
+    getField(field: jabilityintegerlevelfield | jabilityreallevelfield, level?: number): number;
+    getField(field: jabilitybooleanlevelfield, level?: number): boolean;
+    getField(field: jabilitystringlevelfield, level?: number): string;
+    setField(field: jabilityintegerfield | jabilityrealfield, value: number): boolean;
+    setField(field: jabilitybooleanfield, value: boolean): boolean;
+    setField(field: jabilitystringfield, value: string): boolean;
+    setField(field: jabilityintegerlevelfield, value: number): boolean;
+    setField(field: jabilityreallevelfield, value: number): boolean;
+    setField(field: jabilitybooleanlevelfield, value: boolean): boolean;
+    setField(field: jabilitystringlevelfield, value: string): boolean;
+    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[];
+    abstract get level(): number;
+    static get onCreate(): Event<[Ability]>;
+    static get destroyEvent(): Event<[Ability]>;
+}
+/**
+ * Can happen in extreme edge cases such as removing an ability from a unit during a chain of ability events.
+ */
+export declare class UnrecognizedAbility extends Ability {
+    readonly owner: Unit;
+    constructor(typeId: number, owner: Unit);
+    get level(): number;
+}
+export declare class UnitAbility extends Ability {
+    readonly owner: Unit;
+    private readonly u;
+    constructor(handle: jability, typeId: number, owner: Unit);
+    get level(): number;
+    set level(v: number);
+    get cooldownRemaining(): number;
+    set cooldownRemaining(v: number);
+    static get onCreate(): Event<[UnitAbility]>;
+    static get onDestroy(): Event<[UnitAbility]>;
+}
+export declare class ItemAbility extends Ability {
+    readonly owner: Item;
+    constructor(handle: jability, typeId: number, owner: Item);
+    getField(field: jabilityintegerfield | jabilityrealfield): number;
+    getField(field: jabilitybooleanfield): boolean;
+    getField(field: jabilitystringfield): string;
+    getField(field: jabilityintegerlevelfield | jabilityreallevelfield, level?: number): number;
+    getField(field: jabilitybooleanlevelfield, level?: number): boolean;
+    getField(field: jabilitystringlevelfield, level?: number): string;
+    setField(field: jabilityintegerfield | jabilityrealfield, value: number): boolean;
+    setField(field: jabilitybooleanfield, value: boolean): boolean;
+    setField(field: jabilitystringfield, value: string): boolean;
+    setField(field: jabilityintegerlevelfield, value: number): boolean;
+    setField(field: jabilityreallevelfield, value: number): boolean;
+    setField(field: jabilitybooleanlevelfield, value: boolean): boolean;
+    setField(field: jabilitystringlevelfield, value: string): boolean;
+    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 level(): number;
+    static get onCreate(): Event<[ItemAbility]>;
+    static get onDestroy(): Event<[ItemAbility]>;
+}
+export {};

package/engine/internal/ability.lua

@@ -0,0 +1,531 @@
+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
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____ability = require("engine.internal.item.ability")
+local doAbilityAction = ____ability.doAbilityAction
+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 getAbilityBooleanField = BlzGetAbilityBooleanField
+local getAbilityStringField = BlzGetAbilityStringField
+local getAbilityIntegerLevelField = BlzGetAbilityIntegerLevelField
+local getAbilityRealLevelField = BlzGetAbilityRealLevelField
+local getAbilityBooleanLevelField = BlzGetAbilityBooleanLevelField
+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
+local commonFields = compiletime(function()
+    local commonFields = {}
+    for ____, id in ipairs({
+        "anam",
+        "ansf",
+        "aher",
+        "aite",
+        "arac",
+        "abpx",
+        "abpy",
+        "aubx",
+        "auby",
+        "arpx",
+        "arpy",
+        "aart",
+        "auar",
+        "arar",
+        "acat",
+        "atat",
+        "asat",
+        "aeat",
+        "aaea",
+        "alig",
+        "amat",
+        "amsp",
+        "amac",
+        "amho",
+        "atac",
+        "ata0",
+        "ata1",
+        "ata2",
+        "ata3",
+        "ata4",
+        "ata5",
+        "acac",
+        "acap",
+        "aca1",
+        "aspt",
+        "aani",
+        "atp1",
+        "aut1",
+        "aub1",
+        "auu1",
+        "aret",
+        "arut",
+        "arhk",
+        "ahky",
+        "auhk",
+        "areq",
+        "arqa",
+        "achd",
+        "apri",
+        "aord",
+        "aoru",
+        "aoro",
+        "aorf",
+        "aefs",
+        "aefl",
+        "alev",
+        "arlv",
+        "alsk",
+        "atar",
+        "acas",
+        "adur",
+        "ahdu",
+        "acdn",
+        "amcs",
+        "aare",
+        "aran",
+        "abuf",
+        "aeff",
+        "ausk"
+    }) do
+        commonFields[fourCC(id)] = true
+    end
+    return commonFields
+end)
+local availableFields = postcompile(function()
+    local availableFields = {}
+    if currentMap then
+        for id, ability in pairs(currentMap.objects.ability.all) do
+            if ability.parentId then
+                availableFields[fourCC(id)] = fourCC(ability.parentId)
+            else
+                local fields = __TS__ArrayFilter(
+                    __TS__ArrayMap(
+                        ability.all,
+                        function(____, id) return fourCC(id) end
+                    ),
+                    function(____, id) return not commonFields[id] end
+                )
+                if #fields ~= 0 then
+                    local set = {}
+                    for ____, field in ipairs(fields) do
+                        set[field] = true
+                    end
+                    availableFields[fourCC(id)] = set
+                end
+            end
+        end
+    end
+    return availableFields
+end)
+local orders = postcompile(function()
+    local orders = {}
+    if currentMap then
+        for id, ability in pairs(currentMap.objects.ability.all) do
+            if not ability.parentId then
+                orders[fourCC(id)] = ability.aord
+            end
+        end
+    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)
+    end,
+    abilityrealfield = function(ability, field)
+        return getAbilityRealField(ability.handle, field)
+    end,
+    abilitybooleanfield = function(ability, field)
+        return getAbilityBooleanField(ability.handle, field)
+    end,
+    abilitystringfield = function(ability, field)
+        return getAbilityStringField(ability.handle, field)
+    end,
+    abilityintegerlevelfield = function(ability, field, level)
+        return getAbilityIntegerLevelField(ability.handle, field, level or ability.level)
+    end,
+    abilityreallevelfield = function(ability, field, level)
+        return getAbilityRealLevelField(ability.handle, field, level or ability.level)
+    end,
+    abilitybooleanlevelfield = function(ability, field, level)
+        return getAbilityBooleanLevelField(ability.handle, field, level or ability.level)
+    end,
+    abilitystringlevelfield = function(ability, field, level)
+        return getAbilityStringLevelField(ability.handle, field, level or ability.level)
+    end
+}
+local fieldSetters = {
+    abilityintegerfield = function(ability, field, value)
+        return setAbilityIntegerField(ability.handle, field, value)
+    end,
+    abilityrealfield = function(ability, field, value)
+        return setAbilityRealField(ability.handle, field, value)
+    end,
+    abilitybooleanfield = function(ability, field, value)
+        return setAbilityBooleanField(ability.handle, field, value)
+    end,
+    abilitystringfield = function(ability, field, value)
+        return setAbilityStringField(ability.handle, field, value)
+    end,
+    abilityintegerlevelfield = function(ability, field, value, level)
+        return setAbilityIntegerLevelField(ability.handle, field, level or ability.level, value)
+    end,
+    abilityreallevelfield = function(ability, field, value, level)
+        return setAbilityRealLevelField(ability.handle, field, level or ability.level, value)
+    end,
+    abilitybooleanlevelfield = function(ability, field, value, level)
+        return setAbilityBooleanLevelField(ability.handle, field, level or ability.level, value)
+    end,
+    abilitystringlevelfield = function(ability, field, value, level)
+        return setAbilityStringLevelField(ability.handle, field, level or ability.level, value)
+    end
+}
+local levelRefreshFields = {
+    [fourCC("Isx1")] = true,
+    [fourCC("Idam")] = true,
+    [fourCC("Iob5")] = true,
+    [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,
+    [fourCC("AAns")] = ABILITY_SLF_BASE_ORDER_ID_ANS5
+}
+____exports.AbilitySnapshot = __TS__Class()
+local AbilitySnapshot = ____exports.AbilitySnapshot
+AbilitySnapshot.name = "AbilitySnapshot"
+function AbilitySnapshot.prototype.____constructor(self)
+end
+---
+-- @internal For use by internal systems only.
+____exports.getOrderIdByAbilityTypeId = function(abilityTypeId)
+    local parentTypeId = availableFields[abilityTypeId]
+    return order2orderId(orders[____type(parentTypeId) == "number" and parentTypeId or abilityTypeId] or "")
+end
+____exports.Ability = __TS__Class()
+local Ability = ____exports.Ability
+Ability.name = "Ability"
+__TS__ClassExtends(Ability, Handle)
+function Ability.prototype.____constructor(self, handle, typeId)
+    Handle.prototype.____constructor(self, handle)
+    self.typeId = typeId
+end
+function Ability.prototype.__tostring(self)
+    return (((self.constructor.name .. "$") .. util.id2s(self.typeId)) .. "@") .. tostring(getHandleId(self.handle))
+end
+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])
+end
+function Ability.prototype.getField(self, field, level)
+    local fieldType = match(
+        ____tostring(field),
+        "^(.-):"
+    )
+    return fieldGetters[fieldType](self, field, level)
+end
+function Ability.prototype.setField(self, field, levelOrValue, value)
+    local fieldType = match(
+        ____tostring(field),
+        "^(.-):"
+    )
+    local ____temp_0
+    if value ~= nil then
+        ____temp_0 = fieldSetters[fieldType](self, field, value, levelOrValue)
+    else
+        ____temp_0 = fieldSetters[fieldType](self, field, levelOrValue)
+    end
+    local success = ____temp_0
+    if levelRefreshFields[getHandleId(field)] and success and __TS__InstanceOf(self, ____exports.UnitAbility) then
+        local unit = self.owner.handle
+        local ability = self.handle
+        local typeId = self.typeId
+        local levels = getAbilityIntegerField(ability, levelsField)
+        setAbilityIntegerField(ability, levelsField, levels + 1)
+        local level = getUnitAbilityLevel(unit, typeId)
+        setUnitAbilityLevel(unit, typeId, levels + 1)
+        setUnitAbilityLevel(unit, typeId, level)
+        setAbilityIntegerField(ability, levelsField, levels)
+    end
+    return success
+end
+__TS__SetDescriptor(
+    Ability.prototype,
+    "parentTypeId",
+    {get = function(self)
+        local parentTypeId = availableFields[self.typeId]
+        parentTypeId = ____type(parentTypeId) == "number" and parentTypeId or self.typeId
+        rawset(self, "parentTypeId", parentTypeId)
+        return parentTypeId
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Ability.prototype,
+    "orderId",
+    {get = function(self)
+        local field = orderIdFieldByParentTypeId[self.parentTypeId]
+        return order2orderId(field ~= nil and getAbilityStringLevelField(self.handle, ABILITY_SLF_BASE_ORDER_ID_NCL6, self.level) or (orders[self.parentTypeId] or ""))
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Ability.prototype,
+    "realFields",
+    {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
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Ability.prototype,
+    "level",
+    {get = function(self)
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    Ability,
+    "onCreate",
+    {get = function(self)
+        return self.onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Ability,
+    "destroyEvent",
+    {get = function(self)
+        return self.onDestroyEvent
+    end}
+)
+--- Can happen in extreme edge cases such as removing an ability from a unit during a chain of ability events.
+____exports.UnrecognizedAbility = __TS__Class()
+local UnrecognizedAbility = ____exports.UnrecognizedAbility
+UnrecognizedAbility.name = "UnrecognizedAbility"
+__TS__ClassExtends(UnrecognizedAbility, ____exports.Ability)
+function UnrecognizedAbility.prototype.____constructor(self, typeId, owner)
+    UnrecognizedAbility.____super.prototype.____constructor(self, nil, typeId)
+    self.owner = owner
+end
+__TS__SetDescriptor(
+    UnrecognizedAbility.prototype,
+    "level",
+    {get = function(self)
+        return 0
+    end},
+    true
+)
+____exports.UnitAbility = __TS__Class()
+local UnitAbility = ____exports.UnitAbility
+UnitAbility.name = "UnitAbility"
+__TS__ClassExtends(UnitAbility, ____exports.Ability)
+function UnitAbility.prototype.____constructor(self, handle, typeId, owner)
+    UnitAbility.____super.prototype.____constructor(self, handle, typeId)
+    self.owner = owner
+    self.u = owner.handle
+end
+__TS__SetDescriptor(
+    UnitAbility.prototype,
+    "level",
+    {
+        get = function(self)
+            return getUnitAbilityLevel(self.u, self.typeId) - 1
+        end,
+        set = function(self, v)
+            setUnitAbilityLevel(self.u, self.typeId, v + 1)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    UnitAbility.prototype,
+    "cooldownRemaining",
+    {
+        get = function(self)
+            return getUnitAbilityCooldownRemaining(self.u, self.typeId)
+        end,
+        set = function(self, v)
+            startUnitAbilityCooldown(self.u, self.typeId, v)
+        end
+    },
+    true
+)
+__TS__ObjectDefineProperty(
+    UnitAbility,
+    "onCreate",
+    {get = function(self)
+        return self.onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    UnitAbility,
+    "onDestroy",
+    {get = function(self)
+        return self.onDestroyEvent
+    end}
+)
+local function getAbilityField(_, ability, field, level)
+    return ____exports.Ability.prototype.getField(ability, field, level)
+end
+local function setAbilityField(_, ability, field, levelOrValue, value)
+    return ____exports.Ability.prototype.setField(ability, field, levelOrValue, value)
+end
+____exports.ItemAbility = __TS__Class()
+local ItemAbility = ____exports.ItemAbility
+ItemAbility.name = "ItemAbility"
+__TS__ClassExtends(ItemAbility, ____exports.Ability)
+function ItemAbility.prototype.____constructor(self, handle, typeId, owner)
+    ItemAbility.____super.prototype.____constructor(self, handle, typeId)
+    self.owner = owner
+end
+function ItemAbility.prototype.getField(self, field, level)
+    return doAbilityAction(
+        self.owner.handle,
+        getAbilityField,
+        self,
+        field,
+        level
+    )
+end
+function ItemAbility.prototype.setField(self, field, levelOrValue, value)
+    return doAbilityAction(
+        self.owner.handle,
+        setAbilityField,
+        self,
+        field,
+        levelOrValue,
+        value
+    )
+end
+__TS__SetDescriptor(
+    ItemAbility.prototype,
+    "level",
+    {get = function(self)
+        return 0
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    ItemAbility,
+    "onCreate",
+    {get = function(self)
+        return self.onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    ItemAbility,
+    "onDestroy",
+    {get = function(self)
+        return self.onDestroyEvent
+    end}
+)
+return ____exports

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

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

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