@funpixel/tools 0.0.0-stage → 0.1.1

package/dist/reach/envelope.js

@@ -0,0 +1,111 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const RULE_FILES = ['src/sim/rules.ts', 'src/rules.ts', 'src/sim', 'src/rules', 'src/logic'];
+function ruleSources(root) {
+    const out = [];
+    for (const rel of RULE_FILES) {
+        const p = join(root, rel);
+        if (!existsSync(p))
+            continue;
+        const files = /\.ts$/.test(rel) ? [rel] : readdirSync(p).filter((f) => /\.[jt]s$/.test(f)).map((f) => join(rel, f));
+        for (const f of files)
+            if (!out.some((o) => o.file === f)) {
+                try {
+                    out.push({ file: f, text: readFileSync(join(root, f), 'utf8') });
+                }
+                catch { }
+            }
+    }
+    return out;
+}
+export function ruleValue(sources, name) {
+    const id = name.split('.').pop();
+    if (!/^[A-Za-z_$][\w$]*$/.test(id))
+        return null;
+    const re = new RegExp(`(?:^|[\\s,{(])${id.replace(/\$/g, '\\$')}\\s*[:=]\\s*(-?\\d+(?:\\.\\d+)?)(?![\\w.])`, 'm');
+    for (const s of sources) {
+        const m = re.exec(s.text);
+        if (m)
+            return { value: Number(m[1]), file: s.file };
+    }
+    return null;
+}
+export function readEnvelope(root, movement, defaults) {
+    if (!movement || typeof movement !== 'object') {
+        return { envelope: null, declared: false, why: 'no reach.movement in funpixel.json: jumps are not judged' };
+    }
+    const m = movement;
+    const sources = ruleSources(root);
+    const from = [];
+    const missing = [];
+    const num = (key) => {
+        const v = m[key];
+        if (v === undefined || v === null)
+            return undefined;
+        if (typeof v === 'number' && Number.isFinite(v)) {
+            from.push(`${key} ${v}`);
+            return v;
+        }
+        if (typeof v === 'string') {
+            const hit = ruleValue(sources, v);
+            if (hit) {
+                from.push(`${key} ${hit.value} (${v} in ${hit.file})`);
+                return hit.value;
+            }
+            missing.push(`${key}: no constant ${v} in ${RULE_FILES.slice(0, 2).join(' or ')}`);
+            return undefined;
+        }
+        missing.push(`${key}: a number or a rule constant's name`);
+        return undefined;
+    };
+    const unit = num('unit') ?? 1;
+    let height = num('jump_height');
+    let distance = num('jump_distance');
+    const v0 = num('jump_velocity'), g = num('gravity'), run = num('run_speed');
+    if (height === undefined && v0 !== undefined && g)
+        height = (v0 * v0) / (2 * g);
+    if (distance === undefined && run !== undefined && g) {
+        const v = v0 ?? (height !== undefined ? Math.sqrt(2 * g * height) : undefined);
+        if (v !== undefined)
+            distance = (2 * v * run) / g;
+    }
+    if (m.jump === false || height === 0) {
+        height = 0;
+        distance = 0;
+    }
+    if (missing.length)
+        return { envelope: null, declared: false, why: missing.join('; ') };
+    if (height === undefined || distance === undefined || unit <= 0) {
+        return { envelope: null, declared: false, why: 'reach.movement needs jump_height and jump_distance, or gravity with jump_velocity (or jump_height) and run_speed; "jump": false for a game without one' };
+    }
+    const size = Array.isArray(m.size) && m.size.length === 2 && m.size.every((n) => typeof n === 'number' && n > 0)
+        ? [m.size[0] / unit, m.size[1] / unit] : (from.push(`size ${defaults.size.join('×')} (default)`), defaults.size);
+    const step = num('step');
+    if (step === undefined)
+        from.push(`step ${defaults.step} (default)`);
+    const safe = num('safe_drop');
+    return {
+        declared: true,
+        envelope: {
+            height: height / unit, distance: distance / unit, airJumps: Math.max(0, Math.floor(num('air_jumps') ?? 0)),
+            dash: (num('dash') ?? 0) / unit, step: step === undefined ? defaults.step : step / unit, size,
+            safeDrop: safe === undefined ? null : safe / unit, from,
+        },
+    };
+}
+export const maxRise = (e) => Math.max(e.step, e.height * (e.airJumps + 1));
+export function reachAcross(e, rise) {
+    if (rise <= e.step && e.height <= 0)
+        return e.dash;
+    if (e.height <= 0 || rise > maxRise(e) + 1e-9)
+        return rise <= e.step ? e.dash : -Infinity;
+    const H = e.height, half = e.distance / 2;
+    const k = rise <= 0 ? 0 : Math.min(e.airJumps, Math.max(0, Math.ceil(rise / H - 1e-9) - 1));
+    return half * (k + 1 + Math.sqrt(Math.max(0, k + 1 - rise / H))) + (e.airJumps - k) * e.distance + e.dash;
+}
+export function describe(e, unit) {
+    if (e.height <= 0)
+        return `no jump; walks up ${fmt(e.step)} ${unit}${e.dash ? `, dash ${fmt(e.dash)}` : ''}`;
+    return `jump ${fmt(e.height)} ${unit} up, ${fmt(e.distance)} across${e.airJumps ? `, ${e.airJumps} air jump${e.airJumps > 1 ? 's' : ''}` : ''}${e.dash ? `, dash ${fmt(e.dash)}` : ''}; reaches ${fmt(maxRise(e))} up at most`;
+}
+export const fmt = (n) => (Math.round(n * 100) / 100).toString();

