@inglorious/engine 0.1.1 → 0.2.0

package/src/utils/physics/gravity.js

@@ -1,71 +1,69 @@
-/**
- * @typedef {import('@inglorious/utils/math/linear-algebra/types').Vector3} Vector3
- */
-
-/* eslint-disable no-magic-numbers */
-
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-const DEFAULT_OPTIONS = { dt: 0 } // Default options for the applyGravity function.
-const DEFAULT_JUMP = 0 // Default maximum jump height.
-const DEFAULT_LEAP = 0 // Default maximum leap distance.
-const DEFAULT_SPEED = 0 // Default maximum speed.
-const NO_VELOCITY = 0 // No initial velocity.
-
-/**
- * Applies gravity to an object based on its current velocity and position.
- *
- * @see https://youtu.be/hG9SzQxaCm8
- *
- * Projectile equations:
- * 1. a(t) = g
- * 2. v(t) = g*t + v_0
- * 3. y(t) = 1/2*g*t^2 + v_0*t + y_0
- *
- * Known values:
- * 1. y_0 = 0
- * 2. v(t_h) = 0 -> 2. 0 = g*t_h + v_0 -> v_0 = -g*t_h
- * 3. y_h = h -> 3. h = 1/2*g*t_h^2 (-g*t_h)*t_h = -1/2*g*t_h^2 -> g = -2*h/t_h^2
- * 4. v_0 = -g*t_h = (-2*h/t_h^2)*t_h = 2*h/t_h
- *
- * Transforming time into space:
- * 1. t_h = x_h/v_x
- * 2. v0 = 2*h/t_h = 2*h*v_x/x_h
- * 3. g = -2*h/t_h^2 = -2*h*v_x^2/x_h^2
- *
- * Euler's Integration:
- * 1. v += a * dt
- * 2. p += v * dt + 1/2 * a * dt * dt
- *
- * @param {Object} params - Parameters for gravity calculation.
- * @param {number} params.maxJump - Maximum jump height. Defaults to 0.
- * @param {number} params.maxLeap - Maximum leap distance. Defaults to 0.
- * @param {number} params.maxSpeed - Maximum speed. Defaults to 0.
- * @param {number} params.vy - Current vertical velocity. Defaults to 0.
- * @param {Vector3} params.position - Current position vector.
- * @param {Object} [options=DEFAULT_OPTIONS] - Additional options.
- * @param {number} options.dt - Time delta for the calculation.
- * @returns {Object} Updated acceleration, velocity, and position.
- * @throws {Error} If maxLeap is not provided.
- */
-export function applyGravity(params, options = DEFAULT_OPTIONS) {
-  let {
-    maxJump = DEFAULT_JUMP,
-    maxLeap = DEFAULT_LEAP,
-    maxSpeed = DEFAULT_SPEED,
-    vy = NO_VELOCITY,
-    position = zero(),
-  } = params
-
-  if (!maxLeap) {
-    throw new Error("Missing maxLeap")
-  }
-
-  const { dt } = options
-  const ay = (-2 * maxJump * maxSpeed ** 2) / maxLeap ** 2
-  vy += ay * dt
-  const [x, y, z] = position
-  const py = y + vy * dt + 0.5 * ay * dt * dt
-
-  return { ay, vy, position: [x, py, z] }
-}
+/**
+ * @typedef {import('@inglorious/utils/math/linear-algebra/types').Vector3} Vector3
+ */
+
+/* eslint-disable no-magic-numbers */
+
+import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
+
+const DEFAULT_DT = 1 // Default delta time for the applyGravity function.
+const DEFAULT_JUMP = 0 // Default maximum jump height.
+const DEFAULT_LEAP = 0 // Default maximum leap distance.
+const DEFAULT_SPEED = 0 // Default maximum speed.
+const NO_VELOCITY = 0 // No initial velocity.
+
+/**
+ * Applies gravity to an object based on its current velocity and position.
+ *
+ * @see https://youtu.be/hG9SzQxaCm8
+ *
+ * Projectile equations:
+ * 1. a(t) = g
+ * 2. v(t) = g*t + v_0
+ * 3. y(t) = 1/2*g*t^2 + v_0*t + y_0
+ *
+ * Known values:
+ * 1. y_0 = 0
+ * 2. v(t_h) = 0 -> 2. 0 = g*t_h + v_0 -> v_0 = -g*t_h
+ * 3. y_h = h -> 3. h = 1/2*g*t_h^2 (-g*t_h)*t_h = -1/2*g*t_h^2 -> g = -2*h/t_h^2
+ * 4. v_0 = -g*t_h = (-2*h/t_h^2)*t_h = 2*h/t_h
+ *
+ * Transforming time into space:
+ * 1. t_h = x_h/v_x
+ * 2. v0 = 2*h/t_h = 2*h*v_x/x_h
+ * 3. g = -2*h/t_h^2 = -2*h*v_x^2/x_h^2
+ *
+ * Euler's Integration:
+ * 1. v += a * dt
+ * 2. p += v * dt + 1/2 * a * dt * dt
+ *
+ * @param {Object} params - Parameters for gravity calculation.
+ * @param {number} params.maxJump - Maximum jump height. Defaults to 0.
+ * @param {number} params.maxLeap - Maximum leap distance. Defaults to 0.
+ * @param {number} params.maxSpeed - Maximum speed. Defaults to 0.
+ * @param {number} params.vy - Current vertical velocity. Defaults to 0.
+ * @param {Vector3} params.position - Current position vector. Defaults to a zero vector.
+ * @param {number} dt - Time delta for the calculation. Defaults to 1.
+ * @returns {Object} Updated acceleration, velocity, and position.
+ * @throws {Error} If maxLeap is not provided.
+ */
+export function applyGravity(params, dt = DEFAULT_DT) {
+  let {
+    maxJump = DEFAULT_JUMP,
+    maxLeap = DEFAULT_LEAP,
+    maxSpeed = DEFAULT_SPEED,
+    vy = NO_VELOCITY,
+    position = zero(),
+  } = params
+
+  if (!maxLeap) {
+    throw new Error("Missing maxLeap")
+  }
+
+  const ay = (-2 * maxJump * maxSpeed ** 2) / maxLeap ** 2
+  vy += ay * dt
+  const [x, y, z] = position
+  const py = y + vy * dt + 0.5 * ay * dt * dt
+
+  return { ay, vy, position: [x, py, z] }
+}

