doom-osm-godmode 1.2.0

package/src/osm.js

@@ -0,0 +1,110 @@
+const { closeRing } = require('./geo.js');
+
+const USER_AGENT = 'doom-osm-wad/0.1.0';
+const OVERPASS_URL = 'https://overpass-api.de/api/interpreter';
+
+function buildOverpassQuery(bbox) {
+  const bounds = `${bbox.south},${bbox.west},${bbox.north},${bbox.east}`;
+
+  return `
+[out:json][timeout:45];
+(
+  way["building"](${bounds});
+  way["natural"="water"](${bounds});
+  way["water"](${bounds});
+  way["leisure"~"park|garden|pitch"](${bounds});
+  way["landuse"~"grass|meadow|recreation_ground|village_green"](${bounds});
+);
+out tags geom;
+`.trim();
+}
+
+function inferKind(tags = {}) {
+  if (tags.building) {
+    return 'building';
+  }
+
+  if (tags.natural === 'water' || tags.water) {
+    return 'water';
+  }
+
+  if (
+    tags.leisure === 'park' ||
+    tags.leisure === 'garden' ||
+    tags.leisure === 'pitch' ||
+    tags.landuse === 'grass' ||
+    tags.landuse === 'meadow' ||
+    tags.landuse === 'recreation_ground' ||
+    tags.landuse === 'village_green'
+  ) {
+    return 'park';
+  }
+
+  return null;
+}
+
+function overpassToFeatureCollection(payload) {
+  const features = [];
+
+  for (const element of payload.elements || []) {
+    if (element.type !== 'way' || !Array.isArray(element.geometry) || element.geometry.length < 3) {
+      continue;
+    }
+
+    const kind = inferKind(element.tags);
+    if (!kind) {
+      continue;
+    }
+
+    const ring = closeRing(
+      element.geometry.map((point) => [Number(point.lon), Number(point.lat)])
+    );
+
+    if (!Array.isArray(ring) || ring.length < 4) {
+      continue;
+    }
+
+    features.push({
+      type: 'Feature',
+      properties: {
+        id: `way/${element.id}`,
+        name: element.tags?.name || null,
+        kind,
+        tags: element.tags || {}
+      },
+      geometry: {
+        type: 'Polygon',
+        coordinates: [ring]
+      }
+    });
+  }
+
+  return {
+    type: 'FeatureCollection',
+    features
+  };
+}
+
+async function fetchFeatureCollectionForBbox(bbox) {
+  const query = buildOverpassQuery(bbox);
+  const response = await fetch(OVERPASS_URL, {
+    method: 'POST',
+    headers: {
+      'content-type': 'text/plain;charset=UTF-8',
+      'user-agent': USER_AGENT
+    },
+    body: query
+  });
+
+  if (!response.ok) {
+    throw new Error(`Overpass request failed with ${response.status}.`);
+  }
+
+  const payload = await response.json();
+  return overpassToFeatureCollection(payload);
+}
+
+module.exports = {
+  fetchFeatureCollectionForBbox
+};
+

package/src/udmf.js

