Major changes

Note - really slow

Author: ng-23

SlidePuzzle.py

@@ -75,8 +75,9 @@ def load_image(self):
         if file_path:
             # Load and resize image
             image = Image.open(file_path)
-            image = image.resize((self.tile_size * self.size, 
-                                self.tile_size * self.size))
+            image = image.resize(
+                (self.tile_size * self.size, self.tile_size * self.size),
+                )
 
             # Split image into tiles
             self.image_tiles = []
@@ -117,7 +118,7 @@ def create_board(self):
                 btn = tk.Button(
                     self.game_frame,
                     image=self.image_tiles[number],
-                    command=lambda x=i, y=j: self.make_move(x, y),
+                    command=lambda x=i, y=j: self.make_move(x, y, self.current_state, self.empty_pos, simulate=False),
                     )
                 btn.grid(row=i, column=j, padx=1, pady=1)
                 row.append(btn)
@@ -129,21 +130,18 @@ def create_board(self):
     def shuffle_board(self):
         # Perform random moves
         for _ in range(100):
-            possible_moves = self.get_possible_moves()
+            possible_moves = self.get_possible_moves(self.empty_pos)
             i, j = self.rand.choice(possible_moves)
-            self.swap_tiles(i, j)
+            self.empty_pos = self.swap_tiles(i, j, self.current_state)
         self.num_moves = 0
 
         # Update display
         self.update_display()
 
-    def get_possible_moves(self, simulate=False, empty_pos=()):
+    def get_possible_moves(self, empty_pos:tuple[int,int]):
         moves = []
 
-        if simulate:
-            i, j = empty_pos
-        else:
-            i, j = self.empty_pos
+        i, j = empty_pos
 
         # Check all adjacent positions
         for di, dj in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
@@ -153,53 +151,29 @@ def get_possible_moves(self, simulate=False, empty_pos=()):
 
         return moves
 
-    def make_move(self, i, j, simulate=False, game_state=None, empty_pos=(), possible_moves:list[tuple[int,int]]=[]) -> None|list[list[int]]:
-        # simulate making the move, but don't actually change the board
-        if simulate:
-            if game_state is None or len(empty_pos) < 2:
-                # no state provided which is necessary for simulation to work properly
-                # also need to know empty position for simulation to work properly
-                return None
-            
-            if len(possible_moves) == 0:
-                # possible moves not already supplied so calculate them
-                possible_moves = self.get_possible_moves(simulate=True, empty_pos=empty_pos)
-                
-            # assumes possible moves provided (or calculated) are indeed valid
-            if (i,j) not in possible_moves:
-                return None # invalid move, no valid board
-            
-            # make a copy of the game state - otherwise our modifications will be done in-place
-            # which will mess up subsequent move simulations
-            curr_state = copy.deepcopy(game_state)
-                        
-            # move must be valid
-            # just swap the empty tile with the tile at the i,j position
-            empty_i, empty_j = empty_pos
-            empty_tile = curr_state[empty_i][empty_j] # actual empty tile number
-            swap_tile = curr_state[i][j] # actual soon-to-be-swapped tile number
-            curr_state[empty_i][empty_j] = swap_tile
-            curr_state[i][j] = empty_tile
-
-            return curr_state
+    def make_move(self, i:int, j:int, game_state:utils.UniqueGrid, empty_pos:tuple[int,int], possible_moves:list[tuple[int,int]]=[], simulate=False):
+        possible_moves = possible_moves if possible_moves else self.get_possible_moves(empty_pos)
+        if (i,j) in possible_moves:
+            temp_state = copy.deepcopy(game_state)
+            empty_pos = self.swap_tiles(i, j, temp_state)
 
-        # not a simulation - carry out the move and update the board
-        # Check if the clicked tile is adjacent to empty space
-        if (i, j) in self.get_possible_moves():
-            self.num_moves += 1
-            self.swap_tiles(i, j)
-            self.update_display()
-            # Check if puzzle is solved
-            if self.check_win():
-                messagebox.showinfo(
-                    "Congratulations!", "You solved the puzzle in " + str(self.num_moves) + " moves!"
-                    )
-                
-    def swap_tiles(self, i, j):
-        # Swap values in current_state
-        self.current_state.swap(self.empty_pos, (i,j))
+            if not simulate:
+                self.num_moves += 1
+                self.current_state = temp_state
+                self.empty_pos = empty_pos
+                self.update_display()
+                # Check if puzzle is solved
+                if self.check_win():
+                    messagebox.showinfo(
+                        "Congratulations!", "You solved the puzzle in " + str(self.num_moves) + " moves!"
+                        )
+                    
+            return temp_state
+                        
+    def swap_tiles(self, i, j, game_state:utils.UniqueGrid):
+        game_state.swap(self.empty_pos, (i,j))
 
-        self.empty_pos = (i,j)
+        return (i,j)
 
     def update_display(self):
         # Update button images based on current_state
@@ -214,7 +188,7 @@ def update_display(self):
         if self.debug:
             print(f'Total moves: {self.num_moves}')
             print(f'Current game state:\n{self.current_state}')
-            print(f'Possible moves:\n{self.get_possible_moves()}')
+            print(f'Possible moves:\n{self.get_possible_moves(self.empty_pos)}')
             print('-'*50)
 
     def check_win(self):
