ColoredLines: Moved tap-UI selection state up into UpperGameState--not cleaned.

Author: Daniel Barclay

src/main/scala/com/us/dsb/explore/algs/coloredlines/manual/game/GameLogicSupport.scala

@@ -32,7 +32,10 @@ object GameLogicSupport {
   //???? probably split into BoardState-level vs. level of BoardState + score
   case class MoveResult(boardPlus: BoardPlus,
                         //??? clarify re placing next three balls (re interpreting differently in different contexts
-                        anyRemovals: Boolean)
+                        anyRemovals: Boolean,
+                        //?????? clean this hack (used in only one case; re-plumb that case without this):
+                        clearSelection: Boolean
+                       )
   {
     println(s"???  $this")
     //??? print("")
@@ -49,13 +52,13 @@ object GameLogicSupport {
   private[game] def placeInitialBalls(boardPlus: BoardPlus)(implicit rng: Random): MoveResult = {
     val postPlacementsResult =
       //???? parameterize:
-      (1 to 5).foldLeft(MoveResult(boardPlus, false)) {
+      (1 to 5).foldLeft(MoveResult(boardPlus, false, false)) {
         case (resultSoFar, _) =>
           val address =
             pickRandomEmptyCell(resultSoFar.boardPlus).getOrElse(scala.sys.error("Unexpectedly full board"))
           val postPlacementBoardPlus = resultSoFar.boardPlus.withBallAt(address, pickRandomBallKind())
           val placementHandlingResult = LineDetector.handleBallArrival(postPlacementBoardPlus, address)
-          MoveResult(placementHandlingResult.boardPlus, placementHandlingResult.anyRemovals)
+          MoveResult(placementHandlingResult.boardPlus, placementHandlingResult.anyRemovals, false)
       }
 
     val replenishedOnDeckBoard = replenishOnDeckBalls(postPlacementsResult.boardPlus.boardState)
@@ -72,12 +75,12 @@ object GameLogicSupport {
   }
   import Action._
 
-  def interpretTapLocationToTapAction(boardPlus: BoardPlus,
+  def interpretTapLocationToTapAction(tapUiState: UpperGameState,
                                       address: CellAddress): Action =
-    tapAndStateToTapAction(onABall            = boardPlus.hasABallAt(address),
-                           isSelectedAt       = boardPlus.isSelectedAt(address),
-                           hasABallSelected   = boardPlus.hasABallSelected,
-                           hasAnyCellSelected = boardPlus.hasAnyCellSelected)
+    tapAndStateToTapAction(onABall            = tapUiState.boardPlus.hasABallAt(address),
+                           isSelectedAt       = tapUiState.isSelectedAt(address),
+                           hasABallSelected   = tapUiState.hasABallSelected,
+                           hasAnyCellSelected = tapUiState.hasAnyCellSelected)
 
   private def tapAndStateToTapAction(onABall: Boolean,
                                      isSelectedAt: Boolean,
@@ -128,7 +131,7 @@ object GameLogicSupport {
       //???? for 1 to 3, consume on-deck ball from list, and then place (better for internal state view);;
       // can replenish incrementally or later; later might show up better in internal state view
       boardPlus.boardState.getOnDeckBalls
-        .foldLeft(MoveResult(boardPlus, false)) {
+        .foldLeft(MoveResult(boardPlus, false, false)) {
           case (curMoveResult, onDeckBall) =>
             pickRandomEmptyCell(curMoveResult.boardPlus) match {
               case None =>  // board full; break out early (game will become over)
@@ -210,20 +213,29 @@ object GameLogicSupport {
   }
 
 
-  private[game] def doTryMoveBall(boardPlus: BoardPlus,  //???? change to game state to carry and update score?
+  private[game] def doTryMoveBall(boardPlus: BoardPlus,
                                   from: CellAddress,
                                   to: CellAddress
                                   )(implicit rng: Random): MoveResult = {
+    //?????? re-plumb returning indication of whether to clear selection
+    // - first, pull clear-selection flag out of (current) MoveResult; return
+    //   tuple or wrapper move-result adding flag
+    // - eventually, separate move-ball move validation from actually moving
+    //   (selection clearing depends on just validity of move, not on deleting
+    //   any lines)
+    //   - see note near some Option/etc. re encoding only valid moves at
+    //     that point in move-execution path
     val canMoveBall = pathExists(boardPlus, from, to)
     canMoveBall match {
       case false =>  // can't move--ignore (keep selection state)
-        MoveResult(boardPlus, false)
+        MoveResult(boardPlus, anyRemovals = false, clearSelection = false)
       case true =>
-        val deselectedBoardPlus = boardPlus.withNoSelection
-        val moveBallColor = deselectedBoardPlus.getBallStateAt(from).get  //????
-        val postMoveBoard = deselectedBoardPlus.withNoBallAt(from).withBallAt(to, moveBallColor)
+        val moveBallColor = boardPlus.getBallStateAt(from).get  //????
+        val postMoveBoard = boardPlus.withNoBallAt(from).withBallAt(to, moveBallColor)
 
-        val postHandlingResult = LineDetector.handleBallArrival(postMoveBoard, to)
+        val postHandlingResult =
+          LineDetector.handleBallArrival(postMoveBoard, to)
+              .copy(clearSelection = true)
         if (! postHandlingResult.anyRemovals )
           placeNextBalls(postHandlingResult.boardPlus)
         else

src/main/scala/com/us/dsb/explore/algs/coloredlines/manual/game/UpperGameState.scala

@@ -14,7 +14,7 @@ private[manual] object UpperGameState {
   /**
    * Result of completed game.
    */
-  private[manual] sealed trait GameResult //???? change to final score (and maybe stats?)
+  private[manual] sealed trait GameResult
   private[manual] object GameResult {
     private[manual] case class Done(score: Int) extends GameResult
   }
@@ -23,7 +23,7 @@ private[manual] object UpperGameState {
     val initialPlacementResult = GameLogicSupport.placeInitialBalls(BoardPlus.empty)
     //????? probably split GameState level from slightly lower game state
     //  carrying board plus score (probably modifying MoveResult for that)
-    UpperGameState(initialPlacementResult.boardPlus, None)
+    UpperGameState(initialPlacementResult.boardPlus, None, None)
   }
 
   private[manual/*game*/] def initial(seed: Long): UpperGameState = makeInitialState(new Random(seed))
@@ -35,12 +35,30 @@ import UpperGameState._
 
 /** Game state AND currently controller.
  * @constructor
- * @param gameResult  `None` means no win or draw yet
+ * @param gameResult
+ *   `None` means not ended yet
  */
 private[manual] case class UpperGameState(boardPlus: BoardPlus,
+                                          selectionAddress: Option[CellAddress],
                                           gameResult: Option[GameResult]
                                          )(implicit rng: Random) {
 
+  // top-UI selection:
+
+  private[manual /*game*/ ] def withCellSelected(address: CellAddress): UpperGameState =
+    copy(selectionAddress = Some(address))
+
+  private[manual/*game*/] def withNoSelection: UpperGameState =
+    copy(selectionAddress = None)
+
+  private[manual/*game*/] def hasAnyCellSelected: Boolean = selectionAddress.isDefined
+  private[manual/*game*/] def getSelectionCoordinates: Option[CellAddress] = selectionAddress
+  private[manual] def isSelectedAt(address: CellAddress): Boolean =
+    selectionAddress.fold(false)(_ == address)
+
+  private[game] def hasABallSelected: Boolean =
+    selectionAddress.fold(false)(boardPlus.hasABallAt(_))
+
   //????? Probably move to GameLogicSupport
 
   // ?? later refine from Either[String, ...] to "fancier" error type
@@ -49,36 +67,49 @@ private[manual] case class UpperGameState(boardPlus: BoardPlus,
   //  game history
   private[manual] def tryMoveAt(tapAddress: CellAddress): Either[String, UpperGameState] = {
     import GameLogicSupport.Action._
-    val tapAction = GameLogicSupport.interpretTapLocationToTapAction(boardPlus, tapAddress)
+    val tapAction = GameLogicSupport.interpretTapLocationToTapAction(this, tapAddress)
     println("tryMoveAt: tapAction = " + tapAction)
-    val moveResult: MoveResult =
+    val postMoveState: UpperGameState =
       tapAction match {
         case SelectBall |
              SelectEmpty =>
-          MoveResult(boardPlus.withCellSelected(tapAddress), false)  //???? ?
+          this.withCellSelected(tapAddress)
         case Deselect    =>
-          MoveResult(boardPlus.withNoSelection, false)  //????
+          this.withNoSelection
         case TryMoveBall =>
           //???? should TryMoveBall carry coordinates?:
           //???? need to split logical moves/plays (e.g., move ball from source
           // to target from top-/selection-level ~UI (keep that separate from cursor-to-taps UI))
           val fromAddress =
-            boardPlus.getSelectionCoordinates.getOrElse(sys.error("Shouldn't be able to happen"))
-          GameLogicSupport.doTryMoveBall(boardPlus, fromAddress, tapAddress)
-          //???? try to move (conditional) .withNoSelection out of doTryMoveBall
-          //  up to here; need additional could-move flag (addedScore None would be ambiguous)
+            this.getSelectionCoordinates.getOrElse(sys.error("Shouldn't be able to happen"))
+
+          val tryMoveResult =
+            GameLogicSupport.doTryMoveBall(boardPlus, fromAddress, tapAddress)
 
+          //?????? clean:
+          val xxx =
+            if (tryMoveResult.clearSelection)
+              this.withNoSelection
+            else
+              this
+          xxx.copy(boardPlus = tryMoveResult.boardPlus)
         case Pass        =>
           val passResult = GameLogicSupport.doPass(boardPlus)
-          passResult.copy(boardPlus = passResult.boardPlus.withNoSelection)
+          //?????? clean the several "this."
+          this.copy(boardPlus = passResult.boardPlus)
+              .withNoSelection
       }
 
     val nextState =
-      if (! moveResult.boardPlus.isFull) {
-        UpperGameState(moveResult.boardPlus, gameResult).asRight
+      if (! postMoveState.boardPlus.isFull) {
+        //?????? use .copy
+        UpperGameState(postMoveState.boardPlus, postMoveState.selectionAddress, gameResult).asRight
       }
       else {
-        UpperGameState(moveResult.boardPlus, Some(GameResult.Done(moveResult.boardPlus.getScore))).asRight
+        UpperGameState(postMoveState.boardPlus,
+                       postMoveState.selectionAddress,
+                       Some(GameResult.Done(postMoveState.boardPlus.getScore))
+                       ).asRight
       }
     nextState
   }

src/main/scala/com/us/dsb/explore/algs/coloredlines/manual/game/board/BoardPlus.scala

@@ -2,27 +2,24 @@ package com.us.dsb.explore.algs.coloredlines.manual.game.board
 
 private[game] object BoardPlus {
 
-  private[game] def empty: BoardPlus = new BoardPlus(BoardState.empty,0, None)
+  private[game] def empty: BoardPlus = new BoardPlus(BoardState.empty, 0)
 }
 
 //???? move tap-UI selection state out of this low-level game state
 /**
  * CURRENTLY:  Core board state (now wrapped), not score yet, tap-UI selection state
  */
 private[game] class BoardPlus(private[manual] val boardState: BoardState,
-                              private[this] val score: Int,
-                              //???? move to (low-level) tap-UI state:
-                              private[this] val selectionAddress: Option[CellAddress]
+                              private[this] val score: Int
                              ) {
   println("??? BoardPlus : " + this)
   //print("")
 
   // internal/support methods:
 
-  private[this] def copy(boardState: BoardState                = boardState,
-                         score: Int                            = score,
-                         selectionAddress: Option[CellAddress] = selectionAddress) =
-    new BoardPlus(boardState, score, selectionAddress)
+  private[this] def copy(boardState: BoardState = boardState,
+                         score: Int             = score) =
+    new BoardPlus(boardState, score)
 
   // grid balls:
 
@@ -41,12 +38,6 @@ private[game] class BoardPlus(private[manual] val boardState: BoardState,
     copy(boardState = boardState.withNoBallAt(address))
 
 
-  private[game] def withCellSelected(address: CellAddress): BoardPlus =
-    copy(selectionAddress = Some(address))
-
-  private[game] def withNoSelection: BoardPlus =
-    copy(selectionAddress = None)
-
   //???? move out?
   private[manual] def getCellBallStateChar(ballState: Option[BallKind], isSelected: Boolean): String = {
     ballState match {
@@ -67,21 +58,13 @@ private[game] class BoardPlus(private[manual] val boardState: BoardState,
 
   private[manual] def getScore: Int = score
 
-  // top-UI selection:
-
-  private[game] def hasAnyCellSelected: Boolean = selectionAddress.isDefined
-  private[game] def getSelectionCoordinates: Option[CellAddress] = selectionAddress
-  private[manual] def isSelectedAt(address: CellAddress): Boolean =
-    selectionAddress.fold(false)(_ == address)
-
-  private[game] def hasABallSelected: Boolean = selectionAddress.fold(false)(hasABallAt)
 
   // renderings:
 
   /** Makes compact single-line string. */
   override def toString: String = "< " + boardState.toString + "; " + score + " pts" + ">"
 
-  private[this] def renderMultiline: String = {
+  private[this] def renderMultiline(selectionAddress: Option[CellAddress]): String = {
     val cellWidth = " X ".length
     val cellSeparator = "|"
     val wholeWidth =
@@ -92,16 +75,18 @@ private[game] class BoardPlus(private[manual] val boardState: BoardState,
     rowIndices.map { row =>
       columnIndices.map { column =>
         val addr = CellAddress(row, column)
-        "" + getCellBallStateChar(getBallStateAt(addr), isSelectedAt(addr)) + " "
+        val isSelected = selectionAddress.fold(false)(_ == addr)
+        "" + getCellBallStateChar(getBallStateAt(addr), isSelected) + " "
       }.mkString(cellSeparator)  // make each row line
     }.mkString(rowSeparator)     // make whole-board multi-line string
   }
 
-  private[this] def renderCompactMultiline: String = {
+  private[this] def renderCompactMultiline(selectionAddress: Option[CellAddress]): String = {
     rowIndices.map { row =>
       columnIndices.map { column =>
         val addr = CellAddress(row, column)
-        getCellBallStateChar(getBallStateAt(addr), isSelectedAt(addr))
+        val isSelected = selectionAddress.fold(false)(_ == addr)
+        getCellBallStateChar(getBallStateAt(addr), isSelected)
       }.mkString("|")  // make each row line
     }.mkString("\n")
   }

src/main/scala/com/us/dsb/explore/algs/coloredlines/manual/game/lines/LineDetector.scala

@@ -144,7 +144,7 @@ object LineDetector {  //????? adjust most from using BoardPlus to using just Bo
           (postLinesRemovalBoard.withAddedScore(ballPlacementScore), Some(ballPlacementScore))
       }
     //println(s"-handleBallArrival(... ballTo = $ballTo...).9 = score result = $scoreResult")
-    MoveResult(boardResult, scoreResult.isDefined)
+    MoveResult(boardResult, scoreResult.isDefined, false)
   }
 
 }

src/main/scala/com/us/dsb/explore/algs/coloredlines/manual/ui/GameUIState.scala

@@ -51,7 +51,7 @@ private[this] case class GameUIState(gameState: UpperGameState,
         val scanAddress = CellAddress(row, column)
         val cellStateStr =
           gameState.boardPlus.getCellBallStateChar(gameState.boardPlus.getBallStateAt(scanAddress),
-                                               gameState.boardPlus.isSelectedAt(scanAddress))
+                                                   gameState.isSelectedAt(scanAddress))
         if (scanAddress == cursorAddress ) {
           "*" + cellStateStr + "*"
         }

src/test/scala/com/us/dsb/explore/algs/coloredlines/manual/game/UpperGameStateTest.scala

@@ -1,11 +1,58 @@
 package com.us.dsb.explore.algs.coloredlines.manual.game
 
+import com.us.dsb.explore.algs.coloredlines.manual.game.board.{BoardPlus, CellAddress, ColumnIndex, Index, RowIndex, columnIndices, rowIndices}
+
+import org.scalatest.PrivateMethodTester
 import org.scalatest.funspec.AnyFunSpec
-import cats.syntax.option._
-import com.us.dsb.explore.algs.coloredlines.manual.game.board.{ColumnIndex, Index, RowIndex}
+import org.scalatest.matchers.should.Matchers._
+
 
 class UpperGameStateTest extends AnyFunSpec {
 
+  describe("GameState selection:") {
+    //???? randomize?
+    lazy val someRow = rowIndices.head
+    lazy val someCol = columnIndices.head
+    lazy val upperGameState0 = UpperGameState.initial()
+    lazy val address = CellAddress(someRow, someCol)
+
+    describe("hasAnyCellSelected should:") {
+      it("- return false for fresh, initial game state") {
+        upperGameState0.hasAnyCellSelected shouldBe false
+      }
+      it("- return true for game state with selection") {
+        val selectedGameState = upperGameState0.withCellSelected(address)
+        selectedGameState.hasAnyCellSelected shouldBe true
+      }
+    }
+
+    describe("withCellSelected should") {
+      lazy val selectedGameState = upperGameState0.withCellSelected(address)
+
+      it("- select _something_") {
+        selectedGameState.hasAnyCellSelected shouldBe true
+      }
+      it("- select _specified_ cell") {
+        selectedGameState.isSelectedAt(address) shouldBe true
+      }
+    }
+
+    describe("withNoSelection should:") {
+      lazy val selectedGameState = upperGameState0.withCellSelected(address)
+      lazy val deselectedGameState = selectedGameState.withNoSelection
+
+      it("- deselect (anything)") {
+        deselectedGameState.hasAnyCellSelected shouldBe false
+      }
+      it("- deselect selected cell") {
+        deselectedGameState.isSelectedAt(address) shouldBe false
+      }
+    }
+    //???? test works when no selection anyway
+    //???? test isSelectedAt matches row/column with withCellSelected
+  }
+  
+  
   describe("XxGameState$?. tryMoveAt") {
 //    import Player._
     import scala.language.implicitConversions