feat: wall collisions

src/animation.rs

@@ -0,0 +1,98 @@
+use sdl2::{
+    rect::Rect,
+    render::{Canvas, Texture},
+    video::Window,
+};
+
+use crate::direction::Direction;
+
+pub struct AnimatedTexture<'a> {
+    raw_texture: Texture<'a>,
+    ticker: u32,
+    reversed: bool,
+    offset: (i32, i32),
+    ticks_per_frame: u32,
+    frame_count: u32,
+    frame_width: u32,
+    frame_height: u32,
+}
+
+impl<'a> AnimatedTexture<'a> {
+    pub fn new(
+        texture: Texture<'a>,
+        ticks_per_frame: u32,
+        frame_count: u32,
+        frame_width: u32,
+        frame_height: u32,
+        offset: Option<(i32, i32)>,
+    ) -> Self {
+        AnimatedTexture {
+            raw_texture: texture,
+            ticker: 0,
+            reversed: false,
+            ticks_per_frame,
+            frame_count,
+            frame_width,
+            frame_height,
+            offset: offset.unwrap_or((0, 0)),
+        }
+    }
+
+    fn current_frame(&self) -> u32 {
+        self.ticker / self.ticks_per_frame
+    }
+
+    fn next_frame(&mut self) {
+        if self.reversed {
+            self.ticker -= 1;
+
+            if self.ticker == 0 {
+                self.reversed = !self.reversed;
+            }
+        } else {
+            self.ticker += 1;
+
+            if self.ticker + 1 == self.ticks_per_frame * self.frame_count {
+                self.reversed = !self.reversed;
+            }
+        }
+    }
+
+    fn get_frame_rect(&self) -> Rect {
+        Rect::new(
+            self.current_frame() as i32 * self.frame_width as i32,
+            0,
+            self.frame_width,
+            self.frame_height,
+        )
+    }
+
+    pub fn render(
+        &mut self,
+        canvas: &mut Canvas<Window>,
+        position: (i32, i32),
+        direction: Direction,
+    ) {
+        let frame_rect = self.get_frame_rect();
+        let position_rect = Rect::new(
+            position.0 + self.offset.0,
+            position.1 + self.offset.1,
+            self.frame_width,
+            self.frame_height,
+        );
+
+        canvas
+            .copy_ex(
+                &self.raw_texture,
+                Some(frame_rect),
+                Some(position_rect),
+                direction.angle(),
+                None,
+                false,
+                false,
+            )
+            .expect("Could not render texture on canvas");
+
+        self.next_frame();
+    }
+}

src/direction.rs

@@ -0,0 +1,27 @@
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+impl Direction {
+    pub fn angle(&self) -> f64 {
+        match self {
+            Direction::Right => 0f64,
+            Direction::Down => 90f64,
+            Direction::Left => 180f64,
+            Direction::Up => 270f64,
+        }
+    }
+
+    pub fn offset(&self) -> (i32, i32) {
+        match self {
+            Direction::Right => (1, 0),
+            Direction::Down => (0, 1),
+            Direction::Left => (-1, 0),
+            Direction::Up => (0, -1),
+        }
+    }
+}

src/entity.rs

@@ -0,0 +1,11 @@
+pub trait Entity {
+    // Returns true if the entity is colliding with the other entity
+    fn is_colliding(&self, other: &dyn Entity) -> bool;
+    // Returns the absolute position of the entity
+    fn position(&self) -> (i32, i32);
+    // Returns the cell position of the entity (XY position within the grid)
+    fn cell_position(&self) -> (u32, u32);
+    fn internal_position(&self) -> (u32, u32);
+    // Tick the entity (move it, perform collision checks, etc) 
+    fn tick(&mut self);
+}

src/game.rs

@@ -1,11 +1,120 @@
-pub struct Game {}
+use sdl2::image::LoadTexture;
+use sdl2::keyboard::Keycode;
+use sdl2::render::{Texture, TextureCreator};
+use sdl2::video::WindowContext;
+use sdl2::{pixels::Color, render::Canvas, video::Window};
 
