cleanup

Author: Trolldemorted

navpointmatrixcli/Cargo.toml

@@ -9,3 +9,6 @@ clap = { workspace = true }
 log = { workspace = true }
 pathfinding = { workspace = true }
 geo = "0.29.3"
+
+[dev-dependencies]
+regex = "1.11.1"

navpointmatrixcli/src/cli.rs

@@ -1,7 +1,6 @@
+use clap::{Args, Parser, Subcommand, ValueEnum};
 use std::path::PathBuf;
 
-use clap::{Args, Parser, Subcommand};
-
 /// Patrician 3 navpoint matrix calculation
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -54,7 +53,17 @@ pub struct ConnectedNodesFromNavigationDataArgs {
     #[arg(long = "navigation-vector", value_name = "navigation-vector-file")]
     pub navigation_vector_file: PathBuf,
 
+    /// F
+    #[arg(long = "calculation-mode", value_name = "calculation-mode")]
+    pub mode: ConnectedNodesMode,
+
     /// Path to the output connected nodes file
     #[arg(long = "output", value_name = "output-file")]
     pub output_file: PathBuf,
 }
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum ConnectedNodesMode {
+    BresenhamLine,
+    //P3,
+}

navpointmatrixcli/src/connected_nodes.rs

@@ -1,5 +1,8 @@
 use p3_api::data::{navigation_matrix::NavigationMatrix, navigation_vector::NavigationVector, navpoint_matrix::NavpointMatrix};
 
+use crate::cli::ConnectedNodesMode;
+
+#[derive(Debug, Clone)]
 pub struct ConnectedNodes {
     pub connected_nodes: Vec<(u16, u16)>,
 }
@@ -37,12 +40,12 @@ impl ConnectedNodes {
         neighbours
     }
 
