Update app.py

app.py

@@ -2,72 +2,84 @@ import gradio as gr
 import numpy as np
 from game_logic import my_agent, Configuration, Observation
 
+# Constants
+EMPTY = 0
+PLAYER = 1
+AI = 2
+SYMBOLS = {EMPTY: "⚪", PLAYER: "🔴", AI: "🟡"}
+BOARD_SIZE = (6, 7)
+WIN_LENGTH = 4
+
 def initialize_game():
-    return np.zeros((6, 7), dtype=int)
+    return np.zeros(BOARD_SIZE, dtype=int)
 
 def make_move(board, column, player):
-    """Make a move on the board"""
-    for row in range(5, -1, -1):
-        if board[row][column] == 0:
-            board[row][column] = player
-            return board
+    """Make a move on the board - returns None if invalid move"""
+    row = np.where(board[:, column] == EMPTY)[0]
+    if len(row) == 0:
+        return None
+    board[row[-1], column] = player
     return board
 
-def format_board(board):
-    """Convert board to player-friendly visualization"""
-    symbols = {0: "⚪", 1: "🔴", 2: "🟡"}
-    return [[symbols[cell] for cell in row] for row in board]
-
 def check_winner(board):
-    """Check if there's a winner"""
-    board = np.array(board)
-    
-    def check_line(line):
-        return (len(line) >= 4 and 
-                (any(np.all(line[i:i+4] == 1) for i in range(len(line)-3)) or
-                 any(np.all(line[i:i+4] == 2) for i in range(len(line)-3))))
-
+    """Optimized winner check using numpy operations"""
     # Horizontal
-    for row in board:
-        if check_line(row):
-            return True
+    for row in range(BOARD_SIZE[0]):
+        for col in range(BOARD_SIZE[1] - WIN_LENGTH + 1):
+            window = board[row, col:col + WIN_LENGTH]
+            if np.all(window == PLAYER) or np.all(window == AI):
+                return True
 
     # Vertical
-    for col in board.T:
-        if check_line(col):
-            return True
+    for row in range(BOARD_SIZE[0] - WIN_LENGTH + 1):
+        for col in range(BOARD_SIZE[1]):
+            window = board[row:row + WIN_LENGTH, col]
+            if np.all(window == PLAYER) or np.all(window == AI):
+                return True
 
     # Diagonals
-    for offset in range(-2, 4):
-        diag = np.diagonal(board, offset)
-        if check_line(diag):
-            return True
-        diag = np.diagonal(np.fliplr(board), offset)
-        if check_line(diag):
-            return True
-
+    for row in range(BOARD_SIZE[0] - WIN_LENGTH + 1):
+        for col in range(BOARD_SIZE[1] - WIN_LENGTH + 1):
+            # Positive diagonal
+            window = board[range(row, row + WIN_LENGTH), range(col, col + WIN_LENGTH)]
+            if np.all(window == PLAYER) or np.all(window == AI):
+                return True
+            # Negative diagonal
+            window = board[range(row, row + WIN_LENGTH), range(col + WIN_LENGTH - 1, col - 1, -1)]
+            if np.all(window == PLAYER) or np.all(window == AI):
+                return True
+    
     return False
 
+def format_board(board):
+    """Convert board to emoji representation"""
+    return [[SYMBOLS[cell] for cell in row] for row in board]
+
 def play_game(board, col, state):
     if state["game_over"]:
         return board, "Game is over! Click 'New Game' to play again."
     
-    # Convert Dataframe to numpy array for game logic
-    board_array = np.array([[0 if cell == "⚪" else 1 if cell == "🔴" else 2 for cell in row] 
-                           for row in board.values.tolist()])
+    # Convert display format to game logic format
+    board_array = np.array([[0 if cell == SYMBOLS[EMPTY] else 
+                            1 if cell == SYMBOLS[PLAYER] else 2 
+                            for cell in row] for row in board.values.tolist()])
     
     # Player move
-    board_array = make_move(board_array, col, 1)
+    new_board = make_move(board_array.copy(), col, PLAYER)
+    if new_board is None:
+        return format_board(board_array), "Invalid move! Try again."
+    board_array = new_board
+    
     if check_winner(board_array):
         state["game_over"] = True
         return format_board(board_array), "You win! 🎉"
     
     # AI move
-    config = Configuration({"rows": 6, "columns": 7, "inarow": 4})
-    obs = Observation({"board": board_array.flatten().tolist(), "mark": 2})
+    config = Configuration({"rows": BOARD_SIZE[0], "columns": BOARD_SIZE[1], "inarow": WIN_LENGTH})
+    obs = Observation({"board": board_array.flatten().tolist(), "mark": AI})
     
     ai_col = my_agent(obs, config)
-    board_array = make_move(board_array, ai_col, 2)
+    board_array = make_move(board_array, ai_col, AI)
     
     if check_winner(board_array):
         state["game_over"] = True
@@ -75,15 +87,43 @@ def play_game(board, col, state):
     
     return format_board(board_array), "Your turn!"
 
+css = """
+#board {
+    max-width: 400px;
+    margin: 20px auto;
+}
+#board table {
+    width: 100%;
+    table-layout: fixed;
+}
+#board td {
+    text-align: center;
+    font-size: 32px;
+    padding: 12px;
+    width: 14.28%;
+}
+.button-row {
+    max-width: 400px;
+    margin: 0 auto;
+    display: flex;
+    justify-content: space-between;
+    gap: 10px;
+}
+.button-row button {
+    flex: 1;
+    min-width: 40px;
+}
+"""
+
 def create_ui():
     with gr.Blocks(css=css) as demo:
         gr.Markdown("# Play Connect Four Against AI")
-        gr.Markdown("You are Red (🔴), AI is Yellow (🟡)")
+        gr.Markdown(f"You are {SYMBOLS[PLAYER]}, AI is {SYMBOLS[AI]}")
         
         state = gr.State({"game_over": False})
         
         with gr.Row(elem_classes="button-row"):
-            buttons = [gr.Button(str(i), size="sm") for i in range(7)]
+            buttons = [gr.Button(str(i), size="sm") for i in range(BOARD_SIZE[1])]
         
         board = gr.Dataframe(
             value=format_board(initialize_game()),
@@ -92,8 +132,8 @@ def create_ui():
             headers=False,
             wrap=True,
             elem_id="board",
-            row_count=6,
-            col_count=7
+            row_count=BOARD_SIZE[0],
+            col_count=BOARD_SIZE[1]
         )
         
         message = gr.Textbox(value="Your turn!", label="Status")
@@ -117,34 +157,5 @@ def create_ui():
     
     return demo
 
-# CSS definition
-css = """
-#board {
-    max-width: 400px;
-    margin: 20px auto;
-}
-#board table {
-    width: 100%;
-    table-layout: fixed;
-}
-#board td {
-    text-align: center;
-    font-size: 32px;
-    padding: 12px;
-    width: 14.28%;  /* 100% / 7 columns */
-}
-.button-row {
-    max-width: 400px;
-    margin: 0 auto;
-    display: flex;
-    justify-content: space-between;
-    gap: 10px;
-}
-.button-row button {
-    flex: 1;
-    min-width: 40px;
-}
-"""
-
 demo = create_ui()
 demo.launch()