def testAi(self):
b = Board(False)
b.set_white(4, 0)
b.set_white(5, 0)
b.set_white(6, 0)
b.set_white(7, 0)
b.set_white(3, 4)
b.set_white(4, 4)
b.set_white(4, 3)
b.set_white(5, 3)
b.set_white(5, 1)
b.set_white(6, 1)
b.set_black(1, 5)
b.set_black(2, 0)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 1)
b.set_black(3, 2)
b.set_black(3, 3)
b.set_black(4, 1)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 1)
b.set_black(7, 2)
print(b.draw())
ai = AiController(0, WHITE)
move = ai.next_move(b)
#self.assertEqual(, )
self.assertIn(move, [p.get_position() for p in b.get_move_pieces(WHITE)])
def test_ai(self):
b = Board(False)
b.set_black(4, 3)
b.set_black(3, 4)
b.set_white(4, 4)
b.set_white(3, 3)
b.clear_moves()
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ......MM........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
def test_ai(self):
b = Board(False)
b.set_black(4, 3)
b.set_black(3, 4)
b.set_white(4, 4)
b.set_white(3, 3)
b.clear_moves()
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ......MM........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
def testAi(self):
b = Board(False)
b.set_white(4, 0)
b.set_white(5, 0)
b.set_white(6, 0)
b.set_white(7, 0)
b.set_white(3, 4)
b.set_white(4, 4)
b.set_white(4, 3)
b.set_white(5, 3)
b.set_white(5, 1)
b.set_white(6, 1)
b.set_black(1, 5)
b.set_black(2, 0)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 1)
b.set_black(3, 2)
b.set_black(3, 3)
b.set_black(4, 1)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 1)
b.set_black(7, 2)
print(b.draw())
ai = AiController(0, WHITE)
move = ai.next_move(b)
#self.assertEqual(, )
self.assertIn(move,
[p.get_position() for p in b.get_move_pieces(WHITE)])
def test_draw(self):
b = Board(False)
b.set_black(0, 0)
b.set_black(1, 0)
b.set_white(1, 1)
b.set_move(0, 1)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 BBBB............1
2 MMWW............2
3 ................3
4 ................4
5 ................5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 BBBB............1
2 ..WW............2
3 ..MMMM..........3
4 ................4
5 ................5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b = Board(False)
b.set_white(3, 3)
b.set_white(3, 4)
b.set_white(4, 4)
b.set_white(4, 3)
b.set_black(2, 2)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(2, 3)
b.set_black(5, 3)
b.set_black(2, 4)
b.set_black(5, 4)
b.set_black(2, 5)
b.set_black(3, 5)
b.set_black(4, 5)
b.set_black(5, 5)
b.clear_moves()
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ..MMMMMMMMMMMM..2
3 ..MMBBBBBBBBMM..3
4 ..MMBBWWWWBBMM..4
5 ..MMBBWWWWBBMM..5
6 ..MMBBBBBBBBMM..6
7 ..MMMMMMMMMMMM..7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 3)
b.set_white(4, 4)
b.set_black(3, 4)
b.set_black(4, 3)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ......MM........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b.clear_moves()
b.make_move((3, 2), BLACK)
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ....MMBBMM......3
4 ......BBBB......4
5 ....MMBBWW......5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b.clear_moves()
b.make_move((2, 2), WHITE)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ..MMWWBB........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b = Board(False)
b.set_white(6, 0)
b.set_white(5, 1)
b.set_white(3, 1)
b.set_white(3, 2)
b.set_white(4, 2)
b.set_white(5, 2)
b.set_white(3, 3)
b.set_white(4, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 4)
b.set_black(4, 4)
b.set_black(1, 5)
b.set_black(4, 5)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ......MM....WW..1
2 ......WWMMWWMM..2
3 ....MMWWWWWW....3
4 ....BBWWWWMM....4
5 ....BBBBBB......5
6 ..BB....BB......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 4)
b.set_white(4, 0)
b.set_white(4, 3)
b.set_white(4, 4)
b.set_white(5, 0)
b.set_white(5, 1)
b.set_white(5, 3)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(7, 0)
b.set_black(2, 0)
b.set_black(3, 1)
b.set_black(4, 1)
b.set_black(7, 1)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 2)
b.set_black(3, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(1, 5)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..WWWWWWWW1
2 ......BBBBWWWWBB2
3 ......BBBBBBBBBB3
4 ....BBBBWWWWMM..4
5 ....BBWWWWMMMM..5
6 ..BBMMMMMMMM....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 4)
b.set_white(4, 0)
b.set_white(4, 3)
b.set_white(4, 4)
b.set_white(5, 0)
b.set_white(5, 1)
b.set_white(5, 3)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(7, 0)
b.set_black(2, 0)
b.set_black(3, 1)
b.set_black(4, 1)
b.set_black(7, 1)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 2)
b.set_black(3, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(1, 5)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..WWWWWWWW1
2 ......BBBBWWWWBB2
3 ......BBBBBBBBBB3
4 ....BBBBWWWWMM..4
5 ....BBWWWWMMMM..5
6 ..BBMMMMMMMM....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 2)
b.set_white(4, 1)
b.set_white(4, 2)
b.set_white(5, 1)
b.set_white(5, 2)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(6, 2)
b.set_white(6, 3)
b.set_black(1, 3)
b.set_black(1, 5)
b.set_black(2, 0)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 1)
b.set_black(3, 3)
b.set_black(3, 4)
b.set_black(3, 5)
b.set_black(4, 3)
b.set_black(4, 4)
b.set_black(5, 3)
b.set_black(5, 5)
b.set_black(6, 4)
b.set_black(7, 0)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..MMMMWWBB1
2 ....MMBBWWWWWWMM2
3 ......WWWWWWWW..3
4 ..BBBBBBBBBBWWMM4
5 ....BBBBBB..BB..5
6 ..BB..BB..BB....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ....BBMM....WWBB1
2 ....MMBBWWWWWW..2
3 ......WWWWWWWW..3
4 MMBBBBBBBBBBWW..4
5 ..MMBBBBBBMMBB..5
6 ..BBMMBBMMBBMMMM6
7 MM..MMMM........7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
##b.clear_moves()
##b.mark_moves(WHITE)
b.clear_moves()
b.make_move((0, 3), WHITE)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB......WWBB1
2 ......BBWWWWWW..2
3 ......WWWWWWWW..3
4 WWWWWWWWWWWWWW..4
5 ....BBBBBB..BB..5
6 ..BB..BB..BB....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
class Game(object):
def __init__(self, window, player_color, theme):
self.window = window
self.theme = theme
self.move_history = MoveHistory()
self.human = Human(player_color, self)
self.turn = "White"
# Game Over Conditions
self.checkmate_win = False
self.stalemate_draw = False
self.threefold_draw = False
self.no_captures_50 = False
self.insufficient_material_draw = False
self.resign = False
if player_color == "White":
self.board = Board("White")
self.computer = Computer("Black")
else:
self.board = Board("Black")
self.computer = Computer("White")
def game_over(self):
if self.checkmate_win or self.stalemate_draw or self.threefold_draw or \
self.no_captures_50 or self.insufficient_material_draw or self.resign:
return True
return False
def update_screen(self, valid_moves, board):
# Draw Board
self.board.create_board(self.window, themes[self.theme])
# Draw Previous Move
self.board.draw_previous_move(self.window)
# Draw all valid moves for selected piece
if self.board.show_valid_moves:
self.board.draw_valid_moves(valid_moves, self.window)
# Draw change theme buttons
self.board.draw_theme_window(self.window)
# Draw Game Buttons
self.board.draw_game_buttons(self.window, themes[self.theme])
# Draw Move Log
self.move_history.draw_move_log(self.window)
# Draw captured and advantages
self.board.material.draw_captured(self.window, self.human.color)
self.board.material.draw_advantages(self.window, self.human.color)
# Draw the chess pieces
self.board.draw(self.window, board)
# Draw Promotion Menu
if self.human.promoting:
self.board.promotion_menu(self.human.color, self.window)
# Update the screen
pygame.display.update()
def update_game(self):
self.board.material.update_advantages(self.board)
self.change_turn()
self.update_all_valid_moves()
def check_game_status(self):
if self.king_checked():
self.checkmate()
self.stalemate()
self.threefold_repetition()
self.insufficient_material()
self.no_captures_in_50()
def update_all_valid_moves(self):
for row in self.board.board:
for piece in row:
if isinstance(piece, (Knight, Bishop, Rook, Queen, King)):
piece.update_valid_moves(self.board.board)
elif isinstance(piece, Pawn):
piece.update_valid_moves(self.board.board,
self.move_history.move_log)
def get_dangerous_squares(self):
dangerous_squares = []
for row in self.board.board:
for piece in row:
if isinstance(piece,
(Pawn, Knight, Bishop, Rook, Queen, King)):
if piece.color != self.turn:
for move in piece.valid_moves:
dangerous_squares.append(move)
return dangerous_squares
def king_checked(self):
self.update_all_valid_moves()
king = None
dangerous_squares = self.get_dangerous_squares()
king_pos = (None, None)
for row in self.board.board:
for piece in row:
if isinstance(piece, King):
if piece.color == self.turn:
king = piece
king_pos = (piece.row, piece.col)
break
if king_pos in dangerous_squares:
king.is_checked = True
return True
king.is_checked = False
return False
def checkmate(self):
for row in self.board.board:
for piece in row:
# Get all pieces that are the same color as the king in check
if isinstance(piece,
(Pawn, Knight, Bishop, Rook, Queen, King)):
if piece.color == self.turn:
prev_row = piece.row
prev_col = piece.col
# Try all the moves available for each piece to see if they can escape check
for move in piece.valid_moves:
target = self.board.board[move[0]][move[1]]
# If capturing an enemy piece
if isinstance(
target,
(Pawn, Knight, Bishop, Rook, Queen, King)):
if target.color != self.turn:
self.board.board[move[0]][move[1]] = 0
self.board.move(piece, move[0], move[1])
# If king is still checked, undo move and go next
if self.king_checked():
self.board.move(
piece, prev_row, prev_col)
self.board.board[move[0]][
move[1]] = target
# If king is no longer checked, then there is no checkmate yet
else:
self.board.move(
piece, prev_row, prev_col)
self.board.board[move[0]][
move[1]] = target
return False
# If moving to an empty square
else:
self.board.move(piece, move[0], move[1])
# If king is still checked, undo move and go next
if self.king_checked():
self.board.move(piece, prev_row, prev_col)
# If king is no longer checked, then there is no checkmate yet
else:
self.board.move(piece, prev_row, prev_col)
return False
self.update_screen(self.human.valid_moves, self.board)
self.checkmate_win = True
def threefold_repetition(self):
unique_moves = set()
if len(self.move_history.move_log) > 9:
for i in range(-1, -10, -1):
move = self.move_history.move_log[i]
unique_moves.add(move)
if len(unique_moves) == 4:
self.update_screen(self.human.valid_moves, self.board)
self.threefold_draw = True
def stalemate(self):
all_valid_moves = []
dangerous_squares = self.get_dangerous_squares()
for row in self.board.board:
for piece in row:
# Get all pieces that are the same color as the current player's team
if isinstance(piece,
(Pawn, Knight, Bishop, Rook, Queen, King)):
if piece.color == self.turn:
# Go through all possible moves to see if any are legal
if isinstance(piece, King):
for move in piece.valid_moves:
if move not in dangerous_squares:
all_valid_moves.append(move)
else:
for move in piece.valid_moves:
all_valid_moves.append(move)
# If there was a legal move, there is no stalemate yet
if len(all_valid_moves) > 0:
return False
# If there were no legal moves for the current player, its a stalemate
if len(all_valid_moves) == 0:
self.update_screen(self.human.valid_moves, self.board)
self.stalemate_draw = True
def no_captures_in_50(self):
if len(self.move_history.move_log) > 50:
moves = self.move_history.move_log[-50:]
captures = [move for move in moves if "x" in move]
if len(captures) == 0:
self.no_captures_50 = True
def insufficient_material(self):
white_pieces = {"Knights": 0, "Bishops": 0}
black_pieces = {"Knights": 0, "Bishops": 0}
for row in self.board.board:
for piece in row:
# If there is a pawn, rook, or queen on the board, the game is still winnable
if isinstance(piece, (Pawn, Rook, Queen)):
return False
# Count number of knights on board
elif isinstance(piece, Knight):
if piece.color == "White":
white_pieces["Knights"] += 1
else:
black_pieces["Knights"] += 1
# Count number of bishops on board
elif isinstance(piece, Bishop):
if piece.color == "Black":
black_pieces["Bishops"] += 1
else:
white_pieces["Bishops"] += 1
white_material_remaining = white_pieces["Knights"] + white_pieces[
"Bishops"]
black_material_remaining = black_pieces["Knights"] + black_pieces[
"Bishops"]
# In the best case, there is a King + Knight or King + Bishop for either side (still a draw).
if white_material_remaining * 3 <= 3 and black_material_remaining * 3 <= 3:
self.update_screen(self.human.valid_moves, self.board)
self.insufficient_material_draw = True
def move_creates_check(self, move):
self.change_turn()
if self.king_checked():
move += "+"
self.change_turn()
return move
def change_turn(self):
self.human.valid_moves = []
if self.turn == "White":
self.turn = "Black"
else:
self.turn = "White"
def capture(self, piece):
if piece.color == "Black":
self.board.material.add_to_captured_pieces(
piece, self.board.material.captured_black_pieces)
if piece.color == "White":
self.board.material.add_to_captured_pieces(
piece, self.board.material.captured_white_pieces)
def castle(self, king, rook, row, col, dangerous_squares, board):
# Save a temp variable for rook column
rook_col = rook.col
# Long Castle
if row == 0:
if ((row + 1, col) and (row + 2, col)
and (row + 3, col)) not in dangerous_squares:
board.move(rook, 3, king.col)
board.move(king, 2, rook_col)
board.move_notation = "O-O-O"
else:
return False
# Short Castle
elif row == 7:
if (row - 1, col) and (row - 2, col) not in dangerous_squares:
board.move(rook, 5, king.col)
board.move(king, 6, rook_col)
board.move_notation = "O-O"
else:
return False
king.can_castle = False
return True
def detect_promotion(self, piece):
# If a pawn reaches the other side of the board (any promotion square, let player choose how to promote)
if isinstance(piece, Pawn):
if (piece.color == "White"
and piece.col == 0) or (piece.color == "Black"
and piece.col == 7):
return True
return False
class Game(object):
"""Game ties everything together. It has a board,
two controllers, and can draw to the screen."""
def __init__(self, timeout=1, players=['ai', 'ai'], colour=False):
self.board = Board(colour)
self.timeout = timeout
self.ai_counter = 0
self.list_of_colours = [BLACK, WHITE]
self.ctrlers = deque([
self.mk_ctrler(BLACK, players[0]),
self.mk_ctrler(WHITE, players[1])
])
self.player = self.ctrlers[0].get_colour()
self.board.set_black(4, 3)
self.board.set_black(3, 4)
self.board.set_white(4, 4)
self.board.set_white(3, 3)
self.board.mark_moves(self.player)
self.previous_move = [0, 0]
self.previous_round_passed = False
def mk_ctrler(self, colour, ctrler_type):
""" Returns a controller with the specified colour.
'player' == PlayerController,
'ai' == AiController.
"""
if ctrler_type == 'player':
return PlayerController(colour)
elif ctrler_type == 'random':
return RandomController(colour)
else:
self.ai_counter += 1
return AiController(self.ai_counter, colour, self.timeout)
def show_info(self):
""" Prints game information to stdout.
"""
self.player = self.ctrlers[0].get_colour()
print("Playing as: " + self.player)
print("Current turn: " + str(self.ctrlers[0]))
print("Previous move: " + self.coordinate(self.previous_move))
print("Number of Black: " +
str(len([p
for p in self.board.pieces if p.get_state() == BLACK])))
print("Number of White: " +
str(len([p
for p in self.board.pieces if p.get_state() == WHITE])))
def show_board(self):
""" Prints the current state of the board to stdout.
"""
self.board.mark_moves(self.player)
print(self.board.draw())
def show_commands(self):
""" Prints the possible moves to stdout.
"""
moves = [
self.coordinate(piece.get_position())
for piece in self.board.get_move_pieces(self.player)
]
if not moves:
raise NoMovesError
print("Possible moves are: ", moves)
self.board.clear_moves()
def run(self):
""" The game loop will print game information, the board, the possible moves, and then wait for the
current player to make its decision before it processes it and then goes on repeating itself.
"""
while True:
os.system('clear')
self.show_info()
self.show_board()
try:
self.show_commands()
next_move = self.ctrlers[0].next_move(self.board)
self.board.make_move(next_move, self.ctrlers[0].get_colour())
self.previous_round_passed = False
except NoMovesError:
if self.previous_round_passed:
print("Game Over")
blacks = len([
p for p in self.board.pieces if p.get_state() == BLACK
])
whites = len([
p for p in self.board.pieces if p.get_state() == WHITE
])
if blacks > whites:
print("BLACK won this game.")
exit()
elif blacks == whites:
print("This game was a tie.")
exit()
else:
print("WHITE won this game.")
exit()
else:
self.previous_round_passed = True
self.ctrlers.rotate()
self.previous_move = next_move
def coordinate(self, coordinate):
""" Transforms an (x, y) tuple into (a-h, 1-8) tuple.
"""
x, y = coordinate
return '{0}{1}'.format(chr(ord('a') + x), y + 1)
def main_game(genomes, config):
gameSpeed = 5
gameOver = False
nets = []
genomes_track = []
snakes = []
for _, genome in genomes:
net = neat.nn.FeedForwardNetwork.create(genome, config)
nets.append(net)
snake_initial_coord = unique_coords(snakes)
snakes.append(Snake(snake_initial_coord, gameSpeed))
genome.fitness = 0
genomes_track.append(genome)
#snake = Snake((int(BOARD_ROWS / 2), int(BOARD_COLS / 2)), gameSpeed)
tile_coord = unique_coords(snakes)
tile = Tile(tile_coord)
board = Board(screen)
score = Score(screen)
#last_obstacle = pygame.sprite.Group()
while not gameOver:
for event in pygame.event.get():
if event.type == QUIT:
gameOver = True
quit()
if event.type == KEYDOWN:
if event.key == K_UP:
for snake in snakes:
snake.move_up()
if event.key == K_DOWN:
for snake in snakes:
snake.move_down()
if event.key == K_RIGHT:
for snake in snakes:
snake.move_right()
if event.key == K_LEFT:
for snake in snakes:
snake.move_left()
for snake in snakes:
snake.update()
check_collide(snakes, tile, genomes_track, nets)
if tile.is_dead():
score.update()
#snake.eat_tile()
tile_coord = unique_coords(snakes)
tile = Tile(tile_coord)
if len(snakes) == 0:
gameOver = True
quit()
board.clean_board()
for snake in snakes:
board.display_snake(snake.get_body())
board.display_tile(tile.get_coord())
update_fitness(snakes, tile, genomes_track, nets)
if pygame.display.get_surface() != None:
screen.fill(BG_COLOR)
board.draw()
score.draw()
pygame.display.update()
clock.tick(FPS)
class Game(object):
"""Game ties everything together. It has a board,
two controllers, and can draw to the screen."""
def __init__(self,
max_depth=1000,
display_moves=True,
players=['ai', 'ai'],
colour=False):
self.board = Board(colour)
self.max_depth = max_depth
self.ai_counter = 0
self.list_of_colours = [BLACK, WHITE]
self.players = players
self.display_moves = display_moves
self.controllers = deque([
self._make_controller(c, p)
for c, p in zip(self.list_of_colours, self.players)
])
self.player = self.controllers[0].get_colour()
self.board.set_black(int(WIDTH / 2), int(WIDTH / 2 - 1))
self.board.set_black(int(WIDTH / 2 - 1), int(WIDTH / 2))
self.board.set_white(int(WIDTH / 2), int(WIDTH / 2))
self.board.set_white(int(WIDTH / 2 - 1), int(WIDTH / 2 - 1))
self.board.mark_moves(self.player)
self.previous_move = None
def _make_controller(self, colour, controller_type):
""" Returns a controller with the specified colour.
'player' == PlayerController,
'ai' == AiController.
"""
if controller_type == 'player':
return PlayerController(colour)
else:
self.ai_counter += 1
return AiController(self.ai_counter, colour, self.max_depth)
def show_info(self):
""" Prints game information to stdout.
"""
print("Playing as: " + self.player)
print("Displaying moves: " + str(self.display_moves))
print("Current turn: " + str(self.controllers[0]))
print("Number of Black: " +
str(len([p
for p in self.board.pieces if p.get_state() == BLACK])))
print("Number of White: " +
str(len([p
for p in self.board.pieces if p.get_state() == WHITE])))
def show_board(self):
""" Prints the current state of the board to stdout.
"""
self.player = self.controllers[0].get_colour()
self.board.mark_moves(self.player)
print(self.board.draw())
def show_commands(self):
""" Prints the possible moves to stdout.
"""
moves = [
self.to_board_coordinates(piece.get_position())
for piece in self.board.get_move_pieces(self.player)
]
if not moves:
raise NoMovesError
print("Possible moves are: ", moves)
self.board.clear_moves()
def run(self):
""" The game loop will print game information, the board, the possible moves, and then wait for the
current player to make its decision before it processes it and then goes on repeating itself.
"""
while True:
os.system('clear')
self.show_info()
self.show_board()
try:
self.show_commands()
next_move = self.controllers[0].next_move(self.board)
self.board.make_move(next_move,
self.controllers[0].get_colour())
except NoMovesError:
print("Game Over")
blacks = len(
[p for p in self.board.pieces if p.get_state() == BLACK])
whites = len(
[p for p in self.board.pieces if p.get_state() == WHITE])
if blacks > whites:
print("Black won this game.")
break
elif blacks == whites:
print("This game was a tie.")
break
else:
print("White won this game.")
break
self.controllers.rotate()
print("Current move is: ", self.to_board_coordinates(next_move))
self.previous_move = next_move
for i in range(1, SIZE):
COMM.isend(-1, dest=i, tag=1)
def to_board_coordinates(self, coordinate):
""" Transforms an (x, y) tuple into (a-h, 1-8) tuple.
"""
x, y = coordinate
return '{0}{1}'.format(chr(ord('a') + x), y + 1)
class Game(object):
"""Game ties everything together. It has a board,
two controllers, and can draw to the screen."""
def __init__(self, timeout=1000,
display_moves=True,
players=['ai', 'ai'],
colour=False):
self.board = Board(colour)
self.timeout = timeout
self.ai_counter = 0
self.list_of_colours = [BLACK, WHITE]
self.players = players
self.display_moves = display_moves
self.controllers = deque([self._make_controller(c, p) for c, p in zip(self.list_of_colours, self.players)])
self.player = self.controllers[0].get_colour()
self.board.set_black(4, 3)
self.board.set_black(3, 4)
self.board.set_white(4, 4)
self.board.set_white(3, 3)
self.board.mark_moves(self.player)
self.previous_move = None
def _make_controller(self, colour, controller_type):
""" Returns a controller with the specified colour.
'player' == PlayerController,
'ai' == AiController.
"""
if controller_type == 'player':
return PlayerController(colour)
else:
self.ai_counter += 1
return AiController(self.ai_counter, colour, self.timeout)
def show_info(self):
""" Prints game information to stdout.
"""
print("Playing as: " + self.player)
print("Displaying moves: " + str(self.display_moves))
print("Current turn: " + str(self.controllers[0]))
print("Number of Black: " + str(
len([p for p in self.board.pieces if p.get_state() == BLACK])))
print("Number of White: " + str(
len([p for p in self.board.pieces if p.get_state() == WHITE])))
def show_board(self):
""" Prints the current state of the board to stdout.
"""
self.player = self.controllers[0].get_colour()
self.board.mark_moves(self.player)
print(self.board.draw())
def show_commands(self):
""" Prints the possible moves to stdout.
"""
moves = [self.to_board_coordinates(piece.get_position()) for piece in self.board.get_move_pieces(self.player)]
if not moves:
raise NoMovesError
print("Possible moves are: ", moves)
self.board.clear_moves()
def run(self):
""" The game loop will print game information, the board, the possible moves, and then wait for the
current player to make its decision before it processes it and then goes on repeating itself.
"""
while True:
os.system('clear')
self.show_info()
self.show_board()
try:
self.show_commands()
next_move = self.controllers[0].next_move(self.board)
self.board.make_move(next_move, self.controllers[0].get_colour())
except NoMovesError:
print("Game Over")
blacks = len([p for p in self.board.pieces if p.get_state() == BLACK])
whites = len([p for p in self.board.pieces if p.get_state() == WHITE])
if blacks > whites:
print("Black won this game.")
exit()
elif blacks == whites:
print("This game was a tie.")
exit()
else:
print("White won this game.")
exit()
self.controllers.rotate()
print("Current move is: ", self.to_board_coordinates(next_move))
self.previous_move = next_move
def to_board_coordinates(self, coordinate):
""" Transforms an (x, y) tuple into (a-h, 1-8) tuple.
"""
x, y = coordinate
return '{0}{1}'.format(chr(ord('a') + x), y + 1)
def test_draw(self):
b = Board(False)
b.set_black(0, 0)
b.set_black(1, 0)
b.set_white(1, 1)
b.set_move(0, 1)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 BBBB............1
2 MMWW............2
3 ................3
4 ................4
5 ................5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 BBBB............1
2 ..WW............2
3 ..MMMM..........3
4 ................4
5 ................5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b = Board(False)
b.set_white(3, 3)
b.set_white(3, 4)
b.set_white(4, 4)
b.set_white(4, 3)
b.set_black(2, 2)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(2, 3)
b.set_black(5, 3)
b.set_black(2, 4)
b.set_black(5, 4)
b.set_black(2, 5)
b.set_black(3, 5)
b.set_black(4, 5)
b.set_black(5, 5)
b.clear_moves()
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ..MMMMMMMMMMMM..2
3 ..MMBBBBBBBBMM..3
4 ..MMBBWWWWBBMM..4
5 ..MMBBWWWWBBMM..5
6 ..MMBBBBBBBBMM..6
7 ..MMMMMMMMMMMM..7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 3)
b.set_white(4, 4)
b.set_black(3, 4)
b.set_black(4, 3)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ......MM........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b.clear_moves()
b.make_move((3, 2), BLACK)
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ....MMBBMM......3
4 ......BBBB......4
5 ....MMBBWW......5
6 ................6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b.clear_moves()
b.make_move((2, 2), WHITE)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ................1
2 ................2
3 ..MMWWBB........3
4 ....MMWWBB......4
5 ......BBWWMM....5
6 ........MM......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
b = Board(False)
b.set_white(6, 0)
b.set_white(5, 1)
b.set_white(3, 1)
b.set_white(3, 2)
b.set_white(4, 2)
b.set_white(5, 2)
b.set_white(3, 3)
b.set_white(4, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 4)
b.set_black(4, 4)
b.set_black(1, 5)
b.set_black(4, 5)
b.mark_moves(BLACK)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ......MM....WW..1
2 ......WWMMWWMM..2
3 ....MMWWWWWW....3
4 ....BBWWWWMM....4
5 ....BBBBBB......5
6 ..BB....BB......6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 4)
b.set_white(4, 0)
b.set_white(4, 3)
b.set_white(4, 4)
b.set_white(5, 0)
b.set_white(5, 1)
b.set_white(5, 3)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(7, 0)
b.set_black(2, 0)
b.set_black(3, 1)
b.set_black(4, 1)
b.set_black(7, 1)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 2)
b.set_black(3, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(1, 5)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..WWWWWWWW1
2 ......BBBBWWWWBB2
3 ......BBBBBBBBBB3
4 ....BBBBWWWWMM..4
5 ....BBWWWWMMMM..5
6 ..BBMMMMMMMM....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 4)
b.set_white(4, 0)
b.set_white(4, 3)
b.set_white(4, 4)
b.set_white(5, 0)
b.set_white(5, 1)
b.set_white(5, 3)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(7, 0)
b.set_black(2, 0)
b.set_black(3, 1)
b.set_black(4, 1)
b.set_black(7, 1)
b.set_black(3, 2)
b.set_black(4, 2)
b.set_black(5, 2)
b.set_black(6, 2)
b.set_black(7, 2)
b.set_black(3, 3)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(1, 5)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..WWWWWWWW1
2 ......BBBBWWWWBB2
3 ......BBBBBBBBBB3
4 ....BBBBWWWWMM..4
5 ....BBWWWWMMMM..5
6 ..BBMMMMMMMM....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b = Board(False)
b.set_white(3, 2)
b.set_white(4, 1)
b.set_white(4, 2)
b.set_white(5, 1)
b.set_white(5, 2)
b.set_white(6, 0)
b.set_white(6, 1)
b.set_white(6, 2)
b.set_white(6, 3)
b.set_black(1, 3)
b.set_black(1, 5)
b.set_black(2, 0)
b.set_black(2, 3)
b.set_black(2, 4)
b.set_black(3, 1)
b.set_black(3, 3)
b.set_black(3, 4)
b.set_black(3, 5)
b.set_black(4, 3)
b.set_black(4, 4)
b.set_black(5, 3)
b.set_black(5, 5)
b.set_black(6, 4)
b.set_black(7, 0)
b.mark_moves(BLACK)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB..MMMMWWBB1
2 ....MMBBWWWWWWMM2
3 ......WWWWWWWW..3
4 ..BBBBBBBBBBWWMM4
5 ....BBBBBB..BB..5
6 ..BB..BB..BB....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
b.clear_moves()
b.mark_moves(WHITE)
result = b.draw()
canvas = """ a.b.c.d.e.f.g.h.
1 ....BBMM....WWBB1
2 ....MMBBWWWWWW..2
3 ......WWWWWWWW..3
4 MMBBBBBBBBBBWW..4
5 ..MMBBBBBBMMBB..5
6 ..BBMMBBMMBBMMMM6
7 MM..MMMM........7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
##b.clear_moves()
##b.mark_moves(WHITE)
b.clear_moves()
b.make_move((0, 3), WHITE)
result = b.draw()
#0 1 2 3 4 5 6 7
canvas = """ a.b.c.d.e.f.g.h.
1 ....BB......WWBB1
2 ......BBWWWWWW..2
3 ......WWWWWWWW..3
4 WWWWWWWWWWWWWW..4
5 ....BBBBBB..BB..5
6 ..BB..BB..BB....6
7 ................7
8 ................8
a.b.c.d.e.f.g.h."""
self.assertEqual(result, canvas)
