cyberia 2.8.885

package/src/server/logger.js

@@ -0,0 +1,197 @@
+/**
+ * Module for managing logger control and configuration
+ * @module src/server/logger.js
+ * @namespace Logger
+ */
+
+'use strict';
+
+import dotenv from 'dotenv';
+import winston from 'winston';
+import morgan from 'morgan';
+import colorize from 'json-colorizer';
+import colors from 'colors';
+import v8 from 'v8';
+import { clearTerminalStringColor, formatBytes } from '../client/components/core/CommonJs.js';
+
+colors.enable();
+dotenv.config();
+
+// Define your severity levels.
+// With them, You can create log files,
+// see or hide levels based on the running ENV.
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4,
+};
+
+// This method set the current severity based on
+// the current NODE_ENV: show all the log levels
+// if the server was run in development mode; otherwise,
+// if it was run in production, show only warn and error messages.
+const level = () => 'info'; // (process.env.NODE_ENV || 'development' ? 'debug' : 'warn');
+
+// Define different colors for each level.
+// Colors make the log message more visible,
+// adding the ability to focus or ignore messages.
+
+// Tell winston that you want to link the colors
+// defined above to the severity levels.
+winston.addColors({
+  error: 'red',
+  warn: 'yellow',
+  info: 'green',
+  http: 'magenta',
+  debug: 'white',
+});
+
+// Chose the aspect of your log customizing the log format.
+const format = (meta) =>
+  winston.format.combine(
+    // winston.format.errors({ stack: true }),
+    // Add the message timestamp with the preferred format
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }),
+    // Tell Winston that the logs must be colored
+    winston.format.colorize({ all: true }),
+    // Define the format of the message showing the timestamp, the level and the message
+    winston.format.printf((info) => {
+      const symbols = Object.getOwnPropertySymbols(info);
+      return `${`[${meta}]`.green} ${info.timestamp} ${info.level} ${
+        symbols[1]
+          ? `${clearTerminalStringColor(info.message)}: ${colorize(JSON.stringify(info[symbols[1]][0], null, 4), {
+              colors: {
+                STRING_KEY: 'green',
+                STRING_LITERAL: 'magenta.bold',
+                NUMBER_LITERAL: '#FF0000',
+              },
+            })}`
+          : info.message
+      }`;
+    }),
+  );
+
+/**
+ * Logs information about the current process environment to the console.
+ *
+ * This function is used to log details about
+ * the execution context, such as command-line arguments,
+ * environment variables, and the maximum available heap space size.
+ *
+ * @param {winston.Logger} logger - A pre-configured Winston logger object.
+ * @memberof Logger
+ */
+const setUpInfo = async (logger = new winston.Logger()) => {
+  logger.info('argv', process.argv);
+  logger.info('cwd', process.cwd());
+  logger.info('platform', process.platform);
+  logger.info('env', process.env.NODE_ENV);
+  logger.info('--max-old-space-size', {
+    total_available_size: formatBytes(v8.getHeapStatistics().total_available_size),
+  });
+};
+
+/**
+ * The function `loggerFactory` creates a logger instance with specified transports for printing out
+ * messages.
+ * @param meta - The `meta` parameter in the `loggerFactory` function is used to extract the last part
+ * of a URL and use it to create log files in a specific directory.
+ * @returns {winston.Logger} The `loggerFactory` function returns a logger instance created using Winston logger
+ * library. The logger instance is configured with various transports for printing out messages to
+ * different destinations such as the terminal, error.log file, and all.log file. The logger instance
+ * also has a method `setUpInfo` attached to it for setting up additional information.
+ * @memberof Logger
+ */
+const loggerFactory = (meta = { url: '' }) => {
+  meta = meta.url.split('/').pop();
+  // Define which transports the logger must use to print out messages.
+  // In this example, we are using three different transports
+  const transports = [
+    // Allow the use the terminal to print the messages
+    new winston.transports.Console(),
+    // Allow to print all the error level messages inside the error.log file
+    // new winston.transports.File({
+    //   filename: `logs/${meta}/error.log`,
+    //   level: 'error',
+    // }),
+    // Allow to print all the error message inside the all.log file
+    // (also the error log that are also printed inside the error.log(
+    new winston.transports.File({ filename: `logs/${meta}/all.log` }),
+  ];
+
+  // Create the logger instance that has to be exported
+  // and used to log messages.
+  const logger = winston.createLogger({
+    defaultMeta: meta,
+    level: level(),
+    levels,
+    format: format(meta),
+    transports,
+    // exceptionHandlers: [new winston.transports.File({ filename: 'exceptions.log' })],
+    // rejectionHandlers: [new winston.transports.File({ filename: 'rejections.log' })],
+    // exitOnError: false,
+  });
+  logger.setUpInfo = async () => {
+    await setUpInfo(logger);
+  };
+  return logger;
+};
+
+/**
+ * The `loggerMiddleware` function creates a middleware for logging HTTP requests using Morgan with
+ * custom message format and options.
+ * @param meta - The `meta` parameter in the `loggerMiddleware` function is an object that contains
+ * information about the request URL. It has a default value of an empty object `{ url: '' }`. This
+ * object is used to provide additional metadata for logging purposes.
+ * @returns {Handler<any, any>} The `loggerMiddleware` function returns a middleware function that uses the Morgan library
+ * to log HTTP request information. The middleware function formats the log message using predefined
+ * tokens provided by Morgan and custom tokens like `:host` to include specific request details. The
+ * log message format includes information such as remote address, HTTP method, host, URL, status code,
+ * content length, and response time in milliseconds. The middleware
+ * @memberof Logger
+ */
+const loggerMiddleware = (meta = { url: '' }) => {
+  const stream = {
+    // Use the http severity
+    write: (message) => loggerFactory(meta).http(message),
+  };
+
+  const skip = (req, res) => process.env.NODE_ENV === 'production';
+
+  morgan.token('host', function (req, res) {
+    return req.headers['host'];
+  });
+
+  return morgan(
+    // Define message format string (this is the default one).
+    // The message format is made from tokens, and each token is
+    // defined inside the Morgan library.
+    // You can create your custom token to show what do you want from a request.
+    `:remote-addr :method :host:url :status :res[content-length] - :response-time ms`,
+    // Options: in this case, I overwrote the stream and the skip logic.
+    // See the methods above.
+    { stream, skip },
+  );
+};
+
+const underpostASCII = () => `
+
+██╗░░░██╗███╗░░██╗██████╗░███████╗██████╗░██████╗░░█████╗░░██████╗████████╗
+██║░░░██║████╗░██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
+██║░░░██║██╔██╗██║██║░░██║█████╗░░██████╔╝██████╔╝██║░░██║╚█████╗░░░░██║░░░
+██║░░░██║██║╚████║██║░░██║██╔══╝░░██╔══██╗██╔═══╝░██║░░██║░╚═══██╗░░░██║░░░
+╚██████╔╝██║░╚███║██████╔╝███████╗██║░░██║██║░░░░░╚█████╔╝██████╔╝░░░██║░░░
+░╚═════╝░╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝░░╚═╝╚═╝░░░░░░╚════╝░╚═════╝░░░░╚═╝░░░
+                                                `;
+
+const actionInitLog = () =>
+  console.log(
+    underpostASCII() +
+      `
+    https://www.nexodev.org/docs
+`,
+  );
+
+export { loggerFactory, loggerMiddleware, setUpInfo, underpostASCII, actionInitLog };

