warscript 0.0.1-dev.2af030d → 0.0.1-dev.2b3f95e

package/engine/buff.lua

@@ -14,8 +14,10 @@ local Unit = ____unit.Unit
 local ____applicable = require("engine.object-data.entry.buff-type.applicable")
 local internalApplyBuff = ____applicable.internalApplyBuff
 local removeBuff = ____applicable.removeBuff
+local removeBuffApplicator = ____applicable.removeBuffApplicator
 local ____ability = require("engine.internal.ability")
 local Ability = ____ability.Ability
+local UnitAbility = ____ability.UnitAbility
 local ____ability = require("engine.object-field.ability")
 local AbilityBooleanField = ____ability.AbilityBooleanField
 local AbilityNumberField = ____ability.AbilityNumberField
@@ -28,13 +30,11 @@ 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 check = ____preconditions.check
 local checkNotNull = ____preconditions.checkNotNull
 local ____effect = require("core.types.effect")
 local Effect = ____effect.Effect
@@ -43,9 +43,25 @@ local BuffType = ____buff_2Dtype.BuffType
 local ____unit = require("engine.behaviour.unit")
 local UnitBehavior = ____unit.UnitBehavior
 local ____arrays = require("utility.arrays")
+local emptyArray = ____arrays.emptyArray
 local forEach = ____arrays.forEach
