Update app.py

app.py

@@ -3,11 +3,13 @@ import gradio as gr
 from llama_cpp import Llama
 from huggingface_hub import hf_hub_download
 import numpy as np
+from typing import List
+import re
 
 model = Llama(
     model_path=hf_hub_download(
-        repo_id=os.environ.get("REPO_ID", "Lyte/QuadConnect2.5-0.5B-v0.0.6b"),#"Lyte/QuadConnect2.5-0.5B-v0.0.5b"),
-        filename=os.environ.get("MODEL_FILE", "quadconnect.Q8_0.gguf"),#"unsloth.Q8_0.gguf"),
+        repo_id=os.environ.get("REPO_ID", "Lyte/QuadConnect2.5-0.5B-v0.0.6b"),
+        filename=os.environ.get("MODEL_FILE", "quadconnect.Q8_0.gguf"),
     ),
     n_ctx=16384
 )
@@ -35,11 +37,95 @@ Specify the column letter (a–g) for your next move.
 </move>
 """
 
+def extract_xml_move(text: str) -> str:
+    """
+    Extracts the move (a single column letter a–g) from the XML format
+    using regex.
+    """
+    match = re.search(r'<move>\s*([a-g])\s*</move>', text)
+    if match:
+        return match.group(1)
+    return ""
+
+def convert_moves_to_coordinate_list(moves_list: List[str]) -> str:
+    """
+    Converts a list of moves to a coordinate list representation.
+    Each move is formatted as <column><row>(<piece>).
+    Returns "Empty Board" if no moves are present.
+    """
+    # Create an empty 6x7 grid (row 1 is at index 0)
+    grid = [['.' for _ in range(7)] for _ in range(6)]
+    
+    for i, move in enumerate(moves_list):
+        if not move:
+            continue
+        col = ord(move[0]) - ord('a')
+        # Find the lowest available row in this column:
+        for row in range(6):
+            if grid[row][col] == '.':
+                grid[row][col] = 'X' if i % 2 == 0 else 'O'
+                break
+    
+    # Build coordinate list: Only include cells with a piece
+    coords = []
+    for row in range(6):
+        for col in range(7):
+            if grid[row][col] != '.':
+                # Convert row index to board row number (row 0 -> 1, etc.)
+                coords.append(f"{chr(col + ord('a'))}{row+1}({grid[row][col]})")
+    
+    return ", ".join(coords) if coords else "Empty Board"
+
+def parse_coordinate_list(board_str: str) -> List[List[str]]:
+    """
+    Converts a coordinate list representation (e.g., "a1(O), a2(X), b1(O)")
+    into a 6x7 grid (list of lists) with row index 0 as the bottom.
+    """
+    grid = [['.' for _ in range(7)] for _ in range(6)]
+    if not board_str.strip() or board_str == "Empty Board":
+        return grid
+        
+    coords = board_str.split(",")
+    for coord in coords:
+        coord = coord.strip()
+        # Expecting format: a1(O)
+        if len(coord) < 4:
+            continue
+        col_letter = coord[0]
+        try:
+            row_number = int(coord[1])
+        except ValueError:
+            continue
+        piece = coord[3]  # The piece inside the parentheses
+        col = ord(col_letter) - ord('a')
+        row = row_number - 1
+        if 0 <= row < 6 and 0 <= col < 7:
+            grid[row][col] = piece
+    return grid
+
+def get_available_positions(grid: List[List[str]]) -> str:
+    """Returns the next available position (lowest empty spot) for each column."""
+    available = []
+    for col in range(7):
+        col_letter = chr(ord('a') + col)
+        # Search from bottom (row 0) to top (row 5)
+        next_pos = None
+        for row in range(6):
+            if grid[row][col] == '.':  # Found empty spot
+                next_pos = f"{col_letter}{row + 1}"  # +1 because grid is 0-based
+                break
+        if next_pos:  # Only add if column isn't full
+            available.append(f"{col_letter}: {next_pos}")
+    
+    return "\n  ".join(available)  # Format with newlines and indentation
+
 class ConnectFour:
     def __init__(self):
         self.board = np.zeros((6, 7))
         self.current_player = 1  # 1 for player (X), 2 for AI (O)
         self.game_over = False
+        self.player_moves = []
+        self.ai_moves = []
         
     def make_move(self, col):
         if self.game_over:
@@ -47,9 +133,17 @@ class ConnectFour:
             
         # Find the lowest empty row in the selected column
         for row in range(5, -1, -1):
-            if self.board[row][col] == 0:
-                self.board[row][col] = self.current_player
-                return True, row
+            if self.board[5-row][col] == 0:  # Flip the row index to match the display
+                self.board[5-row][col] = self.current_player
+                
+                # Record the move
+                move = f"{chr(ord('a') + col)}{row+1}"
+                if self.current_player == 1:
+                    self.player_moves.append(move)
+                else:
+                    self.ai_moves.append(move)
+                    
+                return True, 5-row
         return False, -1
 
     def check_winner(self):
@@ -96,7 +190,17 @@ class ConnectFour:
                     row_num = str(6 - row)  # Convert to 1-based indexing
                     piece = "X" if self.board[row][col] == 1 else "O"
                     moves.append(f"{col_letter}{row_num}({piece})")
-        return ", ".join(moves) if moves else ""
+        return ", ".join(moves) if moves else "Empty Board"
+    
+    def get_grid_from_board(self):
+        grid = [['.' for _ in range(7)] for _ in range(6)]
+        for row in range(6):
+            for col in range(7):
+                if self.board[row][col] == 1:
+                    grid[5-row][col] = 'X'  # Convert to the format used by helper functions
+                elif self.board[row][col] == 2:
+                    grid[5-row][col] = 'O'
+        return grid
 
     def parse_ai_move(self, move_str):
         # Parse move like 'a', 'b', etc.
@@ -107,6 +211,25 @@ class ConnectFour:
             return -1
         except:
             return -1
+    
+    def format_game_state(self):
+        board_str = self.board_to_string()
+        grid = self.get_grid_from_board()
+        available_positions = get_available_positions(grid)
+        
+        # Format the player and AI moves
+        player_moves_str = ", ".join(self.player_moves) if self.player_moves else ""
+        ai_moves_str = ", ".join(self.ai_moves) if self.ai_moves else ""
+        
+        return f"""Game State:
+- You are playing as: O
+- Your previous moves: {ai_moves_str}
+- Opponent's moves: {player_moves_str}
+- Current board state: {board_str}
+- Next available position per column:
+  {available_positions}
+
+Make your move."""
 
 def create_interface():
     game = ConnectFour()
@@ -228,15 +351,15 @@ def create_interface():
             
             # AI move
             game.current_player = 2
-            board_state = game.board_to_string()
             
-            prompt = f"Current board state (you are O, opponent is X):\n{board_state}\n\nMake your move."
+            # Format game state using the new format
+            game_state = game.format_game_state()
             
             # Get AI response
             response = model.create_chat_completion(
                 messages=[
                     {"role": "system", "content": SYSTEM_PROMPT},
-                    {"role": "user", "content": prompt}
+                    {"role": "user", "content": game_state}
                 ],
                 temperature=0.8,
                 top_p=0.95,
@@ -249,7 +372,11 @@ def create_interface():
             # Extract reasoning and move
             try:
                 reasoning = ai_response.split("<reasoning>")[1].split("</reasoning>")[0].strip()
-                move_str = ai_response.split("<move>")[1].split("</move>")[0].strip()
+                move_str = extract_xml_move(ai_response)
+                
+                if not move_str:
+                    raise ValueError("Invalid move format from AI")
+                
                 ai_col = game.parse_ai_move(move_str)
                 
                 if ai_col == -1:
@@ -298,6 +425,8 @@ def create_interface():
             game.board = np.zeros((6, 7))
             game.current_player = 1
             game.game_over = False
+            game.player_moves = []
+            game.ai_moves = []
             return [
                 render_board(),
                 "Your turn! Click a button to drop your piece!",