Update app.py

app.py

@@ -1,35 +1,30 @@
 import math
 import random
+import json
+import os
 import numpy as np
 import gradio as gr
 
 # ============================================================
 # RFT Predator Space — First-Person Observer View (Pseudo-3D)
-# - Raycast wall slicing (occlusion + distance shading)
-# - Prey billboard with LOS + per-column occlusion vs walls
-# - Optional top-down minimap for debugging / verification
+# + Unlockable maps
+# + Save/Load (slot + export/import) + slot dropdown auto-lists ./saves/
+# + Hybrid mode: AutoRun ON + AutoChase OFF => predator WANDERS autonomously (while prey flees if not player-controlled)
+# + Toggle control POV/inputs between Predator vs Prey (symmetric observers)
+# + Optional coherence overlay (subtle; off by default)
 # ============================================================
 
-# -----------------------------
-# World config (grid)
-# -----------------------------
-GRID_W, GRID_H = 23, 23
-OBSTACLE_P = 0.13
-
 # -----------------------------
 # View config (render)
 # -----------------------------
-VIEW_W, VIEW_H = 560, 360          # output size
-RAY_W = 280                         # internal ray columns (upscaled to VIEW_W)
+VIEW_W, VIEW_H = 560, 360
+RAY_W = 280
 FOV_DEG = 78
 MAX_DEPTH = 18
 
-# Movement
-TURN_DEG = 20
 MOVE_STEP = 1
 AUTO_TICK_HZ = 8
 
-# Colors
 SKY = np.array([14, 16, 26], dtype=np.uint8)
 FLOOR_NEAR = np.array([20, 22, 34], dtype=np.uint8)
 FLOOR_FAR = np.array([10, 11, 18], dtype=np.uint8)
@@ -37,76 +32,388 @@ FLOOR_FAR = np.array([10, 11, 18], dtype=np.uint8)
 WALL_BASE = np.array([210, 210, 225], dtype=np.uint8)
 WALL_SIDE = np.array([150, 150, 170], dtype=np.uint8)
 
-PREY_COLOR = np.array([255, 140, 90], dtype=np.uint8)  # “billboard”
+AGENT_OTHER_COLOR = np.array([255, 140, 90], dtype=np.uint8)   # billboard for the "other" observer
 RETICLE = np.array([120, 190, 255], dtype=np.uint8)
 
 # 0=E,1=S,2=W,3=N
 DIRS = [(1,0),(0,1),(-1,0),(0,-1)]
 ORI_DEG = [0, 90, 180, 270]
+DIR_TO_ORI = {(1,0):0, (0,1):1, (-1,0):2, (0,-1):3}
+
+# -----------------------------
+# Progression / unlocks
+# -----------------------------
+MAP_UNLOCKS = [
+    ("Training Bay", 0),
+    ("Arena+", 1),
+    ("Corridor Maze", 3),
+    ("Rooms", 6),
+    ("Labyrinth", 10),
+    ("Dense Field", 15),
+]
 
+# -----------------------------
+# Saves
+# -----------------------------
+SAVE_DIR = "saves"
+os.makedirs(SAVE_DIR, exist_ok=True)
+
+def _slot_path(slot: str) -> str:
+    slot = (slot or "slot1").strip().replace(" ", "_")
+    if not slot:
+        slot = "slot1"
+    if not slot.lower().endswith(".json"):
+        slot += ".json"
+    return os.path.join(SAVE_DIR, slot)
+
+def list_save_slots():
+    try:
+        files = []
+        for fn in os.listdir(SAVE_DIR):
+            if fn.lower().endswith(".json"):
+                files.append(fn)
+        files.sort()
+        return files
+    except Exception:
+        return []
+
+# -----------------------------
+# Utility
+# -----------------------------
 def clamp(x, lo, hi):
     return lo if x < lo else hi if x > hi else x
 
-def wrap_angle_deg(a):
-    a = a % 360.0
-    if a < 0: a += 360.0
-    return a
-
 def angle_diff_rad(a, b):
-    # minimal difference a-b in [-pi, pi]
-    d = (a - b + math.pi) % (2*math.pi) - math.pi
-    return d
+    return (a - b + math.pi) % (2*math.pi) - math.pi
 
 def seeded_rng(seed: int):
     return random.Random(int(seed) & 0xFFFFFFFF)
 
-def make_world(seed=1):
-    rng = seeded_rng(seed)
-    grid = np.zeros((GRID_H, GRID_W), dtype=np.int8)
-
-    # borders
+def neighbors4(x, y):
+    return [(x+1,y),(x-1,y),(x,y+1),(x,y-1)]
+
+def bfs_reachable(grid, start):
+    H, W = grid.shape
+    sx, sy = start
+    if grid[sy, sx] == 1:
+        return set()
+    q = [(sx, sy)]
+    seen = set([(sx, sy)])
+    while q:
+        x, y = q.pop(0)
+        for nx, ny in neighbors4(x, y):
+            if 0 <= nx < W and 0 <= ny < H and (nx, ny) not in seen and grid[ny, nx] == 0:
+                seen.add((nx, ny))
+                q.append((nx, ny))
+    return seen
+
+def pick_spawn_pair(grid, rng, min_dist=8):
+    H, W = grid.shape
+    empties = [(x, y) for y in range(1, H-1) for x in range(1, W-1) if grid[y, x] == 0]
+    rng.shuffle(empties)
+    for pred in empties[:800]:
+        reach = bfs_reachable(grid, pred)
+        if len(reach) < 30:
+            continue
+        candidates = [p for p in reach if (p[0]-pred[0])**2 + (p[1]-pred[1])**2 >= min_dist*min_dist]
+        if candidates:
+            prey = rng.choice(candidates)
+            return pred, prey
+    pred = empties[0] if empties else (1, 1)
+    prey = empties[-1] if len(empties) > 1 else (2, 2)
+    return pred, prey
+
+def add_border_walls(grid):
+    H, W = grid.shape
     grid[0, :] = 1
-    grid[GRID_H-1, :] = 1
+    grid[H-1, :] = 1
     grid[:, 0] = 1
-    grid[:, GRID_W-1] = 1
+    grid[:, W-1] = 1
+    return grid
+
+def compute_unlocks(catches: int):
+    unlocked = set()
+    for name, need in MAP_UNLOCKS:
+        if catches >= need:
+            unlocked.add(name)
+    return unlocked
+
+# -----------------------------
+# Map generators (deterministic by seed)
+# -----------------------------
+def map_training(seed, w=23, h=23):
+    rng = seeded_rng(seed)
+    grid = np.zeros((h, w), dtype=np.int8)
+    add_border_walls(grid)
+    for y in range(2, h-2):
+        for x in range(2, w-2):
+            if rng.random() < 0.08:
+                grid[y, x] = 1
+    return grid
 