+local ____event = require("event")
+local Event = ____event.Event
 local ____ability_2Dduration = require("engine.internal.mechanics.ability-duration")
 local getAbilityDuration = ____ability_2Dduration.getAbilityDuration
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____destructable = require("core.types.destructable")
+local Destructable = ____destructable.Destructable
+local ____ability = require("engine.standard.fields.ability")
+local COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD = ____ability.COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
+local ____records = require("utility.records")
+local sortedKeysUnnested = ____records.sortedKeysUnnested
+local ____sound = require("core.types.sound")
+local Sound3D = ____sound.Sound3D
+local SoundSettings = ____sound.SoundSettings
 local getUnitAbility = BlzGetUnitAbility
 local stringValueByBuffTypeIdByFieldId = postcompile(function()
     local stringValueByBuffTypeIdByFieldId = {}
@@ -91,14 +107,21 @@ local buffParametersKeys = {
     damageIncrease = true,
     damageIncreaseFactor = true,
     armorIncrease = true,
-    armorIncreaseFactor = true,
+    maxHealthIncrease = true,
+    maxManaIncrease = true,
     attackSpeedIncreaseFactor = true,
     movementSpeedIncreaseFactor = true,
+    manaRegenerationRateIncreaseFactor = true,
+    evasionProbability = true,
+    missProbability = true,
+    damageFactor = true,
     receivedDamageFactor = true,
+    returnedMeleeDamageFactor = true,
     receivedMagicDamageFactor = true,
     durationIncreaseOnAutoAttack = true,
     maximumDuration = true,
     maximumRemainingDuration = true,
+    turnsIntoGhost = true,
     stuns = true,
     ignoresStunImmunity = true,
     providesStunImmunity = true,
@@ -107,8 +130,32 @@ local buffParametersKeys = {
     disablesAutoAttack = true,
     destroysOnDamage = true,
     maximumAutoAttackCount = true,
-    uniqueGroup = true
+    maximumDamageDealtEventCount = true,
+    maximumDamageReceivedEventCount = true,
+    absorbedDamageFactor = true,
+    maximumDamageAbsorbed = true,
+    destroysOnMaximumDamageAbsorbed = true,
+    uniqueGroup = true,
+    destructionSoundPresetId = true,
+    damageOnExpiration = true,
+    healingOnExpiration = true,
+    killsOnExpiration = true,
+    explodesOnExpiration = true,
+    abilityCooldownFactor = true,
+    sharesVisionWithSource = true
 }
+local function resolveEnumValue(ability, level, value)
+    if value == nil or type(value) == "number" then
+        return value
+    end
+    if ability == nil then
+        error(
+            __TS__New(IllegalArgumentException),
+            0
+        )
+    end
+    return value:getValue(ability, level or ability.level)
+end
 local function resolveNumberValue(ability, level, value)
     if value == nil or type(value) == "number" then
         return value
@@ -145,20 +192,43 @@ local function resolveAndSetNumberValue(buff, property, ability, level, value, d
         buff[property] = resolvedValue
     end
 end
-local buffBooleanParameters = {"stuns", "ignoresStunImmunity", "disablesAutoAttack", "providesInvulnerability"}
+local buffBooleanParameters = {
+    "destroysOnMaximumDamageAbsorbed",
+    "turnsIntoGhost",
+    "stuns",
+    "ignoresStunImmunity",
+    "disablesAutoAttack",
+    "providesInvulnerability",
+    "killsOnExpiration",
+    "explodesOnExpiration",
+    "sharesVisionWithSource"
+}
 local buffNumberParameters = {
     "durationIncreaseOnAutoAttack",
     "attackSpeedIncreaseFactor",
     "movementSpeedIncreaseFactor",
+    "manaRegenerationRateIncreaseFactor",
+    "evasionProbability",
     "armorIncrease",
+    "maxHealthIncrease",
+    "maxManaIncrease",
+    "damageFactor",
     "receivedDamageFactor",
+    "returnedMeleeDamageFactor",
     "maximumAutoAttackCount",
+    "maximumDamageDealtEventCount",
+    "maximumDamageReceivedEventCount",
     "damageInterval",
     "damagePerInterval",
     "damageOverDuration",
     "healingInterval",
     "healingPerInterval",
-    "healingOverDuration"
+    "healingOverDuration",
+    "damageOnExpiration",
+    "healingOnExpiration",
+    "absorbedDamageFactor",
+    "maximumDamageAbsorbed",
+    "abilityCooldownFactor"
 }
 local unsuccessfulApplicationMarker = {}
 local function selectBuffTypeIdWithLeastDuration(buffTypeIds, unit)
@@ -185,81 +255,110 @@ local function selectBuffTypeIdWithLeastDuration(buffTypeIds, unit)
     return checkNotNull(firstNativeBuffTypeId)
 end
 local function destroyBuffIfItHasSameUniqueGroup(buff, uniqueGroup)
-    if buff[103] == uniqueGroup then
+    if buff[104] == uniqueGroup then
         buff:destroy()
     end
 end
 local function destroyBuff(buff)
     buff:destroy()
 end
+local function destroyBuffOnDeath(buff)
+    if buff[100] == 0 then
+        Timer:run(destroyBuff, buff)
+    else
+        buff:destroy()
+    end
+end
+local function shareVisionWithSource(buff)
+    local source = buff[102]
+    if source ~= nil then
+        local player = source.owner
+        buff[101]:incrementSharedVisionCounter(player)
+        buff[151] = player
+    end
+end
+local function unshareVisionWithSource(buff)
+    local player = buff[151]
+    if player ~= nil then
+        buff[101]:decrementSharedVisionCounter(player)
+        buff[151] = nil
+    end
+end
 local function expireBuff(buff)
-    local remainingDamageOverDuration = buff[112] or 0
-    local remainingHealingOverDuration = buff[112] or 0
+    if buff.isDestroyed or buff[100] ~= 1 then
+        return
+    end
+    buff[100] = 2
+    local remainingDamageOverDuration = buff[114] or 0
+    local remainingHealingOverDuration = buff[114] 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
+            (buff[102] or buff[101]):damageTarget(buff[101], remainingDamageOverDuration)
+            buff[114] = nil
         end
         if remainingHealingOverDuration ~= 0 then
-            (buff[101] or buff[100]):healTarget(buff[100], remainingHealingOverDuration)
-            buff[117] = nil
+            (buff[102] or buff[101]):healTarget(buff[101], remainingHealingOverDuration)
+            buff[119] = nil
         end
     end
     Timer:run(destroyBuff, buff)
+    buff:onExpiration()
 end
 local function buffDamageIntervalInitialTimerCallback(buff)
     buffDamageIntervalTimerCallback(buff)
-    local timer = buff[113]
-    local damageInterval = buff[111]
+    local timer = buff[115]
+    local damageInterval = buff[113]
     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
+    local source = buff[102] or buff[101]
+    local remainingDamageOverDuration = buff[114] or 0
     if remainingDamageOverDuration ~= 0 then
-        local damageInterval = buff[111] or 0
+        local damageInterval = buff[113] or 0
         if damageInterval ~= 0 then
             local damage = remainingDamageOverDuration / (1 + buff.remainingDuration / damageInterval)
-            source:damageTarget(buff[100], damage)
-            buff[112] = remainingDamageOverDuration - damage
+            source:damageTarget(buff[101], damage)
+            buff[114] = remainingDamageOverDuration - damage
         end
     end
-    local damagePerInterval = buff[110] or 0
+    local damagePerInterval = buff[112] or 0
     if remainingDamageOverDuration == 0 or damagePerInterval ~= 0 then
-        source:damageTarget(buff[100], damagePerInterval)
+        source:damageTarget(buff[101], damagePerInterval)
     end
 end
 local function buffHealingIntervalInitialTimerCallback(buff)
     buffHealingIntervalTimerCallback(buff)
-    local timer = buff[118]
-    local healingInterval = buff[116]
+    local timer = buff[120]
+    local healingInterval = buff[118]
     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
+    if buff[118] ~= buff[113] then
         buff:flashSpecialEffect()
     end
-    local source = buff[101] or buff[100]
-    local remainingHealingOverDuration = buff[117] or 0
+    local source = buff[102] or buff[101]
+    local remainingHealingOverDuration = buff[119] or 0
     if remainingHealingOverDuration ~= 0 then
-        local healingInterval = buff[116] or 0
+        local healingInterval = buff[118] or 0
         if healingInterval ~= 0 then
             local healing = remainingHealingOverDuration / (1 + buff.remainingDuration / healingInterval)
-            source:healTarget(buff[100], healing)
-            buff[117] = remainingHealingOverDuration - healing
+            source:healTarget(buff[101], healing)
+            buff[119] = remainingHealingOverDuration - healing
         end
     end
-    local healingPerInterval = buff[115] or 0
+    local healingPerInterval = buff[117] or 0
     if remainingHealingOverDuration == 0 or healingPerInterval ~= 0 then
-        source:healTarget(buff[100], healingPerInterval)
+        source:healTarget(buff[101], healingPerInterval)
     end
 end
+local buffCreatedEvent = __TS__New(Event)
+local buffBeingDestroyedEvent = __TS__New(Event)
 ____exports.Buff = __TS__Class()
 local Buff = ____exports.Buff
 Buff.name = "Buff"
@@ -268,40 +367,44 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
     UnitBehavior.prototype.____constructor(self, _unit)
     self._unit = _unit
     self.parameters = nil
-    self[100] = _unit
+    self[100] = 0
+    self[101] = _unit
     local typeId
     local polarity
     local resistanceType
     local ability
+    local abilityBehavior
     if type(typeIdOrTypeIds) ~= "number" then
         typeId = selectBuffTypeIdWithLeastDuration(typeIdOrTypeIds, _unit)
         polarity = resistanceTypeOrPolarity
         resistanceType = abilityOrParametersOrResistanceType
-        if __TS__InstanceOf(parametersOrAbility, Ability) then
+        if __TS__InstanceOf(parametersOrAbility, AbilityBehavior) then
+            abilityBehavior = parametersOrAbility
+            ability = abilityBehavior.ability
+        elseif __TS__InstanceOf(parametersOrAbility, Ability) then
             ability = parametersOrAbility
-        else
-            ability = nil
+        elseif parametersOrAbility ~= nil then
             parameters = parametersOrAbility
         end
     else
         typeId = typeIdOrTypeIds
         polarity = polarityOrTypeIdSelectionPolicy
         resistanceType = resistanceTypeOrPolarity
-        if __TS__InstanceOf(abilityOrParametersOrResistanceType, Ability) then
+        if __TS__InstanceOf(abilityOrParametersOrResistanceType, AbilityBehavior) then
+            abilityBehavior = abilityOrParametersOrResistanceType
+            ability = abilityBehavior.ability
+            parameters = parametersOrAbility
+        elseif __TS__InstanceOf(abilityOrParametersOrResistanceType, Ability) then
             ability = abilityOrParametersOrResistanceType
             parameters = parametersOrAbility
-        else
-            ability = nil
+        elseif abilityOrParametersOrResistanceType ~= nil then
             parameters = abilityOrParametersOrResistanceType
+        else
+            parameters = parametersOrAbility
         end
     end
+    self.sourceAbilityBehavior = abilityBehavior
     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
@@ -324,14 +427,22 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
         learnLevelMinimum = learnLevelMinimum or ability:getField(ABILITY_IF_REQUIRED_LEVEL)
         duration = duration or getAbilityDuration(ability, _unit)
     end
+    self.polarity = resolveEnumValue(ability, level, polarity)
+    self.resistanceType = resolveEnumValue(ability, level, resistanceType)
+    local missProbability = parameters and parameters.missProbability or defaultParameters.missProbability
+    if missProbability ~= nil then
+        missProbability = resolveNumberValue(ability, level, missProbability)
+        self[147] = missProbability
+    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()
+    self.previousBuff = buffByTypeId[typeId]
+    local ____opt_15 = self.previousBuff
+    if ____opt_15 ~= nil then
+        ____opt_15:destroy()
     end
     local uniqueGroup = parameters and parameters.uniqueGroup or defaultParameters and defaultParameters.uniqueGroup
     if uniqueGroup ~= nil then
@@ -340,18 +451,21 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
     if not internalApplyBuff(
         _unit,
         typeId,
-        polarity,
-        resistanceType,
+        self.polarity,
+        self.resistanceType,
         level,
         duration,
         spellStealPriority,
-        learnLevelMinimum
+        learnLevelMinimum,
+        missProbability
     ) then
+        self[100] = 1
         UnitBehavior.prototype.destroy(self)
         error(unsuccessfulApplicationMarker, 0)
     end
     local handle = BlzGetUnitAbility(_unit.handle, typeId)
     if handle == nil then
+        self[100] = 1
         UnitBehavior.prototype.destroy(self)
         error(unsuccessfulApplicationMarker, 0)
     end
@@ -360,20 +474,21 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
     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)
+    self[102] = source
+    self[103] = duration or 0
+    self[104] = uniqueGroup
+    self[105] = parameters and parameters.destructionSoundPresetId or defaultParameters and defaultParameters.destructionSoundPresetId
+    self[106] = BlzGetAbilityStringLevelField(self.handle, ABILITY_SLF_EFFECT, 0)
+    self[107] = 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]
+            local ____ability_28 = ability
+            local ____level_29 = level
+            local ____temp_27 = parameters and parameters[buffBooleanParameter]
+            if ____temp_27 == nil then
+                ____temp_27 = defaultParameters[buffBooleanParameter]
             end
-            if resolveBooleanValue(____ability_22, ____level_23, ____temp_21) then
+            if resolveBooleanValue(____ability_28, ____level_29, ____temp_27) then
                 self[buffBooleanParameter] = true
             end
         end
@@ -389,11 +504,11 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
         end
         local maximumDuration = parameters and parameters.maximumDuration or defaultParameters.maximumDuration
         if maximumDuration ~= nil then
-            self[107] = resolveNumberValue(ability, level, maximumDuration)
+            self[109] = resolveNumberValue(ability, level, maximumDuration)
         end
         local maximumRemainingDuration = parameters and parameters.maximumRemainingDuration or defaultParameters.maximumRemainingDuration
         if maximumRemainingDuration ~= nil then
-            self[108] = resolveNumberValue(ability, level, maximumRemainingDuration)
+            self[110] = resolveNumberValue(ability, level, maximumRemainingDuration)
         end
         local parametersAbilityTypeIds = parameters and parameters.abilityTypeIds or defaultParameters.abilityTypeIds
         if parametersAbilityTypeIds ~= nil then
@@ -402,24 +517,22 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
                 abilityTypeIds = {}
                 self._abilityTypeIds = abilityTypeIds
             end
-            for abilityTypeId, abilityParameters in pairs(parametersAbilityTypeIds) do
+            for ____, abilityTypeId in ipairs(sortedKeysUnnested(parametersAbilityTypeIds)) do
+                local abilityParameters = checkNotNull(parametersAbilityTypeIds[abilityTypeId])
                 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
+                    if abilityParameters.isButtonVisible == false then
+                        _unit:hideAbility(abilityTypeId, true)
                     end
-                    abilityTypeIds[abilityTypeId] = true
+                    for ____, field in ipairs(abilityParameters.fields or emptyArray()) do
+                        field[1]:setValue(
+                            addedAbility,
+                            resolveNumberValue(ability, level, field[2])
+                        )
+                    end
+                    abilityTypeIds[#abilityTypeIds + 1] = abilityTypeId
                 end
             end
             local behaviorConstructors = parameters and parameters.behaviorConstructors or defaultParameters.behaviorConstructors
@@ -431,18 +544,20 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
                 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
+        if parameters ~= nil then
+            local additionalParameters = {}
+            for ____, key in ipairs(sortedKeysUnnested(parameters)) do
+                if not buffParametersKeys[key] then
+                    if ability then
+                        additionalParameters[key] = resolveCurrentAbilityDependentValue(ability, parameters[key])
+                    else
+                        additionalParameters[key] = parameters[key]
+                    end
                 end
             end
-        end
-        if (next(additionalParameters)) ~= nil then
-            self.parameters = additionalParameters
+            if (next(additionalParameters)) ~= nil then
+                self.parameters = additionalParameters
+            end
         end
     end
     if duration ~= nil and duration > 0 then
@@ -450,77 +565,107 @@ function Buff.prototype.____constructor(self, _unit, typeIdOrTypeIds, polarityOr
         timer:start(duration, false, expireBuff, self)
         self._timer = timer
     end
+    self:onCreate()
+    self[100] = 1
+    Event.invoke(buffCreatedEvent, self)
 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
+function Buff.prototype.onAbilityGained(self, ability)
+    if __TS__InstanceOf(ability, UnitAbility) then
+        local abilityCooldownModifier = self[149]
+        if abilityCooldownModifier then
+            COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:applyModifier(ability, abilityCooldownModifier)
+        end
     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
+function Buff.prototype.onAbilityLost(self, ability)
+    if __TS__InstanceOf(ability, UnitAbility) then
+        local abilityCooldownModifier = self[149]
+        if abilityCooldownModifier then
+            COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:removeModifier(ability, abilityCooldownModifier)
+        end
     end
-    __TS__SparseArrayPush(____array_39, ____isWidgetProvided_38)
-    ____Effect_flash_41(
-        ____Effect_40,
-        __TS__SparseArraySpread(____array_39)
+end
+function Buff.prototype.flashEffect(self, widgetOrXOrParametersOrDuration, yOrParametersOrDuration, parametersOrDuration)
+    self:flash(
+        self[106],
+        stringValueByBuffTypeIdByFieldId[fourCC("feft")][self.typeId] or "origin",
+        widgetOrXOrParametersOrDuration,
+        yOrParametersOrDuration,
+        parametersOrDuration
     )
 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"
+function Buff.prototype.flashSpecialEffect(self, widgetOrXOrParametersOrDuration, yOrParametersOrDuration, parametersOrDuration)
+    self:flash(
+        self[107],
+        stringValueByBuffTypeIdByFieldId[fourCC("fspt")][self.typeId] or "origin",
+        widgetOrXOrParametersOrDuration,
+        yOrParametersOrDuration,
+        parametersOrDuration
     )
-    local ____isWidgetProvided_42
-    if isWidgetProvided then
-        ____isWidgetProvided_42 = duration
+end
+function Buff.prototype.flash(self, modelPath, attachmentPoint, widgetOrXOrParametersOrDuration, yOrParametersOrDuration, parametersOrDuration)
+    if type(widgetOrXOrParametersOrDuration) == "number" and type(yOrParametersOrDuration) == "number" then
+        Effect:flash(modelPath, widgetOrXOrParametersOrDuration, yOrParametersOrDuration, parametersOrDuration)
     else
-        ____isWidgetProvided_42 = widgetOrDuration
+        local isWidgetProvided = __TS__InstanceOf(widgetOrXOrParametersOrDuration, Unit) or __TS__InstanceOf(widgetOrXOrParametersOrDuration, Item) or __TS__InstanceOf(widgetOrXOrParametersOrDuration, Destructable)
+        local ____Effect_44 = Effect
+        local ____Effect_flash_45 = Effect.flash
+        local ____array_43 = __TS__SparseArrayNew(modelPath, isWidgetProvided and widgetOrXOrParametersOrDuration or self._unit, attachmentPoint)
+        local ____isWidgetProvided_42
+        if isWidgetProvided then
+            ____isWidgetProvided_42 = yOrParametersOrDuration
+        else
+            ____isWidgetProvided_42 = widgetOrXOrParametersOrDuration
+        end
+        __TS__SparseArrayPush(____array_43, ____isWidgetProvided_42)
+        ____Effect_flash_45(
+            ____Effect_44,
+            __TS__SparseArraySpread(____array_43)
+        )
     end
-    __TS__SparseArrayPush(____array_43, ____isWidgetProvided_42)
-    ____Effect_flash_45(
-        ____Effect_44,
-        __TS__SparseArraySpread(____array_43)
-    )
+end
+function Buff.prototype.expire(self)
+    expireBuff(self)
+end
+function Buff.prototype.dispel(self, source)
+    if self.isDestroyed or self[100] ~= 1 then
+        return
+    end
+    self[100] = 2
+    do
+        pcall(function()
+            self:onDispel(source)
+        end)
+        do
+            self:destroy()
+        end
+    end
+end
+function Buff.prototype.onCreate(self)
 end
 function Buff.prototype.onDestroy(self)
+    check(self[100] ~= 0, "Cannot destroy a buff that has not finished creating yet.")
+    self[100] = 2
     local unit = self._unit
+    local destructionSoundPresetId = self[105]
+    if destructionSoundPresetId ~= nil then
+        Sound3D:playFromLabel(destructionSoundPresetId, SoundSettings.Ability, unit)
+    end
     if getUnitAbility(unit.handle, self.typeId) == self.handle then
         removeBuff(unit.handle, self.typeId)
+    else
+        removeBuffApplicator(unit.handle, self.typeId)
     end
     buffByTypeIdByUnit[unit][self.typeId] = nil
-    local healingIntervalTimer = self[118]
+    local healingIntervalTimer = self[120]
     if healingIntervalTimer ~= nil then
         healingIntervalTimer:destroy()
-        self[118] = nil
+        self[120] = nil
     end
-    local damageIntervalTimer = self[113]
+    local damageIntervalTimer = self[115]
     if damageIntervalTimer ~= nil then
         damageIntervalTimer:destroy()
-        self[113] = nil
+        self[115] = nil
     end
     if self._timer ~= nil then
         self._timer:destroy()
@@ -530,25 +675,35 @@ function Buff.prototype.onDestroy(self)
             behavior:destroy()
         end
     end
-    if self[130] then
+    local previousAbilityCooldownModifier = self[149]
+    if previousAbilityCooldownModifier then
+        for ____, ability in ipairs(self._unit.abilities) do
+            COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:removeModifier(ability, previousAbilityCooldownModifier)
+        end
+    end
+    if self[144] then
+        unit:decrementInvulnerabilityCounter()
+    end
+    if self[143] then
         unit:decrementDisableAutoAttackCounter()
     end
-    if self[128] then
-        if self[129] then
-            unit:decrementStunCounter()
+    if self[141] then
+        if self[142] then
+            unit:decrementForceStunCounter()
         end
         unit:decrementStunCounter()
     end
+    if self[140] then
+        unit:decrementGhostCounter()
+    end
+    unshareVisionWithSource(self)
     if self._abilityTypeIds ~= nil then
-        for abilityTypeId in pairs(self._abilityTypeIds) do
+        for ____, abilityTypeId in ipairs(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
+    Event.invoke(buffBeingDestroyedEvent, self)
+    self[100] = 3
     return UnitBehavior.prototype.onDestroy(self)
 end
 function Buff.apply(self, ...)
@@ -583,44 +738,88 @@ function Buff.getByTypeId(self, unit, typeId)
     end
     return nil
 end
+function Buff.prototype.onDispel(self, source)
+end
+function Buff.prototype.onExpiration(self)
+    local unit = self.unit
+    if self[121] ~= nil then
+        (self[102] or unit):damageTarget(unit, self[121] or 0)
+    end
+    if self[122] ~= nil then
+        (self[102] or unit):healTarget(unit, self[121] or 0)
+    end
+    if self[146] then
+        unit:explode()
+    elseif self[145] then
+        unit:kill()
+    end
+end
 function Buff.prototype.onDeath(self, source)
     local unit = self.unit
-    if self[119] ~= nil then
+    if self[123] ~= nil then
         damageArea(
-            self[101] or unit,
-            self[119],
+            self[102] or unit,
+            self[123],
             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
+            self[124] or 0,
+            self[127] or 0,
+            self[126] or 0,
+            self[129] or 0,
+            self[128] 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 self[108] ~= nil then
+            local durationIncrease = self[108]
+            local maximumDuration = self[109] or 0
             if maximumDuration > 0 then
                 durationIncrease = min(
                     durationIncrease,
-                    max(0, maximumDuration - self[102])
+                    max(0, maximumDuration - self[103])
                 )
             end
             local remainingDuration = self.remainingDuration + durationIncrease
-            local maximumRemainingDuration = self[108] or 0
+            local maximumRemainingDuration = self[110] 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
+        local autoAttackCount = (self[130] or 0) + 1
+        self[130] = autoAttackCount
+        if autoAttackCount == self[131] then
+            self:destroy()
+        end
+    end
+    if event.originalAmount ~= 0 then
+        local damageDealtEventCount = (self[132] or 0) + 1
+        self[132] = damageDealtEventCount
+        if damageDealtEventCount == self[133] then
+            self:destroy()
+        end
+    end
+end
+function Buff.prototype.onDamageReceived(self, source, event)
+    if event.originalAmount ~= 0 then
+        local absorbedDamage = min(event.amount * (self[136] or 1), (self[137] or 0) - (self[138] or 0))
+        if absorbedDamage > 0 then
+            event.amount = event.amount - absorbedDamage
+            self[138] = (self[138] or 0) + absorbedDamage
+            local ____self__139_48 = self[139]
+            if ____self__139_48 == nil then
+                ____self__139_48 = true
+            end
+            if ____self__139_48 and self[138] >= (self[137] or 0) then
+                self:destroy()
+            end
+        end
+        local damageReceivedEventCount = (self[134] or 0) + 1
+        self[134] = damageReceivedEventCount
+        if damageReceivedEventCount == self[135] then
             self:destroy()
         end
     end
@@ -630,7 +829,7 @@ __TS__SetDescriptor(
     Buff.prototype,
     "source",
     {get = function(self)
-        return self[101] or self._unit
+        return self[102] or self._unit
     end},
     true
 )
@@ -647,13 +846,13 @@ __TS__SetDescriptor(
     "remainingDamageOverDuration",
     {
         get = function(self)
-            return self[112] or 0
+            return self[114] 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
+            local remainingDamageOverDurationDelta = remainingDamageOverDuration - (self[114] or 0)
+            self[114] = remainingDamageOverDuration ~= 0 and remainingDamageOverDuration or nil
+            local damageOverDuration = (self[111] or 0) + remainingDamageOverDurationDelta
+            self[111] = damageOverDuration ~= 0 and damageOverDuration or nil
         end
     },
     true
@@ -663,13 +862,13 @@ __TS__SetDescriptor(
     "damageOverDuration",
     {
         get = function(self)
-            return self[109] or 0
+            return self[111] 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
+            local damageOverDurationDelta = damageOverDuration - (self[111] or 0)
+            self[111] = damageOverDuration ~= 0 and damageOverDuration or nil
+            local remainingDamageOverDuration = (self[114] or 0) + damageOverDurationDelta
+            self[114] = remainingDamageOverDuration ~= 0 and remainingDamageOverDuration or nil
         end
     },
     true
@@ -679,10 +878,10 @@ __TS__SetDescriptor(
     "damagePerInterval",
     {
         get = function(self)
-            return self[110] or 0
+            return self[112] or 0
         end,
         set = function(self, damagePerInterval)
-            self[110] = damagePerInterval ~= 0 and damagePerInterval or nil
+            self[112] = damagePerInterval ~= 0 and damagePerInterval or nil
         end
     },
     true
@@ -692,25 +891,25 @@ __TS__SetDescriptor(
     "damageInterval",
     {
         get = function(self)
-            return self[111] or 0
+            return self[113] or 0
         end,
         set = function(self, damageInterval)
             if damageInterval <= 0 then
-                self[111] = damageInterval ~= 0 and damageInterval or nil
-                local timer = self[113]
+                self[113] = damageInterval ~= 0 and damageInterval or nil
+                local timer = self[115]
                 if timer ~= nil then
                     timer:destroy()
-                    self[113] = nil
+                    self[115] = 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]
+            self[113] = damageInterval
+            local ____opt_49 = self._timer
+            local elapsed = ____opt_49 and ____opt_49.elapsed or 0
+            local timer = self[115]
             if timer == nil then
                 timer = Timer:create()
-                self[113] = timer
+                self[115] = timer
             end
             local initialDelay = damageInterval - (elapsed >= damageInterval and math.fmod(elapsed, damageInterval) or elapsed)
             if initialDelay == damageInterval then
@@ -727,13 +926,13 @@ __TS__SetDescriptor(
     "remainingHealingOverDuration",
     {
         get = function(self)
-            return self[117] or 0
+            return self[119] 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
+            local remainingHealingOverDurationDelta = remainingHealingOverDuration - (self[119] or 0)
+            self[114] = remainingHealingOverDuration ~= 0 and remainingHealingOverDuration or nil
+            local healingOverDuration = (self[116] or 0) + remainingHealingOverDurationDelta
+            self[116] = healingOverDuration ~= 0 and healingOverDuration or nil
         end
     },
     true
@@ -743,13 +942,13 @@ __TS__SetDescriptor(
     "healingOverDuration",
     {
         get = function(self)
-            return self[114] or 0
+            return self[116] 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
+            local healingOverDurationDelta = healingOverDuration - (self[116] or 0)
+            self[116] = healingOverDuration ~= 0 and healingOverDuration or nil
+            local remainingHealingOverDuration = (self[119] or 0) + healingOverDurationDelta
+            self[119] = remainingHealingOverDuration ~= 0 and remainingHealingOverDuration or nil
         end
     },
     true
@@ -759,10 +958,10 @@ __TS__SetDescriptor(
     "healingPerInterval",
     {
         get = function(self)
-            return self[115] or 0
+            return self[117] or 0
         end,
         set = function(self, healingPerInterval)
-            self[115] = healingPerInterval ~= 0 and healingPerInterval or nil
+            self[117] = healingPerInterval ~= 0 and healingPerInterval or nil
         end
     },
     true
@@ -772,25 +971,25 @@ __TS__SetDescriptor(
     "healingInterval",
     {
         get = function(self)
-            return self[116] or 0
+            return self[118] or 0
         end,
         set = function(self, healingInterval)
             if healingInterval <= 0 then
-                self[116] = healingInterval ~= 0 and healingInterval or nil
-                local timer = self[118]
+                self[118] = healingInterval ~= 0 and healingInterval or nil
+                local timer = self[120]
                 if timer ~= nil then
                     timer:destroy()
-                    self[118] = nil
+                    self[120] = 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]
+            self[118] = healingInterval
+            local ____opt_51 = self._timer
+            local elapsed = ____opt_51 and ____opt_51.elapsed or 0
+            local timer = self[120]
             if timer == nil then
                 timer = Timer:create()
-                self[118] = timer
+                self[120] = timer
             end
             local initialDelay = healingInterval - (elapsed >= healingInterval and math.fmod(elapsed, healingInterval) or elapsed)
             if initialDelay == healingInterval then
@@ -802,6 +1001,45 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damageOnExpiration",
+    {
+        get = function(self)
+            return self[121] or 0
+        end,
+        set = function(self, damageOnExpiration)
+            self[121] = damageOnExpiration ~= 0 and damageOnExpiration or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "healingOnExpiration",
+    {
+        get = function(self)
+            return self[122] or 0
+        end,
+        set = function(self, healingOnExpiration)
+            self[122] = healingOnExpiration ~= 0 and healingOnExpiration or nil
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damageFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.DAMAGE_FACTOR)
+        end,
+        set = function(self, damageFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.DAMAGE_FACTOR, damageFactor)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Buff.prototype,
     "receivedDamageFactor",
@@ -815,6 +1053,19 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Buff.prototype,
+    "returnedMeleeDamageFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.RETURNED_MELEE_DAMAGE_FACTOR)
+        end,
+        set = function(self, returnedMeleeDamageFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.RETURNED_MELEE_DAMAGE_FACTOR, returnedMeleeDamageFactor)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Buff.prototype,
     "armorIncrease",
@@ -828,30 +1079,79 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maxHealthIncrease",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.HEALTH)
+        end,
+        set = function(self, maxHealthIncrease)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.HEALTH, maxHealthIncrease)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maxManaIncrease",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.MANA)
+        end,
+        set = function(self, maxManaIncrease)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.MANA, maxManaIncrease)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "turnsIntoGhost",
+    {
+        get = function(self)
+            local ____self__140_53 = self[140]
+            if ____self__140_53 == nil then
+                ____self__140_53 = false
+            end
+            return ____self__140_53
+        end,
+        set = function(self, turnsIntoGhost)
+            if not turnsIntoGhost and self[140] then
+                self.object:decrementGhostCounter()
+                self[140] = nil
+            elseif turnsIntoGhost and not self[140] then
+                self.object:incrementGhostCounter()
+                self[140] = true
+            end
+        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
+            local ____self__141_54 = self[141]
+            if ____self__141_54 == nil then
+                ____self__141_54 = false
             end
-            return ____self__128_52
+            return ____self__141_54
         end,
         set = function(self, stuns)
-            if not stuns and self[128] then
-                if self[129] then
-                    self.object:decrementStunCounter()
+            if not stuns and self[141] then
+                if self[142] then
+                    self.object:decrementForceStunCounter()
                 end
                 self.object:decrementStunCounter()
-                self[128] = nil
-            elseif stuns and not self[128] then
-                if self[129] then
-                    self.object:incrementStunCounter()
+                self[141] = nil
+            elseif stuns and not self[141] then
+                if self[142] then
+                    self.object:incrementForceStunCounter()
                 end
                 self.object:incrementStunCounter()
-                self[128] = true
+                self[141] = true
             end
         end
     },
@@ -862,23 +1162,23 @@ __TS__SetDescriptor(
     "ignoresStunImmunity",
     {
         get = function(self)
-            local ____self__129_53 = self[129]
-            if ____self__129_53 == nil then
-                ____self__129_53 = false
+            local ____self__142_55 = self[142]
+            if ____self__142_55 == nil then
+                ____self__142_55 = false
             end
-            return ____self__129_53
+            return ____self__142_55
         end,
         set = function(self, ignoresStunImmunity)
-            if not ignoresStunImmunity and self[129] then
-                if self[128] then
-                    self.object:decrementStunCounter()
+            if not ignoresStunImmunity and self[142] then
+                if self[141] then
+                    self.object:decrementForceStunCounter()
                 end
-                self[129] = nil
-            elseif ignoresStunImmunity and not self[129] then
-                if self[128] then
-                    self.object:incrementStunCounter()
+                self[142] = nil
+            elseif ignoresStunImmunity and not self[142] then
+                if self[141] then
+                    self.object:incrementForceStunCounter()
                 end
-                self[129] = true
+                self[142] = true
             end
         end
     },
@@ -889,19 +1189,19 @@ __TS__SetDescriptor(
     "disablesAutoAttack",
     {
         get = function(self)
-            local ____self__130_54 = self[130]
-            if ____self__130_54 == nil then
-                ____self__130_54 = false
+            local ____self__143_56 = self[143]
+            if ____self__143_56 == nil then
+                ____self__143_56 = false
             end
-            return ____self__130_54
+            return ____self__143_56
         end,
         set = function(self, disablesAutoAttack)
-            if not disablesAutoAttack and self[130] then
+            if not disablesAutoAttack and self[143] then
                 self.object:decrementDisableAutoAttackCounter()
-                self[130] = nil
-            elseif disablesAutoAttack and not self[130] then
+                self[143] = nil
+            elseif disablesAutoAttack and not self[143] then
                 self.object:incrementDisableAutoAttackCounter()
-                self[130] = true
+                self[143] = true
             end
         end
     },
@@ -912,19 +1212,118 @@ __TS__SetDescriptor(
     "providesInvulnerability",
     {
         get = function(self)
-            local ____self__131_55 = self[131]
-            if ____self__131_55 == nil then
-                ____self__131_55 = false
+            local ____self__144_57 = self[144]
+            if ____self__144_57 == nil then
+                ____self__144_57 = false
             end
-            return ____self__131_55
+            return ____self__144_57
         end,
         set = function(self, providesInvulnerability)
-            if not providesInvulnerability and self[131] then
+            if not providesInvulnerability and self[144] then
                 self.object:decrementInvulnerabilityCounter()
-                self[131] = nil
-            elseif providesInvulnerability and not self[131] then
+                self[144] = nil
+            elseif providesInvulnerability and not self[144] then
                 self.object:incrementInvulnerabilityCounter()
-                self[131] = true
+                self[144] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "killsOnExpiration",
+    {
+        get = function(self)
+            local ____self__145_58 = self[145]
+            if ____self__145_58 == nil then
+                ____self__145_58 = false
+            end
+            return ____self__145_58
+        end,
+        set = function(self, killsOnExpiration)
+            if not killsOnExpiration and self[145] then
+                self[145] = nil
+            elseif killsOnExpiration and not self[145] then
+                self[145] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "explodesOnExpiration",
+    {
+        get = function(self)
+            local ____self__146_59 = self[146]
+            if ____self__146_59 == nil then
+                ____self__146_59 = false
+            end
+            return ____self__146_59
+        end,
+        set = function(self, killsOnExpiration)
+            if not killsOnExpiration and self[146] then
+                self[146] = nil
+            elseif killsOnExpiration and not self[146] then
+                self[146] = true
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "sharesVisionWithSource",
+    {
+        get = function(self)
+            local ____self__150_60 = self[150]
+            if ____self__150_60 == nil then
+                ____self__150_60 = false
+            end
+            return ____self__150_60
+        end,
+        set = function(self, sharesVisionWithSource)
+            if not sharesVisionWithSource and self[150] then
+                unshareVisionWithSource(self)
+                self[150] = nil
+            elseif sharesVisionWithSource and not self[150] then
+                self[150] = true
+                shareVisionWithSource(self)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maximumDamageDealtEventCount",
+    {
+        get = function(self)
+            return self[133] or 0
+        end,
+        set = function(self, maximumDamageDealtEventCount)
+            if maximumDamageDealtEventCount == 0 then
+                self[133] = nil
+            else
+                self[133] = maximumDamageDealtEventCount
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maximumDamageReceivedEventCount",
+    {
+        get = function(self)
+            return self[135] or 0
+        end,
+        set = function(self, maximumDamageReceivedEventCount)
+            if maximumDamageReceivedEventCount == 0 then
+                self[135] = nil
+            else
+                self[135] = maximumDamageReceivedEventCount
             end
         end
     },
@@ -935,13 +1334,13 @@ __TS__SetDescriptor(
     "maximumAutoAttackCount",
     {
         get = function(self)
-            return self[127] or 0
+            return self[131] or 0
         end,
         set = function(self, maximumAutoAttackCount)
             if maximumAutoAttackCount == 0 then
-                self[127] = nil
+                self[131] = nil
             else
-                self[127] = maximumAutoAttackCount
+                self[131] = maximumAutoAttackCount
             end
         end
     },
@@ -952,10 +1351,10 @@ __TS__SetDescriptor(
     "durationIncreaseOnAutoAttack",
     {
         get = function(self)
-            return self[106] or 0
+            return self[108] or 0
         end,
         set = function(self, durationIncreaseOnAutoAttack)
-            self[106] = durationIncreaseOnAutoAttack
+            self[108] = durationIncreaseOnAutoAttack
         end
     },
     true
@@ -986,12 +1385,52 @@ __TS__SetDescriptor(
     },
     true
 )
+__TS__SetDescriptor(
+    Buff.prototype,
+    "evasionProbability",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.EVASION_PROBABILITY)
+        end,
+        set = function(self, evasionProbability)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.EVASION_PROBABILITY, evasionProbability)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "manaRegenerationRateIncreaseFactor",
+    {
+        get = function(self)
+            return self:getUnitBonus(UnitBonusType.MANA_REGENERATION_RATE_FACTOR)
+        end,
+        set = function(self, manaRegenerationRateIncreaseFactor)
+            self:addOrUpdateOrRemoveUnitBonus(UnitBonusType.MANA_REGENERATION_RATE_FACTOR, manaRegenerationRateIncreaseFactor)
+        end
+    },
+    true
+)
 __TS__SetDescriptor(
     Buff.prototype,
     "duration",
-    {get = function(self)
-        return self[102]
-    end},
+    {
+        get = function(self)
+            return self[103]
+        end,
+        set = function(self, duration)
+            if duration <= 0 then
+                local timer = self._timer
+                if timer ~= nil then
+                    timer:destroy()
+                    self._timer = nil
+                end
+                self[103] = 0
+            else
+                self.remainingDuration = self.remainingDuration + (duration - self[103])
+            end
+        end
+    },
     true
 )
 __TS__SetDescriptor(
@@ -999,15 +1438,15 @@ __TS__SetDescriptor(
     "remainingDuration",
     {
         get = function(self)
-            local ____opt_56 = self._timer
-            return ____opt_56 and ____opt_56.remaining or 0
+            local ____opt_61 = self._timer
+            return ____opt_61 and ____opt_61.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)
+            local ____remainingDuration_65 = remainingDuration
+            local ____opt_63 = self._timer
+            local remainingDurationDelta = ____remainingDuration_65 - (____opt_63 and ____opt_63.remaining or 0)
             if remainingDurationDelta ~= 0 then
-                self[102] = self[102] + remainingDurationDelta
+                self[103] = self[103] + remainingDurationDelta
                 if remainingDuration <= 0 then
                     Timer:run(destroyBuff, self)
                 else
@@ -1019,7 +1458,8 @@ __TS__SetDescriptor(
                         self._level,
                         remainingDuration,
                         self._spellStealPriority,
-                        self._learnLevelMinimum
+                        self._learnLevelMinimum,
+                        self[147]
                     ) then
                         local timer = self._timer
                         if timer == nil then
@@ -1033,39 +1473,135 @@ __TS__SetDescriptor(
         end
     },
     true
-);
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "absorbedDamageFactor",
+    {
+        get = function(self)
+            return self[136] or 1
+        end,
+        set = function(self, absorbedDamageFactor)
+            if absorbedDamageFactor == 1 then
+                self[136] = nil
+            else
+                self[136] = absorbedDamageFactor
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "maximumDamageAbsorbed",
+    {
+        get = function(self)
+            return self[137] or 0
+        end,
+        set = function(self, maximumDamageAbsorbed)
+            if maximumDamageAbsorbed == 0 then
+                self[137] = nil
+            else
+                self[137] = maximumDamageAbsorbed
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "damageAbsorbed",
+    {get = function(self)
+        return self[138] or 0
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "destroysOnMaximumDamageAbsorbed",
+    {
+        get = function(self)
+            local ____self__139_66 = self[139]
+            if ____self__139_66 == nil then
+                ____self__139_66 = true
+            end
+            return ____self__139_66
+        end,
+        set = function(self, destroysOnMaximumDamageAbsorbed)
+            local ____destroysOnMaximumDamageAbsorbed_67
+            if destroysOnMaximumDamageAbsorbed then
+                ____destroysOnMaximumDamageAbsorbed_67 = nil
+            else
+                ____destroysOnMaximumDamageAbsorbed_67 = false
+            end
+            self[139] = ____destroysOnMaximumDamageAbsorbed_67
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Buff.prototype,
+    "abilityCooldownFactor",
+    {
+        get = function(self)
+            return self[148] or 1
+        end,
+        set = function(self, abilityCooldownFactor)
+            local previousAbilityCooldownModifier = self[149]
+            if previousAbilityCooldownModifier then
+                for ____, ability in ipairs(self._unit.abilities) do
+                    COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:removeModifier(ability, previousAbilityCooldownModifier)
+                end
+            end
+            local function modifier(ability, level, cooldown)
+                return cooldown * abilityCooldownFactor
+            end
+            for ____, ability in ipairs(self._unit.abilities) do
+                COOLDOWN_ABILITY_FLOAT_LEVEL_FIELD:applyModifier(ability, modifier)
+            end
+            self[149] = modifier
+            self[148] = abilityCooldownFactor
+        end
+    },
+    true
+)
+Buff.createdEvent = buffCreatedEvent
+Buff.beingDestroyedEvent = buffBeingDestroyedEvent;
 (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
+    local function destroyBuffIfNeeded(buff, isDispel, source)
+        local currentHandle = getUnitAbility(buff[101].handle, buff.typeId)
+        if currentHandle ~= buff.handle and buff[100] == 1 then
+            if isDispel and currentHandle == nil and buff.unit.isAlive and buff.resistanceType == 1 and (buff._timer == nil or buff.remainingDuration > 0) then
+                buff:dispel(source)
+            else
                 buff:destroy()
             end
         end
     end
-    ____exports.checkBuffs = function(unit)
+    ____exports.checkBuff = function(unit, buffTypeId, isDispel, source)
         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
+            local buff = buffByTypeId[buffTypeId]
+            if buff ~= nil then
+                destroyBuffIfNeeded(buff, isDispel, source)
             end
         end
     end
+    ____exports.checkBuffs = function(unit, isDispel, source)
+        ____exports.Buff:forAll(unit, destroyBuffIfNeeded, isDispel, source)
+    end
     Unit.abilityChannelingStartEvent:addListener(
         0,
         function(caster)
-            ____exports.checkBuffs(caster)
-            Timer:run(____exports.checkBuffs, caster)
+            ____exports.checkBuffs(caster, true, caster)
+            Timer:run(____exports.checkBuffs, caster, true, caster)
         end
     )
     Unit.abilityUnitTargetChannelingStartEvent:addListener(
         0,
         function(caster, ability, target)
-            ____exports.checkBuffs(target)
-            Timer:run(____exports.checkBuffs, target)
+            ____exports.checkBuffs(target, true, caster)
+            Timer:run(____exports.checkBuffs, target, true, caster)
         end
     )
     Unit.abilityPointTargetChannelingStartEvent:addListener(
@@ -1076,18 +1612,53 @@ __TS__SetDescriptor(
                 y,
                 ability:getField(ABILITY_RLF_AREA_OF_EFFECT)
             )
-            forEach(units, ____exports.checkBuffs)
-            Timer:run(forEach, units, ____exports.checkBuffs)
+            forEach(units, ____exports.checkBuffs, true, caster)
+            Timer:run(
+                forEach,
+                units,
+                ____exports.checkBuffs,
+                true,
+                caster
+            )
+        end
+    )
+    Unit.abilityNoTargetChannelingStartEvent:addListener(
+        0,
+        function(caster, ability)
+            local radius = ability:getField(ABILITY_RLF_AREA_OF_EFFECT)
+            if radius > 0 then
+                local units = Unit:getInCollisionRange(caster.x, caster.y, radius)
+                forEach(units, ____exports.checkBuffs, true, caster)
+                Timer:run(
+                    forEach,
+                    units,
+                    ____exports.checkBuffs,
+                    true,
+                    caster
+                )
+            end
         end
     )
     Unit.onDamage:addListener(
         0,
         function(source, target)
             if source ~= nil then
-                ____exports.checkBuffs(source)
+                Timer:run(____exports.checkBuffs, source, false)
             end
-            ____exports.checkBuffs(target)
+            Timer:run(____exports.checkBuffs, target, false)
+        end
+    )
+    Unit.deathEvent:addListener(
+        -999999,
+        function(unit)
+            ____exports.Buff:forAll(unit, destroyBuffOnDeath)
         end
     )
+    buffCreatedEvent:addListener(function(buff)
+        UnitBehavior:forAll(buff.unit, "onBuffGained", buff)
+    end)
+    buffBeingDestroyedEvent:addListener(function(buff)
+        UnitBehavior:forAll(buff.unit, "onBuffLost", buff)
+    end)
 end)(Buff)
 return ____exports