@funpixel/tools 0.0.0-stage → 0.1.1

package/templates/three-world/src/world.ts

@@ -0,0 +1,70 @@
+// The world's pieces: a renderer that reads (sRGB output, a capped pixel ratio), a ground that varies (two
+// colours mixed by noise under a surface's detail, a soft rise beyond the play), the layout's platforms
+// and pillars, and motes drifting in the air. The sky (sky.ts), the light (light.ts, light-math.ts), the
+// post (post.ts) and the dressing (dressing.ts) are each their own file; stage.ts puts one place of
+// places.json on stage with them. Everything reads PALETTE; budget.ts watches the cost.
+
+import * as THREE from 'three';
+import { random, type Box, type Post } from './layout';
+import { PALETTE } from './palette';
+import { budget } from './budget';
+import { heightAt } from './dressing-math';
+import { detailTexture, SURFACES, surfaceMaterial, type Surface } from './surfaces';
+
+export function makeRenderer(host: HTMLElement): THREE.WebGLRenderer {
+  const r = new THREE.WebGLRenderer({ antialias: true, powerPreference: 'high-performance' });
+  r.outputColorSpace = THREE.SRGBColorSpace; // tone mapping, exposure and shadows: the light rig (light.ts), from the place's light
+  budget.attach(r);
+  host.appendChild(r.domElement);
+  return r;
+}
+
+/** The ground: a disc flat under the play that rises past its edge (dressing-math heightAt, the one terrain
+ *  every prop stands on), coloured by noise between the place's two ground colours, its surface's detail over it. */
+export function ground(scene: THREE.Object3D, seed: number, surface = 'grass'): THREE.Mesh {
+  const geo = new THREE.RingGeometry(0, 80, 96, 48).rotateX(-Math.PI / 2), pos = geo.attributes.position as THREE.BufferAttribute, uv = geo.attributes.uv as THREE.BufferAttribute;
+  const colors: number[] = [], c = new THREE.Color(), n = (x: number, z: number) => Math.sin(x * 0.31 + seed) * Math.cos(z * 0.27 - seed) * 0.6 + Math.sin(x * 1.1 - z * 0.9) * 0.4;
+  for (let i = 0; i < pos.count; i++) {
+    const x = pos.getX(i), z = pos.getZ(i), t = 0.5 + 0.5 * n(x, z);
+    pos.setY(i, heightAt(x, z, seed)); uv.setXY(i, x, z);
+    c.copy(PALETTE.ground).lerp(PALETTE.ground2, t * 0.8); colors.push(c.r, c.g, c.b);
+  }
+  geo.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3)); geo.computeVertexNormals();
+  const kind = (SURFACES as string[]).includes(surface) ? (surface as Surface) : 'grass';
+  const mesh = new THREE.Mesh(geo, surfaceMaterial(kind));
+  mesh.name = 'ground'; mesh.receiveShadow = true; scene.add(mesh);
+  return mesh;
+}
+
+/** A box's UVs in metres per face (+x/−x, +y/−y, +z/−z: [u, v] spans), so its stone tiles at one size on every face. */
+function metric(g: THREE.BoxGeometry, [a, b, c, d, e, f]: number[]): THREE.BoxGeometry {
+  const uv = g.attributes.uv as THREE.BufferAttribute, span = [[a, b], [a, b], [c, d], [c, d], [e, f], [e, f]];
+  for (let i = 0; i < uv.count; i++) { const [su, sv] = span[Math.floor(i / 4)]; uv.setXY(i, (uv.getX(i) * su) / 2.5, (uv.getY(i) * sv) / 2.5); }
+  return g;
+}
+
+/** The layout's platforms and pillars: what the rules collide with, drawn as solid, lit shapes with a trim. */
+export function solids(scene: THREE.Object3D, boxes: Box[], posts: Post[]): THREE.Object3D[] {
+  const out: THREE.Object3D[] = [], stone = new THREE.MeshStandardMaterial({ color: PALETTE.stone, roughness: 0.85, map: detailTexture('flagstone') }), trim = new THREE.MeshStandardMaterial({ color: PALETTE.stone.clone().multiplyScalar(0.7), roughness: 0.9 });
+  for (const b of boxes) {
+    const m = new THREE.Mesh(metric(new THREE.BoxGeometry(b.hw * 2, b.top, b.hd * 2), [b.hd * 2, b.top, b.hw * 2, b.hd * 2, b.hw * 2, b.top]), stone); m.position.set(b.x, b.top / 2, b.z);
+    const lip = new THREE.Mesh(new THREE.BoxGeometry(b.hw * 2 + 0.16, 0.12, b.hd * 2 + 0.16), trim); lip.position.set(b.x, b.top - 0.04, b.z);
+    for (const o of [m, lip]) { o.castShadow = o.receiveShadow = true; scene.add(o); out.push(o); }
+  }
+  const pillar = new THREE.InstancedMesh(new THREE.CylinderGeometry(1, 1.12, 1, 10), stone, posts.length), mat = new THREE.Matrix4();
+  posts.forEach((p, i) => pillar.setMatrixAt(i, mat.compose(new THREE.Vector3(p.x, p.h / 2, p.z), new THREE.Quaternion(), new THREE.Vector3(p.r, p.h, p.r))));
+  pillar.castShadow = pillar.receiveShadow = true; scene.add(pillar); out.push(pillar);
+  return out;
+}
+
+/** Motes of light drifting up through the air (one draw call): the place breathes behind the title and the play. Call the result every frame. */
+export function motes(scene: THREE.Object3D, map: THREE.Texture, count = 90): (t: number) => void {
+  const s = { seed: 77 }, base = Array.from({ length: count }, () => [(random(s) - 0.5) * 40, random(s) * 8, (random(s) - 0.5) * 40, 0.3 + random(s)]);
+  const geo = new THREE.BufferGeometry(), pos = new Float32Array(count * 3);
+  geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+  scene.add(new THREE.Points(geo, new THREE.PointsMaterial({ map, color: PALETTE.pickup, size: 0.22, transparent: true, opacity: 0.8, depthWrite: false, blending: THREE.AdditiveBlending })));
+  return (t) => {
+    base.forEach(([x, y, z, v], i) => { pos.set([x + Math.sin(t * v + i) * 0.6, (y + t * v * 0.5) % 8, z + Math.cos(t * v * 0.7 + i) * 0.6], i * 3); });
+    geo.attributes.position.needsUpdate = true;
+  };
+}

