warscript 0.0.1-dev.008d8ef

package/core/types/missile.lua

@@ -0,0 +1,239 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__InstanceOf = ____lualib.__TS__InstanceOf
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____unit = require("core.types.unit")
+local Unit = ____unit.Unit
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____unit_2Dmissile_2Ddata = require("engine.internal.unit-missile-data")
+local MISSILE_DATA_BY_UNIT_TYPE_ID = ____unit_2Dmissile_2Ddata.MISSILE_DATA_BY_UNIT_TYPE_ID
+local rad = math.rad
+local cos = math.cos
+local sin = math.sin
+local sqrt = math.sqrt
+local atan = math.atan
+local terrainZ = vec2.terrainZ
+local addSpecialEffect = AddSpecialEffect
+local setSpecialEffectScale = BlzSetSpecialEffectScale
+local setSpecialEffectPosition = BlzSetSpecialEffectPosition
+local setSpecialEffectYaw = BlzSetSpecialEffectYaw
+local setSpecialEffectPitch = BlzSetSpecialEffectPitch
+local destroyEffect = DestroyEffect
+local getHandleId = GetHandleId
+local getUnitX = GetUnitX
+local getUnitY = GetUnitY
+local safeCall = warpack.safeCall
+local head
+local next = {}
+local previous = {}
+____exports.Missile = __TS__Class()
+local Missile = ____exports.Missile
+Missile.name = "Missile"
+function Missile.prototype.____constructor(self, effect, retarget, update)
+    self.effect = effect
+    self.retarget = retarget
+    self.update = update
+    if head then
+        next[self] = head
+        previous[head] = self
+    end
+    head = self
+end
+function Missile.launch(self, config, source, target, onArrival, ...)
+    local parameters = {...}
+    local ____opt_0 = config.sourceOffset
+    local offsetX = ____opt_0 and ____opt_0.x or 0
+    local ____opt_2 = config.sourceOffset
+    local offsetY = ____opt_2 and ____opt_2.y or 0
+    local visualOffsetX = 0
+    local visualOffsetY = 0
+    local ____temp_6 = source.z or terrainZ(source)
+    local ____opt_4 = config.sourceOffset
+    local visualOffsetZ = ____temp_6 + (____opt_4 and ____opt_4.z or 0)
+    if __TS__InstanceOf(source, Unit) then
+        local data = MISSILE_DATA_BY_UNIT_TYPE_ID[source.typeId]
+        local launchX = data.launchOffsetX
+        local launchY = data.launchOffsetY
+        local projectileVisOffsetX = data.launchVisualOffsetX
+        local projectileVisOffsetY = data.launchVisualOffsetY
+        local angle = rad(source.facing - 90)
+        local s = sin(angle)
+        local c = cos(angle)
+        offsetX = offsetX + (c * launchX - s * launchY)
+        offsetY = offsetY + (s * launchX + c * launchY)
+        visualOffsetX = visualOffsetX + (c * projectileVisOffsetX - s * projectileVisOffsetY)
+        visualOffsetY = visualOffsetY + (s * projectileVisOffsetX + c * projectileVisOffsetY)
+        visualOffsetZ = visualOffsetZ + data.launchOffsetZ
+    end
+    local ____opt_7 = config.targetOffset
+    local targetOffsetX = ____opt_7 and ____opt_7.x or 0
+    local ____opt_9 = config.targetOffset
+    local targetOffsetY = ____opt_9 and ____opt_9.y or 0
+    local targetVisualOffsetX = 0
+    local targetVisualOffsetY = 0
+    local ____temp_13 = target.z or terrainZ(target)
+    local ____opt_11 = config.targetOffset
+    local targetVisualOffsetZ = ____temp_13 + (____opt_11 and ____opt_11.z or 0)
+    if __TS__InstanceOf(target, Unit) then
+        targetVisualOffsetZ = targetVisualOffsetZ + MISSILE_DATA_BY_UNIT_TYPE_ID[target.typeId].impactOffsetZ
+    end
+    local retarget = false
+    local positionX = source.x + offsetX
+    local positionY = source.y + offsetY
+    local visualPositionX = positionX + visualOffsetX
+    local visualPositionY = positionY + visualOffsetY
+    local visualPositionZ = visualOffsetZ
+    local visualPositionArcX = visualPositionX
+    local visualPositionArcY = visualPositionY
+    local visualPositionArcZ = visualPositionZ
+    local currentTargetX = target.x + targetOffsetX
+    local currentTargetY = target.y + targetOffsetY
+    local currentVisualTargetX = currentTargetX + targetVisualOffsetX
+    local currentVisualTargetY = currentTargetY + targetVisualOffsetY
+    local currentVisualTargetZ = targetVisualOffsetZ
+    local dx = currentTargetX - positionX
+    local dy = currentTargetY - positionY
+    local fullDist = sqrt(dx * dx + dy * dy)
+    local effect = addSpecialEffect(config.art, visualPositionX, visualPositionY)
+    setSpecialEffectPosition(effect, visualPositionX, visualPositionY, visualPositionZ)
+    if config.scale then
+        setSpecialEffectScale(effect, config.scale)
+    end
+    local acceleration = (config.acceleration or 0) / 128
+    local speed = config.speed / 128 + acceleration / 2
+    local arcVAcceleration = 0
+    local arcVSpeed = 0
+    if config.arc then
+        arcVAcceleration = acceleration * config.arc
+        arcVSpeed = 4 * speed * config.arc
+    end
+    local arcZ = 0
+    local unit = __TS__InstanceOf(target, Unit) and target.handle or nil
+    local initialTargetX = target.x + targetOffsetX
+    local initialTargetY = target.y + targetOffsetY
+    local function update(self)
+        if unit and getHandleId(unit) ~= 0 then
+            currentTargetX = getUnitX(unit) + targetOffsetX
+            currentTargetY = getUnitY(unit) + targetOffsetY
+            currentVisualTargetX = currentTargetX + targetVisualOffsetX
+            currentVisualTargetY = currentTargetY + targetVisualOffsetY
+            currentVisualTargetZ = targetVisualOffsetZ
+        end
+        dx = currentTargetX - positionX
+        dy = currentTargetY - positionY
+        local dist = sqrt(dx * dx + dy * dy)
+        if dist <= speed then
+            local dx = currentVisualTargetX - visualPositionArcX
+            local dy = currentVisualTargetY - visualPositionArcY
+            local dz = currentVisualTargetZ - visualPositionArcZ
+            local yaw = atan(dy, dx)
+            local pitch = atan(
+                dz,
+                sqrt(dx * dx + dy * dy)
+            )
+            setSpecialEffectYaw(effect, yaw)
+            setSpecialEffectPitch(effect, -pitch)
+            setSpecialEffectPosition(effect, currentVisualTargetX, currentVisualTargetY, currentVisualTargetZ)
+            visualPositionX = currentVisualTargetX
+            visualPositionY = currentVisualTargetY
+            visualPositionZ = currentVisualTargetZ
+            visualPositionArcX = currentVisualTargetX
+            visualPositionArcY = currentVisualTargetY
+            visualPositionArcZ = currentVisualTargetZ
+            retarget = false
+            safeCall(
+                onArrival,
+                self,
+                true,
+                table.unpack(parameters)
+            )
+            return not retarget
+        end
+        if arcVSpeed ~= 0 and (currentTargetX ~= initialTargetX or currentTargetY ~= initialTargetY) then
+            arcVSpeed = 0
+            arcVAcceleration = 0
+            visualPositionZ = visualPositionZ + arcZ
+            arcZ = 0
+        end
+        local newPositionX = positionX + dx / dist * speed
+        local newPositionY = positionY + dy / dist * speed
+        local timeLeft = dist / speed
+        local visualDx = currentVisualTargetX - visualPositionX
+        local visualDy = currentVisualTargetY - visualPositionY
+        local visualDz = currentVisualTargetZ - visualPositionZ
+        local newVisualPositionX = visualPositionX + visualDx / timeLeft
+        local newVisualPositionY = visualPositionY + visualDy / timeLeft
+        local newVisualPositionZ = visualPositionZ + visualDz / timeLeft
+        arcZ = arcZ + arcVSpeed * (2 * (dist / fullDist) - 1)
+        local newVisualPositionArcX = newVisualPositionX
+        local newVisualPositionArcY = newVisualPositionY
+        local newVisualPositionArcZ = newVisualPositionZ + arcZ
+        local visualArcDx = newVisualPositionArcX - visualPositionArcX
+        local visualArcDy = newVisualPositionArcY - visualPositionArcY
+        local visualArcDz = newVisualPositionArcZ - visualPositionArcZ
+        local yaw = atan(visualArcDy, visualArcDx)
+        local pitch = atan(
+            visualArcDz,
+            sqrt(visualArcDx * visualArcDx + visualArcDy * visualArcDy)
+        )
+        setSpecialEffectYaw(effect, yaw)
+        setSpecialEffectPitch(effect, -pitch)
+        setSpecialEffectPosition(effect, newVisualPositionArcX, newVisualPositionArcY, newVisualPositionArcZ)
+        positionX = newPositionX
+        positionY = newPositionY
+        visualPositionX = newVisualPositionX
+        visualPositionY = newVisualPositionY
+        visualPositionZ = newVisualPositionZ
+        visualPositionArcX = newVisualPositionArcX
+        visualPositionArcY = newVisualPositionArcY
+        visualPositionArcZ = newVisualPositionArcZ
+        speed = speed + acceleration
+        arcVSpeed = arcVSpeed + arcVAcceleration
+        return false
+    end
+    return __TS__New(
+        ____exports.Missile,
+        effect,
+        function(newTarget)
+            target = newTarget
+            targetVisualOffsetX = 0
+            targetVisualOffsetY = 0
+            local ____temp_16 = target.z or terrainZ(target)
+            local ____opt_14 = config.targetOffset
+            targetVisualOffsetZ = ____temp_16 + (____opt_14 and ____opt_14.z or 0)
+            if __TS__InstanceOf(target, Unit) then
+                targetVisualOffsetZ = targetVisualOffsetZ + MISSILE_DATA_BY_UNIT_TYPE_ID[target.typeId].impactOffsetZ
+            end
+            retarget = true
+        end,
+        update
+    )
+end
+function Missile.prototype.destroy(self)
+    destroyEffect(self.effect)
+    local previousMissile = previous[self]
+    local nextMissile = next[self]
+    if previousMissile then
+        next[previousMissile] = nextMissile
+    else
+        head = nextMissile
+    end
+    if nextMissile then
+        previous[nextMissile] = previousMissile
+    end
+    previous[self] = nil
+    next[self] = nil
+end
+Timer.onPeriod[1 / 64]:addListener(function()
+    local missile = head
+    while missile do
+        local nextMissile = next[missile]
+        if missile.update(missile) then
+            missile:destroy()
+        end
+        missile = nextMissile
+    end
+end)
+return ____exports

