feat: boardAfter

vincentfrochot · vincentfrochot · commit 763e0db44fb1 · 2024-10-25T09:13:03.000+02:00
diff --git a/src/main/scala/abalone/Move.scala b/src/main/scala/abalone/Move.scala
@@ -16,7 +16,7 @@ case class Move(
 ) extends Action(situationBefore, after, metrics) {
 
   def situationAfter =
-    Situation(finalizeAfter, if (autoEndTurn) !piece.player else piece.player)
+    Situation(finalizeAfter, !piece.player)
 
   def applyVariantEffect: Move = before.variant addVariantEffect this
 
diff --git a/src/main/scala/abalone/variant/Variant.scala b/src/main/scala/abalone/variant/Variant.scala
@@ -4,7 +4,7 @@ import cats.data.Validated
 import cats.syntax.option._
 import scala.annotation.nowarn
 
-import strategygames.{ GameFamily, Player }
+import strategygames.{ GameFamily, Player, Score }
 import strategygames.abalone._
 import strategygames.abalone.format.FEN
 
@@ -106,34 +106,33 @@ abstract class Variant private[variant] (
     val activePlayerPieces = situation.board.piecesOf(situation.player)
     val opponentPieces = situation.board.piecesOf(!situation.player)
 
-    def createMove(orig: Pos, dest: Pos, category: String): (String, Move) =
-      (category, Move(Piece(situation.player, Role.defaultRole), orig, dest, situation, boardAfter(situation, orig, dest), true, if (category == "pushout") Some(dest) else None))
+    def createMove(category: String, orig: Pos, dest: Pos, directions: List[String] = List()): (String, Move) =
+      (category, Move(Piece(situation.player, Role.defaultRole), orig, dest, situation, boardAfter(situation, orig, dest, directions), true, if (category == "pushout") Some(dest) else None))
 
     def generateSideMoves(lineOfMarbles: List[Pos], direction: Option[String]): List[(String, Move)] = {
-      def canMoveTowards(pos: Pos, dir: String): Boolean = {
-        situation.board.isEmptySquare(pos.dir(dir))
-      }
+      def canMoveTowards(pos: Pos, direction: String): Boolean = situation.board.isEmptySquare(pos.dir(direction))
 
-      def possibleSideMoves: List[(Pos, Pos)] = Pos.sideMovesDirsFromDir(direction).map(
+      def possibleSideMoves: List[(Pos, Pos, String)] = Pos.sideMovesDirsFromDir(direction).map(
         dir =>
           if (lineOfMarbles.map(
             (pos) => canMoveTowards(pos, dir)
           ).contains(false)) None
           else (
             lineOfMarbles.headOption,
-            lineOfMarbles.reverse.headOption.flatMap(_.dir(dir))
+            lineOfMarbles.reverse.headOption.flatMap(_.dir(dir)),
+            dir
           ) match {
-            case (Some(head), Some(tail)) => Some( (head, tail) )
+            case ( (Some(head), Some(tail), dir) ) => Some( (head, tail, dir) )
             case _ => None
           }
       ).flatten
 
-    List(
+      List(
         if (lineOfMarbles.size == 3) generateSideMoves(lineOfMarbles.dropRight(1), direction) else List(),
         possibleSideMoves.flatMap {
-            case ( (orig, dest) ) => Some(createMove(orig, dest, "side"))
-            case _ => None
-          }
+          case ( (orig, dest, dir) ) => Some(createMove("side", orig, dest, List(dir, direction.getOrElse("")))) // @TODO: get rid of this getOrElse. was added for quick testing purpose
+          case _ => None
+        }
       ).flatten
     }
 
@@ -143,30 +142,30 @@ abstract class Variant private[variant] (
         neighbour.dir(direction).toList.flatMap {
           case (thirdSquareInLine) => {
             if (situation.board.isEmptySquare(Some(thirdSquareInLine))) // xx.
-              Some(createMove(pos, thirdSquareInLine, "line"))
+              Some(createMove("line", pos, thirdSquareInLine))
             else if (opponentPieces.contains(thirdSquareInLine)) // xxo
               thirdSquareInLine.dir(direction) match { // xxo?
-                case None => Some(createMove(pos, thirdSquareInLine, "pushout")) // xxo\
+                case None => Some(createMove("pushout", pos, thirdSquareInLine, List(direction.getOrElse("")))) // xxo\  // @TODO: get rid of this getOrElse. was added for quick testing purpose
                 case Some(emptySquare) if situation.board.isEmptySquare(Some(emptySquare)) => {
-                  Some(createMove(pos, thirdSquareInLine, "push")) // xxo.
+                  Some(createMove("push", pos, thirdSquareInLine, List(direction.getOrElse("")))) // xxo. // @TODO: get rid of this getOrElse. was added for quick testing purpose
                 }
                 case _ => None
               }
             else if (activePlayerPieces.contains(thirdSquareInLine)) // xxx
               thirdSquareInLine.dir(direction).flatMap {
                 case (fourthSquareInLine) => // xxx_
                   if (situation.board.isEmptySquare(Some(fourthSquareInLine))) // xxx.
-                    Some(createMove(pos, fourthSquareInLine, "line"))
+                    Some(createMove("line", pos, fourthSquareInLine))
                   else if (opponentPieces.contains(fourthSquareInLine)) // xxxo
                     fourthSquareInLine.dir(direction) match { // xxxo?
-                      case None => Some(createMove(pos, fourthSquareInLine, "pushout")) // xxxo\
-                      case Some(emptyPos) if (situation.board.isEmptySquare(Some(emptyPos))) => Some(createMove(pos, fourthSquareInLine, "push")) // xxxo.
+                      case None => Some(createMove("pushout", pos, fourthSquareInLine, List(direction.getOrElse("")))) // xxxo\ // @TODO: get rid of this getOrElse. was added for quick testing purpose
+                      case Some(emptyPos) if (situation.board.isEmptySquare(Some(emptyPos))) => Some(createMove("push", pos, fourthSquareInLine, List(direction.getOrElse("")))) // xxxo. // @TODO: get rid of this getOrElse. was added for quick testing purpose
                       case _ => fourthSquareInLine.dir(direction).flatMap { // xxxo?
                         case (fifthSquareInLine) =>
                           if (opponentPieces.contains(fifthSquareInLine)) // xxxoo
                             fifthSquareInLine.dir(direction) match {
-                              case None => Some(createMove(pos, fourthSquareInLine, "pushout")) // xxxoo\
-                              case Some(emptySquare) if situation.board.isEmptySquare(Some(emptySquare)) => Some(createMove(pos, emptySquare, "push")) // xxxoo.
+                              case None => Some(createMove("pushout", pos, fourthSquareInLine, List(direction.getOrElse("")))) // xxxoo\ // @TODO: get rid of this getOrElse. was added for quick testing purpose
+                              case Some(emptySquare) if situation.board.isEmptySquare(Some(emptySquare)) => Some(createMove("push", pos, emptySquare, List(direction.getOrElse("")))) // xxxoo. // @TODO: get rid of this getOrElse. was added for quick testing purpose
                               case _ => None
                             }
                           else None
@@ -193,72 +192,86 @@ abstract class Variant private[variant] (
           case (pos, neighbour) =>
             generateMovesForNeighbours(pos, neighbour)
         }).view.toList
-      }
+    }
   }
 
-  // @TODO: would be interesting to pass the direction so we can easily differenciate a side move from a line move (orig meets dest in case of line move)
-  def boardAfter(situation: Situation, orig: Pos, dest: Pos): Board = {
+  def boardAfter(situation: Situation, orig: Pos, dest: Pos, directions: List[String] = List()): Board = {
     // 1. move pieces and get the score
-    val (pieces, capture)   = piecesAfterAction(situation.board.pieces, situation.player, orig, dest)
-
-    // 2. update the board
-    situation.board.copy(
-      pieces = pieces,
-      history = History(
-        situation.history.currentTurn,
-        situation.history.currentTurn, // @TODO: fix this, understand how to create the new Uci with the move being played
-        situation.history.positionHashes,
-        if (capture) situation.history.score.add(situation.player) else situation.history.score,
-        situation.history.halfMoveClock + 1
+    val (pieces, capture)   = piecesAfterAction(situation.board.pieces, orig, dest, directions)
+    val score = Score(situation.history.score.p1, situation.history.score.p2)
+
+    val boardAfter = situation.board.copy(pieces = pieces)
+    boardAfter.withHistory(
+      situation.history.copy(
+        // @TODO: lastTurn handled on Move.finalizeAfter to keep consistency with other gamelogics ?
+        score = if (capture) score.add(situation.player) else score,
+        halfMoveClock = situation.board.history.halfMoveClock + 1 // situation.player.fold(0, 1)
       )
     )
   }
 
-  // @TODO: adapt
+  // @TODO: rewrite this code properly as it's currently full of get()
   // will take care of moving the marbles and determine if a capture has been made
-  def piecesAfterAction(pieces: PieceMap, player: Player, @nowarn orig: Pos, dest: Pos): (PieceMap, Boolean) = {
+  private def piecesAfterAction(pieces: PieceMap, orig: Pos, dest: Pos, directions: List[String]): (PieceMap, Boolean) = {
     var capture = false
+    var updatedPieceMap: PieceMap = Map()
 
     /*
-
-        * * * * *
-       * a A B C 1
-      * * * * * 2 *
-      How to move pieces based on orig and dest :
-        1. identify the type of move :
-          - push : dest contains a marble (orig=C, dest=a)
-          - line move : orig meets dest thanks to the direction we passed as extra parameter
-          - side move : NOT a push or a side move
+      How to move pieces based on orig, dest, and direction :
+        1. identify the type of move
+          - line move : no direction to apply (a line move is just 1 marble moving)
+          - push : 1 direction, and dest contains a marble
+          - side move : 2 direction:
+              - HEAD will contain the direction to apply to move from orig to dest
+              - TAIL will contain the direction to apply to each marble for doing effectively the side move
 
         2. play the move
           - line move :
-              - move from orig to dest
+              - move from orig to dest, without considering the direction
           - push :
             - dest contains a marble
-            - we know the direction :
+            - we have the direction :
               - apply the direction from dest until there is an empty square or being off the board
                 - in case of being off the board, increment the score (capture = true)
               - do the line move (orig to dest)
           - side move :
-            - apply the direction to orig and dest : but still have to find the marble in the middle in case of a move of 3 marbles ?
-    
-      in case of a side move, orig=A and dest=1, how do we determine how to move A and B ?
-    
+            - we received both directions :s
+              - 1st direction : we know how to move through all these marbles from orig to dest
+              - 2nd direction : we know what direction we want to apply to all these 2 or 3 marbles
     */
 
-    if (pieces.contains(dest)) { // push
-      // apply that direction from orig, until we find an empty square or get out of the board (considering a max distance of 3 from dest)
-
-      // then move the 2 marbles :
-      // pieces(finalDest) = pieces(dest)
-      // pieces(dest) = pieces(orig)
-      // pieces(orig) = None
-      capture = true
+    if (directions.size == 0) { // line move
+      updatedPieceMap = pieces + (dest -> pieces(orig)) - (orig)
+    } else if (directions.size == 1) { // push
+      if(dest.dir(directions(0)) == None) {
+        // __(_)o\
+        capture = true
+        updatedPieceMap = pieces + (dest -> pieces(orig)) - orig
+      } else if (!pieces.contains(dest.dir(directions(0)).get)) { 
+        // __(_)o.
+        updatedPieceMap = pieces + (dest.dir(directions(0)).get -> pieces(dest)) + (dest -> pieces(orig)) - orig
+      } else if (dest.dir(directions(0)).get.dir(directions(0)) == None) {
+        // ___oo\
+        capture = true
+        updatedPieceMap = pieces + (dest.dir(directions(0)).get -> pieces(dest)) + (dest -> pieces(orig)) - orig
+      } else  {
+        // ___oo.
+        updatedPieceMap = pieces + (dest.dir(directions(0)).get.dir(directions(0)).get -> pieces(dest)) + (dest -> pieces(orig)) - orig
+      }
+    } else { // side move
+        // from orig, move of the second direction
+        // then move from orig of the first direction and repeat until we have reached dest
+        if ( orig.dir(directions(1)).get.dir(directions(0)).get.index != dest.index ) {
+          updatedPieceMap = pieces + (orig.dir(directions(0)).get -> pieces(orig)) - orig +
+          (orig.dir(directions(1)).get.dir(directions(0)).get -> pieces(orig.dir(directions(1)).get)) - orig.dir(directions(1)).get +
+          (orig.dir(directions(1)).get.dir(directions(1)).get.dir(directions(0)).get -> pieces(orig.dir(directions(1)).get.dir(directions(1)).get)) - orig.dir(directions(1)).get.dir(directions(1)).get
+        } else {
+          updatedPieceMap = pieces + (orig.dir(directions(0)).get -> pieces(orig)) - orig +
+            (orig.dir(directions(1)).get.dir(directions(0)).get -> pieces(orig.dir(directions(1)).get)) - orig.dir(directions(1)).get
+        }
     }
-    if (player == P1)
-      (pieces, capture)
-    else
-      (pieces, capture)
+
+    (updatedPieceMap, capture)
   }
 
   def move(
@@ -275,6 +288,7 @@ abstract class Variant private[variant] (
   // if a player runs out of move, the match is a draw
   def stalemateIsDraw = true
 
+  // @TODO: might want to use this winner method in specialEnd method below ? code is duplicated...
   def winner(situation: Situation): Option[Player] = {
     if (situation.board.history.score.p1 == 6) Some(P1)
     else if (situation.board.history.score.p2 == 6) Some(P2)
diff --git a/src/test/scala/abalone/AbaloneVariantTest.scala b/src/test/scala/abalone/AbaloneVariantTest.scala
