Update selfchess.py

selfchess.py

@@ -5,6 +5,8 @@ import chess
 import os
 import chess.engine as eng
 import torch.multiprocessing as mp
+import random
+from pathlib import Path
 
 # CONFIGURATION
 CONFIG = {
@@ -117,23 +119,55 @@ def get_evaluation(board):
     else:
         return -evaluation
 
-def search(board, depth, alpha, beta):
+def search(board, depth, simulations=100):
     """
-    A negamax search function.
+    Monte Carlo Tree Search with basic negamax evaluation.
+    Reads moves from san_moves.txt and picks the best move.
     """
-    if depth == 0 or board.is_game_over():
-        return get_evaluation(board)
+    # Load predefined moves from SAN file
+    san_file_path = Path("ChessEnv/san_moves.txt")
+    if san_file_path.exists():
+        with open(san_file_path, "r") as f:
+            san_moves = [line.strip() for line in f if line.strip()]
+    else:
+        san_moves = []
+
+    def negamax(board, depth, alpha, beta):
+        if depth == 0 or board.is_game_over():
+            return get_evaluation(board)
+
+        max_eval = float('-inf')
+        for move in board.legal_moves:
+            board.push(move)
+            eval = -negamax(board, depth - 1, -beta, -alpha)
+            board.pop()
+            max_eval = max(max_eval, eval)
+            alpha = max(alpha, eval)
+            if alpha >= beta:
+                break
+        return max_eval
+
+    move_scores = {}
 
-    max_eval = float('-inf')
-    for move in board.legal_moves:
+    for _ in range(simulations):
+        # Optionally start from a random legal move (Monte Carlo rollout)
+        move = random.choice(list(board.legal_moves))
+        
+        # If san_moves.txt is not empty, prefer moves from it when possible
+        move_san = board.san(move)
+        if san_moves and move_san in san_moves:
+            move = chess.Move.from_uci(board.parse_san(move_san).uci())
+        
         board.push(move)
-        eval = -search(board, depth - 1, -beta, -alpha)
+        score = -negamax(board, depth - 1, -float('inf'), float('inf'))
         board.pop()
-        max_eval = max(max_eval, eval)
-        alpha = max(alpha, eval)
-        if alpha >= beta:
-            break
-    return max_eval
+
+        move_scores[move] = move_scores.get(move, 0) + score
+
+    # Pick move with highest average score
+    best_move = max(move_scores.items(), key=lambda x: x[1] / simulations)[0]
+    return best_move
+