@inglorious/engine 0.1.1 → 0.3.0

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 on the border of a rectangle intersects with it", () => {
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-  const rectangle = {
-    position: [-2, 0, 0],
-    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: [-1, -1, 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,39 +0,0 @@
-// @see https://jonathanwhiting.com/tutorial/collision/
-
-const LOWER_BOUND = 0
-const TOP_TILE_OFFSET = 1 // Offset to include the top boundary tile
-
-export function findCollisions(hitmask, target) {
-  const { position, tileSize, columns, heights } = hitmask
-  const [left, top, front] = position
-  const [tileWidth, tileHeight] = tileSize
-  const rows = heights.length / columns
-
-  const [x, y, z] = target.position
-  const [width, height, depth] = target.size
-
-  const leftTile = Math.floor((x - left) / tileWidth)
-  const rightTile = Math.floor((x - left + width) / tileWidth)
-  const bottomTile = Math.floor((z - front) / tileHeight)
-  const topTile = Math.floor((z - front + depth) / tileHeight)
-
-  if (
-    leftTile < LOWER_BOUND ||
-    rightTile > columns ||
-    bottomTile < LOWER_BOUND ||
-    topTile > rows
-  ) {
-    return false
-  }
-
-  for (let i = leftTile; i < rightTile; i++) {
-    for (let j = bottomTile; j <= topTile + TOP_TILE_OFFSET; j++) {
-      const heightAtTile = heights[i * columns + j]
-      if (y + height <= top + heightAtTile) {
-        return true
-      }
-    }
-  }
-
-  return false
-}

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

@@ -1,84 +0,0 @@
-import { expect, test } from "vitest"
-
-import { findCollisions } from "./hitmask"
-
-test("it should prove that a rectangle touching a wall intersects with it", () => {
-  const hitmask = {
-    position: [0, 0, 0],
-    tileSize: [1, 1],
-    columns: 4,
-    heights: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: [2.5, 0, 1.5],
-    size: [1, 1, 1],
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(true)
-})
-
-test("it should prove that shifting operands does not change the outcome", () => {
-  const SHIFT = 10
-  const hitmask = {
-    position: [0 + SHIFT, 0, 0 + SHIFT],
-    tileSize: [1, 1],
-    columns: 4,
-    heights: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: [2.5 + SHIFT, 0, 1.5 + SHIFT],
-    size: [1, 1, 1],
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(true)
-})
-
-test("it should prove that a rectangle not touching a wall does not intersect with it", () => {
-  const hitmask = {
-    position: [0, 0, 0],
-    tileSize: [1, 1],
-    columns: 4,
-    heights: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: [0.5, 0, 0.5],
-    size: [1, 1, 1],
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})
-
-test("it should prove that a rectangle above the tile of a hitmask does not intersect with it", () => {
-  const hitmask = {
-    position: [0, 0, 0],
-    tileSize: [1, 1],
-    columns: 4,
-    heights: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: [2.5, 1, 1.5],
-    size: [1, 1, 1],
-  }
-
-  expect(findCollisions(hitmask, rectangle)).toBe(false)
-})
-
-test("it should prove that a rectangle outside of a hitmask does not intersect with it", () => {
-  const hitmask = {
-    position: [0, 0, 0],
-    tileSize: [1, 1],
-    columns: 4,
-    heights: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
-  }
-  const rectangle = {
-    shape: "rectangle",
-    position: [5, 0, 1],
-    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/platform.js

@@ -1,42 +0,0 @@
-/**
- * Checks if a platform intersects with a circle in 3D space.
- * @param {Platform} platform - The platform to check.
- * @param {Circle} circle - The circle to check.
- * @returns {boolean} True if the platform intersects the circle, false otherwise.
- */
-export function intersectsCircle(platform, circle) {
-  const [left, top, front] = platform.position
-  const [extension, elevation, thickness] = platform.size
-
-  const [x, y, z] = circle.position
-
-  const lowestPoint = y - circle.radius
-  const isAbove = lowestPoint <= top && lowestPoint >= top - elevation
-
-  const isOverlappingX = x >= left && x <= left + extension
-  const isOverlappingZ = z >= front && z <= front + thickness
-
-  return isAbove && isOverlappingX && isOverlappingZ
-}
-
-/**
- * Determines whether platform intersects with a rectangle in 3D space.
- *
- * @param {Platform} platform - The platform defined by its position (top-left-front corner) and size (extension, elevation, thickness).
- * @param {Rectangle} rectangle - The rectangle defined by its position (top-left-front corner) and size (width, height, depth).
- * @returns {boolean} True if the platform intersects the rectangle, false otherwise.
- */
-export function intersectsRectangle(platform, rectangle) {
-  const [left, top, front] = platform.position
-  const [extension, elevation, thickness] = platform.size
-
-  const [x, y, z] = rectangle.position
-  const [width, , depth] = rectangle.size
-
-  const isAbove = y >= top && y <= top + elevation
-
-  const isOverlappingX = x + width >= left && x <= left + extension
-  const isOverlappingZ = z + depth >= front && z <= front + thickness
-
-  return isAbove && isOverlappingX && isOverlappingZ
-}

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

@@ -1,133 +0,0 @@
-import { expect, test } from "vitest"
-
-import { intersectsCircle, intersectsRectangle } from "./platform"
-
-test("it should prove that a circle right above a platform intersects with it", () => {
-  const platform = {
-    position: [-1, 0, 0],
-    size: [2, 1, 0],
-  }
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(platform, circle)).toBe(true)
-})
-
-test("it should prove that a circle way above a platform intersects with it", () => {
-  const platform = {
-    position: [0, 0, -2],
-    size: [2, 1, 0],
-  }
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(platform, circle)).toBe(false)
-})
-
-test("it should prove that a circle crossing a platform does not intersect with it", () => {
-  const platform = {
-    position: [-1, -1, 0],
-    size: [2, 2, 0],
-  }
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(platform, circle)).toBe(false)
-})
-
-test("it should prove that a circle below a platform does not intersect with it", () => {
-  const platform = {
-    position: [0, 2, 0],
-    size: [2, 1, 0],
-  }
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(platform, circle)).toBe(false)
-})
-
-test("it should prove that a circle not crossing a platform horizontally does not intersect with it", () => {
-  const platform = {
-    position: [-3, -1, 0],
-    size: [2, 1, 0],
-  }
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(platform, circle)).toBe(false)
-})
-
-test("it should prove that a rectangle crossing a platform from above intersects with it", () => {
-  const platform = {
-    position: [0, -1, 0],
-    size: [2, 2, 0],
-  }
-  const rectangle = {
-    position: [0, 0, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(platform, rectangle)).toBe(true)
-})
-
-test("it should prove that a rectangle right on top of a platform intersects with it", () => {
-  const platform = {
-    position: [0, -2, 0],
-    size: [2, 2, 0],
-  }
-  const rectangle = {
-    position: [0, 0, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(platform, rectangle)).toBe(true)
-})
-
-test("it should prove that a rectangle crossing a platform from below does not intersect with it", () => {
-  const platform = {
-    position: [0, 1, 0],
-    size: [2, 2, 0],
-  }
-  const rectangle = {
-    position: [0, 0, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(platform, rectangle)).toBe(false)
-})
-
-test("it should prove that a rectangle below a platform does not intersect with it", () => {
-  const platform = {
-    position: [0, -3, 0],
-    size: [2, 2, 0],
-  }
-  const rectangle = {
-    position: [0, 0, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(platform, rectangle)).toBe(false)
-})
-
-test("it should prove that a rectangle not crossing a platform horizontally does not intersect with it", () => {
-  const platform = {
-    position: [-3, 0, 0],
-    size: [2, 2, 0],
-  }
-  const rectangle = {
-    position: [0, 0, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(platform, rectangle)).toBe(false)
-})

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

@@ -1,71 +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 [left, top, front] = circle.position
-  const radius = circle.radius
-
-  return (
-    (x - left) ** SQUARED + (y - top) ** SQUARED + (z - front) ** 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 [left, top, front] = rectangle.position
-  const [width, height, depth] = rectangle.size
-
-  return (
-    x >= left - width / HALF &&
-    x <= left + width / HALF &&
-    y >= top - height / HALF &&
-    y <= top + height / HALF &&
-    z >= front - depth / HALF &&
-    z <= front + depth / HALF
-  )
-}

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,45 +0,0 @@
-/**
- * @typedef {import("./types").Rectangle} Rectangle
- * @typedef {import("./types").Platform} Platform
- */
-
-import { intersectsRectangle as circleIntersectsRectangle } from "./circle.js"
-import { intersectsRectangle as platformIntersectsRectangle } from "./platform.js"
-
-export function intersectsCircle(rectangle, circle) {
-  return circleIntersectsRectangle(circle, rectangle)
-}
-
-/**
- * Determines whether a rectangle intersects another in 3D space.
- *
- * @param {Rectangle} rectangle1 - The rectangle defined by its position (x, y, z) and size (width, height, depth).
- * @param {Rectangle} rectangle2 - The other rectangle defined by its position (z, 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 [x2, y2, z2] = rectangle2.position
-  const [w2, h2, d2] = rectangle2.size
-
-  return (
-    x1 <= x2 + w2 &&
-    x1 + w1 >= x2 &&
-    y1 <= y2 + h2 &&
-    y1 + h1 >= y2 &&
-    z1 <= z2 + d2 &&
-    z1 + d1 >= z2
-  )
-}
-
-/**
- * Checks if a rectangle intersects with a platform.
- * @param {Rectangle} rectangle - The rectangle to check.
- * @param {Platform} platform - The platform to check.
- * @returns {boolean} True if the rectangle intersects the platform, false otherwise.
- */
-export function intersectsPlatform(rectangle, platform) {
-  return platformIntersectsRectangle(platform, rectangle)
-}