package/src/server/network.js

@@ -0,0 +1,72 @@
+import Underpost from '../index.js';
+import { actionInitLog, loggerFactory } from './logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const logRuntimeRouter = () => {
+  const displayLog = {};
+
+  for (const host of Object.keys(Underpost.deployNetwork))
+    for (const path of Object.keys(Underpost.deployNetwork[host]))
+      displayLog[Underpost.deployNetwork[host][path].publicHost] = Underpost.deployNetwork[host][path].local;
+
+  logger.info('Runtime network', displayLog);
+};
+
+const listenServerFactory = (logic = async () => {}) => {
+  return {
+    listen: async (...args) => (
+      setTimeout(() => {
+        const message = 'Listen server factory timeout';
+        logger.error(message);
+        throw new Error(message);
+      }, 80000000), // ~ 55 days
+      (logic ? await logic(...args) : undefined, args[1]())
+    ),
+  };
+};
+
+const listenPortController = async (server, port, metadata) =>
+  new Promise((resolve) => {
+    try {
+      if (port === ':') {
+        server.listen(port, actionInitLog);
+        return resolve(true);
+      }
+
+      const { host, path, client, runtime, meta } = metadata;
+      const error = [];
+      if (port === undefined) error.push(`port`);
+      if (host === undefined) error.push(`host`);
+      if (path === undefined) error.push(`path`);
+      if (client === undefined) error.push(`client`);
+      if (runtime === undefined) error.push(`runtime`);
+      if (meta === undefined) error.push(`meta`);
+      if (error.length > 0) throw new Error('Listen port controller requires values: ' + error.join(', '));
+
+      server.listen(port, () => {
+        if (!Underpost.deployNetwork[host]) Underpost.deployNetwork[host] = {};
+        Underpost.deployNetwork[host][path] = {
+          meta,
+          client,
+          runtime,
+          port,
+          publicHost:
+            port === 80
+              ? `http://${host}${path}`
+              : port === 443
+              ? `https://${host}${path}`
+              : `http://${host}:${port}${path}`,
+          local: `http://localhost:${port}${path}`,
+          apis: metadata.apis,
+        };
+
+        return resolve(true);
+      });
+    } catch (error) {
+      logger.error(error, { metadata, port, stack: error.stack });
+      resolve(false);
+    }
+  });
+
+export { listenPortController, logRuntimeRouter, listenServerFactory };