-    # obstacles
-    for y in range(1, GRID_H-1):
-        for x in range(1, GRID_W-1):
-            if rng.random() < OBSTACLE_P:
+def map_arena_plus(seed, w=23, h=23):
+    rng = seeded_rng(seed)
+    grid = np.zeros((h, w), dtype=np.int8)
+    add_border_walls(grid)
+    cx, cy = w//2, h//2
+    for y in range(1, h-1):
+        for x in range(1, w-1):
+            r2 = (x-cx)**2 + (y-cy)**2
+            if 36 <= r2 <= 44 and rng.random() < 0.85:
                 grid[y, x] = 1
+    for _ in range(8):
+        x = rng.randint(3, w-4)
+        y = rng.randint(3, h-4)
+        grid[y, x] = 1
+    return grid
 
-    def empty_cell():
-        for _ in range(20000):
-            x = rng.randint(1, GRID_W-2)
-            y = rng.randint(1, GRID_H-2)
-            if grid[y, x] == 0:
-                return (x, y)
-        return (1, 1)
+def map_corridor_maze(seed, w=23, h=23):
+    rng = seeded_rng(seed)
+    grid = np.ones((h, w), dtype=np.int8)
+    add_border_walls(grid)
+    for y in range(1, h-1):
+        for x in range(1, w-1):
+            if x % 2 == 1 and y % 2 == 1:
+                grid[y, x] = 0
+
+    start = (1, 1)
+    stack = [start]
+    visited = set([start])
+
+    def carve_between(a, b):
+        ax, ay = a; bx, by = b
+        mx, my = (ax+bx)//2, (ay+by)//2
+        grid[my, mx] = 0
+
+    while stack:
+        x, y = stack[-1]
+        dirs = [(2,0),(-2,0),(0,2),(0,-2)]
+        rng.shuffle(dirs)
+        moved = False
+        for dx, dy in dirs:
+            nx, ny = x+dx, y+dy
+            if 1 <= nx < w-1 and 1 <= ny < h-1 and (nx, ny) not in visited:
+                visited.add((nx, ny))
+                carve_between((x, y), (nx, ny))
+                stack.append((nx, ny))
+                moved = True
+                break
+        if not moved:
+            stack.pop()
+
+    grid[1,1] = 0
+    grid[1,2] = 0
+    grid[2,1] = 0
+    return grid
+
+def map_rooms(seed, w=25, h=25):
+    rng = seeded_rng(seed)
+    grid = np.ones((h, w), dtype=np.int8)
+    add_border_walls(grid)
+
+    rooms = []
+    for _ in range(10):
+        rw = rng.randint(4, 7)
+        rh = rng.randint(4, 7)
+        rx = rng.randint(1, w-rw-2)
+        ry = rng.randint(1, h-rh-2)
+        grid[ry:ry+rh, rx:rx+rw] = 0
+        rooms.append((rx, ry, rw, rh))
+
+    for i in range(len(rooms)-1):
+        x1 = rooms[i][0] + rooms[i][2]//2
+        y1 = rooms[i][1] + rooms[i][3]//2
+        x2 = rooms[i+1][0] + rooms[i+1][2]//2
+        y2 = rooms[i+1][1] + rooms[i+1][3]//2
+        if rng.random() < 0.5:
+            grid[y1, min(x1,x2):max(x1,x2)+1] = 0
+            grid[min(y1,y2):max(y1,y2)+1, x2] = 0
+        else:
+            grid[min(y1,y2):max(y1,y2)+1, x1] = 0
+            grid[y2, min(x1,x2):max(x1,x2)+1] = 0
+    return grid
 
