@inglorious/engine 0.2.0 → 0.4.0

package/src/{engine/core → core}/engine.js

@@ -1,119 +1,119 @@
-import { game } from "@inglorious/engine/behaviors/game.js"
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-
-import { createApi } from "./api.js"
-import {
-  ACTION_BLACKLIST,
-  disconnectDevTools,
-  initDevTools,
-  sendAction,
-} from "./dev-tools.js"
-import Loop from "./loop.js"
-import { createStore } from "./store.js"
-
-// Default game configuration
-// loop.type specifies the type of loop to use (defaults to "animationFrame").
-const DEFAULT_GAME_CONFIG = {
-  loop: { type: "animationFrame", fps: 60 },
-
-  systems: [],
-
-  types: {
-    game: [game()],
-  },
-
-  entities: {
-    // eslint-disable-next-line no-magic-numbers
-    game: { type: "game", bounds: [0, 0, 800, 600] },
-  },
-}
-
-const ONE_SECOND = 1000 // Number of milliseconds in one second.
-
-// Delta time for the final update call when stopping the engine.
-const FINAL_UPDATE_DELTA_TIME = 0 // This ensures any pending events (like 'stop') are processed before shutdown.
-
-/**
- * Engine class responsible for managing the game loop, state, and rendering.
- */
-export class Engine {
-  _devMode = false
-
-  /**
-   * @param {Object} [gameConfig] - Game-specific configuration.
-   * @param {Object} [renderer] - UI entity responsible for rendering. It must have a `render` method.
-   */
-  constructor(gameConfig) {
-    this._config = extend(DEFAULT_GAME_CONFIG, gameConfig)
-
-    const systems = [...(this._config.systems ?? [])]
-    if (this._config.renderer) {
-      systems.push(...this._config.renderer.getSystems())
-    }
-
-    this._store = createStore({ ...this._config, systems })
-    this._loop = new Loop[this._config.loop.type]()
-    this._api = createApi(this._store)
-
-    // The renderer might need the engine instance to initialize itself (e.g., to set up DOM events).
-    this._config.renderer?.init(this)
-
-    // Determine devMode from the entities config.
-    const devMode = this._config.entities.game?.devMode
-    this._devMode = devMode
-    if (devMode) {
-      initDevTools(this._store)
-    }
-  }
-
-  /**
-   * Starts the game engine, initializing the loop and notifying the store.
-   */
-  start() {
-    this._store.notify("start", this._api)
-    this._loop.start(this, ONE_SECOND / this._config.loop.fps)
-    this.isRunning = true
-  }
-
-  /**
-   * Stops the game engine, halting the loop and notifying the store.
-   */
-  stop() {
-    this._store.notify("stop", this._api)
-    this._store.update(FINAL_UPDATE_DELTA_TIME, this._api)
-    this._loop.stop()
-    this.isRunning = false
-  }
-
-  /**
-   * Updates the game state.
-   * @param {number} dt - Delta time since the last update in milliseconds.
-   */
-  update(dt) {
-    const processedEvents = this._store.update(dt, this._api)
-    const state = this._store.getState()
-
-    // Check for devMode changes and connect/disconnect dev tools accordingly.
-    const newDevMode = state.entities.game?.devMode
-    if (newDevMode !== this._devMode) {
-      if (newDevMode) {
-        initDevTools(this._store)
-      } else {
-        disconnectDevTools()
-      }
-      this._devMode = newDevMode
-    }
-
-    const eventsToLog = processedEvents.filter(
-      ({ type }) => !ACTION_BLACKLIST.includes(type),
-    )
-
-    if (eventsToLog.length) {
-      const action = {
-        type: eventsToLog.map(({ type }) => type).join("|"),
-        payload: eventsToLog,
-      }
-      sendAction(action, state)
-    }
-  }
-}
+import { game } from "@inglorious/engine/behaviors/game.js"
+import { createApi } from "@inglorious/store/api.js"
+import { createStore } from "@inglorious/store/store.js"
+import { extend } from "@inglorious/utils/data-structures/objects.js"
+
+import {
+  ACTION_BLACKLIST,
+  disconnectDevTools,
+  initDevTools,
+  sendAction,
+} from "./dev-tools.js"
+import Loop from "./loop.js"
+
+// Default game configuration
+// loop.type specifies the type of loop to use (defaults to "animationFrame").
+const DEFAULT_GAME_CONFIG = {
+  loop: { type: "animationFrame", fps: 60 },
+
+  systems: [],
+
+  types: {
+    game: [game()],
+  },
+
+  entities: {
+    // eslint-disable-next-line no-magic-numbers
+    game: { type: "game", bounds: [0, 0, 800, 600] },
+  },
+}
+
+const ONE_SECOND = 1000 // Number of milliseconds in one second.
+
+// Delta time for the final update call when stopping the engine.
+const FINAL_UPDATE_DELTA_TIME = 0 // This ensures any pending events (like 'stop') are processed before shutdown.
+
+/**
+ * Engine class responsible for managing the game loop, state, and rendering.
+ */
+export class Engine {
+  _devMode = false
+
+  /**
+   * @param {Object} [gameConfig] - Game-specific configuration.
+   * @param {Object} [renderer] - UI entity responsible for rendering. It must have a `render` method.
+   */
+  constructor(gameConfig) {
+    this._config = extend(DEFAULT_GAME_CONFIG, gameConfig)
+
+    const systems = [...(this._config.systems ?? [])]
+    if (this._config.renderer) {
+      systems.push(...this._config.renderer.getSystems())
+    }
+
+    this._store = createStore({ ...this._config, systems })
+    this._loop = new Loop[this._config.loop.type]()
+    this._api = createApi(this._store)
+
+    // The renderer might need the engine instance to initialize itself (e.g., to set up DOM events).
+    this._config.renderer?.init(this)
+
+    // Determine devMode from the entities config.
+    const devMode = this._config.entities.game?.devMode
+    this._devMode = devMode
+    if (devMode) {
+      initDevTools(this._store)
+    }
+  }
+
+  /**
+   * Starts the game engine, initializing the loop and notifying the store.
+   */
+  start() {
+    this._store.notify("start", this._api)
+    this._loop.start(this, ONE_SECOND / this._config.loop.fps)
+    this.isRunning = true
+  }
+
+  /**
+   * Stops the game engine, halting the loop and notifying the store.
+   */
+  stop() {
+    this._store.notify("stop", this._api)
+    this._store.update(FINAL_UPDATE_DELTA_TIME, this._api)
+    this._loop.stop()
+    this.isRunning = false
+  }
+
+  /**
+   * Updates the game state.
+   * @param {number} dt - Delta time since the last update in milliseconds.
+   */
+  update(dt) {
+    const processedEvents = this._store.update(dt, this._api)
+    const state = this._store.getState()
+
+    // Check for devMode changes and connect/disconnect dev tools accordingly.
+    const newDevMode = state.entities.game?.devMode
+    if (newDevMode !== this._devMode) {
+      if (newDevMode) {
+        initDevTools(this._store)
+      } else {
+        disconnectDevTools()
+      }
+      this._devMode = newDevMode
+    }
+
+    const eventsToLog = processedEvents.filter(
+      ({ type }) => !ACTION_BLACKLIST.includes(type),
+    )
+
+    if (eventsToLog.length) {
+      const action = {
+        type: eventsToLog.map(({ type }) => type).join("|"),
+        payload: eventsToLog,
+      }
+      sendAction(action, state)
+    }
+  }
+}

