Create ai.py

ai.py

@@ -0,0 +1,129 @@
+# ai.py
+import numpy as np
+from game_logic import (
+    get_possible_moves, get_empty_cells, evaluate_board, 
+    is_game_over, DIRECTIONS
+ )
+import time
+
+# Cache: key=board_tuple, value=score
+# Use tuple(board.flatten()) as key because arrays are not hashable
+cache = {} 
+SEARCH_DEPTH = 4 # <<<===== START WITH 3 or 4. 6 WILL BE VERY SLOW/TIMEOUT!
+MAX_CACHE_SIZE = 50000 # Prevent memory explosion
+
+def clear_cache():
+     global cache
+     # Simple cache clearing if it gets too big
+     if len(cache) > MAX_CACHE_SIZE:
+        print(f"Clearing cache ({len(cache)})")
+        cache = {}
+     # Or just clear every top-level call:
+     # cache = {}
+
+
+# Expectimax: alternates between player (max) and chance (avg) nodes
+def expectimax(board: np.ndarray, depth: int, is_player_turn: bool) -> float:
+    """
+    Recursive Expectimax search.
+    Returns the heuristic score for the given board state and depth.
+    """
+    board_tuple = tuple(board.flatten())
+    # Cache lookup: include depth to ensure we don't reuse a shallow search result for a deep one
+    cache_key = (board_tuple, depth, is_player_turn)
+    if cache_key in cache:
+       return cache[cache_key]
+
+    # Base Cases
+    if depth == 0 or is_game_over(board):
+        return evaluate_board(board)
+
+    # --- Player's Turn (Maximize) ---
+    if is_player_turn:
+        best_score = -float('inf')
+        possible_moves = get_possible_moves(board)
+        if not possible_moves:
+             return evaluate_board(board) # Game over / stuck
+             
+        for move_info in possible_moves:
+            # Recursively call for chance node after player move
+            score = expectimax(move_info['board'], depth - 1, False)
+            # Add score gained directly by this move? evaluate_board can also include it.
+            # score += move_info['score'] 
+            if score > best_score:
+                best_score = score
+        cache[cache_key] = best_score
+        return best_score
+
+    # --- Chance Node's Turn (Average / Expectation) ---
+    else: 
+        avg_score = 0.0
+        empty_cells = get_empty_cells(board)
+        if not empty_cells:
+           # This state should technically not be reached if the player move was valid, 
+           # but handle defensively.
+           return evaluate_board(board)
+
+        # Calculate expected score over all possible random tile placements
+        prob_2 = 0.9 / len(empty_cells)
+        prob_4 = 0.1 / len(empty_cells)
+        
+        for r, c in empty_cells:
+            # Case 1: Add a '2' tile
+            board[r, c] = 2
+            avg_score += prob_2 * expectimax(board, depth - 1, True) # Player's turn next
+            
+            # Case 2: Add a '4' tile
+            board[r, c] = 4
+            avg_score += prob_4 * expectimax(board, depth - 1, True) # Player's turn next
+            
+            board[r, c] = 0 # backtrack / reset cell for next iteration
+            
+        cache[cache_key] = avg_score
+        return avg_score
+
+def find_best_move(board: np.ndarray, depth: int) -> str:
+    """
+    Entry point for the AI. Finds the best move from the current board.
+    """
+    start_time = time.time()
+    clear_cache() # Clear cache for each new top-level request
+    
+    best_score = -float('inf')
+    best_move = 'g' # Default to game over
+    
+    possible_moves = get_possible_moves(board)
+     
+    if not possible_moves:
+         print("AI: No possible moves.")
+         return 'g' # Game over
+
+    # Evaluate each possible first move
+    # Note: depth here applies to the search *after* this first move
+    for move_info in possible_moves:
+         # Start recursion: after player move, it's the chance node's turn
+         # Use depth, not depth-1, because this is the root
+         score = expectimax(move_info['board'], depth , False)
+         # score += move_info['score'] # Optional: add immediate score gain
+         print(f"  Move {move_info['dir']}: Score {score:.2f}")
+         if score > best_score:
+            best_score = score
+            best_move = move_info['dir']
+            
+    # Fallback if all moves lead to terrible scores, just pick the first valid one
+    if best_move == 'g' and possible_moves:
+        best_move = possible_moves[0]['dir']
+
+    duration = time.time() - start_time
+    print(f"AI Decision: {best_move} (Score: {best_score:.2f}, Depth: {depth}, Time: {duration:.4f}s, Cache: {len(cache)})")
+    return best_move
+
+# Adjust depth based on board state (optional but good)
+def get_dynamic_depth(board):
+    empty = len(get_empty_cells(board))
+    # Use deeper search when fewer choices, shallower when many choices
+    if empty <= 4:
+        return SEARCH_DEPTH + 1 
+    #if empty >= 10:
+    #   return max(2, SEARCH_DEPTH -1)
+    return SEARCH_DEPTH