@inglorious/engine 0.2.0 → 0.4.0

package/src/{engine/movement → movement}/kinematic/modern.js

@@ -1,16 +1,16 @@
-import {
-  angle,
-  magnitude,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import { applyVelocity } from "@inglorious/utils/physics/velocity.js"
-
-const DEFAULT_ORIENTATION = 0
-
-export function modernMove(entity, dt) {
-  const { velocity, position } = applyVelocity(entity, dt)
-
-  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
-  orientation = magnitude(velocity) ? angle(velocity) : orientation
-
-  return { velocity, position, orientation }
-}
+import {
+  angle,
+  magnitude,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { applyVelocity } from "@inglorious/utils/physics/velocity.js"
+
+const DEFAULT_ORIENTATION = 0
+
+export function modernMove(entity, dt) {
+  const { velocity, position } = applyVelocity(entity, dt)
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation = magnitude(velocity) ? angle(velocity) : orientation
+
+  return { velocity, position, orientation }
+}

package/src/{engine/movement → movement}/kinematic/modern.test.js

@@ -1,27 +1,27 @@
-import { expect, test } from "vitest"
-
-import { modernMove } from "./modern.js"
-
-test("it should move following its velocity", () => {
-  const entity = { maxSpeed: 1, velocity: [1, 0, 0], position: [0, 0, 0] }
-  const dt = 1
-  const expectedResult = {
-    velocity: [1, 0, 0],
-    position: [1, 0, 0],
-    orientation: 0,
-  }
-
-  expect(modernMove(entity, dt)).toStrictEqual(expectedResult)
-})
-
-test("it should limit the velocity to the max speed", () => {
-  const entity = { maxSpeed: 1, velocity: [10, 0, 0], position: [0, 0, 0] }
-  const dt = 1
-  const expectedResult = {
-    velocity: [1, 0, 0],
-    position: [1, 0, 0],
-    orientation: 0,
-  }
-
-  expect(modernMove(entity, dt)).toStrictEqual(expectedResult)
-})
+import { expect, test } from "vitest"
+
+import { modernMove } from "./modern.js"
+
+test("it should move following its velocity", () => {
+  const entity = { maxSpeed: 1, velocity: [1, 0, 0], position: [0, 0, 0] }
+  const dt = 1
+  const expectedResult = {
+    velocity: [1, 0, 0],
+    position: [1, 0, 0],
+    orientation: 0,
+  }
+
+  expect(modernMove(entity, dt)).toStrictEqual(expectedResult)
+})
+
+test("it should limit the velocity to the max speed", () => {
+  const entity = { maxSpeed: 1, velocity: [10, 0, 0], position: [0, 0, 0] }
+  const dt = 1
+  const expectedResult = {
+    velocity: [1, 0, 0],
+    position: [1, 0, 0],
+    orientation: 0,
+  }
+
+  expect(modernMove(entity, dt)).toStrictEqual(expectedResult)
+})

package/src/{engine/movement → movement}/kinematic/tank.js

@@ -1,27 +1,27 @@
-import {
-  clamp,
-  multiply,
-  rotate,
-  zero,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
-import { toRange } from "@inglorious/utils/math/trigonometry.js"
-
-const DEFAULT_MAX_SPEED = 0
-
-const DEFAULT_ORIENTATION = 0
-
-export function tankMove(entity, dt) {
-  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
-
-  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
-  orientation = toRange(orientation)
-
-  let velocity = entity.velocity ?? zero()
-  velocity = rotate(velocity, orientation)
-  velocity = clamp(velocity, -maxSpeed, maxSpeed)
-
-  const position = sum(entity.position, multiply(velocity, dt))
-
-  return { velocity, position, orientation }
-}
+import {
+  clamp,
+  multiply,
+  rotate,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { toRange } from "@inglorious/utils/math/trigonometry.js"
+
+const DEFAULT_MAX_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export function tankMove(entity, dt) {
+  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation = toRange(orientation)
+
+  let velocity = entity.velocity ?? zero()
+  velocity = rotate(velocity, orientation)
+  velocity = clamp(velocity, -maxSpeed, maxSpeed)
+
+  const position = sum(entity.position, multiply(velocity, dt))
+
+  return { velocity, position, orientation }
+}

package/src/{engine/physics → physics}/bounds.js

@@ -1,138 +1,138 @@
-import {
-  angle,
-  clamp,
-  createVector,
-  fromAngle,
-  multiply,
-  zero,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
-import { abs } from "@inglorious/utils/math/numbers.js"
-
-const DOUBLE = 2
-const HALF = 2
-const X = 0
-const Z = 2
-
-export function bounce(entity, dt, [minX, minZ, maxX, maxZ]) {
-  const [x, , z] = entity.position
-
-  const velocity = createVector(entity.maxSpeed, entity.orientation)
-  if (x < minX || x >= maxX) {
-    velocity[X] = -velocity[X]
-  }
-
-  if (z < minZ || z >= maxZ) {
-    velocity[Z] = -velocity[Z]
-  }
-
-  const position = sum(entity.position, multiply(velocity, dt))
-  const orientation = angle(velocity)
-
-  return { velocity, position, orientation }
-}
-
-const ClampToBoundsByShape = {
-  rectangle(entity, [minX, minZ, maxX, maxZ], collisionGroup) {
-    const [width, height, depth] =
-      entity.collisions[collisionGroup].size ?? entity.size
-
-    const halfWidth = width / HALF
-    const halfHeight = height / HALF
-    const halfDepth = depth / HALF
-
-    return clamp(
-      entity.position,
-      [minX + halfWidth, minZ + halfHeight, minZ + halfDepth],
-      [maxX - halfWidth, maxZ - halfHeight, maxZ - halfDepth],
-    )
-  },
-
-  circle(entity, [minX, minY, maxX, maxY], collisionGroup, depthAxis = "y") {
-    const radius = entity.collisions[collisionGroup].radius ?? entity.radius
-
-    if (depthAxis === "z") {
-      return clamp(
-        entity.position,
-        [minX + radius, minY + radius, minY],
-        [maxX - radius, maxY - radius, maxY],
-      )
-    }
-
-    return clamp(
-      entity.position,
-      [minX + radius, minY, minY + radius],
-      [maxX - radius, maxY, maxY - radius],
-    )
-  },
-
-  point(entity, [minX, minZ, maxX, maxZ]) {
-    return clamp(entity.position, [minX, minZ, minZ], [maxX, maxZ, maxZ])
-  },
-}
-
-export function clampToBounds(
-  entity,
-  bounds,
-  collisionGroup = "bounds",
-  depthAxis,
-) {
-  const shape = entity.collisions[collisionGroup].shape || "rectangle"
-  const handler = ClampToBoundsByShape[shape] || ClampToBoundsByShape.point
-  return handler(entity, bounds, collisionGroup, depthAxis)
-}
-
-export function flip(entity, [minX, minZ, maxX, maxZ]) {
-  const [x, , z] = entity.position
-
-  entity.collisions ??= {}
-  entity.collisions.bounds ??= {}
-  entity.collisions.bounds.shape ??= "rectangle"
-
-  let width, height, depth
-  if (entity.collisions.bounds.shape === "circle") {
-    width = entity.collisions.bounds.radius * DOUBLE
-    height = entity.collisions.bounds.radius * DOUBLE
-    depth = entity.collisions.bounds.radius * DOUBLE
-  } else {
-    ;[width, height, depth] = entity.collisions.bounds.size ?? entity.size
-  }
-  const halfWidth = width / HALF
-  const halfHeight = height / HALF
-  const halfDepth = depth / HALF
-
-  const left = x - halfWidth
-  const right = x + halfWidth
-  const bottom = z - halfHeight
-  const top = z + halfHeight
-  const back = z - halfDepth
-  const front = z + halfDepth
-
-  const direction = fromAngle(entity.orientation)
-
-  if (
-    left < minX ||
-    right >= maxX ||
-    bottom < minZ ||
-    top >= maxZ ||
-    back < minZ ||
-    front >= maxZ
-  ) {
-    if (left < minX) {
-      direction[X] = abs(direction[X])
-    } else if (right >= maxX) {
-      direction[X] = -abs(direction[X])
-    }
-
-    if (back < minZ) {
-      direction[Z] = abs(direction[Z])
-    } else if (front >= maxZ) {
-      direction[Z] = -abs(direction[Z])
-    }
-
-    entity.acceleration = zero()
-    entity.velocity = zero()
-  }
-
-  entity.orientation = angle(direction)
-}
+import {
+  angle,
+  clamp,
+  createVector,
+  fromAngle,
+  multiply,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { abs } from "@inglorious/utils/math/numbers.js"
+
+const DOUBLE = 2
+const HALF = 2
+const X = 0
+const Z = 2
+
+export function bounce(entity, dt, [minX, minZ, maxX, maxZ]) {
+  const [x, , z] = entity.position
+
+  const velocity = createVector(entity.maxSpeed, entity.orientation)
+  if (x < minX || x >= maxX) {
+    velocity[X] = -velocity[X]
+  }
+
+  if (z < minZ || z >= maxZ) {
+    velocity[Z] = -velocity[Z]
+  }
+
+  const position = sum(entity.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}
+
+const ClampToBoundsByShape = {
+  rectangle(entity, [minX, minZ, maxX, maxZ], collisionGroup) {
+    const [width, height, depth] =
+      entity.collisions[collisionGroup].size ?? entity.size
+
+    const halfWidth = width / HALF
+    const halfHeight = height / HALF
+    const halfDepth = depth / HALF
+
+    return clamp(
+      entity.position,
+      [minX + halfWidth, minZ + halfHeight, minZ + halfDepth],
+      [maxX - halfWidth, maxZ - halfHeight, maxZ - halfDepth],
+    )
+  },
+
+  circle(entity, [minX, minY, maxX, maxY], collisionGroup, depthAxis = "y") {
+    const radius = entity.collisions[collisionGroup].radius ?? entity.radius
+
+    if (depthAxis === "z") {
+      return clamp(
+        entity.position,
+        [minX + radius, minY + radius, minY],
+        [maxX - radius, maxY - radius, maxY],
+      )
+    }
+
+    return clamp(
+      entity.position,
+      [minX + radius, minY, minY + radius],
+      [maxX - radius, maxY, maxY - radius],
+    )
+  },
+
+  point(entity, [minX, minZ, maxX, maxZ]) {
+    return clamp(entity.position, [minX, minZ, minZ], [maxX, maxZ, maxZ])
+  },
+}
+
+export function clampToBounds(
+  entity,
+  bounds,
+  collisionGroup = "bounds",
+  depthAxis,
+) {
+  const shape = entity.collisions[collisionGroup].shape || "rectangle"
+  const handler = ClampToBoundsByShape[shape] || ClampToBoundsByShape.point
+  return handler(entity, bounds, collisionGroup, depthAxis)
+}
+
+export function flip(entity, [minX, minZ, maxX, maxZ]) {
+  const [x, , z] = entity.position
+
+  entity.collisions ??= {}
+  entity.collisions.bounds ??= {}
+  entity.collisions.bounds.shape ??= "rectangle"
+
+  let width, height, depth
+  if (entity.collisions.bounds.shape === "circle") {
+    width = entity.collisions.bounds.radius * DOUBLE
+    height = entity.collisions.bounds.radius * DOUBLE
+    depth = entity.collisions.bounds.radius * DOUBLE
+  } else {
+    ;[width, height, depth] = entity.collisions.bounds.size ?? entity.size
+  }
+  const halfWidth = width / HALF
+  const halfHeight = height / HALF
+  const halfDepth = depth / HALF
+
+  const left = x - halfWidth
+  const right = x + halfWidth
+  const bottom = z - halfHeight
+  const top = z + halfHeight
+  const back = z - halfDepth
+  const front = z + halfDepth
+
+  const direction = fromAngle(entity.orientation)
+
+  if (
+    left < minX ||
+    right >= maxX ||
+    bottom < minZ ||
+    top >= maxZ ||
+    back < minZ ||
+    front >= maxZ
+  ) {
+    if (left < minX) {
+      direction[X] = abs(direction[X])
+    } else if (right >= maxX) {
+      direction[X] = -abs(direction[X])
+    }
+
+    if (back < minZ) {
+      direction[Z] = abs(direction[Z])
+    } else if (front >= maxZ) {
+      direction[Z] = -abs(direction[Z])
+    }
+
+    entity.acceleration = zero()
+    entity.velocity = zero()
+  }
+
+  entity.orientation = angle(direction)
+}

package/src/{engine/physics → physics}/position.js

@@ -1,43 +1,43 @@
-const HALF = 2
-
-export function calculateLandingPosition(
-  entity,
-  target,
-  collisionGroup = "platform",
-) {
-  const entityShape = entity.collisions[collisionGroup]?.shape
-
-  if (CalculatePY[entityShape]) {
-    return CalculatePY[entityShape](entity, target, collisionGroup)
-  }
-
-  return calculatePYForPoint(entity, target, collisionGroup)
-}
-
-function calculatePYForPoint(entity, target, collisionGroup) {
-  const [, targetY] = target.position
-  const [, targetHeight] = target.collisions[collisionGroup].size ?? target.size
-  return targetY + targetHeight / HALF
-}
-
-function calculatePYForCircle(entity, target, collisionGroup) {
-  const entityRadius = entity.collisions[collisionGroup].radius ?? entity.radius
-
-  const [, targetY] = target.position
-  const [, targetHeight] = target.collisions[collisionGroup].size ?? target.size
-  return targetY + targetHeight / HALF + entityRadius
-}
-
-function calculatePYForRectangle(entity, target, collisionGroup) {
-  const [, entityHeight] = entity.collisions[collisionGroup].size ?? entity.size
-
-  const [, targetY] = target.position
-  const [, targetHeight] = target.collisions[collisionGroup].size ?? target.size
-  return targetY + targetHeight / HALF + entityHeight / HALF
-}
-
-const CalculatePY = {
-  point: calculatePYForPoint,
-  circle: calculatePYForCircle,
-  rectangle: calculatePYForRectangle,
-}
+const HALF = 2
+
+export function calculateLandingPosition(
+  entity,
+  target,
+  collisionGroup = "platform",
+) {
+  const entityShape = entity.collisions[collisionGroup]?.shape
+
+  if (CalculatePY[entityShape]) {
+    return CalculatePY[entityShape](entity, target, collisionGroup)
+  }
+
+  return calculatePYForPoint(entity, target, collisionGroup)
+}
+
+function calculatePYForPoint(entity, target, collisionGroup) {
+  const [, targetY] = target.position
+  const [, targetHeight] = target.collisions[collisionGroup].size ?? target.size
+  return targetY + targetHeight / HALF
+}
+
+function calculatePYForCircle(entity, target, collisionGroup) {
+  const entityRadius = entity.collisions[collisionGroup].radius ?? entity.radius
+
+  const [, targetY] = target.position
+  const [, targetHeight] = target.collisions[collisionGroup].size ?? target.size
+  return targetY + targetHeight / HALF + entityRadius
+}
+
+function calculatePYForRectangle(entity, target, collisionGroup) {
+  const [, entityHeight] = entity.collisions[collisionGroup].size ?? entity.size
+
+  const [, targetY] = target.position
+  const [, targetHeight] = target.collisions[collisionGroup].size ?? target.size
+  return targetY + targetHeight / HALF + entityHeight / HALF
+}
+
+const CalculatePY = {
+  point: calculatePYForPoint,
+  circle: calculatePYForCircle,
+  rectangle: calculatePYForRectangle,
+}

package/src/{engine/physics → physics}/position.test.js

@@ -1,80 +1,80 @@
-import { expect, test } from "vitest"
-
-import { calculateLandingPosition } from "./position.js"
-
-test("it should calculate the landing position for a point entity on a platform", () => {
-  const entity = {
-    collisions: {
-      platform: { shape: "point" },
-    },
-  }
-  const target = {
-    position: [0, 0, 0],
-    collisions: {
-      platform: { size: [20, 10, 0] },
-    },
-  }
-  const collisionGroup = "platform"
-
-  const py = calculateLandingPosition(entity, target, collisionGroup)
-
-  expect(py).toBe(5)
-})
-
-test("it should calculate the landing position for a circular entity on a platform", () => {
-  const entity = {
-    collisions: {
-      platform: { shape: "circle", radius: 5 },
-    },
-  }
-  const target = {
-    position: [0, 0, 0],
-    collisions: {
-      platform: { size: [20, 10, 0] },
-    },
-  }
-  const collisionGroup = "platform"
-
-  const py = calculateLandingPosition(entity, target, collisionGroup)
-
-  expect(py).toBe(10)
-})
-
-test("it should calculate the landing position for a rectangular entity on a platform", () => {
-  const entity = {
-    size: [10, 10, 0],
-    collisions: {
-      platform: { shape: "rectangle" },
-    },
-  }
-  const target = {
-    position: [0, 0, 0],
-    collisions: {
-      platform: { size: [20, 10, 0] },
-    },
-  }
-  const collisionGroup = "platform"
-
-  const py = calculateLandingPosition(entity, target, collisionGroup)
-
-  expect(py).toBe(10)
-})
-
-test("it should fallback to a rectangular calculation for an unknown entity shape", () => {
-  const entity = {
-    collisions: {
-      platform: { shape: "triangle" },
-    },
-  }
-  const target = {
-    position: [0, 0, 0],
-    collisions: {
-      platform: { size: [20, 10, 0] },
-    },
-  }
-  const collisionGroup = "platform"
-
-  const py = calculateLandingPosition(entity, target, collisionGroup)
-
-  expect(py).toBe(5)
-})
+import { expect, test } from "vitest"
+
+import { calculateLandingPosition } from "./position.js"
+
+test("it should calculate the landing position for a point entity on a platform", () => {
+  const entity = {
+    collisions: {
+      platform: { shape: "point" },
+    },
+  }
+  const target = {
+    position: [0, 0, 0],
+    collisions: {
+      platform: { size: [20, 10, 0] },
+    },
+  }
+  const collisionGroup = "platform"
+
+  const py = calculateLandingPosition(entity, target, collisionGroup)
+
+  expect(py).toBe(5)
+})
+
+test("it should calculate the landing position for a circular entity on a platform", () => {
+  const entity = {
+    collisions: {
+      platform: { shape: "circle", radius: 5 },
+    },
+  }
+  const target = {
+    position: [0, 0, 0],
+    collisions: {
+      platform: { size: [20, 10, 0] },
+    },
+  }
+  const collisionGroup = "platform"
+
+  const py = calculateLandingPosition(entity, target, collisionGroup)
+
+  expect(py).toBe(10)
+})
+
+test("it should calculate the landing position for a rectangular entity on a platform", () => {
+  const entity = {
+    size: [10, 10, 0],
+    collisions: {
+      platform: { shape: "rectangle" },
+    },
+  }
+  const target = {
+    position: [0, 0, 0],
+    collisions: {
+      platform: { size: [20, 10, 0] },
+    },
+  }
+  const collisionGroup = "platform"
+
+  const py = calculateLandingPosition(entity, target, collisionGroup)
+
+  expect(py).toBe(10)
+})
+
+test("it should fallback to a rectangular calculation for an unknown entity shape", () => {
+  const entity = {
+    collisions: {
+      platform: { shape: "triangle" },
+    },
+  }
+  const target = {
+    position: [0, 0, 0],
+    collisions: {
+      platform: { size: [20, 10, 0] },
+    },
+  }
+  const collisionGroup = "platform"
+
+  const py = calculateLandingPosition(entity, target, collisionGroup)
+
+  expect(py).toBe(5)
+})