package/dist/reach/load.js

@@ -0,0 +1,84 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { readEnvelope } from "./envelope.js";
+import { checkSpec, isSpec } from "./spec3d.js";
+import { checkSide } from "./side.js";
+import { checkTop, parseTileLevel } from "./tiles.js";
+export const DEFAULT_LEVELS = ['design/level.json', 'design/levels'];
+export const DEFAULTS_2D = { step: 0, size: [1, 1] };
+export const DEFAULTS_3D = { step: 0.35, size: [0.6, 1.8] };
+export function readConfig(root, flagLevels) {
+    let manifest = null;
+    try {
+        manifest = JSON.parse(readFileSync(join(root, 'funpixel.json'), 'utf8'));
+    }
+    catch { }
+    const r = manifest?.reach && typeof manifest.reach === 'object' ? manifest.reach : {};
+    const listed = Array.isArray(r.levels) ? r.levels.filter((l) => typeof l === 'string') : null;
+    return {
+        levels: flagLevels ?? listed ?? DEFAULT_LEVELS,
+        movement: r.movement,
+        sealed: Array.isArray(r.sealed) ? r.sealed.filter((s) => typeof s === 'string') : [],
+        seen: Array.isArray(r.seen) ? r.seen.filter((s) => typeof s === 'string') : [],
+        from: flagLevels ? 'flag' : listed ? 'funpixel.json' : 'default',
+    };
+}
+function filesOf(root, entry) {
+    const p = join(root, entry);
+    if (!existsSync(p))
+        return [];
+    if (!statSync(p).isDirectory())
+        return [p];
+    return readdirSync(p).filter((f) => f.endsWith('.json')).sort().map((f) => join(p, f));
+}
+export function runReach(root, cfg) {
+    const env2 = readEnvelope(root, cfg.movement, DEFAULTS_2D);
+    const env3 = readEnvelope(root, cfg.movement, DEFAULTS_3D);
+    const walkOnly = { height: 0, distance: 0, airJumps: 0, dash: 0, step: DEFAULTS_3D.step, size: DEFAULTS_3D.size, safeDrop: null, from: [] };
+    const levels = [];
+    const skipped = [];
+    for (const entry of cfg.levels) {
+        const files = filesOf(root, entry);
+        if (!files.length && cfg.from !== 'default')
+            skipped.push({ file: entry, why: 'not found' });
+        for (const f of files) {
+            const rel = relative(root, f);
+            let raw;
+            try {
+                raw = JSON.parse(readFileSync(f, 'utf8'));
+            }
+            catch (e) {
+                skipped.push({ file: rel, why: `not JSON: ${e.message}` });
+                continue;
+            }
+            const list = Array.isArray(raw?.levels) ? raw.levels : [raw];
+            list.forEach((one, i) => {
+                const label = list.length > 1 ? `${rel}#${i}` : rel;
+                if (isSpec(one)) {
+                    levels.push(checkSpec(one, label, env3.envelope ?? walkOnly, env3.declared, cfg.sealed, cfg.seen ?? []));
+                    return;
+                }
+                const level = parseTileLevel(one, list.length > 1 ? `level ${i + 1}` : rel);
+                if (typeof level === 'string') {
+                    skipped.push({ file: label, why: level });
+                    return;
+                }
+                const unknown = level.unknown.length ? [{ status: 'note', what: `characters read as empty: ${level.unknown.map((c) => JSON.stringify(c)).join(' ')}`, why: 'name them in "legend" if they are walls, pickups or hazards' }] : [];
+                if (level.view === 'top') {
+                    const res = checkTop(level, label);
+                    res.findings.push(...unknown);
+                    levels.push(res);
+                    return;
+                }
+                if (!env2.envelope) {
+                    levels.push({ file: label, name: level.name, kind: 'side', size: `${level.cols}×${level.rows} tiles`, verdict: 'not_observed', gaps: [], findings: [{ status: 'not_observed', what: 'jumps not judged', why: env2.declared ? undefined : env2.why }] });
+                    return;
+                }
+                const res = checkSide(level, label, env2.envelope);
+                res.findings.push(...unknown);
+                levels.push(res);
+            });
+        }
+    }
+    return { levels, skipped, envelope2d: env2, envelope3d: env3 };
+}

