warscript 0.0.1-dev.f566ce7 → 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