warscript 0.0.1-dev.404878c

package/engine/internal/unit/ability.lua

@@ -0,0 +1,369 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____ability = require("engine.internal.ability")
+local ItemAbility = ____ability.ItemAbility
+local UnitAbility = ____ability.UnitAbility
+local UnrecognizedAbility = ____ability.UnrecognizedAbility
+local ____destructable = require("core.types.destructable")
+local Destructable = ____destructable.Destructable
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local UnitTriggerEvent = ____unit.UnitTriggerEvent
+local ____event = require("event")
+local createDispatchingEvent = ____event.createDispatchingEvent
+local DependentInitializingEvent = ____event.DependentInitializingEvent
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+local getItemAbility = BlzGetItemAbility
+local getSpellAbility = GetSpellAbility
+local getSpellAbilityId = GetSpellAbilityId
+local getSpellTargetDestructible = GetSpellTargetDestructable
+local getSpellTargetItem = GetSpellTargetItem
+local getSpellTargetUnit = GetSpellTargetUnit
+local getSpellTargetX = GetSpellTargetX
+local getSpellTargetY = GetSpellTargetY
+local getTriggerUnit = GetTriggerUnit
+local getUnitAbility = BlzGetUnitAbility
+local unitAddAbility = UnitAddAbility
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local unitRemoveAbility = UnitRemoveAbility
+local function retrieveAbility(unit, ability, abilityId)
+    if ability == nil then
+        return __TS__New(
+            UnrecognizedAbility,
+            abilityId,
+            Unit:of(unit)
+        )
+    end
+    if not unitAddAbility(unit, abilityId) then
+        if getUnitAbility(unit, abilityId) == ability then
+            return UnitAbility:of(
+                ability,
+                abilityId,
+                Unit:of(unit)
+            )
+        end
+    else
+        unitRemoveAbility(unit, abilityId)
+    end
+    for i = 0, unitInventorySize(unit) - 1 do
+        local item = unitItemInSlot(unit, i)
+        if getItemAbility(item, abilityId) == ability then
+            return ItemAbility:of(
+                ability,
+                abilityId,
+                Item:of(item)
+            )
+        end
+    end
+    return UnitAbility:of(
+        ability,
+        abilityId,
+        Unit:of(unit)
+    )
+end
+local function collectInternalUnitAbilityEventParameters()
+    local unit = checkNotNull(getTriggerUnit())
+    return Unit:of(unit), retrieveAbility(
+        unit,
+        getSpellAbility(),
+        getSpellAbilityId()
+    ), getSpellTargetUnit(), getSpellTargetItem(), getSpellTargetDestructible(), getSpellTargetX(), getSpellTargetY()
+end
+local function collectUnitAbilityEventParameters()
+    local unit = checkNotNull(getTriggerUnit())
+    return Unit:of(unit), retrieveAbility(
+        unit,
+        getSpellAbility(),
+        getSpellAbilityId()
+    )
+end
+local function createCommonEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        3,
+        function(caster, ability)
+            return true, caster, ability
+        end
+    )
+end
+local function createWidgetTargetEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        2,
+        function(caster, ability, targetUnit, targetItem, targetDestructible)
+            if targetUnit ~= nil or targetItem ~= nil or targetDestructible ~= nil then
+                return true, caster, ability, Unit:of(targetUnit) or Item:of(targetItem) or Destructable:of(targetDestructible)
+            else
+                return false
+            end
+        end
+    )
+end
+local function createUnitTargetEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        1,
+        function(caster, ability, targetUnit)
+            if targetUnit ~= nil then
+                return true, caster, ability, Unit:of(targetUnit)
+            else
+                return false
+            end
+        end
+    )
+end
+local function createItemTargetEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        1,
+        function(caster, ability, targetUnit, targetItem)
+            if targetItem ~= nil then
+                return true, caster, ability, Item:of(targetItem)
+            else
+                return false
+            end
+        end
+    )
+end
+local function createDestructibleTargetEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        1,
+        function(caster, ability, targetUnit, targetItem, targetDestructible)
+            if targetDestructible ~= nil then
+                return true, caster, ability, Destructable:of(targetDestructible)
+            else
+                return false
+            end
+        end
+    )
+end
+local function createPointTargetEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        1,
+        function(caster, ability, targetUnit, targetItem, targetDestructible, x, y)
+            if x ~= 0 and y ~= 0 and targetUnit == nil and targetItem == nil and targetDestructible == nil then
+                return true, caster, ability, x, y
+            else
+                return false
+            end
+        end
+    )
+end
+local function createNoTargetEvent(underlyingEvent)
+    return __TS__New(
+        DependentInitializingEvent,
+        underlyingEvent,
+        1,
+        function(caster, ability, targetUnit, targetItem, targetDestructible, x, y)
+            if x == 0 and y == 0 and targetUnit == nil and targetItem == nil and targetDestructible == nil then
+                return true, caster, ability
+            else
+                return false
+            end
+        end
+    )
+end
+local function extractAbilityTypeId(unit, ability)
+    return ability.typeId
+end
+local internalAbilityCastingStartEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_CHANNEL, collectInternalUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityCastingStartEvent",
+    createDispatchingEvent(
+        createCommonEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityWidgetTargetCastingStartEvent",
+    createDispatchingEvent(
+        createWidgetTargetEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityUnitTargetCastingStartEvent",
+    createDispatchingEvent(
+        createUnitTargetEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityItemTargetCastingStartEvent",
+    createDispatchingEvent(
+        createItemTargetEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityDestructibleTargetCastingStartEvent",
+    createDispatchingEvent(
+        createDestructibleTargetEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityPointTargetCastingStartEvent",
+    createDispatchingEvent(
+        createPointTargetEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityNoTargetCastingStartEvent",
+    createDispatchingEvent(
+        createNoTargetEvent(internalAbilityCastingStartEvent),
+        extractAbilityTypeId
+    )
+)
+local internalAbilityCastingFinishEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_CAST, collectInternalUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityCastingFinishEvent",
+    createDispatchingEvent(
+        createCommonEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityWidgetTargetCastingFinishEvent",
+    createDispatchingEvent(
+        createWidgetTargetEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityUnitTargetCastingFinishEvent",
+    createDispatchingEvent(
+        createUnitTargetEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityItemTargetCastingFinishEvent",
+    createDispatchingEvent(
+        createItemTargetEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityDestructibleTargetCastingFinishEvent",
+    createDispatchingEvent(
+        createDestructibleTargetEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityPointTargetCastingFinishEvent",
+    createDispatchingEvent(
+        createPointTargetEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityNoTargetCastingFinishEvent",
+    createDispatchingEvent(
+        createNoTargetEvent(internalAbilityCastingFinishEvent),
+        extractAbilityTypeId
+    )
+)
+local internalAbilityChannelingStartEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_EFFECT, collectInternalUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityChannelingStartEvent",
+    createDispatchingEvent(
+        createCommonEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityWidgetTargetChannelingStartEvent",
+    createDispatchingEvent(
+        createWidgetTargetEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityUnitTargetChannelingStartEvent",
+    createDispatchingEvent(
+        createUnitTargetEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityItemTargetChannelingStartEvent",
+    createDispatchingEvent(
+        createItemTargetEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityDestructibleTargetChannelingStartEvent",
+    createDispatchingEvent(
+        createDestructibleTargetEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityPointTargetChannelingStartEvent",
+    createDispatchingEvent(
+        createPointTargetEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityNoTargetChannelingStartEvent",
+    createDispatchingEvent(
+        createNoTargetEvent(internalAbilityChannelingStartEvent),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityChannelingFinishEvent",
+    createDispatchingEvent(
+        __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_FINISH, collectUnitAbilityEventParameters),
+        extractAbilityTypeId
+    )
+)
+rawset(
+    Unit,
+    "abilityStopEvent",
+    createDispatchingEvent(
+        __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_ENDCAST, collectUnitAbilityEventParameters),
+        extractAbilityTypeId
+    )
+)
+return ____exports

package/engine/internal/unit/allowed-targets.d.ts

@@ -0,0 +1,17 @@
+/** @noSelfInFile */
+import { CombatClassifications } from "../../object-data/auxiliary/combat-classification";
+declare module "../unit" {
+    interface Unit {
+        isAllowedTarget(this: Unit, source: Unit, allowedTargetCombatClassifications: CombatClassifications): boolean;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        function getAllowedTargetsInRange(this: void, source: Unit, allowedTargetCombatClassifications: CombatClassifications, x: number, y: number, range: number): Unit[];
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        function getAllowedTargetsInCollisionRange(this: void, source: Unit, allowedTargetCombatClassifications: CombatClassifications, x: number, y: number, range: number): Unit[];
+    }
+}

package/engine/internal/unit/allowed-targets.lua

@@ -0,0 +1,19 @@
+local ____exports = {}
+local ____combat_2Dclassification = require("engine.object-data.auxiliary.combat-classification")
+local filterTarget = ____combat_2Dclassification.filterTarget
+local initializeFilterTargetState = ____combat_2Dclassification.initializeFilterTargetState
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+Unit.prototype.isAllowedTarget = function(self, source, allowedTargetCombatClassifications)
+    initializeFilterTargetState(source, allowedTargetCombatClassifications)
+    return filterTarget(self)
+end
+Unit.getAllowedTargetsInRange = function(source, allowedTargetCombatClassifications, x, y, range)
+    initializeFilterTargetState(source, allowedTargetCombatClassifications)
+    return Unit:getInRange(x, y, range, filterTarget)
+end
+Unit.getAllowedTargetsInCollisionRange = function(source, allowedTargetCombatClassifications, x, y, range)
+    initializeFilterTargetState(source, allowedTargetCombatClassifications)
+    return Unit:getInCollisionRange(x, y, range, filterTarget)
+end
+return ____exports

package/engine/internal/unit/band-aids/ancestral-spirit-cannibalize.d.ts

@@ -0,0 +1,2 @@
+/** @noSelfInFile */
+import "../../unit+ability";

package/engine/internal/unit/band-aids/ancestral-spirit-cannibalize.lua

@@ -0,0 +1,21 @@
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local UnitClassification = ____unit.UnitClassification
+require("engine.internal.unit+ability")
+local ____lua_2Dsets = require("utility.lua-sets")
+local luaSetOf = ____lua_2Dsets.luaSetOf
+local cannibalizeAbilityTypeIds = luaSetOf(
+    fourCC("Acan"),
+    fourCC("Acn2"),
+    fourCC("ACcn")
+)
+Unit.abilityUnitTargetChannelingStartEvent:addListener(
+    4,
+    function(caster, ability, target)
+        if cannibalizeAbilityTypeIds[ability.parentTypeId] ~= nil then
+            target:removeClassification(UnitClassification.TAUREN)
+        end
+    end
+)
+return ____exports

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

@@ -0,0 +1,41 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+import { Unit } from "../unit";
+import { AbilityTypeId } from "../../object-data/entry/ability-type";
+export type UnitBonusId<Brand extends string = any> = number & {
+    readonly __unitBonusId: unique symbol;
+    readonly __unitBonusIdBrand: Brand;
+};
+export type UnitArmorBonusId = UnitBonusId<"armor">;
+export type UnitAttackSpeedFactorBonusId = UnitBonusId<"attackSpeedFactor">;
+export type UnitMovementSpeedFactorBonusId = UnitBonusId<"movementSpeedFactor">;
+export type UnitDamageBonusId = UnitBonusId<"damage">;
+export type UnitReceivedDamageFactorBonusId = UnitBonusId<"receivedDamageFactor">;
+export type UnitBonusType<Id extends UnitBonusId = UnitBonusId> = ({
+    abilityTypeId: AbilityTypeId;
+    field: jabilityintegerlevelfield;
+    integer: true;
+} | {
+    abilityTypeId: AbilityTypeId;
+    field: jabilityreallevelfield;
+    integer: false;
+} | {
+    abilityTypeId?: undefined;
+    valueByUnit: LuaMap<Unit, number>;
+}) & {
+    reduce: (this: void, array: number[]) => number;
+    initialValue: number;
+    readonly __unitBonusTypeId?: Id;
+};
+export declare namespace UnitBonusType {
+    const ARMOR: UnitBonusType<UnitArmorBonusId>;
+    const ATTACK_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
+    const MOVEMENT_SPEED_FACTOR: UnitBonusType<UnitAttackSpeedFactorBonusId>;
+    const DAMAGE: UnitBonusType<UnitDamageBonusId>;
+    const RECEIVED_DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
+}
+export declare const addUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, value: number) => Id;
+export declare const removeUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => boolean;
+export declare const updateUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id, value: number) => boolean;
+export declare const addOrUpdateOrRemoveUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id | undefined, value: number) => Id | undefined;
+export declare const getUnitBonus: <Id extends UnitBonusId<any>>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => number;

package/engine/internal/unit/bonus.lua

@@ -0,0 +1,188 @@
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____armor_2Dincrease = require("engine.internal.object-data.armor-increase")
+local ARMOR_BONUS_DUMMY_ABILITY_FIELD = ____armor_2Dincrease.ARMOR_BONUS_DUMMY_ABILITY_FIELD
+local ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID = ____armor_2Dincrease.ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID
+local ____utility = require("engine.internal.utility")
+local addInternalAbility = ____utility.addInternalAbility
+local ____arrays = require("utility.arrays")
+local product = ____arrays.product
+local sum = ____arrays.sum
+local ____auto_2Dattack_2Dspeed_2Dincrease = require("engine.internal.object-data.auto-attack-speed-increase")
+local AUTO_ATTACK_SPEED_INCREASE_DUMMY_ABILITY_TYPE_ID = ____auto_2Dattack_2Dspeed_2Dincrease.AUTO_ATTACK_SPEED_INCREASE_DUMMY_ABILITY_TYPE_ID
+local AUTO_ATTACK_SPEED_INCREASE_FACTOR_ABILITY_FIELD = ____auto_2Dattack_2Dspeed_2Dincrease.AUTO_ATTACK_SPEED_INCREASE_FACTOR_ABILITY_FIELD
+local ____preconditions = require("utility.preconditions")
+local check = ____preconditions.check
+local checkNotNull = ____preconditions.checkNotNull
+local ____auto_2Dattack_2Ddamage_2Dincrease = require("engine.internal.object-data.auto-attack-damage-increase")
+local AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD = ____auto_2Dattack_2Ddamage_2Dincrease.AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD
+local AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID = ____auto_2Dattack_2Ddamage_2Dincrease.AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID
+local ____movement_2Dspeed_2Dincrease_2Dfactor = require("engine.internal.object-data.movement-speed-increase-factor")
+local MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD
+local MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____movement_2Dspeed_2Dincrease_2Dfactor.MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID
+local receivedDamageFactorByUnit = {}
+____exports.UnitBonusType = {}
+local UnitBonusType = ____exports.UnitBonusType
+do
+    UnitBonusType.ARMOR = {
+        abilityTypeId = ARMOR_BONUS_DUMMY_ABILITY_TYPE_ID,
+        field = ARMOR_BONUS_DUMMY_ABILITY_FIELD,
+        integer = false,
+        reduce = sum,
+        initialValue = 0
+    }
+    UnitBonusType.ATTACK_SPEED_FACTOR = {
+        abilityTypeId = AUTO_ATTACK_SPEED_INCREASE_DUMMY_ABILITY_TYPE_ID,
+        field = AUTO_ATTACK_SPEED_INCREASE_FACTOR_ABILITY_FIELD,
+        integer = false,
+        reduce = sum,
+        initialValue = 0
+    }
+    UnitBonusType.MOVEMENT_SPEED_FACTOR = {
+        abilityTypeId = MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID,
+        field = MOVEMENT_SPEED_INCREASE_FACTOR_ABILITY_FIELD,
+        integer = false,
+        reduce = sum,
+        initialValue = 0
+    }
+    UnitBonusType.DAMAGE = {
+        abilityTypeId = AUTO_ATTACK_DAMAGE_INCREASE_DUMMY_ABILITY_TYPE_ID,
+        field = AUTO_ATTACK_DAMAGE_INCREASE_ABILITY_FIELD,
+        integer = false,
+        reduce = sum,
+        initialValue = 0
+    }
+    UnitBonusType.RECEIVED_DAMAGE_FACTOR = {reduce = product, valueByUnit = receivedDamageFactorByUnit, initialValue = 1}
+end
+local bonusesByUnitByBonusType = {}
+local nextId = 1
+local function processUnitBonus(unit, bonusType, bonusesArray)
+    local unitHandle = unit.handle
+    local totalValue = bonusType.reduce(bonusesArray)
+    local abilityTypeId = bonusType.abilityTypeId
+    if abilityTypeId == nil then
+        local valueByUnit = bonusType.valueByUnit
+        if totalValue == bonusType.initialValue then
+            valueByUnit[unit] = nil
+        else
+            valueByUnit[unit] = totalValue
+        end
+        return
+    end
+    if totalValue == bonusType.initialValue then
+        UnitRemoveAbility(unitHandle, abilityTypeId)
+        return
+    end
+    local abilityHandle = checkNotNull(addInternalAbility(unitHandle, abilityTypeId))
+    check((bonusType.integer and BlzSetAbilityIntegerLevelField or BlzSetAbilityRealLevelField)(abilityHandle, bonusType.field, 0, totalValue))
+    BlzSetAbilityIntegerField(abilityHandle, ABILITY_IF_LEVELS, 2)
+    SetUnitAbilityLevel(unitHandle, abilityTypeId, 2)
+    SetUnitAbilityLevel(unitHandle, abilityTypeId, 1)
+    BlzSetAbilityIntegerField(abilityHandle, ABILITY_IF_LEVELS, 1)
+end
+____exports.addUnitBonus = function(unit, bonusType, value)
+    local bonusesByUnit = bonusesByUnitByBonusType[bonusType]
+    if bonusesByUnit == nil then
+        bonusesByUnit = setmetatable({}, {__mode = "k"})
+        bonusesByUnitByBonusType[bonusType] = bonusesByUnit
+    end
+    local bonuses = bonusesByUnit[unit]
+    if bonuses == nil then
+        bonuses = {array = {}, idByIndex = {}, indexById = {}}
+        bonusesByUnit[unit] = bonuses
+    end
+    local bonusesArray = bonuses.array
+    local ____nextId_0 = nextId
+    nextId = ____nextId_0 + 1
+    local id = ____nextId_0
+    local index = #bonusesArray
+    bonusesArray[index + 1] = value
+    bonuses.idByIndex[index] = id
+    bonuses.indexById[id] = index
+    processUnitBonus(unit, bonusType, bonusesArray)
+    return id
+end
+____exports.removeUnitBonus = function(unit, bonusType, id)
+    local bonusesByUnit = bonusesByUnitByBonusType[bonusType]
+    if bonusesByUnit == nil then
+        return false
+    end
+    local bonuses = bonusesByUnit[unit]
+    if bonuses == nil then
+        return false
+    end
+    local index = bonuses.indexById[id]
+    if index == nil then
+        return false
+    end
+    local bonusesArray = bonuses.array
+    local bonusesArrayLastIndex = #bonusesArray - 1
+    local bonusesIdByIndex = bonuses.idByIndex
+    local bonusesIndexById = bonuses.indexById
+    bonusesArray[index + 1] = bonusesArray[bonusesArrayLastIndex + 1]
+    bonusesArray[bonusesArrayLastIndex + 1] = nil
+    local lastElementId = checkNotNull(bonuses.idByIndex[bonusesArrayLastIndex])
+    bonusesIdByIndex[index] = lastElementId
+    bonusesIdByIndex[bonusesArrayLastIndex] = nil
+    bonusesIndexById[lastElementId] = index
+    bonusesIndexById[id] = nil
+    processUnitBonus(unit, bonusType, bonusesArray)
+    return true
+end
+____exports.updateUnitBonus = function(unit, bonusType, id, value)
+    local bonusesByUnit = bonusesByUnitByBonusType[bonusType]
+    if bonusesByUnit == nil then
+        return false
+    end
+    local bonuses = bonusesByUnit[unit]
+    if bonuses == nil then
+        return false
+    end
+    local index = bonuses.indexById[id]
+    if index == nil then
+        return false
+    end
+    local bonusesArray = bonuses.array
+    bonusesArray[index + 1] = value
+    processUnitBonus(unit, bonusType, bonusesArray)
+    return true
+end
+____exports.addOrUpdateOrRemoveUnitBonus = function(unit, bonusType, id, value)
+    if value == bonusType.initialValue then
+        if id == nil then
+            return nil
+        end
+        ____exports.removeUnitBonus(unit, bonusType, id)
+        return nil
+    end
+    if id == nil then
+        return ____exports.addUnitBonus(unit, bonusType, value)
+    end
+    check(____exports.updateUnitBonus(unit, bonusType, id, value))
+    return id
+end
+____exports.getUnitBonus = function(unit, bonusType, id)
+    local bonusesByUnit = bonusesByUnitByBonusType[bonusType]
+    if bonusesByUnit == nil then
+        return bonusType.initialValue
+    end
+    local bonuses = bonusesByUnit[unit]
+    if bonuses == nil then
+        return bonusType.initialValue
+    end
+    local index = bonuses.indexById[id]
+    if index == nil then
+        return bonusType.initialValue
+    end
+    return bonuses.array[index + 1]
+end
+Unit.onDamage:addListener(
+    4,
+    function(source, target, event)
+        if receivedDamageFactorByUnit[target] ~= nil then
+            event.amount = event.amount * receivedDamageFactorByUnit[target]
+        end
+    end
+)
+return ____exports