Fix warnings, add collision

Author: jmshrv

src/main.rs

@@ -1,14 +1,14 @@
 extern crate sdl2;
 
+use map::MAP;
 use nalgebra::Rotation2;
 use player::{Player, MOVE_SPEED};
-use rayon::prelude::{IntoParallelIterator, ParallelIterator};
 use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
 use sdl2::pixels::Color;
-use sdl2::rect::Point;
 use std::collections::HashSet;
 use std::time::Instant;
+use tile::Tile;
 
 mod map;
 mod player;
@@ -19,7 +19,6 @@ pub fn main() {
     // Create SDL context for video
     let sdl_context = sdl2::init().unwrap();
     let video_subsystem = sdl_context.video().unwrap();
-    let timer_subsystem = sdl_context.timer().unwrap();
 
     // Create a window
     // position_centered - puts the window in the middle of the screen
@@ -85,23 +84,29 @@ pub fn main() {
         // Calculate the movement speed.
         let move_speed = MOVE_SPEED * delta_time as f64;
 
+        let mut new_position = player.position;
+
         // Handle movement with keyboard
         for key in keys {
             match key {
-                Keycode::W => player.position += player.direction * move_speed,
+                Keycode::W => new_position += player.direction * move_speed,
                 Keycode::A => {
-                    player.position.x += player.direction.y * move_speed;
-                    player.position.y -= player.direction.x * move_speed;
+                    new_position.x += player.direction.y * move_speed;
+                    new_position.y -= player.direction.x * move_speed;
                 }
-                Keycode::S => player.position -= player.direction * move_speed,
+                Keycode::S => new_position -= player.direction * move_speed,
                 Keycode::D => {
-                    player.position.x -= player.direction.y * move_speed;
-                    player.position.y += player.direction.x * move_speed;
+                    new_position.x -= player.direction.y * move_speed;
+                    new_position.y += player.direction.x * move_speed;
                 }
                 _ => {}
             }
         }
 
+        if MAP[new_position.x as usize][new_position.y as usize] == Tile::Floor {
+            player.position = new_position;
+        }
+
         // Rotate the player's direction using the mouse's (relative) X
         // position. 0.001 is a random small number.
         let rotation = Rotation2::new(mouse_state.x() as f64 * 0.001);

src/player.rs

@@ -1,7 +1,7 @@
 use nalgebra::Vector2;
 
 /// The move speed of the player, to be compensated with a delta time.
-pub const MOVE_SPEED: f64 = 0.00000001;
+pub const MOVE_SPEED: f64 = 0.000000005;
 
 /// The Player struct stores our player's position, direction, and plane
 pub struct Player {

src/ray_caster.rs

@@ -1,6 +1,7 @@
-use std::cmp::{max, min};
+use std::cmp::max;
 
 use nalgebra::Vector2;
+use sdl2::pixels::Color;
 use sdl2::rect::Point;
 use sdl2::render::Canvas;
 use sdl2::video::Window;
@@ -48,7 +49,7 @@ pub fn draw_ray(player: &Player, x: u32, canvas: &mut Canvas<Window>) {
     let delta_dist = Vector2::new((1.0 / ray_dir.x).abs(), (1.0 / ray_dir.y).abs());
 
     // The distance that the ray has travelled
-    let mut perp_wall_dist = 0.0;
+    let perp_wall_dist;
 
     // Which direction to step in. The DDA will always jump exactly one square.
     let mut step = Vector2::new(0, 0);
@@ -57,7 +58,7 @@ pub fn draw_ray(player: &Player, x: u32, canvas: &mut Canvas<Window>) {
     // but it doesn't really matter what the intial value is.
     let mut hit_side: HitSide;
 
-    let mut hit_tile: Tile;
+    let hit_tile: Tile;
 
     // Here, we calculate our step and initial distance using the ray direction.
 
@@ -129,7 +130,14 @@ pub fn draw_ray(player: &Player, x: u32, canvas: &mut Canvas<Window>) {
     };
 
     if let Tile::Wall(colour) = hit_tile {
-        canvas.set_draw_color(colour);
+        // If the hit side is vertical, half the colour to give some shading
+        match hit_side {
+            HitSide::Horizontal => canvas.set_draw_color(colour),
+            HitSide::Vertical => {
+                canvas.set_draw_color(Color::RGB(colour.r / 2, colour.g / 2, colour.b / 2))
+            }
+        }
+
         let start = Point::new(x as i32, draw_start);
         let end = Point::new(x as i32, draw_end);
         canvas.draw_line(start, end).expect("Failed to draw ray!");