warscript 0.0.1-dev.404878c

package/core/types/player.lua

@@ -0,0 +1,448 @@
+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__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____event = require("event")
+local Event = ____event.Event
+local InitializingEvent = ____event.InitializingEvent
+local TriggerEvent = ____event.TriggerEvent
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____playerCamera = require("core.types.playerCamera")
+local PlayerCamera = ____playerCamera.PlayerCamera
+local ____playerColor = require("core.types.playerColor")
+local PlayerColor = ____playerColor.PlayerColor
+local ____exception = require("exception")
+local IllegalStateException = ____exception.IllegalStateException
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local getPlayerColor = GetPlayerColor
+local getPlayerName = GetPlayerName
+local getPlayerTechCount = GetPlayerTechCount
+local getPlayerTechMaxAllowed = GetPlayerTechMaxAllowed
+local setPlayerTechMaxAllowed = SetPlayerTechMaxAllowed
+local setPlayerTechResearched = SetPlayerTechResearched
+local setPlayerAbilityAvailable = SetPlayerAbilityAvailable
+local playerNative = _G.Player
+____exports.Player = __TS__Class()
+local Player = ____exports.Player
+Player.name = "Player"
+__TS__ClassExtends(Player, Handle)
+function Player.prototype.____constructor(self, handle)
+    Handle.prototype.____constructor(self, handle)
+    self.id = GetPlayerId(handle)
+end
+function Player.prototype.onDestroy(self)
+    error(
+        __TS__New(IllegalStateException, "Player instances are not supposed to be destroyed."),
+        0
+    )
+end
+function Player.prototype.__tostring(self)
+    return ("Player(id = " .. tostring(self.id)) .. ")"
+end
+function Player.prototype.clearSelection(self)
+    if self.isLocal then
+        ClearSelection()
+    end
+end
+function Player.prototype.selectSingle(self, unit)
+    if self.isLocal then
+        ClearSelection()
+        SelectUnit(unit.handle, true)
+    end
+end
+function Player.prototype.select(self, unit)
+    if self.isLocal then
+        SelectUnit(unit.handle, true)
+    end
+end
+function Player.prototype.deselect(self, unit)
+    if self.isLocal then
+        SelectUnit(unit.handle, false)
+    end
+end
+function Player.prototype.forceUIKey(self, key)
+    if self.isLocal then
+        ForceUIKey(key)
+    end
+end
+function Player.prototype.forceUICancel(self)
+    if self.isLocal then
+        ForceUICancel()
+    end
+end
+function Player.prototype.isAllyOf(self, other)
+    return IsPlayerAlly(self.handle, other.handle)
+end
+function Player.prototype.isEnemyOf(self, other)
+    return IsPlayerEnemy(self.handle, other.handle)
+end
+function Player.prototype.setAbilityAvailable(self, abilityId, available)
+    setPlayerAbilityAvailable(self.handle, abilityId, available)
+end
+function Player.prototype.getMaximumUpgradeLevel(self, upgradeId)
+    return getPlayerTechMaxAllowed(self.handle, upgradeId)
+end
+function Player.prototype.setMaximumUpgradeLevel(self, upgradeId, maximumLevel)
+    setPlayerTechMaxAllowed(self.handle, upgradeId, maximumLevel)
+end
+function Player.prototype.resetMaximumUpgradeLevel(self, upgradeId)
+    setPlayerTechMaxAllowed(self.handle, upgradeId, MAXIMUM_INTEGER)
+end
+function Player.prototype.getUpgradeLevel(self, upgradeId)
+    return getPlayerTechCount(self.handle, upgradeId, true)
+end
+function Player.prototype.setUpgradeLevel(self, upgradeId, level)
+    setPlayerTechResearched(self.handle, upgradeId, level)
+end
+function Player.getEvent(self, event, collector)
+    local eventId = GetHandleId(event)
+    if not self.events[eventId] then
+        self.events[eventId] = __TS__New(
+            TriggerEvent,
+            function(trigger)
+                for ____, player in ipairs(____exports.Player.all) do
+                    TriggerRegisterPlayerEvent(trigger, player.handle, event)
+                end
+            end,
+            collector
+        )
+    end
+    return self.events[eventId]
+end
+function Player.getMouseEvent(self, event, collector)
+    local eventId = GetHandleId(event)
+    if not self.events[eventId] then
+        self.events[eventId] = __TS__New(
+            TriggerEvent,
+            function(trigger)
+                Timer:simple(
+                    0,
+                    function()
+                        for ____, player in ipairs(____exports.Player.all) do
+                            TriggerRegisterPlayerEvent(trigger, player.handle, event)
+                        end
+                    end
+                )
+            end,
+            collector or (function() return {} end)
+        )
+    end
+    return self.events[eventId]
+end
+function Player.getKeyEvent(self, isDown)
+    local trigger = CreateTrigger()
+    local registered = {}
+    local function register(key, metakey)
+        if not registered[(tostring(GetHandleId(key)) .. "|") .. tostring(metakey)] then
+            registered[(tostring(GetHandleId(key)) .. "|") .. tostring(metakey)] = true
+            for ____, player in ipairs(____exports.Player.all) do
+                BlzTriggerRegisterPlayerKeyEvent(
+                    trigger,
+                    player.handle,
+                    key,
+                    metakey,
+                    isDown
+                )
+            end
+        end
+    end
+    local keyEvents = {}
+    local event = __TS__New(
+        InitializingEvent,
+        function()
+            do
+                local oskey = 1
+                while oskey < 255 do
+                    do
+                        local metakey = 0
+                        while metakey < 15 do
+                            register(
+                                ConvertOsKeyType(oskey),
+                                metakey
+                            )
+                            metakey = metakey + 1
+                        end
+                    end
+                    oskey = oskey + 1
+                end
+            end
+        end
+    )
+    TriggerAddCondition(
+        trigger,
+        Condition(function()
+            local player = ____exports.Player:of(GetTriggerPlayer())
+            local key = BlzGetTriggerPlayerKey()
+            local metaKey = BlzGetTriggerPlayerMetaKey()
+            Event.invoke(event, player, key, metaKey)
+            local keyEvent = keyEvents[key]
+            if keyEvent ~= nil then
+                Event.invoke(keyEvent, player, metaKey)
+                local metaKeyEvent = rawget(keyEvent, metaKey)
+                if metaKeyEvent ~= nil then
+                    Event.invoke(metaKeyEvent, player)
+                end
+            end
+        end)
+    )
+    return setmetatable(
+        {},
+        {
+            __index = function(self, key)
+                if type(key) == "string" then
+                    return event[key]
+                end
+                local keyEvent = __TS__New(
+                    InitializingEvent,
+                    function()
+                        do
+                            local metakey = 0
+                            while metakey < 5 do
+                                register(key, metakey)
+                                metakey = metakey + 1
+                            end
+                        end
+                    end
+                )
+                local mt = setmetatable(
+                    {},
+                    {
+                        __index = function(self, metaKey)
+                            if type(metaKey) == "string" then
+                                return keyEvent[metaKey]
+                            end
+                            local metaKeyEvent = __TS__New(
+                                InitializingEvent,
+                                function()
+                                    register(key, metaKey)
+                                end
+                            )
+                            keyEvent[metaKey] = metaKeyEvent
+                            rawset(self, metaKey, metaKeyEvent)
+                            return metaKeyEvent
+                        end,
+                        __newindex = keyEvent
+                    }
+                )
+                keyEvents[key] = mt
+                rawset(self, key, mt)
+                return mt
+            end,
+            __newindex = event
+        }
+    )
+end
+function Player.byId(self, id)
+    return ____exports.Player.all[id + 1]
+end
+Player.all = (function()
+    local all = {}
+    for i = 1, bj_MAX_PLAYER_SLOTS do
+        all[i] = ____exports.Player:of(playerNative(i - 1))
+    end
+    return all
+end)()
+Player["local"] = ____exports.Player:of(GetLocalPlayer())
+Player.neutralPassive = ____exports.Player.all[PLAYER_NEUTRAL_PASSIVE + 1]
+Player.neutralAggressive = ____exports.Player.all[PLAYER_NEUTRAL_AGGRESSIVE + 1]
+Player.neutralVictim = ____exports.Player.all[bj_PLAYER_NEUTRAL_VICTIM + 1]
+Player.neutralExtra = ____exports.Player.all[bj_PLAYER_NEUTRAL_EXTRA + 1]
+Player.events = {}
+__TS__SetDescriptor(
+    Player.prototype,
+    "name",
+    {
+        get = function(self)
+            return getPlayerName(self.handle)
+        end,
+        set = function(self, name)
+            SetPlayerName(self.handle, name)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "color",
+    {
+        get = function(self)
+            return PlayerColor:of(getPlayerColor(self.handle))
+        end,
+        set = function(self, color)
+            SetPlayerColor(self.handle, color.handle)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "nameColored",
+    {get = function(self)
+        return (("|c" .. PlayerColor:of(getPlayerColor(self.handle)).hexCode) .. getPlayerName(self.handle)) .. "|r"
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "gold",
+    {
+        get = function(self)
+            return GetPlayerState(self.handle, PLAYER_STATE_RESOURCE_GOLD)
+        end,
+        set = function(self, gold)
+            SetPlayerState(self.handle, PLAYER_STATE_RESOURCE_GOLD, gold)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "lumber",
+    {
+        get = function(self)
+            return GetPlayerState(self.handle, PLAYER_STATE_RESOURCE_LUMBER)
+        end,
+        set = function(self, gold)
+            SetPlayerState(self.handle, PLAYER_STATE_RESOURCE_LUMBER, gold)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "isLocal",
+    {get = function(self)
+        local isLocal = self == ____exports.Player["local"]
+        rawset(self, "isLocal", isLocal)
+        return isLocal
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "camera",
+    {get = function(self)
+        local camera = PlayerCamera:of(self.handle)
+        rawset(self, "camera", camera)
+        return camera
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "isUser",
+    {get = function(self)
+        return GetPlayerController(self.handle) == MAP_CONTROL_USER
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "isPlaying",
+    {get = function(self)
+        return GetPlayerSlotState(self.handle) == PLAYER_SLOT_STATE_PLAYING
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "controller",
+    {get = function(self)
+        return GetPlayerController(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Player.prototype,
+    "slotState",
+    {get = function(self)
+        return GetPlayerSlotState(self.handle)
+    end},
+    true
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onLeave",
+    {get = function(self)
+        return ____exports.Player:getEvent(
+            EVENT_PLAYER_LEAVE,
+            function() return ____exports.Player:of(GetTriggerPlayer()) end
+        )
+    end}
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onMouseDown",
+    {get = function(self)
+        return ____exports.Player:getMouseEvent(
+            EVENT_PLAYER_MOUSE_DOWN,
+            function() return ____exports.Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerMouseButton() end
+        )
+    end}
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onMouseUp",
+    {get = function(self)
+        return ____exports.Player:getMouseEvent(
+            EVENT_PLAYER_MOUSE_UP,
+            function() return ____exports.Player:of(GetTriggerPlayer()), BlzGetTriggerPlayerMouseButton() end
+        )
+    end}
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onMouseMove",
+    {get = function(self)
+        return ____exports.Player:getMouseEvent(
+            EVENT_PLAYER_MOUSE_MOVE,
+            function() return ____exports.Player:of(GetTriggerPlayer()), vec2(
+                BlzGetTriggerPlayerMouseX(),
+                BlzGetTriggerPlayerMouseY()
+            ) end
+        )
+    end}
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onKeyPress",
+    {get = function(self)
+        local onKeyPress = self:getKeyEvent(true)
+        rawset(self, "onKeyPress", onKeyPress)
+        return onKeyPress
+    end}
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onKeyRelease",
+    {get = function(self)
+        local onKeyRelease = self:getKeyEvent(false)
+        rawset(self, "onKeyRelease", onKeyRelease)
+        return onKeyRelease
+    end}
+)
+__TS__ObjectDefineProperty(
+    Player,
+    "onChat",
+    {get = function(self)
+        local event = __TS__New(
+            TriggerEvent,
+            function(trigger)
+                for ____, player in ipairs(____exports.Player.all) do
+                    TriggerRegisterPlayerChatEvent(trigger, player.handle, "", false)
+                end
+            end,
+            function() return ____exports.Player:of(GetTriggerPlayer()), GetEventPlayerChatString() end
+        )
+        rawset(self, "onChat", event)
+        return event
+    end}
+)
+return ____exports

package/core/types/playerCamera.d.ts

@@ -0,0 +1,32 @@
+/** @noSelfInFile */
+export declare class PlayerCamera {
+    private readonly player;
+    private readonly isLocal;
+    private constructor();
+    /** async */
+    get x(): number;
+    set x(x: number);
+    /** async */
+    get y(): number;
+    set y(y: number);
+    /** async */
+    get zOffset(): number;
+    set zOffset(zOffset: number);
+    /** async */
+    get distance(): number;
+    set distance(distance: number);
+    /** async */
+    get farClipping(): number;
+    set farClipping(farClipping: number);
+    /** async */
+    get yaw(): number;
+    set yaw(v: number);
+    /** async */
+    get pitch(): number;
+    set pitch(v: number);
+    /** async */
+    get roll(): number;
+    set roll(v: number);
+    reset(): void;
+    static of(player: jplayer): PlayerCamera;
+}

package/core/types/playerCamera.lua

@@ -0,0 +1,162 @@
+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 getHandleId = GetHandleId
+local setCameraField = SetCameraField
+local getCameraField = GetCameraField
+local setCameraPosition = SetCameraPosition
+local getCameraTargetPositionX = GetCameraTargetPositionX
+local getCameraTargetPositionY = GetCameraTargetPositionY
+local resetToGameCamera = ResetToGameCamera
+local deg = math.deg
+local localPlayer = GetLocalPlayer()
+local memoized = {}
+____exports.PlayerCamera = __TS__Class()
+local PlayerCamera = ____exports.PlayerCamera
+PlayerCamera.name = "PlayerCamera"
+function PlayerCamera.prototype.____constructor(self, player)
+    local id = getHandleId(player)
+    if memoized[id] then
+        error("Double-constructor run player camera!")
+    end
+    memoized[id] = self
+    self.player = player
+    self.isLocal = player == localPlayer
+end
+function PlayerCamera.prototype.reset(self)
+    if self.isLocal then
+        resetToGameCamera(0)
+    end
+end
+function PlayerCamera.of(self, player)
+    return memoized[getHandleId(player)] or __TS__New(____exports.PlayerCamera, player)
+end
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "x",
+    {
+        get = function(self)
+            return self.isLocal and getCameraTargetPositionX() or 0
+        end,
+        set = function(self, x)
+            if self.isLocal then
+                setCameraPosition(
+                    x,
+                    getCameraTargetPositionY()
+                )
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "y",
+    {
+        get = function(self)
+            return self.isLocal and getCameraTargetPositionY() or 0
+        end,
+        set = function(self, y)
+            if self.isLocal then
+                setCameraPosition(
+                    getCameraTargetPositionX(),
+                    y
+                )
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "zOffset",
+    {
+        get = function(self)
+            return self.isLocal and getCameraField(CAMERA_FIELD_ZOFFSET) or 0
+        end,
+        set = function(self, zOffset)
+            if self.isLocal then
+                setCameraField(CAMERA_FIELD_ZOFFSET, zOffset, 0)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "distance",
+    {
+        get = function(self)
+            return self.isLocal and getCameraField(CAMERA_FIELD_TARGET_DISTANCE) or 0
+        end,
+        set = function(self, distance)
+            if self.isLocal then
+                setCameraField(CAMERA_FIELD_TARGET_DISTANCE, distance, 0)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "farClipping",
+    {
+        get = function(self)
+            return self.isLocal and getCameraField(CAMERA_FIELD_FARZ) or 0
+        end,
+        set = function(self, farClipping)
+            if self.isLocal then
+                setCameraField(CAMERA_FIELD_FARZ, farClipping, 0)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "yaw",
+    {
+        get = function(self)
+            return self.isLocal and deg(getCameraField(CAMERA_FIELD_ROTATION)) or 0
+        end,
+        set = function(self, v)
+            if self.isLocal then
+                setCameraField(CAMERA_FIELD_ROTATION, v, 0)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "pitch",
+    {
+        get = function(self)
+            return self.isLocal and deg(getCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK)) or 0
+        end,
+        set = function(self, v)
+            if self.isLocal then
+                setCameraField(CAMERA_FIELD_ANGLE_OF_ATTACK, v, 0)
+            end
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    PlayerCamera.prototype,
+    "roll",
+    {
+        get = function(self)
+            return self.isLocal and deg(getCameraField(CAMERA_FIELD_ROLL)) or 0
+        end,
+        set = function(self, v)
+            if self.isLocal then
+                setCameraField(CAMERA_FIELD_ROLL, v, 0)
+            end
+        end
+    },
+    true
+)
+return ____exports

package/core/types/playerColor.d.ts

@@ -0,0 +1,40 @@
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "./handle";
+import { Color } from "./color";
+export declare class PlayerColor extends Handle<jplayercolor> {
+    readonly rgba: Readonly<Color>;
+    readonly name: string;
+    readonly id: number;
+    constructor(handle: jplayercolor);
+    protected onDestroy(): HandleDestructor;
+    get hexCode(): string;
+    private static readonly data;
+    static readonly red: PlayerColor;
+    static readonly blue: PlayerColor;
+    static readonly teal: PlayerColor;
+    static readonly purple: PlayerColor;
+    static readonly yellow: PlayerColor;
+    static readonly orange: PlayerColor;
+    static readonly green: PlayerColor;
+    static readonly pink: PlayerColor;
+    static readonly gray: PlayerColor;
+    static readonly lightBlue: PlayerColor;
+    static readonly darkGreen: PlayerColor;
+    static readonly brown: PlayerColor;
+    static readonly maroon: PlayerColor;
+    static readonly navy: PlayerColor;
+    static readonly turquoise: PlayerColor;
+    static readonly violet: PlayerColor;
+    static readonly wheat: PlayerColor;
+    static readonly peach: PlayerColor;
+    static readonly mint: PlayerColor;
+    static readonly lavender: PlayerColor;
+    static readonly coal: PlayerColor;
+    static readonly snow: PlayerColor;
+    static readonly emerald: PlayerColor;
+    static readonly peanut: PlayerColor;
+    static readonly black: PlayerColor;
+    static readonly all: PlayerColor[];
+    static byName(name: string): PlayerColor | null;
+    static byId(id: number): PlayerColor | null;
+}