Create app.py

app.py

@@ -0,0 +1,542 @@
+import math
+import random
+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
+# ============================================================
+
+# -----------------------------
+# 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)
+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)
+
+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”
+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]
+
+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
+
+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
+    grid[0, :] = 1
+    grid[GRID_H-1, :] = 1
+    grid[:, 0] = 1
+    grid[:, GRID_W-1] = 1
+
+    # obstacles
+    for y in range(1, GRID_H-1):
+        for x in range(1, GRID_W-1):
+            if rng.random() < OBSTACLE_P:
+                grid[y, x] = 1
+
+    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)
+
+    pred = empty_cell()
+    prey = empty_cell()
+    while prey == pred:
+        prey = empty_cell()
+
+    ori = rng.randint(0, 3)
+
+    st = {
+        "seed": int(seed),
+        "grid": grid,
+        "pred": pred,
+        "prey": prey,
+        "ori": ori,
+        "step": 0,
+        "caught": False,
+        "auto_chase": False,
+        "auto_run": False,
+        "log": ["Reset."]
+    }
+    return st
+
+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
+    dist = math.hypot(dx, dy)
+    if dist < 1e-6:
+        return True
+    dx /= dist
+    dy /= dist
+
+    x, y = ax, ay
+    steps = int(dist * 20)  # oversample for safety
+    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)
+        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)
+    """
+    map_x = int(px)
+    map_y = int(py)
+
+    delta_dist_x = abs(1.0 / ray_dx) if abs(ray_dx) > 1e-9 else 1e9
+    delta_dist_y = abs(1.0 / ray_dy) if abs(ray_dy) > 1e-9 else 1e9
+
+    if ray_dx < 0:
+        step_x = -1
+        side_dist_x = (px - map_x) * delta_dist_x
+    else:
+        step_x = 1
+        side_dist_x = (map_x + 1.0 - px) * delta_dist_x
+
+    if ray_dy < 0:
+        step_y = -1
+        side_dist_y = (py - map_y) * delta_dist_y
+    else:
+        step_y = 1
+        side_dist_y = (map_y + 1.0 - py) * delta_dist_y
+
+    hit = False
+    side = 0
+    for _ in range(max_depth * 8):
+        if side_dist_x < side_dist_y:
+            side_dist_x += delta_dist_x
+            map_x += step_x
+            side = 0
+        else:
+            side_dist_y += delta_dist_y
+            map_y += step_y
+            side = 1
+
+        if map_x < 0 or map_x >= GRID_W or map_y < 0 or map_y >= GRID_H:
+            break
+        if grid[map_y, map_x] == 1:
+            hit = True
+            break
+
+    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
+    else:
+        denom = ray_dy if abs(ray_dy) > 1e-9 else 1e-9
+        perp = (map_y - py + (1 - step_y) / 2) / denom
+
+    perp = abs(perp)
+    perp = clamp(perp, 0.0005, max_depth)
+    return perp, side, map_x, map_y
+
+def render_first_person(st):
+    grid = st["grid"]
+    (cx, cy) = st["pred"]
+    ori = st["ori"]
+
+    px = cx + 0.5
+    py = cy + 0.5
+
+    fov = math.radians(FOV_DEG)
+    base = math.radians(ORI_DEG[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):
+        u = (x / (RAY_W - 1)) if RAY_W > 1 else 0.5
+        ang = base + (u - 0.5) * fov
+        ray_dx = math.cos(ang)
+        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)
+    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_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
+    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))
+
+    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
+    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):
+            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
+
+    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)
+
+    # heading marker
+    ori = st["ori"]
+    dx, dy = DIRS[ori]
+    hx = px + dx
+    hy = 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)
+
+    return img
+
+def status(st):
+    ori_txt = ["E", "S", "W", "N"][st["ori"]]
+    tail = st["log"][-10:]
+    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"
+        + "\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)
+    else:
+        st["log"].append("Bumped wall.")
+
+def turn_left(st):
+    if st["caught"]:
+        return
+    st["ori"] = (st["ori"] - 1) % 4
+
+def turn_right(st):
+    if st["caught"]:
+        return
+    st["ori"] = (st["ori"] + 1) % 4
+
+def prey_step(st):
+    if st["caught"]:
+        return
+    rng = seeded_rng(st["seed"] + 1337 + st["step"] * 19)
+    px, py = st["prey"]
+    ax, ay = st["pred"]
+
+    options = [(0,0),(1,0),(-1,0),(0,1),(0,-1)]
+    scored = []
+    for dx, dy in options:
+        nx, ny = px + dx, py + dy
+        if st["grid"][ny, nx] == 1:
+            continue
+        dist = (nx-ax)**2 + (ny-ay)**2
+        scored.append((dist + rng.random()*0.1, (nx, ny)))
+
+    if scored:
+        scored.sort(reverse=True)
+        st["prey"] = scored[0][1] if rng.random() < 0.78 else rng.choice(scored)[1]
+
+def check_catch(st):
+    if st["pred"] == st["prey"]:
+        st["caught"] = True
+        st["log"].append("CAUGHT the prey.")
+
+def auto_chase_policy(st):
+    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
+        ang = math.atan2(vy, vx)
+        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.")
+            elif rel > 0.10:
+                turn_right(st); st["log"].append("AutoChase: turn right.")
+            else:
+                move_forward(st); 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.")
+
+def tick(st):
+    if st["caught"]:
+        return
+    st["step"] += 1
+
+    if st["auto_chase"]:
+        auto_chase_policy(st)
+
+    prey_step(st)
+    check_catch(st)
+
+    if st["step"] >= 600:
+        st["caught"] = True
+        st["log"].append("Max steps reached (freeze).")
+
+# -----------------------------
+# Gradio actions
+# -----------------------------
+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.")
+    tick(st)
+    return st, render_first_person(st), render_minimap(st), status(st)
+
+def ui_right(st):
+    turn_right(st); st["log"].append("Turn right.")
+    tick(st)
+    return st, render_first_person(st), render_minimap(st), status(st)
+
+def ui_forward(st):
+    move_forward(st); st["log"].append("Forward.")
+    check_catch(st)
+    tick(st)
+    return st, render_first_person(st), render_minimap(st), status(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)
+
+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)
+
+def ui_tick(st):
+    tick(st)
+    return st, render_first_person(st), render_minimap(st), status(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)
+
+# -----------------------------
+# App
+# -----------------------------
+with gr.Blocks(title="RFT Predator Space — First Person Observer") 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)."
+    )
+
+    st = gr.State(make_world(1))
+
+    with gr.Row():
+        seed = gr.Number(label="Seed", value=1, precision=0)
+        btn_reset = gr.Button("Reset")
+        btn_chase = gr.Button("Toggle AutoChase")
+        btn_run = gr.Button("Toggle AutoRun")
+        btn_tick = gr.Button("Tick")
+
+    with gr.Row():
+        btn_left = gr.Button("Turn Left")
+        btn_fwd = gr.Button("Forward")
+        btn_right = gr.Button("Turn Right")
+
+    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)
+
+    demo.load(lambda: (st.value, render_first_person(st.value), render_minimap(st.value), status(st.value)),
+              outputs=[st, view, mini, info])
+
+    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])
+
+    # 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])
+
+demo.launch()