@inglorious/engine 0.1.1 → 0.3.0

package/src/physics/bounds.js

@@ -0,0 +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)
+}

package/src/physics/position.js

@@ -0,0 +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,
+}

package/src/physics/position.test.js

@@ -0,0 +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)
+})

package/src/systems/sprite-animation.js

@@ -0,0 +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 })
+      }
+    },
+  }
+}

package/src/engine/ai/movement/dynamic/look-where-youre-going.js

@@ -1,17 +0,0 @@
-import {
-  angle,
-  magnitude,
-  zero,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-
-import align from "./align.js"
-
-export default function lookWhereYoureGoing(instance, options) {
-  const velocity = instance.velocity ?? zero()
-
-  if (!magnitude(velocity)) {
-    return instance
-  }
-
-  return align(instance, { orientation: angle(velocity) }, options)
-}

package/src/engine/collision/detection.js

@@ -1,115 +0,0 @@
-import { filter } from "@inglorious/utils/data-structures/object.js"
-import * as circle from "@inglorious/utils/math/geometry/circle.js"
-import * as hitmask from "@inglorious/utils/math/geometry/hitmask.js"
-import * as line from "@inglorious/utils/math/geometry/line.js"
-import * as platform from "@inglorious/utils/math/geometry/platform.js"
-import * as point from "@inglorious/utils/math/geometry/point.js"
-import * as rectangle from "@inglorious/utils/math/geometry/rectangle.js"
-import * as segment from "@inglorious/utils/math/geometry/segment.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { add } from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-const Z = 2 // Z-axis index.
-
-const Shape = {
-  circle,
-  line,
-  platform,
-  point,
-  rectangle,
-  segment,
-  hitmask,
-}
-
-/**
- * Finds the first collision between a point and a list of instances.
- *
- * @param {Point} instance - The point to check for collisions.
- * @param {Options} options - Options for collision detection.
- * @returns {Instance | undefined} The first instance that collides with the point, or undefined if none are found.
- */
-export function findCollision(instance, options = {}) {
-  const { instances, collisionType = "hitbox" } = options
-
-  const otherInstances = filter(
-    instances,
-    (id, { collisions }) => id !== instance.id && collisions?.[collisionType],
-  )
-
-  return Object.values(otherInstances)
-    .toSorted((a, b) => a.position[Z] - b.position[Z])
-    .find((target) => collidesWith(instance, target, collisionType))
-}
-
-export function collidesWith(instance, target, collisionType = "hitbox") {
-  const instanceCollision = instance.collisions[collisionType]
-  const instanceShape = {
-    ...instanceCollision,
-    position: add(instance.position, instanceCollision.position ?? zero()),
-    size: instanceCollision.size ?? instance.size,
-    radius: instanceCollision.radius ?? instance.radius,
-  }
-
-  const targetCollision = target.collisions[collisionType]
-  const targetShape = {
-    ...targetCollision,
-    position: add(target.position, targetCollision.position ?? zero()),
-    size: targetCollision.size ?? target.size,
-    radius: targetCollision.radius ?? target.radius,
-  }
-
-  return shapeCollidesWith(instanceShape, targetShape)
-}
-
-function shapeCollidesWith(instance, target) {
-  const shapeFns = Shape[instance.shape]
-
-  switch (target.shape) {
-    case "circle":
-      return shapeFns.intersectsCircle(instance, target)
-
-    case "line":
-      return shapeFns.intersectsLine(instance, target)
-
-    case "platform":
-      return shapeFns.intersectsPlatform(instance, target)
-
-    case "point":
-      return shapeFns.intersectsPoint(instance, target)
-
-    case "rectangle":
-      return shapeFns.intersectsRectangle(instance, target)
-
-    case "segment":
-      return shapeFns.intersectsSegment(instance, target)
-  }
-}
-
-export function findCollisions(instance, target, collisionType = "hitbox") {
-  const instanceCollision = instance.collisions[collisionType]
-  const shapeFns = Shape[instanceCollision.shape]
-  const instanceShape = {
-    ...instanceCollision,
-    position: add(instance.position, instanceCollision.offset ?? zero()),
-    heights: flipUpsideDown(
-      instanceCollision.heights,
-      instanceCollision.columns,
-    ),
-  }
-
-  const targetCollision = target.collisions[collisionType]
-  const targetShape = {
-    ...targetCollision,
-    position: add(target.position, targetCollision.offset ?? zero()),
-  }
-
-  return shapeFns.findCollisions(instanceShape, targetShape)
-}
-
-export function flipUpsideDown(grid, columns) {
-  const rows = []
-  for (let i = 0; i < grid.length; i += columns) {
-    rows.push(grid.slice(i, i + columns))
-  }
-  return rows.reverse().flat()
-}

package/src/engine/loop.js

@@ -1,15 +0,0 @@
-import AnimationFrameLoop from "./loop/animation-frame.js"
-import ElapsedLoop from "./loop/elapsed.js"
-import FixedLoop from "./loop/fixed.js"
-import FlashLoop from "./loop/flash.js"
-import LagLoop from "./loop/lag.js"
-
-// @see https://gameprogrammingpatterns.com/game-loop.html
-
-export default {
-  flash: FlashLoop,
-  fixed: FixedLoop,
-  elapsed: ElapsedLoop,
-  lag: LagLoop,
-  animationFrame: AnimationFrameLoop,
-}

package/src/engine/movement/kinematic/modern.test.js

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

package/src/engine/store.js

@@ -1,174 +0,0 @@
-import { enableGame } from "@inglorious/game/decorators/game.js"
-import { map } from "@inglorious/utils/data-structures/object.js"
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-import { pipe } from "@inglorious/utils/functions/functions.js"
-import { produce } from "immer"
-
-const DEFAULT_TYPES = {
-  game: [enableGame()],
-}
-
-const DEFAULT_INSTANCES = {
-  // eslint-disable-next-line no-magic-numbers
-  game: { type: "game", bounds: [0, 0, 800, 600] }, // Default game instance with bounds.
-}
-
-const DEFAULT_LAYER = 0
-
-/**
- * Creates a store to manage state and events.
- * @param {Object} options - Configuration options for the store.
- * @param {Object} options.instances - Initial instances to include in the store.
- * @param {Object} options.originalConfig - Additional configuration for the store.
- * @returns {Object} The store with methods to interact with state and events.
- */
-export function createStore({
-  types: originalTypes,
-  instances: originalInstances,
-}) {
-  const listeners = new Set()
-  let incomingEvents = []
-
-  let types = extend(DEFAULT_TYPES, originalTypes)
-  types = augmentTypes(types)
-
-  let instances = extend(DEFAULT_INSTANCES, originalInstances)
-  instances = augmentInstances(instances)
-
-  let state = { events: [], instances }
-
-  return {
-    subscribe,
-    update,
-    notify,
-    dispatch: notify, // needed for react-redux
-    getTypes,
-    getState,
-  }
-
-  /**
-   * Subscribes a listener to state updates.
-   * @param {Function} listener - The listener function to call on updates.
-   * @returns {Function} A function to unsubscribe the listener.
-   */
-  function subscribe(listener) {
-    listeners.add(listener)
-
-    return function unsubscribe() {
-      listeners.delete(listener)
-    }
-  }
-
-  /**
-   * Updates the state based on elapsed time and processes events.
-   * @param {number} dt - The delta time since the last update.
-   */
-  function update(dt) {
-    state = { ...state }
-
-    state.events.push(...incomingEvents, { id: "game:update" })
-    incomingEvents = []
-
-    while (state.events.length) {
-      const event = state.events.shift()
-
-      if (event.id === "instance:add") {
-        add(event.payload.id, event.payload)
-      }
-
-      state.instances = map(state.instances, (_, instance, instances) => {
-        const type = types[instance.type]
-        const handle = type[event.id]
-        return (
-          handle?.(instance, event, {
-            dt,
-            type: originalTypes[instance.type],
-            instances,
-            notify,
-          }) ?? instance
-        )
-      })
-
-      if (event.id === "instance:remove") {
-        remove(event.payload)
-      }
-    }
-
-    listeners.forEach((onUpdate) => onUpdate())
-  }
-
-  /**
-   * Adds a new instance to the state.
-   * @param {string} id - The ID of the instance to add.
-   * @param {Object} instance - The instance object to add.
-   */
-  function add(id, instance) {
-    state = { ...state }
-    state.instances[id] = augmentInstance(id, instance)
-  }
-
-  /**
-   * Removes an instance from the state.
-   * @param {string} id - The ID of the instance to remove.
-   */
-  function remove(id) {
-    state = { ...state }
-    delete state.instances[id]
-  }
-
-  /**
-   * Notifies the store of a new event.
-   * @param {Object} event - The event object to notify.
-   */
-  function notify(event) {
-    incomingEvents.push(event)
-  }
-
-  /**
-   * Retrieves the types configuration.
-   * @returns {Object} The types configuration.
-   */
-  function getTypes() {
-    return types
-  }
-
-  /**
-   * Retrieves the current state.
-   * @returns {Object} The current state.
-   */
-  function getState() {
-    return state
-  }
-}
-
-function augmentTypes(types) {
-  return pipe(applyDecorators, enableMutability)(types)
-}
-
-function applyDecorators(types) {
-  return map(types, (_, type) => {
-    if (!Array.isArray(type)) {
-      return type
-    }
-
-    const decorators = type.map((fn) =>
-      typeof fn !== "function" ? (type) => extend(type, fn) : fn,
-    )
-    return pipe(...decorators)({})
-  })
-}
-
-function enableMutability(types) {
-  return map(types, (_, { draw, ...events }) => ({
-    draw,
-    ...map(events, (_, event) => produce(event)),
-  }))
-}
-
-function augmentInstances(instances) {
-  return map(instances, augmentInstance)
-}
-
-function augmentInstance(id, instance) {
-  return { ...instance, layer: instance.layer ?? DEFAULT_LAYER, id }
-}