cyberia 3.2.22 → 3.2.70

package/src/api/cyberia-client-hints/cyberia-client-hints.model.js

@@ -18,82 +18,83 @@
 import { Schema, model } from 'mongoose';
 
 const ColorRgbaSchema = new Schema(
-    {
-        r: { type: Number, default: 0 },
-        g: { type: Number, default: 0 },
-        b: { type: Number, default: 0 },
-        a: { type: Number, default: 255 },
-    },
-    { _id: false },
+  {
+    r: { type: Number, default: 0 },
+    g: { type: Number, default: 0 },
+    b: { type: Number, default: 0 },
+    a: { type: Number, default: 255 },
+  },
+  { _id: false },
 );
 
 const PaletteEntrySchema = new Schema(
-    {
-        key: { type: String, required: true },
-        r: { type: Number, default: 0 },
-        g: { type: Number, default: 0 },
-        b: { type: Number, default: 0 },
-        a: { type: Number, default: 255 },
-    },
-    { _id: false },
+  {
+    key: { type: String, required: true },
+    r: { type: Number, default: 0 },
+    g: { type: Number, default: 0 },
+    b: { type: Number, default: 0 },
+    a: { type: Number, default: 255 },
+  },
+  { _id: false },
 );
 
 const StatusIconHintSchema = new Schema(
-    {
-        id: { type: Number, required: true },
-        iconId: { type: String, default: '' },
-        bounce: { type: Boolean, default: false },
-        borderColor: { type: ColorRgbaSchema, default: () => ({ r: 100, g: 100, b: 100, a: 200 }) },
-    },
-    { _id: false },
+  {
+    id: { type: Number, required: true },
+    iconId: { type: String, default: '' },
+    bounce: { type: Boolean, default: false },
+    borderColor: { type: ColorRgbaSchema, default: () => ({ r: 100, g: 100, b: 100, a: 200 }) },
+  },
+  { _id: false },
 );
 
 const EntityColorKeySchema = new Schema(
-    {
-        entityType: { type: String, required: true },
-        colorKey: { type: String, required: true },
-    },
-    { _id: false },
+  {
+    entityType: { type: String, required: true },
+    colorKey: { type: String, required: true },
+  },
+  { _id: false },
 );
 
 const CyberiaClientHintsSchema = new Schema(
-    {
-        // Instance code this hint set is scoped to. Matches CyberiaInstance.code
-        // and CyberiaInstanceConf.instanceCode. Indexed and unique to make the
-        // service-layer cache a 1-to-1 keyed lookup.
-        code: { type: String, required: true, unique: true, index: true },
+  {
+    // Instance code this hint set is scoped to. Matches CyberiaInstance.code
+    // and CyberiaInstanceConf.instanceCode. Indexed and unique to make the
+    // service-layer cache a 1-to-1 keyed lookup.
+    code: { type: String, required: true, unique: true, index: true },
 
-        // Optional palette overrides. Keys not present here fall back to the
-        // client's compile-time defaults.
-        palette: { type: [PaletteEntrySchema], default: [] },
+    // Optional palette overrides. Keys not present here fall back to the
+    // client's compile-time defaults.
+    palette: { type: [PaletteEntrySchema], default: [] },
 
-        // Optional per-entity-type color-key overrides.
-        entityColorKeys: { type: [EntityColorKeySchema], default: [] },
+    // Optional per-entity-type color-key overrides.
+    entityColorKeys: { type: [EntityColorKeySchema], default: [] },
 
-        // Optional status-icon visual overrides (id → iconId + borderColor).
-        statusIcons: { type: [StatusIconHintSchema], default: [] },
+    // Optional status-icon visual overrides (id → iconId + borderColor).
+    statusIcons: { type: [StatusIconHintSchema], default: [] },
 
-        // Camera, viewport, and cell-sizing tunings — null/undefined means
-        // "use the SharedDefaultsCyberia.RENDER_DEFAULTS value".
-        cellSize: { type: Number, default: null },
-        defaultObjWidth: { type: Number, default: null },
-        defaultObjHeight: { type: Number, default: null },
-        cameraSmoothing: { type: Number, default: null },
-        cameraZoom: { type: Number, default: null },
-        defaultWidthScreenFactor: { type: Number, default: null },
-        defaultHeightScreenFactor: { type: Number, default: null },
-        interpolationMs: { type: Number, default: null },
-        devUi: { type: Boolean, default: null },
-    },
-    { timestamps: true },
+    // Camera, viewport, and cell-sizing tunings — null/undefined means
+    // "use the SharedDefaultsCyberia.RENDER_DEFAULTS value".
+    cellSize: { type: Number, default: null },
+    defaultObjWidth: { type: Number, default: null },
+    defaultObjHeight: { type: Number, default: null },
+    cameraSmoothing: { type: Number, default: null },
+    cameraZoom: { type: Number, default: null },
+    defaultWidthScreenFactor: { type: Number, default: null },
+    defaultHeightScreenFactor: { type: Number, default: null },
+    interpolationMs: { type: Number, default: null },
+    devUi: { type: Boolean, default: null },
+
+    // Main UI font: TTF file name under engine assets/fonts/ (null = built-in
+    // raylib font) and a uniform text-size multiplier.
+    fontFamily: { type: String, default: null },
+    fontFactorSize: { type: Number, default: null },
+  },
+  { timestamps: true },
 );
 
 const CyberiaClientHintsModel = model('CyberiaClientHints', CyberiaClientHintsSchema);
 
 const ProviderSchema = CyberiaClientHintsSchema;
 
