warscript 0.0.1-dev.404878c

package/engine/buff.lua

@@ -0,0 +1,1093 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__InstanceOf = ____lualib.__TS__InstanceOf
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SparseArrayNew = ____lualib.__TS__SparseArrayNew
+local __TS__SparseArrayPush = ____lualib.__TS__SparseArrayPush
+local __TS__SparseArraySpread = ____lualib.__TS__SparseArraySpread
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local buffDamageIntervalTimerCallback, buffHealingIntervalTimerCallback
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____applicable = require("engine.object-data.entry.buff-type.applicable")
+local internalApplyBuff = ____applicable.internalApplyBuff
+local removeBuff = ____applicable.removeBuff
+local ____ability = require("engine.internal.ability")
+local Ability = ____ability.Ability
+local ____ability = require("engine.object-field.ability")
+local AbilityBooleanField = ____ability.AbilityBooleanField
+local AbilityNumberField = ____ability.AbilityNumberField
+local resolveCurrentAbilityDependentValue = ____ability.resolveCurrentAbilityDependentValue
+local ____exception = require("exception")
+local IllegalArgumentException = ____exception.IllegalArgumentException
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____math = require("math")
+local max = ____math.max
+local min = ____math.min
+local ____bonus = require("engine.internal.unit.bonus")
+local addOrUpdateOrRemoveUnitBonus = ____bonus.addOrUpdateOrRemoveUnitBonus
+local getUnitBonus = ____bonus.getUnitBonus
+local removeUnitBonus = ____bonus.removeUnitBonus
+local UnitBonusType = ____bonus.UnitBonusType
+local ____area_2Ddamage = require("engine.internal.mechanics.area-damage")
+local damageArea = ____area_2Ddamage.damageArea
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+local ____effect = require("core.types.effect")
+local Effect = ____effect.Effect
+local ____buff_2Dtype = require("engine.object-data.entry.buff-type")
+local BuffType = ____buff_2Dtype.BuffType
+local ____unit = require("engine.behaviour.unit")
+local UnitBehavior = ____unit.UnitBehavior
+local ____arrays = require("utility.arrays")
+local forEach = ____arrays.forEach
+local ____ability_2Dduration = require("engine.internal.mechanics.ability-duration")
+local getAbilityDuration = ____ability_2Dduration.getAbilityDuration
+local getUnitAbility = BlzGetUnitAbility
+local stringValueByBuffTypeIdByFieldId = postcompile(function()
+    local stringValueByBuffTypeIdByFieldId = {}
+    for ____, rawFieldId in ipairs({"feft", "fspt"}) do
+        local stringValueByBuffTypeId = {}
+        for ____, buffType in ipairs(BuffType:getAll()) do
+            local stringValue = buffType.getStringField(buffType, rawFieldId)
+            if stringValue ~= "" then
+                stringValueByBuffTypeId[buffType.id] = stringValue
+            end
+        end
+        stringValueByBuffTypeIdByFieldId[fourCC(rawFieldId)] = stringValueByBuffTypeId
+    end
+    return stringValueByBuffTypeIdByFieldId
+end)
+local buffByTypeIdByUnit = setmetatable({}, {__mode = "k"})
+____exports.BuffUniqueGroup = __TS__Class()
+local BuffUniqueGroup = ____exports.BuffUniqueGroup
+BuffUniqueGroup.name = "BuffUniqueGroup"
+function BuffUniqueGroup.prototype.____constructor(self)
+end
+local buffParametersKeys = {
+    spellStealPriority = true,
+    level = true,
+    duration = true,
+    learnLevelMinimum = true,
+    source = true,
+    behaviorConstructors = true,
+    abilityTypeIds = true,
+    damageUponDeathAllowedTargetCombatClassifications = true,
+    damageUponDeath = true,
+    damageUponDeathRange = true,
+    mediumDamageUponDeath = true,
+    mediumDamageUponDeathRange = true,
+    smallDamageUponDeath = true,
+    smallDamageUponDeathRange = true,
+    damageOverDuration = true,
+    damagePerInterval = true,
+    damageInterval = true,
+    healingOverDuration = true,
+    healingPerInterval = true,
+    healingInterval = true,
+    damageIncrease = true,
+    damageIncreaseFactor = true,
+    armorIncrease = true,
+    armorIncreaseFactor = true,
+    attackSpeedIncreaseFactor = true,
+    movementSpeedIncreaseFactor = true,
+    receivedDamageFactor = true,
+    receivedMagicDamageFactor = true,
+    durationIncreaseOnAutoAttack = true,
+    maximumDuration = true,
+    maximumRemainingDuration = true,
+    stuns = true,
+    ignoresStunImmunity = true,
+    providesStunImmunity = true,
+    providesSpellImmunity = true,
+    providesInvulnerability = true,
+    disablesAutoAttack = true,
+    destroysOnDamage = true,
+    maximumAutoAttackCount = true,
+    uniqueGroup = true
+}
+local function resolveNumberValue(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 __TS__InstanceOf(value, AbilityNumberField) and value:getValue(ability) or value:getValue(ability, level or ability.level)
+end
+local function resolveBooleanValue(ability, level, value)
+    if value == nil or type(value) == "boolean" then
+        return value
+    end
+    if ability == nil then
+        error(
+            __TS__New(IllegalArgumentException),
+            0
+        )
+    end
+    local ____temp_0
+    if __TS__InstanceOf(value, AbilityBooleanField) then
+        ____temp_0 = value:getValue(ability)
+    else
+        ____temp_0 = value:getValue(ability, level or ability.level)
+    end
+    return ____temp_0
+end
+local function resolveAndSetNumberValue(buff, property, ability, level, value, defaultValue)
+    local resolvedValue = resolveNumberValue(ability, level, value or defaultValue)
+    if resolvedValue ~= nil then
+        buff[property] = resolvedValue
+    end
+end
+local buffBooleanParameters = {"stuns", "ignoresStunImmunity", "disablesAutoAttack", "providesInvulnerability"}
+local buffNumberParameters = {
+    "durationIncreaseOnAutoAttack",
+    "attackSpeedIncreaseFactor",
+    "movementSpeedIncreaseFactor",
+    "armorIncrease",
+    "receivedDamageFactor",
+    "maximumAutoAttackCount",
+    "damageInterval",
+    "damagePerInterval",
+    "damageOverDuration",
+    "healingInterval",
+    "healingPerInterval",
+    "healingOverDuration"
+}
+local unsuccessfulApplicationMarker = {}
+local function selectBuffTypeIdWithLeastDuration(buffTypeIds, unit)
+    local minimumDuration = nil
+    local minimumDurationBuffTypeId
+    local firstNativeBuffTypeId = nil
+    for ____, buffTypeId in ipairs(buffTypeIds) do
+        local ____opt_1 = buffByTypeIdByUnit[unit]
+        local buff = ____opt_1 and ____opt_1[buffTypeId]
+        if buff ~= nil then
+            if minimumDuration == nil or buff.remainingDuration < minimumDuration then
+                minimumDuration = buff.remainingDuration
+                minimumDurationBuffTypeId = buffTypeId
+            end
+        elseif unit:hasBuff(buffTypeId) then
+            firstNativeBuffTypeId = firstNativeBuffTypeId or buffTypeId
+        else
+            return buffTypeId
+        end
+    end
+    if minimumDurationBuffTypeId ~= nil then
+        return minimumDurationBuffTypeId
+    end
+    return checkNotNull(firstNativeBuffTypeId)
+end
+local function destroyBuffIfItHasSameUniqueGroup(buff, uniqueGroup)
+    if buff[103] == uniqueGroup then
+        buff:destroy()
+    end
+end
+local function destroyBuff(buff)
+    buff:destroy()
+end
+local function expireBuff(buff)
+    local remainingDamageOverDuration = buff[112] or 0
+    local remainingHealingOverDuration = buff[112] or 0
+    if remainingDamageOverDuration ~= 0 or remainingHealingOverDuration ~= 0 then
+        buff:flashSpecialEffect()
+        if remainingDamageOverDuration ~= 0 then
+            (buff[101] or buff[100]):damageTarget(buff[100], remainingDamageOverDuration)
+            buff[112] = nil
+        end
+        if remainingHealingOverDuration ~= 0 then
+            (buff[101] or buff[100]):healTarget(buff[100], remainingHealingOverDuration)
+            buff[117] = nil
+        end
+    end
+    Timer:run(destroyBuff, buff)
+end
+local function buffDamageIntervalInitialTimerCallback(buff)
+    buffDamageIntervalTimerCallback(buff)
+    local timer = buff[113]
+    local damageInterval = buff[111]
+    if timer ~= nil and damageInterval ~= nil and damageInterval > 0 then
+        timer:start(damageInterval, true, buffDamageIntervalTimerCallback, buff)
+    end
+end
+buffDamageIntervalTimerCallback = function(buff)
+    buff:flashSpecialEffect()
+    local source = buff[101] or buff[100]
+    local remainingDamageOverDuration = buff[112] or 0
+    if remainingDamageOverDuration ~= 0 then
+        local damageInterval = buff[111] or 0
+        if damageInterval ~= 0 then
+            local damage = remainingDamageOverDuration / (1 + buff.remainingDuration / damageInterval)
+            source:damageTarget(buff[100], damage)
+            buff[112] = remainingDamageOverDuration - damage
+        end
+    end
+    local damagePerInterval = buff[110] or 0
+    if remainingDamageOverDuration == 0 or damagePerInterval ~= 0 then
+        source:damageTarget(buff[100], damagePerInterval)
+    end
+end
+local function buffHealingIntervalInitialTimerCallback(buff)
+    buffHealingIntervalTimerCallback(buff)
+    local timer = buff[118]
+    local healingInterval = buff[116]
+    if timer ~= nil and healingInterval ~= nil and healingInterval > 0 then
+        timer:start(healingInterval, true, buffHealingIntervalTimerCallback, buff)
+    end
+end
+buffHealingIntervalTimerCallback = function(buff)
+    if buff[116] ~= buff[111] then
+        buff:flashSpecialEffect()
+    end
+    local source = buff[101] or buff[100]
+    local remainingHealingOverDuration = buff[117] or 0
+    if remainingHealingOverDuration ~= 0 then
+        local healingInterval = buff[116] or 0
+        if healingInterval ~= 0 then
+            local healing = remainingHealingOverDuration / (1 + buff.remainingDuration / healingInterval)
+            source:healTarget(buff[100], healing)
+            buff[117] = remainingHealingOverDuration - healing
+        end
+    end
+    local healingPerInterval = buff[115] or 0
+    if remainingHealingOverDuration == 0 or healingPerInterval ~= 0 then
+        source:healTarget(buff[100], healingPerInterval)
+    end
+end
+____exports.Buff = __TS__Class()
+local Buff = ____exports.Buff
+Buff.name = "Buff"
+__TS__ClassExtends(Buff, UnitBehavior)
+function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOrTypeIdSelectionPolicy, resistanceTypeOrPolarity, abilityOrParametersOrResistanceType, parametersOrAbility, parameters)
+    UnitBehavior.prototype.____constructor(self, _unit)
+    self._unit = _unit
+    self.parameters = nil
+    self[100] = _unit
+    local typeId
+    local polarity
+    local resistanceType
+    local ability
+    if type(typeIdOrTypeIds) ~= "number" then
+        typeId = selectBuffTypeIdWithLeastDuration(typeIdOrTypeIds, _unit)
+        polarity = resistanceTypeOrPolarity
+        resistanceType = abilityOrParametersOrResistanceType
+        if __TS__InstanceOf(parametersOrAbility, Ability) then
+            ability = parametersOrAbility
+        else
+            ability = nil
+            parameters = parametersOrAbility
+        end
+    else
+        typeId = typeIdOrTypeIds
+        polarity = polarityOrTypeIdSelectionPolicy
+        resistanceType = resistanceTypeOrPolarity
+        if __TS__InstanceOf(abilityOrParametersOrResistanceType, Ability) then
+            ability = abilityOrParametersOrResistanceType
+            parameters = parametersOrAbility
+        else
+            ability = nil
+            parameters = abilityOrParametersOrResistanceType
+        end
+    end
+    self.typeId = typeId
+    self.polarity = polarity
+    self.resistanceType = resistanceType
+    if not __TS__InstanceOf(ability, Ability) then
+        parameters = ability
+        ability = nil
+    end
+    local defaultParameters = self.constructor.defaultParameters
+    local level = parameters and parameters.level or defaultParameters.level
+    local spellStealPriority = parameters and parameters.spellStealPriority or defaultParameters.spellStealPriority
+    local learnLevelMinimum = parameters and parameters.learnLevelMinimum or defaultParameters.learnLevelMinimum
+    local duration = parameters and parameters.duration or defaultParameters.duration
+    local source = parameters and parameters.source or defaultParameters.source
+    if ability ~= nil then
+        if level == nil and ability:getField(ABILITY_IF_LEVELS) > 1 then
+            level = ability.level
+        end
+        if source == nil then
+            local abilityOwner = ability.owner
+            if __TS__InstanceOf(abilityOwner, Unit) then
+                source = abilityOwner
+            else
+                source = abilityOwner.owner
+            end
+        end
+        spellStealPriority = spellStealPriority or ability:getField(ABILITY_IF_PRIORITY)
+        learnLevelMinimum = learnLevelMinimum or ability:getField(ABILITY_IF_REQUIRED_LEVEL)
+        duration = duration or getAbilityDuration(ability, _unit)
+    end
+    local buffByTypeId = buffByTypeIdByUnit[_unit]
+    if buffByTypeId == nil then
+        buffByTypeId = {}
+        buffByTypeIdByUnit[_unit] = buffByTypeId
+    end
+    local ____opt_13 = buffByTypeId[typeId]
+    if ____opt_13 ~= nil then
+        ____opt_13:destroy()
+    end
+    local uniqueGroup = parameters and parameters.uniqueGroup or defaultParameters and defaultParameters.uniqueGroup
+    if uniqueGroup ~= nil then
+        ____exports.Buff:forAll(_unit, destroyBuffIfItHasSameUniqueGroup, uniqueGroup)
+    end
+    if not internalApplyBuff(
+        _unit,
+        typeId,
+        polarity,
+        resistanceType,
+        level,
+        duration,
+        spellStealPriority,
+        learnLevelMinimum
+    ) then
+        UnitBehavior.prototype.destroy(self)
+        error(unsuccessfulApplicationMarker, 0)
+    end
+    local handle = BlzGetUnitAbility(_unit.handle, typeId)
+    if handle == nil then
+        UnitBehavior.prototype.destroy(self)
+        error(unsuccessfulApplicationMarker, 0)
+    end
+    self.handle = handle
+    buffByTypeId[typeId] = self
+    self._level = level
+    self._spellStealPriority = spellStealPriority
+    self._learnLevelMinimum = learnLevelMinimum
+    self[101] = source
+    self[102] = duration or 0
+    self[103] = uniqueGroup
+    self[104] = BlzGetAbilityStringLevelField(self.handle, ABILITY_SLF_EFFECT, 0)
+    self[105] = BlzGetAbilityStringLevelField(self.handle, ABILITY_SLF_SPECIAL, 0)
+    if parameters ~= nil or (next(defaultParameters)) ~= nil then
+        for ____, buffBooleanParameter in ipairs(buffBooleanParameters) do
+            local ____ability_22 = ability
+            local ____level_23 = level
+            local ____temp_21 = parameters and parameters[buffBooleanParameter]
+            if ____temp_21 == nil then
+                ____temp_21 = defaultParameters[buffBooleanParameter]
+            end
+            if resolveBooleanValue(____ability_22, ____level_23, ____temp_21) then
+                self[buffBooleanParameter] = true
+            end
+        end
+        for ____, buffNumberParameter in ipairs(buffNumberParameters) do
+            resolveAndSetNumberValue(
+                self,
+                buffNumberParameter,
+                ability,
+                level,
+                parameters and parameters[buffNumberParameter],
+                defaultParameters[buffNumberParameter]
+            )
+        end
+        local maximumDuration = parameters and parameters.maximumDuration or defaultParameters.maximumDuration
+        if maximumDuration ~= nil then
+            self[107] = resolveNumberValue(ability, level, maximumDuration)
+        end
+        local maximumRemainingDuration = parameters and parameters.maximumRemainingDuration or defaultParameters.maximumRemainingDuration
+        if maximumRemainingDuration ~= nil then
+            self[108] = resolveNumberValue(ability, level, maximumRemainingDuration)
+        end
+        local parametersAbilityTypeIds = parameters and parameters.abilityTypeIds or defaultParameters.abilityTypeIds
+        if parametersAbilityTypeIds ~= nil then
+            local abilityTypeIds = self._abilityTypeIds
+            if abilityTypeIds == nil then
+                abilityTypeIds = {}
+                self._abilityTypeIds = abilityTypeIds
+            end
+            for abilityTypeId, abilityParameters in pairs(parametersAbilityTypeIds) do
+                local addedAbility = _unit:addAbility(abilityTypeId)
+                if addedAbility ~= nil then
+                    _unit:makeAbilityPermanent(abilityTypeId, true)
+                    _unit:setAbilityLevel(abilityTypeId, 1 + (abilityParameters.level or ability and ability.level or 0))
+                    for abilityParameterKey, abilityParameterValue in pairs(abilityParameters) do
+                        if abilityParameterKey == "isButtonVisible" then
+                            if not resolveBooleanValue(ability, level, abilityParameterValue) then
+                                _unit:hideAbility(abilityTypeId, true)
+                            end
+                        elseif abilityParameterKey ~= "level" then
+                            abilityParameterKey:setValue(
+                                addedAbility,
+                                resolveNumberValue(ability, level, abilityParameterValue)
+                            )
+                        end
+                    end
+                    abilityTypeIds[abilityTypeId] = true
+                end
+            end
+            local behaviorConstructors = parameters and parameters.behaviorConstructors or defaultParameters.behaviorConstructors
+            if behaviorConstructors ~= nil then
+                local behaviors = {}
+                for i = 1, #behaviorConstructors do
+                    behaviors[i] = __TS__New(behaviorConstructors[i], _unit)
+                end
+                self._behaviors = behaviors
+            end
+        end
+        local additionalParameters = {}
+        for key, value in pairs(parameters) do
+            if not buffParametersKeys[key] then
+                if ability then
+                    additionalParameters[key] = resolveCurrentAbilityDependentValue(ability, value)
+                else
+                    additionalParameters[key] = value
+                end
+            end
+        end
+        if (next(additionalParameters)) ~= nil then
+            self.parameters = additionalParameters
+        end
+    end
+    if duration ~= nil and duration > 0 then
+        local timer = Timer:create()
+        timer:start(duration, false, expireBuff, self)
+        self._timer = timer
+    end
+end
+function Buff.prototype.getUnitBonus(self, bonusType)
+    local ____opt_36 = self._bonusIdByBonusType
+    local bonusId = ____opt_36 and ____opt_36[bonusType]
+    return bonusId == nil and 0 or getUnitBonus(self._unit, bonusType, bonusId)
+end
+function Buff.prototype.addOrUpdateOrRemoveUnitBonus(self, bonusType, value)
+    local bonusIdByBonusType = self._bonusIdByBonusType
+    if bonusIdByBonusType == nil then
+        bonusIdByBonusType = {}
+        self._bonusIdByBonusType = bonusIdByBonusType
+    end
+    bonusIdByBonusType[bonusType] = addOrUpdateOrRemoveUnitBonus(self._unit, bonusType, bonusIdByBonusType[bonusType], value)
+end
+function Buff.prototype.flashEffect(self, widgetOrDuration, duration)
+    local isWidgetProvided = type(widgetOrDuration) == "table"
+    local ____Effect_40 = Effect
+    local ____Effect_flash_41 = Effect.flash
+    local ____array_39 = __TS__SparseArrayNew(
+        self[104],
+        isWidgetProvided and widgetOrDuration or self._unit,
+        stringValueByBuffTypeIdByFieldId[fourCC("feft")][self.typeId] or "origin"
+    )
+    local ____isWidgetProvided_38
+    if isWidgetProvided then
+        ____isWidgetProvided_38 = duration
+    else
+        ____isWidgetProvided_38 = widgetOrDuration
+    end
+    __TS__SparseArrayPush(____array_39, ____isWidgetProvided_38)
+    ____Effect_flash_41(
+        ____Effect_40,
+        __TS__SparseArraySpread(____array_39)
+    )
+end
+function Buff.prototype.flashSpecialEffect(self, widgetOrDuration, duration)
+    local isWidgetProvided = type(widgetOrDuration) == "table"
+    local ____Effect_44 = Effect
+    local ____Effect_flash_45 = Effect.flash
+    local ____array_43 = __TS__SparseArrayNew(
+        self[105],
+        isWidgetProvided and widgetOrDuration or self._unit,
+        stringValueByBuffTypeIdByFieldId[fourCC("fspt")][self.typeId] or "origin"
+    )
+    local ____isWidgetProvided_42
+    if isWidgetProvided then
+        ____isWidgetProvided_42 = duration
+    else
+        ____isWidgetProvided_42 = widgetOrDuration
+    end
+    __TS__SparseArrayPush(____array_43, ____isWidgetProvided_42)
+    ____Effect_flash_45(
+        ____Effect_44,
+        __TS__SparseArraySpread(____array_43)
+    )
+end
+function Buff.prototype.onDestroy(self)
+    local unit = self._unit
+    if getUnitAbility(unit.handle, self.typeId) == self.handle then
+        removeBuff(unit.handle, self.typeId)
+    end
+    buffByTypeIdByUnit[unit][self.typeId] = nil
+    local healingIntervalTimer = self[118]
+    if healingIntervalTimer ~= nil then
+        healingIntervalTimer:destroy()
+        self[118] = nil
+    end
+    local damageIntervalTimer = self[113]
+    if damageIntervalTimer ~= nil then
+        damageIntervalTimer:destroy()
+        self[113] = nil
+    end
+    if self._timer ~= nil then
+        self._timer:destroy()
+    end
+    if self._behaviors ~= nil then
+        for ____, behavior in ipairs(self._behaviors) do
+            behavior:destroy()
+        end
+    end
+    if self[130] then
+        unit:decrementDisableAutoAttackCounter()
+    end
+    if self[128] then
+        if self[129] then
+            unit:decrementStunCounter()
+        end
+        unit:decrementStunCounter()
+    end
+    if self._abilityTypeIds ~= nil then
+        for abilityTypeId in pairs(self._abilityTypeIds) do
+            unit:removeAbility(abilityTypeId)
+        end
+    end
+    if self._bonusIdByBonusType ~= nil then
+        for bonusType, bonusId in pairs(self._bonusIdByBonusType) do
+            removeUnitBonus(unit, bonusType, bonusId)
+        end
+    end
+    return UnitBehavior.prototype.onDestroy(self)
+end
+function Buff.apply(self, ...)
+    local args = {...}
+    do
+        local function ____catch(exception)
+            if exception == unsuccessfulApplicationMarker then
+                return true, nil
+            else
+                error(exception, 0)
+            end
+        end
+        local ____try, ____hasReturned, ____returnValue = pcall(function()
+            return true, __TS__New(
+                self,
+                table.unpack(args)
+            )
+        end)
+        if not ____try then
+            ____hasReturned, ____returnValue = ____catch(____hasReturned)
+        end
+        if ____hasReturned then
+            return ____returnValue
+        end
+    end
+end
+function Buff.getByTypeId(self, unit, typeId)
+    local ____opt_46 = buffByTypeIdByUnit[unit]
+    local buff = ____opt_46 and ____opt_46[typeId]
+    if __TS__InstanceOf(buff, self) then
+        return buff
+    end
+    return nil
+end
+function Buff.prototype.onDeath(self, source)
+    local unit = self.unit
+    if self[119] ~= nil then
+        damageArea(
+            self[101] or unit,
+            self[119],
+            unit.x,
+            unit.y,
+            self[121] or 0,
+            self[120] or 0,
+            self[123] or 0,
+            self[122] or 0,
+            self[125] or 0,
+            self[124] or 0
+        )
+    end
+end
+function Buff.prototype.onDamageDealt(self, target, event)
+    if event.isAttack then
+        if self[106] ~= nil then
+            local durationIncrease = self[106]
+            local maximumDuration = self[107] or 0
+            if maximumDuration > 0 then
+                durationIncrease = min(
+                    durationIncrease,
+                    max(0, maximumDuration - self[102])
+                )
+            end
+            local remainingDuration = self.remainingDuration + durationIncrease
+            local maximumRemainingDuration = self[108] or 0
+            if maximumRemainingDuration > 0 then
+                remainingDuration = min(remainingDuration, maximumRemainingDuration)
+            end
+            self.remainingDuration = remainingDuration
+        end
+        local autoAttackCount = (self[126] or 0) + 1
+        self[126] = autoAttackCount
+        if autoAttackCount == self[127] then
+            self:destroy()
+        end
+    end
+end
+Buff.defaultParameters = {}
+__TS__SetDescriptor(
+    Buff.prototype,
+    "source",
+    {get = function(self)
+        return self[101] or self._unit
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "level",
+    {get = function(self)
+        return self._level or 0
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "remainingDamageOverDuration",
+    {
+        get = function(self)
+            return self[112] or 0
+        end,
+        set = function(self, remainingDamageOverDuration)
+            local remainingDamageOverDurationDelta = remainingDamageOverDuration - (self[112] or 0)
+            self[112] = remainingDamageOverDuration ~= 0 and remainingDamageOverDuration or nil
+            local damageOverDuration = (self[109] or 0) + remainingDamageOverDurationDelta
+            self[109] = damageOverDuration ~= 0 and damageOverDuration or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damageOverDuration",
+    {
+        get = function(self)
+            return self[109] or 0
+        end,
+        set = function(self, damageOverDuration)
+            local damageOverDurationDelta = damageOverDuration - (self[109] or 0)
+            self[109] = damageOverDuration ~= 0 and damageOverDuration or nil
+            local remainingDamageOverDuration = (self[112] or 0) + damageOverDurationDelta
+            self[112] = remainingDamageOverDuration ~= 0 and remainingDamageOverDuration or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damagePerInterval",
+    {
+        get = function(self)
+            return self[110] or 0
+        end,
+        set = function(self, damagePerInterval)
+            self[110] = damagePerInterval ~= 0 and damagePerInterval or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damageInterval",
+    {
+        get = function(self)
+            return self[111] or 0
+        end,
+        set = function(self, damageInterval)
+            if damageInterval <= 0 then
+                self[111] = damageInterval ~= 0 and damageInterval or nil
+                local timer = self[113]
+                if timer ~= nil then
+                    timer:destroy()
+                    self[113] = nil
+                end
+                return
+            end
+            self[111] = damageInterval
+            local ____opt_48 = self._timer
+            local elapsed = ____opt_48 and ____opt_48.elapsed or 0
+            local timer = self[113]
+            if timer == nil then
+                timer = Timer:create()
+                self[113] = timer
+            end
+            local initialDelay = damageInterval - (elapsed >= damageInterval and math.fmod(elapsed, damageInterval) or elapsed)
+            if initialDelay == damageInterval then
+                timer:start(damageInterval, true, buffDamageIntervalTimerCallback, self)
+            else
+                timer:start(initialDelay, false, buffDamageIntervalInitialTimerCallback, self)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "remainingHealingOverDuration",
+    {
+        get = function(self)
+            return self[117] or 0
+        end,
+        set = function(self, remainingHealingOverDuration)
+            local remainingHealingOverDurationDelta = remainingHealingOverDuration - (self[117] or 0)
+            self[112] = remainingHealingOverDuration ~= 0 and remainingHealingOverDuration or nil
+            local healingOverDuration = (self[114] or 0) + remainingHealingOverDurationDelta
+            self[114] = healingOverDuration ~= 0 and healingOverDuration or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "healingOverDuration",
+    {
+        get = function(self)
+            return self[114] or 0
+        end,
+        set = function(self, healingOverDuration)
+            local healingOverDurationDelta = healingOverDuration - (self[114] or 0)
+            self[114] = healingOverDuration ~= 0 and healingOverDuration or nil
+            local remainingHealingOverDuration = (self[117] or 0) + healingOverDurationDelta
+            self[117] = remainingHealingOverDuration ~= 0 and remainingHealingOverDuration or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "healingPerInterval",
+    {
+        get = function(self)
+            return self[115] or 0
+        end,
+        set = function(self, healingPerInterval)
+            self[115] = healingPerInterval ~= 0 and healingPerInterval or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "healingInterval",
+    {
+        get = function(self)
+            return self[116] or 0
+        end,
+        set = function(self, healingInterval)
+            if healingInterval <= 0 then
+                self[116] = healingInterval ~= 0 and healingInterval or nil
+                local timer = self[118]
+                if timer ~= nil then
+                    timer:destroy()
+                    self[118] = nil
+                end
+                return
+            end
+            self[116] = healingInterval
+            local ____opt_50 = self._timer
+            local elapsed = ____opt_50 and ____opt_50.elapsed or 0
+            local timer = self[118]
+            if timer == nil then
+                timer = Timer:create()
+                self[118] = timer
+            end
+            local initialDelay = healingInterval - (elapsed >= healingInterval and math.fmod(elapsed, healingInterval) or elapsed)
+            if initialDelay == healingInterval then
+                timer:start(healingInterval, true, buffHealingIntervalTimerCallback, self)
+            else
+                timer:start(initialDelay, false, buffHealingIntervalInitialTimerCallback, self)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "receivedDamageFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.RECEIVED_DAMAGE_FACTOR)
+        end,
+        set = function(self, receivedDamageFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.RECEIVED_DAMAGE_FACTOR, receivedDamageFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "armorIncrease",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.ARMOR)
+        end,
+        set = function(self, armorIncrease)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.ARMOR, armorIncrease)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "stuns",
+    {
+        get = function(self)
+            local ____self__128_52 = self[128]
+            if ____self__128_52 == nil then
+                ____self__128_52 = false
+            end
+            return ____self__128_52
+        end,
+        set = function(self, stuns)
+            if not stuns and self[128] then
+                if self[129] then
+                    self.object:decrementStunCounter()
+                end
+                self.object:decrementStunCounter()
+                self[128] = nil
+            elseif stuns and not self[128] then
+                if self[129] then
+                    self.object:incrementStunCounter()
+                end
+                self.object:incrementStunCounter()
+                self[128] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "ignoresStunImmunity",
+    {
+        get = function(self)
+            local ____self__129_53 = self[129]
+            if ____self__129_53 == nil then
+                ____self__129_53 = false
+            end
+            return ____self__129_53
+        end,
+        set = function(self, ignoresStunImmunity)
+            if not ignoresStunImmunity and self[129] then
+                if self[128] then
+                    self.object:decrementStunCounter()
+                end
+                self[129] = nil
+            elseif ignoresStunImmunity and not self[129] then
+                if self[128] then
+                    self.object:incrementStunCounter()
+                end
+                self[129] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "disablesAutoAttack",
+    {
+        get = function(self)
+            local ____self__130_54 = self[130]
+            if ____self__130_54 == nil then
+                ____self__130_54 = false
+            end
+            return ____self__130_54
+        end,
+        set = function(self, disablesAutoAttack)
+            if not disablesAutoAttack and self[130] then
+                self.object:decrementDisableAutoAttackCounter()
+                self[130] = nil
+            elseif disablesAutoAttack and not self[130] then
+                self.object:incrementDisableAutoAttackCounter()
+                self[130] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "providesInvulnerability",
+    {
+        get = function(self)
+            local ____self__131_55 = self[131]
+            if ____self__131_55 == nil then
+                ____self__131_55 = false
+            end
+            return ____self__131_55
+        end,
+        set = function(self, providesInvulnerability)
+            if not providesInvulnerability and self[131] then
+                self.object:decrementInvulnerabilityCounter()
+                self[131] = nil
+            elseif providesInvulnerability and not self[131] then
+                self.object:incrementInvulnerabilityCounter()
+                self[131] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maximumAutoAttackCount",
+    {
+        get = function(self)
+            return self[127] or 0
+        end,
+        set = function(self, maximumAutoAttackCount)
+            if maximumAutoAttackCount == 0 then
+                self[127] = nil
+            else
+                self[127] = maximumAutoAttackCount
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "durationIncreaseOnAutoAttack",
+    {
+        get = function(self)
+            return self[106] or 0
+        end,
+        set = function(self, durationIncreaseOnAutoAttack)
+            self[106] = durationIncreaseOnAutoAttack
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "attackSpeedIncreaseFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.ATTACK_SPEED_FACTOR)
+        end,
+        set = function(self, attackSpeedIncreaseFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.ATTACK_SPEED_FACTOR, attackSpeedIncreaseFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "movementSpeedIncreaseFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.MOVEMENT_SPEED_FACTOR)
+        end,
+        set = function(self, movementSpeedIncreaseFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.MOVEMENT_SPEED_FACTOR, movementSpeedIncreaseFactor)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "duration",
+    {get = function(self)
+        return self[102]
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "remainingDuration",
+    {
+        get = function(self)
+            local ____opt_56 = self._timer
+            return ____opt_56 and ____opt_56.remaining or 0
+        end,
+        set = function(self, remainingDuration)
+            local ____remainingDuration_60 = remainingDuration
+            local ____opt_58 = self._timer
+            local remainingDurationDelta = ____remainingDuration_60 - (____opt_58 and ____opt_58.remaining or 0)
+            if remainingDurationDelta ~= 0 then
+                self[102] = self[102] + remainingDurationDelta
+                if remainingDuration <= 0 then
+                    Timer:run(destroyBuff, self)
+                else
+                    if internalApplyBuff(
+                        self._unit,
+                        self.typeId,
+                        self.polarity,
+                        self.resistanceType,
+                        self._level,
+                        remainingDuration,
+                        self._spellStealPriority,
+                        self._learnLevelMinimum
+                    ) then
+                        local timer = self._timer
+                        if timer == nil then
+                            timer = Timer:create()
+                            self._timer = timer
+                        end
+                        timer:start(remainingDuration, false, expireBuff, self)
+                    end
+                end
+            end
+        end
+    },
+    true
+);
+(function(self)
+    ____exports.checkBuff = function(unit, buffTypeId)
+        local buffByTypeId = buffByTypeIdByUnit[unit]
+        if buffByTypeId ~= nil then
+            local buff = buffByTypeId[buffTypeId]
+            if buff ~= nil and getUnitAbility(unit.handle, buffTypeId) ~= buff.handle then
+                buff:destroy()
+            end
+        end
+    end
+    ____exports.checkBuffs = function(unit)
+        local buffByTypeId = buffByTypeIdByUnit[unit]
+        if buffByTypeId ~= nil then
+            for ____, buff in pairs(buffByTypeId) do
+                if getUnitAbility(unit.handle, buff.typeId) ~= buff.handle then
+                    buff:destroy()
+                end
+            end
+        end
+    end
+    Unit.abilityChannelingStartEvent:addListener(
+        0,
+        function(caster)
+            ____exports.checkBuffs(caster)
+            Timer:run(____exports.checkBuffs, caster)
+        end
+    )
+    Unit.abilityUnitTargetChannelingStartEvent:addListener(
+        0,
+        function(caster, ability, target)
+            ____exports.checkBuffs(target)
+            Timer:run(____exports.checkBuffs, target)
+        end
+    )
+    Unit.abilityPointTargetChannelingStartEvent:addListener(
+        0,
+        function(caster, ability, x, y)
+            local units = Unit:getInCollisionRange(
+                x,
+                y,
+                ability:getField(ABILITY_RLF_AREA_OF_EFFECT)
+            )
+            forEach(units, ____exports.checkBuffs)
+            Timer:run(forEach, units, ____exports.checkBuffs)
+        end
+    )
+    Unit.onDamage:addListener(
+        0,
+        function(source, target)
+            if source ~= nil then
+                ____exports.checkBuffs(source)
+            end
+            ____exports.checkBuffs(target)
+        end
+    )
+end)(Buff)
+return ____exports