cyberia 3.2.5 → 3.2.12

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

@@ -1,18 +1,17 @@
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
-import { connectPortals, generateProceduralEntities } from './cyberia-portal-connector.js';
+import { connectPortals } from './cyberia-portal-connector.js';
 import { generateFallbackWorld } from './cyberia-fallback-world.js';
-import { CYBERIA_INSTANCE_CONF_DEFAULTS } from '../cyberia-instance-conf/cyberia-instance-conf.defaults.js';
 
 const logger = loggerFactory(import.meta);
 
-const CyberiaInstanceService = {
-  post: async (req, res, options) => {
+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 CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     const CyberiaInstanceConf =
-      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+      DataBaseProviderService.getModel("CyberiaInstanceConf", options);
     if (req.auth && req.auth.user) req.body.creator = req.auth.user._id;
     const instance = await new CyberiaInstance(req.body).save();
 
@@ -23,7 +22,7 @@ const CyberiaInstanceService = {
         const conf = await CyberiaInstanceConf.findOneAndUpdate(
           { instanceCode: instance.code },
           { $setOnInsert: { instanceCode: instance.code } },
-          { upsert: true, new: true },
+          { upsert: true, returnDocument: 'after' },
         );
         if (conf && !instance.conf) {
           await CyberiaInstance.findByIdAndUpdate(instance._id, { conf: conf._id });
@@ -35,10 +34,10 @@ const CyberiaInstanceService = {
     }
 
     return instance;
-  },
-  get: async (req, res, options) => {
+  };
+  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 CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     const populateCreator = { path: 'creator', model: 'User', select: '_id username' };
     if (req.params.id) return await CyberiaInstance.findById(req.params.id).populate(populateCreator);
 
@@ -52,20 +51,20 @@ const CyberiaInstanceService = {
 
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
-  put: async (req, res, options) => {
+  };
+  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 CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     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;
+      const File = DataBaseProviderService.getModel("File", options);
       await File.findByIdAndDelete(instance.thumbnail);
     }
     return await CyberiaInstance.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
-  },
+  };
   /**
    * Central portal connector endpoint.
    *
@@ -73,16 +72,16 @@ const CyberiaInstanceService = {
    * from cyberia-portal-connector.js so the same logic can be used by the
    * GUI without a DB dependency.
    *
-   * Optionally generates procedural fallback obstacle/foreground entities
-   * for maps that have none, controlled by query flags:
-   *   ?generateEntities=true   — append procedural obstacles & foreground
-   *   ?obstacleCount=N         — obstacles per map   (default 5)
-   *   ?foregroundCount=N       — foreground per map   (default 3)
-   *   ?persist=true            — save generated portals & entities to DB
+   * 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
    */
-  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;
+  static portalConnect = async (req, res, options) => {
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
+    const CyberiaMap = DataBaseProviderService.getModel("CyberiaMap", options);
 
     const instance = await CyberiaInstance.findById(req.params.id).lean();
     if (!instance) throw new Error('instance not found');
@@ -103,67 +102,33 @@ const CyberiaInstanceService = {
     // ── Portal topology (pure function) ──────────────────────────────────
     const result = connectPortals(mapCodes, mapDocs);
 
-    // ── Procedural entity generation (optional) ──────────────────────────
-    const colors = CYBERIA_INSTANCE_CONF_DEFAULTS.colors;
-    const wantEntities = req.query?.generateEntities === 'true';
-    const obstacleCount = req.query?.obstacleCount ? parseInt(req.query.obstacleCount, 10) : undefined;
-    const foregroundCount = req.query?.foregroundCount ? parseInt(req.query.foregroundCount, 10) : undefined;
-    const seed = instance.seed || '';
-
-    const generatedEntities = {};
-    if (wantEntities) {
-      for (const doc of mapDocs) {
-        const hasObstacles = (doc.entities || []).some((e) => e.entityType === 'obstacle');
-        const hasForeground = (doc.entities || []).some((e) => e.entityType === 'foreground');
-        if (!hasObstacles || !hasForeground) {
-          const mapSeed = seed ? `${seed}:${doc.code}` : doc.code;
-          const generated = generateProceduralEntities({ gridX: doc.gridX || 16, gridY: doc.gridY || 16 }, colors, {
-            obstacleCount,
-            foregroundCount,
-            seed: mapSeed,
-          });
-          generatedEntities[doc.code] = {
-            obstacles: hasObstacles ? [] : generated.obstacles,
-            foreground: hasForeground ? [] : generated.foreground,
-          };
-        }
-      }
-    }
-
     // ── Persist to DB when requested ─────────────────────────────────────
     const persist = req.query?.persist === 'true';
     if (persist) {
       await CyberiaInstance.findByIdAndUpdate(req.params.id, { portals: result.portals });
-      for (const [mapCode, ents] of Object.entries(generatedEntities)) {
-        const toAdd = [...ents.obstacles, ...ents.foreground];
-        if (toAdd.length > 0) {
-          await CyberiaMap.findOneAndUpdate({ code: mapCode }, { $push: { entities: { $each: toAdd } } });
-        }
-      }
     }
 
     return {
       ...result,
-      ...(wantEntities ? { generatedEntities } : {}),
       persisted: persist,
     };
-  },
+  };
 
-  delete: async (req, res, options) => {
+  static delete = async (req, res, options) => {
     /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
-    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstance = DataBaseProviderService.getModel("CyberiaInstance", options);
     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;
+        const File = DataBaseProviderService.getModel("File", options);
         await File.findByIdAndDelete(instance.thumbnail);
       }
       return await CyberiaInstance.findByIdAndDelete(req.params.id);
     } else return await CyberiaInstance.deleteMany();
-  },
+  };
 
   /**
    * Return an in-memory procedural fallback world.
@@ -177,7 +142,7 @@ const CyberiaInstanceService = {
    *   ?obstacleCount=<number>  — obstacles per map  (random 12–20 if omitted)
    *   ?foregroundCount=<number>— foreground per map (random 6–12 if omitted)
    */
