Faster board evaluation

Author: replomancer

src/swordfight/ai.clj

@@ -10,7 +10,8 @@
                                       black-king black-queen black-rook
                                       black-bishop black-knight black-pawn
                                       empty-square white black
-                                      piece-type ->piece]]
+                                      piece-type ->piece move-piece
+                                      notation->coords]]
             #_[taoensso.tufte :refer [defnp p profiled profile]]
             #_[swordfight.profiling]))
 
@@ -102,6 +103,14 @@
                  (for [[y x] all-coords]
                    [(get-in board [y x]) [y x]]))))
 
+(defn board-value-delta [board board' move]
+  (let [[move-from move-to] move
+        [from-pos to-pos] [move-from (subs move-to 0 2)]
+        [from-idx to-idx] (map notation->coords [from-pos to-pos])]
+    (- (piece-val-with-bonus (get-in board' to-idx) to-idx)
+       (piece-val-with-bonus (get-in board to-idx) to-idx)
+       (piece-val-with-bonus (get-in board from-idx) from-idx))))
+
 (def checkmated-val {white -100000  black 100000})
 (defn stalemated-val [board] (/ (eval-board board) 4))
 
@@ -113,10 +122,23 @@
 
 (defn move-evaluation [game-state alpha beta depth piece-move]
   (let [state-after-move (move game-state piece-move)
+        extra-board-changes (not= (:board state-after-move)
+                                  (first (move-piece (:board game-state)
+                                                     piece-move)))
+        evaled-state-after-move (assoc state-after-move
+                                       :board-value
+                                       (if extra-board-changes
+                                         ;; full board reevaluation only after
+                                         ;; castling, en passant and promotions
+                                         (eval-board (:board state-after-move))
+                                         (+ (:board-value game-state)
+                                            (board-value-delta (:board game-state)
+                                                               (:board state-after-move)
+                                                               piece-move))))
         move-value (if (or (= depth 1) @hurried-move)
-                     (eval-board (:board state-after-move))
+                     (:board-value evaled-state-after-move)
                      (second
-                      (best-move state-after-move alpha beta (dec depth))))]
+                      (best-move evaled-state-after-move alpha beta (dec depth))))]
     [piece-move move-value]))
 
 (defn best-move [{:keys [board turn] :as game-state} alpha beta depth]
@@ -172,8 +194,10 @@
 
 (defn computer-move [game-state]
   (let [moves-cnt (:moves-cnt game-state)
+        board-value (eval-board (:board game-state))
+        evaled-board-game-state (assoc game-state :board-value board-value)
         [square-from square-to] (if (and (< moves-cnt early-game-turns)
                                          (false? (:edited game-state)))
-                                  (early-move game-state)
-                                  (midgame-move game-state))]
+                                  (early-move evaled-board-game-state)
+                                  (midgame-move evaled-board-game-state))]
     [square-from square-to]))

src/swordfight/game_rules.clj

@@ -213,7 +213,7 @@
               [last-m-from last-m-to last-moved-piece] (:last-move game-state)
               [[last-m-from-y _] [last-m-to-y last-m-to-x]]
               (map notation->coords [last-m-from last-m-to])]
-          ;; We assume here the moves being made are (pseudo)legal:
+          ;; We assume here the moves being made are pseudolegal:
           (if (and (pawn? last-moved-piece)
                    (= (Math/abs (- last-m-from-y last-m-to-y)) 2)
                    (= last-m-to-y from-y)

test/swordfight/ai_test.clj

@@ -2,7 +2,7 @@
   (:require [midje.sweet :refer [facts fact has-prefix]]
             [swordfight.board :refer [white black ->board
                                       white-pawn black-pawn white-king]]
-            [swordfight.ai :refer [midgame-move]]))
+            [swordfight.ai :refer [midgame-move eval-board]]))
 
 (facts "about en passant moves"
   (let [board (->board [" . . . . k . . . "
@@ -15,7 +15,7 @@
                         " . . . . K . . . "])
         en-passant-move ["b4" "a3"]
         game-state {:board board :turn black :last-move ["a2" "a4" white-pawn]
-                    :moves-cnt 0}]
+                    :moves-cnt 0 :board-value (eval-board board)}]
     (fact "Engine makes an en passant move in an obvious scenario"
       (midgame-move game-state) => (has-prefix [en-passant-move])))
 
@@ -28,7 +28,8 @@
                         " . . . . . . . . "
                         " . . . . K . . . "])
         forward-move ["b4" "b3"]
-        game-state {:board board :turn black :last-move ["a3" "a4" white-pawn] :moves-cnt 0}]
+        game-state {:board board :turn black :last-move ["a3" "a4" white-pawn]
+                    :moves-cnt 0 :board-value (eval-board board)}]
     (fact "Engine makes an obvious best move when en passant not possible"
       (midgame-move game-state) => (has-prefix [forward-move]))))
 
@@ -51,7 +52,7 @@
                          " . q . . K . . . "])
         promotion-move ["b2" "b1q"]
         game-state {:board board :turn black :last-move ["a5" "a6" white-pawn]
-                    :moves-cnt 10}]
+                    :moves-cnt 10 :board-value (eval-board board)}]
     (fact "Engine promotes pawns to queens"
       (midgame-move game-state) => (has-prefix [promotion-move])))
 
@@ -73,7 +74,7 @@
                          " R N n . . . . . "])
         promotion-move ["c2" "c1n"]
         game-state {:board board :turn black :last-move ["b3" "a2" white-king]
-                    :moves-cnt 10}]
+                    :moves-cnt 10 :board-value (eval-board board)}]
     (fact "Engine promotes pawns to knights"
       (midgame-move game-state) => (has-prefix [promotion-move]))))
 
@@ -96,6 +97,6 @@
                          " R N . . . . . . "])
         regular-pawn-attack ["g2" "h3"]
         game-state {:board board :turn white :last-move ["h4" "h3" black-pawn]
-                    :moves-cnt 10}]
+                    :moves-cnt 10 :board-value (eval-board board)}]
     (fact "Engine chooses to attack with pawn"
       (midgame-move game-state) => (has-prefix [regular-pawn-attack]))))