add

Quaternion.lua

@@ -1,4 +1,8 @@
 ---@class Quaternion
+---@field x number
+---@field y number
+---@field z number
+---@field w number
 local Quaternion = {}
 Quaternion.__index = Quaternion
 
@@ -7,14 +11,23 @@ function math.sign(x)
     return x < 0 and -1 or 1
   end
 
+---@param x number
+---@param y number
+---@param z number
+---@param w number
+---@return Quaternion
 function Quaternion.new(x, y, z, w)
   return setmetatable({ x = x or 0, y = y or 0, z = z or 0, w = w or 1 }, Quaternion)
 end
 
+---@return Quaternion
 function Quaternion:copy()
   return Quaternion.new(self.x, self.y, self.z, self.w)
 end
 
+---@param axis Vector3 | Vec3Like
+---@param angle number
+---@return Quaternion
 function Quaternion.fromAxisAngle(axis, angle)
   axis = axis:normalize()
   local halfAngle = angle * 0.5
@@ -27,20 +40,25 @@ function Quaternion.fromAxisAngle(axis, angle)
   )
 end
 
+---@return string
 function Quaternion:__tostring()
   return string.format("Quaternion(%.3f, %.3f, %.3f, %.3f)", self.x, self.y, self.z, self.w)
 end
 
+---@return number
 function Quaternion:length()
   return math.sqrt(self.x^2 + self.y^2 + self.z^2 + self.w^2)
 end
 
+---@return Quaternion
 function Quaternion:normalize()
   local len = self:length()
   if len == 0 then return Quaternion.new(0, 0, 0, 1) end
   return Quaternion.new(self.x / len, self.y / len, self.z / len, self.w / len)
 end
 
+---@param q Quaternion
+---@return Quaternion
 function Quaternion:mul(q)
   return Quaternion.new(
     self.w * q.x + self.x * q.w + self.y * q.z - self.z * q.y,
@@ -50,6 +68,7 @@ function Quaternion:mul(q)
   )
 end
 
+---@return table
 function Quaternion:toMatrix()
   local x, y, z, w = self.x, self.y, self.z, self.w
   return {
@@ -59,6 +78,9 @@ function Quaternion:toMatrix()
   }
 end
 
+---@return number
+---@return number
+---@return number
 function Quaternion:toEuler()
   local x, y, z, w = self.x, self.y, self.z, self.w
 
@@ -76,14 +98,23 @@ function Quaternion:toEuler()
   return roll, pitch, yaw
 end
 
+
+---@return table
 function Quaternion:toTable()
   return { x = self.x, y = self.y, z = self.z, w = self.w }
 end
 
+---@param t table
+---@return Quaternion
 function Quaternion.fromTable(t)
   return Quaternion.new(t.x, t.y, t.z, t.w)
 end
 
+
+---@param rx number
+---@param ry number
+---@param rz number
+---@return Quaternion
 function Quaternion.fromEuler(rx, ry, rz)
   local cy = math.cos(rz * 0.5)
   local sy = math.sin(rz * 0.5)
@@ -100,6 +131,9 @@ function Quaternion.fromEuler(rx, ry, rz)
   )
 end
 
+
+---@param v Vector3 | Vec3Like
+---@return table
 function Quaternion:rotateVector(v)
   local qvec = { x = self.x, y = self.y, z = self.z }
   local uv = {
@@ -120,6 +154,7 @@ function Quaternion:rotateVector(v)
   }
 end
 
+---@return Quaternion
 function Quaternion:conjugate()
   return Quaternion.new(-self.x, -self.y, -self.z, self.w)
 end

Vector2.lua

@@ -1,105 +1,160 @@
+---@alias Vec2Like { x: number, y: number}
+
 ---@class Vector2
+---@field x number
+---@field y number
+
+---@operator add: Vector2
+---@operator sub: Vector2
+
 local Vector2 = {}
 Vector2.__index = Vector2
 
