warscript 0.0.1-dev.c37d12c → 0.0.1-dev.c47d565

package/engine/internal/item/ability.lua

@@ -1,27 +1,103 @@
 local ____exports = {}
+local restoreCooldownGroup
 local ____player = require("core.types.player")
 local Player = ____player.Player
 local ____dummy = require("objutil.dummy")
 local dummyUnitId = ____dummy.dummyUnitId
+local ____utility = require("engine.internal.utility")
+local findUnitItemSlot = ____utility.findUnitItemSlot
+local ____blank = require("engine.object-data.entry.item-type.blank")
+local BlankItemType = ____blank.BlankItemType
+local ____object_2Ddata_2Dentry_2Did_2Dgenerator = require("engine.object-data.utility.object-data-entry-id-generator")
+local abilityTypeIdGenerator = ____object_2Ddata_2Dentry_2Did_2Dgenerator.abilityTypeIdGenerator
+local ____math = require("math")
+local MINIMUM_POSITIVE_NORMALIZED_FLOAT = ____math.MINIMUM_POSITIVE_NORMALIZED_FLOAT
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____ignore_2Devents_2Ditems = require("engine.internal.unit.ignore-events-items")
+local ignoreEventsItems = ____ignore_2Devents_2Ditems.ignoreEventsItems
+local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slot")
+local unitAddItemToSlot = ____add_2Ditem_2Dto_2Dslot.unitAddItemToSlot
 local isItemOwned = IsItemOwned
 local isItemPowerup = IsItemPowerup
+local getItemAbility = BlzGetItemAbility
 local getItemX = GetItemX
 local getItemY = GetItemY
+local setAbilityRealLevelField = BlzSetAbilityRealLevelField
+local setItemIntegerField = BlzSetItemIntegerField
+local getItemIntegerField = BlzGetItemIntegerField
 local setItemBooleanField = BlzSetItemBooleanField
 local setItemPosition = SetItemPosition
 local unitAddItem = UnitAddItem
 local unitRemoveItem = UnitRemoveItem
