@underpostnet/cyberia 3.2.80 → 3.2.90

package/src/api/cyberia-instance/cyberia-fallback-world.js

@@ -19,6 +19,7 @@
  */
 
 import { connectPortals } from './cyberia-portal-connector.js';
+import { withSeededRandom } from './cyberia-random-source.js';
 
 import {
   generateObstacles,
@@ -38,6 +39,7 @@ import {
   DEFAULT_PLAYER_SPAWN,
   ENTITY_TYPE_DEFAULTS,
   RESOURCE_ENTITY_TYPE_DEFAULTS,
+  DefaultCyberiaActions,
   DefaultSkillConfig,
 } from '../cyberia-server-defaults/cyberia-server-defaults.js';
 import {
@@ -92,6 +94,19 @@ function collectReferencedItemIds() {
       }
     }
   }
+  // Provider catalogs: the interact modal draws an icon for every item a
+  // vendor sells and every ingredient/output an assembler recipe names, so all
+  // of them must resolve to an ObjectLayer.
+  for (const action of DefaultCyberiaActions) {
+    for (const shopItem of action.shopItems || []) {
+      push(shopItem.itemId);
+      push(shopItem.priceItemId);
+    }
+    for (const recipe of action.craftRecipes || []) {
+      (recipe.ingredients || []).forEach((i) => push(i.itemId));
+      (recipe.outputItems || []).forEach((o) => push(o.itemId));
+    }
+  }
   return ids;
 }
 
@@ -262,20 +277,32 @@ function generateFallbackWorld(opts = {}) {
     mapCodes.push(`fallback-map-${i}`);
   }
 
