warscript 0.0.1-dev.4753736 → 0.0.1-dev.47e7849

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

@@ -133,55 +133,55 @@ declare module "../unit" {
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityImpactEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityChannelingFinishEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityWidgetTargetImpactEvent: DispatchingEvent<[Unit, Ability, Widget]>;
+        const abilityStopEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityUnitTargetImpactEvent: DispatchingEvent<[Unit, Ability, Unit]>;
+        const abilityCommandEvent: {
+            readonly [abilityTypeId: number]: {
+                readonly [orderTypeStringId: string]: Event<[Unit, Ability, string]>;
+            };
+        };
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityItemTargetImpactEvent: DispatchingEvent<[Unit, Ability, Item]>;
+        const abilityImpactEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityDestructibleTargetImpactEvent: DispatchingEvent<[Unit, Ability, Destructable]>;
+        const abilityWidgetTargetImpactEvent: DispatchingEvent<[Unit, Ability, Widget]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityPointTargetImpactEvent: DispatchingEvent<[Unit, Ability, number, number]>;
+        const abilityUnitTargetImpactEvent: DispatchingEvent<[Unit, Ability, Unit]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityNoTargetImpactEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityItemTargetImpactEvent: DispatchingEvent<[Unit, Ability, Item]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityChannelingFinishEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityDestructibleTargetImpactEvent: DispatchingEvent<[Unit, Ability, Destructable]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityStopEvent: DispatchingEvent<[Unit, Ability]>;
+        const abilityPointTargetImpactEvent: DispatchingEvent<[Unit, Ability, number, number]>;
     }
 }
 declare module "../unit" {
     namespace Unit {
-        const abilityCommandEvent: {
-            readonly [abilityTypeId: number]: {
-                readonly [orderTypeStringId: string]: Event<[Unit, Ability, string]>;
-            };
-        };
+        const abilityNoTargetImpactEvent: DispatchingEvent<[Unit, Ability]>;
     }
 }

package/engine/internal/unit/ability.lua

@@ -22,7 +22,12 @@ local checkNotNull = ____preconditions.checkNotNull
 local ____lazy = require("utility.lazy")
 local lazyRecord = ____lazy.lazyRecord
 local ____timer = require("core.types.timer")
+local consumeZeroTimerCallback = ____timer.consumeZeroTimerCallback
 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 eventInvoke = Event.invoke
 local condition = Condition
 local createTrigger = CreateTrigger
@@ -347,10 +352,65 @@ rawset(
         extractAbilityTypeId
     )
 )
+local internalAbilityChannelingFinishEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_FINISH, collectUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityChannelingFinishEvent",
+    createDispatchingEvent(internalAbilityChannelingFinishEvent, extractAbilityTypeId)
+)
+local internalAbilityStopEvent = __TS__New(UnitTriggerEvent, EVENT_PLAYER_UNIT_SPELL_ENDCAST, collectUnitAbilityEventParameters)
+rawset(
+    Unit,
+    "abilityStopEvent",
+    createDispatchingEvent(internalAbilityStopEvent, extractAbilityTypeId)
+)
+rawset(
+    Unit,
+    "abilityCommandEvent",
+    lazyRecord(function(abilityTypeId)
+        return lazyRecord(function(orderTypeStringId)
+            return __TS__New(
+                InitializingEvent,
+                function(event)
+                    local trigger = createTrigger()
+                    triggerRegisterCommandEvent(trigger, abilityTypeId, orderTypeStringId)
+                    triggerAddCondition(
+                        trigger,
+                        condition(function()
+                            local unit = Unit:of(getTriggerUnit())
+                            if unit ~= nil then
+                                local ability = unit:getAbility(abilityTypeId)
+                                if ability ~= nil then
+                                    eventInvoke(event, unit, ability, orderTypeStringId)
+                                end
+                            end
+                        end)
+                    )
+                end
+            )
+        end)
+    end)
+)
 local internalAbilityImpactEvent = __TS__New(Event)
