Rework and some fixes

src/amaz_lib/MazeGenerator.py

@@ -0,0 +1,90 @@
+from typing import Generator
+import numpy as np
+from .classes.Cell import Cell
+import math
+
+
+class MazeGenerator:
+    class Kruskal:
+        @staticmethod
+        def walls_to_maze(
+            walls: list[tuple[int, int]], height: int, width: int
+        ) -> np.ndarray:
+            maze: np.ndarray = np.array(
+                [[Cell(value=0) for _ in range(width)] for _ in range(height)]
+            )
+            for wall in walls:
+                x, y = wall
+                match y - x:
+                    case 1:
+                        maze[math.trunc((x / width))][x % width].set_est(True)
+                        maze[math.trunc((y / width))][y % width].set_west(True)
+                    case 5:
+                        maze[math.trunc((x / width))][x % width].set_south(
+                            True
+                        )
+                        maze[math.trunc((y / width))][y % width].set_north(
+                            True
+                        )
+            return maze
+
+        @staticmethod
+        def is_in_same_set(
+            sets: list[list[int]], wall: tuple[int, int]
+        ) -> bool:
+            a, b = wall
+            for set in sets:
+                if a in set and b in set:
+                    return True
+                if a in set or b in set:
+                    return False
+            return False
+
+        @staticmethod
+        def merge_sets(sets: list[list[int]], wall: tuple[int, int]) -> None:
+            a, b = wall
+            base_set = None
+            for set in sets:
+                if base_set is None and (a in set or b in set):
+                    base_set = set
+                elif base_set and (a in set or b in set):
+                    base_set += set
+                    sets.remove(set)
+
+        @classmethod
+        def kruskal(
+            cls, height: int, width: int
+        ) -> Generator[np.ndarray, None, np.ndarray]:
+            sets = [[i] for i in range(height * width)]
+            walls = []
+            for h in range(height):
+                for w in range(width - 1):
+                    walls += [(w + (width * h), w + (width * h) + 1)]
+            for w in range(width):
+                for h in range(height - 1):
+                    walls += [(w + (width * h), w + (width * h) + width)]
+            np.random.shuffle(walls)
+
+            yield cls.walls_to_maze(walls, height, width)
+            for wall in walls:
+                if not cls.is_in_same_set(sets, wall):
+                    cls.merge_sets(sets, wall)
+                    walls.remove(wall)
+                    yield cls.walls_to_maze(walls, height, width)
+            return cls.walls_to_maze(walls, height, width)
+
+
+def main():
+    try:
+        for alg in MazeGenerator.Kruskal.kruskal(10, 10):
+            maze = alg
+            # print(maze)
+            # print()
+        print(maze)
+
+    except GeneratorExit as maze:
+        print(maze)
+
+
+if __name__ == "__main__":
+    main()

src/amaz_lib/__init__.py

@@ -1,7 +1,7 @@
 from .classes.Cell import Cell
 from .classes.Maze import Maze
-from .generators.kruskal import kruskal
+from .MazeGenerator import MazeGenerator
 
 __version__ = "1.0.0"
 __author__ = "us"
-__all__ = ["Cell", "Maze", "kruskal"]
+__all__ = ["Cell", "Maze", "MazeGenerator"]

src/amaz_lib/classes/Cell.py

@@ -5,7 +5,7 @@ class Cell(BaseModel):
     value: int = Field(ge=0, le=15)
 
     def __str__(self) -> str:
-        return hex(self.value).removeprefix("0x")
+        return hex(self.value).removeprefix("0x").upper()
 
     def set_value(self, value: int) -> None:
         self.value = value

src/amaz_lib/classes/Maze.py

@@ -1,15 +1,19 @@
 from dataclasses import dataclass
+
+import numpy
 from .Cell import Cell
 
 
 @dataclass
 class Maze:
-    maze: list[list[Cell]]
+    maze: numpy.ndarray
+    start: tuple[int, int]
+    end: tuple[int, int]
 
-    def get_maze(self) -> list[list[Cell]] | None:
+    def get_maze(self) -> numpy.ndarray | None:
         return self.maze
 
-    def set_maze(self, new_maze: list[list[Cell]]) -> None:
+    def set_maze(self, new_maze: numpy.ndarray) -> None:
         self.maze = new_maze
 
     def __str__(self) -> str:
@@ -20,8 +24,14 @@ class Maze:
             for cell in line:
                 res += cell.__str__()
             res += "\n"
+        res += "\n"
+        res += f"{self.start[0]},{self.start[1]}\n"
+        res += f"{self.end[0]},{self.end[1]}\n"
         return res
 
-    def export_maze(self, file_name: str):
+    def export_maze(self, file_name: str) -> None:
         with open(file_name, "w") as file:
             file.write(self.__str__())
+
+    def solver(self) -> str:
+        pass

src/amaz_lib/generators/kruskal.py

@@ -1,83 +0,0 @@
-from typing import Generator
-import numpy as np
-from ..classes.Cell import Cell
-import math
-
-
-def walls_to_maze(
-    walls: list[tuple[int, int]],
-    height: int,
-    width: int,
-) -> np.ndarray:
-    maze: np.ndarray = np.array(
-        [[Cell(value=0) for _ in range(width)] for _ in range(height)]
-    )
-    for wall in walls:
-        x, y = wall
-        match y - x:
-            case 1:
-                maze[math.trunc((x / width))][x % width].set_est(True)
-                maze[math.trunc((y / width))][y % width].set_west(True)
-            case 5:
-                maze[math.trunc((x / width))][x % width].set_south(True)
-                maze[math.trunc((y / width))][y % width].set_north(True)
-    return maze
-
-
-def is_in_same_set(sets: list[list[int]], wall: tuple[int, int]) -> bool:
-    a, b = wall
-    for set in sets:
-        if a in set and b in set:
-            return True
-        if a in set or b in set:
-            return False
-    return False
-
-
-def merge_sets(sets: list[list[int]], wall: tuple[int, int]) -> None:
-    a, b = wall
-    base_set = None
-    for set in sets:
-        if base_set is None and (a in set or b in set):
-            base_set = set
-        elif base_set and (a in set or b in set):
-            base_set += set
-            sets.remove(set)
-
-
-def kruskal(
-    height: int, width: int
-) -> Generator[np.ndarray, None, np.ndarray]:
-    sets = [[i] for i in range(height * width)]
-    walls = []
-    for h in range(height):
-        for w in range(width - 1):
-            walls += [(w + (width * h), w + (width * h) + 1)]
-    for w in range(width):
-        for h in range(height - 1):
-            walls += [(w + (width * h), w + (width * h) + width)]
-    np.random.shuffle(walls)
-
-    yield walls_to_maze(walls, height, width)
-    for wall in walls:
-        if not is_in_same_set(sets, wall):
-            merge_sets(sets, wall)
-            walls.remove(wall)
-            yield walls_to_maze(walls, height, width)
-    return walls_to_maze(walls, height, width)
-
-
-def main():
-    try:
-        for alg in kruskal(10, 10):
-            maze = alg
-            # print(maze)
-            # print()
-        print(maze)
-
-    except GeneratorExit as maze:
-        print(maze)
-
-
-if __name__ == "__main__":
-    main()