Vector2.ttslua

require('ge_tts.License')

---
--- A 2D vector implementation.
---
--- Components can be accessed as x and y properties, or indexed by numbers [1] and [2].
---
---@class ge_tts__Vector2 : __ge_tts__NumCharVec2Shape<number>

---@shape ge_tts__CharVec2Shape
---@field x number
---@field y number

---@shape ge_tts__NumVec2Shape
---@field [1] number
---@field [2] number

---@alias ge_tts__Vec2Shape ge_tts__CharVec2Shape | ge_tts__NumVec2Shape

---@shape __ge_tts__NumCharVec2Shape<T>
---@field x T
---@field y T
---@field [1] T
---@field [2] T

---@shape ge_tts__NumCharVec2Shape : __ge_tts__NumCharVec2Shape<number>

---@param vector ge_tts__Vector2
---@param index any
local function numberedIndex(vector, index)
    if type(index) == 'number' then
        if index == 1 then
            return vector.x
        elseif index == 2 then
            return vector.y
        end

        return nil
    end
end

local DEGREES_RATIO = 180 / math.pi
local RADIANS_RATIO = math.pi / 180

---@class ge_tts__static_Vector2
---@overload fun(): ge_tts__Vector2
---@overload fun(x: number, y: number): ge_tts__Vector2
---@overload fun(source: ge_tts__Vec2Shape): ge_tts__Vector2
local Vector2 = {}

setmetatable(Vector2, {
    ---@param sourceXOrVector nil | __ge_tts__NumCharVec2Shape<nil | number>
    ---@param sourceY nil | number
    ---@return ge_tts__Vector2
    __call = function(_, sourceXOrVector, sourceY)
        local self = --[[---@type self]] {x = 0, y = 0}

        setmetatable(self, {
            __index = numberedIndex,
            __tostring = function(_)
                return self.toString()
            end,
        })

        if sourceXOrVector then
            if type(sourceXOrVector) == 'table' then
                local source = --[[---@type __ge_tts__NumCharVec2Shape<nil | number>]] sourceXOrVector

                self.x = source.x or source[1] or self.x
                self.y = source.y or source[2] or self.y
            else
                self.x = --[[---@type number]] sourceXOrVector
                self.y = --[[---@type number]] sourceY
            end
        end

        ---@return string
        function self.toString()
            return '{x = ' .. self.x .. ', y = ' .. self.y .. '}'
        end

        ---@return ge_tts__CharVec2Shape
        function self.toData()
            return {x = self.x, y = self.y}
        end

        ---@return number
        function self.lengthSquared()
            return Vector2.lengthSquared(self)
        end

        ---@return number
        function self.length()
            return Vector2.length(self)
        end

        ---Add a vector to self.
        ---@overload fun(v: ge_tts__Vec2Shape): self
        ---@param v ge_tts__NumCharVec2Shape
        ---@return self
        function self.add(v)
            self.x = self.x + (v.x or v[1])
            self.y = self.y + (v.y or v[2])
            return self
        end

        ---Subtract a vector from self.
        ---@overload fun(v: ge_tts__Vec2Shape): self
        ---@param v ge_tts__NumCharVec2Shape
        ---@return self
        function self.sub(v)
            self.x = self.x - (v.x or v[1])
            self.y = self.y - (v.y or v[2])
            return self
        end

        ---@param factor number | ge_tts__Vec2Shape
        ---@return self
        function self.scale(factor)
            if (type(factor) == 'number') then
                self.x = self.x * factor
                self.y = self.y * factor
            else
                self.x = self.x * ((--[[---@type ge_tts__CharVec2Shape]] factor).x or (--[[---@type ge_tts__NumVec2Shape]] factor)[1])
                self.y = self.y * ((--[[---@type ge_tts__CharVec2Shape]] factor).y or (--[[---@type ge_tts__NumVec2Shape]] factor)[2])
            end

            return self
        end

        ---@return self
        function self.normalize()
            return self.scale(1 / self.length())
        end

        ---@param angle number @angle in degrees
        ---@return self
        function self.rotate(angle)
            angle = angle * RADIANS_RATIO
            local x = self.x
            self.x = x * math.cos(angle) - self.y * math.sin(angle)
            self.y = x * math.sin(angle) + self.y * math.cos(angle)
            return self
        end

        return self
    end,
})

---@overload fun(v: ge_tts__Vec2Shape): number
---@param v ge_tts__NumCharVec2Shape
---@return number
function Vector2.x(v)
    return v.x or v[1]
