warscript 0.0.1-dev.d750e38 → 0.0.1-dev.d77b529

package/engine/object-data/entry/ability-type/berserk.lua

@@ -36,4 +36,17 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    BerserkAbilityType.prototype,
+    "receivedDamageIncreaseFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("bsk3")
+        end,
+        set = function(self, receivedDamageIncreaseFactor)
+            self:setNumberLevelField("bsk3", receivedDamageIncreaseFactor)
+        end
+    },
+    true
+)
 return ____exports

package/engine/object-data/entry/ability-type/blank-configurable.d.ts

@@ -7,11 +7,14 @@ export declare class BlankConfigurableAbilityType extends ChannelAbilityType {
     private readonly autoOrderTypeStringIdByTargetingType;
     private _usesAttackAnimation;
     private _isChanneling;
+    private _isPassive;
     constructor(object: WarObject);
     get usesAttackAnimation(): boolean;
     set usesAttackAnimation(usesAttackAnimation: boolean);
     get isChanneling(): boolean;
     set isChanneling(isChanneling: boolean);
+    get isPassive(): boolean;
+    set isPassive(isPassive: boolean);
     get targetingType(): ChannelAbilityTypeTargetingType[];
     set targetingType(targetingType: ObjectDataEntryLevelFieldValueSupplier<ChannelAbilityTypeTargetingType>);
     get baseOrderTypeStringId(): string[];

package/engine/object-data/entry/ability-type/blank-configurable.lua

@@ -6,6 +6,8 @@ local __TS__New = ____lualib.__TS__New
 local ____exports = {}
 local ____channel = require("engine.object-data.entry.ability-type.channel")
 local ChannelAbilityType = ____channel.ChannelAbilityType
+local ____animation_2Dname = require("engine.object-data.auxiliary.animation-name")
+local isAnimationName = ____animation_2Dname.isAnimationName
 local ____order_2Dtype_2Dstring_2Did_2Dfactory = require("engine.object-data.utility.order-type-string-id-factory")
 local orderTypeStringIdFactory = ____order_2Dtype_2Dstring_2Did_2Dfactory.orderTypeStringIdFactory
 local ____timer = require("core.types.timer")
@@ -21,6 +23,9 @@ local ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD = ____ability.A
 local AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD = ____ability.AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD
 local ____linked_2Dset = require("utility.linked-set")
 local LinkedSet = ____linked_2Dset.LinkedSet
+local ____pseudo_2Dpassive_2Dabilities = require("engine.internal.unit.pseudo-passive-abilities")
+local compiletimePseudoPassiveAbilityTypeIds = ____pseudo_2Dpassive_2Dabilities.compiletimePseudoPassiveAbilityTypeIds
+local pseudoPassiveAbilityOrderTypeStringId = ____pseudo_2Dpassive_2Dabilities.pseudoPassiveAbilityOrderTypeStringId
 local isChannelingAbilityTypeIds = {}
 local usesAttackAnimationByAbilityTypeId = {}
 ____exports.BlankConfigurableAbilityType = __TS__Class()
@@ -33,6 +38,7 @@ function BlankConfigurableAbilityType.prototype.____constructor(self, object)
     self.autoOrderTypeStringIdByTargetingType = {}
     self._usesAttackAnimation = false
     self._isChanneling = false
+    self._isPassive = false
     self.buttonPositionX = 0
     self.buttonPositionY = 0
     self.casterAttachmentPresets = {}
@@ -103,6 +109,24 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    BlankConfigurableAbilityType.prototype,
+    "isPassive",
+    {
+        get = function(self)
+            return self._isPassive
+        end,
+        set = function(self, isPassive)
+            if isPassive then
+                compiletimePseudoPassiveAbilityTypeIds[self.id] = true
+            else
+                compiletimePseudoPassiveAbilityTypeIds[self.id] = nil
+            end
+            self._isPassive = isPassive
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     BlankConfigurableAbilityType.prototype,
     "targetingType",
@@ -207,11 +231,28 @@ do
         end
     )
 end
+local _ = postcompile(function()
+    for abilityTypeId in pairs(compiletimePseudoPassiveAbilityTypeIds) do
+        local abilityType = checkNotNull(____exports.BlankConfigurableAbilityType:of(abilityTypeId))
+        abilityType.hotkey = ""
+        abilityType.baseOrderTypeStringId = pseudoPassiveAbilityOrderTypeStringId
+        abilityType.targetingType = 0
+    end
+end)
 for abilityTypeId, usesAttackAnimation in pairs(postcompile(function()
     for abilityTypeId, usesAttackAnimation in pairs(usesAttackAnimationByAbilityTypeId) do
         if usesAttackAnimation then
             local abilityType = checkNotNull(____exports.BlankConfigurableAbilityType:of(abilityTypeId))
-            abilityType.channelingAnimation = {"attack"}
+            if isAnimationName(abilityType.channelingAnimation[1]) then
+                if abilityType.channelingAnimation[1] ~= "attack" then
+                    abilityType.channelingAnimation = {"attack"}
+                end
+            else
+                abilityType.channelingAnimation = {
+                    "attack",
+                    table.unpack(abilityType.channelingAnimation)
+                }
+            end
         end
     end
     return usesAttackAnimationByAbilityTypeId

package/engine/object-data/entry/ability-type/carrion-swarm.d.ts

@@ -0,0 +1,14 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class CarrionSwarmAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    get damagePerTarget(): number[];
+    set damagePerTarget(damagePerTarget: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get maximumTotalDamage(): number[];
+    set maximumTotalDamage(maximumTotalDamage: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get distance(): number[];
+    set distance(distance: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get finalAreaOfEffect(): number[];
+    set finalAreaOfEffect(finalAreaOfEffect: ObjectDataEntryLevelFieldValueSupplier<number>);
+}

package/engine/object-data/entry/ability-type/carrion-swarm.lua

@@ -0,0 +1,65 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.CarrionSwarmAbilityType = __TS__Class()
+local CarrionSwarmAbilityType = ____exports.CarrionSwarmAbilityType
+CarrionSwarmAbilityType.name = "CarrionSwarmAbilityType"
+__TS__ClassExtends(CarrionSwarmAbilityType, AbilityType)
+CarrionSwarmAbilityType.BASE_ID = fourCC("AUcs")
+__TS__SetDescriptor(
+    CarrionSwarmAbilityType.prototype,
+    "damagePerTarget",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ucs1")
+        end,
+        set = function(self, damagePerTarget)
+            self:setNumberLevelField("Ucs1", damagePerTarget)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CarrionSwarmAbilityType.prototype,
+    "maximumTotalDamage",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ucs2")
+        end,
+        set = function(self, maximumTotalDamage)
+            self:setNumberLevelField("Ucs2", maximumTotalDamage)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CarrionSwarmAbilityType.prototype,
+    "distance",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ucs3")
+        end,
+        set = function(self, distance)
+            self:setNumberLevelField("Ucs3", distance)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CarrionSwarmAbilityType.prototype,
+    "finalAreaOfEffect",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ucs4")
+        end,
+        set = function(self, finalAreaOfEffect)
+            self:setNumberLevelField("Ucs4", finalAreaOfEffect)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/cleansing-fire.d.ts

@@ -0,0 +1,27 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class CleansingFireAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    /** Ally Healing Base */
+    get allyBaseHealing(): number[];
+    set allyBaseHealing(allyBaseHealing: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Ally Healing Per Debuff Removed */
+    get allyHealingPerDebuffRemoved(): number[];
+    set allyHealingPerDebuffRemoved(allyHealingPerDebuffRemoved: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Ally Buff Duration */
+    get allyBuffDuration(): number[];
+    set allyBuffDuration(allyBuffDuration: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Ally Damage Bonus Percent Base */
+    get allyBaseDamageBonusPercentage(): number[];
+    set allyBaseDamageBonusPercentage(allyBaseDamageBonusPercentage: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Ally Damage Bonus Percent Per Debuff Removed */
+    get allyDamageBonusPercentagePerDebuffRemoved(): number[];
+    set allyDamageBonusPercentagePerDebuffRemoved(allyDamageBonusPercentagePerDebuffRemoved: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Enemy Stun Duration */
+    get enemyStunDuration(): number[];
+    set enemyStunDuration(enemyStunDuration: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Summoned Damage */
+    get summonedDamage(): number[];
+    set summonedDamage(summonedDamage: ObjectDataEntryLevelFieldValueSupplier<number>);
+}

package/engine/object-data/entry/ability-type/cleansing-fire.lua

@@ -0,0 +1,104 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.CleansingFireAbilityType = __TS__Class()
+local CleansingFireAbilityType = ____exports.CleansingFireAbilityType
+CleansingFireAbilityType.name = "CleansingFireAbilityType"
+__TS__ClassExtends(CleansingFireAbilityType, AbilityType)
+CleansingFireAbilityType.BASE_ID = fourCC("AHcl")
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "allyBaseHealing",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl1")
+        end,
+        set = function(self, allyBaseHealing)
+            self:setNumberLevelField("hcl1", allyBaseHealing)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "allyHealingPerDebuffRemoved",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl2")
+        end,
+        set = function(self, allyHealingPerDebuffRemoved)
+            self:setNumberLevelField("hcl2", allyHealingPerDebuffRemoved)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "allyBuffDuration",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl3")
+        end,
+        set = function(self, allyBuffDuration)
+            self:setNumberLevelField("hcl3", allyBuffDuration)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "allyBaseDamageBonusPercentage",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl4")
+        end,
+        set = function(self, allyBaseDamageBonusPercentage)
+            self:setNumberLevelField("hcl4", allyBaseDamageBonusPercentage)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "allyDamageBonusPercentagePerDebuffRemoved",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl5")
+        end,
+        set = function(self, allyDamageBonusPercentagePerDebuffRemoved)
+            self:setNumberLevelField("hcl5", allyDamageBonusPercentagePerDebuffRemoved)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "enemyStunDuration",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl6")
+        end,
+        set = function(self, enemyStunDuration)
+            self:setNumberLevelField("hcl6", enemyStunDuration)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CleansingFireAbilityType.prototype,
+    "summonedDamage",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcl7")
+        end,
+        set = function(self, summonedDamage)
+            self:setNumberLevelField("hcl7", summonedDamage)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/consecration.d.ts

@@ -0,0 +1,15 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class ConsecrationAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    /** Ally Healing Per Second */
+    get allyHealingPerSecond(): number[];
+    set allyHealingPerSecond(allyHealingPerSecond: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Enemy Damage Per Second */
+    get enemyDamagePerSecond(): number[];
+    set enemyDamagePerSecond(enemyDamagePerSecond: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Enemy Healing Reduction Percent */
+    get enemyHealingReductionPercentage(): number[];
+    set enemyHealingReductionPercentage(enemyHealingReductionPercentage: ObjectDataEntryLevelFieldValueSupplier<number>);
+}

package/engine/object-data/entry/ability-type/consecration.lua

@@ -0,0 +1,52 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.ConsecrationAbilityType = __TS__Class()
+local ConsecrationAbilityType = ____exports.ConsecrationAbilityType
+ConsecrationAbilityType.name = "ConsecrationAbilityType"
+__TS__ClassExtends(ConsecrationAbilityType, AbilityType)
+ConsecrationAbilityType.BASE_ID = fourCC("AHcr")
+__TS__SetDescriptor(
+    ConsecrationAbilityType.prototype,
+    "allyHealingPerSecond",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcr1")
+        end,
+        set = function(self, allyHealingPerSecond)
+            self:setNumberLevelField("hcr1", allyHealingPerSecond)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ConsecrationAbilityType.prototype,
+    "enemyDamagePerSecond",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcr2")
+        end,
+        set = function(self, enemyDamagePerSecond)
+            self:setNumberLevelField("hcr2", enemyDamagePerSecond)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    ConsecrationAbilityType.prototype,
+    "enemyHealingReductionPercentage",
+    {
+        get = function(self)
+            return self:getNumberLevelField("hcr3")
+        end,
+        set = function(self, enemyHealingReductionPercentage)
+            self:setNumberLevelField("hcr3", enemyHealingReductionPercentage)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/cooldown-reduction.d.ts

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class CooldownReductionAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    /** Cooldown Reduction */
+    get cooldownReduction(): number[];
+    set cooldownReduction(cooldownReduction: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Flat Bonus */
+    get isFlatBonus(): boolean[];
+    set isFlatBonus(isFlatBonus: ObjectDataEntryLevelFieldValueSupplier<boolean>);
+}

package/engine/object-data/entry/ability-type/cooldown-reduction.lua

@@ -0,0 +1,39 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.CooldownReductionAbilityType = __TS__Class()
+local CooldownReductionAbilityType = ____exports.CooldownReductionAbilityType
+CooldownReductionAbilityType.name = "CooldownReductionAbilityType"
+__TS__ClassExtends(CooldownReductionAbilityType, AbilityType)
+CooldownReductionAbilityType.BASE_ID = fourCC("AIcr")
+__TS__SetDescriptor(
+    CooldownReductionAbilityType.prototype,
+    "cooldownReduction",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Icr1")
+        end,
+        set = function(self, cooldownReduction)
+            self:setNumberLevelField("Icr1", cooldownReduction)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CooldownReductionAbilityType.prototype,
+    "isFlatBonus",
+    {
+        get = function(self)
+            return self:getBooleanLevelField("Icr2")
+        end,
+        set = function(self, isFlatBonus)
+            self:setBooleanLevelField("Icr2", isFlatBonus)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/critical-strike-system.d.ts

@@ -0,0 +1,18 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class CriticalStrikeSystemAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    /** Chance to Critical Strike */
+    get criticalStrikePercentageProbability(): number[];
+    set criticalStrikePercentageProbability(criticalStrikePercentageProbability: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Damage Multiplier */
+    get damageFactor(): number[];
+    set damageFactor(damageFactor: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Chance to Evade */
+    get evasionProbability(): number[];
+    set evasionProbability(evasionProbability: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Exclude Item Damage */
+    get shouldExcludeItemDamage(): boolean[];
+    set shouldExcludeItemDamage(shouldExcludeItemDamage: ObjectDataEntryLevelFieldValueSupplier<boolean>);
+}

package/engine/object-data/entry/ability-type/critical-strike-system.lua

@@ -0,0 +1,65 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.CriticalStrikeSystemAbilityType = __TS__Class()
+local CriticalStrikeSystemAbilityType = ____exports.CriticalStrikeSystemAbilityType
+CriticalStrikeSystemAbilityType.name = "CriticalStrikeSystemAbilityType"
+__TS__ClassExtends(CriticalStrikeSystemAbilityType, AbilityType)
+CriticalStrikeSystemAbilityType.BASE_ID = fourCC("AIxr")
+__TS__SetDescriptor(
+    CriticalStrikeSystemAbilityType.prototype,
+    "criticalStrikePercentageProbability",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ocr1")
+        end,
+        set = function(self, criticalStrikePercentageProbability)
+            self:setNumberLevelField("Ocr1", criticalStrikePercentageProbability)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CriticalStrikeSystemAbilityType.prototype,
+    "damageFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ixr2")
+        end,
+        set = function(self, damageFactor)
+            self:setNumberLevelField("Ixr2", damageFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CriticalStrikeSystemAbilityType.prototype,
+    "evasionProbability",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ixr3")
+        end,
+        set = function(self, evasionProbability)
+            self:setNumberLevelField("Ixr3", evasionProbability)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    CriticalStrikeSystemAbilityType.prototype,
+    "shouldExcludeItemDamage",
+    {
+        get = function(self)
+            return self:getBooleanLevelField("Ixr4")
+        end,
+        set = function(self, shouldExcludeItemDamage)
+            self:setBooleanLevelField("Ixr4", shouldExcludeItemDamage)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/deathseeker-arrows.d.ts

@@ -0,0 +1,21 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class DeathseekerArrowsAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    /** Flat Damage */
+    get flatDamage(): number[];
+    set flatDamage(flatDamage: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Percent Damage */
+    get damagePercentage(): number[];
+    set damagePercentage(damagePercentage: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Stacks Required */
+    get stacksRequired(): number[];
+    set stacksRequired(stacksRequired: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Bonus Attack Speed per Attack */
+    get bonusAttackSpeedPerAttack(): number[];
+    set bonusAttackSpeedPerAttack(bonusAttackSpeedPerAttack: ObjectDataEntryLevelFieldValueSupplier<number>);
+    /** Max Attack Speed Stacks */
+    get maximumAttackSpeedStacks(): number[];
+    set maximumAttackSpeedStacks(maximumAttackSpeedStacks: ObjectDataEntryLevelFieldValueSupplier<number>);
+}

package/engine/object-data/entry/ability-type/deathseeker-arrows.lua

@@ -0,0 +1,78 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____ability_2Dtype = require("engine.object-data.entry.ability-type")
+local AbilityType = ____ability_2Dtype.AbilityType
+____exports.DeathseekerArrowsAbilityType = __TS__Class()
+local DeathseekerArrowsAbilityType = ____exports.DeathseekerArrowsAbilityType
+DeathseekerArrowsAbilityType.name = "DeathseekerArrowsAbilityType"
+__TS__ClassExtends(DeathseekerArrowsAbilityType, AbilityType)
+DeathseekerArrowsAbilityType.BASE_ID = fourCC("AUdb")
+__TS__SetDescriptor(
+    DeathseekerArrowsAbilityType.prototype,
+    "flatDamage",
+    {
+        get = function(self)
+            return self:getNumberLevelField("udb1")
+        end,
+        set = function(self, flatDamage)
+            self:setNumberLevelField("udb1", flatDamage)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    DeathseekerArrowsAbilityType.prototype,
+    "damagePercentage",
+    {
+        get = function(self)
+            return self:getNumberLevelField("udb2")
+        end,
+        set = function(self, damagePercentage)
+            self:setNumberLevelField("udb2", damagePercentage)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    DeathseekerArrowsAbilityType.prototype,
+    "stacksRequired",
+    {
+        get = function(self)
+            return self:getNumberLevelField("udb3")
+        end,
+        set = function(self, stacksRequired)
+            self:setNumberLevelField("udb3", stacksRequired)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    DeathseekerArrowsAbilityType.prototype,
+    "bonusAttackSpeedPerAttack",
+    {
+        get = function(self)
+            return self:getNumberLevelField("udb4")
+        end,
+        set = function(self, bonusAttackSpeedPerAttack)
+            self:setNumberLevelField("udb4", bonusAttackSpeedPerAttack)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    DeathseekerArrowsAbilityType.prototype,
+    "maximumAttackSpeedStacks",
+    {
+        get = function(self)
+            return self:getNumberLevelField("udb5")
+        end,
+        set = function(self, maximumAttackSpeedStacks)
+            self:setNumberLevelField("udb5", maximumAttackSpeedStacks)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/disease-cloud.lua

@@ -54,10 +54,10 @@ __TS__SetDescriptor(
     "plagueWardUnitTypeId",
     {
         get = function(self)
-            return self:getObjectDataEntryIdLevelField("Aplu")
+            return self:getObjectDataEntryNumericIdLevelField("Aplu")
         end,
         set = function(self, plagueWardUnitTypeId)
-            self:setObjectDataEntryIdLevelField("Aplu", plagueWardUnitTypeId)
+            self:setObjectDataEntryNumericIdLevelField("Aplu", plagueWardUnitTypeId)
         end
     },
     true

package/engine/object-data/entry/ability-type/engineering-upgrade.lua

@@ -55,7 +55,7 @@ __TS__SetDescriptor(
         get = function(self)
             local abilityUpgrades = {}
             for i = 0, 3 do
-                local abilityUpgrade = self:getObjectDataEntryIdsLevelField("Neg" .. tostring(3 + i))
+                local abilityUpgrade = self:getObjectDataEntryNumericIdsLevelField("Neg" .. tostring(3 + i))
                 for level = 0, #abilityUpgrade - 1 do
                     local levelAbilityUpgrade = abilityUpgrade[level + 1]
                     if #levelAbilityUpgrade == 2 then
@@ -71,7 +71,7 @@ __TS__SetDescriptor(
             local ____opt_0 = abilityUpgrades[1]
             local isArray = __TS__ArrayIsArray(____opt_0 and ____opt_0[1])
             for i = 0, #abilityUpgrades - 1 do
-                self:setObjectDataEntryIdsLevelField(
+                self:setObjectDataEntryNumericIdsLevelField(
                     "Neg" .. tostring(3 + i),
                     isArray and map(
                         abilityUpgrades,