@inglorious/engine 0.2.0 → 0.3.0

package/src/utils/math/geometry/circle.js

@@ -1,70 +0,0 @@
-/**
- * @typedef {import("./types").Point} Point
- * @typedef {import("./types").Circle} Circle
- * @typedef {import("./types").Rectangle} Rectangle
- * @typedef {import("./types").Platform} Platform
- */
-
-import { clamp } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-import { intersectsCircle as pointIntersectsCircle } from "./point.js"
-import { hypothenuse } from "./triangle.js"
-
-const HALF = 2
-const SQUARED = 2
-const INITIAL_SUM = 0
-
-/**
- * Checks if a circle intersects with a point.
- * @param {Circle} circle - The circle to check.
- * @param {Point} point - The point to check.
- * @returns {boolean} True if the point intersects the circle, false otherwise.
- */
-export function intersectsPoint(circle, point) {
-  return pointIntersectsCircle(point, circle)
-}
-
-/**
- * Checks if two circles intersect.
- * @param {Circle} circle1 - The first circle.
- * @param {Circle} circle2 - The second circle.
- * @returns {boolean} True if the circles intersect, false otherwise.
- */
-export function intersectsCircle(circle1, circle2) {
-  return (
-    hypothenuse(...subtract(circle1.position, circle2.position)) <=
-    circle1.radius + circle2.radius
-  )
-}
-
-/**
- * Checks if a circle intersects with a rectangle.
- * @param {Circle} circle - The circle to check.
- * @param {Rectangle} rectangle - The rectangle to check.
- * @returns {boolean} True if the circle intersects the rectangle, false otherwise.
- */
-export function intersectsRectangle(circle, rectangle) {
-  const [rectX, rectY, rectZ] = rectangle.position
-  const [width, height, depth] = rectangle.size
-
-  const left = rectX - width / HALF
-  const right = rectX + width / HALF
-  const bottom = rectY - height / HALF
-  const top = rectY + height / HALF
-  const back = rectZ - depth / HALF
-  const front = rectZ + depth / HALF
-
-  const closestPoint = clamp(
-    circle.position,
-    [left, bottom, back],
-    [right, top, front],
-  )
-
-  const distanceSquared = subtract(circle.position, closestPoint).reduce(
-    (sum, value) => sum + value ** SQUARED,
-    INITIAL_SUM,
-  )
-
-  return distanceSquared <= circle.radius ** SQUARED
-}

package/src/utils/math/geometry/circle.test.js

