1 files changed, 204 insertions, 0 deletions

diff --git a/src/game.rs b/src/game.rs
new file mode 100644
index 0000000..4bedecc
--- /dev/null
+++ b/src/game.rs
@@ -0,0 +1,204 @@
+use rand::Rng;
+
+// --------------- maze grid ---------------
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Cell {
+    Wall,
+    Passage,
+    Exit,
+}
+
+pub struct Maze {
+    cells: Vec<Cell>,
+    width: usize,
+    height: usize,
+}
+
+impl Maze {
+    /// Recursive-backtracker perfect maze.  `room_w × room_h` is the logical
+    /// room count; the actual grid will be `(room_w*2+1) × (room_h*2+1)`.
+    pub fn generate(room_w: usize, room_h: usize, rng: &mut impl Rng) -> Self {
+        let w = room_w * 2 + 1;
+        let h = room_h * 2 + 1;
+
+        let mut cells = vec![Cell::Wall; w * h];
+        cells[1 * w + 1] = Cell::Passage;
+
+        let mut stack = vec![(1usize, 1usize)];
+
+        while let Some(&(cy, cx)) = stack.last() {
+            let mut unvisited = Vec::new();
+
+            for (dy, dx) in [(-2isize, 0isize), (2, 0), (0, -2), (0, 2)] {
+                let ny = cy as isize + dy;
+                let nx = cx as isize + dx;
+                if ny >= 1 && ny < (h - 1) as isize && nx >= 1 && nx < (w - 1) as isize {
+                    if cells[ny as usize * w + nx as usize] == Cell::Wall {
+                        unvisited.push((ny as usize, nx as usize));
+                    }
+                }
+            }
+
+            if unvisited.is_empty() {
+                stack.pop();
+            } else {
+                let idx = rng.gen_range(0..unvisited.len());
+                let (ny, nx) = unvisited[idx];
+
+                // carve the wall between current cell and chosen neighbour
+                let wall_y = (cy + ny) / 2;
+                let wall_x = (cx + nx) / 2;
+                cells[wall_y * w + wall_x] = Cell::Passage;
+                cells[ny * w + nx] = Cell::Passage;
+
+                stack.push((ny, nx));
+            }
+        }
+
+        // ---- place exit in a far-away passage ----
+        let mut passages: Vec<(f64, usize, usize)> = Vec::new();
+        for y in (1..h).step_by(2) {
+            for x in (1..w).step_by(2) {
+                if cells[y * w + x] == Cell::Passage && !(y == 1 && x == 1) {
+                    let dist = ((y as f64 - 1.0).powi(2) + (x as f64 - 1.0).powi(2)).sqrt();
+                    passages.push((dist, y, x));
+                }
+            }
+        }
+
+        if !passages.is_empty() {
+            passages.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
+            let far_count = (passages.len() / 4).max(1);
+            let idx = rng.gen_range(0..far_count);
+            let (_, ey, ex) = passages[idx];
+            cells[ey * w + ex] = Cell::Exit;
+        }
+
+        Self {
+            cells,
+            width: w,
+            height: h,
+        }
+    }
+
+    #[inline]
+    pub fn is_wall(&self, y: usize, x: usize) -> bool {
+        self.cells
+            .get(y * self.width + x)
+            .map_or(true, |&c| c == Cell::Wall)
+    }
+
+    /// Floating-point query — out-of-bounds is treated as wall.
+    #[inline]
+    pub fn is_passage_at_float(&self, x: f64, y: f64) -> bool {
+        let xi = x as usize;
+        let yi = y as usize;
+        if xi >= self.width || yi >= self.height {
+            return false;
+        }
+        self.cells[yi * self.width + xi] != Cell::Wall
+    }
+
+    #[inline]
+    pub fn is_exit(&self, x: f64, y: f64) -> bool {
+        let xi = x as usize;
+        let yi = y as usize;
+        if xi >= self.width || yi >= self.height {
+            return false;
+        }
+        self.cells[yi * self.width + xi] == Cell::Exit
+    }
+
+    pub fn width(&self) -> usize {
+        self.width
+    }
+    pub fn height(&self) -> usize {
+        self.height
+    }
+}
+
+// --------------- player ---------------
+
+pub struct Player {
+    pub x: f64,
+    pub y: f64,
+    pub angle: f64, // radians, 0 = +x (east), π/2 = +y (south)
+}
+
+impl Player {
+    pub fn new(x: f64, y: f64, angle: f64) -> Self {
+        Self { x, y, angle }
+    }
+
+    pub fn rotate(&mut self, delta: f64) {
+        self.angle = (self.angle + delta).rem_euclid(2.0 * std::f64::consts::PI);
+    }
+
+    /// Apply a raw (dx, dy) displacement with wall-sliding collision.
+    /// Checks are done per-axis so the player slides along walls naturally.
+    pub fn try_move(&mut self, dx: f64, dy: f64, maze: &Maze) {
+        let m = 0.35; // collision margin — keeps the camera out of walls
+
+        let nx = self.x + dx;
+        if maze.is_passage_at_float(nx + m, self.y + m)
+            && maze.is_passage_at_float(nx + m, self.y - m)
+            && maze.is_passage_at_float(nx - m, self.y + m)
+            && maze.is_passage_at_float(nx - m, self.y - m)
+        {
+            self.x = nx;
+        }
+
+        let ny = self.y + dy;
+        if maze.is_passage_at_float(self.x + m, ny + m)
+            && maze.is_passage_at_float(self.x - m, ny + m)
+            && maze.is_passage_at_float(self.x + m, ny - m)
+            && maze.is_passage_at_float(self.x - m, ny - m)
+        {
+            self.y = ny;
+        }
+    }
+}
+
+// --------------- top-level game ---------------
+
+pub struct Game {
+    pub maze: Maze,
+    pub player: Player,
+    pub wall_texture: Vec<u32>,
+    pub floor_texture: Vec<u32>,
+}
+
+impl Game {
+    pub fn new() -> Self {
+        let mut rng = rand::thread_rng();
+        let maze = Maze::generate(16, 16, &mut rng); // 33×33 grid
+        let player = Player::new(1.5, 1.5, 0.0); // start centre of (1,1), facing east
+        let wall_texture = crate::texture::generate_wall_texture(&mut rng);
+        let floor_texture = crate::texture::generate_floor_texture(&mut rng);
+
+        Self {
+            maze,
+            player,
+            wall_texture,
+            floor_texture,
+        }
+    }
+
+    pub fn rotate(&mut self, delta: f64) {
+        self.player.rotate(delta);
+    }
+
+    /// Apply forward + strafe as a single combined displacement so that
+    /// diagonal wall-hugging is checked atomically (no two-step clip).
+    pub fn apply_movement(&mut self, forward: f64, strafe: f64) {
+        let a = self.player.angle;
+        let dx = a.cos() * forward + (a + std::f64::consts::FRAC_PI_2).cos() * strafe;
+        let dy = a.sin() * forward + (a + std::f64::consts::FRAC_PI_2).sin() * strafe;
+        self.player.try_move(dx, dy, &self.maze);
+    }
+
+    pub fn check_win(&self) -> bool {
+        self.maze.is_exit(self.player.x, self.player.y)
+    }
+}