Add move procs.

'makeMove' advances the game by one turn, switches the current player
and updates the game result.

tests/testChecks.nim

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