Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import numpy as np
 from enum import Enum
 import random
+import cv2
 
 class Difficulty(Enum):
     EASY = "Easy"
@@ -15,135 +16,62 @@ class GoGame:
         self.current_player = 1  # 1 for black, -1 for white
         self.last_move = None
         self.pass_count = 0
-        
-    def is_valid_move(self, x, y):
-        if x < 0 or x >= self.size or y < 0 or y >= self.size:
-            return False
-        if self.board[x][y] != 0:
-            return False
-        # Make move temporarily to check for suicide rule
-        self.board[x][y] = self.current_player
-        has_liberties = self.has_liberties(x, y)
-        self.board[x][y] = 0
-        return has_liberties
-    
-    def get_neighbors(self, x, y):
-        neighbors = []
-        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
-            nx, ny = x + dx, y + dy
-            if 0 <= nx < self.size and 0 <= ny < self.size:
-                neighbors.append((nx, ny))
-        return neighbors
-    
-    def has_liberties(self, x, y):
-        color = self.board[x][y]
-        checked = set()
-        
-        def check_group(x, y):
-            if (x, y) in checked:
-                return False
-            checked.add((x, y))
-            
-            for nx, ny in self.get_neighbors(x, y):
-                if self.board[nx][ny] == 0:
-                    return True
-                if self.board[nx][ny] == color and check_group(nx, ny):
-                    return True
-            return False
-        
-        return check_group(x, y)
-    
-    def make_move(self, x, y):
-        if not self.is_valid_move(x, y):
-            return False
-        
-        self.board[x][y] = self.current_player
-        self.last_move = (x, y)
-        self.pass_count = 0
-        self.current_player *= -1
-        return True
-    
-    def ai_move(self, difficulty):
-        if difficulty == Difficulty.EASY:
-            return self.random_move()
-        elif difficulty == Difficulty.MEDIUM:
-            return self.medium_move()
-        else:
-            return self.hard_move()
-    
-    def random_move(self):
-        valid_moves = []
-        for i in range(self.size):
-            for j in range(self.size):
-                if self.is_valid_move(i, j):
-                    valid_moves.append((i, j))
-        
-        if not valid_moves:
-            return None
-        
-        move = random.choice(valid_moves)
-        self.make_move(*move)
-        return move
-    
-    def medium_move(self):
-        # Medium difficulty tries to play near the last human move
-        if self.last_move is None:
-            return self.random_move()
-        
-        last_x, last_y = self.last_move
-        for radius in range(1, self.size):
-            valid_moves = []
-            for dx in range(-radius, radius + 1):
-                for dy in range(-radius, radius + 1):
-                    if abs(dx) + abs(dy) == radius:
-                        x, y = last_x + dx, last_y + dy
-                        if 0 <= x < self.size and 0 <= y < self.size and self.is_valid_move(x, y):
-                            valid_moves.append((x, y))
-            
-            if valid_moves:
-                move = random.choice(valid_moves)
-                self.make_move(*move)
-                return move
-        
-        return self.random_move()
-    
-    def hard_move(self):
-        # Hard difficulty tries to control the center and corners
-        center = self.size // 2
-        priority_moves = [
-            (center, center),
-            (1, 1), (1, self.size-2), (self.size-2, 1), (self.size-2, self.size-2),
-            (center, 1), (1, center), (center, self.size-2), (self.size-2, center)
-        ]
-        
-        for x, y in priority_moves:
-            if self.is_valid_move(x, y):
-                self.make_move(x, y)
-                return (x, y)
-        
-        return self.medium_move()
 
 def create_board_image(board):
-    # Convert board to RGB image
-    image = np.zeros((board.shape[0], board.shape[1], 3), dtype=np.uint8)
-    image.fill(222)  # Wooden background color
+    # Create a larger base image (19x19 cells, each 40 pixels)
+    cell_size = 40
+    margin = 30
+    total_size = board.shape[0] * cell_size + 2 * margin
+    
+    # Create base image with wooden texture color
+    image = np.full((total_size, total_size, 3), [219, 179, 119], dtype=np.uint8)
     
     # Draw grid lines
     for i in range(board.shape[0]):
