@inglorious/engine 0.1.0 → 0.2.0

package/src/engine/core/store.js

@@ -0,0 +1,178 @@
+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"
+
+/**
+ * Creates a store to manage state and events.
+ * @param {Object} config - Configuration options for the store.
+ * @param {Object} [config.types] - The initial types configuration.
+ * @param {Object} [config.entities] - The initial entities configuration.
+ * @returns {Object} The store with methods to interact with state and events.
+ */
+export function createStore({
+  types: originalTypes,
+  entities: originalEntities,
+  systems = [],
+}) {
+  const listeners = new Set()
+  let incomingEvents = []
+
+  let types = augmentTypes(originalTypes)
+  let entities = augmentEntities(originalEntities)
+
+  const initialState = { entities }
+  let state = initialState
+
+  return {
+    subscribe,
+    update,
+    notify,
+    dispatch, // needed for compatibility with Redux
+    getTypes,
+    getOriginalTypes,
+    getState,
+    setState,
+    reset,
+  }
+
+  /**
+   * 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 in milliseconds.
+   * @param {Object} api - The engine's public API.
+   */
+  function update(dt, api) {
+    const processedEvents = []
+
+    state = produce(state, (state) => {
+      incomingEvents.push({ type: "update", payload: dt })
+
+      while (incomingEvents.length) {
+        const event = incomingEvents.shift()
+        processedEvents.push(event)
+
+        if (event.type === "morph") {
+          const { id, type } = event.payload
+          originalTypes[id] = type
+          types = augmentTypes(originalTypes)
+        }
+
+        if (event.type === "add") {
+          const { id, ...entity } = event.payload
+          state.entities[id] = augmentEntity(id, entity)
+        }
+
+        if (event.type === "remove") {
+          const id = event.payload
+          delete state.entities[id]
+        }
+
+        for (const id in state.entities) {
+          const entity = state.entities[id]
+          const type = types[entity.type]
+          const handle = type[event.type]
+          handle?.(entity, event.payload, api)
+        }
+
+        systems.forEach((system) => {
+          const handle = system[event.type]
+          handle?.(state, event.payload, api)
+        })
+      }
+    })
+
+    listeners.forEach((onUpdate) => onUpdate())
+
+    return processedEvents
+  }
+
+  /**
+   * Notifies the store of a new event.
+   * @param {string} type - The event object type to notify.
+   * @param {any} payload - The event object payload to notify.
+   */
+  function notify(type, payload) {
+    dispatch({ type, payload })
+  }
+
+  /**
+   * Dispatches an event to be processed in the next update cycle.
+   * @param {Object} event - The event object.
+   * @param {string} event.type - The type of the event.
+   * @param {any} [event.payload] - The payload of the event.
+   */
+  function dispatch(event) {
+    incomingEvents.push(event)
+  }
+
+  /**
+   * Retrieves the augmented types configuration.
+   * This includes composed behaviors and event handlers wrapped for immutability.
+   * @returns {Object} The augmented types configuration.
+   */
+  function getTypes() {
+    return types
+  }
+
+  /**
+   * Retrieves the original, un-augmented types configuration.
+   * @returns {Object} The original types configuration.
+   */
+  function getOriginalTypes() {
+    return originalTypes
+  }
+
+  /**
+   * Retrieves the current state.
+   * @returns {Object} The current state.
+   */
+  function getState() {
+    return state
+  }
+
+  function setState(newState) {
+    state = newState
+  }
+
+  function reset() {
+    state = initialState // Reset state to its originally computed value
+  }
+}
+
+function augmentTypes(types) {
+  return pipe(applyBehaviors)(types)
+}
+
+function applyBehaviors(types) {
+  return map(types, (_, type) => {
+    if (!Array.isArray(type)) {
+      return type
+    }
+
+    const behaviors = type.map((fn) =>
+      typeof fn !== "function" ? (type) => extend(type, fn) : fn,
+    )
+    return pipe(...behaviors)({})
+  })
+}
+
+function augmentEntities(entities) {
+  return map(entities, augmentEntity)
+}
+
+function augmentEntity(id, entity) {
+  return { ...entity, id }
+}

package/src/engine/core/store.test.js