-export {
-    CyberiaClientHintsSchema,
-    CyberiaClientHintsModel,
-    ProviderSchema,
-};
+export { CyberiaClientHintsSchema, CyberiaClientHintsModel, ProviderSchema };

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

@@ -1,6 +1,7 @@
 import { loggerFactory } from '../../server/logger.js';
 import { CyberiaDialogueController } from './cyberia-dialogue.controller.js';
 import express from 'express';
+import { moderatorGuard, adminGuard } from '../../server/auth.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -11,8 +12,18 @@ class CyberiaDialogueRouter {
    */
   static router(options) {
     const router = express.Router();
-    router.post(`/:id`, async (req, res) => await CyberiaDialogueController.post(req, res, options));
-    router.post(`/`, async (req, res) => await CyberiaDialogueController.post(req, res, options));
+    router.post(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaDialogueController.post(req, res, options),
+    );
+    router.post(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaDialogueController.post(req, res, options),
+    );
     // Direct lookup by code — C client fetches dialogue by code (e.g. "default-lain")
     router.get(`/code/:code`, async (req, res) => await CyberiaDialogueController.getByCode(req, res, options));
     router.get(
@@ -21,10 +32,30 @@ class CyberiaDialogueRouter {
       async (req, res) => await CyberiaDialogueController.get(req, res, options),
     );
     router.get(`/`, async (req, res) => await CyberiaDialogueController.get(req, res, options));
-    router.put(`/:id`, async (req, res) => await CyberiaDialogueController.put(req, res, options));
-    router.put(`/`, async (req, res) => await CyberiaDialogueController.put(req, res, options));
-    router.delete(`/:id`, async (req, res) => await CyberiaDialogueController.delete(req, res, options));
-    router.delete(`/`, async (req, res) => await CyberiaDialogueController.delete(req, res, options));
+    router.put(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaDialogueController.put(req, res, options),
+    );
+    router.put(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaDialogueController.put(req, res, options),
+    );
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaDialogueController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await CyberiaDialogueController.delete(req, res, options),
+    );
     return router;
   }
 }

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

@@ -1,6 +1,7 @@
 import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
+import { DefaultCyberiaDialogues } from '../cyberia-server-defaults/cyberia-server-defaults.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -43,8 +44,13 @@ class CyberiaDialogueService {
     const { code } = req.params;
     if (!code) throw new Error('code parameter is required');
     const data = await CyberiaDialogue.find({ code }).sort({ order: 1 }).lean();
-    if (!data.length) throw new Error(`No dialogue found for code: ${code}`);
-    return data;
+    if (data.length) return data;
+    // Fallback world greetings/quest dialogue come from the canonical defaults
+    // without persisting them; serve those so action NPCs always have lines
+    // (and thus the dlg_complete grant handshake fires).
+    const fallback = DefaultCyberiaDialogues.filter((d) => d.code === code).sort((a, b) => a.order - b.order);
+    if (fallback.length) return fallback;
+    throw new Error(`No dialogue found for code: ${code}`);
   };
 }
 

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

