warscript 0.0.1-dev.404878c

package/core/types/color.lua

@@ -0,0 +1,93 @@
+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 floor = math.floor
+local min = math.min
+local max = math.max
+local format = string.format
+local pack = string.pack
+local cache = {}
+____exports.Color = __TS__Class()
+local Color = ____exports.Color
+Color.name = "Color"
+function Color.prototype.____constructor(self, r, g, b, a, key)
+    self.r = r
+    self.g = g
+    self.b = b
+    self.a = a
+    cache[key] = self
+end
+function Color.prototype.__tostring(self)
+    return ((((((("color(" .. tostring(self.r)) .. ", ") .. tostring(self.g)) .. ", ") .. tostring(self.b)) .. ", ") .. tostring(self.a)) .. ")"
+end
+function Color.lerp(self, lhs, rhs, t)
+    return ____exports.Color:of(lhs.r * (1 - t) + rhs.r * t, lhs.g * (1 - t) + rhs.g * t, lhs.b * (1 - t) + rhs.b * t, lhs.a * (1 - t) + rhs.a * t)
+end
+function Color.of(self, red, green, blue, alpha)
+    red = max(
+        0,
+        min(
+            floor(red + 0.5),
+            255
+        )
+    )
+    green = max(
+        0,
+        min(
+            floor(green + 0.5),
+            255
+        )
+    )
+    blue = max(
+        0,
+        min(
+            floor(blue + 0.5),
+            255
+        )
+    )
+    alpha = max(
+        0,
+        min(
+            floor(alpha or 255 + 0.5),
+            255
+        )
+    )
+    local key = pack(
+        "=BBBB",
+        red,
+        green,
+        blue,
+        alpha
+    )
+    return cache[key] or __TS__New(
+        ____exports.Color,
+        red,
+        green,
+        blue,
+        alpha,
+        key
+    )
+end
+Color.white = ____exports.Color:of(255, 255, 255, 255)
+Color.black = ____exports.Color:of(0, 0, 0, 255)
+Color.gold = ____exports.Color:of(255, 204, 0, 255)
+Color.silver = ____exports.Color:of(195, 219, 255, 255)
+__TS__SetDescriptor(
+    Color.prototype,
+    "hexCode",
+    {get = function(self)
+        local code = format(
+            "%02x%02x%02x%02x",
+            self.a,
+            self.r,
+            self.g,
+            self.b
+        )
+        rawset(self, "hexCode", code)
+        return code
+    end},
+    true
+)
+return ____exports

package/core/types/destructable.d.ts

@@ -0,0 +1,31 @@
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "./handle";
+import { Event, TriggerEvent } from "../../event";
+import { ReadonlyRect } from "./rect";
+export declare class Destructable extends Handle<jdestructable> {
+    protected onDestroy(): HandleDestructor;
+    get typeId(): number;
+    get name(): string;
+    get x(): number;
+    get y(): number;
+    get position(): Vec2;
+    get isInvulnerable(): boolean;
+    set isInvulnerable(isInvulnerable: boolean);
+    get maxHealth(): number;
+    set maxHealth(v: number);
+    get health(): number;
+    set health(v: number);
+    static create(id: number, x: number, y: number, facing: number, scale: number, variation: number): Destructable | null;
+    static createZ(id: number, x: number, y: number, z: number, facing: number, scale: number, variation: number): Destructable | null;
+    static getInRange(x: number, y: number, range: number): Destructable[];
+    static getInRect(rect: ReadonlyRect): Destructable[];
+    static get onCreate(): Event<[Destructable]>;
+    static get onDestroy(): Event<[Destructable]>;
+    static readonly onDeath: TriggerEvent<[Destructable]>;
+    setAnimation(animation: string): void;
+    queueAnimation(animation: string): void;
+    restore(): void;
+    kill(): void;
+    get isAlive(): boolean;
+    get isDead(): boolean;
+}

package/core/types/destructable.lua

