@inglorious/engine 0.1.1 → 0.2.0

package/src/engine/store.test.js

@@ -1,256 +0,0 @@
-import { expect, test } from "vitest"
-
-import { createStore } from "./store.js"
-
-test("it should add an event to the event queue", () => {
-  const event = { id: "something:happened" }
-  const config = {
-    types: {
-      kitty: {
-        [event.id](instance) {
-          return { ...instance, wasNotified: true }
-        },
-      },
-    },
-    instances: {
-      instance1: { type: "kitty" },
-    },
-  }
-  const store = createStore(config)
-  const afterState = {
-    events: [],
-    instances: {
-      game: {
-        id: "game",
-        type: "game",
-        layer: 0,
-        bounds: [0, 0, 800, 600],
-      },
-      instance1: {
-        id: "instance1",
-        type: "kitty",
-        layer: 0,
-        wasNotified: true,
-      },
-    },
-  }
-
-  store.notify(event)
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should process the event queue", () => {
-  const event = { id: "something:happened" }
-  const config = {
-    types: {
-      kitty: {
-        "game:update"(instance) {
-          return { ...instance, wasUpdated: true }
-        },
-
-        [event.id](instance) {
-          return { ...instance, wasNotified: true }
-        },
-      },
-    },
-    instances: {
-      instance1: { type: "kitty" },
-    },
-  }
-  const store = createStore(config)
-  store.notify(event)
-  const afterState = {
-    events: [],
-    instances: {
-      game: {
-        id: "game",
-        type: "game",
-        layer: 0,
-        bounds: [0, 0, 800, 600],
-      },
-      instance1: {
-        id: "instance1",
-        type: "kitty",
-        layer: 0,
-        wasNotified: true,
-        wasUpdated: true,
-      },
-    },
-  }
-
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should send an event from an instance", () => {
-  const event = {
-    id: "doge:message",
-    payload: { id: "inu", message: "Woof!" },
-  }
-  const config = {
-    types: {
-      doge: {
-        "game:update"(instance, event, { instances, notify }) {
-          if (instances.instance2.position === "near") {
-            notify(event)
-          }
-        },
-      },
-      kitty: {
-        [event.id](instance) {
-          if (event.payload.id === "inu" && event.payload.message === "Woof!") {
-            instance.position = "far"
-          }
-        },
-      },
-    },
-
-    instances: {
-      instance1: {
-        type: "doge",
-      },
-      instance2: {
-        type: "kitty",
-        position: "near",
-      },
-    },
-  }
-  const store = createStore(config)
-  const afterState = {
-    events: [],
-    instances: {
-      game: {
-        id: "game",
-        type: "game",
-        layer: 0,
-        bounds: [0, 0, 800, 600],
-      },
-      instance1: {
-        id: "instance1",
-        type: "doge",
-        layer: 0,
-      },
-      instance2: {
-        id: "instance2",
-        type: "kitty",
-        layer: 0,
-        position: "near", // should do nothing at first
-      },
-    },
-  }
-
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should receive an event from an instance", () => {
-  const event = {
-    id: "doge:message",
-    payload: { id: "inu", message: "Woof!" },
-  }
-  const config = {
-    types: {
-      doge: {
-        "game:update"(instance, event, { instances, notify }) {
-          if (instances.instance2.position === "near") {
-            notify(event)
-          }
-        },
-      },
-      kitty: {
-        [event.id](instance, event) {
-          if (event.payload.id === "inu" && event.payload.message === "Woof!") {
-            instance.position = "far"
-          }
-        },
-      },
-    },
-
-    instances: {
-      instance1: {
-        type: "doge",
-      },
-      instance2: {
-        type: "kitty",
-        position: "near",
-      },
-    },
-  }
-  const store = createStore(config)
-  store.notify(event)
-  const afterState = {
-    events: [],
-    instances: {
-      game: {
-        id: "game",
-        type: "game",
-        layer: 0,
-        bounds: [0, 0, 800, 600],
-      },
-      instance1: {
-        id: "instance1",
-        type: "doge",
-        layer: 0,
-      },
-      instance2: {
-        id: "instance2",
-        type: "kitty",
-        layer: 0,
-        position: "far", // position changed
-      },
-    },
-  }
-
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should mutate state in an immutable way", () => {
-  const config = {
-    types: {
-      kitty: {
-        "game:update"(instance) {
-          instance.wasUpdated = true
-        },
-      },
-    },
-
-    instances: {
-      instance1: {
-        type: "kitty",
-      },
-    },
-  }
-  const store = createStore(config)
-  const afterState = {
-    events: [],
-    instances: {
-      game: {
-        id: "game",
-        type: "game",
-        layer: 0,
-        bounds: [0, 0, 800, 600],
-      },
-      instance1: {
-        id: "instance1",
-        type: "kitty",
-        layer: 0,
-        wasUpdated: true,
-      },
-    },
-  }
-
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})