@@ -1,6 +1,7 @@
 import { loggerFactory } from '../../server/logger.js';
 import { CyberiaEntityController } from './cyberia-entity.controller.js';
 import express from 'express';
+import { moderatorGuard, adminGuard } from '../../server/auth.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -11,17 +12,48 @@ class CyberiaEntityRouter {
    */
   static router(options) {
     const router = express.Router();
-    router.post(`/:id`, async (req, res) => await CyberiaEntityController.post(req, res, options));
-    router.post(`/`, async (req, res) => await CyberiaEntityController.post(req, res, options));
-    router.get(`/:id`,
+    router.post(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityController.post(req, res, options),
+    );
+    router.post(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityController.post(req, res, options),
+    );
+    router.get(
+      `/:id`,
       // options.authMiddleware,
       async (req, res) => await CyberiaEntityController.get(req, res, options),
     );
     router.get(`/`, async (req, res) => await CyberiaEntityController.get(req, res, options));
-    router.put(`/:id`, async (req, res) => await CyberiaEntityController.put(req, res, options));
-    router.put(`/`, async (req, res) => await CyberiaEntityController.put(req, res, options));
-    router.delete(`/:id`, async (req, res) => await CyberiaEntityController.delete(req, res, options));
-    router.delete(`/`, async (req, res) => await CyberiaEntityController.delete(req, res, options));
+    router.put(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityController.put(req, res, options),
+    );
+    router.put(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityController.put(req, res, options),
+    );
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await CyberiaEntityController.delete(req, res, options),
+    );
     return router;
   }
 }

package/src/api/cyberia-entity-type-default/cyberia-entity-type-default.controller.js

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaEntityTypeDefaultService } from './cyberia-entity-type-default.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaEntityTypeDefaultController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaEntityTypeDefaultService.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 CyberiaEntityTypeDefaultService.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 CyberiaEntityTypeDefaultService.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 CyberiaEntityTypeDefaultService.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 { CyberiaEntityTypeDefaultController };

package/src/api/cyberia-entity-type-default/cyberia-entity-type-default.model.js