package/src/utils/physics/gravity.test.js

@@ -1,80 +1,77 @@
-import { expect, test } from "vitest"
-
-import { applyGravity } from "./gravity.js"
-
-test("it should compute no gravity when max jump height is not set", () => {
-  const params = {
-    maxLeap: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: [0, 10, 0],
-  }
-  const dt = 1
-
-  expect(applyGravity(params, { dt })).toStrictEqual({
-    ay: -0,
-    vy: 10,
-    position: [0, 20, 0],
-  })
-})
-
-test("it should throw an error when max leap distance is not set", () => {
-  const params = {
-    maxJump: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: [0, 10, 0],
-  }
-  const dt = 1
-
-  expect(() => applyGravity(params, { dt })).toThrow()
-})
-
-test("it should compute no gravity when max movement speed is not set", () => {
-  const params = {
-    maxJump: 10,
-    maxLeap: 10,
-    vy: 10,
-    position: [0, 10, 0],
-  }
-  const dt = 1
-
-  expect(applyGravity(params, { dt })).toStrictEqual({
-    ay: -0,
-    vy: 10,
-    position: [0, 20, 0],
-  })
-})
-
-test("it should apply no gravity when no time has passed (gravity is calculated but not applied)", () => {
-  const params = {
-    maxJump: 10,
-    maxLeap: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: [0, 10, 0],
-  }
-
-  expect(applyGravity(params)).toStrictEqual({
-    ay: -20,
-    vy: 10,
-    position: [0, 10, 0],
-  })
-})
-
-test("it should apply gravity based on input parameters", () => {
-  const params = {
-    maxJump: 10,
-    maxLeap: 10,
-    maxSpeed: 10,
-    vy: 10,
-    position: [0, 10, 0],
-  }
-  const dt = 1
-
-  expect(applyGravity(params, { dt })).toStrictEqual({
-    ay: -20,
-    vy: -10,
-    position: [0, -10, 0],
-  })
-})
+import { expect, test } from "vitest"
+
+import { applyGravity } from "./gravity.js"
+
+test("it should apply gravity based on input parameters", () => {
+  const params = {
+    maxJump: 10,
+    maxLeap: 10,
+    maxSpeed: 10,
+    vy: 10,
+    position: [0, 10, 0],
+  }
+
+  expect(applyGravity(params)).toStrictEqual({
+    ay: -20,
+    vy: -10,
+    position: [0, -10, 0],
+  })
+})
+
+test("it should compute no gravity when max jump height is not set", () => {
+  const params = {
+    maxLeap: 10,
+    maxSpeed: 10,
+    vy: 10,
+    position: [0, 10, 0],
+  }
+
+  expect(applyGravity(params)).toStrictEqual({
+    ay: -0,
+    vy: 10,
+    position: [0, 20, 0],
+  })
+})
+
+test("it should compute no gravity when max movement speed is not set", () => {
+  const params = {
+    maxJump: 10,
+    maxLeap: 10,
+    vy: 10,
+    position: [0, 10, 0],
+  }
+
+  expect(applyGravity(params)).toStrictEqual({
+    ay: -0,
+    vy: 10,
+    position: [0, 20, 0],
+  })
+})
+
+test("it should apply no gravity when no time has passed", () => {
+  const params = {
+    maxJump: 10,
+    maxLeap: 10,
+    maxSpeed: 10,
+    vy: 10,
+    position: [0, 10, 0],
+  }
+  const dt = 0
+
+  expect(applyGravity(params, dt)).toStrictEqual({
+    ay: -20,
+    vy: 10,
+    position: [0, 10, 0],
+  })
+})
+
+test("it should throw an error when max leap distance is not set", () => {
+  const params = {
+    maxJump: 10,
+    maxSpeed: 10,
+    vy: 10,
+    position: [0, 10, 0],
+  }
+
+  expect(() => applyGravity(params)).toThrow()
+})

