Provide an alternative structure of Maze Game

The aim is to demonstrate a value of the Factory Method pattern.
The Game trait (interface) should be decoupled modularly from impls.
It would demonstrate that there could be many implementations, and
the game runs similarly with different ones.

Author: fadeevab

creational/factory-method/maze-game/game.rs

@@ -0,0 +1,27 @@
+/// Maze room that is going to be instantiated with a factory method.
+pub trait Room {
+    fn render(&self);
+}
+
+/// Maze game has a factory method producing different rooms.
+pub trait MazeGame {
+    type RoomImpl: Room;
+
+    /// A factory method.
+    fn rooms(&self) -> Vec<Self::RoomImpl>;
+
+    fn play(&self) {
+        for room in self.rooms() {
+            room.render();
+        }
+    }
+}
+
+/// The client code initializes resources and does other preparations
+/// then it uses a factory to construct and run the game.
+pub fn run(maze_game: impl MazeGame) {
+    println!("Loading resources...");
+    println!("Starting the game...");
+
+    maze_game.play();
+}

creational/factory-method/maze-game/game/mod.rs

@@ -1,4 +1,4 @@
-use super::{MazeGame, Room};
+use super::game::{MazeGame, Room};
 
 #[derive(Clone)]
 pub struct MagicRoom {
@@ -17,11 +17,11 @@ impl Room for MagicRoom {
     }
 }
 
-pub struct MagicMazeGame {
+pub struct MagicMaze {
     rooms: Vec<MagicRoom>,
 }
 
-impl MagicMazeGame {
+impl MagicMaze {
     pub fn new() -> Self {
         Self {
             rooms: vec![
@@ -32,7 +32,7 @@ impl MagicMazeGame {
     }
 }
 
-impl MazeGame for MagicMazeGame {
+impl MazeGame for MagicMaze {
     type RoomImpl = MagicRoom;
 
     fn rooms(&self) -> Vec<Self::RoomImpl> {

creational/factory-method/maze-game/game/magic_maze.rs renamed to creational/factory-method/maze-game/magic_maze.rs

@@ -1,19 +1,14 @@
 mod game;
+mod magic_maze;
+mod ordinary_maze;
 
-/// The client code demonstrates that it does its own things
-/// (e.g. loading resources) and it can use a factory in a proper place to
-/// construct a game.
-fn run(game: impl game::MazeGame) {
-    println!("Loading resources...");
-    println!("Starting the game...");
-
-    game.play();
-}
+use magic_maze::MagicMaze;
+use ordinary_maze::OrdinaryMaze;
 
 fn main() {
-    let game = game::MagicMazeGame::new();
-    run(game);
+    let magic_maze = MagicMaze::new();
+    game::run(magic_maze);
 
-    let game = game::OrdinaryMazeGame::new();
-    run(game);
+    let ordinary_maze = OrdinaryMaze::new();
+    game::run(ordinary_maze);
 }

creational/factory-method/maze-game/main.rs

@@ -1,4 +1,4 @@
-use super::{MazeGame, Room};
+use super::game::{MazeGame, Room};
 
 #[derive(Clone)]
 pub struct OrdinaryRoom {
@@ -17,19 +17,19 @@ impl Room for OrdinaryRoom {
     }
 }
 
-pub struct OrdinaryMazeGame {
+pub struct OrdinaryMaze {
     rooms: Vec<OrdinaryRoom>,
 }
 
-impl OrdinaryMazeGame {
+impl OrdinaryMaze {
     pub fn new() -> Self {
         Self {
             rooms: vec![OrdinaryRoom::new(1), OrdinaryRoom::new(2)],
         }
     }
 }
 
-impl MazeGame for OrdinaryMazeGame {
+impl MazeGame for OrdinaryMaze {
     type RoomImpl = OrdinaryRoom;
 
     fn rooms(&self) -> Vec<Self::RoomImpl> {