warscript 0.0.1-dev.008d8ef

package/destroyable.d.ts

@@ -0,0 +1,20 @@
+/** @noSelfInFile */
+declare const noOverrideSymbol: unique symbol;
+type NoOverride = {
+    [noOverrideSymbol]: typeof noOverrideSymbol;
+};
+export type Destructor = {
+    readonly __destructor: unique symbol;
+};
+export interface Destroyable {
+    destroy(): void;
+}
+export declare abstract class AbstractDestroyable implements Destroyable {
+    /**
+     * An overriding function should always call the super one at the end of it,
+     * in the following manner: `return super.onDestroy()`.
+     */
+    protected onDestroy(): Destructor;
+    destroy(): boolean & NoOverride;
+}
+export {};

package/destroyable.lua

@@ -0,0 +1,31 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____exception = require("exception")
+local IllegalStateException = ____exception.IllegalStateException
+local stateByDestroyable = setmetatable({}, {__mode = "k"})
+____exports.AbstractDestroyable = __TS__Class()
+local AbstractDestroyable = ____exports.AbstractDestroyable
+AbstractDestroyable.name = "AbstractDestroyable"
+function AbstractDestroyable.prototype.____constructor(self)
+end
+function AbstractDestroyable.prototype.onDestroy(self)
+    stateByDestroyable[self] = 1
+    return nil
+end
+function AbstractDestroyable.prototype.destroy(self)
+    if stateByDestroyable[self] ~= nil then
+        return false
+    end
+    stateByDestroyable[self] = 0
+    self:onDestroy()
+    if stateByDestroyable[self] ~= 1 then
+        error(
+            __TS__New(IllegalStateException, ("'onDestroy' is incorrectly overridden (class '" .. self.constructor.name) .. "')."),
+            0
+        )
+    end
+    return true
+end
+return ____exports

package/engine/ability.d.ts

@@ -0,0 +1,5 @@
+/** @noSelfInFile */
+import { AbilityTypeId } from "./object-data/entry/ability-type";
+import { UnitAbility } from "./internal/ability";
+import { Player } from "../core/types/player";
+export declare const castAbility: (owner: Player, abilityTypeId: AbilityTypeId, ...args: [...levelOrAbilityConsumer: [number] | [(ability: UnitAbility) => void] | [], x: number, y: number]) => void;

package/engine/ability.lua

@@ -0,0 +1,7 @@
+local ____exports = {}
+local ____dummy = require("core.dummy")
+local InstantDummyCaster = ____dummy.InstantDummyCaster
+____exports.castAbility = function(owner, abilityTypeId, ...)
+    InstantDummyCaster:getInstance():cast(owner, abilityTypeId, ...)
+end
+return ____exports

package/engine/behavior.d.ts

