def test_board_trap(self):
"""Create artificial traps and make pieces fall onto them to check their functionality"""
# Start a new board
game_board = board.Board(board.WHITE)
# Create trap tiles
board.Board.tiles[5][0].trap = True
# Make a Pawn fall into trap, nothing changes
piece: Piece = board.Board.get_piece(Coordinate(6, 0))
self.assertTrue(piece.__class__.__name__ is "Pawn")
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertTrue(piece.__class__.__name__ is "Pawn")
# Start a new board
game_board = board.Board(board.WHITE)
# Create trap tiles
board.Board.tiles[5][0].trap = True
piece: Piece = board.Board.get_piece(Coordinate(6, 0))
game_board.move_piece(piece.position, Coordinate(4, 0))
# Manually change to our turn and make a Rook fall in the trap
game_board.turn = piece.color
piece = board.Board.get_piece(Coordinate(7, 0))
self.assertTrue(piece.__class__.__name__ is "Rook")
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertTrue(piece.__class__.__name__ is "Pawn")
def test_rook_movement(self):
"""Initialize a board, choose a rook piece and check the chess rules work correctly"""
game_board = board.Board(board.WHITE) # Start a new board
piece: Piece = board.Board.get_piece(Coordinate(7, 0))
self.assertTrue(piece.__class__.__name__ is "Rook")
self.assertTrue(piece.position.x == 7)
self.assertTrue(piece.position.y == 0)
self.assertEqual(piece.color, board.WHITE)
# Artificially remove the front pawn out of the way to allow rook movement
board.Board.get_piece(Coordinate(6, 0)).active = False
# First move, rook can advance forward
legal_moves: List[Coordinate] = [
move for move in piece.get_legal_moves()
if board.Board.get_piece(move) is None
or board.Board.get_piece(move).color != piece.color
or board.Board.get_piece(move).active is False
]
self.assertIs(len(legal_moves), 6)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(2, 0))
self.assertTrue(piece.position.x == 2)
self.assertTrue(piece.position.y == 0)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(2, 7))
self.assertTrue(piece.position.x == 2)
self.assertTrue(piece.position.y == 7)
def buildPuzzle(puzzle: str, size: int = 3) -> Board.Board:
board = Board.Board(size)
data = structPuzzleData(puzzle, size)
rows = [board.columns(i) for i in range(size * size)]
for r, dr in zip(rows, data):
for c, dc in zip(r, dr):
if dc != '0': c.setValue(dc)
return board
def test_king_movement(self):
"""Initialize a board, choose a king piece and check the chess rules work correctly"""
game_board = board.Board(board.WHITE) # Start a new board
piece: Piece = board.Board.get_piece(Coordinate(7, 4))
self.assertTrue(piece.__class__.__name__ is "King")
self.assertTrue(piece.position.x == 7)
self.assertTrue(piece.position.y == 4)
self.assertEqual(piece.color, board.WHITE)
# Fake move, king can not move because it is surrounded by other allies
legal_moves: List[Coordinate] = [
move for move in piece.get_legal_moves()
if board.Board.get_piece(move) is None
or board.Board.get_piece(move).color != piece.color
or board.Board.get_piece(move).active is False
]
self.assertIs(len(legal_moves), 0)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(6, 3))
self.assertTrue(piece.position.x == 7) # Unchanged
self.assertTrue(piece.position.y == 4)
# Artificially remove the front and side pawns out of the way to allow king movement
board.Board.get_piece(Coordinate(6, 3)).active = False
board.Board.get_piece(Coordinate(6, 4)).active = False
board.Board.get_piece(Coordinate(6, 5)).active = False
# First move, king can move diagonally
legal_moves = [
move for move in piece.get_legal_moves()
if board.Board.get_piece(move) is None
or board.Board.get_piece(move).color != piece.color
or board.Board.get_piece(move).active is False
]
self.assertIs(len(legal_moves), 3)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(6, 3))
self.assertTrue(piece.position.x == 6)
self.assertTrue(piece.position.y == 3)
# Second move, return home
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(7, 4))
self.assertTrue(piece.position.x == 7)
self.assertTrue(piece.position.y == 4)
# Third move, try moving forward
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(6, 4))
self.assertTrue(piece.position.x == 6)
self.assertTrue(piece.position.y == 4)
def test_pawn_movement(self):
"""Initialize a board, choose a pawn piece and check the chess rules work correctly"""
game_board = board.Board(board.WHITE) # Start a new board
piece: Piece = board.Board.get_piece(Coordinate(6, 0))
self.assertTrue(piece.__class__.__name__ is "Pawn")
self.assertTrue(piece.position.x == 6)
self.assertTrue(piece.position.y == 0)
self.assertEqual(piece.color, board.WHITE)
# First move, pawn can advance two tiles or one
legal_moves: List[Coordinate] = piece.get_legal_moves()
self.assertIs(len(legal_moves), 2)
game_board.move_piece(piece.position, Coordinate(4, 0))
self.assertTrue(piece.position.x == 4)
self.assertTrue(piece.position.y == 0)
self.assertTrue(piece.has_moved)
# Nor first move, pawn can advance one tile
legal_moves = piece.get_legal_moves()
self.assertIs(len(legal_moves), 1)
# This movement is ignored because after each move the board changes the player in control
game_board.move_piece(piece.position, Coordinate(3, 0))
self.assertTrue(piece.position.x == 4)
self.assertTrue(piece.position.y == 0)
# Manually change to our turn
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(3, 0))
self.assertTrue(piece.position.x == 3)
self.assertTrue(piece.position.y == 0)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(2, 0))
self.assertTrue(piece.position.x == 2)
self.assertTrue(piece.position.y == 0)
# Where are facing a line of pawns not, we can eat one of them
legal_moves = piece.get_legal_moves()
self.assertIs(len(legal_moves), 1)
self.assertIs(
board.Board.get_piece(Coordinate(1, 1)).color, board.BLACK)
# Eat the pawn in 1, 1
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(1, 1))
self.assertTrue(piece.position.x == 1)
self.assertTrue(piece.position.y == 1)
self.assertIs(
board.Board.get_piece(Coordinate(1, 1)).color, board.WHITE)
def test_board_constructor(self):
"""Initialize a new game board and check the all inner data has been stored correctly"""
game_board = board.Board(board.WHITE) # Start a new board
self.assertEqual(board.WHITE, True)
self.assertEqual(board.BLACK, False)
self.assertEqual(game_board.turn, board.WHITE)
self.assertEqual(game_board.player_side, board.WHITE)
self.assertEqual(game_board.rival_side, board.BLACK)
self.assertIs(len(game_board.previous_movements), 0)
self.assertIs(len(game_board.future_movements), 0)
self.assertEqual(game_board.white_king.__class__.__name__, "King")
self.assertEqual(game_board.white_king.position, Coordinate(7, 4))
self.assertEqual(game_board.black_king.__class__.__name__, "King")
self.assertEqual(game_board.black_king.position, Coordinate(0, 4))
def test_bishop_movement(self):
"""Initialize a board, choose a bishop piece and check the chess rules work correctly"""
game_board = board.Board(board.WHITE) # Start a new board
piece: Piece = board.Board.get_piece(Coordinate(7, 2))
self.assertTrue(piece.__class__.__name__ is "Bishop")
self.assertTrue(piece.position.x == 7)
self.assertTrue(piece.position.y == 2)
self.assertEqual(piece.color, board.WHITE)
# Artificially remove the front side pawns out of the way to allow bishop movement
board.Board.get_piece(Coordinate(6, 1)).active = False
board.Board.get_piece(Coordinate(6, 3)).active = False
# First move, bishop diagonal
legal_moves: List[Coordinate] = [
move for move in piece.get_legal_moves()
if board.Board.get_piece(move) is None
or board.Board.get_piece(move).color != piece.color
or board.Board.get_piece(move).active is False
]
self.assertIs(len(legal_moves), 7)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertTrue(piece.position.x == 5)
self.assertTrue(piece.position.y == 0)
# Second move, return home
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(7, 2))
self.assertTrue(piece.position.x == 7)
self.assertTrue(piece.position.y == 2)
# Third move, try the other diagonal
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(2, 7))
self.assertTrue(piece.position.x == 2)
self.assertTrue(piece.position.y == 7)
def test_check(self):
"""
Create a game situation in which one of the kings is in check ('jaque') adn then checkmate ('jaque mate')
to test the detection algorithm
"""
# Start a new board
game_board = board.Board(board.WHITE)
# Move pawn to let Rook exit
piece: Piece = board.Board.get_piece(Coordinate(6, 0))
self.assertTrue(piece.__class__.__name__ is "Pawn")
game_board.move_piece(piece.position, Coordinate(4, 0))
# Select rook
piece: Piece = board.Board.get_piece(Coordinate(7, 0))
self.assertTrue(piece.__class__.__name__ is "Rook")
# Manually change to our turn and make the Rook corner the enemy king
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertEqual(piece.position.x, 5)
self.assertEqual(piece.position.y, 0)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(5, 4))
self.assertEqual(piece.position.x, 5)
self.assertEqual(piece.position.y, 4)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(1, 4))
self.assertEqual(piece.position.x, 1)
self.assertEqual(piece.position.y, 4)
# The black king should be in check
game_board.turn = piece.color
self.assertTrue(game_board.check_check())
# Move rook backwards to create checkmate
game_board.move_piece(piece.position, Coordinate(2, 4))
game_board.turn = piece.color
self.assertTrue(game_board.check_checkmate(piece.get_legal_moves()))
def test_knight_movement(self):
"""Initialize a board, choose a knight piece and check the chess rules work correctly"""
game_board = board.Board(board.WHITE) # Start a new board
piece: Piece = board.Board.get_piece(Coordinate(7, 1))
self.assertTrue(piece.__class__.__name__ is "Knight")
self.assertTrue(piece.position.x == 7)
self.assertTrue(piece.position.y == 1)
self.assertEqual(piece.color, board.WHITE)
# First move, knight can advance in two ways
legal_moves: List[Coordinate] = [
move for move in piece.get_legal_moves()
if board.Board.get_piece(move) is None
or board.Board.get_piece(move).color != piece.color
or board.Board.get_piece(move).active is False
]
self.assertIs(len(legal_moves), 2)
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertTrue(piece.position.x == 5)
self.assertTrue(piece.position.y == 0)
self.assertTrue(piece.has_moved)
# Manually change to our turn and check available moves
game_board.turn = piece.color
legal_moves = [
move for move in piece.get_legal_moves()
if board.Board.get_piece(move) is None
or board.Board.get_piece(move).color != piece.color
or board.Board.get_piece(move).active is False
]
self.assertIs(len(legal_moves), 3)
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertTrue(piece.position.x == 5)
self.assertTrue(piece.position.y == 0)
invalid_command: bool = True
print_board: Union[bool, List[str]] = True
while invalid_command is True:
player_command: str = input(">> Run a command or type 'help' for information: ").lower()
results = parse_and_run_command (player_command)
invalid_command = results[0]
print_board = results[1]
if isinstance(print_board, list):
# Special case when we are executing code from a file. Run each command.
for command in print_board:
print ("\t --> {}...".format(command))
parse_and_run_command(command)
print ("FINISHED EXECUTING FILE COMMANDS:\n")
print (game_board)
if print_board is True:
if game_board.turn == board.WHITE:
print("Turn of " + Fore.BLUE + "white" + Fore.RESET)
else:
print("Turn of " + Fore.RED + "black" + Fore.RESET)
print(game_board)
# Beginning of the main script ----------------------------------------------
init() # Allow printing in color
player_side: bool = ask_player_side() # Get player side
command_prefix: str = "action_" # Define the nomenclature of the methods of the board the user can access
game_board: board.Board = board.Board(player_side) # Start a new board
run_game(game_board) # Start the interpreter
"""
Script to play tic tac toe game
"""
import sys
from board import board
b = board.Board()
while True:
b.display_board()
move = int(raw_input("Enter your move\n"))
b.place_piece(move)
if b.check_win(1):
print "Player 0 won!"
b.display_board(True)
exit()
elif b.check_win(-1):
print "Player 1 won!"
b.display_board(True)
exit()
""" Initializes everything """
""" Import libraries """
import sys, pygame
""" Import Classes """
from board import board
from player import player
from game import Game
""" Init All The Things! """
# Declarations of game objects
board = board.Board()
playerW = player.Player("white")
playerB = player.Player("black")
game = Game({"white": playerW, "black": playerB}, board)
# Constants
START_X = 60
START_Y = 50
ADJUST = 110
""" Starting output """
"""
print("Let's play chess! \n White goes first")
while(playerW.lost != False or playerB.lost != False):
game.turn()
playerW.lost = True
"""
screen_size = (1000, 1000)
screen = pygame.display.set_mode(screen_size)
field_size = (800, 800)
# field = pygame.display.set_mode(field_size)
board = pygame.image.load("images/board.jpg")
def start():
print("Tic-Tac-Toe")
try:
new_board = board.Board()
new_board.make_board(parameters.gridsize)
new_locations = location.Locations()
new_locations.set_cell_locations(parameters.locations)
new_locations.set_winning_combo(parameters.winning_combo)
token1 = tokens.Token()
player1 = players.Player()
player1.set_id(parameters.player1)
token1.setType(player1.get_id())
player1.set_token(token1)
token2 = tokens.Token()
player2 = players.Player()
player2.set_id(parameters.player2)
token2.setType(player2.get_id())
player2.set_token(token2)
except Exception as e:
print('Error: ', e)
exit(-1)
new_board.draw_board()
won = False
current_player = 1
while won is False:
if current_player == player1.get_id():
player_input = input(
'Player 1: Choose a cell in row,column format.\n')
else:
player_input = input(
'Player 2: Choose a cell in row,column format.\n')
player_input = player_input.replace(" ", "")
remove_check = new_locations.remove_cell(player_input)
while remove_check is False:
player_input = input(
'Invalid or location chosen already. Choose a cell in row,column format.\n'
)
player_input = player_input.replace(" ", '')
remove_check = new_locations.remove_cell(player_input)
if current_player == player1.get_id():
new_board.set_board(token1.getType(), player_input)
player1.set_player_choices(player_input)
new_board.draw_board()
won = new_locations.win_check(player1.get_player_choices())
current_player = player2.get_id()
else:
new_board.set_board(token2.getType(), player_input)
player2.set_player_choices(player_input)
new_board.draw_board()
won = new_locations.win_check(player2.get_player_choices())
current_player = player1.get_id()
if won is True:
print('Wow you won?!')
again = input('Wanna play again? Y or N\n')
if again.upper() == 'Y' or again.upper() == 'YES':
start()
elif again.upper() == 'N' or again.upper() == 'NO':
print('Peace dawg.')
exit(0)
def test_undo_redo(self):
"""
Create a game situation in which undoing the previous action may cause one piece to be alive again, etc.
and try redoing it as well
"""
# Start a new board
game_board = board.Board(board.WHITE)
self.assertFalse(game_board.action_undo())
self.assertFalse(game_board.action_redo())
# Move pawn to let Rook exit and check undo and redo work for just changes in position
piece: Piece = board.Board.get_piece(Coordinate(6, 0))
self.assertTrue(piece.__class__.__name__ is "Pawn")
game_board.move_piece(piece.position, Coordinate(4, 0))
self.assertEqual(piece.position.x, 4)
self.assertEqual(piece.position.y, 0)
game_board.action_undo()
self.assertEqual(piece.position.x, 6)
self.assertEqual(piece.position.y, 0)
game_board.action_redo()
self.assertEqual(piece.position.x, 4)
self.assertEqual(piece.position.y, 0)
# Select rook
piece: Piece = board.Board.get_piece(Coordinate(7, 0))
self.assertTrue(piece.__class__.__name__ is "Rook")
# Manually change to our turn and make the Rook corner the enemy king
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(5, 0))
self.assertEqual(piece.position.x, 5)
self.assertEqual(piece.position.y, 0)
game_board.turn = piece.color
game_board.move_piece(piece.position, Coordinate(5, 4))
self.assertEqual(piece.position.x, 5)
self.assertEqual(piece.position.y, 4)
# Kill the black pawn
game_board.turn = piece.color
self.assertEqual(board.Board.tiles[1][4].piece.__class__.__name__, "Pawn")
self.assertEqual(board.Board.get_piece(Coordinate(1, 4)).color, board.BLACK)
game_board.move_piece(piece.position, Coordinate(1, 4))
self.assertEqual(piece.position.x, 1)
self.assertEqual(piece.position.y, 4)
self.assertEqual(board.Board.tiles[1][4].piece.__class__.__name__, "Rook")
self.assertEqual(board.Board.get_piece(Coordinate(1, 4)).color, board.WHITE)
# Undo the movement that killed the pawn
game_board.action_undo()
self.assertEqual(board.Board.tiles[1][4].piece.__class__.__name__, "Pawn")
self.assertEqual(board.Board.get_piece(Coordinate(1, 4)).color, board.BLACK)
self.assertEqual(board.Board.tiles[5][4].piece.__class__.__name__, "Rook")
self.assertEqual(board.Board.get_piece(Coordinate(5, 4)).color, board.WHITE)
# Redo the movement that killed the pawn
game_board.action_redo()
# The black king should be in check after that move
game_board.turn = piece.color
self.assertTrue(game_board.check_check())
s = section.Section()
s.print()
s.rows[0].cols[0].setValue(3)
s.print()
s.reduce()
s.print()
l = layout.BoardRow()
c = l.columns(0)
print(c)
b = layout.Board()
for i in range(9):
start = i
row = b.columns(i)
for cell in row:
cellValue = start % 9
cell.setValue(cellValue + 1)
def displaySect(b, row, col):
sec1 = b._boardRows[row]._sectionCols[col]
sec1.print()
displaySect(b, 0, 1)