package/src/engine.js

@@ -1,74 +0,0 @@
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-
-import Loop from "./engine/loop.js"
-import { createStore } from "./engine/store.js"
-
-// Default configuration for the engine
-// loop.type specifies the type of loop to use (defaults to "animationFrame").
-const DEFAULT_CONFIG = {
-  loop: { type: "animationFrame" },
-}
-const ONE_SECOND = 1000 // Number of milliseconds in one second.
-
-/**
- * Engine class responsible for managing the game loop, state, and rendering.
- */
-export default class Engine {
-  /**
-   * @param {Object} game - Game-specific configuration.
-   * @param {Object} ui - UI instance responsible for rendering.
-   */
-  constructor(game, ui) {
-    this._config = extend(DEFAULT_CONFIG, game)
-    this._store = createStore(this._config)
-    this._loop = new Loop[this._config.loop.type]()
-    this._ui = ui
-  }
-
-  /**
-   * Starts the game engine, initializing the loop and notifying the store.
-   */
-  start() {
-    this._store.notify({ id: "game:start" })
-    this._loop.start(this, ONE_SECOND / this._config.loop.fps)
-    this.isRunning = true
-  }
-
-  /**
-   * Updates the game state.
-   * @param {number} dt - Delta time since the last update in milliseconds.
-   */
-  update(dt) {
-    this._store.update(dt)
-  }
-
-  /**
-   * Renders the game state using the UI.
-   * @param {number} dt - Delta time since the last render in milliseconds.
-   */
-  render(dt) {
-    this._ui?.render({
-      dt,
-      types: this._store.getTypes(),
-      instances: this._store.getState().instances,
-    })
-  }
-
-  /**
-   * Notifies the store of an event.
-   * @param {Object} event - Event object to notify the store with.
-   */
-  notify = (event) => {
-    this._store.notify(event)
-  }
-
-  /**
-   * Stops the game engine, halting the loop and notifying the store.
-   */
-  stop() {
-    this._store.notify({ id: "game:stop" })
-    this._store.update()
-    this._loop.stop()
-    this.isRunning = false
-  }
-}

package/src/game/animation.js

@@ -1,26 +0,0 @@
-const COUNTER_RESET = 0
-const DEFAULT_VALUE = 0
-
-export const Animation = { play }
-
-function play(what, state, instance, options) {
-  const { dt, onTick } = options
-  const {
-    speed,
-    defaultValue = DEFAULT_VALUE,
-    value = DEFAULT_VALUE,
-  } = instance[what]
-
-  if (state !== instance[what].state) {
-    instance[what].state = state
-    instance[what].counter = COUNTER_RESET
-    instance[what].value = defaultValue
-  }
-
-  instance[what].counter += dt
-  if (instance[what].counter >= speed) {
-    instance[what].counter = COUNTER_RESET
-    instance[what].value = value
-    onTick && onTick(instance, options)
-  }
-}

package/src/game/bounds.js

@@ -1,66 +0,0 @@
-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 X = 0
-const Z = 2
-
-export function bounce(instance, { dt, instances }) {
-  const [minX, minZ, maxX, maxZ] = instances.game.bounds
-  const [x, , z] = instance.position
-
-  const velocity = createVector(instance.maxSpeed, instance.orientation)
-  if (x < minX || x >= maxX) {
-    velocity[X] = -velocity[X]
-  }
-
-  if (z < minZ || z >= maxZ) {
-    velocity[Z] = -velocity[Z]
-  }
-
-  const position = sum(instance.position, multiply(velocity, dt))
-  const orientation = angle(velocity)
-
-  return { velocity, position, orientation }
-}
-
-// TODO: make the following functions pure
-export function clampToBounds(instance, [minX, minZ, maxX, maxZ]) {
-  instance.position = clamp(
-    instance.position,
-    [minX, minZ, minZ],
-    [maxX, maxZ, maxZ],
-  )
-}
-
-export function flip(instance, [minX, minZ, maxX, maxZ]) {
-  const [x, , z] = instance.position
-
-  const direction = fromAngle(instance.orientation)
-
-  if (x < minX || x >= maxX || z < minZ || z >= maxZ) {
-    if (x < minX) {
-      direction[X] = abs(direction[X])
-    } else if (x >= maxX) {
-      direction[X] = -abs(direction[X])
-    }
-
-    if (z < minZ) {
-      direction[Z] = abs(direction[Z])
-    } else if (z >= maxZ) {
-      direction[Z] = -abs(direction[Z])
-    }
-
-    instance.acceleration = zero()
-    instance.velocity = zero()
-  }
-
-  instance.orientation = angle(direction)
-}

