@inglorious/engine 0.1.0 → 0.2.0

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

@@ -1,117 +1,70 @@
-/**
- * @typedef {import("./types").Point} Point
- * @typedef {import("./types").Circle} Circle
- * @typedef {import("./types").Rectangle} Rectangle
- * @typedef {import("./types").Platform} Platform
- */
-
-import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-import { clamp } from "../numbers.js"
-import { intersectsCircle as platformIntersectsCircle } from "./platform.js"
-import {
-  intersectsCircle as pointIntersectsCircle,
-  intersectsRectangle as pointIntersectsRectangle,
-} from "./point.js"
-import { intersectsCircle as segmentIntersectsCircle } from "./segment.js"
-import { hypothenuse } from "./triangle.js"
-
-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 [left, top, front] = rectangle.position
-  const [width, height, depth] = rectangle.size
-
-  const ltf = [left, top, front]
-  const rtf = [left + width, top, front]
-  const lbf = [left, top, front + depth]
-  const rbf = [left + width, top, front + depth]
-
-  const ltb = [left, top + height, front]
-  const rtb = [left + width, top + height, front]
-  const lbb = [left, top + height, front + depth]
-  const rbb = [left + width, top + height, front + depth]
-
-  return (
-    // Center
-    pointIntersectsRectangle(circle.position, rectangle) ||
-    // Front face
-    segmentIntersectsCircle({ from: ltf, to: rtf }, circle) ||
-    segmentIntersectsCircle({ from: rtf, to: rbf }, circle) ||
-    segmentIntersectsCircle({ from: rbf, to: lbf }, circle) ||
-    segmentIntersectsCircle({ from: lbf, to: ltf }, circle) ||
-    // Back face
-    segmentIntersectsCircle({ from: ltb, to: rtb }, circle) ||
-    segmentIntersectsCircle({ from: rtb, to: rbb }, circle) ||
-    segmentIntersectsCircle({ from: rbb, to: lbb }, circle) ||
-    segmentIntersectsCircle({ from: lbb, to: ltb }, circle) ||
-    // Connecting edges
-    segmentIntersectsCircle({ from: ltf, to: ltb }, circle) ||
-    segmentIntersectsCircle({ from: rtf, to: rtb }, circle) ||
-    segmentIntersectsCircle({ from: lbf, to: lbb }, circle) ||
-    segmentIntersectsCircle({ from: rbf, to: rbb }, circle) ||
-    // Corners
-    isCircleWithinRectangleRadius(circle, rectangle)
-  )
-}
-
-/**
- * Checks if a circle intersects with a platform.
- * @param {Circle} circle - The circle to check.
- * @param {Platform} platform - The platform to check.
- * @returns {boolean} True if the circle intersects the platform, false otherwise.
- */
-export function intersectsPlatform(circle, platform) {
-  return platformIntersectsCircle(platform, circle)
-}
-
-function isCircleWithinRectangleRadius(circle, rectangle) {
-  const [left, top, front] = rectangle.position
-  const [width, height, depth] = rectangle.size
-
-  // Find the closest point on the rectangle to the circle's center
-  const [x, y, z] = circle.position
-  const closestPoint = [
-    clamp(x, left, left + width),
-    clamp(y, top, top + height),
-    clamp(z, front, front + depth),
-  ]
-
-  // Calculate the distance from the circle's center to the closest point
-  const distanceSquared = subtract(circle.position, closestPoint).reduce(
-    (sum, value) => sum + value ** SQUARED,
-    INITIAL_SUM,
-  )
-
-  return distanceSquared <= circle.radius ** SQUARED
-}
+/**
+ * @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 +1,97 @@
-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)
-})
+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,39 +1,70 @@
-// @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
-}
+// @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
+}