@inglorious/server 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/server",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A real-time, lightweight server designed to enable multiplayer experiences for games built with the Inglorious Engine.",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -41,7 +41,7 @@
   "dependencies": {
     "pino": "^9.9.4",
     "ws": "^8.18.3",
-    "@inglorious/store": "1.0.0"
+    "@inglorious/store": "1.2.0"
   },
   "devDependencies": {
     "globals": "^16.3.0",

package/src/game-loader.js

@@ -11,39 +11,28 @@ export async function loadGame(gameFilePath, logger) {
   let gameConfig = {}
 
   try {
-    // Dynamically import the game module.
+    if (!gameFilePath) {
+      return gameConfig
+    }
+
     const __filename = fileURLToPath(import.meta.url)
     const __dirname = path.dirname(__filename)
     const modulePath = path.resolve(__dirname, gameFilePath)
-    const { default: config } = await import(`file://${modulePath}`)
-    gameConfig = config
-    gameConfig.types ??= {}
-    gameConfig.entities ??= {}
+    const module = await import(`file://${modulePath}`)
 
     logger.info(`Loaded game data from ${gameFilePath}`)
+    gameConfig = module.default
+    return gameConfig
   } catch (error) {
     logger.error(`Failed to load game module: ${gameFilePath}`)
     logger.error(error)
-    // Fallback to a basic initial state if loading fails.
-    gameConfig = {
-      types: {
-        player: {
-          move: (entity, payload) => {
-            logger.info(
-              `Player ${entity.id} moved to ${payload.x}, ${payload.y}`,
-            )
-          },
-        },
-        box: {},
-      },
 
-      entities: {
-        player1: { id: "player1", type: "player", x: 0, y: 0 },
-        box1: { id: "box1", type: "box", x: 10, y: 10 },
-      },
-    }
+    // Fallback to a basic initial state if loading fails.
     logger.warn("Using default game state as a fallback.")
+    gameConfig = {}
+    return gameConfig
+  } finally {
+    gameConfig.types ??= {}
+    gameConfig.entities ??= {}
   }
-
-  return gameConfig
 }

package/src/index.js

@@ -2,69 +2,35 @@ import http from "node:http"
 
 import { createStore } from "@inglorious/store"
 import pino from "pino"
-import { WebSocketServer } from "ws"
 
 import { loadGame } from "./game-loader.js"
-import { start as startGameLoop } from "./game-loop.js"
-import { setup as setupWebSocketHandler } from "./ws-handler.js"
+import * as gameLoop from "./game-loop.js"
+import * as wsHandler from "./ws-handler.js"
 
-// The server's port. You can change this or use an environment variable.
-const PORT = 3000
-const HTTP_STATUS_OK = 200
+const ERROR_CODE = 1
+const DEFAULT_PORT = 3000
 
 const logger = pino({ name: "Inglorious Server", level: "info" })
 
-// =========================================================================
-// Initial Game State
-// =========================================================================
-
-// Get the game file path from command-line arguments.
-let [, , gameFilePath] = process.argv
-gameFilePath ??= "./default-game.js"
-
-const gameConfig = await loadGame(gameFilePath, logger)
-
-// =========================================================================
-// Server Setup
-// =========================================================================
-
-// Create a minimal HTTP server. The WebSocket server will be "attached" to this.
-const httpServer = http.createServer((req, res) => {
-  res.writeHead(HTTP_STATUS_OK, { "Content-Type": "text/plain" })
-  res.end("Inglorious Server is running.")
+bootstrap().catch((error) => {
+  logger.error(error, "Failed to start the server.")
+  process.exit(ERROR_CODE)
 })
 
-// Create the WebSocket server.
-const wss = new WebSocketServer({ server: httpServer })
-const clients = new Set() // A Set to keep track of all connected clients.
+async function bootstrap() {
+  let [, , gameFilePath] = process.argv
+  const gameConfig = await loadGame(gameFilePath, logger)
 
-// Initialize the game store. This is the central source of truth.
-const store = createStore(gameConfig)
+  const store = createStore(gameConfig)
 
-// A small-scale API for your systems and events to interact with the world.
-// This can be expanded as needed.
-const api = {
-  // A simple broadcast function.
-  broadcast: (event) => {
-    // Stringify the event for transmission.
-    const message = JSON.stringify(event)
-    for (const client of clients) {
-      client.send(message)
-    }
-  },
-}
-
-// =========================================================================
-// Start Game Loop and WebSocket Handling
-// =========================================================================
+  const httpServer = http.createServer()
 
-// Start the core game loop.
-startGameLoop(store, api)
+  wsHandler.setup(httpServer, store, logger)
 
-// Set up the WebSocket event handlers.
-setupWebSocketHandler(wss, store, clients, logger)
+  gameLoop.start(store)
 
-// Start the server and listen on the specified port.
-httpServer.listen(PORT, () => {
-  logger.info(`Listening on http://localhost:${PORT}`)
-})
+  const port = process.env.PORT || DEFAULT_PORT
+  httpServer.listen(port, () => {
+    logger.info(`Listening on http://localhost:${port}`)
+  })
+}

package/src/ws-handler.js

@@ -1,49 +1,42 @@
+import { WebSocketServer } from "ws"
+
 /**
- * Sets up WebSocket event handling for a given server and store.
- * @param {object} wss The WebSocket server instance.
+ * Initializes the WebSocket server and sets up event handlers.
+ * @param {object} httpServer The HTTP server instance to attach to.
  * @param {object} store The game store instance.
- * @param {Set<object>} clients A Set to keep track of all connected clients.
  * @param {object} logger A Pino logger instance.
+ * @returns {void}
  */
-export function setup(wss, store, clients, logger) {
-  // Listen for new client connections.
+export function setup(httpServer, store, logger) {
+  const wss = new WebSocketServer({ server: httpServer })
+
   wss.on("connection", (ws) => {
     logger.info("A new client has connected.")
-    clients.add(ws)
 
-    // Send the initial state to the new client.
     ws.send(JSON.stringify({ type: "initialState", payload: store.getState() }))
 
-    // Listen for messages from the client.
-    ws.on("message", (message) => {
+    ws.on("message", (rawData) => {
       try {
-        // Parse the incoming event.
-        const event = JSON.parse(message)
-
-        // Dispatch the event to the central store.
+        const eventString = rawData.toString()
+        const event = JSON.parse(eventString)
         store.dispatch(event)
 
-        // Broadcast the event to all other clients.
-        const eventMessage = JSON.stringify(event)
-        for (const client of clients) {
-          if (client !== ws) {
-            // Exclude the sender from the broadcast.
-            client.send(eventMessage)
+        for (const client of wss.clients) {
+          if (client !== ws && client.readyState === WebSocket.OPEN) {
+            client.send(eventString)
           }
         }
       } catch (error) {
-        logger.error("Failed to parse message:", error)
+        logger.error({ error }, "Failed to parse message.")
       }
     })
 
-    // Listen for the client disconnecting.
-    ws.on("close", () => {
-      logger.info("A client has disconnected.")
-      clients.delete(ws)
+    ws.on("close", (code, reason) => {
+      logger.info(`Client disconnected. Code: ${code}, Reason: ${reason}`)
     })
 
     ws.on("error", (error) => {
-      logger.error("WebSocket error:", error)
+      logger.error({ error }, "WebSocket error occurred.")
     })
   })
 }

package/src/default-game.js

@@ -1 +0,0 @@
-export default {}