+---@param x number
+---@param y number
+---@return Vector2
 function Vector2.new(x, y)
   return setmetatable({ x = x or 0, y = y or 0 }, Vector2)
 end
 
+---@return Vector2
 function Vector2:copy()
   return Vector2.new(self.x, self.y)
 end
 
+---@return string
 function Vector2:__tostring()
   return string.format("Vector2(%.3f, %.3f)", self.x, self.y)
 end
 
+---@param v Vector2 | Vec2Like
+---@return Vector2
 function Vector2:add(v)
   return Vector2.new(self.x + v.x, self.y + v.y)
 end
 
+---@param v Vector2 | Vec2Like
+---@return Vector2
 function Vector2:sub(v)
   return Vector2.new(self.x - v.x, self.y - v.y)
 end
 
+---@param scalar number
+---@return Vector2
 function Vector2:mul(scalar)
   return Vector2.new(self.x * scalar, self.y * scalar)
 end
 
+---@param scalar number | Vec2Like
+---@return Vector2
 function Vector2:div(scalar)
   return Vector2.new(self.x / scalar, self.y / scalar)
 end
 
+---@param self Vector2 | Vec2Like
+---@param v Vector2 | Vec2Like
+---@return Vector2
 function Vector2.__add(self, v)
   return Vector2.new(self.x + v.x, self.y + v.y)
 end
 
+---@param self Vector2 | Vec2Like
+---@param v Vector2 | Vec2Like
+---@return Vector2
 function Vector2.__sub(self, v)
   return Vector2.new(self.x - v.x, self.y - v.y)
 end
 
+---@return number
 function Vector2:length()
   return math.sqrt(self.x^2 + self.y^2)
 end
 
+---@return number
 function Vector2:lengthSq()
   return self.x^2 + self.y^2
 end
 
+---@param dx number
+---@return Vector2
 function Vector2:addX(dx)
     self.x = self.x + dx
     return self
 end
 
+---@param dy number
+---@return Vector2
 function Vector2:addY(dy)
     self.y = self.y + dy
     return self
 end
 
+---@return Vector2
 function Vector2:normalize()
   local len = self:length()
   if len == 0 then return Vector2.new(0, 0) end
   return Vector2.new(self.x / len, self.y / len)
 end
 
+---@param v Vector2 | Vec2Like
+---@return number
 function Vector2:dot(v)
   return self.x * v.x + self.y * v.y
 end
 
+---@param v Vector2 | Vec2Like
+---@return number
 function Vector2:distanceTo(v)
   return (self:sub(v)):length()
 end
 
+---@param v Vector2 | Vec2Like
+---@return number
 function Vector2:distanceToSq(v)
   return (self:sub(v)):lengthSq()
+
 end
 
+
+---@param v Vector2 | Vec2Like
+---@param epsilon number
+---@return boolean
 function Vector2:equals(v, epsilon)
   epsilon = epsilon or 1e-5
   return math.abs(self.x - v.x) < epsilon and
          math.abs(self.y - v.y) < epsilon
 end
 
+---@param func function
+---@return Vector2
 function Vector2:map(func)
   return Vector2.new(func(self.x), func(self.y))
 end
 
+---@return Vec2Like
 function Vector2:toTable()
   return { x = self.x, y = self.y }
 end
 
+---@param tbl Vec2Like
+---@return Vector2
 function Vector2.fromTable(tbl)
   return Vector2.new(tbl.x, tbl.y)
 end
 
+---@param tbl table
+---@return Vector2
 function Vector2.fromArray(tbl)
   return Vector2.new(tbl[1], tbl[2])
 end
 
+---@return table
 function Vector2:toArray()
     return {self.x, self.y}
 end
 
+---@return number
+---@return number
 function Vector2:unpack()
     return self.x, self.y
 end

Vector3.lua