-  fallbackWorld: async (req) => {
+  static fallbackWorld = async (req) => {
     const q = req.query || {};
     return generateFallbackWorld({
       mapCount: q.mapCount ? parseInt(q.mapCount, 10) : undefined,
@@ -185,7 +150,7 @@ const CyberiaInstanceService = {
       obstacleCount: q.obstacleCount ? parseInt(q.obstacleCount, 10) : undefined,
       foregroundCount: q.foregroundCount ? parseInt(q.foregroundCount, 10) : undefined,
     });
-  },
-};
+  };
+}
 
 export { CyberiaInstanceService };

package/src/api/cyberia-instance/cyberia-portal-connector.js

@@ -1,126 +1,26 @@
 /**
  * Central Portal Connector — pure-function module.
  *
- * Shared by the backend (CyberiaInstanceService) and the GUI (map editor)
- * to build, validate, and procedurally generate portal topology and world
- * entities for a CyberiaInstance.
+ * Sole responsibility: build, validate, and connect portal topology
+ * for a CyberiaInstance.  Given map documents with portal entities,
+ * produces a minimal ring that guarantees full reachability, then
+ * assigns random portal behaviour to every remaining (unconnected)
+ * portal.
  *
- * All exported functions are stateless and synchronous — they operate on
- * plain JS objects (lean Mongoose docs or JSON from the API) so the GUI
- * can call them directly without a DB dependency.
+ * Shared by the backend (CyberiaInstanceService.portalConnect) and the
+ * GUI (Instance Engine "Portal Connector" button) so the same logic
+ * runs everywhere without a DB dependency.
+ *
+ * This module does NOT generate procedural entities (obstacles,
+ * foreground, resources, bots, etc.).  For that, see
+ * cyberia-world-generator.js.
+ *
+ * All exported functions are stateless and synchronous.
  *
  * @module src/api/cyberia-instance/cyberia-portal-connector
  */
 
