Add checking for terminal node in the alpha-beta search

melvic-ybanez · Mar 11, 2019 · d27461c · d27461c
1 parent e0c3bcc
commit d27461c
Show file tree

Hide file tree

Showing 4 changed files with 53 additions and 25 deletions.
diff --git a/src/controllers/GameController.scala b/src/controllers/GameController.scala
@@ -123,7 +123,7 @@ case class DefaultGameController(
         val movedBoard = task.getValue
         val accessor = boardAccessor.updatedBoard(movedBoard)
         val move = movedBoard.lastMove.get
-        val piece = movedBoard(move.destination).get
+        val piece = boardAccessor.board(move.source).get
         handleMoveResult(accessor.accessorMove(move),
           piece, accessor, movedBoard.isCheckmate(sideToMove))
       }
@@ -155,12 +155,13 @@ case class DefaultGameController(
     historyView.addMove(accessorMove, boardAccessor.board, piece)
     boardAccessor = accessor
     boardView.resetBoard(false)
+
     boardView.animateMove {
       if (checkmate) gameOver(sideToMove, "checkmate")
       undoneBoards.clear()
+      sideToMove = sideToMove.opposite
       if (computerToMove) computerMove()
     }
-    sideToMove = sideToMove.opposite
   }
 
   override def undo() = _undo(historyBoards, undoneBoards)

diff --git a/src/engine/board/bitboards/Bitboard.scala b/src/engine/board/bitboards/Bitboard.scala
@@ -255,7 +255,7 @@ case class Bitboard(bitsets: Vector[U64],
     val loosingSide = winningSide.opposite
     val piecesToMove = Pawn :: Knight :: Bishop :: Rook :: Queen :: King :: Nil
 
-    !piecesToMove.exists { pieceType =>
+    isChecked(loosingSide) && !piecesToMove.exists { pieceType =>
       val piece = Piece(pieceType, loosingSide)
       val pieceIndexes = toSquareIndexes(pieceBitset(piece))
       pieceIndexes.exists { squareIndex =>
@@ -301,4 +301,21 @@ case class Bitboard(bitsets: Vector[U64],
 
   override def pieceLocations(piece: Piece) =
     toSquareIndexes(pieceBitset(piece)).map(intToLocation)
+
+  override def toString = {
+    def sideString: Side => String = List("W", "B")(_)
+    def pieceTypeString: PieceType => String = "PNBRQK"(_).toString
+    val space = " " * 2
+
+    val squareStrings = (0 until 64).foldLeft[List[String]](Nil) { (acc, i) =>
+      val squareString = this(i).map { case Piece(pieceType, side) =>
+        sideString(side) + pieceTypeString(pieceType)
+      } getOrElse ("_" * space.length)
+
+      if (i % Board.Size == 0) squareString :: acc
+      else acc.head + space + squareString :: acc.tail
+    }
+
+    squareStrings.mkString("\n")
+  }
 }
diff --git a/src/engine/movegen/bitboards/PawnMoveGenerator.scala b/src/engine/movegen/bitboards/PawnMoveGenerator.scala
@@ -76,7 +76,7 @@ object PawnMoveGenerator extends BitboardMoveGenerator with PostShiftOneStep {
       moves flatMap { case move@(pawnMove, _) =>
         val moveBitset: PawnMove => U64 = _(pawnBitset, getTargets(bitboard, sideToMove), sideToMove)
 
-        val promotionMasks = 0xff000000000000L :: 0xff00L :: Nil
+        val promotionMasks = 0x00ff000000000000L :: 0xff00L :: Nil
         val promote = isNonEmptySet(promotionMasks(sideToMove) & pawnBitset)
 
         if (promote)

diff --git a/src/engine/search/AlphaBeta.scala b/src/engine/search/AlphaBeta.scala
@@ -1,8 +1,7 @@
 package engine.search
 
-import engine.board.{Board, Piece, Side}
+import engine.board._
 import engine.eval.Evaluator
-import engine.movegen.Move.LocationMove
 
 import scala.annotation.tailrec
 
@@ -24,34 +23,45 @@ sealed trait AlphaBeta {
     * @param depth remaining depth in the search tree
     * @return A pair consisting of the evaluation score and the chosen next move.
     */
-  def search(board: Board, side: Side, currentScore: Double, bound: Double, depth: Int): (Double, Board) =
-    if (depth == 0) (evaluateBoard(board, side), board)
-    else {
-      @tailrec
-      def recurse(bestScore: Double,
-          nextBoard: Board, updatedBoards: Stream[Board]): (Double, Board) = updatedBoards match {
-        case Stream() => (bestScore, nextBoard)
-        case updatedBoard +: nextMoves =>
-          val (score, _) = opponent.search(updatedBoard,
-            side.opposite,
-            bound, bestScore,   // params positions switched
-            depth - 1)
-
-          if (cutOffBound(score, bound)) (bound, updatedBoard)
-          else if (isBetterScore(score, bestScore)) recurse(score, updatedBoard, nextMoves)
-          else recurse(bestScore, nextBoard, nextMoves)
-      }
+  def search(board: Board, side: Side, currentScore: Double, bound: Double, depth: Int): (Double, Board) = {
+    lazy val result = (evaluateBoard(board, side), board)
 
-      recurse(currentScore, board, {
+    if (depth == 0) result
+    else {
+      val validMoves = {
         // Apply all the moves
         val moves = board.generateMoves(side).map { case (move, piece) =>
           board.updateByMove(move, piece)
         }
 
         // Only include moves that do not leave the king checked
         moves.filter(!_.isChecked(side))
-      })
+      }
+
+      validMoves match {
+        // This is a terminal node, return immediately
+        case Stream() => result
+
+        case _ =>
+          @tailrec
+          def recurse(bestScore: Double,
+            nextBoard: Board, updatedBoards: Stream[Board]): (Double, Board) = updatedBoards match {
+            case Stream() => (bestScore, nextBoard)
+            case updatedBoard +: nextMoves =>
+              val (score, _) = opponent.search(updatedBoard,
+                side.opposite,
+                bound, bestScore, // params positions switched
+                depth - 1)
+
+              if (cutOffBound(score, bound)) (bound, updatedBoard)
+              else if (isBetterScore(score, bestScore)) recurse(score, updatedBoard, nextMoves)
+              else recurse(bestScore, nextBoard, nextMoves)
+          }
+
+          recurse(currentScore, board, validMoves)
+      }
     }
+  }
 }
 
 object AlphaBeta {