package/templates/three-world/test/feel.json

@@ -0,0 +1,29 @@
+{
+  "name": "feel",
+  "viewport": "desktop",
+  "seed": 1,
+  "steps": [
+    "until screen=title 3000",
+    "press Space",
+    "until screen=playing 3000",
+    "hold ArrowRight 300",
+    "wait 400",
+    "hold Space 500",
+    "wait 600",
+    "hold Space 500",
+    "wait 900",
+    "until control=false 10000",
+    "until screen=lost 3000",
+    "retry press Space",
+    "wait 500"
+  ],
+  "expect": {
+    "jump height": "1.6 body",
+    "time in the air": "0.65 s",
+    "flare tell": "0.7 s",
+    "death beat": "0.6 s",
+    "restart": "under 2 s",
+    "coyote time (late jump)": "0.1 s",
+    "jump buffer (early press)": "0.1 s"
+  }
+}

package/templates/three-world/test/probes.ts

@@ -0,0 +1,65 @@
+// The rules played by five policies over 100 seeds each (src/probe-kit.ts), printed as JSON for
+// `npx @funpixel/tools sim`, which reads it: standing still must not win, a naive player should not do as
+// well as a sharp one unless the design says so, doing what the game teaches should pay. Rewrite the
+// policies with your rules: each sees only what a player could see. Run: node --import ./test/resolve.mjs test/probes.ts
+// This file and src/rules.ts are one piece: when you rewrite the rules, rewrite this in the same step,
+// and set the seconds per run past the length the game means to have (sim reads play length from the
+// sharp bot: 15 min and an ending, the design doc's play-length line). With levels, add level(run),
+// and name the ending in ended(run), in the game below.
+
+import { FLARE_TELL, GOAL, newRun, tick, type Input, type Run } from '../src/rules.ts';
+import { bestInput } from '../src/bot.ts';
+import { cohort, stageMoment, type Ev, type Policy, type ProbeGame } from '../src/probe-kit.ts';
+import { humanRate } from '../src/probe-human.ts';
+
+const burned = new WeakSet<Run>(), DT = 1 / 30;
+const game: ProbeGame<Run, Input> = {
+  newRun, dt: DT,
+  step(run, input) {
+    const { events, outcome } = tick(run, input, DT);
+    const ev: Ev[] = events.map((e) => ({ type: e.type }));
+    if (outcome === 'lost' && run.timeLeft > 0) { burned.add(run); ev.push({ type: 'burned' }); }
+    return ev;
+  },
+  outcome: (run) => (run.score >= GOAL ? 'won' : run.timeLeft <= 0 || burned.has(run) ? 'lost' : null),
+  progress: (run) => run.score,
+  firstSuccess: (run) => run.score >= 4,
+  broken: (run) => (![run.x, run.y, run.z].every(Number.isFinite) ? 'position is not a number' : run.y < -0.01 ? 'under the ground' : null),
+};
+
+/** Straight at the nearest pickup on the ground, never jumping, flares or not: the naive line. */
+const naiveLine = (run: Run): Input => {
+  const p = run.pickups.filter((q) => !q.taken).sort((a, b) => Math.hypot(a.x - run.x, a.z - run.z) - Math.hypot(b.x - run.x, b.z - run.z))[0];
+  if (!p) return { x: 0, z: 0 };
+  const d = Math.hypot(p.x - run.x, p.z - run.z) || 1;
+  return { x: (p.x - run.x) / d, z: (p.z - run.z) / d };
+};
+/** Decide every `react` seconds, as a hand would; between decisions the stick stays where it was, presses do not repeat. */
+const every = (react: number, choose: (run: Run, rnd: () => number) => Input) => (seed: number) => {
+  let wait = 0, last: Input = { x: 0, z: 0 }, s = seed;
+  const rnd = () => ((s = (s * 1103515245 + 12345) >>> 0) / 4294967296);
+  return (run: Run): Input => { if ((wait -= DT) > 0) return { ...last, jump: false, dash: false }; wait = react; return (last = choose(run, rnd)); };
+};
+
+const policies: Policy<Run, Input>[] = [
+  { name: 'idle', role: 'idle', says: 'never touches the stick', make: () => () => ({ x: 0, z: 0 }) },
+  { name: 'naive', role: 'naive', says: 'runs straight at the nearest pickup every 0.3 s, never jumps, flares or not', make: every(0.3, naiveLine) },
+  { name: 'taught', role: 'taught', says: 'what the how-to says: run to the lights, jump up to the high ones, jump as a ring flares, every 0.2 s',
+    make: every(0.2, (run) => ({ ...naiveLine(run), jump: run.grounded && (!!run.flare && run.flare.t > FLARE_TELL - 0.15 || run.pickups.some((p) => !p.taken && p.y > 1 && Math.hypot(p.x - run.x, p.z - run.z) < 2.4)) })) },
+  { name: 'skilled', role: 'skilled', says: 'nearest pickup by route, out of every ring, jumps for the high ones, every 0.1 s', make: every(0.1, bestInput) },
+  { name: 'novice', role: 'novice', says: 'nearest pickup every 0.5 s, one decision in five aimed wrong; jumps when it sees a ring under it', make: every(0.5, (run, rnd) => {
+    const i = bestInput(run), off = rnd() < 0.2;
+    return off ? { x: -i.z, z: i.x } : i;
+  }) },
+];
+const best = policies.find((p) => p.role === 'skilled')!;
+// The sharp line again at a thumb's rate (12 decisions a second, 200 ms to react): a level only the bot clears is a wall.
+policies.push(humanRate({ ...best, make: () => (run) => bestInput(run) }, game.dt, { rest: { x: 0, z: 0 }, hold: true }));
+
+const seeds = Array.from({ length: 100 }, (_, i) => i + 1);
+console.log(JSON.stringify({
+  probes: 1,
+  cohorts: policies.map((p) => cohort(game, p, seeds, 60)),
+  moments: [{ name: 'streak', says: 'pickups in 3 s', candidates: stageMoment(game, best, { seeds: seeds.slice(0, 20), at: [3, 6, 9], window: 3, score: (e) => (e.type === 'pickup' ? 1 : 0) }) }],
+  timelines: [],
+}));

