warscript 0.0.1-dev.3b2adda → 0.0.1-dev.3b93f8c

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";
@@ -55,16 +55,19 @@ export declare class UnrecognizedAbility extends Ability {
 export declare class UnitAbility extends Ability {
     readonly owner: Unit;
     private readonly u;
+    private d?;
     constructor(handle: jability, typeId: number, owner: Unit);
     incrementHideCounter(): void;
     decrementHideCounter(): void;
     incrementDisableCounter(): void;
     decrementDisableCounter(): void;
+    get isDisabled(): boolean;
     get level(): number;
     set level(v: number);
     get cooldownRemaining(): number;
     set cooldownRemaining(cooldownRemaining: number);
     interruptCast(): void;
+    protected onDestroy(): HandleDestructor;
     static get onCreate(): Event<[UnitAbility]>;
     static get onDestroy(): Event<[UnitAbility]>;
 }
@@ -91,6 +94,7 @@ export declare class ItemAbility extends Ability {
     get cooldownRemaining(): number;
     set cooldownRemaining(cooldownRemaining: number);
     interruptCast(): void;
+    protected onDestroy(): HandleDestructor;
     static get onCreate(): Event<[ItemAbility]>;
     static get onDestroy(): Event<[ItemAbility]>;
 }

package/engine/internal/ability.lua

@@ -232,6 +232,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 +260,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(
@@ -404,14 +409,36 @@ function UnitAbility.prototype.decrementHideCounter(self)
     unitHideAbility(self.u, self.typeId, false)
 end
 function UnitAbility.prototype.incrementDisableCounter(self)
-    unitDisableAbility(self.u, self.typeId, true, false)
+    local unit = self.u
+    local typeId = self.typeId
+    unitHideAbility(unit, typeId, true)
+    unitDisableAbility(unit, typeId, true, false)
+    self.d = (self.d or 0) + 1
 end
 function UnitAbility.prototype.decrementDisableCounter(self)
-    unitDisableAbility(self.u, self.typeId, false, false)
+    local unit = self.u
+    local typeId = self.typeId
+    unitDisableAbility(unit, typeId, false, false)
+    unitHideAbility(unit, typeId, true)
+    self.d = (self.d or 0) - 1
 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",
+    {get = function(self)
+        return self.d ~= nil and self.d > 0
+    end},
+    true
+)
 __TS__SetDescriptor(
     UnitAbility.prototype,
     "level",
@@ -496,6 +523,12 @@ function ItemAbility.prototype.interruptCast(self)
         setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, true)
     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,
     "level",

package/engine/internal/item/ability.lua

@@ -20,6 +20,7 @@ local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slo
 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
@@ -31,6 +32,8 @@ local unitAddItem = UnitAddItem
 local unitRemoveItem = UnitRemoveItem
 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
@@ -65,7 +68,7 @@ ____exports.itemAbilityDummy = assert(CreateUnit(
     270
 ))
 local cooldownStarterItem = UnitAddItemById(____exports.itemAbilityDummy, COOLDOWN_STARTER_ITEM_TYPE_ID)
-local cooldownStarterAbility = BlzGetItemAbility(cooldownStarterItem, COOLDOWN_STARTER_ABILITY_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)
@@ -153,4 +156,51 @@ ____exports.doAbilityActionForceDummy = function(handle, owner, action, ...)
     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+owner.lua

@@ -6,12 +6,18 @@ 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)
+Unit.itemPickedUpEvent:addListener(
+    4,
+    function(unit, item)
+        ownerByItem[item] = unit
+    end
+)
+Unit.itemDroppedEvent:addListener(
+    4,
+    function(unit, item)
+        ownerByItem[item] = nil
+    end
+)
 __TS__ObjectDefineProperty(
     Item.prototype,
     "owner",

package/engine/internal/item.d.ts

@@ -7,14 +7,11 @@ 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
+    ABILITIES = 100
 }
 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;
@@ -31,22 +28,22 @@ 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 canBeSold(canBeSold: boolean);
+    get canBeSold(): 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 isActivelyUsed(isActivelyUsed: boolean);
+    get isActivelyUsed(): boolean;
     set visible(v: boolean);
     get visible(): boolean;
     set level(v: number);