-    pred = empty_cell()
-    prey = empty_cell()
-    while prey == pred:
-        prey = empty_cell()
+def map_labyrinth(seed, w=31, h=23):
+    rng = seeded_rng(seed)
+    grid = np.zeros((h, w), dtype=np.int8)
+    add_border_walls(grid)
+    for y in range(1, h-1):
+        for x in range(1, w-1):
+            if (x % 2 == 0 and rng.random() < 0.85) or (y % 3 == 0 and rng.random() < 0.55):
+                grid[y, x] = 1
+    for x in range(1, w-1):
+        grid[h//2, x] = 0
+    for x in range(3, w-3, 6):
+        for y in range(2, h-2):
+            if rng.random() < 0.75:
+                grid[y, x] = 0
+    return grid
+
+def map_dense_field(seed, w=23, h=23):
+    rng = seeded_rng(seed)
+    grid = np.zeros((h, w), dtype=np.int8)
+    add_border_walls(grid)
+    for y in range(1, h-1):
+        for x in range(1, w-1):
+            if rng.random() < 0.22:
+                grid[y, x] = 1
+    for _ in range(6):
+        cx = rng.randint(3, w-4)
+        cy = rng.randint(3, h-4)
+        for yy in range(cy-2, cy+3):
+            for xx in range(cx-2, cx+3):
+                if 1 <= xx < w-1 and 1 <= yy < h-1:
+                    grid[yy, xx] = 0
+    return grid
+
+MAP_BUILDERS = {
+    "Training Bay": map_training,
+    "Arena+": map_arena_plus,
+    "Corridor Maze": map_corridor_maze,
+    "Rooms": map_rooms,
+    "Labyrinth": map_labyrinth,
+    "Dense Field": map_dense_field,
+}
 
-    ori = rng.randint(0, 3)
+# -----------------------------
+# State construction
+# -----------------------------
+def build_state(seed, map_name, progress=None, override=None):
+    rng = seeded_rng(seed)
+    grid = MAP_BUILDERS[map_name](seed)
+    pred, prey = pick_spawn_pair(grid, rng, min_dist=8)
+    pred_ori = rng.randint(0, 3)
+    prey_ori = (pred_ori + 2) % 4
+
+    if progress is None:
+        progress = {"catches": 0, "unlocked": compute_unlocks(0)}
 
     st = {
         "seed": int(seed),
         "grid": grid,
+
         "pred": pred,
         "prey": prey,
-        "ori": ori,
+
+        "ori": pred_ori,
+        "prey_ori": prey_ori,
+
+        "control": "pred",          # "pred" or "prey" (view + manual inputs)
+        "overlay": False,           # coherence overlay
+        "disturbance": 0.0,         # subtle coherence metric (EWMA)
+        "last_impulse": 0.0,        # updated by actions
+
         "step": 0,
         "caught": False,
         "auto_chase": False,
         "auto_run": False,
-        "log": ["Reset."]
+
+        "log": [f"Reset into map: {map_name}"],
+        "map_name": map_name,
+        "progress": progress,
     }
+
+    if override:
+        for k, v in override.items():
+            if k == "grid":
+                continue
+            st[k] = v
+
     return st
 
+# -----------------------------
+# Save / Load helpers
+# -----------------------------
+def serialize_state(st):
+    catches = int(st["progress"]["catches"])
+    payload = {
+        "version": 2,
+        "seed": int(st["seed"]),
+        "map_name": str(st["map_name"]),
+        "step": int(st["step"]),
+
+        "pred": [int(st["pred"][0]), int(st["pred"][1])],
+        "prey": [int(st["prey"][0]), int(st["prey"][1])],
+
+        "ori": int(st["ori"]),
+        "prey_ori": int(st.get("prey_ori", 0)),
+
+        "control": str(st.get("control", "pred")),
+        "overlay": bool(st.get("overlay", False)),
+        "disturbance": float(st.get("disturbance", 0.0)),
+
+        "caught": bool(st["caught"]),
+        "auto_chase": bool(st["auto_chase"]),
+        "auto_run": bool(st["auto_run"]),
+
+        "catches": catches,
+        "log_tail": st["log"][-20:],
+    }
+    return payload
+
+def deserialize_state(payload):
+    seed = int(payload.get("seed", 1))
+    map_name = str(payload.get("map_name", "Training Bay"))
+    if map_name not in MAP_BUILDERS:
+        map_name = "Training Bay"
+
+    catches = int(payload.get("catches", 0))
+    progress = {"catches": catches, "unlocked": compute_unlocks(catches)}
+
+    override = {
+        "step": int(payload.get("step", 0)),
+        "pred": tuple(payload.get("pred", [1, 1])),
+        "prey": tuple(payload.get("prey", [2, 2])),
+
+        "ori": int(payload.get("ori", 0)) % 4,
+        "prey_ori": int(payload.get("prey_ori", 0)) % 4,
+
+        "control": str(payload.get("control", "pred")) if str(payload.get("control", "pred")) in ("pred", "prey") else "pred",
+        "overlay": bool(payload.get("overlay", False)),
+        "disturbance": float(payload.get("disturbance", 0.0)),
+        "last_impulse": 0.0,
+
+        "caught": bool(payload.get("caught", False)),
+        "auto_chase": bool(payload.get("auto_chase", False)),
+        "auto_run": bool(payload.get("auto_run", False)),
+
+        "log": (payload.get("log_tail", []) or [])[:],
+    }
+
+    st = build_state(seed, map_name, progress=progress, override=override)
+
+    # validate positions (must be on empty cells)
+    grid = st["grid"]
+    H, W = grid.shape
+    px, py = st["pred"]
+    qx, qy = st["prey"]
+    ok = (
+        0 <= px < W and 0 <= py < H and 0 <= qx < W and 0 <= qy < H
+        and grid[py, px] == 0 and grid[qy, qx] == 0
+    )
+    if not ok:
+        rng = seeded_rng(seed + 777)
+        st["pred"], st["prey"] = pick_spawn_pair(grid, rng, min_dist=8)
+        st["log"].append("Loaded save had invalid positions for this map; respawned safely.")
+
+    st["log"].append("Loaded save.")
+    return st
+
+def save_to_path(st, path):
+    payload = serialize_state(st)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+    st["log"].append(f"Saved to: {path}")
+
+def load_from_path(path):
+    with open(path, "r", encoding="utf-8") as f:
+        payload = json.load(f)
+    return deserialize_state(payload)
+
+# -----------------------------
+# Perception + rendering
+# -----------------------------
 def los_clear(grid, a, b):
-    # Grid LOS using DDA in continuous space (cell centers)
     ax, ay = a[0] + 0.5, a[1] + 0.5
     bx, by = b[0] + 0.5, b[1] + 0.5
     dx, dy = bx - ax, by - ay
@@ -117,23 +424,20 @@ def los_clear(grid, a, b):
     dy /= dist
 
     x, y = ax, ay
-    steps = int(dist * 20)  # oversample for safety
+    steps = int(dist * 20)
+    H, W = grid.shape
     for _ in range(steps):
         x += dx * (dist / steps)
         y += dy * (dist / steps)
         cx, cy = int(x), int(y)
-        cx = clamp(cx, 0, GRID_W-1)
-        cy = clamp(cy, 0, GRID_H-1)
+        cx = clamp(cx, 0, W-1)
+        cy = clamp(cy, 0, H-1)
         if grid[cy, cx] == 1:
             return False
     return True
 
 def dda_raycast(grid, px, py, ray_dx, ray_dy, max_depth=MAX_DEPTH):
-    """
-    DDA raycast in grid.
-    Returns: (hit_dist, hit_side, hit_cell_x, hit_cell_y)
-    hit_side: 0 if hit vertical wall, 1 if hit horizontal wall (used for shading)
-    """
+    H, W = grid.shape
     map_x = int(px)
     map_y = int(py)
 
@@ -156,7 +460,7 @@ def dda_raycast(grid, px, py, ray_dx, ray_dy, max_depth=MAX_DEPTH):
 
     hit = False
     side = 0
-    for _ in range(max_depth * 8):
+    for _ in range(max_depth * 10):
         if side_dist_x < side_dist_y:
             side_dist_x += delta_dist_x
             map_x += step_x
@@ -166,7 +470,7 @@ def dda_raycast(grid, px, py, ray_dx, ray_dy, max_depth=MAX_DEPTH):
             map_y += step_y
             side = 1
 
-        if map_x < 0 or map_x >= GRID_W or map_y < 0 or map_y >= GRID_H:
+        if map_x < 0 or map_x >= W or map_y < 0 or map_y >= H:
             break
         if grid[map_y, map_x] == 1:
             hit = True
@@ -175,7 +479,6 @@ def dda_raycast(grid, px, py, ray_dx, ray_dy, max_depth=MAX_DEPTH):
     if not hit:
         return max_depth, 0, map_x, map_y
 
-    # perpendicular distance (avoid fisheye by using projection)
     if side == 0:
         denom = ray_dx if abs(ray_dx) > 1e-9 else 1e-9
         perp = (map_x - px + (1 - step_x) / 2) / denom
@@ -187,29 +490,71 @@ def dda_raycast(grid, px, py, ray_dx, ray_dy, max_depth=MAX_DEPTH):
     perp = clamp(perp, 0.0005, max_depth)
     return perp, side, map_x, map_y
 
+def _apply_coherence_overlay(img, disturbance: float):
+    # Very subtle: faint torque lines + edge tint. Disturbance expected ~[0..~3]
+    d = float(disturbance)
+    if d <= 0.001:
+        return img
+
+    alpha = clamp(d * 0.06, 0.0, 0.22)  # keep subtle
+    h, w, _ = img.shape
+    cx, cy = w // 2, h // 2
+
+    # edge tint
+    edge = int(min(w, h) * 0.08)
+    if edge >= 2:
+        tint = np.array([22, 8, 18], dtype=np.float32)  # slight magenta heat
+        # top
+        img[:edge, :, :] = np.clip(img[:edge, :, :].astype(np.float32) + tint * alpha, 0, 255).astype(np.uint8)
+        # bottom
+        img[h-edge:, :, :] = np.clip(img[h-edge:, :, :].astype(np.float32) + tint * alpha, 0, 255).astype(np.uint8)
+        # left
+        img[:, :edge, :] = np.clip(img[:, :edge, :].astype(np.float32) + tint * alpha, 0, 255).astype(np.uint8)
+        # right
+        img[:, w-edge:, :] = np.clip(img[:, w-edge:, :].astype(np.float32) + tint * alpha, 0, 255).astype(np.uint8)
+
+    # torque lines near center
+    line_col = np.array([180, 70, 160], dtype=np.float32)  # muted
+    for i in range(-40, 41):
+        x = cx + i
+        y = cy + int(i * 0.35)
+        if 0 <= x < w and 0 <= y < h:
+            img[y:y+1, x:x+1, :] = np.clip(img[y:y+1, x:x+1, :].astype(np.float32) * (1-alpha) + line_col * alpha, 0, 255).astype(np.uint8)
+
+        y2 = cy - int(i * 0.35)
+        if 0 <= x < w and 0 <= y2 < h:
+            img[y2:y2+1, x:x+1, :] = np.clip(img[y2:y2+1, x:x+1, :].astype(np.float32) * (1-alpha) + line_col * alpha, 0, 255).astype(np.uint8)
+
+    return img
+
 def render_first_person(st):
     grid = st["grid"]
-    (cx, cy) = st["pred"]
-    ori = st["ori"]
 
+    # viewer is whichever agent is currently controlled
+    if st["control"] == "prey":
+        view_cell = st["prey"]
+        view_ori = st["prey_ori"]
+        other_cell = st["pred"]
+    else:
+        view_cell = st["pred"]
+        view_ori = st["ori"]
+        other_cell = st["prey"]
+
+    (cx, cy) = view_cell
     px = cx + 0.5
     py = cy + 0.5
 
     fov = math.radians(FOV_DEG)
-    base = math.radians(ORI_DEG[ori])
+    base = math.radians(ORI_DEG[view_ori])
 
     img = np.zeros((VIEW_H, VIEW_W, 3), dtype=np.uint8)
-
-    # sky
     img[:VIEW_H//2, :, :] = SKY
 
-    # floor gradient
     for y in range(VIEW_H//2, VIEW_H):
         t = (y - VIEW_H//2) / max(1, (VIEW_H//2 - 1))
         col = (FLOOR_NEAR * (1 - t) + FLOOR_FAR * t).astype(np.uint8)
         img[y, :, :] = col
 
-    # Raycast at lower resolution then upscale to VIEW_W
     wall_dists = np.full(RAY_W, MAX_DEPTH, dtype=np.float32)
 
     for x in range(RAY_W):
@@ -219,163 +564,224 @@ def render_first_person(st):
         ray_dy = math.sin(ang)
 
         dist, side, hitx, hity = dda_raycast(grid, px, py, ray_dx, ray_dy, MAX_DEPTH)
-        # remove fisheye: project on camera direction
         dist *= math.cos(ang - base)
         dist = clamp(dist, 0.001, MAX_DEPTH)
         wall_dists[x] = dist
 
-        # wall slice height
         slice_h = int((VIEW_H * 0.92) / dist)
         slice_h = clamp(slice_h, 1, VIEW_H)
         top = (VIEW_H - slice_h) // 2
         bot = top + slice_h
 
-        # shading: distance + side shading
         shade = 1.0 / (1.0 + dist * 0.12)
         shade = clamp(shade, 0.12, 1.0)
-
         base_col = WALL_SIDE if side == 1 else WALL_BASE
-
-        # cheap "texture" pattern by hit cell coords
         checker = ((hitx + hity) & 1)
         tex = 0.90 if checker == 0 else 1.05
-
         col = np.clip(base_col.astype(np.float32) * shade * tex, 0, 255).astype(np.uint8)
 
-        # draw vertical stripe into upscaled coordinates later
-        # map x from RAY_W -> VIEW_W
         x0 = int(x * VIEW_W / RAY_W)
         x1 = int((x + 1) * VIEW_W / RAY_W)
         if x1 <= x0:
             x1 = x0 + 1
         img[top:bot, x0:x1, :] = col
 
-    # Prey billboard: only if in FOV AND LOS AND not behind wall per-column
-    prey = st["prey"]
-    prey_vis = False
-    if not st["caught"]:
-        if los_clear(grid, st["pred"], prey):
-            vx = (prey[0] + 0.5) - px
-            vy = (prey[1] + 0.5) - py
-            prey_dist = math.hypot(vx, vy)
-            prey_ang = math.atan2(vy, vx)
-            rel = angle_diff_rad(prey_ang, base)
-            if abs(rel) <= fov * 0.5 and prey_dist < MAX_DEPTH:
-                prey_vis = True
-
-                # screen x in ray space
-                u = (rel / fov) + 0.5
-                sx_ray = int(u * (RAY_W - 1))
-                sx_ray = clamp(sx_ray, 0, RAY_W - 1)
-
-                # sprite size
-                sprite_h = int((VIEW_H * 0.75) / max(0.2, prey_dist))
-                sprite_w = int(sprite_h * 0.45)
-                sprite_h = clamp(sprite_h, 8, VIEW_H)
-                sprite_w = clamp(sprite_w, 6, VIEW_W)
-
-                # convert to VIEW coords
-                sx = int(sx_ray * VIEW_W / RAY_W)
-                sy = VIEW_H // 2
-
-                x0 = clamp(sx - sprite_w // 2, 0, VIEW_W - 1)
-                x1 = clamp(sx + sprite_w // 2, 0, VIEW_W - 1)
-                y0 = clamp(sy - sprite_h // 2, 0, VIEW_H - 1)
-                y1 = clamp(sy + sprite_h // 2, 0, VIEW_H - 1)
-
-                # Occlusion test: only draw columns where prey is closer than wall
-                # Convert view columns -> ray columns
-                for vxcol in range(x0, x1):
-                    rx = int(vxcol * RAY_W / VIEW_W)
-                    rx = clamp(rx, 0, RAY_W - 1)
-                    if prey_dist < wall_dists[rx]:
-                        img[y0:y1, vxcol:vxcol+1, :] = PREY_COLOR
-
-    # Reticle (crosshair)
+    # Other-agent billboard (LOS + per-column occlusion)
+    other_vis = False
+    if not st["caught"] and los_clear(grid, view_cell, other_cell):
+        vx = (other_cell[0] + 0.5) - px
+        vy = (other_cell[1] + 0.5) - py
+        other_dist = math.hypot(vx, vy)
+        other_ang = math.atan2(vy, vx)
+        rel = angle_diff_rad(other_ang, base)
+        if abs(rel) <= fov * 0.5 and other_dist < MAX_DEPTH:
+            other_vis = True
+            u = (rel / fov) + 0.5
+            sx_ray = int(u * (RAY_W - 1))
+            sx_ray = clamp(sx_ray, 0, RAY_W - 1)
+
+            sprite_h = int((VIEW_H * 0.75) / max(0.2, other_dist))
+            sprite_w = int(sprite_h * 0.45)
+            sprite_h = clamp(sprite_h, 8, VIEW_H)
+            sprite_w = clamp(sprite_w, 6, VIEW_W)
+
+            sx = int(sx_ray * VIEW_W / RAY_W)
+            sy = VIEW_H // 2
+
+            x0 = clamp(sx - sprite_w // 2, 0, VIEW_W - 1)
+            x1 = clamp(sx + sprite_w // 2, 0, VIEW_W - 1)
+            y0 = clamp(sy - sprite_h // 2, 0, VIEW_H - 1)
+            y1 = clamp(sy + sprite_h // 2, 0, VIEW_H - 1)
+
+            for vxcol in range(x0, x1):
+                rx = int(vxcol * RAY_W / VIEW_W)
+                rx = clamp(rx, 0, RAY_W - 1)
+                if other_dist < wall_dists[rx]:
+                    img[y0:y1, vxcol:vxcol+1, :] = AGENT_OTHER_COLOR
+
+    # Reticle
     cxh, cyh = VIEW_W // 2, VIEW_H // 2
     img[cyh-1:cyh+2, cxh-12:cxh+13, :] = RETICLE
     img[cyh-12:cyh+13, cxh-1:cxh+2, :] = RETICLE
 
-    # HUD strip (simple, in-image)
+    # HUD strip
     hud_h = 26
     img[:hud_h, :, :] = np.clip(img[:hud_h, :, :].astype(np.int16) + 20, 0, 255).astype(np.uint8)
 
-    # encode tiny indicators as pixels (keeps deps minimal: no PIL)
-    # left corner: auto_chase / auto_run / prey_vis
+    # Indicator dots:
+    # - AutoChase
+    # - AutoRun
+    # - OtherVisible
     def dot(x, y, c):
         img[y:y+6, x:x+6, :] = c
 
     dot(8, 10, np.array([90, 255, 140], np.uint8) if st["auto_chase"] else np.array([60, 60, 70], np.uint8))
     dot(20, 10, np.array([120, 190, 255], np.uint8) if st["auto_run"] else np.array([60, 60, 70], np.uint8))
-    dot(32, 10, np.array([255, 140, 90], np.uint8) if prey_vis else np.array([60, 60, 70], np.uint8))
+    dot(32, 10, np.array([255, 140, 90], np.uint8) if other_vis else np.array([60, 60, 70], np.uint8))
+
+    # Optional coherence overlay
+    if st.get("overlay", False):
+        img = _apply_coherence_overlay(img, st.get("disturbance", 0.0))
 
     return img
 
 def render_minimap(st, scale=14):
     grid = st["grid"]
-    h, w = grid.shape
-    img = np.zeros((h*scale, w*scale, 3), dtype=np.uint8)
-
-    # base
+    H, W = grid.shape
+    img = np.zeros((H*scale, W*scale, 3), dtype=np.uint8)
     img[:, :, :] = np.array([18, 20, 32], dtype=np.uint8)
 
-    # walls
     wall = np.array([220, 220, 235], dtype=np.uint8)
-    for y in range(h):
-        for x in range(w):
+    for y in range(H):
+        for x in range(W):
             if grid[y, x] == 1:
                 img[y*scale:(y+1)*scale, x*scale:(x+1)*scale, :] = wall
 
-    # prey / pred
-    pred = st["pred"]
-    prey = st["prey"]
-    px, py = pred
-    qx, qy = prey
+    px, py = st["pred"]
+    qx, qy = st["prey"]
 
-    img[py*scale:(py+1)*scale, px*scale:(px+1)*scale, :] = np.array([120, 190, 255], np.uint8)
-    img[qy*scale:(qy+1)*scale, qx*scale:(qx+1)*scale, :] = np.array([255, 140, 90], np.uint8)
+    pred_col = np.array([120, 190, 255], np.uint8)
+    prey_col = np.array([255, 140, 90], np.uint8)
 
-    # heading marker
-    ori = st["ori"]
-    dx, dy = DIRS[ori]
-    hx = px + dx
-    hy = py + dy
-    if 0 <= hx < w and 0 <= hy < h:
+    img[py*scale:(py+1)*scale, px*scale:(px+1)*scale, :] = pred_col
+    img[qy*scale:(qy+1)*scale, qx*scale:(qx+1)*scale, :] = prey_col
+
+    # headings
+    dx, dy = DIRS[st["ori"]]
+    hx, hy = px + dx, py + dy
+    if 0 <= hx < W and 0 <= hy < H:
         img[hy*scale:(hy+1)*scale, hx*scale:(hx+1)*scale, :] = np.array([80, 255, 160], np.uint8)
 
+    dx2, dy2 = DIRS[st["prey_ori"]]
+    hx2, hy2 = qx + dx2, qy + dy2
+    if 0 <= hx2 < W and 0 <= hy2 < H:
+        img[hy2*scale:(hy2+1)*scale, hx2*scale:(hx2+1)*scale, :] = np.array([255, 220, 120], np.uint8)
+
+    # highlight controlled agent with a bright ring (simple border)
+    if st["control"] == "pred":
+        x0, y0 = px*scale, py*scale
+    else:
+        x0, y0 = qx*scale, qy*scale
+    ring = np.array([240, 240, 140], np.uint8)
+    img[y0:y0+scale, x0:x0+2, :] = ring
+    img[y0:y0+scale, x0+scale-2:x0+scale, :] = ring
+    img[y0:y0+2, x0:x0+scale, :] = ring
+    img[y0+scale-2:y0+scale, x0:x0+scale, :] = ring
+
     return img
 
+def unlock_summary(st):
+    catches = st["progress"]["catches"]
+    unlocked = st["progress"]["unlocked"]
+    lines = []
+    for name, need in MAP_UNLOCKS:
+        if name in unlocked:
+            lines.append(f"✅ {name} (unlocked)")
+        else:
+            lines.append(f"🔒 {name} (needs {need} catches)")
+    return "### Map progression\n" + "\n".join(lines) + f"\n\n**Total catches:** {catches}"
+
 def status(st):
-    ori_txt = ["E", "S", "W", "N"][st["ori"]]
+    pred_ori_txt = ["E", "S", "W", "N"][st["ori"]]
+    prey_ori_txt = ["E", "S", "W", "N"][st["prey_ori"]]
     tail = st["log"][-10:]
+    catches = st["progress"]["catches"]
+    current = st["map_name"]
+
+    # interpret hybrid clearly
+    mode = "Manual"
+    if st["auto_run"] and st["auto_chase"]:
+        mode = "AutoRun+AutoChase (pred chases autonomously)"
+    elif st["auto_run"] and not st["auto_chase"]:
+        mode = "Hybrid AutoRun (pred wanders autonomously)"
+
+    ctrl = "Predator" if st["control"] == "pred" else "Prey"
+    coh = st.get("disturbance", 0.0)
     return (
-        f"Step: {st['step']} | Predator: {st['pred']} {ori_txt} | Prey: {st['prey']} | "
-        f"AutoChase: {st['auto_chase']} | AutoRun: {st['auto_run']} | Caught: {st['caught']}\n\n"
+        f"Map: {current} | Catches: {catches} | Step: {st['step']} | Mode: {mode} | Control: {ctrl} | Overlay: {st.get('overlay', False)}\n"
+        f"Predator: {st['pred']} {pred_ori_txt} | Prey: {st['prey']} {prey_ori_txt} | "
+        f"AutoChase: {st['auto_chase']} | AutoRun: {st['auto_run']} | Caught: {st['caught']} | Coherence: {coh:.2f}\n\n"
         + "\n".join(tail)
     )
 
-def move_forward(st):
-    if st["caught"]:
-        return
-    x, y = st["pred"]
-    dx, dy = DIRS[st["ori"]]
-    nx, ny = x + dx * MOVE_STEP, y + dy * MOVE_STEP
-    if st["grid"][ny, nx] == 0:
-        st["pred"] = (nx, ny)
+# -----------------------------
+# Actions (manual + autonomous)
+# -----------------------------
+def _add_impulse(st, x):
+    st["last_impulse"] = float(st.get("last_impulse", 0.0)) + float(x)
+
+def _step_disturbance(st):
+    # EWMA, keeps it subtle. Decays naturally.
+    d = float(st.get("disturbance", 0.0))
+    imp = float(st.get("last_impulse", 0.0))
+    st["disturbance"] = 0.92 * d + imp
+    st["last_impulse"] = 0.0
+
+def _agent_pos_ori(st, who):
+    if who == "prey":
+        return st["prey"], st["prey_ori"]
+    return st["pred"], st["ori"]
+
+def _set_agent_pos_ori(st, who, pos=None, ori=None):
+    if who == "prey":
+        if pos is not None: st["prey"] = pos
+        if ori is not None: st["prey_ori"] = int(ori) % 4
     else:
-        st["log"].append("Bumped wall.")
+        if pos is not None: st["pred"] = pos
+        if ori is not None: st["ori"] = int(ori) % 4
 
-def turn_left(st):
+def _turn(st, who, direction):  # direction = -1 left, +1 right
     if st["caught"]:
         return
-    st["ori"] = (st["ori"] - 1) % 4
+    pos, ori = _agent_pos_ori(st, who)
+    ori = (ori + direction) % 4
+    _set_agent_pos_ori(st, who, ori=ori)
+    _add_impulse(st, 0.9)  # turning = higher disturbance
 
-def turn_right(st):
+def _forward(st, who):
     if st["caught"]:
         return
-    st["ori"] = (st["ori"] + 1) % 4
+    (x, y), ori = _agent_pos_ori(st, who)
+    dx, dy = DIRS[ori]
+    nx, ny = x + dx * MOVE_STEP, y + dy * MOVE_STEP
+    if st["grid"][ny, nx] == 0:
+        _set_agent_pos_ori(st, who, pos=(nx, ny))
+        _add_impulse(st, 0.25)
+    else:
+        st["log"].append(f"{'Prey' if who=='prey' else 'Predator'} bumped wall.")
+        _add_impulse(st, 0.7)
+
+def _check_catch_and_unlock(st):
+    if st["pred"] == st["prey"] and not st["caught"]:
+        st["caught"] = True
+        st["log"].append("CAUGHT the prey.")
+        st["progress"]["catches"] += 1
+        st["progress"]["unlocked"] = compute_unlocks(st["progress"]["catches"])
+        st["log"].append(f"Catches now {st['progress']['catches']}. Unlocks updated.")
+        _add_impulse(st, 1.2)
 
-def prey_step(st):
+def prey_flee_step(st):
+    # prey flees predator (if prey is not player-controlled)
     if st["caught"]:
         return
     rng = seeded_rng(st["seed"] + 1337 + st["step"] * 19)
@@ -389,28 +795,52 @@ def prey_step(st):
         if st["grid"][ny, nx] == 1:
             continue
         dist = (nx-ax)**2 + (ny-ay)**2
-        scored.append((dist + rng.random()*0.1, (nx, ny)))
+        scored.append((dist + rng.random()*0.1, (nx, ny), (dx, dy)))
 
     if scored:
         scored.sort(reverse=True)
-        st["prey"] = scored[0][1] if rng.random() < 0.78 else rng.choice(scored)[1]
+        pick = scored[0] if rng.random() < 0.78 else rng.choice(scored)
+        _, (nx, ny), (dx, dy) = pick
+        st["prey"] = (nx, ny)
+        if (dx, dy) in DIR_TO_ORI and (dx, dy) != (0,0):
+            st["prey_ori"] = DIR_TO_ORI[(dx, dy)]
+
+def predator_wander_step(st):
+    # Hybrid mode: predator wanders autonomously (if predator is not player-controlled)
+    if st["caught"]:
+        return
+    rng = seeded_rng(st["seed"] + 4242 + st["step"] * 23)
+    (x, y) = st["pred"]
+    ori = st["ori"]
+    dx, dy = DIRS[ori]
+    front_blocked = (st["grid"][y+dy, x+dx] == 1)
 
-def check_catch(st):
-    if st["pred"] == st["prey"]:
-        st["caught"] = True
-        st["log"].append("CAUGHT the prey.")
+    # If blocked, turn deterministically-ish. Else random preference: forward with occasional turns.
+    r = rng.random()
+    if front_blocked:
+        if r < 0.5:
+            _turn(st, "pred", -1); st["log"].append("AutoWander: avoid left.")
+        else:
+            _turn(st, "pred", +1); st["log"].append("AutoWander: avoid right.")
+    else:
+        if r < 0.72:
+            _forward(st, "pred"); st["log"].append("AutoWander: forward.")
+        elif r < 0.86:
+            _turn(st, "pred", -1); st["log"].append("AutoWander: turn left.")
+        else:
+            _turn(st, "pred", +1); st["log"].append("AutoWander: turn right.")
 
-def auto_chase_policy(st):
+def predator_chase_step(st):
+    # AutoChase mode: predator turns/moves toward prey when in LOS+FOV; else roams with wall avoid
     if st["caught"]:
         return
-    # If prey visible + in FOV, turn toward it; else drift forward avoiding walls.
     grid = st["grid"]
     px = st["pred"][0] + 0.5
     py = st["pred"][1] + 0.5
     base = math.radians(ORI_DEG[st["ori"]])
     fov = math.radians(FOV_DEG)
-
     prey = st["prey"]
+
     if los_clear(grid, st["pred"], prey):
         vx = (prey[0] + 0.5) - px
         vy = (prey[1] + 0.5) - py
@@ -418,99 +848,196 @@ def auto_chase_policy(st):
         rel = angle_diff_rad(ang, base)
         if abs(rel) <= fov * 0.5:
             if rel < -0.10:
-                turn_left(st); st["log"].append("AutoChase: turn left.")
+                _turn(st, "pred", -1); st["log"].append("AutoChase: turn left.")
             elif rel > 0.10:
-                turn_right(st); st["log"].append("AutoChase: turn right.")
+                _turn(st, "pred", +1); st["log"].append("AutoChase: turn right.")
             else:
-                move_forward(st); st["log"].append("AutoChase: forward.")
+                _forward(st, "pred"); st["log"].append("AutoChase: forward.")
             return
 
-    # avoid walls: look one step ahead
-    x, y = st["pred"]
-    dx, dy = DIRS[st["ori"]]
-    if st["grid"][y+dy, x+dx] == 1:
-        if random.random() < 0.5:
-            turn_left(st); st["log"].append("AutoChase: avoid left.")
-        else:
-            turn_right(st); st["log"].append("AutoChase: avoid right.")
-    else:
-        move_forward(st); st["log"].append("AutoChase: forward roam.")
+    # fallback: wander-ish
+    predator_wander_step(st)
 
 def tick(st):
     if st["caught"]:
         return
+
     st["step"] += 1
 
-    if st["auto_chase"]:
-        auto_chase_policy(st)
+    # Autonomous predator step ONLY when predator is not player-controlled and AutoRun is enabled.
+    if st["auto_run"] and st["control"] != "pred":
+        if st["auto_chase"]:
+            predator_chase_step(st)
+        else:
+            predator_wander_step(st)
 
-    prey_step(st)
-    check_catch(st)
+    # Autonomous prey flee ONLY when prey is not player-controlled.
+    if st["control"] != "prey":
+        prey_flee_step(st)
+
+    _check_catch_and_unlock(st)
+    _step_disturbance(st)
 
     if st["step"] >= 600:
         st["caught"] = True
         st["log"].append("Max steps reached (freeze).")
 
 # -----------------------------
-# Gradio actions
+# Gradio handlers
 # -----------------------------
-def ui_reset(seed):
-    st = make_world(int(seed))
-    return st, render_first_person(st), render_minimap(st), status(st)
-
-def ui_left(st):
-    turn_left(st); st["log"].append("Turn left.")
+def ui_refresh_slots(current_value=None):
+    choices = list_save_slots()
+    if current_value and current_value in choices:
+        value = current_value
+    else:
+        value = choices[0] if choices else "slot1.json"
+    return gr.Dropdown(choices=choices if choices else ["slot1.json"], value=value)
+
+def ui_reset(seed, map_choice, st=None):
+    seed = int(seed)
+    progress = st["progress"] if st else {"catches": 0, "unlocked": compute_unlocks(0)}
+    if map_choice not in progress["unlocked"]:
+        map_choice = "Training Bay"
+    new_st = build_state(seed, map_choice, progress=progress)
+    # keep user prefs
+    if st:
+        new_st["control"] = st.get("control", "pred")
+        new_st["overlay"] = st.get("overlay", False)
+    return new_st, render_first_person(new_st), render_minimap(new_st), status(new_st), unlock_summary(new_st)
+
+def ui_toggle_control(st):
+    st["control"] = "prey" if st["control"] == "pred" else "pred"
+    st["log"].append(f"Control switched to: {'Prey' if st['control']=='prey' else 'Predator'}.")
+    _add_impulse(st, 0.15)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+
+def ui_turn_left(st):
+    who = st["control"]
+    _turn(st, who, -1)
+    st["log"].append(f"{'Prey' if who=='prey' else 'Predator'} turn left.")
     tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
 
-def ui_right(st):
-    turn_right(st); st["log"].append("Turn right.")
+def ui_turn_right(st):
+    who = st["control"]
+    _turn(st, who, +1)
+    st["log"].append(f"{'Prey' if who=='prey' else 'Predator'} turn right.")
     tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
 
 def ui_forward(st):
-    move_forward(st); st["log"].append("Forward.")
-    check_catch(st)
+    who = st["control"]
+    _forward(st, who)
+    st["log"].append(f"{'Prey' if who=='prey' else 'Predator'} forward.")
+    _check_catch_and_unlock(st)
     tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
 
 def ui_toggle_chase(st):
     st["auto_chase"] = not st["auto_chase"]
     st["log"].append(f"AutoChase set to {st['auto_chase']}.")
-    return st, render_first_person(st), render_minimap(st), status(st)
+    _add_impulse(st, 0.10)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
 
 def ui_toggle_run(st):
     st["auto_run"] = not st["auto_run"]
     st["log"].append(f"AutoRun set to {st['auto_run']}.")
-    return st, render_first_person(st), render_minimap(st), status(st)
+    _add_impulse(st, 0.10)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+
+def ui_toggle_overlay(st):
+    st["overlay"] = not st.get("overlay", False)
+    st["log"].append(f"Overlay set to {st['overlay']}.")
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
 
 def ui_tick(st):
     tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
 
 def ui_timer(st):
-    # Timer-driven tick when AutoRun is enabled
     if st["auto_run"] and not st["caught"]:
         tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+
+def ui_swap_roles(st):
+    # Optional: swap predator <-> prey positions/orientations (symmetry hammer)
+    if st["caught"]:
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+
+    st["pred"], st["prey"] = st["prey"], st["pred"]
+    st["ori"], st["prey_ori"] = st["prey_ori"], st["ori"]
+    st["log"].append("Swapped roles (Predator ⇄ Prey).")
+    _add_impulse(st, 0.35)
+    _check_catch_and_unlock(st)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+
+# ---- Save/load UI handlers ----
+def ui_save_slot(st, slot_name):
+    try:
+        path = _slot_path(slot_name)
+        save_to_path(st, path)
+        export_path = path
+    except Exception as e:
+        st["log"].append(f"Save failed: {e}")
+        export_path = None
+
+    dd = ui_refresh_slots(os.path.basename(export_path) if export_path else None)
+    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st), export_path, dd
+
+def ui_load_slot(st, selected_slot):
+    path = os.path.join(SAVE_DIR, selected_slot) if selected_slot else _slot_path("slot1")
+    try:
+        if not os.path.exists(path):
+            st["log"].append(f"No save found at {path}")
+            dd = ui_refresh_slots(selected_slot)
+            return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st), None, dd
+        loaded = load_from_path(path)
+        dd = ui_refresh_slots(os.path.basename(path))
+        return loaded, render_first_person(loaded), render_minimap(loaded), status(loaded), unlock_summary(loaded), None, dd
+    except Exception as e:
+        st["log"].append(f"Load failed: {e}")
+        dd = ui_refresh_slots(selected_slot)
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st), None, dd
+
+def ui_import_save(st, uploaded_file):
+    try:
+        if uploaded_file is None:
+            st["log"].append("Import: no file provided.")
+            dd = ui_refresh_slots()
+            return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st), None, dd
+        loaded = load_from_path(uploaded_file)
+        dd = ui_refresh_slots()
+        return loaded, render_first_person(loaded), render_minimap(loaded), status(loaded), unlock_summary(loaded), None, dd
+    except Exception as e:
+        st["log"].append(f"Import failed: {e}")
+        dd = ui_refresh_slots()
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st), None, dd
 
 # -----------------------------
 # App
 # -----------------------------
-with gr.Blocks(title="RFT Predator Space — First Person Observer") as demo:
+all_map_names = [name for name, _ in MAP_UNLOCKS]
+initial_progress = {"catches": 0, "unlocked": compute_unlocks(0)}
+initial_state = build_state(seed=1, map_name="Training Bay", progress=initial_progress)
+
+initial_slots = list_save_slots()
+initial_slot_value = initial_slots[0] if initial_slots else "slot1.json"
+
+with gr.Blocks(title="RFT Predator Space — Symmetric Observers") as demo:
     gr.Markdown(
         "## Experience reality through an RFT observer agent’s perspective\n"
-        "This view shows **only what the predator can perceive**: a pseudo-3D raycast viewport with occlusion and LOS-correct prey visibility.\n"
-        "**Dots:** AutoChase / AutoRun / PreyVisible (top-left)."
+        "Two symmetric observers share the same frame.\n\n"
+        "**Hybrid mode:** AutoRun ON + AutoChase OFF ⇒ predator wanders autonomously while prey flees (unless you control it).\n"
+        "**Symmetry:** Toggle control to view/drive either observer."
     )
 
-    st = gr.State(make_world(1))
+    st = gr.State(initial_state)
 
     with gr.Row():
         seed = gr.Number(label="Seed", value=1, precision=0)
+        map_choice = gr.Dropdown(label="Map (locked unless unlocked)", choices=all_map_names, value="Training Bay")
         btn_reset = gr.Button("Reset")
-        btn_chase = gr.Button("Toggle AutoChase")
-        btn_run = gr.Button("Toggle AutoRun")
+        btn_control = gr.Button("Toggle Control (Pred ↔ Prey)")
         btn_tick = gr.Button("Tick")
 
     with gr.Row():
@@ -518,25 +1045,77 @@ with gr.Blocks(title="RFT Predator Space — First Person Observer") as demo:
         btn_fwd = gr.Button("Forward")
         btn_right = gr.Button("Turn Right")
 
+    with gr.Row():
+        btn_chase = gr.Button("Toggle AutoChase")
+        btn_run = gr.Button("Toggle AutoRun")
+        btn_overlay = gr.Button("Toggle Overlay (optional)")
+        btn_swap = gr.Button("Swap Roles (Pred ⇄ Prey)")
+
     with gr.Row():
         view = gr.Image(label="First-person observer view", type="numpy")
         mini = gr.Image(label="Minimap (debug)", type="numpy")
 
-    info = gr.Textbox(label="Run log", lines=12)
+    with gr.Row():
+        info = gr.Textbox(label="Run log", lines=12)
+        unlocks = gr.Markdown(value=unlock_summary(initial_state))
 
-    demo.load(lambda: (st.value, render_first_person(st.value), render_minimap(st.value), status(st.value)),
-              outputs=[st, view, mini, info])
+    gr.Markdown("### Save / Load")
 
-    btn_reset.click(ui_reset, inputs=[seed], outputs=[st, view, mini, info])
-    btn_left.click(ui_left, inputs=[st], outputs=[st, view, mini, info])
-    btn_right.click(ui_right, inputs=[st], outputs=[st, view, mini, info])
-    btn_fwd.click(ui_forward, inputs=[st], outputs=[st, view, mini, info])
-    btn_chase.click(ui_toggle_chase, inputs=[st], outputs=[st, view, mini, info])
-    btn_run.click(ui_toggle_run, inputs=[st], outputs=[st, view, mini, info])
-    btn_tick.click(ui_tick, inputs=[st], outputs=[st, view, mini, info])
+    with gr.Row():
+        slot_pick = gr.Dropdown(label="Existing saves", choices=initial_slots if initial_slots else ["slot1.json"], value=initial_slot_value)
+        slot_name = gr.Textbox(label="New save name (optional)", value="slot1")
+
+    with gr.Row():
+        btn_refresh = gr.Button("Refresh Saves List")
+        btn_save = gr.Button("Save (to name)")
+        btn_load = gr.Button("Load (selected)")
+
+    with gr.Row():
+        export_file = gr.File(label="Exported Save File (download this)", interactive=False)
+        import_file = gr.File(label="Import Save File (upload)", interactive=True)
+        btn_import = gr.Button("Import (Load Uploaded File)")
+
+    demo.load(
+        lambda: (st.value, render_first_person(st.value), render_minimap(st.value), status(st.value), unlock_summary(st.value), None, ui_refresh_slots(initial_slot_value)),
+        outputs=[st, view, mini, info, unlocks, export_file, slot_pick]
+    )
+
+    btn_reset.click(ui_reset, inputs=[seed, map_choice, st], outputs=[st, view, mini, info, unlocks])
+
+    btn_control.click(ui_toggle_control, inputs=[st], outputs=[st, view, mini, info, unlocks])
+
+    btn_left.click(ui_turn_left, inputs=[st], outputs=[st, view, mini, info, unlocks])
+    btn_right.click(ui_turn_right, inputs=[st], outputs=[st, view, mini, info, unlocks])
+    btn_fwd.click(ui_forward, inputs=[st], outputs=[st, view, mini, info, unlocks])
+
+    btn_chase.click(ui_toggle_chase, inputs=[st], outputs=[st, view, mini, info, unlocks])
+    btn_run.click(ui_toggle_run, inputs=[st], outputs=[st, view, mini, info, unlocks])
+    btn_overlay.click(ui_toggle_overlay, inputs=[st], outputs=[st, view, mini, info, unlocks])
+    btn_swap.click(ui_swap_roles, inputs=[st], outputs=[st, view, mini, info, unlocks])
+
+    btn_tick.click(ui_tick, inputs=[st], outputs=[st, view, mini, info, unlocks])
+
+    btn_refresh.click(lambda cur: ui_refresh_slots(cur), inputs=[slot_pick], outputs=[slot_pick])
+
+    btn_save.click(
+        lambda st_, name_, pick_: ui_save_slot(st_, name_ if (name_ and name_.strip()) else pick_),
+        inputs=[st, slot_name, slot_pick],
+        outputs=[st, view, mini, info, unlocks, export_file, slot_pick]
+    )
+
+    btn_load.click(
+        ui_load_slot,
+        inputs=[st, slot_pick],
+        outputs=[st, view, mini, info, unlocks, export_file, slot_pick]
+    )
+
+    btn_import.click(
+        ui_import_save,
+        inputs=[st, import_file],
+        outputs=[st, view, mini, info, unlocks, export_file, slot_pick]
+    )
 
-    # Timer auto-run (if supported by your Gradio build)
     if hasattr(gr, "Timer"):
-        gr.Timer(1.0 / AUTO_TICK_HZ).tick(ui_timer, inputs=[st], outputs=[st, view, mini, info])
+        gr.Timer(1.0 / AUTO_TICK_HZ).tick(ui_timer, inputs=[st], outputs=[st, view, mini, info, unlocks])
 
 demo.launch()