package/src/utils/physics/jump.js

@@ -1,41 +1,31 @@
-/**
- * @typedef {import('@inglorious/utils/math/linear-algebra/types').Vector3} Vector3
- */
-
-/* eslint-disable no-magic-numbers */
-
-import { zero } from "@inglorious/utils/math/linear-algebra/vector.js"
-
-const DEFAULT_OPTIONS = { dt: 0 } // Default options for the jump function.
-const DEFAULT_MAX_JUMP = 0 // Default maximum jump height.
-const DEFAULT_MAX_LEAP = 0 // Default maximum leap distance.
-const DEFAULT_MAX_SPEED = 0 // Default maximum speed.
-
-/**
- * Calculates the vertical velocity (vy) and updates the Y position
- * based on the provided parameters and options.
- *
- * @param {Object} params - Parameters for the jump calculation.
- * @param {number} params.maxJump - Maximum jump height. Defaults to 0.
- * @param {number} params.maxLeap - Maximum leap distance. Defaults to 0.
- * @param {number} params.maxSpeed - Maximum speed. Defaults to 0.
- * @param {Vector3} params.position - Current position vector.
- * @param {Object} [options=DEFAULT_OPTIONS] - Options for the jump calculation.
- * @param {number} options.dt - Delta time for the calculation. Defaults to 0.
- * @returns {Object} An object containing the vertical velocity (vy) and updated position.
- */
-export function jump(params, options = DEFAULT_OPTIONS) {
-  let {
-    maxJump = DEFAULT_MAX_JUMP,
-    maxLeap = DEFAULT_MAX_LEAP,
-    maxSpeed = DEFAULT_MAX_SPEED,
-    position = zero(),
-  } = params
-  const { dt } = options
-
-  const vy = (2 * maxJump * maxSpeed) / maxLeap
-  const [x, y, z] = position
-  const py = y + vy * dt
-
-  return { vy, position: [x, py, z] }
-}
+/**
+ * @typedef {import('@inglorious/utils/math/linear-algebra/types').Vector3} Vector3
+ */
+
+/* eslint-disable no-magic-numbers */
+
+const DEFAULT_MAX_JUMP = 0 // Default maximum jump height.
+const DEFAULT_MAX_LEAP = 0 // Default maximum leap distance.
+const DEFAULT_MAX_SPEED = 0 // Default maximum speed.
+
+/**
+ * Calculates the vertical velocity (vy) of a jump
+ * based on the provided parameters.
+ *
+ * @param {Object} params - Parameters for the jump calculation.
+ * @param {number} params.maxJump - Maximum jump height. Defaults to 0.
+ * @param {number} params.maxLeap - Maximum leap distance. Defaults to 0.
+ * @param {number} params.maxSpeed - Maximum speed. Defaults to 0.
+ * @returns {number} The computed vertical velocity (vy).
+ */
+export function jump(params) {
+  let {
+    maxJump = DEFAULT_MAX_JUMP,
+    maxLeap = DEFAULT_MAX_LEAP,
+    maxSpeed = DEFAULT_MAX_SPEED,
+  } = params
+
+  const vy = (2 * maxJump * maxSpeed) / maxLeap
+
+  return vy
+}

