@underpostnet/cyberia 3.3.73 → 3.3.77

package/src/client/components/cyberia/MapEngineCyberia.js

@@ -13,8 +13,8 @@ import { FileService } from '../../services/file/file.service.js';
 import { DefaultManagement } from '../../services/default/default.management.js';
 import { getApiBaseUrl } from '../../services/core/core.service.js';
 import { ObjectLayerService } from '../../services/object-layer/object-layer.service.js';
-import { getProxyPath } from '../core/Router.js';
-import { ENTITY_TYPES, getDefaultCyberiaItemById } from './SharedDefaultsCyberia.js';
+import { getProxyPath, getQueryParams, listenQueryParamsChange, setQueryParams } from '../core/Router.js';
+import { ENTITY_TYPES, ENTITY_LEVEL_MIN, ENTITY_LEVEL_MAX, validateEntityLevel } from './SharedDefaultsCyberia.js';
 import '../core/ColorPaletteElement.js';
 
 const DEFAULT_ENTITY_TYPE = ENTITY_TYPES.floor;
@@ -29,6 +29,7 @@ const createDropdownOption = (value, onClick = () => {}, display = value, data =
 class MapEngineCyberia {
   static entities = [];
   static currentMapId = null;
+  static currentMapCode = null;
   static currentThumbnailId = null;
   static thumbnailDirty = false;
   static currentPreviewId = null;
@@ -65,6 +66,14 @@ class MapEngineCyberia {
       : [];
   }
 
+  /** Comma-separated ItemIds as typed, in order, blanks removed. Duplicates are the caller's to judge. */
+  static parseItemIdList(value = '') {
+    return String(value)
+      .split(',')
+      .map((itemId) => itemId.trim())
+      .filter((itemId) => itemId);
+  }
+
   static getRenameObjectLayerItemIds() {
     return {
       source: s(`.${MapEngineCyberia.renameSourceObjectLayerInputId}`)?.value?.trim() || '',
@@ -72,6 +81,47 @@ class MapEngineCyberia {
     };
   }
 
+  /**
+   * source ItemId → the ItemIds that replace it, or the reason the lists cannot be paired.
+   *
+   * Three shapes, each unambiguous on its own:
+   *   - one source, many targets — the source expands into all of them, so a layer can be split
+   *     into a skin plus a weapon in one pass;
+   *   - one target, many sources — every source collapses onto it;
+   *   - equal counts — paired off in the order they were typed.
+   * Any other combination is a typo worth refusing: pairing a short list by position would
+   * rewrite some entities and silently leave the rest.
+   *
+   * @returns {{map?: Map<string,string[]>, error?: string}}
+   */
+  static buildRenameItemIdMap() {
+    const { source, target } = MapEngineCyberia.getRenameObjectLayerItemIds();
+    const sources = MapEngineCyberia.parseItemIdList(source);
+    const targets = MapEngineCyberia.parseItemIdList(target);
+    if (!sources.length || !targets.length) return { error: 'Source and target ItemId are required.' };
+
+    const repeated = sources.filter((itemId, index) => sources.indexOf(itemId) !== index);
+    if (repeated.length) {
+      return { error: `Each source ItemId may appear once: "${[...new Set(repeated)].join('", "')}" is repeated.` };
+    }
+    if (sources.length > 1 && targets.length > 1 && targets.length !== sources.length) {
+      return {
+        error: `${sources.length} sources take one target for all of them, or ${sources.length} paired in order — got ${targets.length}. A list of targets replaces a single source.`,
+      };
+    }
+
+    const replacement = (index) =>
+      sources.length === 1 || targets.length === 1 ? [...new Set(targets)] : [targets[index]];
+    const map = new Map(sources.map((itemId, index) => [itemId, replacement(index)]));
+    // A source that expands into a list containing itself is keeping its layer and gaining
+    // others, which is the point. Only a replacement that is the source alone does nothing.
+    const unchanged = [...map].filter(([from, to]) => to.length === 1 && to[0] === from).map(([from]) => from);
+    if (unchanged.length) {
+      return { error: `Source and target ItemId must differ: "${unchanged.join('", "')}".` };
+    }
+    return { map };
+  }
+
   static setDropdownValue(dropdownId, value) {
     if (!value || !DropDown.Tokens[dropdownId]) return;
     DropDown.Tokens[dropdownId].value = value;
@@ -111,8 +161,8 @@ class MapEngineCyberia {
       excludeSelected: true,
       serviceProvider: async (q) => {
         const result = await ObjectLayerService.searchItemIds({ q });
-        if (result.status === 'success' && result.data?.itemIds) {
-          return result.data.itemIds.map((itemId) => createDropdownOption(itemId));
+        if (result.status === 'success' && result.data?.items) {
+          return result.data.items.map(({ id }) => createDropdownOption(id));
         }
         return [];
       },
@@ -128,22 +178,12 @@ class MapEngineCyberia {
   }
 
   static renameFilteredObjectLayerItemId() {
-    const { source, target } = MapEngineCyberia.getRenameObjectLayerItemIds();
-    if (!source || !target) {
-      NotificationManager.Push({
-        html: 'Source and target ItemId are required.',
-        status: 'error',
-      });
-      return false;
-    }
-
-    if (source === target) {
-      NotificationManager.Push({
-        html: 'Source and target ItemId must be different.',
-        status: 'error',
-      });
+    const { map: renames, error } = MapEngineCyberia.buildRenameItemIdMap();
+    if (error) {
+      NotificationManager.Push({ html: error, status: 'error' });
       return false;
     }
+    const sourceList = [...renames.keys()].join('", "');
 
     const filtered = MapEngineCyberia.getFilteredEntities();
     if (!filtered.length) {
@@ -154,18 +194,19 @@ class MapEngineCyberia {
       return false;
     }
 
-    // Collect indices of filtered entities that have the source itemId
+    // Exact ItemId equality, never a prefix or a case fold: this rewrites map documents, and a
+    // near-miss would rename an entity nobody asked about.
     const eligible = [];
     for (const { i } of filtered) {
       const entity = MapEngineCyberia.entities[i];
-      if (Array.isArray(entity?.objectLayerItemIds) && entity.objectLayerItemIds.includes(source)) {
+      if (Array.isArray(entity?.objectLayerItemIds) && entity.objectLayerItemIds.some((id) => renames.has(id))) {
         eligible.push(i);
       }
     }
 
     if (!eligible.length) {
       NotificationManager.Push({
-        html: `No exact ItemId matches for "${source}" were found in the current filtered entities.`,
+        html: `No exact ItemId matches for "${sourceList}" were found in the current filtered entities.`,
         status: 'error',
       });
       return false;
@@ -175,6 +216,8 @@ class MapEngineCyberia {
     // a random probability check in [fMin, fMax]. If the roll passes, it gets renamed;
     // otherwise it stays unchanged. This produces an intermediate intensity between
     // "almost everyone" (factors near/above 1.0) and "almost no one" (factors near 0).
+    // The roll is per entity, not per ItemId: an entity carrying several sources takes all of
+    // its renames or none, so a partly-renamed loadout is never produced.
     let matchedEntities = 0;
     let renamedReferences = 0;
     const changed = MapEngineCyberia.commitEntityMutation(() => {
@@ -191,20 +234,28 @@ class MapEngineCyberia {
           if (roll < 1.0 && Math.random() > roll) continue;
         }
         const entity = MapEngineCyberia.entities[i];
-        let entityChanged = false;
-        entity.objectLayerItemIds = entity.objectLayerItemIds.map((itemId) => {
-          if (itemId !== source) return itemId;
-          entityChanged = true;
-          renamedReferences += 1;
-          return target;
+        const previous = entity.objectLayerItemIds;
+        let replaced = 0;
+        const expanded = previous.flatMap((itemId) => {
+          if (!renames.has(itemId)) return [itemId];
+          replaced += 1;
+          return renames.get(itemId);
         });
-        if (entityChanged) matchedEntities += 1;
+        // A replacement the entity already carries must not be added twice: an ItemId appearing
+        // once is what every reader of a loadout assumes.
+        const next = [...new Set(expanded)];
+        if (next.length === previous.length && next.every((itemId, index) => itemId === previous[index])) continue;
+        entity.objectLayerItemIds = next;
+        renamedReferences += replaced;
+        matchedEntities += 1;
       }
     });
 
     if (!changed) {
       NotificationManager.Push({
-        html: `No exact ItemId matches for "${source}" were found in the current filtered entities.`,
+        html: MapEngineCyberia.enableRandomFactors
+          ? `Random factors skipped all ${eligible.length} matching entit${eligible.length === 1 ? 'y' : 'ies'} — raise the factors or turn them off.`
+          : `All ${eligible.length} entit${eligible.length === 1 ? 'y' : 'ies'} matching "${sourceList}" already carry the target ItemIds.`,
         status: 'error',
       });
       return false;
@@ -374,16 +425,24 @@ class MapEngineCyberia {
       filterType: s('.map-engine-filter-entity-type')?.value?.trim().toLowerCase() || '',
       filterX: s('.map-engine-filter-init-x')?.value?.trim() || '',
       filterY: s('.map-engine-filter-init-y')?.value?.trim() || '',
+      filterItemIds: MapEngineCyberia.parseItemIdList(s('.map-engine-filter-object-layer-item-ids')?.value || ''),
     };
   }
 
   static getFilteredEntities() {
-    const { filterType, filterX, filterY } = MapEngineCyberia.getEntityFilters();
+    const { filterType, filterX, filterY, filterItemIds } = MapEngineCyberia.getEntityFilters();
 
     return MapEngineCyberia.entities.reduce((acc, entity, i) => {
       if (filterType && !(entity.entityType || '').toLowerCase().includes(filterType)) return acc;
       if (filterX !== '' && String(entity.initCellX) !== filterX) return acc;
       if (filterY !== '' && String(entity.initCellY) !== filterY) return acc;
+      // Every listed id, matched exactly: the list narrows the selection like the other filters,
+      // so naming a second id picks out the entities carrying that combination rather than
+      // widening the set. What this selects is exactly what the rename will act on.
+      if (filterItemIds.length) {
+        const carried = entity.objectLayerItemIds || [];
+        if (!filterItemIds.every((itemId) => carried.includes(itemId))) return acc;
+      }
       acc.push({ entity, i });
       return acc;
     }, []);
@@ -393,41 +452,16 @@ class MapEngineCyberia {
     if (MapEngineCyberia.imageCache[itemId]) return;
     MapEngineCyberia.imageCache[itemId] = { img: null, loaded: false, error: false };
 
-    const loadImage = (type, id) => {
-      const img = new Image();
-      img.onload = () => {
-        MapEngineCyberia.imageCache[itemId].img = img;
-        MapEngineCyberia.imageCache[itemId].loaded = true;
-        if (onLoad) onLoad();
-      };
-      img.onerror = () => {
-        MapEngineCyberia.imageCache[itemId].error = true;
-      };
-      img.src = `${getProxyPath()}assets/${type}/${id}/08/0.png`;
+    const img = new Image();
+    img.onload = () => {
+      MapEngineCyberia.imageCache[itemId].img = img;
+      MapEngineCyberia.imageCache[itemId].loaded = true;
+      if (onLoad) onLoad();
     };
-
-    const sharedItem = getDefaultCyberiaItemById(itemId)?.item;
-    if (sharedItem?.type && sharedItem?.id) {
-      loadImage(sharedItem.type, sharedItem.id);
-      return;
-    }
-
-    ObjectLayerService.get({
-      limit: 1,
-      filterModel: { 'data.item.id': { filterType: 'text', type: 'equals', filter: itemId } },
-    })
-      .then((res) => {
-        const doc = res?.data?.data?.[0];
-        if (!doc || !doc.data?.item?.type || !doc.data?.item?.id) {
-          MapEngineCyberia.imageCache[itemId].error = true;
-          return;
-        }
-        const { type, id } = doc.data.item;
-        loadImage(type, id);
-      })
-      .catch(() => {
-        MapEngineCyberia.imageCache[itemId].error = true;
-      });
+    img.onerror = () => {
+      MapEngineCyberia.imageCache[itemId].error = true;
+    };
+    img.src = `${getProxyPath()}api/atlas-sprite-sheet/idle-preview/${itemId}`;
   }
 
   static renderGrid(canvas, cols, rows, cellW, cellH, showGrid = true) {
@@ -578,6 +612,7 @@ class MapEngineCyberia {
         if (s('.map-engine-init-cell-x')) s('.map-engine-init-cell-x').value = entity.initCellX || 0;
         if (s('.map-engine-init-cell-y')) s('.map-engine-init-cell-y').value = entity.initCellY || 0;
         if (s('.map-engine-dim-x')) s('.map-engine-dim-x').value = entity.dimX || 1;
+        if (s('.map-engine-level')) s('.map-engine-level').value = entity.level ?? '';
         if (s('.map-engine-dim-y')) s('.map-engine-dim-y').value = entity.dimY || 1;
 
         // Parse rgba color back to hex + alpha
@@ -619,6 +654,7 @@ class MapEngineCyberia {
     const canvasId = 'map-engine-canvas';
 
     const idEntityType = MapEngineCyberia.entityTypeDropdownId;
+    const idLevel = 'map-engine-level';
     const idInitCellX = 'map-engine-init-cell-x';
     const idInitCellY = 'map-engine-init-cell-y';
     const idDimX = 'map-engine-dim-x';
@@ -639,6 +675,7 @@ class MapEngineCyberia {
 
     MapEngineCyberia.setEntities([], { clearHistory: true });
     MapEngineCyberia.currentMapId = null;
+    MapEngineCyberia.currentMapCode = null;
     MapEngineCyberia.currentThumbnailId = null;
     MapEngineCyberia.currentPreviewId = null;
 
@@ -704,7 +741,16 @@ class MapEngineCyberia {
     const getEntityParams = () => {
       const hex = s(`.${idColor}`)?.value || '#ff0000';
       const alpha = parseFloat(s(`.${idAlpha}`)?.value);
+      const rawLevel = s(`.${idLevel}`)?.value.trim();
+      let level;
+      try {
+        if (rawLevel) level = validateEntityLevel(Number(rawLevel));
+      } catch (error) {
+        NotificationManager.Push({ html: error.message, status: 'error' });
+        return null;
+      }
       return {
+        level,
         entityType: MapEngineCyberia.getSelectedEntityType(),
         initCellX: parseInt(s(`.${idInitCellX}`)?.value) || 0,
         initCellY: parseInt(s(`.${idInitCellY}`)?.value) || 0,
@@ -724,6 +770,7 @@ class MapEngineCyberia {
 
     const addEntityLocally = () => {
       const ep = getEntityParams();
+      if (!ep) return;
       ep.objectLayerItemIds = DropDown.Tokens[idObjLayerDropdown]?.value
         ? [...DropDown.Tokens[idObjLayerDropdown].value]
         : [];
@@ -735,6 +782,7 @@ class MapEngineCyberia {
 
     const fillMapWithEntity = () => {
       const ep = getEntityParams();
+      if (!ep) return;
       ep.objectLayerItemIds = DropDown.Tokens[idObjLayerDropdown]?.value
         ? [...DropDown.Tokens[idObjLayerDropdown].value]
         : [];
@@ -813,6 +861,7 @@ class MapEngineCyberia {
       const selectedCount = getAffectedEntityCount(preserveIndices.length);
       const selected = [...preserveIndices].sort(() => Math.random() - 0.5).slice(0, selectedCount);
       const template = getEntityParams();
+      if (!template) return;
       template.objectLayerItemIds = DropDown.Tokens[idObjLayerDropdown]?.value
         ? [...DropDown.Tokens[idObjLayerDropdown].value]
         : [];
@@ -823,6 +872,7 @@ class MapEngineCyberia {
           const replacement = {
             ...target,
             entityType: template.entityType,
+            level: template.level,
             dimX: template.dimX,
             dimY: template.dimY,
             color: template.color,
@@ -964,6 +1014,9 @@ class MapEngineCyberia {
       });
       if (result.status === 'success') {
         if (result.data?._id) MapEngineCyberia.currentMapId = result.data._id;
+        // A saved map becomes the one the URL points at.
+        MapEngineCyberia.currentMapCode = body.code || null;
+        setQueryParams({ mapCode: body.code || null }, { replace: true });
         renderPreviewImage();
         await DefaultManagement.loadTable(managementId, { force: true, reload: true });
       }
@@ -1008,6 +1061,8 @@ class MapEngineCyberia {
       });
       if (result.status === 'success') {
         if (result.data?._id) MapEngineCyberia.currentMapId = result.data._id;
+        MapEngineCyberia.currentMapCode = body.code || null;
+        setQueryParams({ mapCode: body.code || null }, { replace: true });
         if (cloneThumbnailId) MapEngineCyberia.currentThumbnailId = cloneThumbnailId;
         if (clonePreviewId) MapEngineCyberia.currentPreviewId = clonePreviewId;
         renderPreviewImage();
@@ -1017,6 +1072,8 @@ class MapEngineCyberia {
 
     const loadMap = async (mapData) => {
       MapEngineCyberia.currentMapId = mapData._id || null;
+      MapEngineCyberia.currentMapCode = mapData.code || null;
+      setQueryParams({ mapCode: mapData.code || null }, { replace: true });
       if (s(`.${idCode}`)) s(`.${idCode}`).value = mapData.code || '';
       if (s(`.${idName}`)) s(`.${idName}`).value = mapData.name || '';
       if (s(`.${idDescription}`)) s(`.${idDescription}`).value = mapData.description || '';
@@ -1089,6 +1146,7 @@ class MapEngineCyberia {
 
       const nextEntities = (mapData.entities || []).map((e) => ({
         entityType: e.entityType,
+        level: e.level,
         initCellX: e.initCellX,
         initCellY: e.initCellY,
         dimX: e.dimX,
@@ -1103,6 +1161,8 @@ class MapEngineCyberia {
 
     const resetForm = () => {
       MapEngineCyberia.currentMapId = null;
+      MapEngineCyberia.currentMapCode = null;
+      setQueryParams({ mapCode: null }, { replace: true });
       MapEngineCyberia.currentThumbnailId = null;
       MapEngineCyberia.currentPreviewId = null;
       MapEngineCyberia.thumbnailDirty = false;
@@ -1127,6 +1187,7 @@ class MapEngineCyberia {
       if (s(`.${idY}`)) s(`.${idY}`).value = 16;
       if (s(`.${idCellW}`)) s(`.${idCellW}`).value = 32;
       if (s(`.${idCellH}`)) s(`.${idCellH}`).value = 32;
+      if (s(`.${idLevel}`)) s(`.${idLevel}`).value = '';
       if (s(`.${idVariationPreserve}`)) s(`.${idVariationPreserve}`).value = '';
       if (s(`.${idRenameSourceObjectLayer}`)) s(`.${idRenameSourceObjectLayer}`).value = '';
       if (s(`.${idRenameTargetObjectLayer}`)) s(`.${idRenameTargetObjectLayer}`).value = '';
@@ -1140,6 +1201,28 @@ class MapEngineCyberia {
       }
     };
 
+    // ?mapCode=<code> loads that map into the form on arrival.
+    const loadMapByCode = async (code) => {
+      if (!code || code === MapEngineCyberia.currentMapCode) return;
+      const { status, data } = await CyberiaMapService.get({ id: code });
+      if (status !== 'success' || !data?._id) {
+        NotificationManager.Push({ html: `No map answers to the code "${code}"`, status: 'error' });
+        return;
+      }
+      await loadMap(data);
+      NotificationManager.Push({ html: `Map "${data.name || data.code}" loaded`, status: 'success' });
+    };
+
+    listenQueryParamsChange({
+      id: 'cyberia-map-engine-query-listener',
+      event: async (queryParams) => {
+        if (!s(`.${idCode}`)) return;
+        const code = queryParams.mapCode || null;
+        if (code) await loadMapByCode(code);
+        else if (MapEngineCyberia.currentMapCode) resetForm();
+      },
+    });
+
     setTimeout(() => {
       const canvas = s(`.${canvasId}`);
       if (!canvas) return;
@@ -1311,13 +1394,13 @@ class MapEngineCyberia {
           MapEngineCyberia.renderEntityList(entityListId);
         }, 300);
       };
-      [idFilterEntityType, idFilterInitX, idFilterInitY].forEach((cls) => {
+      [idFilterEntityType, idFilterInitX, idFilterInitY, idFilterObjectLayerItemIds].forEach((cls) => {
         if (s(`.${cls}`)) s(`.${cls}`).addEventListener('input', applyEntityFilter);
       });
 
       if (s('.btn-map-engine-clear-entity-filter'))
         s('.btn-map-engine-clear-entity-filter').onclick = () => {
-          [idFilterEntityType, idFilterInitX, idFilterInitY].forEach((cls) => {
+          [idFilterEntityType, idFilterInitX, idFilterInitY, idFilterObjectLayerItemIds].forEach((cls) => {
             if (s(`.${cls}`)) s(`.${cls}`).value = '';
           });
           MapEngineCyberia.renderEntityList(entityListId);
@@ -1330,6 +1413,9 @@ class MapEngineCyberia {
         s('.btn-map-engine-rename-filtered-object-layer-item-id').onclick = () => {
           MapEngineCyberia.renameFilteredObjectLayerItemId();
         };
+
+      // Loaded last: loadMap repaints the canvas through the history sync above.
+      loadMapByCode(getQueryParams().mapCode);
     });
 
     const statusOptions = [
@@ -1368,6 +1454,7 @@ class MapEngineCyberia {
     const idFilterEntityType = 'map-engine-filter-entity-type';
     const idFilterInitX = 'map-engine-filter-init-x';
     const idFilterInitY = 'map-engine-filter-init-y';
+    const idFilterObjectLayerItemIds = 'map-engine-filter-object-layer-item-ids';
 
     return html`<div class="in section-mp map-engine-container">
       ${dynamicCol({ containerSelector: 'map-engine-container', id: dcMapFields, type: 'search-inputs' })}
@@ -1674,6 +1761,11 @@ class MapEngineCyberia {
               value: DEFAULT_ENTITY_TYPE,
               containerClass: 'inl',
             })}
+            ${await Input.instance({
+              id: idLevel,
+              label: html`Level (empty uses instance default)`,
+              containerClass: 'inl', type: 'number', min: ENTITY_LEVEL_MIN, max: ENTITY_LEVEL_MAX, value: '',
+            })}
           </div>
           <div class="in fll ${dcEntityType}-col-b">
             ${await Input.instance({
@@ -1816,13 +1908,15 @@ class MapEngineCyberia {
         <div class="in section-mp-border" style="margin: 10px; padding: 10px;">
           <div class="in input-label">Rename Object Layer ItemId on Filtered Entities</div>
           <div class="in" style="font-size:12px;color:#888;margin-bottom:8px;">
-            Replaces only exact source ItemId matches inside entities currently visible through the filters.
+            Replaces only exact source ItemId matches inside entities currently visible through the filters. Both
+            fields take comma-separated lists: several targets expand one source into all of them, one target
+            renames every source onto it, and equal counts pair off in the order typed.
           </div>
           <div class="fl">
             <div class="in fll" style="flex:1;padding-right:5px;">
               ${await Input.instance({
                 id: idRenameSourceObjectLayer,
-                label: html`Source ItemId`,
+                label: html`Source ItemIds`,
                 containerClass: 'inl',
                 type: 'text',
                 placeholder: true,
@@ -1831,7 +1925,7 @@ class MapEngineCyberia {
             <div class="in fll" style="flex:1;padding-left:5px;">
               ${await Input.instance({
                 id: idRenameTargetObjectLayer,
-                label: html`Target ItemId`,
+                label: html`Target ItemIds`,
                 containerClass: 'inl',
                 type: 'text',
                 placeholder: true,
@@ -1923,6 +2017,18 @@ class MapEngineCyberia {
                 })}
               </div>
             </div>
+            <div class="in" style="margin-top:5px;">
+              ${await Input.instance({
+                id: idFilterObjectLayerItemIds,
+                label: html`Object Layer ItemIds`,
+                containerClass: 'inl',
+                type: 'text',
+                placeholder: true,
+              })}
+              <div class="in" style="font-size:12px;color:#888;margin-top:3px;">
+                Comma separated, matched exactly. Keeps only entities carrying all of them.
+              </div>
+            </div>
             <div
               class="in map-engine-entity-filter-count"
               style="margin-top:5px;font-size:12px;color:#888;font-family:monospace;"