Darkscott/movement (#13)

* Minor changes to get things to work on Windows.

* Switch to Chebyshev distance model instead of Manhatten distance for computing pathing cost. Switch to constant interpolation instead of linear interpolation for moving between tiles. Set walking speed to 3 tiles per second, which felt OK, but might need to be changed later.

* Make keyboard walking feel natural and work with the updated walking system.

* Make mouse movement work with the keyboard movement by bypassing the grace period for the keypresses. Mouse clicks are instantaneous.

Author: darkscott

dyrah_client/src/game.rs

@@ -47,12 +47,17 @@ pub struct Game {
     auth_password: String,
     auth_error: Option<String>,
     hovered_tile: Option<IVec2>,
+    // time since each direction key was last held (rises when released)
+    dir_age: [f32; 4], // left, up, right, down
+    // when starting from a stop, wait this long before sending to allow diagonal input
+    move_start_grace: f32,
+    was_moving: bool,
 }
 
 impl Game {
     pub fn new() -> Self {
         Self {
-            client: Client::new(Transport::new("0.0.0.0:8080"), "0.0.0.0:0"),
+            client: Client::new(Transport::new("127.0.0.1:8080"), "0.0.0.0:0"),
             world: World::default(),
             map: Map::new("assets/map.json"),
             lobby: HashMap::new(),
@@ -67,6 +72,9 @@ impl Game {
             auth_password: String::new(),
             auth_error: None,
             hovered_tile: None,
+            dir_age: [f32::MAX; 4],
+            move_start_grace: 0.0,
+            was_moving: false,
         }
     }
 
@@ -179,27 +187,35 @@ impl Game {
         }
 
         let egui_focused = egui_ctx.wants_keyboard_input();
-        let left = if egui_focused {
-            false
+        let raw_dirs = if egui_focused {
+            [false; 4]
         } else {
-            input.keys_held(&[KeyCode::KeyA, KeyCode::ArrowLeft])
-        };
-        let up = if egui_focused {
-            false
-        } else {
-            input.keys_held(&[KeyCode::KeyW, KeyCode::ArrowUp])
-        };
-        let right = if egui_focused {
-            false
-        } else {
-            input.keys_held(&[KeyCode::KeyD, KeyCode::ArrowRight])
-        };
-        let down = if egui_focused {
-            false
-        } else {
-            input.keys_held(&[KeyCode::KeyS, KeyCode::ArrowDown])
+            [
+                input.keys_held(&[KeyCode::KeyA, KeyCode::ArrowLeft]),
+                input.keys_held(&[KeyCode::KeyW, KeyCode::ArrowUp]),
+                input.keys_held(&[KeyCode::KeyD, KeyCode::ArrowRight]),
+                input.keys_held(&[KeyCode::KeyS, KeyCode::ArrowDown]),
+            ]
         };
 
+        // ~3 frames at 60fps
+        let diagonal_buffer = 3.0 / 60.0;
+        for i in 0..4 {
+            if raw_dirs[i] {
+                self.dir_age[i] = 0.0;
+            } else {
+                self.dir_age[i] += timer.delta;
+            }
+        }
+
+        let buffered = [
+            self.dir_age[0] < diagonal_buffer,
+            self.dir_age[1] < diagonal_buffer,
+            self.dir_age[2] < diagonal_buffer,
+            self.dir_age[3] < diagonal_buffer,
+        ];
+        let [left, up, right, down] = buffered;
+
         let mouse_world_pos = gfx.camera().screen_to_world(input.mouse_position().into());
         let mouse_tile_pos = input
             .mouse_released(MouseButton::Left)
@@ -213,25 +229,32 @@ impl Game {
             *age < 10.0
         });
 
+        // 3 tiles/sec × 32 px/tile = 96 px/sec
+        let move_speed = 3.0 * dyrah_shared::TILE_SIZE;
+        let dt = timer.delta;
+
         self.world.query(
             |_,
              _: &Player,
              pos: &mut WorldPos,
              target_pos: &mut TargetWorldPos,
              spr: &mut Sprite| {
                 if pos.vec != target_pos.vec {
-                    pos.vec = pos.vec.lerp(target_pos.vec, 0.1);
+                    let diff = target_pos.vec - pos.vec;
+                    let dist = diff.length();
+                    let step = move_speed * dt;
 
-                    let delta = target_pos.vec - pos.vec;
-                    if delta.x != 0.0 {
-                        spr.anim.flip_x(delta.x < 0.0);
+                    if step >= dist {
+                        pos.vec = target_pos.vec;
+                    } else {
+                        pos.vec += diff * (step / dist);
                     }
 
-                    spr.anim.update(timer.delta);
-
-                    if pos.vec.distance(target_pos.vec) < 1.0 {
-                        pos.vec = target_pos.vec;
+                    if diff.x != 0.0 {
+                        spr.anim.flip_x(diff.x < 0.0);
                     }
+
+                    spr.anim.update(dt);
                 } else {
                     spr.anim.set_frame(0);
                     target_pos.path = None;
@@ -240,20 +263,51 @@ impl Game {
         );
 
         self.last_input_time += timer.delta;
-        if self.last_input_time >= 0.3 && moving {
+
+        // mouse clicks send immediately — no grace delay or rate limiting
+        if mouse_tile_pos.is_some() {
             self.last_input_time = 0.0;
 
             let msg = ClientMessage::PlayerUpdate {
                 input: ClientInput {
-                    left,
-                    up,
-                    right,
-                    down,
+                    left: false,
+                    up: false,
+                    right: false,
+                    down: false,
                     mouse_tile_pos,
                 },
             };
             self.client
                 .send(&serialize(&msg).unwrap(), Reliability::Unreliable);
+        } else {
+            let keyboard_moving = left || up || right || down;
+
+            // when keyboard movement starts from a stop, wait the buffer window
+            // so the player can add a second key for diagonal
+            if keyboard_moving && !self.was_moving {
+                self.move_start_grace = diagonal_buffer;
+            }
+            self.was_moving = keyboard_moving;
+
+            if self.move_start_grace > 0.0 {
+                self.move_start_grace -= timer.delta;
+            }
+
+            if self.last_input_time >= 0.3 && keyboard_moving && self.move_start_grace <= 0.0 {
+                self.last_input_time = 0.0;
+
+                let msg = ClientMessage::PlayerUpdate {
+                    input: ClientInput {
+                        left,
+                        up,
+                        right,
+                        down,
+                        mouse_tile_pos: None,
+                    },
+                };
+                self.client
+                    .send(&serialize(&msg).unwrap(), Reliability::Unreliable);
+            }
         }
     }
 

dyrah_client/src/map.rs

@@ -24,8 +24,9 @@ impl Map {
 
     pub fn load(&mut self, gfx: &mut Graphics) {
         for tileset in &self.tiled.tilesets {
-            if let Some(path) = &tileset.image {
-                let bytes = std::fs::read(format!("assets/{}", path)).unwrap();
+            if let Some(image_path) = &tileset.image {
+                let filename = std::path::Path::new(image_path).file_name().unwrap();
+                let bytes = std::fs::read(std::path::Path::new("assets").join(filename)).unwrap();
                 let img = image::load_from_memory(&bytes).unwrap().to_rgba8();
                 let (w, h) = img.dimensions();
                 let tex = gfx.load_texture(&bytes);
@@ -38,7 +39,7 @@ impl Map {
                     },
                 );
 
-                println!("Loaded tileset: {} ({}x{})", path, w, h);
+                println!("Loaded tileset: {} ({}x{})", image_path, w, h);
             }
         }
     }

dyrah_server/src/game.rs

@@ -162,7 +162,22 @@ impl Game {
                                 let dir = input.to_direction();
                                 if dir != IVec2::ZERO {
                                     let next_pos = tile_pos.vec + dir;
-                                    if self.map.is_walkable(next_pos, &self.collision_grid) {
+                                    let walkable = if dir.x != 0 && dir.y != 0 {
+                                        // diagonal: destination + both adjacent cardinals must be clear
+                                        self.map.is_walkable(next_pos, &self.collision_grid)
+                                            && self.map.is_walkable(
+                                                tile_pos.vec + IVec2::new(dir.x, 0),
+                                                &self.collision_grid,
+                                            )
+                                            && self.map.is_walkable(
+                                                tile_pos.vec + IVec2::new(0, dir.y),
+                                                &self.collision_grid,
+                                            )
+                                    } else {
+                                        self.map.is_walkable(next_pos, &self.collision_grid)
+                                    };
+
+                                    if walkable {
                                         target_pos.vec = next_pos;
                                         target_pos.path = None;
                                         tile_pos.vec = next_pos;

dyrah_server/src/map.rs

@@ -71,21 +71,36 @@ impl Map {
         grid.is_walkable(tile_pos)
     }
 
-    fn manhattan_distance(&self, a: IVec2, b: IVec2) -> u32 {
-        ((a.x - b.x).abs() + (a.y - b.y).abs()) as u32
+    fn chebyshev_distance(&self, a: IVec2, b: IVec2) -> u32 {
+        let dx = (a.x - b.x).abs() as u32;
+        let dy = (a.y - b.y).abs() as u32;
+        // cardinal cost=2, diagonal cost=3; Chebyshev: max(dx,dy)*2 + min(dx,dy)*(3-2)
+        let (min, max) = if dx < dy { (dx, dy) } else { (dy, dx) };
+        max * 2 + min
     }
 
     fn get_walkable_successors(&self, tile_pos: IVec2, grid: &CollisionGrid) -> Vec<(IVec2, u32)> {
         let mut successors = Vec::new();
-        for (dx, dy) in &[(0, 1), (1, 0), (0, -1), (-1, 0)] {
+        for &(dx, dy, cost) in &[
+            (0, 1, 2), (1, 0, 2), (0, -1, 2), (-1, 0, 2),
+            (1, 1, 3), (1, -1, 3), (-1, 1, 3), (-1, -1, 3),
+        ] {
             let neighbor = IVec2::new(tile_pos.x + dx, tile_pos.y + dy);
             if neighbor.x >= 0
                 && neighbor.y >= 0
                 && neighbor.x < self.tiled.width as i32
                 && neighbor.y < self.tiled.height as i32
                 && grid.is_walkable(neighbor)
             {
-                successors.push((neighbor, 1));
+                // for diagonals, also require both adjacent cardinal tiles to be walkable
+                if dx != 0 && dy != 0 {
+                    let adj_x = IVec2::new(tile_pos.x + dx, tile_pos.y);
+                    let adj_y = IVec2::new(tile_pos.x, tile_pos.y + dy);
+                    if !grid.is_walkable(adj_x) || !grid.is_walkable(adj_y) {
+                        continue;
+                    }
+                }
+                successors.push((neighbor, cost));
             }
         }
         successors
@@ -95,7 +110,7 @@ impl Map {
         let result = astar(
             &start,
             |&pos| self.get_walkable_successors(pos, grid),
-            |&pos| self.manhattan_distance(pos, end),
+            |&pos| self.chebyshev_distance(pos, end),
             |&pos| pos == end,
         );
         result.map(|(path, _)| path.into_iter().skip(1).collect())