@@ -0,0 +1,67 @@
+import { Schema, model } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+// CyberiaEntityTypeDefault — DB-backed, editable mirror of the per-entity-type
+// item defaults that ship in cyberia-server-defaults.js (ENTITY_TYPE_DEFAULTS).
+// A document binds an entity category (entityType) to the item ids the runtime
+// rotates through by lifecycle state:
+//   liveItemIds          — ObjectLayer item ids while the entity is alive.
+//   deadItemIds          — ids swapped in on death / ghost state.
+//   dropItemIds          — ids granted to the killer on depletion (resources).
+//   defaultObjectLayers  — seed inventory rows ({ itemId, active, quantity }).
+//
+// Resolution rule (authoritative): defaults are looked up by the entity's ACTIVE
+// itemId (usually the skin) — the system finds the document whose `liveItemIds`
+// contains that itemId, then applies the document's deadItemIds / dropItemIds /
+// defaultObjectLayers to drive what is shown as the entity's state changes.
+//
+// Resolution (subset matching): a document matches an entity when ALL of its
+// `liveItemIds` are present in the entity's active item ids, and the MOST SPECIFIC
+// match wins — the document requiring the largest item set. This lets the same
+// skin map to different defaults by its full active set, e.g.
+//   { bot, liveItemIds:[purple, atlas_pistol_mk2], behavior:hostile }
+//   { bot, liveItemIds:[purple],                    behavior:passive }
+// where a purple bot carrying the pistol is hostile and a bare purple bot is
+// passive. The Go simulation (game/entity_defaults.go) implements the same rule.
+//
+// Invariants:
+//   - `entityType` is a label, not a unique key — a category appears in many
+//     documents.
+//   - There is NO per-itemId uniqueness: the same itemId may appear in the
+//     `liveItemIds` of many documents (different entity types, or the same type
+//     at different specificity levels). `liveItemIds` is indexed (non-unique
+//     multikey) only for fast membership lookups.
+
+const ObjectLayerDefaultSchema = new Schema(
+  {
+    itemId: { type: String, required: true, trim: true },
+    active: { type: Boolean, default: false },
+    quantity: { type: Number, default: 0 },
+  },
+  { _id: false },
+);
+
+const CyberiaEntityTypeDefaultSchema = new Schema(
+  {
+    entityType: { type: String, required: true, trim: true },
+    liveItemIds: { type: [{ type: String, trim: true }], index: true },
+    deadItemIds: [{ type: String, trim: true }],
+    dropItemIds: [{ type: String, trim: true }],
+    defaultObjectLayers: [ObjectLayerDefaultSchema],
+    // Canonical entity behavior bound to entities matched by liveItemIds (see
+    // SharedDefaultsCyberia.ENTITY_BEHAVIORS). Empty = let the runtime derive it
+    // (armed → hostile, else passive). The Go simulation resolves this with the
+    // same liveItemIds matching used for the live/dead/drop sets.
+    behavior: { type: String, trim: true },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const CyberiaEntityTypeDefaultModel = model('CyberiaEntityTypeDefault', CyberiaEntityTypeDefaultSchema);
+
+const ProviderSchema = CyberiaEntityTypeDefaultSchema;
+
+export { CyberiaEntityTypeDefaultSchema, CyberiaEntityTypeDefaultModel, ProviderSchema };

package/src/api/cyberia-entity-type-default/cyberia-entity-type-default.router.js

@@ -0,0 +1,63 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaEntityTypeDefaultController } from './cyberia-entity-type-default.controller.js';
+import express from 'express';
+import { moderatorGuard, adminGuard } from '../../server/auth.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaEntityTypeDefaultRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityTypeDefaultController.post(req, res, options),
+    );
+    router.post(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityTypeDefaultController.post(req, res, options),
+    );
+    router.get(
+      `/:id`,
+      // options.authMiddleware,
+      async (req, res) => await CyberiaEntityTypeDefaultController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await CyberiaEntityTypeDefaultController.get(req, res, options));
+    router.put(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityTypeDefaultController.put(req, res, options),
+    );
+    router.put(
+      `/`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityTypeDefaultController.put(req, res, options),
+    );
+    router.delete(
+      `/:id`,
+      options.authMiddleware,
+      moderatorGuard,
+      async (req, res) => await CyberiaEntityTypeDefaultController.delete(req, res, options),
+    );
+    router.delete(
+      `/`,
+      options.authMiddleware,
+      adminGuard,
+      async (req, res) => await CyberiaEntityTypeDefaultController.delete(req, res, options),
+    );
+    return router;
+  }
+}
+
+const ApiRouter = (options) => CyberiaEntityTypeDefaultRouter.router(options);
+
+export { ApiRouter, CyberiaEntityTypeDefaultRouter };

package/src/api/cyberia-entity-type-default/cyberia-entity-type-default.service.js

@@ -0,0 +1,46 @@
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaEntityTypeDefaultService {
+  // No per-itemId uniqueness: resolution is by subset containment (most-specific
+  // match wins), so the same itemId may appear in many documents — e.g.
+  // [purple, atlas_pistol_mk2]→hostile alongside [purple]→passive. See the model.
+
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-entity-type-default.model.js').CyberiaEntityTypeDefaultModel} */
+    const CyberiaEntityTypeDefault = DataBaseProviderService.getModel('CyberiaEntityTypeDefault', options);
+    return await new CyberiaEntityTypeDefault(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-entity-type-default.model.js').CyberiaEntityTypeDefaultModel} */
+    const CyberiaEntityTypeDefault = DataBaseProviderService.getModel('CyberiaEntityTypeDefault', options);
+    if (req.params.id) return await CyberiaEntityTypeDefault.findById(req.params.id);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaEntityTypeDefault.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaEntityTypeDefault.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-entity-type-default.model.js').CyberiaEntityTypeDefaultModel} */
+    const CyberiaEntityTypeDefault = DataBaseProviderService.getModel('CyberiaEntityTypeDefault', options);
+    return await CyberiaEntityTypeDefault.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-entity-type-default.model.js').CyberiaEntityTypeDefaultModel} */
+    const CyberiaEntityTypeDefault = DataBaseProviderService.getModel('CyberiaEntityTypeDefault', options);
+    if (req.params.id) return await CyberiaEntityTypeDefault.findByIdAndDelete(req.params.id);
+    else return await CyberiaEntityTypeDefault.deleteMany();
+  };
+}
+
+export { CyberiaEntityTypeDefaultService };