-impl Game {
-    pub fn new() -> Game {
-        Game {}
+use crate::constants::{MapTile, BOARD, BOARD_HEIGHT, BOARD_WIDTH};
+use crate::direction::Direction;
+use crate::entity::Entity;
+use crate::pacman::Pacman;
+
+pub struct Game<'a> {
+    canvas: &'a mut Canvas<Window>,
+    map_texture: Texture<'a>,
+    pacman: Pacman<'a>,
+    debug: bool,
+}
+
+impl Game<'_> {
+    pub fn new<'a>(
+        canvas: &'a mut Canvas<Window>,
+        texture_creator: &'a TextureCreator<WindowContext>,
+    ) -> Game<'a> {
+        let pacman_atlas = texture_creator
+            .load_texture("assets/32/pacman.png")
+            .expect("Could not load pacman texture");
+        let pacman = Pacman::new(Some(Game::cell_to_pixel((1, 4))), pacman_atlas);
+
+        Game {
+            canvas,
+            pacman: pacman,
+            debug: false,
+            map_texture: texture_creator
+                .load_texture("assets/map.png")
+                .expect("Could not load pacman texture"),
+        }
     }
 
-    pub fn tick() {}
+    pub fn cell_to_pixel(cell: (u32, u32)) -> (i32, i32) {
+        ((cell.0 as i32 * 24), ((cell.1) as i32 * 24))
+    }
 
-    pub fn draw() {}
-}
+    pub fn keyboard_event(&mut self, keycode: Keycode) {
+        match keycode {
+            Keycode::D => {
+                self.pacman.next_direction = Some(Direction::Right);
+            }
+            Keycode::A => {
+                self.pacman.next_direction = Some(Direction::Left);
+            }
+            Keycode::W => {
+                self.pacman.next_direction = Some(Direction::Up);
+            }
+            Keycode::S => {
+                self.pacman.next_direction = Some(Direction::Down);
+            }
+            Keycode::Space => {
+                self.debug = !self.debug;
+            }
+            _ => {}
+        }
+    }
+
+    pub fn tick(&mut self) {
+        self.pacman.tick();
+    }
+
+    pub fn draw(&mut self) {
+        // Clear the screen (black)
+        self.canvas.set_draw_color(Color::RGB(0, 0, 0));
+        self.canvas.clear();
+
+        self.canvas
+            .copy(&self.map_texture, None, None)
+            .expect("Could not render texture on canvas");
+
+        // Render the pacman
+        self.pacman.render(self.canvas);
+
+        // Draw a grid
+        if self.debug {
+            for x in 0..BOARD_WIDTH {
+                for y in 0..BOARD_HEIGHT {
+                    let tile = BOARD[x as usize][y as usize];
+                    let mut color = None;
+
+                    if (x, y) == self.pacman.cell_position() {
+                        self.draw_cell((x, y), Color::CYAN);
+                    } else {
+                        color = match tile {
+                            MapTile::Empty => None,
+                            MapTile::Wall => Some(Color::BLUE),
+                            MapTile::Pellet => Some(Color::RED),
+                            MapTile::PowerPellet => Some(Color::MAGENTA),
+                            MapTile::StartingPosition(_) => Some(Color::GREEN),
+                        };
+                    }
+
+                    if let Some(color) = color {
+                        self.draw_cell((x, y), color);
+                    }
+                }
+            }
+        }
+
+        self.canvas.present();
+    }
+
+    fn draw_cell(&mut self, cell: (u32, u32), color: Color) {
+        self.canvas.set_draw_color(color);
+        self.canvas
+            .draw_rect(sdl2::rect::Rect::new(
+                cell.0 as i32 * 24,
+                cell.1 as i32 * 24,
+                24,
+                24,
+            ))
+            .expect("Could not draw rectangle");
+    }
+}

src/helper.rs

