@myclaw163/clawclaw-cli 0.6.64 → 0.6.66

package/scripts/find-hide-spots.py

@@ -1,157 +1,157 @@
-"""Compute bot "hiding spots" from the server's baked map.
-
-Usage: python scripts/find-hide-spots.py [npz_path]
-
-Reads the baked map npz (room_lookup + inflated walkable weights + meta), counts
-each room's wall openings to classify through-rooms (>=2 exits) vs dead-ends, then
-within each through-room picks the walkable cell that is deepest from the room's
-exits and far from task points / spawns — a tucked corner that is off the
-task-running routes but still has >=2 ways to flee. Corridors (the task routes
-themselves) and >=4-exit junction hubs are excluded.
-
-Prints a summary table and a ready-to-paste TS array for
-`src/strategies/hide-spots.ts` (`HIDE_SPOTS`). Re-run whenever the map is rebaked.
-Dependency: numpy only (run with the backend venv interpreter).
-"""
-import json
-import math
-import sys
-from pathlib import Path
-
-import numpy as np
-
-DEFAULT_NPZ = r"I:\crab-kill-backend\config\clawclaw\clawclaw.tmj.baked.npz"
-
-# Tunables (world px)
-EXIT_MIN = 120.0       # candidate must be at least this deep from any exit (kills thin corridors)
-SPAWN_MIN = 160.0      # keep clear of spawn clusters
-TASK_MIN = 110.0       # don't sit on top of a task point (players doing it would see you)
-MAX_EXITS = 3          # >=4 openings = a junction/hub: too much through-traffic to hide in
-DEEP_CAP = 250.0       # diminishing returns on exit depth
-TASK_CAP = 300.0       # diminishing returns on task clearance
-TASK_W = 0.8
-SAMPLE_STEP = 4        # evaluate every Nth tile inside a room (tile=4px -> 16px grid)
-MIN_SPACING = 240.0    # spread chosen spots apart
-MAX_SPOTS = 14
-EXCLUDE_NAME_SUBSTR = ("走廊",)  # corridors are exactly the task-running routes -> never hide there
-
-
-def union_find_components(cells):
-    """8-connected component count over a set of (ty, tx) cells."""
-    cellset = set(cells)
-    parent = {c: c for c in cellset}
-
-    def find(a):
-        while parent[a] != a:
-            parent[a] = parent[parent[a]]
-            a = parent[a]
-        return a
-
-    for (ty, tx) in cellset:
-        for dy in (-1, 0, 1):
-            for dx in (-1, 0, 1):
-                if dy == 0 and dx == 0:
-                    continue
-                nb = (ty + dy, tx + dx)
-                if nb in cellset:
-                    ra, rb = find((ty, tx)), find(nb)
-                    if ra != rb:
-                        parent[ra] = rb
-    return len({find(c) for c in cellset})
-
-
-def exit_cells_of(room_lookup, walk, r):
-    """Walkable cells of room r that border a walkable cell outside room r."""
-    room_mask = (room_lookup == r) & walk
-    if not room_mask.any():
-        return None, None
-    outside = walk & (room_lookup != r)
-    border = np.zeros_like(room_mask)
-    border[:-1, :] |= room_mask[:-1, :] & outside[1:, :]
-    border[1:, :] |= room_mask[1:, :] & outside[:-1, :]
-    border[:, :-1] |= room_mask[:, :-1] & outside[:, 1:]
-    border[:, 1:] |= room_mask[:, 1:] & outside[:, :-1]
-    ys, xs = np.where(border)
-    return room_mask, list(zip(ys.tolist(), xs.tolist()))
-
-
-def best_cell_in_room(room_mask, opening_px, task_xy, spawn_xy, tw, th):
-    ys, xs = np.where(room_mask)
-    if len(ys) == 0:
-        return None
-    sel = (ys % SAMPLE_STEP == 0) & (xs % SAMPLE_STEP == 0)
-    ys, xs = ys[sel], xs[sel]
-    if len(ys) == 0:
-        return None
-    cx = xs * tw + tw / 2.0
-    cy = ys * th + th / 2.0
-    pts = np.stack([cx, cy], axis=1)
-
-    op = np.array(opening_px, dtype=np.float64)
-    exit_d = np.sqrt(((pts[:, None, :] - op[None, :, :]) ** 2).sum(-1)).min(1)
-    task_d = np.sqrt(((pts[:, None, :] - task_xy[None, :, :]) ** 2).sum(-1)).min(1)
-    spawn_d = np.sqrt(((pts[:, None, :] - spawn_xy[None, :, :]) ** 2).sum(-1)).min(1)
-
-    ok = (exit_d >= EXIT_MIN) & (spawn_d >= SPAWN_MIN) & (task_d >= TASK_MIN)
-    if not ok.any():
-        return None
-    score = np.minimum(exit_d, DEEP_CAP) + TASK_W * np.minimum(task_d, TASK_CAP)
-    score = np.where(ok, score, -1e9)
-    i = int(np.argmax(score))
-    return (round(float(cx[i]), 1), round(float(cy[i]), 1), float(score[i]),
-            float(exit_d[i]), float(task_d[i]), float(spawn_d[i]))
-
-
-def main() -> None:
-    npz_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_NPZ
-    data = np.load(npz_path, allow_pickle=False)
-    meta = json.loads(data["meta"].tobytes().decode("utf-8"))
-    room_lookup = data["room_lookup"]
-    weights = data["inflated_weights"]
-    tw, th = meta["tile_width"], meta["tile_height"]
-    room_names = meta["room_names"]
-    walk = np.isfinite(weights)
-    task_xy = np.array([[t["x"], t["y"]] for t in meta["task_points"]], dtype=np.float64)
-    spawn_xy = np.array([[s["x"], s["y"]] for s in meta["spawn_points"]], dtype=np.float64)
-
-    candidates = []
-    for r in range(1, len(room_names)):
-        room_mask, opening = exit_cells_of(room_lookup, walk, r)
-        if room_mask is None or not opening:
-            continue
-        name = room_names[r]
-        if any(s in name for s in EXCLUDE_NAME_SUBSTR):
-            continue
-        n_exits = union_find_components(opening)
-        if n_exits < 2 or n_exits > MAX_EXITS:
-            continue
-        opening_px = [(tx * tw + tw / 2.0, ty * th + th / 2.0) for (ty, tx) in opening]
-        best = best_cell_in_room(room_mask, opening_px, task_xy, spawn_xy, tw, th)
-        if best is None:
-            continue
-        x, y, score, ed, td, sd = best
-        candidates.append({"x": x, "y": y, "room": name, "exits": n_exits,
-                           "score": round(score, 1), "exit_dist": round(ed, 1),
-                           "task_dist": round(td, 1), "spawn_dist": round(sd, 1)})
-
-    candidates.sort(key=lambda c: c["score"], reverse=True)
-    chosen = []
-    for c in candidates:
-        if all(math.hypot(c["x"] - k["x"], c["y"] - k["y"]) >= MIN_SPACING for k in chosen):
-            chosen.append(c)
-        if len(chosen) >= MAX_SPOTS:
-            break
-
-    print(f"{len(candidates)} through-room candidates, {len(chosen)} chosen after spacing:\n")
-    print(f"{'room':>8} {'x':>7} {'y':>7} {'exits':>5} {'exitD':>6} {'taskD':>6} {'spawnD':>6}")
-    for c in chosen:
-        print(f"{c['room']:>8} {c['x']:>7.0f} {c['y']:>7.0f} {c['exits']:>5} "
-              f"{c['exit_dist']:>6.0f} {c['task_dist']:>6.0f} {c['spawn_dist']:>6.0f}")
-
-    print("\n// paste into src/strategies/hide-spots.ts (HIDE_SPOTS):")
-    for c in chosen:
-        print(f"  {{ x: {c['x']:.0f}, y: {c['y']:.0f}, room: '{c['room']}' }},")
-
-
-if __name__ == "__main__":
-    main()
+"""Compute bot "hiding spots" from the server's baked map.
+
+Usage: python scripts/find-hide-spots.py [npz_path]
+
+Reads the baked map npz (room_lookup + inflated walkable weights + meta), counts
+each room's wall openings to classify through-rooms (>=2 exits) vs dead-ends, then
+within each through-room picks the walkable cell that is deepest from the room's
+exits and far from task points / spawns — a tucked corner that is off the
+task-running routes but still has >=2 ways to flee. Corridors (the task routes
+themselves) and >=4-exit junction hubs are excluded.
+
+Prints a summary table and a ready-to-paste TS array for
+`src/strategies/hide-spots.ts` (`HIDE_SPOTS`). Re-run whenever the map is rebaked.
+Dependency: numpy only (run with the backend venv interpreter).
+"""
+import json
+import math
+import sys
+from pathlib import Path
+
+import numpy as np
+
+DEFAULT_NPZ = r"I:\crab-kill-backend\config\clawclaw\clawclaw.tmj.baked.npz"
+
+# Tunables (world px)
+EXIT_MIN = 120.0       # candidate must be at least this deep from any exit (kills thin corridors)
+SPAWN_MIN = 160.0      # keep clear of spawn clusters
+TASK_MIN = 110.0       # don't sit on top of a task point (players doing it would see you)
+MAX_EXITS = 3          # >=4 openings = a junction/hub: too much through-traffic to hide in
+DEEP_CAP = 250.0       # diminishing returns on exit depth
+TASK_CAP = 300.0       # diminishing returns on task clearance
+TASK_W = 0.8
+SAMPLE_STEP = 4        # evaluate every Nth tile inside a room (tile=4px -> 16px grid)
+MIN_SPACING = 240.0    # spread chosen spots apart
+MAX_SPOTS = 14
+EXCLUDE_NAME_SUBSTR = ("走廊",)  # corridors are exactly the task-running routes -> never hide there
+
+
+def union_find_components(cells):
+    """8-connected component count over a set of (ty, tx) cells."""
+    cellset = set(cells)
+    parent = {c: c for c in cellset}
+
+    def find(a):
+        while parent[a] != a:
+            parent[a] = parent[parent[a]]
+            a = parent[a]
+        return a
+
+    for (ty, tx) in cellset:
+        for dy in (-1, 0, 1):
+            for dx in (-1, 0, 1):
+                if dy == 0 and dx == 0:
+                    continue
+                nb = (ty + dy, tx + dx)
+                if nb in cellset:
+                    ra, rb = find((ty, tx)), find(nb)
+                    if ra != rb:
+                        parent[ra] = rb
+    return len({find(c) for c in cellset})
+
+
+def exit_cells_of(room_lookup, walk, r):
+    """Walkable cells of room r that border a walkable cell outside room r."""
+    room_mask = (room_lookup == r) & walk
+    if not room_mask.any():
+        return None, None
+    outside = walk & (room_lookup != r)
+    border = np.zeros_like(room_mask)
+    border[:-1, :] |= room_mask[:-1, :] & outside[1:, :]
+    border[1:, :] |= room_mask[1:, :] & outside[:-1, :]
+    border[:, :-1] |= room_mask[:, :-1] & outside[:, 1:]
+    border[:, 1:] |= room_mask[:, 1:] & outside[:, :-1]
+    ys, xs = np.where(border)
+    return room_mask, list(zip(ys.tolist(), xs.tolist()))
+
+
+def best_cell_in_room(room_mask, opening_px, task_xy, spawn_xy, tw, th):
+    ys, xs = np.where(room_mask)
+    if len(ys) == 0:
+        return None
+    sel = (ys % SAMPLE_STEP == 0) & (xs % SAMPLE_STEP == 0)
+    ys, xs = ys[sel], xs[sel]
+    if len(ys) == 0:
+        return None
+    cx = xs * tw + tw / 2.0
+    cy = ys * th + th / 2.0
+    pts = np.stack([cx, cy], axis=1)
+
+    op = np.array(opening_px, dtype=np.float64)
+    exit_d = np.sqrt(((pts[:, None, :] - op[None, :, :]) ** 2).sum(-1)).min(1)
+    task_d = np.sqrt(((pts[:, None, :] - task_xy[None, :, :]) ** 2).sum(-1)).min(1)
+    spawn_d = np.sqrt(((pts[:, None, :] - spawn_xy[None, :, :]) ** 2).sum(-1)).min(1)
+
+    ok = (exit_d >= EXIT_MIN) & (spawn_d >= SPAWN_MIN) & (task_d >= TASK_MIN)
+    if not ok.any():
+        return None
+    score = np.minimum(exit_d, DEEP_CAP) + TASK_W * np.minimum(task_d, TASK_CAP)
+    score = np.where(ok, score, -1e9)
+    i = int(np.argmax(score))
+    return (round(float(cx[i]), 1), round(float(cy[i]), 1), float(score[i]),
+            float(exit_d[i]), float(task_d[i]), float(spawn_d[i]))
+
+
+def main() -> None:
+    npz_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_NPZ
+    data = np.load(npz_path, allow_pickle=False)
+    meta = json.loads(data["meta"].tobytes().decode("utf-8"))
+    room_lookup = data["room_lookup"]
+    weights = data["inflated_weights"]
+    tw, th = meta["tile_width"], meta["tile_height"]
+    room_names = meta["room_names"]
+    walk = np.isfinite(weights)
+    task_xy = np.array([[t["x"], t["y"]] for t in meta["task_points"]], dtype=np.float64)
+    spawn_xy = np.array([[s["x"], s["y"]] for s in meta["spawn_points"]], dtype=np.float64)
+
+    candidates = []
+    for r in range(1, len(room_names)):
+        room_mask, opening = exit_cells_of(room_lookup, walk, r)
+        if room_mask is None or not opening:
+            continue
+        name = room_names[r]
+        if any(s in name for s in EXCLUDE_NAME_SUBSTR):
+            continue
+        n_exits = union_find_components(opening)
+        if n_exits < 2 or n_exits > MAX_EXITS:
+            continue
+        opening_px = [(tx * tw + tw / 2.0, ty * th + th / 2.0) for (ty, tx) in opening]
+        best = best_cell_in_room(room_mask, opening_px, task_xy, spawn_xy, tw, th)
+        if best is None:
+            continue
+        x, y, score, ed, td, sd = best
+        candidates.append({"x": x, "y": y, "room": name, "exits": n_exits,
+                           "score": round(score, 1), "exit_dist": round(ed, 1),
+                           "task_dist": round(td, 1), "spawn_dist": round(sd, 1)})
+
+    candidates.sort(key=lambda c: c["score"], reverse=True)
+    chosen = []
+    for c in candidates:
+        if all(math.hypot(c["x"] - k["x"], c["y"] - k["y"]) >= MIN_SPACING for k in chosen):
+            chosen.append(c)
+        if len(chosen) >= MAX_SPOTS:
+            break
+
+    print(f"{len(candidates)} through-room candidates, {len(chosen)} chosen after spacing:\n")
+    print(f"{'room':>8} {'x':>7} {'y':>7} {'exits':>5} {'exitD':>6} {'taskD':>6} {'spawnD':>6}")
+    for c in chosen:
+        print(f"{c['room']:>8} {c['x']:>7.0f} {c['y']:>7.0f} {c['exits']:>5} "
+              f"{c['exit_dist']:>6.0f} {c['task_dist']:>6.0f} {c['spawn_dist']:>6.0f}")
+
+    print("\n// paste into src/strategies/hide-spots.ts (HIDE_SPOTS):")
+    for c in chosen:
+        print(f"  {{ x: {c['x']:.0f}, y: {c['y']:.0f}, room: '{c['room']}' }},")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/postinstall.mjs

