@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/assets/process.js

@@ -0,0 +1,209 @@
+import { existsSync, mkdirSync, mkdtempSync, copyFileSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, posix } from 'node:path';
+import { sendJson } from "../api/http.js";
+import { decodePng, encodePng } from "../look/png.js";
+import { findHelper, runHelper } from "../optimize/helper.js";
+import { familyOf, laneOf } from "./manifest.js";
+import { onlyMatches } from "./plan.js";
+import { shaOfBytes } from "./lock.js";
+import { snapPixels } from "./pixelart.js";
+import { crop, DEPTH_SATURATION, desaturate, hasAlpha, meanLuma, measuredAnchors, opaqueBox, roleSize, shrink, tintTo } from "./pixels.js";
+export const ART_DATA = join('src', 'art', 'assets.json');
+export const defaultAnchor = (it) => (laneOf(it) === 'cast' ? [0.5, 1] : [0.5, 0.5]);
+export function boxFor(it, kept, w, h) {
+    const d = it.box;
+    if (d) {
+        const bw = d.w ?? Math.round((d.h * w) / Math.max(h, 1));
+        const bh = d.h ?? Math.round((d.w * h) / Math.max(w, 1));
+        return { w: bw, h: bh, anchor: d.anchor ?? kept?.anchor ?? defaultAnchor(it), from: 'manifest' };
+    }
+    if (kept && kept.w > 0 && kept.h > 0)
+        return { ...kept, from: kept.from === 'manifest' ? 'kept' : kept.from };
+    return { w, h, anchor: defaultAnchor(it), from: 'first land' };
+}
+export function fitInBox(pw, ph, box) {
+    const scale = Math.min(box.w / Math.max(pw, 1), box.h / Math.max(ph, 1));
+    return { scale, w: pw * scale, h: ph * scale };
+}
+const readArt = (game) => { try {
+    return JSON.parse(readFileSync(join(game, ART_DATA), 'utf8')).items ?? {};
+}
+catch {
+    return {};
+} };
+export const urlOf = (file) => posix.relative('public', file.split('\\').join('/'));
+const CUTOUT_FAMILIES = { fx: 'effect', ui: 'ui_icon', part: 'part', face: 'face', character: 'character', sprite: 'character' };
+async function keyOnServer(api, png, it, assetId, gameId) {
+    const body = { role: CUTOUT_FAMILIES[familyOf(it) ?? ''] ?? 'prop', trim: false, ...(gameId ? { game_id: gameId } : {}) };
+    if (assetId)
+        body.asset_id = assetId;
+    else
+        body.image_base64 = png.toString('base64');
+    const r = (await sendJson(api, 'POST', '/v1/tools/key_sprite', { body })).json;
+    if (r.verdict !== 'accept' || typeof r.png_base64 !== 'string')
+        return { note: `key_sprite rejected it: ${r.message ?? r.cause ?? 'no reason given'}` };
+    return { img: decodePng(Buffer.from(r.png_base64, 'base64')) };
+}
+export async function processAssets(game, items, lock, o = {}) {
+    const results = [];
+    const notes = [];
+    const measured = new Map();
+    const before = readArt(game);
+    for (const it of items) {
+        if (o.only && !onlyMatches(o.only, it.name))
+            continue;
+        const e = lock.items[it.name];
+        const skip = (note) => results.push({ name: it.name, status: 'skipped', ops: [], note });
+        if (it.out?.split('\\').join('/').startsWith('design/')) {
+            if (o.only)
+                skip('a design reference (design/), not shipped art');
+            continue;
+        }
+        if (!['image', 'sprite', 'texture', 'strip'].includes(it.kind)) {
+            if (o.only)
+                skip(`${it.kind} items are shipped as generated`);
+            continue;
+        }
+        if (!e || e.verdict !== 'accept' || !e.file) {
+            skip('not made yet — run assets gen');
+            continue;
+        }
+        const src = e.raw && existsSync(join(game, e.raw)) ? e.raw : e.file;
+        const bytes = readFileSync(join(game, src));
+        let img;
+        try {
+            img = decodePng(bytes);
+        }
+        catch {
+            skip(`${src} is not a PNG this can read; shipped as generated`);
+            continue;
+        }
+        const ops = [];
+        const cutout = it.kind === 'sprite' || !!it.transparent;
+        if (cutout && !hasAlpha(img)) {
+            if (!o.api)
+                notes.push(`${it.name}: came back on a plate and there is no API key to key it (key_sprite is free) — funtools login`);
+            else {
+                const k = await keyOnServer(o.api, bytes, it, e.raw_sha256 === shaOfBytes(bytes) ? e.asset_id : undefined, o.gameId);
+                if (k.img) {
+                    img = k.img;
+                    ops.push('key');
+                }
+                else
+                    notes.push(`${it.name}: ${k.note}`);
+            }
+        }
+        if (cutout && hasAlpha(img)) {
+            const box = opaqueBox(img);
+            if (box && (box.w < img.width || box.h < img.height)) {
+                img = crop(img, box);
+                ops.push('trim');
+            }
+        }
+        const size = roleSize(img.width, img.height, it.role);
+        if (o.pixelArt) {
+            if (it.depth) {
+                img = desaturate(img, DEPTH_SATURATION[it.depth]);
+                ops.push(`depth ${it.depth}`);
+            }
+            img = snapPixels(img, o.pixelArt, size);
+            ops.push(`pixel ${img.width / o.pixelArt.scale}x${img.height / o.pixelArt.scale} at ${o.pixelArt.scale}x${o.pixelArt.palette.length ? `, ${o.pixelArt.palette.length} inks` : ''}`);
+        }
+        else {
+            if (size.w !== img.width || size.h !== img.height) {
+                img = shrink(img, size.w, size.h);
+                ops.push(`size ${size.w}x${size.h}`);
+            }
+            if (it.depth) {
+                img = desaturate(img, DEPTH_SATURATION[it.depth]);
+                ops.push(`depth ${it.depth}`);
+            }
+        }
+        const out = encodePng(img);
+        const file = e.file.replace(/\.[^./]+$/, '.png');
+        mkdirSync(dirname(join(game, file)), { recursive: true });
+        writeFileSync(join(game, file), out);
+        if (file !== e.file)
+            rmSync(join(game, e.file), { force: true });
+        e.file = file;
+        e.sha256 = shaOfBytes(out);
+        e.processed = { at: new Date().toISOString(), sha256: e.sha256, ops };
+        results.push({ name: it.name, status: 'done', ops });
+        const anchors = { ...(cutout ? measuredAnchors(img) : {}), ...(it.anchors ?? {}) };
+        const box = boxFor(it, before[it.name]?.box, img.width, img.height);
+        const was = before[it.name]?.box;
+        if (was && box.from !== 'manifest' && (img.width / img.height).toFixed(2) !== (was.w / was.h).toFixed(2))
+            notes.push(`${it.name}: the new picture is ${img.width}x${img.height}, drawn into its kept box ${box.w}x${box.h} (contain) — a different shape leaves margin; declare "box" in the manifest to change it`);
+        measured.set(it.name, { entry: { url: urlOf(file), w: img.width, h: img.height, anchors, tint: 1, ...(it.atlas ? { atlas: it.atlas } : {}), box }, luma: meanLuma(img), family: familyOf(it) ?? it.kind });
+    }
+    const byFamily = new Map();
+    for (const m of measured.values())
+        byFamily.set(m.family, [...(byFamily.get(m.family) ?? []), m.luma]);
+    for (const m of measured.values()) {
+        const ls = [...byFamily.get(m.family)].sort((a, b) => a - b);
+        const median = ls[Math.floor(ls.length / 2)];
+        m.entry.tint = ls.length > 1 ? tintTo(m.luma, median) : 1;
+    }
+    const data = {};
+    for (const [name, m] of measured)
+        data[name] = m.entry;
+    await packAtlases(game, items, lock, data, notes);
+    return { results, data, notes };
+}
+async function packAtlases(game, items, lock, data, notes) {
+    const groups = new Map();
+    for (const it of items) {
+        const f = lock.items[it.name]?.file;
+        if (it.atlas && data[it.name] && f)
+            groups.set(it.atlas, [...(groups.get(it.atlas) ?? []), f]);
+    }
+    if (!groups.size)
+        return;
+    const helper = findHelper();
+    if ('missing' in helper) {
+        notes.push(`atlas not packed (the pieces stay loose): ${helper.missing}`);
+        return;
+    }
+    for (const [group, paths] of groups) {
+        const staging = mkdtempSync(join(tmpdir(), 'funtools-assets-'));
+        try {
+            const png = `public/assets/atlas/${group}.png`;
+            const a = await runHelper(helper.bin, { root: game, op: 'pack_atlas', paths, options: { output_path: png, trim: false }, out_dir: staging });
+            if (!a.adopted) {
+                notes.push(`atlas ${group} not packed: ${a.notes.join('; ') || 'the optimizer kept the loose files'}`);
+                continue;
+            }
+            for (const out of a.outputs) {
+                mkdirSync(dirname(join(game, out.path)), { recursive: true });
+                copyFileSync(join(staging, out.path), join(game, out.path));
+            }
+            const json = a.outputs.find((x) => x.path.endsWith('.json'))?.path;
+            for (const it of items) {
+                if (it.atlas !== group || !data[it.name])
+                    continue;
+                data[it.name].frame = posix.basename(lock.items[it.name].file);
+                if (json)
+                    data[it.name].url = urlOf(json);
+            }
+        }
+        catch (e) {
+            notes.push(`atlas ${group} not packed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        finally {
+            rmSync(staging, { recursive: true, force: true });
+        }
+    }
+}
+export function writeArtData(game, data, keep) {
+    const p = join(game, ART_DATA);
+    let old = {};
+    try {
+        old = JSON.parse(readFileSync(p, 'utf8')).items ?? {};
+    }
+    catch { }
+    const items = Object.fromEntries(Object.entries({ ...old, ...data }).filter(([n]) => keep.has(n)).sort(([a], [b]) => a.localeCompare(b)));
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, JSON.stringify({ generated_by: 'funtools assets process', note: 'URLs are relative to the page; anchors are fractions of each picture (0–1); multiply tint into the sprite colour; draw each picture fitted into its box (contain, at box.anchor), so a re-made one lands at the same size', items }, null, 2) + '\n');
+    return p;
+}

package/dist/assets/script.js

@@ -0,0 +1,194 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { MANIFEST } from "./manifest.js";
+import { readLock } from "./lock.js";
+import { STARTERS } from "../init/starters.js";
+export const SCRIPT_SOURCES = ['design/GDD.md', 'design/plan.md', 'GDD.md', 'plan.md'];
+export const DEFAULT_POSES = {
+    hero: ['idle', 'step', 'act', 'hit', 'step2'],
+    enemy: ['idle', 'act'],
+    pickup: ['idle'],
+    other: ['idle', 'act'],
+};
+export const HERO_CANDIDATES = 3;
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '').slice(0, 24) || 'item';
+const cells = (line) => line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+export function readScript(text) {
+    const lines = text.split('\n');
+    const at = lines.findIndex((l) => /^#{2,3}\s+(\d+[.)]?\s*)?asset script\b/i.test(l.trim()));
+    if (at < 0)
+        return null;
+    const rows = [];
+    let head = null;
+    for (let i = at + 1; i < lines.length; i++) {
+        const l = lines[i].trim();
+        if (/^#{1,3}\s/.test(l))
+            break;
+        if (!l.startsWith('|'))
+            continue;
+        const c = cells(l);
+        if (!head) {
+            head = c.map((h) => h.toLowerCase());
+            continue;
+        }
+        if (c.every((x) => /^:?-{2,}:?$/.test(x) || !x))
+            continue;
+        const get = (...names) => { const k = head.findIndex((h) => names.some((n) => h.startsWith(n))); return k >= 0 ? c[k]?.trim() : undefined; };
+        const id = get('id') ?? '';
+        const what = get('what') ?? '';
+        if (!id || /^<.*>$/.test(id) || /^<.*>$/.test(what))
+            continue;
+        const n = Number(get('count') ?? '');
+        const range = /(\d+)\s*(?:…|\.\.\.?|–|-)\s*(\d+)\s*$/.exec(id);
+        const times = /[×x]\s*(\d+)\s*$/i.exec(id);
+        const count = Number.isInteger(n) && n > 0 ? n : range ? Number(range[2]) - Number(range[1]) + 1 : times ? Number(times[1]) : null;
+        rows.push({ id, what, kind: ((get('kind') ?? '') || inferKind(what)).toLowerCase(), count, cast: get('cast')?.toLowerCase() || undefined, beat: get('beat'), locks: get('locks'), status: get('status') });
+    }
+    return rows;
+}
+export function inferKind(what) {
+    const t = what.toLowerCase();
+    if (/\b3d\b|\bmodel\b|\bmesh\b|\bglb\b/.test(t))
+        return /\b(rigged|walks?|runs?|animated|moves)\b/.test(t) ? 'character3d' : 'model';
+    if (/\b(music|ballad|theme|song|score|loop|track|bgm|soundtrack)\b/.test(t))
+        return 'music';
+    if (/\b(sfx|sounds?|footsteps?|creak|chime|blip|thud|whoosh|clank|hum|ambience|ambient bed)\b/.test(t))
+        return 'sound';
+    if (/\b(textures?|tiles?|tiling|pbr|ground|floor material)\b/.test(t))
+        return 'texture';
+    if (/\b(title lettered|wordmark|logo|hud|icons?|button|panel|plate|ui)\b/.test(t))
+        return 'ui';
+    return '';
+}
+function pieces(what) {
+    const colon = what.indexOf(':');
+    if (colon > 0)
+        return { subject: what.slice(0, colon).trim(), names: what.slice(colon + 1).split(/[;,]/).map((s) => s.trim()).filter(Boolean) };
+    if (what.includes(';'))
+        return { subject: '', names: what.split(';').map((s) => s.trim()).filter(Boolean) };
+    return { subject: what.trim(), names: [] };
+}
+const roleOf = (r) => {
+    const t = `${r.what} ${r.beat ?? ''}`.toLowerCase();
+    return /\bhero\b|\bplayer\b|\bprotagonist\b/.test(t) ? 'hero' : /\benemy\b|\bfoe\b|\bboss\b|\bpursuer\b/.test(t) ? 'enemy' : /\bpickup\b|\bcollectible\b|\bcoin\b/.test(t) ? 'pickup' : 'other';
+};
+export const NOTES = [];
+export function motionOf(word) {
+    const w = word.toLowerCase().trim();
+    if (/\b(idle|stand)/.test(w))
+        return { word, clip: 'idle' };
+    if (/\b(walk|run|jog|carry|stride)/.test(w))
+        return { word, clip: 'walk' };
+    if (/\b(attack|swing|punch|kick)/.test(w))
+        return { word, clip: 'attack' };
+    if (/\b(death|die|dies|fall over|collapse)/.test(w))
+        return { word, clip: 'death' };
+    if (/\b(wave|greet)/.test(w))
+        return { word, motion: 'wave' };
+    if (/\b(nod|agree)/.test(w))
+        return { word, motion: 'nod' };
+    if (/\b(hop|jump|leap)/.test(w))
+        return { word, motion: 'hop' };
+    if (/\b(strike|hit|slam)/.test(w))
+        return { word, motion: 'strike' };
+    if (/\b(flinch|stumble|stagger|recoil|knocked)/.test(w))
+        return { word, motion: 'flinch' };
+    if (/\b(celebrate|cheer|victory|dance)/.test(w))
+        return { word, motion: 'celebrate' };
+    return { word };
+}
+export function rowItems(r) {
+    const { subject, names } = pieces(r.what);
+    const base = r.cast ?? slug(r.id.replace(/[-_]?\d+\s*(?:…|\.\.\.?|–|-)\s*\d+\s*$/, ''));
+    const n = Math.max(1, r.count ?? (names.length || 1));
+    const list = names.length ? names.slice(0, Math.max(n, names.length)) : Array.from({ length: n }, (_, i) => (n > 1 ? String(i + 1) : ''));
+    const named = (piece) => (piece ? `${base}_${slug(piece)}` : base);
+    const about = (piece) => [subject || piece, subject && piece && !/^\d+$/.test(piece) ? piece : ''].filter(Boolean).join(', ');
+    const tag = { script: r.id };
+    const cast = r.cast ? { cast: r.cast } : {};
+    switch (r.kind) {
+        case 'character':
+        case 'creature':
+        case 'pose':
+        case 'poses': {
+            const poses = names.length ? names : r.count ? DEFAULT_POSES[roleOf(r)].slice(0, r.count) : DEFAULT_POSES[roleOf(r)];
+            return poses.map((p) => ({ name: named(p), kind: 'pose', subject: `${subject || base}: ${p}`, change: `the pose (${p}) and the expression`, ...cast, ...tag }));
+        }
+        case 'strip':
+        case 'animation':
+        case 'cycle':
+            return list.map((p) => ({ name: `${named(p)}_strip`, kind: 'sheet', ...(p && !/^\d+$/.test(p) ? { params: { animations: [{ name: p, frames: 6 }] } } : {}), ...cast, ...tag }));
+        case 'model':
+        case 'model3d':
+        case '3d':
+        case 'character3d': {
+            const hero = roleOf(r) === 'hero';
+            const moves = /\b(moves|walks|runs|rigged|animated)\b/i.test(r.what) || r.kind === 'character3d';
+            const clipsNamed = r.kind === 'character3d' && names.length && !r.count;
+            const mapped = clipsNamed ? names.map((x) => motionOf(x)) : [];
+            const clips = ['idle', ...new Set(mapped.flatMap((m) => (m.clip ? [m.clip] : [])))].filter((c, i, a) => a.indexOf(c) === i);
+            if (clips.length === 1)
+                clips.push('walk');
+            const motions = [...new Set(mapped.flatMap((m) => (m.motion ? [m.motion] : [])))].map((kind) => ({ kind }));
+            const unmade = mapped.filter((m) => !m.clip && !m.motion).map((m) => m.word);
+            const pieceList = clipsNamed ? [''] : list;
+            const named3 = (piece) => named(piece).replace(/3d$/, '');
+            return pieceList.flatMap((p) => {
+                const name = `${named3(p)}3d`;
+                const m = { name, kind: 'model3d', ...(r.cast ? {} : { subject: clipsNamed ? subject : about(p) }), ...(hero ? { draws: HERO_CANDIDATES } : {}), ...(moves ? {} : { optimize: { device: 'phone' } }), ...cast, ...tag };
+                if (unmade.length)
+                    NOTES.push(`${r.id}: no rig clip or motion for ${unmade.map((w) => `"${w}"`).join(', ')} — animate it in code from the rig, or name a clip (idle, walk, attack, death) or a motion (wave, nod, hop, strike, flinch, celebrate)`);
+                return moves ? [m, { name: `${named3(p)}rig`, kind: 'rig', from: name, clips, ...(motions.length ? { motions } : {}), optimize: { device: 'phone', budget: 'character' }, ...tag }] : [m];
+            });
+        }
+        case 'structure':
+        case 'prop':
+        case 'ui':
+        case 'icon':
+        case 'item':
+        case 'vehicle':
+            return list.map((p) => ({ name: named(p), kind: 'sprite', subject: about(p), family: r.kind === 'ui' || r.kind === 'icon' ? 'ui' : 'prop', ...cast, ...tag }));
+        case 'tile':
+        case 'texture':
+            return list.map((p) => ({ name: named(p), kind: 'texture', subject: about(p), ...tag }));
+        case 'sound':
+        case 'sfx':
+            return list.map((p) => ({ name: named(p), kind: 'sound', subject: about(p), ...tag }));
+        case 'music':
+        case 'cue':
+        case 'bgm':
+            return list.map((p) => ({ name: named(p), kind: 'music', subject: about(p), ...tag }));
+        default:
+            return list.map((p) => ({ name: named(p), kind: 'image', subject: about(p), family: /key ?art|poster|title/i.test(`${r.kind} ${r.what}`) ? 'keyart' : 'background', ...tag }));
+    }
+}
+export function scriptManifest(game, from) {
+    const source = from ?? SCRIPT_SOURCES.find((f) => existsSync(join(game, f)));
+    if (!source || !existsSync(join(game, source)))
+        throw new Error(`no plan document with an "## Asset script" (looked in ${SCRIPT_SOURCES.join(', ')}) — write the table there first (funpixel-gdd's template)`);
+    NOTES.length = 0;
+    const rows = readScript(readFileSync(join(game, source), 'utf8'));
+    if (!rows?.length)
+        throw new Error(`${source} has no rows under "## Asset script" — one row per family: | ID | What | Kind | Count | Cast | …`);
+    const current = existsSync(join(game, MANIFEST)) ? (JSON.parse(readFileSync(join(game, MANIFEST), 'utf8')).items ?? []) : [];
+    let made0 = {};
+    try {
+        made0 = readLock(game).items ?? {};
+    }
+    catch { }
+    const demo = new Set(Object.values(STARTERS).flatMap((st) => st.assets.map((a) => a.name)));
+    const hand = current.filter((i) => !i.script && !(demo.has(i.name) && !made0[i.name]));
+    const made = rows.flatMap(rowItems);
+    const taken = new Set(hand.map((i) => i.name));
+    const clash = made.filter((i) => taken.has(i.name)).map((i) => i.name);
+    if (clash.length)
+        throw new Error(`the script makes ${clash.join(', ')}, which a hand-written item already names — rename the row's pieces or the item`);
+    const keep = new Set(made.map((i) => i.name));
+    const gone = current.filter((i) => (i.script && !keep.has(i.name)) || (!i.script && !hand.includes(i))).map((i) => i.name);
+    return { source, rows, items: [...hand, ...made], kept: hand.length, dropped: gone, notes: [...NOTES] };
+}
+export function writeScriptManifest(game, plan) {
+    const p = join(game, MANIFEST);
+    const raw = existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : {};
+    writeFileSync(p, JSON.stringify({ ...raw, items: plan.items }, null, 2) + '\n');
+}