@inglorious/engine 0.11.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/engine",
-  "version": "0.11.0",
+  "version": "1.1.0",
   "description": "A JavaScript game engine written with global state, immutability, and pure functions in mind. Have fun(ctional programming) with it!",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -30,8 +30,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@inglorious/store": "3.0.0",
-    "@inglorious/utils": "3.0.0"
+    "@inglorious/store": "4.0.0",
+    "@inglorious/utils": "3.2.0"
   },
   "devDependencies": {
     "prettier": "^3.5.3",

package/src/core/engine.js

@@ -1,6 +1,5 @@
 import { audio } from "@inglorious/engine/behaviors/audio.js"
 import { game } from "@inglorious/engine/behaviors/game.js"
-import { createApi } from "@inglorious/store/api.js"
 import { createStore } from "@inglorious/store/store.js"
 import { augmentType } from "@inglorious/store/types.js"
 import { isArray } from "@inglorious/utils/data-structures/array.js"
@@ -10,10 +9,8 @@ import { v } from "@inglorious/utils/v.js"
 
 import { coreEvents } from "./core-events.js"
 import { disconnectDevTools, initDevTools, sendAction } from "./dev-tools.js"
-import { Loops } from "./loops/loops.js"
+import { Loop } from "./loops/index.js"
 import { entityPoolMiddleware } from "./middlewares/entity-pool/entity-pool-middleware.js"
-import { EntityPools } from "./middlewares/entity-pool/entity-pools.js"
-import { applyMiddlewares } from "./middlewares/middlewares.js"
 import { multiplayerMiddleware } from "./middlewares/multiplayer-middleware.js"
 
 // Default game configuration
@@ -42,44 +39,29 @@ const ONE_SECOND = 1000 // Number of milliseconds in one second.
  */
 export class Engine {
   /**
-   * @param {Object} [gameConfig] - Game-specific configuration.
-   * @param {Object} [renderer] - UI entity responsible for rendering. It must have a `render` method.
+   * @param {...Object} gameConfigs - Game-specific configurations.
    */
   constructor(...gameConfigs) {
     this._config = extendWith(merger, DEFAULT_GAME_CONFIG, ...gameConfigs)
 
-    // Determine devMode from the entities config.
+    // Determine devMode from the entities config
     const devMode = this._config.entities.game?.devMode
     this._devMode = devMode
 
-    // Add user-defined systems
-    const systems = [...(this._config.systems ?? [])]
+    const middlewares = []
 
-    this._store = createStore({ ...this._config, systems })
+    // Always add entity pool middleware
+    middlewares.push(entityPoolMiddleware())
 
-    // Create API layer, with optional methods for debugging
-    this._api = createApi(this._store)
-
-    this._entityPools = new EntityPools()
-    this._api = applyMiddlewares(entityPoolMiddleware(this._entityPools))(
-      this._api,
-    )
-    this._api.getAllActivePoolEntities = () =>
-      this._entityPools.getAllActiveEntities()
-
-    if (this._devMode) {
-      this._api.getEntityPoolsStats = () => this._entityPools.getStats()
-    }
-
-    // Apply multiplayer if specified.
+    // Add multiplayer middleware if needed
     const multiplayer = this._config.entities.game?.multiplayer
     if (multiplayer) {
-      this._api = applyMiddlewares(multiplayerMiddleware(multiplayer))(
-        this._api,
-      )
+      middlewares.push(multiplayerMiddleware(multiplayer))
     }
 
-    this._loop = new Loops[this._config.loop.type]()
+    this._store = createStore({ ...this._config, middlewares })
+    this._api = this._store.getApi()
+    this._loop = new Loop[this._config.loop.type]()
 
     if (this._devMode) {
       initDevTools(this._store)
@@ -109,7 +91,7 @@ export class Engine {
    */
   stop() {
     this._api.notify("stop")
-    this._store.update(this._api)
+    this._store.update()
     this._loop.stop()
   }
 
@@ -119,7 +101,7 @@ export class Engine {
    */
   update(dt) {
     this._api.notify("update", dt)
-    const processedEvents = this._store.update(this._api)
+    const processedEvents = this._store.update()
     const state = this._store.getState()
 
     // Check for devMode changes and connect/disconnect dev tools accordingly.

package/src/core/loops/{loops.js → index.js}

@@ -6,7 +6,7 @@ import { LagLoop } from "./lag.js"
 
 // @see https://gameprogrammingpatterns.com/game-loop.html
 
-export const Loops = {
+export const Loop = {
   flash: FlashLoop,
   fixed: FixedLoop,
   elapsed: ElapsedLoop,

package/src/core/middlewares/entity-pool/entity-pool-middleware.js

@@ -1,10 +1,20 @@
 import { EventMap } from "@inglorious/store/event-map.js"
 
-export function entityPoolMiddleware(pools) {
-  return (api) => {
+import { EntityPools } from "./entity-pools"
+
+export function entityPoolMiddleware() {
+  return (store, api) => {
+    const pools = new EntityPools()
     const types = api.getTypes()
     const eventMap = new EventMap()
 
+    api.getAllActivePoolEntities = () => pools.getAllActiveEntities()
+
+    const game = api.getEntity("game")
+    if (game.devMode) {
+      api.getEntityPoolsStats = () => pools.getStats()
+    }
+
     return (next) => (event) => {
       switch (event.type) {
         case "spawn": {

package/src/core/middlewares/multiplayer-middleware.js

@@ -1,3 +1,7 @@
+import {
+  deserialize,
+  serialize,
+} from "@inglorious/utils/data-structures/object.js"
 import { extend } from "@inglorious/utils/data-structures/objects.js"
 
 import { coreEvents } from "../core-events.js"
@@ -19,21 +23,21 @@ export function multiplayerMiddleware(config = {}) {
   const localQueue = []
 
   // The middleware function that will be applied to the store.
-  return (api) => (next) => (event) => {
+  return (store) => (next) => (event) => {
     if (coreEvents.includes(event.type)) {
       return next(event)
     }
 
     // Establish the connection on the first event.
     if (!ws) {
-      establishConnection(api)
+      establishConnection(store)
     }
 
     // Only send the event to the server if it didn't come from the server.
     if (!event.fromServer) {
       if (ws?.readyState === WebSocket.OPEN) {
         // If the connection is open, send the event immediately.
-        ws.send(JSON.stringify(event))
+        ws.send(serialize(event))
       } else {
         // If the connection is not open, queue the event for later.
         localQueue.push(event)
@@ -48,7 +52,7 @@ export function multiplayerMiddleware(config = {}) {
   /**
    * Attempts to establish a WebSocket connection to the server.
    */
-  function establishConnection(api) {
+  function establishConnection(store) {
     // If a connection already exists, close it first.
     if (ws) {
       ws.close()
@@ -62,26 +66,26 @@ export function multiplayerMiddleware(config = {}) {
     ws.onopen = () => {
       // Send any queued events to the server.
       while (localQueue.length) {
-        ws.send(JSON.stringify(localQueue.shift()))
+        ws.send(serialize(localQueue.shift()))
       }
     }
 
     ws.onmessage = (event) => {
-      const serverEvent = JSON.parse(event.data)
+      const serverEvent = deserialize(event.data)
 
       if (serverEvent.type === "initialState") {
         // Merge the server's initial state with the client's local state.
-        const nextState = extend(api.getState(), serverEvent.payload)
-        api.setState(nextState)
+        const nextState = extend(store.getState(), serverEvent.payload)
+        store.setState(nextState)
       } else {
         // Dispatch the event to the local store to update the client's state.
-        api.dispatch({ ...serverEvent, fromServer: true })
+        store.dispatch({ ...serverEvent, fromServer: true })
       }
     }
 
     ws.onclose = () => {
       // Attempt to reconnect after a short delay.
-      setTimeout(() => establishConnection(api), reconnectionDelay)
+      setTimeout(() => establishConnection(store), reconnectionDelay)
     }
 
     ws.onerror = () => {

package/src/core/middlewares/middlewares.js

@@ -1,32 +0,0 @@
-import { compose } from "@inglorious/utils/functions/functions.js"
-
-/**
- * Applies a list of middleware functions to a store's dispatch method.
- *
- * @param {...Function} middlewares The middleware functions to apply.
- * @returns {Function} A store enhancer function.
- */
-export function applyMiddlewares(...middlewares) {
-  return (store) => {
-    let dispatch = () => {
-      throw new Error(
-        "Dispatching while constructing your middleware is not allowed.",
-      )
-    }
-
-    // The middleware API that can be passed to each middleware function.
-    const api = {
-      ...store,
-      dispatch: (...args) => dispatch(...args),
-      notify: (type, payload) => dispatch({ type, payload }),
-    }
-
-    // Create a chain of middleware functions.
-    const chain = middlewares.map((middleware) => middleware(api))
-
-    // Compose the middleware chain to create the final dispatch function.
-    dispatch = compose(...chain)(store.dispatch)
-
-    return api
-  }
-}