doom-osm-godmode 1.2.0

package/src/feature-set.js

@@ -0,0 +1,155 @@
+const path = require('node:path');
+const { readJson } = require('./lib/fs.js');
+const { closeRing, computeBounds, createProjection, polygonArea } = require('./geo.js');
+
+function inferKind(properties = {}) {
+  if (properties.kind) {
+    return properties.kind;
+  }
+
+  const tags = properties.tags || {};
+
+  if (tags.building) {
+    return 'building';
+  }
+
+  if (tags.natural === 'water' || tags.water) {
+    return 'water';
+  }
+
+  if (tags.leisure || tags.landuse) {
+    return 'park';
+  }
+
+  return 'building';
+}
+
+function extractPrimaryRing(geometry) {
+  if (!geometry) {
+    return null;
+  }
+
+  if (geometry.type === 'Polygon' && Array.isArray(geometry.coordinates?.[0])) {
+    return closeRing(geometry.coordinates[0]);
+  }
+
+  if (geometry.type === 'MultiPolygon' && Array.isArray(geometry.coordinates)) {
+    let bestRing = null;
+    let bestPointCount = 0;
+
+    for (const polygon of geometry.coordinates) {
+      const ring = closeRing(polygon?.[0]);
+      if (Array.isArray(ring) && ring.length > bestPointCount) {
+        bestRing = ring;
+        bestPointCount = ring.length;
+      }
+    }
+
+    return bestRing;
+  }
+
+  return null;
+}
+
+function collectAllCoordinates(featureCollection) {
+  const coordinates = [];
+
+  for (const feature of featureCollection.features || []) {
+    const ring = extractPrimaryRing(feature.geometry);
+    if (!ring) {
+      continue;
+    }
+
+    for (const [lon, lat] of ring) {
+      coordinates.push({ lon: Number(lon), lat: Number(lat) });
+    }
+  }
+
+  return coordinates;
+}
+
+function resolveCenter(featureCollection) {
+  const coordinates = collectAllCoordinates(featureCollection);
+  if (coordinates.length === 0) {
+    throw new Error('No polygon features found.');
+  }
+
+  const lons = coordinates.map((point) => point.lon);
+  const lats = coordinates.map((point) => point.lat);
+
+  return {
+    lon: (Math.min(...lons) + Math.max(...lons)) / 2,
+    lat: (Math.min(...lats) + Math.max(...lats)) / 2
+  };
+}
+
+function formatFeatureName(feature, index) {
+  const candidate = feature.properties?.name;
+  if (candidate && String(candidate).trim().length > 0) {
+    return String(candidate).trim();
+  }
+  return `${inferKind(feature.properties)}-${index + 1}`;
+}
+
+function prepareFeatureSet(featureCollection, options = {}) {
+  const maxRooms = Number.isFinite(options.maxRooms) ? options.maxRooms : 12;
+  const center = resolveCenter(featureCollection);
+  const projection = createProjection(center.lat, center.lon);
+
+  const features = [];
+
+  for (const [index, feature] of (featureCollection.features || []).entries()) {
+    const ring = extractPrimaryRing(feature.geometry);
+    if (!ring || ring.length < 4) {
+      continue;
+    }
+
+    const projectedRing = ring.map(([lon, lat]) => projection.project(Number(lon), Number(lat)));
+    const area = Math.abs(polygonArea(projectedRing));
+
+    if (area < 40) {
+      continue;
+    }
+
+    const bounds = computeBounds(projectedRing);
+    features.push({
+      id: feature.properties?.id || `feature-${index + 1}`,
+      name: formatFeatureName(feature, index),
+      kind: inferKind(feature.properties),
+      sourceProperties: feature.properties || {},
+      sourceRing: ring,
+      projectedRing,
+      areaMeters: area,
+      boundsMeters: bounds,
+      centroid: {
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2
+      }
+    });
+  }
+
+  features.sort((left, right) => right.areaMeters - left.areaMeters);
+
+  return {
+    title: options.title || 'Imported Site',
+    center,
+    featureCount: features.length,
+    features: features.slice(0, maxRooms)
+  };
+}
+
+async function loadFeatureCollectionFromFile(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const value = await readJson(absolutePath);
+
+  if (value.type !== 'FeatureCollection' || !Array.isArray(value.features)) {
+    throw new Error(`Unsupported GeoJSON in ${absolutePath}.`);
+  }
+
+  return value;
+}
+
+module.exports = {
+  loadFeatureCollectionFromFile,
+  prepareFeatureSet
+};