package/templates/three-world/test/resolve.mjs

@@ -0,0 +1,13 @@
+// Lets Node run src/ files that import each other without an extension ('./layout'), as vite does, so
+// `npm test` and `node test/probes.ts` load the same rules the game bundles. Node 22.15+.
+import { registerHooks } from 'node:module';
+
+registerHooks({
+  resolve(spec, ctx, next) {
+    try { return next(spec, ctx); } catch (e) {
+      if (!/^\.{1,2}\//.test(spec) || /\.[cm]?[jt]sx?$/.test(spec)) throw e;
+      for (const ext of ['.ts', '/index.ts']) { try { return next(spec + ext, ctx); } catch { /* next */ } }
+      throw e;
+    }
+  },
+});

package/templates/three-world/test/rules.test.ts

@@ -0,0 +1,81 @@
+// The rules under Node: `npm test` (Node 22.18+ runs TypeScript as is; test/resolve.mjs lets the rules'
+// files import each other as vite does). Kept outside src/, so the platform's build never type-checks it.
+// Name a test after the rule it proves, and grow this file with the rules.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { FLARE_FIRST, FLARE_LATE, FLARE_TELL, GOAL, MOVE, newRun, phase, ROUND_SECONDS, tick, type Run } from '../src/rules.ts';
+import { botRound } from '../src/bot.ts';
+
+const still = { x: 0, z: 0 };
+const run = (r: Run, input: Parameters<typeof tick>[1], seconds: number) => { let out = null; for (let t = 0; t < seconds - 1e-9; t += 1 / 60) out = tick(r, input, 1 / 60).outcome ?? out; return out; };
+
+test(`the hero reaches full speed (${MOVE.run} m/s) in about a sixth of a second and stops as quickly`, () => {
+  const r = newRun(1); r.boxes = []; r.posts = [];
+  run(r, { x: 1, z: 0 }, 0.2);
+  assert.ok(Math.abs(Math.hypot(r.vx, r.vz) - MOVE.run) < 0.01, `speed ${Math.hypot(r.vx, r.vz)}`);
+  run(r, still, 0.25);
+  assert.equal(Math.hypot(r.vx, r.vz), 0);
+});
+
+test(`a jump rises ${MOVE.jumpHeight} m held, lower on a tap, and lands`, () => {
+  const peak = (held: boolean) => { const r = newRun(1); r.boxes = []; let top = 0; tick(r, { ...still, jump: true, held }, 1 / 60); for (let i = 0; i < 90; i++) { tick(r, { ...still, held }, 1 / 60); top = Math.max(top, r.y); } return { top, r }; };
+  const full = peak(true), tap = peak(false);
+  assert.ok(Math.abs(full.top - MOVE.jumpHeight) < 0.08, `held peak ${full.top}`);
+  assert.ok(tap.top < full.top * 0.75, `a tap peaks lower: ${tap.top}`);
+  assert.ok(full.r.grounded && full.r.y === 0, 'back on the ground');
+});
+
+test(`coyote time: a jump ${MOVE.coyote} s after walking off a ledge still fires; later it does not`, () => {
+  const off = (late: number) => {
+    const r = newRun(1); r.posts = []; r.boxes = [{ x: 0, z: 0, hw: 1, hd: 1, top: 1 }]; r.y = 1;
+    for (let i = 0; i < 120 && r.grounded; i++) tick(r, { x: 1, z: 0 }, 1 / 120);
+    assert.equal(r.grounded, false, 'walked off');
+    tick(r, { x: 1, z: 0 }, late);
+    const jumps = r.jumps; tick(r, { x: 1, z: 0, jump: true }, 1 / 120);
+    return r.jumps > jumps;
+  };
+  assert.ok(off(MOVE.coyote - 0.03), 'just after the edge');
+  assert.ok(!off(MOVE.coyote + 0.05), 'too late');
+});
+
+test(`jump buffer: a press ${MOVE.buffer} s before landing jumps on landing`, () => {
+  const r = newRun(1); r.boxes = [];
+  tick(r, { ...still, jump: true }, 1 / 120);
+  while (!(r.vy < 0 && r.y < 0.4)) tick(r, still, 1 / 120);
+  tick(r, { ...still, jump: true }, 1 / 120);
+  run(r, still, 0.15);
+  assert.equal(r.jumps, 2, 'the early press fired on landing');
+});
+
+test('platforms are walls below their top and floors above it; pillars push the hero round', () => {
+  const r = newRun(1); r.posts = []; r.boxes = [{ x: 3, z: 0, hw: 1, hd: 1, top: 1 }];
+  run(r, { x: 1, z: 0 }, 1);
+  assert.ok(r.x < 2 - MOVE.radius + 0.01, `stopped at the wall: ${r.x}`);
+  r.y = 1.2; r.x = 3; r.grounded = false;
+  run(r, still, 0.5);
+  assert.equal(r.y, 1, 'stands on the top');
+});
+
+test(`a flare glows ${FLARE_TELL} s, burns after ${FLARE_LATE} s more, and a jump late in the glow clears it`, () => {
+  const r = newRun(2);
+  assert.equal(tick(r, still, FLARE_FIRST).outcome, null);
+  assert.equal(phase(r), 'tell');
+  assert.equal(tick(r, still, FLARE_TELL + FLARE_LATE - 0.05).outcome, null, 'the warning is not the hit');
+  assert.equal(tick(r, still, 0.08).outcome, 'lost');
+  const j = newRun(2); tick(j, still, FLARE_FIRST + FLARE_TELL - 0.1);
+  assert.equal(tick(j, { ...still, jump: true }, 0.6).outcome, null);
+});
+
+test(`collecting ${GOAL} wins; the clock running out (${ROUND_SECONDS} s) loses; standing still loses`, () => {
+  assert.equal(botRound(newRun(5), 0.12), 'won');
+  assert.equal(botRound(newRun(5), null), 'lost');
+  const r = newRun(5); r.nextFlare = Infinity;
+  assert.equal(tick(r, still, ROUND_SECONDS).outcome, 'lost');
+});
+
+test('the same seed lays out and replays the same round', () => {
+  const a = newRun(9), b = newRun(9);
+  for (let i = 0; i < 60; i++) { tick(a, { x: 0.6, z: 1 }, 1 / 30); tick(b, { x: 0.6, z: 1 }, 1 / 30); }
+  assert.deepEqual(a, b);
+});

package/unity/com.funpixel.probe/Editor/Funpixel.Probe.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Funpixel.Probe.Editor",
+    "rootNamespace": "Funpixel.Probe.Editor",
+    "references": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/unity/com.funpixel.probe/Editor/Funpixel.Probe.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5b4d0f132f31964b51db291e46c0a66f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Editor/ProbeBuild.cs

@@ -0,0 +1,97 @@
+// The development player funtools unity probe, play and capture launch, built through the machine-wide queue:
+//
+//   funtools unity run -- -executeMethod Funpixel.Probe.Editor.ProbeBuild.Mac -fpOut <folder>
+//   funtools unity run -- -executeMethod Funpixel.Probe.Editor.ProbeBuild.IosSimulator -fpOut <folder>
+//
+// The scenes enabled in Build Settings, as a Development build (so Funpixel.Probe.Player is compiled in); with
+// -fpCapture, a non-development build with FUNPIXEL_PROBE passed for this build only (extraScriptingDefines), so judged
+// frames carry no development watermark (the render counters read nothing there: measure with the development one).
+// It changes no ProjectSettings: the Simulator SDK it sets for an iOS build is put back before the Editor saves, and the active
+// build target (kept in Library/) is switched back afterwards unless -fpKeepTarget. The result is one line in the log,
+// "[FunpixelProbe] build {…}", and <folder>/funpixel-probe-build.json, which funtools reads to reuse the player.
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+namespace Funpixel.Probe.Editor
+{
+    public static class ProbeBuild
+    {
+        public static void Mac() => Exit(Build(BuildTarget.StandaloneOSX));
+        public static void IosSimulator() => Exit(Build(BuildTarget.iOS));
+
+        static void Exit(int code) { if (Application.isBatchMode) EditorApplication.Exit(code); }
+
+        static string Arg(string name)
+        {
+            var a = Environment.GetCommandLineArgs();
+            int i = Array.FindIndex(a, x => string.Equals(x, name, StringComparison.OrdinalIgnoreCase));
+            return i >= 0 && i + 1 < a.Length && !a[i + 1].StartsWith("-") ? a[i + 1] : null;
+        }
+
+        static bool Has(string name) => Environment.GetCommandLineArgs().Any(x => string.Equals(x, name, StringComparison.OrdinalIgnoreCase));
+
+        static string Safe(string s)
+        {
+            var t = new string((s ?? "Game").Select(c => char.IsLetterOrDigit(c) || c == ' ' || c == '-' || c == '_' ? c : '_').ToArray()).Trim();
+            return t.Length > 0 ? t : "Game";
+        }
+
+        static string Q(string s) => s == null ? "null" : "\"" + s.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
+
+        public static int Build(BuildTarget target)
+        {
+            bool ios = target == BuildTarget.iOS;
+            bool capture = Has("-fpCapture");
+            string outDir = Path.GetFullPath(Arg("-fpOut") ?? Path.Combine("Builds", "FunpixelProbe", (ios ? "ios-sim" : "mac") + (capture ? "-capture" : "")));
+            var scenes = EditorBuildSettings.scenes.Where(s => s.enabled && File.Exists(s.path)).Select(s => s.path).ToArray();
+            if (scenes.Length == 0)
+            {
+                Debug.LogError("[FunpixelProbe] build {\"result\":\"NoScenes\",\"error\":\"no scene is enabled in Build Settings\"}");
+                return 2;
+            }
+            Directory.CreateDirectory(outDir);
+            string location = ios ? Path.Combine(outDir, "xcode") : Path.Combine(outDir, Safe(PlayerSettings.productName) + ".app");
+            var original = EditorUserBuildSettings.activeBuildTarget;
+            var sdk = PlayerSettings.iOS.sdkVersion;
+            var started = DateTime.UtcNow;
+            BuildSummary s = default;
+            string error = null;
+            try
+            {
+                if (ios) PlayerSettings.iOS.sdkVersion = iOSSdkVersion.SimulatorSDK;
+                var report = BuildPipeline.BuildPlayer(new BuildPlayerOptions
+                {
+                    scenes = scenes,
+                    locationPathName = location,
+                    target = target,
+                    targetGroup = BuildPipeline.GetBuildTargetGroup(target),
+                    options = capture ? BuildOptions.None : BuildOptions.Development,
+                    extraScriptingDefines = capture ? new[] { ReleaseGuard.Define } : null,
+                });
+                s = report.summary;
+                if (s.result != BuildResult.Succeeded)
+                    error = string.Join("; ", report.steps.SelectMany(st => st.messages).Where(m => m.type == LogType.Error || m.type == LogType.Exception).Select(m => m.content).Take(8));
+            }
+            catch (Exception e) { error = e.GetType().Name + ": " + e.Message; }
+            finally
+            {
+                if (ios) PlayerSettings.iOS.sdkVersion = sdk;
+                if (EditorUserBuildSettings.activeBuildTarget != original && !Has("-fpKeepTarget"))
+                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildPipeline.GetBuildTargetGroup(original), original);
+            }
+            bool ok = error == null && s.result == BuildResult.Succeeded;
+            string line = "{\"result\":" + Q(ok ? "Succeeded" : s.result.ToString()) + ",\"target\":" + Q(ios ? "ios-sim" : "mac") + ",\"variant\":" + Q(capture ? "capture" : "development") +
+                ",\"path\":" + Q(location) + ",\"scenes\":" + scenes.Length + ",\"seconds\":" + ((int)(DateTime.UtcNow - started).TotalSeconds) +
+                ",\"bytes\":" + (ok ? s.totalSize : 0) + ",\"unity\":" + Q(Application.unityVersion) + ",\"product\":" + Q(PlayerSettings.productName) +
+                ",\"bundle\":" + Q(PlayerSettings.GetApplicationIdentifier(UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(BuildPipeline.GetBuildTargetGroup(target)))) +
+                ",\"built_at\":" + Q(DateTime.UtcNow.ToString("o")) + ",\"error\":" + Q(error) + "}";
+            if (ok) Debug.Log("[FunpixelProbe] build " + line); else Debug.LogError("[FunpixelProbe] build " + line);
+            File.WriteAllText(Path.Combine(outDir, "funpixel-probe-build.json"), line + "\n");
+            return ok ? 0 : 1;
+        }
+    }
+}

