warscript 0.0.1-dev.404878c

package/engine/object-data/entry/ability-type/auto-attack-damage-increase.lua

@@ -0,0 +1,26 @@
+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.DamageIncreaseAbilityType = __TS__Class()
+local DamageIncreaseAbilityType = ____exports.DamageIncreaseAbilityType
+DamageIncreaseAbilityType.name = "DamageIncreaseAbilityType"
+__TS__ClassExtends(DamageIncreaseAbilityType, AbilityType)
+DamageIncreaseAbilityType.BASE_ID = fourCC("AItg")
+__TS__SetDescriptor(
+    DamageIncreaseAbilityType.prototype,
+    "autoAttackDamageIncrease",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Iatt")
+        end,
+        set = function(self, autoAttackDamageIncrease)
+            self:setNumberLevelField("Iatt", autoAttackDamageIncrease)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/auto-attack-heal-reduction-effect.d.ts

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class AutoAttackHealReductionEffectAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    get healingFactor(): number[];
+    set healingFactor(healingFactor: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get autoAttackDamageIncrease(): number[];
+    set autoAttackDamageIncrease(autoAttackDamageIncrease: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get enabledWeaponIndex(): number[];
+    set enabledWeaponIndex(enabledWeaponIndex: ObjectDataEntryLevelFieldValueSupplier<number>);
+}

package/engine/object-data/entry/ability-type/auto-attack-heal-reduction-effect.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.AutoAttackHealReductionEffectAbilityType = __TS__Class()
+local AutoAttackHealReductionEffectAbilityType = ____exports.AutoAttackHealReductionEffectAbilityType
+AutoAttackHealReductionEffectAbilityType.name = "AutoAttackHealReductionEffectAbilityType"
+__TS__ClassExtends(AutoAttackHealReductionEffectAbilityType, AbilityType)
+AutoAttackHealReductionEffectAbilityType.BASE_ID = fourCC("AIf2")
+__TS__SetDescriptor(
+    AutoAttackHealReductionEffectAbilityType.prototype,
+    "healingFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Iofr")
+        end,
+        set = function(self, healingFactor)
+            self:setNumberLevelField("Iofr", healingFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    AutoAttackHealReductionEffectAbilityType.prototype,
+    "autoAttackDamageIncrease",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Idam")
+        end,
+        set = function(self, autoAttackDamageIncrease)
+            self:setNumberLevelField("Idam", autoAttackDamageIncrease)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    AutoAttackHealReductionEffectAbilityType.prototype,
+    "enabledWeaponIndex",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Iob5")
+        end,
+        set = function(self, enabledWeaponIndex)
+            self:setNumberLevelField("Iob5", enabledWeaponIndex)
+        end
+    },
+    true
+)
+return ____exports

package/engine/object-data/entry/ability-type/auto-attack-speed-increase.d.ts

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

package/engine/object-data/entry/ability-type/auto-attack-speed-increase.lua

@@ -0,0 +1,26 @@
+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.AutoAttackSpeedIncreaseAbilityType = __TS__Class()
+local AutoAttackSpeedIncreaseAbilityType = ____exports.AutoAttackSpeedIncreaseAbilityType
+AutoAttackSpeedIncreaseAbilityType.name = "AutoAttackSpeedIncreaseAbilityType"
+__TS__ClassExtends(AutoAttackSpeedIncreaseAbilityType, AbilityType)
+AutoAttackSpeedIncreaseAbilityType.BASE_ID = fourCC("AIsx")
+__TS__SetDescriptor(
+    AutoAttackSpeedIncreaseAbilityType.prototype,
+    "autoAttackSpeedIncreaseFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Isx1")
+        end,
+        set = function(self, autoAttackSpeedIncreaseFactor)
+            self:setNumberLevelField("Isx1", autoAttackSpeedIncreaseFactor)
+        end
+    },
+    true
+)
+return ____exports

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