package/src/{engine/core → core}/loop.js

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

package/src/{engine/core → core}/loops/animation-frame.js

@@ -1,25 +1,25 @@
-const ONE_SECOND = 1000
-
-export 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)
-
-    this._previousTime = currentTime
-  }
-}
+const ONE_SECOND = 1000
+
+export 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)
+
+    this._previousTime = currentTime
+  }
+}

package/src/{engine/core → core}/loops/elapsed.js

@@ -1,22 +1,22 @@
-const ONE_SECOND = 1000
-
-export 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)
-
-      previousTime = currentTime
-    }
-  }
-
-  stop() {
-    this._shouldStop = true
-  }
-}
+const ONE_SECOND = 1000
+
+export 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)
+
+      previousTime = currentTime
+    }
+  }
+
+  stop() {
+    this._shouldStop = true
+  }
+}

package/src/{engine/core → core}/loops/fixed.js

@@ -1,27 +1,27 @@
-const ONE_SECOND = 1000
-
-export class FixedLoop {
-  _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)
-
-      previousTime = currentTime
-      await sleep(Date.now() - currentTime + msPerUpdate)
-    }
-  }
-
-  stop() {
-    this._shouldStop = true
-  }
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
+const ONE_SECOND = 1000
+
+export class FixedLoop {
+  _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)
+
+      previousTime = currentTime
+      await sleep(Date.now() - currentTime + msPerUpdate)
+    }
+  }
+
+  stop() {
+    this._shouldStop = true
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/{engine/core → core}/loops/flash.js

@@ -1,13 +1,13 @@
-export class FlashLoop {
-  _shouldStop = false
-
-  start(engine) {
-    while (!this._shouldStop) {
-      engine.update()
-    }
-  }
-
-  stop() {
-    this._shouldStop = true
-  }
-}
+export class FlashLoop {
+  _shouldStop = false
+
+  start(engine) {
+    while (!this._shouldStop) {
+      engine.update()
+    }
+  }
+
+  stop() {
+    this._shouldStop = true
+  }
+}

package/src/{engine/core → core}/loops/lag.js

@@ -1,26 +1,26 @@
-const ONE_SECOND = 1000
-
-export class LagLoop {
-  _shouldStop = false
-
-  start(engine, msPerUpdate) {
-    let previousTime = Date.now()
-    let lag = 0
-
-    while (!this._shouldStop) {
-      const currentTime = Date.now()
-      const dt = currentTime - previousTime
-      previousTime = currentTime
-      lag += dt
-
-      while (lag >= msPerUpdate) {
-        engine.update(dt / ONE_SECOND)
-        lag -= msPerUpdate
-      }
-    }
-  }
-
-  stop() {
-    this._shouldStop = true
-  }
-}
+const ONE_SECOND = 1000
+
+export class LagLoop {
+  _shouldStop = false
+
+  start(engine, msPerUpdate) {
+    let previousTime = Date.now()
+    let lag = 0
+
+    while (!this._shouldStop) {
+      const currentTime = Date.now()
+      const dt = currentTime - previousTime
+      previousTime = currentTime
+      lag += dt
+
+      while (lag >= msPerUpdate) {
+        engine.update(dt / ONE_SECOND)
+        lag -= msPerUpdate
+      }
+    }
+  }
+
+  stop() {
+    this._shouldStop = true
+  }
+}

package/src/main.js

@@ -1,10 +1,10 @@
-import { Engine } from "@inglorious/engine/core/engine.js"
-import { CanvasRenderer } from "@inglorious/renderers/canvas/canvas-renderer.js"
-import game from "game"
-
-const canvas = document.getElementById("canvas")
-window.addEventListener("load", () => {
-  const renderer = new CanvasRenderer(canvas)
-  const engine = new Engine({ ...game, renderer })
-  engine.start()
-})
+import { Engine } from "@inglorious/engine/core/engine.js"
+import { CanvasRenderer } from "@inglorious/renderer-2d/canvas-renderer.js"
+import game from "game"
+
+const canvas = document.getElementById("canvas")
+window.addEventListener("load", () => {
+  const renderer = new CanvasRenderer(canvas)
+  const engine = new Engine({ ...game, renderer })
+  engine.start()
+})

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

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

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

@@ -1,43 +1,43 @@
-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"
-import { applyFriction } from "@inglorious/utils/physics/friction.js"
-
-const DEFAULT_MAX_ACCELERATION = 0
-const DEFAULT_MAX_SPEED = 0
-const DEFAULT_FRICTION = 0
-
-const DEFAULT_ORIENTATION = 0
-
-const HALF_ACCELERATION = 0.5
-
-export function tankMove(entity, dt) {
-  const maxAcceleration = entity.maxAcceleration ?? DEFAULT_MAX_ACCELERATION
-  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
-  const friction = entity.friction ?? DEFAULT_FRICTION
-
-  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
-  orientation = toRange(orientation)
-
-  let acceleration = entity.acceleration ?? zero()
-  acceleration = rotate(acceleration, orientation)
-  acceleration = clamp(acceleration, -maxAcceleration, maxAcceleration)
-
-  let velocity = entity.velocity ?? zero()
-  velocity = sum(velocity, multiply(acceleration, dt))
-  velocity = clamp(velocity, -maxSpeed, maxSpeed)
-  velocity = applyFriction({ velocity, friction }, dt)
-
-  const position = sum(
-    entity.position,
-    multiply(velocity, dt),
-    multiply(acceleration, HALF_ACCELERATION * dt * 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"
+import { applyFriction } from "@inglorious/utils/physics/friction.js"
+
+const DEFAULT_MAX_ACCELERATION = 0
+const DEFAULT_MAX_SPEED = 0
+const DEFAULT_FRICTION = 0
+
+const DEFAULT_ORIENTATION = 0
+
+const HALF_ACCELERATION = 0.5
+
+export function tankMove(entity, dt) {
+  const maxAcceleration = entity.maxAcceleration ?? DEFAULT_MAX_ACCELERATION
+  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
+  const friction = entity.friction ?? DEFAULT_FRICTION
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation = toRange(orientation)
+
+  let acceleration = entity.acceleration ?? zero()
+  acceleration = rotate(acceleration, orientation)
+  acceleration = clamp(acceleration, -maxAcceleration, maxAcceleration)
+
+  let velocity = entity.velocity ?? zero()
+  velocity = sum(velocity, multiply(acceleration, dt))
+  velocity = clamp(velocity, -maxSpeed, maxSpeed)
+  velocity = applyFriction({ velocity, friction }, dt)
+
+  const position = sum(
+    entity.position,
+    multiply(velocity, dt),
+    multiply(acceleration, HALF_ACCELERATION * dt * dt),
+  )
+
+  return { velocity, position, orientation }
+}