@@ -0,0 +1,15 @@
+pub fn is_adjacent(a: (u32, u32), b: (u32, u32), diagonal: bool) -> bool {
+    let (ax, ay) = a;
+    let (bx, by) = b;
+    if diagonal {
+        (ax == bx && (ay == by + 1 || ay == by - 1))
+            || (ay == by && (ax == bx + 1 || ax == bx - 1))
+            || (ax == bx + 1 && ay == by + 1)
+            || (ax == bx + 1 && ay == by - 1)
+            || (ax == bx - 1 && ay == by + 1)
+            || (ax == bx - 1 && ay == by - 1)
+    } else {
+        (ax == bx && (ay == by + 1 || ay == by - 1))
+            || (ay == by && (ax == bx + 1 || ax == bx - 1))
+    }
+}

src/main.rs

@@ -1,30 +1,22 @@
 use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
 use crate::game::Game;
-use crate::textures::TextureManager;
-use sdl2::event::{Event};
+use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
-use sdl2::pixels::Color;
-use sdl2::render::{Canvas, Texture};
 use std::time::{Duration, Instant};
 
 #[cfg(target_os = "emscripten")]
 pub mod emscripten;
 
+mod animation;
 mod constants;
 mod direction;
+mod entity;
 mod game;
 mod pacman;
-mod textures;
-mod entity;
-mod animation;
+mod modulation;
 
