ci: add dependabot config

.github/dependabot.yml

@@ -0,0 +1,20 @@
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    groups:
+      dependencies:
+        patterns:
+          - "*"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    groups:
+      dependencies:
+        patterns:
+          - "*"

src/game.rs

@@ -1,7 +1,7 @@
 //! This module contains the main game logic and state.
 
 use anyhow::Result;
-use glam::UVec2;
+use glam::{UVec2, Vec2};
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use sdl2::{
     image::LoadTexture,
@@ -14,7 +14,7 @@ use sdl2::{
 use crate::{
     asset::{get_asset_bytes, Asset},
     audio::Audio,
-    constants::RAW_BOARD,
+    constants::{CELL_SIZE, RAW_BOARD},
     entity::{
         ghost::{Ghost, GhostType},
         pacman::Pacman,
@@ -188,7 +188,7 @@ impl Game {
     fn render_pathfinding_debug<T: RenderTarget>(&self, canvas: &mut Canvas<T>) -> Result<()> {
         let pacman_node = self.pacman.current_node_id();
 
-        for (i, ghost) in self.ghosts.iter().enumerate() {
+        for ghost in self.ghosts.iter() {
             if let Some(path) = ghost.calculate_path_to_target(&self.map.graph, pacman_node) {
                 if path.len() < 2 {
                     continue; // Skip if path is too short
@@ -198,34 +198,41 @@ impl Game {
                 canvas.set_draw_color(ghost.debug_color());
 
                 // Calculate offset based on ghost index to prevent overlapping lines
-                let offset = (i as f32) * 2.0 - 3.0; // Offset range: -3.0 to 3.0
+                // let offset = (i as f32) * 2.0 - 3.0; // Offset range: -3.0 to 3.0
 
                 // Calculate a consistent offset direction for the entire path
-                let first_node = self.map.graph.get_node(path[0]).unwrap();
-                let last_node = self.map.graph.get_node(path[path.len() - 1]).unwrap();
-                let first_pos = first_node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-                let last_pos = last_node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
+                // let first_node = self.map.graph.get_node(path[0]).unwrap();
+                // let last_node = self.map.graph.get_node(path[path.len() - 1]).unwrap();
 
                 // Use the overall direction from start to end to determine the perpendicular offset
-                let overall_dir = (last_pos - first_pos).normalize();
-                let perp_dir = glam::Vec2::new(-overall_dir.y, overall_dir.x);
+                let offset = match ghost.ghost_type {
+                    GhostType::Blinky => Vec2::new(0.25, 0.5),
+                    GhostType::Pinky => Vec2::new(-0.25, -0.25),
+                    GhostType::Inky => Vec2::new(0.5, -0.5),
+                    GhostType::Clyde => Vec2::new(-0.5, 0.25),
+                } * 5.0;
 
                 // Calculate offset positions for all nodes using the same perpendicular direction
                 let mut offset_positions = Vec::new();
                 for &node_id in &path {
                     let node = self.map.graph.get_node(node_id).unwrap();
                     let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-                    offset_positions.push(pos + perp_dir * offset);
+                    offset_positions.push(pos + offset);
                 }
 
                 // Draw lines between the offset positions
                 for window in offset_positions.windows(2) {
-                    canvas
-                        .draw_line(
-                            (window[0].x as i32, window[0].y as i32),
-                            (window[1].x as i32, window[1].y as i32),
-                        )
-                        .map_err(anyhow::Error::msg)?;
+                    if let (Some(from), Some(to)) = (window.first(), window.get(1)) {
+                        // Skip if the distance is too far (used for preventing lines between tunnel portals)
+                        if from.distance_squared(*to) > (CELL_SIZE * 16).pow(2) as f32 {
+                            continue;
+                        }
+
+                        // Draw the line
+                        canvas
+                            .draw_line((from.x as i32, from.y as i32), (to.x as i32, to.y as i32))
+                            .map_err(anyhow::Error::msg)?;
+                    }
                 }
             }
         }