@@ -0,0 +1,16 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class BashAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    get bashPercentageProbability(): number[];
+    set bashPercentageProbability(bashPercentageProbability: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get damageFactor(): number[];
+    set damageFactor(damageFactor: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get damageIncrease(): number[];
+    set damageIncrease(damageIncrease: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get evasionProbability(): number[];
+    set evasionProbability(evasionProbability: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get shouldNeverMiss(): boolean[];
+    set shouldNeverMiss(shouldNeverMiss: ObjectDataEntryLevelFieldValueSupplier<boolean>);
+}

package/engine/object-data/entry/ability-type/bash.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.BashAbilityType = __TS__Class()
+local BashAbilityType = ____exports.BashAbilityType
+BashAbilityType.name = "BashAbilityType"
+__TS__ClassExtends(BashAbilityType, AbilityType)
+BashAbilityType.BASE_ID = fourCC("AHbh")
+__TS__SetDescriptor(
+    BashAbilityType.prototype,
+    "bashPercentageProbability",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Hbh1")
+        end,
+        set = function(self, bashPercentageProbability)
+            self:setNumberLevelField("Hbh1", bashPercentageProbability)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BashAbilityType.prototype,
+    "damageFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Hbh2")
+        end,
+        set = function(self, damageFactor)
+            self:setNumberLevelField("Hbh2", damageFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BashAbilityType.prototype,
+    "damageIncrease",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Hbh3")
+        end,
+        set = function(self, damageIncrease)
+            self:setNumberLevelField("Hbh3", damageIncrease)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BashAbilityType.prototype,
+    "evasionProbability",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Hbh4")
+        end,
+        set = function(self, evasionProbability)
+            self:setNumberLevelField("Hbh4", evasionProbability)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BashAbilityType.prototype,
+    "shouldNeverMiss",
+    {
+        get = function(self)
+            return self:getBooleanLevelField("Hbh5")
+        end,
+        set = function(self, shouldNeverMiss)
+            self:setBooleanLevelField("Hbh5", shouldNeverMiss)
+        end
+    },
+    true
+)
+return ____exports

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

@@ -0,0 +1,10 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class BerserkAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    get movementSpeedIncreaseFactor(): number[];
+    set movementSpeedIncreaseFactor(movementSpeedIncreaseFactor: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get attackSpeedIncreaseFactor(): number[];
+    set attackSpeedIncreaseFactor(attackSpeedIncreaseFactor: ObjectDataEntryLevelFieldValueSupplier<number>);
+}

package/engine/object-data/entry/ability-type/berserk.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.BerserkAbilityType = __TS__Class()
+local BerserkAbilityType = ____exports.BerserkAbilityType
+BerserkAbilityType.name = "BerserkAbilityType"
+__TS__ClassExtends(BerserkAbilityType, AbilityType)
+BerserkAbilityType.BASE_ID = fourCC("Absk")
+__TS__SetDescriptor(
+    BerserkAbilityType.prototype,
+    "movementSpeedIncreaseFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("bsk1")
+        end,
+        set = function(self, movementSpeedIncreaseFactor)
+            self:setNumberLevelField("bsk1", movementSpeedIncreaseFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BerserkAbilityType.prototype,
+    "attackSpeedIncreaseFactor",
+    {
+        get = function(self)
+            return self:getNumberLevelField("bsk2")
+        end,
+        set = function(self, attackSpeedIncreaseFactor)
+            self:setNumberLevelField("bsk2", attackSpeedIncreaseFactor)
+        end
+    },
+    true
+)
+return ____exports

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

@@ -0,0 +1,21 @@
+/// <reference types="warpack-types/warpack" />
+/** @noSelfInFile */
+import { ChannelAbilityType, ChannelAbilityTypeTargetingType } from "./channel";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class BlankConfigurableAbilityType extends ChannelAbilityType {
+    static readonly IS_SYNTHETIC = true;
+    private autoOrderTypeStringIdsEnabled;
+    private readonly autoOrderTypeStringIdByTargetingType;
+    private _usesAttackAnimation;
+    private _isChanneling;
+    constructor(object: WarObject);
+    get usesAttackAnimation(): boolean;
+    set usesAttackAnimation(usesAttackAnimation: boolean);
+    get isChanneling(): boolean;
+    set isChanneling(isChanneling: boolean);
+    get targetingType(): ChannelAbilityTypeTargetingType[];
+    set targetingType(targetingType: ObjectDataEntryLevelFieldValueSupplier<ChannelAbilityTypeTargetingType>);
+    get baseOrderTypeStringId(): string[];
+    set baseOrderTypeStringId(baseOrderTypeStringId: ObjectDataEntryLevelFieldValueSupplier<string>);
+    private setAutoOrderTypeStringIds;
+}

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

@@ -0,0 +1,249 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____channel = require("engine.object-data.entry.ability-type.channel")
+local ChannelAbilityType = ____channel.ChannelAbilityType
+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")
+local Timer = ____timer.Timer
+local ____unit = require("core.types.unit")
+local Unit = ____unit.Unit
+local ____arrays = require("utility.arrays")
+local toLuaSet = ____arrays.toLuaSet
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+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 ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local isChannelingAbilityTypeIds = {}
+local usesAttackAnimationByAbilityTypeId = {}
+____exports.BlankConfigurableAbilityType = __TS__Class()
+local BlankConfigurableAbilityType = ____exports.BlankConfigurableAbilityType
+BlankConfigurableAbilityType.name = "BlankConfigurableAbilityType"
+__TS__ClassExtends(BlankConfigurableAbilityType, ChannelAbilityType)
+function BlankConfigurableAbilityType.prototype.____constructor(self, object)
+    ChannelAbilityType.prototype.____constructor(self, object)
+    self.autoOrderTypeStringIdsEnabled = true
+    self.autoOrderTypeStringIdByTargetingType = {}
+    self._usesAttackAnimation = false
+    self._isChanneling = false
+    self.buttonPositionX = 0
+    self.buttonPositionY = 0
+    self.casterAttachmentPresets = {}
+    self.effectModelPaths = {}
+    self.targetEffectPresets = {}
+    self.levelCount = 1
+    self.channelingDuration = 0
+    self.isTargetingImageVisible = false
+    self.isPhysical = false
+    self.isUniversal = false
+    self.isUniqueCast = true
+    self.casterAttachmentPresetsDuration = 0
+    self.disablesOtherAbilities = false
+    self:setAutoOrderTypeStringIds()
+    usesAttackAnimationByAbilityTypeId[self.id] = false
+end
+function BlankConfigurableAbilityType.prototype.setAutoOrderTypeStringIds(self)
+    local targetingTypes = toLuaSet(self.targetingType)
+    local unusedTargetingTypes = {}
+    for targetingType, orderTypeStringId in pairs(self.autoOrderTypeStringIdByTargetingType) do
+        if not (targetingTypes[targetingType] ~= nil) then
+            unusedTargetingTypes[#unusedTargetingTypes + 1] = targetingType
+            orderTypeStringIdFactory:recycle(orderTypeStringId)
+        end
+    end
+    for ____, unusedTargetingType in ipairs(unusedTargetingTypes) do
+        self.autoOrderTypeStringIdByTargetingType[unusedTargetingType] = nil
+    end
+    for targetingType in pairs(targetingTypes) do
+        if self.autoOrderTypeStringIdByTargetingType[targetingType] == nil then
+            self.autoOrderTypeStringIdByTargetingType[targetingType] = orderTypeStringIdFactory:next(targetingType)
+        end
+    end
+    self.baseOrderTypeStringId = function(level)
+        return checkNotNull(self.autoOrderTypeStringIdByTargetingType[self.targetingType[level + 1]])
+    end
+end
+BlankConfigurableAbilityType.IS_SYNTHETIC = true
+__TS__SetDescriptor(
+    BlankConfigurableAbilityType.prototype,
+    "usesAttackAnimation",
+    {
+        get = function(self)
+            return self._usesAttackAnimation
+        end,
+        set = function(self, usesAttackAnimation)
+            usesAttackAnimationByAbilityTypeId[self.id] = usesAttackAnimation
+            self._usesAttackAnimation = usesAttackAnimation
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BlankConfigurableAbilityType.prototype,
+    "isChanneling",
+    {
+        get = function(self)
+            return self._isChanneling
+        end,
+        set = function(self, isChanneling)
+            if isChanneling then
+                isChannelingAbilityTypeIds[self.id] = true
+            else
+                isChannelingAbilityTypeIds[self.id] = nil
+            end
+            self._isChanneling = isChanneling
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BlankConfigurableAbilityType.prototype,
+    "targetingType",
+    {
+        get = function(self)
+            return self:getNumberLevelField("Ncl2")
+        end,
+        set = function(self, targetingType)
+            self:setNumberLevelField("Ncl2", targetingType)
+            if self.autoOrderTypeStringIdsEnabled then
+                self:setAutoOrderTypeStringIds()
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    BlankConfigurableAbilityType.prototype,
+    "baseOrderTypeStringId",
+    {
+        get = function(self)
+            return self:getStringLevelField("Ncl6")
+        end,
+        set = function(self, baseOrderTypeStringId)
+            self.autoOrderTypeStringIdsEnabled = false
+            self:setStringLevelField("Ncl6", baseOrderTypeStringId)
+        end
+    },
+    true
+)
+do
+    local channelInfoByCaster = {}
+    local castersByTarget = {}
+    local targets = __TS__New(LinkedSet)
+    do
+        local function abilityUnitTargetChannelingStartEventListener(caster, ability, target)
+            targets:add(target)
+            local casters = castersByTarget[target]
+            if casters == nil then
+                casters = __TS__New(LinkedSet)
+                castersByTarget[target] = casters
+            end
+            casters:add(caster)
+            channelInfoByCaster[caster] = {
+                abilityTypeId = ability.typeId,
+                areaOfEffect = AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD:getValue(ability, ability.level),
+                allowedTargetCombatClassifications = ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD:getValue(ability, ability.level),
+                target = target
+            }
+        end
+        local function abilityStopEventListener(caster)
+            local channelInfo = channelInfoByCaster[caster]
+            if channelInfo ~= nil then
+                channelInfoByCaster[caster] = nil
+                local casters = castersByTarget[channelInfo.target]
+                if casters ~= nil then
+                    casters:remove(caster)
+                end
+                targets:remove(channelInfo.target)
+            end
+        end
+        for abilityTypeId in pairs(postcompile(function() return isChannelingAbilityTypeIds end)) do
+            Unit.abilityUnitTargetChannelingStartEvent[abilityTypeId]:addListener(0, abilityUnitTargetChannelingStartEventListener)
+            Unit.abilityStopEvent[abilityTypeId]:addListener(abilityStopEventListener)
+        end
+    end
+    local function unitChangeEventListener(unit)
+        local casters = castersByTarget[unit]
+        if casters ~= nil then
+            for caster in pairs(casters) do
+                local channelInfo = channelInfoByCaster[caster]
+                if channelInfo ~= nil then
+                    if not unit:isAllowedTarget(caster, channelInfo.allowedTargetCombatClassifications) or unit:isInvisibleTo(caster.owner) or channelInfo.areaOfEffect > 0 and caster:getCollisionDistanceTo(unit) > channelInfo.areaOfEffect or unit.transport ~= nil then
+                        caster:interruptCast(channelInfo.abilityTypeId)
+                    end
+                end
+            end
+        end
+    end
+    Unit.abilityChannelingStartEvent:addListener(
+        4,
+        function(caster)
+            unitChangeEventListener(caster)
+            Timer:run(unitChangeEventListener, caster)
+        end
+    )
+    Unit.abilityUnitTargetChannelingStartEvent:addListener(
+        4,
+        function(caster, ability, target)
+            unitChangeEventListener(target)
+            Timer:run(unitChangeEventListener, target)
+        end
+    )
+    Unit.onBoard:addListener(4, unitChangeEventListener)
+    Unit.deathEvent:addListener(4, unitChangeEventListener)
+    Timer.onPeriod[1]:addListener(
+        4,
+        function()
+            for target in pairs(targets) do
+                unitChangeEventListener(target)
+            end
+        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"}
+        end
+    end
+    return usesAttackAnimationByAbilityTypeId
+end)) do
+    if usesAttackAnimation then
+        Unit.abilityCastingStartEvent[abilityTypeId]:addListener(
+            4,
+            function(caster, ability)
+                if ability:getField(ABILITY_RLF_CASTING_TIME) ~= 0 then
+                    Timer:run(function()
+                        caster:playAnimation("ready")
+                    end)
+                end
+            end
+        )
+        Unit.abilityCastingFinishEvent[abilityTypeId]:addListener(function(caster, ability)
+            if ability:getField(ABILITY_RLF_FOLLOW_THROUGH_TIME) == 0 then
+                ability:setField(
+                    ABILITY_RLF_FOLLOW_THROUGH_TIME,
+                    BlzGetUnitWeaponRealField(caster.handle, UNIT_WEAPON_RF_ATTACK_BACKSWING_POINT, 0) + BlzGetUnitWeaponRealField(caster.handle, UNIT_WEAPON_RF_ATTACK_DAMAGE_POINT, 0) - caster:getField(UNIT_RF_CAST_POINT)
+                )
+            end
+        end)
+    else
+        Unit.abilityCastingFinishEvent[abilityTypeId]:addListener(function(caster, ability)
+            if ability:getField(ABILITY_RLF_FOLLOW_THROUGH_TIME) == 0 then
+                ability:setField(
+                    ABILITY_RLF_FOLLOW_THROUGH_TIME,
+                    caster:getField(UNIT_RF_CAST_BACK_SWING)
+                )
+            end
+        end)
+    end
+end
+return ____exports

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

@@ -0,0 +1,7 @@
+/// <reference types="warpack-types/warpack" />
+/** @noSelfInFile */
+import { DiseaseCloudAbilityType } from "./disease-cloud";
+export declare class BlankPassiveAbilityType extends DiseaseCloudAbilityType {
+    static readonly IS_SYNTHETIC = true;
+    constructor(object: WarObject);
+}

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

@@ -0,0 +1,28 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____disease_2Dcloud = require("engine.object-data.entry.ability-type.disease-cloud")
+local DiseaseCloudAbilityType = ____disease_2Dcloud.DiseaseCloudAbilityType
+local ____combat_2Dclassification = require("engine.object-data.auxiliary.combat-classification")
+local combatClassificationsOf = ____combat_2Dclassification.combatClassificationsOf
+____exports.BlankPassiveAbilityType = __TS__Class()
+local BlankPassiveAbilityType = ____exports.BlankPassiveAbilityType
+BlankPassiveAbilityType.name = "BlankPassiveAbilityType"
+__TS__ClassExtends(BlankPassiveAbilityType, DiseaseCloudAbilityType)
+function BlankPassiveAbilityType.prototype.____constructor(self, object)
+    DiseaseCloudAbilityType.prototype.____constructor(self, object)
+    self.levelCount = 1
+    self.iconPath = ""
+    self.targetEffectPresets = {}
+    self.diseaseDuration = 0
+    self.damagePerSecond = 0
+    self.plagueWardDuration = 0
+    self.plagueWardUnitTypeId = 0
+    self.allowedTargetCombatClassifications = combatClassificationsOf(1)
+    self.areaOfEffect = 0
+    self.buffTypeIds = {}
+    self.techTreeDependencies = {}
+end
+BlankPassiveAbilityType.IS_SYNTHETIC = true
+return ____exports

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

@@ -0,0 +1,16 @@
+/** @noSelfInFile */
+import { AbilityType, AbilityTypeId } from "../ability-type";
+import { ObjectDataEntryLevelFieldValueSupplier } from "../../entry";
+export declare class BlizzardAbilityType extends AbilityType {
+    static readonly BASE_ID: AbilityTypeId;
+    get waveCount(): number[];
+    set waveCount(waveCount: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get damage(): number[];
+    set damage(damage: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get shardCount(): number[];
+    set shardCount(shardCount: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get structureDamageDecreaseFactor(): number[];
+    set structureDamageDecreaseFactor(structureDamageDecreaseFactor: ObjectDataEntryLevelFieldValueSupplier<number>);
+    get damagePerSecond(): number[];
+    set damagePerSecond(damagePerSecond: ObjectDataEntryLevelFieldValueSupplier<number>);
+}