luxick/libmttt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor constuctors and Mark enum

Browse Source
This commit is contained in:
luxick
2019-11-20 19:05:22 +01:00
parent e1841d35be
commit be953892dc
3 changed files with 136 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
src/libmttt.nim
View File

@@ -1,25 +1,25 @@
import sets, strformat, options, sequtils import sets, options, sequtils
type type
## A game board is a simple 2 dimensional array. ## A game board is a 2 dimensional array.
## Markers of any type can be placed inside the cells ## Markers of any type can be placed inside the cells
Board*[T] = array[3, array[3, T]] Board*[T] = array[3, array[3, T]]
## A Position in a board ## A Position on a board
Coordinate* = tuple[x: int, y:int] Coordinate* = tuple[x: int, y:int]
Player* = ref object Player* = ref object
mark*: Mark mark*: Mark
name*: string name*: string
Mark* = enum Mark* {.pure.} = enum
mPlayer1, ## The mark of the fist player Player1, ## The mark of the fist player
mPlayer2, ## The mark of the second player Player2, ## The mark of the second player
mFree, ## This mark signals that a cell is empty Free, ## This mark signals that a cell is empty
mDraw ## Special mark to indicate the game has ended in a draw Draw ## Special mark to indicate the game has ended in a draw
GameState* = ref object GameState* = ref object
## Contains all state for a pint in the game ## Contains all state for a game
board*: Board[Board[Mark]] board*: Board[Board[Mark]]
players*: array[2, Player] players*: array[2, Player]
currentPlayer*: Player currentPlayer*: Player
@@ -28,20 +28,11 @@ type
turn*: int turn*: int
IllegalMoveError* = object of Exception IllegalMoveError* = object of Exception
IIlegalStateError* = object of Exception
proc `$`*(player: Player): string = ###################################################
$player.name # Constructors
###################################################
proc `$`*(player: ref Player): string =
$player.name
proc `$`*(game: GameState): string =
&"""
Game is in turn {$game.turn}
Players are: '{$game.players[0]}' and '{$game.players[1]}'
Current player: '{$game.currentPlayer}'
Game state is: {$game.result}
"""
proc newBoard[T](initial: T): Board[T] = proc newBoard[T](initial: T): Board[T] =
## Create a new game board filled with the initial value ## Create a new game board filled with the initial value
@@ -51,23 +42,15 @@ proc newBoard[T](initial: T): Board[T] =
[initial, initial, initial] [initial, initial, initial]
] ]
proc newMetaBoard[T](val: T): Board[Board[T]] = proc newGameState*(player1: var Player, player2: var Player): GameState =
## Create the meta board, composed out of 9 normal boards. ## Initializes a new game state with the passed players
[ player1.mark = Mark.Player1
[newBoard(val), newBoard(val), newBoard(val)], player2.mark = Mark.Player2
[newBoard(val), newBoard(val), newBoard(val)],
[newBoard(val), newBoard(val), newBoard(val)]
]
proc newGame*(player1: var Player, player2: var Player): GameState =
## Create a new game board
player1.mark = mPlayer1
player2.mark = mPlayer2
GameState( GameState(
players: [player1, player2], players: [player1, player2],
currentPlayer: player1, currentPlayer: player1,
result: mFree, result: Mark.Free,
board: newMetaBoard(mFree)) board: newBoard(newBoard(Mark.Free)))
################################################### ###################################################
# Board Checking # Board Checking
@@ -75,28 +58,29 @@ proc newGame*(player1: var Player, player2: var Player): GameState =
proc selectResult(states: HashSet[Mark]): Mark = proc selectResult(states: HashSet[Mark]): Mark =
## Analyse a set of results and select the correct one ## Analyse a set of results and select the correct one
if states.contains(mPlayer1) and if states.contains(Mark.Player1) and
states.contains(mPlayer2): states.contains(Mark.Player2):
raise newException(Exception, "Both players cannot win at the same time") raise newException(IIlegalStateError, "Both players cannot win at the same time")
if states.contains(mPlayer1): if states.contains(Mark.Player1):
return mPlayer1 return Mark.Player1
if states.contains(mPlayer2): if states.contains(Mark.Player2):
return mPlayer2 return Mark.Player2
if states.contains(mFree): if states.contains(Mark.Free):
return mFree return Mark.Free
return mDraw return Mark.Draw
proc checkRow(row: array[3, Mark]): Mark = proc checkRow(row: array[3, Mark]): Mark =
## Evaluates a single row of a board
var tokens = toHashSet(row) var tokens = toHashSet(row)
# A player has won # A player has won
if tokens.len == 1 and not tokens.contains(mFree): if tokens.len == 1 and not tokens.contains(Mark.Free):
return tokens.pop() return tokens.pop()
# The row is full # The row is full
if tokens.len == 2 and not tokens.contains(mFree): if tokens.len == 2 and not tokens.contains(Mark.Free):
return mDraw return Mark.Draw
# There are still cells free in this row # There are still cells free in this row
return mFree return Mark.Free
proc checkRows(board: Board[Mark]): Mark = proc checkRows(board: Board[Mark]): Mark =
## Iterate over all rows of this board and return the result. ## Iterate over all rows of this board and return the result.
@@ -109,13 +93,13 @@ proc checkRows(board: Board[Mark]): Mark =
proc checkDiagonals(board: Board[Mark]): Mark = proc checkDiagonals(board: Board[Mark]): Mark =
var states: HashSet[Mark] var states: HashSet[Mark]
states.init() states.init()
var topToBottom: array[3, Mark] var criss: array[3, Mark] # Top left to bottom right cell
var bottomToTop: array[3, Mark] var cross: array[3, Mark] # Bottom left to top right cell
for x in 0 .. 2: for x in 0 .. 2:
topToBottom[x] = board[x][x] criss[x] = board[x][x]
bottomToTop[x] = board[2-x][x] cross[x] = board[2-x][x]
states.incl(checkRow(topToBottom)) states.incl(checkRow(criss))
states.incl(checkRow(bottomToTop)) states.incl(checkRow(cross))
return states.selectResult() return states.selectResult()
proc checkBoard*(board: Board[Mark]): Mark = proc checkBoard*(board: Board[Mark]): Mark =
@@ -123,7 +107,7 @@ proc checkBoard*(board: Board[Mark]): Mark =
# Create a seconded, transposed board. # Create a seconded, transposed board.
# This way 'checkRows' can be used to check the columns # This way 'checkRows' can be used to check the columns
var transposed = newBoard(mFree); var transposed = newBoard(Mark.Free);
for x in 0 .. 2: for x in 0 .. 2:
for y in 0 .. 2: for y in 0 .. 2:
transposed[x][y] = board[y][x] transposed[x][y] = board[y][x]
@@ -140,7 +124,7 @@ proc checkBoard*(board: Board[Board[Mark]]): Mark =
## Perform a check on a metaboard to see the overall game result ## Perform a check on a metaboard to see the overall game result
# This temporary board will hold the intermediate results from each sub board # This temporary board will hold the intermediate results from each sub board
var subResults = newBoard(mFree) var subResults = newBoard(Mark.Free)
var states: HashSet[Mark] var states: HashSet[Mark]
states.init() states.init()
for x in 0 .. 2: for x in 0 .. 2:
@@ -161,7 +145,7 @@ proc makeMove*(state: GameState, cell: Coordinate): GameState =
let board = state.currentBoard.get() let board = state.currentBoard.get()
var currBoard = state.board[board.x][board.y] var currBoard = state.board[board.x][board.y]
if currBoard[cell.x][cell.y] != mFree: if currBoard[cell.x][cell.y] != Mark.Free:
raise newException(IllegalMoveError, "Chosen cell is not free") raise newException(IllegalMoveError, "Chosen cell is not free")
state.board[board.x][board.y][cell.x][cell.y] = state.currentPlayer.mark state.board[board.x][board.y][cell.x][cell.y] = state.currentPlayer.mark
@@ -169,11 +153,11 @@ proc makeMove*(state: GameState, cell: Coordinate): GameState =
state.result = checkBoard(state.board) state.result = checkBoard(state.board)
# Exit early. The game has ended. # Exit early. The game has ended.
if state.result != mFree: if state.result != Mark.Free:
return state return state
let nextBoard = checkBoard(state.board[cell.x][cell.y]) let nextBoard = checkBoard(state.board[cell.x][cell.y])
if nextBoard == mFree: if nextBoard == Mark.Free:
state.currentBoard = cell.some() state.currentBoard = cell.some()
else: else:
state.currentBoard = none(Coordinate) state.currentBoard = none(Coordinate)
@@ -184,7 +168,7 @@ proc makeMove*(state: GameState, cell: Coordinate): GameState =
return state return state
proc makeMove*(state: GameState, cell: Coordinate, boardChoice: Coordinate): GameState = proc makeMove*(state: GameState, cell: Coordinate, boardChoice: Coordinate): GameState =
if checkBoard(state.board[boardChoice.x][boardChoice.y]) != mFree: if checkBoard(state.board[boardChoice.x][boardChoice.y]) != Mark.Free:
raise newException(IllegalMoveError, "Player must choose an open board to play in") raise newException(IllegalMoveError, "Player must choose an open board to play in")
if state.currentBoard.isSome: if state.currentBoard.isSome:
raise newException(IllegalMoveError, "Player does not have free choice for board") raise newException(IllegalMoveError, "Player does not have free choice for board")

