Tic Tac Toe on the command line in Scala

Question

This is my first Scala program, so I'd appreciate any feedback but especially feedback specific to Scala, for example situations where I could have utilised a feature better or where I've done something unidiomatic.

import scala.collection.mutable.HashMap

object Main extends App {
  // Type alias to shorten the Teams enum
  type Team = Teams.Value;

  // Represents a position on the board
  type Coord = (Int, Int)

  // The number of tiles in a row or column of the board
  val BOARD_SIZE = 3;

  // Driver method call to start game loop
  Game.runGame();

  object Game {
    // The team that is due to place an item on the board
    private var teamToMove = Teams.Crosses;

    // True if game is running i.e the game hasn't ended yet due to a win or stalemate
    private var isGameRunning = true;

    // The board being played on by both teams
    private var board = new Board();

    // The driver method that runs the game loop
    def runGame(): Unit = {
      while (isGameRunning) {
        UI.displayBoard(board);

        UI.getUserMove(teamToMove) match {
          case None             => UI.displayInvalidMoveMessage();
          case Some((row, col)) => executeMoveAt(row, col)
        }
      }

      UI.displayBoard(board);
    }

    // Given a move, check if move is valid and apply it to board if it is
    def executeMoveAt(row: Int, col: Int) = {
      if (
        !board.isWithinBounds(row, col) || board.tileAt(row, col) != Teams.None
      ) {
        UI.displayInvalidMoveMessage();
      } else {
        board.setTileAt(row, col, teamToMove);
        handleCaseWhereMoveIsWinner(row, col);
        handleStalemateCase();
        switchTeamToMove();
      }
    }

    def handleCaseWhereMoveIsWinner(row: Int, col: Int): Unit = {
      if (board.isWinner((row, col), teamToMove)) {
        UI.displayWinnerMessage(teamToMove);
        isGameRunning = false;
      }
    }

    def handleStalemateCase(): Unit = {
      if (board.isStalemate()) {
        UI.displayStalemateMessage();
        isGameRunning = false;
      }
    }

    def switchTeamToMove(): Unit = {
      if (teamToMove == Teams.Crosses) {
        teamToMove = Teams.Noughts;
      } else {
        teamToMove = Teams.Crosses;
      }
    }

  }

  class Board {
    // A type alias for the data structure used to represent the board internally
    private type InternalBoard = Array[Array[Team]];

    // The data structure used to represent the board internally
    private var internalBoard = genEmptyInternalBoard();

    // Get the value of the tile at some coordinate
    def tileAt(row: Int, col: Int): Team = {
      return internalBoard(row)(col);
    }

    // Set the tile at some coordinate a given value
    def setTileAt(row: Int, col: Int, team: Team): Unit = {
      internalBoard(row)(col) = team;
    }

    // True if a coordinate is within the bounds of the board
    def isWithinBounds(row: Int, col: Int): Boolean = {
      return row >= 0 && row < BOARD_SIZE && col >= 0 && col < BOARD_SIZE;
    }

    def isStalemate(): Boolean = {
      var isStalemate = true;

      for (row <- 0 to BOARD_SIZE - 1) {
        for (col <- 0 to BOARD_SIZE - 1) {
          if (tileAt(row, col) == Teams.None) {
            isStalemate = false;
          }
        }
      }

      return isStalemate;
    }

    def isWinner(coord: Coord, team: Team): Boolean = {
      return isDiagonalWinner(team) || isSidewaysWinner(coord, team);
    }

    // True if a move by some team has resulted in them winning through a vertical / horizontal N in a row
    def isSidewaysWinner(coord: Coord, team: Team): Boolean = {
      val (row, col) = coord;
      var columnAdjacencyCount = 0;
      var rowAdjacencyCount = 0;

      for (i <- 0 to BOARD_SIZE - 1) {
        if (tileAt(row, i) == team)
          columnAdjacencyCount += 1;
        if (tileAt(i, col) == team) {
          rowAdjacencyCount += 1;
        }
      }

      return rowAdjacencyCount == BOARD_SIZE || columnAdjacencyCount == BOARD_SIZE;
    }

