fix: read FEN properly, use Stones for pieces, improve codestyle

Author: vincentfrochot

src/main/scala/abalone/Role.scala

@@ -4,7 +4,7 @@ import strategygames.{ GameFamily, P1, P2, Player }
 
 sealed trait Role {
   val forsyth: Char
-  // lazy val forsythUpper: Char = forsyth.toUpper //this contradicts what the piece is now!
+  lazy val forsythUpper: Char     = forsyth.toUpper
   lazy val pgn: Char              = forsyth
   lazy val name                   = toString
   lazy val groundName             = s"${forsyth}-piece"
@@ -19,7 +19,7 @@ sealed trait Role {
 
 sealed trait PromotableRole extends Role
 
-case object Stone extends Role { // @TODO VFR: just use Stone for Marbles
+case object Stone extends Role { // @TODO VFR: consider if we want a new "Marble" Role or if we just use Stone for Marbles (because these can move)
   val forsyth   = 's'
   val binaryInt = 0
 }

src/main/scala/abalone/format/FEN.scala

@@ -1,73 +1,37 @@
 package strategygames.abalone.format
 
 import strategygames.Player
+import strategygames.abalone.File
 import strategygames.abalone.Piece
 import strategygames.abalone.PieceMap
 import strategygames.abalone.Pos
 import strategygames.abalone.Stone
-import strategygames.abalone.File
 
-// FEN is described from bottomLeft to topRight
 final case class FEN(value: String) extends AnyVal {
-  // Belgian Daisy: pp1PP/pppPPP/1pp1PP1/8/9/8/1PP1pp1/PPPppp/PP1pp 0 0 b 0 0
-  // Snakes: PPPPP/5P/6P/1ppppp1P/1p5P1/p1PPPPP1/p6/p5/ppppp 0 0 b 0 0
+  // squares are described from topLeft to bottomRight in the FEN :
+  // eg. Belgian Daisy: SS1ss/SSSsss/1SS1ss1/8/9/8/1ss1SS1/sssSSS/ss1SS
+  // Snakes: sssss/s5/s6/s1SSSSS1/1s5S1/1sssss1S/6S/5S/SSSSS
 
   override def toString = value
 
-  def pieces: PieceMap = {
-/*
-  squared hex representation of the Belgian Daisy FEN :
-                                          row   col
-9 -   72  73  74  75 'P' 'P' '1' 'p' 'p'   8:   >3 (<9)
-8 -   63  64  65 'P' 'P' 'P' 'p' 'p' 'p'   7:   >2 (<9) next line : +4
-7 -   54  55 '1' 'P' 'P' '1' 'p' 'p' '1'   6:   >1 (<9) next line : +3
-6 -   45         '8'                       5:   >0 (<9) next line : +2
-5 -              '9'                       4:   <9 next line : +1
-4 -              '8'                 35    3:   <8 next line : +1
-3 -  '1' 'p' 'p' '1' 'P' 'P' '1' 25  26    2:   <7 next line : +2
-2 -  'p' 'p' 'p' 'P' 'P' 'P' 15  16  17    1:   <6 next line : +3
-1 -  'p' 'p' '1' 'P' 'P'  5   6   7   8    0:   <5 next line : +4
-      |   |   |   |   |   |   |   |   |
-      A   B   C   D   E   F   G   H   I
- */
-    val position     = value.split(' ')(0)
-    var currentIndex = 0
-    var currentLine = 0
-    position.map {
-      case 'p' => {
-        currentIndex = currentIndex + 1
-        Some((Pos.apply(currentIndex - 1), new Piece(strategygames.abalone.P1, Stone)))
-      }
-      case 'P' => {
-        currentIndex = currentIndex + 1
-        Some((Pos.apply(currentIndex - 1), new Piece(strategygames.abalone.P2, Stone)))
-      }
-      case d if d.isDigit => {
-        currentIndex = currentIndex + d.asDigit
-        None
-      }
-      case '/' => {
-        currentLine = currentLine + 1
-        currentIndex =  if(currentLine < 5) {
-          currentIndex + (File.all.size / 2 + 1) - (currentLine)
-        }
-        else {
-          currentIndex + Math.abs((File.all.size / 2 + 1) - currentLine - 1)
+  def pieces: PieceMap = squares.zipWithIndex.map {
+      case (pieces, row) => pieces.zipWithIndex.map[Option[(Option[strategygames.abalone.Pos], strategygames.abalone.Piece)]] { 
+        case (piece, index) => piece match {
+          case Stone.forsyth => Some((Pos.at(index, (File.all.size - 1 - row)), new Piece(strategygames.abalone.P1, Stone)))
+          case Stone.forsythUpper => Some((Pos.at(index, (File.all.size - 1 - row)), new Piece(strategygames.abalone.P2, Stone)))
+          case _ => None
         }
-        None
+      }.flatMap {
+        case Some((Some(pos), piece)) => Some(pos -> piece)
+        case _ => None
       }
-    }.flatten.flatMap { // flatMap = map + flatten, which gets rid of None and returns the Object instead of a Some(Object) which we would get with map
-      case (Some(pos), piece) => Some(pos -> piece)
-      case _ => None
-    }.toMap
-  }
+    }.flatten.toMap
 
   def player1Score: Int = intFromFen(1).getOrElse(0)
 
   def player2Score: Int = intFromFen(2).getOrElse(0)
 
-  def player: Option[Player] =
-    value.split(' ').lift(3) flatMap (_.headOption) flatMap  Player.apply map( !_ )
+  def player: Option[Player] = value.split(' ').lift(3).flatMap(_.headOption).flatMap(Player.apply).map( !_ )
 
   def halfMovesSinceLastCapture: Option[Int] = intFromFen(4)
 
@@ -82,6 +46,15 @@ final case class FEN(value: String) extends AnyVal {
 
   private def intFromFen(index: Int): Option[Int] =
     value.split(' ').lift(index).flatMap(_.toIntOption)
+
+  // represents pieces on the Board, and '0' or '1' depending if the empty square is in the hexagon or not
+  private def squares: Array[Array[Char]] = value.split(' ')(0).split('/').zipWithIndex.map {
+      case (pieces, row) if (row < (File.all.size / 2 + 1)) => { Array.fill(Math.abs(row + (File.all.size / 2 + 1) - File.all.size)){'0'} ++ pieces.toArray }
+      case (pieces, row) => { pieces.toArray ++ Array.fill(Math.abs((File.all.size / 2) - row)){'0'} }
+    }.flatten.flatMap {
+        case (d) if (d.isDigit && d.asDigit > 0) => Array.fill(d.asDigit){Array('1')}        
+        case (d) => Array.fill(1){Array(d)}
+    }.flatten.grouped(File.all.size).toArray
 }
 
 object FEN {

src/main/scala/abalone/variant/Abalone.scala

@@ -20,9 +20,6 @@ case object Abalone
 
   override def baseVariant: Boolean = true
 
-  // pieces, scoreP1, scoreP2, turn, halfMovesSinceLastCapture (triggering condition could be when == 100 && total moves > 50 ? => draw), total moves
-  override def initialFen = format.FEN("pp1PP/pppPPP/1pp1PP1/8/9/8/1PP1pp1/PPPppp/PP1pp 0 0 b 0 0")
-
   // TODO: Abalone set
   override def winner(situation: Situation): Option[Player] =
     None // winner is the one who pushed out 6 or prevented opponent to move (which is an extremely rare case)

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

@@ -41,7 +41,8 @@ abstract class Variant private[variant] (
   def perfId: Int
   def perfIcon: Char
 
-  def initialFen: FEN = format.FEN("pp1PP/pppPPP/1pp1PP1/8/9/8/1PP1pp1/PPPppp/PP1pp 0 0 b 0 0") // Belgian Daisy
+  // pieces, scoreP1, scoreP2, turn, halfMovesSinceLastCapture (triggering condition could be when == 100 && total moves > 50 ? => draw), total moves
+  def initialFen: FEN = format.FEN("SS1ss/SSSsss/1SS1ss1/8/9/8/1ss1SS1/sssSSS/ss1SS 0 0 b 0 0") // Belgian Daisy
 
   def pieces: PieceMap = initialFen.pieces
 
@@ -60,9 +61,9 @@ abstract class Variant private[variant] (
       situation: Situation,
       from: Pos,
       to: Pos,
-      promotion: Option[PromotableRole]
+      promotion: Option[PromotableRole] // @TODO: try to see if it can be removed, check if it needs an update on the wrapperLayer. Not mandatory though
   ): Validated[String, Move] = {
-    // Find the move in the variant specific list of valid moves
+    // Find the move in the variant specific list of valid moves !
     situation.moves get from flatMap (_.find(m => m.dest == to && m.promotion == promotion)) toValid
       s"Not a valid move: ${from}${to} with prom: ${promotion}. Allowed moves: ${situation.moves}"
   }

src/test/scala/abalone/AbaloneFenTest.scala

@@ -65,7 +65,7 @@ class AbaloneFenTest extends AbaloneTest with ValidatedMatchers {
     }
 
     "Snakes start position" should {
-        val snakesFen = new format.FEN("PPPPP/5P/6P/1ppppp1P/1p5P1/p1PPPPP1/p6/p5/ppppp 0 0 b 0 0")
+        val snakesFen = new format.FEN("sssss/s5/s6/s1SSSSS1/1s5S1/1sssss1S/6S/5S/SSSSS 0 0 b 0 0")
         val pieces = snakesFen.pieces
 
         "have Black starting the game" in {
@@ -80,7 +80,7 @@ class AbaloneFenTest extends AbaloneTest with ValidatedMatchers {
     }
 
     "Atomouche start position" should {
-        val atomoucheFen = new format.FEN("3pP/PpP2p/4P2/p4p1P/P2p1P2p/p1P4P/2p4/P2pPp/pP3 0 0 b 0 0")
+        val atomoucheFen = new format.FEN("sS3/S2sSs/2s4/s1S4S/S2s1S2s/s4s1S/4S2/SsS2s/3sS 0 0 b 0 0")
         val pieces = atomoucheFen.pieces
 
         "have Black starting the game" in {
@@ -122,6 +122,43 @@ class AbaloneFenTest extends AbaloneTest with ValidatedMatchers {
         }
     }
 
+    "Fun little game situation \"5/6/2s4/2ssss2/2SSsS3/1SSSsss1/2s4/1SSs2/3S1 5 3 b 11 42\"" should {
+        val puzzleFen = new format.FEN("5/6/2s4/2ssss2/2SSsS3/1SSSsss1/2s4/1SSs2/3S1 5 3 b 11 42")
+        val pieces = puzzleFen.pieces
+
+        "have a score of 5 for P1 and a score of 3 for P2" in {
+            puzzleFen.player1Score must_== 5
+            puzzleFen.player2Score must_== 3
+        }
+
+        "have a total of 14 marbles per player, on the board and pushed out" in {
+            pieces.filter(p => p._2.player == P1).size + puzzleFen.player2Score must_== 14
+            pieces.filter(p => p._2.player == P2).size + puzzleFen.player1Score must_== 14
+        }
+
+        "11 plies were played since last time a marble was pushed out" in {
+            puzzleFen.halfMovesSinceLastCapture must_== Some(11)
+        }
+
+        "42 moves were played in total" in {
+            puzzleFen.fullMove must_== Some(42)
+        }
+    }
+
+    // @TODO: keep adding interesting cases once we are able to instanciate a Board from a FEN.
+
+    // "Game in progress since ages" should {
+    //     val ongoingGame = new format.FEN("")
+
+    //     "have a score of 3 for P2 and 2 for P1" in {
+    //         fen.player1Score must_== 2
+    //         fen.player2Score must_== 3
+    //     }
+
+    //     "be declared a draw" in {
+    //       ...
+    //      }
+    // }
 
     /*
     "a score of 6" should {