warscript 0.0.1-dev.d1983c6 → 0.0.1-dev.d1b563b

package/core/types/frame.lua

@@ -19,13 +19,16 @@ local ____frame_2Dcoordinates = require("engine.internal.misc.frame-coordinates"
 local FRAME_MAX_Y = ____frame_2Dcoordinates.FRAME_MAX_Y
 local FRAME_MIN_Y = ____frame_2Dcoordinates.FRAME_MIN_Y
 local getFrameMinXMaxX = ____frame_2Dcoordinates.getFrameMinXMaxX
+local ____playerCamera = require("core.types.playerCamera")
+local frameCoordinatesToWorld = ____playerCamera.frameCoordinatesToWorld
+local worldCoordinatesToFrame = ____playerCamera.worldCoordinatesToFrame
+local ____get_2Dterrain_2Dz = require("engine.internal.misc.get-terrain-z")
+local getTerrainZ = ____get_2Dterrain_2Dz.getTerrainZ
 local frameClick = BlzFrameClick
 local frameGetEnable = BlzFrameGetEnable
 local frameIsVisible = BlzFrameIsVisible
 local frameSetEnable = BlzFrameSetEnable
 local frameSetScale = BlzFrameSetScale
-local getCameraTargetPositionX = GetCameraTargetPositionX
-local getCameraTargetPositionY = GetCameraTargetPositionY
 local ____rawget = _G.rawget
 local rawset = _G.rawset
 local invoke = Event.invoke
@@ -936,16 +939,19 @@ __TS__ObjectDefineProperty(
         local event = __TS__New(Event)
         local syncX = 0
         local syncY = 0
-        local syncCamX = getCameraTargetPositionX()
-        local syncCamY = getCameraTargetPositionY()
+        local syncFrameX = 0
+        local syncFrameY = 0
         local lastX = syncX
         local lastY = syncY
         self.onMouseMove:addListener(function(player, x, y)
             if player.isLocal then
                 syncX = x
                 syncY = y
-                syncCamX = getCameraTargetPositionX()
-                syncCamY = getCameraTargetPositionY()
+                syncFrameX, syncFrameY = worldCoordinatesToFrame(
+                    x,
+                    y,
+                    getTerrainZ(x, y)
+                )
                 lastX = x
                 lastY = y
                 invoke(event, x, y)
@@ -955,9 +961,8 @@ __TS__ObjectDefineProperty(
             if syncX == 0 and syncY == 0 then
                 return
             end
-            local x = syncX + (getCameraTargetPositionX() - syncCamX)
-            local y = syncY + (getCameraTargetPositionY() - syncCamY)
-            if x ~= lastX or y ~= lastY then
+            local x, y, ____, isDefinite = frameCoordinatesToWorld(syncFrameX, syncFrameY)
+            if isDefinite and (x ~= lastX or y ~= lastY) then
                 lastX = x
                 lastY = y
                 invoke(event, x, y)

package/core/types/playerCamera.lua

@@ -13,6 +13,8 @@ local ____frame_2Dcoordinates = require("engine.internal.misc.frame-coordinates"
 local FRAME_MAX_Y = ____frame_2Dcoordinates.FRAME_MAX_Y
 local FRAME_MIN_Y = ____frame_2Dcoordinates.FRAME_MIN_Y
 local getFrameMinXMaxX = ____frame_2Dcoordinates.getFrameMinXMaxX
+local ____get_2Dterrain_2Dz = require("engine.internal.misc.get-terrain-z")
+local getTerrainZ = ____get_2Dterrain_2Dz.getTerrainZ
 local getHandleId = GetHandleId
 local setCameraField = SetCameraField
 local getCameraField = GetCameraField
@@ -26,6 +28,7 @@ local resetToGameCamera = ResetToGameCamera
 local cos = math.cos
 local deg = math.deg
 local sin = math.sin
+local sqrt = math.sqrt
 local memoized = {}
 ____exports.PlayerCamera = __TS__Class()
 local PlayerCamera = ____exports.PlayerCamera
@@ -233,4 +236,45 @@ ____exports.worldCoordinatesToFrame = function(x, y, z)
     local frameY = 0.42625 - yCenterScreenShift + (cameraAngleOfAttackSinRotationCos * dx + cameraAngleOfAttackSinRotationSin * dy - cameraAngleOfAttackCos * dz) / xPrime
     return frameX, frameY, xPrime < 0 and frameX >= frameMinX and frameX <= frameMaxX and frameY >= FRAME_MIN_Y and frameY <= FRAME_MAX_Y
 end
+---
+-- @internal For use by internal systems only.
+____exports.frameCoordinatesToWorld = function(x, y)
+    if not isCameraViewPrecalculated then
+        precalculateCameraView()
+    end
+    local a = (x - 0.4) * scaleFactor
+    local b = (0.42625 - yCenterScreenShift - y) * scaleFactor
+    local nx = 1 / sqrt(1 + a * a + b * b)
+    local ny = sqrt(1 - (1 + b * b) * nx * nx)
+    local nz = sqrt(1 - nx * nx - ny * ny)
+    if a > 0 then
+        ny = -ny
+    end
+    if b < 0 then
+        nz = -nz
+    end
+    local nxPrime = cameraAngleOfAttackCosRotationCos * nx - cameraRotationSin * ny + cameraAngleOfAttackSinRotationCos * nz
+    local nyPrime = cameraAngleOfAttackCosRotationSin * nx + cameraRotationCos * ny + cameraAngleOfAttackSinRotationSin * nz
+    local nzPrime = -cameraAngleOfAttackSin * nx + cameraAngleOfAttackCos * nz
+    local zGuess = getTerrainZ(cameraEyeX, cameraEyeY)
+    local xGuess = cameraEyeX + nxPrime * (cameraEyeZ - zGuess) / nzPrime
+    local yGuess = cameraEyeY + nyPrime * (cameraEyeZ - zGuess) / nzPrime
+    local zWorld = getTerrainZ(xGuess, yGuess)
+    local deltaZ = zWorld - zGuess
+    zGuess = zWorld
+    local zWorldOld = zWorld
+    local deltaZOld = deltaZ
+    local i = 0
+    while (deltaZ > 1 or deltaZ < -1) and i < 50 do
+        xGuess = cameraEyeX + nxPrime * (cameraEyeZ - zGuess) / nzPrime
+        yGuess = cameraEyeY + nyPrime * (cameraEyeZ - zGuess) / nzPrime
+        zWorld = getTerrainZ(xGuess, yGuess)
+        deltaZ = zWorld - zGuess
+        zGuess = (deltaZOld * zWorld - deltaZ * zWorldOld) / (deltaZOld - deltaZ)
+        zWorldOld = zWorld
+        deltaZOld = deltaZ
+        i = i + 1
+    end
+    return xGuess, yGuess, zWorld, i < 50
+end
 return ____exports

package/core/types/tileCell.d.ts

@@ -5,6 +5,15 @@ export declare class TileCell implements Readonly<Vec2> {
     readonly y: number;
     readonly z: undefined;
     protected constructor(id: number, x: number, y: number, z: undefined);
+    get up(): TileCell;
+    get down(): TileCell;
+    get left(): TileCell;
+    get right(): TileCell;
+    get terrainTypeId(): number;
+    set terrainTypeId(terrainTypeId: number);
+    get terrainVariance(): number;
+    set terrainVariance(terrainVariance: number);
+    randomizeTerrainVariance(): void;
     isInRangeOf(x: number, y: number, range: number): boolean;
     isInRangeOf(tileCell: TileCell, range: number): boolean;
     static getInRect(minX: number, minY: number, maxX: number, maxY: number): TileCell[];

package/core/types/tileCell.lua

@@ -1,7 +1,11 @@
 local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
 local ____exports = {}
+local getTerrainType = GetTerrainType
+local setTerrainType = SetTerrainType
+local getTerrainVariance = GetTerrainVariance
 local abs = math.abs
 local ____type = math.type
 local ult = math.ult
@@ -16,6 +20,18 @@ function TileCell.prototype.____constructor(self, id, x, y, z)
     self.z = z
     tileCellById[id] = self
 end
+function TileCell.prototype.randomizeTerrainVariance(self)
+    local x = self.x
+    local y = self.y
+    setTerrainType(
+        x,
+        y,
+        getTerrainType(x, y),
+        -1,
+        1,
+        1
+    )
+end
 function TileCell.prototype.isInRangeOf(self, x, y, range)
     if range == nil then
         range = y
@@ -97,4 +113,80 @@ function TileCell.of(x, y)
         nil
     )
 end
+__TS__SetDescriptor(
+    TileCell.prototype,
+    "up",
+    {get = function(self)
+        return ____exports.TileCell.of(self.x, self.y + 128)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    TileCell.prototype,
+    "down",
+    {get = function(self)
+        return ____exports.TileCell.of(self.x, self.y - 128)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    TileCell.prototype,
+    "left",
+    {get = function(self)
+        return ____exports.TileCell.of(self.x - 128, self.y)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    TileCell.prototype,
+    "right",
+    {get = function(self)
+        return ____exports.TileCell.of(self.x + 128, self.y)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    TileCell.prototype,
+    "terrainTypeId",
+    {
+        get = function(self)
+            return getTerrainType(self.x, self.y)
+        end,
+        set = function(self, terrainTypeId)
+            local x = self.x
+            local y = self.y
+            setTerrainType(
+                x,
+                y,
+                terrainTypeId,
+                getTerrainVariance(x, y),
+                1,
+                1
+            )
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    TileCell.prototype,
+    "terrainVariance",
+    {
+        get = function(self)
+            return getTerrainVariance(self.x, self.y)
+        end,
+        set = function(self, terrainVariance)
+            local x = self.x
+            local y = self.y
+            setTerrainType(
+                x,
+                y,
+                getTerrainType(x, y),
+                terrainVariance,
+                1,
+                1
+            )
+        end
+    },
+    true
+)
 return ____exports

package/core/types/timer.lua

@@ -12,6 +12,10 @@ local ____objectPool = require("util.objectPool")
 local ObjectPool = ____objectPool.ObjectPool
 local ____destroyable = require("destroyable")
 local AbstractDestroyable = ____destroyable.AbstractDestroyable
+local ____callback_2Darray = require("utility.callback-array")
+local addCallback = ____callback_2Darray.addCallback
+local callbackArray = ____callback_2Darray.callbackArray
+local consumeCallbacks = ____callback_2Darray.consumeCallbacks
 local createTimer = CreateTimer
 local timerStart = TimerStart
 local pauseTimer = PauseTimer
@@ -49,6 +53,12 @@ local function timerSafeCall()
         end
     end
 end
+local zeroTimerScheduled = false
+local zeroTimerCallbacks = callbackArray()
+local function invokeZeroTimerCallbacks()
+    zeroTimerScheduled = false
+    consumeCallbacks(zeroTimerCallbacks)
+end
 ____exports.Timer = __TS__Class()
 local Timer = ____exports.Timer
 Timer.name = "Timer"
@@ -83,10 +93,14 @@ function Timer.create(self)
     return __TS__New(____exports.Timer)
 end
 function Timer.run(self, objectOrCallback, keyOrFirstArg, ...)
+    if not zeroTimerScheduled then
+        zeroTimerScheduled = true
+        ____exports.Timer:simple(0, invokeZeroTimerCallbacks)
+    end
     if ____type(objectOrCallback) == "function" then
-        ____exports.Timer:simple(0, objectOrCallback, keyOrFirstArg, ...)
+        addCallback(zeroTimerCallbacks, objectOrCallback, keyOrFirstArg, ...)
     else
-        ____exports.Timer:simple(0, objectOrCallback[keyOrFirstArg], objectOrCallback, ...)
+        addCallback(zeroTimerCallbacks, objectOrCallback[keyOrFirstArg], objectOrCallback, ...)
     end
 end
 function Timer.simple(self, timeout, callback, ...)

package/decl/native.d.ts

@@ -5259,8 +5259,8 @@ declare function BlzRemoveAbilityStringLevelArrayField(
     level: number,
     value: string,
 ): boolean
-declare function BlzGetItemAbilityByIndex(whichItem: jitem, index: number): jability | null
-declare function BlzGetItemAbility(whichItem: jitem, abilCode: number): jability | null
+declare function BlzGetItemAbilityByIndex(whichItem: jitem, index: number): jability | undefined
+declare function BlzGetItemAbility(whichItem: jitem, abilCode: number): jability | undefined
 declare function BlzItemAddAbility(whichItem: jitem, abilCode: number): boolean
 declare function BlzGetItemBooleanField(whichItem: jitem, whichField: jitembooleanfield): boolean
 declare function BlzGetItemIntegerField(whichItem: jitem, whichField: jitemintegerfield): number

package/engine/behavior.d.ts

@@ -1,5 +1,6 @@
 /** @noSelfInFile */
 import { AbstractDestroyable, Destructor } from "../destroyable";
+import { Event } from "../event";
 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,
@@ -13,6 +14,8 @@ export declare abstract class Behavior<T extends AnyNotNil, PeriodicActionParame
     private [BehaviorPropertyKey.TIMER]?;
     protected constructor(object: T);
     protected onDestroy(): Destructor;
+    protected registerEvent<K extends string, Args extends any[]>(this: Behavior<any, PeriodicActionParameters> & Record<K, (this: this, ...args: Args) => unknown>, event: Event<[...Args]>, listener: K): void;
+    protected deregisterEvent(event: Event<any>): boolean;
     protected onPeriod(...parameters: PeriodicActionParameters): void;
     protected startPeriodicAction(interval: number, ...parameters: PeriodicActionParameters): void;
     protected stopPeriodicAction(): void;

package/engine/behavior.lua

@@ -2,6 +2,7 @@ local ____lualib = require("lualib_bundle")
 local __TS__InstanceOf = ____lualib.__TS__InstanceOf
 local __TS__Class = ____lualib.__TS__Class
 local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__New = ____lualib.__TS__New
 local ____exports = {}
 local ____destroyable = require("destroyable")
 local AbstractDestroyable = ____destroyable.AbstractDestroyable
@@ -9,6 +10,13 @@ local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
 local ____functions = require("utility.functions")
 local increment = ____functions.increment
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local ____lua_2Dmaps = require("utility.lua-maps")
+local getOrPut = ____lua_2Dmaps.getOrPut
+local mutableLuaMap = ____lua_2Dmaps.mutableLuaMap
+local ____lua_2Dsets = require("utility.lua-sets")
+local mutableLuaSet = ____lua_2Dsets.mutableLuaSet
 local safeCall = warpack.safeCall
 local firstBehaviorByObject = {}
 local lastBehaviorByObject = {}
@@ -47,6 +55,9 @@ local function reduceBehaviors(behaviorConstructor, object, operation, initial,
     end
     return accumulator
 end
+local behaviorsByEvent = {}
+local listenerByBehaviorByEvent = {}
+local eventsByBehavior = {}
 ____exports.Behavior = __TS__Class()
 local Behavior = ____exports.Behavior
 Behavior.name = "Behavior"
@@ -69,6 +80,20 @@ function Behavior.prototype.onDestroy(self)
     if ____opt_0 ~= nil then
         ____opt_0:destroy()
     end
+    local events = eventsByBehavior[self]
+    if events ~= nil then
+        for event in pairs(events) do
+            local ____opt_2 = behaviorsByEvent[event]
+            if ____opt_2 ~= nil then
+                ____opt_2:remove(self)
+            end
+            local ____opt_4 = listenerByBehaviorByEvent[event]
+            if ____opt_4 ~= nil then
+                ____opt_4[self] = nil
+            end
+        end
+        eventsByBehavior[self] = nil
+    end
     local previousBehavior = self[0]
     local nextBehavior = self[1]
     if previousBehavior ~= nil then
@@ -83,6 +108,34 @@ function Behavior.prototype.onDestroy(self)
     end
     return AbstractDestroyable.prototype.onDestroy(self)
 end
+function Behavior.prototype.registerEvent(self, event, listener)
+    local listenerByBehavior = getOrPut(listenerByBehaviorByEvent, event, mutableLuaMap)
+    listenerByBehavior[self] = listener
+    getOrPut(eventsByBehavior, self, mutableLuaSet)[event] = true
+    local behaviors = behaviorsByEvent[event]
+    if behaviors == nil then
+        event:addListener(function(...)
+            local behaviors = behaviorsByEvent[event]
+            if behaviors ~= nil then
+                for behavior in pairs(behaviors) do
+                    safeCall(behavior[listenerByBehavior[behavior]], behavior, ...)
+                end
+            end
+        end)
+        behaviors = __TS__New(LinkedSet)
+        behaviorsByEvent[event] = behaviors
+    end
+    behaviors:add(self)
+end
+function Behavior.prototype.deregisterEvent(self, event)
+    local behaviors = behaviorsByEvent[event]
+    if behaviors ~= nil and behaviors:remove(self) then
+        eventsByBehavior[self][event] = nil
+        listenerByBehaviorByEvent[event][self] = nil
+        return true
+    end
+    return false
+end
 function Behavior.prototype.onPeriod(self, ...)
 end
 function Behavior.prototype.startPeriodicAction(self, interval, ...)

package/engine/behaviour/unit.d.ts

@@ -11,13 +11,17 @@ import { Destructor } from "../../destroyable";
 import type { Widget } from "../../core/types/widget";
 import { Destructable } from "../../core/types/destructable";
 import type { Buff } from "../buff";
+import { UnitBonusType } from "../internal/unit/bonus";
 export type UnitBehaviorConstructor<Args extends any[]> = new (unit: Unit, ...args: Args) => UnitBehavior;
 export declare abstract class UnitBehavior<PeriodicActionParameters extends any[] = any[]> extends Behavior<Unit, PeriodicActionParameters> {
+    readonly sourceAbilityBehavior?: AbilityBehavior;
+    private _bonusIdByBonusType?;
     constructor(unit: Unit);
     protected onDestroy(): Destructor;
-    readonly sourceAbilityBehavior?: AbilityBehavior;
     get unit(): Unit;
-    registerInRangeUnitEvent<T extends string, Args extends any[]>(this: UnitBehavior<PeriodicActionParameters> & Record<T, (this: this, ...args: Args) => unknown>, event: Event<[...Args]>, extractUnit: (...args: Args) => Unit | undefined, range: number, listener: T): void;
+    protected getUnitBonus(bonusType: UnitBonusType): number;
+    protected addOrUpdateOrRemoveUnitBonus(bonusType: UnitBonusType, value: number): void;
+    protected registerInRangeUnitEvent<T extends string, Args extends any[]>(this: UnitBehavior<PeriodicActionParameters> & Record<T, (this: this, ...args: Args) => unknown>, event: Event<[...Args]>, extractUnit: (...args: Args) => Unit | undefined, range: number, listener: T): void;
     onImmediateOrder(orderId: number): void;
     onTargetOrder(orderId: number, target: Widget): void;
     onPointOrder(orderId: number, x: number, y: number): void;

package/engine/behaviour/unit.lua

@@ -17,6 +17,11 @@ local getOrPut = ____lua_2Dmaps.getOrPut
 local mutableLuaMap = ____lua_2Dmaps.mutableLuaMap
 local ____lua_2Dsets = require("utility.lua-sets")
 local mutableLuaSet = ____lua_2Dsets.mutableLuaSet
+local ____bonus = require("engine.internal.unit.bonus")
+local addOrUpdateOrRemoveUnitBonus = ____bonus.addOrUpdateOrRemoveUnitBonus
+local getUnitBonus = ____bonus.getUnitBonus
+local removeUnitBonus = ____bonus.removeUnitBonus
+local safeCall = warpack.safeCall
 local behaviorsByEvent = {}
 local rangeByBehaviorByEvent = {}
 local listenerByBehaviorByEvent = {}
@@ -47,8 +52,26 @@ function UnitBehavior.prototype.onDestroy(self)
         end
         eventsByBehavior[self] = nil
     end
+    if self._bonusIdByBonusType ~= nil then
+        for bonusType, bonusId in pairs(self._bonusIdByBonusType) do
+            removeUnitBonus(self.object, bonusType, bonusId)
+        end
+    end
     return Behavior.prototype.onDestroy(self)
 end
+function UnitBehavior.prototype.getUnitBonus(self, bonusType)
+    local ____opt_6 = self._bonusIdByBonusType
+    local bonusId = ____opt_6 and ____opt_6[bonusType]
+    return bonusId == nil and 0 or getUnitBonus(self.object, bonusType, bonusId)
+end
+function UnitBehavior.prototype.addOrUpdateOrRemoveUnitBonus(self, bonusType, value)
+    local bonusIdByBonusType = self._bonusIdByBonusType
+    if bonusIdByBonusType == nil then
+        bonusIdByBonusType = {}
+        self._bonusIdByBonusType = bonusIdByBonusType
+    end
+    bonusIdByBonusType[bonusType] = addOrUpdateOrRemoveUnitBonus(self.object, bonusType, bonusIdByBonusType[bonusType], value)
+end
 function UnitBehavior.prototype.registerInRangeUnitEvent(self, event, extractUnit, range, listener)
     local rangeByBehavior = getOrPut(rangeByBehaviorByEvent, event, mutableLuaMap)
     rangeByBehavior[self] = range
@@ -65,8 +88,7 @@ function UnitBehavior.prototype.registerInRangeUnitEvent(self, event, extractUni
                     for behavior in pairs(behaviors) do
                         local range = rangeByBehavior[behavior]
                         if range ~= nil and unit:getCollisionDistanceTo(behavior.unit) <= range then
-                            local ____self_6 = behavior
-                            ____self_6[listenerByBehavior[behavior]](____self_6, ...)
+                            safeCall(behavior[listenerByBehavior[behavior]], behavior, ...)
                         end
                     end
                 end

package/engine/buff.d.ts

@@ -201,11 +201,8 @@ export declare class Buff<AdditionalParameters extends Prohibit<Record<string, a
     private readonly _spellStealPriority?;
     private readonly _learnLevelMinimum?;
     private readonly [BuffPropertyKey.MISS_PROBABILITY]?;
-    private _bonusIdByBonusType?;
     private readonly _abilityTypeIds?;
     private _behaviors?;
-    private getUnitBonus;
-    private addOrUpdateOrRemoveUnitBonus;
     constructor(target: Unit, ...parameters: BuffConstructorParameters<AdditionalParameters>);
     get level(): number;
     get remainingDamageOverDuration(): number;