package/src/utils/physics/velocity.js

@@ -1,38 +1,36 @@
-/**
- * @typedef {import('@inglorious/utils/math/linear-algebra/types').Vector3} Vector3
- */
-
-import {
-  clamp,
-  multiply,
-  zero,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-const DEFAULT_OPTIONS = { dt: 0 } // Default options for the applyVelocity function.
-const DEFAULT_MAX_SPEED = 0 // Default maximum speed for velocity clamping.
-
-/**
- * Applies velocity to a position based on the given parameters and options.
- *
- * @param {Object} params - The parameters for velocity application.
- * @param {number} [params.maxSpeed] - The maximum speed for clamping the velocity. Defaults to 0.
- * @param {Vector3} [params.velocity] - The current velocity vector. Defaults to a zero vector.
- * @param {Vector3} [params.position] - The current position vector. Defaults to a zero vector.
- * @param {Object} [options=DEFAULT_OPTIONS] - Additional options for velocity application.
- * @param {number} [options.dt=0] - The time delta for the calculation. Defaults to 0.
- * @returns {Object} The updated velocity and position.
- */
-export function applyVelocity(params, options = DEFAULT_OPTIONS) {
-  let {
-    maxSpeed = DEFAULT_MAX_SPEED,
-    velocity = zero(),
-    position = zero(),
-  } = params
-  const { dt } = options
-
-  velocity = clamp(velocity, -maxSpeed, maxSpeed)
-
-  position = sum(position, multiply(velocity, dt))
-  return { velocity, position }
-}
+/**
+ * @typedef {import('@inglorious/utils/math/linear-algebra/types').Vector3} Vector3
+ */
+
+import {
+  clamp,
+  multiply,
+  zero,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import { sum } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const DEFAULT_DT = 1 // Default time delta for the applyVelocity function.
+const DEFAULT_MAX_SPEED = 0 // Default maximum speed for velocity clamping.
+
+/**
+ * Applies velocity to a position based on the given parameters and options.
+ *
+ * @param {Object} params - The parameters for velocity application.
+ * @param {number} [params.maxSpeed] - The maximum speed for clamping the velocity. Defaults to 0.
+ * @param {Vector3} [params.velocity] - The current velocity vector. Defaults to a zero vector.
+ * @param {Vector3} [params.position] - The current position vector. Defaults to a zero vector.
+ * @param {number} [dt=0] - The time delta for the calculation. Defaults to 0.
+ * @returns {Object} The updated velocity and position.
+ */
+export function applyVelocity(params, dt = DEFAULT_DT) {
+  let {
+    maxSpeed = DEFAULT_MAX_SPEED,
+    velocity = zero(),
+    position = zero(),
+  } = params
+
+  velocity = clamp(velocity, -maxSpeed, maxSpeed)
+
+  position = sum(position, multiply(velocity, dt))
+  return { velocity, position }
+}

package/src/engine/loop.js

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

package/src/engine/store.js

@@ -1,174 +0,0 @@
-import { enableGame } from "@inglorious/game/decorators/game.js"
-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"
-
-const DEFAULT_TYPES = {
-  game: [enableGame()],
-}
-
-const DEFAULT_INSTANCES = {
-  // eslint-disable-next-line no-magic-numbers
-  game: { type: "game", bounds: [0, 0, 800, 600] }, // Default game instance with bounds.
-}
-
-const DEFAULT_LAYER = 0
-
-/**
- * Creates a store to manage state and events.
- * @param {Object} options - Configuration options for the store.
- * @param {Object} options.instances - Initial instances to include in the store.
- * @param {Object} options.originalConfig - Additional configuration for the store.
- * @returns {Object} The store with methods to interact with state and events.
- */
-export function createStore({
-  types: originalTypes,
-  instances: originalInstances,
-}) {
-  const listeners = new Set()
-  let incomingEvents = []
-
-  let types = extend(DEFAULT_TYPES, originalTypes)
-  types = augmentTypes(types)
-
-  let instances = extend(DEFAULT_INSTANCES, originalInstances)
-  instances = augmentInstances(instances)
-
-  let state = { events: [], instances }
-
-  return {
-    subscribe,
-    update,
-    notify,
-    dispatch: notify, // needed for react-redux
-    getTypes,
-    getState,
-  }
-
-  /**
-   * 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.
-   */
-  function update(dt) {
-    state = { ...state }
-
-    state.events.push(...incomingEvents, { id: "game:update" })
-    incomingEvents = []
-
-    while (state.events.length) {
-      const event = state.events.shift()
-
-      if (event.id === "instance:add") {
-        add(event.payload.id, event.payload)
-      }
-
-      state.instances = map(state.instances, (_, instance, instances) => {
-        const type = types[instance.type]
-        const handle = type[event.id]
-        return (
-          handle?.(instance, event, {
-            dt,
-            type: originalTypes[instance.type],
-            instances,
-            notify,
-          }) ?? instance
-        )
-      })
-
-      if (event.id === "instance:remove") {
-        remove(event.payload)
-      }
-    }
-
-    listeners.forEach((onUpdate) => onUpdate())
-  }
-
-  /**
-   * Adds a new instance to the state.
-   * @param {string} id - The ID of the instance to add.
-   * @param {Object} instance - The instance object to add.
-   */
-  function add(id, instance) {
-    state = { ...state }
-    state.instances[id] = augmentInstance(id, instance)
-  }
-
-  /**
-   * Removes an instance from the state.
-   * @param {string} id - The ID of the instance to remove.
-   */
-  function remove(id) {
-    state = { ...state }
-    delete state.instances[id]
-  }
-
-  /**
-   * Notifies the store of a new event.
-   * @param {Object} event - The event object to notify.
-   */
-  function notify(event) {
-    incomingEvents.push(event)
-  }
-
-  /**
-   * Retrieves the types configuration.
-   * @returns {Object} The types configuration.
-   */
-  function getTypes() {
-    return types
-  }
-
-  /**
-   * Retrieves the current state.
-   * @returns {Object} The current state.
-   */
-  function getState() {
-    return state
-  }
-}
-
-function augmentTypes(types) {
-  return pipe(applyDecorators, enableMutability)(types)
-}
-
-function applyDecorators(types) {
-  return map(types, (_, type) => {
-    if (!Array.isArray(type)) {
-      return type
-    }
-
-    const decorators = type.map((fn) =>
-      typeof fn !== "function" ? (type) => extend(type, fn) : fn,
-    )
-    return pipe(...decorators)({})
-  })
-}
-
-function enableMutability(types) {
-  return map(types, (_, { draw, ...events }) => ({
-    draw,
-    ...map(events, (_, event) => produce(event)),
-  }))
-}
-
-function augmentInstances(instances) {
-  return map(instances, augmentInstance)
-}
-
-function augmentInstance(id, instance) {
-  return { ...instance, layer: instance.layer ?? DEFAULT_LAYER, id }
-}