Update app.py

app.py

@@ -1,106 +1,84 @@
 import gradio as gr
 import random
 
-# Simulated AI models for checkers (replace these with actual AI model imports later)
-from transformers import pipeline  # Example for using real AI models
-
-class BasicAI:
-    def move(self, board):
-        # Basic AI makes a random valid move
-        valid_moves = self.get_valid_moves(board)
-        return random.choice(valid_moves) if valid_moves else None
-
-    def get_valid_moves(self, board):
-        # Simulate valid moves as random pairs of coordinates
-        return [(random.randint(0, 7), random.randint(0, 7)) for _ in range(random.randint(1, 5))]
-
-class AdvancedAI:
-    def move(self, board):
-        # Advanced AI prioritizes moves with a placeholder strategy
-        valid_moves = self.get_valid_moves(board)
-        return valid_moves[0] if valid_moves else None
-
-    def get_valid_moves(self, board):
-        # Simulate valid moves as random pairs of coordinates
-        return [(random.randint(0, 7), random.randint(0, 7)) for _ in range(random.randint(1, 5))]
-
-# Replace BasicAI and AdvancedAI with actual models (example Hugging Face pipelines)
-ai_models = {
-    "Basic AI": BasicAI(),
-    "Advanced AI": AdvancedAI(),
-    "HuggingFace AI 1": pipeline("text-generation", model="gpt2"),
-    "HuggingFace AI 2": pipeline("text-generation", model="EleutherAI/gpt-neo-1.3B")
-}
-
-def play_ai_vs_ai(ai1_name, ai2_name, rounds):
-    ai1 = ai_models[ai1_name]
-    ai2 = ai_models[ai2_name]
-
-    board = [["." for _ in range(8)] for _ in range(8)]  # Simplified 8x8 board
-    history = []
-
-    for i in range(rounds):
-        ai1_move = ai1.move(board) if hasattr(ai1, 'move') else "Simulated AI 1 Move"
-        ai2_move = ai2.move(board) if hasattr(ai2, 'move') else "Simulated AI 2 Move"
-        history.append(f"Round {i + 1}: {ai1_name} -> {ai1_move}, {ai2_name} -> {ai2_move}")
-
-    return "\n".join(history)
-
-def render_board():
-    board_html = "<table style='border-collapse: collapse; width: 100px; height: 100px;'>"
-    for i in range(8):
-        board_html += "<tr>"
-        for j in range(8):
-            color = "#f0d9b5" if (i + j) % 2 == 0 else "#b58863"
-            board_html += f"<td style='width: 40px; height: 40px; background-color: {color}; border: 1px solid black;'></td>"
-        board_html += "</tr>"
-    board_html += "</table>"
-    return board_html
-
-# Gradio Interface
-def build_interface():
-    with gr.Blocks() as interface:
-        gr.Markdown("""
-        # AI vs AI Checkers Game
-        Watch different AI models compete against each other in a simulated game of checkers. Select the models and number of rounds to see how they perform!
-        """)
-
-        with gr.Row():
-            ai1_dropdown = gr.Dropdown(choices=list(ai_models.keys()), label="Select AI Model for Player 1", value="Basic AI")
-            ai2_dropdown = gr.Dropdown(choices=list(ai_models.keys()), label="Select AI Model for Player 2", value="Advanced AI")
-
-        rounds_slider = gr.Slider(minimum=1, maximum=20, step=1, value=5, label="Number of Rounds")
-
-        with gr.Row():
-            start_button = gr.Button("Start AI vs AI")
-
-        output_box = gr.Textbox(label="Game History", lines=10)
-        board_output = gr.HTML(render_board(), label="Checkers Board")
-
-        start_button.click(
-            play_ai_vs_ai,
-            inputs=[ai1_dropdown, ai2_dropdown, rounds_slider],
-            outputs=[output_box]
-        )
-
-        gr.HTML("""
-        <div style='margin-top: 20px;'>
-            <h3>Game Board</h3>
-            <div>""" + render_board() + """</div>
-        </div>
-        """)
-
-        gr.Markdown("""
-        ### How It Works
-        - **Basic AI**: Makes random valid moves.
-        - **Advanced AI**: Uses a placeholder strategy to prioritize specific moves.
-        - **HuggingFace AI Models**: These use text generation pipelines for creative move generation.
+# Initialize board, pieces, and game state
+class CheckersGame:
+    def __init__(self):
+        self.board = self.create_board()
+        self.turn = 'white'  # White goes first
+        self.game_over = False
+
+    def create_board(self):
+        board = [['' for _ in range(8)] for _ in range(8)]
+        # Initialize the pieces
+        for row in range(3):
+            for col in range(row % 2, 8, 2):
+                board[row][col] = 'red'
+        for row in range(5, 8):
+            for col in range(row % 2, 8, 2):
+                board[row][col] = 'white'
+        return board
+
+    def make_move(self):
+        # AI logic: Random move for the sake of simplicity
+        if self.game_over:
+            return self.board, "Game Over! Restart to play again."
         
-        Select models, adjust the rounds, and press "Start AI vs AI" to see the results!
-        """)
-
-    return interface
-
-# Launch the app
-interface = build_interface()
-interface.launch()
+        valid_moves = self.get_valid_moves(self.turn)
+        if valid_moves:
+            move = random.choice(valid_moves)
+            self.board[move[2]][move[3]] = self.board[move[0]][move[1]]
+            self.board[move[0]][move[1]] = ''
+            self.turn = 'white' if self.turn == 'red' else 'red'
+            return self.board, f"{self.turn.capitalize()} moved."
+        else:
+            self.game_over = True
+            return self.board, f"Game Over! {self.turn.capitalize()} has no moves left."
+
+    def get_valid_moves(self, color):
+        valid_moves = []
+        for row in range(8):
+            for col in range(8):
+                if self.board[row][col] == color:
+                    # Check all directions for valid moves (simplified)
+                    directions = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
+                    for dr, dc in directions:
+                        new_row, new_col = row + dr, col + dc
+                        if 0 <= new_row < 8 and 0 <= new_col < 8 and self.board[new_row][new_col] == '':
+                            valid_moves.append((row, col, new_row, new_col))
+        return valid_moves
+
+    def render_board(self):
+        board_repr = ''
+        for row in self.board:
+            board_repr += ' '.join([cell[0].upper() if cell else '.' for cell in row]) + '\n'
+        return board_repr
+
+# Create a Checkers game instance
+game = CheckersGame()
+
+# Function to handle the game move and display
+def play_checkers():
+    board, status = game.make_move()
+    return game.render_board(), status
+
+# Gradio interface
+def create_ui():
+    with gr.Blocks() as demo:
+        gr.Markdown("## AI vs AI - Watch the Game!")
+        
+        # Display the board and game status
+        with gr.Row():
+            board_display = gr.Textbox(label="Game Board", interactive=False, value=game.render_board())
+            game_status = gr.Textbox(label="Game Status", interactive=False, value="Game is running...")
+
+        # Button to simulate a move and update the board
+        play_button = gr.Button("AI makes a move")
+        play_button.click(play_checkers, outputs=[board_display, game_status])
+    
+    return demo
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    ui = create_ui()
+    ui.launch(share=True)