cyberia 3.2.5 → 3.2.9

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

@@ -23,6 +23,7 @@ import { loggerFactory } from './logger.js';
 
 import { registerFloorSemantics } from './semantic-layer-generator-floor.js';
 import { registerSkinSemantics } from './semantic-layer-generator-skin.js';
+import { registerResourceSemantics } from './semantic-layer-generator-resource.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -81,6 +82,64 @@ function deriveFrameSeed(layerSeed, frameIndex) {
   return hashString(`${layerSeed}:${frameIndex}`);
 }
 
+/* ═══════════════════════════════════════════════════════════════════════════
+ *  BIOME COLOUR PALETTES  (canonical source — shared by floor + resource)
+ * ═══════════════════════════════════════════════════════════════════════════ */
+
+/** @type {Object<string, number[][]>} */
+const BIOME_PALETTES = {
+  desert: [
+    [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],
+  ],
+  grass: [
+    [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],
+  ],
+  water: [
+    [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],
+  ],
+  stone: [
+    [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],
+  ],
+  lava: [
+    [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],
+  ],
+};
+
 /* ═══════════════════════════════════════════════════════════════════════════
  *  SEMANTIC REGISTRY
  * ═══════════════════════════════════════════════════════════════════════════ */
@@ -111,6 +170,12 @@ function deriveFrameSeed(layerSeed, frameIndex) {
  * @property {number}   [frameJitter]
  * @property {number}   [frameRotation]
  * @property {number}   [frameScale]
+ * @property {boolean}  [fill]             When true, shapes are scanline-filled (solid silhouettes).
+ * @property {Object}   [shapeParams]      Extra parameters forwarded to generateShape (e.g. {sides, closed, a, rangeX}).
+ * @property {number}   [scaleBase=0.15]   Base scale for stamped shapes (0..1 fraction of GRID_DIM).
+ * @property {number}   [scaleRange=0.25]  Random range added on top of scaleBase.
+ * @property {number}   [rotationBase=0]   Fixed rotation offset in degrees applied before random variance.
+ * @property {number}   [centerBias=0]     0..1 factor pulling element positions toward the tile centre.
  * @memberof SemanticLayerGenerator
  */
 
@@ -153,6 +218,7 @@ export function lookupSemantic(itemId) {
 /* ── Load category submodules at startup ────────────────────────────────── */
 registerFloorSemantics(registerSemantic);
 registerSkinSemantics(registerSemantic);
+registerResourceSemantics(registerSemantic);
 
 /* ═══════════════════════════════════════════════════════════════════════════
  *  COLOR UTILITIES
@@ -262,9 +328,19 @@ function generateNoiseFieldLayer(palette, layerSeedInt, frameIndex, spec, densit
 
 /**
  * Stamps a parametric shape onto a frame matrix at a given position/scale.
+ * @param {number[][]} frameMatrix
+ * @param {number[][]} colors
+ * @param {string} shapeKey
+ * @param {Object} transform
+ * @param {number[]} color
+ * @param {number} noiseLevel
+ * @param {number} detailLevel
+ * @param {string|number} seed
+ * @param {boolean} [fill]
+ * @param {Object} [shapeParams] Extra parameters forwarded to generateShape (e.g. sides, closed, a, rangeX).
  * @memberof SemanticLayerGenerator
  */
-function stampShape(frameMatrix, colors, shapeKey, transform, color, noiseLevel, detailLevel, seed) {
+function stampShape(frameMatrix, colors, shapeKey, transform, color, noiseLevel, detailLevel, seed, fill, shapeParams) {
   const gridSize = Math.max(4, Math.round(GRID_DIM * transform.scale));
   const result = generateShape(shapeKey, {
     intCoords: [gridSize, gridSize],
@@ -272,6 +348,8 @@ function stampShape(frameMatrix, colors, shapeKey, transform, color, noiseLevel,
     rotation: transform.rotation,
     seed,
     count: Math.round(80 * detailLevel),
+    fill: !!fill,
+    ...shapeParams,
   });
 
   const existingIdx = colors.findIndex(
@@ -430,10 +508,17 @@ export function generateFrame(options) {
         const shapeKey = pickShape(spec.shapes, preferredShapes, createRng(layerSeedInt + ei * 97));
 
         const baseRng = createRng(layerSeedInt + ei * 31 + 17);
-        const baseX = baseRng();
-        const baseY = baseRng();
-        const baseScale = 0.15 + baseRng() * 0.25 + (baseRng() * 2 - 1) * spec.scaleVariance * 0.15;
-        const baseRotation = (baseRng() * 2 - 1) * spec.rotationVariance;
+        let baseX = baseRng();
+        let baseY = baseRng();
+        const cb = spec.centerBias ?? 0;
+        if (cb > 0) {
+          baseX = baseX + (0.5 - baseX) * cb;
+          baseY = baseY + (0.5 - baseY) * cb;
+        }
+        const sBase = spec.scaleBase ?? 0.15;
+        const sRange = spec.scaleRange ?? 0.25;
+        const baseScale = sBase + baseRng() * sRange + (baseRng() * 2 - 1) * spec.scaleVariance * 0.15;
+        const baseRotation = (spec.rotationBase ?? 0) + (baseRng() * 2 - 1) * spec.rotationVariance;
 
         const fj = spec.frameJitter || 0;
         const fr = spec.frameRotation || 0;
@@ -459,12 +544,28 @@ export function generateFrame(options) {
         const shapeSeed = `${seed}:${itemId}:${layerKey}:${ei}`;
 
         stampShape(
-          compositeMatrix, compositeColors, shapeKey, transform, color,
-          spec.noiseLevel * (spec.jitter + 0.5), spec.detailLevel, shapeSeed,
+          compositeMatrix,
+          compositeColors,
+          shapeKey,
+          transform,
+          color,
+          spec.noiseLevel * (spec.jitter + 0.5),
+          spec.detailLevel,
+          shapeSeed,
+          spec.fill,
+          spec.shapeParams,
         );
         stampShape(
-          layerMatrix, layerColors, shapeKey, transform, color,
-          spec.noiseLevel * 0.5, spec.detailLevel, shapeSeed,
+          layerMatrix,
+          layerColors,
+          shapeKey,
+          transform,
+          color,
+          spec.noiseLevel * 0.5,
+          spec.detailLevel,
+          shapeSeed,
+          spec.fill,
+          spec.shapeParams,
         );
 
         layerEntries.push({ type: 'shape', shapeKey, transform, color, shapeSeed });
@@ -553,9 +654,7 @@ export function generateMultiFrame(options) {
     const mapping = {};
     for (let ci = 0; ci < frame.compositeColors.length; ci++) {
       const c = frame.compositeColors[ci];
-      let found = globalColors.findIndex(
-        (gc) => gc[0] === c[0] && gc[1] === c[1] && gc[2] === c[2] && gc[3] === c[3],
-      );
+      let found = globalColors.findIndex((gc) => gc[0] === c[0] && gc[1] === c[1] && gc[2] === c[2] && gc[3] === c[3]);
       if (found < 0) {
         globalColors.push([...c]);
         found = globalColors.length - 1;
@@ -572,7 +671,6 @@ export function generateMultiFrame(options) {
 
   const objectLayerRenderFramesData = {
     frame_duration: frameDuration,
-    is_stateless: descriptor.itemType === 'floor',
     frames: {},
     colors: globalColors,
   };
@@ -642,4 +740,14 @@ function hashMod(str, mod) {
  *  EXPORTS
  * ═══════════════════════════════════════════════════════════════════════════ */
 
-export { hashString, deriveLayerSeed, deriveFrameSeed, pickColor, pickShape, seedToUUIDv4, GRID_DIM, semanticRegistry };
+export {
+  hashString,
+  deriveLayerSeed,
+  deriveFrameSeed,
+  pickColor,
+  pickShape,
+  seedToUUIDv4,
+  GRID_DIM,
+  semanticRegistry,
+  BIOME_PALETTES,
+};

package/src/server/shape-generator.js

@@ -155,6 +155,26 @@ registerShape('parabola', (t, params) => {
   return { x, y: a * x * x };
 });
 
+registerShape('thick-parabola', (t, params) => {
+  // Closed parabolic band — traces the outer curve forward then the inner
+  // curve backward, producing a thick filled crescent when rasterized.
+  // `a` controls curvature, `rangeX` controls horizontal span, and
+  // `thickness` controls band width (vertical gap between outer/inner).
+  const a = params.a ?? 0.6;
+  const rangeX = params.rangeX ?? 1.3;
+  const thickness = params.thickness ?? 0.35;
+  if (t <= 0.5) {
+    // Outer parabola (forward: left → right)
+    const u = t * 2;
+    const xNorm = -rangeX + 2 * rangeX * u;
+    return { x: xNorm, y: a * xNorm * xNorm };
+  }
+  // Inner parabola (reverse: right → left, shifted up by thickness)
+  const u = 1 - (t - 0.5) * 2;
+  const xNorm = -rangeX + 2 * rangeX * u;
+  return { x: xNorm, y: a * xNorm * xNorm + thickness };
+});
+
 registerShape('heart', (t) => {
   const angle = t * Math.PI * 2;
   const x = 16 * Math.pow(Math.sin(angle), 3);
@@ -408,6 +428,42 @@ registerShape('bezier-path', (t, params) => {
   return { x, y };
 });
 
+registerShape('regular-polygon', (t, params) => {
+  // Regular convex polygon with `sides` edges.
+  // Traces straight vertex-to-vertex segments for perfect geometric figures.
+  const sides = Math.max(3, params.sides ?? 4);
+  const r = params.r ?? 1;
+  const segAngle = (2 * Math.PI) / sides;
+  const angle = t * Math.PI * 2;
+  // Which segment are we in?
+  const seg = Math.floor(angle / segAngle);
+  const frac = (angle - seg * segAngle) / segAngle;
+  // Offset: -π/2 puts first vertex at top (flat bottom for odd-sided).
+  // For even-sided polygons, shift by half a segment so edges are axis-aligned.
+  const offset = -Math.PI / 2 + (sides % 2 === 0 ? Math.PI / sides : 0);
+  const a0 = seg * segAngle + offset;
+  const a1 = (seg + 1) * segAngle + offset;
+  const x = r * ((1 - frac) * Math.cos(a0) + frac * Math.cos(a1));
+  const y = r * ((1 - frac) * Math.sin(a0) + frac * Math.sin(a1));
+  return { x, y };
+});
+
+registerShape('rectangle', (t, params) => {
+  // Axis-aligned rectangle with configurable aspect ratio.
+  // `width` and `height` control proportions (default: 1.4 × 1.0).
+  const w = params.width ?? 1.4;
+  const h = params.height ?? 1.0;
+  const hw = w / 2,
+    hh = h / 2;
+  const perim = 2 * (w + h);
+  const d = t * perim;
+  // Traverse: bottom-left → bottom-right → top-right → top-left
+  if (d < w) return { x: -hw + d, y: hh };
+  if (d < w + h) return { x: hw, y: hh - (d - w) };
+  if (d < 2 * w + h) return { x: hw - (d - w - h), y: -hh };
+  return { x: -hw, y: -hh + (d - 2 * w - h) };
+});
+
 /* ═══════════════════════════════════════════════════════════════════════════
  *  GEOMETRY HELPERS
  * ═══════════════════════════════════════════════════════════════════════════ */
@@ -677,6 +733,49 @@ function rasterizeContour(normalizedPoints, gridW, gridH, closed) {
   return unique;
 }
 
+/**
+ * Scanline-fills the interior of a closed contour on an integer grid.
+ * Takes the contour points produced by `rasterizeContour` and returns a
+ * new array containing both the contour AND all interior cells.
+ *
+ * Uses the standard even-odd scanline algorithm: for each row, find the
+ * leftmost and rightmost contour cell then fill everything in between.
+ *
+ * @param {ShapePoint[]} contourPoints - Contour cells from rasterizeContour.
+ * @param {number} gridW - Grid width.
+ * @param {number} gridH - Grid height.
+ * @returns {ShapePoint[]} All unique filled cells (contour + interior).
+ * @memberof ShapeGenerator
+ */
+function scanlineFill(contourPoints, gridW, gridH) {
+  // Build per-row min/max from contour
+  const rowBounds = new Map();
+  for (const p of contourPoints) {
+    const b = rowBounds.get(p.y);
+    if (b) {
+      if (p.x < b.min) b.min = p.x;
+      if (p.x > b.max) b.max = p.x;
+    } else {
+      rowBounds.set(p.y, { min: p.x, max: p.x });
+    }
+  }
+
+  const seen = new Set();
+  const filled = [];
+
+  for (const [y, { min, max }] of rowBounds) {
+    for (let x = min; x <= max; x++) {
+      const k = x * 100000 + y;
+      if (!seen.has(k)) {
+        seen.add(k);
+        filled.push({ x, y });
+      }
+    }
+  }
+
+  return filled;
+}
+
 /**
  * Renders an integer-coordinate ShapeResult as an ASCII grid string.
  * Useful for quick visual verification of pixel-art shapes.
@@ -738,6 +837,9 @@ export function renderGrid(shapeResult, opts = {}) {
  *   with Bresenham rasterization so that even on a 16×16 grid the full contour
  *   is visible as a connected set of cells. `count` is ignored in this mode;
  *   the number of output points equals the number of unique rasterized cells.
+ * @property {boolean} [fill=false] - When true (and intCoords is enabled),
+ *   scanline-fills the interior of the closed contour, producing a solid
+ *   silhouette instead of an outline-only shape.
  * @memberof ShapeGenerator
  */
 
@@ -810,6 +912,7 @@ export function generateShape(key, options = {}) {
     closed = true,
     normalize = true,
     intCoords = false,
+    fill = false,
     color,
     ...extraParams
   } = options;
@@ -896,6 +999,11 @@ export function generateShape(key, options = {}) {
   if (useIntCoords) {
     points = rasterizeContour(points, gridW, gridH, closed);
 
+    // ---- Scanline fill (solid silhouette) -----------------------------------
+    if (fill && closed) {
+      points = scanlineFill(points, gridW, gridH);
+    }
+
     // Build metadata for integer grid mode
     const bbox = computeBbox(points);
     /** @type {ShapeMetadata} */

package/src/server/start.js

@@ -131,11 +131,21 @@ class UnderpostStartUp {
      * @param {boolean} options.build - Whether to build the deployment.
      * @param {boolean} options.run - Whether to run the deployment.
      * @param {boolean} options.underpostQuicklyInstall - Whether to use underpost quickly install.
+     * @param {boolean} options.skipPullBase - Whether to skip pulling the base code.
+     * @param {boolean} options.skipFullBuild - Whether to skip building the full client bundle.
+     * @param {boolean} options.pullBundle - When true, download pre-built client bundle from Cloudinary via pull-bundle before starting.
      */
     async callback(
       deployId = 'dd-default',
       env = 'development',
-      options = { build: false, run: false, underpostQuicklyInstall: false },
+      options = {
+        build: false,
+        run: false,
+        underpostQuicklyInstall: false,
+        skipPullBase: false,
+        skipFullBuild: false,
+        pullBundle: false,
+      },
     ) {
       Underpost.env.set('container-status', `${deployId}-${env}-build-deployment`);
       if (options.build === true) await Underpost.start.build(deployId, env, options);
@@ -149,12 +159,15 @@ class UnderpostStartUp {
      * @param {Object} options - Options for the build.
      * @param {boolean} options.skipPullBase - Whether to skip pulling the base code and use the current workspace code directly.
      * @param {boolean} options.underpostQuicklyInstall - Whether to use underpost quickly install.
+     * @param {boolean} options.skipFullBuild - Whether to skip building the full client bundle.
+     * @param {boolean} options.pullBundle - When true, download pre-built client bundle from Cloudinary via pull-bundle (must be pushed first with push-bundle).
+     *   This flag is independent of skipFullBuild: it can be combined with skipFullBuild or used alone.
      * @memberof UnderpostStartUp
      */
     async build(
       deployId = 'dd-default',
       env = 'development',
-      options = { underpostQuicklyInstall: false, skipPullBase: false },
+      options = { underpostQuicklyInstall: false, skipPullBase: false, skipFullBuild: false, pullBundle: false },
     ) {
       const buildBasePath = `/home/dd`;
       const repoName = `engine-${deployId.split('-')[1]}`;
@@ -173,7 +186,8 @@ class UnderpostStartUp {
         for (const itcScript of itcScripts)
           if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
       }
-      shellExec(`node bin client ${deployId}`);
+      if (options.pullBundle === true) shellExec(`node bin run pull-bundle --deploy-id ${deployId}`);
+      else if (!options.skipFullBuild) shellExec(`node bin client ${deployId}`);
     },
     /**
      * Runs a deployment.