warscript 0.0.1-dev.5dbd5af → 0.0.1-dev.5fb7641

package/engine/internal/item.lua

@@ -1,26 +1,33 @@
 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")
 local ItemAbility = ____ability.ItemAbility
 local ____ability = require("engine.internal.item.ability")
 local doAbilityAction = ____ability.doAbilityAction
+local doAbilityActionForceDummy = ____ability.doAbilityActionForceDummy
+local itemAbilityDummy = ____ability.itemAbilityDummy
 local ____dummy_2Ditem = require("engine.internal.object-data.dummy-item")
 local DUMMY_ITEM_ID = ____dummy_2Ditem.DUMMY_ITEM_ID
 local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slot")
 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
@@ -36,10 +43,26 @@ local getEnumItem = GetEnumItem
 local getItemTypeId = GetItemTypeId
 local getItemX = GetItemX
 local getItemY = GetItemY
+local getItemCharges = GetItemCharges
+local setItemCharges = SetItemCharges
+local unitRemoveAbility = UnitRemoveAbility
+local unitUseItem = UnitUseItem
+local unitUseItemPoint = UnitUseItemPoint
+local unitUseItemTarget = UnitUseItemTarget
+_G.SetItemCharges = function(whichItem, charges)
+    setItemCharges(whichItem, charges)
+    invoke(
+        itemChargesChangeEvent,
+        ____exports.Item:of(whichItem)
+    )
+end
 local getItemIntegerField = BlzGetItemIntegerField
 local setItemBooleanField = BlzSetItemBooleanField
 local getItemBooleanField = BlzGetItemBooleanField
+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)
@@ -65,6 +88,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
@@ -116,6 +156,36 @@ end
 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 > count then
+        setItemCharges(handle, charges - count)
+        invoke(itemChargesChangeEvent, self)
+        return true
+    end
+    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, consumeCharge)
+        invoke(itemChargesChangeEvent, self)
+        return true
+    end
+    return false
+end
 function Item.prototype.addAbility(self, abilityTypeId)
     local nativeAbility = doAbilityAction(self.handle, ____exports.addAndGetAbility, abilityTypeId)
     if nativeAbility ~= nil then