@@ -0,0 +1,28 @@
+/** @noSelfInFile */
+import { AbstractDestroyable, Destructor } from "../destroyable";
+export type BehaviorConstructor<T extends Behavior<AnyNotNil>, Parameters extends any[] = any[]> = OmitConstructor<typeof Behavior<any>> & (abstract new (...parameters: Parameters) => T);
+declare const enum BehaviorPropertyKey {
+    PREVIOUS_BEHAVIOR = 0,
+    NEXT_BEHAVIOR = 1,
+    TIMER = 2
+}
+export declare abstract class Behavior<T extends AnyNotNil, PeriodicActionParameters extends any[] = any[]> extends AbstractDestroyable {
+    protected readonly object: T;
+    private [BehaviorPropertyKey.PREVIOUS_BEHAVIOR]?;
+    private [BehaviorPropertyKey.NEXT_BEHAVIOR]?;
+    private [BehaviorPropertyKey.TIMER]?;
+    protected constructor(object: T);
+    protected onDestroy(): Destructor;
+    protected onPeriod(...parameters: PeriodicActionParameters): void;
+    protected startPeriodicAction(interval: number, ...parameters: PeriodicActionParameters): void;
+    protected stopPeriodicAction(): void;
+    static count<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, limit?: number): number;
+    static getFirst<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[], Count extends [number] | []>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, ...[count]: Count): Count extends [number] ? T[] : T | undefined;
+    static getLast<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never): T | undefined;
+    static getAll<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never): T[];
+    static forFirst<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[], ConsumerParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, count: number, consumer: (this: void, behavior: T, ...parameters: ConsumerParameters) => any, ...parameters: ConsumerParameters): number;
+    static forFirst<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[], K extends KeysOfType<T, (this: T, ...args: any) => any>>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, count: number, key: K, ...parameters: T[K] extends (this: T, ...args: any) => any ? Parameters<T[K]> : never): number;
+    static forAll<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[], ConsumerParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, consumer: (this: void, behavior: T, ...parameters: ConsumerParameters) => unknown, ...parameters: ConsumerParameters): number;
+    static forAll<T extends Behavior<AnyNotNil>, ConstructorParameters extends any[], K extends KeysOfType<T, (this: T, ...args: any) => any>>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, key: K, ...parameters: T[K] extends (this: T, ...args: any) => any ? Parameters<T[K]> : never): number;
+}
+export {};

package/engine/behavior.lua