-fn redraw(canvas: &mut Canvas<sdl2::video::Window>, tex: &Texture, i: u8) {
-    canvas.set_draw_color(Color::RGB(i, i, i));
-    canvas.clear();
-    canvas
-        .copy(tex, None, None)
-        .expect("Could not render texture on canvas");
-}
+#[cfg(target_os = "emscripten")]
+mod emscripten;
 
 pub fn main() {
     let sdl_context = sdl2::init().unwrap();
@@ -38,6 +30,7 @@ pub fn main() {
 
     let mut canvas = window
         .into_canvas()
+        .accelerated()
         .build()
         .expect("Could not build canvas");
 
@@ -46,7 +39,7 @@ pub fn main() {
         .expect("Could not set logical size");
 
     let texture_creator = canvas.texture_creator();
-    let mut game = Game::new(&mut canvas, TextureManager::new(&texture_creator));
+    let mut game = Game::new(&mut canvas, &texture_creator);
 
     let mut event_pump = sdl_context
         .event_pump()
@@ -55,7 +48,11 @@ pub fn main() {
     game.draw();
     game.tick();
 
+    let loop_time = Duration::from_millis(1000 / 60);
+
     let mut main_loop = || {
+        let start = Instant::now();
+
         for event in event_pump.poll_iter() {
             match event {
                 // Handle quitting keys or window close
@@ -64,34 +61,25 @@ pub fn main() {
                     keycode: Some(Keycode::Escape) | Some(Keycode::Q),
                     ..
                 } => return false,
-                event @ Event::KeyDown { .. } => {
-                    println!("{:?}", event);
+                Event::KeyDown { keycode, .. } => {
+                    game.keyboard_event(keycode.unwrap());
                 }
                 _ => {}
             }
         }
 
-        let tick_time = {
-            let start = Instant::now();
-            game.tick();
-            start.elapsed()
-        };
+        game.tick();
+        game.draw();
 
-        let draw_time = {
-            let start = Instant::now();
-            game.draw();
-            start.elapsed()
-        };
-
-        // Alert if tick time exceeds 10ms
-        if tick_time > Duration::from_millis(3) {
-            println!("Tick took: {:?}", tick_time);
-        }
-        if draw_time > Duration::from_millis(3) {
-            println!("Draw took: {:?}", draw_time);
+        if start.elapsed() < loop_time {
+            ::std::thread::sleep(loop_time - start.elapsed());
+        } else {
+            println!(
+                "Game loop behind schedule by: {:?}",
+                start.elapsed() - loop_time
+            );
         }
 
-        ::std::thread::sleep(Duration::from_millis(10));
         true
     };
 

src/modulation.rs

@@ -0,0 +1,26 @@
+pub struct SpeedModulator {
+    tick_count: u32,
+    ticks_left: u32,
+}
+
+impl SpeedModulator {
+    pub fn new(percent: f32) -> Self {
+        let ticks_required: u32 = (1f32 / (1f32 - percent)).round() as u32;
+
+        SpeedModulator {
+            tick_count: ticks_required,
+            ticks_left: ticks_required,
+        }
+    }
+
+    pub fn next(&mut self) -> bool {
+        self.ticks_left -= 1;
+
+        if self.ticks_left == 0 {
+            self.ticks_left = self.tick_count;
+            false
+        } else {
+            true
+        }
+    }
+}

src/pacman.rs

@@ -0,0 +1,100 @@
+use sdl2::{
+    render::{Canvas, Texture},
+    video::Window,
+};
+
+use crate::{
+    constants::{BOARD, MapTile},
+    animation::AnimatedTexture, constants::CELL_SIZE, direction::Direction, entity::Entity,
+    modulation::SpeedModulator,
+};
+
+pub struct Pacman<'a> {
+    // Absolute position on the board (precise)
+    pub position: (i32, i32),
+    pub direction: Direction,
+    pub next_direction: Option<Direction>,
+    pub stopped: bool,
+    speed: u32,
+    modulation: SpeedModulator,
+    sprite: AnimatedTexture<'a>,
+}
+
+impl Pacman<'_> {
+    pub fn new<'a>(starting_position: Option<(i32, i32)>, atlas: Texture<'a>) -> Pacman<'a> {
+        Pacman {
+            position: starting_position.unwrap_or((0i32, 0i32)),
+            direction: Direction::Right,
+            next_direction: None,
+            speed: 2,
+            stopped: false,
+            modulation: SpeedModulator::new(0.9333),
+            sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32, Some((-4, -4))),
+        }
+    }
+
+    pub fn render(&mut self, canvas: &mut Canvas<Window>) {
+        self.sprite.render(canvas, self.position, self.direction);
+    }
+
+    fn next_cell(&self) -> (i32, i32) {
+        let (x, y) = self.direction.offset();
+        let cell = self.cell_position();
+        (cell.0 as i32 + x, cell.1 as i32 + y)
+    }
+}
+
+impl Entity for Pacman<'_> {
+    fn is_colliding(&self, other: &dyn Entity) -> bool {
+        let (x, y) = self.position();
+        let (other_x, other_y) = other.position();
+        x == other_x && y == other_y
+    }
+
+    fn position(&self) -> (i32, i32) {
+        self.position
+    }
+
+    fn cell_position(&self) -> (u32, u32) {
+        let (x, y) = self.position();
+        (x as u32 / CELL_SIZE, y as u32 / CELL_SIZE)
+    }
+
+    fn internal_position(&self) -> (u32, u32) {
+        let (x, y) = self.position();
+        (x as u32 % CELL_SIZE, y as u32 % CELL_SIZE)
+    }
+
+    fn tick(&mut self) {
+        let can_change = self.internal_position() == (0, 0);
+        if can_change {
+            if let Some(direction) = self.next_direction {
+                self.direction = direction;
+                self.next_direction = None;
+            }
+        }
+
+        if !self.stopped && self.modulation.next() {
+            let speed = self.speed as i32;
+            match self.direction {
+                Direction::Right => {
+                    self.position.0 += speed;
+                }
+                Direction::Left => {
+                    self.position.0 -= speed;
+                }
+                Direction::Up => {
+                    self.position.1 -= speed;
+                }
+                Direction::Down => {
+                    self.position.1 += speed;
+                }
+            }
+        }
+
+        let next = self.next_cell();
+        if BOARD[next.1 as usize][next.0 as usize] == MapTile::Wall {
+            self.stopped = true;
+        }
+    }
+}