@inglorious/engine 0.1.0 → 0.2.0

package/src/docs/utils/math/random.mdx

@@ -1,35 +0,0 @@
-import { Meta } from '@storybook/blocks'
-
-import { random, randomBinomial } from '@inglorious/utils/math/rng'
-
-<Meta title="Utils/Math/Rng" />
-
-# Rng
-
-Random number generators.
-
-## Random
-
-Generates a random number with optional parameters that specify range and step.
-
-No parameters will generate a random number in the range `[0, 1)` (zero included, one excluded).
-
-<code>random() == {random()}</code>&nbsp;
-
-A parameter `n` means the random number will be an integer in the range `[0, n]` (zero and `n` included).
-
-<code>random(6) == {random(6)}</code>&nbsp;
-
-Two parameters `n` and `m` means the random number will be an integer in the range `[n, m]` (both numbers included).
-
-<code>random(1, 6) == {random(1, 6)}</code>&nbsp;
-
-A third parameter allows to specify the step.
-
-<code>random(2, 6, 2) == {random(2, 6, 2)}</code>&nbsp;
-
-## Random Binomial
-
-Generates a random number in the range `(-1, 1)` (minus one excluded, one excluded), with probability following the [Binomial Distribution](https://en.wikipedia.org/wiki/Binomial_distribution).
-
-<code>randomBinomial() == {randomBinomial()}</code>&nbsp;

package/src/docs/utils/math/statistics.mdx

@@ -1,38 +0,0 @@
-import { Meta } from '@storybook/blocks'
-
-import { mean, median, mode } from '@inglorious/utils/math/statistics'
-import { toString } from '@inglorious/utils/data-structures/object'
-
-<Meta title="Utils/Math/Statistics" />
-
-# Statistics
-
-Basic statistics functions.
-
-## Average
-
-Alias of `mean`.
-
-## Mean
-
-Returns the mathematical mean of a list of numbers.
-
-<code>mean(1, 3, 2) == {mean(1, 3, 2)}</code>&nbsp;
-
-## Median
-
-Returns the median value from a list of numbers.
-
-When the list has odd length, the median is whatever value sits in between:
-
-<code>median(1, 3, 2) == {median(1, 3, 2)}</code>&nbsp;
-
-When the list has an even length, the median is the average of its two values in between (in this case, 2 and 3):
-
-<code>median(1, 3, 2, 4) == {median(1, 3, 2, 4)}</code>&nbsp;
-
-## Mode
-
-Returns the most frequent item in a list of values.
-
-<code>mode("rarely", "sometimes", "sometimes", "always") == {toString(mode("rarely", "sometimes", "sometimes", "always"))}</code>&nbsp;

package/src/docs/utils/math/trigonometry.mdx

@@ -1,85 +0,0 @@
-import { Meta } from '@storybook/blocks'
-
-import { atan2, cos, cosine, pi, sin, sine, toDegrees, toRadians, toRange } from '@inglorious/utils/math/trigonometry'
-
-<Meta title="Utils/Math/Trigonometry" />
-
-# Trigonometry
-
-Basic trigonometry functions.
-
-## Atan2
-
-Returns the atan2 of y and x.
-
-<code>atan2(0, 0) == {atan2(0, 0)}</code>&nbsp;
-
-
-<code>atan2(0, pi() / 2) == {atan2(0, pi() / 2)}</code>&nbsp;
-
-
-<code>atan2(pi() / 2, 0) == {atan2(pi() / 2, 0)}</code>&nbsp;
-
-
-<code>atan2(pi() / 2, pi() / 2) == {atan2(pi() / 2, pi() / 2)}</code>&nbsp;
-
-## Cos
-
-Returns the cosine of an angle in radians (alias `cosine`).
-
-<code>cos(0) == {cos(0)}</code>&nbsp;
-
-<code>cos(pi() / 4) == {cos(pi() / 4).toFixed(3)}</code>&nbsp;
-
-<code>cos(pi() / 2) == {cos(pi() / 2)}</code> (&asymp;0)
-
-## Cosine
-
-Alias of `cos`.
-
-## Pi
-
-Returns an approximation of &pi;.
-
-<code>pi() == {pi()}</code> (&asymp;&pi;)
-
-## Sin
-
-Return the sine of an angle in degrees (alias `sine`).
-
-
-<code>sin(0) == {sin(0)}</code>&nbsp;
-
-<code>sin(pi() / 4) == {sin(pi() / 4).toFixed(3)}</code>&nbsp;
-
-<code>sin(pi() / 2) == {sin(pi() / 2)}</code>&nbsp;
-
-## Sine
-
-Alias of `sin`.
-
-## To Degrees
-
-Converts radians into degrees.
-
-<code>toDegrees(pi() / 4) == {toDegrees(pi() / 4)}</code>&nbsp;
-
-## To Radians
-
-Converts degrees into radians.
-
-<code>toRadians(45) == {toRadians(45)}</code> (&asymp;&pi;/4)
-
-## To Range
-
-Clamps any angle into the range [-&pi;, &pi;].
-
-<code>toRange(5 / 4 * pi()) == {toRange((5 / 4) * pi())}</code> (&asymp;-3/4&pi;)
-
-<code>toRange(13 / 4 * pi()) == {toRange((13 / 4) * pi())}</code> (&asymp;-3/4&pi;)
-
-<code>toRange(-5 / 4 * pi()) == {toRange((-5 / 4) * pi())}</code> (&asymp;3/4&pi;)
-
-<code>toRange(-13 / 4 * pi()) == {toRange((-13 / 4) * pi())}</code> (&asymp;3/4&pi;)
-
-<code>toRange(3 / 4 * pi()) == {toRange((3 / 4) * pi())}</code> (&asymp;3/4&pi;)

package/src/docs/utils/physics/friction.mdx

@@ -1,20 +0,0 @@
-import { Meta } from '@storybook/blocks'
-
-import { applyFriction } from '@inglorious/utils/physics/friction'
-import { toString } from '@inglorious/utils/math/linear-algebra/vector'
-
-<Meta title="Utils/Physics/Friction" />
-
-# Friction
-
-Friction is a force that resists movement. It is directly related to the body's momentum, which is mass times velocity, but for our purposes we can safely ignore mass and apply it directly to velocity.
-
-A friction that is equal to the velocity's magnitude will eventually stop the body after some time.
-
-<code>applyFriction(\{ velocity: [8, 0, 6], friction: 5 \}, \{ dt: 1 \}) == {toString(applyFriction({ velocity: [8, 0, 6], friction: 5 }, { dt: 1 }))}</code>&nbsp;
-
-<code>applyFriction(\{ velocity: [8, 0, 6], friction: 5 \}, \{ dt: 2 \}) == {toString(applyFriction({ velocity: [8, 0, 6], friction: 5 }, { dt: 2 }))}</code>&nbsp;
-
-When the body is still then no friction will be applied:
-
-<code>applyFriction(\{ velocity: [0, 0, 0], friction: 5 \}, \{ dt: 1 \}) == {toString(applyFriction({ velocity: [0, 0, 0], friction: 5 }, { dt: 1 }))}</code>&nbsp;

package/src/docs/utils/physics/gravity.mdx

@@ -1,28 +0,0 @@
-import { Meta } from '@storybook/blocks'
-
-import { applyGravity } from '@inglorious/utils/physics/gravity'
-import { toString } from '@inglorious/utils/data-structures/object'
-
-<Meta title="Utils/Physics/Gravity" />
-
-# Gravity
-
-We can consider gravity as a constant acceleration downards. [This video](https://youtu.be/hG9SzQxaCm8) shows how to calculate this acceleration based on the curve that we want our character to draw when jumping. Also, it rightfully warns to keep jump parameters separate from our world coordinates. That's why we need a specific acceleration and velocity to model our jumps, while directly integrating into the position vector.
-
-- `maxJump` is the maximum height that we want to achieve;
-- `maxLeap` is the maximum distance we want to cover with a jump;
-- `maxSpeed` is the maximum horizontal speed when running;
-- `vy` is the current jump velocity;
-- `position[Y]` is the current world height.
-
-<code>applyGravity(\{ maxJump: 10, maxLeap: 10, maxSpeed: 10, vy: 10, position: [0,10,0] \}, \{ dt: 1 \}) == {toString(applyGravity({ maxJump: 10, maxLeap: 10, maxSpeed: 10, vy: 10, position: [0,10,0] }, { dt: 1 }))}</code>&nbsp;
-
-Not specifying `maxJump` and `maxSpeed` will result in no gravity being applied:
-
-<code>applyGravity(\{ maxLeap: 10, maxSpeed: 10, vy: 10, position: [0,10,0] \}, \{ dt: 1 \}) == {toString(applyGravity({ maxLeap: 10, maxSpeed: 10, vy: 10, position: [0,10,0] }, { dt: 1 }))}</code>&nbsp;
-
-<code>applyGravity(\{ maxJump: 10, maxSpeed: 10, vy: 10, position: [0,10,0] \}, \{ dt: 1 \}) == {toString(applyGravity({ maxJump: 10, maxLeap: 10, vy: 10, position: [0,10,0] }, { dt: 1 }))}</code>&nbsp;
-
-While not specifying `maxLeap` will result in an error, since we have to divide by this quantity:
-
-<code>applyGravity(\{ maxJump: 10, maxSpeed: 10, vy: 10, position: [0,10,0] \}, \{ dt: 1 \}) == Error(['maxLeap'])</code>&nbsp;

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 }
-}

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)
-})