@@ -75,6 +72,7 @@ export declare class Item extends Handle<jitem> {
     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;
@@ -84,5 +82,6 @@ export declare class Item extends Handle<jitem> {
     static getInRect(rect: ReadonlyRect): Item[];
     static get onCreate(): Event<[Item]>;
     static get destroyEvent(): Event<[Item]>;
+    static readonly chargesChangedEvent: Event<[Item]>;
 }
 export {};

package/engine/internal/item.lua

@@ -1,14 +1,18 @@
 local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
 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 invoke
 local ____handle = require("core.types.handle")
 local Handle = ____handle.Handle
 local ____color = require("core.types.color")
 local Color = ____color.Color
+local ____event = require("event")
+local Event = ____event.Event
 local ____rect = require("core.types.rect")
 local Rect = ____rect.Rect
 local ____ability = require("engine.internal.ability")
@@ -23,6 +27,7 @@ local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slo
 local SLOT_FILLER_ITEM_TYPE_ID = ____add_2Ditem_2Dto_2Dslot.SLOT_FILLER_ITEM_TYPE_ID
 local ____vec2 = require("math.vec2")
 local distance = ____vec2.distance
+local itemChargesChangeEvent = __TS__New(Event)
 local itemAddAbility = BlzItemAddAbility
 local itemRemoveAbility = BlzItemRemoveAbility
 local getItemAbility = BlzGetItemAbility
@@ -40,10 +45,30 @@ local getItemX = GetItemX
 local getItemY = GetItemY
 local getItemCharges = GetItemCharges
 local setItemCharges = SetItemCharges
+local unitRemoveAbility = UnitRemoveAbility
+local unitRemoveItem = UnitRemoveItem
+local unitUseItem = UnitUseItem
+local unitUseItemPoint = UnitUseItemPoint
+local unitUseItemTarget = UnitUseItemTarget
+local setItemDropOnDeath = SetItemDropOnDeath
+local setItemDroppable = SetItemDroppable
+local setItemPawnable = SetItemPawnable
+local isItemPawnable = IsItemPawnable
 local getItemIntegerField = BlzGetItemIntegerField
 local setItemBooleanField = BlzSetItemBooleanField
 local getItemBooleanField = BlzGetItemBooleanField
+local tableRemove = table.remove
+_G.SetItemCharges = function(whichItem, charges)
+    setItemCharges(whichItem, charges)
+    invoke(
+        itemChargesChangeEvent,
+        ____exports.Item:of(whichItem)
+    )
+end
+invoke = Event.invoke
 local enumRect = Rect:create(0, 0, 0, 0).handle
+---
+-- @internal For use by internal systems only.
 ____exports.addAndGetAbility = function(handle, abilityTypeId)
     if itemAddAbility(handle, abilityTypeId) then
         return getItemAbility(handle, abilityTypeId)
@@ -69,6 +94,23 @@ local function getItemAbilities(handle, item)
     end
     return abilities
 end
+local function consumeCharge(handle)
+    do
+        local i = 0
+        local ability = getItemAbilityByIndex(handle, i)
+        while ability ~= nil do
+            unitRemoveAbility(
+                itemAbilityDummy,
+                getAbilityId(ability)
+            )
+            do
+                i = i + 1
+                ability = getItemAbilityByIndex(handle, i)
+            end
+        end
+    end
+    return unitUseItem(itemAbilityDummy, handle) or unitUseItemPoint(itemAbilityDummy, handle, 0, 0) or unitUseItemTarget(itemAbilityDummy, handle, itemAbilityDummy)
+end
 local targetCollection
 local targetCollectionNextIndex
 local centerX
@@ -101,15 +143,13 @@ 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
+    self[100] = doAbilityAction(handle, getItemAbilities, self)
 end
 function Item.prototype.onDestroy(self)
+    local owner = self.owner
+    if owner ~= nil then
+        unitRemoveItem(owner.handle, self.handle)
+    end
     local abilities = self[100]
     for i = 1, #abilities do
         abilities[i]:destroy()
@@ -121,40 +161,31 @@ function Item.create(self, id, x, y, skinId)
     return self:of(BlzCreateItemWithSkin(id, x, y, skinId or id))
 end
 function Item.prototype.consumeCharge(self)
+    return self:consumeCharges(1)
+end
+function Item.prototype.consumeCharges(self, count)
     local handle = self.handle
     local charges = getItemCharges(handle)
-    if charges >= 2 then
-        setItemCharges(handle, charges - 1)
+    if charges > count then
+        setItemCharges(handle, charges - count)
+        invoke(itemChargesChangeEvent, self)
         return true
     end
-    if charges == 1 then
+    if charges == count then
         if getItemBooleanField(handle, ITEM_BF_PERISHABLE) then
             self:destroy()
             return true
         end
+        if not getItemBooleanField(handle, ITEM_BF_ACTIVELY_USED) then
+            setItemCharges(handle, 0)
+            invoke(itemChargesChangeEvent, self)
+            return true
+        end
+        setItemCharges(handle, 1)
         local ____doAbilityActionForceDummy_2 = doAbilityActionForceDummy
         local ____opt_0 = self.owner
-        ____doAbilityActionForceDummy_2(
-            handle,
-            ____opt_0 and ____opt_0.handle,
-            function()
-                do
-                    local i = 0
-                    local ability = getItemAbilityByIndex(handle, i)
-                    while ability ~= nil do
-                        UnitRemoveAbility(
-                            itemAbilityDummy,
-                            getAbilityId(ability)
-                        )
-                        do
-                            i = i + 1
-                            ability = getItemAbilityByIndex(handle, i)
-                        end
-                    end
-                end
-                UnitUseItem(itemAbilityDummy, handle)
-            end
-        )
+        ____doAbilityActionForceDummy_2(handle, ____opt_0 and ____opt_0.handle, consumeCharge)
+        invoke(itemChargesChangeEvent, self)
         return true
     end
     return false
@@ -164,33 +195,32 @@ function Item.prototype.addAbility(self, 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
+        abilities[#abilities + 1] = ability
         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]
+    local abilities = self[100]
+    for i = 1, #abilities do
+        if abilities[i].typeId == abilityTypeId then
+            local ability = abilities[i]
+            tableRemove(abilities, i)
+            ability:destroy()
+            return true
         end
     end
-    return false
+    return doAbilityAction(self.handle, itemRemoveAbility, abilityTypeId)
 end
 function Item.prototype.hasAbility(self, abilityTypeId)
-    return self[101][abilityTypeId] ~= nil
+    return doAbilityAction(self.handle, getItemAbility, 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
+    return ItemAbility:of(
+        doAbilityAction(self.handle, getItemAbility, abilityTypeId),
+        abilityTypeId,
+        self
+    )
 end
 function Item.getInRange(self, x, y, range)
     targetCollection = {}
@@ -302,65 +332,68 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "dropOnDeath",
+    "dropsOnDeath",
     {
         get = function(self)
-            return BlzGetItemBooleanField(self.handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
+            return getItemBooleanField(self.handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
         end,
-        set = function(self, v)
-            SetItemDropOnDeath(self.handle, v)
+        set = function(self, dropsOnDeath)
+            setItemDropOnDeath(self.handle, dropsOnDeath)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "droppable",
+    "canBeDropped",
     {
         get = function(self)
-            return BlzGetItemBooleanField(self.handle, ITEM_BF_CAN_BE_DROPPED)
+            return getItemBooleanField(self.handle, ITEM_BF_CAN_BE_DROPPED)
         end,
-        set = function(self, v)
-            SetItemDroppable(self.handle, v)
+        set = function(self, canBeDropped)
+            setItemDroppable(self.handle, canBeDropped)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "pawnable",
+    "canBeSold",
     {
         get = function(self)
-            return IsItemPawnable(self.handle)
+            return isItemPawnable(self.handle)
         end,
-        set = function(self, v)
-            SetItemPawnable(self.handle, v)
+        set = function(self, canBeSold)
+            setItemPawnable(self.handle, canBeSold)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "perishable",
+    "perishes",
     {
         get = function(self)
             return getItemBooleanField(self.handle, ITEM_BF_PERISHABLE)
         end,
-        set = function(self, v)
-            BlzSetItemBooleanField(self.handle, ITEM_BF_PERISHABLE, v)
+        set = function(self, perishes)
+            local handle = self.handle
+            local powerUp = isItemPowerup(handle)
+            setItemBooleanField(handle, ITEM_BF_PERISHABLE, perishes)
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerUp)
         end
     },
     true
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "powerup",
+    "isPowerUp",
     {
         get = function(self)
             return isItemPowerup(self.handle)
         end,
-        set = function(self, v)
-            setItemBooleanField(self.handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, v)
+        set = function(self, isPowerUp)
+            setItemBooleanField(self.handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, isPowerUp)
         end
     },
     true
@@ -396,16 +429,24 @@ __TS__SetDescriptor(
 )
 __TS__SetDescriptor(
     Item.prototype,
-    "usable",
+    "isActivelyUsed",
     {
         get = function(self)
             return getItemBooleanField(self.handle, ITEM_BF_ACTIVELY_USED)
         end,
-        set = function(self, v)
+        set = function(self, isActivelyUsed)
             local handle = self.handle
-            local powerup = isItemPowerup(handle)
-            setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, v)
-            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerup)
+            local powerUp = isItemPowerup(handle)
+            local perishes = getItemBooleanField(handle, ITEM_BF_PERISHABLE)
+            local dropsOnDeath = getItemBooleanField(handle, ITEM_BF_DROPPED_WHEN_CARRIER_DIES)
+            local canBeDropped = getItemBooleanField(handle, ITEM_BF_CAN_BE_DROPPED)
+            local canBeSold = isItemPawnable(handle)
+            setItemBooleanField(handle, ITEM_BF_ACTIVELY_USED, isActivelyUsed)
+            setItemPawnable(handle, canBeSold)
+            setItemDroppable(handle, canBeDropped)
+            setItemDropOnDeath(handle, dropsOnDeath)
+            setItemBooleanField(handle, ITEM_BF_PERISHABLE, perishes)
+            setItemBooleanField(handle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, powerUp)
         end
     },
     true
@@ -604,6 +645,7 @@ __TS__SetDescriptor(
         end,
         set = function(self, v)
             setItemCharges(self.handle, v)
+            invoke(itemChargesChangeEvent, self)
         end
     },
     true
@@ -630,6 +672,7 @@ __TS__ObjectDefineProperty(
         return self.onDestroyEvent
     end}
 )
+Item.chargesChangedEvent = itemChargesChangeEvent
 local getManipulatedItem = GetManipulatedItem
 local trigger = CreateTrigger()
 TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_PICKUP_ITEM)

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

@@ -74,9 +74,12 @@ ____exports.castAbility = function(nativeUnit, abilityTypeId, prepareAbility, ..
         unitRemoveAbility(nativeUnit, INVENTORY_ABILITY_TYPE_ID)
         if latestInventoryAbilityTypeId ~= 0 then
             unitAddAbility(nativeUnit, latestInventoryAbilityTypeId)
-            for slot, nativeItem in pairs(nativeItemBySlot) do
-                unitAddItem(nativeUnit, nativeItem)
-                unitDropItemSlot(nativeUnit, nativeItem, slot)
+            for slot = 0, inventorySize - 1 do
+                local nativeItem = nativeItemBySlot[slot]
+                if nativeItem ~= nil then
+                    unitAddItem(nativeUnit, nativeItem)
+                    unitDropItemSlot(nativeUnit, nativeItem, slot)
+                end
             end
         end
     end

package/engine/internal/misc/frame-coordinates.lua

@@ -0,0 +1,21 @@
+local ____exports = {}
+local getLocalClientWidth = BlzGetLocalClientWidth
+local getLocalClientHeight = BlzGetLocalClientHeight
+---
+-- @internal For use by internal systems only.
+____exports.getFrameMinXMaxX = function()
+    local w = getLocalClientWidth()
+    local h = getLocalClientHeight()
+    local width4by3 = (w - h / 600 * 800) / 2
+    local pxtodpi = 0.6 / h
+    local minX = -width4by3 * pxtodpi
+    local maxX = minX + w * pxtodpi
+    return minX, maxX
+end
+---
+-- @internal For use by internal systems only.
+____exports.FRAME_MIN_Y = 0
+---
+-- @internal For use by internal systems only.
+____exports.FRAME_MAX_Y = 0.6
+return ____exports

package/engine/internal/misc/get-terrain-z.d.ts

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

package/engine/internal/misc/get-terrain-z.lua

@@ -0,0 +1,11 @@
+local ____exports = {}
+local getLocationZ = GetLocationZ
+local moveLocation = MoveLocation
+local location = Location(0, 0)
+---
+-- @internal For use by internal systems only.
+____exports.getTerrainZ = function(x, y)
+    moveLocation(location, x, y)
+    return getLocationZ(location)
+end
+return ____exports