warscript 0.0.1-dev.404878c

package/math/vec2.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+/** Gets the height of the terrain at the position specified by the vector. */
+export declare const getTerrainZ: (x: number, y: number) => number;
+/** Returns the unsigned angle in degrees between from and to. */
+export declare const angleBetweenPoints: (x1: number, y1: number, x2: number, y2: number) => number;
+/** Returns the distance between a and b. */
+export declare const distance: (x1: number, y1: number, x2: number, y2: number) => number;
+/** Moves a point current towards target. */
+export declare const moveTowards: (x1: number, y1: number, x2: number, y2: number, distance: number) => LuaMultiReturn<[
+    number,
+    number
+]>;
+/** Gets a polar offset from this vector. Angle should be specified in degrees. */
+export declare const polarOffset: (x: number, y: number, angle: number, distance: number) => LuaMultiReturn<[
+    number,
+    number
+]>;

package/math/vec2.lua

@@ -0,0 +1,42 @@
+local ____exports = {}
+local atan = math.atan
+local cos = math.cos
+local deg = math.deg
+local rad = math.rad
+local sin = math.sin
+local sqrt = math.sqrt
+local getLocationZ = _G.GetLocationZ
+local moveLocation = _G.MoveLocation
+local location = _G.Location(0, 0)
+--- Gets the height of the terrain at the position specified by the vector.
+____exports.getTerrainZ = function(x, y)
+    moveLocation(location, x, y)
+    return getLocationZ(location)
+end
+--- Returns the unsigned angle in degrees between from and to.
+____exports.angleBetweenPoints = function(x1, y1, x2, y2)
+    return deg(atan(y2 - y1, x2 - x1))
+end
+--- Returns the distance between a and b.
+____exports.distance = function(x1, y1, x2, y2)
+    local dx = x2 - x1
+    local dy = y2 - y1
+    return sqrt(dx * dx + dy * dy)
+end
+--- Moves a point current towards target.
+____exports.moveTowards = function(x1, y1, x2, y2, distance)
+    local dx = x2 - x1
+    local dy = y2 - y1
+    local d = sqrt(dx * dx + dy * dy)
+    if d ~= 0 then
+        local ratio = distance / d
+        return x1 + dx * ratio, y1 + dy * ratio
+    end
+    return x1 + distance, y1
+end
+--- Gets a polar offset from this vector. Angle should be specified in degrees.
+____exports.polarOffset = function(x, y, angle, distance)
+    angle = rad(angle)
+    return x + cos(angle) * distance, y + sin(angle) * distance
+end
+return ____exports

package/math.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="lua-types/5.3" />
+/// <reference types="lua-types/5.3" />
+/** @noSelfInFile */
+export declare const MINIMUM_POSITIVE_NORMALIZED_FLOAT: number;
+export declare const MINIMUM_POSITIVE_FLOAT: number;
+export declare const MAXIMUM_INTEGER = 2147483647;
+export declare const MINIMUM_INTEGER = -2147483648;
+export declare const POSITIVE_INFINITY: number;
+export declare const NEGATIVE_INFINITY: number;
+export declare const E: number;
+export declare const LN10: number;
+export declare const LN2: number;
+export declare const LOG2E: number;
+export declare const LOG10E: number;
+export declare const PI: number;
+export declare const SQRT1_2: number;
+export declare const SQRT2: number;
+export declare const ceil: typeof math.ceil;
+/** Clamps the value to fit between min and max. */
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const abs: typeof math.abs;
+export declare const cos: typeof math.cos;
+export declare const exp: typeof math.exp;
+export declare const floor: typeof math.floor;
+export declare const log: typeof math.log;
+export declare const max: typeof math.max;
+export declare const min: typeof math.min;
+/** Returns the signum function of the argument;
+ * zero if the argument is zero,
+ * 1.0 if the argument is greater than zero,
+ * -1.0 if the argument is less than zero. */
+export declare const signum: (value: number) => number;
+/** Returns the trigonometric sine of an angle (assumed to be in radians). */
+export declare const sin: typeof math.sin;
+/** Returns the positive square root of a value. */
+export declare const sqrt: typeof math.sqrt;
+export declare const nextUp: (value: number) => number;
+export declare const nextDown: (value: number) => number;
+export declare const nextAfter: (start: number, direction: number) => number;

package/math.lua

