ColoredLines: Refining Board: Renamed BoardPlus items to ...boardPlus.

Author: Daniel Barclay

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

@@ -17,36 +17,36 @@ object GameLogicSupport {
 
   // (was "private[this]" before test calls:)
   @tailrec
-  private[game] def pickRandomEmptyCell(board: BoardPlus)(implicit rng: Random): Option[CellAddress] = {
-    if (board.isFull)
+  private[game] def pickRandomEmptyCell(boardPlus: BoardPlus)(implicit rng: Random): Option[CellAddress] = {
+    if (boardPlus.isFull)
       None
     else {
       val row = rowIndices(rng.nextInt(BoardOrder))
       val col = columnIndices(rng.nextInt(BoardOrder))
-      if (board.getBallStateAt(CellAddress(row, col)).isEmpty)
+      if (boardPlus.getBallStateAt(CellAddress(row, col)).isEmpty)
         Some(CellAddress(row, col))
       else
-        pickRandomEmptyCell(board) // loop: try again
+        pickRandomEmptyCell(boardPlus) // loop: try again
     }
   }
 
   /**
    * @param board
    *   expected to be empty //???? maybe refactor something?
    */
-  private[game] def placeInitialBalls(board: BoardPlus)(implicit rng: Random): MoveResult = {
+  private[game] def placeInitialBalls(boardPlus: BoardPlus)(implicit rng: Random): MoveResult = {
     val postPlacementsResult =
       //???? parameterize:
-      (1 to 5).foldLeft(MoveResult(board, false)) {
+      (1 to 5).foldLeft(MoveResult(boardPlus, false)) {
         case (resultSoFar, _) =>
           val address =
-            pickRandomEmptyCell(resultSoFar.board).getOrElse(scala.sys.error("Unexpectedly full board"))
-          val postPlacementBoard = resultSoFar.board.withBallAt(address, pickRandomBallKind())
+            pickRandomEmptyCell(resultSoFar.boardPlus).getOrElse(scala.sys.error("Unexpectedly full board"))
+          val postPlacementBoard = resultSoFar.boardPlus.withBallAt(address, pickRandomBallKind())
           val placementHandlingResult = LineDetector.handleBallArrival(postPlacementBoard, address)
-          MoveResult(placementHandlingResult.board, placementHandlingResult.anyRemovals)
+          MoveResult(placementHandlingResult.boardPlus, placementHandlingResult.anyRemovals)
       }
     //???? parameterize
-    postPlacementsResult.copy(board = postPlacementsResult.board.withOnDeckBalls(List.fill(3)(pickRandomBallKind())))
+    postPlacementsResult.copy(boardPlus = postPlacementsResult.boardPlus.withOnDeckBalls(List.fill(3)(pickRandomBallKind())))
   }
 
   private[game] sealed trait Action
@@ -59,12 +59,12 @@ object GameLogicSupport {
   }
   import Action._
 
-  def interpretTapLocationToTapAction(board: BoardPlus,
+  def interpretTapLocationToTapAction(boardPlus: BoardPlus,
                                       address: CellAddress): Action =
-    tapAndStateToTapAction(onABall            = board.hasABallAt(address),
-                           isSelectedAt       = board.isSelectedAt(address),
-                           hasABallSelected   = board.hasABallSelected,
-                           hasAnyCellSelected = board.hasAnyCellSelected)
+    tapAndStateToTapAction(onABall            = boardPlus.hasABallAt(address),
+                           isSelectedAt       = boardPlus.isSelectedAt(address),
+                           hasABallSelected   = boardPlus.hasABallSelected,
+                           hasAnyCellSelected = boardPlus.hasAnyCellSelected)
 
   private def tapAndStateToTapAction(onABall: Boolean,
                                      isSelectedAt: Boolean,
@@ -110,46 +110,46 @@ object GameLogicSupport {
     action
   }
 
-  private[this] def placeNextBalls(board: BoardPlus)(implicit rng: Random): MoveResult = {
+  private[this] def placeNextBalls(boardPlus: BoardPlus)(implicit rng: Random): MoveResult = {
     val postPlacementResult =
       //???? 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
-      board.getOnDeckBalls
-        .foldLeft(MoveResult(board, false)) {
+      boardPlus.getOnDeckBalls
+        .foldLeft(MoveResult(boardPlus, false)) {
           case (curMoveResult, onDeckBall) =>
-            pickRandomEmptyCell(curMoveResult.board) match {
+            pickRandomEmptyCell(curMoveResult.boardPlus) match {
               case None =>  // board full; break out early (game will become over)
                 curMoveResult
               case Some(address) =>
-                val postDeueueBoard =
-                  curMoveResult.board.withOnDeckBalls(curMoveResult.board.getOnDeckBalls.tail)
-                val postPlacementBoard = postDeueueBoard.withBallAt(address, onDeckBall)
+                val postDeueueBoardPlus =
+                  curMoveResult.boardPlus.withOnDeckBalls(curMoveResult.boardPlus.getOnDeckBalls.tail)
+                val postPlacementBoard = postDeueueBoardPlus.withBallAt(address, onDeckBall)
                 LineDetector.handleBallArrival(postPlacementBoard, address)
             }
         }
     //???? parameterize?
     //????? check re duplicate on-deck code (look for other "fill(3)"
-    postPlacementResult.copy(board = postPlacementResult.board.withOnDeckBalls(List.fill(3)(pickRandomBallKind())))
+    postPlacementResult.copy(boardPlus = postPlacementResult.boardPlus.withOnDeckBalls(List.fill(3)(pickRandomBallKind())))
   }
 
   //???? rename?  isn't _user_ move result; is ball move/placement/arrival result
-  case class MoveResult(board: BoardPlus,
+  case class MoveResult(boardPlus: BoardPlus,
                         //??? clarify re placing next three balls (re interpreting differently in different contexts
                         anyRemovals: Boolean)
   {
     println(s"??? ${this}")
     //??? print("")
   }
 
-  private[game] def doPass(board: BoardPlus)(implicit rng: Random): MoveResult =
-    placeNextBalls(board)
+  private[game] def doPass(boardPlus: BoardPlus)(implicit rng: Random): MoveResult =
+    placeNextBalls(boardPlus)
 
 
   //???: likely move core algorithm out; possibly move outer code into BoardPlus/BoardState:
   /**
    * @param toTapCell - must be empty */
   // (was "private[this]" before test calls:)
-  private[game] def pathExists(board: BoardPlus,
+  private[game] def pathExists(boardPlus: BoardPlus,
                                fromBallCell: CellAddress,
                                toTapCell: CellAddress): Boolean = {
     //???? CLEAN ALL THIS:
@@ -160,7 +160,7 @@ object GameLogicSupport {
     val blockedAt: Array[Array[Boolean]] =
       rowIndices.map { row =>
           columnIndices.map { column =>
-            board.hasABallAt(CellAddress(row, column))
+            boardPlus.hasABallAt(CellAddress(row, column))
           }.toArray
       }.toArray
     val cellsToExpandFrom = mutable.Queue[CellAddress](fromBallCell)
@@ -202,22 +202,22 @@ object GameLogicSupport {
   }
 
 
-  private[game] def doTryMoveBall(board: BoardPlus,  //???? change to game state to carry and update score?
+  private[game] def doTryMoveBall(boardPlus: BoardPlus,  //???? change to game state to carry and update score?
                                   from: CellAddress,
                                   to: CellAddress
                                   )(implicit rng: Random): MoveResult = {
-    val canMoveBall = pathExists(board, from, to)
+    val canMoveBall = pathExists(boardPlus, from, to)
     canMoveBall match {
       case false =>  // can't move--ignore (keep selection state)
-        MoveResult(board, false)
+        MoveResult(boardPlus, false)
       case true =>
-        val deselectedBoard = board.withNoSelection
-        val moveBallColor = deselectedBoard.getBallStateAt(from).get  //????
-        val postMoveBoard = deselectedBoard.withNoBallAt(from).withBallAt(to, moveBallColor)
+        val deselectedBoardPlus = boardPlus.withNoSelection
+        val moveBallColor = deselectedBoardPlus.getBallStateAt(from).get  //????
+        val postMoveBoard = deselectedBoardPlus.withNoBallAt(from).withBallAt(to, moveBallColor)
 
         val postHandlingResult = LineDetector.handleBallArrival(postMoveBoard, to)
         if (! postHandlingResult.anyRemovals )
-          placeNextBalls(postHandlingResult.board)
+          placeNextBalls(postHandlingResult.boardPlus)
         else
           postHandlingResult
     }

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

@@ -24,7 +24,7 @@ private[manual] object GameState {
     val initialPlacementResult = GameLogicSupport.placeInitialBalls(BoardPlus.empty)
     //????? probably split GameState level from slightly lower game state
     //  carrying board plus score (probably modifying MoveResult for that)
-    GameState(initialPlacementResult.board, None)
+    GameState(initialPlacementResult.boardPlus, None)
   }
 
   private[manual/*game*/] def initial(seed: Long): GameState = makeInitialState(new Random(seed))
@@ -38,7 +38,7 @@ import GameState._
  * @constructor
  * @param gameResult  `None` means no win or draw yet
  */
-private[manual] case class GameState(board: BoardPlus,
+private[manual] case class GameState(boardPlus: BoardPlus,
                                      gameResult: Option[GameResult]
                                     )(implicit rng: Random) {
 
@@ -50,36 +50,36 @@ private[manual] case class GameState(board: BoardPlus,
   //  game history
   private[manual] def tryMoveAt(tapAddress: CellAddress): Either[String, GameState] = {
     import GameLogicSupport.Action._
-    val tapAction = GameLogicSupport.interpretTapLocationToTapAction(board, tapAddress)
+    val tapAction = GameLogicSupport.interpretTapLocationToTapAction(boardPlus, tapAddress)
     println("tryMoveAt: tapAction = " + tapAction)
     val moveResult: MoveResult =
       tapAction match {
         case SelectBall |
              SelectEmpty =>
-          MoveResult(board.withCellSelected(tapAddress), false)  //???? ?
+          MoveResult(boardPlus.withCellSelected(tapAddress), false)  //???? ?
         case Deselect    =>
-          MoveResult(board.withNoSelection, false)  //????
+          MoveResult(boardPlus.withNoSelection, false)  //????
         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 =
-            board.getSelectionCoordinates.getOrElse(sys.error("Shouldn't be able to happen"))
-          GameLogicSupport.doTryMoveBall(board, fromAddress, tapAddress)
+            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)
 
         case Pass        =>
-          val passResult = GameLogicSupport.doPass(board)
-          passResult.copy(board = passResult.board.withNoSelection)
+          val passResult = GameLogicSupport.doPass(boardPlus)
+          passResult.copy(boardPlus = passResult.boardPlus.withNoSelection)
       }
 
     val nextState =
-      if (! moveResult.board.isFull) {
-        GameState(moveResult.board, gameResult).asRight
+      if (! moveResult.boardPlus.isFull) {
+        GameState(moveResult.boardPlus, gameResult).asRight
       }
       else {
-        GameState(moveResult.board, Some(Done(moveResult.board.getScore))).asRight
+        GameState(moveResult.boardPlus, Some(Done(moveResult.boardPlus.getScore))).asRight
       }
     nextState
   }

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

@@ -11,8 +11,8 @@ import com.us.dsb.explore.algs.coloredlines.manual.game.board.{BallKind, BoardPl
 object LineDetector {
 
   private[lines] case class LineAxis(labelArray: String,
-                                     rowDelta  : Int, // -1 / 0 / 1 (Make refined type?)
-                                     colDelta  : Int)
+                                     rowDelta: Int, // -1 / 0 / 1 (Make refined type?)
+                                     colDelta: Int)
 
   private[this] val lineAxes =
     List(
@@ -23,27 +23,27 @@ object LineDetector {
   private[this] val relativeDirectionFactors = List(1, -1) // use type of length 2 (refined List?, Tuple2?, some array?)
 
   private[lines] def haveMatchingBallAt(moveBallColor: BallKind,
-                                        board        : BoardPlus,
-                                        rawRowIndex  : Int,
-                                        rawColIndex  : Int): Boolean = {
+                                        boardPlus: BoardPlus,
+                                        rawRowIndex: Int,
+                                        rawColIndex: Int): Boolean = {
     val inRange =
       1 <= rawRowIndex && rawRowIndex <= BoardOrder &&
           1 <= rawColIndex && rawColIndex <= BoardOrder
     val haveMatch =
       inRange && {
         val candidateAddress = CellAddress.fromRaw(rawRowIndex, rawColIndex)
-        board.getBallStateAt(candidateAddress).fold(false)(ball => ball == moveBallColor)
+        boardPlus.getBallStateAt(candidateAddress).fold(false)(ball => ball == moveBallColor)
       }
     haveMatch
   }
 
   private[lines] case class RelativeDirectionResult(excursionLength: Int)
 
-  private[lines] def computeDirectionResult(moveBallColor    : BallKind,
-                                            board            : BoardPlus,
-                                            ballTo           : CellAddress,
+  private[lines] def computeDirectionResult(moveBallColor: BallKind,
+                                            boardPlus: BoardPlus,
+                                            ballTo: CellAddress,
                                             lineDirectionAxis: LineAxis,
-                                            directionFactor  : Int): RelativeDirectionResult = {
+                                            directionFactor: Int): RelativeDirectionResult = {
     val newBallRowIndex = ballTo.row.value.value
     val newBallColIndex = ballTo.column.value.value
     import lineDirectionAxis.{colDelta, rowDelta}
@@ -54,7 +54,7 @@ object LineDetector {
       val candidateColIndex = newBallColIndex + colDelta * directionFactor * candidateExcursionLength
       //??? println(s"    ??.n.0: candidate address: ($candidateRowIndex / $candidateColIndex)")
 
-      val haveMatchingBall = haveMatchingBallAt(moveBallColor, board, candidateRowIndex, candidateColIndex)
+      val haveMatchingBall = haveMatchingBallAt(moveBallColor, boardPlus, candidateRowIndex, candidateColIndex)
       if (haveMatchingBall) {
         excursionLength = candidateExcursionLength
       }
@@ -63,19 +63,19 @@ object LineDetector {
     RelativeDirectionResult(excursionLength)
   }
 
-  private[lines] case class AxisResult(axis               : LineAxis,
+  private[lines] case class AxisResult(axis: LineAxis,
                                        axisLineAddedLength: Int, // length WITHOUT moved ball
-                                       directionDetails   : List[RelativeDirectionResult])
+                                       directionDetails: List[RelativeDirectionResult])
 
-  private[lines] def computeLineAxisResult(moveBallColor    : BallKind,
-                                           board            : BoardPlus,
-                                           ballTo           : CellAddress,
+  private[lines] def computeLineAxisResult(moveBallColor: BallKind,
+                                           boardPlus: BoardPlus,
+                                           ballTo: CellAddress,
                                            lineDirectionAxis: LineAxis): AxisResult = {
     //??? println(s"+  computeLineAxisResult( axis = $lineDirectionAxis ).1")
     val directionsResults: List[RelativeDirectionResult] =
       relativeDirectionFactors.map { directionFactor =>
         computeDirectionResult(moveBallColor,
-                               board,
+                               boardPlus,
                                ballTo,
                                lineDirectionAxis,
                                directionFactor)
@@ -87,10 +87,10 @@ object LineDetector {
     result
   }
 
-  private[lines] def removeCompletedLineBalls(ballTo                  : CellAddress,
-                                              preremovalBoard         : BoardPlus,
+  private[lines] def removeCompletedLineBalls(ballTo: CellAddress,
+                                              preremovalBoardPlus: BoardPlus,
                                               completedLineAxesResults: List[AxisResult]): BoardPlus = {
-    val newBallRemovedBoard = preremovalBoard.withNoBallAt(ballTo)
+    val newBallRemovedBoard = preremovalBoardPlus.withNoBallAt(ballTo)
     val linesRemovedBoard =
       completedLineAxesResults.foldLeft(newBallRemovedBoard) { case (axisBoard, axisResult) =>
         val fromOffset = -axisResult.directionDetails(1).excursionLength
@@ -113,31 +113,31 @@ object LineDetector {
    * None if no line(s) completed; score increment otherwise
    */
   //???? rename?:  harvestAnyLines?
-  private[game] def handleBallArrival(board   : BoardPlus,
-                                      ballTo  : CellAddress
+  private[game] def handleBallArrival(boardPlus: BoardPlus,
+                                      ballTo: CellAddress
                                      ): MoveResult = {
     //println(s"+handleBallArrival(... ballTo = $ballTo...).1")
-    val moveBallColor = board.getBallStateAt(ballTo).get //????
+    val moveBallColor = boardPlus.getBallStateAt(ballTo).get //????
 
     val allAxesResults: List[AxisResult] =
       lineAxes.map { lineAxis =>
-        computeLineAxisResult(moveBallColor, board, ballTo, lineAxis)
+        computeLineAxisResult(moveBallColor, boardPlus, ballTo, lineAxis)
       }
     //??? println("??? allAxesResults:" + allAxesResults.mkString("\n- ", "\n- ", ""))
     val completedLineAxesResults = allAxesResults.filter(_.axisLineAddedLength + 1 >= LineOrder)
     //println("??? completedLineAxesResults:" + completedLineAxesResults.map("- " + _.toString).mkString("\n", "\n", "\n:end"))
     val (boardResult, scoreResult) =
       completedLineAxesResults match {
         case Nil =>
-          (board, None) // return None for score (signal to place 3 more IF ball moved by user)
+          (boardPlus, None) // return None for score (signal to place 3 more IF ball moved by user)
         case linesAxes =>
           val totalBallsBeingRemoved = 1 + linesAxes.map(_.axisLineAddedLength).sum
           println(s" scoreMove(... ballTo = $ballTo...).x totalBallsBeingRemoved = $totalBallsBeingRemoved")
           //???? move?
           // note original game scoring: score = totalBallsBeingRemoved * 4 - 10,
           //  which seems to be from 2 pts per ball in 5-ball line, but 4 for any extra balls in line
           val postLinesRemovalBoard = removeCompletedLineBalls(ballTo,
-                                                               board,
+                                                               boardPlus,
                                                                completedLineAxesResults)
           val ballPlacementScore = 2 * LineOrder + 4 * (totalBallsBeingRemoved - LineOrder)
           (postLinesRemovalBoard.withAddedScore(ballPlacementScore), Some(ballPlacementScore))

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

@@ -50,8 +50,8 @@ private[this] case class GameUIState(gameState: GameState,
       columnIndices.map { column =>
         val scanAddress = CellAddress(row, column)
         val cellStateStr =
-          gameState.board.getCellBallStateChar(gameState.board.getBallStateAt(scanAddress),
-                                               gameState.board.isSelectedAt(scanAddress))
+          gameState.boardPlus.getCellBallStateChar(gameState.boardPlus.getBallStateAt(scanAddress),
+                                               gameState.boardPlus.isSelectedAt(scanAddress))
         if (scanAddress == cursorAddress ) {
           "*" + cellStateStr + "*"
         }
@@ -65,7 +65,7 @@ private[this] case class GameUIState(gameState: GameState,
 
   private[ui] def toDisplayString: String = {
     renderTableMultilineWithSelection + "\n" +
-    s"Score: ${gameState.board.getScore}  " +
+    s"Score: ${gameState.boardPlus.getScore}  " +
         s"Marking cursor: <row ${cursorAddress.row} / column ${cursorAddress.column}>"
   }