    // True if a move by some team has resulted in them winning through a diagonal N in a row
    def isDiagonalWinner(team: Team): Boolean = {
      var posGradient = true;
      var negGradient = true;

      for (i <- 1 to BOARD_SIZE - 1) {
        if (hasNoPosGradientForIndex(i)) {
          posGradient = false;
        }

        if (hasNoNegGradientForIndex(i)) {
          negGradient = false;
        }
      }

      return posGradient || negGradient;
    }

    private def hasNoPosGradientForIndex(i: Int): Boolean = {
      return tileAt(i, i) != tileAt(i - 1, i - 1) || tileAt(
        i - 1,
        i - 1
      ) == Teams.None
    }

    private def hasNoNegGradientForIndex(i: Int): Boolean = {
      return tileAt(BOARD_SIZE - 1 - i, i) != tileAt(
        BOARD_SIZE - i,
        i - 1
      ) || tileAt(BOARD_SIZE - i, i - 1) == Teams.None
    }

    private def genEmptyInternalBoard(): InternalBoard = {
      val internalBoard = Array.ofDim[Team](BOARD_SIZE, BOARD_SIZE);

      for (row <- 0 to BOARD_SIZE - 1) {
        for (col <- 0 to BOARD_SIZE - 1) {
          internalBoard(row)(col) = Teams.None;
        }
      }

      return internalBoard;
    }
  }

  object UI {
    private val teamToDisplayStr =
      HashMap(Teams.Crosses -> "X", Teams.Noughts -> "O", Teams.None -> " ")

    def displayBoard(board: Board): Unit = {
      for (row <- 0 to BOARD_SIZE - 1) {
        print(" ")
        for (col <- 0 to BOARD_SIZE - 1) {
          print(teamToDisplayStr.get(board.tileAt(row, col)).get)

          if (col < BOARD_SIZE - 1) {
            print(" | ")
          }
        }

        if (row < BOARD_SIZE - 1) {
          println(" ")
          println("   |   |")
          println("---|---|---")
          println("   |   |")
        }
      }

      println("   |   |")
      println();
    }

    def getUserMove(teamToMove: Team): Option[Coord] = {
      val teamToMoveStr = teamToDisplayStr.get(teamToMove).get;

      println(
        s"$teamToMoveStr to move! Select where you want to place in coordinate format"
      )
      println(
        "For example, \"(1, 1)\" would make a move at the top left corner"
      )

      return parseUserInputAsCoord(scala.io.StdIn.readLine());
    }

    def displayInvalidMoveMessage(): Unit = {
      println("Move is invalid!");
    }

    def displayWinnerMessage(team: Team): Unit = {
      val winningTeam = teamToDisplayStr.get(team).get;

      println(s"$winningTeam has won!");
    }

    def displayStalemateMessage(): Unit = {
      println("Game has ended in a stalemate!");
    }

    private def parseUserInputAsCoord(coordAsStr: String): Option[Coord] = {
      val coordAsArray = coordAsStr
        .filter(char => char.isDigit || char == ',')
        .split(",");

      coordAsArray match {
        case Array(col, row) =>
          return Some((row.toInt - 1, col.toInt - 1));
        case _ =>
          return None;
      }
    }
  }

  object Teams extends Enumeration {
    val Noughts, Crosses, None = Value;
  }
}

Answer 1

I've learned a fair amount of Scala conventions since posting this, so I'll leave a few comments on my own code for anyone who comes across this.

The way the Map is used can be improved. For the purpose of setting up a correspondence between enums and how they're displayed on the console, a mutable map isn't needed. An immutable map would have sufficed while also providing the safety of knowing it can't be accidentally modified later on. When getting values from the map it would be less code to call map(key) rather than calling map.get(key).get

The return keyword isn't needed in Scala. Scala blocks of code (i.e anything in between a pair of curly brackets {}) automatically return what the last expression evaluates to, so simply stating the variable is enough.

for (i <- 0 to BOARD_SIZE - 1) can be rewritten as for (i <- 0 until BOARD_SIZE)