package/dist/reach/side.js

@@ -0,0 +1,320 @@
+import { fmt, maxRise, reachAcross } from "./envelope.js";
+import { at, spawnsOf, targetsOf } from "./tiles.js";
+const EPS = 1e-3;
+const FINE_STATES = 400_000;
+const MAX_STATES = 2_000_000;
+class World {
+    cols;
+    rows;
+    half;
+    tall;
+    level;
+    constructor(level, env) {
+        this.level = level;
+        this.cols = level.cols;
+        this.rows = level.rows;
+        this.half = env.size[0] / 2 - EPS;
+        this.tall = env.size[1] - EPS;
+    }
+    role(c, k) {
+        if (c < 0 || c >= this.cols)
+            return 'solid';
+        if (k < 0 || k >= this.rows)
+            return 'empty';
+        return this.level.cells[this.rows - 1 - k][c];
+    }
+    any(x, y, hit) {
+        for (let c = Math.floor(x - this.half); c <= Math.floor(x + this.half); c++) {
+            for (let k = Math.floor(y + EPS); k <= Math.floor(y + this.tall); k++)
+                if (hit(this.role(c, k)))
+                    return true;
+        }
+        return false;
+    }
+    blocked = (x, y) => this.any(x, y, (r) => r === 'solid');
+    hurt = (x, y) => this.any(x, y, (r) => r === 'hazard');
+    ladder = (x, y) => this.role(Math.floor(x), Math.floor(y + EPS)) === 'ladder' || this.role(Math.floor(x), Math.floor(y + this.tall / 2)) === 'ladder';
+    groundAt(x, k, platforms = true) {
+        for (let c = Math.floor(x - this.half); c <= Math.floor(x + this.half); c++) {
+            const r = this.role(c, k - 1);
+            if (r === 'solid' || (platforms && r === 'platform'))
+                return true;
+        }
+        return false;
+    }
+    supported(x, y) {
+        return Math.abs(y - Math.round(y)) < 1e-6 && this.groundAt(x, Math.round(y));
+    }
+    touch(x, y, into) {
+        for (let c = Math.max(0, Math.floor(x - this.half)); c <= Math.min(this.cols - 1, Math.floor(x + this.half)); c++) {
+            for (let k = Math.max(0, Math.floor(y + EPS)); k <= Math.min(this.rows - 1, Math.floor(y + this.tall)); k++) {
+                const r = this.role(c, k);
+                if (r === 'exit' || r === 'pickup' || r === 'checkpoint')
+                    into.add((this.rows - 1 - k) * this.cols + c);
+            }
+        }
+    }
+}
+function nodesOf(w) {
+    const nodes = [];
+    const ledgeAt = new Map(), ladderAt = new Map();
+    const standing = (c, k) => {
+        const r = w.role(c, k - 1);
+        if (r !== 'solid' && r !== 'platform')
+            return false;
+        for (let h = k; h <= Math.floor(k + w.tall); h++) {
+            const o = w.role(c, h);
+            if (o === 'solid' || o === 'hazard')
+                return false;
+        }
+        return true;
+    };
+    for (let k = 0; k <= w.rows; k++) {
+        for (let c = 0; c < w.cols; c++) {
+            if (!standing(c, k))
+                continue;
+            let e = c;
+            while (e + 1 < w.cols && standing(e + 1, k))
+                e++;
+            for (let x = c; x <= e; x++)
+                ledgeAt.set(`${x},${k}`, nodes.length);
+            nodes.push({ kind: 'ledge', c0: c, c1: e, k0: k, k1: k });
+            c = e;
+        }
+    }
+    for (let c = 0; c < w.cols; c++) {
+        for (let k = 0; k < w.rows; k++) {
+            if (w.role(c, k) !== 'ladder')
+                continue;
+            let e = k;
+            while (w.role(c, e + 1) === 'ladder')
+                e++;
+            for (let y = k; y <= e; y++)
+                ladderAt.set(`${c},${y}`, nodes.length);
+            nodes.push({ kind: 'ladder', c0: c, c1: c, k0: k, k1: e + 1 });
+            k = e;
+        }
+    }
+    return { nodes, ledgeAt, ladderAt };
+}
+export function checkSide(level, file, env) {
+    const w = new World(level, env);
+    const base = { file, name: level.name, kind: 'side', size: `${level.cols}×${level.rows} tiles` };
+    const spawns = spawnsOf(level);
+    if (!spawns.length)
+        return { ...base, verdict: 'not_observed', gaps: [], findings: [{ status: 'not_observed', what: 'no spawn tile', why: 'mark where the player starts (S or @, or a legend entry "spawn")' }] };
+    const { nodes, ledgeAt, ladderAt } = nodesOf(w);
+    const H = env.height, D = env.distance;
+    const nodeOf = (x, y) => {
+        if (w.supported(x, y)) {
+            const k = Math.round(y);
+            for (let c = Math.floor(x - w.half); c <= Math.floor(x + w.half); c++) {
+                const id = ledgeAt.get(`${c},${k}`);
+                if (id !== undefined)
+                    return id;
+            }
+        }
+        if (w.ladder(x, y))
+            return ladderAt.get(`${Math.floor(x)},${Math.floor(y + EPS)}`) ?? ladderAt.get(`${Math.floor(x)},${Math.floor(y + w.tall / 2)}`) ?? -1;
+        return -1;
+    };
+    const vertical = (x, y, dy, n, N) => {
+        if (dy > 0) {
+            const head = y + w.tall;
+            for (let kb = Math.floor(head) + 1; kb <= Math.floor(head + dy); kb++) {
+                for (let c = Math.floor(x - w.half); c <= Math.floor(x + w.half); c++) {
+                    if (w.role(c, kb) === 'solid')
+                        return { y: kb - w.tall - EPS, n: N, landed: false };
+                }
+            }
+            return { y: y + dy, n: n + 1, landed: false };
+        }
+        for (let kb = Math.floor(y); kb >= Math.ceil(y + dy); kb--)
+            if (w.groundAt(x, kb))
+                return { y: kb, n: -1, landed: true };
+        return { y: y + dy, n: n + 1, landed: false };
+    };
+    const search = (N, limit) => {
+        const hs = H > 0 ? D / (2 * N) : 0.25;
+        const a = H > 0 ? (2 * H) / (N * N) : 0;
+        const reached = new Uint8Array(nodes.length), touched = new Set();
+        const seen = new Map();
+        const combos = (env.airJumps + 1) * 2;
+        const covered = (key, s) => {
+            for (let j = s.j; j <= env.airJumps; j++)
+                for (let d = s.d; d <= 1; d++) {
+                    const n = seen.get(key * combos + j * 2 + d);
+                    if (n !== undefined && n <= s.n)
+                        return true;
+                }
+            seen.set(key * combos + s.j * 2 + s.d, s.n);
+            return false;
+        };
+        const queue = [];
+        const push = (s) => {
+            const x = s.i * hs;
+            if (s.y < -w.tall - 2 || w.hurt(x, s.y))
+                return;
+            if (s.n < 0) {
+                const id = nodeOf(x, s.y);
+                if (id >= 0)
+                    reached[id] = 1;
+                else if (!w.ladder(x, s.y))
+                    s = { ...s, n: H > 0 ? N : 0 };
+            }
+            const down = s.n >= N;
+            const key = s.n < 0 ? -((s.i + 1) * 65536 + Math.round(s.y * 64) + 1024)
+                : ((s.i + 1) * 4096 + Math.round(s.y * 8) + 512) * 128 + (down ? 127 : s.n);
+            if (covered(key, s))
+                return;
+            w.touch(x, s.y, touched);
+            queue.push(s);
+        };
+        const fresh = { j: env.airJumps, d: env.dash > 0 ? 1 : 0 };
+        for (const [c, r] of spawns)
+            push({ i: Math.round((c + 0.5) / hs), y: level.rows - 1 - r, n: -1, ...fresh });
+        for (let q = 0; q < queue.length; q++) {
+            if (queue.length > limit)
+                return { reached, touched, overflow: true, hs };
+            const s = queue[q];
+            const x = s.i * hs;
+            if (s.n < 0) {
+                for (const dir of [-1, 1]) {
+                    const nx = (s.i + dir) * hs;
+                    if (!w.blocked(nx, s.y))
+                        push({ ...s, i: s.i + dir, n: w.supported(nx, s.y) || w.ladder(nx, s.y) ? -1 : (H > 0 ? N : 0), ...fresh });
+                }
+                if (H > 0)
+                    push({ ...s, n: 0, ...fresh });
+                if (w.ladder(x, s.y))
+                    for (const dy of [-0.5, 0.5])
+                        if (!w.blocked(x, s.y + dy))
+                            push({ ...s, y: s.y + dy, n: -1 });
+                if (w.supported(x, s.y) && !w.groundAt(x, Math.round(s.y), false))
+                    push({ ...s, y: s.y - 0.01, n: H > 0 ? N : 0 });
+                continue;
+            }
+            for (const dir of H > 0 ? [-1, 0, 1] : [0]) {
+                const nx = (s.i + dir) * hs;
+                if (w.blocked(nx, s.y))
+                    continue;
+                const v = vertical(nx, s.y, H > 0 ? (N - s.n - 0.5) * a : -0.5, s.n, N);
+                push({ ...s, i: s.i + dir, y: v.y, n: v.landed ? -1 : v.n });
+            }
+            if (s.j > 0 && s.n >= N)
+                push({ ...s, n: 0, j: s.j - 1 });
+            if (s.d > 0) {
+                for (const dir of [-1, 1]) {
+                    let i = s.i;
+                    for (let t = 0; t < Math.round(env.dash / hs); t++) {
+                        const nx = (i + dir) * hs;
+                        if (w.blocked(nx, s.y) || w.hurt(nx, s.y))
+                            break;
+                        i += dir;
+                        w.touch(nx, s.y, touched);
+                    }
+                    push({ ...s, i, n: H > 0 ? N : 0, d: 0 });
+                }
+            }
+            if (w.ladder(x, s.y))
+                push({ ...s, n: -1 });
+        }
+        return { reached, touched, overflow: false, hs };
+    };
+    const fine = H > 0 ? Math.min(64, Math.max(6, Math.ceil(4 * H), Math.ceil(D))) : 1;
+    let run = search(fine, FINE_STATES);
+    const coarse = run.overflow && H > 0 && fine > 4;
+    if (coarse)
+        run = search(Math.max(4, Math.ceil(D), Math.ceil(fine / 2)), MAX_STATES);
+    if (run.overflow) {
+        return { ...base, verdict: 'not_observed', gaps: [], findings: [{ status: 'not_observed', what: 'too large to search', why: `the search passed ${MAX_STATES} states; split the level into smaller files` }] };
+    }
+    const { reached, touched, hs } = run;
+    const rowOf = (k) => level.rows - 1 - Math.round(k);
+    const findings = [];
+    const gaps = [];
+    for (const t of targetsOf(level)) {
+        const [c, r] = t.cells[0];
+        const label = `${t.role} (${at(c, r)})`;
+        if (t.cells.some(([x, y]) => touched.has(y * level.cols + x))) {
+            findings.push({ status: 'pass', what: `${label} reached` });
+            continue;
+        }
+        const path = criticalPath(nodes, reached, { col: c, k: level.rows - 1 - r }, env, w.tall, 1.5 * hs);
+        findings.push({ status: 'fail', what: `${label} cannot be reached from the spawn`, why: path.length ? `${path.length} gap${path.length > 1 ? 's' : ''} on the way` : 'no ledge reaches it' });
+        for (const g of path) {
+            const right = g.to.c0 > g.from.c1;
+            gaps.push({ from: at(right ? g.from.c1 : g.from.c0, rowOf(g.from.k1)), to: at(right ? g.to.c0 : g.to.c1, rowOf(g.to.k0)), across: g.across, rise: g.rise, clears: g.clears, blocked: g.blocked });
+        }
+    }
+    const ledges = nodes.filter((n) => n.kind === 'ledge').length;
+    const never = nodes.filter((n, id) => n.kind === 'ledge' && !reached[id]).length;
+    if (never)
+        findings.push({ status: 'note', what: `${never} of ${ledges} ledges are never stood on` });
+    if (coarse)
+        findings.push({ status: 'note', what: `searched on a coarse tick (${fmt(hs)} tiles a step): a jump within ${fmt(1.5 * hs)} of the limit is called an edge` });
+    return { ...base, verdict: findings.some((f) => f.status === 'fail') ? 'fail' : 'pass', findings, gaps };
+}
+function linkCost(a, b, env, tol) {
+    const across = Math.max(0, b.c0 - (a.c1 + 1), a.c0 - (b.c1 + 1));
+    const rise = b.k0 > a.k1 ? b.k0 - a.k1 : b.k1 < a.k0 ? b.k1 - a.k0 : 0;
+    const top = maxRise(env);
+    const r = reachAcross(env, Math.min(rise, top));
+    const clears = rise > top || !Number.isFinite(r) ? null : r + env.size[0];
+    const short = Math.max(0, rise - top) + Math.max(0, across - (Number.isFinite(r) ? r + env.size[0] - tol : 0));
+    return { cost: short > 0 ? short + 0.01 : 0.5, across, rise, clears };
+}
+function criticalPath(nodes, reached, cell, env, tall, tol) {
+    const n = nodes.length;
+    const feet = cell.k - tall + 0.01;
+    const goal = { kind: 'ledge', c0: cell.col, c1: cell.col, k0: feet, k1: feet };
+    const cost = (u, to) => {
+        const l = linkCost(nodes[u], to, env, tol);
+        return { ...l, cost: l.cost === 0.5 && !reached[u] ? 0 : l.cost };
+    };
+    const dist = new Float64Array(n + 1).fill(Infinity);
+    const prev = new Int32Array(n + 1).fill(-1);
+    const done = new Uint8Array(n + 1);
+    for (let id = 0; id < n; id++)
+        if (reached[id])
+            dist[id] = 0;
+    for (;;) {
+        let u = -1;
+        for (let i = 0; i <= n; i++)
+            if (!done[i] && dist[i] < Infinity && (u < 0 || dist[i] < dist[u]))
+                u = i;
+        if (u < 0 || u === n)
+            break;
+        done[u] = 1;
+        const relax = (v, c) => { if (dist[u] + c < dist[v]) {
+            dist[v] = dist[u] + c;
+            prev[v] = u;
+        } };
+        relax(n, cost(u, goal).cost);
+        for (let v = 0; v < n; v++)
+            if (v !== u && !done[v] && !reached[v])
+                relax(v, cost(u, nodes[v]).cost);
+    }
+    const links = [];
+    for (let v = n; prev[v] >= 0; v = prev[v]) {
+        const u = prev[v];
+        const to = v === n ? goal : nodes[v];
+        const l = cost(u, to);
+        if (l.cost > 0)
+            links.unshift({ from: nodes[u], to, across: l.across, rise: l.rise, clears: l.clears, blocked: l.cost === 0.5 });
+    }
+    return links;
+}
+export function gapText(g, unit) {
+    const rise = g.rise > 0 ? `${fmt(g.rise)} up` : g.rise < 0 ? `${fmt(-g.rise)} down` : 'level';
+    const what = `${g.from} → ${g.to}: ${fmt(g.across)} ${unit} across, ${rise}`;
+    if (g.wall)
+        return `${what}; a wall with no opening the body fits through stands between them: a door, a lower sill or a gap opens the way`;
+    if (g.blocked)
+        return `${what}; the jump makes that on paper, so something solid is in the way (a ceiling, a wall, a hazard)`;
+    if (g.clears === null)
+        return `${what}; higher than the jump reaches`;
+    if (g.across <= g.clears)
+        return `${what}; at the very edge of the jump (it clears ${fmt(g.clears)} at that rise, only with a perfect takeoff): a player will miss it`;
+    return `${what}; the jump clears ${fmt(g.clears)} at that rise`;
+}