warscript 0.0.1-dev.19d0f81 → 0.0.1-dev.1a26d39

package/engine/internal/unit/range-event.d.ts

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+import { Event } from "../../../event";
+declare module "../unit" {
+    interface Unit {
+        readonly unitInRangeEvent: Record<number, Event<[unit: Unit, range: number, unitInRange: Unit]>>;
+    }
+}
+declare module "../unit" {
+    interface Unit {
+        readonly unitOutOfRangeEvent: Record<number, Event<[unit: Unit, range: number, unitOutOfRange: Unit]>>;
+    }
+}

package/engine/internal/unit/range-event.lua

@@ -0,0 +1,90 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____event = require("event")
+local Event = ____event.Event
+local InitializingEvent = ____event.InitializingEvent
+local TriggerEvent = ____event.TriggerEvent
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____attributes = require("attributes")
+local attribute = ____attributes.attribute
+local ____linked_2Dmap = require("utility.linked-map")
+local mutableLinkedMap = ____linked_2Dmap.mutableLinkedMap
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local mutableLinkedSet = ____linked_2Dset.mutableLinkedSet
+local getTriggerUnit = GetTriggerUnit
+local triggerRegisterUnitInRange = TriggerRegisterUnitInRange
+local eventInvoke = Event.invoke
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "unitInRangeEvent",
+    {get = function(self)
+        local unit = self
+        local handle = self.handle
+        local unitInRangeEvent = setmetatable(
+            {},
+            {__index = function(self, value)
+                local event = __TS__New(
+                    TriggerEvent,
+                    function(trigger)
+                        triggerRegisterUnitInRange(trigger, handle, value, nil)
+                    end,
+                    function() return unit, value, Unit:of(getTriggerUnit()) end
+                )
+                rawset(self, value, event)
+                return event
+            end}
+        )
+        rawset(self, "unitInRangeEvent", unitInRangeEvent)
+        return unitInRangeEvent
+    end}
+)
+local units = __TS__New(LinkedSet)
+local unitsInRangeByRangeAttribute = attribute()
+local function registerUnitOfRangeEvent(unit, range, unitInRange)
+    units:add(unit)
+    unit:getOrPut(unitsInRangeByRangeAttribute, mutableLinkedMap):getOrPut(range, mutableLinkedSet):add(unitInRange)
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "unitOutOfRangeEvent",
+    {get = function(self)
+        local unit = self
+        local unitOutOfRangeEvent = setmetatable(
+            {},
+            {__index = function(self, value)
+                local event = __TS__New(
+                    InitializingEvent,
+                    function()
+                        unit.unitInRangeEvent[value]:addListener(999999, registerUnitOfRangeEvent)
+                    end
+                )
+                rawset(self, value, event)
+                return event
+            end}
+        )
+        rawset(self, "unitOutOfRangeEvent", unitOutOfRangeEvent)
+        return unitOutOfRangeEvent
+    end}
+)
+Timer.onPeriod[1]:addListener(function()
+    for unit in pairs(units) do
+        local unitsInRangeByRange = unit[unitsInRangeByRangeAttribute]
+        if unitsInRangeByRange ~= nil then
+            for range, unitsInRange in pairs(unitsInRangeByRange) do
+                for unitInRange in pairs(unitsInRange) do
+                    if unit:getDistanceTo(unitInRange) > range then
+                        unitsInRange:remove(unitInRange)
+                        eventInvoke(unit.unitOutOfRangeEvent[range], unit, range, unitInRange)
+                    end
+                end
+            end
+        end
+    end
+end)
+return ____exports

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

@@ -0,0 +1,7 @@
+/** @noSelfInFile */
+declare module "../unit" {
+    interface Unit {
+        scale: number;
+    }
+}
+export {};

package/engine/internal/unit/scale.lua

