implemented generator and updated examples

src/executor/builder.rs

@@ -50,7 +50,7 @@ pub mod maze_state {
 
     impl MazeState for Generated {}
     impl BuildableMazeState for Generated {
-        fn get(mut self) -> Maze {
+        fn get(self) -> Maze {
             self.generator.generate()
         }
     }

src/implementations.rs

@@ -12,18 +12,16 @@ pub use depth_first::DepthFirst;
 
 #[test]
 fn depth_first() {
-    use crate::{generate, Executor};
+    use crate::{Executor, SimpleGenerator};
     let algorithm = DepthFirst::new();
-    let maze = generate(20, 20);
-    // let mut executor = Executor::new(maze, algorithm);
-    // executor.run();
+    let mut executor = Executor::build(algorithm, |b| b.generated(SimpleGenerator::new(40, 20)));
+    executor.run();
 }
 
 #[test]
 fn breath_first() {
-    use crate::{generate, Executor};
+    use crate::{Executor, SimpleGenerator};
     let algorithm = BreathFirst::new();
-    let maze = generate(20, 20);
-    // let mut executor = Executor::new(maze, algorithm);
-    // executor.run();
+    let mut executor = Executor::build(algorithm, |b| b.generated(SimpleGenerator::new(40, 20)));
+    executor.run();
 }

src/labyrinth/generator.rs

@@ -8,8 +8,26 @@ use rand::{prelude::SliceRandom, thread_rng};
 
 use crate::{Maze, Pos};
 
+/// Trait encapsulating the behavior of a type capable to create mazes.
+pub trait MazeGenerator {
+    fn generate(&self) -> Maze;
+}
+
 /// Most common maze generation technique, recursively creating paths to unvisited cells, each time choosing next direction at random.
-pub fn generate(width: isize, height: isize) -> Maze {
+pub struct SimpleGenerator {
+    width: isize,
+    height: isize,
+}
+
+impl SimpleGenerator {
+    pub fn new(width: isize, height: isize) -> Self {
+        Self { height, width }
+    }
+}
+
+impl MazeGenerator for SimpleGenerator {
+    fn generate(&self) -> Maze {
+        let Self { width, height } = *self;
         let mut result = Maze::new(
             width,
             height,
@@ -36,15 +54,13 @@ pub fn generate(width: isize, height: isize) -> Maze {
         recursive(current, &mut result, &mut visited);
 
         result
+    }
 }
 
 #[test]
 fn generation() {
-    let maze = generate(20, 20);
+    let generator = SimpleGenerator::new(10, 10);
+    let maze = generator.generate();
     let text = maze.display(None);
     println!("{text}");
 }
-
-pub trait MazeGenerator {
-    fn generate(&mut self) -> Maze;
-}

src/lib.rs

@@ -14,5 +14,8 @@ mod position;
 
 pub use algorithm::Algorithm;
 pub use executor::{Context, Executor, Guess, Insight};
-pub use labyrinth::{generator::generate, Maze};
+pub use labyrinth::{
+    generator::{MazeGenerator, SimpleGenerator},
+    Maze,
+};
 pub use position::Pos;