mirror of
https://github.com/sbrl/Minetest-WorldEditAdditions.git
synced 2024-08-21 05:54:06 +02:00
Vector3/tests: flip assert orderings
This commit is contained in:
parent
57df2d045f
commit
8ae0d92e3d
@ -14,89 +14,74 @@ describe("Vector3.add", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a:add(b),
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
a:add(b)
|
||||
)
|
||||
end)
|
||||
it("should support the add operator", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should work with floats", function()
|
||||
local a = Vector3.new(3.5, 4.5, 5.5)
|
||||
local b = Vector3.new(1.1, 1.1, 1.1)
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(4.6, 5.6, 6.6)
|
||||
Vector3.new(4.6, 5.6, 6.6),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should work with scalar a", function()
|
||||
local a = 2
|
||||
local b = Vector3.new(6, 7, 8)
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(8, 9, 10)
|
||||
Vector3.new(8, 9, 10),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should work with scalar b", function()
|
||||
local a = Vector3.new(6, 7, 8)
|
||||
local b = 2
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(8, 9, 10)
|
||||
Vector3.new(8, 9, 10),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should handle negative b", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(-1, -1, -1)
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(2, 3, 4)
|
||||
Vector3.new(2, 3, 4),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a", function()
|
||||
local a = Vector3.new(-3, -4, -5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(-2, -3, -4)
|
||||
Vector3.new(-2, -3, -4),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a and b", function()
|
||||
local a = Vector3.new(-3, -4, -5)
|
||||
local b = Vector3.new(-1, -1, -1)
|
||||
assert.are.same(
|
||||
a + b,
|
||||
Vector3.new(-4, -5, -6)
|
||||
Vector3.new(-4, -5, -6),
|
||||
a + b
|
||||
)
|
||||
end)
|
||||
it("should throw an error on invalid x", function()
|
||||
assert.has.errors(function()
|
||||
Vector3.new("cheese", 4, 5)
|
||||
end)
|
||||
end)
|
||||
it("should throw an error on invalid y", function()
|
||||
assert.has.errors(function()
|
||||
Vector3.new(4, "cheese", 5)
|
||||
end)
|
||||
end)
|
||||
it("should throw an error on invalid z", function()
|
||||
assert.has.errors(function()
|
||||
Vector3.new(66, 2, "cheese")
|
||||
end)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
|
||||
local result = a + b
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
assert.are_not.equal(result, b)
|
||||
|
@ -13,22 +13,22 @@ describe("Vector3.area", function()
|
||||
it("should work with a positive vector", function()
|
||||
local a = Vector3.new(3, 3, 3)
|
||||
assert.are.equal(
|
||||
a:area(),
|
||||
27
|
||||
27,
|
||||
a:area()
|
||||
)
|
||||
end)
|
||||
it("should work with a negative vector", function()
|
||||
local a = Vector3.new(-4, -4, -4)
|
||||
assert.are.equal(
|
||||
a:area(),
|
||||
-64
|
||||
-64,
|
||||
a:area()
|
||||
)
|
||||
end)
|
||||
it("should work with a mixed vector", function()
|
||||
local a = Vector3.new(-3, 3, -3)
|
||||
assert.are.equal(
|
||||
a:area(),
|
||||
27
|
||||
27,
|
||||
a:area()
|
||||
)
|
||||
end)
|
||||
end)
|
||||
|
@ -13,15 +13,15 @@ describe("Vector3.ceil", function()
|
||||
it("should ceil a positive vector", function()
|
||||
local a = Vector3.new(3.1, 4.2, 5.8)
|
||||
assert.are.same(
|
||||
a:ceil(),
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
a:ceil()
|
||||
)
|
||||
end)
|
||||
it("should ceil a negative vector", function()
|
||||
local a = Vector3.new(-3.1, -4.2, -5.3)
|
||||
assert.are.same(
|
||||
a:ceil(),
|
||||
Vector3.new(-3, -4, -5)
|
||||
Vector3.new(-3, -4, -5),
|
||||
a:ceil()
|
||||
)
|
||||
end)
|
||||
it("should work with integers", function()
|
||||
@ -36,8 +36,8 @@ describe("Vector3.ceil", function()
|
||||
|
||||
local result = a:ceil()
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
end)
|
||||
|
@ -5,64 +5,64 @@ describe("Vector3.divide", function()
|
||||
local a = Vector3.new(30, 40, 50)
|
||||
local b = Vector3.new(2, 2, 2)
|
||||
assert.are.same(
|
||||
a:divide(b),
|
||||
Vector3.new(15, 20, 25)
|
||||
Vector3.new(15, 20, 25),
|
||||
a:divide(b)
|
||||
)
|
||||
end)
|
||||
it("should work with the div alias", function()
|
||||
local a = Vector3.new(30, 40, 50)
|
||||
local b = Vector3.new(2, 2, 2)
|
||||
assert.are.same(
|
||||
a:div(b),
|
||||
Vector3.new(15, 20, 25)
|
||||
Vector3.new(15, 20, 25),
|
||||
a:div(b)
|
||||
)
|
||||
end)
|
||||
it("should work with scalar a", function()
|
||||
local a = 2
|
||||
local b = Vector3.new(12, 14, 16)
|
||||
assert.are.same(
|
||||
a / b,
|
||||
Vector3.new(6, 7, 8)
|
||||
Vector3.new(6, 7, 8),
|
||||
a / b
|
||||
)
|
||||
end)
|
||||
it("should work with scalar b", function()
|
||||
local a = Vector3.new(6, 8, 10)
|
||||
local b = 2
|
||||
assert.are.same(
|
||||
a / b,
|
||||
Vector3.new(3, 4, 5)
|
||||
Vector3.new(3, 4, 5),
|
||||
a / b
|
||||
)
|
||||
end)
|
||||
it("should support the divide operator", function()
|
||||
local a = Vector3.new(10, 12, 14)
|
||||
local b = Vector3.new(2, 3, 2)
|
||||
assert.are.same(
|
||||
a / b,
|
||||
Vector3.new(5, 4, 7)
|
||||
Vector3.new(5, 4, 7),
|
||||
a / b
|
||||
)
|
||||
end)
|
||||
it("should handle negative b", function()
|
||||
local a = Vector3.new(30, 40, 50)
|
||||
local b = Vector3.new(-2, -2, -2)
|
||||
assert.are.same(
|
||||
a / b,
|
||||
Vector3.new(-15, -20, -25)
|
||||
Vector3.new(-15, -20, -25),
|
||||
a / b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a", function()
|
||||
local a = Vector3.new(-30, -40, -50)
|
||||
local b = Vector3.new(2, 4, 2)
|
||||
assert.are.same(
|
||||
a / b,
|
||||
Vector3.new(-15, -10, -25)
|
||||
Vector3.new(-15, -10, -25),
|
||||
a / b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a and b", function()
|
||||
local a = Vector3.new(-30, -40, -50)
|
||||
local b = Vector3.new(-2, -2, -2)
|
||||
assert.are.same(
|
||||
a / b,
|
||||
Vector3.new(15, 20, 25)
|
||||
Vector3.new(15, 20, 25),
|
||||
a / b
|
||||
)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
@ -71,8 +71,8 @@ describe("Vector3.divide", function()
|
||||
|
||||
local result = a / b
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(3, 4, 5)
|
||||
Vector3.new(3, 4, 5),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
assert.are_not.equal(result, b)
|
||||
|
@ -13,22 +13,22 @@ describe("Vector3.floor", function()
|
||||
it("should floor a positive vector", function()
|
||||
local a = Vector3.new(3.1, 4.75, 5.9)
|
||||
assert.are.same(
|
||||
a:floor(),
|
||||
Vector3.new(3, 4, 5)
|
||||
Vector3.new(3, 4, 5),
|
||||
a:floor()
|
||||
)
|
||||
end)
|
||||
it("should floor a negative vector", function()
|
||||
local a = Vector3.new(-3.1, -4.2, -5.3)
|
||||
assert.are.same(
|
||||
a:floor(),
|
||||
Vector3.new(-4, -5, -6)
|
||||
Vector3.new(-4, -5, -6),
|
||||
a:floor()
|
||||
)
|
||||
end)
|
||||
it("should work with integers", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
assert.are.same(
|
||||
a:floor(),
|
||||
Vector3.new(3, 4, 5)
|
||||
Vector3.new(3, 4, 5),
|
||||
a:floor()
|
||||
)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
@ -36,8 +36,8 @@ describe("Vector3.floor", function()
|
||||
|
||||
local result = a:floor()
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(3, 4, 5)
|
||||
Vector3.new(3, 4, 5),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
end)
|
||||
|
@ -5,64 +5,64 @@ describe("Vector3.multiply", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(2, 2, 2)
|
||||
assert.are.same(
|
||||
a:multiply(b),
|
||||
Vector3.new(6, 8, 10)
|
||||
Vector3.new(6, 8, 10),
|
||||
a:multiply(b)
|
||||
)
|
||||
end)
|
||||
it("should work with the mul alias", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(2, 2, 2)
|
||||
assert.are.same(
|
||||
a:mul(b),
|
||||
Vector3.new(6, 8, 10)
|
||||
Vector3.new(6, 8, 10),
|
||||
a:mul(b)
|
||||
)
|
||||
end)
|
||||
it("should work with scalar a", function()
|
||||
local a = 2
|
||||
local b = Vector3.new(6, 7, 8)
|
||||
assert.are.same(
|
||||
a * b,
|
||||
Vector3.new(12, 14, 16)
|
||||
Vector3.new(12, 14, 16),
|
||||
a * b
|
||||
)
|
||||
end)
|
||||
it("should work with scalar b", function()
|
||||
local a = Vector3.new(6, 7, 8)
|
||||
local b = 2
|
||||
assert.are.same(
|
||||
a * b,
|
||||
Vector3.new(12, 14, 16)
|
||||
Vector3.new(12, 14, 16),
|
||||
a * b
|
||||
)
|
||||
end)
|
||||
it("should support the multiply operator", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(2, 2, 2)
|
||||
assert.are.same(
|
||||
a * b,
|
||||
Vector3.new(6, 8, 10)
|
||||
Vector3.new(6, 8, 10),
|
||||
a * b
|
||||
)
|
||||
end)
|
||||
it("should handle negative b", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(-1, -1, -1)
|
||||
assert.are.same(
|
||||
a * b,
|
||||
Vector3.new(-3, -4, -5)
|
||||
Vector3.new(-3, -4, -5),
|
||||
a * b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a", function()
|
||||
local a = Vector3.new(-3, -4, -5)
|
||||
local b = Vector3.new(2, 2, 2)
|
||||
assert.are.same(
|
||||
a * b,
|
||||
Vector3.new(-6, -8, -10)
|
||||
Vector3.new(-6, -8, -10),
|
||||
a * b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a and b", function()
|
||||
local a = Vector3.new(-3, -4, -5)
|
||||
local b = Vector3.new(-2, -2, -2)
|
||||
assert.are.same(
|
||||
a * b,
|
||||
Vector3.new(6, 8, 10)
|
||||
Vector3.new(6, 8, 10),
|
||||
a * b
|
||||
)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
@ -71,8 +71,8 @@ describe("Vector3.multiply", function()
|
||||
|
||||
local result = a * b
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(9, 12, 15)
|
||||
Vector3.new(9, 12, 15),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
assert.are_not.equal(result, b)
|
||||
|
@ -3,8 +3,8 @@ local Vector3 = require("worldeditadditions.utils.vector3")
|
||||
describe("Vector3.add", function()
|
||||
it("should create a new Vector3", function()
|
||||
assert.are.same(
|
||||
Vector3.new(3, 4, 5),
|
||||
{ x = 3, y = 4, z = 5 }
|
||||
{ x = 3, y = 4, z = 5 },
|
||||
Vector3.new(3, 4, 5)
|
||||
)
|
||||
end)
|
||||
it("should throw an error on invalid x", function()
|
||||
|
@ -13,22 +13,22 @@ describe("Vector3.round", function()
|
||||
it("should round a positive vector", function()
|
||||
local a = Vector3.new(3.1, 4.75, 5.9)
|
||||
assert.are.same(
|
||||
a:round(),
|
||||
Vector3.new(3, 5, 6)
|
||||
Vector3.new(3, 5, 6),
|
||||
a:round()
|
||||
)
|
||||
end)
|
||||
it("should round a negative vector", function()
|
||||
local a = Vector3.new(-3.1, -4.2, -5.3)
|
||||
assert.are.same(
|
||||
a:round(),
|
||||
Vector3.new(-3, -4, -5)
|
||||
Vector3.new(-3, -4, -5),
|
||||
a:round()
|
||||
)
|
||||
end)
|
||||
it("should work with integers", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
assert.are.same(
|
||||
a:round(),
|
||||
Vector3.new(3, 4, 5)
|
||||
Vector3.new(3, 4, 5),
|
||||
a:round()
|
||||
)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
@ -36,8 +36,8 @@ describe("Vector3.round", function()
|
||||
|
||||
local result = a:round()
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(3, 5, 6)
|
||||
Vector3.new(3, 5, 6),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
end)
|
||||
|
45
.tests/Vector3/snap_to.test.lua
Normal file
45
.tests/Vector3/snap_to.test.lua
Normal file
@ -0,0 +1,45 @@
|
||||
local Vector3 = require("worldeditadditions.utils.vector3")
|
||||
|
||||
local function format_map(map)
|
||||
local result = {}
|
||||
for key, value in pairs(map) do
|
||||
table.insert(result, key.."\t"..tostring(value))
|
||||
end
|
||||
return table.concat(result, "\n")
|
||||
end
|
||||
|
||||
|
||||
describe("Vector3.snap_to", function()
|
||||
it("should snap_to a positive vector", function()
|
||||
local a = Vector3.new(3.1, 4.75, 5.9)
|
||||
print("DEBUG "..tostring(a:snap_to(10)))
|
||||
assert.are.same(
|
||||
a:snap_to(10),
|
||||
Vector3.new(0, 0, 10)
|
||||
)
|
||||
end)
|
||||
it("should snap_to a negative vector", function()
|
||||
local a = Vector3.new(-2.5, -4.2, -5.3)
|
||||
assert.are.same(
|
||||
a:snap_to(6),
|
||||
Vector3.new(0, -6, -6)
|
||||
)
|
||||
end)
|
||||
it("should work with integers", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
assert.are.same(
|
||||
a:snap_to(3),
|
||||
Vector3.new(3, 3, 6)
|
||||
)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
local a = Vector3.new(3.1, 4.7, 5.99999)
|
||||
|
||||
local result = a:snap_to(3)
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(3, 6, 6)
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
end)
|
||||
end)
|
@ -5,64 +5,64 @@ describe("Vector3.subtract", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a:subtract(b),
|
||||
Vector3.new(2, 3, 4)
|
||||
Vector3.new(2, 3, 4),
|
||||
a:subtract(b)
|
||||
)
|
||||
end)
|
||||
it("should work with the sub alias", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a:sub(b),
|
||||
Vector3.new(2, 3, 4)
|
||||
Vector3.new(2, 3, 4),
|
||||
a:sub(b)
|
||||
)
|
||||
end)
|
||||
it("should work with scalar a", function()
|
||||
local a = 2
|
||||
local b = Vector3.new(6, 7, 8)
|
||||
assert.are.same(
|
||||
a - b,
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
a - b
|
||||
)
|
||||
end)
|
||||
it("should work with scalar b", function()
|
||||
local a = Vector3.new(6, 7, 8)
|
||||
local b = 2
|
||||
assert.are.same(
|
||||
a - b,
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
a - b
|
||||
)
|
||||
end)
|
||||
it("should support the subtract operator", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a - b,
|
||||
Vector3.new(2, 3, 4)
|
||||
Vector3.new(2, 3, 4),
|
||||
a - b
|
||||
)
|
||||
end)
|
||||
it("should handle negative b", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
local b = Vector3.new(-1, -1, -1)
|
||||
assert.are.same(
|
||||
a - b,
|
||||
Vector3.new(4, 5, 6)
|
||||
Vector3.new(4, 5, 6),
|
||||
a - b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a", function()
|
||||
local a = Vector3.new(-3, -4, -5)
|
||||
local b = Vector3.new(1, 1, 1)
|
||||
assert.are.same(
|
||||
a - b,
|
||||
Vector3.new(-4, -5, -6)
|
||||
Vector3.new(-4, -5, -6),
|
||||
a - b
|
||||
)
|
||||
end)
|
||||
it("should handle negative a and b", function()
|
||||
local a = Vector3.new(-3, -4, -5)
|
||||
local b = Vector3.new(-1, -1, -1)
|
||||
assert.are.same(
|
||||
a - b,
|
||||
Vector3.new(-2, -3, -4)
|
||||
Vector3.new(-2, -3, -4),
|
||||
a - b
|
||||
)
|
||||
end)
|
||||
it("should return a new Vector3 instance", function()
|
||||
@ -71,8 +71,8 @@ describe("Vector3.subtract", function()
|
||||
|
||||
local result = a - b
|
||||
assert.are.same(
|
||||
result,
|
||||
Vector3.new(2, 3, 4)
|
||||
Vector3.new(2, 3, 4),
|
||||
result
|
||||
)
|
||||
assert.are_not.equal(result, a)
|
||||
assert.are_not.equal(result, b)
|
||||
|
@ -13,36 +13,36 @@ describe("Vector3.__tostring", function()
|
||||
it("should stringify a Vector3", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
assert.are.same(
|
||||
a:__tostring(),
|
||||
"(3, 4, 5)"
|
||||
"(3, 4, 5)",
|
||||
a:__tostring()
|
||||
)
|
||||
end)
|
||||
it("should implicitly stringify a Vector3", function()
|
||||
local a = Vector3.new(3, 4, 5)
|
||||
assert.are.same(
|
||||
tostring(a),
|
||||
"(3, 4, 5)"
|
||||
"(3, 4, 5)",
|
||||
tostring(a)
|
||||
)
|
||||
end)
|
||||
it("should implicitly stringify another Vector3", function()
|
||||
local a = Vector3.new(55, 77, 22)
|
||||
assert.are.same(
|
||||
tostring(a),
|
||||
"(55, 77, 22)"
|
||||
"(55, 77, 22)",
|
||||
tostring(a)
|
||||
)
|
||||
end)
|
||||
it("should handle negative numbers", function()
|
||||
local a = Vector3.new(-1, -2, -3)
|
||||
assert.are.same(
|
||||
tostring(a),
|
||||
"(-1, -2, -3)"
|
||||
"(-1, -2, -3)",
|
||||
tostring(a)
|
||||
)
|
||||
end)
|
||||
it("should handle a mix of positive and negative numbers", function()
|
||||
local a = Vector3.new(-7, 2, -99)
|
||||
assert.are.same(
|
||||
tostring(a),
|
||||
"(-7, 2, -99)"
|
||||
"(-7, 2, -99)",
|
||||
tostring(a)
|
||||
)
|
||||
end)
|
||||
end)
|
||||
|
@ -116,6 +116,16 @@ function Vector3.round(a)
|
||||
return Vector3.new(math.floor(a.x+0.5), math.floor(a.y+0.5), math.floor(a.z+0.5))
|
||||
end
|
||||
|
||||
|
||||
--- Snaps this Vector3 to an imaginary square grid with the specified sized
|
||||
-- squares.
|
||||
-- @param a Vector3 The vector to operate on.
|
||||
-- @param number grid_size The size of the squares on the imaginary grid to which to snap.
|
||||
-- @returns Vector3 A new Vector3 instance snapped to an imaginary grid of the specified size.
|
||||
function Vector3.snap_to(a, grid_size)
|
||||
return a:round(a / grid_size) * grid_size
|
||||
end
|
||||
|
||||
--- Returns the area of this vector.
|
||||
-- In other words, multiplies all the components together and returns a scalar value.
|
||||
-- @param a Vector3 The vector to return the area of.
|
||||
|
Loading…
Reference in New Issue
Block a user