Update app.py

app.py

@@ -7,11 +7,10 @@ import gradio as gr
 
 # ============================================================
 # RFT Predator Space — First-Person Observer View (Pseudo-3D)
-# + 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)
+# FIXES:
+#  1) NO flashing progression panel (do NOT update it on timer ticks)
+#  2) AutoRun works in first-person POV (autopilot moves current POV agent)
+#  3) queue() enabled for reliable timer updates on Spaces
 # ============================================================
 
 # -----------------------------
@@ -68,10 +67,7 @@ def _slot_path(slot: str) -> str:
 
 def list_save_slots():
     try:
-        files = []
-        for fn in os.listdir(SAVE_DIR):
-            if fn.lower().endswith(".json"):
-                files.append(fn)
+        files = [fn for fn in os.listdir(SAVE_DIR) if fn.lower().endswith(".json")]
         files.sort()
         return files
     except Exception:
@@ -300,8 +296,8 @@ def build_state(seed, map_name, progress=None, override=None):
 
         "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
+        "disturbance": 0.0,
+        "last_impulse": 0.0,
 
         "step": 0,
         "caught": False,
@@ -331,21 +327,16 @@ def serialize_state(st):
         "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:],
     }
@@ -364,25 +355,20 @@ def deserialize_state(payload):
         "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"]
@@ -394,7 +380,7 @@ def deserialize_state(payload):
     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 had invalid positions; respawned safely.")
 
     st["log"].append("Loaded save.")
     return st
@@ -491,30 +477,23 @@ def dda_raycast(grid, px, py, ray_dx, ray_dy, max_depth=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
+    alpha = clamp(d * 0.06, 0.0, 0.22)  # 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
+        tint = np.array([22, 8, 18], dtype=np.float32)
         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
+    line_col = np.array([180, 70, 160], dtype=np.float32)
     for i in range(-40, 41):
         x = cx + i
         y = cy + int(i * 0.35)
@@ -530,7 +509,6 @@ def _apply_coherence_overlay(img, disturbance: float):
 def render_first_person(st):
     grid = st["grid"]
 
-    # viewer is whichever agent is currently controlled
     if st["control"] == "prey":
         view_cell = st["prey"]
         view_ori = st["prey_ori"]
@@ -586,7 +564,6 @@ def render_first_person(st):
             x1 = x0 + 1
         img[top:bot, x0:x1, :] = col
 
-    # 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
@@ -619,19 +596,13 @@ def render_first_person(st):
                 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
     hud_h = 26
     img[:hud_h, :, :] = np.clip(img[:hud_h, :, :].astype(np.int16) + 20, 0, 255).astype(np.uint8)
 
-    # Indicator dots:
-    # - AutoChase
-    # - AutoRun
-    # - OtherVisible
     def dot(x, y, c):
         img[y:y+6, x:x+6, :] = c
 
@@ -639,7 +610,6 @@ def render_first_person(st):
     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 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))
 
@@ -659,14 +629,12 @@ def render_minimap(st, scale=14):
 
     px, py = st["pred"]
     qx, qy = st["prey"]
-
     pred_col = np.array([120, 190, 255], np.uint8)
     prey_col = np.array([255, 140, 90], np.uint8)
 
     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:
@@ -677,7 +645,6 @@ def render_minimap(st, scale=14):
     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:
@@ -708,12 +675,11 @@ def status(st):
     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)"
+        mode = "AutoRun+AutoChase"
     elif st["auto_run"] and not st["auto_chase"]:
-        mode = "Hybrid AutoRun (pred wanders autonomously)"
+        mode = "Hybrid AutoRun (wander)"
 
     ctrl = "Predator" if st["control"] == "pred" else "Prey"
     coh = st.get("disturbance", 0.0)
@@ -731,7 +697,6 @@ 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
@@ -750,13 +715,13 @@ def _set_agent_pos_ori(st, who, pos=None, ori=None):
         if pos is not None: st["pred"] = pos
         if ori is not None: st["ori"] = int(ori) % 4
 
-def _turn(st, who, direction):  # direction = -1 left, +1 right
+def _turn(st, who, direction):
     if st["caught"]:
         return
-    pos, ori = _agent_pos_ori(st, who)
+    _, 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
+    _add_impulse(st, 0.9)
 
 def _forward(st, who):
     if st["caught"]:
@@ -779,9 +744,10 @@ def _check_catch_and_unlock(st):
         st["progress"]["unlocked"] = compute_unlocks(st["progress"]["catches"])
         st["log"].append(f"Catches now {st['progress']['catches']}. Unlocks updated.")
         _add_impulse(st, 1.2)
+        return True
+    return False
 
 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)
@@ -806,7 +772,6 @@ def prey_flee_step(st):
             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)
@@ -815,7 +780,6 @@ def predator_wander_step(st):
     dx, dy = DIRS[ori]
     front_blocked = (st["grid"][y+dy, x+dx] == 1)
 
-    # If blocked, turn deterministically-ish. Else random preference: forward with occasional turns.
     r = rng.random()
     if front_blocked:
         if r < 0.5:
@@ -831,7 +795,6 @@ def predator_wander_step(st):
             _turn(st, "pred", +1); st["log"].append("AutoWander: turn right.")
 
 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
     grid = st["grid"]
