def test_get_legal_moves_speed(): time_dict = { "generate": 0, "copy": 0, "validate": 0, "special": 0, "full": 0, } for _ in range(5): chess = Chess() while chess.is_in_progress: chess.move(chess.legal_moves[1]) # chess.move(random.choice(chess.legal_moves)) chess_f.get_legal_moves(chess, chess.in_turn, time_dict=time_dict) # for i in range(50): # chess_f.get_legal_moves(chess, chess.in_turn, time_dict=time_dict) # chess.move(chess.legal_moves[1]) total = time_dict["full"] # for key in time_dict: # total += time_dict[key] print("Total time: ", total, "\n") print(time_dict, "\n") for key in time_dict: time_dict[key] = (time_dict[key] / total) * 100 print(time_dict)
def test_get_displayable_history_no_capture_history(self): chess = Chess() chess.move((1, 1), (2, 1)) chess.move((6, 4), (5, 4)) chess.move((2, 1), (3, 1)) actual = get_displayable_history(chess) self.assertEqual( actual, [ {'name': 'b2 -> b3', 'images': [], 'class': ''}, {'name': 'e7 -> e6', 'images': [], 'class': ''}, {'name': 'b3 -> b4', 'images': [], 'class': 'current'}, ], )
def test_ab_prune_speed(depth=4): chess = Chess() succes, msg = chess.move(chess.legal_moves[0]) print(succes, msg) # print(len(chess.legal_moves)) # depth = 4 start_time = time.time() move, root, time_dict = chess_ai.choose_move_ab(chess, depth=depth, return_tree=True) end_time = time.time() move_choise_time = end_time - start_time print("Time for depth ", depth, ": ", move_choise_time) analysis_dict = {"count": 0, "branch": [[]]} chess_ai.count_tree_size(root, analysis_dict, 0) print("nodes visited: ", analysis_dict["count"]) for level, l in enumerate(analysis_dict["branch"]): print("Branching factor at level ", level, ": ", sum(l) / len(l)) print(time_dict)
def selected(game_token, row, column): # db_game = Game.query.get(game_token) db_game = Game.query.get(game_token) if not db_game: abort(400, "That game doesn't exits.") board = db_game.board game = Chess(existing_board=board) index = (int(row), int(column)) destinations = game.destinations(index) requested_index = get_requested_index(request) if requested_index: if requested_index in destinations: # move piece to requested index and re-direct to board if game.move(index, requested_index): db_game.board = game.export() db_game.save() url = "chess/game/{}/".format(game_token) return redirect(url) else: print("NOT A VALID MOVE!!!") elif game.destinations(requested_index): # redirect to a different selected route url = "chess/game/{}/selected/{}/{}/".format( game_token, requested_index[0], requested_index[1]) return redirect(url) else: # redirect to board url = "chess/game/{}/".format(game_token) return redirect(url) return render_template('selected.html', rows=8, columns=8, board=db_game.piece_locations, images=piece_images, destinations=destinations)
def move(game_token, start, end): # aborts if an invalid move. otherwise returns new board state after the move. game = Game.query.get(game_token) if game: if not game.is_full: abort(400, "This game needs more players.") chess = Chess(game.board) for player in game.board['players']: if game.current_player != current_user: abort(400, "Not your turn cheater!") # valid game, check if valid move success = chess.move(start, end) if not success: abort( 400, "Moving from {} to {} is an invalid move.".format(start, end)) data = dict(token=game.id, board=chess.generate_fen()) response = jsonify(data) response.status_code = 200 return response else: abort(400, "The game does not exist.")
def selected(game_token, row, column): # db_game = Game.query.get(game_token) db_game = Game.query.get(game_token) if not db_game: abort(400, "That game doesn't exits.") board = db_game.board game = Chess(existing_board=board) index = (int(row), int(column)) destinations = game.destinations(index) requested_index = get_requested_index(request) if requested_index: if requested_index in destinations: # move piece to requested index and re-direct to board if game.move(index, requested_index): db_game.board = game.export() db_game.save() url = "chess/game/{}/".format(game_token) return redirect(url) else: print("NOT A VALID MOVE!!!") elif game.destinations(requested_index): # redirect to a different selected route url = "chess/game/{}/selected/{}/{}/".format(game_token, requested_index[0], requested_index[1]) return redirect(url) else: # redirect to board url = "chess/game/{}/".format(game_token) return redirect(url) return render_template('selected.html', rows=8, columns=8, board=db_game.piece_locations, images=piece_images, destinations=destinations)
def move(game_token, start, end): # aborts if an invalid move. otherwise returns new board state after the move. game = Game.query.get(game_token) if game: if not game.is_full: abort(400, "This game needs more players.") chess = Chess(game.board) for player in game.board['players']: if game.current_player != current_user: abort(400, "Not your turn cheater!") # valid game, check if valid move success = chess.move(start, end) if not success: abort(400, "Moving from {} to {} is an invalid move.".format(start, end)) data = dict(token=game.id, board=chess.generate_fen()) response = jsonify(data) response.status_code = 200 return response else: abort(400, "The game does not exist.")
def move(self, request, pk=None): game = Game.objects.get(pk=pk) if not game.is_my_turn(request.user): return Response("not your turn", status=status.HTTP_400_BAD_REQUEST) chess = Chess(game.data) data = request.data destination_row = int(data['destination']['row']) destination_column = int(data['destination']['column']) start_row = int(data['start']['row']) start_column = int(data['start']['column']) chess.move((start_row, start_column), (destination_row, destination_column)) # update db with new board game.data = chess.export() game.save() return Response("success, time to refresh")
def test_get_displayable_history_with_capture_history(self): chess = Chess() chess.move((1, 1), (3, 1)) chess.move((6, 2), (4, 2)) chess.move((3, 1), (4, 2)) actual = get_displayable_history(chess) self.assertEqual( actual, [ {'name': 'b2 -> b4', 'images': [], 'class': ''}, {'name': 'c7 -> c5', 'images': [], 'class': ''}, { 'name': 'b4 -> c5', 'images': [ 'https://upload.wikimedia.org/wikipedia/commons/c/c7/Chess_pdt45.svg' ], 'class': 'current', }, ], )
def test_chess_move_speed(): time_dict = { "start": 0, "is_legal": 0, "copy": 0, "mid1": 0, "castleEnPassantCheck": 0, "is_in_check1": 0, "get_legal_moves": 0, "is_in_check2": 0 } chess = Chess() for i in range(35): # print(i) chess.move(chess.legal_moves[0], time_dict=time_dict) total = 0 for key in time_dict: total += time_dict[key] print(total) print(time_dict) for key in time_dict: time_dict[key] = (time_dict[key] / total) * 100 print(time_dict)
async def chat_message(self, event): message = event['message'] game_id = message['game_id'] game = await self.get_game(game_id) chess = Chess(game.data) if not await self.is_my_turn(game_id, self.scope["user"]): print("Failed Not my turn") await self.send_update(game) else: chess = Chess(game.data) print("Trying to move") moved = chess.move( self.convert_to_position(message['start']), self.convert_to_position(message['destination'])) print("Successfully moved: " + str(moved)) await self.save_game(game, chess) await self.send_update(game)
class TestChess(unittest.TestCase): def setUp(self): self.chess = Chess() def _print(self): print(self.chess) def _move(self, origin, destination): self.chess.move(origin, destination) def test_piece_color_and_type(self): self.assertRaises(ValueError, Pawn, "string") p = Pawn(Color.WHITE) self.assertEqual(p.type, Piece_Type.PAWN) self.assertEqual(p.color, Color.WHITE) self.assertEqual(p.has_moved, False) self.assertEqual(str(p), "P") p = Pawn(Color.BLACK) self.assertEqual(p.color, Color.BLACK) self.assertEqual(str(p), "p") self.assertEqual(p.has_moved, False) p = Knight(Color.WHITE) self.assertEqual(p.type, Piece_Type.KNIGHT) self.assertEqual(str(p), "N") p = Bishop(Color.WHITE) self.assertEqual(p.type, Piece_Type.BISHOP) self.assertEqual(str(p), "B") p = Rook(Color.WHITE) self.assertEqual(p.type, Piece_Type.ROOK) self.assertEqual(str(p), "R") p = Queen(Color.WHITE) self.assertEqual(p.type, Piece_Type.QUEEN) self.assertEqual(str(p), "Q") p = King(Color.WHITE) self.assertEqual(p.type, Piece_Type.KING) self.assertEqual(str(p), "K") self.assertEqual(p.has_moved, False) def test_pawn_valid_moves_no_capture(self): # white move - two squares pos = Coordinate.e2 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set([Coordinate.e3, Coordinate.e4]) self.assertEqual(moves, answer) # black move - two squares self._move(Coordinate.e2, Coordinate.e4) self.assertEqual(self.chess.pieces[Coordinate.e4].has_moved, True) pos = Coordinate.e7 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set([Coordinate.e6, Coordinate.e5]) self.assertEqual(moves, answer) # blocked white pawn self._move(Coordinate.e7, Coordinate.e5) self.assertEqual(self.chess.pieces[Coordinate.e5].has_moved, True) pos = Coordinate.e4 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set() self.assertEqual(moves, answer) # blocked black pawn pos = Coordinate.e5 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) self.assertEqual(moves, answer) # white move - pawn that moved previously self._move(Coordinate.a2, Coordinate.a3) pos = Coordinate.a3 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set([Coordinate.a4]) self.assertEqual(moves, answer) # black move - pawn that moved previously self._move(Coordinate.b7, Coordinate.b5) pos = Coordinate.b5 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set([Coordinate.b4]) self.assertEqual(moves, answer) # white move - second square not empty self._move(Coordinate.a3, Coordinate.a4) self._move(Coordinate.b5, Coordinate.b4) pos = Coordinate.b2 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set([Coordinate.b3]) self.assertEqual(moves, answer) # black move - second square not empty self._move(Coordinate.a4, Coordinate.a5) pos = Coordinate.a7 moves = self.chess.valid_moves_for_piece_at_coordinate(pos) answer = set([Coordinate.a6]) self.assertEqual(moves, answer) def test_pawn_valid_moves_capture(self): # white one capture available self._move(Coordinate.e2, Coordinate.e4) self._move(Coordinate.f7, Coordinate.f5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e4) answer = set([Coordinate.e5, Coordinate.f5]) self.assertEqual(moves, answer) # black one capture available moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.f5) answer = set([Coordinate.e4, Coordinate.f4]) self.assertEqual(moves, answer) # black two captures available self._move(Coordinate.g2, Coordinate.g4) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.f5) answer = set([Coordinate.e4, Coordinate.f4, Coordinate.g4]) self.assertEqual(moves, answer) # white two captures available self._move(Coordinate.d7, Coordinate.d5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e4) answer = set([Coordinate.d5, Coordinate.e5, Coordinate.f5]) self.assertEqual(moves, answer) def test_en_passant_white(self): # white right self._move(Coordinate.e2, Coordinate.e4) self._move(Coordinate.a7, Coordinate.a6) self._move(Coordinate.e4, Coordinate.e5) self._move(Coordinate.f7, Coordinate.f5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e5) answer = set([Coordinate.e6, Coordinate.f6]) self.assertEqual(moves, answer) # en passant gone after move is made self._move(Coordinate.a2, Coordinate.a3) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e5) answer = set([Coordinate.e6]) self.assertEqual(moves, answer) # white left self._move(Coordinate.a3, Coordinate.a4) self._move(Coordinate.d7, Coordinate.d5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e5) answer = set([Coordinate.d6, Coordinate.e6]) self.assertEqual(moves, answer) # en passant gone after move is made self._move(Coordinate.a4, Coordinate.a5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e5) answer = set([Coordinate.e6]) self.assertEqual(moves, answer) def test_en_passant_black(self): # black right self._move(Coordinate.a2, Coordinate.a3) self._move(Coordinate.e7, Coordinate.e5) self._move(Coordinate.a3, Coordinate.a4) self._move(Coordinate.e5, Coordinate.e4) self._move(Coordinate.f2, Coordinate.f4) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e4) answer = set([Coordinate.e3, Coordinate.f3]) self.assertEqual(moves, answer) # en passant gone after move is made self._move(Coordinate.a4, Coordinate.a5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e4) answer = set([Coordinate.e3]) self.assertEqual(moves, answer) # black left self._move(Coordinate.a7, Coordinate.a6) self._move(Coordinate.d2, Coordinate.d4) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e4) answer = set([Coordinate.d3, Coordinate.e3]) self.assertEqual(moves, answer) # en passant gone after move is made self._move(Coordinate.b2, Coordinate.b3) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.e4) answer = set([Coordinate.e3]) self.assertEqual(moves, answer) def test_pawn_squares_attacked(self): # center pos = Coordinate.e2 attacked = self.chess.squares_attacked_by_piece_at_coordinate(pos) answer = set([Coordinate.d3, Coordinate.f3]) self.assertEqual(attacked, answer) # edge pos = Coordinate.a2 attacked = self.chess.squares_attacked_by_piece_at_coordinate(pos) answer = set([Coordinate.b3]) self.assertEqual(attacked, answer) def test_knight_valid_moves(self): # white edge moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.b1) answer = set([Coordinate.a3, Coordinate.c3]) self.assertEqual(moves, answer) # black edge moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.b8) answer = set([Coordinate.a6, Coordinate.c6]) self.assertEqual(moves, answer) # white center self._move(Coordinate.b1, Coordinate.c3) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.c3) answer = set([Coordinate.b5, Coordinate.d5, # top Coordinate.b1, # btm Coordinate.a4, # left Coordinate.e4]) # right self.assertEqual(moves, answer) # black center self._move(Coordinate.b8, Coordinate.c6) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.c6) answer = set([Coordinate.b8, # top Coordinate.b4, Coordinate.d4, # btm Coordinate.a5, # left Coordinate.e5]) # right self.assertEqual(moves, answer) # white attacking pieces self._move(Coordinate.c3, Coordinate.d5) attacked = self.chess.squares_attacked_by_piece_at_coordinate(Coordinate.d5) answer = set([Coordinate.c7, Coordinate.e7, # top Coordinate.f4, Coordinate.f6, # right Coordinate.c3, Coordinate.e3, # btm Coordinate.b4, Coordinate.b6]) # left self.assertEqual(attacked, answer) def test_knight_squares_attacked(self): # white edge pos = Coordinate.b1 attacked = self.chess.squares_attacked_by_piece_at_coordinate(pos) answer = set([Coordinate.a3, Coordinate.c3, Coordinate.d2]) self.assertEqual(attacked, answer) # white center self._move(Coordinate.b1, Coordinate.c3) pos = Coordinate.c3 attacked = self.chess.squares_attacked_by_piece_at_coordinate(pos) answer = set([Coordinate.b5, Coordinate.d5, # top Coordinate.e2, Coordinate.e4, # right Coordinate.b1, Coordinate.d1, # btm Coordinate.a2, Coordinate.a4]) # left self.assertEqual(attacked, answer) def test_bishop_valid_moves_white(self): # no moves moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.c1) answer = set() self.assertEqual(moves, answer) # one lane self._move(Coordinate.e2, Coordinate.e4) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.f1) answer = set([Coordinate.e2, Coordinate.d3, Coordinate.c4, Coordinate.b5, Coordinate.a6]) self.assertEqual(moves, answer) # one lane with capture self._move(Coordinate.a7, Coordinate.a6) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.f1) self.assertEqual(moves, answer) # four lanes with capture self._move(Coordinate.f1, Coordinate.b5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.b5) answer = set([Coordinate.c6, Coordinate.d7, Coordinate.c4, Coordinate.d3, Coordinate.e2, Coordinate.f1, Coordinate.a4, Coordinate.a6]) self.assertEqual(moves, answer) def test_bishop_valid_moves_black(self): # no moves self._move(Coordinate.e2, Coordinate.e4) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.c8) answer = set() self.assertEqual(moves, answer) # one lane self._move(Coordinate.e7, Coordinate.e5) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.f8) answer = set([Coordinate.e7, Coordinate.d6, Coordinate.c5, Coordinate.b4, Coordinate.a3]) self.assertEqual(moves, answer) # four lanes self._move(Coordinate.f8, Coordinate.b4) moves = self.chess.valid_moves_for_piece_at_coordinate(Coordinate.b4) answer = set([Coordinate.c5, Coordinate.d6, Coordinate.e7, Coordinate.f8, Coordinate.c3, Coordinate.d2, Coordinate.a3, Coordinate.a5]) self.assertEqual(moves, answer) self._print()