@@ -0,0 +1,181 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__InstanceOf = ____lualib.__TS__InstanceOf
+local ____exports = {}
+local ____destroyable = require("destroyable")
+local AbstractDestroyable = ____destroyable.AbstractDestroyable
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local safeCall = warpack.safeCall
+local firstBehaviorByObject = {}
+local lastBehaviorByObject = {}
+local function invokeBehaviorOnPeriod(behavior, ...)
+    behavior.onPeriod(behavior, ...)
+end
+____exports.Behavior = __TS__Class()
+local Behavior = ____exports.Behavior
+Behavior.name = "Behavior"
+__TS__ClassExtends(Behavior, AbstractDestroyable)
+function Behavior.prototype.____constructor(self, object)
+    AbstractDestroyable.prototype.____constructor(self)
+    self.object = object
+    local lastBehavior = lastBehaviorByObject[object]
+    if lastBehavior == nil then
+        firstBehaviorByObject[object] = self
+        lastBehaviorByObject[object] = self
+    else
+        self[0] = lastBehavior
+        lastBehavior[1] = self
+        lastBehaviorByObject[object] = self
+    end
+end
+function Behavior.prototype.onDestroy(self)
+    local ____opt_0 = self[2]
+    if ____opt_0 ~= nil then
+        ____opt_0:destroy()
+    end
+    local previousBehavior = self[0]
+    local nextBehavior = self[1]
+    if previousBehavior ~= nil then
+        previousBehavior[1] = nextBehavior
+    else
+        firstBehaviorByObject[self.object] = nextBehavior
+    end
+    if nextBehavior ~= nil then
+        nextBehavior[0] = previousBehavior
+    else
+        lastBehaviorByObject[self.object] = previousBehavior
+    end
+    return AbstractDestroyable.prototype.onDestroy(self)
+end
+function Behavior.prototype.onPeriod(self, ...)
+end
+function Behavior.prototype.startPeriodicAction(self, interval, ...)
+    local timer = self[2]
+    if timer == nil then
+        timer = Timer:create()
+        self[2] = timer
+    end
+    timer:start(
+        interval,
+        true,
+        invokeBehaviorOnPeriod,
+        self,
+        ...
+    )
+end
+function Behavior.prototype.stopPeriodicAction(self)
+    local timer = self[2]
+    if timer ~= nil then
+        timer:destroy()
+        self[2] = nil
+    end
+end
+function Behavior.count(self, object, limit)
+    local behaviorsCount = 0
+    local behavior = firstBehaviorByObject[object]
+    while behavior ~= nil and (limit == nil or behaviorsCount < limit) do
+        if __TS__InstanceOf(behavior, self) then
+            behaviorsCount = behaviorsCount + 1
+        end
+        behavior = behavior[1]
+    end
+    return behaviorsCount
+end
+function Behavior.getFirst(self, object, count)
+    local behavior = firstBehaviorByObject[object]
+    if count == nil then
+        while behavior ~= nil do
+            if __TS__InstanceOf(behavior, self) then
+                return behavior
+            end
+            behavior = behavior[1]
+        end
+        return nil
+    end
+    local behaviors = {}
+    local behaviorsCount = 0
+    while behavior ~= nil and behaviorsCount < count do
+        if __TS__InstanceOf(behavior, self) then
+            behaviorsCount = behaviorsCount + 1
+            behaviors[behaviorsCount] = behavior
+        end
+        behavior = behavior[1]
+    end
+    return behaviors
+end
+function Behavior.getLast(self, object)
+    local behavior = lastBehaviorByObject[object]
+    while behavior ~= nil do
+        if __TS__InstanceOf(behavior, self) then
+            return behavior
+        end
+        behavior = behavior[0]
+    end
+    return nil
+end
+function Behavior.getAll(self, object)
+    local behaviors = {}
+    local behaviorsCount = 0
+    local behavior = firstBehaviorByObject[object]
+    while behavior ~= nil do
+        if __TS__InstanceOf(behavior, self) then
+            behaviorsCount = behaviorsCount + 1
+            behaviors[behaviorsCount] = behavior
+        end
+        behavior = behavior[1]
+    end
+    return behaviors
+end
+function Behavior.forFirst(self, object, count, consumerOrKey, ...)
+    local behaviorsCount = 0
+    local behavior = firstBehaviorByObject[object]
+    if type(consumerOrKey) == "function" then
+        while behavior ~= nil and behaviorsCount < count do
+            if __TS__InstanceOf(behavior, self) then
+                safeCall(consumerOrKey, behavior, ...)
+                behaviorsCount = behaviorsCount + 1
+            end
+            behavior = behavior[1]
+        end
+    else
+        while behavior ~= nil and behaviorsCount < count do
+            if __TS__InstanceOf(behavior, self) then
+                safeCall(behavior[consumerOrKey], behavior, ...)
+                behaviorsCount = behaviorsCount + 1
+            end
+            behavior = behavior[1]
+        end
+    end
+    return behaviorsCount
+end
+function Behavior.forAll(self, object, consumerOrKey, ...)
+    local behaviorsCount = 0
+    local behavior = firstBehaviorByObject[object]
+    if behavior ~= nil then
+        if type(consumerOrKey) == "function" then
+            repeat
+                do
+                    if __TS__InstanceOf(behavior, self) then
+                        safeCall(consumerOrKey, behavior, ...)
+                        behaviorsCount = behaviorsCount + 1
+                    end
+                    behavior = behavior[1]
+                end
+            until not (behavior ~= nil)
+        else
+            repeat
+                do
+                    if __TS__InstanceOf(behavior, self) then
+                        safeCall(behavior[consumerOrKey], behavior, ...)
+                        behaviorsCount = behaviorsCount + 1
+                    end
+                    behavior = behavior[1]
+                end
+            until not (behavior ~= nil)
+        end
+    end
+    return behaviorsCount
+end
+return ____exports

package/engine/behaviour/ability/apply-buff.d.ts

