warscript 0.0.1-dev.ea10f2b → 0.0.1-dev.eb24bc1

package/engine/behaviour/ability/damage.d.ts

@@ -4,26 +4,29 @@ import { Ability } from "../../internal/ability";
 import { Unit } from "../../internal/unit";
 import { AbilityDependentValue } from "../../object-field/ability";
 import { Widget } from "../../../core/types/widget";
-import { AttackType, DamageType, WeaponType } from "../../internal/unit+damage";
+import { DamageType, WeaponType } from "../../internal/unit+damage";
 import { CombatClassifications } from "../../object-data/auxiliary/combat-classification";
+import { AttackType } from "../../object-data/auxiliary/attack-type";
 export type DamageAbilityBehaviorParameters = {
     damagePerStrength?: AbilityDependentValue<number>;
     damagePerAgility?: AbilityDependentValue<number>;
     damagePerIntelligence?: AbilityDependentValue<number>;
-    attackType?: AttackType;
+    attackType?: AbilityDependentValue<AttackType>;
     damageType?: DamageType;
     weaponType?: WeaponType;
+    metadata?: AbilityDependentValue<string | number | boolean>;
 };
 export type DamageAreaAbilityBehaviorParameters = DamageAbilityBehaviorParameters & {
     maximumDamage?: AbilityDependentValue<number>;
     areaOfEffect?: AbilityDependentValue<number>;
     allowedTargetCombatClassifications?: AbilityDependentValue<CombatClassifications>;
 };
-declare abstract class DamageAbilityBehavior<T extends DamageAbilityBehaviorParameters = DamageAbilityBehaviorParameters> extends AbilityBehavior {
+export declare abstract class DamageAbilityBehavior<T extends DamageAbilityBehaviorParameters = DamageAbilityBehaviorParameters> extends AbilityBehavior {
     protected readonly damage: AbilityDependentValue<number>;
     protected readonly parameters?: T | undefined;
     protected constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: T | undefined);
     protected calculateDamage(caster: Unit): number;
+    protected damageTarget(caster: Unit, target: Widget, damage?: number): void;
 }
 export declare class DamageSelfAbilityBehavior extends DamageAbilityBehavior {
     constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: DamageAbilityBehaviorParameters);

package/engine/behaviour/ability/damage.lua

@@ -9,7 +9,8 @@ local Unit = ____unit.Unit
 local ____ability = require("engine.standard.fields.ability")
 local ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD = ____ability.ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD
 local AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD = ____ability.AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD
-local DamageAbilityBehavior = __TS__Class()
+____exports.DamageAbilityBehavior = __TS__Class()
+local DamageAbilityBehavior = ____exports.DamageAbilityBehavior
 DamageAbilityBehavior.name = "DamageAbilityBehavior"
 __TS__ClassExtends(DamageAbilityBehavior, AbilityBehavior)
 function DamageAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
@@ -34,49 +35,44 @@ function DamageAbilityBehavior.prototype.calculateDamage(self, caster)
     end
     return damage
 end
-____exports.DamageSelfAbilityBehavior = __TS__Class()
-local DamageSelfAbilityBehavior = ____exports.DamageSelfAbilityBehavior
-DamageSelfAbilityBehavior.name = "DamageSelfAbilityBehavior"
-__TS__ClassExtends(DamageSelfAbilityBehavior, DamageAbilityBehavior)
-function DamageSelfAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
-    DamageAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
-end
-function DamageSelfAbilityBehavior.prototype.onImpact(self, caster)
+function DamageAbilityBehavior.prototype.damageTarget(self, caster, target, damage)
     local parameters = self.parameters
     caster:damageTarget(
-        caster,
-        self:calculateDamage(caster),
+        target,
+        damage or self:calculateDamage(caster),
         nil,
         nil,
-        parameters and parameters.attackType,
+        self:resolveCurrentAbilityDependentValue(parameters and parameters.attackType),
         parameters and parameters.damageType,
-        parameters and parameters.weaponType
+        parameters and parameters.weaponType,
+        self:resolveCurrentAbilityDependentValue(parameters and parameters.metadata)
     )
 end
