Fix Oware Isometric test - be able to load FEN when final stones have been scored

Author: Matt Tucker

src/main/scala/samurai/Api.scala

@@ -51,7 +51,8 @@ object Api {
   private class OwarePosition(
       position: OwareGame,
       ply: Int = 0,
-      fromFen: Option[FEN] = None
+      fromFen: Option[FEN] = None,
+      forceEnd: Boolean = false
   ) extends Position {
     // TODO: yes, this is an abuse of scala. We could get an
     //       exception here, but I'm not sure how to work around that
@@ -170,7 +171,8 @@ object Api {
     lazy val gameResult: GameResult =
       GameResult.resultFromInt(position.outcome(), gameEnd)
 
-    lazy val gameEnd: Boolean = position.hasEnded() && (!position.isRepetition() || isRepetition)
+    lazy val gameEnd: Boolean =
+      forceEnd || (position.hasEnded() && (!position.isRepetition() || isRepetition))
 
     lazy val gameOutcome: Int      = position.outcome()
     lazy val isRepetition: Boolean = position.isRepetition() && !allSeedsOnSameSide
@@ -212,13 +214,17 @@ object Api {
     new OwarePosition(game, fen.ply.getOrElse(0), Some(fen))
   }
 
-  def positionFromVariantNameAndFEN(variantName: String, fenString: String): Position = {
+  def positionFromVariantNameAndFEN(
+      variantName: String,
+      fenString: String,
+      forceEnd: Boolean = false
+  ): Position = {
     val game = new OwareGame()
     val fen  = FEN(fenString)
     game.setBoard(owareBoardFromFen(fenString))
     variantName.toLowerCase() match {
-      case "oware" => new OwarePosition(game, fen.ply.getOrElse(0), Some(fen))
-      case _       => new OwarePosition(new OwareGame(), fen.ply.getOrElse(0), Some(fen))
+      case "oware" => new OwarePosition(game, fen.ply.getOrElse(0), Some(fen), forceEnd)
+      case _       => new OwarePosition(new OwareGame(), fen.ply.getOrElse(0), Some(fen), forceEnd)
     }
   }
 

src/main/scala/samurai/format/FEN.scala

@@ -25,12 +25,10 @@ final case class FEN(value: String) extends AnyVal {
   private def intFromFen(index: Int): Option[Int] =
     value.split(' ').lift(index).flatMap(_.toIntOption)
 
+  private def boardStr = value.split(' ')(0)
+
   def owareStoneArray: Array[Int] =
-    (
-      value.split(' ')(0).split('/')(1).split(',')
-        ++
-          value.split(' ')(0).split('/')(0).split(',').reverse
-    )
+    (boardStr.split('/')(1).split(',') ++ boardStr.split('/')(0).split(',').reverse)
       .map(c =>
         c.toString() match {
           case x if 1 to 6 map (_.toString) contains x => Array.fill(x.toInt)(0)
@@ -40,7 +38,25 @@ final case class FEN(value: String) extends AnyVal {
       .flatten
       .toArray
 
+  def stonesOwnedByPlayer(player: Player) = {
+    val stonesByPlayer = owareStoneArray.splitAt(6)
+    player.fold(stonesByPlayer._1, stonesByPlayer._2).sum
+  }
+
   def initial = value == Forsyth.initial.value
+
+  private def rawPlayerScore(player: Player) =
+    player.fold(player1Score, player2Score) - stonesOwnedByPlayer(player)
+
+  def finalStonesScored = player1Score + player2Score == 48
+
+  def withoutFinalStonesScored =
+    if (finalStonesScored)
+      FEN(
+        s"${boardStr} ${rawPlayerScore(Player.P1)} ${rawPlayerScore(Player.P2)} ${value.split(' ').drop(3).mkString(" ")}"
+      )
+    else this
+
 }
 
 object FEN {

src/main/scala/samurai/format/Forsyth.scala

@@ -14,7 +14,11 @@ object Forsyth {
   val initial = FEN("4S,4S,4S,4S,4S,4S/4S,4S,4S,4S,4S,4S 0 0 S 1")
 
   def <<@(variant: Variant, fen: FEN): Option[Situation] = {
-    val apiPosition = Api.positionFromVariantNameAndFEN(variant.name, fen.value)
+    val apiPosition = Api.positionFromVariantNameAndFEN(
+      variant.name,
+      fen.withoutFinalStonesScored.value,
+      fen.finalStonesScored
+    )
     Some(
       Situation(
         Board(

src/main/scala/samurai/variant/Variant.scala

@@ -52,44 +52,46 @@ abstract class Variant private[variant] (
   def isValidPromotion(@nowarn promotion: Option[PromotableRole]): Boolean = true
 
   def validMoves(situation: Situation): Map[Pos, List[Move]] =
-    situation.board.apiPosition.legalMoves
-      .map { move =>
-        val numSeeds = situation.board.apiPosition.fen.owareStoneArray(move)
-        (
-          move,
-          Pos(move),
-          Pos(
-            (numSeeds + move + (numSeeds - 1) / 11) % 12
-          ) // dest = seeds + move position + skipping own house
-        )
-      }
-      .map {
-        case (move, Some(orig), Some(dest)) => {
-          val uciMove       = s"${orig.key}${dest.key}"
-          val previousMoves = situation.board.uciMoves
-          val newPosition   = situation.board.apiPosition.makeMovesWithPrevious(List(move), previousMoves)
+    if (situation.status.isEmpty)
+      situation.board.apiPosition.legalMoves
+        .map { move =>
+          val numSeeds = situation.board.apiPosition.fen.owareStoneArray(move)
           (
-            orig,
-            Move(
-              piece = situation.board.pieces(orig)._1,
-              orig = orig,
-              dest = dest,
-              situationBefore = situation,
-              after = situation.board.copy(
-                pieces = newPosition.pieceMap,
-                uciMoves = situation.board.uciMoves :+ uciMove,
-                position = newPosition.some
-              ),
-              autoEndTurn = true,
-              capture = None,
-              promotion = None
-            )
+            move,
+            Pos(move),
+            Pos(
+              (numSeeds + move + (numSeeds - 1) / 11) % 12
+            ) // dest = seeds + move position + skipping own house
           )
         }
-        case (_, orig, dest)                => sys.error(s"Invalid position from uci: ${orig}${dest}")
-      }
-      .groupBy(_._1)
-      .map { case (k, v) => (k, v.toList.map(_._2)) }
+        .map {
+          case (move, Some(orig), Some(dest)) => {
+            val uciMove       = s"${orig.key}${dest.key}"
+            val previousMoves = situation.board.uciMoves
+            val newPosition   = situation.board.apiPosition.makeMovesWithPrevious(List(move), previousMoves)
+            (
+              orig,
+              Move(
+                piece = situation.board.pieces(orig)._1,
+                orig = orig,
+                dest = dest,
+                situationBefore = situation,
+                after = situation.board.copy(
+                  pieces = newPosition.pieceMap,
+                  uciMoves = situation.board.uciMoves :+ uciMove,
+                  position = newPosition.some
+                ),
+                autoEndTurn = true,
+                capture = None,
+                promotion = None
+              )
+            )
+          }
+          case (_, orig, dest)                => sys.error(s"Invalid position from uci: ${orig}${dest}")
+        }
+        .groupBy(_._1)
+        .map { case (k, v) => (k, v.toList.map(_._2)) }
+    else Map.empty
 
   def move(
       situation: Situation,