Update app.py

app.py

@@ -33,7 +33,7 @@ class GoGame:
         if color == 0:
             return set()
         
-        group = set([(x, y)])
+        group = {(x, y)}
         frontier = [(x, y)]
         
         while frontier:
@@ -66,18 +66,15 @@ class GoGame:
     def is_valid_move(self, x, y):
         if self.board[x, y] != 0:
             return False
-            
-        # Make temporary move
+
+        # Make a temporary move.
         self.board[x, y] = self.current_player
-        
-        # Check for suicide rule
-        has_liberties = self.has_liberties(x, y)
+        valid = self.has_liberties(x, y)
         captures_enemy = self.capture_stones() > 0
-        
-        # Undo temporary move and captures
+        # Undo temporary move.
         self.board[x, y] = 0
-        
-        return has_liberties or captures_enemy
+
+        return valid or captures_enemy
 
     def make_move(self, x, y):
         if not self.is_valid_move(x, y):
@@ -115,7 +112,6 @@ class GoGame:
         return move
 
     def medium_ai(self, valid_moves):
-        # Prioritize moves near the last human move
         if self.last_move:
             lx, ly = self.last_move
             valid_moves.sort(key=lambda p: abs(p[0] - lx) + abs(p[1] - ly))
@@ -128,7 +124,6 @@ class GoGame:
         return valid_moves[0]
 
     def hard_ai(self, valid_moves):
-        # Check for capturing moves
         for move in valid_moves:
             self.board[move] = self.current_player
             if self.capture_stones() > 0:
@@ -136,7 +131,6 @@ class GoGame:
                 return move
             self.board[move] = 0
 
-        # Check for moves that prevent capture
         opponent = -self.current_player
         self.current_player = opponent
         for move in valid_moves:
@@ -156,10 +150,10 @@ def create_board_image(board, last_move=None, hover_pos=None):
     margin = 40
     total_size = board.shape[0] * cell_size + 2 * margin
     
-    # Create wooden background
+    # Create wooden background.
     image = np.full((total_size, total_size, 3), [219, 179, 119], dtype=np.uint8)
     
-    # Draw grid with thicker lines
+    # Draw grid with thicker lines.
     for i in range(board.shape[0]):
         cv2.line(image, 
                  (margin + i * cell_size, margin), 
@@ -172,7 +166,7 @@ def create_board_image(board, last_move=None, hover_pos=None):
                  (0, 0, 0), 
                  2)
     
-    # Draw star points (hoshi)
+    # Draw star points (hoshi).
     star_points = [(2, 2), (2, 6), (4, 4), (6, 2), (6, 6)]
     for point in star_points:
         cv2.circle(image,
@@ -182,59 +176,55 @@ def create_board_image(board, last_move=None, hover_pos=None):
                   -1,
                   cv2.LINE_AA)
     
-    # Draw hover position indicator
+    # Draw hover position indicator.
     if hover_pos:
-        hover_x, hover_y = hover_pos
-        center = (margin + hover_y * cell_size, margin + hover_x * cell_size)
-        # Draw semi-transparent stone preview
-        color = (0, 0, 0) if board.sum() == 0 or board.sum() == 1 else (255, 255, 255)
-        cv2.circle(image, center, 23, color, -1, cv2.LINE_AA)
-        cv2.circle(image, center, 23, (255, 255, 255), 1, cv2.LINE_AA)
-        # Add transparency
+        hover_row, hover_col = hover_pos
+        center = (margin + hover_col * cell_size, margin + hover_row * cell_size)
         overlay = image.copy()
-        cv2.circle(overlay, center, 23, color, -1, cv2.LINE_AA)
+        # 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 with enhanced 3D effect.
     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
+                # Shadow effect.
                 cv2.circle(image,
-                          (center[0] + 2, center[1] + 2),
-                          23,
-                          (0, 0, 0, 128),
-                          -1,
-                          cv2.LINE_AA)
+                           (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, color, -1, cv2.LINE_AA)
+                # Stone.
+                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 stones
+                # 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 stones
+                               (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)
+                               (center[0] - 5, center[1] - 5),
+                               8,
+                               (40, 40, 40),
+                               -1,
+                               cv2.LINE_AA)
     
-    # Highlight last move
+    # Highlight last move.
     if last_move:
-        x, y = last_move
-        center = (margin + y * cell_size, margin + x * cell_size)
-        color = (255, 0, 0)  # Red marker
-        cv2.circle(image, center, 5, color, -1, cv2.LINE_AA)
+        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)
 
@@ -247,42 +237,38 @@ class GradioGoGame:
     def process_click(self, evt: gr.SelectData, difficulty):
         cell_size = 60
         margin = 40
-    
-        # Calculate board coordinates from click position
-        y = round((evt.index[1] - margin) / cell_size)
-        x = round((evt.index[0] - margin) / cell_size)
-    
-        # Validate coordinates
-        if not (0 <= x < self.game.size and 0 <= y < self.game.size):
+
+        # 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.is_valid_move(x, y):
-            return create_board_image(self.game.board, self.game.last_move), "Invalid move"
-    
-        # Make player move
-        self.game.make_move(x, y)
-    
-        # AI Move (if enabled)
-        if self.difficulty != Difficulty.EASY:
-            ai_move = self.game.ai_move(self.difficulty)
-            if ai_move:
-                print(f"AI moved to: {ai_move}")
-    
-        return create_board_image(self.game.board, self.game.last_move), "Move registered"
-
+        
+        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):
-        # Convert mouse position to board coordinates
         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)
         
-        x = round((evt.index[1] - margin) / cell_size)
-        y = round((evt.index[0] - margin) / cell_size)
-        
-        if 0 <= x < self.game.size and 0 <= y < self.game.size:
-            self.hover_pos = (x, y)
+        if 0 <= row < self.game.size and 0 <= col < self.game.size:
+            self.hover_pos = (row, col)
         else:
             self.hover_pos = None
             
@@ -298,13 +284,13 @@ def create_interface():
     
     with gr.Blocks(theme=gr.themes.Soft()) as interface:
         gr.Markdown("""
-        # Go Game vs AI
+        # Go Game vs AI  
         Play the ancient game of Go against an AI opponent. Black plays first.
         
-        Rules:
-        - Click on any intersection to place a stone
-        - Capture enemy stones by surrounding them
-        - Stones must have liberties (empty adjacent points) to survive
+        **Rules:**  
+        - Click on any intersection to place a stone.  
+        - Capture enemy stones by surrounding them.  
+        - Stones must have liberties (empty adjacent points) to survive.
         """)
         
         with gr.Row():
@@ -324,21 +310,21 @@ def create_interface():
                 )
             
             with gr.Column(scale=1):
-                with gr.Group():
-                    difficulty = gr.Radio(
-                        choices=[d.value for d in Difficulty],
-                        value=Difficulty.EASY.value,
-                        label="AI Difficulty"
-                    )
-                    reset_btn = gr.Button("Reset Game", variant="secondary")
+                difficulty = gr.Radio(
+                    choices=[d.value for d in Difficulty],
+                    value=Difficulty.EASY.value,
+                    label="AI Difficulty"
+                )
+                reset_btn = gr.Button("Reset Game", variant="secondary")
         
-        # Handle clicks and hover
-        board_output.click(
+        # Use .select() for click events on the interactive image.
+        board_output.select(
             game.process_click,
             inputs=[board_output, difficulty],
             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,
@@ -354,4 +340,4 @@ def create_interface():
 
 if __name__ == "__main__":
     interface = create_interface()
-    interface.launch()
+    interface.launch()