@@ -1,20 +1,20 @@
-#!/usr/bin/env node
-import { syncBundledSkill } from './sync-bundled-skill.mjs';
-
-function main() {
-  if (process.env.CLAWCLAW_SKIP_SKILL_SYNC === '1') return;
-  if (process.env.npm_config_global !== 'true') return;
-
-  try {
-    const result = syncBundledSkill();
-    if (result.backupDir) {
-      console.warn(`[clawclaw-cli] Backed up existing clawclaw skill to: ${result.backupDir}`);
-    }
-  } catch (err) {
-    console.warn('[clawclaw-cli] CLI installed, but bundled agent skill was not updated.');
-    console.warn('[clawclaw-cli] Run: ccl upgrade skill');
-    console.warn(`[clawclaw-cli] Error: ${err?.message ?? String(err)}`);
-  }
-}
-
-main();
+#!/usr/bin/env node
+import { syncBundledSkill } from './sync-bundled-skill.mjs';
+
+function main() {
+  if (process.env.CLAWCLAW_SKIP_SKILL_SYNC === '1') return;
+  if (process.env.npm_config_global !== 'true') return;
+
+  try {
+    const result = syncBundledSkill();
+    if (result.backupDir) {
+      console.warn(`[clawclaw-cli] Backed up existing clawclaw skill to: ${result.backupDir}`);
+    }
+  } catch (err) {
+    console.warn('[clawclaw-cli] CLI installed, but bundled agent skill was not updated.');
+    console.warn('[clawclaw-cli] Run: ccl upgrade skill');
+    console.warn(`[clawclaw-cli] Error: ${err?.message ?? String(err)}`);
+  }
+}
+
+main();