@pixelvibing/cli 0.71.0 → 0.73.0

package/dist/pixel-vibing-cli.js

@@ -3456,6 +3456,11 @@ function numbers(args, names) {
   return read;
 }
 const mapShow = reading("map show", "Print the linked project's map outline: its revision, size, levels and the sectors they hold", "/map");
+const mapObjects = reading(
+  "map objects",
+  "Print the linked project's map's named points and areas, with their types and properties (specs/ide-map-editor/ R2.1)",
+  "/map/objects"
+);
 const mapVersions = reading(
   "map versions",
   "Print the version of each sector a level of the linked project's map holds",
@@ -4080,6 +4085,188 @@ function packSheets(items, side = SHEET_SIDE, gap = SHEET_GAP) {
     placements: placements.sort(byName$1)
   };
 }
+const TILED_MAP = "map.tiled.json";
+const TILES_IMAGE = "tiles.png";
+const BLOCKING_IMAGE = "blocking.png";
+const propertyOf = (name, value) => ({
+  name,
+  type: typeof value === "boolean" ? "bool" : typeof value === "number" ? Number.isInteger(value) ? "int" : "float" : "string",
+  value
+});
+const plainTile = (sprite) => sprite.width === TILE_SIZE && sprite.height === TILE_SIZE && sprite.animation === null && sprite.x === sprite.tile[0] * TILE_SIZE && sprite.y === sprite.tile[1] * TILE_SIZE;
+function tiledMap(input, codec2) {
+  const { width, height } = input;
+  const tileNames = [...new Set(input.sprites.filter(plainTile).map((sprite) => sprite.frame))].filter((name) => input.rasters.has(name)).sort();
+  const columns = Math.max(1, Math.ceil(Math.sqrt(tileNames.length)));
+  const rows = Math.max(1, Math.ceil(tileNames.length / columns));
+  const sheet = blank(columns * TILE_SIZE, rows * TILE_SIZE);
+  tileNames.forEach((name, index) => {
+    const raster = input.rasters.get(name);
+    const left = index % columns * TILE_SIZE;
+    const top = Math.floor(index / columns) * TILE_SIZE;
+    for (let y = 0; y < TILE_SIZE; y += 1)
+      sheet.data.set(raster.data.subarray(y * TILE_SIZE * 4, (y + 1) * TILE_SIZE * 4), ((top + y) * sheet.width + left) * 4);
+  });
+  const gidOf = new Map(tileNames.map((name, index) => [name, index + 1]));
+  const blockingGid = tileNames.length + 1;
+  const mark = blank(TILE_SIZE, TILE_SIZE);
+  for (let at = 0; at < mark.data.length; at += 4) mark.data.set([220, 40, 40, 128], at);
+  const levels = [
+    .../* @__PURE__ */ new Set([...input.sprites.map((each) => each.level), ...input.blocking.map((each) => each.level), ...input.places.map((each) => each.level)])
+  ].sort((a, b) => a - b);
+  let nextLayer = 1;
+  let nextObject = 1;
+  const layerPaths = [];
+  const groups = levels.map((level) => {
+    const group = `level-${level}`;
+    const bands = /* @__PURE__ */ new Map();
+    for (const sprite of input.sprites) {
+      if (sprite.level !== level || !plainTile(sprite) || !gidOf.has(sprite.frame)) continue;
+      const [x, y] = sprite.tile;
+      if (x < 0 || y < 0 || x >= width || y >= height) continue;
+      const stack = bands.get(sprite.layer) ?? [];
+      bands.set(sprite.layer, stack);
+      const index = y * width + x;
+      let data = stack.find((layer) => layer[index] === 0);
+      if (data === void 0) {
+        data = new Array(width * height).fill(0);
+        stack.push(data);
+      }
+      data[index] = gidOf.get(sprite.frame);
+    }
+    const tileLayers = [...bands].flatMap(
+      ([band, stack]) => stack.map((data, index) => {
+        const name = index === 0 ? band : `${band}-${index + 1}`;
+        layerPaths.push(`${group}/${name}`);
+        return { id: nextLayer++, name, type: "tilelayer", x: 0, y: 0, width, height, opacity: 1, visible: true, data };
+      })
+    );
+    const blocking = new Array(width * height).fill(0);
+    for (const cell of input.blocking)
+      if (cell.level === level && cell.x >= 0 && cell.y >= 0 && cell.x < width && cell.y < height) blocking[cell.y * width + cell.x] = blockingGid;
+    layerPaths.push(`${group}/blocking`);
+    const objects = [
+      ...input.sprites.filter((sprite) => sprite.level === level && !plainTile(sprite)).map((sprite) => ({
+        id: nextObject++,
+        name: sprite.frame,
+        type: "sprite",
+        x: sprite.x,
+        y: sprite.y,
+        width: 0,
+        height: 0,
+        rotation: 0,
+        visible: true,
+        point: true,
+        properties: [
+          propertyOf("frame", sprite.frame),
+          ...sprite.animation === null ? [] : [propertyOf("animation", sprite.animation)],
+          propertyOf("width", sprite.width),
+          propertyOf("height", sprite.height),
+          propertyOf("band", sprite.layer)
+        ]
+      })),
+      ...input.places.filter((place) => place.level === level).map((place) => ({
+        id: nextObject++,
+        name: place.name,
+        type: place.type,
+        x: place.x,
+        y: place.y,
+        width: place.kind === "area" ? place.width : 0,
+        height: place.kind === "area" ? place.height : 0,
+        rotation: 0,
+        visible: true,
+        ...place.kind === "point" ? { point: true } : {},
+        properties: Object.entries(place.properties).map(([name, value]) => propertyOf(name, value))
+      }))
+    ];
+    layerPaths.push(`${group}/objects`);
+    return {
+      id: nextLayer++,
+      name: group,
+      type: "group",
+      x: 0,
+      y: 0,
+      opacity: 1,
+      visible: true,
+      layers: [
+        ...tileLayers,
+        { id: nextLayer++, name: "blocking", type: "tilelayer", x: 0, y: 0, width, height, opacity: 0.5, visible: false, data: blocking },
+        { id: nextLayer++, name: "objects", type: "objectgroup", x: 0, y: 0, opacity: 1, visible: true, draworder: "topdown", objects }
+      ]
+    };
+  });
+  const map = {
+    type: "map",
+    version: "1.10",
+    tiledversion: "1.12.0",
+    orientation: "orthogonal",
+    renderorder: "right-down",
+    infinite: false,
+    compressionlevel: -1,
+    width,
+    height,
+    tilewidth: TILE_SIZE,
+    tileheight: TILE_SIZE,
+    nextlayerid: nextLayer,
+    nextobjectid: nextObject,
+    layers: groups,
+    tilesets: [
+      {
+        firstgid: 1,
+        name: "tiles",
+        image: TILES_IMAGE,
+        imagewidth: sheet.width,
+        imageheight: sheet.height,
+        tilewidth: TILE_SIZE,
+        tileheight: TILE_SIZE,
+        tilecount: tileNames.length,
+        columns,
+        margin: 0,
+        spacing: 0,
+        // Each tile's asset name, so the game and Tiled both say what a tile is.
+        tiles: tileNames.map((name, id2) => ({ id: id2, properties: [propertyOf("asset", name)] }))
+      },
+      {
+        firstgid: blockingGid,
+        name: "blocking",
+        image: BLOCKING_IMAGE,
+        imagewidth: TILE_SIZE,
+        imageheight: TILE_SIZE,
+        tilewidth: TILE_SIZE,
+        tileheight: TILE_SIZE,
+        tilecount: 1,
+        columns: 1,
+        margin: 0,
+        spacing: 0
+      }
+    ]
+  };
+  const typesOf = (kind) => [...new Set(input.places.filter((place) => place.kind === kind).map((place) => place.type))].sort();
+  return {
+    files: [
+      { path: TILED_MAP, bytes: new TextEncoder().encode(`${JSON.stringify(map, null, 2)}
+`) },
+      { path: TILES_IMAGE, bytes: codec2.encodePng(sheet) },
+      { path: BLOCKING_IMAGE, bytes: codec2.encodePng(mark) }
+    ],
+    layers: layerPaths,
+    pointTypes: typesOf("point"),
+    areaTypes: typesOf("area")
+  };
+}
+function mapNames(output) {
+  const list2 = (values) => `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+  return [
+    "// Written by PixelVibing's export with the map: the names its layers, points and areas have.",
+    `export const MAP_LAYERS = ${list2(output.layers)} as const;`,
+    "export type MapLayer = (typeof MAP_LAYERS)[number];",
+    `export const POINT_TYPES = ${list2(output.pointTypes)} as const;`,
+    "export type PointType = (typeof POINT_TYPES)[number];",
+    `export const AREA_TYPES = ${list2(output.areaTypes)} as const;`,
+    "export type AreaType = (typeof AREA_TYPES)[number];",
+    ""
+  ].join("\n");
+}
 const ENGINES = ["default", "pixi", "phaser", "godot"];
 const EXPORT_FORMAT = 1;
 const DEFAULT_GODOT_ROOT = "res://pixelvibing/";
@@ -4302,10 +4489,27 @@ function phaserFiles(made) {
   return [
     json("atlas.json", atlas),
     json("animations.json", anims),
+    // The placed sprites, for a game written before the Tiled map (specs/ide-map-editor/ R3.5).
     json("map.json", defaultMap(made)),
-    ...made.nineGrids.size === 0 ? [] : [json("nine-slices.json", { format: EXPORT_FORMAT, atlas: PHASER_ATLAS_KEY, frames: nineSlices })]
+    ...made.nineGrids.size === 0 ? [] : [json("nine-slices.json", { format: EXPORT_FORMAT, atlas: PHASER_ATLAS_KEY, frames: nineSlices })],
+    ...tiledFiles(made)
   ];
 }
+function tiledFiles(made) {
+  if (made.map === null) return [];
+  const output = tiledMap(
+    {
+      width: made.map.width,
+      height: made.map.height,
+      sprites: made.sprites,
+      blocking: made.map.tiles.filter((tile) => tile.blocking !== 0).map((tile) => ({ x: tile.x, y: tile.y, level: tile.z })),
+      rasters: made.rasters,
+      places: made.places
+    },
+    made.codec
+  );
+  return [...output.files, text("map-names.ts", mapNames(output))];
+}
 const godotString = (value) => JSON.stringify(value);
 const number = (value) => Number.isInteger(value) ? `${value}` : `${Number(value.toFixed(6))}`;
 const rect = (placed) => `Rect2(${placed.x}, ${placed.y}, ${placed.width}, ${placed.height})`;
@@ -4457,7 +4661,7 @@ function exportProject(input, engine, codec2, options = {}) {
   const animations = animationsOf(metadata, rasters, omitted);
   const sprites = placedSprites(input, metadata, rasters, omitted);
   const sheets = sheetsOf(rasters, codec2);
-  const made = { sheets, animations, sprites, map: input.map, nineGrids: nineGridsOf(metadata, rasters) };
+  const made = { sheets, animations, sprites, map: input.map, nineGrids: nineGridsOf(metadata, rasters), rasters, places: input.places ?? [], codec: codec2 };
   const godotRoot = options.godotRoot ?? DEFAULT_GODOT_ROOT;
   const described = engine === "default" ? defaultFiles(made) : engine === "pixi" ? pixiFiles(made) : engine === "phaser" ? phaserFiles(made) : godotFiles(made, godotRoot.endsWith("/") ? godotRoot : `${godotRoot}/`);
   return {
@@ -4642,7 +4846,7 @@ async function exportFolder(art, engine, options = {}) {
   try {
     const boundary = new Boundary([art]);
     const read = await readProjectArt(boundary, art);
-    const mirrored2 = await readMirroredProjectMap(boundary, art);
+    const mirrored2 = options.map ?? await readMirroredProjectMap(boundary, art);
     const mapText = mirrored2 === null ? await readProjectMap(boundary, art) : null;
     checkExportable(
       read.pictures.map((picture) => {
@@ -4662,7 +4866,8 @@ async function exportFolder(art, engine, options = {}) {
         pictures,
         entries: read.entries,
         map: mirrored2 ?? (mapText === null ? null : parseMapText(mapText, "pixelvibing/map.json").document),
-        idMap: read.idMap === null ? null : parseIdMap(JSON.parse(read.idMap))
+        idMap: read.idMap === null ? null : parseIdMap(JSON.parse(read.idMap)),
+        ...options.places === void 0 ? {} : { places: options.places }
       },
       engine,
       codec$1,
@@ -7506,7 +7711,7 @@ function terminalOf(streams) {
     step: (title, at = "step") => drawStep(streams.stderr, title, at)
   };
 }
-const version = "0.71.0";
+const version = "0.73.0";
 const manifest = {
   version
 };
@@ -7562,6 +7767,7 @@ const COMMANDS = [
   artTileset,
   artDraft,
   mapShow,
+  mapObjects,
   mapVersions,
   mapSectors,
   mapWrite,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixelvibing/cli",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "description": "PixelVibing: pixel art game assets from the command line, and the Skills that teach coding assistants to make them.",
   "license": "MIT",
   "homepage": "https://pixelvibing.com",