@inglorious/engine 0.2.0 → 0.4.0

package/src/{engine/ai → ai}/movement/kinematic/flee.js

@@ -1,26 +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 function flee(entity, target, dt) {
-  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
-
-  const direction = subtract(entity.position, target.position)
-  const distance = magnitude(direction)
-
-  if (!distance) {
-    return entity
-  }
-
-  const velocity = setMagnitude(direction, maxSpeed)
-  const position = sum(entity.position, multiply(velocity, dt))
-  const orientation = angle(velocity)
-
-  return { velocity, position, orientation }
-}
+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 function flee(entity, target, dt) {
+  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  const direction = subtract(entity.position, target.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return entity
+  }
+
+  const velocity = setMagnitude(direction, maxSpeed)
+  const position = sum(entity.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

package/src/{engine/ai → ai}/movement/kinematic/seek.js

@@ -1,26 +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 function seek(entity, target, dt) {
-  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
-
-  const direction = subtract(target.position, entity.position)
-  const distance = magnitude(direction)
-
-  if (!distance) {
-    return entity
-  }
-
-  const velocity = setMagnitude(direction, maxSpeed)
-  const position = sum(entity.position, multiply(velocity, dt))
-  const orientation = angle(velocity)
-
-  return { velocity, position, orientation }
-}
+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 function seek(entity, target, dt) {
+  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  const direction = subtract(target.position, entity.position)
+  const distance = magnitude(direction)
+
+  if (!distance) {
+    return entity
+  }
+
+  const velocity = setMagnitude(direction, maxSpeed)
+  const position = sum(entity.position, multiply(velocity, dt))
+  const orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

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

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

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

@@ -1,31 +1,31 @@
-import { seek } from "@inglorious/engine/ai/movement/kinematic/seek.js"
-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"
-
-export const DEFAULT_WANDER_RADIUS = 10
-
-const DEFAULT_MAX_ANGULAR_SPEED = 0
-
-const DEFAULT_ORIENTATION = 0
-
-export function wanderAsSeek(
-  entity,
-  dt,
-  { wanderRadius = DEFAULT_WANDER_RADIUS } = {},
-) {
-  const maxAngularSpeed = entity.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
-
-  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
-  orientation += randomBinomial() * maxAngularSpeed
-
-  const position = sum(
-    entity.position,
-    multiply(fromAngle(orientation), wanderRadius),
-  )
-
-  return seek(entity, { position }, dt)
-}
+import { seek } from "@inglorious/engine/ai/movement/kinematic/seek.js"
+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"
+
+export const DEFAULT_WANDER_RADIUS = 10
+
+const DEFAULT_MAX_ANGULAR_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export function wanderAsSeek(
+  entity,
+  dt,
+  { wanderRadius = DEFAULT_WANDER_RADIUS } = {},
+) {
+  const maxAngularSpeed = entity.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation += randomBinomial() * maxAngularSpeed
+
+  const position = sum(
+    entity.position,
+    multiply(fromAngle(orientation), wanderRadius),
+  )
+
+  return seek(entity, { position }, dt)
+}

package/src/{engine/ai → ai}/movement/kinematic/wander.js

@@ -1,27 +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 function wander(entity, dt) {
-  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
-  const maxAngularSpeed = entity.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
-
-  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
-  orientation += randomBinomial() * maxAngularSpeed
-
-  const velocity = createVector(maxSpeed, orientation)
-
-  const position = sum(entity.position, multiply(velocity, dt))
-  orientation = angle(velocity)
-
-  return { velocity, position, orientation }
-}
+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 function wander(entity, dt) {
+  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
+  const maxAngularSpeed = entity.maxAngularSpeed ?? DEFAULT_MAX_ANGULAR_SPEED
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation += randomBinomial() * maxAngularSpeed
+
+  const velocity = createVector(maxSpeed, orientation)
+
+  const position = sum(entity.position, multiply(velocity, dt))
+  orientation = angle(velocity)
+
+  return { velocity, position, orientation }
+}

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

@@ -1,101 +1,101 @@
-/* eslint-disable no-magic-numbers */
-import { Ticker } from "@inglorious/engine/animation/ticker.js"
-import { mod } from "@inglorious/utils/math/numbers.js"
-import { pi, toRange } from "@inglorious/utils/math/trigonometry.js"
-
-export const Sprite = {
-  fromAngle,
-  move2,
-  move4,
-  move6,
-  move8,
-  play,
-}
-
-function move2(entity) {
-  return fromAngle(entity, ["right", "left"]) ?? "right"
-}
-
-function move4(entity) {
-  return fromAngle(entity, ["right", "up", "left", "down"]) ?? "down"
-}
-
-function move6(entity) {
-  return (
-    fromAngle(entity, [
-      "right",
-      "rightUp",
-      "leftUp",
-      "left",
-      "leftDown",
-      "rightDown",
-    ]) ?? "down"
-  )
-}
-
-function move8(entity) {
-  return (
-    fromAngle(entity, [
-      "right",
-      "rightUp",
-      "up",
-      "leftUp",
-      "left",
-      "leftDown",
-      "down",
-      "rightDown",
-    ]) ?? "down"
-  )
-}
-
-function play(animation, { entity, dt, notify }) {
-  const missing = [
-    animation == null && "'animation'",
-    entity == null && "'entity'",
-    dt == null && "'dt'",
-    notify == null && "'notify'",
-  ]
-    .filter(Boolean)
-    .join(", ")
-  if (missing.length) {
-    throw new Error(`Sprite.play is missing mandatory parameters: ${missing}`)
-  }
-
-  Ticker.tick({
-    target: entity.sprite,
-    state: animation,
-    dt,
-    onTick: (sprite) => {
-      const { frames, state: animation } = sprite
-      const framesLength = frames[animation].length
-      sprite.value = mod(sprite.value + 1, framesLength)
-      if (sprite.value === framesLength - 1) {
-        notify("spriteAnimationEnd", { entityId: entity.id, animation })
-      }
-    },
-  })
-}
-
-/**
- * Determines a sprite state from an orientation angle, based on a list of states.
- * The states are assumed to be ordered starting from the right (0 radians) and
- * proceeding counter-clockwise.
- *
- * @param {object} entity - The entity with an orientation.
- * @param {string[]} states - An array of state names corresponding to directions.
- * @returns {string} The calculated state name.
- */
-function fromAngle(entity, states) {
-  const directions = states.length
-  const slice = (2 * pi()) / directions
-
-  // Normalize orientation to [0, 2*PI)
-  const normalizedOrientation = mod(toRange(entity.orientation), 2 * pi())
-
-  // Shift by half a slice so that 0 rad is in the middle of the first slice, then find the index
-  const index = Math.floor(
-    mod(normalizedOrientation + slice / 2, 2 * pi()) / slice,
-  )
-
-  return states[index] ?? entity.sprite.state
-}
+/* eslint-disable no-magic-numbers */
+import { Ticker } from "@inglorious/engine/animation/ticker.js"
+import { mod } from "@inglorious/utils/math/numbers.js"
+import { pi, toRange } from "@inglorious/utils/math/trigonometry.js"
+
+export const Sprite = {
+  fromAngle,
+  move2,
+  move4,
+  move6,
+  move8,
+  play,
+}
+
+function move2(entity) {
+  return fromAngle(entity, ["right", "left"]) ?? "right"
+}
+
+function move4(entity) {
+  return fromAngle(entity, ["right", "up", "left", "down"]) ?? "down"
+}
+
+function move6(entity) {
+  return (
+    fromAngle(entity, [
+      "right",
+      "rightUp",
+      "leftUp",
+      "left",
+      "leftDown",
+      "rightDown",
+    ]) ?? "down"
+  )
+}
+
+function move8(entity) {
+  return (
+    fromAngle(entity, [
+      "right",
+      "rightUp",
+      "up",
+      "leftUp",
+      "left",
+      "leftDown",
+      "down",
+      "rightDown",
+    ]) ?? "down"
+  )
+}
+
+function play(animation, { entity, dt, notify }) {
+  const missing = [
+    animation == null && "'animation'",
+    entity == null && "'entity'",
+    dt == null && "'dt'",
+    notify == null && "'notify'",
+  ]
+    .filter(Boolean)
+    .join(", ")
+  if (missing.length) {
+    throw new Error(`Sprite.play is missing mandatory parameters: ${missing}`)
+  }
+
+  Ticker.tick({
+    target: entity.sprite,
+    state: animation,
+    dt,
+    onTick: (sprite) => {
+      const { frames, state: animation } = sprite
+      const framesLength = frames[animation].length
+      sprite.value = mod(sprite.value + 1, framesLength)
+      if (sprite.value === framesLength - 1) {
+        notify("spriteAnimationEnd", { entityId: entity.id, animation })
+      }
+    },
+  })
+}
+
+/**
+ * Determines a sprite state from an orientation angle, based on a list of states.
+ * The states are assumed to be ordered starting from the right (0 radians) and
+ * proceeding counter-clockwise.
+ *
+ * @param {object} entity - The entity with an orientation.
+ * @param {string[]} states - An array of state names corresponding to directions.
+ * @returns {string} The calculated state name.
+ */
+function fromAngle(entity, states) {
+  const directions = states.length
+  const slice = (2 * pi()) / directions
+
+  // Normalize orientation to [0, 2*PI)
+  const normalizedOrientation = mod(toRange(entity.orientation), 2 * pi())
+
+  // Shift by half a slice so that 0 rad is in the middle of the first slice, then find the index
+  const index = Math.floor(
+    mod(normalizedOrientation + slice / 2, 2 * pi()) / slice,
+  )
+
+  return states[index] ?? entity.sprite.state
+}

package/src/{engine/animation → animation}/ticker.js

@@ -1,38 +1,38 @@
-const DEFAULT_STATE = "default"
-const DEFAULT_VALUE = 0
-const COUNTER_RESET = 0
-
-export const Ticker = { tick }
-
-function tick({ target, state = DEFAULT_STATE, dt, onTick, ...options }) {
-  const missing = [target == null && "'target'", dt == null && "'dt'"]
-    .filter(Boolean)
-    .join(", ")
-  if (missing.length) {
-    throw new Error(`Ticker.tick is missing mandatory parameters: ${missing}`)
-  }
-
-  const { speed, defaultValue = DEFAULT_VALUE } = target
-
-  // The `state` property on a sprite is used to declare the desired animation.
-  // The Ticker needs its own internal property to track the *current* animation
-  // to detect when it changes. We'll use `target.animation`.
-  if (state !== target.animation) {
-    target.animation = state
-    target.counter = COUNTER_RESET
-    target.value = defaultValue
-  }
-
-  // Always ensure the public `state` property reflects the intended animation for `onTick`.
-  target.state = state
-
-  // Ensure properties are initialized on the first run for a given target.
-  target.counter ??= COUNTER_RESET
-  target.value ??= defaultValue
-
-  target.counter += dt
-  if (target.counter >= speed) {
-    target.counter = COUNTER_RESET
-    onTick?.(target, dt, options)
-  }
-}
+const DEFAULT_STATE = "default"
+const DEFAULT_VALUE = 0
+const COUNTER_RESET = 0
+
+export const Ticker = { tick }
+
+function tick({ target, state = DEFAULT_STATE, dt, onTick, ...options }) {
+  const missing = [target == null && "'target'", dt == null && "'dt'"]
+    .filter(Boolean)
+    .join(", ")
+  if (missing.length) {
+    throw new Error(`Ticker.tick is missing mandatory parameters: ${missing}`)
+  }
+
+  const { speed, defaultValue = DEFAULT_VALUE } = target
+
+  // The `state` property on a sprite is used to declare the desired animation.
+  // The Ticker needs its own internal property to track the *current* animation
+  // to detect when it changes. We'll use `target.animation`.
+  if (state !== target.animation) {
+    target.animation = state
+    target.counter = COUNTER_RESET
+    target.value = defaultValue
+  }
+
+  // Always ensure the public `state` property reflects the intended animation for `onTick`.
+  target.state = state
+
+  // Ensure properties are initialized on the first run for a given target.
+  target.counter ??= COUNTER_RESET
+  target.value ??= defaultValue
+
+  target.counter += dt
+  if (target.counter >= speed) {
+    target.counter = COUNTER_RESET
+    onTick?.(target, dt, options)
+  }
+}