Scala Connect Four Moving Between Rows - scala

Question

I am trying to make a connect four game in scala. Currently i have it so it prints the board everytime and switches between players asking them to enter which column they want. The problem is I dont know how to change the rows. All 64 moves stay in row 7 (the 1st row). I was thinking of somehow doing a check that will check if there is already an X or O in the spot the user wants to play and just bump up the row. Would i use a if else for this? So if x or o is there move up a row else make move.
// Initialize the grid
val table = Array.fill(9,8)('.')
var i = 0;
while(i < 8){
table(8)(i) = (i+'0').toChar
i = i+1;
}
/* printGrid: Print out the grid provided */
def printGrid(table: Array[Array[Char]]) {
table.foreach( x => println(x.mkString(" ")))
}
var allowedMoves = 64
var spotsLeft = 8
//Player One
def player1(){
printGrid(table)
println("Player 1 it is your turn. Choose a column 0-7")
val move = readInt
table(7)(move) = ('X')
}
//Player Two
def player2(){
printGrid(table)
println("Player 1 it is your turn. Choose a column 0-7")
val move = readInt
table(7)(move) = ('O')
for (turn <- 1 to 32) {
player 1
player 2
}

Answer 1

I am not sure if you're still baffled by my comments, but let me try to give you a more in-depth explanation here.
The code in question is:
//Player One
def player1(){
printGrid(table)
println("Player 1 it is your turn. Choose a column 0-7")
val move = readInt
table(7)(move) = ('X')
}
//Player Two
def player2(){
printGrid(table)
println("Player 1 it is your turn. Choose a column 0-7")
val move = readInt
table(7)(move) = ('O')
}
for (turn <- 1 to 32) {
player1
player2
}
where the players take turns. But before going straight to the answer, let us refactor this code a bit by removing the duplication we have here. player1 and player2 are almost the same implementation. So let us pass the distinct parts as a parameter. The distinct part is the name of the player and the symbol that represents this player in the table. So let us define a class Player:
case class Player(name: String, symbol: Char)
and contract the two functions into one:
def player(player: Player): Unit ={
printGrid(table)
println(s"${player.name} it is your turn. Choose a column 0-7")
val move = readInt
table(7)(move) = player.symbol
}
for (turn <- 1 to 32) {
player(Player("Player 1", 'X'))
player(Player("Player 2", 'O'))
}
Now, we don't have to do everything twice, but the problem is still the same.
Okay, let's say, we are going to use conditionals: If table(7)(move) is occupied, then we choose table(6)(move). However, if this is also occupied, we choose table(5)(move). This goes on, until we find the column is completely full, in which case we may for example want to throw an exception. In code, this would look as follows:
def player(player: Player): Unit = {
printGrid(table)
println(s"${player.name} it is your turn. Choose a column 0-7")
val move = readInt
if (table(7)(move) != '.') {
if (table(6)(move) != '.') {
if (table(5)(move) != '.') {
if (table(4)(move) != '.') {
if (table(3)(move) != '.') {
if (table(2)(move) != '.') {
if (table(1)(move) != '.') {
if (table(0)(move) != '.') {
throw new IllegalArgumentException(s"Column $move is already full")
} else table(0)(move) = player.symbol
} else table(1)(move) = player.symbol
} else table(2)(move) = player.symbol
} else table(3)(move) = player.symbol
} else table(4)(move) = player.symbol
} else table(5)(move) = player.symbol
} else table(6)(move) = player.symbol
} else table(7)(move) = player.symbol
}
Let's run the code and... yay, it works!. But it is terrible code. There is an awful lot of duplication and we couldn't easily make the table bigger.
Okay, what problem do we really want to solve? We want to find the highest index of the row that has a free space at move, i.e., contains a '.' at move.
How could we find this index? There exists a function indexOf that takes an argument x and returns the index of the first occurrence of x in the array. But our array table is a two-dimensional array, and we care only about the value at move in each inner array. Fortunately, every collection in Scala provides a function map to map each element, so we could do: table map (_(move)).
Say that we receive the following array: . . O X O O 2, so the index of the last occurrence of . is 1. But indexOf will return the first index, so indexOf('.') would return 0. We could reverse the array, because finding the first index in the reversed array is equivalent to finding the last index in the array, but this is a bit tricky, as we also need to inverse the index, because the the index in the reversed array is generally not the same as the index in the original array.
Let's apply a little trick: Instead of finding the last index of ., let's find the index of the first element that is not . and subtract one. But the function indexOf does not allow us to pass a not x. However, we can solve this problem by modifying our map function slightly: Instead of table map (_(move)), let's map to table map (_(move) == '.'). Now, we need to find the index of the first false value and subtract one.
The whole solution would look as follows:
def player(player: Player): Unit = {
printGrid(table)
println(s"${player.name} it is your turn. Choose a column 0-7")
val move = readInt
val freeRows = table map (_(move) == '.')
val indexOfLastFreeRow = (freeRows indexOf false) - 1
if (indexOfLastFreeRow == -1) throw new IllegalArgumentException(s"Column $move is already full")
else table(indexOfLastFreeRow)(move) = player.symbol
}
for (turn <- 1 to 32) {
player(Player("Player 1", 'X'))
player(Player("Player 2", 'O'))
}
case class Player(name: String, symbol: Char)
I hope this answer helps. As a final note: I would still not work with plain arrays, but instead define a class Table and Column and let them provide the functionality to add elements, and an appropriate toString to print the table.
case class Table(columns: List[Column]) {
override def toString = (for (i <- 0 until columns.head.values.length) yield {
columns map (_.values(i).toString) reduceLeft (_ + " " + _)
}) reduceLeft (_ + System.lineSeparator + _)
def add(entry: Char, columnIndex: Int): Table = {
val (prefix, column :: suffix) = columns.splitAt(columnIndex)
Table(prefix ++ (column.add(entry) :: suffix))
}
}
object Table {
val EmptyEntry = '.'
def empty(numberOfColumns: Int, numberOfRows: Int): Table =
Table(List.fill(numberOfColumns)(Column.empty(numberOfRows)))
}
case class Column(values: List[Char]) {
def isFull: Boolean = !values.contains(Table.EmptyEntry)
def add(entry: Char): Column = {
if (isFull) this
else {
val (empty, filled) = values.partition(_ == Table.EmptyEntry)
Column(empty.dropRight(1) ++ (entry :: filled))
}
}
}
object Column {
def empty(numberOfRows: Int): Column =
Column(List.fill(numberOfRows)(Table.EmptyEntry))
}