warscript 0.0.1-dev.f5421e8 → 0.0.1-dev.f594e71

package/utility/random.lua

@@ -0,0 +1,273 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____exception = require("exception")
+local IllegalArgumentException = ____exception.IllegalArgumentException
+local ____math = require("math")
+local MAXIMUM_INTEGER = ____math.MAXIMUM_INTEGER
+local PI = ____math.PI
+local cos = ____math.cos
+local sin = ____math.sin
+local sqrt = ____math.sqrt
+local clock = os.clock
+local time = os.time
+local byte = string.byte
+local pack = string.pack
+local ____unpack = string.unpack
+local select = _G.select
+local toString = _G.tostring
+local globals = _G
+local UINT32_MASK = 4294967295
+local POW_2_32 = 4294967296
+--- 2^26, used to join two draws into a 53-bit mantissa.
+local POW_2_26 = 67108864
+--- 2^53, the amount of representable values of a 53-bit mantissa.
+local POW_2_53 = 9007199254740992
+local GOLDEN_RATIO_32 = 2654435769
+local FNV_PRIME_32 = 16777619
+--- The SplitMix32 finalizer: avalanches a 32-bit value.
+local function mix(value)
+    local z = value & UINT32_MASK
+    z = (z ~ z >> 16) * 569420461 & UINT32_MASK
+    z = (z ~ z >> 15) * 1935289751 & UINT32_MASK
+    return (z ~ z >> 15) & UINT32_MASK
+end
+--- Folds the bytes of `value` into `hash` (FNV-1a).
+local function hashString(hash, value)
+    for i = 1, #value do
+        hash = (hash ~ byte(value, i)) * FNV_PRIME_32 & UINT32_MASK
+    end
+    return hash
+end
+--- Folds the exact bit pattern of `value` into `hash`, without assuming it is an integer.
+local function hashNumber(hash, value)
+    local low, high = ____unpack(
+        "<i4i4",
+        pack("<d", value)
+    )
+    return mix(mix(hash ~ low & UINT32_MASK) ~ high & UINT32_MASK)
+end
+local entropyCounter = 0
+--- Gathers 32 bits of client-local entropy.
+-- 
+-- Every source is local by nature: the wall clock and the process CPU time drift apart between
+-- machines, and the heap addresses of freshly allocated tables and of loaded code differ between
+-- processes. The CPU time is read once more at the end, so that the time the gathering itself took
+-- contributes as well.
+local function collectEntropy()
+    entropyCounter = entropyCounter + 1
+    local entropy = mix(GOLDEN_RATIO_32 ~ entropyCounter)
+    entropy = mix(entropy ~ time() & UINT32_MASK)
+    entropy = hashNumber(
+        entropy,
+        clock()
+    )
+    entropy = mix(hashString(
+        entropy,
+        toString({})
+    ))
+    entropy = mix(hashString(
+        entropy,
+        toString({})
+    ))
+    entropy = mix(hashString(
+        entropy,
+        toString(globals)
+    ))
+    entropy = mix(hashString(
+        entropy,
+        toString(mix)
+    ))
+    return hashNumber(
+        entropy,
+        clock()
+    )
+end
+--- A client-local pseudorandom generator that is safe to advance inside a local block.
+-- 
+-- Instances are independent of each other and of the game's synchronous randomness.
+____exports.AsyncRandom = __TS__Class()
+local AsyncRandom = ____exports.AsyncRandom
+AsyncRandom.name = "AsyncRandom"
+function AsyncRandom.prototype.____constructor(self, seed)
+    self.a = 0
+    self.b = 0
+    self.c = 0
+    self.d = 0
+    self:setSeed(seed or collectEntropy())
+end
+function AsyncRandom.prototype.setSeed(self, seed)
+    local z = hashNumber(GOLDEN_RATIO_32, seed)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local a = mix(z)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local b = mix(z)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local c = mix(z)
+    z = z + GOLDEN_RATIO_32 & UINT32_MASK
+    local d = mix(z)
+    self.a = a
+    self.b = b
+    self.c = c
+    self.d = a | b | c | d ~= 0 and d or GOLDEN_RATIO_32
+end
+function AsyncRandom.prototype.addEntropy(self, value)
+    local entropy = collectEntropy()
+    if type(value) == "number" then
+        entropy = hashNumber(entropy, value)
+    elseif value ~= nil then
+        entropy = hashString(entropy, value)
+    end
+    local a = self.a ~ mix(entropy)
+    local b = self.b ~ mix(a)
+    local c = self.c ~ mix(b)
+    local d = self.d ~ mix(c)
+    self.a = a
+    self.b = b
+    self.c = c
+    self.d = a | b | c | d ~= 0 and d or GOLDEN_RATIO_32
+    self:next()
+end
+function AsyncRandom.prototype.next(self)
+    local a = self.a
+    local b = self.b
+    local result = b * 5 & UINT32_MASK
+    result = (result << 7 | result >> 25) & UINT32_MASK
+    result = result * 9 & UINT32_MASK
+    local t = b << 9 & UINT32_MASK
+    local c = self.c ~ a
+    local d = self.d ~ b
+    self.a = a ~ d
+    self.b = b ~ c
+    self.c = c ~ t
+    self.d = (d << 11 | d >> 21) & UINT32_MASK
+    return result
+end
+function AsyncRandom.prototype.nextBounded(self, bound)
+    if bound <= 1 then
+        return 0
+    end
+    local limit = POW_2_32 - POW_2_32 % bound
+    local value = self:next()
+    while value >= limit do
+        value = self:next()
+    end
+    return value % bound
+end
+function AsyncRandom.prototype.nextBits(self, bitCount)
+    return self:next() >> 32 - bitCount
+end
+function AsyncRandom.prototype.nextInteger(self, m, n)
+    local lowerBound = n ~= nil and m or 0
+    local upperBound = n ~= nil and n or (m or MAXIMUM_INTEGER)
+    if upperBound < lowerBound then
+        error(
+            __TS__New(
+                IllegalArgumentException,
+                ((("Upper bound (" .. tostring(upperBound)) .. ") is less than lower bound (") .. tostring(lowerBound)) .. ")."
+            ),
+            0
+        )
+    end
+    return lowerBound + self:nextBounded(upperBound - lowerBound + 1)
+end
+function AsyncRandom.prototype.nextFloat(self, m, n)
+    local high = self:next() >> 5
+    local low = self:next() >> 6
+    local value = (high * POW_2_26 + low) / POW_2_53
+    return n ~= nil and m + value * (n - m) or value * (m or MAXIMUM_INTEGER)
+end
+function AsyncRandom.prototype.nextBoolean(self, probability)
+    local ____temp_0
+    if probability == nil then
+        ____temp_0 = self:next() >> 31 ~= 0
+    else
+        ____temp_0 = self:nextFloat() < probability
+    end
+    return ____temp_0
+end
+function AsyncRandom.prototype.nextAngle(self)
+    return self:nextFloat() * 360
+end
+function AsyncRandom.prototype.nextXY(self, centerX, centerY, range)
+    local r = range * sqrt(self:nextFloat())
+    local t = self:nextFloat() * 2 * PI
+    return centerX + r * cos(t), centerY + r * sin(t)
+end
+function AsyncRandom.prototype.nextElement(self, array)
+    local length = #array
+    local ____temp_1
+    if length ~= 0 then
+        ____temp_1 = array[self:nextBounded(length) + 1]
+    else
+        ____temp_1 = nil
+    end
+    return ____temp_1
+end
+function AsyncRandom.prototype.nextOf(self, ...)
+    local count = select("#", ...)
+    local ____temp_2
+    if count ~= 0 then
+        ____temp_2 = (select(
+            self:nextBounded(count) + 1,
+            ...
+        ))
+    else
+        ____temp_2 = nil
+    end
+    return ____temp_2
+end
+function AsyncRandom.prototype.shuffle(self, array)
+    for i = #array - 1, 1, -1 do
+        local j = self:nextBounded(i + 1)
+        local value = array[i + 1]
+        array[i + 1] = array[j + 1]
+        array[j + 1] = value
+    end
+end
+local defaultAsyncRandom
+local function getDefaultAsyncRandom()
+    defaultAsyncRandom = defaultAsyncRandom or __TS__New(____exports.AsyncRandom)
+    return defaultAsyncRandom
+end
+--- Folds freshly gathered client-local entropy, optionally together with the given `value`,
+-- into the state of the generator backing the `asyncRandom*` functions.
+____exports.addAsyncRandomEntropy = function(value)
+    getDefaultAsyncRandom():addEntropy(value)
+end
+--- Returns the given amount (`0` to `32`) of random bits as a non-negative integer.
+____exports.asyncRandomBits = function(bitCount)
+    return getDefaultAsyncRandom():nextBits(bitCount)
+end
+--- Returns a uniformly distributed integer, both bounds being inclusive:
+-- in `[0, upperBound]` when called with a single bound, in `[lowerBound, upperBound]` otherwise.
+____exports.asyncRandomInteger = function(m, n) return n ~= nil and getDefaultAsyncRandom():nextInteger(m, n) or getDefaultAsyncRandom():nextInteger(m) end
+--- Returns a uniformly distributed float with 53 bits of precision, the upper bound being exclusive:
+-- in `[0, upperBound)` when called with a single bound, in `[lowerBound, upperBound)` otherwise.
+____exports.asyncRandomFloat = function(m, n) return n ~= nil and getDefaultAsyncRandom():nextFloat(m, n) or getDefaultAsyncRandom():nextFloat(m) end
+--- Returns `true` with the given `probability`, or with a probability of one half by default.
+____exports.asyncRandomBoolean = function(probability)
+    return getDefaultAsyncRandom():nextBoolean(probability)
+end
+--- Returns a uniformly distributed angle in degrees, in `[0, 360)`.
+____exports.asyncRandomAngle = function()
+    return getDefaultAsyncRandom():nextAngle()
+end
+--- Returns a uniformly distributed point within `range` of the given center.
+____exports.asyncRandomXY = function(centerX, centerY, range)
+    return getDefaultAsyncRandom():nextXY(centerX, centerY, range)
+end
+--- Returns a uniformly distributed element of the given `array`.
+____exports.asyncRandomElement = function(array)
+    return getDefaultAsyncRandom():nextElement(array)
+end
+--- Returns a uniformly distributed one of the given `elements`.
+____exports.asyncRandom = function(...)
+    return getDefaultAsyncRandom():nextOf(...)
+end
+--- Shuffles the given `array` in place, each permutation being equally likely.
+____exports.asyncShuffle = function(array)
+    getDefaultAsyncRandom():shuffle(array)
+end
+return ____exports

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/core/types/order.d.ts

@@ -1,25 +0,0 @@
-/** @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

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