@@ -0,0 +1,245 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____event = require("event")
+local TriggerEvent = ____event.TriggerEvent
+local ____rect = require("core.types.rect")
+local Rect = ____rect.Rect
+local setRect = SetRect
+local getEnumDestructable = GetEnumDestructable
+local createDestructable = CreateDestructable
+local createDestructableZ = CreateDestructableZ
+local removeDestructable = RemoveDestructable
+local killDestructable = KillDestructable
+local setDestructableInvulnerable = SetDestructableInvulnerable
+local isDestructableInvulnerable = IsDestructableInvulnerable
+local enumDestructablesInRect = EnumDestructablesInRect
+local getDestructableTypeId = GetDestructableTypeId
+local getDestructableX = GetDestructableX
+local getDestructableY = GetDestructableY
+local setDestructableLife = SetDestructableLife
+local getDestructableLife = GetDestructableLife
+local setDestructableMaxLife = SetDestructableMaxLife
+local getDestructableMaxLife = GetDestructableMaxLife
+local destructableRestoreLife = DestructableRestoreLife
+local queueDestructableAnimation = QueueDestructableAnimation
+local setDestructableAnimation = SetDestructableAnimation
+local getDestructableName = GetDestructableName
+local enumRect = Rect:create(0, 0, 0, 0).handle
+____exports.Destructable = __TS__Class()
+local Destructable = ____exports.Destructable
+Destructable.name = "Destructable"
+__TS__ClassExtends(Destructable, Handle)
+function Destructable.prototype.onDestroy(self)
+    killDestructable(self.handle)
+    removeDestructable(self.handle)
+    return Handle.prototype.onDestroy(self)
+end
+function Destructable.create(self, id, x, y, facing, scale, variation)
+    return ____exports.Destructable:of(createDestructable(
+        id,
+        x,
+        y,
+        facing,
+        scale,
+        variation
+    ))
+end
+function Destructable.createZ(self, id, x, y, z, facing, scale, variation)
+    return ____exports.Destructable:of(createDestructableZ(
+        id,
+        x,
+        y,
+        z,
+        facing,
+        scale,
+        variation
+    ))
+end
+function Destructable.getInRange(self, x, y, range)
+    local collection = {}
+    setRect(
+        enumRect,
+        x - range,
+        y - range,
+        x + range,
+        y + range
+    )
+    enumDestructablesInRect(
+        enumRect,
+        nil,
+        function()
+            collection[#collection + 1] = ____exports.Destructable:of(getEnumDestructable())
+        end
+    )
+    return collection
+end
+function Destructable.getInRect(self, rect)
+    local collection = {}
+    enumDestructablesInRect(
+        rect.handle,
+        nil,
+        function()
+            collection[#collection + 1] = ____exports.Destructable:of(getEnumDestructable())
+        end
+    )
+    return collection
+end
+function Destructable.prototype.setAnimation(self, animation)
+    setDestructableAnimation(self.handle, animation)
+end
+function Destructable.prototype.queueAnimation(self, animation)
+    queueDestructableAnimation(self.handle, animation)
+end
+function Destructable.prototype.restore(self)
+    destructableRestoreLife(
+        self.handle,
+        getDestructableMaxLife(self.handle),
+        true
+    )
+end
+function Destructable.prototype.kill(self)
+    killDestructable(self.handle)
+end
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "typeId",
+    {get = function(self)
+        local typeId = getDestructableTypeId(self.handle)
+        rawset(self, "typeId", typeId)
+        return typeId
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "name",
+    {get = function(self)
+        return getDestructableName(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "x",
+    {get = function(self)
+        return getDestructableX(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "y",
+    {get = function(self)
+        return getDestructableY(self.handle)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "position",
+    {get = function(self)
+        return vec2(
+            getDestructableX(self.handle),
+            getDestructableY(self.handle)
+        )
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "isInvulnerable",
+    {
+        get = function(self)
+            return isDestructableInvulnerable(self.handle)
+        end,
+        set = function(self, isInvulnerable)
+            setDestructableInvulnerable(self.handle, isInvulnerable)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "maxHealth",
+    {
+        get = function(self)
+            return getDestructableMaxLife(self.handle)
+        end,
+        set = function(self, v)
+            setDestructableMaxLife(self.handle, v)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "health",
+    {
+        get = function(self)
+            return getDestructableLife(self.handle)
+        end,
+        set = function(self, v)
+            setDestructableLife(self.handle, v)
+        end
+    },
+    true
+)
+__TS__ObjectDefineProperty(
+    Destructable,
+    "onCreate",
+    {get = function(self)
+        return self.onCreateEvent
+    end}
+)
+__TS__ObjectDefineProperty(
+    Destructable,
+    "onDestroy",
+    {get = function(self)
+        return self.onDestroyEvent
+    end}
+)
+Destructable.onDeath = __TS__New(
+    TriggerEvent,
+    function(trigger)
+        local rect = GetWorldBounds()
+        enumDestructablesInRect(
+            rect,
+            nil,
+            function()
+                TriggerRegisterDeathEvent(
+                    trigger,
+                    getEnumDestructable()
+                )
+            end
+        )
+        RemoveRect(rect)
+        ____exports.Destructable.onCreate:addListener(function(destructable)
+            TriggerRegisterDeathEvent(trigger, destructable.handle)
+        end)
+    end,
+    function() return ____exports.Destructable:of(GetDyingDestructable()) end
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "isAlive",
+    {get = function(self)
+        return getDestructableLife(self.handle) > 0
+    end},
+    true
+)
+__TS__SetDescriptor(
+    Destructable.prototype,
+    "isDead",
+    {get = function(self)
+        return getDestructableLife(self.handle) <= 0
+    end},
+    true
+)
+return ____exports

package/core/types/effect.d.ts

@@ -0,0 +1,31 @@
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "./handle";
+import { Widget } from "./widget";
+import { PlayerColor } from "./playerColor";
+declare const enum EffectPropertyKey {
+    COLOR = 100,
+    PITCH = 101
+}
+export type EffectParameters = {
+    readonly scale?: number;
+    readonly color?: PlayerColor;
+};
+export declare class Effect extends Handle<jeffect> {
+    private [EffectPropertyKey.COLOR]?;
+    private [EffectPropertyKey.PITCH]?;
+    protected onDestroy(): HandleDestructor;
+    get color(): PlayerColor;
+    set color(color: PlayerColor);
+    get scale(): number;
+    set scale(scale: number);
+    get pitch(): number;
+    set pitch(pitch: number);
+    static create<T extends Effect>(this: typeof Effect & (new (handle: jeffect) => T), model: string, pos: Vec2): T;
+    static createTarget<T extends Effect>(this: typeof Effect & (new (handle: jeffect) => T), model: string, target: Widget, attachPoint: string): T;
+    static flash(modelPath: string, ...args: [
+        ...pointOrWidget: [x: number, y: number] | [widget: Widget, attachmentPoint: string],
+        ...parametersOrDuration: [parameters?: EffectParameters] | [duration?: number, parameters?: EffectParameters]
+    ]): void;
+    static flashTarget(model: string, target: Widget, attachPoint: string, duration?: number): void;
+}
+export {};

package/core/types/effect.lua

@@ -0,0 +1,209 @@
+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 dummyPlayer
+local ____handle = require("core.types.handle")
+local Handle = ____handle.Handle
+local ____playerColor = require("core.types.playerColor")
+local PlayerColor = ____playerColor.PlayerColor
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local ____pairs = _G.pairs
+local select = _G.select
+local mathRad = math.rad
+local addSpecialEffect = AddSpecialEffect
+local addSpecialEffectTarget = AddSpecialEffectTarget
+local destroyEffect = DestroyEffect
+local getSpecialEffectScale = BlzGetSpecialEffectScale
+local playSpecialEffect = BlzPlaySpecialEffect
+local setSpecialEffectScale = BlzSetSpecialEffectScale
+local setSpecialEffectPitch = BlzSetSpecialEffectPitch
+local setSpecialEffectColorByPlayer = BlzSetSpecialEffectColorByPlayer
+local specialEffectAddSubAnimation = BlzSpecialEffectAddSubAnimation
+local specialEffectClearSubAnimations = BlzSpecialEffectClearSubAnimations
+local specialEffectRemoveSubAnimation = BlzSpecialEffectRemoveSubAnimation
+local animTypeByAnimationName = {
+    attack = ANIM_TYPE_ATTACK,
+    birth = ANIM_TYPE_BIRTH,
+    death = ANIM_TYPE_DEATH,
+    decay = ANIM_TYPE_DECAY,
+    dissipate = ANIM_TYPE_DISSIPATE,
+    morph = ANIM_TYPE_MORPH,
+    portrait = ANIM_TYPE_PORTRAIT,
+    sleep = ANIM_TYPE_SLEEP,
+    spell = ANIM_TYPE_SPELL,
+    stand = ANIM_TYPE_STAND,
+    walk = ANIM_TYPE_WALK
+}
+local subAnimTypeByAnimationQualifier = {
+    alternate = SUBANIM_TYPE_ROOTED,
+    alternateex = SUBANIM_TYPE_ALTERNATE_EX,
+    chain = SUBANIM_TYPE_CHAINLIGHTNING,
+    channel = SUBANIM_TYPE_CHANNEL,
+    complete = SUBANIM_TYPE_COMPLETE,
+    critical = SUBANIM_TYPE_CRITICAL,
+    defend = SUBANIM_TYPE_DEFEND,
+    drain = SUBANIM_TYPE_DRAIN,
+    eattree = SUBANIM_TYPE_EATTREE,
+    fast = SUBANIM_TYPE_FAST,
+    fill = SUBANIM_TYPE_FILL,
+    flail = SUBANIM_TYPE_FLAIL,
+    flesh = SUBANIM_TYPE_FLESH,
+    fifth = SUBANIM_TYPE_FIFTH,
+    fire = SUBANIM_TYPE_FIRE,
+    first = SUBANIM_TYPE_FIRST,
+    five = SUBANIM_TYPE_FIVE,
+    four = SUBANIM_TYPE_FOUR,
+    fourth = SUBANIM_TYPE_FOURTH,
+    gold = SUBANIM_TYPE_GOLD,
+    hit = SUBANIM_TYPE_HIT,
+    large = SUBANIM_TYPE_LARGE,
+    left = SUBANIM_TYPE_LEFT,
+    light = SUBANIM_TYPE_LIGHT,
+    looping = SUBANIM_TYPE_LOOPING,
+    lumber = SUBANIM_TYPE_LUMBER,
+    medium = SUBANIM_TYPE_MEDIUM,
+    moderate = SUBANIM_TYPE_MODERATE,
+    off = SUBANIM_TYPE_OFF,
+    one = SUBANIM_TYPE_ONE,
+    puke = SUBANIM_TYPE_PUKE,
+    ready = SUBANIM_TYPE_READY,
+    right = SUBANIM_TYPE_RIGHT,
+    second = SUBANIM_TYPE_SECOND,
+    severe = SUBANIM_TYPE_SEVERE,
+    slam = SUBANIM_TYPE_SLAM,
+    small = SUBANIM_TYPE_SMALL,
+    spiked = SUBANIM_TYPE_SPIKED,
+    spin = SUBANIM_TYPE_SPIN,
+    swim = SUBANIM_TYPE_SWIM,
+    talk = SUBANIM_TYPE_TALK,
+    third = SUBANIM_TYPE_THIRD,
+    three = SUBANIM_TYPE_THREE,
+    throw = SUBANIM_TYPE_THROW,
+    two = SUBANIM_TYPE_TWO,
+    turn = SUBANIM_TYPE_TURN,
+    victory = SUBANIM_TYPE_VICTORY,
+    work = SUBANIM_TYPE_WORK,
+    wounded = SUBANIM_TYPE_WOUNDED,
+    upgrade = SUBANIM_TYPE_UPGRADE
+}
+local function setSpecialEffectColor(effect, color)
+    local dummyColor = dummyPlayer.color
+    dummyPlayer.color = color
+    setSpecialEffectColorByPlayer(effect, dummyPlayer.handle)
+    dummyPlayer.color = dummyColor
+end
+local setters = {scale = setSpecialEffectScale, color = setSpecialEffectColor}
+dummyPlayer = Player.neutralExtra
+local temporaryEffects = {}
+local temporaryEffectsDurations = {}
+local temporaryEffectsCount = 0
+local period = 1 / 32
+Timer.onPeriod[period]:addListener(function()
+    local i = 1
+    while i <= temporaryEffectsCount do
+        local duration = temporaryEffectsDurations[i]
+        if duration <= 0 then
+            destroyEffect(temporaryEffects[i])
+            temporaryEffects[i] = temporaryEffects[temporaryEffectsCount]
+            temporaryEffectsCount = temporaryEffectsCount - 1
+        else
+            temporaryEffectsDurations[i] = duration - period
+            i = i + 1
+        end
+    end
+end)
+____exports.Effect = __TS__Class()
+local Effect = ____exports.Effect
+Effect.name = "Effect"
+__TS__ClassExtends(Effect, Handle)
+function Effect.prototype.onDestroy(self)
+    destroyEffect(self.handle)
+    return Handle.prototype.onDestroy(self)
+end
+function Effect.create(self, model, pos)
+    return self:of(addSpecialEffect(model, pos.x, pos.y))
+end
+function Effect.createTarget(self, model, target, attachPoint)
+    return self:of(addSpecialEffectTarget(model, target.handle, attachPoint))
+end
+function Effect.flash(self, modelPath, xOrWidget, yOrOrAttachmentPoint, parametersOrDuration, parameters)
+    if type(parametersOrDuration) ~= "number" then
+        parameters = parametersOrDuration
+        parametersOrDuration = nil
+    end
+    local effect = type(xOrWidget) == "number" and addSpecialEffect(modelPath, xOrWidget, yOrOrAttachmentPoint) or addSpecialEffectTarget(modelPath, xOrWidget.handle, yOrOrAttachmentPoint)
+    if parameters ~= nil then
+        for key, value in ____pairs(parameters) do
+            setters[key](effect, value)
+        end
+    end
+    if parametersOrDuration ~= nil and parametersOrDuration > 0 then
+        temporaryEffectsCount = temporaryEffectsCount + 1
+        temporaryEffects[temporaryEffectsCount] = effect
+        temporaryEffectsDurations[temporaryEffectsCount] = parametersOrDuration
+        return
+    end
+    destroyEffect(effect)
+end
+function Effect.flashTarget(self, model, target, attachPoint, duration)
+    local effect = addSpecialEffectTarget(model, target.handle, attachPoint)
+    if effect ~= nil then
+        if duration and duration > 0 then
+            temporaryEffectsCount = temporaryEffectsCount + 1
+            temporaryEffects[temporaryEffectsCount] = effect
+            temporaryEffectsDurations[temporaryEffectsCount] = duration
+        else
+            destroyEffect(effect)
+        end
+    end
+end
+__TS__SetDescriptor(
+    Effect.prototype,
+    "color",
+    {
+        get = function(self)
+            return self[100] or PlayerColor.black
+        end,
+        set = function(self, color)
+            setSpecialEffectColor(self.handle, color)
+            self[100] = color
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Effect.prototype,
+    "scale",
+    {
+        get = function(self)
+            return getSpecialEffectScale(self.handle)
+        end,
+        set = function(self, scale)
+            setSpecialEffectScale(self.handle, scale)
+        end
+    },
+    true
+)
+__TS__SetDescriptor(
+    Effect.prototype,
+    "pitch",
+    {
+        get = function(self)
+            return self[101] or 0
+        end,
+        set = function(self, pitch)
+            setSpecialEffectPitch(
+                self.handle,
+                -mathRad(pitch)
+            )
+            self[101] = pitch
+        end
+    },
+    true
+)
+return ____exports