warscript 0.0.1-dev.404878c

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2020 ElusiveMori
+
+Copyright (c) 2021 Rhazarian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/binaryreader.d.ts

@@ -0,0 +1,20 @@
+/** @noSelfInFile */
+export declare class BinaryReader {
+    private readonly s;
+    private i;
+    constructor(data: string);
+    read(fmt: string): any;
+    readBytes(size: number): string;
+    readDouble(): number;
+    readFloat(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt8(): number;
+    readString(): string;
+    readUInt16(): number;
+    readUInt32(): number;
+    readUInt8(): number;
+    readObject<T>(clazz: {
+        deserialize(reader: BinaryReader): T;
+    }): T;
+}

package/binaryreader.lua

@@ -0,0 +1,50 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local ____unpack = string.unpack
+____exports.BinaryReader = __TS__Class()
+local BinaryReader = ____exports.BinaryReader
+BinaryReader.name = "BinaryReader"
+function BinaryReader.prototype.____constructor(self, data)
+    self.i = 1
+    self.s = data
+end
+function BinaryReader.prototype.read(self, fmt)
+    local value, pos = ____unpack(">" .. fmt, self.s, self.i)
+    self.i = pos
+    return value
+end
+function BinaryReader.prototype.readBytes(self, size)
+    return self:read("c" .. tostring(size))
+end
+function BinaryReader.prototype.readDouble(self)
+    return self:read("d")
+end
+function BinaryReader.prototype.readFloat(self)
+    return self:read("f")
+end
+function BinaryReader.prototype.readInt16(self)
+    return self:read("h")
+end
+function BinaryReader.prototype.readInt32(self)
+    return self:read("i4")
+end
+function BinaryReader.prototype.readInt8(self)
+    return self:read("b")
+end
+function BinaryReader.prototype.readString(self)
+    return self:read("z")
+end
+function BinaryReader.prototype.readUInt16(self)
+    return self:read("H")
+end
+function BinaryReader.prototype.readUInt32(self)
+    return self:read("I4")
+end
+function BinaryReader.prototype.readUInt8(self)
+    return self:read("B")
+end
+function BinaryReader.prototype.readObject(self, clazz)
+    return clazz:deserialize(self)
+end
+return ____exports

package/binarywriter.d.ts

@@ -0,0 +1,21 @@
+/** @noSelfInFile */
+export declare class BinaryWriter {
+    private readonly v;
+    private readonly f;
+    private i;
+    toString(): string;
+    write(fmt: string, value: number): void;
+    writeBytes(value: string): void;
+    writeDouble(value: number): void;
+    writeFloat(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt8(value: number): void;
+    writeString(value: string): void;
+    writeUInt16(value: number): void;
+    writeUInt32(value: number): void;
+    writeUInt8(value: number): void;
+    writeObject<T>(value: {
+        serialize(writer: BinaryWriter): T;
+    }): T;
+}

package/binarywriter.lua

@@ -0,0 +1,90 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local pack = string.pack
+local concat = table.concat
+local ____unpack = table.unpack
+____exports.BinaryWriter = __TS__Class()
+local BinaryWriter = ____exports.BinaryWriter
+BinaryWriter.name = "BinaryWriter"
+function BinaryWriter.prototype.____constructor(self)
+    self.v = {}
+    self.f = {">"}
+    self.i = 1
+end
+function BinaryWriter.prototype.__tostring(self)
+    return pack(
+        concat(self.f),
+        ____unpack(self.v, 2, self.i)
+    )
+end
+function BinaryWriter.prototype.write(self, fmt, value)
+    local i = self.i + 1
+    self.f[i] = fmt
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeBytes(self, value)
+    local i = self.i + 1
+    self.f[i] = "c" .. tostring(#value)
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeDouble(self, value)
+    local i = self.i + 1
+    self.f[i] = "d"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeFloat(self, value)
+    local i = self.i + 1
+    self.f[i] = "f"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeInt16(self, value)
+    local i = self.i + 1
+    self.f[i] = "h"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeInt32(self, value)
+    local i = self.i + 1
+    self.f[i] = "i4"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeInt8(self, value)
+    local i = self.i + 1
+    self.f[i] = "b"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeString(self, value)
+    local i = self.i + 1
+    self.f[i] = "z"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeUInt16(self, value)
+    local i = self.i + 1
+    self.f[i] = "H"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeUInt32(self, value)
+    local i = self.i + 1
+    self.f[i] = "I4"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeUInt8(self, value)
+    local i = self.i + 1
+    self.f[i] = "B"
+    self.v[i] = value
+    self.i = i
+end
+function BinaryWriter.prototype.writeObject(self, value)
+    return value:serialize(self)
+end
+return ____exports

package/core/dummy.d.ts

@@ -0,0 +1,22 @@
+/** @noSelfInFile */
+import { Widget } from "./types/widget";
+import { Player } from "./types/player";
+import { UnitAbility } from "./types/ability";
+import { AbilityTypeId } from "../engine/object-data/entry/ability-type";
+export declare class InstantDummyCaster {
+    private static instance;
+    private readonly dummy;
+    private constructor();
+    static getInstance(): InstantDummyCaster;
+    private prepare;
+    private finish;
+    castTarget(owner: Player, abilityTypeId: number, level: number | ((ability: UnitAbility) => void), orderId: number, target: Widget, pos?: Vec2): boolean;
+    castTarget<T extends [number, ...number[]]>(owner: Player, abilityTypeId: T, level: number[] | ((...abilities: {
+        [Index in keyof T]: UnitAbility;
+    }) => void), orderId: number, target: Widget, pos?: Vec2): boolean;
+    cast(owner: Player, abilityTypeId: AbilityTypeId, ...args: [
+        ...levelOrAbilityConsumer: [number] | [(ability: UnitAbility) => void] | [],
+        x: number,
+        y: number
+    ]): void;
+}

package/core/dummy.lua

@@ -0,0 +1,133 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ArrayIsArray = ____lualib.__TS__ArrayIsArray
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____ability = require("core.types.ability")
+local UnitAbility = ____ability.UnitAbility
+local ____unit = require("core.types.unit")
+local Unit = ____unit.Unit
+local ____dummy = require("objutil.dummy")
+local dummyUnitId = ____dummy.dummyUnitId
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+local ____ability = require("engine.internal.ability")
+local getOrderIdByAbilityTypeId = ____ability.getOrderIdByAbilityTypeId
+local neutralVictim = Player.neutralVictim.handle
+____exports.InstantDummyCaster = __TS__Class()
+local InstantDummyCaster = ____exports.InstantDummyCaster
+InstantDummyCaster.name = "InstantDummyCaster"
+function InstantDummyCaster.prototype.____constructor(self)
+    local dummy = CreateUnit(
+        neutralVictim,
+        dummyUnitId,
+        0,
+        0,
+        0
+    )
+    ShowUnit(dummy, false)
+    self.dummy = dummy
+end
+function InstantDummyCaster.getInstance(self)
+    if not self.instance then
+        self.instance = __TS__New(self)
+    end
+    return self.instance
+end
+function InstantDummyCaster.prototype.prepare(self, owner, abilityId, level)
+    local dummy = self.dummy
+    SetUnitOwner(dummy, owner.handle, false)
+    if type(abilityId) == "number" then
+        UnitAddAbility(dummy, abilityId)
+        if type(level) == "number" then
+            SetUnitAbilityLevel(dummy, abilityId, level + 1)
+        else
+            level(UnitAbility:of(
+                checkNotNull(BlzGetUnitAbility(dummy, abilityId)),
+                abilityId,
+                Unit:of(dummy)
+            ))
+        end
+    else
+        for i = 1, #abilityId do
+            UnitAddAbility(dummy, abilityId[i])
+        end
+        if __TS__ArrayIsArray(level) then
+            for i = 1, #abilityId do
+                SetUnitAbilityLevel(dummy, abilityId[i], level[i] + 1)
+            end
+        else
+            local abilities = {}
+            for i = 1, #abilityId do
+                abilities[i] = UnitAbility:of(
+                    checkNotNull(BlzGetUnitAbility(dummy, abilityId[i])),
+                    abilityId[i],
+                    Unit:of(dummy)
+                )
+            end
+            level(table.unpack(abilities))
+        end
+    end
+    SetUnitState(dummy, UNIT_STATE_MANA, 99999)
+end
+function InstantDummyCaster.prototype.finish(self, abilityId)
+    local dummy = self.dummy
+    SetUnitOwner(dummy, neutralVictim, false)
+    if type(abilityId) == "number" then
+        UnitRemoveAbility(dummy, abilityId)
+    else
+        for ____, id in ipairs(abilityId) do
+            UnitRemoveAbility(dummy, id)
+        end
+    end
+    ShowUnit(dummy, false)
+end
+function InstantDummyCaster.prototype.castTarget(self, owner, abilityId, level, orderId, target, pos)
+    self:prepare(owner, abilityId, level)
+    local dummy = self.dummy
+    if pos then
+        SetUnitX(dummy, pos.x)
+        SetUnitY(dummy, pos.y)
+        if pos.z then
+            SetUnitFlyHeight(dummy, pos.z, 99999)
+        end
+    else
+        SetUnitX(dummy, target.x)
+        SetUnitY(dummy, target.y)
+        SetUnitFlyHeight(dummy, 0, 99999)
+    end
+    local fm = CreateFogModifierRadius(
+        owner.handle,
+        FOG_OF_WAR_VISIBLE,
+        target.x,
+        target.y,
+        128,
+        false,
+        false
+    )
+    FogModifierStart(fm)
+    local result = IssueTargetOrderById(dummy, orderId, target.handle)
+    FogModifierStop(fm)
+    DestroyFogModifier(fm)
+    self:finish(abilityId)
+    return result
+end
+function InstantDummyCaster.prototype.cast(self, owner, abilityTypeId, levelOrAbilityConsumerOrX, xOrY, y)
+    if y == nil then
+        y = xOrY
+        xOrY = levelOrAbilityConsumerOrX
+        levelOrAbilityConsumerOrX = 1
+    end
+    self:prepare(owner, abilityTypeId, levelOrAbilityConsumerOrX)
+    local dummy = self.dummy
+    SetUnitX(dummy, xOrY)
+    SetUnitY(dummy, y)
+    IssueImmediateOrderById(
+        dummy,
+        getOrderIdByAbilityTypeId(abilityTypeId)
+    )
+    self:finish(abilityTypeId)
+end
+return ____exports

package/core/game.d.ts

@@ -0,0 +1,3 @@
+/** @noSelfInFile */
+export declare function elapsedTime(): number;
+export declare function isSinglePlayer(): boolean;

package/core/game.lua

@@ -0,0 +1,24 @@
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local context = util.contextFn(
+    "game",
+    function()
+        local tracker = CreateTimer()
+        TimerStart(tracker, 60 * 60 * 24 * 365, false, nil)
+        return {tracker = tracker}
+    end
+)
+function ____exports.elapsedTime()
+    return TimerGetElapsed(context.tracker)
+end
+function ____exports.isSinglePlayer()
+    local count = 0
+    for ____, player in ipairs(Player.all) do
+        if player.isUser and player.isPlaying then
+            count = count + 1
+        end
+    end
+    return count == 1
+end
+return ____exports

package/core/mapbounds.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+import { Rect } from "./types/rect";
+import { Region } from "./types/region";
+export declare const boundRect: Rect;
+export declare const boundRegion: Region;
+export declare const boundMin: Readonly<Vec2>;
+export declare const boundMax: Readonly<Vec2>;
+export declare const boundCenter: Readonly<Vec2>;

package/core/mapbounds.lua

@@ -0,0 +1,12 @@
+local ____exports = {}
+local ____rect = require("core.types.rect")
+local Rect = ____rect.Rect
+local ____region = require("core.types.region")
+local Region = ____region.Region
+____exports.boundRect = Rect:of(GetWorldBounds())
+____exports.boundRegion = Region:create()
+____exports.boundRegion:addRect(____exports.boundRect)
+____exports.boundMin = vec2(____exports.boundRect.minX, ____exports.boundRect.minY)
+____exports.boundMax = vec2(____exports.boundRect.maxX, ____exports.boundRect.maxY)
+____exports.boundCenter = (____exports.boundMin + ____exports.boundMax) * 0.5
+return ____exports

package/core/thread.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+export declare class Thread {
+    private readonly t;
+    private constructor();
+    static start(f: (this: void, thread: Thread) => void): Thread;
+    static running(): Thread;
+    sleep(seconds: number): void;
+}

package/core/thread.lua

@@ -0,0 +1,40 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local cocreate = coroutine.create
+local coresume = coroutine.resume
+local corunning = coroutine.running
+local coyield = coroutine.yield
+local cache = setmetatable({}, {__mode = "k"})
+____exports.Thread = __TS__Class()
+local Thread = ____exports.Thread
+Thread.name = "Thread"
+function Thread.prototype.____constructor(self, t)
+    self.t = t
+    cache[t] = self
+end
+function Thread.start(self, f)
+    local lt = cocreate(f)
+    local t = __TS__New(____exports.Thread, lt)
+    Timer:run(function()
+        coresume(lt, t)
+    end)
+    return t
+end
+function Thread.running(self)
+    local lt = corunning()
+    return cache[lt] or __TS__New(____exports.Thread, lt)
+end
+function Thread.prototype.sleep(self, seconds)
+    Timer:simple(
+        seconds,
+        function()
+            coresume(self.t)
+        end
+    )
+    coyield()
+end
+return ____exports

package/core/types/ability.d.ts

@@ -0,0 +1,4 @@
+/** @noSelfInFile */
+import { Ability, ItemAbility, UnitAbility } from "../../engine/internal/ability";
+import "./internal/ability+cooldownRemaining";
+export { Ability, ItemAbility, UnitAbility };

package/core/types/ability.lua

@@ -0,0 +1,10 @@
+local ____exports = {}
+local ____ability = require("engine.internal.ability")
+local Ability = ____ability.Ability
+local ItemAbility = ____ability.ItemAbility
+local UnitAbility = ____ability.UnitAbility
+require("core.types.internal.ability+cooldownRemaining")
+____exports.Ability = Ability
+____exports.ItemAbility = ItemAbility
+____exports.UnitAbility = UnitAbility
+return ____exports

package/core/types/async.d.ts

@@ -0,0 +1,3 @@
+/** @noSelfInFile */
+import { Handle } from "./handle";
+export type Async<T extends Handle<any>> = Readonly<T>;

package/core/types/async.lua

@@ -0,0 +1,2 @@
+local ____exports = {}
+return ____exports

package/core/types/camera.d.ts

@@ -0,0 +1,4 @@
+/** @noSelfInFile */
+export declare class Camera {
+    static setBounds(minX: number, minY: number, maxX: number, maxY: number): void;
+}

package/core/types/camera.lua

@@ -0,0 +1,21 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+____exports.Camera = __TS__Class()
+local Camera = ____exports.Camera
+Camera.name = "Camera"
+function Camera.prototype.____constructor(self)
+end
+function Camera.setBounds(self, minX, minY, maxX, maxY)
+    SetCameraBounds(
+        minX,
+        minY,
+        minX,
+        maxY,
+        maxX,
+        maxY,
+        maxX,
+        minY
+    )
+end
+return ____exports

package/core/types/cameraField.d.ts

@@ -0,0 +1,15 @@
+/** @noSelfInFile */
+import { Handle } from "./handle";
+export declare class CameraField extends Handle<jcamerafield> {
+    static targetDistance: CameraField;
+    static fieldOfView: CameraField;
+    static farClipping: CameraField;
+    static nearClipping: CameraField;
+    static zOffset: CameraField;
+    static yaw: CameraField;
+    static pitch: CameraField;
+    static roll: CameraField;
+    private static readonly _init;
+    get value(): number;
+    set value(v: number);
+}

package/core/types/cameraField.lua

@@ -0,0 +1,38 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+____exports.CameraField = __TS__Class()
+local CameraField = ____exports.CameraField
+CameraField.name = "CameraField"
+__TS__ClassExtends(CameraField, Handle)
+CameraField._init = util.contextFn(
+    "warscript/cameraField/init",
+    function()
+        ____exports.CameraField.targetDistance = ____exports.CameraField:of(CAMERA_FIELD_TARGET_DISTANCE)
+        ____exports.CameraField.farClipping = ____exports.CameraField:of(CAMERA_FIELD_FARZ)
+        ____exports.CameraField.pitch = ____exports.CameraField:of(CAMERA_FIELD_ANGLE_OF_ATTACK)
+        ____exports.CameraField.fieldOfView = ____exports.CameraField:of(CAMERA_FIELD_FIELD_OF_VIEW)
+        ____exports.CameraField.roll = ____exports.CameraField:of(CAMERA_FIELD_ROLL)
+        ____exports.CameraField.yaw = ____exports.CameraField:of(CAMERA_FIELD_ROTATION)
+        ____exports.CameraField.zOffset = ____exports.CameraField:of(CAMERA_FIELD_ZOFFSET)
+        ____exports.CameraField.nearClipping = ____exports.CameraField:of(CAMERA_FIELD_NEARZ)
+    end
+)
+__TS__SetDescriptor(
+    CameraField.prototype,
+    "value",
+    {
+        get = function(self)
+            return GetCameraField(self.handle)
+        end,
+        set = function(self, v)
+            SetCameraField(self.handle, v, 0)
+        end
+    },
+    true
+)
+return ____exports

package/core/types/color.d.ts

@@ -0,0 +1,16 @@
+/** @noSelfInFile */
+export declare class Color {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
+    private constructor();
+    static readonly white: Color;
+    static readonly black: Color;
+    static readonly gold: Color;
+    static readonly silver: Color;
+    toString(): string;
+    get hexCode(): string;
+    static lerp(lhs: Color, rhs: Color, t: number): Color;
+    static of(red: number, green: number, blue: number, alpha?: number): Color;
+}