@@ -0,0 +1,91 @@
+local ____exports = {}
+local pack = string.pack
+local ____unpack = string.unpack
+local function intBitsToFloat(intBits)
+    return (____unpack(
+        "<f",
+        pack("<i4", intBits)
+    ))
+end
+local function floatToIntBits(float)
+    return (____unpack(
+        "<i4",
+        pack("<f", float)
+    ))
+end
+____exports.MINIMUM_POSITIVE_NORMALIZED_FLOAT = intBitsToFloat(8388608)
+____exports.MINIMUM_POSITIVE_FLOAT = intBitsToFloat(1)
+____exports.MAXIMUM_INTEGER = 2147483647
+____exports.MINIMUM_INTEGER = -2147483648
+____exports.POSITIVE_INFINITY = math.huge
+____exports.NEGATIVE_INFINITY = -math.huge
+____exports.E = 2.718281828459045
+____exports.LN10 = 2.302585092994046
+____exports.LN2 = 0.6931471805599453
+____exports.LOG2E = 1.4426950408889634
+____exports.LOG10E = 0.4342944819032518
+____exports.PI = math.pi
+____exports.SQRT1_2 = 0.7071067811865476
+____exports.SQRT2 = 1.4142135623730951
+____exports.ceil = math.ceil
+--- Clamps the value to fit between min and max.
+____exports.clamp = function(value, min, max)
+    return value < min and min or (value > max and max or value)
+end
+____exports.abs = math.abs
+____exports.cos = math.cos
+____exports.exp = math.exp
+____exports.floor = math.floor
+____exports.log = math.log
+____exports.max = math.max
+____exports.min = math.min
+--- Returns the signum function of the argument;
+-- zero if the argument is zero,
+-- 1.0 if the argument is greater than zero,
+-- -1.0 if the argument is less than zero.
+____exports.signum = function(value)
+    return value == 0 and 0 or (value > 0 and 1 or -1)
+end
+--- Returns the trigonometric sine of an angle (assumed to be in radians).
+____exports.sin = math.sin
+--- Returns the positive square root of a value.
+____exports.sqrt = math.sqrt
+____exports.nextUp = function(value)
+    value = value + .0
+    if value < ____exports.POSITIVE_INFINITY then
+        local transducer = floatToIntBits(value)
+        return intBitsToFloat(transducer + (transducer >= 0 and 1 or -1))
+    else
+        return value
+    end
+end
+____exports.nextDown = function(value)
+    value = value + .0
+    if value ~= value or value == ____exports.NEGATIVE_INFINITY then
+        return value
+    elseif value == 0 then
+        return -____exports.MINIMUM_POSITIVE_FLOAT
+    else
+        return intBitsToFloat(floatToIntBits(value) + (value > 0 and -1 or 1))
+    end
+end
+____exports.nextAfter = function(start, direction)
+    start = start + .0
+    direction = direction + .0
+    if start > direction then
+        if start ~= 0 then
+            local transducer = floatToIntBits(start)
+            return intBitsToFloat(transducer + (transducer > 0 and -1 or 1))
+        else
+            return -____exports.MINIMUM_POSITIVE_FLOAT
+        end
+    elseif start < direction then
+        local transducer = floatToIntBits(start)
+        return intBitsToFloat(transducer + (transducer >= 0 and 1 or -1))
+    elseif start == direction then
+        return direction
+    else
+        return start + direction
+    end
+end
+return ____exports

package/net/signal.d.ts

@@ -0,0 +1,11 @@
+/** @noSelfInFile */
+import { Player } from "../core/types/player";
+import { Event } from "../event";
+export declare class Signal {
+    private readonly frame;
+    private readonly trigger;
+    readonly onReceive: Event<[Player]>;
+    constructor();
+    send(): void;
+    destroy(): void;
+}

package/net/signal.lua

@@ -0,0 +1,56 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____event = require("event")
+local Event = ____event.Event
+local eventInvoke = Event.invoke
+local condition = Condition
+local createTrigger = CreateTrigger
+local triggerAddCondition = TriggerAddCondition
+local triggerClearConditions = TriggerClearConditions
+local destroyTrigger = DestroyTrigger
+local getTriggerPlayer = GetTriggerPlayer
+local triggerRegisterFrameEvent = BlzTriggerRegisterFrameEvent
+local createFrameByType = BlzCreateFrameByType
+local frameClick = BlzFrameClick
+local destroyFrame = BlzDestroyFrame
+local worldFrame = BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0)
+____exports.Signal = __TS__Class()
+local Signal = ____exports.Signal
+Signal.name = "Signal"
+function Signal.prototype.____constructor(self)
+    local frame = createFrameByType(
+        "BUTTON",
+        "SignalButton",
+        worldFrame,
+        "",
+        0
+    )
+    local trigger = createTrigger()
+    triggerRegisterFrameEvent(trigger, frame, FRAMEEVENT_CONTROL_CLICK)
+    local onReceive = __TS__New(Event)
+    triggerAddCondition(
+        trigger,
+        condition(function()
+            eventInvoke(
+                onReceive,
+                Player:of(getTriggerPlayer())
+            )
+        end)
+    )
+    self.frame = frame
+    self.trigger = trigger
+    self.onReceive = onReceive
+end
+function Signal.prototype.send(self)
+    frameClick(self.frame)
+end
+function Signal.prototype.destroy(self)
+    triggerClearConditions(self.trigger)
+    destroyTrigger(self.trigger)
+    destroyFrame(self.frame)
+end
+return ____exports

