Adjusted UI && tests; Reworked most utils functions into functional style

Author: an-Iceberg

src/graph.rs

@@ -126,30 +126,36 @@ impl DijkstraGraph
   pub fn get(&self, id: usize) -> Option<DijkstraNode>
   { return self.graph[id]; }
 
-  pub fn get_start(&self) -> Option<usize>
+  pub fn start(&self) -> Option<usize>
   { return self.start; }
 
-  pub fn set_start(&mut self, start: Option<usize>)
-  { self.start = start; }
+  pub fn set_start(&mut self, start: usize)
+  {
+    if start > 100 { return; }
+
+    self.start = Some(start);
+  }
 
   pub fn clear_start(&mut self)
   { self.start = None; }
 
-  pub fn get_end(&self) -> Option<usize>
+  pub fn end(&self) -> Option<usize>
   { return self.end; }
 
-  pub fn set_end(&mut self, end: Option<usize>)
-  { self.end = end; }
+  pub fn set_end(&mut self, end: usize)
+  {
+    if end > 100 { return; }
+
+    self.end = Some(end);
+  }
 
   pub fn clear_end(&mut self)
   { self.end = None; }
 
   /// Returns true if the shortest path has been found
-  pub fn find_shortest_path(&mut self, start: usize, end: usize) -> bool
+  pub fn find_shortest_path(&mut self) -> bool
   {
-    if start > 100 || end > 100 { return false; }
-    self.start = Some(start);
-    self.end = Some(end);
+    if self.start.is_none() || self.end.is_none() { return false; }
 
     todo!();
     // --- DIJKSTRA'S SHORTEST PATH ALGORITHM ---
@@ -180,6 +186,27 @@ impl DijkstraGraph
   pub fn points_iter(&self) -> Iter<Option<DijkstraNode>>
   { return self.graph.iter(); }
 
+  pub fn lines_iter(&self) -> Iter<&(DijkstraNode, u16, DijkstraNode)>
+  {
+    self.graph.iter()
+      .filter_map(|node| *node)
+      .map(|node| (node, node.edges))
+      .map(|(node, edges)| edges.iter()
+        .map(|edge| (edge.distance, edge.destination))
+        .map(|(distance, id)| (distance, self.graph.get(id)))
+        .filter(|(distance, option)| option.is_some())
+        .map(|(distance, option)| (distance, option.unwrap()))
+        .filter(|(distance, option)| option.is_some())
+        .map(|(distance, option)| (distance, option.unwrap()))
+        .map(|(distance, destination)| (node, distance, destination))
+        .collect::<Vec<_>>()
+        .iter()
+      )
+      .flatten()
+      .collect::<Vec<_>>()
+      .iter()
+  }
+
   pub fn get_lines(&self)
   {
     todo!();
@@ -366,7 +393,7 @@ impl DijkstraGraph
 
 struct DijkstraNode
 {
-  position: Position,
+  pub position: Position,
   parent: Option<usize>,
   distance: Option<u16>,
   visited: bool,
@@ -415,24 +442,12 @@ impl DijkstraNode
 // TODO: consider making these fields pub
 struct Position
 {
-  x: f32,
-  y: f32,
+  pub x: f32,
+  pub y: f32,
 }
 
 impl Position
 {
-  pub fn x(&self) -> f32
-  { return self.x; }
-
-  pub fn set_x(&mut self, x: f32)
-  { self.x = x; }
-
-  pub fn y(&self) -> f32
-  { return self.y; }
-
-  pub fn set_y(&mut self, y: f32)
-  { self.y = y; }
-
   pub fn get(&self) -> (f32, f32)
   { return (self.x, self.y); }
 

src/main.rs

@@ -2,7 +2,6 @@ mod graph;
 mod ui;
 mod utils;
 
-use crate::utils::Mode;
 use egui_macroquad::draw;
 use graph::*;
 use macroquad::prelude::*;
@@ -20,12 +19,19 @@ fn window_configuration() -> Conf
   };
 }
 
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub(crate) enum Mode {
+  Move,
+  Point,
+  Line,
+  Path,
+}
+
 // FIX: path from 6 to 18 is wrong, there exist a much shorter one (point 10 seems to cause that somehow)
 #[macroquad::main(window_configuration)]
 async fn main()
 {
   let mut graph = DijkstraGraph::new();
-  let mut path: Option<Vec<u8>> = None;
   // let mut start: Option<usize> = None;
   // let mut end: Option<usize> = None;
   // This is the id of the point that the mouse is currently hovering over
@@ -78,7 +84,22 @@ async fn main()
 
     // --- GUI ---
     // TODO: style the GUI
-    ui::paint_ui(&mut mode, &mut graph, &mut bg_color);
+    ui::paint_ui(
+      &mut mode,
+      &mut graph,
+      &mut radius,
+      &mut angle,
+      &mut arrow_head_length,
+      &mut path_thickness,
+      &mut base_point,
+      &mut padding,
+      &mut selected_point_id,
+      &mut line_length,
+      &mut path_color,
+      &mut line_color,
+      &mut point_color,
+      &mut bg_color
+    );
 
     // ! dbg
     if is_key_pressed(KeyCode::P)

src/tests/graph_tests.rs

@@ -58,7 +58,9 @@ fn shortest_path_small()
   {
     let mut graph = DijkstraGraph::new();
     graph.insert_small_graph();
-    assert!(graph.find_shortest_path(2, 0));
+    graph.set_start(2);
+    graph.set_end(0);
+    assert!(graph.find_shortest_path());
 
     let should_path_1 = vec![2, 3, 4, 0];
     let should_path_2 = vec![2, 5, 7, 0];
@@ -122,7 +124,10 @@ fn shortest_path_small()
 
     let should_path = vec![6, 7, 0, 1, 2, 8];
 
-    assert!(graph.find_shortest_path(6, 8));
+    graph.set_start(6);
+    graph.set_end(8);
+
+    assert!(graph.find_shortest_path());
 
     match graph.get_path()
     {
@@ -150,7 +155,10 @@ fn shortest_path_medium()
     let should_path_2 = vec![3, 10, 7, 4, 0];
     let should_path_3 = vec![3, 11, 8, 4, 0];
 
-    graph.find_shortest_path(3, 0);
+    graph.set_start(3);
+    graph.set_end(0);
+
+    graph.find_shortest_path();
 
     match graph.get_path()
     {
@@ -175,7 +183,10 @@ fn shortest_path_medium()
     let should_path_4 = vec![3, 11, 7, 4, 1];
     let should_path_5 = vec![3, 11, 7, 1];
 
-    graph.find_shortest_path(3, 1);
+    graph.set_start(3);
+    graph.set_end(1);
+
+    graph.find_shortest_path();
 
     match graph.get_path()
     {
@@ -206,7 +217,10 @@ fn shortest_path_medium()
     let should_path_1 = vec![3, 10, 7, 5, 2];
     let should_path_2 = vec![3, 11, 7, 5, 2];
 
-    graph.find_shortest_path(3, 2);
+    graph.set_start(3);
+    graph.set_end(2);
+
+    graph.find_shortest_path();
 
     match graph.get_path()
     {
@@ -232,7 +246,10 @@ fn shortest_path_large()
 
   let should_path = vec![5, 6, 4, 1, 2, 7, 3, 0, 8];
 
-  graph.find_shortest_path(5, 8);
+  graph.set_start(5);
+  graph.set_end(8);
+
+  graph.find_shortest_path();
 
   match graph.get_path()
   {
@@ -284,7 +301,10 @@ fn start_and_end_are_within_graph()
 
   let should_path = vec![10, 7, 6, 4];
 
-  graph.find_shortest_path(10, 4);
+  graph.set_start(10);
+  graph.set_end(4);
+
+  graph.find_shortest_path();
 
   match graph.get_path()
   {
@@ -305,7 +325,10 @@ fn no_possible_path()
   let mut graph = DijkstraGraph::new();
   graph.insert_small_graph();
 
-  assert!(!graph.find_shortest_path(0, 2));
+  graph.set_start(0);
+  graph.set_end(2);
+
+  assert!(!graph.find_shortest_path());
   assert!(graph.get_path().is_none());
 }
 
@@ -332,7 +355,10 @@ fn disconnected_graph()
   graph.add_line(7, 6, 20);
   graph.add_line(2, 4, 20);
 
-  graph.find_shortest_path(2, 0);
+  graph.set_start(2);
+  graph.set_end(0);
+
+  graph.find_shortest_path();
 
   assert!(graph.get_path().is_none());
 }
@@ -371,7 +397,10 @@ fn cyclical_valid_path()
 
   let should_path = vec![3, 7, 6, 5, 4];
 
-  graph.find_shortest_path(3, 4);
+  graph.set_start(3);
+  graph.set_end(4);
+
+  graph.find_shortest_path();
 
   match graph.get_path()
   {