@funpixel/tools 0.0.0-stage → 0.1.1

package/plugins/claude/hooks/vendor/owner/bar.mjs

@@ -0,0 +1,286 @@
+// Generated from funpixel-mono/libs/funpixel-tools/src/owner/bar.ts by the GDK build. Do not edit.
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { readProgress } from '../progress/progress.mjs';
+export const BAR_FILE = 'owner.md';
+export const GAME_BAR_FILE = join('design', 'owner-bar.json');
+export const WORLD_TOPIC = 'owner-bar:world';
+export const BAR_STAGE = 'owner-bar';
+export const OWNER_SEED = [
+    'At least 15 minutes of play, with something new every 2–3 minutes',
+    'Fun first: a clear loop, goals and streaks, the fun factors shown in the plan',
+    'A title screen made as the game\'s own world, with its name as art',
+    'Every screen designed: title, pause, settings, level select, results, end',
+    'An amazing HUD, drawn for the phone (portrait and landscape) and the desktop',
+    'Mobile and desktop both look right: a responsive layout, real touch and keys',
+    'Animation everywhere: the hero, the creatures and the UI move with real frames',
+    'Sound: an SFX for every action and music that follows the game\'s states',
+    'Juice on every verb: sight, sound, motion and haptics',
+    'A living world: creatures, people and ambient life, each doing something',
+    'Imagined environments: distinct places (palette, hour, weather, landmark), each tied to the story',
+];
+export const NUGGET = { max: 15, minutes: 3 };
+export function lineMinutes(text) {
+    const n = /(\d+(?:\.\d+)?)\s*(hours?|h\b|minutes?|min)/i.exec(text);
+    return n ? (/^h/i.test(n[2]) ? Number(n[1]) * 60 : Number(n[1])) : null;
+}
+const ASPECTS = [
+    ['length', /\b\d+\s*(?:[-–]\s*\d+\s*)?(?:min|minutes?|hours?)\b|\bminutes of (?:game)?play\b|\blong(?:er)? (?:game|play)\b/i],
+    ['juice', /\bjuic\w*|\bhaptic\w*|\bgame ?feel\b|\bscreen ?shake\b/i],
+    ['animation', /\banimat\w*/i],
+    ['hud', /\bhud\b/i],
+    ['screens', /\bevery screen\b|\bscreens\b|\bmenus?\b|\bpause\b|\bsettings\b|\blevel select\b/i],
+    ['title', /\btitle\b|\bwordmark\b|\blogo\b/i],
+    ['world', /\bliving world\b|\bcreatures?\b|\benvironments?\b|\bplaces?\b|\bstory\b|\bimagined\b|\bambient\b|\bnpcs?\b|\bpeople\b|\bworld\b/i],
+    ['sound', /\bsfx\b|\bsounds?\b|\bmusic\b|\baudio\b/i],
+    ['responsive', /\bmobile\b|\bdesktop\b|\brespons\w*|\bphone\b|\btouch\b/i],
+    ['fun', /\bfun\b|\bloop\b|\bgoals?\b|\bstreaks?\b/i],
+];
+const ASPECT_NAMES = new Set([...ASPECTS.map(([a]) => a), 'other']);
+export function aspectOf(text) {
+    const tag = /\[(\w+)\]\s*$/.exec(text)?.[1]?.toLowerCase();
+    if (tag && ASPECT_NAMES.has(tag))
+        return tag;
+    return ASPECTS.find(([, re]) => re.test(text))?.[0] ?? 'other';
+}
+const norm = (t) => t.replace(/\s+/g, ' ').trim();
+export const lineId = (text) => `b-${createHash('sha1').update(norm(text).toLowerCase()).digest('hex').slice(0, 6)}`;
+export function parseBar(md, source) {
+    const out = [];
+    for (const raw of md.split('\n')) {
+        const m = /^\s*[-*]\s+(.+?)\s*$/.exec(raw);
+        if (!m)
+            continue;
+        const text = norm(m[1]);
+        if (!text || out.some((x) => x.id === lineId(text)))
+            continue;
+        out.push({ id: lineId(text), text, aspect: aspectOf(text), source });
+    }
+    return out;
+}
+export function renderBar(lines) {
+    return ['# The owner\'s bar', '', 'Standing requests carried to every new game, matched to it (relevant, skipped with a reason, or asked).', 'Edit with `funtools owner add|list|remove`, or by hand: one `- line` per request.', '', ...lines.map((l) => `- ${norm(l)}`), ''].join('\n');
+}
+export function personBarPath(env = process.env) {
+    if (env.FUNPIXEL_OWNER_HOME)
+        return join(env.FUNPIXEL_OWNER_HOME, BAR_FILE);
+    if (env.NODE_TEST_CONTEXT)
+        return null;
+    return join(homedir(), '.funpixel', BAR_FILE);
+}
+export function repoBarPath(root, env = process.env) {
+    const home = resolve(env.FUNPIXEL_OWNER_HOME ? dirname(env.FUNPIXEL_OWNER_HOME) : homedir());
+    let d = resolve(root);
+    for (let i = 0; i < 24; i++) {
+        if (d === home)
+            return null;
+        const p = join(d, '.funpixel', BAR_FILE);
+        if (existsSync(p))
+            return p;
+        const up = dirname(d);
+        if (up === d)
+            return null;
+        d = up;
+    }
+    return null;
+}
+const readText = (p) => { if (!p)
+    return null; try {
+    return readFileSync(p, 'utf8');
+}
+catch {
+    return null;
+} };
+export function readBar(root, env = process.env) {
+    const person = parseBar(readText(personBarPath(env)) ?? '', 'person');
+    const repo = parseBar(readText(repoBarPath(root, env)) ?? '', 'repo');
+    return [...person, ...repo.filter((r) => !person.some((p) => p.id === r.id))];
+}
+const readJson = (p) => { try {
+    return JSON.parse(readFileSync(p, 'utf8'));
+}
+catch {
+    return null;
+} };
+export function gddOf(root) {
+    for (const rel of [join('design', 'GDD.md'), join('design', 'gdd.md'), join('design', 'plan.md')]) {
+        const t = readText(join(root, rel));
+        if (t)
+            return t;
+    }
+    return '';
+}
+export function section(text, heading, own = false) {
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const m = /^(#{2,3})\s+(.+?)\s*$/.exec(lines[i]);
+        if (!m || !heading.test(m[2]) || (own && /starter default/i.test(m[2])))
+            continue;
+        const depth = m[1].length, body = [];
+        for (let j = i + 1; j < lines.length; j++) {
+            const h = /^(#{1,3})\s/.exec(lines[j]);
+            if (h && h[1].length <= depth)
+                break;
+            body.push(lines[j]);
+        }
+        return body.join('\n');
+    }
+    return null;
+}
+export function sectionsAll(text, heading) {
+    const out = [];
+    let rest = text;
+    for (let i = 0; i < 12; i++) {
+        const m = [...rest.matchAll(/^(#{2,3})\s+(.+?)\s*$/gm)].find((x) => heading.test(x[2]));
+        if (!m)
+            break;
+        const after = rest.slice(m.index);
+        out.push(section(after, heading) ?? '');
+        rest = after.slice(m[0].length);
+    }
+    return out.join('\n');
+}
+export function words(body) {
+    if (!body)
+        return 0;
+    return body.split('\n').filter((l) => !/starter default/i.test(l)).join('\n').replace(/<[^>]*>/g, ' ').replace(/\b(todo|tbd|to draw)\b/gi, ' ').replace(/[|*#`_-]+/g, ' ').split(/\s+/).filter((w) => /[a-z]{2,}/i.test(w)).length;
+}
+export function ownRows(body) {
+    if (!body)
+        return 0;
+    let n = 0, inTable = false;
+    for (const line of body.split('\n')) {
+        const t = /^\s*\|(.+)\|\s*$/.exec(line);
+        if (!t) {
+            inTable = false;
+            if (/^\s*[-*]\s+\S/.test(line) && !/[<>]|starter default/i.test(line))
+                n++;
+            continue;
+        }
+        const header = !inTable;
+        inTable = true;
+        if (header || t[1].split('|').every((c) => /^\s*:?-+:?\s*$/.test(c)) || /[<>]|starter default/i.test(line))
+            continue;
+        n++;
+    }
+    return n;
+}
+export function placesOf(gdd) {
+    const body = section(gdd, /^places\b/i, true);
+    if (!body)
+        return [];
+    const out = [];
+    const add = (name, row) => {
+        const n = name.replace(/[*_`]/g, '').trim();
+        if (!n || n.length > 60 || /[<>]/.test(n) || /^(place|name|where|-+|:?-+:?)$/i.test(n) || out.some((x) => x.name.toLowerCase() === n.toLowerCase()))
+            return;
+        out.push({ name: n, row });
+    };
+    for (const line of body.split('\n')) {
+        if (/starter default/i.test(line))
+            continue;
+        const t = /^\s*\|(.+)\|\s*$/.exec(line);
+        if (t) {
+            const cells = t[1].split('|').map((c) => c.trim());
+            if (cells.every((c) => /^:?-+:?$/.test(c)))
+                continue;
+            add(cells[0], line);
+            continue;
+        }
+        const h = /^###\s+(.+)$/.exec(line);
+        if (h) {
+            add(h[1], line);
+            continue;
+        }
+        const b = /^\s*[-*]\s+(?:\*\*([^*]+)\*\*|([^:—–-]{2,60})\s*[:—–-])/.exec(line);
+        if (b)
+            add(b[1] ?? b[2], line);
+    }
+    return out;
+}
+const WORLD_WORDS = /\b(world|valley|island|forest|woods?|city|town|village|explor\w*|journey|adventure|kingdom|ocean|seas?|mountains?|desert|caves?|dungeon|planet|orchard|garden|creatures?|travel\w*|story|quest|realm|harbou?r|river|meadow|jungle|swamp|tundra|space station|countryside|open world|levels? to walk|wander\w*)\b/i;
+const ONE_SCREEN = /\b(puzzle|word game|word puzzle|crossword|sudoku|match[- ]?3|solitaire|card game|board game|chess|checkers|trivia|quiz|tetris|one[- ]screen|single[- ]screen|clicker|idle|minesweeper|2048|nonogram|mahjong|pinball|breakout|pong|typing)\b/i;
+export function gameProfile(root) {
+    const m = readJson(join(root, 'funpixel.json')) ?? {};
+    const md = m.metadata ?? {};
+    const idea = String(readJson(join(root, '.funtools', 'flow.json'))?.idea ?? '');
+    const gdd = gddOf(root);
+    const tier = m.production?.tier === 'mid' || m.production?.tier === 'deep' ? m.production.tier : 'small';
+    const genre = String(md.genre ?? '');
+    const lockedGenre = String(m.studio?.locked?.genre ?? m.studio?.picks?.genre ?? '');
+    const said = [idea, md.tagline, lockedGenre, m.studio?.locked?.setting ?? '', m.studio?.locked?.premise ?? ''].filter(Boolean).join(' · ');
+    const places = placesOf(gdd);
+    const living = ownRows(section(gdd, /^living world/i, true));
+    const ad = /playable[- ]?ad/i.test(`${genre} ${m.kind ?? ''} ${idea}`) || !!m.playable_ad;
+    const three = md.dimension === '3d' || /three/i.test(String(md.framework ?? ''));
+    const what = short(String(md.tagline || idea || m.name || 'this game').replace(/\s+/g, ' '), 70);
+    let world, why;
+    if (three) {
+        world = 'yes';
+        why = 'a 3D game: a world the camera moves through';
+    }
+    else if (places.length >= 2) {
+        world = 'yes';
+        why = `its plan names ${places.length} places (${places.slice(0, 3).map((p) => p.name).join(', ')})`;
+    }
+    else if (living >= 2) {
+        world = 'yes';
+        why = 'its plan has a living world';
+    }
+    else if (ONE_SCREEN.test(`${genre} ${lockedGenre} ${said}`) && !WORLD_WORDS.test(said)) {
+        world = 'no';
+        why = `a ${(ONE_SCREEN.exec(`${lockedGenre} ${said} ${genre}`)?.[0] ?? genre).toLowerCase()} game with no world named`;
+    }
+    else if (WORLD_WORDS.test(said)) {
+        world = 'yes';
+        why = `its idea is set in a world ("${WORLD_WORDS.exec(said)?.[0]}")`;
+    }
+    else {
+        world = 'unsure';
+        why = 'nothing in its idea or plan says whether it has places and creatures';
+    }
+    const both = /\bboth orientations\b|\bany orientation\b|\brotat(e|es|ion) (to|between)\b/i.test(gdd) || /^(any|both)$/i.test(String(md.orientation ?? ''));
+    const orientations = both ? ['portrait', 'landscape'] : md.orientation === 'portrait' ? ['portrait'] : ['landscape'];
+    const levels = places.length >= 2 || /^##\s+(levels|chapters|stages|worlds)\b/im.test(gdd) || /\blevels?\b|\bchapters?\b|\bstages\b/i.test(said);
+    return { world, why, ad, tier, orientations, levels, places, what };
+}
+const short = (s, n) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`);
+export function readGameBar(root) {
+    const b = readJson(join(root, GAME_BAR_FILE));
+    return b && Array.isArray(b.lines) ? b : null;
+}
+export function judgeLine(line, g) {
+    const topic = short(line.text.replace(/[:,(].*$/, '').trim().toLowerCase(), 40);
+    switch (line.aspect) {
+        case 'world':
+            return g.world === 'yes' ? { verdict: 'applies', why: `${g.why}` }
+                : g.world === 'no' ? { verdict: 'skipped', why: `${topic}: ${g.why}, so no world to fill` }
+                    : { verdict: 'asked', why: `${topic}: ${g.why}; asked whether it has a world` };
+        case 'length': {
+            if (g.ad)
+                return { verdict: 'skipped', why: `${topic}: a playable ad is under a minute by design` };
+            const want = lineMinutes(line.text);
+            if (g.tier === 'small' && want !== null && want >= NUGGET.max)
+                return { verdict: 'skipped', why: `${topic}: this game is a nugget (production.tier small, a few minutes), and ${want} minutes is a longer tier's length; the owner holds it to the line with \`owner apply <id>\`, which makes it a longer game` };
+            return { verdict: 'applies', why: 'every game but a playable ad' };
+        }
+        default:
+            return { verdict: 'applies', why: 'every game has it' };
+    }
+}
+export function worldVerdict(root, bar = readGameBar(root), g = null) {
+    const lines = (bar?.lines ?? []).filter((l) => l.aspect === 'world');
+    const flipped = lines.filter((l) => l.by === 'owner' && l.why.startsWith('the owner')).sort((a, b) => a.at.localeCompare(b.at)).at(-1);
+    const q = readProgress(root).questions.filter((x) => x.topic === WORLD_TOPIC).at(-1);
+    const answeredAt = q?.answer ? q.answer.at : '';
+    if (flipped && flipped.verdict !== 'asked' && (!answeredAt || flipped.at >= answeredAt.replace(/\.\d+Z$/, 'Z')))
+        return flipped.verdict === 'applies' ? { world: 'yes', why: flipped.why } : { world: 'no', why: flipped.why };
+    if (q?.answer)
+        return q.answer.pick === 'yes' ? { world: 'yes', why: `the owner said it has a world (${q.id})` } : { world: 'no', why: `the owner said no world to fill (${q.id})` };
+    if (q)
+        return { world: 'unsure', why: (g ?? gameProfile(root)).why, ask: q.id };
+    const p = g ?? gameProfile(root);
+    return { world: p.world, why: p.why };
+}