cyberia 3.1.3 → 3.2.9

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

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

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

@@ -0,0 +1,87 @@
+import { Schema, model } from 'mongoose';
+import { CYBERIA_ACTION_TYPES } from '../../client/components/cyberia-portal/CommonCyberiaPortal.js';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaActionSchema = new Schema(
+  {
+    // Spatial origin: the NPC/entity cell that provides this action.
+    // Matched against map entity initCellX/initCellY during instance init
+    // and assignable from ObjectLayerEngineModal.
+    sourceMapCode: { type: String, trim: true },
+    sourceCellX: { type: Number },
+    sourceCellY: { type: Number },
+
+    // ── Identity ──────────────────────────────────────────────────────────
+    code: { type: String, required: true, trim: true },
+    type: {
+      type: String,
+      required: true,
+      trim: true,
+      enum: CYBERIA_ACTION_TYPES,
+    },
+    label: { type: String, trim: true, default: '' },
+
+    // The item ID of the NPC/entity that provides this action.
+    // Used to match 'talk' quest objectives: a step with { type: 'talk', itemId: X }
+    // is satisfied when the player triggers an action where provideItemId === X.
+    // Typically the entity's active skin ObjectLayer item ID (e.g. 'wason', 'alex').
+    provideItemId: { type: String, trim: true, default: '' },
+
+    // Quest code granted to the player on their first interaction with this action.
+    // Used by 'quest-talk' NPCs to start a quest chain on first contact.
+    // Empty string = no quest granted.
+    grantQuestCode: { type: String, trim: true, default: '' },
+
+    // ── Dialogue ──────────────────────────────────────────────────────────
+    // General greeting/intro dialogue shown when the action button is tapped.
+    dialogCode: { type: String, trim: true, default: '' },
+
+    // Ordered list of CyberiaDialogue codes the player must view to satisfy
+    // a 'talk' quest objective linked to this action via provideItemId.
+    // For simple actions this may match dialogCode; for multi-stage NPCs it can diverge.
+    questDialogueCodes: [{ type: String, trim: true }],
+
+    // ── Shop payload (type="shop") ─────────────────────────────────────────
+    shopItems: [
+      {
+        itemId: { type: String, required: true, trim: true },
+        priceItemId: { type: String, default: 'coin', trim: true },
+        priceQty: { type: Number, default: 1, min: 0 },
+      },
+    ],
+
+    // ── Craft payload (type="craft") ───────────────────────────────────────
+    craftRecipes: [
+      {
+        outputItems: [
+          {
+            itemId: { type: String, required: true, trim: true },
+            qty: { type: Number, default: 1, min: 1 },
+          },
+        ],
+        ingredients: [
+          {
+            itemId: { type: String, required: true, trim: true },
+            qty: { type: Number, default: 1, min: 1 },
+          },
+        ],
+      },
+    ],
+
+    // ── Storage payload (type="storage") ──────────────────────────────────
+    storageSlots: { type: Number, default: 0, min: 0 },
+  },
+  { timestamps: true },
+);
+
+CyberiaActionSchema.index({ code: 1 }, { unique: true });
+CyberiaActionSchema.index({ provideItemId: 1 });
+CyberiaActionSchema.index({ grantQuestCode: 1 }, { sparse: true });
+CyberiaActionSchema.index({ sourceMapCode: 1, sourceCellX: 1, sourceCellY: 1 });
+
+const CyberiaActionModel = model('CyberiaAction', CyberiaActionSchema);
+
+const ProviderSchema = CyberiaActionSchema;
+
+export { CyberiaActionSchema, CyberiaActionModel, ProviderSchema };

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

