Merge pull request #374 from ppizarror/improve-maze-example

Improve maze example

Author: ppizarror

pygame_menu/_scrollarea.py

@@ -122,10 +122,10 @@ class ScrollArea(Base):
     _menubar: 'pygame_menu.widgets.MenuBar'
     _parent_scrollarea: 'ScrollArea'
     _rect: 'pygame.Rect'
-    _scrollbars_props: Tuple[Any, ...]
     _scrollbar_positions: Tuple[str, ...]
     _scrollbar_thick: int
     _scrollbars: List['ScrollBar']
+    _scrollbars_props: Tuple[Any, ...]
     _translate: Tuple2IntType
     _view_rect: 'pygame.Rect'
     _world: 'pygame.Surface'
@@ -1072,7 +1072,7 @@ def update(self, events: EventVectorType) -> bool:
         :param events: List of pygame events
         :return: ``True`` if updated
         """
-        updated = [0, 0]
+        updated = [False, False]
         for sbar in self._scrollbars:
             if not sbar.is_visible():
                 continue

pygame_menu/events.py

@@ -21,6 +21,31 @@
     'NONE',
     'RESET',
 
+    # Last menu events
+    'MENU_LAST_DISABLE_UPDATE',
+    'MENU_LAST_FRAMES',
+    'MENU_LAST_JOY_REPEAT',
+    'MENU_LAST_MENU_BACK',
+    'MENU_LAST_MENU_CLOSE',
+    'MENU_LAST_MENUBAR',
+    'MENU_LAST_MOUSE_ENTER_MENU',
+    'MENU_LAST_MOUSE_ENTER_WINDOW',
+    'MENU_LAST_MOUSE_LEAVE_MENU',
+    'MENU_LAST_MOUSE_LEAVE_WINDOW',
+    'MENU_LAST_MOVE_DOWN',
+    'MENU_LAST_MOVE_LEFT',
+    'MENU_LAST_MOVE_RIGHT',
+    'MENU_LAST_MOVE_UP',
+    'MENU_LAST_NONE',
+    'MENU_LAST_QUIT',
+    'MENU_LAST_SCROLL_AREA',
+    'MENU_LAST_SELECTED_WIDGET_BUTTON_UP',
+    'MENU_LAST_SELECTED_WIDGET_EVENT',
+    'MENU_LAST_SELECTED_WIDGET_FINGER_UP',
+    'MENU_LAST_WIDGET_DISABLE_ACTIVE_STATE',
+    'MENU_LAST_WIDGET_SELECT',
+    'MENU_LAST_WIDGET_SELECT_MOTION',
+
     # Pygame events
     'PYGAME_QUIT',
     'PYGAME_WINDOWCLOSE'
@@ -74,3 +99,28 @@ def is_event(event: Any) -> bool:
     PYGAME_WINDOWCLOSE = __locals.WINDOWCLOSE
 elif hasattr(__locals, 'WINDOWEVENT_CLOSE'):
     PYGAME_WINDOWCLOSE = __locals.WINDOWEVENT_CLOSE
+
+# Menu last event types. Returned by menu.get_last_update_mode()
+MENU_LAST_DISABLE_UPDATE = 'DISABLE_UPDATE'
+MENU_LAST_FRAMES = 'FRAMES'
+MENU_LAST_JOY_REPEAT = 'JOY_REPEAT'
+MENU_LAST_MENU_BACK = 'MENU_BACK'
+MENU_LAST_MENU_CLOSE = 'MENU_CLOSE'
+MENU_LAST_MENUBAR = 'MENUBAR'
+MENU_LAST_MOUSE_ENTER_MENU = 'MOUSE_ENTER_MENU'
+MENU_LAST_MOUSE_ENTER_WINDOW = 'MOUSE_ENTER_WINDOW'
+MENU_LAST_MOUSE_LEAVE_MENU = 'MOUSE_LEAVE_MENU'
+MENU_LAST_MOUSE_LEAVE_WINDOW = 'MOUSE_LEAVE_WINDOW'
+MENU_LAST_MOVE_DOWN = 'MOVE_DOWN'
+MENU_LAST_MOVE_LEFT = 'MOVE_LEFT'
+MENU_LAST_MOVE_RIGHT = 'MOVE_RIGHT'
+MENU_LAST_MOVE_UP = 'MOVE_UP'
+MENU_LAST_NONE = 'NONE'
+MENU_LAST_QUIT = 'QUIT'
+MENU_LAST_SCROLL_AREA = 'SCROLL_AREA'
+MENU_LAST_SELECTED_WIDGET_BUTTON_UP = 'SELECTED_WIDGET_BUTTON_UP'
+MENU_LAST_SELECTED_WIDGET_EVENT = 'SELECTED_WIDGET_EVENT'
+MENU_LAST_SELECTED_WIDGET_FINGER_UP = 'SELECTED_WIDGET_FINGER_UP'
+MENU_LAST_WIDGET_DISABLE_ACTIVE_STATE = 'WIDGET_DISABLE_ACTIVE_STATE'
+MENU_LAST_WIDGET_SELECT = 'WIDGET_SELECT'
+MENU_LAST_WIDGET_SELECT_MOTION = 'WIDGET_SELECT_MOTION'

pygame_menu/examples/other/maze.py

@@ -175,6 +175,7 @@ class MazeApp(object):
     Maze class.
     """
 
