warscript 0.0.1-dev.008d8ef

package/global/math.lua

@@ -0,0 +1,72 @@
+local min = math.min
+local max = math.max
+
+function math.clamp(x, a, b)
+    return min(max(x, a), b)
+end
+
+function math.sign(x)
+    return x >= 0 and 1 or -1
+end
+
+function math.lerp(a, b, t)
+    return a + (b - a) * t
+end
+
+do
+    local floor = math.floor
+    local insert = table.insert
+    local fcomp_default = function( a,b ) return a < b end
+    function table.bininsert(t, value, fcomp)
+        -- Initialise compare function
+        fcomp = fcomp or fcomp_default
+        --  Initialise numbers
+        local iStart,iEnd,iMid,iState = 1,#t,1,0
+        -- Get insert position
+        while iStart <= iEnd do
+            -- calculate middle
+            iMid = floor( (iStart+iEnd)/2 )
+            -- compare
+            if fcomp( value,t[iMid] ) then
+                iEnd,iState = iMid - 1,0
+            else
+                iStart,iState = iMid + 1,1
+            end
+        end
+        insert( t,(iMid+iState),value )
+        return (iMid+iState)
+    end
+end
+
+do
+    -- Avoid heap allocs for performance
+    local floor = math.floor
+    local fcomp_default = function( a,b ) return a < b end
+    function table.binsearch( tbl,value,fcomp)
+        -- Initialise functions
+        fcomp = fcomp or fcomp_default
+        --  Initialise numbers
+        local iStart,iEnd,iMid = 1,#tbl,0
+        -- Binary Search
+        while iStart <= iEnd do
+            -- calculate middle
+            iMid = floor( (iStart+iEnd)/2 )
+
+            if value == tbl[iMid] then
+                local len = #tbl
+                local s, e = iMid, iMid
+                while s > 1 and value == tbl[s - 1] do
+                    s = s - 1
+                end
+                while e < len and value == tbl[e + 1] do
+                    e = e + 1
+                end
+                return s, e
+            elseif fcomp( value,  tbl[iMid]) then
+                iEnd = iMid - 1
+            else
+                iStart = iMid + 1
+            end
+        end
+    end
+end

package/global/vec2.d.ts

@@ -0,0 +1,66 @@
+/** @noSelfInFile */
+
+declare interface Vec2 {
+    x: number
+    y: number
+    z: undefined | number
+}
+
+/** @noResolution */
+declare namespace vec2 {
+    const zero: Readonly<Vec2>
+    const one: Readonly<Vec2>
+    const up: Readonly<Vec2>
+    const down: Readonly<Vec2>
+    const left: Readonly<Vec2>
+    const right: Readonly<Vec2>
+    const maxinteger: Readonly<Vec2>
+    const mininteger: Readonly<Vec2>
+
+    const add: LuaAddition<Readonly<Vec2>, Readonly<Vec2>, Vec2>
+    const subtract: LuaSubtraction<Readonly<Vec2>, Readonly<Vec2>, Vec2>
+    const negate: LuaNegation<Readonly<Vec2>, Vec2>
+    const multiply: LuaMultiplication<Readonly<Vec2>, number, Vec2>
+    const divide: LuaDivision<Readonly<Vec2>, number, Vec2>
+
+    /** Gets the height of the terrain at the position specified by the vector. */
+    function terrainZ(vector: Readonly<Vec2>): number
+    /** Returns true if two vectors are approximately equal. */
+    function equals(a: Readonly<Vec2>, b: Readonly<Vec2>, eps?: number): number
+    /** Returns the magnitude of the vector. */
+    function magnitude(vector: Readonly<Vec2>): number
+    /** Returns the unsigned angle in degrees between from and to. */
+    function angle(from: Readonly<Vec2>, to: Readonly<Vec2>): number
+    /** Returns the distance between a and b. */
+    function distance(a: Readonly<Vec2>, b: Readonly<Vec2>): number
+    /** Dot Product of two vectors. */
+    function dot(a: Readonly<Vec2>, b: Readonly<Vec2>): number
+    /** Linearly interpolates between vectors a and b by t. */
+    function lerp(a: Readonly<Vec2>, b: Readonly<Vec2>, t: number): Vec2
+    /** Returns a vector that is made from the largest components of two vectors. */
+    function max(a: Readonly<Vec2>, b: Readonly<Vec2>): Vec2
+    /** Returns a vector that is made from the smallest components of two vectors. */
+    function min(a: Readonly<Vec2>, b: Readonly<Vec2>): Vec2
+    /** Returns a vector that is made from the largest integral values smaller than or equal to components of the vector. */
+    function floor(vector: Readonly<Vec2>): Vec2
+    /** Returns a vector that is made from the smallest integral values larger than or equal to components of the vector. */
+    function ceil(vector: Readonly<Vec2>): Vec2
+    /** Moves a point current towards target. */
+    function moveTowards(current: Vec2, target: Vec2, dist: number): Vec2
+    /** Gets a polar offset from this vector. Angle should be specified in degrees. */
+    function polarOffset(vector: Vec2, angle: number, dist: number): Vec2
+    /** Rotates this vector. Angle should be specified in degrees. */
+    function rotate(vector: Vec2, angle: number): Vec2
+    /** Returns the 2D vector perpendicular to this 2D vector.
+     * The result is always rotated 90-degrees in a counter-clockwise direction for a 2D coordinate system where the positive Y axis goes up. */
+    function perpendicular(inDirection: Readonly<Vec2>): Vec2
+    /** Reflects a vector off the vector defined by a normal. */
+    function reflect(inDirection: Readonly<Vec2>, inNormal: Readonly<Vec2>): Vec2
+    /** Multiplies two vectors component-wise. */
+    function scale(a: Readonly<Vec2>, b: Readonly<Vec2>): Vec2
+    /** Returns an independent copy of the vector. */
+    function copy(vector: Readonly<Vec2>): Vec2
+}
+
+/** @noResolution */
+declare function vec2(this: void, x?: number, y?: number): Vec2

