sindicate 0.13.0 → 0.16.0

package/tools/ExportKiwiRoadMaterials.cs

@@ -0,0 +1,145 @@
+// EXPORT KIWI ROAD MATERIALS — drop this file into Kiwi's Assets/Editor/ folder, let
+// Unity compile, then run  Tools ▸ Sindicate ▸ Export Road Materials.  (~10 seconds.)
+//
+// It does NOT export models (Sindicate already recovered the geometry). It walks every
+// prefab and records each part's UNITY-RESOLVED world transform (the truth — no more
+// hierarchy archaeology) alongside its material stack. It also walks every
+// road prefab (AIGenerateMap/Prefabs/Roads, JunctionPrefabs, RoadPrefabs) and writes ONE
+// truth file mapping every renderer's mesh to its real material stack:
+//   Assets/SindicateExport/road-materials.json
+//     { entries: [{ prefab, object, mesh, meshGuid,
+//                   materials: [{ name, shader, mainTex, color, tiling, offset }] }] }
+// …and copies every referenced texture into Assets/SindicateExport/textures/.
+// Copy the SindicateExport folder to Nick's Sites machine and Sindicate's assembler
+// applies exact materials to the already-recovered assemblies.
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+public static class ExportKiwiRoadMaterials
+{
+    static readonly string[] ROOTS = {
+        "Assets/AIGenerateMap/Prefabs/Roads",
+        "Assets/AIGenerateMap/JunctionPrefabs",
+        "Assets/AIGenerateMap/RoadPrefabs",
+    };
+
+    [MenuItem("Tools/Sindicate/Export Road Materials")]
+    public static void Export()
+    {
+        var outDir = "Assets/SindicateExport";
+        var texDir = Path.Combine(outDir, "textures");
+        Directory.CreateDirectory(texDir);
+
+        var sb = new StringBuilder();
+        sb.Append("{\"entries\":[");
+        bool first = true;
+        var texturesCopied = new HashSet<string>();
+        int prefabCount = 0;
+
+        foreach (var root in ROOTS)
+        {
+            foreach (var guid in AssetDatabase.FindAssets("t:Prefab", new[] { root }))
+            {
+                var path = AssetDatabase.GUIDToAssetPath(guid);
+                var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
+                if (prefab == null) continue;
+                prefabCount++;
+
+                foreach (var r in prefab.GetComponentsInChildren<MeshRenderer>(true))
+                {
+                    var mf = r.GetComponent<MeshFilter>();
+                    if (mf == null || mf.sharedMesh == null) continue;
+                    var meshPath = AssetDatabase.GetAssetPath(mf.sharedMesh);
+                    var meshGuid = AssetDatabase.AssetPathToGUID(meshPath);
+
+                    if (!first) sb.Append(",");
+                    first = false;
+                    sb.Append("{\"prefab\":").Append(J(Path.GetFileNameWithoutExtension(path)));
+                    sb.Append(",\"object\":").Append(J(r.gameObject.name));
+                    sb.Append(",\"mesh\":").Append(J(Path.GetFileName(meshPath)));
+                    sb.Append(",\"meshGuid\":").Append(J(meshGuid));
+                    sb.Append(",\"meshName\":").Append(J(mf.sharedMesh.name));
+                    sb.Append(",\"active\":").Append(r.gameObject.activeInHierarchy && r.enabled ? "true" : "false");
+                    var t = r.transform;
+                    var wp = t.position; var wq = t.rotation; var ws = t.lossyScale;
+                    sb.Append(",\"pos\":[").Append(wp.x).Append(",").Append(wp.y).Append(",").Append(wp.z).Append("]");
+                    sb.Append(",\"quat\":[").Append(wq.x).Append(",").Append(wq.y).Append(",").Append(wq.z).Append(",").Append(wq.w).Append("]");
+                    sb.Append(",\"scale\":[").Append(ws.x).Append(",").Append(ws.y).Append(",").Append(ws.z).Append("]");
+                    sb.Append(",\"materials\":[");
+                    for (int i = 0; i < r.sharedMaterials.Length; i++)
+                    {
+                        var m = r.sharedMaterials[i];
+                        if (i > 0) sb.Append(",");
+                        if (m == null) { sb.Append("null"); continue; }
+                        var tex = m.HasProperty("_BaseMap") && m.GetTexture("_BaseMap") != null ? m.GetTexture("_BaseMap")
+                                : m.HasProperty("_MainTex") ? m.GetTexture("_MainTex") : null;
+                        string texName = null;
+                        if (tex != null)
+                        {
+                            var tp = AssetDatabase.GetAssetPath(tex);
+                            texName = Path.GetFileName(tp);
+                            if (!string.IsNullOrEmpty(tp) && texturesCopied.Add(texName))
+                                File.Copy(tp, Path.Combine(texDir, texName), true);
+                        }
+                        var col = m.HasProperty("_BaseColor") ? m.GetColor("_BaseColor")
+                                : m.HasProperty("_Color") ? m.GetColor("_Color") : Color.white;
+                        var st = m.HasProperty("_BaseMap") ? m.GetTextureScale("_BaseMap")
+                               : m.HasProperty("_MainTex") ? m.GetTextureScale("_MainTex") : Vector2.one;
+                        var so = m.HasProperty("_BaseMap") ? m.GetTextureOffset("_BaseMap")
+                               : m.HasProperty("_MainTex") ? m.GetTextureOffset("_MainTex") : Vector2.zero;
+                        sb.Append("{\"name\":").Append(J(m.name));
+                        sb.Append(",\"shader\":").Append(J(m.shader != null ? m.shader.name : ""));
+                        sb.Append(",\"mainTex\":").Append(texName == null ? "null" : J(texName));
+                        sb.Append(",\"color\":[").Append(col.r).Append(",").Append(col.g).Append(",").Append(col.b).Append(",").Append(col.a).Append("]");
+                        sb.Append(",\"tiling\":[").Append(st.x).Append(",").Append(st.y).Append("]");
+                        sb.Append(",\"offset\":[").Append(so.x).Append(",").Append(so.y).Append("]}");
+                    }
+                    sb.Append("]}");
+                }
+            }
+        }
+        sb.Append("],\"nodes\":[");
+
+        // MARKERS — every GameObject WITHOUT a MeshRenderer: connectors, sockets, spawn
+        // points, group empties. These are what tells Sindicate where a junction's arms
+        // are and which way they face, so roads can auto-connect junction to junction.
+        // (Renderers are already covered above; this keeps the file small.)
+        bool firstNode = true;
+        foreach (var root in ROOTS)
+        {
+            foreach (var guid in AssetDatabase.FindAssets("t:Prefab", new[] { root }))
+            {
+                var path = AssetDatabase.GUIDToAssetPath(guid);
+                var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
+                if (prefab == null) continue;
+                foreach (var t in prefab.GetComponentsInChildren<Transform>(true))
+                {
+                    if (t.GetComponent<MeshRenderer>() != null) continue;
+                    if (!firstNode) sb.Append(",");
+                    firstNode = false;
+                    // parent path so hierarchy meaning survives (e.g. Sockets/Connector_A)
+                    var chain = t.name;
+                    for (var p = t.parent; p != null && p != prefab.transform; p = p.parent) chain = p.name + "/" + chain;
+                    sb.Append("{\"prefab\":").Append(J(Path.GetFileNameWithoutExtension(path)));
+                    sb.Append(",\"path\":").Append(J(chain));
+                    sb.Append(",\"name\":").Append(J(t.name));
+                    sb.Append(",\"active\":").Append(t.gameObject.activeInHierarchy ? "true" : "false");
+                    var np = t.position; var nq = t.rotation; var ns = t.lossyScale;
+                    sb.Append(",\"pos\":[").Append(np.x).Append(",").Append(np.y).Append(",").Append(np.z).Append("]");
+                    sb.Append(",\"quat\":[").Append(nq.x).Append(",").Append(nq.y).Append(",").Append(nq.z).Append(",").Append(nq.w).Append("]");
+                    sb.Append(",\"scale\":[").Append(ns.x).Append(",").Append(ns.y).Append(",").Append(ns.z).Append("]}");
+                }
+            }
+        }
+        sb.Append("]}");
+        File.WriteAllText(Path.Combine(outDir, "road-materials.json"), sb.ToString());
+        AssetDatabase.Refresh();
+        EditorUtility.DisplayDialog("Sindicate export",
+            $"Done: {prefabCount} prefabs walked, {texturesCopied.Count} textures copied.\n\nCopy Assets/SindicateExport/ to Sites and tell Claude.", "OK");
+    }
+
+    static string J(string s) => "\"" + (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
+}

package/tools/ExportKiwiRoadRefs.cs

@@ -0,0 +1,94 @@
+// EXPORT ROAD REFS — Unity renders every road prefab to a PNG (the GROUND TRUTH in
+// pixels). Drop next to ExportKiwiRoadMaterials.cs in Assets/Editor/, run
+//   Tools ▸ Sindicate ▸ Export Road Reference Images
+// Writes Assets/SindicateExport/refs/<prefab>.png (512px, iso view). Sindicate's compare
+// sheet puts these beside its own renders so every mismatch is visible at a glance.
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+public static class ExportKiwiRoadRefs
+{
+    static readonly string[] ROOTS = {
+        "Assets/AIGenerateMap/Prefabs/Roads",
+        "Assets/AIGenerateMap/JunctionPrefabs",
+        "Assets/AIGenerateMap/RoadPrefabs",
+    };
+
+    [MenuItem("Tools/Sindicate/Export Road Reference Images")]
+    public static void Export()
+    {
+        var outDir = "Assets/SindicateExport/refs";
+        Directory.CreateDirectory(outDir);
+
+        var camGO = new GameObject("__sindicateRefCam");
+        var cam = camGO.AddComponent<Camera>();
+        cam.clearFlags = CameraClearFlags.SolidColor;
+        cam.backgroundColor = new Color(0.09f, 0.09f, 0.14f);
+        cam.fieldOfView = 40f;
+        cam.farClipPlane = 5000f;
+        var lightGO = new GameObject("__sindicateRefLight");
+        var light = lightGO.AddComponent<Light>();
+        light.type = LightType.Directional;
+        light.intensity = 1.4f;
+        lightGO.transform.rotation = Quaternion.Euler(50, -30, 0);
+
+        var rt = new RenderTexture(512, 512, 24);
+        var tex = new Texture2D(512, 512, TextureFormat.RGB24, false);
+        int done = 0;
+
+        try
+        {
+            foreach (var root in ROOTS)
+            {
+                foreach (var guid in AssetDatabase.FindAssets("t:Prefab", new[] { root }))
+                {
+                    var path = AssetDatabase.GUIDToAssetPath(guid);
+                    var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
+                    if (prefab == null) continue;
+                    // name refs the same way the materials export names runs: variant dirs
+                    // (Motorway/DualCarriageway) prefixed to disambiguate duplicates
+                    var name = Path.GetFileNameWithoutExtension(path);
+                    if (path.Contains("/Motorway/")) name = "Motorway_" + name;
+                    else if (path.Contains("/DualCarriageway/")) name = "DualCarriageway_" + name;
+
+                    var inst = (GameObject)Object.Instantiate(prefab, new Vector3(0, -5000, 0), Quaternion.identity);
+                    try
+                    {
+                        var bounds = new Bounds(inst.transform.position, Vector3.one);
+                        bool first = true;
+                        foreach (var r in inst.GetComponentsInChildren<Renderer>())
+                        {
+                            if (first) { bounds = r.bounds; first = false; }
+                            else bounds.Encapsulate(r.bounds);
+                        }
+                        var size = Mathf.Max(bounds.size.x, bounds.size.z, bounds.size.y, 2f);
+                        var dist = size * 1.35f;
+                        cam.transform.position = bounds.center + new Vector3(0.7f, 0.8f, 1f).normalized * dist;
+                        cam.transform.LookAt(bounds.center);
+
+                        cam.targetTexture = rt;
+                        cam.Render();
+                        RenderTexture.active = rt;
+                        tex.ReadPixels(new Rect(0, 0, 512, 512), 0, 0);
+                        tex.Apply();
+                        File.WriteAllBytes(Path.Combine(outDir, name + ".png"), tex.EncodeToPNG());
+                        done++;
+                    }
+                    finally { Object.DestroyImmediate(inst); }
+                }
+            }
+        }
+        finally
+        {
+            cam.targetTexture = null;
+            RenderTexture.active = null;
+            Object.DestroyImmediate(rt);
+            Object.DestroyImmediate(tex);
+            Object.DestroyImmediate(camGO);
+            Object.DestroyImmediate(lightGO);
+            AssetDatabase.Refresh();
+        }
+        EditorUtility.DisplayDialog("Sindicate refs", $"Rendered {done} reference images.\n\nTell Claude.", "OK");
+    }
+}

package/tools/buildKiwiRoadsPack.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// BUILD THE KIWIROADS PACK — one command, correct order. The stages are order-dependent
+// (assemblies must exist before patches merge; FBX must be referenced before they're baked),
+// so running them by hand invites half-built packs.
+//
+//   node tools/buildKiwiRoadsPack.mjs [--export <SindicateExport>] [--kiwi <KiwiAssets>] [--pack <packDir>]
+//
+//   1. truthToAssemblies       Unity truth export → 538 assemblies (+ merges patches/, fbxScale.json)
+//   2. rebuildSimpleRoundabouts  regenerate the meshes Kiwi lost upstream → patches/
+//   3. truthToAssemblies again   so the fresh patches land in the assemblies
+//   4. fbxToGlb                  bake Synty FBX props (with their Unity import scale) → GLB
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const arg = (name, fallback) => {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > 0 ? process.argv[i + 1] : fallback;
+};
+const exportDir = arg('export', '/Users/nick/Desktop/Kiwi/Assets/SindicateExport');
+const kiwiAssets = arg('kiwi', '/Users/nick/Desktop/Kiwi/Assets');
+const packDir = arg('pack', '/Users/nick/Sites/TakeTheCity/public/assets/packs/KiwiRoads');
+
+const run = (script, args, label) => {
+  console.log(`\n── ${label}`);
+  const r = spawnSync(process.execPath, [path.join(here, script), ...args], { stdio: 'inherit' });
+  if (r.status !== 0) { console.error(`FAILED at ${label}`); process.exit(r.status ?? 1); }
+};
+
+run('truthToAssemblies.mjs', [exportDir, kiwiAssets, packDir], 'assemblies from Unity truth');
+run('rebuildSimpleRoundabouts.mjs', [packDir], 'reconstruct SimpleRoundabout meshes');
+run('truthToAssemblies.mjs', [exportDir, kiwiAssets, packDir], 'assemblies again (merge fresh patches)');
+run('fbxToGlb.mjs', [packDir], 'bake FBX props → GLB');
+run('roadKitAnalyze.mjs', [packDir], 'measure sockets → roadkit.json');
+console.log('\npack built.');

package/tools/designer-mcp.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+// THE DESIGNER's MCP SERVER — lets a Claude session drive the World Designer while the
+// human watches the viewport. Zero-dep stdio JSON-RPC (MCP 2024-11-05): every tool call
+// proxies to the game dev server's designer bus (/__designer-bus) or endpoints, and the
+// open /designer.html page executes it live.
+//
+// Register once per game:
+//   claude mcp add dustwater-designer -- node /Users/nick/Sites/Sindicate/tools/designer-mcp.mjs --server http://localhost:5317
+//
+// The designer page must be open in a browser tab (it polls the bus).
+const SERVER = (() => {
+  const i = process.argv.indexOf('--server');
+  return (i >= 0 && process.argv[i + 1]) || process.env.SINDICATE_SERVER || 'http://localhost:5317';
+})();
+
+async function bus(op, args = {}, timeoutMs = 20000) {
+  const { id } = await fetch(`${SERVER}/__designer-bus/cmd`, {
+    method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ op, args }),
+  }).then((r) => r.json());
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    const r = await fetch(`${SERVER}/__designer-bus/take?id=${id}`);
+    if (r.status === 200) {
+      const j = await r.json();
+      if (!j.ok) throw new Error(j.err ?? 'designer op failed');
+      return j.value;
+    }
+    await new Promise((res) => setTimeout(res, 300));
+  }
+  throw new Error(`designer page did not answer in ${timeoutMs / 1000}s — is /designer.html open in a browser tab on ${SERVER}?`);
+}
+
+const num = (d) => ({ type: 'number', description: d });
+const str = (d) => ({ type: 'string', description: d });
+const TOOLS = [
+  { name: 'designer_status', description: 'Current designer state: mode, prefab/road counts, selection, layout name.', inputSchema: { type: 'object', properties: {} },
+    run: () => bus('status') },
+  { name: 'designer_packs', description: 'List imported asset packs available to the designer.', inputSchema: { type: 'object', properties: {} },
+    run: async () => (await fetch(`${SERVER}/__pack/list`).then((r) => r.json())).imported },
+  { name: 'designer_models', description: 'List a pack’s placeable models plus its default texture atlas URL.', inputSchema: { type: 'object', properties: { pack: str('imported pack name') }, required: ['pack'] },
+    run: ({ pack }) => fetch(`${SERVER}/__designer/models?pack=${encodeURIComponent(pack)}`).then((r) => r.json()) },
+  { name: 'designer_palette', description: 'Search the loaded palette (pack/model labels) by substring.', inputSchema: { type: 'object', properties: { filter: str('substring filter, empty for first 200') } },
+    run: ({ filter = '' }) => bus('palette', filter) },
+  { name: 'designer_place', description: 'Place a prefab at world x,z (y defaults to terrain height). Returns its index.', inputSchema: { type: 'object', properties: { file: str('model name without extension'), dir: str('URL dir, e.g. /assets/packs/<pack>/models'), x: num('world x'), z: num('world z'), y: num('optional y override'), ry: num('yaw radians'), tex: str('optional texture URL') }, required: ['file', 'dir', 'x', 'z'] },
+    run: (a) => bus('place', a) },
+  { name: 'designer_move', description: 'Move/rotate placed prefab #i (omitted fields keep their value; y re-snaps to terrain unless given).', inputSchema: { type: 'object', properties: { i: num('prefab index'), x: num(''), z: num(''), y: num(''), ry: num('yaw radians') }, required: ['i'] },
+    run: (a) => bus('move', a) },
+  { name: 'designer_remove', description: 'Delete placed prefab #i.', inputSchema: { type: 'object', properties: { i: num('prefab index') }, required: ['i'] },
+    run: (a) => bus('remove', a) },
+  { name: 'designer_road', description: 'Add a road polyline: pts = [{x,z}, ...] in world metres.', inputSchema: { type: 'object', properties: { pts: { type: 'array', items: { type: 'object', properties: { x: num(''), z: num('') }, required: ['x', 'z'] }, description: 'polyline points' } }, required: ['pts'] },
+    run: (a) => bus('road', a) },
+  { name: 'designer_camera', description: 'Move the viewport camera to x,y,z looking at tx,ty,tz.', inputSchema: { type: 'object', properties: { x: num(''), y: num(''), z: num(''), tx: num('look-at x'), ty: num('look-at y'), tz: num('look-at z') }, required: ['x', 'y', 'z'] },
+    run: (a) => bus('camera', a) },
+  { name: 'designer_save', description: 'Save the layout to designs/<name>.json in the game repo.', inputSchema: { type: 'object', properties: { name: str('design name') }, required: ['name'] },
+    run: (a) => bus('save', a) },
+  { name: 'designer_load', description: 'Load designs/<name>.json into the viewport (replaces current layout).', inputSchema: { type: 'object', properties: { name: str('design name') }, required: ['name'] },
+    run: (a) => bus('load', a, 120000) },
+  { name: 'designer_clear', description: 'Remove every placed prefab and road (does not touch saved files).', inputSchema: { type: 'object', properties: {} },
+    run: () => bus('clear') },
+  { name: 'designer_designs', description: 'List saved design names.', inputSchema: { type: 'object', properties: {} },
+    run: async () => (await fetch(`${SERVER}/__designer/list`).then((r) => r.json())).designs },
+];
+
+// ---- stdio JSON-RPC plumbing (newline-delimited, per the MCP stdio transport) ----
+const reply = (id, result) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+const fail = (id, message) => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32603, message } }) + '\n');
+
+let buf = '';
+process.stdin.on('data', (chunk) => {
+  buf += chunk;
+  let nl;
+  while ((nl = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, nl).trim();
+    buf = buf.slice(nl + 1);
+    if (line) handle(line);
+  }
+});
+
+async function handle(line) {
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+  const { id, method, params } = msg;
+  if (method === 'initialize') {
+    return reply(id, {
+      protocolVersion: params?.protocolVersion ?? '2024-11-05',
+      capabilities: { tools: {} },
+      serverInfo: { name: 'sindicate-designer', version: '1.0.0' },
+    });
+  }
+  if (method === 'tools/list') return reply(id, { tools: TOOLS.map(({ run, ...t }) => t) });
+  if (method === 'tools/call') {
+    const tool = TOOLS.find((t) => t.name === params?.name);
+    if (!tool) return fail(id, `unknown tool ${params?.name}`);
+    try {
+      const value = await tool.run(params?.arguments ?? {});
+      return reply(id, { content: [{ type: 'text', text: JSON.stringify(value ?? { ok: true }) }] });
+    } catch (e) {
+      return reply(id, { content: [{ type: 'text', text: String(e?.message ?? e) }], isError: true });
+    }
+  }
+  if (method === 'ping') return reply(id, {});
+  if (id !== undefined) return fail(id, `unknown method ${method}`);   // notifications are ignored
+}