+____exports.DamageSelfAbilityBehavior = __TS__Class()
+local DamageSelfAbilityBehavior = ____exports.DamageSelfAbilityBehavior
+DamageSelfAbilityBehavior.name = "DamageSelfAbilityBehavior"
+__TS__ClassExtends(DamageSelfAbilityBehavior, ____exports.DamageAbilityBehavior)
+function DamageSelfAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
+    DamageSelfAbilityBehavior.____super.prototype.____constructor(self, ability, damage, parameters)
+end
+function DamageSelfAbilityBehavior.prototype.onImpact(self, caster)
+    self:damageTarget(caster, caster)
+end
 ____exports.DamageTargetAbilityBehavior = __TS__Class()
 local DamageTargetAbilityBehavior = ____exports.DamageTargetAbilityBehavior
 DamageTargetAbilityBehavior.name = "DamageTargetAbilityBehavior"
-__TS__ClassExtends(DamageTargetAbilityBehavior, DamageAbilityBehavior)
+__TS__ClassExtends(DamageTargetAbilityBehavior, ____exports.DamageAbilityBehavior)
 function DamageTargetAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
-    DamageAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
+    DamageTargetAbilityBehavior.____super.prototype.____constructor(self, ability, damage, parameters)
 end
 function DamageTargetAbilityBehavior.prototype.onWidgetTargetImpact(self, caster, target)
-    local parameters = self.parameters
-    caster:damageTarget(
-        target,
-        self:calculateDamage(caster),
-        nil,
-        nil,
-        parameters and parameters.attackType,
-        parameters and parameters.damageType,
-        parameters and parameters.weaponType
-    )
+    self:damageTarget(caster, target)
 end
 local DamageAreaAbilityBehavior = __TS__Class()
 DamageAreaAbilityBehavior.name = "DamageAreaAbilityBehavior"
-__TS__ClassExtends(DamageAreaAbilityBehavior, DamageAbilityBehavior)
+__TS__ClassExtends(DamageAreaAbilityBehavior, ____exports.DamageAbilityBehavior)
 function DamageAreaAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
-    DamageAbilityBehavior.prototype.____constructor(self, ability, damage, parameters)
+    DamageAreaAbilityBehavior.____super.prototype.____constructor(self, ability, damage, parameters)
 end
 function DamageAreaAbilityBehavior.prototype.damageArea(self, caster, x, y)
     local parameters = self.parameters
@@ -93,15 +89,7 @@ function DamageAreaAbilityBehavior.prototype.damageArea(self, caster, x, y)
         damage = maximumDamage / #targets
     end
     for ____, target in ipairs(targets) do
-        caster:damageTarget(
-            target,
-            damage,
-            nil,
-            nil,
-            parameters and parameters.attackType,
-            parameters and parameters.damageType,
-            parameters and parameters.weaponType
-        )
+        self:damageTarget(caster, target, damage)
     end
 end
 ____exports.DamageSelfAreaAbilityBehavior = __TS__Class()

package/engine/behaviour/ability/emulate-impact.lua

@@ -10,6 +10,9 @@ local MANA_COST_ABILITY_INTEGER_LEVEL_FIELD = ____ability.MANA_COST_ABILITY_INTE
 local ____math = require("math")
 local max = ____math.max
 local MINIMUM_POSITIVE_NORMALIZED_FLOAT = ____math.MINIMUM_POSITIVE_NORMALIZED_FLOAT
+local ____sound = require("core.types.sound")
+local Sound3D = ____sound.Sound3D
+local SoundSettings = ____sound.SoundSettings
 ____exports.EmulateImpactAbilityBehavior = __TS__Class()
 local EmulateImpactAbilityBehavior = ____exports.EmulateImpactAbilityBehavior
 EmulateImpactAbilityBehavior.name = "EmulateImpactAbilityBehavior"
@@ -23,6 +26,10 @@ function EmulateImpactAbilityBehavior.prototype.emulateImpact(self, caster)
     caster.mana = caster.mana - manaCost
     self.ability.cooldownRemaining = max(cooldown, MINIMUM_POSITIVE_NORMALIZED_FLOAT)
     self:flashCasterEffect(caster)
+    local soundPresetId = self.ability:getField(ABILITY_SF_EFFECT_SOUND)
+    if soundPresetId ~= "" then
+        Sound3D:playFromLabel(soundPresetId, SoundSettings.Ability, caster)
+    end
     AbilityBehavior:forAll(self.ability, "onImpact", caster)
 end
 return ____exports

package/engine/internal/item.d.ts

