warscript 0.0.1-dev.008d8ef

package/core/types/game.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+export declare class Game {
+    private constructor();
+    static readonly isSinglePlayer: boolean;
+    static get timeOfDay(): number;
+    static set timeOfDay(v: number);
+    static end(doScoreScreen?: boolean): void;
+}

package/core/types/game.lua

@@ -0,0 +1,41 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local getFloatGameState = GetFloatGameState
+local setFloatGameState = SetFloatGameState
+local endGame = EndGame
+local isSinglePlayer = true
+for ____, player in ipairs(Player.all) do
+    if player.isUser and player.isPlaying then
+        isSinglePlayer = false
+        break
+    end
+end
+____exports.Game = __TS__Class()
+local Game = ____exports.Game
+Game.name = "Game"
+function Game.prototype.____constructor(self)
+end
+Game["end"] = function(self, doScoreScreen)
+    if doScoreScreen == nil then
+        doScoreScreen = true
+    end
+    endGame(doScoreScreen)
+end
+Game.isSinglePlayer = isSinglePlayer
+__TS__ObjectDefineProperty(
+    Game,
+    "timeOfDay",
+    {
+        get = function(self)
+            return getFloatGameState(GAME_STATE_TIME_OF_DAY)
+        end,
+        set = function(self, v)
+            setFloatGameState(GAME_STATE_TIME_OF_DAY, v)
+        end
+    }
+)
+return ____exports

package/core/types/group.d.ts

@@ -0,0 +1,21 @@
+/** @noSelfInFile */
+import { Widget } from "./widget";
+import { Unit } from "../../engine/internal/unit";
+export declare class Group {
+    private readonly handle;
+    private constructor();
+    static create(...units: Unit[]): Group;
+    private __gc;
+    add(unit: Unit): boolean;
+    addAll(group: Group): number;
+    delete(unit: Unit): boolean;
+    deleteAll(group: Group): number;
+    clear(): void;
+    get size(): number;
+    toArray(): Unit[];
+    toSet(): Set<Unit>;
+    toLuaSet(): LuaSet<Unit>;
+    issueImmediateOrder(order: number): boolean;
+    issuePointOrder(order: number, x: number, y: number): boolean;
+    issueTargetOrder(order: number, target: Widget): boolean;
+}

package/core/types/group.lua

@@ -0,0 +1,94 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local Set = ____lualib.Set
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local select = _G.select
+local createGroup = CreateGroup
+local destroyGroup = DestroyGroup
+local groupAddGroupFast = BlzGroupAddGroupFast
+local groupAddUnit = GroupAddUnit
+local groupClear = GroupClear
+local groupGetSize = BlzGroupGetSize
+local groupRemoveGroupFast = BlzGroupRemoveGroupFast
+local groupRemoveUnit = GroupRemoveUnit
+local groupImmediateOrderById = GroupImmediateOrderById
+local groupPointOrderById = GroupPointOrderById
+local groupTargetOrderById = GroupTargetOrderById
+local groupUnitAt = BlzGroupUnitAt
+____exports.Group = __TS__Class()
+local Group = ____exports.Group
+Group.name = "Group"
+function Group.prototype.____constructor(self, handle)
+    self.handle = handle
+end
+function Group.create(self, ...)
+    local handle = createGroup()
+    for i = 1, select("#", ...) do
+        groupAddUnit(handle, (select(i, ...)).handle)
+    end
+    return __TS__New(self, handle)
+end
+function Group.prototype.__gc(self)
+    destroyGroup(self.handle)
+end
+function Group.prototype.add(self, unit)
+    return groupAddUnit(self.handle, unit.handle)
+end
+function Group.prototype.addAll(self, group)
+    return groupAddGroupFast(self.handle, group.handle)
+end
+function Group.prototype.delete(self, unit)
+    return groupRemoveUnit(self.handle, unit.handle)
+end
+function Group.prototype.deleteAll(self, group)
+    return groupRemoveGroupFast(self.handle, group.handle)
+end
+function Group.prototype.clear(self)
+    groupClear(self.handle)
+end
+function Group.prototype.toArray(self)
+    local handle = self.handle
+    local array = {}
+    for i = 0, groupGetSize(handle) - 1 do
+        array[i + 1] = Unit:of(groupUnitAt(handle, i))
+    end
+    return array
+end
+function Group.prototype.toSet(self)
+    local handle = self.handle
+    local set = __TS__New(Set)
+    for i = 0, groupGetSize(handle) - 1 do
+        set:add(Unit:of(groupUnitAt(handle, i)))
+    end
+    return set
+end
+function Group.prototype.toLuaSet(self)
+    local handle = self.handle
+    local luaSet = {}
+    for i = 0, groupGetSize(handle) - 1 do
+        luaSet[Unit:of(groupUnitAt(handle, i))] = true
+    end
+    return luaSet
+end
+function Group.prototype.issueImmediateOrder(self, order)
+    return groupImmediateOrderById(self.handle, order)
+end
+function Group.prototype.issuePointOrder(self, order, x, y)
+    return groupPointOrderById(self.handle, order, x, y)
+end
+function Group.prototype.issueTargetOrder(self, order, target)
+    return groupTargetOrderById(self.handle, order, target.handle)
+end
+__TS__SetDescriptor(
+    Group.prototype,
+    "size",
+    {get = function(self)
+        return groupGetSize(self.handle)
+    end},
+    true
+)
+return ____exports