package/src/geo.js

@@ -0,0 +1,98 @@
+const EARTH_RADIUS_METERS = 6378137;
+
+function toRadians(value) {
+  return (value * Math.PI) / 180;
+}
+
+function toDegrees(value) {
+  return (value * 180) / Math.PI;
+}
+
+function bboxFromNominatimResult(result) {
+  if (!Array.isArray(result.boundingbox) || result.boundingbox.length !== 4) {
+    throw new Error('Nominatim result is missing boundingbox.');
+  }
+
+  return {
+    south: Number(result.boundingbox[0]),
+    north: Number(result.boundingbox[1]),
+    west: Number(result.boundingbox[2]),
+    east: Number(result.boundingbox[3])
+  };
+}
+
+function bboxAroundPoint(lat, lon, radiusMeters) {
+  const deltaLat = radiusMeters / EARTH_RADIUS_METERS;
+  const deltaLon = radiusMeters / (EARTH_RADIUS_METERS * Math.cos(toRadians(lat)));
+
+  return {
+    south: lat - toDegrees(deltaLat),
+    north: lat + toDegrees(deltaLat),
+    west: lon - toDegrees(deltaLon),
+    east: lon + toDegrees(deltaLon)
+  };
+}
+
+function createProjection(centerLat, centerLon, scale = 1) {
+  const lat0 = toRadians(centerLat);
+  const lon0 = toRadians(centerLon);
+
+  return {
+    project(lon, lat) {
+      const x = (toRadians(lon) - lon0) * Math.cos(lat0) * EARTH_RADIUS_METERS * scale;
+      const y = (toRadians(lat) - lat0) * EARTH_RADIUS_METERS * scale;
+      return { x, y };
+    }
+  };
+}
+
+function computeBounds(points) {
+  const xs = points.map((point) => point.x);
+  const ys = points.map((point) => point.y);
+  return {
+    minX: Math.min(...xs),
+    maxX: Math.max(...xs),
+    minY: Math.min(...ys),
+    maxY: Math.max(...ys),
+    width: Math.max(...xs) - Math.min(...xs),
+    height: Math.max(...ys) - Math.min(...ys)
+  };
+}
+
+function polygonArea(points) {
+  let area = 0;
+
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const current = points[index];
+    const next = points[index + 1];
+    area += current.x * next.y;
+    area -= next.x * current.y;
+  }
+
+  return area / 2;
+}
+
+function closeRing(ring) {
+  if (!Array.isArray(ring) || ring.length < 3) {
+    return ring;
+  }
+
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+
+  if (first[0] === last[0] && first[1] === last[1]) {
+    return ring;
+  }
+
+  return [...ring, first];
+}
+
+module.exports = {
+  bboxAroundPoint,
+  bboxFromNominatimResult,
+  closeRing,
+  computeBounds,
+  createProjection,
+  polygonArea
+};
+

package/src/geocode.js

@@ -0,0 +1,26 @@
+const NOMINATIM_URL = 'https://nominatim.openstreetmap.org/search';
+const USER_AGENT = 'doom-osm-wad/0.1.0';
+
+async function searchPlace(query, limit = 5) {
+  const url = new URL(NOMINATIM_URL);
+  url.searchParams.set('format', 'jsonv2');
+  url.searchParams.set('limit', String(limit));
+  url.searchParams.set('q', query);
+
+  const response = await fetch(url, {
+    headers: {
+      'user-agent': USER_AGENT
+    }
+  });
+
+  if (!response.ok) {
+    throw new Error(`Nominatim search failed with ${response.status}.`);
+  }
+
+  return response.json();
+}
+
+module.exports = {
+  searchPlace
+};
+

package/src/layout.js