package/core/types/order.d.ts

@@ -0,0 +1,25 @@
+/** @noSelfInFile */
+import { Unit } from "./unit";
+import { Item } from "./item";
+import { Destructable } from "./destructable";
+export type Order = {
+    id: number;
+    startX: number;
+    startY: number;
+} & ({
+    type: "immediate";
+} | {
+    type: "point";
+    targetX: number;
+    targetY: number;
+} | {
+    type: "target";
+    target: Unit | Item | Destructable;
+});
+declare module "../../engine/internal/unit" {
+    interface Unit {
+        readonly currentOrder: Order;
+        readonly lastOrder: Order;
+        issueOrder(order: Order): void;
+    }
+}

package/core/types/order.lua

@@ -0,0 +1,55 @@
+local ____lualib = require("lualib_bundle")
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____unit = require("core.types.unit")
+local Unit = ____unit.Unit
+local getUnitCurrentOrder = GetUnitCurrentOrder
+local orders = setmetatable({}, {__mode = "k"})
+Unit.onImmediateOrder:addListener(function(unit, orderId)
+    orders[unit] = {id = orderId, startX = unit.x, startY = unit.y, type = "immediate"}
+end)
+Unit.onPointOrder:addListener(function(unit, orderId, x, y)
+    orders[unit] = {
+        id = orderId,
+        startX = unit.x,
+        startY = unit.y,
+        type = "point",
+        targetX = x,
+        targetY = y
+    }
+end)
+Unit.onTargetOrder:addListener(function(unit, orderId, target)
+    orders[unit] = {
+        id = orderId,
+        startX = unit.x,
+        startY = unit.y,
+        type = "target",
+        target = target
+    }
+end)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "currentOrder",
+    {get = function(self)
+        local currentOrderId = getUnitCurrentOrder(self.handle)
+        local lastOrder = orders[self]
+        return lastOrder and (lastOrder.id == currentOrderId or currentOrderId == orderId("patrolAI") and lastOrder.id == orderId("patrol")) and lastOrder or ({id = 0, type = "immediate"})
+    end}
+)
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "lastOrder",
+    {get = function(self)
+        return orders[self] or ({id = 0, type = "immediate"})
+    end}
+)
+Unit.prototype.issueOrder = function(self, order)
+    if order.type == "immediate" then
+        IssueImmediateOrderById(self.handle, order.id)
+    elseif order.type == "point" then
+        IssuePointOrderById(self.handle, order.id, order.targetX, order.targetY)
+    else
+        IssueTargetOrderById(self.handle, order.id, order.target.handle)
+    end
+end
+return ____exports

