@inglorious/engine 0.1.0

package/src/engine/ai/movement/dynamic/flee.js

@@ -0,0 +1,45 @@
+import {
+  angle,
+  clamp,
+  magnitude,
+  multiply,
+  setMagnitude,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const DEFAULT_MAX_ACCELERATION = 0
+const DEFAULT_MAX_SPEED = 0
+
+const MIN_SPEED = 0
+
+const HALF_ACCELERATION = 0.5
+
+export default function flee(instance, target, { dt }) {
+  const maxAcceleration = instance.maxAcceleration ?? DEFAULT_MAX_ACCELERATION
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  let velocity = instance.velocity ?? zero()
+
+  const direction = subtract(instance.position, target.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return instance
+  }
+
+  const acceleration = setMagnitude(direction, maxAcceleration)
+
+  velocity = sum(velocity, multiply(acceleration, dt))
+  velocity = clamp(velocity, MIN_SPEED, maxSpeed)
+
+  const position = sum(
+    instance.position,
+    multiply(velocity, dt),
+    multiply(acceleration, HALF_ACCELERATION * dt * dt),
+  )
+
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

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

@@ -0,0 +1,17 @@
+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/ai/movement/dynamic/match-velocity.js

@@ -0,0 +1,50 @@
+import {
+  angle,
+  clamp,
+  divide,
+  magnitude,
+  multiply,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+export const DEFAULT_TIME_TO_TARGET = 0.1
+
+const DEFAULT_MAX_ACCELERATION = 0
+const DEFAULT_MAX_SPEED = 0
+const DEFAULT_ORIENTATION = 0
+
+const MIN_ACCELERATION = 0
+const MIN_SPEED = 0
+
+const HALF_ACCELERATION = 0.5
+
+export default function matchVelocity(
+  instance,
+  target,
+  { dt, timeToTarget = DEFAULT_TIME_TO_TARGET },
+) {
+  const maxAcceleration = instance.maxAcceleration ?? DEFAULT_MAX_ACCELERATION
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
+
+  let velocity = instance.velocity ?? zero()
+  const velocityDelta = subtract(target.velocity, velocity)
+
+  let acceleration = divide(velocityDelta, timeToTarget)
+  acceleration = clamp(acceleration, MIN_ACCELERATION, maxAcceleration)
+
+  velocity = sum(velocity, multiply(acceleration, dt))
+  velocity = clamp(velocity, MIN_SPEED, maxSpeed)
+
+  const position = sum(
+    instance.position,
+    multiply(velocity, dt),
+    multiply(acceleration, HALF_ACCELERATION * dt * dt),
+  )
+
+  orientation = magnitude(velocity) ? angle(velocity) : orientation
+
+  return { acceleration, velocity, position, orientation }
+}

package/src/engine/ai/movement/dynamic/pursue.js

@@ -0,0 +1,38 @@
+import {
+  magnitude,
+  multiply,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+import seek from "./seek.js"
+
+export const DEFAULT_MAX_PREDICTION = 10
+
+export default function pursue(
+  instance,
+  target,
+  { dt, maxPrediction = DEFAULT_MAX_PREDICTION },
+) {
+  const velocity = instance.velocity ?? zero()
+
+  const direction = subtract(target.position, instance.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return instance
+  }
+
+  const speed = magnitude(velocity)
+
+  let prediction
+  if (speed <= distance / maxPrediction) {
+    prediction = maxPrediction
+  } else {
+    prediction = distance / speed
+  }
+
+  const position = sum(target.position, multiply(target.velocity, prediction))
+
+  return seek(instance, { ...target, position }, { dt })
+}

package/src/engine/ai/movement/dynamic/seek.js

@@ -0,0 +1,44 @@
+import {
+  angle,
+  clamp,
+  magnitude,
+  multiply,
+  setMagnitude,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const DEFAULT_MAX_ACCELERATION = 0
+const DEFAULT_MAX_SPEED = 0
+
+const MIN_SPEED = 0
+
+const HALF_ACCELERATION = 0.5
+
+export default function seek(instance, target, { dt }) {
+  const maxAcceleration = instance.maxAcceleration ?? DEFAULT_MAX_ACCELERATION
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  const direction = subtract(target.position, instance.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return instance
+  }
+
+  const acceleration = setMagnitude(direction, maxAcceleration)
+
+  let velocity = instance.velocity ?? zero()
+  velocity = sum(velocity, multiply(acceleration, dt))
+  velocity = clamp(velocity, MIN_SPEED, maxSpeed)
+
+  const position = sum(
+    instance.position,
+    multiply(velocity, dt),
+    multiply(acceleration, HALF_ACCELERATION * dt * dt),
+  )
+
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

package/src/engine/ai/movement/dynamic/wander.js

@@ -0,0 +1,32 @@
+import { createVector } from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { randomBinomial } from "@inglorious/utils/math/rng.js"
+
+import seek from "./seek.js"
+
+export const DEFAULT_WANDER_OFFSET = 100
+export const DEFAULT_WANDER_RADIUS = 100
+
+const DEFAULT_MAX_ANGULAR_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export default function wander(
+  instance,
+  {
+    wanderOffset = DEFAULT_WANDER_OFFSET,
+    wanderRadius = DEFAULT_WANDER_RADIUS,
+    ...options
+  },
+) {
+  const maxAngularSpeed = instance.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
+
+  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
+
+  let position = sum(instance.position, createVector(wanderOffset, orientation))
+
+  orientation += randomBinomial() * maxAngularSpeed
+  position = sum(position, createVector(wanderRadius, orientation))
+
+  return seek(instance, { position }, options)
+}

package/src/engine/ai/movement/kinematic/align.js

@@ -0,0 +1,37 @@
+import { abs, clamp } from "@inglorious/utils/math/numbers.js"
+import { toRange } from "@inglorious/utils/math/trigonometry.js"
+
+export const DEFAULT_TARGET_RADIUS = 0.1
+export const DEFAULT_TIME_TO_TARGET = 0.1
+
+const DEFAULT_MAX_ANGULAR_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export default function align(
+  instance,
+  target,
+  {
+    dt,
+    targetRadius = DEFAULT_TARGET_RADIUS,
+    timeToTarget = DEFAULT_TIME_TO_TARGET,
+  },
+) {
+  const maxAngularSpeed = instance.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
+
+  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
+
+  const direction = toRange(target.orientation - orientation)
+  const distance = abs(direction)
+
+  if (distance < targetRadius) {
+    return instance
+  }
+
+  let angularVelocity = direction / timeToTarget
+  angularVelocity = clamp(angularVelocity, -maxAngularSpeed, maxAngularSpeed)
+
+  orientation += angularVelocity * dt
+
+  return { orientation }
+}

package/src/engine/ai/movement/kinematic/arrive.js

@@ -0,0 +1,42 @@
+import {
+  angle,
+  clamp,
+  divide,
+  magnitude,
+  multiply,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+export const DEFAULT_TARGET_RADIUS = 1
+export const DEFAULT_TIME_TO_TARGET = 0.1
+
+const DEFAULT_MAX_SPEED = 0
+
+const MIN_SPEED = 0
+
+export default function arrive(
+  instance,
+  target,
+  {
+    dt,
+    targetRadius = DEFAULT_TARGET_RADIUS,
+    timeToTarget = DEFAULT_TIME_TO_TARGET,
+  },
+) {
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  const direction = subtract(target.position, instance.position)
+  const distance = magnitude(direction)
+
+  if (distance < targetRadius) {
+    return instance
+  }
+
+  let velocity = divide(direction, timeToTarget)
+  velocity = clamp(velocity, MIN_SPEED, maxSpeed)
+
+  const position = sum(instance.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

package/src/engine/ai/movement/kinematic/face.js

@@ -0,0 +1,20 @@
+import {
+  angle,
+  magnitude,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+import align from "./align.js"
+
+export default function face(instance, target, options) {
+  const direction = subtract(target.position, instance.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return instance
+  }
+
+  const orientation = angle(direction)
+
+  return align(instance, { ...target, orientation }, options)
+}

package/src/engine/ai/movement/kinematic/flee.js

@@ -0,0 +1,26 @@
+import {
+  angle,
+  magnitude,
+  multiply,
+  setMagnitude,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const DEFAULT_MAX_SPEED = 0
+
+export default function flee(instance, target, { dt }) {
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  const direction = subtract(instance.position, target.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return instance
+  }
+
+  const velocity = setMagnitude(direction, maxSpeed)
+  const position = sum(instance.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

package/src/engine/ai/movement/kinematic/seek.js

@@ -0,0 +1,26 @@
+import {
+  angle,
+  magnitude,
+  multiply,
+  setMagnitude,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract, sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const DEFAULT_MAX_SPEED = 0
+
+export default function seek(instance, target, { dt }) {
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  const direction = subtract(target.position, instance.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return instance
+  }
+
+  const velocity = setMagnitude(direction, maxSpeed)
+  const position = sum(instance.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

package/src/engine/ai/movement/kinematic/seek.test.js

@@ -0,0 +1,42 @@
+import { expect, test } from "vitest"
+
+import seek from "./seek.js"
+
+test("it should move toward the target", () => {
+  const instance = { maxSpeed: 1, position: [0, 0, 0] }
+  const target = { position: [2, 0, 0] }
+  const options = { dt: 1 }
+  const expectedResult = {
+    position: [1, 0, 0],
+    velocity: [1, 0, 0],
+    orientation: 0,
+  }
+
+  expect(seek(instance, target, options)).toStrictEqual(expectedResult)
+})
+
+test("it should eventually reach the target", () => {
+  const instance = { maxSpeed: 1, position: [0, 0, 0] }
+  const target = { position: [2, 0, 0] }
+  const options = { dt: 2 }
+  const expectedResult = {
+    position: [2, 0, 0],
+    velocity: [1, 0, 0],
+    orientation: 0,
+  }
+
+  expect(seek(instance, target, options)).toStrictEqual(expectedResult)
+})
+
+test("it should overshoot when speed is too high", () => {
+  const instance = { maxSpeed: 10, position: [0, 0, 0] }
+  const target = { position: [2, 0, 0] }
+  const options = { dt: 1 }
+  const expectedResult = {
+    position: [10, 0, 0],
+    velocity: [10, 0, 0],
+    orientation: 0,
+  }
+
+  expect(seek(instance, target, options)).toStrictEqual(expectedResult)
+})

package/src/engine/ai/movement/kinematic/wander-as-seek.js

@@ -0,0 +1,31 @@
+import {
+  fromAngle,
+  multiply,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { randomBinomial } from "@inglorious/utils/math/rng.js"
+
+import seek from "./seek.js"
+
+export const DEFAULT_WANDER_RADIUS = 10
+
+const DEFAULT_MAX_ANGULAR_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export default function wander(
+  instance,
+  { wanderRadius = DEFAULT_WANDER_RADIUS, ...options },
+) {
+  const maxAngularSpeed = instance.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
+
+  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
+  orientation += randomBinomial() * maxAngularSpeed
+
+  const position = sum(
+    instance.position,
+    multiply(fromAngle(orientation), wanderRadius),
+  )
+
+  return seek(instance, { position }, options)
+}

package/src/engine/ai/movement/kinematic/wander.js

@@ -0,0 +1,27 @@
+import {
+  angle,
+  createVector,
+  multiply,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+import { randomBinomial } from "@inglorious/utils/math/rng.js"
+
+const DEFAULT_MAX_SPEED = 0
+const DEFAULT_MAX_ANGULAR_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export default function wander(instance, { dt }) {
+  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
+  const maxAngularSpeed = instance.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
+
+  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
+  orientation += randomBinomial() * maxAngularSpeed
+
+  const velocity = createVector(maxSpeed, orientation)
+
+  const position = sum(instance.position, multiply(velocity, dt))
+  orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

package/src/engine/collision/detection.js

@@ -0,0 +1,115 @@
+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/animation-frame.js

@@ -0,0 +1,26 @@
+const ONE_SECOND = 1000
+
+export default class AnimationFrameLoop {
+  _id = null
+  _previousTime = new Date()
+
+  start(engine) {
+    this._tick(engine)
+  }
+
+  stop() {
+    window.cancelAnimationFrame(this._id)
+    this._id = null
+  }
+
+  _tick(engine) {
+    const currentTime = new Date()
+    this._id = window.requestAnimationFrame(() => this._tick(engine))
+    const dt = currentTime - this._previousTime
+
+    engine.update(dt / ONE_SECOND)
+    engine.render(dt / ONE_SECOND)
+
+    this._previousTime = currentTime
+  }
+}

package/src/engine/loop/elapsed.js

@@ -0,0 +1,23 @@
+const ONE_SECOND = 1000
+
+export default class ElapsedLoop {
+  _shouldStop = false
+
+  start(engine) {
+    let previousTime = Date.now()
+
+    while (!this._shouldStop) {
+      const currentTime = Date.now()
+      const dt = currentTime - previousTime
+
+      engine.update(dt / ONE_SECOND)
+      engine.render(dt / ONE_SECOND)
+
+      previousTime = currentTime
+    }
+  }
+
+  stop() {
+    this._shouldStop = true
+  }
+}

package/src/engine/loop/fixed.js

@@ -0,0 +1,28 @@
+const ONE_SECOND = 1000
+
+export default class NapLoop {
+  _shouldStop = false
+
+  async start(engine, msPerUpdate) {
+    let previousTime = Date.now()
+
+    while (!this._shouldStop) {
+      const currentTime = Date.now()
+      const dt = currentTime - previousTime
+
+      engine.update(dt / ONE_SECOND)
+      engine.render(dt / ONE_SECOND)
+
+      previousTime = currentTime
+      await sleep(Date.now() - currentTime + msPerUpdate)
+    }
+  }
+
+  stop() {
+    this._shouldStop = true
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}