@@ -0,0 +1,38 @@
+/** @noSelfInFile */
+import { AbilityBehavior } from "../ability";
+import { Ability } from "../../internal/ability";
+import { Buff, BuffConstructor, BuffParameters, BuffTypeIdSelectionPolicy } from "../../buff";
+import { Unit } from "../../internal/unit";
+import { ApplicableBuffTypeId } from "../../object-data/entry/buff-type/applicable";
+import { BuffResistanceType } from "../../object-data/auxiliary/buff-resistance-type";
+import { BuffPolarity } from "../../object-data/auxiliary/buff-polarity";
+import { Widget } from "../../../core/types/widget";
+type BuffParametersType<T extends BuffConstructor> = BuffParameters & Omit<BuffAdditionalParametersType<T>, keyof BuffParameters>;
+type BuffAdditionalParametersType<T extends BuffConstructor> = T extends BuffConstructor<Buff<infer AdditionalParameters>> ? AdditionalParameters : never;
+export declare abstract class ApplyBuffAbilityBehavior<T extends BuffConstructor = typeof Buff> extends AbilityBehavior {
+    protected readonly applyBuff: (this: void, unit: Unit) => InstanceType<T> | undefined;
+    constructor(ability: Ability, ...parameters: [
+        ...constructor: [] | [T],
+        ...typeId: [ApplicableBuffTypeId] | [
+            typeIds: [ApplicableBuffTypeId, ...ApplicableBuffTypeId[]],
+            typeIdSelectionPolicy: BuffTypeIdSelectionPolicy
+        ],
+        polarity: BuffPolarity,
+        resistanceType: BuffResistanceType,
+        parameters?: BuffParametersType<T>
+    ]);
+}
+export declare class ApplyBuffSelfAbilityBehaviour<T extends BuffConstructor = typeof Buff> extends ApplyBuffAbilityBehavior<T> {
+    onImpact(caster: Unit): void;
+}
+export declare class ApplyBuffTargetAbilityBehavior<T extends BuffConstructor = typeof Buff> extends ApplyBuffAbilityBehavior<T> {
+    onUnitTargetImpact(caster: Unit, target: Unit): void;
+}
+export declare class ApplyBuffSelfAreaAbilityBehavior<T extends BuffConstructor = typeof Buff> extends ApplyBuffAbilityBehavior<T> {
+    onImpact(caster: Unit): void;
+}
+export declare class ApplyBuffTargetAreaAbilityBehavior<T extends BuffConstructor = typeof Buff> extends ApplyBuffAbilityBehavior<T> {
+    onPointTargetImpact(caster: Unit, x: number, y: number): void;
+    onWidgetTargetImpact(caster: Unit, target: Widget): void;
+}
+export {};

package/engine/behaviour/ability/apply-buff.lua