@@ -1,97 +0,0 @@
-import { expect, test } from "vitest"
-
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./circle.js"
-
-test("it should prove that a circle around a point intersects with it", () => {
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-  const point = [1.5, 1.5, 0]
-
-  expect(intersectsPoint(circle, point)).toBe(true)
-})
-
-test("it should prove that two equal circles intersect", () => {
-  const circle1 = { position: [1, 1, 0], radius: 1 }
-  const circle2 = { position: [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: [1, 1, 0], radius: 1 }
-  const circle2 = { position: [2, 1, 0], radius: 1 }
-
-  expect(intersectsCircle(circle1, circle2)).toBe(true)
-})
-
-test("it should prove that two touching circles intersect", () => {
-  const circle1 = { position: [1, 1, 0], radius: 1 }
-  const circle2 = { position: [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: [1, 1, 0], radius: 1 }
-  const circle2 = { position: [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: [1, 1, 0],
-    radius: 1,
-  }
-  const rectangle = {
-    position: [-1, -1, 0],
-    size: [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: [1, 1, 0],
-    radius: 1,
-  }
-  const rectangle = {
-    position: [-1, 1, 0], // Rectangle's right edge is at x=0, touching the circle's left edge.
-    size: [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: [1, 1, 0],
-    radius: 1,
-  }
-  const rectangle = {
-    position: [0, 0, 0],
-    size: [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: [1, 1, 0],
-    radius: 1,
-  }
-  const rectangle = {
-    position: [-3, 0, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(circle, rectangle)).toBe(false)
-})

package/src/utils/math/geometry/hitmask.js

@@ -1,70 +0,0 @@
-// @see https://jonathanwhiting.com/tutorial/collision/
-
-import { intersectsRectangle } from "./rectangle.js"
-
-const FIRST_TILE = 0
-const HALF = 2
-const LAST_ROW = 1
-
-export function findCollisions(hitmask, target) {
-  const [tilemapX, tilemapY, tilemapZ] = hitmask.position
-  const [tileWidth, tileDepth] = hitmask.tileSize
-  const halfTileWidth = tileWidth / HALF
-  const halfTileDepth = tileDepth / HALF
-
-  const dRows = Math.ceil(hitmask.heights.length / hitmask.columns)
-  const tilemapWidth = hitmask.columns * tileWidth
-  const tilemapDepth = dRows * tileDepth
-
-  const tilemapLeft = tilemapX - tilemapWidth / HALF
-  const tilemapBack = tilemapZ - tilemapDepth / HALF
-
-  const [targetX, , targetZ] = target.position
-  const [targetWidth, , targetDepth] = target.size
-  const targetHalfWidth = targetWidth / HALF
-  const targetHalfDepth = targetDepth / HALF
-
-  const targetLeft = targetX - targetHalfWidth
-  const targetRight = targetX + targetHalfWidth
-  const targetBack = targetZ - targetHalfDepth
-  const targetFront = targetZ + targetHalfDepth
-
-  const minTileX = Math.floor((targetLeft - tilemapLeft) / tileWidth)
-  const maxTileX = Math.floor((targetRight - tilemapLeft) / tileWidth)
-  const minTileZ = Math.floor((targetBack - tilemapBack) / tileDepth)
-  const maxTileZ = Math.floor((targetFront - tilemapBack) / tileDepth)
-
-  for (let i = minTileX; i <= maxTileX; i++) {
-    for (let j = minTileZ; j <= maxTileZ; j++) {
-      if (
-        i < FIRST_TILE ||
-        i >= hitmask.columns ||
-        j < FIRST_TILE ||
-        j >= dRows
-      ) {
-        continue
-      }
-
-      const invertedRow = dRows - LAST_ROW - j
-      const tileIndex = invertedRow * hitmask.columns + i
-      const tileHeightValue = hitmask.heights[tileIndex]
-
-      if (tileHeightValue) {
-        const tileRectangle = {
-          position: [
-            tilemapLeft + i * tileWidth + halfTileWidth,
-            tilemapY,
-            tilemapBack + j * tileDepth + halfTileDepth,
-          ],
-          size: [tileWidth, tileHeightValue, tileDepth],
-        }
-
-        if (intersectsRectangle(target, tileRectangle)) {
-          return true
-        }
-      }
-    }
-  }
-
-  return false
-}

package/src/utils/math/geometry/hitmask.test.js

@@ -1,155 +0,0 @@
-import { expect, test } from "vitest"
-
-import { findCollisions } from "./hitmask"
-
-/**
- * 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: [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: [1.5, 0, 2.5],
-    size: [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: [11.5, 0, 12.5],
-    size: [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: [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: [0.5, 0, 0.5],
-    size: [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: [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: [1.5, 1.6, 2.5],
-    size: [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: [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: [5.5, 0.5, 1.5],
-    size: [1, 1, 1],
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})

package/src/utils/math/geometry/line.js

@@ -1,35 +0,0 @@
-/**
- * @typedef {import("./types").Line} Line
- * @typedef {import("./types").Point} Point
- * @typedef {import("./types").Circle} Circle
- */
-
-import { abs } from "@inglorious/utils/math/numbers.js"
-
-import { hypothenuse } from "./triangle.js"
-
-/**
- * Calculates the shortest distance from a point to a line in 2D space.
- *
- * @param {Line} line - The line represented by the equation ax + bz + c = 0, where `line` is [a, b, c].
- * @param {Point} point - The point in 3D space represented as [x, y, z].
- * @returns {number} The shortest distance from the point to the line.
- */
-export function distanceFromPoint(line, point) {
-  const [a, b, c] = line
-  const [x, , z] = point
-
-  return abs(a * x + b * z + c) / hypothenuse(a, b)
-}
-
-// @see https://math.stackexchange.com/questions/275529/check-if-line-intersects-with-circles-perimeter
-/**
- * Determines whether a line intersects with the perimeter of a circle.
- *
- * @param {Line} line - The line represented by the equation ax + bz + c = 0, where `line` is [a, b, c].
- * @param {Circle} circle - The circle defined by its position (center) and radius.
- * @returns {boolean} `true` if the line intersects the circle's perimeter, otherwise `false`.
- */
-export function intersectsCircle(line, circle) {
-  return distanceFromPoint(line, circle.position) <= circle.radius
-}

package/src/utils/math/geometry/line.test.js

@@ -1,49 +0,0 @@
-import { expect, test } from "vitest"
-
-import { distanceFromPoint, intersectsCircle } from "./line.js"
-
-test("it should compute the distance between a line and a point", () => {
-  const line = [-4, 3, 0]
-  const point = [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 = [-1, 1, 0]
-  const point = [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 = [-2, 2, 0]
-  const circle = {
-    position: [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 = [-2, 0, 0]
-  const circle = {
-    position: [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 = [1, 1, 0]
-  const circle = {
-    position: [1, 0, 1],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(line, circle)).toBe(false)
-})

package/src/utils/math/geometry/point.js

@@ -1,78 +0,0 @@
-/**
- * @typedef {import("./types").Point} Point
- * @typedef {import("./types").Line} Line
- * @typedef {import("./types").Circle} Circle
- * @typedef {import("./types").Rectangle} Rectangle
- */
-
-const SQUARED = 2
-const HALF = 2
-
-import { distanceFromPoint } from "./line.js"
-
-/**
- * Calculates the distance from a point to a line.
- * @param {Point} point - The point as a 3D coordinate [x, y, z].
- * @param {Line} line - The line to calculate the distance from.
- * @returns {number} The distance from the point to the line.
- */
-export function getDistanceFromLine(point, line) {
-  return distanceFromPoint(line, point)
-}
-
-/**
- * Checks if two points intersect.
- * @param {Point} point1 - The first point as a 3D coordinate [x, y, z].
- * @param {Point} point2 - The second point as a 3D coordinate [x, y, z].
- * @returns {boolean} True if the points intersect, false otherwise.
- */
-export function intersectsPoint(point1, point2) {
-  const [x1, y1, z1] = point1
-  const [x2, y2, z2] = point2
-  return x1 === x2 && y1 === y2 && z1 === z2
-}
-
-/**
- * Checks if a point intersects with a circle.
- * @param {Point} point - The point as a 3D coordinate [x, y, z].
- * @param {Circle} circle - The circle with a position and radius.
- * @returns {boolean} True if the point intersects the circle, false otherwise.
- */
-export function intersectsCircle(point, circle) {
-  const [x, y, z] = point
-  const [cx, cy, cz] = circle.position
-  const radius = circle.radius
-
-  return (
-    (x - cx) ** SQUARED + (y - cy) ** SQUARED + (z - cz) ** SQUARED <=
-    radius ** SQUARED
-  )
-}
-
-/**
- * Checks if a point intersects with a rectangle.
- * @param {Point} point - The point as a 3D coordinate [x, y, z].
- * @param {Rectangle} rectangle - The rectangle with a position and size.
- * @returns {boolean} True if the point intersects the rectangle, false otherwise.
- */
-export function intersectsRectangle(point, rectangle) {
-  const [x, y, z] = point
-  const [rectX, rectY, rectZ] = rectangle.position
-  const [width, height, depth] = rectangle.size
-
-  const left = rectX - width / HALF
-  const right = rectX + width / HALF
-  const bottom = rectY - height / HALF
-  const top = rectY + height / HALF
-  const back = rectZ - depth / HALF
-  const front = rectZ + depth / HALF
-
-  return (
-    x >= left &&
-    x <= right &&
-    y >= bottom &&
-    y <= top &&
-    z >= back &&
-    z <= front
-  )
-}

package/src/utils/math/geometry/point.test.js

@@ -1,81 +0,0 @@
-import { expect, test } from "vitest"
-
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./point.js"
-
-test("it should prove that two equal points intersect", () => {
-  const point1 = [1.5, 1.5, 0]
-  const point2 = [1.5, 1.5, 0]
-
-  expect(intersectsPoint(point1, point2)).toBe(true)
-})
-
-test("it should prove that two different points do not intersect", () => {
-  const point1 = [1.5, 1.5, 0]
-  const point2 = [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 = [1.5, 1.5, 0]
-  const circle = {
-    position: [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 = [2, 1, 0]
-  const circle = {
-    position: [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 = [2, 2, 0]
-  const circle = {
-    position: [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 = [1.5, 1.5, 0]
-  const rectangle = {
-    position: [1, 1, 0],
-    size: [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 = [2, 1, 0]
-  const rectangle = {
-    position: [1, 1, 0],
-    size: [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 = [2.5, 2.5, 0]
-  const rectangle = {
-    position: [1, 1, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(false)
-})