[3] MORE FUNC to maze-core.py

KislyuninED/docks/data/2-st-exercize/maze-core.py

@@ -246,10 +246,150 @@ class SearchStats:
         self.path_length = path_length
 
 
+class Observer:
+    def update(self, event_type, data):
+        raise NotImplementedError
+
+
+class ConsoleView(Observer):
+    def __init__(self, player=None):
+        self._last_path = None
+        self._player = player
+    
+    def update(self, event_type, data):
+        if event_type == "maze_loaded":
+            self.render_maze(data)
+        elif event_type == "path_found":
+            self._last_path = data
+            self.render_path(data)
+        elif event_type == "player_moved":
+            self.render_maze_with_player(data)
+    
+    def render_maze(self, maze):
+        os.system('cls' if os.name == 'nt' else 'clear')
+        print("=" * (maze.width * 2 + 4))
+        print("   LABIRINT")
+        print("=" * (maze.width * 2 + 4))
+        
+        for y in range(maze.height):
+            print("  ", end='')
+            for x in range(maze.width):
+                cell = maze.get_cell(x, y)
+                if cell == maze.start:
+                    print('S', end=' ')
+                elif cell == maze.exit:
+                    print('E', end=' ')
+                elif cell.is_wall:
+                    print('#', end=' ')
+                else:
+                    print('.', end=' ')
+            print()
+        print("=" * (maze.width * 2 + 4))
+        print("  S - start  E - exit  # - wall  . - path")
+    
+    def render_maze_with_player(self, maze):
+        os.system('cls' if os.name == 'nt' else 'clear')
+        print("=" * (maze.width * 2 + 4))
+        print("   LABIRINT (P - player)")
+        print("=" * (maze.width * 2 + 4))
+        
+        for y in range(maze.height):
+            print("  ", end='')
+            for x in range(maze.width):
+                cell = maze.get_cell(x, y)
+                if self._player and cell == self._player.current:
+                    print('P', end=' ')
+                elif cell == maze.start:
+                    print('S', end=' ')
+                elif cell == maze.exit:
+                    print('E', end=' ')
+                elif cell.is_wall:
+                    print('#', end=' ')
+                else:
+                    print('.', end=' ')
+            print()
+        print("=" * (maze.width * 2 + 4))
+        print(f"  Player position: ({self._player.current.x}, {self._player.current.y})")
+        print("  S - start  E - exit  # - wall  . - path  P - player")
+    
+    def render_path(self, path):
+        if not path:
+            print("\n  Path not found!")
+            return
+        print(f"\n  Path found! Length: {len(path)}")
+
+
+class Player:
+    def __init__(self, start_cell, maze):
+        self._current = start_cell
+        self._previous = None
+        self._maze = maze
+    
+    @property
+    def current(self):
+        return self._current
+    
+    def move_to(self, cell):
+        if cell and cell.is_passable():
+            self._previous = self._current
+            self._current = cell
+            return True
+        return False
+    
+    def undo_move(self):
+        if self._previous:
+            self._current, self._previous = self._previous, None
+            return True
+        return False
+
+
+class Command:
+    def execute(self):
+        raise NotImplementedError
+    
+    def undo(self):
+        raise NotImplementedError
+
+
+class MoveCommand(Command):
+    def __init__(self, player, direction, maze):
+        self._player = player
+        self._direction = direction
+        self._maze = maze
+        self._executed = False
+    
+    def execute(self):
+        dx, dy = self._direction
+        new_x = self._player.current.x + dx
+        new_y = self._player.current.y + dy
+        target_cell = self._maze.get_cell(new_x, new_y)
+        
+        if target_cell and target_cell.is_passable():
+            self._player.move_to(target_cell)
+            self._executed = True
+            return True
+        return False
+    
+    def undo(self):
+        if self._executed:
+            self._player.undo_move()
+            self._executed = False
+            return True
+        return False
+
+
 class MazeSolver:
     def __init__(self, maze):
         self._maze = maze
         self._strategy = None
+        self._observers = []
+    
+    def attach(self, observer):
+        self._observers.append(observer)
+    
+    def notify(self, event_type, data):
+        for observer in self._observers:
+            observer.update(event_type, data)
     
     def set_strategy(self, strategy):
         self._strategy = strategy
@@ -263,4 +403,6 @@ class MazeSolver:
         end_time = time.perf_counter()
         time_ms = (end_time - start_time) * 1000
         
+        self.notify("path_found", path)
+        
         return SearchStats(time_ms, self._strategy.get_visited_count(), len(path))