-local dummy = assert(CreateUnit(
+local unitUseItem = UnitUseItem
+local unitResetCooldown = UnitResetCooldown
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local COOLDOWN_STARTER_ABILITY_TYPE_ID = compiletime(function()
+    if not currentMap then
+        return 0
+    end
+    local abilityType = currentMap.objects.ability:newObject(
+        util.id2s(abilityTypeIdGenerator:next()),
+        "Absk"
+    )
+    abilityType["bsk1+0"] = 0
+    abilityType["bsk2+0"] = 0
+    abilityType["bsk3+0"] = 0
+    abilityType["amcs+0"] = 0
+    abilityType["adur+0"] = MINIMUM_POSITIVE_NORMALIZED_FLOAT
+    abilityType["ahdu+0"] = MINIMUM_POSITIVE_NORMALIZED_FLOAT
+    return util.s2id(abilityType.id)
+end)
+local COOLDOWN_STARTER_ITEM_TYPE_ID = compiletime(function()
+    local itemType = BlankItemType:create()
+    itemType.name = "[Warscript/Dummy] Item Cooldown Starter"
+    itemType.abilityTypeIds = {COOLDOWN_STARTER_ABILITY_TYPE_ID}
+    itemType.cooldownGroupId = COOLDOWN_STARTER_ABILITY_TYPE_ID
+    itemType.activelyUsed = true
+    return itemType.id
+end)
+---
+-- @internal For use by internal systems only.
+____exports.itemAbilityDummy = assert(CreateUnit(
     Player.neutralVictim.handle,
     dummyUnitId,
     0,
     0,
     270
 ))
-ShowUnit(dummy, false)
+local cooldownStarterItem = UnitAddItemById(____exports.itemAbilityDummy, COOLDOWN_STARTER_ITEM_TYPE_ID)
+local cooldownStarterAbility = getItemAbility(cooldownStarterItem, COOLDOWN_STARTER_ABILITY_TYPE_ID)
+ShowUnit(____exports.itemAbilityDummy, false)
+local function startItemCooldownInternal(handle, cooldown)
+    local cooldownGroup = getItemIntegerField(handle, ITEM_IF_COOLDOWN_GROUP)
+    setItemIntegerField(handle, ITEM_IF_COOLDOWN_GROUP, COOLDOWN_STARTER_ABILITY_TYPE_ID)
+    setAbilityRealLevelField(cooldownStarterAbility, ABILITY_RLF_COOLDOWN, 0, cooldown)
+    unitResetCooldown(____exports.itemAbilityDummy)
+    unitUseItem(____exports.itemAbilityDummy, cooldownStarterItem)
+    Timer:run(restoreCooldownGroup, handle, cooldownGroup)
+end
+restoreCooldownGroup = function(handle, cooldownGroup)
+    if getItemIntegerField(handle, ITEM_IF_COOLDOWN_GROUP) == COOLDOWN_STARTER_ABILITY_TYPE_ID then
+        setItemIntegerField(handle, ITEM_IF_COOLDOWN_GROUP, cooldownGroup)
+    end
+end
+---
+-- @internal For use by internal systems only.
+____exports.startItemCooldown = function(handle, owner, cooldown)
+    ____exports.doAbilityActionForceDummy(handle, owner, startItemCooldownInternal, cooldown)
+end
+---
+-- @internal For use by internal systems only.
+____exports.abilityActionDummy = ____exports.itemAbilityDummy
 ---
 -- @internal For use by internal systems only.
 ____exports.doAbilityAction = function(handle, action, ...)
+    local isAlreadyIgnoredInEvents = ignoreEventsItems[handle] ~= nil
+    if not isAlreadyIgnoredInEvents then
+        ignoreEventsItems[handle] = true
+    end
     local isOwned = isItemOwned(handle)
     local isPowerup
     local x
@@ -33,16 +109,98 @@ ____exports.doAbilityAction = function(handle, action, ...)
         end
         x = getItemX(handle)
         y = getItemY(handle)
-        unitAddItem(dummy, handle)
+        unitAddItem(____exports.itemAbilityDummy, handle)
     end
     local result = action(handle, ...)
     if not isOwned then
-        unitRemoveItem(dummy, handle)
+        unitRemoveItem(____exports.itemAbilityDummy, handle)
         setItemPosition(handle, x, y)
         if isPowerup then
             setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
         end
     end
+    if not isAlreadyIgnoredInEvents then
+        ignoreEventsItems[handle] = nil
+    end
+    return result
+end
+---
+-- @internal For use by internal systems only.
+____exports.doAbilityActionForceDummy = function(handle, owner, action, ...)
+    if owner == nil then
+        return ____exports.doAbilityAction(handle, action, ...)
+    end
+    local slot = findUnitItemSlot(owner, handle)
+    if slot == nil then
+        return ____exports.doAbilityAction(handle, action, ...)
+    end
+    local isAlreadyIgnoredInEvents = ignoreEventsItems[handle] ~= nil
+    if not isAlreadyIgnoredInEvents then
+        ignoreEventsItems[handle] = true
+    end
+    local isPowerup
+    if isItemPowerup(handle) then
+        setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        isPowerup = true
+    end
+    unitRemoveItem(owner, handle)
+    unitAddItem(____exports.itemAbilityDummy, handle)
+    local result = action(handle, ...)
+    unitRemoveItem(____exports.itemAbilityDummy, handle)
+    unitAddItemToSlot(owner, handle, slot)
+    if isPowerup then
+        setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+    end
+    if not isAlreadyIgnoredInEvents then
+        ignoreEventsItems[handle] = nil
+    end
+    return result
+end
+local depth = 0
+local itemBySlot = {}
+---
+-- @internal For use by internal systems only.
+____exports.doUnitAbilityAction = function(unit, abilityTypeId, action, ...)
+    local ____depth_0 = depth
+    depth = ____depth_0 + 1
+    local offset = 6 * ____depth_0
+    for slot = 0, unitInventorySize(unit) - 1 do
+        local item = unitItemInSlot(unit, slot)
+        if getItemAbility(item, abilityTypeId) ~= nil then
+            local isAlreadyIgnoredInEvents = ignoreEventsItems[item] ~= nil
+            if not isAlreadyIgnoredInEvents then
+                ignoreEventsItems[item] = true
+            end
+            unitRemoveItem(unit, item)
+            if not isAlreadyIgnoredInEvents then
+                ignoreEventsItems[item] = nil
+            end
+            itemBySlot[offset + slot] = item
+        end
+    end
+    local result = action(unit, ...)
+    for slot = 0, unitInventorySize(unit) - 1 do
+        local item = itemBySlot[offset + slot]
+        if item ~= nil then
+            local isAlreadyIgnoredInEvents = ignoreEventsItems[item] ~= nil
+            if not isAlreadyIgnoredInEvents then
+                ignoreEventsItems[item] = true
+            end
+            local isPowerup = isItemPowerup(item)
+            if isPowerup then
+                setItemBooleanField(item, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+            end
+            unitAddItemToSlot(unit, item, slot)
+            if isPowerup then
+                setItemBooleanField(item, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+            end
+            if not isAlreadyIgnoredInEvents then
+                ignoreEventsItems[item] = nil
+            end
+            itemBySlot[offset + slot] = nil
+        end
+    end
+    depth = depth - 1
     return result
 end
 return ____exports

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.onItemPickup:addListener(function(unit, item)
-    ownerByItem[item] = unit
-end)
-Unit.onItemDrop: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,22 +2,38 @@
 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";
+import type { ItemTypeId } from "../object-data/entry/item-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
+    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;
-    get typeId(): number;
+    /** 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;
     set name(v: string);
@@ -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);
@@ -73,14 +85,18 @@ export declare class Item extends Handle<jitem> {
     set position(v: Vec2);
     set charges(v: number);
     get charges(): number;
+    consumeCharge(): boolean;
+    consumeCharges(count: number): boolean;
     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 getInRange(x: number, y: number, range: number): Item[];
     static getInRect(rect: ReadonlyRect): Item[];
     static get onCreate(): Event<[Item]>;
-    static get onDestroy(): Event<[Item]>;
+    static get destroyEvent(): Event<[Item]>;
+    static readonly deathEvent: Event<[Item]>;
+    static readonly chargesChangedEvent: Event<[Item]>;
 }
 export {};