ManualTicTacToe: Simplified and clarified hasThreeInARow.

Author: Daniel Barclay

src/main/scala/com/us/dsb/explore/algs/ttt/manual/ManualTicTacToe.scala

@@ -4,7 +4,7 @@ import com.us.dsb.explore.algs.ttt.manual.ui.{ColoredConsoleTextIO, GameUI}
 
 object ManualTicTacToe extends App {
 
-  val gameResult = GameUI.runGame(ColoredConsoleTextIO)  // ?? specify starting user?
+  val gameResult = GameUI.runGame(ColoredConsoleTextIO)
   println("Game result: " + gameResult.text)
 
 }

src/main/scala/com/us/dsb/explore/algs/ttt/manual/game/Board.scala

@@ -53,32 +53,33 @@ private[game] class Board(private val cellStates: Vector[Cell]) {
   def hasNoMovesLeft: Boolean = ! cellStates.exists(_.state.isEmpty)
 
 
-  // (note almost completely unoptimized; do we care?)
-  // ?? revisit passing player (which made check simpler)
-  def hasThreeInARow(player: Player): Boolean = {
-    // ?? Q: How to use Tuple3 in data and then convert to or use as 3-element
-    //   List and call .forall?
-    // ?? any way auto-generate this simply?  or factor out repeated cell pairs?
-    type CellRawIndices = Tuple2[Int, Int]
-    val linesData: List[Tuple3[CellRawIndices, CellRawIndices, CellRawIndices]] =
-      List(
-        ((1, 1), (1, 2), (1, 3)),
-        ((2, 1), (2, 2), (2, 3)),
-        ((3, 1), (3, 2), (3, 3)),
-        ((1, 1), (2, 1), (3, 1)),
-        ((1, 2), (2, 2), (3, 2)),
-        ((1, 3), (2, 3), (3, 3)),
-        ((1, 1), (2, 2), (3, 3)),
-        ((1, 3), (2, 2), (3, 1))
-    )
-    // See if there _exists_ line where _all_ cells are marked by user:
+  // ?? Q: How to use Tuple3 in data and then convert to or use as 3-element
+  //   List and call .forall?
+  // ?? any way auto-generate this simply?  or factor out repeated cell pairs?
+  private type CellRawIndices = Tuple2[Int, Int]
+  private val linesData: List[Tuple3[CellRawIndices, CellRawIndices, CellRawIndices]] =
+        List(
+          ((1, 1), (1, 2), (1, 3)),
+          ((2, 1), (2, 2), (2, 3)),
+          ((3, 1), (3, 2), (3, 3)),
+          ((1, 1), (2, 1), (3, 1)),
+          ((1, 2), (2, 2), (3, 2)),
+          ((1, 3), (2, 3), (3, 3)),
+          ((1, 1), (2, 2), (3, 3)),
+          ((1, 3), (2, 2), (3, 1)))
+
+  def hasThreeInARow: Boolean = {
+    // See if there _exists_ line where _all_ cells are marked by the same player:
     linesData.exists { case (cell1, cell2, cell3) =>
-      val lineList = List(cell1, cell2, cell3)
-      lineList.forall { case (row, column) =>
-        player.some ==
-            getMarkAt(RowIndex(Index.unsafeFrom(row)),
-                      ColumnIndex(Index.unsafeFrom(column)))
+      val lineCellValues =
+        List(cell1, cell2, cell3) .map { case (row, column) =>
+              getMarkAt(RowIndex(Index.unsafeFrom(row)),
+                        ColumnIndex(Index.unsafeFrom(column)))
         }
+      // if first not None and all same as that first one:
+      // compare all to first (if not None)
+      val firstCellState = lineCellValues.head  // .get -- list size > 0
+      firstCellState.isDefined && lineCellValues.forall(_ == firstCellState)
     }
   }
 

src/main/scala/com/us/dsb/explore/algs/ttt/manual/game/GameState.scala

@@ -41,7 +41,7 @@ case class GameState(board: Board,
       case None =>
         val markedBoard = board.withCellMarkedForPlayer(row, column, currentPlayer)
         val newGameResult =
-          if (markedBoard.hasThreeInARow(currentPlayer)) {
+          if (markedBoard.hasThreeInARow) {
             GameState.GameResult.Win(currentPlayer).some
           }
           else if (markedBoard.hasNoMovesLeft) {

src/test/scala/com/us/dsb/explore/algs/ttt/manual/game/BoardTest.scala

@@ -200,37 +200,48 @@ class BoardTest extends AnyFunSpec {
     implicit def intToRow(int: Int) = RowIndex(Index.unsafeFrom(int))
     implicit def intToCol(int: Int) = ColumnIndex(Index.unsafeFrom(int))
 
+    lazy val `<XX-/---/OO->` = {
+      Board.initial
+          .withCellMarkedForPlayer(1, 1, X)
+          .withCellMarkedForPlayer(3, 1, O)
+          .withCellMarkedForPlayer(1, 2, X)
+          .withCellMarkedForPlayer(3, 2, O)
+    }
+    lazy val `<XXX/---/OO->` = {
+      `<XX-/---/OO->`
+          .withCellMarkedForPlayer(1, 3, X)
+    }
+    lazy val `<XX-/X--/OOO>` = {
+      `<XX-/---/OO->`
+          .withCellMarkedForPlayer(2, 1, X)
+          .withCellMarkedForPlayer(3, 3, O)
+    }
+
     it("should not detect for empty board") {
       val testBoard = Board.initial
-      assertResult(false, s" (from .hasThreeInARow(X) for $testBoard)") {
-        testBoard.hasThreeInARow(X)
+      assertResult(false, s" (from .hasThreeInARow for $testBoard)") {
+        testBoard.hasThreeInARow
       }
     }
 
-    lazy val `<XXX/---/OO->` = {
-        Board.initial
-            .withCellMarkedForPlayer(1, 1, X)
-            .withCellMarkedForPlayer(3, 1, O)
-            .withCellMarkedForPlayer(1, 2, X)
-            .withCellMarkedForPlayer(3, 2, O)
-            .withCellMarkedForPlayer(1, 3, X)
-    }
-
-    it("should detect for some three-in-a-row case, w/right player") {
-      assertResult(true, s" (from .hasThreeInARow(X) for ${`<XXX/---/OO->`})") {
-        `<XXX/---/OO->`.hasThreeInARow(X)
+    it("should detect for some three-in-a-row case for X ") {
+      assertResult(true, s" (from .hasThreeInARow for ${`<XXX/---/OO->`})") {
+        `<XXX/---/OO->`.hasThreeInARow
       }
     }
 
-    it("should not detect for wrong player") {
-      assertResult(false, s" (from .hasThreeInARow(O) for ${`<XXX/---/OO->`})") {
-        `<XXX/---/OO->`.hasThreeInARow(O)
+    it("should for detect some three-in-a-row case for O") {
+      assertResult(true, s" (from .hasThreeInARow for ${`<XX-/X--/OOO>`})") {
+        `<XX-/X--/OOO>`.hasThreeInARow
       }
     }
 
     ignore("possibly check all lines (algorithmically)") {
     }
 
+    ignore("possibly check more/all non-wins (algorithmically)") {
+    }
+
   }
 
   describe("Board.vectorIndex (private method we want to test directly):") {