end

---@overload fun(v: ge_tts__Vec2Shape): number
---@param v ge_tts__NumCharVec2Shape
---@return number
function Vector2.y(v)
    return v.y or v[2]
end

---@overload fun(v: ge_tts__Vec2Shape): number
---@param v ge_tts__NumCharVec2Shape
---@return number
function Vector2.lengthSquared(v)
    local x = v.x or v[1]
    local y = v.y or v[2]
    return x * x + y * y
end

---@param v ge_tts__Vec2Shape
---@return number
function Vector2.length(v)
    return math.sqrt(Vector2.lengthSquared(v))
end

---@param v1 ge_tts__Vec2Shape
---@param v2 ge_tts__Vec2Shape
---@return ge_tts__Vector2
function Vector2.add(v1, v2)
    return Vector2(v1).add(v2)
end

---@param v1 ge_tts__Vec2Shape
---@param v2 ge_tts__Vec2Shape
---@return ge_tts__Vector2
function Vector2.sub(v1, v2)
    return Vector2(v1).sub(v2)
end

---@param v ge_tts__Vec2Shape
---@param factor number | ge_tts__Vec2Shape
---@return ge_tts__Vector2
function Vector2.scale(v, factor)
    return Vector2(v).scale(factor)
end

---@param v ge_tts__Vec2Shape
---@return ge_tts__Vector2
function Vector2.normalize(v)
    return Vector2(v).normalize()
end

---@overload fun(v1: ge_tts__Vec2Shape, v2: ge_tts__Vec2Shape): number
---@param v1 ge_tts__NumCharVec2Shape
---@param v2 ge_tts__NumCharVec2Shape
---@return number
function Vector2.cross(v1, v2)
    local x1 = v1.x or v1[1]
    local y1 = v1.y or v1[2]

    local x2 = v2.x or v2[1]
    local y2 = v2.y or v2[2]

    return x1 * y2 - y1 * x2
end

--- Returns the angle between v1 and v2 in degrees.
---@overload fun(v1: ge_tts__Vec2Shape, v2: ge_tts__Vec2Shape): number
---@param v1 ge_tts__NumCharVec2Shape
---@param v2 ge_tts__NumCharVec2Shape
---@return number
function Vector2.angle(v1, v2)
    return DEGREES_RATIO * math.acos(Vector2.dot(v1, v2) / (Vector2.length(v1) * Vector2.length(v2)))
end

---@overload fun(v1: ge_tts__Vec2Shape, v2: ge_tts__Vec2Shape): number
---@param v1 ge_tts__NumCharVec2Shape
---@param v2 ge_tts__NumCharVec2Shape
---@return number
function Vector2.dot(v1, v2)
    local x1 = v1.x or v1[1]
    local y1 = v1.y or v1[2]

    local x2 = v2.x or v2[1]
    local y2 = v2.y or v2[2]

    return x1 * x2 + y1 * y2
end

---@overload fun(v1: ge_tts__Vec2Shape, v2: ge_tts__Vec2Shape): number
---@param v1 ge_tts__NumCharVec2Shape
---@param v2 ge_tts__NumCharVec2Shape
---@return number
function Vector2.distanceSquared(v1, v2)
    local x1 = v1.x or v1[1]
    local y1 = v1.y or v1[2]

    local x2 = v2.x or v2[1]
    local y2 = v2.y or v2[2]

    return Vector2.lengthSquared({x = x2 - x1, y = y2 - y1})
end

---@param v1 ge_tts__Vec2Shape
---@param v2 ge_tts__Vec2Shape
---@return number
function Vector2.distance(v1, v2)
    return math.sqrt(Vector2.distanceSquared(v1, v2))
end

---@overload fun(v: ge_tts__Vec2Shape, angle: number): ge_tts__Vector2
---@param v ge_tts__NumCharVec2Shape
---@param angle number @angle in degrees
---@return ge_tts__Vector2
function Vector2.rotate(v, angle)
    angle = angle * RADIANS_RATIO

    local x = v.x or v[1]
    local y = v.y or v[2]

    return Vector2(
        x * math.cos(angle) - y * math.sin(angle),
        x * math.sin(angle) + y * math.cos(angle)
    )
end

---@overload fun(v3: tts__VectorShape): ge_tts__Vector2
---@param v3 ge_tts__NumCharVec3
---@return ge_tts__Vector2
function Vector2.fromXZ(v3)
    return Vector2(v3.x or v3[1], v3.z or v3[3])
end

return Vector2