@@ -0,0 +1,233 @@
+const CELL_SIZE = 128;
+const ROOM_GAP_CELLS = 4;
+const OUTER_PADDING_CELLS = 2;
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+function themeForKind(kind) {
+  if (kind === 'water') {
+    return {
+      floorHeight: -24,
+      ceilingHeight: 144,
+      floorTexture: 'NUKAGE1',
+      ceilingTexture: 'CEIL3_5',
+      wallTexture: 'STONE2',
+      lightLevel: 144
+    };
+  }
+
+  if (kind === 'park') {
+    return {
+      floorHeight: 0,
+      ceilingHeight: 192,
+      floorTexture: 'FLOOR0_3',
+      ceilingTexture: 'F_SKY1',
+      wallTexture: 'BROWN96',
+      lightLevel: 176
+    };
+  }
+
+  if (kind === 'road') {
+    return {
+      floorHeight: 0,
+      ceilingHeight: 160,
+      floorTexture: 'FLOOR4_8',
+      ceilingTexture: 'CEIL3_5',
+      wallTexture: 'STARTAN3',
+      lightLevel: 160
+    };
+  }
+
+  return {
+    floorHeight: 0,
+    ceilingHeight: 176,
+    floorTexture: 'FLOOR0_1',
+    ceilingTexture: 'CEIL5_1',
+    wallTexture: 'BIGBRIK1',
+    lightLevel: 152
+  };
+}
+
+function sizeFromFeature(feature) {
+  const widthCells = clamp(Math.round(feature.boundsMeters.width / 12) + 4, 6, 18);
+  const heightCells = clamp(Math.round(feature.boundsMeters.height / 12) + 4, 6, 18);
+
+  return {
+    widthCells,
+    heightCells
+  };
+}
+
+function markCell(cells, x, y, value) {
+  const key = `${x},${y}`;
+  if (cells.has(key)) {
+    return;
+  }
+
+  cells.set(key, {
+    x,
+    y,
+    ...value
+  });
+}
+
+function paintCorridor(cells, from, to) {
+  const width = 2;
+
+  const paintSpan = (x, y, horizontal) => {
+    if (horizontal) {
+      for (let offset = 0; offset < width; offset += 1) {
+        markCell(cells, x, y + offset, { kind: 'road', label: 'corridor' });
+      }
+      return;
+    }
+
+    for (let offset = 0; offset < width; offset += 1) {
+      markCell(cells, x + offset, y, { kind: 'road', label: 'corridor' });
+    }
+  };
+
+  const stepX = from.x <= to.x ? 1 : -1;
+  for (let x = from.x; x !== to.x; x += stepX) {
+    paintSpan(x, from.y, true);
+  }
+  paintSpan(to.x, from.y, true);
+
+  const stepY = from.y <= to.y ? 1 : -1;
+  for (let y = from.y; y !== to.y; y += stepY) {
+    paintSpan(to.x, y, false);
+  }
+  paintSpan(to.x, to.y, false);
+}
+
+function fallbackFeatureSet() {
+  return [
+    {
+      id: 'fallback-1',
+      name: 'Start Plaza',
+      kind: 'building',
+      boundsMeters: { width: 48, height: 48 }
+    }
+  ];
+}
+
+function buildRoomPlacements(features) {
+  const source = features.length > 0 ? features : fallbackFeatureSet();
+  const rooms = source.map((feature, index) => {
+    const size = sizeFromFeature(feature);
+    return {
+      id: `room-${index + 1}`,
+      featureId: feature.id,
+      featureName: feature.name,
+      kind: feature.kind,
+      widthCells: size.widthCells,
+      heightCells: size.heightCells
+    };
+  });
+
+  const columns = Math.max(1, Math.ceil(Math.sqrt(rooms.length)));
+  const rows = Math.ceil(rooms.length / columns);
+  const columnWidths = Array.from({ length: columns }, () => 0);
+  const rowHeights = Array.from({ length: rows }, () => 0);
+
+  for (const [index, room] of rooms.entries()) {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    columnWidths[column] = Math.max(columnWidths[column], room.widthCells);
+    rowHeights[row] = Math.max(rowHeights[row], room.heightCells);
+  }
+
+  const xOffsets = [];
+  const yOffsets = [];
+  let runningX = OUTER_PADDING_CELLS;
+  let runningY = OUTER_PADDING_CELLS;
+
+  for (const width of columnWidths) {
+    xOffsets.push(runningX);
+    runningX += width + ROOM_GAP_CELLS;
+  }
+
+  for (const height of rowHeights) {
+    yOffsets.push(runningY);
+    runningY += height + ROOM_GAP_CELLS;
+  }
+
+  return rooms.map((room, index) => {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const roomX = xOffsets[column] + Math.floor((columnWidths[column] - room.widthCells) / 2);
+    const roomY = yOffsets[row] + Math.floor((rowHeights[row] - room.heightCells) / 2);
+
+    return {
+      ...room,
+      row,
+      column,
+      x: roomX,
+      y: roomY,
+      center: {
+        x: roomX + Math.floor(room.widthCells / 2),
+        y: roomY + Math.floor(room.heightCells / 2)
+      }
+    };
+  });
+}
+
+function buildLayout(featureSet) {
+  const placements = buildRoomPlacements(featureSet.features);
+  const cells = new Map();
+
+  for (const room of placements) {
+    for (let x = room.x; x < room.x + room.widthCells; x += 1) {
+      for (let y = room.y; y < room.y + room.heightCells; y += 1) {
+        markCell(cells, x, y, {
+          kind: room.kind,
+          roomId: room.id,
+          label: room.featureName
+        });
+      }
+    }
+  }
+
+  for (let index = 0; index < placements.length - 1; index += 1) {
+    paintCorridor(cells, placements[index].center, placements[index + 1].center);
+  }
+
+  const cellList = Array.from(cells.values()).sort((left, right) => {
+    if (left.y !== right.y) {
+      return left.y - right.y;
+    }
+    return left.x - right.x;
+  });
+
+  const xs = cellList.map((cell) => cell.x);
+  const ys = cellList.map((cell) => cell.y);
+
+  return {
+    title: featureSet.title,
+    cellSize: CELL_SIZE,
+    gridBounds: {
+      minX: Math.min(...xs),
+      maxX: Math.max(...xs),
+      minY: Math.min(...ys),
+      maxY: Math.max(...ys)
+    },
+    rooms: placements,
+    cells: cellList.map((cell) => ({
+      ...cell,
+      theme: themeForKind(cell.kind)
+    })),
+    playerStart: placements[0]
+      ? {
+          x: placements[0].center.x,
+          y: placements[0].center.y
+        }
+      : { x: OUTER_PADDING_CELLS + 3, y: OUTER_PADDING_CELLS + 3 }
+  };
+}
+
+module.exports = {
+  buildLayout
+};
+

