warscript 0.0.1-dev.35997e2 → 0.0.1-dev.35f305e

package/engine/internal/unit/item.lua

@@ -0,0 +1,78 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
+local ____exports = {}
+local ____item = require("engine.internal.item")
+local Item = ____item.Item
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____utility = require("engine.internal.utility")
+local findUnitItemSlot = ____utility.findUnitItemSlot
+local ____add_2Ditem_2Dto_2Dslot = require("engine.internal.unit.add-item-to-slot")
+local unitAddItemToSlot = ____add_2Ditem_2Dto_2Dslot.unitAddItemToSlot
+local rawset = _G.rawset
+local ____type = _G.type
+local isItemPowerup = IsItemPowerup
+local setItemBooleanField = BlzSetItemBooleanField
+local unitInventorySize = UnitInventorySize
+local unitItemInSlot = UnitItemInSlot
+local unitRemoveItemFromSlot = UnitRemoveItemFromSlot
+local handleByUnitItems = setmetatable({}, {__mode = "k"})
+local function unitItemsNext(handle, index)
+    local slot = index & 7
+    if index >> 3 == slot then
+        return nil, nil
+    end
+    return index + 1, Item:of(unitItemInSlot(handle, slot))
+end
+____exports.UnitItems = __TS__Class()
+local UnitItems = ____exports.UnitItems
+UnitItems.name = "UnitItems"
+function UnitItems.prototype.____constructor(self, handle)
+    handleByUnitItems[self] = handle
+end
+function UnitItems.prototype.findSlot(self, item)
+    return findUnitItemSlot(handleByUnitItems[self], item.handle)
+end
+function UnitItems.prototype.__newindex(self, slot, item)
+    local handle = handleByUnitItems[self]
+    if slot < 1 or slot > unitInventorySize(handle) then
+        return
+    end
+    unitRemoveItemFromSlot(handle, slot - 1)
+    if item ~= nil then
+        local itemHandle = item.handle
+        local isPowerup = isItemPowerup(itemHandle)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, false)
+        end
+        unitAddItemToSlot(handle, itemHandle, slot - 1)
+        if isPowerup then
+            setItemBooleanField(itemHandle, ITEM_BF_USE_AUTOMATICALLY_WHEN_ACQUIRED, true)
+        end
+    end
+end
+function UnitItems.prototype.__index(self, key)
+    if ____type(key) == "number" then
+        return Item:of(unitItemInSlot(handleByUnitItems[self], key - 1))
+    end
+    return rawget(____exports.UnitItems.prototype, key)
+end
+function UnitItems.prototype.__len(self)
+    return unitInventorySize(handleByUnitItems[self])
+end
+function UnitItems.prototype.__ipairs(self)
+    local handle = handleByUnitItems[self]
+    return unitItemsNext, handle, unitInventorySize(handle) << 3
+end
+__TS__ObjectDefineProperty(
+    Unit.prototype,
+    "items",
+    {get = function(self)
+        local items = __TS__New(____exports.UnitItems, self.handle)
+        rawset(self, "items", items)
+        return items
+    end}
+)
+return ____exports

package/engine/internal/unit/main-selected.d.ts

@@ -0,0 +1,13 @@
+/** @noSelfInFile */
+import { Player } from "../../../core/types/player";
+import { Event } from "../../../event";
+declare module "../unit" {
+    namespace Unit {
+        const mainSelectedUnitChangeEvent: Event<[Player]>;
+    }
+}
+declare module "../unit" {
+    namespace Unit {
+        const getMainSelectedOf: (player: Player) => Unit | undefined;
+    }
+}

package/engine/internal/unit/main-selected.lua

