cyberia 3.1.3 → 3.2.9

package/src/api/cyberia-instance/cyberia-fallback-world.js

@@ -0,0 +1,178 @@
+/**
+ * Fallback World Generator — pure-function module.
+ *
+ * Produces a complete in-memory multi-map world with portal topology,
+ * floor tiles, obstacles, foreground, and bots.  Nothing is persisted
+ * to MongoDB — the result is regenerated on every call.
+ *
+ * Everything that can be random IS random (counts within ranges,
+ * positions, dimensions).  The floor is the exception: it deterministically
+ * covers the entire map grid so there are no gaps.
+ *
+ * Shared by:
+ *   - gRPC server (getFullInstance fallback path)
+ *   - CyberiaInstanceService (API / GUI fallback endpoint)
+ *
+ * All exported functions are stateless and synchronous.
+ *
+ * @module src/api/cyberia-instance/cyberia-fallback-world
+ */
+
+import { connectPortals } from './cyberia-portal-connector.js';
+
+import {
+  generateObstacles,
+  generateForeground,
+  generateResources,
+  generateFloorEntities,
+  generatePortalEntity,
+  generatePortalEntities,
+  generateBots,
+  OccupancyGrid,
+} from './cyberia-world-generator.js';
+
+import { CYBERIA_INSTANCE_CONF_DEFAULTS } from '../cyberia-instance-conf/cyberia-instance-conf.defaults.js';
+
+// ── Defaults ─────────────────────────────────────────────────────────────────
+
+const DEFAULT_MAP_COUNT = 4;
+const DEFAULT_GRID_SIZE = 64;
+
+// ── Single map generator ─────────────────────────────────────────────────────
+
+/**
+ * Generate a complete in-memory map with all entity types.
+ * Everything except floor tiles is randomized.
+ *
+ * @param {string} mapCode
+ * @param {Array} colors             Palette from CYBERIA_INSTANCE_CONF_DEFAULTS.
+ * @param {object} [opts]
+ * @param {number} [opts.gridSize]
+ * @param {number} [opts.obstacleCount]
+ * @param {number} [opts.foregroundCount]
+ * @param {number} [opts.botCount]
+ * @param {number} [opts.resourceCount]
+ * @returns {object}  CyberiaMap-shaped plain object.
+ */
+function generateFallbackMap(mapCode, colors, opts = {}) {
+  const gridSize = opts.gridSize || DEFAULT_GRID_SIZE;
+  const mapDims = { gridX: gridSize, gridY: gridSize };
+
+  // 1. Floor — deterministic full coverage
+  const floors = generateFloorEntities(mapDims, colors);
+
+  // 2. Obstacles — random count, position, dimensions (placed first)
+  const obstacles = generateObstacles(mapDims, colors, { count: opts.obstacleCount });
+
+  // 3. Build occupancy grid from obstacles
+  const grid = new OccupancyGrid(gridSize, gridSize);
+  grid.addObstacles(obstacles);
+
+  // 4. Portals — placed on walkable cells only, then blocked so bots avoid them
+  const portalEntities = generatePortalEntities(mapDims, colors, { grid });
+
+  // 5. Bots — placed on walkable cells (avoids obstacles and portals)
+  const bots = generateBots(mapDims, colors, { count: opts.botCount, grid });
+
+  // 6. Resources — static exploitable entities placed on walkable cells
+  const resources = generateResources(mapDims, colors, { count: opts.resourceCount, grid });
+
+  // 7. Foreground — decorative, no collision restriction
+  const foreground = generateForeground(mapDims, colors, { count: opts.foregroundCount });
+
+  const entities = [...floors, ...obstacles, ...portalEntities, ...foreground, ...bots, ...resources];
+
+  return {
+    code: mapCode,
+    name: `Fallback ${mapCode}`,
+    gridX: gridSize,
+    gridY: gridSize,
+    cellWidth: 32,
+    cellHeight: 32,
+    entities,
+  };
+}
+
+// ── Full world generator ─────────────────────────────────────────────────────
+
+/**
+ * Generate a complete in-memory fallback world: multiple maps connected
+ * by a portal ring topology.
+ *
+ * Returns a plain-object structure matching what a real CyberiaInstance
+ * + CyberiaMap query would return, so consumers can treat it identically.
+ *
+ * Nothing is persisted to MongoDB.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.mapCount=4]          Number of maps to generate.
+ * @param {number} [opts.gridSize=64]         Grid size per map.
+ * @param {number} [opts.obstacleCount]       Obstacles per map (random if omitted).
+ * @param {number} [opts.foregroundCount]     Foreground entities per map (random if omitted).
+ * @param {number} [opts.botCount]            Bots per map (random if omitted).
+ * @param {number} [opts.resourceCount]        Resources per map (random if omitted).
+ * @param {Array}  [opts.colors]              Override palette.
+ * @returns {{
+ *   instance: object,
+ *   maps: object[],
+ *   portals: object[],
+ *   topology: string,
+ *   config: object,
+ *   _fallback: true
+ * }}
+ */
+function generateFallbackWorld(opts = {}) {
+  const {
+    mapCount = DEFAULT_MAP_COUNT,
+    gridSize,
+    obstacleCount,
+    foregroundCount,
+    botCount,
+    resourceCount,
+    colors = CYBERIA_INSTANCE_CONF_DEFAULTS.colors,
+  } = opts;
+
+  // Generate map codes.
+  const mapCodes = [];
+  for (let i = 0; i < mapCount; i++) {
+    mapCodes.push(`fallback-map-${i}`);
+  }
+
+  // Generate each map (all randomized independently).
+  const maps = mapCodes.map((code) =>
+    generateFallbackMap(code, colors, {
+      gridSize,
+      obstacleCount,
+      foregroundCount,
+      botCount,
+      resourceCount,
+    }),
+  );
+
+  // Connect maps with portal topology using the portal connector module.
+  const { portals, topology } = connectPortals(mapCodes, maps);
+
+  // Build the instance shell (never persisted — no mongoId).
+  const instance = {
+    code: 'fallback',
+    name: 'Fallback Instance',
+    description: 'Auto-generated procedural world (not persisted)',
+    tags: ['fallback', 'procedural'],
+    cyberiaMapCodes: mapCodes,
+    portals,
+    topologyMode: 'procedural',
+  };
+
+  return {
+    instance,
+    maps,
+    portals,
+    topology,
+    config: CYBERIA_INSTANCE_CONF_DEFAULTS,
+    _fallback: true,
+  };
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+export { generateFallbackWorld, generateFallbackMap };

package/src/api/cyberia-instance/cyberia-instance.controller.js

@@ -0,0 +1,92 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaInstanceService } from './cyberia-instance.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaInstanceController {
+  static fallbackWorld = async (req, res, options) => {
+    try {
+      const result = await CyberiaInstanceService.fallbackWorld(req);
+      return res.status(200).json({ status: 'success', data: result });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({ status: 'error', message: error.message });
+    }
+  };
+  static portalConnect = async (req, res, options) => {
+    try {
+      const result = await CyberiaInstanceService.portalConnect(req, res, options);
+      return res.status(200).json({ status: 'success', data: result });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({ status: 'error', message: error.message });
+    }
+  };
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaInstanceService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static get = async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaInstanceService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static put = async (req, res, options) => {
+    try {
+      const result = await CyberiaInstanceService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static delete = async (req, res, options) => {
+    try {
+      const result = await CyberiaInstanceService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+}
+
+export { CyberiaInstanceController };

package/src/api/cyberia-instance/cyberia-instance.model.js

@@ -0,0 +1,87 @@
+import { Schema, model } from 'mongoose';
+
+/**
+ * Directed edge in a graph.
+ * Each portal represents an adjacency relation:
+ * source node -> target node
+ */
+const PortalEdgeSchema = new Schema(
+  {
+    // Origin node (graph source vertex)
+    sourceMapCode: { type: String, required: true, trim: true },
+    sourceCellX: { type: Number },
+    sourceCellY: { type: Number },
+
+    // Destination node (graph target vertex)
+    targetMapCode: { type: String, required: true, trim: true },
+    targetCellX: { type: Number },
+    targetCellY: { type: Number },
+
+    // Transport behaviour of this edge:
+    //   inter-portal  — teleport to a portal entity on another map
+    //   inter-random  — teleport to a random walkable cell on another map
+    //   intra-random  — teleport to a random walkable cell on the same map
+    //   intra-portal  — teleport to a portal entity on the same map
+    portalMode: {
+      type: String,
+      enum: ['inter-portal', 'inter-random', 'intra-random', 'intra-portal'],
+      default: 'inter-portal',
+    },
+  },
+  { _id: false },
+);
+
+/**
+ * Graph container / instance.
+ * The instance stores:
+ * - nodes: cyberiaMapCodes[]
+ * - edges: portals[]
+ */
+const CyberiaInstanceSchema = new Schema(
+  {
+    // Instance identifier
+    code: { type: String, default: '', trim: true, unique: true },
+
+    name: { type: String, default: '', trim: true },
+    description: { type: String, default: '' },
+    tags: { type: [String], default: [] },
+    creator: { type: Schema.Types.ObjectId, ref: 'User' },
+    status: { type: String, default: 'unlisted' },
+    thumbnail: { type: Schema.Types.ObjectId, ref: 'File' },
+
+    // Vertex set of the graph
+    cyberiaMapCodes: { type: [String], default: [] },
+
+    // Instance-level object layer item IDs.
+    itemIds: { type: [String], default: [] },
+
+    // Directed edge set of the graph
+    portals: { type: [PortalEdgeSchema], default: [] },
+
+    // Optional topology generation mode
+    seed: { type: String, default: '' },
+    topologyMode: {
+      type: String,
+      enum: ['manual', 'procedural', 'hybrid'],
+      default: 'hybrid',
+    },
+
+    // Game server configuration (all tuning parameters live in a separate document).
+    // Linked to CyberiaInstanceConf.instanceCode === this.code.
+    conf: { type: Schema.Types.ObjectId, ref: 'CyberiaInstanceConf' },
+  },
+  { timestamps: true },
+);
+
+/**
+ * Indexes for fast adjacency lookups.
+ * Useful for traversing the graph by source or target node.
+ */
+CyberiaInstanceSchema.index({ 'portals.sourceMapCode': 1 });
+CyberiaInstanceSchema.index({ 'portals.targetMapCode': 1 });
+
+const CyberiaInstanceModel = model('CyberiaInstance', CyberiaInstanceSchema);
+
+const ProviderSchema = CyberiaInstanceSchema;
+
+export { CyberiaInstanceSchema, CyberiaInstanceModel, ProviderSchema };

package/src/api/cyberia-instance/cyberia-instance.router.js

@@ -0,0 +1,63 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaInstanceController } from './cyberia-instance.controller.js';
+import { userGuard, adminGuard } from '../../server/auth.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaInstanceRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  // ── Custom actions (must come before generic /:id routes) ──────────────
+  router.get(`/fallback-world`, async (req, res) => await CyberiaInstanceController.fallbackWorld(req, res, options));
+  router.get(
+    `/:id/portal-connect`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.portalConnect(req, res, options),
+  );
+
+  router.post(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.post(req, res, options),
+  );
+  router.post(
+    `/`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.post(req, res, options),
+  );
+  router.get(`/:id`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
+  router.get(`/`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
+  router.put(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.put(req, res, options),
+  );
+  router.put(
+    `/`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.put(req, res, options),
+  );
+  router.delete(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.delete(req, res, options),
+  );
+  router.delete(
+    `/`,
+    authMiddleware,
+    adminGuard,
+    async (req, res) => await CyberiaInstanceController.delete(req, res, options),
+  );
+  return router;
+};
+
+const ApiRouter = CyberiaInstanceRouter;
+
+export { ApiRouter, CyberiaInstanceRouter };

package/src/api/cyberia-instance/cyberia-instance.service.js

@@ -0,0 +1,156 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+import { connectPortals } from './cyberia-portal-connector.js';
+import { generateFallbackWorld } from './cyberia-fallback-world.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaInstanceService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstanceConf =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+    if (req.auth && req.auth.user) req.body.creator = req.auth.user._id;
+    const instance = await new CyberiaInstance(req.body).save();
+
+    // Auto-upsert a CyberiaInstanceConf for this instance using schema defaults.
+    // $setOnInsert ensures existing conf documents are never overwritten.
+    if (instance.code && CyberiaInstanceConf) {
+      try {
+        const conf = await CyberiaInstanceConf.findOneAndUpdate(
+          { instanceCode: instance.code },
+          { $setOnInsert: { instanceCode: instance.code } },
+          { upsert: true, returnDocument: 'after' },
+        );
+        if (conf && !instance.conf) {
+          await CyberiaInstance.findByIdAndUpdate(instance._id, { conf: conf._id });
+          instance.conf = conf._id;
+        }
+      } catch (e) {
+        logger.error('auto-upsert CyberiaInstanceConf failed:', e);
+      }
+    }
+
+    return instance;
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const populateCreator = { path: 'creator', model: 'User', select: '_id username' };
+    if (req.params.id) return await CyberiaInstance.findById(req.params.id).populate(populateCreator);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaInstance.find(query).sort(sort).limit(limit).skip(skip).populate(populateCreator),
+      CyberiaInstance.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const instance = await CyberiaInstance.findById(req.params.id);
+    if (!instance) throw new Error('instance not found');
+    if (req.auth.user.role !== 'admin' && String(instance.creator) !== String(req.auth.user._id))
+      throw new Error('insufficient permission');
+    if (req.body.thumbnail && instance.thumbnail && String(req.body.thumbnail) !== String(instance.thumbnail)) {
+      const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+      await File.findByIdAndDelete(instance.thumbnail);
+    }
+    return await CyberiaInstance.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
+  };
+  /**
+   * Central portal connector endpoint.
+   *
+   * Delegates topology computation to the pure-function `connectPortals()`
+   * from cyberia-portal-connector.js so the same logic can be used by the
+   * GUI without a DB dependency.
+   *
+   * Builds a minimal ring connecting all maps and assigns random portal
+   * subtypes to remaining portals.  Does NOT generate procedural entities —
+   * entity generation is handled exclusively by the fallback world logic
+   * (cyberia-world-generator.js).
+   *
+   *   ?persist=true  — save generated portals to DB
+   */
+  static portalConnect = async (req, res, options) => {
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+
+    const instance = await CyberiaInstance.findById(req.params.id).lean();
+    if (!instance) throw new Error('instance not found');
+
+    const mapCodes = instance.cyberiaMapCodes || [];
+
+    // Load maps with the fields needed by the connector.
+    const mapDocs = await CyberiaMap.find(
+      { code: { $in: mapCodes } },
+      {
+        code: 1,
+        gridX: 1,
+        gridY: 1,
+        entities: 1,
+      },
+    ).lean();
+
+    // ── Portal topology (pure function) ──────────────────────────────────
+    const result = connectPortals(mapCodes, mapDocs);
+
+    // ── Persist to DB when requested ─────────────────────────────────────
+    const persist = req.query?.persist === 'true';
+    if (persist) {
+      await CyberiaInstance.findByIdAndUpdate(req.params.id, { portals: result.portals });
+    }
+
+    return {
+      ...result,
+      persisted: persist,
+    };
+  };
+
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    if (req.params.id) {
+      const instance = await CyberiaInstance.findById(req.params.id);
+      if (!instance) throw new Error('instance not found');
+      if (req.auth.user.role !== 'admin' && String(instance.creator) !== String(req.auth.user._id))
+        throw new Error('insufficient permission');
+      if (instance.thumbnail) {
+        const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+        await File.findByIdAndDelete(instance.thumbnail);
+      }
+      return await CyberiaInstance.findByIdAndDelete(req.params.id);
+    } else return await CyberiaInstance.deleteMany();
+  };
+
+  /**
+   * Return an in-memory procedural fallback world.
+   *
+   * Nothing is persisted to MongoDB.  The world is regenerated on every
+   * call but stays deterministic for a given seed.
+   *
+   * Query params:
+   *   ?mapCount=<number>       — maps to generate  (default: 4)
+   *   ?botCount=<number>       — bots per map      (random 8–16 if omitted)
+   *   ?obstacleCount=<number>  — obstacles per map  (random 12–20 if omitted)
+   *   ?foregroundCount=<number>— foreground per map (random 6–12 if omitted)
+   */
+  static fallbackWorld = async (req) => {
+    const q = req.query || {};
+    return generateFallbackWorld({
+      mapCount: q.mapCount ? parseInt(q.mapCount, 10) : undefined,
+      botCount: q.botCount ? parseInt(q.botCount, 10) : undefined,
+      obstacleCount: q.obstacleCount ? parseInt(q.obstacleCount, 10) : undefined,
+      foregroundCount: q.foregroundCount ? parseInt(q.foregroundCount, 10) : undefined,
+    });
+  };
+}
+
+export { CyberiaInstanceService };