package/core/types/player.d.ts

@@ -0,0 +1,71 @@
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "./handle";
+import { Event, InitializingEvent } from "../../event";
+import { PlayerCamera } from "./playerCamera";
+import { PlayerColor } from "./playerColor";
+import { UpgradeId } from "../../engine/object-data/entry/upgrade";
+interface Unit {
+    handle: junit;
+}
+export declare class Player extends Handle<jplayer> {
+    static readonly all: Player[];
+    static readonly local: Player;
+    static readonly neutralPassive: Player;
+    static readonly neutralAggressive: Player;
+    static readonly neutralVictim: Player;
+    static readonly neutralExtra: Player;
+    private static events;
+    readonly id: number;
+    constructor(handle: jplayer);
+    onDestroy(): HandleDestructor;
+    toString(): string;
+    get name(): string;
+    set name(name: string);
+    get color(): PlayerColor;
+    set color(color: PlayerColor);
+    get nameColored(): string;
+    get gold(): number;
+    set gold(gold: number);
+    get lumber(): number;
+    set lumber(gold: number);
+    get isLocal(): boolean;
+    get camera(): PlayerCamera;
+    get isUser(): boolean;
+    get isPlaying(): boolean;
+    get controller(): jmapcontrol;
+    get slotState(): jplayerslotstate;
+    clearSelection(): void;
+    selectSingle(unit: Unit): void;
+    select(unit: Unit): void;
+    deselect(unit: Unit): void;
+    forceUIKey(key: string): void;
+    forceUICancel(): void;
+    isAllyOf(other: Player): boolean;
+    isEnemyOf(other: Player): boolean;
+    setAbilityAvailable(abilityId: number, available: boolean): void;
+    getMaximumUpgradeLevel(upgradeId: UpgradeId): number;
+    setMaximumUpgradeLevel(upgradeId: UpgradeId, maximumLevel: number): void;
+    resetMaximumUpgradeLevel(upgradeId: UpgradeId): void;
+    getUpgradeLevel(upgradeId: UpgradeId): number;
+    setUpgradeLevel(upgradeId: UpgradeId, level: number): void;
+    private static getEvent;
+    private static getMouseEvent;
+    static get onLeave(): Event<[Player]>;
+    static get onMouseDown(): Event<[Player, jmousebuttontype]>;
+    static get onMouseUp(): Event<[Player, jmousebuttontype]>;
+    static get onMouseMove(): Event<[Player, Vec2]>;
+    private static getKeyEvent;
+    static get onKeyPress(): InitializingEvent<[Player, joskeytype, oskeymeta]> & {
+        readonly [key: joskeytype]: InitializingEvent<[Player, oskeymeta]> & {
+            readonly [meta: oskeymeta]: InitializingEvent<[Player]>;
+        };
+    };
+    static get onKeyRelease(): InitializingEvent<[Player, joskeytype, oskeymeta]> & {
+        readonly [key: joskeytype]: InitializingEvent<[Player, oskeymeta]> & {
+            readonly [meta: oskeymeta]: InitializingEvent<[Player]>;
+        };
+    };
+    static get onChat(): Event<[player: Player, message: string]>;
+    static byId(id: number): Player | undefined;
+}
+export {};