package/unity/com.funpixel.probe/Editor/ProbeBuild.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e036c66d81a86c52460ded4b85aa6b7a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Editor/ReleaseGuard.cs

@@ -0,0 +1,23 @@
+// FUNPIXEL_PROBE compiles the probe and the bridge into a non-development build: right for one capture build (passed
+// by ProbeBuild through BuildPlayerOptions.extraScriptingDefines, so it never reaches ProjectSettings), wrong for any
+// build after it. A build whose Player Settings carry the define fails here, before anything is built.
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+
+namespace Funpixel.Probe.Editor
+{
+    public sealed class ReleaseGuard : IPreprocessBuildWithReport
+    {
+        public const string Define = "FUNPIXEL_PROBE";
+        public int callbackOrder => -1000;
+
+        public void OnPreprocessBuild(BuildReport report)
+        {
+            var named = NamedBuildTarget.FromBuildTargetGroup(report.summary.platformGroup);
+            PlayerSettings.GetScriptingDefineSymbols(named, out string[] defines);
+            if (System.Array.IndexOf(defines, Define) >= 0)
+                throw new BuildFailedException($"{Define} is in Player Settings → Scripting Define Symbols for {named.TargetName}: it would put com.funpixel.probe's player bridge into this build. Remove it; a capture build passes it for itself (funtools unity capture).");
+        }
+    }
+}