@@ -1,62 +1,99 @@
+---@alias Vec3Like { x: number, y: number, z: number }
+---@alias Vec3 Vec3Like
+
 ---@class Vector3
+---@field x number
+---@field y number
+---@field z number
+
+---@operator add: Vector3
+---@operator sub: Vector3
+
 local Vector3 = {}
 Vector3.__index = Vector3
 
+
+---@param x number
+---@param y number
+---@param z number
+---@return Vector3
 function Vector3.new(x, y, z)
   return setmetatable({ x = x or 0, y = y or 0, z = z or 0 }, Vector3)
 end
 
+---@return Vector3
 function Vector3:copy()
   return Vector3.new(self.x, self.y, self.z)
 end
 
+---@return string
 function Vector3:__tostring()
   return string.format("Vector3(%.3f, %.3f, %.3f)", self.x, self.y, self.z)
 end
 
+---@param v Vector3 | Vec3Like
+---@return Vector3
 function Vector3:add(v)
   return Vector3.new(self.x + v.x, self.y + v.y, self.z + v.z)
 end
 
+---@param v Vector3 | Vec3Like
+---@return Vector3
 function Vector3:sub(v)
   return Vector3.new(self.x - v.x, self.y - v.y, self.z - v.z)
 end
 
+---@param scalar number
+---@return Vector3
 function Vector3:mul(scalar)
   return Vector3.new(self.x * scalar, self.y * scalar, self.z * scalar)
 end
 
+---@param scalar number
+---@return Vector3
 function Vector3:div(scalar)
   return Vector3.new(self.x / scalar, self.y / scalar, self.z / scalar)
 end
 
+---@param self Vector3 | Vec3Like
+---@param v Vector3 | Vec3Like
+---@return Vector3
 function Vector3.__add(self, v)
   return Vector3.new(self.x + v.x, self.y + v.y, self.z + v.z)
 end
 
+---@param self Vector3 | Vec3Like
+---@param v Vector3 | Vec3Like
+---@return Vector3
 function Vector3.__sub(self, v)
   return Vector3.new(self.x - v.x, self.y - v.y, self.z - v.z)
 end
 
+---@return number
 function Vector3:length()
   return math.sqrt(self.x^2 + self.y^2 + self.z^2)
 end
 
+---@return number
 function Vector3:lengthSq()
   return self.x^2 + self.y^2 + self.z^2
 end
 
+---@return Vector3
 function Vector3:normalize()
   local len = self:length()
   if len == 0 then return Vector3.new(0, 0, 0) end
   return Vector3.new(self.x / len, self.y / len, self.z / len)
 end
 
+---@param v Vector3 | Vec3Like
+---@return number
 function Vector3:dot(v)
   return self.x * v.x + self.y * v.y + self.z * v.z
 end
 
-
+---@param v Vector3 | Vec3Like
+---@return Vector3
 function Vector3:cross(v)
   return Vector3.new(
     self.y * v.z - self.z * v.y,
@@ -65,14 +102,21 @@ function Vector3:cross(v)
   )
 end
 
+---@param v Vector3 | Vec3Like
+---@return number
 function Vector3:distanceTo(v)
   return (self:sub(v)):length()
 end
 
+---@param v Vector3 | Vec3Like
+---@return number
 function Vector3:distanceToSq(v)
   return (self:sub(v)):lengthSq()
 end
 
+---@param v Vector3 | Vec3Like
+---@param epsilon number
+---@return boolean
 function Vector3:equals(v, epsilon)
   epsilon = epsilon or 1e-5
   return math.abs(self.x - v.x) < epsilon and
@@ -80,26 +124,37 @@ function Vector3:equals(v, epsilon)
          math.abs(self.z - v.z) < epsilon
 end
 
+---@param func function
+---@return Vector3
 function Vector3:map(func)
   return Vector3.new(func(self.x), func(self.y), func(self.z))
 end
 
+---@return table
 function Vector3:toTable()
   return { x = self.x, y = self.y, z = self.z }
 end
 
