Create app.py

app.py

@@ -0,0 +1,213 @@
+import gradio as gr
+import numpy as np
+from enum import Enum
+import random
+
+class Difficulty(Enum):
+    EASY = "Easy"
+    MEDIUM = "Medium"
+    HARD = "Hard"
+
+class GoGame:
+    def __init__(self, size=9):
+        self.size = size
+        self.board = np.zeros((size, size))
+        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
+    
+    # Draw grid lines
+    for i in range(board.shape[0]):
+        image[i, :] = [150, 150, 150]
+        image[:, i] = [150, 150, 150]
+    
+    # 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]
+    
+    return image
+
+class GradioGoGame:
+    def __init__(self):
+        self.game = GoGame()
+        self.difficulty = Difficulty.EASY
+    
+    def make_move(self, x, y, difficulty):
+        if x is None or y is None:
+            return create_board_image(self.game.board), "Invalid move"
+        
+        x, y = int(x), int(y)
+        self.difficulty = Difficulty(difficulty)
+        
+        if not self.game.make_move(x, y):
+            return create_board_image(self.game.board), "Invalid move"
+        
+        # AI move
+        ai_move = self.game.ai_move(self.difficulty)
+        if ai_move is None:
+            return create_board_image(self.game.board), "Game Over"
+        
+        return create_board_image(self.game.board), f"AI moved to: {ai_move}"
+    
+    def reset_game(self):
+        self.game = GoGame()
+        return create_board_image(self.game.board), "Game reset"
+
+def create_interface():
+    game = GradioGoGame()
+    
+    with gr.Blocks() as interface:
+        gr.Markdown("# Go Game vs AI")
+        
+        with gr.Row():
+            with gr.Column():
+                board_output = gr.Image(
+                    create_board_image(game.game.board),
+                    shape=(400, 400),
+                    label="Go Board"
+                )
+                msg_output = gr.Textbox(label="Message", value="Click on the board to make a move")
+            
+            with gr.Column():
+                x_input = gr.Number(label="X coordinate (0-8)")
+                y_input = gr.Number(label="Y coordinate (0-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.click(
+            game.make_move,
+            inputs=[x_input, y_input, difficulty],
+            outputs=[board_output, msg_output]
+        )
+        
+        reset_btn.click(
+            game.reset_game,
+            outputs=[board_output, msg_output]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()