@inglorious/engine 0.2.0 → 0.4.0

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)
-})

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

@@ -1,76 +0,0 @@
-/**
- * @typedef {import("./types").Circle} Circle
- * @typedef {import("./types").Rectangle} Rectangle
- * @typedef {import("./types").Platform} Platform
- */
-
-import { intersectsRectangle as circleIntersectsRectangle } from "./circle.js"
-import { intersectsRectangle as pointIntersectsRectangle } from "./point.js"
-
-const HALF = 2
-
-/**
- * Checks if a rectangle intersects with a point.
- * @param {Rectangle} rectangle - The rectangle to check.
- * @param {Point} point - The point to check.
- * @returns {boolean} True if the point intersects the circle, false otherwise.
- */
-export function intersectsPoint(rectangle, point) {
-  return pointIntersectsRectangle(point, rectangle)
-}
-
-/**
- * Checks if a rectangle intersects with a circle.
- *
- * @param {Rectangle} rectangle - The rectangle to check.
- * @param {Circle} circle - The circle to check.
- * @returns {boolean} True if the rectangle intersects the circle, false otherwise.
- */
-export function intersectsCircle(rectangle, circle) {
-  return circleIntersectsRectangle(circle, rectangle)
-}
-
-/**
- * Determines whether a rectangle intersects another in 3D space.
- *
- * @param {Rectangle} rectangle1 - The first rectangle, defined by its position (x, y, z) and size (width, height, depth).
- * @param {Rectangle} rectangle2 - The second rectangle, defined by its position (x, y, z) and size (width, height, depth).
- * @returns {boolean} True if the two rectangles intersect, false otherwise.
- */
-export function intersectsRectangle(rectangle1, rectangle2) {
-  const [x1, y1, z1] = rectangle1.position
-  const [w1, h1, d1] = rectangle1.size
-  const halfW1 = w1 / HALF
-  const halfH1 = h1 / HALF
-  const halfD1 = d1 / HALF
-
-  const left1 = x1 - halfW1
-  const right1 = x1 + halfW1
-  const bottom1 = y1 - halfH1
-  const top1 = y1 + halfH1
-  const back1 = z1 - halfD1
-  const front1 = z1 + halfD1
-
-  const [x2, y2, z2] = rectangle2.position
-  const [w2, h2, d2] = rectangle2.size
-  const halfW2 = w2 / HALF
-  const halfH2 = h2 / HALF
-  const halfD2 = d2 / HALF
-
-  const left2 = x2 - halfW2
-  const right2 = x2 + halfW2
-  const bottom2 = y2 - halfH2
-  const top2 = y2 + halfH2
-  const back2 = z2 - halfD2
-  const front2 = z2 + halfD2
-
-  // AABB intersection test
-  return (
-    left1 <= right2 &&
-    right1 >= left2 &&
-    bottom1 <= top2 &&
-    top1 >= bottom2 &&
-    back1 <= front2 &&
-    front1 >= back2
-  )
-}

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

@@ -1,42 +0,0 @@
-import { expect, test } from "vitest"
-
-import { intersectsRectangle } from "./rectangle.js"
-
-test("it should prove that a rectangle crossing another one intersects with it", () => {
-  const rectangle1 = {
-    position: [0, 0, 0],
-    size: [2, 2, 2],
-  }
-  const rectangle2 = {
-    position: [1, 1, 1],
-    size: [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: [0, 0, 0],
-    size: [2, 2, 2],
-  }
-  const rectangle2 = {
-    position: [0, 0, 0],
-    size: [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: [0, 0, 0],
-    size: [2, 2, 2],
-  }
-  const rectangle2 = {
-    position: [3, 3, 3],
-    size: [2, 2, 2],
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(false)
-})

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

@@ -1,80 +0,0 @@
-/**
- * @typedef {import("./types").Segment} Segment
- * @typedef {import("./types").Point} Point
- * @typedef {import("./types").Circle} Circle
- */
-
-import {
-  magnitude,
-  setMagnitude,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import {
-  distance,
-  dot,
-  subtract,
-  sum,
-} from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-const BEFORE_SEGMENT = 0
-
-/**
- * Calculates the coefficients [a, b, c] of the line equation ax + bz + c = 0
- * for a given segment in 2D space.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @returns {[number, number, number]} An array [a, b, c] representing the line equation.
- */
-export function coefficients(segment) {
-  const [x1, , z1] = segment.from
-  const [x2, , z2] = segment.to
-  return [z1 - z2, x2 - x1, (x1 - x2) * z1 + x1 * (z2 - z1)]
-}
-
-/**
- * Finds the closest point on a segment to a given point in 3D space.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @param {Point} point - The point in 3D space represented as [x, y, z].
- * @returns {Point} The closest point on the segment to the given point.
- */
-export function closestPoint(segment, point) {
-  const shiftedSegment = subtract(segment.to, segment.from)
-  const shiftedPoint = subtract(point, segment.from)
-
-  const projectionLength =
-    dot(shiftedSegment, shiftedPoint) / magnitude(shiftedSegment)
-
-  if (projectionLength < BEFORE_SEGMENT) {
-    return segment.from
-  }
-
-  if (projectionLength > magnitude(shiftedSegment)) {
-    return segment.to
-  }
-
-  const projectedPoint = setMagnitude(shiftedSegment, projectionLength)
-  return sum(segment.from, projectedPoint)
-}
-
-/**
- * Calculates the shortest distance from a point to a segment in 3D space.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @param {Point} point - The point in 3D space represented as [x, y, z].
- * @returns {number} The shortest distance from the point to the segment.
- */
-export function distanceFromPoint(segment, point) {
-  const closest = closestPoint(segment, point)
-  return distance(point, closest)
-}
-
-/**
- * Determines whether a segment intersects with the perimeter of a circle.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @param {Circle} circle - The circle defined by its position (center) and radius.
- * @returns {boolean} `true` if the segment intersects the circle's perimeter, otherwise `false`.
- */
-export function intersectsCircle(segment, circle) {
-  return distanceFromPoint(segment, circle.position) <= circle.radius
-}