-    pub fn from_navigation_matrix(navigation_vector: &NavigationVector, navigation_matrix: &NavigationMatrix) -> Self {
+    pub fn from_navigation_matrix_p3(navigation_vector: &NavigationVector, navigation_matrix: &NavigationMatrix, mode: ConnectedNodesMode) -> Self {
         let mut nodes = vec![];
         for (source_index, source) in navigation_vector.points.iter().enumerate() {
             println!("Calculating neighbours for node {source_index}");
             for (destination_index, destination) in navigation_vector.points.iter().enumerate() {
-                if is_connected(*source, *destination, navigation_matrix) {
+                if is_connected(*source, *destination, navigation_matrix, mode) {
                     nodes.push((source_index as _, destination_index as _))
                 }
             }
@@ -66,23 +69,32 @@ impl ConnectedNodes {
     }
 }
 
-fn is_connected(p0: (i16, i16), p1: (i16, i16), navigation_matrix: &NavigationMatrix) -> bool {
+fn is_connected(p0: (i16, i16), p1: (i16, i16), navigation_matrix: &NavigationMatrix, mode: ConnectedNodesMode) -> bool {
     if p0 == p1 {
         return true;
     }
 
-    // Bresenham's Line Algorithm
-    let (mut x0, mut y0) = p0;
-    let (x1, y1) = p1;
+    let line = match mode {
+        ConnectedNodesMode::BresenhamLine => get_bresenham_line(p0.0, p0.1, p1.0, p0.1),
+        //ConnectedNodesMode::P3 => get_p3_line(p0.0, p0.1, p1.0, p0.1),
+    };
+    for point in line {
+        if navigation_matrix.data[point.0 as usize + navigation_matrix.width as usize * point.1 as usize] == 1 {
+            return false;
+        }
+    }
+    true
+}
+
+pub fn get_bresenham_line(mut x0: i16, mut y0: i16, x1: i16, y1: i16) -> Vec<(i16, i16)> {
+    let mut path = Vec::with_capacity(42);
     let dx = (x1 - x0).abs();
     let sx = if x0 < x1 { 1 } else { -1 };
-    let dy = -(y1 - y0).abs();
+    let dy = -((y1 - y0).abs());
     let sy = if y0 < y1 { 1 } else { -1 };
     let mut error = dx + dy;
     loop {
-        if navigation_matrix.data[x0 as usize + navigation_matrix.width as usize * y0 as usize] == 1 {
-            return false;
-        }
+        path.push((x0, y0));
         let e2 = 2 * error;
         if e2 >= dy {
             if x0 == x1 {
@@ -99,6 +111,83 @@ fn is_connected(p0: (i16, i16), p1: (i16, i16), navigation_matrix: &NavigationMa
             y0 += sy;
         }
     }
+    path
+}
+
+pub fn get_p3_line(mut x0: i16, mut y0: i16, x1: i16, y1: i16) -> Vec<(i16, i16)> {
+    let mut path = Vec::with_capacity(42);
+    path.push((x0, y0));
+    let dx_abs = (x1 - x0).abs();
+    let dy_abs = (y1 - y0).abs();
+    let sx = if x0 < x1 { 1 } else { -1 };
+    let sy = if y0 < y1 { 1 } else { -1 };
+
+    let mut diff = dx_abs;
+    let steps = dx_abs;
+    for _ in 0..steps {
+        // 0x0044477A
+        x0 += sx; // Apply x step
+        diff += 2 * dy_abs; // Add 2*dy to diff
+        if diff >= 2 * dx_abs {
+            // 0x00444784
+            diff -= 2 * dx_abs;
+            if diff == 0 {
+                path.push((x0, y0));
+                y0 += sy;
+            } else {
+                y0 += sy;
+                path.push((x0, y0));
+            }
+        } else {
+            // 0x00444793
+            path.push((x0, y0));
+        }
+    }
+
+    path
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{
+        fs,
+        path::{Path, PathBuf},
+    };
+
+    use regex::Regex;
 
-    navigation_matrix.data[x0 as usize + navigation_matrix.width as usize * y0 as usize] == 0
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        test_file(&PathBuf::from("tests/lines/line1.txt"));
+        test_file(&PathBuf::from("tests/lines/line2.txt"));
+        test_file(&PathBuf::from("tests/lines/line3.txt"));
+    }
+
+    fn test_file(path: &Path) {
+        let data = fs::read_to_string(path).unwrap();
+        let mut lines: Vec<&str> = data.split("\n").collect();
+        let header = lines.remove(0);
+        let header_re = Regex::new(r"^\((\d+)\, (\d+)\) -> \((\d+)\, (\d+)\)").unwrap();
+        let line_re = Regex::new(r"^\((\d+)\, (\d+)\)").unwrap();
+        let header_captures = header_re.captures(header).unwrap();
+        let x0: i16 = header_captures.get(1).unwrap().as_str().parse().unwrap();
+        let y0: i16 = header_captures.get(2).unwrap().as_str().parse().unwrap();
+        let x1: i16 = header_captures.get(3).unwrap().as_str().parse().unwrap();
+        let y1: i16 = header_captures.get(4).unwrap().as_str().parse().unwrap();
+
+        let mut calculated_line = get_p3_line(x1, y1, x0, y0);
+        calculated_line.remove(0);
+        calculated_line.pop();
+        println!("{calculated_line:?}");
+        for (i, line) in lines.iter().enumerate() {
+            let line_captures = line_re.captures(line).unwrap();
+            let x: i16 = line_captures.get(1).unwrap().as_str().parse().unwrap();
+            let y: i16 = line_captures.get(2).unwrap().as_str().parse().unwrap();
+            println!("({}, {})", calculated_line[i].0, calculated_line[i].1);
+            assert_eq!(x, calculated_line[i].0);
+            assert_eq!(y, calculated_line[i].1);
+        }
+    }
 }

navpointmatrixcli/src/main.rs

@@ -10,7 +10,6 @@ use std::{
 
 pub(crate) mod cli;
 pub(crate) mod connected_nodes;
-pub(crate) mod ordered_f32;
 
 fn main() {
     let cli = Cli::parse();
@@ -53,7 +52,7 @@ fn build_connected_nodes_from_navpoint_matrix(args: ConnectedNodesFromNavpointMa
 fn build_connected_nodes_from_navigation_data(args: ConnectedNodesFromNavigationDataArgs) {
     let navigation_matrix = NavigationMatrix::deserialize(&fs::read(args.navigation_matrix_file).unwrap());
     let navigation_vector = NavigationVector::deserialize(&fs::read(args.navigation_vector_file).unwrap());
-    let connected_nodes = ConnectedNodes::from_navigation_matrix(&navigation_vector, &navigation_matrix);
+    let connected_nodes = ConnectedNodes::from_navigation_matrix_p3(&navigation_vector, &navigation_matrix, args.mode);
     fs::write(args.output_file, connected_nodes.serialize()).unwrap();
 }