Merge pull request #187 from Mind-Sports-Games/pla-927-sg-fen-notation

feat: FEN notation

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 (and by extension, pushes) 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 {
@@ -54,9 +55,9 @@ object Board {
 
   sealed abstract class BoardSize(
       val width: Int,
-      val height: Int
+      val height: Int,
+      val irregular: Boolean = true
   ) {
-    val regular = false
 
     val key   = s"${width}x${height}"
     val sizes = List(width, height)

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

@@ -190,10 +190,16 @@ case class Pos private (index: Int) extends AnyVal {
   def right: Option[Pos]     = Pos.at(file.index + 1, rank.index)
   def downRight: Option[Pos] = Pos.at(file.index, rank.index - 1)
   def upRight: Option[Pos]   = Pos.at(file.index + 1, rank.index + 1)
+  def neighbours: List[Option[Pos]] = List(left, downLeft, upLeft, right, downRight, upRight)
 
   @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 +220,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,25 +236,26 @@ 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 = s"${File(rank.index).getOrElse("")}${Rank(file.index).getOrElse("")}"
+  override def toString   = officialNotationKey
 }
 
 object Pos {
 /*
-                                  row col
-9 -  72 73 74 75 &  \' (  )  *    8:   >3 (<9)
-8 -  63 64 65 7  8  9  !  ?  ¥    7:   >2 (<9)
-7 -  54 55 Y  Z  0  1  2  3  £    6:   >1 (<9)
-6 -  45 P  Q  R  S  T  U  V  ¡    5:   >0 (<9)
-5 -  G  H  I  J  K  L  M  N  }    4:   <9
-4 -  y  z  A  B  C  D  E  F  35   3:   <8
-3 -  q  r  s  t  u  v  w  25 26   2:   <7
-2 -  i  j  k  l  m  n  15 16 17   1:   <6
-1 -  a  b  c  d  e  5  6  7  8    0:   <5
-     |  |  |  |  |  |  |  |  |
-     A  B  C  D  E  F  G  H  I
+  indexes of Pos outside of the hexagon :
+                                          row   col
+9 -   72  73  74  75 '&' ''' '(' ')' '*'   8:   >3 (<9)
+8 -   63  64  65 '7' '8' '9' '!' '?' '¥'   7:   >2 (<9)
+7 -   54  55 'Y' 'Z' '0' '1' '2' '3' '£'   6:   >1 (<9)
+6 -   45 'P' 'Q' 'R' 'S' 'T' 'U' 'V' '¡'   5:   >0 (<9)
+5 -  'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' '}'   4:   <9
+4 -  'y' 'z' 'A' 'B' 'C' 'D' 'E' 'F' 35    3:   <8
+3 -  'q' 'r' 's' 't' 'u' 'v' 'w' 25  26    2:   <7
+2 -  'i' 'j' 'k' 'l' 'm' 'n' 15  16  17    1:   <6
+1 -  'a' 'b' 'c' 'd' 'e'  5   6   7   8    0:   <5
+      |   |   |   |   |   |   |   |   |
+      A   B   C   D   E   F   G   H   I
 */
   def isInHexagon(index: Int): Boolean = {
     if (index < 0) return false

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

@@ -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,9 +19,11 @@ 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 {
   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,33 +1,45 @@
 package strategygames.abalone.format
 
 import strategygames.Player
-import strategygames.abalone.PieceMap
+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 :
+  // 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 player: Option[Player] =
-    value.split(' ').lift(3) flatMap (_.headOption) flatMap Player.apply
+  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 {
+    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)
 
   def player2Score: Int = intFromFen(2).getOrElse(0)
 
-  def fullMove: Option[Int] = intFromFen(4)
+  def player: Option[Player] = value.split(' ').lift(3).flatMap(_.headOption).flatMap(Player.apply).map( !_ )
+
+  def halfMovesSinceLastCapture: Option[Int] = intFromFen(4)
+
+  def fullMove: Option[Int] = intFromFen(5)
 
   def ply: Option[Int] =
     fullMove map { fm =>
       fm * 2 - (if (player.exists(_.p1)) 2 else 1)
     }
 
-  private def intFromFen(index: Int): Option[Int] =
-    value.split(' ').lift(index).flatMap(_.toIntOption)
-
   def initial = value == Forsyth.initial.value
 
-  // TODO Abalone Set
-  def pieces: PieceMap = Map.empty
+  private def intFromFen(index: Int): Option[Int] =
+    value.split(' ').lift(index).flatMap(_.toIntOption)
 }
 
 object FEN {

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(
@@ -18,13 +18,5 @@ case object Abalone
   def perfIcon: Char = ''
   def perfId: Int    = 700
 
-  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 when the opponent can not move anymore (which is an extremely rare case)
-
+  override def baseVariant: Boolean = true // Belgian Daisy initialFen is defined in Abalone default "Variant" file
 }