warscript 0.0.1-dev.bad60be → 0.0.1-dev.bc4cd10

package/utility/records.lua

@@ -1,9 +1,28 @@
 local ____exports = {}
+local ____pairs = _G.pairs
+local tableSort = table.sort
 ____exports.invertRecord = function(record)
     local invertRecord = {}
-    for key, value in pairs(record) do
+    for key, value in ____pairs(record) do
         invertRecord[value] = key
     end
     return invertRecord
 end
+local sortedKeysInternal = {}
+local lastSortedKeysLength = 0
+---
+-- @internal For use by internal systems only.
+____exports.sortedKeysUnnested = function(record)
+    local length = 0
+    for key in ____pairs(record) do
+        length = length + 1
+        sortedKeysInternal[length] = key
+    end
+    for i = length + 1, lastSortedKeysLength do
+        sortedKeysInternal[i] = nil
+    end
+    lastSortedKeysLength = length
+    tableSort(sortedKeysInternal)
+    return sortedKeysInternal
+end
 return ____exports

package/utility/types.d.ts

@@ -37,4 +37,7 @@ export type Flatten<T extends readonly any[], A extends readonly any[] = []> = T
 export type Prohibit<T, K extends keyof any> = T & {
     [P in K]?: never;
 };
+type TupleSplit<T, N extends number, O extends readonly any[] = readonly []> = O["length"] extends N ? [O, T] : T extends readonly [infer F, ...infer R] ? TupleSplit<readonly [...R], N, readonly [...O, F]> : [O, T];
+export type TakeFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[0];
+export type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[1];
 export {};

package/utility/unordered-map.d.ts

@@ -0,0 +1,27 @@
+/** @noSelfInFile */
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface ReadonlyUnorderedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    get(key: K): V | undefined;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    readonly size: number;
+}
+export interface UnorderedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __unorderedMap: unique symbol;
+}
+export declare class UnorderedMap<K extends AnyNotNil, V> implements ReadonlyUnorderedMap<K, V> {
+    private readonly v;
+    private s;
+    get(key: K): V | undefined;
+    getOrPut(key: K, defaultValue: (this: void) => V): V;
+    put(key: K, value: V): void;
+    remove(key: K): boolean;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    get size(): number;
+    protected __len(): number;
+    protected __pairs(this: UnorderedMap<K, V>): ReturnType<typeof pairs>;
+}
+export declare const emptyUnorderedMap: <K extends AnyNotNil, V>() => ReadonlyUnorderedMap<K, V>;
+export declare const mutableUnorderedMap: <K extends AnyNotNil, V>() => UnorderedMap<K, V>;
+export {};

package/utility/unordered-map.lua

@@ -0,0 +1,99 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____exception = require("exception")
+local UnsupportedOperationException = ____exception.UnsupportedOperationException
+____exports.UnorderedMap = __TS__Class()
+local UnorderedMap = ____exports.UnorderedMap
+UnorderedMap.name = "UnorderedMap"
+function UnorderedMap.prototype.____constructor(self)
+    self.v = {}
+    self.s = 0
+end
+function UnorderedMap.prototype.get(self, key)
+    return self.v[key]
+end
+function UnorderedMap.prototype.getOrPut(self, key, defaultValue)
+    local value = self.v[key]
+    if value ~= nil then
+        return value
+    end
+    value = defaultValue()
+    if value ~= nil then
+        self.v[key] = value
+        self.s = self.s + 1
+    end
+    return value
+end
+function UnorderedMap.prototype.put(self, key, value)
+    local has = self.v[key] ~= nil
+    self.v[key] = value
+    if value ~= nil and not has then
+        self.s = self.s + 1
+    elseif value == nil and has then
+        self.s = self.s - 1
+    end
+end
+function UnorderedMap.prototype.remove(self, key)
+    if self.v[key] ~= nil then
+        self.v[key] = nil
+        self.s = self.s - 1
+        return true
+    end
+    return false
+end
+function UnorderedMap.prototype.contains(self, key)
+    return self.v[key] ~= nil
+end
+function UnorderedMap.prototype.__len(self)
+    return self.s
+end
+function UnorderedMap.prototype.__pairs(self)
+    return pairs(self.v)
+end
+__TS__SetDescriptor(
+    UnorderedMap.prototype,
+    "size",
+    {get = function(self)
+        return self.s
+    end},
+    true
+)
+local EmptyUnorderedMap = __TS__Class()
+EmptyUnorderedMap.name = "EmptyUnorderedMap"
+__TS__ClassExtends(EmptyUnorderedMap, ____exports.UnorderedMap)
+function EmptyUnorderedMap.prototype.getOrPut(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyUnorderedMap.prototype.put(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyUnorderedMap.prototype.remove(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyUnorderedMap.prototype.__len(self)
+    return 0
+end
+function EmptyUnorderedMap.prototype.__pairs(self)
+    return pairs(self.v)
+end
+local EMPTY_UNORDERED_MAP = __TS__New(EmptyUnorderedMap)
+____exports.emptyUnorderedMap = function()
+    return EMPTY_UNORDERED_MAP
+end
+____exports.mutableUnorderedMap = function()
+    return __TS__New(____exports.UnorderedMap)
+end
+return ____exports

package/engine/internal/unit/item.lua

@@ -1,78 +0,0 @@
-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