def setUp(self) -> None:
self.player_turn = 1
self.chess_game = ChessGame()
self.chess_board = self.chess_game.board
self.chess_game.player_turn = self.player_turn
self.start_space = Vec2(5, 5)
self.king = King(team=self.player_turn)
self.knight = Knight(team=self.player_turn)
self.pawn = Pawn(team=self.player_turn)
self.enemy_pawn = Pawn(team=2)
self.p1_pawn = Pawn(team=1)
async def accept(self, ctx, *args):
#should be log
print("accept read from", ctx.author)
now = datetime.now() #used to clear out old self.challenges
#go through the challenges
for idx in range(len(self.challenges)):
challenge = self.challenges[idx]
if (challenge[3] - now) > timedelta(minutes=15):
print("challenge timed out")
self.challenges.pop(idk)
continue
#first see if the challenge is the same channel as the accept
if challenge[2] == ctx.channel:
#if there is a game already in the channel, do not start another
for game in self.ongoing_games:
if game.channel == ctx.channel:
return
#see if the accepter is one of the people challenged
for mention in challenge[0]:
if mention.id == ctx.author.id:
#see if accepter @'d someone, if not just accept first challenge
if (len(ctx.message.mentions)) == 0:
print("game start between ", ctx.author,
challenge[1], "in channel", ctx.channel)
self.ongoing_games.append(
ChessGame(challenge[1], ctx.author,
ctx.channel, challenge[4]))
await self.ongoing_games[-1].start_game()
self.challenges.pop(idx)
return
else:
#find the challenger who the accepter @'d
for mention2 in ctx.message.mentions:
if mention2.id == challenge[1]:
print("@ game start between ", ctx.author,
challenge[1], "in channel",
ctx.channel)
self.ongoing_games.append(
ChessGame(challenge[1], ctx.author,
ctx.channel, challenge[4]))
await self.ongoing_games[-1].start_game()
self.challenges.pop(idx)
return
async def challenge(self, ctx, *args):
#should be log
print("challenge read from", ctx.author)
#must challenge another user
if len(args) == 0:
return
#cannot challenge everyone
if not ctx.message.mention_everyone:
#if the bot is being challenged start the game
if ctx.bot.user in ctx.message.mentions:
#check if game already in channel
for g in self.ongoing_games:
if g.channel == ctx.channel:
return
self.ongoing_games.append(
ChessGame(ctx.author, 0, ctx.channel, args[-1]))
await self.ongoing_games[-1].start_game()
else:
now = datetime.now()
try:
#Cannot challenge self, try to remove
self.challenges.append(
(ctx.message.mentions.remove(ctx.author), ctx.author,
ctx.channel, now, args[-1]))
except:
self.challenges.append((ctx.message.mentions, ctx.author,
ctx.channel, now, args[-1]))
def main():
print("Welcome to our chess AI! Please select your difficulty:")
print("Easy: 1")
print("Medium: 2")
print("Hard: 3")
diff = input("")
depth = 0
if diff == "1":
depth = 1
elif diff == "2":
depth = 2
elif diff == "3":
depth = 3
demo_human_agent = HumanAgent(True)
demo_opponent_agent = OrderedAgentTrans(False,
combined,
depth,
load_hh=True)
demo_game = ChessGame(demo_human_agent, demo_opponent_agent)
demo_game.play_game(True)
def precmd(self, line):
# Maybe change later for better way to take things out of queue
# Think about using try except
while not self.data_streamer.challenges.empty():
challenge = self.data_streamer.challenges.get()
self.challenges[challenge['id']] = challenge
while not self.data_streamer.games.empty():
new_game, date = self.data_streamer.games.get()
self.games[new_game['id']] = ChessGame(self.username, new_game,
date)
while not self.data_streamer.updates.empty():
# update is tuple of (game_id, message)
game_id, message, date = self.data_streamer.updates.get()
if message['type'] == 'gameState':
self.games[game_id].update_game(message, date)
return line
def transform(self, algebraic_moves):
game = ChessGame()
return ''.join(
game.make_move_from_algebraic_and_return_uci(move)
for move in algebraic_moves)
def main():
game = ChessGame(setup_pieces=True)
game.run()
def main():
my_game = ChessGame(GreedyAgent, RandAgent)
my_game.play_game()
def main():
selected_game_mode = -1
while (selected_game_mode < 0 or selected_game_mode > 3):
print('Select game mode:')
print('1. Normal chess')
print('2. Reverse chess (suicide mode)')
selected_game_mode = int(input('Selection: '))
print('')
selected_scenario = -1
while (selected_scenario < 0 or selected_scenario > 7):
print('Select game scenario:')
print('1. Train AI')
print('2. Watch trained AI vs trained AI')
print('3. Watch trained AI vs normal AI')
print('4. Watch normal AI vs normal AI')
print('5. Play against trained AI')
print('6. Play against normal AI')
selected_scenario = int(input('Selection: '))
# Select playing color if human vs ai
selected_color = -1
if (selected_scenario > 4 and selected_scenario <= 6):
while (selected_color < 0 or selected_color > 3):
print('Select Color:')
print('1. White')
print('2. Black')
selected_color = int(input('Selection: '))
game_variant = None
if (selected_game_mode == 1):
game_variant = 'chess'
elif (selected_game_mode == 2):
game_variant = 'suicide'
else:
raise Exception('Invalid game mode!')
# Load train data if a scenario including 'trained AI' is selected
# train_data = np.load('train_file.npy')
# [1. Train AI]
if (selected_scenario == 1):
# todoooooooooooooooooooooooooo------------------------------------------
pass
else:
white_player = None
black_player = None
# [2. Watch trained AI vs trained AI]
if (selected_scenario == 2):
white_player = AIPlayer(is_white=True,
depth=3,
piece_square_table=None)
black_player = AIPlayer(is_white=False,
depth=3,
piece_square_table=None)
# [3. Watch trained AI vs normal AI]
elif (selected_scenario == 3):
white_player = AIPlayer(is_white=True,
depth=3,
piece_square_table=None)
black_player = AIPlayer(is_white=False,
depth=3,
piece_square_table=None)
# [4. Watch normal AI vs normal AI]
elif (selected_scenario == 4):
white_player = AIPlayer(is_white=True,
depth=3,
piece_square_table=None)
black_player = AIPlayer(is_white=False,
depth=3,
piece_square_table=None)
# [5. Play against trained AI]
elif (selected_scenario == 5):
# [1. White]
if (selected_color == 1):
white_player = HumanPlayer(is_white=True)
black_player = AIPlayer(is_white=False,
depth=3,
piece_square_table=None)
# [2. Black]
elif (selected_color == 2):
white_player = AIPlayer(is_white=True,
depth=3,
piece_square_table=None)
black_player = HumanPlayer(is_white=False)
else:
raise Exception('Invalid color!')
# [6. Play against normal AI]
elif (selected_scenario == 6):
# [1. White]
if (selected_color == 1):
white_player = HumanPlayer(is_white=True)
black_player = AIPlayer(is_white=False,
depth=3,
piece_square_table=None)
# [2. Black]
elif (selected_color == 2):
white_player = AIPlayer(is_white=True,
depth=3,
piece_square_table=None)
black_player = HumanPlayer(is_white=False)
else:
raise Exception('Invalid color!')
else:
raise Exception('Invalid scenario!')
chess_game = ChessGame(white_player=white_player,
black_player=black_player,
variant=game_variant,
max_turn=None)
gameover = False
result = None
while (not gameover):
gameover, result = chess_game.play_half_turn()
print(gameover)
print(result)
class ChessGameTests(unittest.TestCase):
def setUp(self) -> None:
self.player_turn = 1
self.chess_game = ChessGame()
self.chess_board = self.chess_game.board
self.chess_game.player_turn = self.player_turn
self.start_space = Vec2(5, 5)
self.king = King(team=self.player_turn)
self.knight = Knight(team=self.player_turn)
self.pawn = Pawn(team=self.player_turn)
self.enemy_pawn = Pawn(team=2)
self.p1_pawn = Pawn(team=1)
def test_creating_a_chess_game_works_fuck(self):
self.assertIsInstance(self.chess_game, ChessGame)
def test_pawn_can_move_one_space_forward(self):
# Arrange
end_space = self.start_space + Vec2(0, -1)
move = Move(self.start_space, end_space)
self.chess_game.board.set_piece(self.start_space, self.pawn)
# Act
self.chess_game.try_player_move(move, self.player_turn)
# Assert
self.assertEqual(self.chess_game.board.get_piece(end_space), self.pawn)
def test_pawn_cannot_move_backwards(self):
# Arrange
end_space = self.start_space + Vec2(0, 1)
move = Move(self.start_space, end_space)
self.chess_game.board.set_piece(self.start_space, self.pawn)
# Act & Assert
self.assertRaises(IllegalMove, self.chess_game.try_player_move, move, self.player_turn)
def test_king_is_on_board(self):
# Arrange
self.chess_game.board.set_piece(self.start_space, self.king)
# Act & Assert
self.assertTrue(self.chess_game.board.get_king(self.player_turn))
def test_knight_border_portal(self):
# Arrange
knight = Knight(team=1)
knight_starting_space = Vec2(1, 0)
knight_destination_space = Vec2(0, 2)
knight_move = Move(knight_starting_space, knight_destination_space)
self.chess_game.board.set_piece(knight_starting_space, knight)
# Act & Assert
self.assertTrue(knight.can_move(knight_move, self.chess_board))
def test_get_king(self):
# Arrange
king_start_pos = Vec2(4, 0)
self.chess_game.board.set_piece(king_start_pos, self.king)
# Act
the_king = self.chess_board.get_king(self.player_turn)
# Assert
self.assertEqual(self.king, the_king)
def test_get_king_returns_none_if_no_king(self):
# Arrange
# No arrangement
# Act
the_king = self.chess_board.get_king(self.player_turn)
# Assert
self.assertIsNone(the_king)
def test_can_king_free_himself_if_checked(self):
# Arrange
king_start_pos = Vec2(4,7)
self.chess_game.board.set_piece(king_start_pos, self.king)
self.chess_game.board.set_piece(Vec2(5, 6), self.enemy_pawn)
# Act
king_move = self.king.can_move(Move(king_start_pos, Vec2(3, 7)), self.chess_board)
# Assert
self.assertTrue(king_move)
def test_king_cannot_endanger_himself(self):
# Arrange
king_start_pos = Vec2(4, 7)
self.chess_game.board.set_piece(king_start_pos, self.king)
self.chess_game.board.set_piece(Vec2(5, 5), self.enemy_pawn)
# Act
king_move = self.king.can_move(Move(king_start_pos, Vec2(4, 2)), self.chess_board)
# Assert
self.assertFalse(king_move)
def test_pawn_may_double_jump(self):
# Arrange
pawn_start_pos = Vec2(5, 5)
# Act
pawn_move = self.pawn.can_move(Move(pawn_start_pos, Vec2(5, 3)), self.chess_board)
# Assert
self.assertTrue(pawn_move)
def test_pawn_may_not_double_jump_after_moving(self):
# Arrange
pawn_start_pos = Vec2(0, 6)
# Act
self.chess_board.move(Move(pawn_start_pos, Vec2(0, 3)))
pawn_move_to_test = self.p1_pawn.can_move(Move(pawn_start_pos, Vec2(5, 3)), self.chess_board)
# Assert
self.assertFalse(pawn_move_to_test)
def test_horse_may_jump(self):
# Arrange
knight_start_pos = Vec2(5, 5)
self.chess_game.board.set_piece(knight_start_pos, self.knight)
self.chess_game.board.set_piece(Vec2(5, 4), self.pawn)
self.chess_game.board.set_piece(Vec2(4, 4), self.king)
# Act
knight_jump = self.knight.can_move(Move(knight_start_pos, Vec2(3, 4)), self.chess_board)
# Assert
self.assertTrue(knight_jump)
def test_king_may_castle_left(self):
# Arrange
king_start_pos = Vec2(4, 7)
rook_start_pos = Vec2(0, 7)
self.chess_game.board.set_piece(king_start_pos, self.king)
self.chess_game.board.set_piece(rook_start_pos, Rook(team=self.player_turn))
# Act
castle_move = self.king.can_move(Move(king_start_pos, Vec2(2, 7)), self.chess_board)
# Assert
self.assertTrue(castle_move)
def test_king_may_castle_right(self):
# Arrange
king_start_pos = Vec2(4, 7)
rook_start_pos = Vec2(7, 7)
self.chess_game.board.set_piece(king_start_pos, self.king)
self.chess_game.board.set_piece(rook_start_pos, Rook(team=self.player_turn))
# Act
castle_move = self.king.can_move(Move(king_start_pos, Vec2(6, 7)), self.chess_board)
# Assert
self.assertTrue(castle_move)
def test_king_cannot_over_move_For_castle_left(self):
# Arrange
king_start_pos = Vec2(4, 7)
rook_start_pos = Vec2(0, 7)
self.chess_game.board.set_piece(king_start_pos, self.king)
self.chess_game.board.set_piece(rook_start_pos, Rook(team=self.player_turn))
# Act
castle_move = self.king.can_move(Move(king_start_pos, Vec2(1, 7)), self.chess_board)
# Assert
self.assertFalse(castle_move)
def test_king_cannot_over_move_For_castle_right(self):
# Arrange
king_start_pos = Vec2(4, 7)
rook_start_pos = Vec2(7, 7)
self.chess_game.board.set_piece(king_start_pos, self.king)
self.chess_game.board.set_piece(rook_start_pos, Rook(team=self.player_turn))
# Act
castle_move = self.king.can_move(Move(king_start_pos, Vec2(7, 7)), self.chess_board)
# Assert
self.assertFalse(castle_move)
def test_piece_may_not_move_out_of_bounds(self):
# Arrange
knight_end_pos = Vec2(-2, -1)
# Act
is_knight_moving_inbound = self.chess_board.in_board(knight_end_pos)
# Assert
self.assertFalse(is_knight_moving_inbound)
def test_new_coordinates_via_pawn_double_jump(self):
# Arrange
self.chess_board.set_piece(Vec2(0, 2), self.enemy_pawn)
# Act
self.chess_board.move(Move(Vec2(0, 2), Vec2(0, 4)))
# Assert
self.assertTrue(self.chess_board.get_piece(Vec2(0, 4)).name == "Pawn")
def transform(self, algebraic_moves):
game = ChessGame()
return "".join(game.make_move_from_algebraic_and_return_uci(move) for move in algebraic_moves)
from chess_game import ChessGame
_DEBUG = False
if __name__ == '__main__':
my_game = ChessGame()
my_game.run()
def process_result_value(self, uci_moves_string, dialect):
if isinstance(uci_moves_string, basestring):
playable_game = ChessGame()
return playable_game.make_moves_from_long_uci_string(
uci_moves_string)
return uci_moves_string
def moves_list(self):
return ChessGame().make_moves_from_long_uci_string(self.moves)
def process_result_value(self, uci_moves_string, dialect):
if isinstance(uci_moves_string, basestring):
playable_game = ChessGame()
return playable_game.make_moves_from_long_uci_string(uci_moves_string)
return uci_moves_string