-internalAbilityChannelingStartEvent:addListener(function(...)
-    Timer:run(eventInvoke, internalAbilityImpactEvent, ...)
-end)
+local impactCallbackIdAttribute = attribute()
+local function invokeImpactEvent(unit, ability, ...)
+    ability[impactCallbackIdAttribute] = nil
+    eventInvoke(internalAbilityImpactEvent, unit, ability, ...)
+end
+internalAbilityChannelingStartEvent:addListener(
+    999999,
+    function(unit, ability, ...)
+        ability[impactCallbackIdAttribute] = Timer:run(invokeImpactEvent, unit, ability, ...)
+    end
+)
+local function consumeImpactCallback(_, ability)
+    local impactCallbackId = ability[impactCallbackIdAttribute]
+    if impactCallbackId ~= nil then
+        consumeZeroTimerCallback(impactCallbackId)
+    end
+end
+internalAbilityChannelingFinishEvent:addListener(999999, consumeImpactCallback)
+internalAbilityStopEvent:addListener(999999, consumeImpactCallback)
 rawset(
     Unit,
     "abilityImpactEvent",
@@ -407,47 +467,14 @@ rawset(
         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
-    )
-)
-rawset(
-    Unit,
-    "abilityCommandEvent",
-    lazyRecord(function(abilityTypeId)
-        return lazyRecord(function(orderTypeStringId)
-            return __TS__New(
-                InitializingEvent,
-                function(event)
-                    local trigger = createTrigger()
-                    triggerRegisterCommandEvent(trigger, abilityTypeId, orderTypeStringId)
-                    triggerAddCondition(
-                        trigger,
-                        condition(function()
-                            local unit = Unit:of(getTriggerUnit())
-                            if unit ~= nil then
-                                local ability = unit:getAbility(abilityTypeId)
-                                if ability ~= nil then
-                                    eventInvoke(event, unit, ability, orderTypeStringId)
-                                end
-                            end
-                        end)
-                    )
-                end
-            )
-        end)
-    end)
+local spellEffectOnlyAbilityTypeIds = luaSetOf(fourCC("AAns"))
+internalAbilityChannelingStartEvent:addListener(
+    -999999,
+    function(unit, ability)
+        if spellEffectOnlyAbilityTypeIds[ability.parentTypeId] ~= nil then
+            eventInvoke(internalAbilityChannelingFinishEvent, unit, ability)
+            eventInvoke(internalAbilityStopEvent, unit, ability)
+        end
+    end
 )
 return ____exports

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

@@ -12,6 +12,7 @@ export type UnitAutoAttackDamageBonusId = UnitBonusId<"autoAttackDamage">;
 export type UnitDamageFactorBonusId = UnitBonusId<"damageFactor">;
 export type UnitReceivedDamageFactorBonusId = UnitBonusId<"receivedDamageFactor">;
 export type UnitEvasionProbabilityBonusId = UnitBonusId<"evasionProbability">;
+export type UnitManaRegenerationRateFactorBonusId = UnitBonusId<"manaRegenerationRateFactor">;
 export type UnitBonusType<Id extends UnitBonusId = UnitBonusId> = ({
     abilityTypeId: AbilityTypeId;
     field: jabilityintegerlevelfield;
@@ -36,6 +37,7 @@ export declare namespace UnitBonusType {
     const DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
     const RECEIVED_DAMAGE_FACTOR: UnitBonusType<UnitReceivedDamageFactorBonusId>;
     const EVASION_PROBABILITY: UnitBonusType<UnitEvasionProbabilityBonusId>;
+    const MANA_REGENERATION_RATE_FACTOR: UnitBonusType<UnitManaRegenerationRateFactorBonusId>;
 }
 export declare const addUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, value: number) => Id;
 export declare const removeUnitBonus: <Id extends UnitBonusId>(unit: Unit, bonusType: UnitBonusType<Id>, id: Id) => boolean;

package/engine/internal/unit/bonus.lua

@@ -24,6 +24,9 @@ local MOVEMENT_SPEED_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____movement_2Dspee
 local ____evasion_2Dprobability = require("engine.internal.object-data.evasion-probability")
 local EVASION_PROBABILITY_ABILITY_FIELD = ____evasion_2Dprobability.EVASION_PROBABILITY_ABILITY_FIELD
 local EVASION_PROBABILITY_DUMMY_ABILITY_TYPE_ID = ____evasion_2Dprobability.EVASION_PROBABILITY_DUMMY_ABILITY_TYPE_ID
+local ____mana_2Dregeneration_2Drate_2Dincrease_2Dfactor = require("engine.internal.object-data.mana-regeneration-rate-increase-factor")
+local MANA_REGENERATION_RATE_INCREASE_FACTOR_ABILITY_FIELD = ____mana_2Dregeneration_2Drate_2Dincrease_2Dfactor.MANA_REGENERATION_RATE_INCREASE_FACTOR_ABILITY_FIELD
+local MANA_REGENERATION_RATE_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID = ____mana_2Dregeneration_2Drate_2Dincrease_2Dfactor.MANA_REGENERATION_RATE_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID
 local damageFactorByUnit = {}
 local receivedDamageFactorByUnit = {}
 local function atLeastOnceProbability(array)
@@ -73,6 +76,13 @@ do
         reduce = atLeastOnceProbability,
         initialValue = 0
     }
+    UnitBonusType.MANA_REGENERATION_RATE_FACTOR = {
+        abilityTypeId = MANA_REGENERATION_RATE_INCREASE_FACTOR_DUMMY_ABILITY_TYPE_ID,
+        field = MANA_REGENERATION_RATE_INCREASE_FACTOR_ABILITY_FIELD,
+        integer = false,
+        reduce = sum,
+        initialValue = 0
+    }
 end
 local bonusesByUnitByBonusType = {}
 local nextId = 1

package/engine/internal/unit/fly-height.d.ts

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

package/engine/internal/unit/fly-height.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 FLY_HEIGHT_UNIT_FLOAT_FIELD = ____unit.FLY_HEIGHT_UNIT_FLOAT_FIELD
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "flyHeight",
+    {
+        get = function(self)
+            return FLY_HEIGHT_UNIT_FLOAT_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            FLY_HEIGHT_UNIT_FLOAT_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports

package/engine/internal/unit/main-selected.lua

@@ -1,46 +1,31 @@
 local ____lualib = require("lualib_bundle")
 local __TS__New = ____lualib.__TS__New
 local ____exports = {}
-local ____player = require("core.types.player")
-local Player = ____player.Player
-local ____math = require("math")
-local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
-local MINIMUM_INTEGER = ____math.MINIMUM_INTEGER
 local ____local_2Dclient = require("engine.local-client")
 local LocalClient = ____local_2Dclient.LocalClient
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
 local Event = ____event.Event
+local ____synchronization = require("engine.synchronization")
+local ObjectBus = ____synchronization.ObjectBus
 local mainSelectedUnitChangeEvent = __TS__New(Event)
 rawset(Unit, "mainSelectedUnitChangeEvent", mainSelectedUnitChangeEvent)
 local mainSelectedUnitByPlayer = {}
-local syncSlider = BlzCreateFrameByType(
-    "SLIDER",
-    "UnitSyncId",
-    BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0),
-    "",
-    0
+local unitBus = __TS__New(
+    ObjectBus,
+    function(unit) return unit.syncId end,
+    function(syncId) return Unit:getBySyncId(syncId) end
 )
-BlzFrameSetMinMaxValue(syncSlider, MINIMUM_INTEGER, MAXIMUM_INTEGER)
 LocalClient.mainSelectedUnitChangeEvent:addListener(function()
-    local ____opt_0 = LocalClient.mainSelectedUnit
-    local syncId = ____opt_0 and ____opt_0.syncId
-    BlzFrameSetValue(syncSlider, syncId or 0)
+    unitBus:send(LocalClient.mainSelectedUnit)
 end)
-local trg = CreateTrigger()
-BlzTriggerRegisterFrameEvent(trg, syncSlider, FRAMEEVENT_SLIDER_VALUE_CHANGED)
-TriggerAddAction(
-    trg,
-    function()
-        local player = Player:of(GetTriggerPlayer())
-        local mainSelectedUnit = Unit:getBySyncId(BlzGetTriggerFrameValue())
-        if mainSelectedUnit ~= mainSelectedUnitByPlayer[player] then
-            mainSelectedUnitByPlayer[player] = mainSelectedUnit
-            Event.invoke(mainSelectedUnitChangeEvent, player)
-        end
+unitBus.event:addListener(function(player, unit)
+    if unit ~= mainSelectedUnitByPlayer[player] then
+        mainSelectedUnitByPlayer[player] = unit
+        Event.invoke(mainSelectedUnitChangeEvent, player)
     end
-)
+end)
 rawset(
     Unit,
     "getMainSelectedOf",

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_FLOAT_FIELD = ____unit.SCALING_VALUE_UNIT_FLOAT_FIELD
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "scale",
+    {
+        get = function(self)
+            return SCALING_VALUE_UNIT_FLOAT_FIELD:getValue(self)
+        end,
+        set = function(self, value)
+            SCALING_VALUE_UNIT_FLOAT_FIELD:setValue(self, value)
+        end
+    }
+)
+return ____exports

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

@@ -9,11 +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 min = ____math.min
+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"),
@@ -30,35 +37,46 @@ local instantOrderIds = luaSetOf(
     orderId("unimmolation")
 )
 local function reset(source, orderId)
-    if not (instantOrderIds[orderId] ~= nil) then
-        local eventTimer = eventTimerByUnit[source]
-        if eventTimer then
-            eventTimer:destroy()
-            eventTimerByUnit[source] = nil
-        end
+    if not (instantOrderIds[orderId] ~= nil) and units:remove(source) then
+        source[targetAttribute] = nil
+        source[impactDelayAttribute] = nil
+        source[passedTimeAttribute] = nil
     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
+Timer.onPeriod[timerPeriod]:addListener(function()
+    units:forEach(checkUnit)
+end)
 Unit.autoAttackStartEvent:addListener(
-    4,
+    999999,
     function(source, target)
-        local attackPoint = (source:chooseWeapon(target) or source.firstWeapon).impactDelay
-        local timer = Timer:simple(
-            attackPoint + min(
-                compiletime(1 / 64),
-                attackPoint / 2
-            ),
-            timerCallback,
-            source,
-            target
-        )
-        eventTimerByUnit[source] = timer
+        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

@@ -80,6 +80,8 @@ 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];
@@ -107,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;
@@ -121,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]?;
@@ -216,8 +220,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;
@@ -241,8 +243,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;
@@ -292,6 +292,8 @@ 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);
@@ -373,5 +375,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 {};