@inglorious/utils 3.7.0 → 3.7.1

package/src/math/circle.test.js

@@ -1,98 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./circle.js"
-
-test("it should prove that a circle around a point intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const point = v(1.5, 1.5, 0)
-
-  expect(intersectsPoint(circle, point)).toBe(true)
-})
-
-test("it should prove that two equal circles intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(1, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two circles shifted by a small x intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(2, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two touching circles intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(3, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two non-touching circles do not intersect", () => {
-  const circle1 = { position: v(1, 1, 0), radius: 1 }
-  const circle2 = { position: v(4, 1, 0), radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(false)
-})
-
-test("it should prove that a circle inside of a rectangle intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(-1, -1, 0),
-    size: v(4, 4, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(true)
-})
-
-test("it should prove that a circle touching the border of a rectangle intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(-1, 1, 0), // Rectangle's right edge is at x=0, touching the circle's left edge.
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(true)
-})
-
-test("it should prove that a circle crossing a rectangle intersects with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(true)
-})
-
-test("it should prove that a circle outside of a rectangle does not intersect with it", () => {
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-  const rectangle = {
-    position: v(-3, 0, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(false)
-})

package/src/math/hitmask.test.js

@@ -1,156 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { findCollisions } from "./hitmask.js"
-
-/**
- * Given a rectangle located at (x=1.5, y=0, z=2.5) with a size of (1, 1, 1),
- * which is touching a wall tile, this test proves a collision is detected.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position (X,Z): R at (1.5, 2.5)
- *
- * Expected outcome: true
- */
-test("it should prove that a rectangle touching a wall intersects with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(1.5, 0, 2.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(true)
-})
-
-/**
- * Given the same scenario as the previous test, but all coordinates
- * are shifted by a constant value, this test proves the outcome remains
- * unchanged, ensuring the collision detection is relative.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position (X,Z): R at (11.5, 12.5)
- *
- * Expected outcome: true
- */
-test("it should prove that shifting operands does not change the outcome", () => {
-  const SHIFT = 10
-  const hitmask = {
-    position: [2 + SHIFT, 0, 1.5 + SHIFT],
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(11.5, 0, 12.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(true)
-})
-
-/**
- * Given a rectangle located at (x=0.5, y=0, z=0.5) with a size of (1, 1, 1),
- * which is not touching any walls, this test proves no collision is detected.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position (X,Z): R at (0.5, 0.5)
- *
- * Expected outcome: false
- */
-test("it should prove that a rectangle not touching a wall does not intersect with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(0.5, 0, 0.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})
-
-/**
- * Given a rectangle located above the tile, this test proves no
- * collision is detected even when the X and Z positions overlap.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position: R at (x=1.5, y=1.6, z=2.5)
- *
- * Expected outcome: false
- */
-test("it should prove that a rectangle above the tile of a hitmask does not intersect with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(1.5, 1.6, 2.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})
-
-/**
- * Given a rectangle located outside of the tilemap, this test proves
- * no collision is detected.
- *
- * Tilemap layout:
- * ⬛️🟩🟩⬛️
- * ⬛️⬛️⬛️⬛️
- * ⬛️⬛️⬛️⬛️
- *
- * Rectangle position: R at (x=5.5, y=0.5, z=1.5)
- *
- * Expected outcome: false
- */
-test("it should prove that a rectangle outside of a hitmask does not intersect with it", () => {
-  const hitmask = {
-    position: v(2, 0, 1.5),
-    tileSize: [1, 1],
-    columns: 4,
-    // The top row (indices 0, 1, 2, 3) now has the walls.
-    heights: [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: v(5.5, 0.5, 1.5),
-    size: v(1, 1, 1),
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})

package/src/math/line.test.js

@@ -1,50 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { distanceFromPoint, intersectsCircle } from "./line.js"
-
-test("it should compute the distance between a line and a point", () => {
-  const line = v(-4, 3, 0)
-  const point = v(5, 0, 0)
-  const expectedResult = 4
-
-  expect(distanceFromPoint(line, point)).toBe(expectedResult)
-})
-
-test("it should not compute the distance between a line and a point", () => {
-  const line = v(-1, 1, 0)
-  const point = v(2, 0, 2)
-  const expectedResult = 0
-
-  expect(distanceFromPoint(line, point)).toBe(expectedResult)
-})
-
-test("it should prove that a line that crosses a circle intersects with it", () => {
-  const line = v(-2, 2, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(true)
-})
-
-test("it should prove that a line tangent to a circle intersects with it", () => {
-  const line = v(-2, 0, 0)
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(true)
-})
-
-test("it should prove that a line that does not cross a circle does not intersect with it", () => {
-  const line = v(1, 1, 0)
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(false)
-})

package/src/math/numbers.test.js

@@ -1,198 +0,0 @@
-import { expect, test } from "vitest"
-
-import {
-  abs,
-  clamp,
-  isBetween,
-  isClose,
-  mod,
-  sign,
-  snap,
-  sqrt,
-} from "./numbers.js"
-
-test("it should return the same number if already positive", () => {
-  const num = 42
-  const expectedResult = 42
-
-  expect(abs(num)).toBe(expectedResult)
-})
-
-test("it should return the absolute value of a number", () => {
-  const num = -42
-  const expectedResult = 42
-
-  expect(abs(num)).toBe(expectedResult)
-})
-
-test("it should not clamp a number in the range", () => {
-  const num = 42
-  const min = 0
-  const max = 100
-  const expectedResult = 42
-
-  expect(clamp(num, min, max)).toBe(expectedResult)
-})
-
-test("it should clamp a number too small", () => {
-  const num = -42
-  const min = 0
-  const max = 100
-  const expectedResult = 0
-
-  expect(clamp(num, min, max)).toBe(expectedResult)
-})
-
-test("it should clamp a number too big", () => {
-  const num = 142
-  const min = 0
-  const max = 100
-  const expectedResult = 100
-
-  expect(clamp(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return true if a number is between min and max", () => {
-  const num = 50
-  const min = 0
-  const max = 100
-  const expectedResult = true
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return true if a number is equal to min", () => {
-  const num = 0
-  const min = 0
-  const max = 100
-  const expectedResult = true
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return true if a number is equal to max", () => {
-  const num = 100
-  const min = 0
-  const max = 100
-  const expectedResult = true
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return false if a number is lower than min", () => {
-  const num = -1
-  const min = 0
-  const max = 100
-  const expectedResult = false
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return false if a number is greater than max", () => {
-  const num = 101
-  const min = 0
-  const max = 100
-  const expectedResult = false
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should check if two numbers are close given some tolerance", () => {
-  const num1 = 42
-  const num2 = 42.1
-  const tolerance = 0.2
-  const expectedResult = true
-
-  expect(isClose(num1, num2, tolerance)).toBe(expectedResult)
-})
-
-test("it should return zero if dividend equals divisor", () => {
-  const num = 2
-  const divisor = 2
-  const expectedResult = 0
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should return one if number is odd", () => {
-  const num = 3
-  const divisor = 2
-  const expectedResult = 1
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should return one if negative number turns to positive one", () => {
-  const num = -3
-  const divisor = 2
-  const expectedResult = 1
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should convert a float number greater than 1 to a range between -1 and 1", () => {
-  const num = 5 / 4
-  const divisor = 1
-  const expectedResult = 1 / 4
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should convert a float number greater than 2 to a range between -1 and 1", () => {
-  const num = 13 / 4
-  const divisor = 1
-  const expectedResult = 1 / 4
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should convert a negative float number to a range between -1 and 1", () => {
-  const num = -5 / 4
-  const divisor = 1
-  const expectedResult = 3 / 4
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should return the dividend if the divisor is zero", () => {
-  const num = 42
-  const divisor = 0
-
-  expect(mod(num, divisor)).toBe(num)
-})
-
-test("it should return one if number is positive", () => {
-  const num = 42
-  const expectedResult = 1
-
-  expect(sign(num)).toBe(expectedResult)
-})
-
-test("it should return minus one if number is negative", () => {
-  const num = -42
-  const expectedResult = -1
-
-  expect(sign(num)).toBe(expectedResult)
-})
-
-test("it should return the number itself if the sign is zero", () => {
-  const num = 0
-  const expectedResult = 0
-
-  expect(sign(num)).toBe(expectedResult)
-})
-
-test("it should snap the number to the given precision", () => {
-  const num = 42
-  const precision = 10
-  const expectedResult = 40
-
-  expect(snap(num, precision)).toBe(expectedResult)
-})
-
-test("it should compute the square root of the number", () => {
-  const num = 9
-  const expectedResult = 3
-
-  expect(sqrt(num)).toBe(expectedResult)
-})

package/src/math/point.test.js

@@ -1,94 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./point.js"
-
-test("it should prove that two equal points intersect", () => {
-  const point1 = v(1.5, 1.5, 0)
-  const point2 = v(1.5, 1.5, 0)
-
-  expect(intersectsPoint(point1, point2)).toBe(true)
-})
-
-test("it should prove that two different points do not intersect", () => {
-  const point1 = v(1.5, 1.5, 0)
-  const point2 = v(2, 1, 0)
-
-  expect(intersectsPoint(point1, point2)).toBe(false)
-})
-
-test("it should prove that a point inside of a circle intersects with it", () => {
-  const point = v(1.5, 1.5, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(true)
-})
-
-test("it should prove that a point on the border of a circle intersects with it", () => {
-  const point = v(2, 1, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(true)
-})
-
-test("it should prove that a point outside of a circle does not intersect with it", () => {
-  const point = v(2, 2, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(false)
-})
-
-test("it should prove that a point inside of a rectangle intersects with it", () => {
-  const point = v(1.5, 1.5, 0)
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})
-
-test("it should prove that a point on the border of a rectangle intersects with it", () => {
-  const point = v(2, 1, 0)
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})
-
-test("it should prove that a point outside of a rectangle does not intersect with it", () => {
-  const point = v(2.5, 2.5, 0)
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(false)
-})
-
-test("it should work even if the point is an object with a position", () => {
-  const point = {
-    position: v(1.5, 1.5, 0),
-  }
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})

package/src/math/quaternion.test.js

@@ -1,25 +0,0 @@
-import { expect, test } from "vitest"
-
-import { quaternion } from "./quaternion.js"
-import { cos, pi, sin } from "./trigonometry.js"
-
-test("it should return the quaternion for no rotation", () => {
-  const angle = 0
-  const expectedResult = [1, 0, 0, 0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
-
-test("it should return the quaternion for a rotation of pi/2", () => {
-  const angle = pi() / 2
-  const expectedResult = [cos(pi() / 4), 0, sin(pi() / 4), 0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
-
-test("it should return the quaternion for a rotation of negative pi/2", () => {
-  const angle = -pi() / 2
-  const expectedResult = [cos(-pi() / 4), -0, sin(-pi() / 4), -0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})

package/src/math/quaternions.test.js

@@ -1,29 +0,0 @@
-import { expect, test } from "vitest"
-
-import { quaternion } from "./quaternion.js"
-import { combine } from "./quaternions.js"
-import { cos, pi, sin } from "./trigonometry.js"
-
-test("it should combine two zero-angle quaternions by giving the same 0-angle quaternion", () => {
-  const q1 = quaternion(0)
-  const q2 = quaternion(0)
-  const expectedResult = [1, 0, 0, 0]
-
-  expect(combine(q1, q2)).toStrictEqual(expectedResult)
-})
-
-test("it should combine a zero-angle quaternion with a nonzero-angle quaternion", () => {
-  const q1 = quaternion(0)
-  const q2 = quaternion(pi() / 2)
-  const expectedResult = [cos(pi() / 4), 0, sin(pi() / 4), 0]
-
-  expect(combine(q1, q2)).toStrictEqual(expectedResult)
-})
-
-test("it should combine two nonzero-angle quaternions", () => {
-  const q1 = quaternion(pi() / 2)
-  const q2 = quaternion(pi() / 2)
-  const expectedResult = [2.220446049250313e-16, 0, 1, 0] // close to [0, 0, 1, 0]
-
-  expect(combine(q1, q2)).toStrictEqual(expectedResult)
-})

package/src/math/rectangle.test.js

@@ -1,43 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { intersectsRectangle } from "./rectangle.js"
-
-test("it should prove that a rectangle crossing another one intersects with it", () => {
-  const rectangle1 = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 2),
-  }
-  const rectangle2 = {
-    position: v(1, 1, 1),
-    size: v(2, 2, 2),
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
-})
-
-test("it should prove that a rectangle right on top of another intersects with it", () => {
-  const rectangle1 = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 2),
-  }
-  const rectangle2 = {
-    position: v(0, 0, 0),
-    size: v(2, 0, 2),
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
-})
-
-test("it should prove that a rectangle not crossing another one does not intersect with it", () => {
-  const rectangle1 = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 2),
-  }
-  const rectangle2 = {
-    position: v(3, 3, 3),
-    size: v(2, 2, 2),
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(false)
-})