@@ -0,0 +1,110 @@
+import { expect, test } from "vitest"
+
+import { createStore } from "./store.js"
+
+test("it should process events by mutating state inside handlers", () => {
+  const config = {
+    types: {
+      kitty: {
+        feed(entity) {
+          entity.isFed = true
+        },
+        update(entity) {
+          entity.isMeowing = true
+        },
+      },
+    },
+    entities: {
+      kitty1: { type: "kitty" },
+    },
+  }
+  const afterState = {
+    entities: {
+      kitty1: {
+        id: "kitty1",
+        type: "kitty",
+        isFed: true,
+        isMeowing: true,
+      },
+    },
+  }
+
+  const store = createStore(config)
+  store.notify("feed")
+  store.update(0, {})
+
+  const state = store.getState()
+  expect(state).toStrictEqual(afterState)
+})
+
+test("it should send an event from an entity and process it in the same update cycle", () => {
+  const config = {
+    types: {
+      doggo: {
+        update(entity, dt, api) {
+          api.notify("bark")
+        },
+      },
+      kitty: {
+        bark(entity) {
+          entity.position = "far"
+        },
+      },
+    },
+    entities: {
+      doggo1: { type: "doggo" },
+      kitty1: { type: "kitty", position: "near" },
+    },
+  }
+  const afterState = {
+    entities: {
+      doggo1: { id: "doggo1", type: "doggo" },
+      kitty1: { id: "kitty1", type: "kitty", position: "far" },
+    },
+  }
+
+  const store = createStore(config)
+  const api = { notify: store.notify }
+  store.update(0, api)
+
+  const state = store.getState()
+  expect(state).toStrictEqual(afterState)
+})
+
+test("it should add an entity via an 'add' event", () => {
+  const config = {
+    types: {
+      kitty: {},
+    },
+    entities: {},
+  }
+  const newEntity = { id: "kitty1", type: "kitty" }
+
+  const store = createStore(config)
+  store.notify("add", newEntity)
+  store.update(0, {})
+
+  const state = store.getState()
+  expect(state).toStrictEqual({
+    entities: {
+      kitty1: { id: "kitty1", type: "kitty" },
+    },
+  })
+})
+
+test("it should remove an entity via a 'remove' event", () => {
+  const config = {
+    types: {},
+    entities: {
+      kitty1: { type: "kitty" },
+    },
+  }
+  const store = createStore(config)
+
+  store.notify("remove", "kitty1")
+
+  store.update(0, {})
+
+  const state = store.getState()
+  expect(state.entities.kitty1).toBeUndefined()
+})

package/src/engine/movement/dynamic/modern.js

@@ -1,24 +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 default function modernMove(instance, options) {
-  const { acceleration, velocity, position } = applyAcceleration(
-    instance,
-    options,
-  )
-
-  let orientation = instance.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/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 default function tankMove(instance, { dt }) {
-  const maxAcceleration = instance.maxAcceleration ?? DEFAULT_MAX_ACCELERATION
-  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
-  const friction = instance.friction ?? DEFAULT_FRICTION
-
-  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
-  orientation = toRange(orientation)
-
-  let acceleration = instance.acceleration ?? zero()
-  acceleration = rotate(acceleration, orientation)
-  acceleration = clamp(acceleration, -maxAcceleration, maxAcceleration)
-
-  let velocity = instance.velocity ?? zero()
-  velocity = sum(velocity, multiply(acceleration, dt))
-  velocity = clamp(velocity, -maxSpeed, maxSpeed)
-  velocity = applyFriction({ velocity, friction }, { dt })
-
-  const position = sum(
-    instance.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 }
+}

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

@@ -1,16 +1,16 @@
-import {
-  angle,
-  magnitude,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import { applyVelocity } from "@inglorious/utils/physics/velocity.js"
-
-const DEFAULT_ORIENTATION = 0
-
-export default function modernMove(instance, options) {
-  const { velocity, position } = applyVelocity(instance, options)
-
-  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
-  orientation = magnitude(velocity) ? angle(velocity) : orientation
-
-  return { velocity, position, orientation }
-}
+import {
+  angle,
+  magnitude,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { applyVelocity } from "@inglorious/utils/physics/velocity.js"
+
+const DEFAULT_ORIENTATION = 0
+
+export function modernMove(entity, dt) {
+  const { velocity, position } = applyVelocity(entity, dt)
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation = magnitude(velocity) ? angle(velocity) : orientation
+
+  return { velocity, position, orientation }
+}

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

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

package/src/engine/movement/kinematic/tank.js

@@ -1,27 +1,27 @@
-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"
-
-const DEFAULT_MAX_SPEED = 0
-
-const DEFAULT_ORIENTATION = 0
-
-export default function tankMove(instance, { dt }) {
-  const maxSpeed = instance.maxSpeed ?? DEFAULT_MAX_SPEED
-
-  let orientation = instance.orientation ?? DEFAULT_ORIENTATION
-  orientation = toRange(orientation)
-
-  let velocity = instance.velocity ?? zero()
-  velocity = rotate(velocity, orientation)
-  velocity = clamp(velocity, -maxSpeed, maxSpeed)
-
-  const position = sum(instance.position, multiply(velocity, 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"
+
+const DEFAULT_MAX_SPEED = 0
+
+const DEFAULT_ORIENTATION = 0
+
+export function tankMove(entity, dt) {
+  const maxSpeed = entity.maxSpeed ?? DEFAULT_MAX_SPEED
+
+  let orientation = entity.orientation ?? DEFAULT_ORIENTATION
+  orientation = toRange(orientation)
+
+  let velocity = entity.velocity ?? zero()
+  velocity = rotate(velocity, orientation)
+  velocity = clamp(velocity, -maxSpeed, maxSpeed)
+
+  const position = sum(entity.position, multiply(velocity, dt))
+
+  return { velocity, position, orientation }
+}