@@ -0,0 +1,51 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____player = require("core.types.player")
+local Player = ____player.Player
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local MINIMUM_INTEGER = ____math.MINIMUM_INTEGER
+local ____local_2Dclient = require("engine.local-client")
+local LocalClient = ____local_2Dclient.LocalClient
+local ____unit = require("engine.internal.unit")
+local Unit = ____unit.Unit
+local ____event = require("event")
+local Event = ____event.Event
+local mainSelectedUnitChangeEvent = __TS__New(Event)
+rawset(Unit, "mainSelectedUnitChangeEvent", mainSelectedUnitChangeEvent)
+local mainSelectedUnitByPlayer = {}
+local syncSlider = BlzCreateFrameByType(
+    "SLIDER",
+    "UnitSyncId",
+    BlzGetOriginFrame(ORIGIN_FRAME_WORLD_FRAME, 0),
+    "",
+    0
+)
+BlzFrameSetMinMaxValue(syncSlider, MINIMUM_INTEGER, MAXIMUM_INTEGER)
+LocalClient.mainSelectedUnitChangeEvent:addListener(function()
+    local ____opt_0 = LocalClient.mainSelectedUnit
+    local syncId = ____opt_0 and ____opt_0.syncId
+    BlzFrameSetValue(syncSlider, syncId or 0)
+end)
+local trg = CreateTrigger()
+BlzTriggerRegisterFrameEvent(trg, syncSlider, FRAMEEVENT_SLIDER_VALUE_CHANGED)
+TriggerAddAction(
+    trg,
+    function()
+        local player = Player:of(GetTriggerPlayer())
+        local mainSelectedUnit = Unit:getBySyncId(BlzGetTriggerFrameValue())
+        if mainSelectedUnit ~= mainSelectedUnitByPlayer[player] then
+            mainSelectedUnitByPlayer[player] = mainSelectedUnit
+            Event.invoke(mainSelectedUnitChangeEvent, player)
+        end
+    end
+)
+rawset(
+    Unit,
+    "getMainSelectedOf",
+    function(player)
+        return mainSelectedUnitByPlayer[player]
+    end
+)
+return ____exports

package/engine/internal/unit+ability.lua

@@ -40,7 +40,7 @@ ItemAbility.onCreate:addListener(
         end
     end
 )