package/src/game/decorators/character.js

@@ -1,5 +0,0 @@
-import draw from "@inglorious/ui/canvas/character.js"
-
-export function enableCharacter() {
-  return { draw }
-}

package/src/game/decorators/clamp-to-bounds.js

@@ -1,15 +0,0 @@
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-
-import { clampToBounds } from "../bounds.js"
-
-export function enableClampToBounds() {
-  return (type) =>
-    extend(type, {
-      "game:update"(instance, event, options) {
-        type["game:update"]?.(instance, event, options)
-
-        const { instances } = options
-        clampToBounds(instance, instances.game.bounds)
-      },
-    })
-}

package/src/game/decorators/controls/dynamic/modern.js

@@ -1,48 +0,0 @@
-import modernMove from "@inglorious/engine/movement/dynamic/modern.js"
-import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-const DEFAULT_PARAMS = {
-  maxAcceleration: 500,
-}
-const X = 0
-const Z = 2
-
-export function enableModernControls(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      "game:update"(instance, event, options) {
-        type["game:update"]?.(instance, event, options)
-
-        const maxAcceleration =
-          instance.maxAcceleration ?? params.maxAcceleration
-
-        const { input0 } = options.instances
-        instance.acceleration = zero()
-
-        if (input0.left) {
-          instance.acceleration[X] = -maxAcceleration
-        }
-        if (input0.right) {
-          instance.acceleration[X] = maxAcceleration
-        }
-        if (input0.down) {
-          instance.acceleration[Z] = -maxAcceleration
-        }
-        if (input0.up) {
-          instance.acceleration[Z] = maxAcceleration
-        }
-
-        if (input0.leftRight != null) {
-          instance.acceleration[X] += input0.leftRight * maxAcceleration
-        }
-        if (input0.upDown != null) {
-          instance.acceleration[Z] += -input0.upDown * maxAcceleration
-        }
-
-        merge(instance, modernMove(instance, options))
-      },
-    })
-}

package/src/game/decorators/controls/dynamic/shooter.js

@@ -1,47 +0,0 @@
-import face from "@inglorious/engine/ai/movement/dynamic/face.js"
-import tankMove from "@inglorious/engine/movement/dynamic/tank.js"
-import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { pi } from "@inglorious/utils/math/trigonometry.js"
-
-const FULL_CIRCLE = 2
-const DEFAULT_PARAMS = {
-  maxAngularSpeed: FULL_CIRCLE * pi(),
-  maxSpeed: 250,
-}
-const X = 0
-const Z = 2
-
-export function enableShooterControls(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      "game:update"(instance, event, options) {
-        instance.maxAngularSpeed =
-          instance.maxAngularSpeed ?? params.maxAngularSpeed
-        instance.maxAcceleration =
-          instance.maxAcceleration ?? params.maxAcceleration
-        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
-
-        const { input0, mouse } = options.instances
-        instance.acceleration = zero()
-
-        if (input0.left) {
-          instance.acceleration[Z] = -instance.maxAcceleration
-        }
-        if (input0.down) {
-          instance.acceleration[X] = -instance.maxAcceleration
-        }
-        if (input0.right) {
-          instance.acceleration[Z] = instance.maxAcceleration
-        }
-        if (input0.up) {
-          instance.acceleration[X] = instance.maxAcceleration
-        }
-
-        merge(instance, face(instance, mouse, options))
-        merge(instance, tankMove(instance, options))
-      },
-    })
-}

package/src/game/decorators/controls/dynamic/tank.js