@@ -0,0 +1,27 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaActionController } from './cyberia-action.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaActionRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await CyberiaActionController.post(req, res, options));
+  router.post(`/`, async (req, res) => await CyberiaActionController.post(req, res, options));
+  router.get(
+    `/:id`,
+    // authMiddleware,
+    async (req, res) => await CyberiaActionController.get(req, res, options),
+  );
+  router.get(`/`, async (req, res) => await CyberiaActionController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await CyberiaActionController.put(req, res, options));
+  router.put(`/`, async (req, res) => await CyberiaActionController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CyberiaActionRouter;
+
+export { ApiRouter, CyberiaActionRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaActionService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    return await new CyberiaAction(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    if (req.params.id) return await CyberiaAction.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([
+      CyberiaAction.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaAction.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    return await CyberiaAction.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaAction;
+    if (req.params.id) return await CyberiaAction.findByIdAndDelete(req.params.id);
+    else return await CyberiaAction.deleteMany();
+  };
+}
+
+export { CyberiaActionService };

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

@@ -0,0 +1,93 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaDialogueService } from './cyberia-dialogue.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaDialogueController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaDialogueService.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 CyberiaDialogueService.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 CyberiaDialogueService.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 CyberiaDialogueService.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,
+      });
+    }
+  };
+  static getByCode = async (req, res, options) => {
+    try {
+      if (req && req.headers && req.headers.origin) {
+        res.set('Access-Control-Allow-Origin', req.headers.origin);
+      } else res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+      const result = await CyberiaDialogueService.getByCode(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(404).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+}
+
+export { CyberiaDialogueController };

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

@@ -0,0 +1,36 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+/**
+ * CyberiaDialogue — each document is one dialogue line that belongs to a
+ * named dialogue group (`code`).  One code groups many ordered lines.
+ *
+ * Schema fields:
+ *   code    – primary grouping key, e.g. "default-lain" or "wason-intro".
+ *             The C client fetches all lines for a given code in one request.
+ *   order   – zero-based display sequence within the code group.
+ *   speaker – display name shown above the dialogue line.
+ *   text    – the dialogue line itself.
+ *   mood    – optional emotion hint (neutral / angry / sad / happy / …).
+ */
+const CyberiaDialogueSchema = new Schema(
+  {
+    code: { type: String, required: true, index: true },
+    order: { type: Number, default: 0 },
+    speaker: { type: String, default: '' },
+    text: { type: String, required: true },
+    mood: { type: String, default: 'neutral' },
+  },
+  {
+    timestamps: true,
+  },
+);
+
+CyberiaDialogueSchema.index({ code: 1, order: 1 });
+
+const CyberiaDialogueModel = model('CyberiaDialogue', CyberiaDialogueSchema);
+
+const ProviderSchema = CyberiaDialogueSchema;
+
+export { CyberiaDialogueSchema, CyberiaDialogueModel, ProviderSchema };

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

@@ -0,0 +1,29 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaDialogueController } from './cyberia-dialogue.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaDialogueRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await CyberiaDialogueController.post(req, res, options));
+  router.post(`/`, 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(
+    `/:id`,
+    // authMiddleware,
+    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));
+  return router;
+};
+
+const ApiRouter = CyberiaDialogueRouter;
+
+export { ApiRouter, CyberiaDialogueRouter };

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

@@ -0,0 +1,51 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaDialogueService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    return await new CyberiaDialogue(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    if (req.params.id) return await CyberiaDialogue.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([
+      CyberiaDialogue.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaDialogue.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    return await CyberiaDialogue.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    if (req.params.id) return await CyberiaDialogue.findByIdAndDelete(req.params.id);
+    else return await CyberiaDialogue.deleteMany();
+  };
+  static getByCode = async (req, res, options) => {
+    /** @type {import('./cyberia-dialogue.model.js').CyberiaDialogueModel} */
+    const CyberiaDialogue = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaDialogue;
+    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;
+  };
+}
+
+export { CyberiaDialogueService };

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

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

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

@@ -0,0 +1,24 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaEntitySchema = new Schema({
+  entityType: { type: String, default: 'floor' },
+  initCellX: { type: Number, default: 0 },
+  initCellY: { type: Number, default: 0 },
+  dimX: { type: Number, default: 1 },
+  dimY: { type: Number, default: 1 },
+  color: { type: String, default: 'rgba(255, 0, 0, 1)' },
+  objectLayerItemIds: { type: [String], default: [] },
+  // Bot-specific fields (ignored for non-bot entities)
+  spawnRadius: { type: Number, default: 0 },
+  aggroRange: { type: Number, default: 0 },
+  maxLife: { type: Number, default: 0 },
+  lifeRegen: { type: Number, default: 0 },
+});
+
+const CyberiaEntityModel = model('CyberiaEntity', CyberiaEntitySchema);
+
+const ProviderSchema = CyberiaEntitySchema;
+
+export { CyberiaEntitySchema, CyberiaEntityModel, ProviderSchema };

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

@@ -0,0 +1,27 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaEntityController } from './cyberia-entity.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaEntityRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  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`,
+    // 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));
+  return router;
+};
+
+const ApiRouter = CyberiaEntityRouter;
+
+export { ApiRouter, CyberiaEntityRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaEntityService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    return await new CyberiaEntity(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    if (req.params.id) return await CyberiaEntity.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([
+      CyberiaEntity.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaEntity.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    return await CyberiaEntity.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-entity.model.js').CyberiaEntityModel} */
+    const CyberiaEntity = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaEntity;
+    if (req.params.id) return await CyberiaEntity.findByIdAndDelete(req.params.id);
+    else return await CyberiaEntity.deleteMany();
+  };
+}
+
+export { CyberiaEntityService };