@@ -223,8 +197,8 @@ def check_win(self):
         '''
 
         return self.goal_state == self.current_state.get_space(tuplify=True)
-
-    def precompute_search_space(self, init_game_state:tuple[tuple], init_empty_pos:tuple[int,int], n_nodes:int|None=None):
+    
+    def precompute_search_space(self, init_game_state:utils.UniqueGrid, init_empty_pos:tuple[int,int], n_nodes:int|None=None):
         '''
         Computes a graph representing every possible unique game state and the moves to reach it
         '''
@@ -238,40 +212,42 @@ def precompute_search_space(self, init_game_state:tuple[tuple], init_empty_pos:t
 
         empty_pos = init_empty_pos
         queue = [(init_game_state, [], empty_pos)] # tuple of current game state, moves made to reach current state, and position of empty tile
-        seen_states = set([utils.tuplify_2dmatrix(init_game_state)])
+        seen_states = set([init_game_state.get_space(tuplify=True)])
 
         while queue:
             curr_state, moves_made, empty_pos = queue.pop(0)
 
-            graph[utils.tuplify_2dmatrix(curr_state)] = dict()
+            graph[curr_state.get_space(tuplify=True)] = dict()
             if self.debug:
                 print(f'Unique state nodes in graph: {len(graph)}\n')
-                print('Current game state:')
-                # see https://stackoverflow.com/a/63496125/ (pretty printing the 2d matrix)
-                for i in curr_state:
-                    print('   '.join(map(str, i)))
+                print(f'Current game state:\n{curr_state}')
 
             if n_nodes is not None and len(graph) == n_nodes:
                 # this just indicates that we only want to precompute the first n nodes
                 if self.debug:
-                    print(f'\nComputed {n_nodes} state nodes, stopping early\n{'-'*25}')
+                    print(f'Computed {n_nodes} state nodes, stopping early\n{'-'*25}')
                 break
 
-            possible_moves = self.get_possible_moves(simulate=True, empty_pos=empty_pos)
-            next_states = {utils.tuplify_2dmatrix(self.make_move(*move, simulate=True, game_state=curr_state, empty_pos=empty_pos, possible_moves=possible_moves)): move for move in possible_moves}
+            possible_moves = self.get_possible_moves(empty_pos)
+            next_states = {self.make_move(*move, curr_state, empty_pos, possible_moves=possible_moves, simulate=True): move for move in possible_moves}
             unseen_states = set(next_states.keys()) - seen_states
             if self.debug:
-                print(f'\nNext possible {len(next_states)} game states:\n{pprint.pformat(next_states, indent=4, sort_dicts=False)}\n')
-                print(f'{len(unseen_states)}/{len(next_states)} next possible game states are unseen:\n{unseen_states}')
+                print(f'Next possible {len(next_states)} game states:')
+                for i,next_state in enumerate(next_states.keys()):
+                    print(f'{i}:\n' + str(next_state))
+                
+                print(f'{len(unseen_states)}/{len(next_states)} next possible game states are unseen:')
+                for i,next_state in enumerate(next_states.keys()):
+                    print(f'{i}:\n' + str(next_state))
 
             for unseen_state in unseen_states:
                 move_to = next_states[unseen_state]
-                graph[utils.tuplify_2dmatrix(curr_state)][unseen_state] = move_to
+                graph[curr_state.get_space(tuplify=True)][unseen_state.get_space(tuplify=True)] = move_to
 
                 seen_states.add(unseen_state)
                 queue.append(
                     (
-                        utils.listify_2dmatrix(unseen_state), 
+                        unseen_state, 
                         moves_made + [move_to],
                         next_states[unseen_state]
                     )
@@ -303,14 +279,14 @@ def solve_game(self):
         print(f'Correct sequence of {num_moves} moves:\n{moves_made}')
 
         for move in moves_made:
-            self.make_move(*move)
+            self.make_move(*move, self.current_state, self.empty_pos, simulate=False)
 
     def solve_pc_bfs(self):
         '''
         Solve the puzzle using a Breadth-First Search over a precomputed search space graph
         '''
 
-        search_space = self.precompute_search_space(self.current_state.get_space(), self.empty_pos, **self.solve_config)
+        search_space = self.precompute_search_space(copy.deepcopy(self.current_state), self.empty_pos, **self.solve_config)
         moves_made, num_moves = sa.precomputed_bfs(search_space, self.goal_state)
 
         return moves_made, num_moves
@@ -320,7 +296,7 @@ def solve_pc_dfs(self):
         Solve the puzzle using a Depth-First Search over a precomputed search space graph
         '''
 
-        search_space = self.precompute_search_space(self.current_state.get_space(), self.empty_pos, **self.solve_config)
+        search_space = self.precompute_search_space(copy.deepcopy(self.current_state), self.empty_pos, **self.solve_config)
         moves_made, num_moves = sa.precomputed_dfs(search_space, self.goal_state)
 
         return moves_made, num_moves

utils.py

@@ -107,8 +107,6 @@ def set_space(self, space):
             self.space = prev_space
             raise e
 
-        return prev_space
-
     def __str__(self):
         s = ''
 
@@ -149,4 +147,9 @@ def __str__(self):
     new_pos = (1,1)
     g.swap(old_pos, new_pos)
     print(g)
-    
+
+    g2 = copy.deepcopy(g)
+    g2.insert(new_pos, 123)
+
+    print(f'Original grid:\n{str(g)}')
+    print(f'Copied grid:\n{g2}')