package/src/server/object-layer.js

@@ -0,0 +1,294 @@
+/**
+ * Provides utilities and engine logic for processing and managing Cyberia Online's object layer assets (skins, floors, weapons, etc.).
+ * @module src/server/object-layer.js
+ * @namespace CyberiaObjectLayer
+ */
+
+import dotenv from 'dotenv';
+import fs from 'fs-extra';
+import { PNG } from 'pngjs';
+import sharp from 'sharp';
+import { Jimp, intToRGBA, rgbaToInt } from 'jimp';
+
+import { range } from '../client/components/core/CommonJs.js';
+import { random } from '../client/components/core/CommonJs.js';
+import { loggerFactory } from '../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+dotenv.config({ path: `./engine-private/conf/dd-cyberia/.env.production`, override: true });
+
+/**
+ * @typedef {Object} ObjectLayerCallbackPayload
+ * @property {string} path - The full file path to the image.
+ * @property {string} objectLayerType - The type of object layer (e.g., 'skin', 'floor').
+ * @property {string} objectLayerId - The unique ID of the object layer asset.
+ * @property {string} direction - The direction folder name (e.g., '08', '12').
+ * @memberof CyberiaObjectLayer
+ * @property {string} frame - The frame file name.
+ */
+
+export class ObjectLayerEngine {
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Iterates through the directory structure of object layer PNG assets for a given type.
+   * @param {string} [objectLayerType='skin'] - The type of object layer to iterate over (e.g., 'skin', 'floor').
+   * @param {function(ObjectLayerCallbackPayload): Promise<void>} [callback=() => {}] - The async function to execute for each image file found.
+   * @returns {Promise<void>}
+   * @memberof CyberiaObjectLayer
+   */
+  static async pngDirectoryIteratorByObjectLayerType(
+    objectLayerType = 'skin',
+    callback = ({ path, objectLayerType, objectLayerId, direction, frame }) => {},
+  ) {
+    const assetRoot = `./src/client/public/cyberia/assets/${objectLayerType}`;
+    if (!fs.existsSync(assetRoot)) {
+      logger.warn(`Asset root not found for type: ${objectLayerType}`);
+      return;
+    }
+
+    for (const objectLayerId of await fs.readdir(assetRoot)) {
+      const idPath = `${assetRoot}/${objectLayerId}`;
+      if (!fs.statSync(idPath).isDirectory()) continue;
+
+      for (const direction of await fs.readdir(idPath)) {
+        const dirFolder = `${idPath}/${direction}`;
+        if (!fs.statSync(dirFolder).isDirectory()) continue;
+
+        for (const frame of await fs.readdir(dirFolder)) {
+          const imageFilePath = `${dirFolder}/${frame}`;
+          await callback({ path: imageFilePath, objectLayerType, objectLayerId, direction, frame });
+        }
+      }
+    }
+  }
+
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Asynchronously reads a PNG file and resolves with its raw bitmap data, width, and height.
+   * @param {string} filePath - The path to the PNG file.
+   * @returns {Promise<{width: number, height: number, data: Buffer} | {error: true, message: string}>} - The image data or an error object.
+   * @memberof CyberiaObjectLayer
+   */
+  static readPngAsync(filePath) {
+    return new Promise((resolve, reject) => {
+      fs.createReadStream(filePath)
+        .pipe(new PNG())
+        .on('parsed', function () {
+          resolve({
+            width: this.width,
+            height: this.height,
+            data: Buffer.from(this.data),
+          });
+        })
+        .on('error', (error) => {
+          logger.error(`Error reading PNG file: ${filePath}`, error);
+          // Resolve with a specific error indicator instead of rejecting
+          resolve({ error: true, message: error.message });
+        });
+    });
+  }
+
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Processes an image file (PNG or GIF) to generate a frame matrix and a color palette (map_color).
+   * It quantizes the image based on a factor derived from image height (mazeFactor).
+   * @param {string} path - The path to the image file.
+   * @param {Array<number[]>} [colors=[]] - The existing color palette array to append new colors to.
+   * @returns {Promise<{frame: number[][], colors: Array<number[]>}>} - The frame matrix and the updated color palette.
+   * @memberof CyberiaObjectLayer
+   */
+  static async frameFactory(path, colors = []) {
+    const frame = [];
+    try {
+      let image;
+
+      if (path.endsWith('.gif')) {
+        image = await Jimp.read(path);
+        // remove gif file
+        fs.removeSync(path);
+        // save image replacing gif for png
+        const pngPath = path.replace('.gif', '.png');
+        await image.write(pngPath);
+      } else {
+        const png = await ObjectLayerEngine.readPngAsync(path);
+        if (png.error) {
+          throw new Error(`Failed to read PNG: ${png.message}`);
+        }
+        image = new Jimp(png);
+      }
+
+      const mazeFactor = parseInt(image.bitmap.height / 24);
+      let _y = -1;
+      for (const y of range(0, image.bitmap.height - 1)) {
+        if (y % mazeFactor === 0) {
+          _y++;
+          if (!frame[_y]) frame[_y] = [];
+        }
+        let _x = -1;
+        for (const x of range(0, image.bitmap.width - 1)) {
+          const rgba = Object.values(intToRGBA(image.getPixelColor(x, y)));
+          if (y % mazeFactor === 0 && x % mazeFactor === 0) {
+            _x++;
+            const indexColor = colors.findIndex(
+              (c) => c[0] === rgba[0] && c[1] === rgba[1] && c[2] === rgba[2] && c[3] === rgba[3],
+            );
+            if (indexColor === -1) {
+              colors.push(rgba);
+              frame[_y][_x] = colors.length - 1;
+            } else {
+              frame[_y][_x] = indexColor;
+            }
+          }
+        }
+      }
+    } catch (error) {
+      logger.error(`Failed to process image ${path}:`, error);
+    }
+    return { frame, colors };
+  }
+
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Converts a numerical folder direction (e.g., '08', '14') into an array of corresponding keyframe names (e.g., 'down_idle', 'left_walking').
+   * @param {string} direction - The numerical direction string.
+   * @returns {string[]} - An array of keyframe direction names.
+   * @memberof CyberiaObjectLayer
+   */
+  static getKeyFramesDirectionsFromNumberFolderDirection(direction) {
+    let objectLayerFrameDirections = [];
+
+    switch (direction) {
+      case '08':
+        objectLayerFrameDirections = ['down_idle', 'none_idle', 'default_idle'];
+        break;
+      case '18':
+        objectLayerFrameDirections = ['down_walking'];
+        break;
+      case '02':
+        objectLayerFrameDirections = ['up_idle'];
+        break;
+      case '12':
+        objectLayerFrameDirections = ['up_walking'];
+        break;
+      case '04':
+        objectLayerFrameDirections = ['left_idle', 'up_left_idle', 'down_left_idle'];
+        break;
+      case '14':
+        objectLayerFrameDirections = ['left_walking', 'up_left_walking', 'down_left_walking'];
+        break;
+      case '06':
+        objectLayerFrameDirections = ['right_idle', 'up_right_idle', 'down_right_idle'];
+        break;
+      case '16':
+        objectLayerFrameDirections = ['right_walking', 'up_right_walking', 'down_right_walking'];
+        break;
+    }
+
+    return objectLayerFrameDirections;
+  }
+
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Builds a PNG image file from a tile matrix and color map using Jimp and Sharp.
+   * @param {Object} options - Options object.
+   * @param {Object} options.tile - The tile data.
+   * @param {Array<number[]>} options.tile.map_color - The color palette.
+   * @param {number[][]} options.tile.frame_matrix - The matrix of color indices.
+   * @param {string} options.imagePath - The output path for the generated image.
+   * @param {number} [options.cellPixelDim=20] - The pixel dimension of each cell in the matrix.
+   * @param {function(number, number, number[]): number} [options.opacityFilter] - Function to filter opacity (ignored in this implementation).
+   * @returns {Promise<void>}
+   * @memberof CyberiaObjectLayer
+   */
+  static async buildImgFromTile(
+    options = {
+      tile: { map_color: null, frame_matrix: null },
+      imagePath: '',
+      cellPixelDim: 20,
+      opacityFilter: (x, y, color) => 255,
+    },
+  ) {
+    const { tile, imagePath, cellPixelDim } = options;
+    const mainMatrix = tile.frame_matrix;
+    if (!mainMatrix || mainMatrix.length === 0 || mainMatrix[0].length === 0) {
+      logger.error(`Cannot build image from empty or invalid frame_matrix for path: ${imagePath}`);
+      return;
+    }
+
+    const sharpOptions = {
+      create: {
+        width: cellPixelDim * mainMatrix[0].length,
+        height: cellPixelDim * mainMatrix.length,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 0 }, // transparent background
+      },
+    };
+
+    let image = await sharp(sharpOptions).png().toBuffer();
+    fs.writeFileSync(imagePath, image);
+    image = await Jimp.read(imagePath);
+
+    for (let y = 0; y < mainMatrix.length; y++) {
+      for (let x = 0; x < mainMatrix[y].length; x++) {
+        const colorIndex = mainMatrix[y][x];
+        if (colorIndex === null || colorIndex === undefined) continue;
+
+        const color = tile.map_color[colorIndex];
+        if (!color) continue;
+
+        const rgbaColor = color.length === 4 ? color : [...color, 255]; // Ensure alpha channel
+
+        for (let dy = 0; dy < cellPixelDim; dy++) {
+          for (let dx = 0; dx < cellPixelDim; dx++) {
+            const pixelX = x * cellPixelDim + dx;
+            const pixelY = y * cellPixelDim + dy;
+            image.setPixelColor(rgbaToInt(...rgbaColor), pixelX, pixelY);
+          }
+        }
+      }
+    }
+
+    await image.write(imagePath);
+  }
+
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Generates a random set of character statistics for an item, with values between 0 and 10.
+   * @returns {{effect: number, resistance: number, agility: number, range: number, intelligence: number, utility: number}} - The random stats object.
+   * @memberof CyberiaObjectLayer
+   */
+  static generateRandomStats() {
+    return {
+      effect: random(0, 10),
+      resistance: random(0, 10),
+      agility: random(0, 10),
+      range: random(0, 10),
+      intelligence: random(0, 10),
+      utility: random(0, 10),
+    };
+  }
+}
+
+/**
+ * @memberof CyberiaObjectLayer
+ * @constant
+ * @description Mapping of item type names to numerical IDs.
+ * @type {{floor: number, skin: number, weapon: number, skill: number, coin: number}}
+ */
+export const itemTypes = { floor: 0, skin: 1, weapon: 2, skill: 3, coin: 4 };
+
+// Export equivalent for backward compatibility with existing destructured imports.
+export const pngDirectoryIteratorByObjectLayerType = ObjectLayerEngine.pngDirectoryIteratorByObjectLayerType;
+export const readPngAsync = ObjectLayerEngine.readPngAsync;
+export const frameFactory = ObjectLayerEngine.frameFactory;
+export const getKeyFramesDirectionsFromNumberFolderDirection =
+  ObjectLayerEngine.getKeyFramesDirectionsFromNumberFolderDirection;
+export const buildImgFromTile = ObjectLayerEngine.buildImgFromTile;
+export const generateRandomStats = ObjectLayerEngine.generateRandomStats;

