feat: FEN pieces

also starts the work on valid moves generation

Author: vincentfrochot

src/main/scala/Move.scala

@@ -359,10 +359,7 @@ object Move {
         Situation.Abalone(m.situationBefore),
         Board.Abalone(m.after),
         m.autoEndTurn,
-        m.capture match {
-          case Some(capture) => Option(List(Pos.Abalone(capture)))
-          case None          => None
-        },
+        None, // capture. @TODO: Could be the pos of the piece that was on targetSquare described by the move (because line moves are basically just marbles jumping over other ones)
         None,
         None,
         None,

src/main/scala/abalone/Board.scala

@@ -9,23 +9,16 @@ case class Board(
     history: History,
     variant: Variant
 ) {
-
-  def apply(at: Pos): Option[Piece] = pieces get at
+  def apply(at: Pos): Option[Piece] = pieces.get(at)
   def apply(file: File, rank: Rank): Option[Piece] = {
     val pos = Pos(file, rank)
     pos match {
-      case Some(pos) => pieces get pos
+      case Some(pos) => pieces.get(pos)
       case None => None
     }
   }
 
-  lazy val actors: Map[Pos, Actor] = pieces map { case (pos, piece) =>
-    (pos, Actor(piece, pos, this))
-  }
-
-  lazy val posMap: Map[Piece, Iterable[Pos]] = pieces.groupMap(_._2)(_._1)
-
-  lazy val piecesOnBoardCount: Int = pieces.keys.size
+  def piecesOf(player: Player): PieceMap = pieces.filter(_._2.is(player))
 
   def withHistory(h: History): Board       = copy(history = h)
   def updateHistory(f: History => History) = copy(history = f(history))
@@ -41,6 +34,14 @@ case class Board(
   def materialImbalance: Int = variant.materialImbalance(this)
 
   override def toString = s"$variant Position after ${history.recentTurnUciString}"
+
+  lazy val actors: Map[Pos, Actor] = pieces.map {
+    case (pos, piece) => (pos, Actor(piece, pos, this))
+  }
+
+  lazy val posMap: Map[Piece, Iterable[Pos]] = pieces.groupMap(_._2)(_._1)
+
+  lazy val piecesOnBoardCount: Int = pieces.keys.size
 }
 
 object Board {

src/main/scala/abalone/History.scala

@@ -9,7 +9,7 @@ case class History(
     currentTurn: List[Uci] = List.empty,
     positionHashes: PositionHash = Array.empty,
     score: Score = Score(0, 0),
-    // this might be tracking fullMove for Abalone
+    // this is tracking fullMove for Abalone
     halfMoveClock: Int = 0
 ) {
 

src/main/scala/abalone/Move.scala

@@ -10,7 +10,7 @@ case class Move(
     situationBefore: Situation,
     after: Board,
     autoEndTurn: Boolean,
-    capture: Option[Pos] = None,
+    capture: Option[Pos] = None, // @TODO: could just be the dest Pos in a capture move (because line moves are basically just marbles jumping over other ones)
     promotion: Option[PromotableRole] = None,
     metrics: MoveMetrics = MoveMetrics()
 ) extends Action(situationBefore, after, metrics) {

src/main/scala/abalone/Pos.scala

@@ -194,6 +194,11 @@ case class Pos private (index: Int) extends AnyVal {
   @inline def file = File of this // column (as if it was an index in a 1D array)
   @inline def rank = Rank of this // horizontal row, makes sense in a 2D array
 
+  // these 3 below might be handy
+  // def touches(other: Pos): Boolean = xDist(other) <= 1 && yDist(other) <= 1
+  // def xDist(other: Pos) = abs(file - other.file)
+  // def yDist(other: Pos) = abs(rank - other.rank)
+
   // @TODO VFR: test these
   def >|(stop: Pos => Boolean): List[Pos]                   = |<>|(stop, _.right)
   def |<(stop: Pos => Boolean): List[Pos]                   = |<>|(stop, _.left)
@@ -214,15 +219,10 @@ case class Pos private (index: Int) extends AnyVal {
   def <->(other: Pos): Iterable[Pos] =
     min(file.index, other.file.index) to max(file.index, other.file.index) flatMap { Pos.at(_, rank.index) }
 
-  def touches(other: Pos): Boolean = xDist(other) <= 1 && yDist(other) <= 1
-
   def onSameDiagonal(other: Pos): Boolean =
     file.index - rank.index == other.file.index - other.rank.index || file.index + rank.index == other.file.index + other.rank.index
   def onSameLine(other: Pos): Boolean     = ?-(other) || ?|(other)
 
-  def xDist(other: Pos) = abs(file - other.file)
-  def yDist(other: Pos) = abs(rank - other.rank)
-
   def isLight: Boolean = (file.index + rank.index) % 2 == 1
    */
 
@@ -235,9 +235,9 @@ case class Pos private (index: Int) extends AnyVal {
     )
   def piotrStr = piotr.toString
 
-  def key               = file.toString + rank.toString
-  override def toString = key
-
+  def key                 = file.toString + rank.toString
+  def officialNotationKey = File(rank.index).getOrElse("").toString + "" + Rank(file.index).getOrElse("").toString
+  override def toString   = officialNotationKey
 }
 
 object Pos {

src/main/scala/abalone/Replay.scala

@@ -83,7 +83,7 @@ object Replay {
       // TODO Abalone Set
       after = before.situation.board.copy(),
       autoEndTurn = endTurn,
-      capture = None,
+      capture = None, // @TODO:  consider if it's difficult to determine if a capture was made from here (a marble pushed off the board)
       promotion = None
     )
 

src/main/scala/abalone/Role.scala

@@ -19,9 +19,11 @@ sealed trait Role {
 
 sealed trait PromotableRole extends Role
 
-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)
+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 be rolling stones, not Oware "Stones")
   val forsyth   = 's'
   val binaryInt = 0
+
+  val dirs: Directions        = List(_.right, _.left, _.upLeft, _.upRight, _.downLeft, _.downRight)
 }
 
 object Role {

src/main/scala/abalone/Situation.scala

@@ -9,33 +9,22 @@ import strategygames.abalone.format.Uci
 
 case class Situation(board: Board, player: Player) {
 
-  lazy val moves: Map[Pos, List[Move]] = board.variant.validMoves(this)
-
-  lazy val destinations: Map[Pos, List[Pos]] = moves.view.mapValues { _ map (_.dest) }.to(Map)
-
   def history = board.history
 
   def checkMate: Boolean = false
-  def staleMate: Boolean = false
 
-  private def variantEnd = false || board.variant.specialEnd(this)
+  def staleMate: Boolean = board.variant.specialDraw(this)
 
-  def end: Boolean = checkMate || staleMate || variantEnd
+  def end: Boolean = staleMate || variantEnd
 
   def winner: Option[Player] = board.variant.winner(this)
 
   def playable(strict: Boolean): Boolean =
-    (board valid strict) && !end
-
-  lazy val status: Option[Status] =
-    if (checkMate) Status.Mate.some
-    else if (variantEnd) Status.VariantEnd.some
-    else if (staleMate) Status.Stalemate.some
-    else none
+    (board.valid(strict)) && !end
 
   // TODO Abalone set this
   // in case someone does not have more than 2 pieces, it could be considered as insufficient material to do anything
-  // But I'm not sure we do not want to allow having a board containing only 1 marble for a player : Could be interesting for teaching or puzzle purpose.  
+  // But I'm not sure we do not want to allow having a board containing only 1 marble for a player : for didactic consideration e.g. the famous "hunt as 4 v 1"
   def opponentHasInsufficientMaterial: Boolean =
     false
 
@@ -45,17 +34,22 @@ case class Situation(board: Board, player: Player) {
   def move(uci: Uci.Move): Validated[String, Move] =
     board.variant.move(this, uci.orig, uci.dest, uci.promotion)
 
-  def withHistory(history: History) =
-    copy(
-      board = board withHistory history
-    )
+  def withHistory(history: History) = copy(board = board.withHistory(history))
 
-  def withVariant(variant: strategygames.abalone.variant.Variant) =
-    copy(
-      board = board withVariant variant
-    )
+  def withVariant(variant: strategygames.abalone.variant.Variant) = copy(board = board.withVariant(variant))
 
   def unary_! = copy(player = !player)
+
+  lazy val destinations: Map[Pos, List[Pos]] = moves.view.mapValues { _.map(_.dest) }.to(Map)
+
+  lazy val moves: Map[Pos, List[Move]] = board.variant.validMoves(this)
+
+  lazy val status: Option[Status] =
+    if (variantEnd) Status.VariantEnd.some
+    else if (staleMate) Status.Stalemate.some
+    else none
+
+  private def variantEnd = board.variant.specialEnd(this)
 }
 
 object Situation {

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

@@ -1,11 +1,7 @@
 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.{ P1, P2, Piece, PieceMap, Pos, Role }
 
 final case class FEN(value: String) extends AnyVal {
   // squares are described from topLeft to bottomRight in the FEN :
@@ -14,18 +10,16 @@ final case class FEN(value: String) extends AnyVal {
 
   override def toString = value
 
-  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
-        }
-      }.flatMap {
-        case Some((Some(pos), piece)) => Some(pos -> piece)
-        case _ => None
-      }
-    }.flatten.toMap
+  def pieces: PieceMap = value.split(' ')(0).split('/').reverse.flatMap {
+    _.toCharArray
+  }.flatMap{ 
+    case square if (square.isDigit) => { Array.fill(square.asDigit)('1') }
+    case square => Array(square)
+  }.zip(Pos.all).flatMap { // map + flatten (that get rid of the 'Some' and the 'None' (meaning we map to None for cases we want to filter out))
+    case (piece, pos) if (piece == Role.defaultRole.forsyth) => Some((pos, Piece(P1, Role.defaultRole)))
+    case (piece, pos) if (piece == Role.defaultRole.forsythUpper) => Some((pos, Piece(P2, Role.defaultRole)))
+    case _ => None
+  }.toMap
 
   def player1Score: Int = intFromFen(1).getOrElse(0)
 
@@ -46,15 +40,6 @@ 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/format/Uci.scala

@@ -24,7 +24,7 @@ object Uci {
       promotion: Option[PromotableRole] = None
   ) extends Uci {
 
-    def keys = orig.key + dest.key
+    def keys = orig.officialNotationKey + dest.officialNotationKey
     def uci  = keys + promotionString
 
     def keysPiotr = orig.piotrStr + dest.piotrStr

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

@@ -1,8 +1,8 @@
 package strategygames.abalone
 package variant
 
+import strategygames.GameFamily
 import strategygames.abalone._
-import strategygames.{ GameFamily, Player }
 
 case object Abalone
     extends Variant(
@@ -19,9 +19,4 @@ case object Abalone
   def perfId: Int    = 700
 
   override def baseVariant: Boolean = true
-
-  // 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)
-
 }