package/src/lib/cli.js

@@ -0,0 +1,67 @@
+function parseArgs(argv) {
+  const parsed = { _: [] };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (!token.startsWith('--')) {
+      parsed._.push(token);
+      continue;
+    }
+
+    const key = token.slice(2);
+    const next = argv[index + 1];
+
+    if (!next || next.startsWith('--')) {
+      parsed[key] = true;
+      continue;
+    }
+
+    parsed[key] = next;
+    index += 1;
+  }
+
+  return parsed;
+}
+
+function readStringFlag(args, name, fallback) {
+  const value = args[name];
+  if (typeof value === 'string' && value.length > 0) {
+    return value;
+  }
+  return fallback;
+}
+
+function readNumberFlag(args, name, fallback) {
+  const value = args[name];
+  if (value === undefined || value === true) {
+    return fallback;
+  }
+
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Flag --${name} must be numeric.`);
+  }
+
+  return parsed;
+}
+
+function printHelp() {
+  console.log(`
+doom-osm-godmode — turn real places into GZDoom WADs
+
+Commands:
+  search <query>
+  build-place <query> [--radius 450] [--map MAP01] [--max-rooms 12] [--title name] [--out output/site]
+  build-config <config.json>
+  demo [--out output/demo-site]
+`);
+}
+
+module.exports = {
+  parseArgs,
+  printHelp,
+  readStringFlag,
+  readNumberFlag
+};
+

package/src/lib/fs.js

@@ -0,0 +1,38 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function ensureDir(dirPath) {
+  await fs.mkdir(dirPath, { recursive: true });
+}
+
+async function readJson(filePath) {
+  const text = await fs.readFile(filePath, 'utf8');
+  return JSON.parse(text);
+}
+
+async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+async function writeText(filePath, text) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, text, 'utf8');
+}
+
+function slugify(value) {
+  return String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'site';
+}
+
+module.exports = {
+  ensureDir,
+  readJson,
+  writeJson,
+  writeText,
+  slugify
+};
+