@@ -0,0 +1,126 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__ArrayIsArray = ____lualib.__TS__ArrayIsArray
+local ____exports = {}
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
+local ____buff = require("engine.buff")
+local Buff = ____buff.Buff
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____ability = require("engine.object-field.ability")
+local resolveCurrentAbilityDependentValue = ____ability.resolveCurrentAbilityDependentValue
+local ____ability = require("engine.standard.fields.ability")
+local ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD = ____ability.ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD
+local AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD = ____ability.AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD
+____exports.ApplyBuffAbilityBehavior = __TS__Class()
+local ApplyBuffAbilityBehavior = ____exports.ApplyBuffAbilityBehavior
+ApplyBuffAbilityBehavior.name = "ApplyBuffAbilityBehavior"
+__TS__ClassExtends(ApplyBuffAbilityBehavior, AbilityBehavior)
+function ApplyBuffAbilityBehavior.prototype.____constructor(self, ability, constructorOrTypeIdOrTypeIds, typeIdOrTypeIdsOrPolarityOrTypeIdSelectionPolicy, polarityOrTypeIdSelectionPolicyOrResistanceType, resistanceTypeOrPolarityOrParameters, parametersOrResistanceType, parameters)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    if type(constructorOrTypeIdOrTypeIds) == "number" then
+        self.applyBuff = function(unit)
+            return Buff:apply(
+                unit,
+                constructorOrTypeIdOrTypeIds,
+                typeIdOrTypeIdsOrPolarityOrTypeIdSelectionPolicy,
+                polarityOrTypeIdSelectionPolicyOrResistanceType,
+                ability,
+                resistanceTypeOrPolarityOrParameters
+            )
+        end
+    elseif __TS__ArrayIsArray(constructorOrTypeIdOrTypeIds) then
+        self.applyBuff = function(unit)
+            return Buff:apply(
+                unit,
+                constructorOrTypeIdOrTypeIds,
+                typeIdOrTypeIdsOrPolarityOrTypeIdSelectionPolicy,
+                polarityOrTypeIdSelectionPolicyOrResistanceType,
+                resistanceTypeOrPolarityOrParameters,
+                ability,
+                parametersOrResistanceType
+            )
+        end
+    elseif type(typeIdOrTypeIdsOrPolarityOrTypeIdSelectionPolicy) == "number" then
+        self.applyBuff = function(unit)
+            return constructorOrTypeIdOrTypeIds:apply(
+                unit,
+                typeIdOrTypeIdsOrPolarityOrTypeIdSelectionPolicy,
+                polarityOrTypeIdSelectionPolicyOrResistanceType,
+                resistanceTypeOrPolarityOrParameters,
+                ability,
+                parametersOrResistanceType
+            )
+        end
+    else
+        self.applyBuff = function(unit)
+            return constructorOrTypeIdOrTypeIds:apply(
+                unit,
+                typeIdOrTypeIdsOrPolarityOrTypeIdSelectionPolicy,
+                polarityOrTypeIdSelectionPolicyOrResistanceType,
+                resistanceTypeOrPolarityOrParameters,
+                parametersOrResistanceType,
+                ability,
+                parameters
+            )
+        end
+    end
+end
+____exports.ApplyBuffSelfAbilityBehaviour = __TS__Class()
+local ApplyBuffSelfAbilityBehaviour = ____exports.ApplyBuffSelfAbilityBehaviour
+ApplyBuffSelfAbilityBehaviour.name = "ApplyBuffSelfAbilityBehaviour"
+__TS__ClassExtends(ApplyBuffSelfAbilityBehaviour, ____exports.ApplyBuffAbilityBehavior)
+function ApplyBuffSelfAbilityBehaviour.prototype.onImpact(self, caster)
+    self.applyBuff(caster)
+end
+____exports.ApplyBuffTargetAbilityBehavior = __TS__Class()
+local ApplyBuffTargetAbilityBehavior = ____exports.ApplyBuffTargetAbilityBehavior
+ApplyBuffTargetAbilityBehavior.name = "ApplyBuffTargetAbilityBehavior"
+__TS__ClassExtends(ApplyBuffTargetAbilityBehavior, ____exports.ApplyBuffAbilityBehavior)
+function ApplyBuffTargetAbilityBehavior.prototype.onUnitTargetImpact(self, caster, target)
+    self.applyBuff(target)
+end
+____exports.ApplyBuffSelfAreaAbilityBehavior = __TS__Class()
+local ApplyBuffSelfAreaAbilityBehavior = ____exports.ApplyBuffSelfAreaAbilityBehavior
+ApplyBuffSelfAreaAbilityBehavior.name = "ApplyBuffSelfAreaAbilityBehavior"
+__TS__ClassExtends(ApplyBuffSelfAreaAbilityBehavior, ____exports.ApplyBuffAbilityBehavior)
+function ApplyBuffSelfAreaAbilityBehavior.prototype.onImpact(self, caster)
+    for ____, unit in ipairs(Unit.getAllowedTargetsInCollisionRange(
+        caster,
+        resolveCurrentAbilityDependentValue(self.ability, ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD),
+        caster.x,
+        caster.y,
+        resolveCurrentAbilityDependentValue(self.ability, AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD)
+    )) do
+        self.applyBuff(unit)
+    end
+end
+____exports.ApplyBuffTargetAreaAbilityBehavior = __TS__Class()
+local ApplyBuffTargetAreaAbilityBehavior = ____exports.ApplyBuffTargetAreaAbilityBehavior
+ApplyBuffTargetAreaAbilityBehavior.name = "ApplyBuffTargetAreaAbilityBehavior"
+__TS__ClassExtends(ApplyBuffTargetAreaAbilityBehavior, ____exports.ApplyBuffAbilityBehavior)
+function ApplyBuffTargetAreaAbilityBehavior.prototype.onPointTargetImpact(self, caster, x, y)
+    for ____, unit in ipairs(Unit.getAllowedTargetsInCollisionRange(
+        caster,
+        resolveCurrentAbilityDependentValue(self.ability, ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD),
+        x,
+        y,
+        resolveCurrentAbilityDependentValue(self.ability, AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD)
+    )) do
+        self.applyBuff(unit)
+    end
+end
+function ApplyBuffTargetAreaAbilityBehavior.prototype.onWidgetTargetImpact(self, caster, target)
+    for ____, unit in ipairs(Unit.getAllowedTargetsInCollisionRange(
+        caster,
+        resolveCurrentAbilityDependentValue(self.ability, ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD),
+        target.x,
+        target.y,
+        resolveCurrentAbilityDependentValue(self.ability, AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD)
+    )) do
+        self.applyBuff(unit)
+    end
+end
+return ____exports