@@ -0,0 +1,20 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____unit = require("engine.standard.fields.unit")
+local SCALING_VALUE_UNIT_FIELD = ____unit.SCALING_VALUE_UNIT_FIELD
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "scale",
+    {
+        get = function(self)
+            return SCALING_VALUE_UNIT_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            SCALING_VALUE_UNIT_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports

package/engine/internal/unit+ability.lua

@@ -7,8 +7,8 @@ local UnitAbility = ____ability.UnitAbility
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
-local Event = ____event.Event
 local createDispatchingEvent = ____event.createDispatchingEvent
+local Event = ____event.Event
 local abilityGainedEvent = createDispatchingEvent(
     __TS__New(Event),
     function(unit, ability) return ability.typeId end
@@ -40,6 +40,15 @@ ItemAbility.onCreate:addListener(
         end
     end
 )
+ItemAbility.destroyEvent:addListener(
+    4,
+    function(ability)
+        local unit = ability.owner.owner
+        if unit ~= nil then
+            Event.invoke(abilityLostEvent, unit, ability)
+        end
+    end
+)
 Unit.itemPickedUpEvent:addListener(
     0,
     function(unit, item)

package/engine/internal/unit+damage.lua

@@ -9,6 +9,8 @@ local ____dummy = require("objutil.dummy")
 local dummyUnitId = ____dummy.dummyUnitId
 local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
 local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
+local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
 local createUnit = CreateUnit
 local getOwningPlayer = GetOwningPlayer
 local showUnit = ShowUnit
@@ -79,9 +81,6 @@ for ____, player in ipairs(Player.all) do
     showUnit(dummy, false)
     dummies[player] = dummy
 end
----
--- @internal For use by internal systems only.
-____exports.damageMetadataByTarget = setmetatable({}, {__mode = "k"})
 Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType, metadata)
     if attack == nil then
         attack = false
@@ -104,7 +103,7 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
         handle = dummies[__TS__InstanceOf(target, Unit) and target.owner or (self._owner or Player.neutralAggressive)]
     end
     if __TS__InstanceOf(target, Unit) then
-        ____exports.damageMetadataByTarget[target] = metadata
+        damageMetadataByTarget[target] = metadata
     end
     return unitDamageTarget(
         handle,

package/engine/internal/unit-missile-launch.lua

@@ -9,9 +9,18 @@ local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
 local ____lua_2Dsets = require("utility.lua-sets")
 local luaSetOf = ____lua_2Dsets.luaSetOf
+local ____attributes = require("attributes")
+local attribute = ____attributes.attribute
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local ____math = require("math")
+local ceil = ____math.ceil
 local autoAttackFinishEvent = __TS__New(Event)
 rawset(Unit, "autoAttackFinishEvent", autoAttackFinishEvent)
-local eventTimerByUnit = {}
+local units = __TS__New(LinkedSet)
+local targetAttribute = attribute()
+local impactDelayAttribute = attribute()
+local passedTimeAttribute = attribute()
 local instantOrderIds = luaSetOf(
     orderId("avatar"),
     orderId("berserk"),
@@ -27,25 +36,54 @@ local instantOrderIds = luaSetOf(
     orderId("undivineshield"),
     orderId("unimmolation")
 )
-local function reset(source, orderId)
+---
+-- @internal For use by internal systems only.
+____exports.resetAutoAttackTimer = function(unit)
+    if units:remove(unit) then
+        unit[targetAttribute] = nil
+        unit[impactDelayAttribute] = nil
+        unit[passedTimeAttribute] = nil
+    end
+end
+local function reset(unit, orderId)
     if not (instantOrderIds[orderId] ~= nil) then
-        local eventTimer = eventTimerByUnit[source]
-        if eventTimer then
-            eventTimer:destroy()
-            eventTimerByUnit[source] = nil
-        end
+        ____exports.resetAutoAttackTimer(unit)
     end
 end
 Unit.onImmediateOrder:addListener(reset)
 Unit.onPointOrder:addListener(reset)
 Unit.onTargetOrder:addListener(reset)
-local function timerCallback(source, target)
-    eventTimerByUnit[source] = nil
-    Event.invoke(autoAttackFinishEvent, source, target)
+local timerPeriod = 1 / 64
+local function invokeEvent(unit)
+    units:remove(unit)
+    local target = unit[targetAttribute]
+    unit[targetAttribute] = nil
+    unit[impactDelayAttribute] = nil
+    unit[passedTimeAttribute] = nil
+    Event.invoke(autoAttackFinishEvent, unit, target)
+end
+local function checkUnit(unit)
+    local passedTime = unit[passedTimeAttribute] + timerPeriod
+    local impactDelay = unit[impactDelayAttribute]
+    if passedTime >= impactDelay and ceil(passedTime / 0.02) >= ceil(impactDelay / 0.02) then
+        invokeEvent(unit)
+    else
+        unit[passedTimeAttribute] = passedTime
+    end
 end
-Unit.autoAttackStartEvent:addListener(function(source, target)
-    local attackPoint = source.weapons[1].impactDelay
-    local timer = Timer:simple(attackPoint, timerCallback, source, target)
-    eventTimerByUnit[source] = timer
+Timer.onPeriod[timerPeriod]:addListener(function()
+    units:forEach(checkUnit)
 end)
+Unit.autoAttackStartEvent:addListener(
+    999999,
+    function(source, target)
+        if source[targetAttribute] ~= nil then
+            invokeEvent(source)
+        end
+        source[targetAttribute] = target
+        source[impactDelayAttribute] = (source:chooseWeapon(target) or source.firstWeapon).impactDelay
+        source[passedTimeAttribute] = -timerPeriod
+        units:add(source)
+    end
+)
 return ____exports

package/engine/internal/unit.d.ts

@@ -14,7 +14,7 @@ import { CombatClassification, CombatClassifications } from "../object-data/auxi
 import { MovementType } from "../object-data/auxiliary/movement-type";
 import { UnitAttribute } from "../object-data/auxiliary/unit-attribute";
 import { AttackType } from "../object-data/auxiliary/attack-type";
-import "./unit+damage";
+import { AttributesHolder } from "../../attributes";
 export type UnitClassification = junittype;
 export declare namespace UnitClassification {
     const STRUCTURE: junittype;
@@ -23,6 +23,7 @@ export declare namespace UnitClassification {
     const GROUND: junittype;
     const SUMMONED: junittype;
     const MECHANICAL: junittype;
+    const WORKER: junittype;
     const ANCIENT: junittype;
     const SUICIDAL: junittype;
     const TAUREN: junittype;
@@ -40,7 +41,7 @@ type AbilityDispatcherTable<T extends any[] = []> = {
     readonly [id: number]: Event<[Unit, Ability, ...T]>;
 };
 type AbilityEventDispatcher<T extends any[] = []> = Event<[Unit, Ability, ...T]> & AbilityDispatcherTable<T>;
-export interface DamagingEvent {
+export interface DamagingEvent extends AttributesHolder {
     amount: number;
     attackType: AttackType;
     damageType: jdamagetype;
@@ -49,8 +50,9 @@ export interface DamagingEvent {
     readonly isAttack: boolean;
     readonly originalAmount: number;
     readonly originalMetadata: unknown;
+    preventRetaliation(this: DamagingEvent): void;
 }
-export type DamageEvent = DamagingEvent & {
+export type DamageEvent = Omit<DamagingEvent, "preventRetaliation"> & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
 };
 export type AttackDamageEvent = DamagingEvent & {
@@ -78,10 +80,14 @@ export declare class UnitWeapon {
     readonly unit: Unit;
     readonly index: 0 | 1;
     constructor(unit: Unit, index: 0 | 1);
+    get isEnabled(): boolean;
+    set isEnabled(isEnabled: boolean);
     get cooldown(): number;
     set cooldown(cooldown: number);
     get damage(): [minimumDamage: number, maximumDamage: number];
     set damage([minimumDamage, maximumDamage]: [number, number]);
+    get allowedTargetCombatClassifications(): CombatClassifications;
+    set allowedTargetCombatClassifications(allowedTargetCombatClassifications: CombatClassifications);
     get damageBase(): number;
     set damageBase(damageBase: number);
     get damageDiceCount(): number;
@@ -103,12 +109,13 @@ declare const enum UnitPropertyKey {
     SYNC_ID = 100,
     IS_PAUSED = 101,
     STUN_COUNTER = 102,
-    DELAY_HEALTH_CHECKS_COUNTER = 103,
-    DELAY_HEALTH_CHECKS_HEALTH_BONUS = 104,
-    PREVENT_DEATH_HEALTH_BONUS = 105,
-    IS_TEAM_GLOW_HIDDEN = 106,
-    LAST_X = 107,
-    LAST_Y = 108
+    FORCE_STUN_COUNTER = 103,
+    DELAY_HEALTH_CHECKS_COUNTER = 104,
+    DELAY_HEALTH_CHECKS_HEALTH_BONUS = 105,
+    PREVENT_DEATH_HEALTH_BONUS = 106,
+    IS_TEAM_GLOW_HIDDEN = 107,
+    LAST_X = 108,
+    LAST_Y = 109
 }
 export type UnitSyncId = number & {
     readonly __unitSyncId: unique symbol;
@@ -117,6 +124,7 @@ export declare class Unit extends Handle<junit> {
     readonly syncId: UnitSyncId;
     private [UnitPropertyKey.IS_PAUSED]?;
     private [UnitPropertyKey.STUN_COUNTER]?;
+    private [UnitPropertyKey.FORCE_STUN_COUNTER]?;
     private [UnitPropertyKey.DELAY_HEALTH_CHECKS_COUNTER]?;
     private [UnitPropertyKey.DELAY_HEALTH_CHECKS_HEALTH_BONUS]?;
     private [UnitPropertyKey.PREVENT_DEATH_HEALTH_BONUS]?;
@@ -131,6 +139,7 @@ export declare class Unit extends Handle<junit> {
     private _fields?;
     private getEvent;
     constructor(handle: junit);
+    private saveData;
     protected onDestroy(): HandleDestructor;
     addAttackHandler(condition: AttackHandlerCondition, action: AttackHandlerAction): AttackHandler;
     removeAttackHandler(handler: AttackHandler): boolean;
@@ -156,29 +165,23 @@ export declare class Unit extends Handle<junit> {
     isInRangeOf(unit: Unit, range: number): boolean;
     isAllyOf(unit: Unit): boolean;
     isEnemyOf(unit: Unit): boolean;
-    playAnimation(animation: string, rarity?: jraritycontrol): void;
-    playAnimation(animation: number): void;
+    playAnimation(...parameters: [animation: number] | [animation: string, rarity?: jraritycontrol]): void;
     resetAnimation(): void;
     queueAnimation(animation: string): void;
     get weapons(): [UnitWeapon, UnitWeapon];
     get firstWeapon(): UnitWeapon;
     get secondWeapon(): UnitWeapon;
+    chooseWeapon(target: Unit): UnitWeapon | undefined;
     get level(): number;
     set level(v: number);
     get xp(): number;
     set xp(v: number);
     get primaryAttribute(): UnitAttribute;
     set primaryAttribute(primaryAttribute: UnitAttribute);
-    get strengthBase(): number;
-    set strengthBase(strengthBase: number);
     get strengthBonus(): number;
     get strength(): number;
-    get agilityBase(): number;
-    set agilityBase(agilityBase: number);
     get agilityBonus(): number;
     get agility(): number;
-    get intelligenceBase(): number;
-    set intelligenceBase(intelligenceBase: number);
     get intelligenceBonus(): number;
     get intelligence(): number;
     get name(): string;
@@ -212,8 +215,6 @@ export declare class Unit extends Handle<junit> {
     set facing(v: number);
     get speed(): number;
     set speed(v: number);
-    get flyHeight(): number;
-    set flyHeight(v: number);
     get x(): number;
     set x(v: number);
     get y(): number;
@@ -237,8 +238,6 @@ export declare class Unit extends Handle<junit> {
     get isInvulnerable(): boolean;
     get vertexColor(): Color;
     set vertexColor(v: Color);
-    get scale(): number;
-    set scale(v: number);
     get timeScale(): number;
     set timeScale(v: number);
     get collisionSize(): number;
@@ -262,18 +261,17 @@ export declare class Unit extends Handle<junit> {
     dropItemTarget(item: Item, target: Widget): boolean;
     dropItemSlot(item: Item, slot: number): boolean;
     itemInSlot(slot: number): Item | null;
-    addAbility(abilityId: number): UnitAbility | null;
+    addAbility(abilityId: number): UnitAbility | undefined;
     makeAbilityPermanent(abilityId: number, permanent: true): boolean;
     setAbilityLevel(abilityId: number, level: number): number;
     getAbilityLevel(abilityId: number): number;
     hasAbility(abilityId: number): boolean;
-    getAbilityById(abilityId: number): UnitAbility | undefined;
-    removeAbility(abilityId: number): boolean;
+    getAbility(abilityId: number): UnitAbility | undefined;
+    removeAbility(abilityTypeId: number): boolean;
     hideAbility(abilityId: number, flag: boolean): void;
     getAbilityRemainingCooldown(abilityId: number): number;
     startAbilityCooldown(abilityId: number, cooldown: number): void;
     endAbilityCooldown(abilityId: number): void;
-    interruptAttack(): void;
     interruptCast(abilityId: number): void;
     getDistanceTo(target: Unit | Vec2): number;
     getCollisionDistanceTo(...target: [Unit] | [targetX: number, targetY: number]): number;
@@ -287,14 +285,16 @@ export declare class Unit extends Handle<junit> {
     unpauseEx(): void;
     incrementStunCounter(): void;
     decrementStunCounter(): void;
+    incrementForceStunCounter(): void;
+    decrementForceStunCounter(): void;
     set waygateActive(v: boolean);
     get waygateActive(): boolean;
     set waygateDestination(v: Vec2);
     get waygateDestination(): Vec2;
     get abilities(): ReadonlyArray<UnitAbility>;
-    get onUnitInRange(): Record<number, Event<[Unit]>>;
     get onManaEqual(): Record<number, Event<[Unit, number]>>;
     get manaEvent(): Record<Operator, Record<number, Event<[Unit]>>>;
+    get targetAcquiredEvent(): Event;
     get onSelect(): Event;
     get onDeselect(): Event;
     get onImmediateOrder(): Event<[number]>;
@@ -310,6 +310,7 @@ export declare class Unit extends Handle<junit> {
     static getInCollisionRange(x: number, y: number, range: number, predicate?: (unit: Unit) => boolean): Unit[];
     static getInSector(pos: Vec2, range: number, offsetAngle: number, centralAngle: number): Unit[];
     static getSelectionOf(player: Player, target?: Unit[]): Unit[];
+    static readonly levelChangedEvent: UnitTriggerEvent<[]>;
     static readonly deathEvent: UnitTriggerEvent<[Unit]>;
     static readonly onDecay: UnitTriggerEvent<[]>;
     static readonly onResurrect: InitializingEvent<[Unit], void>;
@@ -347,7 +348,8 @@ export declare class Unit extends Handle<junit> {
     static itemDroppedEvent: UnitTriggerEvent<[Item]>;
     static itemPickedUpEvent: UnitTriggerEvent<[Item]>;
     static itemUsedEvent: UnitTriggerEvent<[Item]>;
-    static itemStackedEvent: UnitTriggerEvent<[Item]>;
+    static itemStackedEvent: UnitTriggerEvent<[target: Item, source: Item]>;
+    static get itemChargesChangedEvent(): Event<[unit: Unit, item: Item]>;
     static get itemUseOrderEvent(): Event<[unit: Unit, item: Item]>;
     static get itemMoveOrderEvent(): Event<[
         unit: Unit,
@@ -366,5 +368,6 @@ export declare class Unit extends Handle<junit> {
     setField(field: junitstringfield, value: string): boolean;
     toString(): string;
     static getBySyncId(syncId: UnitSyncId): Unit | undefined;
+    static synchronize: (player: Player, object: Unit | undefined) => Promise<Unit | undefined>;
 }
 export {};