warscript 0.0.1-dev.ec4cf89 → 0.0.1-dev.f967846

package/engine/buff.lua

@@ -94,6 +94,7 @@ local buffParametersKeys = {
     armorIncreaseFactor = true,
     attackSpeedIncreaseFactor = true,
     movementSpeedIncreaseFactor = true,
+    damageFactor = true,
     receivedDamageFactor = true,
     receivedMagicDamageFactor = true,
     durationIncreaseOnAutoAttack = true,
@@ -107,12 +108,26 @@ local buffParametersKeys = {
     disablesAutoAttack = true,
     destroysOnDamage = true,
     maximumAutoAttackCount = true,
+    maximumDamageDealtEventCount = true,
+    maximumDamageReceivedEventCount = true,
     uniqueGroup = true,
     damageOnExpiration = true,
     healingOnExpiration = true,
     killsOnExpiration = true,
     explodesOnExpiration = true
 }
+local function resolveEnumValue(ability, level, value)
+    if value == nil or type(value) == "number" then
+        return value
+    end
+    if ability == nil then
+        error(
+            __TS__New(IllegalArgumentException),
+            0
+        )
+    end
+    return value:getValue(ability, level or ability.level)
+end
 local function resolveNumberValue(ability, level, value)
     if value == nil or type(value) == "number" then
         return value
@@ -162,8 +177,11 @@ local buffNumberParameters = {
     "attackSpeedIncreaseFactor",
     "movementSpeedIncreaseFactor",
     "armorIncrease",
+    "damageFactor",
     "receivedDamageFactor",
     "maximumAutoAttackCount",
+    "maximumDamageDealtEventCount",
+    "maximumDamageReceivedEventCount",
     "damageInterval",
     "damagePerInterval",
     "damageOverDuration",
@@ -310,8 +328,6 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
         end
     end
     self.typeId = typeId
-    self.polarity = polarity
-    self.resistanceType = resistanceType
     if not __TS__InstanceOf(ability, Ability) then
         parameters = ability
         ability = nil
@@ -338,6 +354,8 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
         learnLevelMinimum = learnLevelMinimum or ability:getField(ABILITY_IF_REQUIRED_LEVEL)
         duration = duration or getAbilityDuration(ability, _unit)
     end
+    self.polarity = resolveEnumValue(ability, level, polarity)
+    self.resistanceType = resolveEnumValue(ability, level, resistanceType)
     local buffByTypeId = buffByTypeIdByUnit[_unit]
     if buffByTypeId == nil then
         buffByTypeId = {}
@@ -354,8 +372,8 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
     if not internalApplyBuff(
         _unit,
         typeId,
-        polarity,
-        resistanceType,
+        self.polarity,
+        self.resistanceType,
         level,
         duration,
         spellStealPriority,
@@ -544,11 +562,11 @@ function Buff.prototype.onDestroy(self)
             behavior:destroy()
         end
     end
-    if self[132] then
+    if self[136] then
         unit:decrementDisableAutoAttackCounter()
     end
-    if self[130] then
-        if self[131] then
+    if self[134] then
+        if self[135] then
             unit:decrementStunCounter()
         end
         unit:decrementStunCounter()
@@ -605,9 +623,9 @@ function Buff.prototype.onExpiration(self)
     if self[120] ~= nil then
         (self[101] or unit):healTarget(unit, self[119] or 0)
     end
-    if self[135] then
+    if self[139] then
         unit:explode()
-    elseif self[134] then
+    elseif self[138] then
         unit:kill()
     end
 end
@@ -652,6 +670,22 @@ function Buff.prototype.onDamageDealt(self, target, event)
             self:destroy()
         end
     end
+    if event.originalAmount ~= 0 then
+        local damageDealtEventCount = (self[130] or 0) + 1
+        self[130] = damageDealtEventCount
+        if damageDealtEventCount == self[131] then
+            self:destroy()
+        end
+    end
+end
+function Buff.prototype.onDamageReceived(self, source, event)
+    if event.originalAmount ~= 0 then
+        local damageReceivedEventCount = (self[132] or 0) + 1
+        self[132] = damageReceivedEventCount
+        if damageReceivedEventCount == self[133] then
+            self:destroy()
+        end
+    end
 end
 Buff.defaultParameters = {}
 __TS__SetDescriptor(
@@ -856,6 +890,19 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damageFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.DAMAGE_FACTOR)
+        end,
+        set = function(self, damageFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.DAMAGE_FACTOR, damageFactor)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Buff.prototype,
     "receivedDamageFactor",
@@ -887,25 +934,25 @@ __TS__SetDescriptor(
     "stuns",
     {
         get = function(self)
-            local ____self__130_52 = self[130]
-            if ____self__130_52 == nil then
-                ____self__130_52 = false
+            local ____self__134_52 = self[134]
+            if ____self__134_52 == nil then
+                ____self__134_52 = false
             end
-            return ____self__130_52
+            return ____self__134_52
         end,
         set = function(self, stuns)
-            if not stuns and self[130] then
-                if self[131] then
+            if not stuns and self[134] then
+                if self[135] then
                     self.object:decrementStunCounter()
                 end
                 self.object:decrementStunCounter()
-                self[130] = nil
-            elseif stuns and not self[130] then
-                if self[131] then
+                self[134] = nil
+            elseif stuns and not self[134] then
+                if self[135] then
                     self.object:incrementStunCounter()
                 end
                 self.object:incrementStunCounter()
-                self[130] = true
+                self[134] = true
             end
         end
     },
@@ -916,23 +963,23 @@ __TS__SetDescriptor(
     "ignoresStunImmunity",
     {
         get = function(self)
-            local ____self__131_53 = self[131]
-            if ____self__131_53 == nil then
-                ____self__131_53 = false
+            local ____self__135_53 = self[135]
+            if ____self__135_53 == nil then
+                ____self__135_53 = false
             end
-            return ____self__131_53
+            return ____self__135_53
         end,
         set = function(self, ignoresStunImmunity)
-            if not ignoresStunImmunity and self[131] then
-                if self[130] then
+            if not ignoresStunImmunity and self[135] then
+                if self[134] then
                     self.object:decrementStunCounter()
                 end
-                self[131] = nil
-            elseif ignoresStunImmunity and not self[131] then
-                if self[130] then
+                self[135] = nil
+            elseif ignoresStunImmunity and not self[135] then
+                if self[134] then
                     self.object:incrementStunCounter()
                 end
-                self[131] = true
+                self[135] = true
             end
         end
     },
@@ -943,19 +990,19 @@ __TS__SetDescriptor(
     "disablesAutoAttack",
     {
         get = function(self)
-            local ____self__132_54 = self[132]
-            if ____self__132_54 == nil then
-                ____self__132_54 = false
+            local ____self__136_54 = self[136]
+            if ____self__136_54 == nil then
+                ____self__136_54 = false
             end
-            return ____self__132_54
+            return ____self__136_54
         end,
         set = function(self, disablesAutoAttack)
-            if not disablesAutoAttack and self[132] then
+            if not disablesAutoAttack and self[136] then
                 self.object:decrementDisableAutoAttackCounter()
-                self[132] = nil
-            elseif disablesAutoAttack and not self[132] then
+                self[136] = nil
+            elseif disablesAutoAttack and not self[136] then
                 self.object:incrementDisableAutoAttackCounter()
-                self[132] = true
+                self[136] = true
             end
         end
     },
@@ -966,19 +1013,19 @@ __TS__SetDescriptor(
     "providesInvulnerability",
     {
         get = function(self)
-            local ____self__133_55 = self[133]
-            if ____self__133_55 == nil then
-                ____self__133_55 = false
+            local ____self__137_55 = self[137]
+            if ____self__137_55 == nil then
+                ____self__137_55 = false
             end
-            return ____self__133_55
+            return ____self__137_55
         end,
         set = function(self, providesInvulnerability)
-            if not providesInvulnerability and self[133] then
+            if not providesInvulnerability and self[137] then
                 self.object:decrementInvulnerabilityCounter()
-                self[133] = nil
-            elseif providesInvulnerability and not self[133] then
+                self[137] = nil
+            elseif providesInvulnerability and not self[137] then
                 self.object:incrementInvulnerabilityCounter()
-                self[133] = true
+                self[137] = true
             end
         end
     },
@@ -989,17 +1036,17 @@ __TS__SetDescriptor(
     "killsOnExpiration",
     {
         get = function(self)
-            local ____self__134_56 = self[134]
-            if ____self__134_56 == nil then
-                ____self__134_56 = false
+            local ____self__138_56 = self[138]
+            if ____self__138_56 == nil then
+                ____self__138_56 = false
             end
-            return ____self__134_56
+            return ____self__138_56
         end,
         set = function(self, killsOnExpiration)
-            if not killsOnExpiration and self[134] then
-                self[134] = nil
-            elseif killsOnExpiration and not self[134] then
-                self[134] = true
+            if not killsOnExpiration and self[138] then
+                self[138] = nil
+            elseif killsOnExpiration and not self[138] then
+                self[138] = true
             end
         end
     },
@@ -1010,17 +1057,51 @@ __TS__SetDescriptor(
     "explodesOnExpiration",
     {
         get = function(self)
-            local ____self__135_57 = self[135]
-            if ____self__135_57 == nil then
-                ____self__135_57 = false
+            local ____self__139_57 = self[139]
+            if ____self__139_57 == nil then
+                ____self__139_57 = false
             end
-            return ____self__135_57
+            return ____self__139_57
         end,
         set = function(self, killsOnExpiration)
-            if not killsOnExpiration and self[135] then
-                self[135] = nil
-            elseif killsOnExpiration and not self[135] then
-                self[135] = true
+            if not killsOnExpiration and self[139] then
+                self[139] = nil
+            elseif killsOnExpiration and not self[139] then
+                self[139] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maximumDamageDealtEventCount",
+    {
+        get = function(self)
+            return self[131] or 0
+        end,
+        set = function(self, maximumDamageDealtEventCount)
+            if maximumDamageDealtEventCount == 0 then
+                self[131] = nil
+            else
+                self[131] = maximumDamageDealtEventCount
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maximumDamageReceivedEventCount",
+    {
+        get = function(self)
+            return self[133] or 0
+        end,
+        set = function(self, maximumDamageReceivedEventCount)
+            if maximumDamageReceivedEventCount == 0 then
+                self[133] = nil
+            else
+                self[133] = maximumDamageReceivedEventCount
             end
         end
     },

package/engine/internal/ability.d.ts

@@ -4,14 +4,6 @@ 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>;
-}
 export type jabilityfield = jabilityintegerfield | jabilityrealfield | jabilitybooleanfield | jabilitystringfield | jabilityintegerlevelfield | jabilityreallevelfield | jabilitybooleanlevelfield | jabilitystringlevelfield;
 export declare class AbilitySnapshot {
 }
@@ -40,8 +32,7 @@ export declare abstract class Ability extends Handle<jability> {
     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[];
+    get levelCount(): number;
     abstract get level(): number;
     static get onCreate(): Event<[Ability]>;
     static get destroyEvent(): Event<[Ability]>;
@@ -58,6 +49,8 @@ export declare class UnitAbility extends Ability {
     readonly owner: Unit;
     private readonly u;
     constructor(handle: jability, typeId: number, owner: Unit);
+    incrementHideCounter(): void;
+    decrementHideCounter(): void;
     get level(): number;
     set level(v: number);
     get cooldownRemaining(): number;
@@ -88,4 +81,3 @@ export declare class ItemAbility extends Ability {
     static get onCreate(): Event<[ItemAbility]>;
     static get onDestroy(): Event<[ItemAbility]>;
 }
-export {};

package/engine/internal/ability.lua

@@ -2,7 +2,6 @@ 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
@@ -33,7 +32,7 @@ local getAbilityStringLevelField = BlzGetAbilityStringLevelField
 local getUnitAbilityCooldownRemaining = BlzGetUnitAbilityCooldownRemaining
 local startUnitAbilityCooldown = BlzStartUnitAbilityCooldown
 local getHandleId = GetHandleId
-local getItemAbility = BlzGetItemAbility
+local unitHideAbility = BlzUnitHideAbility
 local match = string.match
 local ____type = _G.type
 local ____tostring = _G.tostring
@@ -151,55 +150,6 @@ local orders = postcompile(function()
     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)
@@ -355,34 +305,9 @@ __TS__SetDescriptor(
 )
 __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",
+    "levelCount",
     {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
+        return self:getField(ABILITY_IF_LEVELS)
     end},
     true
 )
@@ -433,6 +358,12 @@ function UnitAbility.prototype.____constructor(self, handle, typeId, owner)
     self.owner = owner
     self.u = owner.handle
 end
+function UnitAbility.prototype.incrementHideCounter(self)
+    unitHideAbility(self.u, self.typeId, true)
+end
+function UnitAbility.prototype.decrementHideCounter(self)
+    unitHideAbility(self.u, self.typeId, false)
+end
 __TS__SetDescriptor(
     UnitAbility.prototype,
     "level",

package/engine/internal/item+owner.lua

@@ -6,10 +6,10 @@ 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)
+Unit.itemPickedUpEvent:addListener(function(unit, item)
     ownerByItem[item] = unit
 end)
-Unit.onItemDrop:addListener(function(unit, item)
+Unit.itemDroppedEvent:addListener(function(unit, item)
     ownerByItem[item] = nil
 end)
 __TS__ObjectDefineProperty(

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

@@ -8,7 +8,8 @@ export type UnitBonusId<Brand extends string = any> = number & {
 export type UnitArmorBonusId = UnitBonusId<"armor">;
 export type UnitAttackSpeedFactorBonusId = UnitBonusId<"attackSpeedFactor">;
 export type UnitMovementSpeedFactorBonusId = UnitBonusId<"movementSpeedFactor">;
-export type UnitDamageBonusId = UnitBonusId<"damage">;
+export type UnitAutoAttackDamageBonusId = UnitBonusId<"autoAttackDamage">;
+export type UnitDamageFactorBonusId = UnitBonusId<"damageFactor">;
 export type UnitReceivedDamageFactorBonusId = UnitBonusId<"receivedDamageFactor">;
 export type UnitBonusType<Id extends UnitBonusId = UnitBonusId> = ({
     abilityTypeId: AbilityTypeId;
@@ -30,7 +31,8 @@ export declare namespace UnitBonusType {
     const ARMOR: UnitBonusType<UnitArmorBonusId>;
     const ATTACK_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
     const MOVEMENT_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
-    const DAMAGE: UnitBonusType<UnitDamageBonusId>;
+    const AUTO_ATTACK_DAMAGE: UnitBonusType<UnitAutoAttackDamageBonusId>;
+    const DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
     const RECEIVED_DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
 }
 export declare const addUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, value: number) => Id;

package/engine/internal/unit/bonus.lua

@@ -21,6 +21,7 @@ local AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID = ____auto_2Dattack_2Dda
 local ____movement_2Dspeed_2Dincrease_2Dfactor = require("engine.internal.object-data.movement-speed-increase-factor")
 local MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD
 local MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID
+local damageFactorByUnit = {}
 local receivedDamageFactorByUnit = {}
 ____exports.UnitBonusType = {}
 local UnitBonusType = ____exports.UnitBonusType
@@ -46,13 +47,14 @@ do
         reduce = sum,
         initialValue = 0
     }
-    UnitBonusType.DAMAGE = {
+    UnitBonusType.AUTO_ATTACK_DAMAGE = {
         abilityTypeId = AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID,
         field = AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD,
         integer = false,
         reduce = sum,
         initialValue = 0
     }
+    UnitBonusType.DAMAGE_FACTOR = {reduce = product, valueByUnit = damageFactorByUnit, initialValue = 1}
     UnitBonusType.RECEIVED_DAMAGE_FACTOR = {reduce = product, valueByUnit = receivedDamageFactorByUnit, initialValue = 1}
 end
 local bonusesByUnitByBonusType = {}
@@ -180,6 +182,9 @@ end
 Unit.onDamage:addListener(
     4,
     function(source, target, event)
+        if source ~= nil and damageFactorByUnit[source] ~= nil then
+            event.amount = event.amount * damageFactorByUnit[source]
+        end
         if receivedDamageFactorByUnit[target] ~= nil then
             event.amount = event.amount * receivedDamageFactorByUnit[target]
         end

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

@@ -0,0 +1,24 @@
+/** @noSelfInFile */
+import { Item } from "../item";
+export interface UnitItems extends ReadonlyArray<Item | undefined> {
+    readonly length: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    [0]: Item | undefined;
+    [1]: Item | undefined;
+    [2]: Item | undefined;
+    [3]: Item | undefined;
+    [4]: Item | undefined;
+    [5]: Item | undefined;
+}
+export declare class UnitItems {
+    constructor(handle: junit);
+    findSlot(item: Item): 0 | 1 | 2 | 3 | 4 | 5 | undefined;
+    protected __newindex(slot: number, item: Item | undefined): void;
+    protected __index(key: string | number): unknown;
+    protected __len(): number;
+    protected __ipairs(): LuaIterator<LuaMultiReturn<[number, Item | undefined]>, junit>;
+}
+declare module "../unit" {
+    interface Unit {
+        readonly items: UnitItems;
+    }
+}