@@ -1,55 +0,0 @@
-import tankMove from "@inglorious/engine/movement/dynamic/tank.js"
-import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-const DEFAULT_PARAMS = {
-  maxAngularSpeed: 10,
-  maxAcceleration: 500,
-  maxSpeed: 250,
-}
-const X = 0
-const Z = 2
-
-export function enableTankControls(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      "game:update"(instance, event, options) {
-        instance.maxAngularSpeed =
-          instance.maxAngularSpeed ?? params.maxAngularSpeed
-        instance.maxAcceleration =
-          instance.maxAcceleration ?? params.maxAcceleration
-        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
-
-        instance.acceleration = zero()
-
-        const { input0 } = options.instances
-        if (input0.left) {
-          instance.orientation += 0.1
-        }
-        if (input0.down) {
-          instance.acceleration[X] = -instance.maxAcceleration
-        }
-        if (input0.right) {
-          instance.orientation -= 0.1
-        }
-        if (input0.up) {
-          instance.acceleration[X] = instance.maxAcceleration
-        }
-
-        if (input0.leftRight != null) {
-          instance.orientation +=
-            -input0.leftRight * instance.maxAngularSpeed * options.dt
-        }
-        if (input0.upDown != null) {
-          instance.acceleration[X] += -input0.upDown * instance.maxAcceleration
-        }
-        if (input0.strafe != null) {
-          instance.acceleration[Z] += input0.strafe * instance.maxAcceleration
-        }
-
-        merge(instance, tankMove(instance, options))
-      },
-    })
-}

package/src/game/decorators/controls/kinematic/modern.js

@@ -1,49 +0,0 @@
-import modernMove from "@inglorious/engine/movement/kinematic/modern.js"
-import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-const DEFAULT_PARAMS = {
-  onState: "default",
-  movementStrategy: "kinematic",
-  maxSpeed: 250,
-}
-const X = 0
-const Z = 2
-
-export function enableModernControls(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      "game:update"(instance, event, options) {
-        type["game:update"]?.(instance, event, options)
-
-        const maxSpeed = instance.maxSpeed ?? params.maxSpeed
-
-        const { input0 } = options.instances
-        instance.velocity = zero()
-
-        if (input0.left) {
-          instance.velocity[X] = -maxSpeed
-        }
-        if (input0.down) {
-          instance.velocity[Z] = -maxSpeed
-        }
-        if (input0.right) {
-          instance.velocity[X] = maxSpeed
-        }
-        if (input0.up) {
-          instance.velocity[Z] = maxSpeed
-        }
-
-        if (input0.leftRight != null) {
-          instance.velocity[X] += input0.leftRight * maxSpeed
-        }
-        if (input0.upDown != null) {
-          instance.velocity[Z] += -input0.upDown * maxSpeed
-        }
-
-        merge(instance, modernMove(instance, options))
-      },
-    })
-}

package/src/game/decorators/controls/kinematic/shooter.js

@@ -1,45 +0,0 @@
-import face from "@inglorious/engine/ai/movement/kinematic/face.js"
-import tankMove from "@inglorious/engine/movement/kinematic/tank.js"
-import { extend, merge } from "@inglorious/utils/data-structures/objects.js"
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { pi } from "@inglorious/utils/math/trigonometry.js"
-
-const FULL_CIRCLE = 2
-const DEFAULT_PARAMS = {
-  maxAngularSpeed: FULL_CIRCLE * pi(),
-  maxSpeed: 250,
-}
-const X = 0
-const Z = 2
-
-export function enableShooterControls(params) {
-  params = extend(DEFAULT_PARAMS, params)
-
-  return (type) =>
-    extend(type, {
-      "game:update"(instance, event, options) {
-        instance.maxAngularSpeed =
-          instance.maxAngularSpeed ?? params.maxAngularSpeed
-        instance.maxSpeed = instance.maxSpeed ?? params.maxSpeed
-
-        const { input0, mouse } = options.instances
-        instance.velocity = zero()
-
-        if (input0.left) {
-          instance.velocity[Z] = -instance.maxSpeed
-        }
-        if (input0.down) {
-          instance.velocity[X] = -instance.maxSpeed
-        }
-        if (input0.right) {
-          instance.velocity[Z] = instance.maxSpeed
-        }
-        if (input0.up) {
-          instance.velocity[X] = instance.maxSpeed
-        }
-
-        merge(instance, face(instance, mouse, options))
-        merge(instance, tankMove(instance, options))
-      },
-    })
-}