@@ -854,34 +817,51 @@ def predator_chase_step(st):
             else:
                 _forward(st, "pred"); st["log"].append("AutoChase: forward.")
             return
-
-    # fallback: wander-ish
     predator_wander_step(st)
 
+def prey_autopilot_step(st):
+    # if user is viewing prey and AutoRun is on, prey should still behave like prey (flee)
+    prey_flee_step(st)
+    st["log"].append("AutoPrey: flee.")
+
 def tick(st):
     if st["caught"]:
-        return
+        return False  # unlock did not change
 
     st["step"] += 1
+    unlock_changed = False
 
-    # Autonomous predator step ONLY when predator is not player-controlled and AutoRun is enabled.
-    if st["auto_run"] and st["control"] != "pred":
+    # AutoRun = autopilot for the currently viewed observer
+    if st["auto_run"]:
+        if st["control"] == "pred":
+            if st["auto_chase"]:
+                predator_chase_step(st)
+            else:
+                predator_wander_step(st)
+        else:
+            prey_autopilot_step(st)
+
+    # The non-controlled agent still runs its own policy each step
+    if st["control"] != "pred":
         if st["auto_chase"]:
             predator_chase_step(st)
         else:
             predator_wander_step(st)
 
-    # Autonomous prey flee ONLY when prey is not player-controlled.
     if st["control"] != "prey":
         prey_flee_step(st)
 
-    _check_catch_and_unlock(st)
+    # capture + unlock
+    unlock_changed = _check_catch_and_unlock(st)
+
     _step_disturbance(st)
 
     if st["step"] >= 600:
         st["caught"] = True
         st["log"].append("Max steps reached (freeze).")
 
+    return unlock_changed
+
 # -----------------------------
 # Gradio handlers
 # -----------------------------
@@ -899,7 +879,6 @@ def ui_reset(seed, map_choice, st=None):
     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)
@@ -915,61 +894,69 @@ 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), unlock_summary(st)
+    unlock_changed = tick(st)
+    if unlock_changed:
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()  # avoid re-render if unchanged
 
 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), unlock_summary(st)
+    unlock_changed = tick(st)
+    if unlock_changed:
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 def ui_forward(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), unlock_summary(st)
+    unlock_changed = tick(st)
+    if unlock_changed:
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 def ui_toggle_chase(st):
     st["auto_chase"] = not st["auto_chase"]
     st["log"].append(f"AutoChase set to {st['auto_chase']}.")
     _add_impulse(st, 0.10)
-    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 def ui_toggle_run(st):
     st["auto_run"] = not st["auto_run"]
     st["log"].append(f"AutoRun set to {st['auto_run']}.")
     _add_impulse(st, 0.10)
-    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 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)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 def ui_tick(st):
-    tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    unlock_changed = tick(st)
+    if unlock_changed:
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 def ui_timer(st):
+    # IMPORTANT: do NOT update unlock markdown here (prevents flashing)
     if st["auto_run"] and not st["caught"]:
-        tick(st)
-    return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+        _ = tick(st)
+    return st, render_first_person(st), render_minimap(st), status(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)
-
+        return st, render_first_person(st), render_minimap(st), status(st), gr.update()
     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)
+    changed = _check_catch_and_unlock(st)
+    if changed:
+        return st, render_first_person(st), render_minimap(st), status(st), unlock_summary(st)
+    return st, render_first_person(st), render_minimap(st), status(st), gr.update()
 
 # ---- Save/load UI handlers ----
 def ui_save_slot(st, slot_name):
@@ -990,28 +977,28 @@ def ui_load_slot(st, selected_slot):
         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
+            return st, render_first_person(st), render_minimap(st), status(st), gr.update(), 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
+        return st, render_first_person(st), render_minimap(st), status(st), gr.update(), 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
+            return st, render_first_person(st), render_minimap(st), status(st), gr.update(), 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
+        return st, render_first_person(st), render_minimap(st), status(st), gr.update(), None, dd
 
 # -----------------------------
 # App
@@ -1026,9 +1013,8 @@ 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"
-        "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."
+        "**Accessibility note:** the progression panel is now event-driven (no flashing).\n\n"
+        "**AutoRun:** moves the current POV observer (first-person autopilot)."
     )
 
     st = gr.State(initial_state)
@@ -1081,7 +1067,6 @@ with gr.Blocks(title="RFT Predator Space — Symmetric Observers") as demo:
     )
 
     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])
@@ -1115,7 +1100,13 @@ with gr.Blocks(title="RFT Predator Space — Symmetric Observers") as demo:
         outputs=[st, view, mini, info, unlocks, export_file, slot_pick]
     )
 
+    # Timer outputs DO NOT include unlocks (prevents flashing)
     if hasattr(gr, "Timer"):
-        gr.Timer(1.0 / AUTO_TICK_HZ).tick(ui_timer, inputs=[st], outputs=[st, view, mini, info, unlocks])
-
-demo.launch()
+        gr.Timer(1.0 / AUTO_TICK_HZ).tick(
+            ui_timer,
+            inputs=[st],
+            outputs=[st, view, mini, info]
+        )
+
+# queue() helps Timer behave reliably in Spaces
+demo.queue().launch()