package/net/socket.d.ts

@@ -0,0 +1,9 @@
+/** @noSelfInFile */
+import { Event } from "../event";
+import { Player } from "../core/types/player";
+export declare class Socket {
+    private readonly id;
+    readonly onMessage: Event<[Player, string]>;
+    constructor();
+    send(data: string): void;
+}

package/net/socket.lua

@@ -0,0 +1,26 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____event = require("event")
+local Event = ____event.Event
+local ____network = require("network")
+local send = ____network.send
+local onReceive = ____network.onReceive
+local nextId = 0
+____exports.Socket = __TS__Class()
+local Socket = ____exports.Socket
+Socket.name = "Socket"
+function Socket.prototype.____constructor(self)
+    local ____tostring_0 = tostring
+    nextId = nextId + 1
+    self.id = ____tostring_0(nextId)
+    self.onMessage = __TS__New(Event)
+    onReceive[self.id]:addListener(function(sender, data)
+        Event.invoke(self.onMessage, sender, data)
+    end)
+end
+function Socket.prototype.send(self, data)
+    send(self.id, data)
+end
+return ____exports

package/network.d.ts

@@ -0,0 +1,31 @@
+/** @noSelfInFile */
+import { Event } from "./event";
+import { Player } from "./core/types/player";
+import { Operation, OperationContinue, OperationMonitor } from "./operation";
+export declare const onReceive: {
+    [prefix: string]: Event<[Player, string]>;
+} & {
+    [x: string]: Event<[Player, string]>;
+};
+export declare function send(id: string, payload: string): void;
+export declare class SyncOperation extends Operation<string> {
+    private readonly player;
+    private readonly x;
+    private readonly p;
+    private readonly c;
+    private readonly d;
+    private readonly l;
+    private e?;
+    private w?;
+    private r?;
+    private i;
+    private s;
+    static get packetsPerRound(): number;
+    static set packetsPerRound(value: number);
+    constructor(player: Player, data: string);
+    protected estimate(): Promise<number>;
+    protected work(): string | Promise<OperationContinue | string>;
+    protected doCancel(): boolean;
+    private static readonly _;
+}
+export declare function synchronize(player: Player, data: string): OperationMonitor<string>;

package/network.lua

