chore: refactor side moves

Author: vincentfrochot

src/main/scala/abalone/Pos.scala

@@ -192,15 +192,6 @@ case class Pos private (index: Int) extends AnyVal {
   def upRight: Option[Pos]   = Pos.at(file.index + 1, rank.index + 1)
 
   def neighbours: List[Option[Pos]] = List(left, upLeft, upRight, right, downRight, downLeft)
-  def sideMovesDirsFromDir(dir: Option[String]): (Option[Pos], Option[Pos]) = dir match {
-    case Some("left")       => (this.downLeft, this.upLeft)
-    case Some("upLeft")     => (this.left, this.upRight)
-    case Some("upRight")    => (this.upLeft, this.right)
-    case Some("right")      => (this.upRight, this.downRight)
-    case Some("downRight")  => (this.right, this.downLeft)
-    case Some("downLeft")   => (this.downRight, this.left)
-    case _                  => (None, None)
-  }
 
   // NOTE - *neighbourhood
   // these below only work for neighbour pos but that's probably fine as in Abalone we only move to (potentially extended) neighbourhood
@@ -213,6 +204,15 @@ case class Pos private (index: Int) extends AnyVal {
     case Some("downLeft")   => this.downLeft
     case _                  => None
   }
+  def dir(dir: String): Option[Pos]  = dir match {
+    case "left"       => this.left
+    case "upLeft"     => this.upLeft
+    case "upRight"    => this.upRight
+    case "right"      => this.right
+    case "downRight"  => this.downRight
+    case "downLeft"   => this.downLeft
+    case _            => None
+  }
 
   def dir(pos: Pos): Option[String] =
     (pos.file.index - this.file.index, pos.rank.index - this.rank.index) match {
@@ -318,6 +318,16 @@ object Pos {
     if (isInHexagon(x + File.all.size * y)) Some(new Pos(x + File.all.size * y))
     else None
 
+  def sideMovesDirsFromDir(dir: Option[String]): List[String] = dir match {
+    case Some("left")       => List("downLeft", "upLeft")
+    case Some("upLeft")     => List("left", "upRight")
+    case Some("upRight")    => List("upLeft", "right")
+    case Some("right")      => List("upRight", "downRight")
+    case Some("downRight")  => List("right", "downLeft")
+    case Some("downLeft")   => List("downRight", "left")
+    case _                  => List()
+  }
+
   def fromKey(key: String): Option[Pos] = allKeys get key
 
   def piotr(c: Char): Option[Pos] = allPiotrs get c

src/main/scala/abalone/variant/Variant.scala

@@ -96,7 +96,7 @@ abstract class Variant private[variant] (
         Map(pos ->
           pos.neighbours.flatten
           .filterNot(situation.board.pieces.contains(_))
-          .map(landingSquare => 
+          .map(landingSquare =>
             Move(piece, pos, landingSquare, situation, boardAfter(situation, pos, landingSquare), false)
           )
         )
@@ -105,26 +105,37 @@ abstract class Variant private[variant] (
   def validMovesOf2And3(situation: Situation): Map[Pos, List[(String, Move)]] = {
     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 generateSideMoves(lineOfMarbles: List[Pos], direction: Option[String]): List[(String, Move)] = {
-      // "left" is related to the direction
-      def canLeftSideMove(pos: Pos): Boolean =
-        pos.sideMovesDirsFromDir(direction)._1.fold(false)(p => situation.board.isEmptySquare(Some(p)))
-      def canRightSideMove(pos: Pos): Boolean =
-        pos.sideMovesDirsFromDir(direction)._2.fold(false)(p => situation.board.isEmptySquare(Some(p)))
+      def canMoveTowards(pos: Pos, dir: String): Boolean = {
+        situation.board.isEmptySquare(pos.dir(dir))
+      }
+
+      val possibleSideMovesDirections = Pos.sideMovesDirsFromDir(direction)
+      def possibleSideMoves: List[Option[(Pos, Pos)]] = possibleSideMovesDirections.map(
+        dir =>
+          if (lineOfMarbles.flatMap(
+            (pos) => Some(canMoveTowards(pos, dir))
+          ).contains(false)) None
+          else List(
+            lineOfMarbles.headOption,
+            lineOfMarbles.reverse.headOption.flatMap(_.dir(dir))
+          ) match {
+            case List(Some(head), Some(tail)) => Some( (head, tail) )
+            case _ => None
+          }
+      )
 
       List(
         if (lineOfMarbles.size == 3) generateSideMoves(lineOfMarbles.dropRight(1), direction)
         else None,
-        if (!lineOfMarbles.map(canLeftSideMove).contains(false))
-          Some(createMove(lineOfMarbles(0), lineOfMarbles.last.sideMovesDirsFromDir(direction)._1.get, "side"))
-        else None,
-        if (!lineOfMarbles.map(canRightSideMove).contains(false))
-          Some(createMove(lineOfMarbles(0), lineOfMarbles.last.sideMovesDirsFromDir(direction)._2.get, "side"))
-        else None,
+        possibleSideMoves.flatMap {
+          case Some((orig, dest)) => Some(createMove(orig, dest, "side"))
+          case _ => None
+        }
       ).flatten
     }
 
@@ -183,11 +194,11 @@ abstract class Variant private[variant] (
         }.flatMap {
           case (pos, neighbour) =>
             generateMovesForNeighbours(pos, neighbour)
-        }
-        ).view.toList
+        }).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 = {
     // 1. move pieces and get the score
     val (pieces, capture)   = piecesAfterAction(situation.board.pieces, situation.player, orig, dest)
@@ -210,9 +221,34 @@ abstract class Variant private[variant] (
   def piecesAfterAction(pieces: PieceMap, player: Player, @nowarn orig: Pos, dest: Pos): (PieceMap, Boolean) = {
     var capture = false
 
-    if (pieces.contains(dest)) { // push
-      // compute direction between orig and dest to push the opponent marble
+    /*
+
+        * * * * *
+       * 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
+
+        2. play the move
+          - line move :
+              - move from orig to dest
+          - push :
+            - dest contains a marble
+            - we know 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 ?
+    
+    */
 
+    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 :