Navigation demo

AStar2D click-to-move character on a grid.

▶ Run in browser

Tags: 2d

Demonstrates: Node2D, on_process(), on_draw(), Input mouse position, pathfinding. Click anywhere to move the character along the shortest path. Run: uv run python examples/features/2d/navigation.py

Source

#!/usr/bin/env python3
"""Navigation demo -- AStar2D click-to-move character on a grid.

Demonstrates: Node2D, on_process(), on_draw(), Input mouse position, pathfinding.
Click anywhere to move the character along the shortest path.
Run: uv run python examples/features/2d/navigation.py
"""

from simvx.core import Input, InputMap, MouseButton, Node2D, Vec2
from simvx.graphics import App

WIDTH, HEIGHT = 800, 600
CELL = 40
COLS, ROWS = WIDTH // CELL, HEIGHT // CELL


class AStar2D:
    """Minimal A* pathfinder on a 2D grid."""

    def __init__(self, cols: int, rows: int):
        self.cols, self.rows = cols, rows
        self.blocked: set[tuple[int, int]] = set()

    def neighbors(self, x: int, y: int):
        for dx, dy in ((-1, 0), (1, 0), (0, -1), (0, 1)):
            nx, ny = x + dx, y + dy
            if 0 <= nx < self.cols and 0 <= ny < self.rows and (nx, ny) not in self.blocked:
                yield nx, ny

    def find_path(self, start: tuple[int, int], end: tuple[int, int]) -> list[tuple[int, int]]:
        if start == end or end in self.blocked:
            return []
        import heapq

        open_set = [(0, start)]
        came_from: dict[tuple[int, int], tuple[int, int]] = {}
        g_score = {start: 0}

        while open_set:
            _, current = heapq.heappop(open_set)
            if current == end:
                path = [current]
                while current in came_from:
                    current = came_from[current]
                    path.append(current)
                path.reverse()
                return path

            for neighbor in self.neighbors(*current):
                new_g = g_score[current] + 1
                if new_g < g_score.get(neighbor, float("inf")):
                    came_from[neighbor] = current
                    g_score[neighbor] = new_g
                    h = abs(neighbor[0] - end[0]) + abs(neighbor[1] - end[1])
                    heapq.heappush(open_set, (new_g + h, neighbor))
        return []


class NavigationDemo(Node2D):
    def on_ready(self):
        InputMap.add_action("click", [MouseButton.LEFT])

        self.astar = AStar2D(COLS, ROWS)
        self.player_cell = (1, 1)
        self.player_pos = Vec2(1 * CELL + CELL / 2, 1 * CELL + CELL / 2)
        self._nav_path: list[tuple[int, int]] = []
        self.move_speed = 200.0
        self.target_pos: Vec2 | None = None

        # Add some walls
        for x in range(5, 15):
            self.astar.blocked.add((x, 5))
        for y in range(2, 10):
            self.astar.blocked.add((8, y))
        for x in range(3, 8):
            self.astar.blocked.add((x, 10))

    def on_process(self, dt: float):
        # Click to set destination
        if Input.is_action_just_pressed("click"):
            mx, my = Input.mouse_position
            cell = (int(mx // CELL), int(my // CELL))
            if 0 <= cell[0] < COLS and 0 <= cell[1] < ROWS:
                start = self.player_cell
                self._nav_path = self.astar.find_path(start, cell)
                if self._nav_path:
                    self._nav_path.pop(0)  # Remove current cell
                    self._next_waypoint()

        # Move toward current waypoint
        if self.target_pos is not None:
            diff = self.target_pos - self.player_pos
            dist = diff.length()
            if dist < 2.0:
                self.player_pos = Vec2(self.target_pos.x, self.target_pos.y)
                self._next_waypoint()
            else:
                direction = diff * (1.0 / dist)
                self.player_pos += direction * self.move_speed * dt

    def _next_waypoint(self):
        if self._nav_path:
            cell = self._nav_path.pop(0)
            self.player_cell = cell
            self.target_pos = Vec2(cell[0] * CELL + CELL / 2, cell[1] * CELL + CELL / 2)
        else:
            self.target_pos = None

    def on_draw(self, renderer):
        # Grid
        for x in range(COLS):
            for y in range(ROWS):
                blocked = (x, y) in self.astar.blocked
                colour = (0.75, 0.22, 0.22) if blocked else (0.12, 0.12, 0.16)
                renderer.draw_rect((x * CELL, y * CELL), (CELL - 1, CELL - 1), colour=colour, filled=True)

        # Path
        for cell in self._nav_path:
            renderer.draw_rect(
                (cell[0] * CELL + 4, cell[1] * CELL + 4),
                (CELL - 9, CELL - 9),
                colour=(0.24, 0.68, 0.28),
                filled=True,
            )

        # Player
        px, py = self.player_pos.x, self.player_pos.y
        renderer.draw_circle((px, py), CELL // 3, colour=(0.24, 0.71, 1.0), filled=True)

        # HUD
        renderer.draw_text("Navigation Demo -- Click to move", (10, 10), colour=(1.0, 1.0, 1.0), scale=2)


if __name__ == "__main__":
    App(title="Navigation Demo", width=WIDTH, height=HEIGHT).run(NavigationDemo())