@inglorious/engine 0.2.0 → 0.3.0

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

package/src/{engine/systems → systems}/sprite-animation.js

@@ -1,27 +1,27 @@
-import { Sprite } from "@inglorious/engine/animation/sprite.js"
-
-/**
- * Advances sprite animations for entities that have a sprite component
- * with an active animation state.
- *
- * @param {Object} state - The game state, containing all entities.
- * @param {Object<string, Object>} state.entities - A map of entity IDs to entity objects.
- * @param {number} dt - The delta time since the last update.
- * @param {Object} api - The game API.
- * @param {Function} api.notify - A function to notify about events.
- */
-export function spriteAnimationSystem() {
-  return {
-    update(state, dt, api) {
-      for (const id in state.entities) {
-        const entity = state.entities[id]
-
-        if (!entity.sprite || !entity.sprite.state) {
-          continue
-        }
-
-        Sprite.play(entity.sprite.state, { entity, dt, notify: api.notify })
-      }
-    },
-  }
-}
+import { Sprite } from "@inglorious/engine/animation/sprite.js"
+
+/**
+ * Advances sprite animations for entities that have a sprite component
+ * with an active animation state.
+ *
+ * @param {Object} state - The game state, containing all entities.
+ * @param {Object<string, Object>} state.entities - A map of entity IDs to entity objects.
+ * @param {number} dt - The delta time since the last update.
+ * @param {Object} api - The game API.
+ * @param {Function} api.notify - A function to notify about events.
+ */
+export function spriteAnimationSystem() {
+  return {
+    update(state, dt, api) {
+      for (const id in state.entities) {
+        const entity = state.entities[id]
+
+        if (!entity.sprite || !entity.sprite.state) {
+          continue
+        }
+
+        Sprite.play(entity.sprite.state, { entity, dt, notify: api.notify })
+      }
+    },
+  }
+}

package/src/engine/behaviors/debug/collision.js

@@ -1,35 +0,0 @@
-import { renderHitmask } from "@inglorious/renderers/canvas/image/hitmask.js"
-import { renderCircle } from "@inglorious/renderers/canvas/shapes/circle.js"
-import { renderRectangle } from "@inglorious/renderers/canvas/shapes/rectangle.js"
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-
-const Shape = {
-  circle: renderCircle,
-  rectangle: renderRectangle,
-  platform: renderRectangle,
-  hitmask: renderHitmask,
-}
-
-export function collisionGizmos() {
-  return (type) =>
-    extend(type, {
-      render(entity, ctx, api) {
-        type.render(entity, ctx, api)
-
-        const game = api.getEntity("game")
-
-        if (!game.debug) {
-          return
-        }
-
-        ctx.save()
-
-        Object.values(entity.collisions).forEach((collision) => {
-          const render = Shape[collision.shape]
-          render({ ...entity, ...collision, color: "#00FF00" }, ctx, api)
-        })
-
-        ctx.restore()
-      },
-    })
-}

package/src/renderers/canvas/absolute-position.js

@@ -1,18 +0,0 @@
-import { snap, zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-export function absolutePosition(render) {
-  return (entity, ctx, { api }) => {
-    const { position = zero() } = entity
-    const [x, y, z] = snap(position)
-
-    const game = api.getEntity("game")
-    const [, , , screenHeight] = game.bounds
-
-    ctx.save()
-
-    ctx.translate(x, screenHeight - y - z)
-    render(entity, ctx, api)
-
-    ctx.restore()
-  }
-}

package/src/renderers/canvas/camera.js

@@ -1,13 +0,0 @@
-import { renderRectangle } from "./shapes/rectangle.js"
-
-export function renderCamera(entity, ctx, api) {
-  const { devMode } = api.getEntity("game")
-
-  if (devMode) {
-    // In dev mode, we want to see the camera's viewport.
-    // We can reuse the rectangle renderer.
-    renderRectangle(entity, ctx)
-  }
-  // In non-dev mode, the camera itself is not rendered;
-  // its properties are used by the main CanvasRenderer to transform the scene.
-}