package/src/server/peer.js

@@ -0,0 +1,69 @@
+/**
+ * Module for peerjs server management.
+ * Initializes and configures the PeerJS server instance, typically running
+ * alongside a main Node.js application.
+ *
+ * @module src/server/peer.js
+ * @namespace Peer
+ */
+
+import { PeerServer } from 'peer';
+import dotenv from 'dotenv';
+import { loggerFactory } from './logger.js';
+import UnderpostStartUp from './start.js';
+
+dotenv.config();
+
+/**
+ * Logger instance for this module, utilizing the framework's factory.
+ * @type {function(*): void}
+ * @memberof Peer
+ * @private
+ */
+const logger = loggerFactory(import.meta);
+
+// Documentation references:
+// https://github.com/peers/peerjs
+// https://github.com/peers/peerjs-server
+
+/**
+ * Creates and starts a configured PeerJS server instance.
+ *
+ * This function handles port configuration, CORS origins, and paths, then uses
+ * a listener factory to start the server.
+ *
+ * @async
+ * @function createPeerServer
+ * @memberof Peer
+ * @param {object} config - Configuration object for the PeerJS server setup.
+ * @param {number} config.port - The primary port on which the PeerJS server will listen.
+ * @param {string[]} config.origins - An array of allowed domain origins for Cross-Origin Resource Sharing (CORS).
+ * @param {string} config.path - The base path for the API. The PeerJS path ('/peer') will be appended to this.
+ * @returns {Promise<object>} A promise that resolves to an object containing the final configuration and the server instance.
+ * @returns {import('peer').IConfig} return.options - The final options object used to create the PeerServer.
+ * @returns {import('peer').Server} return.peerServer - The created and listening PeerServer instance (wrapped by the listening server factory).
+ * @returns {object} return.meta - The module's import meta object (`import.meta`).
+ */
+const createPeerServer = async ({ port, origins, path }) => {
+  logger.info('origins', origins);
+  /** @type {import('peer').IConfig} */
+  const options = {
+    port,
+    // Ensure the path is correctly formatted, handling the root path case
+    path: `${path === '/' ? '' : path}/peer`,
+    corsOptions: {
+      origin: origins,
+    },
+    proxied: true,
+    // key: fs.readFileSync(''), // Example for HTTPS/SSL
+    // cert: fs.readFileSync(''), // Example for HTTPS/SSL
+    // ca: fs.readFileSync(''),   // Example for HTTPS/SSL
+  };
+
+  // Use the framework's factory to listen on the server, ensuring graceful startup/shutdown
+  const peerServer = UnderpostStartUp.API.listenServerFactory(async () => PeerServer(options));
+
+  return { options, peerServer, meta: import.meta };
+};
+
+export { createPeerServer };