@@ -5,6 +5,7 @@ import { Event } from "../../event";
 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 {
@@ -17,7 +18,7 @@ export declare class Item extends Handle<jitem> {
     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;
+    get typeId(): ItemTypeId;
     set skinId(v: number);
     get skinId(): number;
     set name(v: string);

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+damage.d.ts

@@ -1,15 +1,6 @@
 /** @noSelfInFile */
 import { Widget } from "../../core/types/widget";
-export type AttackType = jattacktype;
-export declare namespace AttackType {
-    const SPELL: jattacktype;
-    const NORMAL: jattacktype;
-    const PIERCE: jattacktype;
-    const SIEGE: jattacktype;
-    const MAGIC: jattacktype;
-    const CHAOS: jattacktype;
-    const HERO: jattacktype;
-}
+import { AttackType } from "../object-data/auxiliary/attack-type";
 export type DamageType = jdamagetype;
 export declare namespace DamageType {
     const UNKNOWN: jdamagetype;
@@ -64,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

@@ -7,21 +7,14 @@ local ____player = require("core.types.player")
 local Player = ____player.Player
 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
 local unitDamageTarget = UnitDamageTarget
-____exports.AttackType = {}
-local AttackType = ____exports.AttackType
-do
-    AttackType.SPELL = ATTACK_TYPE_NORMAL
-    AttackType.NORMAL = ATTACK_TYPE_MELEE
-    AttackType.PIERCE = ATTACK_TYPE_PIERCE
-    AttackType.SIEGE = ATTACK_TYPE_SIEGE
-    AttackType.MAGIC = ATTACK_TYPE_MAGIC
-    AttackType.CHAOS = ATTACK_TYPE_CHAOS
-    AttackType.HERO = ATTACK_TYPE_HERO
-end
 ____exports.DamageType = {}
 local DamageType = ____exports.DamageType
 do
@@ -88,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
@@ -96,7 +89,7 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
         ranged = false
     end
     if attackType == nil then
-        attackType = ____exports.AttackType.SPELL
+        attackType = 0
     end
     if damageType == nil then
         damageType = ____exports.DamageType.MAGIC
@@ -109,13 +102,16 @@ 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,
         amount,
         attack,
         ranged,
-        attackType,
+        attackTypeToNative(attackType),
         damageType,
         weaponType
     )

package/engine/internal/unit+spellSteal.lua

@@ -6,7 +6,6 @@ local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____unit_2Bdamage = require("engine.internal.unit+damage")
-local AttackType = ____unit_2Bdamage.AttackType
 local DamageType = ____unit_2Bdamage.DamageType
 local ____event = require("event")
 local Event = ____event.Event
@@ -33,7 +32,7 @@ local spellStealEventStack = {}
 Unit.onDamaging:addListener(function(source, target, event)
     if event.amount == 0 and source ~= nil then
         local count = countByUnit[source] or 0
-        if count > 0 and event.attackType == AttackType.SPELL then
+        if count > 0 and event.attackType == 0 then
             if event.damageType == DamageType.UNKNOWN then
                 spellStealEventStack[#spellStealEventStack + 1] = {
                     sourceBuffIds = source.buffIds,

package/engine/internal/unit.d.ts

@@ -11,6 +11,10 @@ import { Ability, UnitAbility } from "./ability";
 import { Widget } from "../../core/types/widget";
 import type { UnitTypeId } from "../object-data/entry/unit-type";
 import { CombatClassification, CombatClassifications } from "../object-data/auxiliary/combat-classification";
+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;
@@ -36,13 +40,15 @@ 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: jattacktype;
+    attackType: AttackType;
     damageType: jdamagetype;
     weaponType: jweapontype;
+    metadata: unknown;
     readonly isAttack: boolean;
     readonly originalAmount: number;
+    readonly originalMetadata: unknown;
 }
 export type DamageEvent = DamagingEvent & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
@@ -161,6 +167,8 @@ export declare class Unit extends Handle<junit> {
     set level(v: number);
     get xp(): number;
     set xp(v: number);
+    get primaryAttribute(): UnitAttribute;
+    set primaryAttribute(primaryAttribute: UnitAttribute);
     get strengthBase(): number;
     set strengthBase(strengthBase: number);
     get strengthBonus(): number;
@@ -235,6 +243,8 @@ export declare class Unit extends Handle<junit> {
     set timeScale(v: number);
     get collisionSize(): number;
     get pathingCollisionRange(): number;
+    get movementType(): MovementType;
+    set movementType(movementType: MovementType);
     set pathing(v: boolean);
     isSelected(player: Player): boolean;
     explode(): void;

package/engine/internal/unit.lua

@@ -53,13 +53,17 @@ local ____math = require("math")
 local min = ____math.min
 local ____ignore_2Devents_2Ditems = require("engine.internal.unit.ignore-events-items")
 local ignoreEventsItems = ____ignore_2Devents_2Ditems.ignoreEventsItems
+local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
+local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local nativeToAttackType = ____attack_2Dtype.nativeToAttackType
+local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
+local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
+local ____attributes = require("attributes")
+local isAttribute = ____attributes.isAttribute
 local match = string.match
 local ____tostring = _G.tostring
 local setUnitAnimation = SetUnitAnimation
-local setUnitAnimationWithRarity = SetUnitAnimationWithRarity
 local setUnitAnimationByIndex = SetUnitAnimationByIndex
-local resetUnitAnimation = ResetUnitAnimation
-local queueUnitAnimation = QueueUnitAnimation
 local getUnitIntegerField = BlzGetUnitIntegerField
 local getUnitRealField = BlzGetUnitRealField
 local getHeroStr = GetHeroStr
@@ -81,7 +85,6 @@ local getHandleId = GetHandleId
 local getUnitCurrentOrder = GetUnitCurrentOrder
 local createUnit = CreateUnit
 local killUnit = KillUnit
-local setUnitExploded = SetUnitExploded
 local removeUnit = RemoveUnit
 local getUnitTypeId = GetUnitTypeId
 local isHeroUnitId = IsHeroUnitId
@@ -97,8 +100,6 @@ local getSpellTargetItem = GetSpellTargetItem
 local getSpellTargetDestructable = GetSpellTargetDestructable
 local isUnitInRangeXY = IsUnitInRangeXY
 local isUnitInRange = IsUnitInRange
-local setResourceAmount = SetResourceAmount
-local getResourceAmount = GetResourceAmount
 local getUnitWeaponRealField = BlzGetUnitWeaponRealField
 local setUnitWeaponRealField = BlzSetUnitWeaponRealField
 local getUnitWeaponStringField = BlzGetUnitWeaponStringField
@@ -129,8 +130,6 @@ local isUnitType = IsUnitType
 local isUnitAlly = IsUnitAlly
 local isUnitEnemy = IsUnitEnemy
 local getOwningPlayer = GetOwningPlayer
-local setUnitColor = SetUnitColor
-local showUnitTeamGlow = BlzShowUnitTeamGlow
 ____exports.UnitClassification = {}
 local UnitClassification = ____exports.UnitClassification
 do
@@ -358,7 +357,14 @@ local function damageEventPreventDeath(self, callback, ...)
         rawset(self, 1 + i, (select(i, ...)))
     end
 end
-local damageSetters = {amount = BlzSetEventDamage, attackType = BlzSetEventAttackType, damageType = BlzSetEventDamageType, weaponType = BlzSetEventWeaponType}
+local damageSetters = {
+    amount = BlzSetEventDamage,
+    attackType = function(attackType)
+        return BlzSetEventAttackType(attackTypeToNative(attackType))
+    end,
+    damageType = BlzSetEventDamageType,
+    weaponType = BlzSetEventWeaponType
+}
 local jlimitopByOperator = {
     [0] = LESS_THAN_OR_EQUAL,
     [1] = LESS_THAN_OR_EQUAL,
@@ -640,7 +646,8 @@ local function delayHealthChecksCallback(unit)
     end
 end
 local nextSyncId = 1
-local unitBySyncId = setmetatable({}, {__mode = "k"})
+local unitBySyncId = setmetatable({}, {__mode = "v"})
+local damagingEventByTarget = setmetatable({}, {__mode = "k"})
 ____exports.Unit = __TS__Class()
 local Unit = ____exports.Unit
 Unit.name = "Unit"
@@ -793,16 +800,16 @@ function Unit.prototype.playAnimation(self, animation, rarity)
     if type(animation) == "number" then
         setUnitAnimationByIndex(self.handle, animation)
     elseif rarity then
-        setUnitAnimationWithRarity(self.handle, animation, rarity)
+        SetUnitAnimationWithRarity(self.handle, animation, rarity)
     else
         setUnitAnimation(self.handle, animation)
     end
 end
 function Unit.prototype.resetAnimation(self)
-    resetUnitAnimation(self.handle)
+    ResetUnitAnimation(self.handle)
 end
 function Unit.prototype.queueAnimation(self, animation)
-    queueUnitAnimation(self.handle, animation)
+    QueueUnitAnimation(self.handle, animation)
 end
 function Unit.prototype.delayHealthChecks(self)
     self[103] = (self[103] or 0) + 1
@@ -815,7 +822,7 @@ function Unit.prototype.isSelected(self, player)
     return IsUnitSelected(self.handle, player.handle)
 end
 function Unit.prototype.explode(self)
-    setUnitExploded(self.handle, true)
+    SetUnitExploded(self.handle, true)
     killUnit(self.handle)
 end
 function Unit.prototype.kill(self)
@@ -1292,6 +1299,19 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Unit.prototype,
+    "primaryAttribute",
+    {
+        get = function(self)
+            return getUnitIntegerField(self.handle, UNIT_IF_PRIMARY_ATTRIBUTE)
+        end,
+        set = function(self, primaryAttribute)
+            setUnitIntegerField(self.handle, UNIT_IF_PRIMARY_ATTRIBUTE, primaryAttribute)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Unit.prototype,
     "strengthBase",
@@ -1416,7 +1436,7 @@ __TS__SetDescriptor(
             return not self[106]
         end,
         set = function(self, isTeamGlowVisible)
-            showUnitTeamGlow(self.handle, isTeamGlowVisible)
+            BlzShowUnitTeamGlow(self.handle, isTeamGlowVisible)
             local ____temp_6
             if not isTeamGlowVisible then
                 ____temp_6 = true
@@ -1432,9 +1452,9 @@ __TS__SetDescriptor(
     Unit.prototype,
     "color",
     {set = function(self, color)
-        setUnitColor(self.handle, color.handle)
+        SetUnitColor(self.handle, color.handle)
         if self[106] then
-            showUnitTeamGlow(self.handle, false)
+            BlzShowUnitTeamGlow(self.handle, false)
         end
     end},
     true
@@ -1702,10 +1722,10 @@ __TS__SetDescriptor(
     "gold",
     {
         get = function(self)
-            return getResourceAmount(self.handle)
+            return GetResourceAmount(self.handle)
         end,
         set = function(self, gold)
-            setResourceAmount(self.handle, gold)
+            SetResourceAmount(self.handle, gold)
         end
     },
     true
@@ -1833,6 +1853,19 @@ __TS__SetDescriptor(
     end},
     true
 )
+__TS__SetDescriptor(
+    Unit.prototype,
+    "movementType",
+    {
+        get = function(self)
+            return getUnitIntegerField(self.handle, UNIT_IF_MOVE_TYPE)
+        end,
+        set = function(self, movementType)
+            setUnitIntegerField(self.handle, UNIT_IF_MOVE_TYPE, movementType)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Unit.prototype,
     "pathing",
@@ -2375,13 +2408,18 @@ Unit.onDamaging = (function()
             if source and source.typeId == dummyUnitId then
                 source = nil
             end
-            local target = BlzGetEventDamageTarget()
+            local target = ____exports.Unit:of(BlzGetEventDamageTarget())
+            local metadata = damageMetadataByTarget[target]
+            damageMetadataByTarget[target] = nil
             local data = {
                 amount = GetEventDamage(),
-                attackType = BlzGetEventAttackType(),
+                attackType = nativeToAttackType(BlzGetEventAttackType()),
                 damageType = BlzGetEventDamageType(),
                 weaponType = BlzGetEventWeaponType(),
-                isAttack = BlzGetEventIsAttack()
+                metadata = metadata,
+                isAttack = BlzGetEventIsAttack(),
+                originalAmount = GetEventDamage(),
+                originalMetadata = metadata
             }
             if data.isAttack and source then
                 local weapon = BlzGetUnitWeaponBooleanField(source.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, 1) and (BlzGetUnitWeaponBooleanField(source.handle, UNIT_WEAPON_BF_ATTACKS_ENABLED, 0) and -1 or 1) or 0
@@ -2395,18 +2433,22 @@ Unit.onDamaging = (function()
                 invoke(
                     event,
                     source,
-                    ____exports.Unit:of(target),
+                    target,
                     setmetatable(
                         {},
                         {
                             __index = data,
                             __newindex = function(self, key, value)
-                                damageSetters[key](value)
+                                local damageSetter = damageSetters[key]
+                                if damageSetter ~= nil then
+                                    damageSetter(value)
+                                end
                                 data[key] = value
                             end
                         }
                     )
                 )
+                damagingEventByTarget[target] = data
                 return
             end
             BlzSetEventDamage(0)
@@ -2414,7 +2456,7 @@ Unit.onDamaging = (function()
             BlzSetEventDamageType(DAMAGE_TYPE_UNKNOWN)
             BlzSetEventWeaponType(WEAPON_TYPE_WHOKNOWS)
             local sourceOwner = source.owner.handle
-            local targetOwner = GetOwningPlayer(target)
+            local targetOwner = target.owner.handle
             if not GetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE) then
                 SetPlayerAlliance(sourceOwner, targetOwner, ALLIANCE_PASSIVE, true)
                 Timer:run(function()
@@ -2430,23 +2472,19 @@ Unit.onDamaging = (function()
             for ____, ____value in ipairs(source._attackHandlers) do
                 local condition = ____value[1]
                 local action = ____value[2]
-                if condition(
-                    source,
-                    ____exports.Unit:of(target),
-                    data
-                ) then
+                if condition(source, target, data) then
                     action(
                         source,
-                        ____exports.Unit:of(target),
+                        target,
                         setmetatable(
                             {fire = function()
                                 UnitDamageTarget(
                                     source.handle,
-                                    target,
+                                    target.handle,
                                     data.amount,
                                     true,
                                     true,
-                                    data.attackType,
+                                    attackTypeToNative(data.attackType),
                                     data.damageType,
                                     data.weaponType
                                 )
@@ -2473,26 +2511,40 @@ Unit.onDamage = __TS__New(
                 if source and source.typeId == dummyUnitId then
                     source = nil
                 end
+                local target = ____exports.Unit:of(BlzGetEventDamageTarget())
+                local damagingEvent = damagingEventByTarget[target]
+                damagingEventByTarget[target] = nil
                 local data = {
                     amount = GetEventDamage(),
-                    attackType = BlzGetEventAttackType(),
+                    attackType = nativeToAttackType(BlzGetEventAttackType()),
                     damageType = BlzGetEventDamageType(),
                     weaponType = BlzGetEventWeaponType(),
+                    metadata = damagingEvent and damagingEvent.metadata,
                     isAttack = BlzGetEventIsAttack(),
-                    originalAmount = GetEventDamage(),
+                    originalAmount = damagingEvent and damagingEvent.originalAmount or GetEventDamage(),
+                    originalMetadata = damagingEvent and damagingEvent.originalMetadata,
                     preventDeath = damageEventPreventDeath
                 }
+                if damagingEvent then
+                    for key, value in pairs(damagingEvent) do
+                        if isAttribute(key) then
+                            data[key] = value
+                        end
+                    end
+                end
                 local evData = setmetatable(
                     {},
                     {
                         __index = data,
                         __newindex = function(self, key, value)
-                            damageSetters[key](value)
+                            local damageSetter = damageSetters[key]
+                            if damageSetter ~= nil then
+                                damageSetter(value)
+                            end
                             data[key] = value
                         end
                     }
                 )
-                local target = ____exports.Unit:of(BlzGetEventDamageTarget())
                 invoke(event, source, target, evData)
                 if evData[0] ~= nil and target.health - evData.amount < 0.405 then
                     local bonusHealth = math.ceil(evData.amount)

package/engine/object-data/auxiliary/attachment-preset.d.ts

@@ -2,13 +2,18 @@
 import { ModelNodeName } from "./model-node-name";
 import { ModelNodeQualifier } from "./model-node-qualifier";
 import { Optional } from "../../../utility/types";
+import { EffectParameters } from "../../../core/types/effect";
 export type AttachmentPreset = {
     modelPath: string;
     nodeName: ModelNodeName;
     nodeQualifiers: ModelNodeQualifier[];
 };
-export type AttachmentPresetInput = Optional<AttachmentPreset, "nodeQualifiers"> | string;
-export declare const toAttachmentPreset: (attachmentPresetInput: AttachmentPresetInput) => AttachmentPreset;
+export type EffectPresetWithParameters = AttachmentPreset & {
+    parameters?: EffectParameters;
+};
+export type AttachmentPresetInput<T extends AttachmentPreset = AttachmentPreset> = Optional<T, "nodeName" | "nodeQualifiers"> | string;
+export type EffectPresetWithParametersInput = AttachmentPresetInput<EffectPresetWithParameters>;
+export declare const toEffectPreset: (effectPresetInput: EffectPresetWithParametersInput) => EffectPresetWithParameters;
 export declare const extractAttachmentPresetInputModelPath: (attachmentPresetInput: AttachmentPresetInput | undefined) => string;
 export declare const extractAttachmentPresetInputNodeFQN: (attachmentPresetInput: AttachmentPresetInput | undefined) => string;
 export declare const splitAttachmentNodeFQN: (attachmentNodeFQN: string) => LuaMultiReturn<[attachmentNodeName: ModelNodeName, attachmentNodeQualifiers: ModelNodeQualifier[]]>;