-Unit.onItemPickup:addListener(
+Unit.itemPickedUpEvent:addListener(
     0,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do
@@ -48,7 +48,7 @@ Unit.onItemPickup:addListener(
         end
     end
 )
-Unit.onItemDrop:addListener(
+Unit.itemDroppedEvent:addListener(
     4,
     function(unit, item)
         for ____, ability in ipairs(item.abilities) do

package/engine/internal/unit+damage.d.ts

@@ -1,15 +1,6 @@
 /** @noSelfInFile */
 import { Widget } from "../../core/types/widget";
-export type AttackType = jattacktype;
-export declare namespace AttackType {
-    const SPELL: jattacktype;
-    const NORMAL: jattacktype;
-    const PIERCE: jattacktype;
-    const SIEGE: jattacktype;
-    const MAGIC: jattacktype;
-    const CHAOS: jattacktype;
-    const HERO: jattacktype;
-}
+import { AttackType } from "../object-data/auxiliary/attack-type";
 export type DamageType = jdamagetype;
 export declare namespace DamageType {
     const UNKNOWN: jdamagetype;
@@ -64,6 +55,6 @@ export declare namespace WeaponType {
 }
 declare module "./unit" {
     interface Unit {
-        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType): boolean;
+        damageTarget(target: Widget, amount: number, attack?: boolean, ranged?: boolean, attackType?: AttackType, damageType?: DamageType, weaponType?: WeaponType, metadata?: unknown): boolean;
     }
 }

package/engine/internal/unit+damage.lua

@@ -7,21 +7,14 @@ local ____player = require("core.types.player")
 local Player = ____player.Player
 local ____dummy = require("objutil.dummy")
 local dummyUnitId = ____dummy.dummyUnitId
+local ____attack_2Dtype = require("engine.object-data.auxiliary.attack-type")
+local attackTypeToNative = ____attack_2Dtype.attackTypeToNative
+local ____damage_2Dmetadata_2Dby_2Dtarget = require("engine.internal.misc.damage-metadata-by-target")
+local damageMetadataByTarget = ____damage_2Dmetadata_2Dby_2Dtarget.damageMetadataByTarget
 local createUnit = CreateUnit
 local getOwningPlayer = GetOwningPlayer
 local showUnit = ShowUnit
 local unitDamageTarget = UnitDamageTarget
-____exports.AttackType = {}
-local AttackType = ____exports.AttackType
-do
-    AttackType.SPELL = ATTACK_TYPE_NORMAL
-    AttackType.NORMAL = ATTACK_TYPE_MELEE
-    AttackType.PIERCE = ATTACK_TYPE_PIERCE
-    AttackType.SIEGE = ATTACK_TYPE_SIEGE
-    AttackType.MAGIC = ATTACK_TYPE_MAGIC
-    AttackType.CHAOS = ATTACK_TYPE_CHAOS
-    AttackType.HERO = ATTACK_TYPE_HERO
-end
 ____exports.DamageType = {}
 local DamageType = ____exports.DamageType
 do
@@ -88,7 +81,7 @@ for ____, player in ipairs(Player.all) do
     showUnit(dummy, false)
     dummies[player] = dummy
 end
-Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType)
+Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, attackType, damageType, weaponType, metadata)
     if attack == nil then
         attack = false
     end
@@ -96,7 +89,7 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
         ranged = false
     end
     if attackType == nil then
-        attackType = ____exports.AttackType.SPELL
+        attackType = 0
     end
     if damageType == nil then
         damageType = ____exports.DamageType.MAGIC
@@ -109,13 +102,16 @@ Unit.prototype.damageTarget = function(self, target, amount, attack, ranged, att
     if not getOwningPlayer(handle) then
         handle = dummies[__TS__InstanceOf(target, Unit) and target.owner or (self._owner or Player.neutralAggressive)]
     end
+    if __TS__InstanceOf(target, Unit) then
+        damageMetadataByTarget[target] = metadata
+    end
     return unitDamageTarget(
         handle,
         targetHandle,
         amount,
         attack,
         ranged,
-        attackType,
+        attackTypeToNative(attackType),
         damageType,
         weaponType
     )

package/engine/internal/unit+spellSteal.lua

@@ -6,7 +6,6 @@ local ____exports = {}
 local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____unit_2Bdamage = require("engine.internal.unit+damage")
-local AttackType = ____unit_2Bdamage.AttackType
 local DamageType = ____unit_2Bdamage.DamageType
 local ____event = require("event")
 local Event = ____event.Event
@@ -33,7 +32,7 @@ local spellStealEventStack = {}
 Unit.onDamaging:addListener(function(source, target, event)
     if event.amount == 0 and source ~= nil then
         local count = countByUnit[source] or 0
-        if count > 0 and event.attackType == AttackType.SPELL then
+        if count > 0 and event.attackType == 0 then
             if event.damageType == DamageType.UNKNOWN then
                 spellStealEventStack[#spellStealEventStack + 1] = {
                     sourceBuffIds = source.buffIds,

package/engine/internal/unit+transport.lua

@@ -6,9 +6,8 @@ local ____unit = require("engine.internal.unit")
 local Unit = ____unit.Unit
 local ____event = require("event")
 local Event = ____event.Event
-local ____mapbounds = require("core.mapbounds")
-local boundMax = ____mapbounds.boundMax
-local boundRegion = ____mapbounds.boundRegion
+local ____game_2Dmap = require("engine.game-map")
+local GameMap = ____game_2Dmap.GameMap
 local eventInvoke = Event.invoke
 local tableRemove = table.remove
 local ____assert = _G.assert
@@ -58,8 +57,8 @@ triggerAddCondition(
             deboard(unit)
         end
         if not unitAlive(handle) then
-            unit.x = boundMax.x
-            unit.y = boundMax.y
+            unit.x = GameMap.worldBoundsRect.maxX
+            unit.y = GameMap.worldBoundsRect.maxY
         end
         local transport = Unit:of(getTransportUnit())
         transportByUnit[unit] = transport
@@ -68,11 +67,6 @@ triggerAddCondition(
         eventInvoke(onBoardEvent, unit, transport)
     end)
 )
-boundRegion.onUnitEnter:addListener(function(unit)
-    if transportByUnit[unit] ~= nil and not isUnitLoaded(unit.handle) then
-        deboard(unit)
-    end
-end)
 Unit.deathEvent:addListener(function(unit)
     if transportByUnit[unit] ~= nil then
         deboard(unit)

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

@@ -7,14 +7,33 @@ local ____event = require("event")
 local Event = ____event.Event
 local ____timer = require("core.types.timer")
 local Timer = ____timer.Timer
+local ____lua_2Dsets = require("utility.lua-sets")
+local luaSetOf = ____lua_2Dsets.luaSetOf
 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
+local instantOrderIds = luaSetOf(
+    orderId("avatar"),
+    orderId("berserk"),
+    orderId("divineshield"),
+    orderId("immolation"),
+    orderId("moveslot0"),
+    orderId("moveslot1"),
+    orderId("moveslot2"),
+    orderId("moveslot3"),
+    orderId("moveslot4"),
+    orderId("moveslot5"),
+    orderId("unavatar"),
+    orderId("undivineshield"),
+    orderId("unimmolation")
+)
+local function reset(source, orderId)
+    if not (instantOrderIds[orderId] ~= nil) then
+        local eventTimer = eventTimerByUnit[source]
+        if eventTimer then
+            eventTimer:destroy()
+            eventTimerByUnit[source] = nil
+        end
     end
 end
 Unit.onImmediateOrder:addListener(reset)
@@ -25,7 +44,7 @@ local function timerCallback(source, target)
     Event.invoke(autoAttackFinishEvent, source, target)
 end
 Unit.autoAttackStartEvent:addListener(function(source, target)
-    local attackPoint = source.weapons[1].impactDelay
+    local attackPoint = (source:chooseWeapon(target) or source.firstWeapon).impactDelay
     local timer = Timer:simple(attackPoint, timerCallback, source, target)
     eventTimerByUnit[source] = timer
 end)

package/engine/internal/unit.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@typescript-to-lua/language-extensions" />
 /** @noSelfInFile */
 import { Handle, HandleDestructor } from "../../core/types/handle";
 import { Player } from "../../core/types/player";
@@ -12,6 +11,10 @@ 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";
+import { MovementType } from "../object-data/auxiliary/movement-type";
+import { UnitAttribute } from "../object-data/auxiliary/unit-attribute";
+import { AttackType } from "../object-data/auxiliary/attack-type";
+import { AttributesHolder } from "../../attributes";
 export type UnitClassification = junittype;
 export declare namespace UnitClassification {
     const STRUCTURE: junittype;
@@ -20,6 +23,7 @@ export declare namespace UnitClassification {
     const GROUND: junittype;
     const SUMMONED: junittype;
     const MECHANICAL: junittype;
+    const WORKER: junittype;
     const ANCIENT: junittype;
     const SUICIDAL: junittype;
     const TAUREN: junittype;
@@ -37,14 +41,18 @@ 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 {
+export interface DamagingEvent extends AttributesHolder {
     amount: number;
-    attackType: jattacktype;
+    attackType: AttackType;
     damageType: jdamagetype;
     weaponType: jweapontype;
+    metadata: unknown;
     readonly isAttack: boolean;
+    readonly originalAmount: number;
+    readonly originalMetadata: unknown;
+    preventRetaliation(this: DamagingEvent): void;
 }
-export type DamageEvent = DamagingEvent & {
+export type DamageEvent = Omit<DamagingEvent, "preventRetaliation"> & {
     preventDeath<P extends any[]>(this: DamageEvent, callback: (this: void, ...parameters: P) => any, ...parameters: P): void;
 };
 export type AttackDamageEvent = DamagingEvent & {
@@ -76,6 +84,8 @@ export declare class UnitWeapon {
     set cooldown(cooldown: number);
     get damage(): [minimumDamage: number, maximumDamage: number];
     set damage([minimumDamage, maximumDamage]: [number, number]);
+    get allowedTargetCombatClassifications(): CombatClassifications;
+    set allowedTargetCombatClassifications(allowedTargetCombatClassifications: CombatClassifications);
     get damageBase(): number;
     set damageBase(damageBase: number);
     get damageDiceCount(): number;
@@ -94,20 +104,29 @@ export declare class UnitWeapon {
     set missileSpeed(missileSpeed: number);
 }
 declare const enum UnitPropertyKey {
-    IS_PAUSED = 100,
-    STUN_COUNTER = 101,
-    DELAY_HEALTH_CHECKS_COUNTER = 102,
-    DELAY_HEALTH_CHECKS_HEALTH_BONUS = 103,
-    PREVENT_DEATH_HEALTH_BONUS = 104,
-    IS_TEAM_GLOW_HIDDEN = 105
+    SYNC_ID = 100,
+    IS_PAUSED = 101,
+    STUN_COUNTER = 102,
+    DELAY_HEALTH_CHECKS_COUNTER = 103,
+    DELAY_HEALTH_CHECKS_HEALTH_BONUS = 104,
+    PREVENT_DEATH_HEALTH_BONUS = 105,
+    IS_TEAM_GLOW_HIDDEN = 106,
+    LAST_X = 107,
+    LAST_Y = 108
 }
+export type UnitSyncId = number & {
+    readonly __unitSyncId: unique symbol;
+};
 export declare class Unit extends Handle<junit> {
+    readonly syncId: UnitSyncId;
     private [UnitPropertyKey.IS_PAUSED]?;
     private [UnitPropertyKey.STUN_COUNTER]?;
     private [UnitPropertyKey.DELAY_HEALTH_CHECKS_COUNTER]?;
     private [UnitPropertyKey.DELAY_HEALTH_CHECKS_HEALTH_BONUS]?;
     private [UnitPropertyKey.PREVENT_DEATH_HEALTH_BONUS]?;
     private [UnitPropertyKey.IS_TEAM_GLOW_HIDDEN]?;
+    private [UnitPropertyKey.LAST_X]?;
+    private [UnitPropertyKey.LAST_Y]?;
     private _owner?;
     private _timeScale?;
     private events?;
@@ -128,6 +147,7 @@ export declare class Unit extends Handle<junit> {
     get isAlive(): boolean;
     get isDead(): boolean;
     get isIllusion(): boolean;
+    get isStunned(): boolean;
     get combatClassifications(): CombatClassifications;
     set combatClassifications(combatClassifications: CombatClassifications);
     hasCombatClassification(combatClassification: CombatClassification): boolean;
@@ -142,14 +162,18 @@ export declare class Unit extends Handle<junit> {
     isEnemyOf(unit: Unit): boolean;
     playAnimation(animation: string, rarity?: jraritycontrol): void;
     playAnimation(animation: number): void;
+    resetAnimation(): void;
     queueAnimation(animation: string): void;
     get weapons(): [UnitWeapon, UnitWeapon];
     get firstWeapon(): UnitWeapon;
     get secondWeapon(): UnitWeapon;
+    chooseWeapon(target: Unit): UnitWeapon | undefined;
     get level(): number;
     set level(v: number);
     get xp(): number;
     set xp(v: number);
+    get primaryAttribute(): UnitAttribute;
+    set primaryAttribute(primaryAttribute: UnitAttribute);
     get strengthBase(): number;
     set strengthBase(strengthBase: number);
     get strengthBonus(): number;
@@ -224,11 +248,13 @@ export declare class Unit extends Handle<junit> {
     set timeScale(v: number);
     get collisionSize(): number;
     get pathingCollisionRange(): number;
+    get movementType(): MovementType;
+    set movementType(movementType: MovementType);
     set pathing(v: boolean);
     isSelected(player: Player): boolean;
     explode(): void;
     kill(): void;
-    revive(pos: Vec2, doEffect: boolean): void;
+    revive(x: number, y: number, doEffect?: boolean): void;
     healTarget(target: Widget, amount: number): void;
     useItem(item: Item): boolean;
     issueImmediateOrder(order: number): boolean;
@@ -274,6 +300,7 @@ export declare class Unit extends Handle<junit> {
     get onUnitInRange(): Record<number, Event<[Unit]>>;
     get onManaEqual(): Record<number, Event<[Unit, number]>>;
     get manaEvent(): Record<Operator, Record<number, Event<[Unit]>>>;
+    get targetAcquiredEvent(): Event;
     get onSelect(): Event;
     get onDeselect(): Event;
     get onImmediateOrder(): Event<[number]>;
@@ -288,7 +315,7 @@ export declare class Unit extends Handle<junit> {
     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 getSelectionOf(player: Player, target?: Unit[]): Unit[];
     static readonly deathEvent: UnitTriggerEvent<[Unit]>;
     static readonly onDecay: UnitTriggerEvent<[]>;
     static readonly onResurrect: InitializingEvent<[Unit], void>;
@@ -323,9 +350,18 @@ export declare class Unit extends Handle<junit> {
     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 itemDroppedEvent: UnitTriggerEvent<[Item]>;
+    static itemPickedUpEvent: UnitTriggerEvent<[Item]>;
+    static itemUsedEvent: UnitTriggerEvent<[Item]>;
+    static itemStackedEvent: UnitTriggerEvent<[Item]>;
+    static get itemChargesChangedEvent(): Event<[unit: Unit, item: Item]>;
+    static get itemUseOrderEvent(): Event<[unit: Unit, item: Item]>;
+    static get itemMoveOrderEvent(): Event<[
+        unit: Unit,
+        item: Item,
+        slotFrom: 0 | 1 | 2 | 3 | 4 | 5,
+        slotTo: 0 | 1 | 2 | 3 | 4 | 5
+    ]>;
     static get onCreate(): EventDispatcher<[Unit], [Unit]>;
     static get destroyEvent(): EventDispatcher<[Unit], [Unit]>;
     getField(field: junitintegerfield | junitrealfield): number;
@@ -336,5 +372,6 @@ export declare class Unit extends Handle<junit> {
     setField(field: junitbooleanfield, value: boolean): boolean;
     setField(field: junitstringfield, value: string): boolean;
     toString(): string;
+    static getBySyncId(syncId: UnitSyncId): Unit | undefined;
 }
 export {};