@@ -301,7 +371,7 @@ __TS__SetDescriptor(
     "perishable",
     {
         get = function(self)
-            return BlzGetItemBooleanField(self.handle, ITEM_BF_PERISHABLE)
+            return getItemBooleanField(self.handle, ITEM_BF_PERISHABLE)
         end,
         set = function(self, v)
             BlzSetItemBooleanField(self.handle, ITEM_BF_PERISHABLE, v)
@@ -557,10 +627,11 @@ __TS__SetDescriptor(
     "charges",
     {
         get = function(self)
-            return GetItemCharges(self.handle)
+            return getItemCharges(self.handle)
         end,
         set = function(self, v)
-            SetItemCharges(self.handle, v)
+            setItemCharges(self.handle, v)
+            invoke(itemChargesChangeEvent, self)
         end
     },
     true
@@ -587,6 +658,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/misc/damage-metadata-by-target.d.ts

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

package/engine/internal/misc/damage-metadata-by-target.lua

@@ -0,0 +1,5 @@
+local ____exports = {}
+---
+-- @internal For use by internal systems only.
+____exports.damageMetadataByTarget = setmetatable({}, {__mode = "k"})
+return ____exports

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

@@ -131,6 +131,11 @@ declare module "../unit" {
         const abilityNoTargetChannelingStartEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
+declare module "../unit" {
+    namespace Unit {
+        const abilityImpactEvent: DispatchingEvent<[Unit, Ability]>;
+    }
+}
 declare module "../unit" {
     namespace Unit {
         const abilityChannelingFinishEvent: DispatchingEvent<[Unit, Ability]>;

package/engine/internal/unit/ability.lua

@@ -21,6 +21,8 @@ local ____preconditions = require("utility.preconditions")
 local checkNotNull = ____preconditions.checkNotNull
 local ____lazy = require("utility.lazy")
 local lazyRecord = ____lazy.lazyRecord
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
 local eventInvoke = Event.invoke
 local condition = Condition
 local createTrigger = CreateTrigger
@@ -345,6 +347,18 @@ rawset(
         extractAbilityTypeId
     )
 )
+local internalAbilityImpactEvent = __TS__New(Event)
+internalAbilityChannelingStartEvent:addListener(function(...)
+    Timer:run(eventInvoke, internalAbilityImpactEvent, ...)
+end)
+rawset(
+    Unit,
+    "abilityImpactEvent",
+    createDispatchingEvent(
+        createCommonEvent(internalAbilityImpactEvent),
+        extractAbilityTypeId
+    )
+)
 rawset(
     Unit,
     "abilityChannelingFinishEvent",

package/engine/internal/unit/allowed-targets.d.ts

@@ -2,7 +2,7 @@
 import { CombatClassifications } from "../../object-data/auxiliary/combat-classification";
 declare module "../unit" {
     interface Unit {
-        isAllowedTarget(this: Unit, source: Unit, allowedTargetCombatClassifications: CombatClassifications): boolean;
+        isAllowedTarget(this: Unit, source: Unit, allowedTargetCombatClassifications?: CombatClassifications): boolean;
     }
 }
 declare module "../unit" {

package/engine/internal/unit/allowed-targets.lua

@@ -5,7 +5,15 @@ local initializeFilterTargetState = ____combat_2Dclassification.initializeFilter
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 Unit.prototype.isAllowedTarget = function(self, source, allowedTargetCombatClassifications)
-    initializeFilterTargetState(source, allowedTargetCombatClassifications)
+    if allowedTargetCombatClassifications ~= nil then
+        initializeFilterTargetState(source, allowedTargetCombatClassifications)
+        return filterTarget(self)
+    end
+    initializeFilterTargetState(source, source.firstWeapon.allowedTargetCombatClassifications)
+    if filterTarget(self) then
+        return true
+    end
+    initializeFilterTargetState(source, source.secondWeapon.allowedTargetCombatClassifications)
     return filterTarget(self)
 end
 Unit.getAllowedTargetsInRange = function(source, allowedTargetCombatClassifications, x, y, range)

package/engine/internal/unit+damage.d.ts

@@ -55,6 +55,6 @@ export declare namespace WeaponType {
 }
 declare module "./unit" {
     interface Unit {
-        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType): boolean;
+        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType, metadata?: unknown): boolean;
     }
 }

package/engine/internal/unit+damage.lua

@@ -9,6 +9,8 @@ local ____dummy = require("objutil.dummy")
 local dummyUnitId = ____dummy.dummyUnitId
 local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
 local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
+local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
 local createUnit = CreateUnit
 local getOwningPlayer = GetOwningPlayer
 local showUnit = ShowUnit
@@ -79,7 +81,7 @@ for ____, player in ipairs(Player.all) do
     showUnit(dummy, false)
     dummies[player] = dummy
 end
-Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType)
+Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType, metadata)
     if attack == nil then
         attack = false
     end
@@ -100,6 +102,9 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
     if not getOwningPlayer(handle) then
         handle = dummies[__TS__InstanceOf(target, Unit) and target.owner or (self._owner or Player.neutralAggressive)]
     end
+    if __TS__InstanceOf(target, Unit) then
+        damageMetadataByTarget[target] = metadata
+    end
     return unitDamageTarget(
         handle,
         targetHandle,

package/engine/internal/unit-missile-launch.lua

@@ -44,7 +44,7 @@ local function timerCallback(source, target)
     Event.invoke(autoAttackFinishEvent, source, target)
 end
 Unit.autoAttackStartEvent:addListener(function(source, target)
-    local attackPoint = source.weapons[1].impactDelay
+    local attackPoint = (source:chooseWeapon(target) or source.firstWeapon).impactDelay
     local timer = Timer:simple(attackPoint, timerCallback, source, target)
     eventTimerByUnit[source] = timer
 end)

package/engine/internal/unit.d.ts

@@ -14,6 +14,7 @@ import { CombatClassification, CombatClassifications } from "../object-data/auxi
 import { MovementType } from "../object-data/auxiliary/movement-type";
 import { UnitAttribute } from "../object-data/auxiliary/unit-attribute";
 import { AttackType } from "../object-data/auxiliary/attack-type";
+import { AttributesHolder } from "../../attributes";
 export type UnitClassification = junittype;
 export declare namespace UnitClassification {
     const STRUCTURE: junittype;
@@ -22,6 +23,7 @@ export declare namespace UnitClassification {
     const GROUND: junittype;
     const SUMMONED: junittype;
     const MECHANICAL: junittype;
+    const WORKER: junittype;
     const ANCIENT: junittype;
     const SUICIDAL: junittype;
     const TAUREN: junittype;
@@ -39,15 +41,18 @@ type AbilityDispatcherTable<T extends any[] = []> = {
     readonly [id: number]: Event<[Unit, Ability, ...T]>;
 };
 type AbilityEventDispatcher<T extends any[] = []> = Event<[Unit, Ability, ...T]> & AbilityDispatcherTable<T>;
-export interface DamagingEvent {
+export interface DamagingEvent extends AttributesHolder {
     amount: number;
     attackType: AttackType;
     damageType: jdamagetype;
     weaponType: jweapontype;
+    metadata: unknown;
     readonly isAttack: boolean;
     readonly originalAmount: number;
+    readonly originalMetadata: unknown;
+    preventRetaliation(this: DamagingEvent): void;
 }
-export type DamageEvent = DamagingEvent & {
+export type DamageEvent = Omit<DamagingEvent, "preventRetaliation"> & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
 };
 export type AttackDamageEvent = DamagingEvent & {
@@ -79,6 +84,8 @@ export declare class UnitWeapon {
     set cooldown(cooldown: number);
     get damage(): [minimumDamage: number, maximumDamage: number];
     set damage([minimumDamage, maximumDamage]: [number, number]);
+    get allowedTargetCombatClassifications(): CombatClassifications;
+    set allowedTargetCombatClassifications(allowedTargetCombatClassifications: CombatClassifications);
     get damageBase(): number;
     set damageBase(damageBase: number);
     get damageDiceCount(): number;
@@ -160,6 +167,7 @@ export declare class Unit extends Handle<junit> {
     get weapons(): [UnitWeapon, UnitWeapon];
     get firstWeapon(): UnitWeapon;
     get secondWeapon(): UnitWeapon;
+    chooseWeapon(target: Unit): UnitWeapon | undefined;
     get level(): number;
     set level(v: number);
     get xp(): number;
@@ -292,6 +300,7 @@ export declare class Unit extends Handle<junit> {
     get onUnitInRange(): Record<number, Event<[Unit]>>;
     get onManaEqual(): Record<number, Event<[Unit, number]>>;
     get manaEvent(): Record<Operator, Record<number, Event<[Unit]>>>;
+    get targetAcquiredEvent(): Event;
     get onSelect(): Event;
     get onDeselect(): Event;
     get onImmediateOrder(): Event<[number]>;
@@ -345,6 +354,7 @@ export declare class Unit extends Handle<junit> {
     static itemPickedUpEvent: UnitTriggerEvent<[Item]>;
     static itemUsedEvent: UnitTriggerEvent<[Item]>;
     static itemStackedEvent: UnitTriggerEvent<[Item]>;
+    static get itemChargesChangedEvent(): Event<[unit: Unit, item: Item]>;
     static get itemUseOrderEvent(): Event<[unit: Unit, item: Item]>;
     static get itemMoveOrderEvent(): Event<[
         unit: Unit,