warscript 0.0.1-dev.404878c

package/engine/internal/unit-missile-launch.lua

@@ -0,0 +1,32 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____event = require("event")
+local Event = ____event.Event
+local ____timer = require("core.types.timer")
+local Timer = ____timer.Timer
+local autoAttackFinishEvent = __TS__New(Event)
+rawset(Unit, "autoAttackFinishEvent", autoAttackFinishEvent)
+local eventTimerByUnit = {}
+local function reset(source)
+    local eventTimer = eventTimerByUnit[source]
+    if eventTimer then
+        eventTimer:destroy()
+        eventTimerByUnit[source] = nil
+    end
+end
+Unit.onImmediateOrder:addListener(reset)
+Unit.onPointOrder:addListener(reset)
+Unit.onTargetOrder:addListener(reset)
+local function timerCallback(source, target)
+    eventTimerByUnit[source] = nil
+    Event.invoke(autoAttackFinishEvent, source, target)
+end
+Unit.autoAttackStartEvent:addListener(function(source, target)
+    local attackPoint = source.weapons[1].attackPoint
+    local timer = Timer:simple(attackPoint, timerCallback, source, target)
+    eventTimerByUnit[source] = timer
+end)
+return ____exports

package/engine/internal/unit.d.ts

@@ -0,0 +1,312 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+import { Handle, HandleDestructor } from "../../core/types/handle";
+import { Player } from "../../core/types/player";
+import { ReadonlyRect } from "../../core/types/rect";
+import { Event, IgnoreEvent, InitializingEvent, TriggerEvent } from "../../event";
+import { Color } from "../../core/types/color";
+import { PlayerColor } from "../../core/types/playerColor";
+import { Item } from "./item";
+import { Destructable } from "../../core/types/destructable";
+import { Ability, UnitAbility } from "./ability";
+import { Widget } from "../../core/types/widget";
+import type { UnitTypeId } from "../object-data/entry/unit-type";
+import { CombatClassification, CombatClassifications } from "../object-data/auxiliary/combat-classification";
+export type UnitClassification = junittype;
+export declare namespace UnitClassification {
+    const STRUCTURE: junittype;
+    const UNDEAD: junittype;
+    const AIR: junittype;
+    const GROUND: junittype;
+    const SUMMONED: junittype;
+    const MECHANICAL: junittype;
+    const ANCIENT: junittype;
+    const SUICIDAL: junittype;
+    const TAUREN: junittype;
+    const RESISTANT: junittype;
+}
+type UnitCollector<T extends any[]> = () => LuaMultiReturn<[Unit, ...T]> | LuaMultiReturn<[IgnoreEvent]>;
+export declare class UnitTriggerEvent<T extends any[] = []> extends TriggerEvent<[Unit, ...T]> {
+    constructor(eventType: jplayerunitevent, c: UnitCollector<T>);
+}
+type DispatcherTable<T extends any[]> = {
+    readonly [id: number]: Event<T>;
+};
+type EventDispatcher<T extends any[], S extends any[]> = Event<T> & DispatcherTable<S>;
+type AbilityDispatcherTable<T extends any[] = []> = {
+    readonly [id: number]: Event<[Unit, Ability, ...T]>;
+};
+type AbilityEventDispatcher<T extends any[] = []> = Event<[Unit, Ability, ...T]> & AbilityDispatcherTable<T>;
+export interface DamagingEvent {
+    amount: number;
+    attackType: jattacktype;
+    damageType: jdamagetype;
+    weaponType: jweapontype;
+    readonly isAttack: boolean;
+}
+export type DamageEvent = DamagingEvent & {
+    preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
+};
+export type AttackDamageEvent = DamagingEvent & {
+    readonly isAttack: true;
+    readonly weapon: UnitWeapon;
+};
+export type AttackHandlerCondition = (source: Unit, target: Unit, event: Readonly<AttackDamageEvent>) => boolean;
+export type AttackHandlerAction = (source: Unit, target: Unit, event: AttackDamageEvent & {
+    fire(this: void): void;
+}) => void;
+export type AttackHandler = [AttackHandlerCondition, AttackHandlerAction];
+export declare const enum Operator {
+    LESS_THAN = 0,
+    LESS_THAN_OR_EQUAL = 1,
+    EQUAL = 2,
+    GREATER_THAN_OR_EQUAL = 3,
+    GREATER_THAN = 4,
+    NOT_EQUAL = 5
+}
+declare const modifiers: {
+    speed: (unit: junit, value: number) => void;
+    armor: (unit: junit, value: number) => void;
+};
+interface UnitWeapon {
+    readonly index: 0 | 1;
+    cooldown: number;
+    projectileArc: number;
+    projectileArt: string;
+    projectileSpeed: number;
+    attackPoint: number;
+}
+declare const enum UnitPropertyKey {
+    IS_PAUSED = 100,
+    STUN_COUNTER = 101,
+    PREVENT_DEATH_HEALTH_BONUS = 102,
+    IS_TEAM_GLOW_HIDDEN = 103
+}
+export declare class Unit extends Handle<junit> {
+    private [UnitPropertyKey.IS_PAUSED]?;
+    private [UnitPropertyKey.STUN_COUNTER]?;
+    private [UnitPropertyKey.PREVENT_DEATH_HEALTH_BONUS]?;
+    private [UnitPropertyKey.IS_TEAM_GLOW_HIDDEN]?;
+    private _owner?;
+    private _timeScale?;
+    private events?;
+    private _attackHandlers?;
+    private _eventsToDestroy?;
+    private _fields?;
+    private getEvent;
+    constructor(handle: junit);
+    protected onDestroy(): HandleDestructor;
+    addAttackHandler(condition: AttackHandlerCondition, action: AttackHandlerAction): AttackHandler;
+    removeAttackHandler(handler: AttackHandler): boolean;
+    private get _deltas();
+    addModifier(property: keyof typeof modifiers, modifier: (value: number) => number): Destroyable;
+    get skinId(): number;
+    set skinId(v: number);
+    get typeId(): UnitTypeId;
+    get isHero(): boolean;
+    get isAlive(): boolean;
+    get isDead(): boolean;
+    get isIllusion(): boolean;
+    get combatClassifications(): CombatClassifications;
+    set combatClassifications(combatClassifications: CombatClassifications);
+    hasCombatClassification(combatClassification: CombatClassification): boolean;
+    addClassification(classification: UnitClassification): boolean;
+    removeClassification(classification: UnitClassification): boolean;
+    hasClassification(classification: UnitClassification): boolean;
+    isVisibleTo(player: Player): boolean;
+    isInvisibleTo(player: Player): boolean;
+    isInRangeOf(x: number, y: number, range: number): boolean;
+    isInRangeOf(unit: Unit, range: number): boolean;
+    isAllyOf(unit: Unit): boolean;
+    isEnemyOf(unit: Unit): boolean;
+    playAnimation(animation: string, rarity?: jraritycontrol): void;
+    playAnimation(animation: number): void;
+    queueAnimation(animation: string): void;
+    get weapons(): [UnitWeapon, UnitWeapon];
+    get level(): number;
+    set level(v: number);
+    get xp(): number;
+    set xp(v: number);
+    get strengthBase(): number;
+    set strengthBase(strengthBase: number);
+    get strengthBonus(): number;
+    get strength(): number;
+    get agilityBase(): number;
+    set agilityBase(agilityBase: number);
+    get agilityBonus(): number;
+    get agility(): number;
+    get intelligenceBase(): number;
+    set intelligenceBase(intelligenceBase: number);
+    get intelligenceBonus(): number;
+    get intelligence(): number;
+    get name(): string;
+    set name(v: string);
+    get properName(): string;
+    set properName(v: string);
+    get isTeamGlowVisible(): boolean;
+    set isTeamGlowVisible(isTeamGlowVisible: boolean);
+    set color(color: PlayerColor);
+    get acquisitionRange(): number;
+    set acquisitionRange(v: number);
+    get maxHealth(): number;
+    set maxHealth(maxHealth: number);
+    get healthRegenerationRate(): number;
+    set healthRegenerationRate(healthRegenerationRate: number);
+    get maxMana(): number;
+    set maxMana(maxMana: number);
+    get health(): number;
+    set health(health: number);
+    get mana(): number;
+    set mana(mana: number);
+    get manaRegenerationRate(): number;
+    set manaRegenerationRate(manaRegenerationRate: number);
+    get armor(): number;
+    set armor(armor: number);
+    get facing(): number;
+    set facing(v: number);
+    get speed(): number;
+    set speed(v: number);
+    get flyHeight(): number;
+    set flyHeight(v: number);
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    get z(): number;
+    set xy(v: Vec2);
+    setPosition(x: number, y: number): void;
+    get position(): Vec2;
+    set position(v: Vec2);
+    get owner(): Player;
+    set owner(v: Player);
+    get goldCost(): number;
+    get lumberCost(): number;
+    /** The amount of gold left in the gold mine. */
+    get gold(): number;
+    set gold(gold: number);
+    get isPaused(): boolean;
+    set isPaused(isPaused: boolean);
+    get hidden(): boolean;
+    set hidden(v: boolean);
+    get isInvulnerable(): boolean;
+    get vertexColor(): Color;
+    set vertexColor(v: Color);
+    get scale(): number;
+    set scale(v: number);
+    get timeScale(): number;
+    set timeScale(v: number);
+    get collisionSize(): number;
+    get pathingCollisionRange(): number;
+    set pathing(v: boolean);
+    isSelected(player: Player): boolean;
+    explode(): void;
+    kill(): void;
+    revive(pos: Vec2, doEffect: boolean): void;
+    healTarget(target: Widget, amount: number): void;
+    useItem(item: Item): boolean;
+    issueImmediateOrder(order: number): boolean;
+    issuePointOrder(order: number, x: number, y: number): boolean;
+    issueTargetOrder(order: number, target: Destructable | Item | Unit): boolean;
+    queueImmediateOrder(order: number): boolean;
+    queuePointOrder(order: number, x: number, y: number): boolean;
+    queueTargetOrder(order: number, target: Destructable | Item | Unit): boolean;
+    addItem(item: Item): boolean;
+    dropItemTarget(item: Item, target: Widget): boolean;
+    dropItemSlot(item: Item, slot: number): boolean;
+    itemInSlot(slot: number): Item | null;
+    addAbility(abilityId: number): UnitAbility | null;
+    makeAbilityPermanent(abilityId: number, permanent: true): boolean;
+    setAbilityLevel(abilityId: number, level: number): number;
+    getAbilityLevel(abilityId: number): number;
+    hasAbility(abilityId: number): boolean;
+    getAbilityById(abilityId: number): UnitAbility | undefined;
+    removeAbility(abilityId: number): boolean;
+    hideAbility(abilityId: number, flag: boolean): void;
+    startAbilityCooldown(abilityId: number, cooldown: number): void;
+    endAbilityCooldown(abilityId: number): void;
+    interruptAttack(): void;
+    interruptCast(abilityId: number): void;
+    getDistanceTo(target: Unit | Vec2): number;
+    getCollisionDistanceTo(...target: [Unit] | [targetX: number, targetY: number]): number;
+    get buffIds(): number[];
+    resetCooldown(): void;
+    incrementDisableAutoAttackCounter(): void;
+    decrementDisableAutoAttackCounter(): void;
+    /** @deprecated Use incrementStunCounter. */
+    pauseEx(): void;
+    /** @deprecated Use decrementStunCounter. */
+    unpauseEx(): void;
+    incrementStunCounter(): void;
+    decrementStunCounter(): void;
+    set waygateActive(v: boolean);
+    get waygateActive(): boolean;
+    set waygateDestination(v: Vec2);
+    get waygateDestination(): Vec2;
+    get abilities(): ReadonlyArray<UnitAbility>;
+    get onUnitInRange(): Record<number, Event<[Unit]>>;
+    get onManaEqual(): Record<number, Event<[Unit, number]>>;
+    get manaEvent(): Record<Operator, Record<number, Event<[Unit]>>>;
+    get onSelect(): Event;
+    get onDeselect(): Event;
+    get onImmediateOrder(): Event<[number]>;
+    get onPointOrder(): Event<[number]>;
+    get onTargetOrder(): Event<[number, Unit | Item | Destructable]>;
+    get onSpellEffect(): Event<[number]>;
+    static create<T extends Unit>(this: typeof Unit & (new (handle: junit) => T), owner: Player, id: number, x: number, y: number, facing: number, skinId?: number): T | null;
+    static forAll(consumer: (unit: Unit) => any): void;
+    static getAll(predicate?: (unit: Unit) => boolean): Unit[];
+    static getOwnedBy(player: Player, predicate?: (unit: Unit) => boolean): Unit[];
+    static getInRect(rect: ReadonlyRect, predicate?: (unit: Unit) => boolean): Unit[];
+    static getInRange(x: number, y: number, range: number, predicate?: (unit: Unit) => boolean): Unit[];
+    static getInCollisionRange(x: number, y: number, range: number, predicate?: (unit: Unit) => boolean): Unit[];
+    static getInSector(pos: Vec2, range: number, offsetAngle: number, centralAngle: number): Unit[];
+    static getSelectionOf(player: Player): Unit[];
+    static readonly deathEvent: UnitTriggerEvent<[Unit]>;
+    static readonly onDecay: UnitTriggerEvent<[]>;
+    static readonly onResurrect: InitializingEvent<[Unit], void>;
+    static readonly morphEvent: InitializingEvent<[Unit], void>;
+    static readonly onOwnerChange: UnitTriggerEvent<[Player]>;
+    static readonly onSelect: UnitTriggerEvent<[Player]>;
+    static readonly onDeselect: UnitTriggerEvent<[Player]>;
+    static readonly constructionStartEvent: UnitTriggerEvent<[]>;
+    static readonly onUpgradeFinish: UnitTriggerEvent<[]>;
+    static readonly onSpellEffect: EventDispatcher<[Unit, number], [Unit]>;
+    static readonly onTargetCast: EventDispatcher<[Unit, number, Item | Unit | Destructable], [Unit, Item | Unit | Destructable]>;
+    static readonly onCastPrepare: AbilityEventDispatcher<[]>;
+    static readonly onCast: AbilityEventDispatcher<[]>;
+    static readonly onPointCastPrepare: AbilityEventDispatcher<[number, number]>;
+    static readonly onUnitTargetCastPrepare: AbilityEventDispatcher<[Unit]>;
+    static readonly onUnitTargetCast: AbilityEventDispatcher<[Unit]>;
+    static readonly onPointCast: AbilityEventDispatcher<[number, number]>;
+    static readonly onCastStart: AbilityEventDispatcher<[]>;
+    static readonly onUnitTargetCastStart: AbilityEventDispatcher<[Unit]>;
+    static readonly onCastFinish: AbilityEventDispatcher<[]>;
+    static readonly onCastStop: AbilityEventDispatcher<[]>;
+    static readonly onImmediateOrder: EventDispatcher<[Unit, number], [Unit]>;
+    static readonly onTargetOrder: EventDispatcher<[
+        Unit,
+        number,
+        Unit | Destructable | Item
+    ], [
+        Unit,
+        Unit | Destructable | Item
+    ]>;
+    static readonly onPointOrder: EventDispatcher<[Unit, number, number, number], [Unit, number, number]>;
+    static readonly autoAttackStartEvent: UnitTriggerEvent<[Unit]>;
+    static readonly onDamaging: Event<[source: Unit | undefined, target: Unit, event: DamagingEvent]>;
+    static readonly onDamage: InitializingEvent<[source: Unit | undefined, target: Unit, event: DamageEvent], jtrigger>;
+    static onItemDrop: UnitTriggerEvent<[Item]>;
+    static onItemPickup: UnitTriggerEvent<[Item]>;
+    static onItemUse: UnitTriggerEvent<[Item]>;
+    static get onCreate(): EventDispatcher<[Unit], [Unit]>;
+    static get destroyEvent(): EventDispatcher<[Unit], [Unit]>;
+    getField(field: junitintegerfield | junitrealfield): number;
+    getField(field: junitbooleanfield): boolean;
+    getField(field: junitstringfield): string;
+    setField(field: junitintegerfield, value: number): boolean;
+    setField(field: junitrealfield, value: number): boolean;
+    setField(field: junitbooleanfield, value: boolean): boolean;
+    setField(field: junitstringfield, value: string): boolean;
+    toString(): string;
+}
+export {};