Update app.py

app.py

@@ -2,7 +2,145 @@ import random
 import numpy as np
 import gradio as gr
 
-[Previous TicTacToe, MinimaxPlayer, and QLearningPlayer classes remain exactly the same]
+class TicTacToe:
+    def __init__(self):
+        self.board = [' '] * 9
+        self.current_player = 'X'
+
+    def display_board(self):
+        print("\n")
+        for i in range(3):
+            print(" | ".join(self.board[i * 3:(i + 1) * 3]))
+            if i < 2:
+                print("---------")
+        print("\n")
+
+    def make_move(self, position):
+        if self.board[position] == ' ':
+            self.board[position] = self.current_player
+            return True
+        return False
+
+    def switch_player(self):
+        self.current_player = 'O' if self.current_player == 'X' else 'X'
+
+    def check_winner(self):
+        winning_combinations = [
+            [0, 1, 2], [3, 4, 5], [6, 7, 8],  # Rows
+            [0, 3, 6], [1, 4, 7], [2, 5, 8],  # Columns
+            [0, 4, 8], [2, 4, 6]              # Diagonals
+        ]
+        for combo in winning_combinations:
+            if self.board[combo[0]] == self.board[combo[1]] == self.board[combo[2]] != ' ':
+                return self.board[combo[0]]
+        return None
+
+    def is_draw(self):
+        return ' ' not in self.board
+
+    def reset_board(self):
+        self.board = [' '] * 9
+        self.current_player = 'X'
+
+class MinimaxPlayer:
+    def __init__(self, symbol):
+        self.symbol = symbol
+
+    def minimax(self, game, is_maximizing):
+        winner = game.check_winner()
+        if winner == self.symbol:
+            return 1
+        elif winner == ('O' if self.symbol == 'X' else 'X'):
+            return -1
+        elif game.is_draw():
+            return 0
+
+        if is_maximizing:
+            best_score = -float('inf')
+            for i in range(9):
+                if game.board[i] == ' ':
+                    game.board[i] = self.symbol
+                    score = self.minimax(game, False)
+                    game.board[i] = ' '
+                    best_score = max(score, best_score)
+            return best_score
+        else:
+            best_score = float('inf')
+            for i in range(9):
+                if game.board[i] == ' ':
+                    game.board[i] = ('O' if self.symbol == 'X' else 'X')
+                    score = self.minimax(game, True)
+                    game.board[i] = ' '
+                    best_score = min(score, best_score)
+            return best_score
+
+    def get_move(self, game):
+        best_score = -float('inf')
+        best_move = None
+        for i in range(9):
+            if game.board[i] == ' ':
+                game.board[i] = self.symbol
+                score = self.minimax(game, False)
+                game.board[i] = ' '
+                if score > best_score:
+                    best_score = score
+                    best_move = i
+        return best_move
+
+class QLearningPlayer:
+    def __init__(self, symbol, learning_rate=0.1, discount_factor=0.9, exploration_rate=1.0):
+        self.symbol = symbol
+        self.q_table = {}
+        self.learning_rate = learning_rate
+        self.discount_factor = discount_factor
+        self.exploration_rate = exploration_rate
+
+    def get_state(self, game):
+        return ''.join(game.board)
+
+    def choose_action(self, game):
+        state = self.get_state(game)
+        if random.random() < self.exploration_rate:
+            return random.choice([i for i in range(9) if game.board[i] == ' '])
+        if state not in self.q_table:
+            self.q_table[state] = np.zeros(9)
+        return np.argmax(self.q_table[state])
+
+    def update_q_table(self, state, action, reward, next_state):
+        if state not in self.q_table:
+            self.q_table[state] = np.zeros(9)
+        if next_state not in self.q_table:
+            self.q_table[next_state] = np.zeros(9)
+        self.q_table[state][action] += self.learning_rate * (
+            reward + self.discount_factor * np.max(self.q_table[next_state]) - self.q_table[state][action]
+        )
+
+    def train(self, episodes):
+        for _ in range(episodes):
+            game = TicTacToe()
+            state = self.get_state(game)
+            while True:
+                action = self.choose_action(game)
+                game.make_move(action)
+                next_state = self.get_state(game)
+                winner = game.check_winner()
+                if winner == self.symbol:
+                    reward = 1
+                    self.update_q_table(state, action, reward, next_state)
+                    break
+                elif winner:
+                    reward = -1
+                    self.update_q_table(state, action, reward, next_state)
+                    break
+                elif game.is_draw():
+                    reward = 0.5
+                    self.update_q_table(state, action, reward, next_state)
+                    break
+                else:
+                    reward = 0
+                    self.update_q_table(state, action, reward, next_state)
+                    game.switch_player()
+                    state = next_state
 
 # Global game instance
 game = TicTacToe()
@@ -27,7 +165,6 @@ def make_move(evt: gr.SelectData, game_mode, difficulty):
     """Handle player moves and AI responses"""
     row, col = evt.index
     position = row * 3 + col
-    status = ""
     
     # Human move
     if game.board[position] == ' ':
@@ -86,7 +223,6 @@ def create_gui():
                 value="medium"
             )
         
-        # Fixed DataFrame initialization
         board = gr.DataFrame(
             render_board(),
             headers=[""]*3,  # Empty headers for 3 columns