Update app.py

app.py

@@ -32,10 +32,8 @@ class GoGame:
         color = self.board[x, y]
         if color == 0:
             return set()
-        
         group = {(x, y)}
         frontier = [(x, y)]
-        
         while frontier:
             current = frontier.pop()
             for nx, ny in self.get_neighbors(*current):
@@ -66,28 +64,23 @@ class GoGame:
     def is_valid_move(self, x, y):
         if self.board[x, y] != 0:
             return False
-
         # Make a temporary move.
         self.board[x, y] = self.current_player
         valid = self.has_liberties(x, y)
         captures_enemy = self.capture_stones() > 0
         # Undo temporary move.
         self.board[x, y] = 0
-
         return valid or captures_enemy
 
     def make_move(self, x, y):
         if not self.is_valid_move(x, y):
             return False
-
         self.board[x, y] = self.current_player
         captured = self.capture_stones()
-        
         if self.current_player == 1:
             self.captured_white += captured
         else:
             self.captured_black += captured
-            
         self.last_move = (x, y)
         self.current_player *= -1
         return True
@@ -96,18 +89,15 @@ class GoGame:
         empty_positions = list(zip(*np.where(self.board == 0)))
         if not empty_positions:
             return None
-
         valid_moves = [pos for pos in empty_positions if self.is_valid_move(*pos)]
         if not valid_moves:
             return None
-
         if difficulty == Difficulty.EASY:
             move = random.choice(valid_moves)
         elif difficulty == Difficulty.MEDIUM:
             move = self.medium_ai(valid_moves)
         else:
             move = self.hard_ai(valid_moves)
-
         self.make_move(*move)
         return move
 
@@ -130,7 +120,6 @@ class GoGame:
                 self.board[move] = 0
                 return move
             self.board[move] = 0
-
         opponent = -self.current_player
         self.current_player = opponent
         for move in valid_moves:
@@ -142,90 +131,49 @@ class GoGame:
                     return move
                 self.board[move] = 0
         self.current_player = -opponent
-
         return self.medium_ai(valid_moves)
 
 def create_board_image(board, last_move=None, hover_pos=None):
     cell_size = 60
     margin = 40
     total_size = board.shape[0] * cell_size + 2 * margin
-    
     # Create wooden background.
     image = np.full((total_size, total_size, 3), [219, 179, 119], dtype=np.uint8)
-    
-    # Draw grid with thicker lines.
+    # Draw grid.
     for i in range(board.shape[0]):
-        cv2.line(image, 
-                 (margin + i * cell_size, margin), 
-                 (margin + i * cell_size, total_size - margin), 
-                 (0, 0, 0), 
-                 2)
-        cv2.line(image, 
-                 (margin, margin + i * cell_size), 
-                 (total_size - margin, margin + i * cell_size), 
-                 (0, 0, 0), 
-                 2)
-    
-    # Draw star points (hoshi).
+        cv2.line(image, (margin + i * cell_size, margin), (margin + i * cell_size, total_size - margin), (0, 0, 0), 2)
+        cv2.line(image, (margin, margin + i * cell_size), (total_size - margin, margin + i * cell_size), (0, 0, 0), 2)
+    # Draw star points.
     star_points = [(2, 2), (2, 6), (4, 4), (6, 2), (6, 6)]
     for point in star_points:
-        cv2.circle(image,
-                  (margin + point[1] * cell_size, margin + point[0] * cell_size),
-                  4,
-                  (0, 0, 0),
-                  -1,
-                  cv2.LINE_AA)
-    
-    # Draw hover position indicator.
+        cv2.circle(image, (margin + point[1] * cell_size, margin + point[0] * cell_size), 4, (0, 0, 0), -1, cv2.LINE_AA)
+    # Draw hover indicator, if any.
     if hover_pos:
         hover_row, hover_col = hover_pos
         center = (margin + hover_col * cell_size, margin + hover_row * cell_size)
         overlay = image.copy()
-        # Draw a semi-transparent preview.
         cv2.circle(overlay, center, 23, (0, 0, 0), -1, cv2.LINE_AA)
         image = cv2.addWeighted(overlay, 0.5, image, 0.5, 0)
         cv2.circle(image, center, 23, (255, 255, 255), 1, cv2.LINE_AA)
-    
-    # Draw stones with enhanced 3D effect.
+    # Draw stones.
     for i in range(board.shape[0]):
         for j in range(board.shape[1]):
             if board[i, j] != 0:
                 center = (margin + j * cell_size, margin + i * cell_size)
-                
                 # Shadow effect.
-                cv2.circle(image,
-                           (center[0] + 2, center[1] + 2),
-                           23,
-                           (0, 0, 0),
-                           -1,
-                           cv2.LINE_AA)
-                
-                # Stone.
+                cv2.circle(image, (center[0] + 2, center[1] + 2), 23, (0, 0, 0), -1, cv2.LINE_AA)
                 stone_color = (0, 0, 0) if board[i, j] == 1 else (255, 255, 255)
                 cv2.circle(image, center, 23, stone_color, -1, cv2.LINE_AA)