140
tests/testChecks.nim
View File

@@ -14,146 +14,146 @@ suite "Test the board result checker":
var var
player1 = Player(name: "Adam") player1 = Player(name: "Adam")
player2 = Player(name: "Eve") player2 = Player(name: "Eve")
game: GameState = newGame(player1, player2) game: GameState = newGameState(player1, player2)
test "winning row": test "winning row":
game.board[0][0] = [ game.board[0][0] = [
[mFree, mFree, mFree], [Mark.Free, Mark.Free, Mark.Free],
[mPlayer1, mPlayer1, mPlayer1], [Mark.Player1, Mark.Player1, Mark.Player1],
[mFree, mFree, mFree] [Mark.Free, Mark.Free, Mark.Free]
] ]
check checkBoard(game.board[0][0]) == mPlayer1 check checkBoard(game.board[0][0]) == Mark.Player1
test "winning column": test "winning column":
game.board[0][0] = [ game.board[0][0] = [
[mPlayer2, mFree, mPlayer1], [Mark.Player2, Mark.Free, Mark.Player1],
[mPlayer2, mPlayer1, mFree], [Mark.Player2, Mark.Player1, Mark.Free],
[mPlayer2, mPlayer1, mFree] [Mark.Player2, Mark.Player1, Mark.Free]
] ]
check checkBoard(game.board[0][0]) == mPlayer2 check checkBoard(game.board[0][0]) == Mark.Player2
test "winning diagonals": test "winning diagonals":
game.board[0][0] = [ game.board[0][0] = [
[mFree, mFree, mPlayer2], [Mark.Free, Mark.Free, Mark.Player2],
[mFree, mPlayer2, mFree], [Mark.Free, Mark.Player2, Mark.Free],
[mPlayer2, mFree, mFree] [Mark.Player2, Mark.Free, Mark.Free]
] ]
check(checkBoard(game.board[0][0]) == mPlayer2) check(checkBoard(game.board[0][0]) == Mark.Player2)
game.board[0][0] = [ game.board[0][0] = [
[mPlayer1, mPlayer2, mPlayer2], [Mark.Player1, Mark.Player2, Mark.Player2],
[mPlayer2, mPlayer1, mPlayer1], [Mark.Player2, Mark.Player1, Mark.Player1],
[mPlayer2, mFree, mPlayer1] [Mark.Player2, Mark.Free, Mark.Player1]
] ]
check(checkBoard(game.board[0][0]) == mPlayer1) check(checkBoard(game.board[0][0]) == Mark.Player1)
test "board is a draw": test "board is a draw":
game.board[0][0] = [ game.board[0][0] = [
[mPlayer1, mPlayer2, mPlayer1], [Mark.Player1, Mark.Player2, Mark.Player1],
[mPlayer2, mPlayer1, mPlayer1], [Mark.Player2, Mark.Player1, Mark.Player1],
[mPlayer2, mPlayer1, mPlayer2] [Mark.Player2, Mark.Player1, Mark.Player2]
] ]
check checkBoard(game.board[0][0]) == mDraw check checkBoard(game.board[0][0]) == Mark.Draw
test "board is open": test "board is open":
game.board[0][0] = [ game.board[0][0] = [
[mPlayer1, mPlayer2, mFree], [Mark.Player1, Mark.Player2, Mark.Free],
[mPlayer1, mFree, mPlayer1], [Mark.Player1, Mark.Free, Mark.Player1],
[mFree, mPlayer1, mPlayer2] [Mark.Free, Mark.Player1, Mark.Player2]
] ]
check checkBoard(game.board[0][0]) == mFree check checkBoard(game.board[0][0]) == Mark.Free
test "free inital metaboard": test "free inital metaboard":
check checkBoard(game.board) == mFree check checkBoard(game.board) == Mark.Free
test "winning metaboard row": test "winning metaboard row":
game.board[1][0] = [ game.board[1][0] = [
[mPlayer1, mPlayer2, mFree], [Mark.Player1, Mark.Player2, Mark.Free],
[mPlayer1, mPlayer1, mPlayer1], [Mark.Player1, Mark.Player1, Mark.Player1],
[mFree, mPlayer1, mPlayer2] [Mark.Free, Mark.Player1, Mark.Player2]
] ]
game.board[1][1] = [ game.board[1][1] = [
[mFree, mFree, mPlayer1], [Mark.Free, Mark.Free, Mark.Player1],
[mFree, mPlayer1, mFree], [Mark.Free, Mark.Player1, Mark.Free],
[mPlayer1, mFree, mFree] [Mark.Player1, Mark.Free, Mark.Free]
] ]
game.board[1][2] = [ game.board[1][2] = [
[mFree, mFree, mPlayer1], [Mark.Free, Mark.Free, Mark.Player1],
[mFree, mFree, mPlayer1], [Mark.Free, Mark.Free, Mark.Player1],
[mFree, mFree, mPlayer1] [Mark.Free, Mark.Free, Mark.Player1]
] ]
check checkBoard(game.board) == mPlayer1 check checkBoard(game.board) == Mark.Player1
test "winning metaboard column": test "winning metaboard column":
game.board[0][1] = [ game.board[0][1] = [
[mPlayer1, mPlayer2, mFree], [Mark.Player1, Mark.Player2, Mark.Free],
[mPlayer1, mPlayer1, mPlayer1], [Mark.Player1, Mark.Player1, Mark.Player1],
[mFree, mPlayer1, mPlayer2] [Mark.Free, Mark.Player1, Mark.Player2]
] ]
game.board[1][1] = [ game.board[1][1] = [
[mFree, mFree, mFree], [Mark.Free, Mark.Free, Mark.Free],
[mPlayer1, mPlayer1, mPlayer1], [Mark.Player1, Mark.Player1, Mark.Player1],
[mFree, mFree, mFree] [Mark.Free, Mark.Free, Mark.Free]
] ]
game.board[2][1] = [ game.board[2][1] = [
[mPlayer1, mFree, mFree], [Mark.Player1, Mark.Free, Mark.Free],
[mPlayer1, mFree, mFree], [Mark.Player1, Mark.Free, Mark.Free],
[mPlayer1, mFree, mFree] [Mark.Player1, Mark.Free, Mark.Free]
] ]
check checkBoard(game.board) == mPlayer1 check checkBoard(game.board) == Mark.Player1
test "winning metaboard diagonal": test "winning metaboard diagonal":
game.board[0][0] = [ game.board[0][0] = [
[mPlayer2, mPlayer2, mFree], [Mark.Player2, Mark.Player2, Mark.Free],
[mPlayer2, mPlayer2, mPlayer2], [Mark.Player2, Mark.Player2, Mark.Player2],
[mFree, mPlayer2, mPlayer2] [Mark.Free, Mark.Player2, Mark.Player2]
] ]
game.board[1][1] = [ game.board[1][1] = [
[mFree, mFree, mFree], [Mark.Free, Mark.Free, Mark.Free],
[mPlayer2, mPlayer2, mPlayer2], [Mark.Player2, Mark.Player2, Mark.Player2],
[mFree, mFree, mFree] [Mark.Free, Mark.Free, Mark.Free]
] ]
game.board[2][2] = [ game.board[2][2] = [
[mPlayer2, mFree, mFree], [Mark.Player2, Mark.Free, Mark.Free],
[mPlayer2, mFree, mFree], [Mark.Player2, Mark.Free, Mark.Free],
[mPlayer2, mFree, mFree] [Mark.Player2, Mark.Free, Mark.Free]
] ]
check checkBoard(game.board) == mPlayer2 check checkBoard(game.board) == Mark.Player2
test "winning metaboard with some boards in draw": test "winning metaboard with some boards in draw":
let winner = [ let winner = [
[mFree, mFree, mFree], [Mark.Free, Mark.Free, Mark.Free],
[mPlayer2, mPlayer2, mPlayer2], [Mark.Player2, Mark.Player2, Mark.Player2],
[mFree, mFree, mFree] [Mark.Free, Mark.Free, Mark.Free]
] ]
let drawn = [ let drawn = [
[mPlayer2, mPlayer2, mPlayer1], [Mark.Player2, Mark.Player2, Mark.Player1],
[mPlayer1, mPlayer1, mPlayer2], [Mark.Player1, Mark.Player1, Mark.Player2],
[mPlayer2, mPlayer1, mPlayer2] [Mark.Player2, Mark.Player1, Mark.Player2]
] ]
game.board[0][0] = winner game.board[0][0] = winner
game.board[1][1] = winner game.board[1][1] = winner
game.board[2][2] = winner game.board[2][2] = winner
game.board[1][0] = drawn game.board[1][0] = drawn
game.board[2][0] = drawn game.board[2][0] = drawn
check checkBoard(game.board) == mPlayer2 check checkBoard(game.board) == Mark.Player2
test "metaboard is drawn": test "metaboard is drawn":
let drawn = [ let drawn = [
[mPlayer2, mPlayer2, mPlayer1], [Mark.Player2, Mark.Player2, Mark.Player1],
[mPlayer1, mPlayer1, mPlayer2], [Mark.Player1, Mark.Player1, Mark.Player2],
[mPlayer2, mPlayer1, mPlayer2] [Mark.Player2, Mark.Player1, Mark.Player2]
] ]
for x in 0 .. 2: for x in 0 .. 2:
for y in 0 .. 2: for y in 0 .. 2:
game.board[x][y] = drawn game.board[x][y] = drawn
check checkBoard(game.board) == mDraw check checkBoard(game.board) == Mark.Draw
test "illegal situation: both players win board": test "illegal situation: both players win board":
game.board[1][1] = [ game.board[1][1] = [
[mPlayer1, mPlayer1, mPlayer1], [Mark.Player1, Mark.Player1, Mark.Player1],
[mPlayer2, mPlayer2, mPlayer2], [Mark.Player2, Mark.Player2, Mark.Player2],
[mFree, mFree, mFree] [Mark.Free, Mark.Free, Mark.Free]
] ]
expect(Exception): expect(Exception):
discard checkBoard(game.board) discard checkBoard(game.board)

