@dotmon/core 0.1.0

package/dist/render/index.cjs

@@ -0,0 +1,628 @@
+'use strict';
+
+// src/render/raster.ts
+function svgToCanvas(svg, size, background = "transparent") {
+  return new Promise((resolve, reject) => {
+    const sized = svg.replace("<svg ", `<svg width="${size}" height="${size}" `);
+    const img = new Image();
+    img.onload = () => {
+      const c = document.createElement("canvas");
+      c.width = size;
+      c.height = size;
+      const ctx = c.getContext("2d");
+      ctx.imageSmoothingEnabled = false;
+      if (background !== "transparent") {
+        ctx.fillStyle = background;
+        ctx.fillRect(0, 0, size, size);
+      }
+      ctx.drawImage(img, 0, 0, size, size);
+      resolve(c);
+    };
+    img.onerror = reject;
+    img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(sized);
+  });
+}
+async function toPng(svg, opts = {}) {
+  const { size = 512, background = "transparent" } = opts;
+  const c = await svgToCanvas(svg, size, background);
+  return new Promise((res) => c.toBlob((b) => res(b), "image/png"));
+}
+async function pngBytes(svg, size, background) {
+  const blob = await toPng(svg, { size, background });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+
+// src/render/gif.ts
+function lzwEncode(minCodeSize, indices) {
+  const CLEAR = 1 << minCodeSize;
+  const EOI = CLEAR + 1;
+  let dict;
+  let nextCode = 0;
+  let codeSize = 0;
+  const out = [];
+  let bitBuf = 0;
+  let bitLen = 0;
+  const emit = (code) => {
+    bitBuf |= code << bitLen;
+    bitLen += codeSize;
+    while (bitLen >= 8) {
+      out.push(bitBuf & 255);
+      bitBuf >>= 8;
+      bitLen -= 8;
+    }
+  };
+  const init = () => {
+    dict = /* @__PURE__ */ new Map();
+    for (let i = 0; i < CLEAR; i++) dict.set(String(i), i);
+    nextCode = EOI + 1;
+    codeSize = minCodeSize + 1;
+  };
+  init();
+  emit(CLEAR);
+  let prefix = String(indices[0]);
+  for (let i = 1; i < indices.length; i++) {
+    const k = indices[i];
+    const key = prefix + "," + k;
+    if (dict.has(key)) {
+      prefix = key;
+      continue;
+    }
+    emit(dict.get(prefix));
+    if (nextCode < 4096) {
+      dict.set(key, nextCode);
+      if (nextCode === 1 << codeSize && codeSize < 12) codeSize++;
+      nextCode++;
+    } else {
+      emit(CLEAR);
+      init();
+    }
+    prefix = String(k);
+  }
+  emit(dict.get(prefix));
+  emit(EOI);
+  if (bitLen > 0) out.push(bitBuf & 255);
+  return out;
+}
+function encodeGif(w, h, palette, transparentIndex, frames, delayCs) {
+  const bytes = [];
+  const put = (b) => bytes.push(b & 255);
+  const put16 = (v) => {
+    put(v);
+    put(v >> 8);
+  };
+  const putStr = (s) => {
+    for (let i = 0; i < s.length; i++) put(s.charCodeAt(i));
+  };
+  let bits = 1;
+  while (1 << bits < palette.length) bits++;
+  putStr("GIF89a");
+  put16(w);
+  put16(h);
+  put(128 | 112 | bits - 1);
+  put(0);
+  put(0);
+  for (let i = 0; i < 1 << bits; i++) {
+    const c = palette[i] || [0, 0, 0];
+    put(c[0]);
+    put(c[1]);
+    put(c[2]);
+  }
+  put(33);
+  put(255);
+  put(11);
+  putStr("NETSCAPE2.0");
+  put(3);
+  put(1);
+  put16(0);
+  put(0);
+  const minCode = Math.max(2, bits);
+  for (const indices of frames) {
+    put(33);
+    put(249);
+    put(4);
+    put(2 << 2 | (transparentIndex >= 0 ? 1 : 0));
+    put16(delayCs);
+    put(transparentIndex >= 0 ? transparentIndex : 0);
+    put(0);
+    put(44);
+    put16(0);
+    put16(0);
+    put16(w);
+    put16(h);
+    put(0);
+    put(minCode);
+    const data = lzwEncode(minCode, indices);
+    for (let i = 0; i < data.length; i += 255) {
+      const n = Math.min(255, data.length - i);
+      put(n);
+      for (let j = 0; j < n; j++) put(data[i + j]);
+    }
+    put(0);
+  }
+  put(59);
+  return new Uint8Array(bytes);
+}
+async function toGif(frames, opts = {}) {
+  const { size = 256, background = "transparent", delayMs = 400 } = opts;
+  const bytes = await gifBytes(frames[0], frames[1], size, background, Math.round(delayMs / 10));
+  return new Blob([bytes], { type: "image/gif" });
+}
+async function gifBytes(svgA, svgB, px, bg, delayCs = 40) {
+  const canvases = [await svgToCanvas(svgA, px, bg), await svgToCanvas(svgB, px, bg)];
+  const palette = [];
+  const cmap = /* @__PURE__ */ new Map();
+  let transparentIndex = -1;
+  if (bg === "transparent") {
+    transparentIndex = 0;
+    palette.push([0, 0, 0]);
+  }
+  const frames = canvases.map((c) => {
+    const d = c.getContext("2d").getImageData(0, 0, px, px).data;
+    const out = new Uint8Array(px * px);
+    for (let i = 0; i < px * px; i++) {
+      const r = d[i * 4], gr = d[i * 4 + 1], bl = d[i * 4 + 2], a = d[i * 4 + 3];
+      if (a < 128 && transparentIndex >= 0) {
+        out[i] = transparentIndex;
+        continue;
+      }
+      const key = r << 16 | gr << 8 | bl;
+      let idx = cmap.get(key);
+      if (idx === void 0) {
+        idx = palette.length;
+        palette.push([r, gr, bl]);
+        cmap.set(key, idx);
+      }
+      out[i] = idx;
+    }
+    return out;
+  });
+  return encodeGif(px, px, palette, transparentIndex, frames, delayCs);
+}
+
+// src/render/zip.ts
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c;
+  }
+  return t;
+})();
+function crc32(data) {
+  let c = 4294967295;
+  for (let i = 0; i < data.length; i++) c = CRC_TABLE[(c ^ data[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function buildZip(files) {
+  const enc = new TextEncoder();
+  const u16 = (v) => [v & 255, v >> 8 & 255];
+  const u32 = (v) => [v & 255, v >>> 8 & 255, v >>> 16 & 255, v >>> 24 & 255];
+  const now = /* @__PURE__ */ new Date();
+  const dosTime = (now.getHours() << 11 | now.getMinutes() << 5 | now.getSeconds() >> 1) & 65535;
+  const dosDate = (now.getFullYear() - 1980 << 9 | now.getMonth() + 1 << 5 | now.getDate()) & 65535;
+  const chunks = [];
+  const central = [];
+  let offset = 0;
+  for (const f of files) {
+    const name = enc.encode(f.name);
+    const crc = crc32(f.data);
+    const head = new Uint8Array([80, 75, 3, 4, ...u16(20), ...u16(2048), ...u16(0), ...u16(dosTime), ...u16(dosDate), ...u32(crc), ...u32(f.data.length), ...u32(f.data.length), ...u16(name.length), ...u16(0)]);
+    chunks.push(head, name, f.data);
+    central.push({ name, crc, size: f.data.length, offset });
+    offset += head.length + name.length + f.data.length;
+  }
+  const cd = [];
+  let cdSize = 0;
+  for (const c of central) {
+    const rec = new Uint8Array([80, 75, 1, 2, ...u16(20), ...u16(20), ...u16(2048), ...u16(0), ...u16(dosTime), ...u16(dosDate), ...u32(c.crc), ...u32(c.size), ...u32(c.size), ...u16(c.name.length), ...u16(0), ...u16(0), ...u16(0), ...u16(0), ...u32(0), ...u32(c.offset)]);
+    cd.push(rec, c.name);
+    cdSize += rec.length + c.name.length;
+  }
+  const eocd = new Uint8Array([80, 75, 5, 6, ...u16(0), ...u16(0), ...u16(files.length), ...u16(files.length), ...u32(cdSize), ...u32(offset), ...u16(0)]);
+  const parts = [...chunks, ...cd, eocd].map((p) => p instanceof Uint8Array ? p : new Uint8Array(p));
+  return new Blob(parts, { type: "application/zip" });
+}
+
+// src/hash.ts
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 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;
+  };
+}
+
+// src/presets.ts
+var presets = {
+  mochi: { connected: true, symmetric: true, outline: true, face: true, legs: "auto" },
+  retro: { connected: false, symmetric: true, outline: true, face: false, legs: "none" },
+  chaos: { connected: false, symmetric: false, outline: true, face: true, legs: "none" }
+};
+function resolveOptions(options = {}) {
+  const base = presets[options.preset ?? "mochi"];
+  return {
+    connected: options.connected ?? base.connected,
+    symmetric: options.symmetric ?? base.symmetric,
+    outline: options.outline ?? base.outline,
+    face: options.face ?? base.face,
+    legs: options.legs ?? base.legs
+  };
+}
+
+// src/generate.ts
+var SIZE = 16;
+var HALF = 8;
+function generateSvg(seed, options = {}) {
+  const o = resolveOptions(options);
+  const view = options.view ?? "front";
+  const frame = options.frame ?? 0;
+  const rand = mulberry32(fnv1a(seed));
+  const pick = (arr) => arr[Math.floor(rand() * arr.length)];
+  const g = Array.from({ length: SIZE }, () => new Array(SIZE).fill(0));
+  const hue = Math.floor(rand() * 12) * 30;
+  const sat = 55 + rand() * 25;
+  const lig = 55 + rand() * 12;
+  const top = 2 + Math.floor(rand() * 2);
+  const bottom = 12 + Math.floor(rand() * 2);
+  const height = bottom - top + 1;
+  if (o.connected) {
+    const widths = [];
+    let w = 2 + Math.floor(rand() * 2);
+    for (let i = 0; i < height; i++) {
+      const progress = i / height;
+      let step;
+      const r = rand();
+      if (progress < 0.6) step = r < 0.55 ? 1 : r < 0.85 ? 0 : -1;
+      else step = r < 0.35 ? 1 : r < 0.6 ? 0 : -1;
+      w = Math.max(1, Math.min(7, w + step));
+      widths.push(w);
+    }
+    for (let i = 1; i < height - 1; i++) {
+      if (rand() < 0.18 && widths[i] > 2) widths[i] -= 1;
+    }
+    for (let i = 0; i < height; i++) {
+      for (let x = HALF - widths[i]; x < HALF; x++) g[top + i][x] = 1;
+    }
+  } else {
+    for (let y = top; y <= bottom; y++) {
+      for (let x = 1; x < HALF; x++) {
+        if (rand() < 0.45) g[y][x] = 1;
+      }
+    }
+  }
+  for (let y = 0; y < SIZE; y++) {
+    for (let x = 0; x < HALF; x++) {
+      if (o.symmetric) {
+        g[y][SIZE - 1 - x] = g[y][x];
+      }
+    }
+  }
+  if (!o.symmetric) {
+    for (let y = top; y <= bottom; y++) {
+      for (let x = HALF; x < SIZE - 1; x++) {
+        g[y][x] = rand() < 0.45 ? 1 : 0;
+      }
+    }
+  }
+  if (o.connected && o.symmetric && rand() < 0.55) {
+    const hornStyle = pick(["stub", "long", "ear"]);
+    let topRow = top;
+    while (topRow <= bottom && !g[topRow].some((v) => v)) topRow++;
+    const xs = [];
+    for (let x = 0; x < HALF; x++) if (g[topRow][x]) xs.push(x);
+    if (xs.length) {
+      const hx = xs[0] + (xs.length > 2 ? 1 : 0);
+      const len = hornStyle === "long" ? 2 : 1;
+      for (let d = 1; d <= len; d++) {
+        if (topRow - d >= 0) {
+          const col = hornStyle === "ear" ? 1 : 5;
+          g[topRow - d][hx] = col;
+          g[topRow - d][SIZE - 1 - hx] = col;
+        }
+      }
+    }
+  }
+  if (o.face) {
+    let topRow = 0;
+    while (topRow < SIZE && !g[topRow].some((v) => v === 1)) topRow++;
+    let botRow = SIZE - 1;
+    while (botRow > 0 && !g[botRow].some((v) => v === 1)) botRow--;
+    const eyeRow = Math.min(botRow - 2, topRow + Math.max(1, Math.round((botRow - topRow) * 0.32)));
+    const cols = [];
+    for (let x = 0; x < SIZE; x++) if (g[eyeRow][x] === 1) cols.push(x);
+    if (cols.length >= 1) {
+      const side = view === "left" || view === "right";
+      const cx = (SIZE - 1) / 2;
+      const eyeStyle = pick(["dot", "wide", "sleepy"]);
+      const stamp = (x) => {
+        if (view === "back") return;
+        if (eyeStyle === "dot") {
+          g[eyeRow][x] = 4;
+        } else if (eyeStyle === "wide") {
+          g[eyeRow][x] = 3;
+          if (g[eyeRow + 1]) g[eyeRow + 1][x] = 4;
+        } else {
+          g[eyeRow][x] = 2;
+        }
+      };
+      const twoEyes = cols.length >= 4;
+      if (side) {
+        stamp(cols[Math.min(1, cols.length - 1)]);
+      } else if (twoEyes) {
+        const gap = Math.max(1, Math.min(3, Math.floor(cols.length / 3)));
+        stamp(Math.floor(cx - gap));
+        stamp(Math.ceil(cx + gap));
+      } else {
+        stamp(Math.round(cx));
+      }
+      const mRow = eyeRow + 2 + (eyeStyle === "wide" ? 1 : 0);
+      const mW = twoEyes ? pick([1, 1, 3]) : 1;
+      if (view !== "back" && mRow <= botRow) {
+        if (side) {
+          let m0 = 0;
+          while (m0 < SIZE && g[mRow][m0] !== 1) m0++;
+          for (let x = m0; x < m0 + mW && x < SIZE; x++) {
+            if (g[mRow][x] === 1) g[mRow][x] = 4;
+          }
+        } else {
+          for (let x = Math.round(cx - (mW - 1) / 2); x <= Math.round(cx + (mW - 1) / 2); x++) {
+            if (g[mRow][x] === 1) g[mRow][x] = 4;
+          }
+        }
+      }
+    }
+  }
+  const legCols = [];
+  let drawnLegStyle = null;
+  if (o.connected && o.symmetric) {
+    const rolled = pick(["none", "two", "two", "two", "many"]);
+    const legStyle = o.legs === "auto" ? rolled : o.legs;
+    if (legStyle !== "none") {
+      let botRow = SIZE - 1;
+      while (botRow > 0 && !g[botRow].some((v) => v === 1)) botRow--;
+      const maxLen = SIZE - 2 - botRow;
+      const xs = [];
+      for (let x = 0; x < HALF; x++) if (g[botRow][x] === 1) xs.push(x);
+      if (xs.length && maxLen >= 1) {
+        const draw = (x, len) => {
+          for (let d = 1; d <= len; d++) {
+            g[botRow + d][x] = 1;
+            g[botRow + d][SIZE - 1 - x] = 1;
+          }
+          legCols.push({ x, len, botRow });
+        };
+        if (legStyle === "two") {
+          const lx = xs.length > 2 ? xs[1] : xs[0];
+          const len = Math.min(maxLen, 1 + Math.floor(rand() * 2));
+          if (view === "left" || view === "right") {
+            for (let d = 1; d <= len; d++) g[botRow + d][7] = 1;
+            legCols.push({ x: 7, len, botRow });
+          } else {
+            draw(lx, len);
+          }
+          drawnLegStyle = "two";
+        } else {
+          for (let i = 0; i < xs.length; i += 2) {
+            const len = Math.min(maxLen, rand() < 0.5 ? 2 : 1);
+            draw(xs[i], len);
+          }
+          drawnLegStyle = "many";
+        }
+      }
+    }
+  }
+  const drawn = drawnLegStyle ?? "none";
+  if (frame > 0) {
+    if (drawnLegStyle === "two" && legCols.length) {
+      const c = legCols[0];
+      if (frame === 1) g[c.botRow + c.len][c.x] = 0;
+      else g[c.botRow + c.len][SIZE - 1 - c.x] = 0;
+    } else if (drawnLegStyle === "many" && legCols.length > 1) {
+      for (let i = frame === 1 ? 1 : 0; i < legCols.length; i += 2) {
+        const c = legCols[i];
+        g[c.botRow + c.len][c.x] = 0;
+        g[c.botRow + c.len][SIZE - 1 - c.x] = 0;
+      }
+    }
+    if (frame === 2) {
+      let tR = 0;
+      while (tR < SIZE && !g[tR].some((v) => v)) tR++;
+      let bR = SIZE - 1;
+      while (bR > 0 && !g[bR].some((v) => v)) bR--;
+      if (bR - tR > 3) {
+        const mid = Math.floor((tR + bR) / 2);
+        for (let y = mid; y > tR; y--) g[y] = g[y - 1].slice();
+        g[tR] = new Array(SIZE).fill(0);
+      }
+    }
+  }
+  if (o.outline) {
+    const isBody = (y, x) => y >= 0 && y < SIZE && x >= 0 && x < SIZE && g[y][x] !== 0 && g[y][x] !== 9;
+    const marks = [];
+    for (let y = 0; y < SIZE; y++) {
+      for (let x = 0; x < SIZE; x++) {
+        if (g[y][x] === 0 && (isBody(y - 1, x) || isBody(y + 1, x) || isBody(y, x - 1) || isBody(y, x + 1))) {
+          marks.push([y, x]);
+        }
+      }
+    }
+    for (const [y, x] of marks) g[y][x] = 9;
+  }
+  if (view === "right") for (const row of g) row.reverse();
+  const colors = {
+    1: `hsl(${hue} ${sat}% ${lig}%)`,
+    2: `hsl(${hue} ${sat}% ${Math.max(18, lig - 24)}%)`,
+    3: "#fdfdf5",
+    4: "#1a1a24",
+    5: `hsl(${(hue + 165) % 360} ${sat}% ${lig}%)`,
+    9: "#1a1a24"
+  };
+  let rects = "";
+  for (let y = 0; y < SIZE; y++) {
+    let x = 0;
+    while (x < SIZE) {
+      const v = g[y][x];
+      if (v === 0) {
+        x++;
+        continue;
+      }
+      let x2 = x;
+      while (x2 + 1 < SIZE && g[y][x2 + 1] === v) x2++;
+      rects += `<rect x="${x}" y="${y}" width="${x2 - x + 1}" height="1" fill="${colors[v]}"/>`;
+      x = x2 + 1;
+    }
+  }
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" shape-rendering="crispEdges">${rects}</svg>`;
+  return { svg, drawnLegStyle: drawn, size: SIZE };
+}
+
+// src/render/sheet.ts
+var SHEET_POSES = [
+  ["idle", 0],
+  ["walk1", 1],
+  ["walk2", 2]
+];
+var SHEET_ROWS = ["front", "left", "right", "back"];
+async function toSpriteSheet(seed, options = {}) {
+  const o = resolveOptions(options);
+  const cell = SIZE;
+  const sheet = document.createElement("canvas");
+  sheet.width = cell * SHEET_POSES.length;
+  sheet.height = cell * SHEET_ROWS.length;
+  const ctx = sheet.getContext("2d");
+  ctx.imageSmoothingEnabled = false;
+  const frames = {};
+  const animations = {};
+  for (let r = 0; r < SHEET_ROWS.length; r++) {
+    const view = SHEET_ROWS[r];
+    for (let c = 0; c < SHEET_POSES.length; c++) {
+      const [pose, frame] = SHEET_POSES[c];
+      const cellCanvas = await svgToCanvas(generateSvg(seed, { ...o, view, frame }).svg, cell, "transparent");
+      ctx.drawImage(cellCanvas, c * cell, r * cell);
+      frames[`${view}_${pose}`] = {
+        frame: { x: c * cell, y: r * cell, w: cell, h: cell },
+        rotated: false,
+        trimmed: false,
+        spriteSourceSize: { x: 0, y: 0, w: cell, h: cell },
+        sourceSize: { w: cell, h: cell }
+      };
+    }
+    animations[`idle_${view}`] = [`${view}_idle`];
+    animations[`walk_${view}`] = [`${view}_walk1`, `${view}_walk2`];
+  }
+  const json = {
+    frames,
+    animations,
+    meta: {
+      app: "dotmon",
+      seed,
+      image: "sheet.png",
+      format: "RGBA8888",
+      size: { w: sheet.width, h: sheet.height },
+      scale: "1",
+      grid: { cols: SHEET_POSES.length, rows: SHEET_ROWS.length, cellW: cell, cellH: cell },
+      rowOrder: SHEET_ROWS,
+      colOrder: SHEET_POSES.map((p) => p[0]),
+      note: "Pixel art: scale with nearest neighbor. Walk = alternate walk1/walk2 (~400ms). Sheet is always transparent."
+    }
+  };
+  const png = await new Promise((res) => sheet.toBlob((b) => res(b), "image/png"));
+  return { png, json };
+}
+
+// src/names.ts
+function safeFileName(seed) {
+  return "monster-" + seed.replace(/[\\/:*?"<>|\s]/g, "_");
+}
+
+// src/render/readme.ts
+function assetReadme(seed, locale = "en") {
+  if (locale === "ja") {
+    return `${seed} \u306E\u30E2\u30F3\u30B9\u30BF\u30FC\u30BB\u30C3\u30C8
+=========================
+\u3053\u306EZIP\u306B\u306F\u3001\u30B2\u30FC\u30E0\u3084\u30A2\u30A4\u30B3\u30F3\u306B\u305D\u306E\u307E\u307E\u4F7F\u3048\u308B\u753B\u50CF\u304C\u5165\u3063\u3066\u3044\u307E\u3059\u3002
+
+\u25A0 \u500B\u5225\u753B\u50CF\uFF08512px / \u4FDD\u5B58\u6642\u306E\u80CC\u666F\u8A2D\u5B9A\u3064\u304D\uFF09
+  front_idle.png / front_walk1.png / front_walk2.png \u2026 \u307E\u3048\u5411\u304D\u306E \u7ACB\u3061\u30FB\u6B69\u304D1\u30FB\u6B69\u304D2
+  \u540C\u3058\u7D44\u307F\u5408\u308F\u305B\u304C back\uFF08\u3046\u3057\u308D\uFF09/ left\uFF08\u3072\u3060\u308A\uFF09/ right\uFF08\u307F\u304E\uFF09\u306B\u3082\u3042\u308A\u307E\u3059\uFF08\u8A0812\u679A\uFF09
+
+\u25A0 \u52D5\u304FGIF\uFF08256px\u30FB2\u30B3\u30DE\u30FB\u7121\u9650\u30EB\u30FC\u30D7\uFF09
+  front.gif / back.gif / left.gif / right.gif
+
+\u25A0 \u30B2\u30FC\u30E0\u7528\u30B9\u30D7\u30E9\u30A4\u30C8\u30B7\u30FC\u30C8
+  sheet.png  \u2026 16px\u30C9\u30C3\u30C8\u539F\u5BF8\u30FB3\u5217\xD74\u884C\uFF08\u5217: \u7ACB\u3061/\u6B69\u304D1/\u6B69\u304D2\u3001\u884C: \u307E\u3048/\u3072\u3060\u308A/\u307F\u304E/\u3046\u3057\u308D\uFF09
+  sheet.json \u2026 \u5404\u30B3\u30DE\u306E\u5EA7\u6A19\u3068\u30A2\u30CB\u30E1\u5B9A\u7FA9\uFF08TexturePacker\u4E92\u63DB\u3002Phaser / PixiJS \u3067\u305D\u306E\u307E\u307E\u8AAD\u3081\u307E\u3059\uFF09
+
+\u203B\u30C9\u30C3\u30C8\u7D75\u306A\u306E\u3067\u3001\u62E1\u5927\u3059\u308B\u3068\u304D\u306F\u300C\u307C\u304B\u3057\u306A\u3057\uFF08nearest neighbor\uFF09\u300D\u3092\u9078\u3076\u3068\u304D\u308C\u3044\u306B\u8868\u793A\u3055\u308C\u307E\u3059\u3002
+`;
+  }
+  return `Monster asset set for "${seed}"
+=========================
+This ZIP contains images ready to use in games or as icons.
+
+- Individual PNGs (512px, with your background setting)
+  front_idle.png / front_walk1.png / front_walk2.png = front-facing idle / walk 1 / walk 2
+  The same set exists for back / left / right (12 images total)
+
+- Animated GIFs (256px, 2 frames, infinite loop)
+  front.gif / back.gif / left.gif / right.gif
+
+- Game sprite sheet
+  sheet.png  = native 16px pixels, 3 cols x 4 rows (cols: idle/walk1/walk2, rows: front/left/right/back)
+  sheet.json = frame coordinates + animation definitions (TexturePacker compatible; loads directly in Phaser / PixiJS)
+
+Tip: this is pixel art \u2014 scale it up with "nearest neighbor" (no smoothing) for crisp results.
+`;
+}
+
+// src/render/assetZip.ts
+var VIEWS = ["front", "back", "left", "right"];
+async function toAssetZip(seed, options = {}) {
+  const { background = "transparent", locale = "en", ...genOptions } = options;
+  const o = resolveOptions(genOptions);
+  const dir = safeFileName(seed);
+  const files = [];
+  files.push({ name: `${dir}/README.txt`, data: new TextEncoder().encode(assetReadme(seed, locale)) });
+  for (const view of VIEWS) {
+    for (const [pose, frame] of SHEET_POSES) {
+      files.push({
+        name: `${dir}/${view}_${pose}.png`,
+        data: await pngBytes(generateSvg(seed, { ...o, view, frame }).svg, 512, background)
+      });
+    }
+    const gif = await toGif(
+      [generateSvg(seed, { ...o, view, frame: 1 }).svg, generateSvg(seed, { ...o, view, frame: 2 }).svg],
+      { size: 256, background }
+    );
+    files.push({ name: `${dir}/${view}.gif`, data: new Uint8Array(await gif.arrayBuffer()) });
+  }
+  const sheet = await toSpriteSheet(seed, o);
+  files.push({ name: `${dir}/sheet.png`, data: new Uint8Array(await sheet.png.arrayBuffer()) });
+  files.push({ name: `${dir}/sheet.json`, data: new TextEncoder().encode(JSON.stringify(sheet.json, null, 2)) });
+  return buildZip(files);
+}
+
+exports.SHEET_POSES = SHEET_POSES;
+exports.SHEET_ROWS = SHEET_ROWS;
+exports.assetReadme = assetReadme;
+exports.buildZip = buildZip;
+exports.crc32 = crc32;
+exports.encodeGif = encodeGif;
+exports.lzwEncode = lzwEncode;
+exports.svgToCanvas = svgToCanvas;
+exports.toAssetZip = toAssetZip;
+exports.toGif = toGif;
+exports.toPng = toPng;
+exports.toSpriteSheet = toSpriteSheet;

package/dist/render/index.d.cts

@@ -0,0 +1,42 @@
+import { F as Frame, V as View, G as GenerateOptions, b as Locale } from '../types-kWKrAd-B.cjs';
+
+declare function svgToCanvas(svg: string, size: number, background?: string): Promise<HTMLCanvasElement>;
+interface RasterOptions {
+    size?: number;
+    background?: string;
+}
+declare function toPng(svg: string, opts?: RasterOptions): Promise<Blob>;
+
+declare function lzwEncode(minCodeSize: number, indices: Uint8Array): number[];
+declare function encodeGif(w: number, h: number, palette: number[][], transparentIndex: number, frames: Uint8Array[], delayCs: number): Uint8Array;
+interface GifOptions {
+    size?: number;
+    background?: string;
+    delayMs?: number;
+}
+declare function toGif(frames: [string, string], opts?: GifOptions): Promise<Blob>;
+
+declare function crc32(data: Uint8Array): number;
+interface ZipEntry {
+    name: string;
+    data: Uint8Array;
+}
+declare function buildZip(files: ZipEntry[]): Blob;
+
+declare const SHEET_POSES: [string, Frame][];
+declare const SHEET_ROWS: View[];
+interface SpriteSheetResult {
+    png: Blob;
+    json: Record<string, unknown>;
+}
+declare function toSpriteSheet(seed: string, options?: GenerateOptions): Promise<SpriteSheetResult>;
+
+interface AssetZipOptions extends GenerateOptions {
+    background?: string;
+    locale?: Locale;
+}
+declare function toAssetZip(seed: string, options?: AssetZipOptions): Promise<Blob>;
+
+declare function assetReadme(seed: string, locale?: Locale): string;
+
+export { type AssetZipOptions, type GifOptions, type RasterOptions, SHEET_POSES, SHEET_ROWS, type SpriteSheetResult, type ZipEntry, assetReadme, buildZip, crc32, encodeGif, lzwEncode, svgToCanvas, toAssetZip, toGif, toPng, toSpriteSheet };