-                
-                # Highlight for 3D effect.
-                if board[i, j] == -1:  # White stone highlight.
-                    cv2.circle(image,
-                               (center[0] - 5, center[1] - 5),
-                               8,
-                               (240, 240, 240),
-                               -1,
-                               cv2.LINE_AA)
-                else:  # Black stone highlight.
-                    cv2.circle(image,
-                               (center[0] - 5, center[1] - 5),
-                               8,
-                               (40, 40, 40),
-                               -1,
-                               cv2.LINE_AA)
-    
+                # 3D highlight.
+                if board[i, j] == -1:
+                    cv2.circle(image, (center[0] - 5, center[1] - 5), 8, (240, 240, 240), -1, cv2.LINE_AA)
+                else:
+                    cv2.circle(image, (center[0] - 5, center[1] - 5), 8, (40, 40, 40), -1, cv2.LINE_AA)
     # Highlight last move.
     if last_move:
         row, col = last_move
         center = (margin + col * cell_size, margin + row * cell_size)
         cv2.circle(image, center, 5, (255, 0, 0), -1, cv2.LINE_AA)
-    
     return Image.fromarray(image)
 
 class GradioGoGame:
@@ -233,47 +181,35 @@ class GradioGoGame:
         self.game = GoGame()
         self.difficulty = Difficulty.EASY
         self.hover_pos = None
-    
-    def process_click(self, evt: gr.SelectData, difficulty):
+
+    def process_click(self, evt: gr.SelectData):
         cell_size = 60
         margin = 40
-
-        # evt.index returns pixel coordinates as (x, y).
-        # Convert to board coordinates:
+        # evt.index returns pixel coordinates as (x, y). Convert to board coordinates.
         col = round((evt.index[0] - margin) / cell_size)
         row = round((evt.index[1] - margin) / cell_size)
-
         if not (0 <= row < self.game.size and 0 <= col < self.game.size):
             return create_board_image(self.game.board, self.game.last_move), "Invalid click position"
-        
-        self.difficulty = Difficulty(difficulty)
-        
         if not self.game.make_move(row, col):
             return create_board_image(self.game.board, self.game.last_move), "Invalid move (occupied or suicide)"
-        
         # AI Move.
         ai_move = self.game.ai_move(self.difficulty)
         if ai_move is None:
             return create_board_image(self.game.board, self.game.last_move), "Game Over"
-        
         status = f"Black captures: {self.game.captured_white} | White captures: {self.game.captured_black}"
         return create_board_image(self.game.board, self.game.last_move), f"AI moved to: {ai_move}\n{status}"
-    
+
     def update_hover(self, evt: gr.SelectData):
         cell_size = 60
         margin = 40
-
-        # Convert pixel position to board coordinates.
         col = round((evt.index[0] - margin) / cell_size)
         row = round((evt.index[1] - margin) / cell_size)
-        
         if 0 <= row < self.game.size and 0 <= col < self.game.size:
             self.hover_pos = (row, col)
         else:
             self.hover_pos = None
-            
         return create_board_image(self.game.board, self.game.last_move, self.hover_pos)
-    
+
     def reset_game(self):
         self.game = GoGame()
         self.hover_pos = None
@@ -281,7 +217,6 @@ class GradioGoGame:
 
 def create_interface():
     game = GradioGoGame()
-    
     with gr.Blocks(theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
         # Go Game vs AI  
@@ -292,7 +227,6 @@ def create_interface():
         - Capture enemy stones by surrounding them.  
         - Stones must have liberties (empty adjacent points) to survive.
         """)
-        
         with gr.Row():
             with gr.Column(scale=2):
                 board_output = gr.Image(
@@ -308,7 +242,6 @@ def create_interface():
                     value="Click on an intersection to place a stone",
                     lines=2
                 )
-            
             with gr.Column(scale=1):
                 difficulty = gr.Radio(
                     choices=[d.value for d in Difficulty],
@@ -316,26 +249,22 @@ def create_interface():
                     label="AI Difficulty"
                 )
                 reset_btn = gr.Button("Reset Game", variant="secondary")
-        
+        # Update difficulty when the radio value changes.
+        def update_difficulty(value):
+            game.difficulty = Difficulty(value)
+            return value
+        difficulty.change(update_difficulty, inputs=[difficulty], outputs=[difficulty])
         # Use .select() for click events on the interactive image.
         board_output.select(
             game.process_click,
-            inputs=[board_output, difficulty],
+            inputs=[],  # No additional inputs: the event data is passed automatically.
             outputs=[board_output, msg_output]
         )
-        
-        # Use .mousemove() for hover updates (if supported by your Gradio version).
-        board_output.mousemove(
-            game.update_hover,
-            inputs=board_output,
-            outputs=board_output
-        )
-        
+        # (Removed mousemove event since gr.Image doesn't support it in your version.)
         reset_btn.click(
             game.reset_game,
             outputs=[board_output, msg_output]
         )
-    
     return interface
 
 if __name__ == "__main__":