Math
vec2
vec2(number, number)
vec2(vec2)
local a = vec2(player.x, player.z)
local b = vec2(a)
a:print()
b:print()v1:dot(v2)
Parameters
vec2 v1
vec2 v2
Return Value
number returns dot product
local a = player.pos2D:dot(mousePos2D)
print(a)v1:cross(v2)
Parameters
vec2 v1
vec2 v2
Return Value
number returns cross product
local a = player.pos2D:cross(mousePos2D)
print(a)v1:len()
Parameters
vec2 v1
Return Value
number returns length of v1
local a = mousePos2D - player.pos2D
local b = a:len()
print(b)v1:lenSqr()
Parameters
vec2 v1
Return Value
number returns squared length of v1
local a = mousePos2D - player.pos2D
local b = a:lenSqr()
print(b)v1:norm()
Parameters
vec2 v1
Return Value
vec2 returns normalized v1
local a = mousePos2D - player.pos2D
local b = a:norm()
b:print()v1:extend(to, range)
Parameters
vec2 to
number range
Return Value
vec2 returns extended vec
local a = player.pos2D:extend(mousePos2D, 100)
a:print()v1:dist(v2)
Parameters
vec2 v1
vec2 v2
Return Value
number returns distance between v1 and v2
local a = mousePos2D:dist(player.pos2D)
print(a)v1:distSqr(v2)
Parameters
vec2 v1
vec2 v2
Return Value
number returns squared distance between v1 and v2
local a = mousePos2D:distSqr(player.pos2D)
print(a)v1:distLine(A, B)
Parameters
vec2 v1
vec2 A
vec2 B
Return Value
number returns distance between v1 and line: A to B
v1:inRange(v2, range)
Parameters
vec2 v1
vec2 v2
number range
Return Value
number returns whether v2 in area from v1 to range
v1:isOnLineSegment(a, b)
Parameters
vec2 v1
vec2 a
vec2 b
number range
Return Value
number returns whether v1 in line segment
v1:projectOnLine(a, b)
Parameters
vec2 v1
vec2 a
vec2 b
number range
Return Value
number returns project result in line
v1:projectOnLineSegment(a, b)
Parameters
vec2 v1
vec2 a
vec2 b
number range
Return Value
number returns project result in line segment
v1:angle(v2)
Parameters
vec2 v1
vec2 v2
Return Value
number returns angle (radians) between v1 and v2
v1:angleDeg(v2)
Parameters
vec2 v1
vec2 v2
Return Value
number returns angle (degrees) between v1 and v2
v1:perp1()
Parameters
vec2 v1
Return Value
vec2 returns perpendicular (left) vec2 to v1
local a = mousePos2D-player.pos2D
local b = a:norm()
local c = b:perp1()
c:print()v1:perp2()
Parameters
vec2 v1
Return Value
vec2 returns perpendicular (right) vec2 to v1
local a = mousePos2D-player.pos2D
local b = a:norm()
local c = b:perp2()
c:print()v1:lerp(v2, s)
Parameters
vec2 v1
vec2 v2
number s
Return Value
vec2 returns interpolated vec2 between v1 and v2 by factor s
local a = player.pos2D:lerp(mousePos2D, 0.5)
a:print()v1:clone()
Parameters
vec2 v1
Return Value
vec2 returns cloned v1
local a = player.pos2D:clone()
a:print()v1:to3D(y)
Parameters
vec2 v1
number y
Return Value
vec3 returns vec3
local a = vec2(player.x, player.z)
local b = a:to3D(mousePos.y)
b:print()v1:toGame3D()
Parameters
vec2 v1
Return Value
vec3 returns vec3, y is set to world height for exact position
v1:rotate(s)
Parameters
vec2 v1
number s
Return Value
vec2 returns vec2 rotated by s radians
local a = (mousePos2D-player.pos2D)
local b = a:norm()
local c = b:rotate(0.785398)
c:print()v1:rotateDeg(angle)
Parameters
vec2 v1
number angle
Return Value
vec2 returns vec2 rotated by s degrees
v1:countAllies(range)
Parameters
vec2 v1
number range
Return Value
number
v1:countEnemies(range)
Parameters
vec2 v1
number range
Return Value
number
v1:countAllyLaneMinions(range)
Parameters
vec2 v1
number range
Return Value
number
v1:countEnemyLaneMinions(range)
Parameters
vec2 v1
number range
Return Value
number
v1:isUnderEnemyTurret(range)
Parameters
vec2 v1
number range, extra range, optional
Return Value
boolean
v1:isUnderAllyTurret(range)
Parameters
vec2 v1
number range, extra range, optional
Return Value
boolean
v1:print()
Parameters
vec2 v1
Return Value
void
local a = vec2(mousePos.x, mousePos.z)
a:print()vec2.array(n)
Parameters
number n
Return Value
vec2[?] returns vec2 array of length n
local a = vec2.array(12)
a[0].x = 100
a[0].y = 200
a[0]:print()vec3
vec3(number, number, number)
vec3(vec3)
local a = vec3(player.x, player.y, player.z)
local b = vec3(a)
a:print()
b:print()v1:dot(v2)
Parameters
vec3 v1
vec3 v2
Return Value
number returns dot product
local a = player.pos:dot(mousePos)
print(a)v1:cross(v2)
Parameters
vec3 v1
vec3 v2
Return Value
number returns cross product
local a = player.pos:cross(mousePos)
print(a)v1:len()
Parameters
vec3 v1
Return Value
number returns length of v1
local a = mousePos - player.pos
local b = a:len()
print(b)v1:lenSqr()
Parameters
vec3 v1
Return Value
number returns squared length of v1
local a = mousePos - player.pos
local b = a:lenSqr()
print(b)v1:norm()
Parameters
vec3 v1
Return Value
vec3 returns normalized v1
local a = mousePos - player.pos
local b = a:norm()
b:print()v1:extend(to, range)
Parameters
vec3 to
number range
Return Value
vec3 returns extended vec
local a = player.pos:extend(mousePos, 100)
a:print()v1:dist(v2)
Parameters
vec3 v1
vec3 v2
Return Value
number returns distance between v1 and v2
local a = mousePos:dist(player.pos)
print(a)v1:distSqr(v2)
Parameters
vec3 v1
vec3 v2
Return Value
number returns squared distance between v1 and v2
local a = mousePos:distSqr(player.pos)
print(a)v1:inRange(v2, range)
Parameters
vec3 v1
vec3 v2
number range
Return Value
number returns whether v2 in area from v1 to range
v1:angle(v2)
Parameters
vec3 v1
vec3 v2
Return Value
number returns angle (deg) between v1 and v2
v1:perp1()
Parameters
vec3 v1
Return Value
vec3 returns perpendicular (left) vec3 to v1
local a = mousePos-player.pos
local b = a:norm()
local c = b:perp1()
c:print()v1:perp2()
Parameters
vec3 v1
Return Value
vec3 returns perpendicular (right) vec3 to v1
local a = mousePos-player.pos
local b = a:norm()
local c = b:perp2()
c:print()v1:lerp(v2, s)
Parameters
vec3 v1
vec3 v2
number s
Return Value
vec3 returns interpolated vec3 between v1 and v2 by factor s
local a = player.pos:lerp(mousePos, 0.5)
a:print()v1:clone()
Parameters
vec3 v1
Return Value
vec3 returns cloned v1
local a = player.pos:clone()
a:print()v1:to2D()
Parameters
vec3 v1
Return Value
vec2 returns vec2 from x and z properties
local a = vec3(player.x, player.y, player.z)
local b = a:to2D()
b:print()v1:rotate(s)
Parameters
vec3 v1
number s
Return Value
vec3 returns vec3 rotated by s radians
local a = (mousePos-player.pos)
local b = a:norm()
local c = b:rotate(0.785398)
c:print()v1:countAllies(range)
Parameters
vec3 v1
number range
Return Value
number
v1:countEnemies(range)
Parameters
vec3 v1
number range
Return Value
number
v1:countAllyLaneMinions(range)
Parameters
vec3 v1
number range
Return Value
number
v1:countEnemyLaneMinions(range)
Parameters
vec3 v1
number range
Return Value
number
v1:isUnderEnemyTurret(range)
Parameters
vec3 v1
number range, extra range, optional
Return Value
boolean
v1:isUnderAllyTurret(range)
Parameters
vec3 v1
number range, extra range, optional
Return Value
boolean
v1:print()
Parameters
vec3 v1
Return Value
void
local a = vec3(mousePos.x, mousePos.y, mousePos.z)
a:print()vec3.array(n)
Parameters
number n
Return Value
vec3[?] returns vec3 array of length n
local a = vec3.array(12)
a[0].x = 100
a[0].y = 50
a[0].z = 200
a[0]:print()vec4
vec4(number, number, number)
vec4(vec4)
v1:dot(v2)
Parameters
vec4 v1
vec4 v2
Return Value
number returns dot product
v1:cross(v2)
Parameters
vec4 v1
vec4 v2
Return Value
number returns cross product
v1:len()
Parameters
vec4 v1
Return Value
number returns length of v1
v1:lenSqr()
Parameters
vec4 v1
Return Value
number returns squared length of v1
v1:norm()
Parameters
vec4 v1
Return Value
vec4 returns normalized v1
v1:dist(v2)
Parameters
vec4 v1
vec4 v2
Return Value
number returns distance between v1 and v2
v1:distSqr(v2)
Parameters
vec4 v1
vec4 v2
Return Value
number returns squared distance between v1 and v2
v1:perp1()
Parameters
vec4 v1
Return Value
vec4 returns perpendicular (left) vec4 to v1
v1:perp2()
Parameters
vec4 v1
Return Value
vec4 returns perpendicular (right) vec4 to v1
v1:lerp(v2, s)
Parameters
vec4 v1
vec4 v2
number s
Return Value
vec4 returns interpolated vec4 between v1 and v2 by factor s
v1:clone()
Parameters
vec4 v1
Return Value
vec4 returns cloned v1
v1:to2D()
Parameters
vec4 v1
Return Value
vec2 returns vec2 from x and z properties
v1:rotate(s)
Parameters
vec4 v1
number s
Return Value
vec4 returns vec4 rotated by s radians
v1:print()
Parameters
vec4 v1
Return Value
void
vec4.array(n)
Parameters
number n
Return Value
vec4[?] returns vec4 array of length n
seg2
vec2 seg2.startPos
vec2 seg2.endPos
v1:len()
Parameters
seg2 v1
Return Value
number returns length of v1
v1:lenSqr()
Parameters
seg2 v1
Return Value
number returns squared length of v1
mathf
A library of commonly used 2D math functions.
mathf.PI
Return Value
number returns pi
print(mathf.PI)mathf.cos(n)
Parameters
number n
Return Value
number returns the cosine of n
local a = mathf.cos(mathf.PI)
print(a)mathf.sin(n)
Parameters
number n
Return Value
number returns the sine of n
local a = mathf.sin(mathf.PI)
print(a)mathf.round(n, d)
Parameters
number n
number d
Return Value
number returns rounded n to precision d
local a = mathf.round(1.234567, 3)
print(a)mathf.sqr(n)
Parameters
number n
Return Value
number returns squared value of n
local a = mathf.sqr(2)
print(a)mathf.clamp(min, max, n)
Parameters
number min
number max
number n
Return Value
number returns clamped n between min and max
local a = mathf.clamp(0, 25, -1)
print(a)mathf.sect_line_line(v1, v3, v3, v4)
Parameters
vec2 v1
vec2 v2
vec2 v3
vec2 v4
Return Value
vec2 returns intersection point of lines (v1, v2) and (v3, v4)
local v1 = vec2(0, 0)
local v2 = vec2(100,100)
local v3 = vec2(100, 0)
local v4 = vec2(0,100)
local a = mathf.sect_line_line(v1, v2, v3, v4)
a:print()mathf.dist_line_vector(v1, v2, v3)
Parameters
vec2 v1
vec2 v2
vec2 v3
Return Value
number returns distance between v1 and line (v2, v3)
local v1 = vec2(0, 0)
local v2 = vec2(100, 0)
local v3 = vec2(0,100)
local a = mathf.dist_line_vector(v1, v2, v3)
print(a)mathf.angle_between(v1, v2, v3)
Parameters
vec2 v1
vec2 v2
vec2 v3
Return Value
number returns the angle between v2 and v3 from origin v1 in radians
local v1 = vec2(0, 0)
local a = mathf.angle_between(v1, player.pos2D, mousePos2D)
print(a)mathf.mec(pts, n)
Parameters
vec2[] pts
number n
Return Value
vec2 returns the center of the minimum enclosing circle
number returns the radius of the minimum enclosing circle
local pts = vec2.array(2)
pts[0].x, pts[0].y = 0, 0
pts[1].x, pts[1].y = mousePos.x, mousePos.z
pts[2].x, pts[2].y = player.x, player.z
local c, n = mathf.mec(pts, 2)
print(c.x, c.y, n)mathf.project(v1, v2, v3, s1, s2)
Parameters
vec2 v1
vec2 v2
vec2 v3
number s1
number s2
Return Value
vec2 returns the collision point
number returns the time until collision occurs
--calculates collision position and time of a projectile from mousePos along the players path
local src = mousePos2D
local pos_s = player.path.serverPos2D
local pos_e = player.path.point2D[player.path.index]
local s1 = 2000
local s2 = player.moveSpeed
local res, res_t = mathf.project(src, pos_s, pos_e, s1, s2)
if res then
print(res.x, res.y, res_t)
endmathf.dist_seg_seg(v1, v2, v3, v4)
Parameters
vec2 v1
vec2 v2
vec2 v3
vec2 v4
Return Value
number returns the distance between line segments (v1, v2) and (v3, v4)
local v1 = vec2(0,0)
local v2 = vec2(1000,1000)
local v3 = mousePos2D
local v4 = player.pos2D
local res = mathf.dist_seg_seg(v1, v2, v3, v4)
print(res)mathf.closest_vec_line(v1, v2, v3)
Parameters
vec2 v1
vec2 v2
vec2 v3
Return Value
vec2 returns a vec2 along the line (v2, v3) closest to v1
local v1 = player.pos2D
local v2 = vec2(0,0)
local v3 = mousePos2D
local res = mathf.closest_vec_line(v1, v2, v3)
res:print()mathf.closest_vec_line_seg(v1, v2, v3)
Parameters
vec2 v1
vec2 v2
vec2 v3
Return Value
vec2 returns a vec2 along the line segment (v2, v3) closest to v1
local v1 = player.pos2D
local v2 = vec2(0,0)
local v3 = mousePos2D
local res = mathf.closest_vec_line_seg(v1, v2, v3)
if res then
res:print()
endmathf.col_vec_rect(v1, v2, v3, w1, w2)
Parameters
vec2 v1
vec2 v2
vec2 v3
number w1
number w2
Return Value
boolean returns true if v1 with bounding radius of w1 collides with line (v2, v3) of width w2
local v1 = player.pos2D
local v2 = vec2(0, 0)
local v3 = mousePos2D
local w1 = player.boundingRadius
local w2 = 100
local res = mathf.col_vec_rect(v1, v2, v3, w1, w2)
print(res)mathf.sect_circle_circle(v1, r1, v2, r2)
Parameters
vec2 v1
number r1
vec2 v2
number r2
Return Value
vec2 returns first intersection of circles at v1 with radius of r1 and v2 with radius of r2
vec2 returns second intersection of circles at v1 with radius of r1 and v2 with radius of r2
local v1 = mousePos2D
local r1 = 500
local v2 = player.pos2D
local r2 = player.attackRange
local res1, res2 = mathf.sect_circle_circle(v1, r1, v2, r2)
if res1 then
res1:print()
res2:print()
endmathf.sect_line_circle(v1, v2, v3, r)
Parameters
vec2 v1
vec2 v2
vec2 v3
number r
Return Value
vec2 returns first intersection of line (v1, v2) and circle v3 with radius of r
vec2 returns second intersection of line (v1, v2) and circle v3 with radius of r
local v1 = vec2(0, 0)
local v2 = mousePos2D
local v3 = player.pos2D
local r = player.attackRange
local res1, res2 = mathf.sect_line_circle(v1, v2, v3, r)
if res1 then
res1:print()
end
if res2 then
res2:print()
endmathf.mat2()
Return Value
double[2][2] returns a 2x2 transformation matrix
mathf.mat3()
Return Value
double[3][3] returns a 3x3 transformation matrix
mathf.mat4()
Return Value
double[4][4] returns a 4x4 transformation matrix
clipper
Unlike the other math libraries, clipper must first be loaded.
Further documentation can be found here.
local clip = module.internal('clipper')
local polygon = clip.polygon
local polygons = clip.polygons
local clipper = clip.clipper
local clipper_enum = clip.enumEnums:
- clipper_enum.PolyFillType.EvenOdd
- clipper_enum.PolyFillType.NonZero
- clipper_enum.PolyFillType.Positive
- clipper_enum.PolyFillType.Negative
- clipper_enum.JoinType.Square
- clipper_enum.JoinType.Round
- clipper_enum.JoinType.Miter
- clipper_enum.ClipType.Intersection
- clipper_enum.ClipType.Union
- clipper_enum.ClipType.Difference
- clipper_enum.ClipType.Xor
- clipper_enum.PolyType.Subject
- clipper_enum.PolyType.Clip
polygon:Add(v1)
Parameters
vec2 v1
Return Value
void
local p = polygon()
local v = vec2(200, 200)
p:Add(v)polygon:ChildCount()
Return Value
number returns number of vertices
local p = polygon(vec2(200, 200), vec2(200, 100), vec2(100, 200))
print(p:ChildCount())polygon:Childs(i)
Parameters
number i
Return Value
vec2 returns vec2 at vertex i
local p = polygon(vec2(200, 200), vec2(200, 100), vec2(100, 200))
local v = p:Childs(1)
v:print()polygon:Area()
Return Value
number returns the area of polygon
local p = polygon(vec2(200, 200), vec2(200, 100), vec2(100, 200))
print(p:Area())polygon:Clean(dist)
Parameters
number dist
Return Value
void
local p = polygon(vec2(200, 200), vec2(200, 100), vec2(200, 101), vec2(100, 200))
print(p:ChildCount())
p:Clean(5)
print(p:ChildCount())polygon:Simplify(PolyFillType)
Parameters
number PolyFillType
Return Value
polygons returns polygon set
local p1 = polygon(vec2(5,62), vec2(164,62), vec2(36,157), vec2(85, 4), vec2(134, 158))
local p = p1:Simplify(clipper_enum.PolyFillType.NonZero)
local p2 = p:Childs(0)
cb.add(cb.draw, function()
p2:Draw2D(5, 0xFF00FFFF)
p1:Draw2D(2, 0xFFFF00FF)
end)polygon:Orientation()
Return Value
number returns 1 if polygon has clockwise orientation
polygon:Reverse()
Return Value
void reverses polygons orientation
polygon:Contains(v1)
Parameters
vec2\vec3 v1
Return Value
number returns 1 if v1 is inside of polygon, 0 if outside, -1 if v1 is on polygon edge
local p1 = polygon(vec2(200,200), vec2(200,300), vec2(300,300), vec2(300, 200))
cb.add(cb.draw, function()
p1:Draw2D(2, p1:Contains(game.cursorPos)==1 and 0xFF00FF00 or 0xFFFF0000)
end)polygon:Draw2D(width, color)
Parameters
number width
number color
Return Value
void
polygon:Draw3D(y, width, color)
Parameters
number y
number width
number color
Return Value
void
polygon:OnScreen2D()
Return Value
boolean returns true if polygon intersects the screen
polygon:OnScreen3D(y)
Parameters
number y
Return Value
boolean returns true if polygon intersects the screen
polygons:Add(polygon)
Parameters
polygon polygon
Return Value
void
polygons:ChildCount()
Return Value
number returns number of polygons contained polygon set
polygons:Childs(i)
Parameters
number i
Return Value
polygon returns polygon at index i
polygons:Reverse()
Return Value
void reverses the orientation of all containing polygons
polygons:Clean(dist)
Parameters
number dist
Return Value
void cleans all contained polygons
polygons:Simplify(PolyFillType)
Parameters
number PolyFillType
Return Value
polygons returns polygon set
polygons:Offset(delta, JoinType, limit)
Parameters
number delta
number JoinType
number limit
Return Value
polygons returns polygon set
clipper:AddPath(polygon, PolyType, closed)
Parameters
polygon polygon
number PolyType
boolean closed
Return Value
void
clipper:AddPaths(polygons, PolyType, closed)
Parameters
polygons polygons
number PolyType
boolean closed
Return Value
void
clipper:Clear()
Return Value
void
clipper:Execute(ClipType, PolyFillType, PolyFillType)
Parameters
number ClipType
number PolyFillType
number PolyFillType
Return Value
polygons returns polygon set
-- Example to calc DariusQ Outer Ring
local clip = module.internal('clipper')
local polygon = clip.polygon
local polygons = clip.polygons
local clipper = clip.clipper
local clipper_enum = clip.enum
local function create_ring(center, outer_radius, inner_radius)
local outer_ring = polygon()
local inner_ring = polygon()
for i = 1, 64 do
local angle = (i - 1) * (2 * math.pi / 64)
local x_outer = center.pos.x + outer_radius * math.cos(angle)
local y_outer = center.pos.z + outer_radius * math.sin(angle)
local x_inner = center.pos.x + inner_radius * math.cos(angle)
local y_inner = center.pos.z + inner_radius * math.sin(angle)
outer_ring:Add(vec2(x_outer, y_outer))
inner_ring:Add(vec2(x_inner, y_inner))
end
local clpr = clipper()
clpr:AddPath(outer_ring, clipper_enum.PolyType.Subject, true)
clpr:AddPath(inner_ring, clipper_enum.PolyType.Clip, true)
local ring_area = clpr:Execute(clipper_enum.ClipType.Difference, clipper_enum.PolyFillType.NonZero, clipper_enum.PolyFillType.EvenOdd)
return ring_area
end
-- Darius Outer ring Q, Find hit areas
local function on_draw()
local centers = {}
for i=0, objManager.enemies_n-1 do
local obj = objManager.enemies[i]
if obj and obj:isValidTarget(850) then
table.insert(centers, obj)
end
end
if #centers >= 2 then
local clpr = clipper()
local first_ring = create_ring(centers[1], 460, 250)
local second_ring = create_ring(centers[2], 460, 250)
clpr:AddPaths(first_ring, clipper_enum.PolyType.Subject, true)
clpr:AddPaths(second_ring, clipper_enum.PolyType.Clip, true)
local solution = clpr:Execute(clipper_enum.ClipType.Intersection, clipper_enum.PolyFillType.NonZero, clipper_enum.PolyFillType.EvenOdd)
for i = 0, solution:ChildCount() - 1 do
local poly = solution:Childs(i)
poly:Draw3D(player.y, 2, 0xFF00FF00)
end
end
end
cb.add(cb.draw, on_draw)clipper2
Clipper2 is a high-performance polygon clipping and offsetting library that works with double precision coordinates.
Further documentation can be found https://www.angusj.com/clipper2/Docs/Overview.htm.
local clipper2 = require("clipper2")
local PointD = clipper2.PointD
local PathD = clipper2.PathD
local PathsD = clipper2.PathsD
local BooleanOpD = clipper2.BooleanOpD
local Enum = clipper2.EnumEnums:
ClipType:
- Enum.ClipType.None
- Enum.ClipType.Intersection
- Enum.ClipType.Union
- Enum.ClipType.Difference
- Enum.ClipType.Xor
FillRule:
- Enum.FillRule.EvenOdd
- Enum.FillRule.NonZero
- Enum.FillRule.Positive
- Enum.FillRule.Negative
JoinType:
- Enum.JoinType.Square
- Enum.JoinType.Bevel
- Enum.JoinType.Round
- Enum.JoinType.Miter
EndType:
- Enum.EndType.Polygon
- Enum.EndType.Joined
- Enum.EndType.Butt
- Enum.EndType.Square
- Enum.EndType.Round
PointD(x, y)
Create a new double precision point.
Parameters
number x coordinate
number y coordinate
Return Value
PointD returns a new point object
local point = PointD(100.5, 200.7)PathD()
Create a new double precision path (polygon).
Parameters
... optional points to initialize the path
Return Value
PathD returns a new path object
-- Create empty path
local path = PathD()
-- Create path with initial points
local p1 = PointD(0, 0)
local p2 = PointD(100, 0)
local p3 = PointD(50, 100)
local path = PathD(p1, p2, p3)PathD:Add(x, y)
Add a point to the path.
Parameters
number x coordinate
number y coordinate
Return Value
void
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(50, 100)PathD:ChildCount()
Get the number of points in the path.
Return Value
number returns number of points
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
print(path:ChildCount()) -- prints 2PathD:Childs(index)
Get a point at the specified index.
Parameters
number index (0-based)
Return Value
PointD returns point at index
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
local point = path:Childs(0)
print(point.x, point.y) -- prints 0, 0PathD:Clear()
Remove all points from the path.
Return Value
void
local path = PathD()
path:Add(0, 0)
path:Clear()
print(path:ChildCount()) -- prints 0PathD:Area()
Calculate the area of the polygon.
Return Value
number returns area (positive for clockwise, negative for counter-clockwise)
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(100, 100)
path:Add(0, 100)
print(path:Area()) -- prints 10000PathD:Orientation()
Get the orientation of the polygon.
Return Value
boolean returns true if clockwise, false if counter-clockwise
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(100, 100)
path:Add(0, 100)
print(path:Orientation()) -- prints true (clockwise)PathD:Reverse()
Reverse the order of points in the path.
Return Value
void
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(100, 100)
path:Reverse()PathD:Simplify(epsilon, isClosedPath)
Simplify the path by removing unnecessary points.
Parameters
number epsilon - simplification tolerance
boolean isClosedPath - whether the path is closed (default: true)
Return Value
PathD returns simplified path
local path = PathD()
path:Add(0, 0)
path:Add(50, 1)
path:Add(100, 0)
local simplified = path:Simplify(2.0, false)PathD:Contains(point)
Check if a point is inside the polygon.
Parameters
PointD point to test
Return Value
number returns 1 if inside, 0 if outside
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(100, 100)
path:Add(0, 100)
local point = PointD(50, 50)
print(path:Contains(point)) -- prints 1 (inside)PathD:OnScreen2D()
Check if the path is visible on screen in 2D.
Return Value
boolean returns true if on screen
PathD:OnScreen3D(y)
Check if the path is visible on screen in 3D.
Parameters
number y coordinate (default: 0)
Return Value
boolean returns true if on screen
PathD:Draw2D(width, color)
Draw the path in 2D.
Parameters
number width - line width (default: 0)
number color - color in ARGB format (default: 0xffffffff)
Return Value
void
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(50, 100)
path:Draw2D(2, 0xFF00FF00) -- green lines, 2 pixels widePathD:Draw3D(y, width, color)
Draw the path in 3D.
Parameters
number y coordinate
number width - line width (default: 0)
number color - color in ARGB format (default: 0xffffffff)
Return Value
void
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(50, 100)
path:Draw3D(player.y, 2, 0xFF00FF00)PathD:Intersection(p0, p1) or PathD:Intersection(x0, y0, x1, y1)
Test if the path intersects with a line segment.
Parameters
PointD p0, p1 - line segment endpoints
or
number x0, y0, x1, y1 - line segment coordinates
Return Value
boolean returns true if intersection exists
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(50, 100)
local p0 = PointD(25, -10)
local p1 = PointD(25, 110)
print(path:Intersection(p0, p1)) -- prints truePathD:IntersectionPoint(p0, p1) or PathD:IntersectionPoint(x0, y0, x1, y1)
Get intersection points between the path and a line segment.
Parameters
PointD p0, p1 - line segment endpoints
or
number x0, y0, x1, y1 - line segment coordinates
Return Value
PathD returns path containing intersection points
PathsD()
Create a new collection of paths.
Parameters
... optional PathD objects to initialize the collection
Return Value
PathsD returns a new paths collection
-- Create empty collection
local paths = PathsD()
-- Create with initial paths
local path1 = PathD()
local path2 = PathD()
local paths = PathsD(path1, path2)PathsD:Add(path)
Add a path to the collection.
Parameters
PathD path to add
Return Value
void
local paths = PathsD()
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(50, 100)
paths:Add(path)PathsD:ChildCount()
Get the number of paths in the collection.
Return Value
number returns number of paths
PathsD:Childs(index)
Get a path at the specified index.
Parameters
number index (0-based)
Return Value
PathD returns path at index
PathsD:Clear()
Remove all paths from the collection.
Return Value
void
PathsD:Simplify(epsilon, isClosedPath)
Simplify all paths in the collection.
Parameters
number epsilon - simplification tolerance
boolean isClosedPath - whether paths are closed (default: true)
Return Value
PathsD returns simplified paths collection
PathsD:Reverse()
Reverse the order of points in all paths.
Return Value
void
PathsD:Offset(delta, joinType, endType)
Create offset paths from the collection.
Parameters
number delta - offset distance (positive for expansion, negative for shrinking)
number joinType - join type from Enum.JoinType
number endType - end type from Enum.EndType (default: 0)
Return Value
PathsD returns offset paths
local paths = PathsD()
local path = PathD()
path:Add(0, 0)
path:Add(100, 0)
path:Add(100, 100)
path:Add(0, 100)
paths:Add(path)
local offset_paths = paths:Offset(10, Enum.JoinType.Round, Enum.EndType.Polygon)PathsD:Draw2D(width, color)
Draw all paths in the collection in 2D.
Parameters
number width - line width (default: 0)
number color - color in ARGB format (default: 0xffffffff)
Return Value
void
PathsD:Draw3D(y, width, color)
Draw all paths in the collection in 3D.
Parameters
number y coordinate
number width - line width (default: 0)
number color - color in ARGB format (default: 0xffffffff)
Return Value
void
BooleanOpD(clipType, fillRule, subjects, clips, solution, precision, reverse_solution)
Perform boolean operations on path collections.
Parameters
number clipType - operation type from Enum.ClipType
number fillRule - fill rule from Enum.FillRule
PathsD subjects - subject paths
PathsD clips - clip paths
PathsD solution - result paths (output)
number precision - calculation precision
boolean reverse_solution - whether to reverse result orientation
Return Value
number returns operation result code
local subjects = PathsD()
local clips = PathsD()
local solution = PathsD()
-- Create subject rectangle
local subject = PathD()
subject:Add(0, 0)
subject:Add(100, 0)
subject:Add(100, 100)
subject:Add(0, 100)
subjects:Add(subject)
-- Create clip circle (approximated)
local clip = PathD()
for i = 0, 31 do
local angle = i * 2 * math.pi / 32
local x = 50 + 30 * math.cos(angle)
local y = 50 + 30 * math.sin(angle)
clip:Add(x, y)
end
clips:Add(clip)
-- Perform intersection
local result = BooleanOpD(
Enum.ClipType.Intersection,
Enum.FillRule.NonZero,
subjects,
clips,
solution,
2,
false
)
-- Draw result
cb.add(cb.draw, function()
for i = 0, solution:ChildCount() - 1 do
local path = solution:Childs(i)
path:Draw2D(2, 0xFF00FF00)
end
end)Eigen_PolynomialSolver(a, b, c, d, e)
Solve polynomial equations using Eigen library. Parameters
number a, b, c, d, e - polynomial coefficients
Return Value
PathD returns path containing solutions
Eigen_PolynomialSolver_realRoots(a, b, c, d, e)
Solve polynomial equations and return only real roots. Parameters
number a, b, c, d, e - polynomial coefficients
Return Value
PathD returns path containing real solutions
Example: Complex Boolean Operations
local clipper2 = require("clipper2")
-- Create multiple overlapping circles
local function create_circle(center_x, center_y, radius, segments)
local path = clipper2.PathD()
for i = 0, segments - 1 do
local angle = i * 2 * math.pi / segments
local x = center_x + radius * math.cos(angle)
local y = center_y + radius * math.sin(angle)
path:Add(x, y)
end
return path
end
local function on_draw()
local subjects = clipper2.PathsD()
local clips = clipper2.PathsD()
local solution = clipper2.PathsD()
-- Create overlapping circles
local circle1 = create_circle(100, 100, 50, 32)
local circle2 = create_circle(150, 100, 50, 32)
local circle3 = create_circle(125, 150, 50, 32)
subjects:Add(circle1)
clips:Add(circle2)
clips:Add(circle3)
-- Perform union operation
local result = clipper2.BooleanOpD(
clipper2.Enum.ClipType.Union,
clipper2.Enum.FillRule.NonZero,
subjects,
clips,
solution,
2,
false
)
if result == 1 then
-- Draw the unified shape
for i = 0, solution:ChildCount() - 1 do
local path = solution:Childs(i)
path:Draw2D(3, 0xFF00FFFF)
end
-- Create offset version
local offset_solution = solution:Offset(10, clipper2.Enum.JoinType.Round)
for i = 0, offset_solution:ChildCount() - 1 do
local path = offset_solution:Childs(i)
path:Draw2D(1, 0xFFFF0000)
end
end
end
cb.add(cb.draw, on_draw)