-  // Generate each map (all randomized independently).
-  const maps = mapCodes.map((code) =>
-    generateFallbackMap(code, colors, {
-      gridSize,
-      obstacleCount,
-      foregroundCount,
-      botCount,
-      resourceCount,
-      staticCount,
-    }),
-  );
-
-  // Connect maps with portal topology using the portal connector module.
-  const { portals, topology } = connectPortals(mapCodes, maps);
+  // Deterministic layout: seed the shared random source so every call
+  // reproduces the SAME world. The instance-map `/static` POIs and the
+  // `/preview` node image are built by independent requests (and survive
+  // restarts) — they must agree on where every entity sits, so a resource POI
+  // lands exactly where the preview draws that resource. The seed folds in the
+  // layout-affecting options so a custom count set stays internally consistent.
+  const seed = `cyberia-fallback-world-v1:${mapCount}:${gridSize ?? ''}:${obstacleCount ?? ''}:${
+    foregroundCount ?? ''
+  }:${botCount ?? ''}:${resourceCount ?? ''}:${staticCount ?? ''}`;
+
+  const { maps, portals, topology } = withSeededRandom(seed, () => {
+    // Generate each map (deterministic under the seeded source).
+    const genMaps = mapCodes.map((code) =>
+      generateFallbackMap(code, colors, {
+        gridSize,
+        obstacleCount,
+        foregroundCount,
+        botCount,
+        resourceCount,
+        staticCount,
+      }),
+    );
+    // Connect maps with portal topology using the portal connector module.
+    const { portals: p, topology: t } = connectPortals(mapCodes, genMaps);
+    return { maps: genMaps, portals: p, topology: t };
+  });
 
   // Build the instance shell (never persisted — no mongoId).
   const instance = {

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

@@ -31,8 +31,8 @@ import {
   DefaultCyberiaActions,
   DefaultCyberiaQuests,
   ENTITY_TYPE_DEFAULTS,
-  RESOURCE_ENTITY_TYPE_DEFAULTS,
 } from '../cyberia-server-defaults/cyberia-server-defaults.js';
+import { DefaultCyberiaItems } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -430,22 +430,18 @@ const resolveInstanceWorld = async (instanceCode, options) => {
   const instance = await CyberiaInstance.findOne({ code: instanceCode }).lean();
 
   if (!instance) {
-    // Fallback world: topology is regenerated (portal cells may drift from
-    // the live simulation's world), but map codes and provider POIs come
-    // from the deterministic canonical defaults.
     const world = generateFallbackWorld();
     const mapCodes = new Set(world.instance.cyberiaMapCodes);
 
-    // Build synthetic object-layer metadata for the fallback world's resource
-    // items so resource entities carry a stats-sum readout.  The canonical
-    // resource defaults (wood-1, wood-2) are not persisted to MongoDB in the
-    // fallback path, so we compute a reasonable stats sum from the item type's
-    // default stat block (each stat 0-10, 6 stats → ~30 average).
-    const resourceItemIds = [
-      ...new Set(RESOURCE_ENTITY_TYPE_DEFAULTS.flatMap((r) => [...(r.liveItemIds || []), ...(r.dropItemIds || [])])),
+    const fallbackItemIds = [
+      ...new Set(world.maps.flatMap((m) => (m.entities || []).flatMap((e) => e.objectLayerItemIds || []))),
     ];
+    const itemTypeById = Object.fromEntries(DefaultCyberiaItems.map((entry) => [entry.item.id, entry.item.type]));
+    const resolved = await resolveObjectLayerMetadata(fallbackItemIds, options);
     const objectLayerMetadata = Object.fromEntries(
-      resourceItemIds.map((itemId) => [itemId, { statsSum: 30, type: 'resource' }]),
+      Object.entries(resolved).map(([itemId, meta]) => {
+        return [itemId, { statsSum: meta.statsSum, type: meta.type }];
+      }),
     );
 
     return {

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

@@ -20,6 +20,8 @@
  * @module src/api/cyberia-instance/cyberia-portal-connector
  */
 
+import { nextRandom } from './cyberia-random-source.js';
+
 // ── Portal mode constants ────────────────────────────────────────────────────
 
 /**
@@ -117,7 +119,7 @@ function buildTopologyFromSubtypes(orderedCodes, portalIndex) {
 
       // Target: pick any portal on the target map for landing coordinates
       const tgtAll = portalIndex[tgtCode] || [];
-      const tgtEnt = tgtAll.length > 0 ? tgtAll[Math.floor(Math.random() * tgtAll.length)] : null;
+      const tgtEnt = tgtAll.length > 0 ? tgtAll[Math.floor(nextRandom() * tgtAll.length)] : null;
 
       if (srcEnt) {
         usedInRing.add(srcEnt);
@@ -139,7 +141,7 @@ function buildTopologyFromSubtypes(orderedCodes, portalIndex) {
     if (n < 2) return srcCode;
     let code;
     do {
-      code = orderedCodes[Math.floor(Math.random() * n)];
+      code = orderedCodes[Math.floor(nextRandom() * n)];
     } while (code === srcCode && n > 1);
     return code;
   };
@@ -151,13 +153,13 @@ function buildTopologyFromSubtypes(orderedCodes, portalIndex) {
     for (const srcEnt of remaining) {
       // 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)];
+      const sub = srcEnt.portalSubtype || PORTAL_MODE_LIST[Math.floor(nextRandom() * PORTAL_MODE_LIST.length)];
 
       switch (sub) {
         case PORTAL_MODES.INTER_PORTAL: {
           const tgtCode = otherMap(srcCode);
           const candidates = portalIndex[tgtCode] || [];
-          const tgtEnt = candidates.length > 0 ? candidates[Math.floor(Math.random() * candidates.length)] : null;
+          const tgtEnt = candidates.length > 0 ? candidates[Math.floor(nextRandom() * candidates.length)] : null;
           portals.push({
             sourceMapCode: srcCode,
             sourceCellX: srcEnt.initCellX ?? 0,
@@ -198,7 +200,7 @@ function buildTopologyFromSubtypes(orderedCodes, portalIndex) {
           const candidates = allOnMap.filter(
             (e) => e !== srcEnt && (e.initCellX !== srcEnt.initCellX || e.initCellY !== srcEnt.initCellY),
           );
-          const tgtEnt = candidates.length > 0 ? candidates[Math.floor(Math.random() * candidates.length)] : null;
+          const tgtEnt = candidates.length > 0 ? candidates[Math.floor(nextRandom() * candidates.length)] : null;
           portals.push({
             sourceMapCode: srcCode,
             sourceCellX: srcEnt.initCellX ?? 0,

package/src/api/cyberia-instance/cyberia-random-source.js

@@ -0,0 +1,80 @@
+/**
+ * Swappable random source for procedural world generation.
+ *
+ * The world generator and portal connector draw all randomness through
+ * `nextRandom()` instead of `Math.random()` directly. By default it IS
+ * `Math.random`, so live/editor generation stays random. The fallback world
+ * temporarily installs a seeded PRNG so the SAME layout is produced on every
+ * call — the instance-map `/static` POIs and the `/preview` image are built by
+ * independent HTTP requests (and survive server restarts), so they must agree
+ * on where every entity sits.
+ *
+ * @module src/api/cyberia-instance/cyberia-random-source.js
+ */
+
+let source = Math.random;
+
+/** Draw the next float in [0, 1). Routes through the installed source. */
+const nextRandom = () => source();
+
+/**
+ * mulberry32 — a small, fast, well-distributed seeded PRNG. Deterministic:
+ * the same seed always yields the same sequence.
+ * @param {number} seed 32-bit unsigned integer
+ * @returns {() => number}
+ */
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function () {
+    a |= 0;
+    a = (a + 0x6d2b79f5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Derive a stable 32-bit seed from a string (FNV-1a). */
+function hashSeed(str) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < String(str).length; i++) {
+    h ^= String(str).charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/**
+ * Install a deterministic seeded source. Accepts a number or a string
+ * (hashed to a 32-bit seed). Call `resetRandomSource()` to restore Math.random.
+ * @param {number|string} seed
+ */
+function seedRandomSource(seed) {
+  const s = typeof seed === 'number' ? seed >>> 0 : hashSeed(seed);
+  source = mulberry32(s);
+}
+
+/** Restore the default `Math.random` source. */
+function resetRandomSource() {
+  source = Math.random;
+}
+
+/**
+ * Run `fn` with a deterministic seeded source, restoring the previous source
+ * afterward even if `fn` throws. Returns `fn`'s result.
+ * @template T
+ * @param {number|string} seed
+ * @param {() => T} fn
+ * @returns {T}
+ */
+function withSeededRandom(seed, fn) {
+  const prev = source;
+  seedRandomSource(seed);
+  try {
+    return fn();
+  } finally {
+    source = prev;
+  }
+}
+
+export { nextRandom, seedRandomSource, resetRandomSource, withSeededRandom, hashSeed };

package/src/api/cyberia-instance/cyberia-world-generator.js

@@ -23,6 +23,7 @@ import {
 } from '../cyberia-server-defaults/cyberia-server-defaults.js';
 
 import { DefaultCyberiaItems, ITEM_TYPES } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
+import { nextRandom } from './cyberia-random-source.js';
 
 import { PORTAL_MODES, PORTAL_MODE_COLOR_KEY, EXTRA_PORTAL_MODES } from './cyberia-portal-connector.js';
 
@@ -51,7 +52,7 @@ const findColor = (colors, key) => colors.find((c) => c.key === key);
  * @param {number} max
  * @returns {number}
  */
-const randInt = (min, max) => min + Math.floor(Math.random() * (max - min + 1));
+const randInt = (min, max) => min + Math.floor(nextRandom() * (max - min + 1));
 
 // ── Entity count ranges ──────────────────────────────────────────────────────
 // [min, max] — actual count is random within range on each generation call.
@@ -438,7 +439,7 @@ function generatePortalEntities(mapDims, colors, opts = {}) {
     // First portal is always inter-portal (reserved for the ring topology);
     // extra portals get a random non-ring subtype.
     const subtype =
-      i === 0 ? PORTAL_MODES.INTER_PORTAL : EXTRA_PORTAL_MODES[Math.floor(Math.random() * EXTRA_PORTAL_MODES.length)];
+      i === 0 ? PORTAL_MODES.INTER_PORTAL : EXTRA_PORTAL_MODES[Math.floor(nextRandom() * EXTRA_PORTAL_MODES.length)];
     const portal = generatePortalEntity(mapDims, colors, opts.grid, subtype);
     if (portal) entities.push(portal);
   }
@@ -484,7 +485,7 @@ function generateBots(mapDims, colors, opts = {}) {
 
     // const skin = BOT_SKIN_POOL[Math.floor(Math.random() * BOT_SKIN_POOL.length)];
     const skin = 'kishins';
-    const hasWeapon = Math.random() < BOT_WEAPON_CHANCE;
+    const hasWeapon = nextRandom() < BOT_WEAPON_CHANCE;
     const itemIds = hasWeapon ? [skin, 'atlas_pistol_mk2'] : [skin];
 
     entities.push({

package/src/api/cyberia-server-defaults/cyberia-server-defaults.js

@@ -591,6 +591,76 @@ export const DefaultCyberiaActions = [
     dialogCode: 'default-agent',
     questDialogueCodes: [{ questCode: 'bounty-quest-alpha', dialogCode: 'quest-talk-agent' }],
   },
+  {
+    // Shop capability: an action carrying shopItems is a vendor. The client
+    // surfaces a Shop tab for it and the simulation validates every purchase
+    // against this catalog (price item + quantity).
+    code: 'loc-fallback-map-0-18-16',
+    label: 'Punk',
+    sourceMapCode: 'fallback-map-0',
+    sourceCellX: 18,
+    sourceCellY: 16,
+    dialogCode: 'default-punk',
+    shopItems: [{ itemId: 'tim-knife', priceItemId: 'coin', priceQty: 10 }],
+  },
+  {
+    // Assembler capability: an action carrying craftRecipes is a fabrication
+    // terminal. The client surfaces an Assembly tab for it and the simulation
+    // validates every synthesis against these recipes (ingredients → outputs).
+    // Every id here is obtainable inside the fallback world — wood from the
+    // resource nodes, coin from field drops — so the loop is playable on a
+    // fresh spawn with no seeding.
+    code: 'loc-fallback-map-0-15-16',
+    label: 'Eiri',
+    sourceMapCode: 'fallback-map-0',
+    sourceCellX: 15,
+    sourceCellY: 16,
+    dialogCode: 'default-eiri',
+    craftRecipes: [
+      {
+        outputItems: [{ itemId: 'hatchet', qty: 1 }],
+        ingredients: [
+          { itemId: 'wood-drop-1', qty: 2 },
+          { itemId: 'coin', qty: 5 },
+        ],
+        craftTimeMs: 3000,
+      },
+      {
+        outputItems: [{ itemId: 'tim-knife', qty: 1 }],
+        ingredients: [
+          { itemId: 'wood-drop-2', qty: 1 },
+          { itemId: 'wood-drop-1', qty: 1 },
+          { itemId: 'coin', qty: 10 },
+        ],
+        craftTimeMs: 5000,
+      },
+      {
+        // Multi-output: one blade breaks down into three component stacks, so
+        // the assembly UI and the arrival flights are exercised with more than
+        // a single result slot. Closes the loop with Punk's shop — buy a knife,
+        // salvage it back into parts.
+        outputItems: [
+          { itemId: 'wood-drop-1', qty: 2 },
+          { itemId: 'wood-drop-2', qty: 1 },
+          { itemId: 'coin', qty: 5 },
+        ],
+        ingredients: [{ itemId: 'tim-knife', qty: 1 }],
+        craftTimeMs: 2000,
+      },
+    ],
+  },
+  {
+    // Storage capability: an action carrying storageSlots is a personal vault.
+    // The client surfaces a Storage tab whose square grid is sized from the
+    // capacity (25 → 5x5) and the simulation owns the contents.
+    code: 'loc-fallback-map-0-12-22',
+    label: 'Kaneki',
+    sourceMapCode: 'fallback-map-0',
+    sourceCellX: 12,
+    sourceCellY: 22,
+    dialogCode: 'default-kaneki',
+    storageSlots: 25,
+  },
   {
     code: 'loc-fallback-map-0-15-22',
     label: 'Lain',
@@ -868,6 +938,9 @@ export const ENTITY_TYPE_DEFAULTS = Object.freeze([
   { entityType: ENTITY_TYPES.bot, liveItemIds: ['wason'], deadItemIds: [DEFAULT_DEAD_ITEM_ID], behavior: 'provider' },
   { entityType: ENTITY_TYPES.bot, liveItemIds: ['alex'], deadItemIds: [DEFAULT_DEAD_ITEM_ID], behavior: 'provider' },
   { entityType: ENTITY_TYPES.bot, liveItemIds: ['agent'], deadItemIds: [DEFAULT_DEAD_ITEM_ID], behavior: 'provider' },
+  { entityType: ENTITY_TYPES.bot, liveItemIds: ['punk'], deadItemIds: [DEFAULT_DEAD_ITEM_ID], behavior: 'provider' },
+  { entityType: ENTITY_TYPES.bot, liveItemIds: ['eiri'], deadItemIds: [DEFAULT_DEAD_ITEM_ID], behavior: 'provider-static' },
+  { entityType: ENTITY_TYPES.bot, liveItemIds: ['kaneki'], deadItemIds: [DEFAULT_DEAD_ITEM_ID], behavior: 'provider-static' },
   {
     entityType: ENTITY_TYPES.bot,
     liveItemIds: ['lain'],