package/core/types/handle.d.ts

@@ -0,0 +1,49 @@
+/** @noSelfInFile */
+import { Event } from "../../event";
+import { AttributesHolder } from "../../attributes";
+export type HandleConstructor<H extends jhandle, T extends Handle<H>, Args extends any[]> = new (handle: H, ...args: Args) => T;
+export type HandleDestructor = {
+    readonly __handleDestructor: unique symbol;
+};
+declare const noOverrideSymbol: unique symbol;
+type NoOverride = {
+    [noOverrideSymbol]: typeof noOverrideSymbol;
+};
+declare const enum HandlePropertyKey {
+    STATE = 0
+}
+export declare class Handle<H extends jhandle, DestroyParameters extends any[] = []> extends AttributesHolder implements Destroyable {
+    readonly handle: H;
+    private [HandlePropertyKey.STATE]?;
+    private onDestroyEvent?;
+    /**
+     * @deprecated Do not use the constructor directly, use the factory methods.
+     * The constructor is public solely for type inference purposes.
+     */
+    constructor(handle: H);
+    protected static get onCreateEvent(): Event<[any]>;
+    protected static get onDestroyEvent(): Event<[any]>;
+    private static get memoized();
+    static of<H extends jhandle, T extends Handle<H>, Args extends any[] = []>(this: HandleConstructor<H, T, Args>, handle: null, ...args: Args): null;
+    static of<H extends jhandle, T extends Handle<H>, Args extends any[] = []>(this: HandleConstructor<H, T, Args>, handle: undefined, ...args: Args): undefined;
+    static of<H extends jhandle, T extends Handle<H>, Args extends any[] = []>(this: HandleConstructor<H, T, Args>, handle: H, ...args: Args): T;
+    static of<H extends jhandle, T extends Handle<H>, Args extends any[] = []>(this: HandleConstructor<H, T, Args>, handle: H | null, ...args: Args): T | null;
+    static of<H extends jhandle, T extends Handle<H>, Args extends any[] = []>(this: HandleConstructor<H, T, Args>, handle: H | undefined, ...args: Args): T | undefined;
+    private static createInternal;
+    private static invokeOnCreateEvent;
+    static get onCreate(): Event<[Handle<jhandle>]>;
+    static get destroyEvent(): Event<[Handle<jhandle>]>;
+    get destroyEvent(): Event;
+    toString(): string;
+    /**
+     * An overriding function should always call the super one at the end of it,
+     * in the following manner: `return super.onDestroy()`.
+     */
+    protected onDestroy(...parameters: DestroyParameters): HandleDestructor;
+    /**
+     * Frees this handle, and runs any associated destruction hooks.
+     */
+    destroy(...parameters: DestroyParameters): NoOverride;
+    private static invokeOnDestroyEvent;
+}
+export {};

package/core/types/handle.lua