-        image[i, :] = [150, 150, 150]
-        image[:, i] = [150, 150, 150]
+        # Vertical lines
+        cv2.line(image,
+                 (margin + i * cell_size, margin),
+                 (margin + i * cell_size, total_size - margin),
+                 (0, 0, 0),
+                 1)
+        # Horizontal lines
+        cv2.line(image,
+                 (margin, margin + i * cell_size),
+                 (total_size - margin, margin + i * cell_size),
+                 (0, 0, 0),
+                 1)
     
     # Draw stones
     for i in range(board.shape[0]):
         for j in range(board.shape[1]):
-            if board[i, j] == 1:  # Black stone
-                image[i, j] = [0, 0, 0]
-            elif board[i, j] == -1:  # White stone
-                image[i, j] = [255, 255, 255]
+            if board[i, j] != 0:
+                center = (margin + j * cell_size, margin + i * cell_size)
+                color = (0, 0, 0) if board[i, j] == 1 else (255, 255, 255)
+                # Draw stone with anti-aliasing
+                cv2.circle(image, center, 15, color, -1, cv2.LINE_AA)
+                # Add a shine effect for 3D appearance
+                if board[i, j] == -1:  # Only for white stones
+                    cv2.circle(image,
+                             (center[0] - 3, center[1] - 3),
+                             5,
+                             (240, 240, 240),
+                             -1,
+                             cv2.LINE_AA)
     
-    # Scale the image up for better visibility
-    scaled_image = np.repeat(np.repeat(image, 40, axis=0), 40, axis=1)
-    return scaled_image
+    # Draw star points (hoshi)
+    star_points = []
+    if board.shape[0] == 9:
+        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),
+                  3,
+                  (0, 0, 0),
+                  -1,
+                  cv2.LINE_AA)
+    
+    return image
 
 class GradioGoGame:
     def __init__(self):
@@ -154,7 +82,13 @@ class GradioGoGame:
         if x is None or y is None:
             return create_board_image(self.game.board), "Invalid move"
         
-        x, y = int(x), int(y)
+        try:
+            x, y = int(x), int(y)
+            if x < 0 or x >= self.game.size or y < 0 or y >= self.game.size:
+                return create_board_image(self.game.board), "Invalid coordinates"
+        except:
+            return create_board_image(self.game.board), "Invalid input"
+        
         self.difficulty = Difficulty(difficulty)
         
         if not self.game.make_move(x, y):
@@ -178,25 +112,25 @@ def create_interface():
         gr.Markdown("# Go Game vs AI")
         
         with gr.Row():
-            with gr.Column():
+            with gr.Column(scale=2):
                 board_output = gr.Image(
                     value=create_board_image(game.game.board),
                     label="Go Board",
-                    height=360,
-                    width=360
+                    height=500,
+                    width=500
                 )
-                msg_output = gr.Textbox(label="Message", value="Click on the board to make a move")
+                msg_output = gr.Textbox(label="Message", value="Enter coordinates and click Make Move")
             
-            with gr.Column():
-                x_input = gr.Number(label="X coordinate (0-8)")
-                y_input = gr.Number(label="Y coordinate (0-8)")
+            with gr.Column(scale=1):
+                x_input = gr.Number(label="X coordinate (0-8)", minimum=0, maximum=8)
+                y_input = gr.Number(label="Y coordinate (0-8)", minimum=0, maximum=8)
                 difficulty = gr.Radio(
                     choices=[d.value for d in Difficulty],
                     value=Difficulty.EASY.value,
                     label="Difficulty"
                 )
-                move_btn = gr.Button("Make Move")
-                reset_btn = gr.Button("Reset Game")
+                move_btn = gr.Button("Make Move", variant="primary")
+                reset_btn = gr.Button("Reset Game", variant="secondary")
         
         move_btn.click(
             game.make_move,