+---@param tbl Vec3Like | Vector3
+---@return Vector3
 function Vector3.fromTable(tbl)
   return Vector3.new(tbl.x, tbl.y, tbl.z)
 end
 
+---@param tbl table
+---@return Vector3
 function Vector3.fromArray(tbl)
   return Vector3.new(tbl[1], tbl[2], tbl[3])
 end
 
+---@return number
+---@return number
+---@return number
 function Vector3:unpack()
   return self.x, self.y, self.z
 end
 
+---@return Vec3Like
 function Vector3:toArray()
   return {self.x, self.y, self.z}
 end

packages.json

@@ -8,5 +8,14 @@
         "Quaternion.lua"
       ],
       "dependencies": []
+    },
+    "types": {
+      "base_url": "http://193.23.220.51:3000/p2vman/luastd/raw/branch/main/types",
+      "files": [
+        "Radar.lua"
+      ],
+      "dependencies": [
+        "std"
+      ]
     }
   }

types/PlayerDetector.lua

@@ -0,0 +1,27 @@
+---@class PlayerDetector
+local PlayerDetector = {}
+
+---@alias PPlayer {x: number, y: number, z: number, yaw: number, pitch: number, dimension: string, eyeHeight: number, health: number, maxHealth: number, airSupply: number, respawnPosition: Vec3, respawnDimension: string, respawnAngle: number}
+
+---@return string
+function PlayerDetector:getOnlinePlayers() end
+
+---@return PPlayer
+---@param name string
+function PlayerDetector:getPlayer(name) end
+
+---@return boolean
+---@param name string
+---@param range number
+function PlayerDetector:isPlayerInRange(range, name) end
+
+---@return string[]
+---@param range number
+function PlayerDetector:getPlayersInRange(range) end
+
+---@return string[]
+---@param x number
+---@param y number
+---@param z number
+function PlayerDetector:getPlayersInCubic(x,y,z) end
+

types/Radar.lua

@@ -0,0 +1,28 @@
+---@class Radar
+local Radar = {}
+
+---@alias Ship {is_ship: boolean, id : string, pos: Vec3, mass : number, rotation : Vec3, velocity : Vec3, size : number, scale : Vec3, center_of_mass_in_a_ship : Vec3, moment_of_inertia_tensor: number[][]}
+---@alias Entity {is_entity: boolean, pos: number[], eye_pos: number[], eye_height: number, look_angle: number[], dimension: string, entity_type: string, air_supply: number, max_air_supply: number}
+---@alias Player {is_player: boolean, pos: number[], eye_pos: number[], eye_height: number, look_angle: number[], dimension: string, entity_type: string, air_supply: number, max_air_supply: number, nickname: string, experience_level: number, xp_needed_for_next_level: number, experience_progress: number,health: number, max_health: number, armor_value: number, armor_cover_percentage: number, absorption_amount: number, is_baby: boolean, is_blocking: boolean, is_sleeping: boolean, is_fall_flying: boolean, speed: number, yHeadRot: number, yBodyRot: number}
+---@alias LivingEntity {health: number, max_health: number, armor_value: number, armor_cover_percentage: number, absorption_amount: number, is_baby: boolean, is_blocking: boolean, is_sleeping: boolean, is_fall_flying: boolean, speed: number, yHeadRot: number, yBodyRot: number}
+---@alias EntityType (Entity | Player | LivingEntity)
+
+---@param radius number
+---@return EntityType
+function Radar:scanForEntities(radius) end
+
+---@param radius number
+---@return (EntityType | Ship)[]
+function Radar:scan(radius) end
+
+---@param radius number
+---@return Ship[]
+function Radar:scanForShips(radius) end
+
+---@param radius number
+---@return Player
+function Radar:scanForPlayers(radius) end
+
+---@param radius number
+---@return table
+function Radar:getConfigInfo(radius) end