@@ -0,0 +1,207 @@
+function formatValue(value) {
+  if (typeof value === 'string') {
+    return `"${value}"`;
+  }
+
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? String(value) : value.toFixed(3);
+  }
+
+  return String(value);
+}
+
+function serializeBlock(type, fields) {
+  const lines = [`${type}`, '{'];
+
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+    lines.push(`  ${key} = ${formatValue(value)};`);
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function buildTextMap(layout) {
+  const vertices = [];
+  const vertexIndexByKey = new Map();
+  const sectors = [];
+  const sidedefs = [];
+  const linedefs = [];
+  const sectorIndexByCell = new Map();
+
+  const addVertex = (x, y) => {
+    const key = `${x},${y}`;
+    if (vertexIndexByKey.has(key)) {
+      return vertexIndexByKey.get(key);
+    }
+
+    const index = vertices.length;
+    vertices.push({ x, y });
+    vertexIndexByKey.set(key, index);
+    return index;
+  };
+
+  const addSidedef = (fields) => {
+    const index = sidedefs.length;
+    sidedefs.push(fields);
+    return index;
+  };
+
+  const cellToWorld = (cell) => {
+    const x = cell.x * layout.cellSize;
+    const y = (layout.gridBounds.maxY - cell.y) * layout.cellSize;
+    return {
+      topLeft: { x, y: y + layout.cellSize },
+      topRight: { x: x + layout.cellSize, y: y + layout.cellSize },
+      bottomRight: { x: x + layout.cellSize, y },
+      bottomLeft: { x, y }
+    };
+  };
+
+  for (const cell of layout.cells) {
+    const sectorIndex = sectors.length;
+    sectors.push({
+      heightfloor: cell.theme.floorHeight,
+      heightceiling: cell.theme.ceilingHeight,
+      texturefloor: cell.theme.floorTexture,
+      textureceiling: cell.theme.ceilingTexture,
+      lightlevel: cell.theme.lightLevel
+    });
+    sectorIndexByCell.set(`${cell.x},${cell.y}`, sectorIndex);
+  }
+
+  const neighborOffsets = [
+    { dx: 0, dy: -1, edge: 'north' },
+    { dx: 1, dy: 0, edge: 'east' },
+    { dx: 0, dy: 1, edge: 'south' },
+    { dx: -1, dy: 0, edge: 'west' }
+  ];
+
+  const edgeVertices = (points, edge) => {
+    if (edge === 'north') {
+      return [points.topLeft, points.topRight];
+    }
+
+    if (edge === 'east') {
+      return [points.topRight, points.bottomRight];
+    }
+
+    if (edge === 'south') {
+      return [points.bottomRight, points.bottomLeft];
+    }
+
+    return [points.bottomLeft, points.topLeft];
+  };
+
+  for (const cell of layout.cells) {
+    const currentSector = sectorIndexByCell.get(`${cell.x},${cell.y}`);
+    const points = cellToWorld(cell);
+
+    for (const neighborOffset of neighborOffsets) {
+      const neighborKey = `${cell.x + neighborOffset.dx},${cell.y + neighborOffset.dy}`;
+      const neighborSector = sectorIndexByCell.get(neighborKey);
+
+      if (neighborSector !== undefined && currentSector > neighborSector) {
+        continue;
+      }
+
+      const [start, end] = edgeVertices(points, neighborOffset.edge);
+      const v1 = addVertex(start.x, start.y);
+      const v2 = addVertex(end.x, end.y);
+
+      if (neighborSector === undefined) {
+        const front = addSidedef({
+          sector: currentSector,
+          texturetop: '-',
+          texturebottom: '-',
+          texturemiddle: cell.theme.wallTexture
+        });
+
+        linedefs.push({
+          v1,
+          v2,
+          sidefront: front,
+          blocking: true
+        });
+        continue;
+      }
+
+      const front = addSidedef({
+        sector: currentSector,
+        texturetop: '-',
+        texturebottom: '-',
+        texturemiddle: '-'
+      });
+      const back = addSidedef({
+        sector: neighborSector,
+        texturetop: '-',
+        texturebottom: '-',
+        texturemiddle: '-'
+      });
+
+      linedefs.push({
+        v1,
+        v2,
+        sidefront: front,
+        sideback: back,
+        twosided: true
+      });
+    }
+  }
+
+  const startWorldX = (layout.playerStart.x + 0.5) * layout.cellSize;
+  const startWorldY = (layout.gridBounds.maxY - layout.playerStart.y + 0.5) * layout.cellSize;
+
+  const blocks = [
+    'namespace = "ZDoom";',
+    '',
+    ...vertices.map((vertex) => serializeBlock('vertex', vertex)),
+    '',
+    ...linedefs.map((linedef) => serializeBlock('linedef', linedef)),
+    '',
+    ...sidedefs.map((sidedef) => serializeBlock('sidedef', sidedef)),
+    '',
+    ...sectors.map((sector) => serializeBlock('sector', sector)),
+    '',
+    serializeBlock('thing', {
+      x: startWorldX,
+      y: startWorldY,
+      angle: 90,
+      type: 1,
+      skill1: true,
+      skill2: true,
+      skill3: true,
+      skill4: true,
+      skill5: true,
+      single: true,
+      cooperative: true,
+      dm: true
+    })
+  ];
+
+  return `${blocks.join('\n\n')}\n`;
+}
+
+function buildMapInfo(mapName, title) {
+  return [
+    `map ${mapName} "${title}"`,
+    '{',
+    '  sky1 = "SKY1", 0.0',
+    '  music = "$MUSIC_RUNNIN"',
+    '}',
+    ''
+  ].join('\n');
+}
+
+module.exports = {
+  buildMapInfo,
+  buildTextMap
+};
+

package/src/wad.js

@@ -0,0 +1,67 @@
+function encodeName(name) {
+  const buffer = Buffer.alloc(8);
+  buffer.write(String(name).slice(0, 8).toUpperCase(), 'ascii');
+  return buffer;
+}
+
+function createWadBuffer(options) {
+  const lumps = [
+    {
+      name: 'MAPINFO',
+      data: Buffer.from(options.mapInfo, 'utf8')
+    },
+    {
+      name: options.mapName,
+      data: Buffer.alloc(0)
+    },
+    {
+      name: 'TEXTMAP',
+      data: Buffer.from(options.textMap, 'utf8')
+    },
+    {
+      name: 'OSMJSON',
+      data: Buffer.from(options.metadataJson, 'utf8')
+    },
+    {
+      name: 'ENDMAP',
+      data: Buffer.alloc(0)
+    }
+  ];
+
+  const headerSize = 12;
+  let dataOffset = headerSize;
+  const dataBuffers = [];
+  const directoryEntries = [];
+
+  for (const lump of lumps) {
+    dataBuffers.push(lump.data);
+    directoryEntries.push({
+      filepos: dataOffset,
+      size: lump.data.length,
+      name: lump.name
+    });
+    dataOffset += lump.data.length;
+  }
+
+  const directoryOffset = dataOffset;
+  const directoryBuffer = Buffer.alloc(directoryEntries.length * 16);
+
+  directoryEntries.forEach((entry, index) => {
+    const base = index * 16;
+    directoryBuffer.writeInt32LE(entry.filepos, base);
+    directoryBuffer.writeInt32LE(entry.size, base + 4);
+    encodeName(entry.name).copy(directoryBuffer, base + 8);
+  });
+
+  const header = Buffer.alloc(headerSize);
+  header.write('PWAD', 0, 'ascii');
+  header.writeInt32LE(directoryEntries.length, 4);
+  header.writeInt32LE(directoryOffset, 8);
+
+  return Buffer.concat([header, ...dataBuffers, directoryBuffer]);
+}
+
+module.exports = {
+  createWadBuffer
+};
+

package/src/workflow.js

@@ -0,0 +1,171 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { loadFeatureCollectionFromFile, prepareFeatureSet } = require('./feature-set.js');
+const { searchPlace } = require('./geocode.js');
+const { bboxAroundPoint, bboxFromNominatimResult } = require('./geo.js');
+const { ensureDir, readJson, slugify, writeJson, writeText } = require('./lib/fs.js');
+const { buildLayout } = require('./layout.js');
+const { fetchFeatureCollectionForBbox } = require('./osm.js');
+const { buildMapInfo, buildTextMap } = require('./udmf.js');
+const { createWadBuffer } = require('./wad.js');
+
+async function buildArtifacts(featureCollection, options) {
+  const featureSet = prepareFeatureSet(featureCollection, {
+    title: options.title,
+    maxRooms: options.maxRooms
+  });
+  const layout = buildLayout(featureSet);
+  const textMap = buildTextMap(layout);
+  const mapInfo = buildMapInfo(options.mapName, options.title);
+
+  const metadata = {
+    title: options.title,
+    mapName: options.mapName,
+    source: options.source,
+    featureCount: featureSet.featureCount,
+    exportedFeatures: featureSet.features.length,
+    features: featureSet.features.map((feature) => ({
+      id: feature.id,
+      name: feature.name,
+      kind: feature.kind,
+      areaMeters: Math.round(feature.areaMeters),
+      boundsMeters: {
+        width: Number(feature.boundsMeters.width.toFixed(2)),
+        height: Number(feature.boundsMeters.height.toFixed(2))
+      }
+    }))
+  };
+
+  const wadBuffer = createWadBuffer({
+    mapName: options.mapName,
+    mapInfo,
+    textMap,
+    metadataJson: JSON.stringify(metadata, null, 2)
+  });
+
+  await ensureDir(options.outputDir);
+  await writeJson(path.join(options.outputDir, 'site.json'), {
+    ...featureSet,
+    features: featureSet.features.map((feature) => ({
+      id: feature.id,
+      name: feature.name,
+      kind: feature.kind,
+      areaMeters: Number(feature.areaMeters.toFixed(2)),
+      boundsMeters: {
+        width: Number(feature.boundsMeters.width.toFixed(2)),
+        height: Number(feature.boundsMeters.height.toFixed(2))
+      },
+      sourceProperties: feature.sourceProperties,
+      sourceRing: feature.sourceRing
+    }))
+  });
+  await writeJson(path.join(options.outputDir, 'layout.json'), layout);
+  await writeText(path.join(options.outputDir, 'TEXTMAP.udmf'), textMap);
+  await writeText(path.join(options.outputDir, 'MAPINFO.txt'), mapInfo);
+  await fs.writeFile(path.join(options.outputDir, `${options.mapName}.wad`), wadBuffer);
+
+  return {
+    outputDir: options.outputDir,
+    mapPath: path.join(options.outputDir, `${options.mapName}.wad`),
+    featureCount: featureSet.featureCount,
+    exportedFeatures: featureSet.features.length
+  };
+}
+
+async function buildFromPlace(placeQuery, options = {}) {
+  const results = await searchPlace(placeQuery, 5);
+  if (!Array.isArray(results) || results.length === 0) {
+    throw new Error(`No geocoding result for "${placeQuery}".`);
+  }
+
+  const best = results[0];
+  const radiusMeters = options.radiusMeters;
+  const bbox = radiusMeters
+    ? bboxAroundPoint(Number(best.lat), Number(best.lon), radiusMeters)
+    : bboxFromNominatimResult(best);
+
+  const featureCollection = await fetchFeatureCollectionForBbox(bbox);
+  const title = options.title || best.display_name.split(',')[0];
+  const mapName = options.mapName || 'MAP01';
+  const outputDir = options.outputDir || path.resolve('output', slugify(title));
+
+  return buildArtifacts(featureCollection, {
+    title,
+    mapName,
+    maxRooms: options.maxRooms || 12,
+    outputDir,
+    source: {
+      type: 'place-search',
+      placeQuery,
+      chosenResult: {
+        displayName: best.display_name,
+        lat: Number(best.lat),
+        lon: Number(best.lon)
+      },
+      bbox
+    }
+  });
+}
+
+async function buildFromConfig(configPath) {
+  const absoluteConfigPath = path.resolve(configPath);
+  const configDir = path.dirname(absoluteConfigPath);
+  const config = await readJson(absoluteConfigPath);
+
+  if (config.inputGeoJson) {
+    const inputPath = path.resolve(configDir, config.inputGeoJson);
+    const featureCollection = await loadFeatureCollectionFromFile(inputPath);
+    return buildArtifacts(featureCollection, {
+      title: config.title || 'Imported Site',
+      mapName: config.mapName || 'MAP01',
+      maxRooms: config.maxRooms || 12,
+      outputDir: path.resolve(configDir, config.outputDir || path.join('output', slugify(config.title || 'site'))),
+      source: {
+        type: 'geojson',
+        inputGeoJson: inputPath
+      }
+    });
+  }
+
+  if (config.placeQuery) {
+    return buildFromPlace(config.placeQuery, {
+      title: config.title,
+      mapName: config.mapName,
+      maxRooms: config.maxRooms,
+      radiusMeters: config.radiusMeters,
+      outputDir: path.resolve(configDir, config.outputDir || path.join('output', slugify(config.title || config.placeQuery)))
+    });
+  }
+
+  throw new Error(`Config ${absoluteConfigPath} must include inputGeoJson or placeQuery.`);
+}
+
+async function buildDemo(outputDir) {
+  const configPath = path.resolve(__dirname, '..', 'examples', 'demo-site.json');
+  const result = await buildFromConfig(configPath);
+
+  if (!outputDir) {
+    return result;
+  }
+
+  const targetDir = path.resolve(outputDir);
+  await ensureDir(targetDir);
+
+  const files = ['layout.json', 'MAP01.wad', 'MAPINFO.txt', 'site.json', 'TEXTMAP.udmf'];
+  for (const file of files) {
+    await fs.copyFile(path.join(result.outputDir, file), path.join(targetDir, file));
+  }
+
+  return {
+    ...result,
+    outputDir: targetDir,
+    mapPath: path.join(targetDir, 'MAP01.wad')
+  };
+}
+
+module.exports = {
+  buildDemo,
+  buildFromConfig,
+  buildFromPlace
+};
+