+    _algorithms: dict
     _diagonals: bool
     _end_point: _Point2
     _grid: _MazeType
@@ -190,8 +191,8 @@ class MazeApp(object):
 
     def __init__(
             self,
-            width: int = 7,
-            rows: int = 85,
+            width: int = 8,
+            rows: int = 75,
             margin: int = 0
     ) -> None:
         """
@@ -231,8 +232,9 @@ def __init__(
         self._drag_end_point = False
 
         # Used for deciding what to do in different situations
-        self._path_found = False
         self._algorithm_run = False
+        self._algorithms = {0: 'dijkstra', 1: 'astar', 2: 'dfs', 3: 'bfs'}
+        self._path_found = False
 
         # Create the window
         self._clock = pygame.time.Clock()
@@ -297,6 +299,8 @@ def _diagonals(value: bool) -> None:
             Changes diagonals
             """
             self._diagonals = value
+            if self._algorithm_run:
+                self._path_found = self._update_path()
 
         theme = pygame_menu.Theme(
             background_color=pygame_menu.themes.TRANSPARENT_COLOR,
@@ -309,7 +313,7 @@ def _diagonals(value: bool) -> None:
         self._menu = pygame_menu.Menu(
             height=self._screen_width,
             mouse_motion_selection=True,
-            position=(640, 25, False),
+            position=(645, 25, False),
             theme=theme,
             title='',
             width=240
@@ -349,7 +353,7 @@ def _diagonals(value: bool) -> None:
             items=[('Prim', 0),
                    ('Alt Prim', 1),
                    ('Recursive', 2),
-                   ('Terrain', 3)],
+                   ('(+) Terrain', 3)],
             dropselect_id='generator',
             font_size=16,
             onchange=onchange_dropselect,
@@ -428,15 +432,16 @@ def _diagonals(value: bool) -> None:
 
         # Create about menu
         menu_about = pygame_menu.Menu(
-            height=self._screen_width,
+            height=self._screen_width + 20,
             mouse_motion_selection=True,
-            position=(640, 25, False),
+            position=(645, 8, False),
             theme=theme,
             title='',
             width=240
         )
         menu_about.add.label('pygame-menu\nMaze', font_name=pygame_menu.font.FONT_FIRACODE_BOLD, font_size=25,
                              margin=(0, 5))
+        menu_about.add.vertical_margin(10)
         text = 'Left click to create a wall or move the start and end points.\n' \
                'Hold left CTRL and left click to create a sticky mud patch (whi' \
                'ch reduces movement speed to 1/3).\n'
@@ -478,7 +483,8 @@ def _diagonals(value: bool) -> None:
         for btn in self._menu.get_widgets(['run_generator', 'run_solver', 'about', 'about_back']):
             btn.set_onmouseover(button_onmouseover)
             btn.set_onmouseleave(button_onmouseleave)
-            btn.set_cursor(pygame_menu.locals.CURSOR_HAND)
+            if not btn.readonly:
+                btn.set_cursor(pygame_menu.locals.CURSOR_HAND)
             btn.set_background_color((75, 79, 81))
 
     def _clear_maze(self) -> None:
@@ -491,6 +497,7 @@ def _clear_maze(self) -> None:
             for column in range(self._rows):
                 if (row, column) != self._start_point and (row, column) != self._end_point:
                     self._grid[row][column].update(nodetype='blank', is_visited=False, is_path=False)
+        self._clear_visited()
 
     def _run_generator(self) -> None:
         """
@@ -499,30 +506,37 @@ def _run_generator(self) -> None:
         if self._visualize:
             ut.set_pygame_cursor(pygame_menu.locals.CURSOR_NO)
         o_visualize = self._visualize
-        self._clear_maze()
         gen_type = self._menu.get_widget('generator').get_value()[1]
+        if gen_type != 3:
+            self._clear_maze()
         if gen_type == 0:
-            self._grid = self._prim()
+            self._grid = self._prim(start_point=self._start_point)
         elif gen_type == 1:
-            self._grid = self._better_prim()
+            self._grid = self._better_prim(start_point=self._start_point)
         elif gen_type == 2:
+            pygame.display.flip()
             self._recursive_division()
         elif gen_type == 3:
             self._random_terrain()
         self._visualize = o_visualize
+        if self._visualize:
+            ut.set_pygame_cursor(pygame_menu.locals.CURSOR_ARROW)
 
     def _run_solver(self) -> None:
         """
         Run the solver.
         """
-        if self._visualize:
-            ut.set_pygame_cursor(pygame_menu.locals.CURSOR_NO)
         o_visualize = self._visualize
         solver_type = self._menu.get_widget('solver').get_value()[1]
-        self._clear_visited()
-        self._update_gui()
         if self._visualize:
             pygame.display.flip()
+        if self._path_found and self._algorithms[solver_type] == self._algorithm_run:
+            self._visualize = False
+        else:
+            self._clear_visited()
+            pygame.display.flip()
+        if self._visualize:
+            ut.set_pygame_cursor(pygame_menu.locals.CURSOR_NO)
         if solver_type == 0:
             self._path_found = self._dijkstra(self._grid, self._start_point, self._end_point)
             self._algorithm_run = 'dijkstra'
@@ -538,6 +552,8 @@ def _run_solver(self) -> None:
         self._visualize = o_visualize
         self._grid[self._start_point[0]][self._start_point[1]].update(nodetype='start')
         self._update_path()
+        if self._visualize:
+            ut.set_pygame_cursor(pygame_menu.locals.CURSOR_ARROW)
 
     def _check_esc(self) -> None:
         """
@@ -546,7 +562,7 @@ def _check_esc(self) -> None:
         if self._visualize:
             for event in pygame.event.get():
                 if event.type == pygame.QUIT:
-                    exit()
+                    self._quit()
                 if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                     self._visualize = False
 
@@ -559,7 +575,7 @@ def _sleep(ms: float) -> None:
         """
         time.sleep(ms)
 
-    def _better_prim(self, mazearray: Optional[_MazeType] = None, start_point: bool = False) -> _MazeType:
+    def _better_prim(self, mazearray: Optional[_MazeType] = None, start_point: Optional[_Point2] = None) -> _MazeType:
         """
         Randomized Prim's algorithm for creating random mazes.
         This version maintains the traditional "maze" look, where a route cannot
@@ -646,12 +662,18 @@ def _better_prim(self, mazearray: Optional[_MazeType] = None, start_point: bool
 
             walls.remove(wall)
 
+        # Iterate through each dormant, if so, change to blank
+        for row in range(self._rows):
+            for column in range(self._rows):
+                if mazearray[row][column].nodetype == 'dormant':
+                    mazearray[row][column].update(nodetype='blank')
+
         mazearray[self._end_point[0]][self._end_point[1]].update(nodetype='end')
         mazearray[self._start_point[0]][self._start_point[1]].update(nodetype='start')
 
         return mazearray
 
-    def _prim(self, mazearray: Optional[_MazeType] = None, start_point: bool = False) -> _MazeType:
+    def _prim(self, mazearray: Optional[_MazeType] = None, start_point: Optional[_Point2] = None) -> _MazeType:
         """
         Randomized Prim's algorithm for creating random mazes.
 
@@ -828,7 +850,7 @@ def _gaps_to_offset() -> List[int]:
                         y += 1
                 if y >= self._rows:
                     y = self._rows - 1
-            self._grid[x][y].update(nodetype="blank")
+            self._grid[x][y].update(nodetype='blank')
             self._draw_square(self._grid, x, y)
             if self._visualize:
                 self._update_square(x, y)
@@ -925,10 +947,8 @@ def _update_path(self) -> Union[bool, _MazeType]:
         Updates the path.
         """
         self._clear_visited()
-        valid_algorithms = ['dijkstra', 'astar', 'dfs', 'bfs']
-
-        assert self._algorithm_run in valid_algorithms, \
-            f'last algorithm used ({self._algorithm_run}) is not in valid algorithms: {valid_algorithms}'
+        assert self._algorithm_run in self._algorithms.values(), \
+            f'last algorithm used ({self._algorithm_run}) is not in valid algorithms: {self._algorithms.values()}'
 
         visualize = self._visualize
         self._visualize = False
@@ -1116,8 +1136,8 @@ def _dijkstra(
         time_taken = end - start
 
         # Print timings
-        print(f'Program finished in {time_taken:.4f} seconds after checking {num_visited}'
-              f' nodes. That is {time_taken / num_visited:.8f} seconds per node.')
+        print(f'Program finished in {time_taken:.4f}s after checking {num_visited}'
+              f' nodes ({time_taken / num_visited:.8f} s/node)')
 
         return False if v_distances[goal_node] == float('inf') else True
 
@@ -1275,19 +1295,39 @@ def _pos_in_grid(self, pos: _Point2) -> bool:
         y = pos[1] - self._offset[1]
         return 1 <= x <= self._screen_width and 1 <= y <= self._screen_width
 
+    @staticmethod
+    def _quit() -> None:
+        """
+        Quit app.
+        """
+        pygame.quit()
+        exit()
+
     def mainloop(self, test: bool) -> None:
         """
         Executes the main loop of the app.
 
         :param test: If True, runs only 1 frame
         """
+        print('Press [ESC] to skip process if Visualize is On')
         while True:
+
             # Application events
             events = pygame.event.get()
+
+            # Update the menu
+            self._menu.update(events)
+
+            # If a menu widget disable its active state, disable the events, this is due to
+            # user can click outside a dropselection box, and that triggers the disable active
+            # state. If so, the event is destroyed, thus avoiding clicking the canvas
+            if pygame_menu.events.MENU_LAST_WIDGET_DISABLE_ACTIVE_STATE in self._menu.get_last_update_mode()[0]:
+                events = []
+
             for event in events:
                 # User closes
                 if event.type == pygame.QUIT:
-                    exit()
+                    self._quit()
 
                 # Write in the board
                 elif event.type == pygame.MOUSEBUTTONDOWN:
@@ -1394,9 +1434,6 @@ def mainloop(self, test: bool) -> None:
 
                     pygame.display.flip()
 
-            # Update the menu events
-            self._menu.update(events)
-
             # Update the app
             self._update_gui()
 

pygame_menu/font.py

@@ -54,7 +54,7 @@
 FONT_FIRACODE = __fonts_path__.format('FiraCode-Regular.ttf')
 FONT_FIRACODE_BOLD = __fonts_path__.format('FiraCode-Bold.ttf')
 FONT_FIRACODE_BOLD_ITALIC = __fonts_path__.format('FiraMono-BoldItalic.ttf')
-FONT_FIRACODE_ITALIC = __fonts_path__.format('FiraMono-RegularItalic.ttf')
+FONT_FIRACODE_ITALIC = __fonts_path__.format('FiraMono-Italic.ttf')
 FONT_FRANCHISE = __fonts_path__.format('franchise.ttf')
 FONT_HELVETICA = __fonts_path__.format('helvetica.ttf')
 FONT_MUNRO = __fonts_path__.format('munro.ttf')