-// ── Color helpers ────────────────────────────────────────────────────────────
-
-/**
- * Convert a { r, g, b, a } palette entry to an `rgba(…)` CSS string.
- * @param {{ r: number, g: number, b: number, a: number }} c
- * @returns {string}
- */
-const colorToRgba = (c) => `rgba(${c.r}, ${c.g}, ${c.b}, ${c.a / 255})`;
-
-/**
- * Look up a palette entry by key from a colours array.
- * @param {Array<{ key: string, r: number, g: number, b: number, a: number }>} colors
- * @param {string} key
- * @returns {{ r: number, g: number, b: number, a: number } | undefined}
- */
-const findColor = (colors, key) => colors.find((c) => c.key === key);
-
-// ── Random helpers ───────────────────────────────────────────────────────────
-
-/**
- * Return a random integer in [min, max] (inclusive).
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-const randInt = (min, max) => min + Math.floor(Math.random() * (max - min + 1));
-
-// ── Occupancy grid ───────────────────────────────────────────────────────────
-
-/**
- * 2D boolean grid that tracks which cells are blocked (obstacle / placed entity).
- * Used to find valid walkable positions when placing portals and bots.
- */
-class OccupancyGrid {
-  /**
-   * @param {number} width  Grid columns.
-   * @param {number} height Grid rows.
-   */
-  constructor(width, height) {
-    this.width = width;
-    this.height = height;
-    // false = walkable, true = blocked
-    this.cells = Array.from({ length: height }, () => new Array(width).fill(false));
-  }
-
-  /**
-   * Mark a rectangular region as blocked.
-   * @param {number} x
-   * @param {number} y
-   * @param {number} w
-   * @param {number} h
-   */
-  block(x, y, w, h) {
-    for (let row = y; row < y + h && row < this.height; row++) {
-      for (let col = x; col < x + w && col < this.width; col++) {
-        if (row >= 0 && col >= 0) this.cells[row][col] = true;
-      }
-    }
-  }
-
-  /**
-   * Check whether a rectangle fits entirely within walkable (unblocked) cells.
-   * @param {number} x
-   * @param {number} y
-   * @param {number} w
-   * @param {number} h
-   * @returns {boolean}
-   */
-  fits(x, y, w, h) {
-    if (x < 0 || y < 0 || x + w > this.width || y + h > this.height) return false;
-    for (let row = y; row < y + h; row++) {
-      for (let col = x; col < x + w; col++) {
-        if (this.cells[row][col]) return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Find a random walkable position for a rectangle of given dimensions.
-   * Tries up to `maxAttempts` random positions before giving up.
-   * @param {number} w
-   * @param {number} h
-   * @param {number} [maxAttempts=200]
-   * @returns {{ x: number, y: number } | null}  Position or null if no fit found.
-   */
-  findPosition(w, h, maxAttempts = 200) {
-    const maxX = Math.max(0, this.width - w);
-    const maxY = Math.max(0, this.height - h);
-    for (let i = 0; i < maxAttempts; i++) {
-      const x = randInt(0, maxX);
-      const y = randInt(0, maxY);
-      if (this.fits(x, y, w, h)) return { x, y };
-    }
-    return null;
-  }
-
-  /**
-   * Populate the grid from an array of obstacle entities.
-   * @param {Array<{ initCellX: number, initCellY: number, dimX: number, dimY: number }>} obstacles
-   */
-  addObstacles(obstacles) {
-    for (const o of obstacles) {
-      this.block(o.initCellX, o.initCellY, o.dimX, o.dimY);
-    }
-  }
-}
-
-// ── Portal topology builders ─────────────────────────────────────────────────
+// ── Portal mode constants ────────────────────────────────────────────────────
 
 /**
  * Canonical portal mode strings.
@@ -157,6 +57,8 @@ const PORTAL_MODE_COLOR_KEY = Object.freeze({
  */
 const EXTRA_PORTAL_MODES = [PORTAL_MODES.INTRA_PORTAL, PORTAL_MODES.INTRA_RANDOM, PORTAL_MODES.INTER_RANDOM];
 
+// ── Portal topology builders ─────────────────────────────────────────────────
+
 /**
  * Extract all portal-type entities from each map document and build
  * a lookup: `{ [mapCode]: portalEntity[] }`.
@@ -247,7 +149,9 @@ function buildTopologyFromSubtypes(orderedCodes, portalIndex) {
     const remaining = allOnMap.filter((e) => !usedInRing.has(e));
 
     for (const srcEnt of remaining) {
-      const sub = srcEnt.portalSubtype || PORTAL_MODES.INTER_PORTAL;
+      // If the entity already has an explicit subtype, honour it;
+      // otherwise assign a random mode (matching fallback-world behaviour).
+      const sub = srcEnt.portalSubtype || PORTAL_MODE_LIST[Math.floor(Math.random() * PORTAL_MODE_LIST.length)];
 
       switch (sub) {
         case PORTAL_MODES.INTER_PORTAL: {
@@ -341,119 +245,6 @@ function connectPortals(mapCodes, maps) {
   return { portals, topology, mapCount: ordered.length };
 }
 
-// ── Procedural entity generators ─────────────────────────────────────────────
-
-/**
- * Generate procedural obstacle entities for a map.
- *
- * Obstacles use empty `objectLayerItemIds` so they render as a solid colour
- * from the OBSTACLE palette entry.  Count, dimensions, and positions are
- * all fully random within the declared ranges.
- *
- * @param {{ gridX: number, gridY: number }} mapDims  Map grid dimensions.
- * @param {Array<{ key: string, r: number, g: number, b: number, a: number }>} colors  Palette.
- * @param {object} [opts]
- * @param {number} [opts.count]         Override count (ignores range).
- * @param {number} [opts.minDim=1]      Minimum obstacle width/height (cells).
- * @param {number} [opts.maxDim=4]      Maximum obstacle width/height (cells).
- * @returns {object[]}  Array of CyberiaEntity plain objects.
- */
-function generateObstacles(mapDims, colors, opts = {}) {
-  const { minDim = 1, maxDim = 4 } = opts;
-  const count = opts.count ?? randInt(OBSTACLE_RANGE[0], OBSTACLE_RANGE[1]);
-  const { gridX, gridY } = mapDims;
-
-  const obstacleColor = findColor(colors, 'OBSTACLE');
-  const rgba = obstacleColor ? colorToRgba(obstacleColor) : 'rgba(80, 80, 80, 1)';
-
-  const entities = [];
-  for (let i = 0; i < count; i++) {
-    const dimX = randInt(minDim, maxDim);
-    const dimY = randInt(minDim, maxDim);
-    const maxX = Math.max(0, gridX - dimX);
-    const maxY = Math.max(0, gridY - dimY);
-    entities.push({
-      entityType: 'obstacle',
-      initCellX: randInt(0, maxX),
-      initCellY: randInt(0, maxY),
-      dimX,
-      dimY,
-      color: rgba,
-      objectLayerItemIds: [],
-    });
-  }
-  return entities;
-}
-
-/**
- * Generate procedural foreground entities for a map.
- *
- * Foregrounds use empty `objectLayerItemIds` and a semi-transparent colour
- * from the FOREGROUND palette entry.  Count, dimensions, and positions are
- * all fully random within the declared ranges.
- *
- * @param {{ gridX: number, gridY: number }} mapDims  Map grid dimensions.
- * @param {Array<{ key: string, r: number, g: number, b: number, a: number }>} colors  Palette.
- * @param {object} [opts]
- * @param {number} [opts.count]         Override count (ignores range).
- * @param {number} [opts.minDim=2]      Minimum foreground width/height (cells).
- * @param {number} [opts.maxDim=6]      Maximum foreground width/height (cells).
- * @returns {object[]}  Array of CyberiaEntity plain objects.
- */
-function generateForeground(mapDims, colors, opts = {}) {
-  const { minDim = 2, maxDim = 6 } = opts;
-  const count = opts.count ?? randInt(FOREGROUND_RANGE[0], FOREGROUND_RANGE[1]);
-  const { gridX, gridY } = mapDims;
-
-  const fgColor = findColor(colors, 'FOREGROUND');
-  const rgba = fgColor ? colorToRgba(fgColor) : 'rgba(200, 200, 200, 0.31)';
-
-  const entities = [];
-  for (let i = 0; i < count; i++) {
-    const dimX = randInt(minDim, maxDim);
-    const dimY = randInt(minDim, maxDim);
-    const maxX = Math.max(0, gridX - dimX);
-    const maxY = Math.max(0, gridY - dimY);
-    entities.push({
-      entityType: 'foreground',
-      initCellX: randInt(0, maxX),
-      initCellY: randInt(0, maxY),
-      dimX,
-      dimY,
-      color: rgba,
-      objectLayerItemIds: [],
-    });
-  }
-  return entities;
-}
-
-/**
- * Generate all procedural fallback entities (obstacles + foreground) for a map.
- *
- * @param {{ gridX: number, gridY: number }} mapDims
- * @param {Array<{ key: string, r: number, g: number, b: number, a: number }>} colors
- * @param {object} [opts]
- * @param {number} [opts.obstacleCount]
- * @param {number} [opts.foregroundCount]
- * @returns {{ obstacles: object[], foreground: object[] }}
- */
-function generateProceduralEntities(mapDims, colors, opts = {}) {
-  return {
-    obstacles: generateObstacles(mapDims, colors, { count: opts.obstacleCount }),
-    foreground: generateForeground(mapDims, colors, { count: opts.foregroundCount }),
-  };
-}
-
-// ── Entity count ranges ──────────────────────────────────────────────────────
-// [min, max] — actual count is random within range on each generation call.
-
-const OBSTACLE_RANGE = [20, 35];
-const FOREGROUND_RANGE = [10, 20];
-const BOT_RANGE = [8, 16];
-const BOT_WEAPON_CHANCE = 0.6;
-const PORTAL_DIM_RANGE = [2, 3];
-const PORTAL_COUNT_RANGE = [2, 4];
-
 // ── Public API ───────────────────────────────────────────────────────────────
 
 export {
@@ -466,21 +257,4 @@ export {
   PORTAL_MODE_LIST,
   PORTAL_MODE_COLOR_KEY,
   EXTRA_PORTAL_MODES,
-  // Procedural entities
-  generateObstacles,
-  generateForeground,
-  generateProceduralEntities,
-  // Placement
-  OccupancyGrid,
-  // Helpers
-  colorToRgba,
-  findColor,
-  randInt,
-  // Ranges
-  OBSTACLE_RANGE,
-  FOREGROUND_RANGE,
-  BOT_RANGE,
-  BOT_WEAPON_CHANCE,
-  PORTAL_DIM_RANGE,
-  PORTAL_COUNT_RANGE,
 };