package/engine/behaviour/ability/apply-unit-behavior.d.ts

@@ -0,0 +1,21 @@
+/** @noSelfInFile */
+import { AbilityBehavior } from "../ability";
+import { Ability } from "../../internal/ability";
+import { UnitBehavior } from "../unit";
+import { Unit } from "../../internal/unit";
+import { MutableKeys } from "../../../utility/types";
+import { AbilityDependentValue } from "../../object-field/ability";
+type UnitBehaviorParameters<T extends UnitBehavior> = Partial<{
+    [K in MutableKeys<T> & KeysOfType<T, boolean | number | string>]: T[K] extends boolean | number | string ? AbilityDependentValue<T[K]> : never;
+}>;
+export declare class ApplyUnitBehaviorAbilityBehavior<T extends UnitBehavior> extends AbilityBehavior {
+    private readonly unitBehaviorConstructor;
+    private readonly parameters?;
+    private readonly keys?;
+    private unitBehavior?;
+    constructor(ability: Ability, unitBehaviorConstructor: new (unit: Unit) => T, parameters?: UnitBehaviorParameters<T> | undefined);
+    update(): void;
+    onUnitGainAbility(unit: Unit): void;
+    onUnitLoseAbility(): void;
+}
+export {};

package/engine/behaviour/ability/apply-unit-behavior.lua

@@ -0,0 +1,58 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
+local __TS__ArraySort = ____lualib.__TS__ArraySort
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
+local ____ability = require("engine.object-field.ability")
+local AbilityField = ____ability.AbilityField
+local AbilityLevelField = ____ability.AbilityLevelField
+____exports.ApplyUnitBehaviorAbilityBehavior = __TS__Class()
+local ApplyUnitBehaviorAbilityBehavior = ____exports.ApplyUnitBehaviorAbilityBehavior
+ApplyUnitBehaviorAbilityBehavior.name = "ApplyUnitBehaviorAbilityBehavior"
+__TS__ClassExtends(ApplyUnitBehaviorAbilityBehavior, AbilityBehavior)
+function ApplyUnitBehaviorAbilityBehavior.prototype.____constructor(self, ability, unitBehaviorConstructor, parameters)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.unitBehaviorConstructor = unitBehaviorConstructor
+    self.parameters = parameters
+    if parameters ~= nil then
+        self.keys = __TS__ArraySort(__TS__ObjectKeys(parameters))
+    end
+end
+function ApplyUnitBehaviorAbilityBehavior.prototype.update(self)
+    local unitBehavior = self.unitBehavior
+    local parameters = self.parameters
+    local keys = self.keys
+    if unitBehavior ~= nil and parameters ~= nil and keys ~= nil then
+        for ____, key in ipairs(keys) do
+            local value = parameters[key]
+            if value ~= nil then
+                unitBehavior[key] = self:resolveCurrentAbilityDependentValue(value)
+            end
+        end
+    end
+end
+function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitGainAbility(self, unit)
+    local ____opt_0 = self.unitBehavior
+    if ____opt_0 ~= nil then
+        ____opt_0:destroy()
+    end
+    self.unitBehavior = __TS__New(self.unitBehaviorConstructor, unit)
+    self:update()
+end
+function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitLoseAbility(self)
+    local ____opt_2 = self.unitBehavior
+    if ____opt_2 ~= nil then
+        ____opt_2:destroy()
+    end
+end
+AbilityField.valueChangeEvent:addListener(function(ability)
+    ____exports.ApplyUnitBehaviorAbilityBehavior:forAll(ability, "update")
+end)
+AbilityLevelField.valueChangeEvent:addListener(function(ability)
+    ____exports.ApplyUnitBehaviorAbilityBehavior:forAll(ability, "update")
+end)
+return ____exports