package/unity/com.funpixel.probe/Editor/ReleaseGuard.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d9f45c58d5319023f4a416c3c2530e55
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 31c58484adf140454f312782e88fe829
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/Api/Funpixel.Probe.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "Funpixel.Probe",
+    "rootNamespace": "Funpixel.Probe",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/unity/com.funpixel.probe/Runtime/Api/Funpixel.Probe.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 25cdcb288279b3d12846a1856db9d77f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/Api/FunpixelProbe.cs

@@ -0,0 +1,146 @@
+// The game's side of com.funpixel.probe: the few calls a game makes so funtools can read and drive it.
+//
+//   FunpixelProbe.State("score", () => score);              a fact `state` returns (score, screen, level, lives)
+//   FunpixelProbe.View("title", () => ShowTitle());          a view `capture --all` enters and shoots, in this order
+//   FunpixelProbe.Target("jump", () => jumpButton.rect);     a named tap target in screen pixels (Unity's bottom-left origin)
+//   FunpixelProbe.Command("level", a => StartLevel(...));    a command of the game's own (`{"cmd":"level","id":"2"}`)
+//   FunpixelProbe.MarkCapture();                              the game took its own screenshot this frame: the probe skips it
+//   FunpixelProbe.WorkBegin(); … FunpixelProbe.WorkEnd();     the game's own work in a frame (tells its hitches from the host's)
+//   FunpixelProbe.Note("level 3 built");                      a word for the current frame (shown with a hitch in it)
+//
+// This assembly is always compiled so a game's calls need no #if, but every method is [Conditional] on
+// DEVELOPMENT_BUILD, UNITY_EDITOR or FUNPIXEL_PROBE: in a release build the C# compiler removes the calls and their
+// arguments, and these bodies are empty. The probe and the bridge that read these registries live in
+// Funpixel.Probe.Player, an assembly whose define constraints leave it out of every release build. FUNPIXEL_PROBE is
+// for a capture build (no development watermark in judged frames): ProbeBuild passes it for that one build, and
+// ReleaseGuard fails any build whose Player Settings carry it.
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+[assembly: InternalsVisibleTo("Funpixel.Probe.Player")]
+[assembly: InternalsVisibleTo("Funpixel.Probe.Tests")]
+
+namespace Funpixel.Probe
+{
+    public static class FunpixelProbe
+    {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+        internal sealed class ViewEntry { public string Name; public Action Enter; public int SettleFrames; }
+
+        internal static readonly Dictionary<string, Func<object>> States = new Dictionary<string, Func<object>>();
+        internal static readonly List<ViewEntry> Views = new List<ViewEntry>();
+        internal static readonly Dictionary<string, Func<Rect>> Targets = new Dictionary<string, Func<Rect>>(StringComparer.OrdinalIgnoreCase);
+        internal static readonly Dictionary<string, Func<IDictionary<string, object>, object>> Commands = new Dictionary<string, Func<IDictionary<string, object>, object>>(StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>The last frame the game captured itself (Time.frameCount), or -1.</summary>
+        internal static int CaptureFrame = -1;
+        /// <summary>The game's own work in the frame so far (ms), and the frame it belongs to.</summary>
+        internal static double WorkMs, PrevWorkMs;
+        internal static int WorkFrame = -1, PrevWorkFrame = -1;
+        internal static string NoteText, PrevNoteText;
+        internal static int NoteFrame = -1, PrevNoteFrame = -1;
+        static readonly Stopwatch work = new Stopwatch();
+        static int workDepth;
+
+        static void RollWork()
+        {
+            int f = Time.frameCount;
+            // The frame before is kept: a FixedUpdate can start this frame's work before the probe has read the last one.
+            if (WorkFrame != f) { PrevWorkFrame = WorkFrame; PrevWorkMs = WorkMs; WorkFrame = f; WorkMs = 0; }
+        }
+
+        /// <summary>The game's work in <paramref name="frame"/> (ms), or -1 when it named none.</summary>
+        internal static double TakeWork(int frame) => WorkFrame == frame ? WorkMs : PrevWorkFrame == frame ? PrevWorkMs : -1;
+        internal static string TakeNote(int frame) => NoteFrame == frame ? NoteText : PrevNoteFrame == frame ? PrevNoteText : null;
+#endif
+
+        /// <summary>A fact the bridge's <c>state</c> command returns under <paramref name="key"/> (read when asked, on the main thread).</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void State(string key, Func<object> read)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            if (string.IsNullOrEmpty(key)) return;
+            if (read == null) States.Remove(key); else States[key] = read;
+#endif
+        }
+
+        /// <summary>A view or screen <c>capture --all</c> enters with <paramref name="enter"/> and shoots after
+        /// <paramref name="settleFrames"/> frames. Registered views are shot in the order they were added.</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void View(string name, Action enter, int settleFrames = 10)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            if (string.IsNullOrEmpty(name) || enter == null) return;
+            Views.RemoveAll(v => v.Name == name);
+            Views.Add(new ViewEntry { Name = name, Enter = enter, SettleFrames = Math.Max(1, settleFrames) });
+#endif
+        }
+
+        /// <summary>A named tap target: its rect in screen pixels, Unity's bottom-left origin (a HUD button the
+        /// EventSystem doesn't own). <c>tap {"target": name}</c> presses its centre.</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void Target(string name, Func<Rect> screenRect)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            if (string.IsNullOrEmpty(name)) return;
+            if (screenRect == null) Targets.Remove(name); else Targets[name] = screenRect;
+#endif
+        }
+
+        /// <summary>A command of the game's own: <c>{"cmd": name, …}</c> calls <paramref name="run"/> with the request's
+        /// fields; what it returns is the reply's <c>value</c> (a string, number, bool, list or dictionary).</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void Command(string name, Func<IDictionary<string, object>, object> run)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            if (string.IsNullOrEmpty(name)) return;
+            if (run == null) Commands.Remove(name); else Commands[name] = run;
+#endif
+        }
+
+        /// <summary>The game captured the screen itself this frame: the probe leaves this frame and the 4 after it out.</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void MarkCapture()
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            CaptureFrame = Time.frameCount;
+#endif
+        }
+
+        /// <summary>The game's own work starts (pair with <see cref="WorkEnd"/>; nested pairs count once).</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void WorkBegin()
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            RollWork();
+            if (workDepth++ == 0) work.Restart();
+#endif
+        }
+
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void WorkEnd()
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            if (workDepth == 0) return;
+            if (--workDepth > 0) return;
+            work.Stop();
+            RollWork();
+            WorkMs += work.Elapsed.TotalMilliseconds;
+#endif
+        }
+
+        /// <summary>A word for this frame, shown beside it if it turns out to be a hitch.</summary>
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR"), Conditional("FUNPIXEL_PROBE")]
+        public static void Note(string what)
+        {
+#if DEVELOPMENT_BUILD || UNITY_EDITOR || FUNPIXEL_PROBE
+            int f = Time.frameCount;
+            if (NoteFrame != f) { PrevNoteFrame = NoteFrame; PrevNoteText = NoteText; NoteFrame = f; NoteText = what; }
+            else NoteText = NoteText + ", " + what;
+#endif
+        }
+    }
+}

package/unity/com.funpixel.probe/Runtime/Api/FunpixelProbe.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 800617e3d4093949d45ae5ed2f2d87ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/unity/com.funpixel.probe/Runtime/Api.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6480897442f15c0c16ca6a630c436a69
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: