validMoves and boardAfter

src/main/scala/abalone/Board.scala

@@ -20,6 +20,8 @@ case class Board(
 
   def piecesOf(player: Player): PieceMap = pieces.filter(_._2.is(player))
 
+  def isEmptySquare(pos: Option[Pos]): Boolean = pos.fold(false)(!this.pieces.contains(_))
+
   def withHistory(h: History): Board       = copy(history = h)
   def updateHistory(f: History => History) = copy(history = f(history))
 

src/main/scala/abalone/Move.scala

@@ -16,7 +16,7 @@ case class Move(
 ) extends Action(situationBefore, after, metrics) {
 
   def situationAfter =
-    Situation(finalizeAfter, if (autoEndTurn) !piece.player else piece.player)
+    Situation(finalizeAfter, !piece.player)
 
   def applyVariantEffect: Move = before.variant addVariantEffect this
 

src/main/scala/abalone/Pos.scala

@@ -190,7 +190,43 @@ 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)
+
+  def neighbours: List[Option[Pos]] = List(left, upLeft, upRight, right, downRight, downLeft)
+
+  // NOTE - *neighbourhood
+  // these below only work for neighbour pos but that's probably fine as in Abalone we only move to (potentially extended) neighbourhood
+  def dir(dir: Option[String]): Option[Pos]  = dir match {
+    case Some("left")       => this.left
+    case Some("upLeft")     => this.upLeft
+    case Some("upRight")    => this.upRight
+    case Some("right")      => this.right
+    case Some("downRight")  => this.downRight
+    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 {
+      case (0, 1)   => Some("upLeft")
+      case (0, -1)  => Some("downRight")
+      case (1, 1)   => Some("upRight")
+      case (1, 0)   => Some("right")
+      case (-1, 0)  => Some("left")
+      case (-1, -1) => Some("downLeft")
+      case _ => None
+    }
+
+  def isInLine(pos1: Pos, pos2: Pos): Boolean = this.dir(pos1) == pos1.dir(pos2)
+  // *end of note about neighbourhood
 
   @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
@@ -238,7 +274,7 @@ case class Pos private (index: Int) extends AnyVal {
 
   def key                 = file.toString + rank.toString
   def officialNotationKey = s"${File(rank.index).getOrElse("")}${Rank(file.index).getOrElse("")}"
-  override def toString   = officialNotationKey
+  override def toString   = key
 }
 
 object Pos {
@@ -282,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