40
tests/testMoves.nim
View File

@@ -7,21 +7,21 @@ suite "Test the move procedures":
var var
player1 = Player(name: "Adam") player1 = Player(name: "Adam")
player2 = Player(name: "Eve") player2 = Player(name: "Eve")
game: GameState = newGame(player1, player2) game: GameState = newGameState(player1, player2)
test "Inital state": test "Inital state":
check game.currentPlayer == player1 check game.currentPlayer == player1
check game.players == [player1, player2] check game.players == [player1, player2]
check game.turn == 0 check game.turn == 0
check game.currentBoard.isNone check game.currentBoard.isNone
check game.result == mFree check game.result == Mark.Free
test "First move": test "First move":
game = game.makeMove((1, 1), (1, 1)) game = game.makeMove((1, 1), (1, 1))
check game.currentPlayer == player2 check game.currentPlayer == player2
check game.turn == 1 check game.turn == 1
check game.currentBoard == (1, 1).some() check game.currentBoard == (1, 1).some()
check game.result == mFree check game.result == Mark.Free
test "Second move": test "Second move":
game = game.makeMove((1, 1), (1, 1)) game = game.makeMove((1, 1), (1, 1))
@@ -29,7 +29,7 @@ suite "Test the move procedures":
check game.currentPlayer == player1 check game.currentPlayer == player1
check game.turn == 2 check game.turn == 2
check game.currentBoard == (0, 0).some() check game.currentBoard == (0, 0).some()
check game.result == mFree check game.result == Mark.Free
test "Move on wrong board": test "Move on wrong board":
game = game.makeMove((1, 1), (1, 1)) game = game.makeMove((1, 1), (1, 1))
@@ -47,39 +47,39 @@ suite "Test the move procedures":
test "Player 1 wins the game": test "Player 1 wins the game":
let winner = [ let winner = [
[mPlayer1, mFree, mFree], [Mark.Player1, Mark.Free, Mark.Free],
[mPlayer1, mFree, mFree], [Mark.Player1, Mark.Free, Mark.Free],
[mPlayer1, mFree, mFree] [Mark.Player1, Mark.Free, Mark.Free]
] ]
game.board[0][0] = winner game.board[0][0] = winner
game.board[1][1] = winner game.board[1][1] = winner
game.board[2][2] = [ game.board[2][2] = [
[mPlayer1, mFree, mFree], [Mark.Player1, Mark.Free, Mark.Free],
[mFree, mFree, mFree], [Mark.Free, Mark.Free, Mark.Free],
[mPlayer1, mFree, mFree] [Mark.Player1, Mark.Free, Mark.Free]
] ]
check checkBoard(game.board) == mFree check checkBoard(game.board) == Mark.Free
game = game.makeMove((1, 0), (2, 2)) game = game.makeMove((1, 0), (2, 2))
check game.result == mPlayer1 check game.result == Mark.Player1
check game.currentPlayer == player1 check game.currentPlayer == player1
test "The game ends in a draw": test "The game ends in a draw":
let drawn = [ let drawn = [
[mPlayer2, mPlayer2, mPlayer1], [Mark.Player2, Mark.Player2, Mark.Player1],
[mPlayer1, mPlayer1, mPlayer2], [Mark.Player1, Mark.Player1, Mark.Player2],
[mPlayer2, mPlayer1, mPlayer2] [Mark.Player2, Mark.Player1, Mark.Player2]
] ]
for x in 0 .. 2: for x in 0 .. 2:
for y in 0 .. 2: for y in 0 .. 2:
game.board[x][y] = drawn game.board[x][y] = drawn
game.board[2][2] = [ game.board[2][2] = [
[mPlayer2, mPlayer2, mPlayer1], [Mark.Player2, Mark.Player2, Mark.Player1],
[mPlayer1, mPlayer1, mPlayer2], [Mark.Player1, Mark.Player1, Mark.Player2],
[mPlayer2, mFree, mPlayer2] [Mark.Player2, Mark.Free, Mark.Player2]
] ]
check checkBoard(game.board) == mFree check checkBoard(game.board) == Mark.Free
game = game.makeMove((2, 1), (2, 2)) game = game.makeMove((2, 1), (2, 2))
check game.result == mDraw check game.result == Mark.Draw
check game.currentPlayer == player1 check game.currentPlayer == player1