Create stockfish.py

fairy/stockfish.py

@@ -0,0 +1,266 @@
+import chess
+import time
+import math
+
+class ComplexMaiaEngine:
+    def __init__(self, skill_level=3):
+        # Default skill_level = 3 (~1300 Elo). Max = 20 (2000+ Elo conceptually, throttled by Python speed)
+        self.skill_level = max(1, min(20, skill_level))
+        self.nodes_visited = 0
+        
+        # Piece values for Evaluation
+        self.PIECE_VALUES = {
+            chess.PAWN: 100,
+            chess.KNIGHT: 320,
+            chess.BISHOP: 330,
+            chess.ROOK: 500,
+            chess.QUEEN: 900,
+            chess.KING: 20000
+        }
+
+        # Piece-Square Tables (Heuristics for positional strength)
+        self.PAWN_TABLE = [
+            0,  0,  0,  0,  0,  0,  0,  0,
+            50, 50, 50, 50, 50, 50, 50, 50,
+            10, 10, 20, 30, 30, 20, 10, 10,
+             5,  5, 10, 25, 25, 10,  5,  5,
+             0,  0,  0, 20, 20,  0,  0,  0,
+             5, -5,-10,  0,  0,-10, -5,  5,
+             5, 10, 10,-20,-20, 10, 10,  5,
+             0,  0,  0,  0,  0,  0,  0,  0
+        ]
+
+        self.KNIGHT_TABLE = [
+            -50,-40,-30,-30,-30,-30,-40,-50,
+            -40,-20,  0,  0,  0,  0,-20,-40,
+            -30,  0, 10, 15, 15, 10,  0,-30,
+            -30,  5, 15, 20, 20, 15,  5,-30,
+            -30,  0, 15, 20, 20, 15,  0,-30,
+            -30,  5, 10, 15, 15, 10,  5,-30,
+            -40,-20,  0,  5,  5,  0,-20,-40,
+            -50,-40,-30,-30,-30,-30,-40,-50
+        ]
+
+        self.BISHOP_TABLE = [
+            -20,-10,-10,-10,-10,-10,-10,-20,
+            -10,  0,  0,  0,  0,  0,  0,-10,
+            -10,  0,  5, 10, 10,  5,  0,-10,
+            -10,  5,  5, 10, 10,  5,  5,-10,
+            -10,  0, 10, 10, 10, 10,  0,-10,
+            -10, 10, 10, 10, 10, 10, 10,-10,
+            -10,  5,  0,  0,  0,  0,  5,-10,
+            -20,-10,-10,-10,-10,-10,-10,-20
+        ]
+
+        self.ROOK_TABLE = [
+              0,  0,  0,  0,  0,  0,  0,  0,
+              5, 10, 10, 10, 10, 10, 10,  5,
+             -5,  0,  0,  0,  0,  0,  0, -5,
+             -5,  0,  0,  0,  0,  0,  0, -5,
+             -5,  0,  0,  0,  0,  0,  0, -5,
+             -5,  0,  0,  0,  0,  0,  0, -5,
+             -5,  0,  0,  0,  0,  0,  0, -5,
+              0,  0,  0,  5,  5,  0,  0,  0
+        ]
+
+        self.QUEEN_TABLE = [
+            -20,-10,-10, -5, -5,-10,-10,-20,
+            -10,  0,  0,  0,  0,  0,  0,-10,
+            -10,  0,  5,  5,  5,  5,  0,-10,
+             -5,  0,  5,  5,  5,  5,  0, -5,
+              0,  0,  5,  5,  5,  5,  0, -5,
+            -10,  5,  5,  5,  5,  5,  0,-10,
+            -10,  0,  5,  0,  0,  0,  0,-10,
+            -20,-10,-10, -5, -5,-10,-10,-20
+        ]
+
+        # King Middle-game position table
+        self.KING_TABLE = [
+            -30,-40,-40,-50,-50,-40,-40,-30,
+            -30,-40,-40,-50,-50,-40,-40,-30,
+            -30,-40,-40,-50,-50,-40,-40,-30,
+            -30,-40,-40,-50,-50,-40,-40,-30,
+            -20,-30,-30,-40,-40,-30,-30,-20,
+            -10,-20,-20,-20,-20,-20,-20,-10,
+             20, 20,  0,  0,  0,  0, 20, 20,
+             20, 30, 10,  0,  0, 10, 30, 20
+        ]
+
+    def set_skill_level(self, level):
+        self.skill_level = max(1, min(20, level))
+
+    def evaluate_board(self, board):
+        """ Statically evaluates the board layout. Positive = White advantage """
+        if board.is_checkmate():
+            if board.turn == chess.WHITE:
+                return -99999  # Black wins
+            else:
+                return 99999   # White wins
+        if board.is_stalemate() or board.is_insufficient_material():
+            return 0
+
+        score = 0
+        
+        # Material and Positional Scanning
+        for square in chess.SQUARES:
+            piece = board.piece_at(square)
+            if piece:
+                piece_type = piece.piece_type
+                value = self.PIECE_VALUES[piece_type]
+                
+                # Dynamic adjustment based on skill level
+                # Lower skill levels simulate poor board evaluation
+                if self.skill_level < 5 and piece_type in [chess.KNIGHT, chess.BISHOP]:
+                    value -= 15  # Tweak values down to skew strategic choice
+
+                # Positional Table Additions
+                table_score = 0
+                square_idx = square if piece.color == chess.WHITE else chess.square_mirror(square)
+                
+                if piece_type == chess.PAWN: table_score = self.PAWN_TABLE[square_idx]
+                elif piece_type == chess.KNIGHT: table_score = self.KNIGHT_TABLE[square_idx]
+                elif piece_type == chess.BISHOP: table_score = self.BISHOP_TABLE[square_idx]
+                elif piece_type == chess.ROOK: table_score = self.ROOK_TABLE[square_idx]
+                elif piece_type == chess.QUEEN: table_score = self.QUEEN_TABLE[square_idx]
+                elif piece_type == chess.KING: table_score = self.KING_TABLE[square_idx]
+
+                # Blunder emulation for low ELO
+                if self.skill_level <= 3 and time.time() % 7 == 0:
+                    table_score = -table_score  # Intentionally value positional squares wrong occasionally
+
+                if piece.color == chess.WHITE:
+                    score += (value + table_score)
+                else:
+                    score -= (value + table_score)
+        
+        return score
+
+    def order_moves(self, board, moves):
+        """ Evaluates moves early to maximize Alpha-Beta Pruning Efficiency """
+        scored_moves = []
+        for move in moves:
+            score = 0
+            # Prioritize captures
+            if board.is_capture(move):
+                captured = board.piece_at(move.to_square)
+                attacker = board.piece_at(move.from_square)
+                if captured and attacker:
+                    score += 10 * self.PIECE_VALUES[captured.piece_type] - self.PIECE_VALUES[attacker.piece_type]
+            
+            # Prioritize promotions
+            if move.promotion:
+                score += 900
+                
+            # Avoid putting pieces in danger
+            if board.is_attacked_by(not board.turn, move.to_square):
+                score -= self.PIECE_VALUES[board.piece_at(move.from_square).piece_type] if board.piece_at(move.from_square) else 50
+                
+            scored_moves.append((score, move))
+            
+        # High skill level gets perfect move ordering, low skill level gets chaotic ordering
+        if self.skill_level > 8:
+            scored_moves.sort(key=lambda x: x[0], reverse=True)
+            
+        return [move for score, move in scored_moves]
+
+    def alpha_beta(self, board, depth, alpha, beta, maximizing_player):
+        """ Core Decision Engine Process """
+        self.nodes_visited += 1
+        
+        if depth == 0 or board.is_game_over():
+            return self.evaluate_board(board)
+
+        legal_moves = self.order_moves(board, board.legal_moves)
+
+        if maximizing_player:
+            max_eval = -math.inf
+            for move in legal_moves:
+                board.push(move)
+                evaluation = self.alpha_beta(board, depth - 1, alpha, beta, False)
+                board.pop()
+                max_eval = max(max_eval, evaluation)
+                alpha = max(alpha, evaluation)
+                if beta <= alpha:
+                    break # Beta Pruning
+            return max_eval
+        else:
+            min_eval = math.inf
+            for move in legal_moves:
+                board.push(move)
+                evaluation = self.alpha_beta(board, depth - 1, alpha, beta, True)
+                board.pop()
+                min_eval = min(min_eval, evaluation)
+                beta = min(beta, evaluation)
+                if beta <= alpha:
+                    break # Alpha Pruning
+            return min_eval
+
+    def select_best_move(self, board):
+        """ Calculates optimal choice utilizing an Iterative Deepening technique """
+        self.nodes_visited = 0
+        best_move = None
+        
+        # Determine strict search depths based on Skill Level
+        # Level 3 targets Depth 3 (Solid ~1300 ELO play)
+        if self.skill_level <= 3:
+            target_depth = 3
+        elif self.skill_level <= 8:
+            target_depth = 4
+        else:
+            target_depth = 5 # Maximum depth for pure Python before lag starts hitting hard
+
+        legal_moves = self.order_moves(board, board.legal_moves)
+        
+        if not legal_moves:
+            return None
+
+        # Fallback default
+        best_move = legal_moves[0]
+        
+        # Iterative Deepening wrapper loop
+        for current_depth in range(1, target_depth + 1):
+            if board.turn == chess.WHITE:
+                best_value = -math.inf
+                for move in legal_moves:
+                    board.push(move)
+                    board_value = self.alpha_beta(board, current_depth - 1, -math.inf, math.inf, False)
+                    board.pop()
+                    if board_value > best_value:
+                        best_value = board_value
+                        best_move = move
+            else:
+                best_value = math.inf
+                for move in legal_moves:
+                    board.push(move)
+                    board_value = self.alpha_beta(board, current_depth - 1, -math.inf, math.inf, True)
+                    board.pop()
+                    if board_value < best_value:
+                        best_value = board_value
+                        best_move = move
+                        
+        print(f"Skill Level: {self.skill_level} | Evaluated {self.nodes_visited} Positions | Best Move: {best_move}")
+        return best_move
+
+# ==============================================================================
+# LOCAL EXECUTION DEMONSTRATION
+# ==============================================================================
+if __name__ == "__main__":
+    # Initialize the engine at default skill level 3 (approx. 1300 ELO)
+    engine = ComplexMaiaEngine(skill_level=3)
+    game_board = chess.Board()
+
+    print("--- Local Engine Game Simulation (First 3 Turns) ---")
+    print(game_board)
+    
+    # Simulate a couple of turns to show the code functions correctly
+    for turn in range(3):
+        # White Move (Engine)
+        print("\nEngine Calculating...")
+        chosen_move = engine.select_best_move(game_board)
+        game_board.push(chosen_move)
+        print(game_board)
+        
+        # Adjust skill slider on the fly to simulate switching behavior
+        if turn == 1:
+            print("\n!!! Level Scaled Up to MAX (20) !!!")
+            engine.set_skill_level(20)