@@ -0,0 +1,174 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__New = ____lualib.__TS__New
+local __TS__Delete = ____lualib.__TS__Delete
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____event = require("event")
+local Event = ____event.Event
+local ____reflection = require("utility.reflection")
+local getClass = ____reflection.getClass
+local getSuperclass = ____reflection.getSuperclass
+local ____exception = require("exception")
+local IllegalStateException = ____exception.IllegalStateException
+local ____attributes = require("attributes")
+local AttributesHolder = ____attributes.AttributesHolder
+local getHandleId = GetHandleId
+local onCreateEventByHandleConstructor = {}
+local onDestroyEventByHandleConstructor = {}
+____exports.Handle = __TS__Class()
+local Handle = ____exports.Handle
+Handle.name = "Handle"
+__TS__ClassExtends(Handle, AttributesHolder)
+function Handle.prototype.____constructor(self, handle)
+    AttributesHolder.prototype.____constructor(self)
+    self[0] = 0
+    local id = getHandleId(handle)
+    local clazz = self.constructor
+    if clazz.memoized[id] then
+        error(("Double-constructor run for handle " .. tostring(id)) .. "!")
+    end
+    clazz.memoized[id] = self
+    self.handle = handle
+end
+function Handle.of(self, handle, ...)
+    return handle and (self.memoized[getHandleId(handle)] or self:createInternal(handle, ...))
+end
+function Handle.createInternal(self, handle, ...)
+    local object = __TS__New(self, handle, ...)
+    ____exports.Handle:invokeOnCreateEvent(
+        getClass(object),
+        object
+    )
+    object[0] = nil
+    return object
+end
+function Handle.invokeOnCreateEvent(self, clazz, handle)
+    if clazz == nil then
+        return
+    end
+    ____exports.Handle:invokeOnCreateEvent(
+        getSuperclass(clazz),
+        handle
+    )
+    local onCreateEvent = onCreateEventByHandleConstructor[clazz]
+    if onCreateEvent ~= nil then
+        Event.invoke(onCreateEvent, handle)
+    end
+end
+function Handle.prototype.__tostring(self)
+    return (self.constructor.name .. "@") .. tostring(getHandleId(self.handle))
+end
+function Handle.prototype.onDestroy(self, ...)
+    self[0] = 3
+    return nil
+end
+function Handle.prototype.destroy(self, ...)
+    local clazz = self.constructor
+    local id = getHandleId(self.handle)
+    if not clazz.memoized[id] then
+        error(
+            __TS__New(
+                IllegalStateException,
+                "Double-destroy run for handle " .. tostring(id)
+            ),
+            0
+        )
+    end
+    self[0] = 2
+    if self.onDestroyEvent then
+        Event.invoke(self.onDestroyEvent)
+    end
+    ____exports.Handle:invokeOnDestroyEvent(clazz, self)
+    self:onDestroy(...)
+    if self[0] ~= 3 then
+        error(
+            __TS__New(IllegalStateException, ("'onDestroy' is incorrectly overridden (class '" .. clazz.name) .. "')."),
+            0
+        )
+    end
+    __TS__Delete(clazz.memoized, id)
+    return nil
+end
+function Handle.invokeOnDestroyEvent(self, clazz, handle)
+    if clazz == nil then
+        return
+    end
+    local onDestroyEvent = onDestroyEventByHandleConstructor[clazz]
+    if onDestroyEvent ~= nil then
+        Event.invoke(onDestroyEvent, handle)
+    end
+    ____exports.Handle:invokeOnDestroyEvent(
+        getSuperclass(clazz),
+        handle
+    )
+end
+__TS__SetDescriptor(
+    Handle.prototype,
+    "state",
+    {get = function(self)
+        return self[0] or 1
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    Handle,
+    "onCreateEvent",
+    {get = function(self)
+        local onCreateEvent = onCreateEventByHandleConstructor[self]
+        if onCreateEvent == nil then
+            onCreateEvent = __TS__New(Event)
+            onCreateEventByHandleConstructor[self] = onCreateEvent
+        end
+        return onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Handle,
+    "onDestroyEvent",
+    {get = function(self)
+        local onDestroyEvent = onDestroyEventByHandleConstructor[self]
+        if onDestroyEvent == nil then
+            onDestroyEvent = __TS__New(Event)
+            onDestroyEventByHandleConstructor[self] = onDestroyEvent
+        end
+        return onDestroyEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Handle,
+    "memoized",
+    {get = function(self)
+        local memoized = {}
+        rawset(self, "memoized", memoized)
+        return memoized
+    end}
+)
+__TS__ObjectDefineProperty(
+    Handle,
+    "onCreate",
+    {get = function(self)
+        return self.onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Handle,
+    "destroyEvent",
+    {get = function(self)
+        return self.onDestroyEvent
+    end}
+)
+__TS__SetDescriptor(
+    Handle.prototype,
+    "destroyEvent",
+    {get = function(self)
+        if not self.onDestroyEvent then
+            self.onDestroyEvent = __TS__New(Event)
+        end
+        return self.onDestroyEvent
+    end},
+    true
+)
+return ____exports

package/core/types/image.d.ts

@@ -0,0 +1,29 @@
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "./handle";
+import { Color } from "./color";
+declare const enum ImagePropertyKey {
+    X = 100,
+    Y = 101,
+    VISIBLE = 102,
+    COLOR = 103
+}
+export declare class Image extends Handle<jimage> {
+    private [ImagePropertyKey.X];
+    private [ImagePropertyKey.Y];
+    private [ImagePropertyKey.VISIBLE]?;
+    private [ImagePropertyKey.COLOR]?;
+    constructor(handle: jimage, x: number, y: number);
+    protected onDestroy(): HandleDestructor;
+    get x(): number;
+    set x(x: number);
+    get y(): number;
+    set y(y: number);
+    getPosition(): LuaMultiReturn<[number, number]>;
+    setPosition(x: number, y: number): void;
+    get visible(): boolean;
+    set visible(visible: boolean);
+    get color(): Color;
+    set color(color: Color);
+    static create(path: string, x: number, y: number, sizeX: number, sizeY: number, layer?: 1 | 2 | 3 | 4): Image;
+}
+export {};

package/core/types/image.lua

@@ -0,0 +1,121 @@
+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
+local ____color = require("core.types.color")
+local Color = ____color.Color
+local createImage = CreateImage
+local destroyImage = DestroyImage
+local setImagePosition = SetImagePosition
+____exports.Image = __TS__Class()
+local Image = ____exports.Image
+Image.name = "Image"
+__TS__ClassExtends(Image, Handle)
+function Image.prototype.____constructor(self, handle, x, y)
+    Handle.prototype.____constructor(self, handle)
+    self[100] = x
+    self[101] = y
+end
+function Image.prototype.onDestroy(self)
+    destroyImage(self.handle)
+    return Handle.prototype.onDestroy(self)
+end
+function Image.prototype.getPosition(self)
+    return self[100], self[101]
+end
+function Image.prototype.setPosition(self, x, y)
+    setImagePosition(self.handle, x, y, 0)
+    self[100] = x
+    self[101] = y
+end
+function Image.create(self, path, x, y, sizeX, sizeY, layer)
+    return ____exports.Image:of(
+        createImage(
+            path,
+            sizeX,
+            sizeY,
+            0,
+            x,
+            y,
+            0,
+            sizeX / 2,
+            sizeY / 2,
+            0,
+            layer or 1
+        ),
+        x,
+        y
+    )
+end
+__TS__SetDescriptor(
+    Image.prototype,
+    "x",
+    {
+        get = function(self)
+            return self[100]
+        end,
+        set = function(self, x)
+            setImagePosition(self.handle, x, self[101], 0)
+            self[100] = x
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Image.prototype,
+    "y",
+    {
+        get = function(self)
+            return self[101]
+        end,
+        set = function(self, y)
+            setImagePosition(self.handle, self[100], y, 0)
+            self[101] = y
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Image.prototype,
+    "visible",
+    {
+        get = function(self)
+            return self[102] == true
+        end,
+        set = function(self, visible)
+            SetImageRenderAlways(self.handle, visible)
+            local ____visible_0
+            if visible then
+                ____visible_0 = true
+            else
+                ____visible_0 = nil
+            end
+            self[102] = ____visible_0
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Image.prototype,
+    "color",
+    {
+        get = function(self)
+            return self[103] or Color.white
+        end,
+        set = function(self, color)
+            SetImageColor(
+                self.handle,
+                color.r,
+                color.g,
+                color.b,
+                color.a
+            )
+            self[103] = color
+        end
+    },
+    true
+)
+return ____exports

package/core/types/internal/ability+cooldownRemaining.d.ts

@@ -0,0 +1 @@
+/** @noSelfInFile */

package/core/types/item.d.ts

@@ -0,0 +1,4 @@
+/** @noSelfInFile */
+import { Item } from "../../engine/internal/item";
+import "../../engine/internal/item+owner";
+export { Item };

package/core/types/item.lua

@@ -0,0 +1,6 @@
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+require("engine.internal.item+owner")
+____exports.Item = Item
+return ____exports

package/core/types/missile.d.ts

@@ -0,0 +1,22 @@
+/** @noSelfInFile */
+import { Unit } from "./unit";
+export declare class Missile implements Destroyable {
+    private readonly effect;
+    readonly retarget: (this: void, target: Unit | Vec2) => void;
+    private readonly update;
+    protected constructor(effect: jeffect, retarget: (this: void, target: Unit | Vec2) => void, update: (this: Missile) => boolean);
+    static launch<T extends any[]>(config: Readonly<{
+        art: string;
+        scale?: number;
+        acceleration?: number;
+        speed: number;
+        arc?: number;
+        minSpeed?: number;
+        maxSpeed?: number;
+        sourceOffset?: Vec2;
+        targetOffset?: Vec2;
+    }>, source: Unit | Vec2, target: Unit | Vec2, onArrival: (missile: Missile, success: boolean, ...parameters: T) => void, ...parameters: T): Missile;
+    destroy(): void;
+}
+export declare namespace Missile {
+}