package/global/vec2.lua

@@ -0,0 +1,160 @@
+local setmetatable = setmetatable
+local getmetatable = getmetatable
+local sqrt = math.sqrt
+local max = math.max
+local min = math.min
+local floor = math.floor
+local ceil = math.ceil
+local acos = math.acos
+local atan = math.atan
+local sin = math.sin
+local cos = math.cos
+local deg = math.deg
+local rad = math.rad
+local abs = math.abs
+
+local location = Location and Location(0, 0)
+local moveLocation = MoveLocation
+local getLocationZ = GetLocationZ
+
+local vec2 = {}
+
+local mt = {}
+
+local function new(x, y)
+    return setmetatable({x = x, y = y}, mt)
+end
+
+function mt.__eq(a, b)
+    return getmetatable(a) == mt and getmetatable(b) == mt and a.x == b.x and a.y == b.y
+end
+
+function mt.__unm(v)
+    return new(-v.x, -v.y)
+end
+
+function mt.__add(a, b)
+    return new(a.x + b.x, a.y + b.y)
+end
+
+function mt.__sub(a, b)
+    return new(a.x - b.x, a.y - b.y)
+end
+
+function mt.__mul(a, b)
+    return new(a.x * b, a.y * b)
+end
+
+function mt.__div(a, b)
+    return new(a.x / b, a.y / b)
+end
+
+function mt.__tostring(v)
+    return 'vec2('..v.x..', '..v.y..')'
+end
+
+function mt.__compiletime(v)
+    return '_G.vec2('..v.x..', '..v.y..')'
+end
+
+function vec2.terrainZ(v)
+    moveLocation(location, v.x, v.y)
+    return getLocationZ(location)
+end
+
+function vec2.equals(a, b, eps)
+    eps = eps or 1e-5
+    return abs(b.x - a.x) <= eps and abs(b.y - a.y) <= eps
+end
+
+function vec2.magnitude(v)
+    return sqrt(v.x * v.x + v.y * v.y)
+end
+
+function vec2.angle(a, b)
+    return deg(atan(b.y - a.y, b.x - a.x))
+    --local denominator = sqrt((a.x * a.x + a.y * a.y) * (b.x * b.x + b.y * b.y))
+    --if denominator < 1e-15 then
+    --    return 0
+    --end
+    --return deg(acos(min(max((a.x * b.x + a.y * b.y) / denominator, -1), 1)))
+end
+
+function vec2.distance(a, b)
+    local dx = b.x - a.x
+    local dy = b.y - a.y
+    return sqrt(dx * dx + dy * dy)
+end
+
+function vec2.dot(a, b)
+    return (a.x * b.x) + (a.y * b.y)
+end
+
+function vec2.lerp(a, b, t)
+    return new(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t)
+end
+
+function vec2.max(a, b)
+    return new(max(a.x, b.x), max(a.y, b.y))
+end
+
+function vec2.min(a, b)
+    return new(min(a.x, b.x), min(a.y, b.y))
+end
+
+function vec2.floor(v)
+    return new(floor(v.x), floor(v.y))
+end
+
+function vec2.ceil(v)
+    return new(ceil(v.x), ceil(v.y))
+end
+
+function vec2.moveTowards(a, b, dist)
+    local dx = b.x - a.x
+    local dy = b.y - a.y
+
+    local d = sqrt(dx * dx + dy * dy)
+
+    return d ~= 0 and new(a.x + dx / d * dist, a.y + dy / d * dist) or new(a.x + dist, a.y)
+end
+
+function vec2.polarOffset(v, angle, dist)
+    angle = rad(angle)
+    return new(v.x + cos(angle) * dist, v.y + sin(angle) * dist)
+end
+
+function vec2.rotate(v, angle)
+    angle = rad(angle)
+    local s = sin(angle)
+    local c = cos(angle)
+    return new(c * v.x - s * v.y, s * v.x + c * v.y)
+end
+
+function vec2.perpendicular(v)
+    return new(-v.y, v.x)
+end
+
+function vec2.reflect(v, n)
+    local f = -2 * ((n.x * v.x) + (n.y * v.y))
+    return new(f * n.x + v.x, f * n.y + v.y)
+end
+
+function vec2.scale(a, b)
+    return new(a.x * b.x, a.y * b.y)
+end
+
+function vec2.copy(v)
+    return new(v.x, v.y)
+end
+
+vec2.zero = new(0, 0)
+vec2.one = new(1, 1)
+vec2.up = new(0, 1)
+vec2.down = new(0, -1)
+vec2.left = new(-1, 0)
+vec2.right = new(1, 0)
+vec2.maxinteger = new(math.maxinteger, math.maxinteger)
+vec2.mininteger = new(math.mininteger, math.mininteger)
+
+_G.vec2 = setmetatable(vec2, { __call = function(_, x, y) return new(x or 0, y or 0) end })

package/index.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+import "./types";
+import "./patch-lualib";
+import "./patch-natives";
+import "./global/math";
+import "./global/vec2";
+import "./string";
+import "./core/util";

package/index.lua

@@ -0,0 +1,9 @@
+local ____exports = {}
+require("types")
+require("patch-lualib")
+require("patch-natives")
+require("global.math")
+require("global.vec2")
+require("string")
+require("core.util")
+return ____exports