@@ -0,0 +1,194 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Promise = ____lualib.__TS__Promise
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____event = require("event")
+local TriggerEvent = ____event.TriggerEvent
+local ____exception = require("exception")
+local IllegalArgumentException = ____exception.IllegalArgumentException
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____operation = require("operation")
+local Operation = ____operation.Operation
+local OperationContinue = ____operation.OperationContinue
+local ____base64 = require("utility.base64")
+local decode = ____base64.decode
+local encode = ____base64.encode
+local getTriggerPlayer = GetTriggerPlayer
+local getTriggerSyncData = BlzGetTriggerSyncData
+local sendSyncData = BlzSendSyncData
+local triggerRegisterPlayerSyncEvent = BlzTriggerRegisterPlayerSyncEvent
+local concat = table.concat
+local pack = string.pack
+local sub = string.sub
+local ____unpack = string.unpack
+____exports.onReceive = setmetatable(
+    {},
+    {__index = function(self, prefix)
+        local event = __TS__New(
+            TriggerEvent,
+            function(trigger)
+                for ____, player in ipairs(Player.all) do
+                    triggerRegisterPlayerSyncEvent(trigger, player.handle, prefix, false)
+                end
+            end,
+            function() return Player:of(getTriggerPlayer()), getTriggerSyncData() end
+        )
+        self[prefix] = event
+        return event
+    end}
+)
+function ____exports.send(id, payload)
+    if #payload > 255 then
+        error(
+            __TS__New(
+                IllegalArgumentException,
+                "payload length must be <= 256, but was " .. tostring(#payload)
+            ),
+            0
+        )
+    end
+    sendSyncData(id, payload)
+end
+local packetsPerRound = 4
+local syncOperation
+local preparePromiseExecutor
+local syncPromiseExecutor
+local syncOperationNextId = 1
+local syncOperationById = setmetatable({}, {__mode = "v"})
+____exports.SyncOperation = __TS__Class()
+local SyncOperation = ____exports.SyncOperation
+SyncOperation.name = "SyncOperation"
+__TS__ClassExtends(SyncOperation, Operation)
+function SyncOperation.prototype.____constructor(self, player, data)
+    Operation.prototype.____constructor(self)
+    self.player = player
+    self.c = {}
+    self.i = 1
+    self.s = 0
+    if not player.isUser or not player.isPlaying then
+        error(
+            __TS__New(IllegalArgumentException),
+            0
+        )
+    end
+    local ____syncOperationNextId_0 = syncOperationNextId
+    syncOperationNextId = ____syncOperationNextId_0 + 1
+    local id = ____syncOperationNextId_0
+    syncOperationById[id] = self
+    self.x = id
+    self.p = encode(pack(">i4", id))
+    self.d = encode(data)
+    self.l = #self.d
+end
+function SyncOperation.prototype.estimate(self)
+    if self.player.isLocal then
+        sendSyncData(
+            "__oh",
+            encode(pack(">i4I4", self.x, self.l)) .. sub(self.d, 1, 243)
+        )
+        self.i = 244
+    end
+    syncOperation = self
+    return __TS__New(__TS__Promise, preparePromiseExecutor)
+end
+function SyncOperation.prototype.work(self)
+    if self.progress >= self.maximum then
+        return decode(concat(self.c))
+    end
+    self.s = packetsPerRound
+    if self.player.isLocal then
+        local i = self.i
+        for _ = 1, packetsPerRound do
+            sendSyncData(
+                "__oc",
+                self.p .. sub(self.d, i, i + 246)
+            )
+            i = i + 247
+        end
+        self.i = i
+    end
+    syncOperation = self
+    return __TS__New(__TS__Promise, syncPromiseExecutor)
+end
+function SyncOperation.prototype.doCancel(self)
+    return false
+end
+__TS__ObjectDefineProperty(
+    SyncOperation,
+    "packetsPerRound",
+    {
+        get = function(self)
+            return packetsPerRound
+        end,
+        set = function(self, value)
+            if value <= 0 or math.type(value) ~= "integer" then
+                error(
+                    __TS__New(IllegalArgumentException),
+                    0
+                )
+            end
+            packetsPerRound = value
+        end
+    }
+)
+SyncOperation._ = (function()
+    preparePromiseExecutor = function(____, resolve, reject)
+        syncOperation.e = resolve
+        syncOperation.r = reject
+    end
+    syncPromiseExecutor = function(____, resolve, reject)
+        syncOperation.w = resolve
+        syncOperation.r = reject
+    end
+    ____exports.onReceive.__oh:addListener(function(player, data)
+        local id, length = ____unpack(
+            ">i4I4",
+            decode(sub(data, 1, 12))
+        )
+        local syncOperation = syncOperationById[id]
+        if syncOperation then
+            local chunk = sub(data, 13)
+            local chunks = syncOperation.c
+            chunks[#chunks + 1] = chunk
+            syncOperation.progress = syncOperation.progress + #chunk
+            local resolveEstimate = syncOperation.e
+            if resolveEstimate then
+                resolveEstimate(nil, length)
+            end
+        end
+    end)
+    ____exports.onReceive.__oc:addListener(function(player, data)
+        local id = ____unpack(
+            ">i4",
+            decode(sub(data, 1, 8))
+        )
+        local syncOperation = syncOperationById[id]
+        if syncOperation then
+            local chunk = sub(data, 9)
+            local chunks = syncOperation.c
+            chunks[#chunks + 1] = chunk
+            syncOperation.progress = syncOperation.progress + #chunk
+            local packetsLeft = syncOperation.s - 1
+            syncOperation.s = packetsLeft
+            local resolveWork = syncOperation.w
+            if resolveWork then
+                if syncOperation.progress >= syncOperation.maximum then
+                    resolveWork(
+                        nil,
+                        decode(concat(chunks))
+                    )
+                elseif packetsLeft == 0 then
+                    resolveWork(nil, OperationContinue)
+                end
+            end
+        end
+    end)
+end)()
+function ____exports.synchronize(player, data)
+    return __TS__New(____exports.SyncOperation, player, data):execute()
+end
+return ____exports