package/engine/behaviour/ability/damage.d.ts

@@ -0,0 +1,47 @@
+/** @noSelfInFile */
+import { AbilityBehavior } from "../ability";
+import { Ability } from "../../internal/ability";
+import { Unit } from "../../internal/unit";
+import { AbilityDependentValue } from "../../object-field/ability";
+import { Widget } from "../../../core/types/widget";
+import { AttackType, DamageType, WeaponType } from "../../internal/unit+damage";
+export type DamageAbilityBehaviorParameters = {
+    damagePerStrength?: AbilityDependentValue<number>;
+    damagePerAgility?: AbilityDependentValue<number>;
+    damagePerIntelligence?: AbilityDependentValue<number>;
+    attackType?: AttackType;
+    damageType?: DamageType;
+    weaponType?: WeaponType;
+};
+export type DamageAreaAbilityBehaviorParameters = DamageAbilityBehaviorParameters & {
+    maximumDamage?: AbilityDependentValue<number>;
+};
+declare abstract class DamageAbilityBehavior<T extends DamageAbilityBehaviorParameters = DamageAbilityBehaviorParameters> extends AbilityBehavior {
+    protected readonly damage: AbilityDependentValue<number>;
+    protected readonly parameters?: T | undefined;
+    protected constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: T | undefined);
+    protected calculateDamage(caster: Unit): number;
+}
+export declare class DamageSelfAbilityBehavior extends DamageAbilityBehavior {
+    constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: DamageAbilityBehaviorParameters);
+    onImpact(caster: Unit): void;
+}
+export declare class DamageTargetAbilityBehavior extends DamageAbilityBehavior {
+    constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: DamageAbilityBehaviorParameters);
+    onWidgetTargetImpact(caster: Unit, target: Widget): void;
+}
+declare abstract class DamageAreaAbilityBehavior extends DamageAbilityBehavior<DamageAreaAbilityBehaviorParameters> {
+    protected constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: DamageAreaAbilityBehaviorParameters);
+    protected damageArea(caster: Unit, x: number, y: number): void;
+}
+export declare class DamageSelfAreaAbilityBehavior extends DamageAreaAbilityBehavior {
+    constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: DamageAreaAbilityBehaviorParameters);
+    onImpact(caster: Unit): void;
+}
+export declare class DamageTargetAreaAbilityBehavior extends DamageAreaAbilityBehavior {
+    constructor(ability: Ability, damage: AbilityDependentValue<number>, parameters?: DamageAreaAbilityBehaviorParameters);
+    onNoTargetImpact(caster: Unit): void;
+    onWidgetTargetImpact(caster: Unit, target: Widget): void;
+    onPointTargetImpact(caster: Unit, x: number, y: number): void;
+}
+export {};