cyberia 3.2.5 → 3.2.9

package/src/server/process.js

@@ -4,35 +4,30 @@
  * @module src/server/process.js
  * @namespace Process
  */
-
 // https://nodejs.org/api/process
-
 import shell from 'shelljs';
 import { loggerFactory } from './logger.js';
 import clipboard from 'clipboardy';
 import Underpost from '../index.js';
 import { getNpmRootPath } from './conf.js';
-
 const logger = loggerFactory(import.meta);
-
 /**
  * Gets the current working directory, replacing backslashes with forward slashes for consistency.
  * @memberof Process
  * @returns {string} The root directory path.
  */
 const getRootDirectory = () => process.cwd().replace(/\\/g, '/');
-
 /**
  * Controls and manages process-level events and signals.
  * @namespace ProcessController
  */
-const ProcessController = {
+class ProcessController {
   /**
    * List of signals to listen for for graceful shutdown/handling.
    * @memberof ProcessController
    * @type {string[]}
    */
-  SIG: [
+  static SIG = [
     'SIGPIPE',
     'SIGHUP',
     'SIGTERM',
@@ -45,29 +40,26 @@ const ProcessController = {
     'SIGFPE',
     'SIGSEGV',
     'SIGILL',
-  ],
-
+  ];
   /**
    * Sets up listeners for various process signals defined in {@link ProcessController.SIG}.
    * Handles graceful exit on 'SIGINT' (Ctrl+C).
    * @memberof ProcessController
    * @returns {Array<process.Process>} An array of process listener handles.
    */
-  onSigListen: function () {
-    return this.SIG.map((sig) =>
+  static onSigListen() {
+    return ProcessController.SIG.map((sig) =>
       process.on(sig, (...args) => {
-        this.logger.info(`process on ${sig}`, args);
+        ProcessController.logger.info(`process on ${sig}`, args);
         switch (sig) {
           case 'SIGINT':
             return process.exit();
-
           default:
             break;
         }
       }),
     );
-  },
-
+  }
   /**
    * Initializes the ProcessController.
    * Sets up signal listeners, registers a listener for the 'exit' event, and cleans up temporary deployment environment variables.
@@ -75,16 +67,15 @@ const ProcessController = {
    * @param {Object} logger - The logger instance to use for internal logging.
    * @returns {void}
    */
-  init: function (logger) {
-    this.logger = logger;
+  static init(logger) {
+    ProcessController.logger = logger;
     process.on('exit', (...args) => {
-      this.logger.info(`process on exit`, args);
+      ProcessController.logger.info(`process on exit`, args);
     });
-    this.onSigListen();
+    ProcessController.onSigListen();
     Underpost.env.delete('await-deploy');
-  },
-};
-
+  }
+}
 /**
  * Executes a shell command using shelljs.
  * @memberof Process
@@ -105,7 +96,6 @@ const shellExec = (
   if (options.callback) return shell.exec(cmd, options, options.callback);
   return options.stdout ? shell.exec(cmd, options).stdout : shell.exec(cmd, options);
 };
-
 /**
  * Changes the current working directory using shelljs.
  * @memberof Process
@@ -118,7 +108,6 @@ const shellCd = (cd, options = { disableLog: false }) => {
   if (!options.disableLog) logger.info(`cd`, cd);
   return shell.cd(cd);
 };
-
 /**
  * Wraps a command to run it as a daemon process in a shell (keeping the process alive/terminal open).
  * @memberof Process
@@ -126,7 +115,6 @@ const shellCd = (cd, options = { disableLog: false }) => {
  * @returns {string} The shell command string for the daemon process.
  */
 const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
-
 /**
  * Retrieves the process ID (PID) of the most recently created gnome-terminal instance.
  * Note: This function is environment-specific (GNOME/Linux) and uses `pgrep -n`.
@@ -136,7 +124,6 @@ const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
 // list all terminals: pgrep gnome-terminal
 // list last terminal: pgrep -n gnome-terminal
 const getTerminalPid = () => JSON.parse(shellExec(`pgrep -n gnome-terminal`, { stdout: true, silent: true }));
-
 /**
  * Copies text content to the system clipboard using clipboardy.
  * Logs the copied content for confirmation.
@@ -148,5 +135,4 @@ function pbcopy(data) {
   clipboard.writeSync(data || '🦄');
   logger.info(`copied to clipboard`, clipboard.readSync());
 }
-
 export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, getTerminalPid, daemonProcess };

package/src/server/semantic-layer-generator-floor.js

@@ -5,10 +5,16 @@
  * desert, grass, water, stone, and lava.  Imported by the main
  * semantic-layer-generator.js which registers them at startup.
  *
+ * Biome palettes are imported from the centralized BIOME_PALETTES in the
+ * parent module (circular import is safe because the function body is only
+ * executed after module initialisation completes).
+ *
  * @module src/server/semantic-layer-generator-floor.js
  * @namespace SemanticLayerGeneratorFloor
  */
 
+import { BIOME_PALETTES } from './semantic-layer-generator.js';
+
 /* ═══════════════════════════════════════════════════════════════════════════
  *  FLOOR SEMANTIC REGISTRY
  *  Call registerFloorSemantics(registerFn) once to add all floor descriptors.
@@ -16,7 +22,6 @@
 
 /**
  * Registers all built-in floor semantic descriptors.
- * Uses dependency injection — no import from the parent module.
  *
  * @param {function(string, import('./semantic-layer-generator.js').SemanticDescriptor): void} registerFn
  * @memberof SemanticLayerGeneratorFloor
@@ -25,16 +30,7 @@ export function registerFloorSemantics(registerFn) {
   /* ── Desert ───────────────────────────────────────────────────────────── */
   registerFn('floor-desert', {
     semanticTags: ['sand', 'dune', 'arid', 'dry'],
-    paletteHints: [
-      [210, 180, 120, 255],
-      [194, 160, 100, 255],
-      [230, 205, 150, 255],
-      [180, 140, 80, 255],
-      [160, 120, 70, 255],
-      [120, 90, 55, 255],
-      [100, 80, 50, 255],
-      [240, 220, 175, 255],
-    ],
+    paletteHints: BIOME_PALETTES.desert,
     preferredShapes: { ellipse: 3, circle: 2, cactus: 1, star: 0.5 },
     itemType: 'floor',
     layers: {
@@ -104,16 +100,7 @@ export function registerFloorSemantics(registerFn) {
   /* ── Grass ────────────────────────────────────────────────────────────── */
   registerFn('floor-grass', {
     semanticTags: ['grass', 'meadow', 'green', 'earth'],
-    paletteHints: [
-      [80, 140, 60, 255],
-      [60, 120, 45, 255],
-      [110, 170, 80, 255],
-      [90, 130, 55, 255],
-      [130, 100, 65, 255],
-      [70, 110, 40, 255],
-      [150, 190, 100, 255],
-      [100, 85, 50, 255],
-    ],
+    paletteHints: BIOME_PALETTES.grass,
     preferredShapes: { ellipse: 3, circle: 2, heart: 0.5 },
     itemType: 'floor',
     layers: {
@@ -168,16 +155,7 @@ export function registerFloorSemantics(registerFn) {
   /* ── Water ────────────────────────────────────────────────────────────── */
   registerFn('floor-water', {
     semanticTags: ['water', 'ocean', 'wave', 'liquid'],
-    paletteHints: [
-      [40, 100, 180, 255],
-      [60, 130, 200, 255],
-      [90, 160, 220, 255],
-      [120, 190, 230, 255],
-      [30, 80, 150, 255],
-      [70, 140, 210, 255],
-      [150, 210, 240, 255],
-      [20, 60, 120, 255],
-    ],
+    paletteHints: BIOME_PALETTES.water,
     preferredShapes: { ellipse: 3, circle: 2 },
     itemType: 'floor',
     layers: {
@@ -232,16 +210,7 @@ export function registerFloorSemantics(registerFn) {
   /* ── Stone ────────────────────────────────────────────────────────────── */
   registerFn('floor-stone', {
     semanticTags: ['stone', 'rock', 'cobble', 'grey'],
-    paletteHints: [
-      [140, 140, 145, 255],
-      [120, 118, 125, 255],
-      [165, 165, 170, 255],
-      [100, 98, 105, 255],
-      [180, 180, 185, 255],
-      [90, 85, 80, 255],
-      [155, 150, 148, 255],
-      [110, 108, 115, 255],
-    ],
+    paletteHints: BIOME_PALETTES.stone,
     preferredShapes: { circle: 3, ellipse: 2, star: 1, 'pixel-art': 0.5 },
     itemType: 'floor',
     layers: {
@@ -296,16 +265,7 @@ export function registerFloorSemantics(registerFn) {
   /* ── Lava ─────────────────────────────────────────────────────────────── */
   registerFn('floor-lava', {
     semanticTags: ['lava', 'magma', 'fire', 'hot'],
-    paletteHints: [
-      [200, 50, 20, 255],
-      [230, 100, 30, 255],
-      [255, 180, 50, 255],
-      [160, 30, 10, 255],
-      [80, 20, 10, 255],
-      [50, 15, 8, 255],
-      [240, 140, 40, 255],
-      [120, 25, 12, 255],
-    ],
+    paletteHints: BIOME_PALETTES.lava,
     preferredShapes: { circle: 3, ellipse: 2, cactus: 1 },
     itemType: 'floor',
     layers: {

package/src/server/semantic-layer-generator-resource.js

@@ -0,0 +1,259 @@
+/**
+ * Resource semantic descriptors for the Semantic Layer Generator.
+ *
+ * Provides procedural generation recipes for generic collectible resource
+ * object layers.  Each colour palette is imported from the centralized
+ * BIOME_PALETTES (shared with floor descriptors).
+ *
+ * Each biome is paired with four distinct shape families:
+ *
+ *   • **petal**   — several parabolic arcs facing the same general direction,
+ *                   reminiscent of a semi-ring of Saturn.  Open curves are
+ *                   scanline-filled so each arc reads as a coloured petal.
+ *   • **stone**   — hard, angular mineral shapes (circle, pixel-art); filled.
+ *   • **polygon** — perfect regular geometric figures (triangles, squares,
+ *                   pentagons, hexagons); filled with near-zero noise.
+ *   • **thread**  — thin, wispy lines composed of Bézier curves and
+ *                   parabolas; NOT filled — rendered as outlines only.
+ *
+ * Naming convention: `resource-{biome}-{shape}`
+ *   e.g. `resource-desert-petal`, `resource-grass-stone`, `resource-lava-thread`
+ *
+ * All descriptors use `itemType: 'floor'` so the default single-direction
+ * frame pipeline (`down_idle` / `default_idle`) is used — matching the
+ * stateless, non-directional nature of world-placed resource pickups.
+ *
+ * @module src/server/semantic-layer-generator-resource.js
+ * @namespace SemanticLayerGeneratorResource
+ */
+
+import { BIOME_PALETTES } from './semantic-layer-generator.js';
+
+/* ═══════════════════════════════════════════════════════════════════════════
+ *  SHAPE FAMILY RECIPES
+ *
+ *  Each recipe defines:
+ *    tags            — semantic tags appended to the biome tags
+ *    preferredShapes — shape → weight map for the shape picker
+ *    layers          — ordered LayerSpec dict (rendered bottom→top)
+ * ═══════════════════════════════════════════════════════════════════════════ */
+
+const SHAPE_FAMILIES = {
+  /* ── Petal — thick parabolic arcs all facing roughly the same direction ─
+   *  Uses `thick-parabola` — a closed band shape that traces the outer
+   *  parabola forward and the inner parabola backward, producing a thick
+   *  filled crescent.  Two layers with slightly different curvature &
+   *  thickness overlap to build a bold Saturn-ring effect.
+   * ───────────────────────────────────────────────────────────────────── */
+  petal: {
+    tags: ['petal', 'arc', 'crescent', 'organic'],
+    preferredShapes: { 'thick-parabola': 5 },
+    layers: {
+      arcs: {
+        generator: 'shape',
+        shapes: ['thick-parabola'],
+        count: 2,
+        scaleBase: 0.45,
+        scaleRange: 0.15,
+        scaleVariance: 0.1,
+        rotationBase: 90, // vertical parabolas
+        rotationVariance: 10,
+        colorShift: 18,
+        jitter: 0.04,
+        noiseLevel: 0.04,
+        detailLevel: 1.2,
+        sparsity: 0.05,
+        centerBias: 0.6, // cluster near tile centre
+        frameJitter: 0.008,
+        frameRotation: 1.5,
+        frameScale: 0.004,
+        fill: true,
+        shapeParams: { a: 0.5, rangeX: 1.3, thickness: 0.35 },
+      },
+      inner: {
+        generator: 'shape',
+        shapes: ['thick-parabola'],
+        count: 1,
+        scaleBase: 0.35,
+        scaleRange: 0.15,
+        scaleVariance: 0.1,
+        rotationBase: 90,
+        rotationVariance: 6,
+        colorShift: 24,
+        jitter: 0.03,
+        noiseLevel: 0.03,
+        detailLevel: 1.0,
+        sparsity: 0.05,
+        centerBias: 0.6,
+        frameJitter: 0.006,
+        frameRotation: 1.0,
+        frameScale: 0.003,
+        fill: true,
+        shapeParams: { a: 0.6, rangeX: 1.2, thickness: 0.4 },
+      },
+    },
+  },
+
+  /* ── Stone — hard, angular mineral shapes (filled) ────────────────────── */
+  stone: {
+    tags: ['stone', 'mineral', 'rock', 'hard'],
+    preferredShapes: { circle: 3, 'pixel-art': 3, star: 1, ellipse: 1 },
+    layers: {
+      body: {
+        generator: 'shape',
+        shapes: ['circle', 'pixel-art'],
+        count: 3,
+        scaleVariance: 0.35,
+        rotationVariance: 90,
+        colorShift: 10,
+        jitter: 0.06,
+        noiseLevel: 0.18,
+        detailLevel: 1.2,
+        sparsity: 0.1,
+        frameJitter: 0.002,
+        frameRotation: 0.3,
+        frameScale: 0.002,
+        fill: true,
+      },
+      chips: {
+        generator: 'shape',
+        shapes: ['star', 'pixel-art'],
+        count: 4,
+        scaleVariance: 0.4,
+        rotationVariance: 180,
+        colorShift: 16,
+        jitter: 0.1,
+        noiseLevel: 0.2,
+        detailLevel: 0.9,
+        sparsity: 0.3,
+        frameJitter: 0.001,
+        frameRotation: 0.2,
+        frameScale: 0.001,
+        fill: true,
+      },
+    },
+  },
+
+  /* ── Polygon — one geometric shape repeated with variations ───────────
+   *  A single regular polygon (square) repeated several times with
+   *  varying scale, rotation, and colour — clearly geometric,
+   *  possibly overlapping.  Zero noise keeps edges ruler-straight.
+   * ───────────────────────────────────────────────────────────────────── */
+  polygon: {
+    tags: ['polygon', 'crystal', 'geometric', 'facet'],
+    preferredShapes: { 'regular-polygon': 6 },
+    layers: {
+      figures: {
+        generator: 'shape',
+        shapes: ['regular-polygon'],
+        count: 3,
+        scaleBase: 0.25,
+        scaleRange: 0.25,
+        scaleVariance: 0.15,
+        rotationVariance: 25,
+        colorShift: 20,
+        jitter: 0.02,
+        noiseLevel: 0.0,
+        detailLevel: 1.3,
+        sparsity: 0.0,
+        centerBias: 0.75, // stack near tile centre
+        frameJitter: 0.003,
+        frameRotation: 0.8,
+        frameScale: 0.002,
+        fill: true,
+        shapeParams: { sides: 4 },
+      },
+    },
+  },
+
+  /* ── Thread — thin, wispy wavy lines (outlines only, NOT filled) ──────
+   *  Bézier curves and parabolas rendered as open contours.  High count
+   *  gives a tangle-of-threads appearance.
+   * ───────────────────────────────────────────────────────────────────── */
+  thread: {
+    tags: ['thread', 'fiber', 'sewing', 'wisp'],
+    preferredShapes: { 'bezier-path': 4, parabola: 3 },
+    layers: {
+      strands: {
+        generator: 'shape',
+        shapes: ['bezier-path', 'parabola'],
+        count: 7,
+        scaleVariance: 0.35,
+        rotationVariance: 180,
+        colorShift: 14,
+        jitter: 0.12,
+        noiseLevel: 0.15,
+        detailLevel: 1.0,
+        sparsity: 0.15,
+        frameJitter: 0.015,
+        frameRotation: 3.0,
+        frameScale: 0.006,
+        fill: false, // outlines only — wavy lines
+        shapeParams: { closed: false },
+      },
+      wisps: {
+        generator: 'shape',
+        shapes: ['bezier-path'],
+        count: 4,
+        scaleVariance: 0.3,
+        rotationVariance: 120,
+        colorShift: 10,
+        jitter: 0.1,
+        noiseLevel: 0.1,
+        detailLevel: 0.9,
+        sparsity: 0.3,
+        frameJitter: 0.01,
+        frameRotation: 2.0,
+        frameScale: 0.004,
+        fill: false,
+        shapeParams: { closed: false },
+      },
+    },
+  },
+};
+
+/* ═══════════════════════════════════════════════════════════════════════════
+ *  BIOME SEMANTIC TAGS
+ * ═══════════════════════════════════════════════════════════════════════════ */
+
+const BIOME_TAGS = {
+  desert: ['sand', 'arid', 'dry'],
+  grass: ['grass', 'meadow', 'earth'],
+  water: ['water', 'ocean', 'liquid'],
+  stone: ['rock', 'cobble', 'grey'],
+  lava: ['lava', 'magma', 'fire'],
+};
+
+/* ═══════════════════════════════════════════════════════════════════════════
+ *  REGISTRATION
+ * ═══════════════════════════════════════════════════════════════════════════ */
+
+/**
+ * Registers all built-in resource semantic descriptors.
+ *
+ * Generates 5 biomes × 4 shape families = 20 descriptors, each registered
+ * under the prefix `resource-{biome}-{shape}`.
+ *
+ * @param {function(string, import('./semantic-layer-generator.js').SemanticDescriptor): void} registerFn
+ * @memberof SemanticLayerGeneratorResource
+ */
+export function registerResourceSemantics(registerFn) {
+  const biomes = Object.keys(BIOME_PALETTES);
+  const families = Object.keys(SHAPE_FAMILIES);
+
+  for (const biome of biomes) {
+    for (const family of families) {
+      const prefix = `resource-${biome}-${family}`;
+      const palette = BIOME_PALETTES[biome];
+      const recipe = SHAPE_FAMILIES[family];
+
+      registerFn(prefix, {
+        semanticTags: [...BIOME_TAGS[biome], ...recipe.tags, 'resource'],
+        paletteHints: palette,
+        preferredShapes: recipe.preferredShapes,
+        itemType: 'floor',
+        layers: recipe.layers,
+      });
+    }
+  }
+}