warscript 0.0.1-dev.404878c

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: [x: number, y: number] | [number, x: number, y: 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<any>, 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, 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<any>, ConstructorParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, limit?: number): number;
+    static getFirst<T extends Behavior<any>, 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<any>, ConstructorParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never): T | undefined;
+    static getAll<T extends Behavior<any>, ConstructorParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never): T[];
+    static forFirst<T extends Behavior<any>, ConstructorParameters extends any[], ConsumerParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, count: number, consumer: (behavior: T, ...parameters: ConsumerParameters) => any, ...parameters: ConsumerParameters): number;
+    static forFirst<T extends Behavior<any>, ConstructorParameters extends any[], K extends KeysOfType<T, (...args: any) => any>>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, count: number, key: K, ...parameters: T[K] extends (...args: any) => any ? Parameters<T[K]> : never): number;
+    static forAll<T extends Behavior<any>, ConstructorParameters extends any[], ConsumerParameters extends any[]>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, consumer: (behavior: T, ...parameters: ConsumerParameters) => unknown, ...parameters: ConsumerParameters): number;
+    static forAll<T extends Behavior<any>, ConstructorParameters extends any[], K extends KeysOfType<T, (...args: any) => any>>(this: BehaviorConstructor<T, ConstructorParameters>, object: T extends Behavior<infer Object> ? Object : never, key: K, ...parameters: T[K] extends (...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,12 @@
+/** @noSelfInFile */
+import { AbilityBehavior } from "../ability";
+import { Ability } from "../../internal/ability";
+import { UnitBehaviorConstructor } from "../unit";
+import { Unit } from "../../internal/unit";
+export declare class ApplyUnitBehaviorAbilityBehavior<Args extends any[]> extends AbilityBehavior {
+    private readonly createUnitBehavior;
+    private unitBehavior?;
+    constructor(ability: Ability, unitBehaviorConstructor: UnitBehaviorConstructor<Args>, ...args: Args);
+    onUnitGainAbility(unit: Unit): void;
+    onUnitLoseAbility(): void;
+}

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

@@ -0,0 +1,36 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
+____exports.ApplyUnitBehaviorAbilityBehavior = __TS__Class()
+local ApplyUnitBehaviorAbilityBehavior = ____exports.ApplyUnitBehaviorAbilityBehavior
+ApplyUnitBehaviorAbilityBehavior.name = "ApplyUnitBehaviorAbilityBehavior"
+__TS__ClassExtends(ApplyUnitBehaviorAbilityBehavior, AbilityBehavior)
+function ApplyUnitBehaviorAbilityBehavior.prototype.____constructor(self, ability, unitBehaviorConstructor, ...)
+    local args = {...}
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.createUnitBehavior = function(____, unit)
+        return __TS__New(
+            unitBehaviorConstructor,
+            unit,
+            table.unpack(args)
+        )
+    end
+end
+function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitGainAbility(self, unit)
+    local ____opt_0 = self.unitBehavior
+    if ____opt_0 ~= nil then
+        ____opt_0:destroy()
+    end
+    self.unitBehavior = self:createUnitBehavior(unit)
+end
+function ApplyUnitBehaviorAbilityBehavior.prototype.onUnitLoseAbility(self)
+    local ____opt_2 = self.unitBehavior
+    if ____opt_2 ~= nil then
+        ____opt_2:destroy()
+    end
+end
+return ____exports

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

@@ -0,0 +1,25 @@
+/** @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";
+export declare class DamageSelfAbilityBehavior extends AbilityBehavior {
+    private readonly damage;
+    constructor(ability: Ability, damage: AbilityDependentValue<number>);
+    onImpact(caster: Unit): void;
+}
+export declare class DamageTargetAbilityBehavior extends AbilityBehavior {
+    private readonly damage;
+    constructor(ability: Ability, damage: AbilityDependentValue<number>);
+    onWidgetTargetImpact(caster: Unit, target: Widget): void;
+}
+export declare class DamageTargetAreaAbilityBehavior extends AbilityBehavior {
+    private readonly damage;
+    private readonly maximumDamage?;
+    constructor(ability: Ability, damage: AbilityDependentValue<number>, maximumDamage?: AbilityDependentValue<number> | undefined);
+    onNoTargetImpact(caster: Unit): void;
+    onWidgetTargetImpact(caster: Unit, target: Widget): void;
+    onPointTargetImpact(caster: Unit, x: number, y: number): void;
+    private damageArea;
+}

package/engine/behaviour/ability/damage.lua

@@ -0,0 +1,75 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+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.DamageSelfAbilityBehavior = __TS__Class()
+local DamageSelfAbilityBehavior = ____exports.DamageSelfAbilityBehavior
+DamageSelfAbilityBehavior.name = "DamageSelfAbilityBehavior"
+__TS__ClassExtends(DamageSelfAbilityBehavior, AbilityBehavior)
+function DamageSelfAbilityBehavior.prototype.____constructor(self, ability, damage)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.damage = damage
+end
+function DamageSelfAbilityBehavior.prototype.onImpact(self, caster)
+    caster:damageTarget(
+        caster,
+        self:resolveCurrentAbilityDependentValue(self.damage)
+    )
+end
+____exports.DamageTargetAbilityBehavior = __TS__Class()
+local DamageTargetAbilityBehavior = ____exports.DamageTargetAbilityBehavior
+DamageTargetAbilityBehavior.name = "DamageTargetAbilityBehavior"
+__TS__ClassExtends(DamageTargetAbilityBehavior, AbilityBehavior)
+function DamageTargetAbilityBehavior.prototype.____constructor(self, ability, damage)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.damage = damage
+end
+function DamageTargetAbilityBehavior.prototype.onWidgetTargetImpact(self, caster, target)
+    caster:damageTarget(
+        target,
+        self:resolveCurrentAbilityDependentValue(self.damage)
+    )
+end
+____exports.DamageTargetAreaAbilityBehavior = __TS__Class()
+local DamageTargetAreaAbilityBehavior = ____exports.DamageTargetAreaAbilityBehavior
+DamageTargetAreaAbilityBehavior.name = "DamageTargetAreaAbilityBehavior"
+__TS__ClassExtends(DamageTargetAreaAbilityBehavior, AbilityBehavior)
+function DamageTargetAreaAbilityBehavior.prototype.____constructor(self, ability, damage, maximumDamage)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.damage = damage
+    self.maximumDamage = maximumDamage
+end
+function DamageTargetAreaAbilityBehavior.prototype.onNoTargetImpact(self, caster)
+    self:damageArea(caster, caster.x, caster.y)
+end
+function DamageTargetAreaAbilityBehavior.prototype.onWidgetTargetImpact(self, caster, target)
+    self:damageArea(caster, target.x, target.y)
+end
+function DamageTargetAreaAbilityBehavior.prototype.onPointTargetImpact(self, caster, x, y)
+    self:damageArea(caster, x, y)
+end
+function DamageTargetAreaAbilityBehavior.prototype.damageArea(self, caster, x, y)
+    local targets = Unit.getAllowedTargetsInCollisionRange(
+        caster,
+        self:resolveCurrentAbilityDependentValue(ALLOWED_TARGETS_ABILITY_COMBAT_CLASSIFICATIONS_LEVEL_FIELD),
+        x,
+        y,
+        self:resolveCurrentAbilityDependentValue(AREA_OF_EFFECT_ABILITY_FLOAT_LEVEL_FIELD)
+    )
+    local damage = self:resolveCurrentAbilityDependentValue(self.damage)
+    local maximumDamage = self:resolveCurrentAbilityDependentValue(self.maximumDamage or 0)
+    if maximumDamage ~= 0 and damage > maximumDamage then
+        damage = maximumDamage / #targets
+    end
+    for ____, target in ipairs(targets) do
+        caster:damageTarget(target, damage)
+    end
+end
+return ____exports

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

@@ -0,0 +1,16 @@
+/** @noSelfInFile */
+import { Widget } from "../../../core/types/widget";
+import { Ability } from "../../internal/ability";
+import { Unit } from "../../internal/unit";
+import { AbilityDependentValue } from "../../object-field/ability";
+import { AbilityBehavior } from "../ability";
+export declare class HealSelfAbilityBehavior extends AbilityBehavior {
+    private readonly healing;
+    constructor(ability: Ability, healing: AbilityDependentValue<number>);
+    onImpact(caster: Unit): void;
+}
+export declare class HealTargetAbilityBehavior extends AbilityBehavior {
+    private readonly healing;
+    constructor(ability: Ability, healing: AbilityDependentValue<number>);
+    onWidgetTargetImpact(caster: Unit, target: Widget): void;
+}

package/engine/behaviour/ability/heal.lua

@@ -0,0 +1,35 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____ability = require("engine.behaviour.ability")
+local AbilityBehavior = ____ability.AbilityBehavior
+____exports.HealSelfAbilityBehavior = __TS__Class()
+local HealSelfAbilityBehavior = ____exports.HealSelfAbilityBehavior
+HealSelfAbilityBehavior.name = "HealSelfAbilityBehavior"
+__TS__ClassExtends(HealSelfAbilityBehavior, AbilityBehavior)
+function HealSelfAbilityBehavior.prototype.____constructor(self, ability, healing)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.healing = healing
+end
+function HealSelfAbilityBehavior.prototype.onImpact(self, caster)
+    caster:healTarget(
+        caster,
+        self:resolveCurrentAbilityDependentValue(self.healing)
+    )
+end
+____exports.HealTargetAbilityBehavior = __TS__Class()
+local HealTargetAbilityBehavior = ____exports.HealTargetAbilityBehavior
+HealTargetAbilityBehavior.name = "HealTargetAbilityBehavior"
+__TS__ClassExtends(HealTargetAbilityBehavior, AbilityBehavior)
+function HealTargetAbilityBehavior.prototype.____constructor(self, ability, healing)
+    AbilityBehavior.prototype.____constructor(self, ability)
+    self.healing = healing
+end
+function HealTargetAbilityBehavior.prototype.onWidgetTargetImpact(self, caster, target)
+    caster:healTarget(
+        target,
+        self:resolveCurrentAbilityDependentValue(self.healing)
+    )
+end
+return ____exports

package/engine/behaviour/ability/instant-impact.d.ts

@@ -0,0 +1,6 @@
+/** @noSelfInFile */
+import { AbilityBehavior } from "../ability";
+import { Unit } from "../../internal/unit";
+export declare class InstantImpactAbilityBehavior extends AbilityBehavior {
+    onCastingStart(caster: Unit): void;
+}