def stockFish_init(request): stockfish = Stockfish(parameters={ "Threads": 2, "Minimum Thinking Time": 30 }) stockfish.set_position(["e2e4", "e7e6"]) #posición de Forsyth–Edwards Notation (FEN) stockfish.set_fen_position( "rnbqkbnr/pppp1ppp/4p3/8/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2") #coge el mejor movimiento stockfish.get_best_move( ) #stockfish.get_best_move_time(1000) en base al tiempo #nivel del motor stockfish.set_skill_level(15) #parámetros por defecto stockfish.get_parameters() #coge la posición FEN stockfish.get_fen_position() #coge el tablero por defecto del usuario stockfish.get_board_visual() #evalua jugada stockfish.get_evaluation() p = subprocess.Popen('stockfish-x64.exe', stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) p.stdin.write("position startpos moves e2e4 e7e5\n") p.stdin.write("go infinite\n") p.stdin.flush() time.sleep(1) print(p.communicate())
class Computer: def __init__(self, skill_level): self.engine = Stockfish("./stockfish12/bin/stockfish") self.engine.set_skill_level(skill_level) self.move_history = [] def get_move(self, player_move): self.move_history.append(player_move) self.engine.set_position(self.move_history) auto_move = self.engine.get_best_move() self.move_history.append(auto_move) return auto_move def get_suggestion(self): self.engine.set_position(self.move_history) auto_move = self.engine.get_best_move() return auto_move def print_board(self): self.engine.set_position(self.move_history) print(self.engine.get_board_visual()) # input -- board state (changes based on the user's move) # output -- stockfish move
def play(self): dirname = os.path.dirname(__file__) filename = os.path.join(dirname, 'stockfish-9-win\Windows\stockfish_9_x64') stockfish = Stockfish(filename) stockfish.set_skill_level(15) if not self.chessboard.is_game_over() and not self.chessboard.is_stalemate(): board = self.chessboard.fen() stockfish.set_fen_position(board) ai_move = stockfish.get_best_move() move = chess.Move.from_uci(ai_move) print(move) self.chessboard.push(move) self.update()
class LiChessBot(): def __init__(self): self.driver = webdriver.Firefox() self.engine = Stockfish() self.engine.set_skill_level(20) self.last_output = None self.logged_in = False def enter_match(self, time_format): """Starts a game with the given time format.""" self.driver.get('https://lichess.org') sleep(SLEEP_TIME_MATCHING) self.driver.find_element_by_xpath( f'//*[@data-id="{TIME_FORMAT}"]/div').click() sleep(SLEEP_TIME_MATCHING) # finding the color page = self.request_script() sleep(1) for i in range(len(page) - len((key := "\"player\":{\""))):
class Engine(object): def __init__(self): super().__init__() self.engine = None self.max_time = 1000 # Milliseconds self.list_moves = [] def set_engine(self, engine_name="stockfish", skill_level=10): if engine_name == "stockfish": # stockfish_dir = os.path.join(Resource.get_engine_dir(), "stockfish_20090216_x64.exe") stockfish_dir = os.path.join("E:\\Jeee\\Documents\\Projects\\Python\\Chess\\engines", "stockfish_20090216_x64.exe") self.engine = Stockfish(stockfish_dir) self.set_engine_skill_level(skill_level) def set_engine_skill_level(self, level): self.engine.set_skill_level(level) def get_best_move(self): move = self.engine.get_best_move() return move def move(self, move): self.list_moves.append(move) self.engine.set_position(self.list_moves) # self.print_board_visual() Logger.record_move(move) def print_board_visual(self): print(self.engine.get_board_visual()) def close_engine(self): self.engine.__del__
from stockfish import Stockfish def debug(msg): print(msg, file=sys.stderr) def parser_args(): parser = argparse.ArgumentParser() parser.add_argument('-l', '--level', help='Show board', type=int, action='store', default=1) args = parser.parse_args() return args debug("Stockfish bot starting!\n") args = parser_args() s = Stockfish('./bin/stockfish') s.set_skill_level(args.level) while True: fen = input() debug(fen) s.set_fen_position(fen) print(s.get_best_move())
def main(player1="Player 1", player2="Player 2", mode="STANDARD", bot_bool=False, bot_difficulty=6): # resetting the variables in the .json file# json_file = open(r'components\constants.json', 'r') json_content = json.load(json_file) json_content["round_int"] = 0 json_file.close() json_file = open(r'components\constants.json', 'w') json_file.writelines(json.dumps(json_content)) json_file.close() Pieces.white_is_checked = False Pieces.black_is_checked = False Pieces.checking_piece = None #initiating pygame# pygame.init() player1 = "Spieler 1" if player1 == "" else player1 player2 = "Spieler 2" if player2 == "" else player2 #Constants# BLACK = (0, 0, 0) GREY = (50, 50, 50) WHITE = (255, 255, 255) BG_COLOR_1 = (0, 152, 163) BG_COLOR_2 = (2, 112, 120) #reading the constants from the json file# json_file = open(os.getcwd() + r"\components\constants.json", "r") json_content = json.load(json_file) round_int = json_content["round_int"] tile_size = json_content["tile_size"] anchor_point_s = (json_content["anchor_point_s_x"] * tile_size, json_content["anchor_point_s_y"] * tile_size) anchor_point_h = (json_content["anchor_point_h_x"] * tile_size, json_content["anchor_point_h_y"] * tile_size) anchor_point_hud = (json_content["anchor_point_hud_x"] * tile_size, json_content["anchor_point_hud_y"] * tile_size) json_file.close() #setting up the variables for a new and fresh game# screen_size = (11 * tile_size, 11 * tile_size) font = pygame.font.SysFont("DejaVu Sans", int(tile_size * 0.2)) font_titles = pygame.font.SysFont("DejaVu Sans", int(tile_size * 0.25)) go = True timer = Clock(time=5) #creating the surfaces# screen = pygame.display.set_mode(screen_size, 0, 0) s = pygame.Surface((8 * tile_size, 8 * tile_size)) hud = pygame.Surface((10.25 * tile_size, 2 * tile_size)) p1 = pygame.Surface((3 * tile_size, 1.5 * tile_size)) p2 = pygame.Surface((3 * tile_size, 1.5 * tile_size)) h = Hud((2 * tile_size, 8 * tile_size)) screen.fill(BG_COLOR_1) hud.fill(BG_COLOR_2) h.fill(BG_COLOR_2) h.print(pos=(0.6 * tile_size, 20), label='Spielhistorie', font=font) #window caption# pygame.display.set_caption("Chess") #creating a clock for the ingame ticks# clock = pygame.time.Clock() #creating the board on the subsurface# board = Board(master=s, width=8, height=8, tile_size=tile_size, color_a=(245, 216, 188), color_b=(176, 142, 109), color_t1=(240, 230, 221), color_t2=(201, 181, 163), anchor_point=anchor_point_s) #loading the images for the pieces# images = { "white_pawn_img": pygame.image.load(r'assets/white_pawn.png'), "white_rook_img": pygame.image.load(r'assets/white_rook.png'), "white_knight_img": pygame.image.load(r'assets/white_knight.png'), "white_bishop_img": pygame.image.load(r'assets/white_bishop.png'), "white_queen_img": pygame.image.load(r'assets/white_queen.png'), "white_king_img": pygame.image.load(r'assets/white_king.png'), "black_pawn_img": pygame.image.load(r'assets/black_pawn.png'), "black_rook_img": pygame.image.load(r'assets/black_rook.png'), "black_knight_img": pygame.image.load(r'assets/black_knight.png'), "black_bishop_img": pygame.image.load(r'assets/black_bishop.png'), "black_queen_img": pygame.image.load(r'assets/black_queen.png'), "black_king_img": pygame.image.load(r'assets/black_king.png') } #loading the icons for the buttons# quit_icon = pygame.image.load(r'assets/quit.png') takeback_icon = pygame.image.load(r'assets/takeback.png') resign_icon = pygame.image.load(r'assets/resign_flag.png') test_icon = pygame.image.load(r'assets/lightbulb.png') #creating the board build_board(mode, s, images) #creating the chessbot based on .json parameters bot = Stockfish(b'components\stockfish_20011801_x64.exe') bot.set_skill_level(bot_difficulty) quit_button = Button(x=8.5 * tile_size, y=0.4 * tile_size, w=int(0.6 * tile_size), h=int(0.6 * tile_size), color_b=BLACK, color_in=GREY, color_t=WHITE, command=quit, icon=quit_icon, imaginary_x=anchor_point_hud[0], imaginary_y=anchor_point_hud[1]) resign_button = Button(x=9.2 * tile_size, y=0.4 * tile_size, w=int(0.6 * tile_size), h=int(0.6 * tile_size), color_b=BLACK, color_in=GREY, color_t=WHITE, command=lambda: [decideWhoLost(round_int)], icon=resign_icon, imaginary_x=anchor_point_hud[0], imaginary_y=anchor_point_hud[1]) test_zone_button = Testmode_Button( x=9.2 * tile_size, y=0.4 * tile_size + 0.74 * tile_size, w=int(0.6 * tile_size), h=int(0.6 * tile_size), color_b=BLACK, color_in=GREY, color_t=WHITE, command1=lambda: [ Board.change_testmode(), #Pieces.change_ignore_me_standard(), Pieces.crop_move_done(), Pieces.kill_board(), build_board(mode, s, images), Pieces.build_from_list(screen=s), Pieces.set_round(Pieces.round_safe) ], command2=lambda: [ Board.change_testmode(), #Pieces.change_ignore_me_standard(), Pieces.safe_round() ], icon=test_icon, imaginary_x=anchor_point_hud[0], imaginary_y=anchor_point_hud[1], deaf=False) if bot_bool: command = lambda: [ takeback(board, s, takeback_button), takeback(board, s, takeback_button) ] else: command = lambda: [takeback(board, s, takeback_button)] takeback_button = Button(x=8.5 * tile_size, y=0.4 * tile_size + 0.74 * tile_size, w=int(0.6 * tile_size), h=int(0.6 * tile_size), color_b=BLACK, color_in=GREY, color_t=WHITE, command=command, icon=takeback_icon, imaginary_x=anchor_point_hud[0], imaginary_y=anchor_point_hud[1]) start_sound = mixer.Sound("assets/sounds/board-start.mp3") start_sound.play() #the mainloop# while go: #setting the framerate# clock.tick(60) #refreshing the round counter# json_file = open(os.getcwd() + r"\components\constants.json", "r") json_content = json.load(json_file) round_int = json_content["round_int"] json_file.close() #drawing the board# # if not Board.game_over: board.draw_board() #updating the bot with the new game state# bot.set_fen_position(Pieces.give_FEN()) #detecting, if the game is over, or not if not Board.game_over: Pieces.detectingCheck() Board.game_over = Pieces.detectGameOver(round_int=round_int) #end the game if the game is over# if Board.game_over or Board.resign_w or Board.resign_b: if Pieces.white_is_checked or Board.resign_w: board.end_screen('BLACK', s) elif Pieces.black_is_checked or Board.resign_b: board.end_screen('WHITE', s) else: board.end_screen('STALEMATE', s) takeback_button.active = False resign_button.active = False test_zone_button.active = False #checking if a pawn is promotable# for pawn in Pieces.all_pieces_list: if 'Pawn-B' in pawn.name and pawn.y == 7 * tile_size or 'Pawn-W' in pawn.name and pawn.y == 0 * tile_size: pawn.promotion() Pieces.detectingCheck() #highlighting the checked king# if Pieces.white_is_checked: for king in Pieces.all_pieces_list: if isinstance(king, Kings) and king.farbe == WHITE: board.check(king_pos=(king.x, king.y)) #highlighting the checked king# elif Pieces.black_is_checked: for king in Pieces.all_pieces_list: if isinstance(king, Kings) and king.farbe == BLACK: board.check(king_pos=(king.x, king.y)) #drawing all the pieces# # if not Board.game_over: for pieces in Pieces.all_pieces_list: pieces.draw(screen) #updating the mainsurface# pygame.display.update() #clearing the Subsurfaces# p1.fill(BG_COLOR_1) p2.fill(BG_COLOR_1) hud.fill(BG_COLOR_2) #refresh the time of the timers# timer.refreshTime() #creating the labels to be printed on the subsurfaces# Player_1_label = font_titles.render(player1, 1, BLACK) Player_2_label = font_titles.render(player2, 1, BLACK) timer_label = font_titles.render(timer.getTime(), 1, BLACK) #printing the labes on the subsurfaces# p1.blit(Player_1_label, (p1.get_width() / 2 - Player_1_label.get_width() / 2, 0)) p2.blit(Player_2_label, (p2.get_width() / 2 - Player_2_label.get_width() / 2, 0)) #creating the history h.fill(BG_COLOR_2) h.print((0.31 * tile_size, 20), 'Spielhistorie', font) for i in range(len(Pieces.moves_done)): fac_50 = 5 / 7 * tile_size fac_20 = 2 / 7 * tile_size h.print(pos=((i % 2) * fac_50 + fac_20, (i // 2) * fac_20 + 2 * fac_20), label=Pieces.moves_done[i], font=font) #showing the taken pieces# Pieces.taken_pieces.sort(key=lambda x: x.value, reverse=False) white_loss = [[], []] black_loss = [[], []] for piece in Pieces.taken_pieces: if piece.farbe == (0, 0, 0): if len(black_loss[0]) < 8: black_loss[0].append(piece) else: black_loss[1].append(piece) elif piece.farbe == WHITE: if len(white_loss[0]) < 8: white_loss[0].append(piece) else: white_loss[1].append(piece) for line in black_loss: for piece in line: p1.blit( pygame.transform.scale(piece.image, (tile_size // 3, tile_size // 3)), ((line.index(piece) * 11 / 32 + 6 / 40) * tile_size, (black_loss.index(line) + 1) * 0.5 * tile_size)) for line in white_loss: for piece in line: p2.blit( pygame.transform.scale(piece.image, (tile_size // 3, tile_size // 3)), ((line.index(piece) * 11 / 32 + 6 / 40) * tile_size, (white_loss.index(line) + 1) * 0.5 * tile_size)) value_white = 0 value_black = 0 for piece in Pieces.taken_pieces: if piece.farbe == (0, 0, 0): value_black += piece.value elif piece.farbe == WHITE: value_white += piece.value label = font.render('+' + str(abs(int(value_white - value_black))), True, BLACK) if int(value_white - value_black) > 0: if len(white_loss[0]) < 8: p2.blit(label, ((len(white_loss[0]) * 11 / 32 + 6 / 40) * tile_size, 0.55 * tile_size)) else: p2.blit(label, ((len(white_loss[1]) * 11 / 32 + 6 / 40) * tile_size, 1.05 * tile_size)) elif int(value_white - value_black) < 0: if len(black_loss[0]) < 8: p1.blit(label, ((len(black_loss[0]) * 11 / 32 + 6 / 40) * tile_size, 0.55 * tile_size)) else: p1.blit(label, ((len(black_loss[1]) * 11 / 32 + 6 / 40) * tile_size, 1.05 * tile_size)) #updating the hud# if round_int % 2 == 0: pygame.draw.rect(hud, BLACK, [ 0.45 * tile_size, 0.2 * tile_size, 3.1 * tile_size, 1.6 * tile_size ]) elif round_int % 2 == 1: pygame.draw.rect(hud, BLACK, [ 4.45 * tile_size, 0.2 * tile_size, 3.1 * tile_size, 1.6 * tile_size ]) hud.blit(p1, (0.5 * tile_size, 0.25 * tile_size)) hud.blit(p2, (4.5 * tile_size, 0.25 * tile_size)) hud.blit(timer_label, (3.65 * tile_size, 0.75 * tile_size)) #creating the buttons on the hud resign_button.draw(screen=hud) quit_button.draw(screen=hud) takeback_button.draw(screen=hud) test_zone_button.draw(screen=hud) items = [quit_button, resign_button, takeback_button, test_zone_button] #bliting the subsurfaces on the mainsurface screen.blit(s, anchor_point_s) screen.blit(h, anchor_point_h) screen.blit(hud, anchor_point_hud) #bot moves# if round_int % 2 == 1 and bot_bool and not Board.game_over and not Board.test_mode: opt_move = bot.get_best_move_time(random.randint(400, 1200)) for piece in Pieces.all_pieces_list: if piece.farbe == BLACK: move = piece.move_from_pos( move=opt_move, board=board, screen=screen, takeback_button=takeback_button, ignore_me=Pieces.ignore_me_standard) if move != None: break #checking for events# else: for event in pygame.event.get(): for item in items: item.processEvent(event) #closing the screen by clicking the X# if event.type == pygame.QUIT: go = False #Keyboard-Inputs# if event.type == pygame.KEYDOWN: #kill window if ESC is pressed# if event.key == pygame.K_ESCAPE: Pieces.white_is_checked = False Pieces.black_is_checked = False Pieces.checking_piece = None json_file = open(r'components\constants.json', 'r') json_content = json.load(json_file) json_content["round_int"] = 0 json_file.close() json_file = open(r'components\constants.json', 'w') json_file.writelines(json.dumps(json_content)) json_file.close() quit() #(TEMP) my information key (arrow down) to get certain information# if event.key == pygame.K_DOWN: print(Pieces.give_FEN()) #print([x.name for x in Pieces.all_pieces_list]) # for king in Pieces.all_pieces_list: # if "King-W" in king.name: # print(list(king.is_castle_legal())) #left mouse click# elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: #getting the mouseposition and than correcting it by the relative position of the subsurface# mouse_pos = pygame.mouse.get_pos() mouse_pos = (mouse_pos[0] - anchor_point_s[0], mouse_pos[1] - anchor_point_s[1]) #checking if a Piece stands on the clicked tile# if not Board.game_over: for piece in Pieces.all_pieces_list: if mouse_pos[0] >= piece.x and mouse_pos[ 1] >= piece.y: if mouse_pos[ 0] < piece.x + tile_size and mouse_pos[ 1] < piece.y + tile_size: #if the clicked piece is one of the team that currently is to move...# with_bool = round_int % 2 == 0 and piece.farbe == ( 255, 255, 255) without_bool = round_int % 2 == 1 and piece.farbe == ( 0, 0, 0) if with_bool or without_bool: #...wait for the second mouse input# move_ = piece.move( board=board, screen=screen, takeback_button=takeback_button, ignore_me=Pieces.ignore_me_standard ) move_ = move_[1][2:3] + move_[2] + str( move_[0][2:]) #check if the white kiung is checked# Pieces.detectingCheck() #resetting class variables# Pieces.white_is_checked = False Pieces.black_is_checked = False Pieces.checking_piece = None #resetting the variables in the .json file# json_file = open(r'components\constants.json', 'r') json_content = json.load(json_file) json_content["round_int"] = 0 json_file.close() json_file = open(r'components\constants.json', 'w') json_file.writelines(json.dumps(json_content)) json_file.close()
from stockfish import Stockfish import config import chess import copy board = chess.Board() #Windows # stockfish = Stockfish('stockfish/stockfish_13_win_x64_bmi2.exe') #Linux stockfish = Stockfish('/home/pi/Downloads/Stockfish-sf_13/src/stockfish') stockfish.set_skill_level(25) # stockfish.set_position(["e2e4", "e7e6"]) # print(stockfish.get_board_visual()) # print(stockfish.is_move_correct('a2a5')) # print(stockfish.get_best_move_time(250)) # stockfish.set_position(["b2b3"]) # print(stockfish.get_board_visual()) # print(stockfish.get_fen_position()) def make_move(move): print('the move {} is a move'.format(move)) if stockfish.is_move_correct(move): config.moves.append(move) stockfish.set_position(config.moves) board = chess.Board(stockfish.get_fen_position()) config.confirm_move = copy.deepcopy(config.current_board) return 1 config.current_board = copy.deepcopy(config.confirm_move)
def main(): if tabuleiro.current_player == tabuleiro.bot_color: moviment = stockfish.get_best_move() captured_piece = tabuleiro.perform_chess_move( ChessPosition(moviment[0], int(moviment[1])), ChessPosition(moviment[2], int(moviment[3]))) stockfish.set_fen_position(tabuleiro.get_fen_notation()) gui.cpu_suggestions = Suggestion(tabuleiro) gui.thread = threading.Thread( target=gui.cpu_suggestions.calculate_suggestions, args=(gui, )) gui.thread.start() gui.draw_board() gui.draw_pieces() gui.parent.mainloop() UI.print_match(tabuleiro, stockfish) if __name__ == "__main__": print('Escolha a Cor:') print('[1] BRANCAS') print('[2] NEGRAS') player_color = int(input()) tabuleiro = ChessMatch.ChessMatch('BLACK' if player_color == 1 else 'WHITE') stockfish = Stockfish("./src/cpu/stockfish_20090216_x64") stockfish.set_skill_level(0) gui = GUI(tabuleiro, stockfish) main()
class Player(abc.ABC): """ An abstract class for player. """ QUIT_MOVE = 'a1a1' def __init__(self, first: bool, host: str, port: int, skill_level: Optional[int], depth: Optional[int], stockfish: Optional[str]): """ Initialize a player. Args: first: Is the player going first. host: The host of the game. port: The port in the host of the game. skill_level: Still level for stockfish. depth: Depth to search for best move for stockfish. stockfish: Path to the stockfish executable to use. """ self.player_turn = first self.host = host self.port = port self.skill_level = skill_level self.depth = depth self.moves = [] self.socket = None self.stockfish = Stockfish(stockfish or "./stockfish") if self.skill_level is not None: self.stockfish.set_skill_level(self.skill_level) if self.depth is not None: self.stockfish.set_depth(self.depth) def get_turns(self) -> List[str]: """ Get previous turns to the game from the other player, gets the board to the desired initial state. Returns: The pre turns set by the other player. """ moves_num = struct.unpack('H', self.socket.recv(2))[0] moves = [] for _ in range(moves_num): moves.append(self.socket.recv(5).decode('utf-8').rstrip('\0')) return moves def forward_turns(self, moves: Optional[List[str]] = None): """ Send previous turns to the game to the other player. Args: moves: The pre turns set by this player. """ if moves is None: moves = [] self.socket.send(struct.pack('H', len(moves))) for move in moves: self.socket.send(move.ljust(5, '\0').encode('utf-8')) def set_turns(self, moves: List[str]): """ Set the pre turns of the game. Args: moves: The pre turns of the game. """ self.moves = moves self.player_turn ^= len(moves) % 2 def choose_move(self): """ Choose a move to perform. Chooses the move using stockfish and sends it to the other player. """ self.stockfish.set_position(self.moves) move = self.stockfish.get_best_move() if not move: raise RuntimeError('game over') print('Move chosen:', move) self.socket.send(move.ljust(5, '\0').encode('utf-8')) self.moves.append(move) def get_move(self): """ Get the move done by the other player. """ move = self.socket.recv(5).decode('utf-8').rstrip('\0') if move == self.QUIT_MOVE: raise RuntimeError('game over') self.moves.append(move) print('Move got:', move) def turn(self): """ Perform a single turn, either get the move done by the other player, or do a move. """ if self.player_turn: self.choose_move() else: self.get_move() self.player_turn = not self.player_turn def print_board(self): """ Print the current board's state. """ self.stockfish.set_position(self.moves) print(self.stockfish.get_board_visual()) def __del__(self): """ Destruct a player. Disconnects the socket. """ self.socket and self.socket.close()
class Game: # handles game logic + interacts with stockfish def __init__(self): abs_path = os.path.dirname(__file__) # local path rel_path = 'stockfish-10-win/stockfish-10-win/stockfish_x86-64-modern.exe' self.sf = Stockfish(os.path.join( abs_path, rel_path)) # pull the engine from compiled file self.m_skill_level = 0 # skill level of engine self.m_cur_turn = 0 # 0 for player turn, 1 for computer turn self.m_in_game = False # see if we're still in game self.m_move_his = [] # move history to update position in stockfish self.num_moves = 0 # number of moves (extraneous, may remove) self.set_skill_level( self.request_skill_level()) # request a skill level for engine self.choose_side(self.request_side()) # request a starting side self.m_starting_side = 0 self.m_board = Board(self.m_cur_turn) def set_skill_level(self, d_level): # function to set a skill level self.sf.set_skill_level(d_level) self.m_skill_level = d_level def choose_side(self, d_side): # function to set a starting side self.m_cur_turn = d_side self.m_starting_side = d_side def check_for_mate( self, val ): # function periodically checks if there is a checkmate and ends game if true # we can check for checkmate by looking at what stockfish thinks is the best move # if stockfish says only 1 move is the best move, we're in check # if no move is the best move, we're in checkmate. moves = self.sf.get_best_move() mate = 0 print(moves) if moves == None: mate = 1 return mate def check_for_castle(self, start, end): r_a = 0 r_b = 0 if start == 60: # black side print('black king \n') if (start - end) == -2: # castled 'h' rook r_a = 63 r_b = 61 else: # castled 'a' rook r_a = 56 r_b = 59 elif start == 4: # white side if (start - end) == -2: # h rook r_a = 7 r_b = 5 else: r_a = 0 r_b = 3 self.m_board.change_pos(r_a, r_b) return 1 def updateBoard(self, move): # first two characters of move are start, last two are end start_pos = move[:2] ind_pos_s = (ord(start_pos[0]) - 97) + ((int(start_pos[1]) - 1) * 8) end_pos = move[2:4] ind_pos_e = (ord(end_pos[0]) - 97) + ((int(end_pos[1]) - 1) * 8) # check for special moves occuring # check if a king in its original position has moved. print('Index: ' + str(ind_pos_s) + '\n' + 'Type: ' + str(self.m_board.get_piece_at(ind_pos_s)) + '\n\n\n\n') if (self.m_board.get_piece_at(ind_pos_s) == 1): print('castling!') self.check_for_castle(ind_pos_s, ind_pos_e) self.m_board.change_pos(ind_pos_s, ind_pos_e) return 1 def endGame(self, ): # if mate is triggered, loser will be whoever's current turn it is win = 0 w_side = 0 if self.m_cur_turn == 0: # white lost w_side = 1 if self.m_cur_turn != self.m_starting_side: win = 1 else: # black lost if self.m_cur_turn != self.m_starting_side: win = 1 if win: print('you won!') else: print('you lost!') return 1 def request_side(self, ): # prompts user for choosing a starting side side_set = False side = "white" count = 0 c_side = 0 while not side_set and count < 5: count = count + 1 side = input('Which side? (type in white, black or random): ') if side == 'white' or side == 'black' or side == 'random': if side == 'black': # if black, computer goes first c_side = 1 elif side == 'white': # if white, player goes first c_side = 0 else: if (random.randint(0, 999) / 100) > 5: c_side = 1 else: c_side = 0 side_set = True elif count == 5: print("Setting to default side of white.") c_side = 0 side_set = True else: print("Invalid input" + "\n") return c_side def request_skill_level( self, ): # prompts user for inputting a skill level for engine level_set = False count = 0 while not level_set and count < 5: count = count + 1 skill = input( 'What skill level? (integers between 1 and 21 inclusive): ') if skill.isdigit() and int(skill) > 0 and int(skill) < 22: level_set = True elif count == 5: print("Setting to default of skill level 5.") skill = 5 else: print("Invalid input" + "\n") return skill def run(self, ): print('Game is now starting.') in_game = True # start game self.m_board.print_board_state() while in_game: # check if currently in checkmate (to end game) mate = self.check_for_mate() if mate: # game is now over break turn = "your" if self.m_cur_turn == 0 else "the computer's" print("It is now " + turn + " turn." + "\n") if self.m_cur_turn == 0: move_done = 0 while not move_done: move = input('Enter your move: ' + '\n').strip() # first check if valid move format (letter + number + letter + number) valid = re.search(rule, move) if valid and self.sf.is_move_correct(move): # valid move syntax and able to be made self.m_move_his.append(move) self.sf.set_position(self.m_move_his) print("You entered the move: " + move + '\n') move_done = 1 else: print("Invalid move, please enter a different move." + '\n') self.m_cur_turn = 1 else: # computer's turn move = self.sf.get_best_move() print("The computer moves: " + move + '\n') self.m_move_his.append(move) self.sf.set_position(self.m_move_his) self.m_cur_turn = 0 self.num_moves = self.num_moves + 1 self.updateBoard(move) self.m_board.print_board_state() self.endGame()
class Menu: bot_color = None def __init__(self): self.parent = tk.Tk() self.parent.title("Tutor Chess") self.parent.iconphoto( False, tk.PhotoImage(file='src/application/images/icon.png')) self.tabuleiro = None self.stockfish = None self.game_gui = None # Imagem de fundo width_size = 8 * 64 height_size = 8 * 64 self.principal = tk.Canvas(self.parent, width=width_size, height=height_size) background_image = ImageTk.PhotoImage( Image.open("src/application/images/background_image.jpg").resize( (725, 515))) label = tk.Label(self.parent, image=background_image) label.image = background_image label.place(x=0, y=0, relwidth=1, relheight=1) self.principal.pack() # Imagem da logo img = Image.open("src/application/images/logoProjeto.png").resize( (400, 100)).convert("RGBA") logo_image = ImageTk.PhotoImage(img) label_logo = tk.Label(self.parent, image=logo_image) label_logo.image = logo_image label_logo.place(relx=0.5, rely=0.25, anchor=tk.CENTER) # Botões # PLayer vs Player self.novo_jogo_player = tk.Button(self.parent, text="Player vs Player", height=2, width=50, command=self.new_game) self.novo_jogo_player.place(relx=0.5, rely=0.5, anchor=tk.CENTER) # PLayer vs Bot self.novo_jogo_bot = tk.Button(self.parent, text="Player vs Bot", height=2, width=50, command=self.set_color) self.novo_jogo_bot.place(relx=0.5, rely=0.6, anchor=tk.CENTER) # Tutorial self.tutorial = tk.Button(self.parent, text="Tutorial", height=2, width=50, command=self.tutorial_text) self.tutorial.place(relx=0.5, rely=0.7, anchor=tk.CENTER) # Sair self.finalizar = tk.Button(self.parent, text="Finalizar", height=2, width=50, command=exit) self.finalizar.place(relx=0.5, rely=0.8, anchor=tk.CENTER) # Posicionamento da Tela Principal self.parent.update_idletasks() positionRight = int( (self.parent.winfo_screenwidth() - self.parent.winfo_reqwidth()) / 2) positionDown = int( (self.parent.winfo_screenheight() - self.parent.winfo_reqheight()) / 2) self.parent.geometry("+{}+{}".format(positionRight, positionDown)) self.parent.resizable(0, 0) # Descrever um tutorial sobre a aplicação def tutorial_text(self): tk.messagebox.showinfo("Tutorial", "Tutorial sobre o Jogo") def __initial_game(self): # self.parent.withdraw() self.parent.destroy() self.tabuleiro = ChessMatch.ChessMatch(self.bot_color) self.stockfish = Stockfish("./src/cpu/stockfish_20090216_x64") self.stockfish.set_skill_level(0) self.game_gui = Game(self.tabuleiro, self.stockfish) def new_game(self): self.__initial_game() if self.tabuleiro.current_player == self.bot_color: moviment = self.stockfish.get_best_move() self.tabuleiro.perform_chess_move( ChessPosition(moviment[0], int(moviment[1])), ChessPosition(moviment[2], int(moviment[3]))) self.stockfish.set_fen_position(self.tabuleiro.get_fen_notation()) self.game_gui.cpu_suggestions = Suggestion(self.tabuleiro) self.game_gui.thread = threading.Thread( target=self.game_gui.cpu_suggestions.calculate_suggestions, args=(self.game_gui, )) self.game_gui.thread.start() self.game_gui.lateral_suggestions.insert(1, "Calculando Sugestões...") self.game_gui.draw_board() self.game_gui.draw_pieces() self.game_gui.parent.mainloop() # self.parent.deiconify() def set_color(self): self.win = tk.Toplevel(bg="#FFFFFF") self.win.wm_title("Escolha a Cor") positionRight = int(self.win.winfo_screenwidth() / 2 - 266 / 2) positionDown = int(self.win.winfo_screenheight() / 2 - 100 / 2) self.win.geometry("+{}+{}".format(positionRight, positionDown)) self.win.grab_set() text = tk.Text(self.win, width=30, height=1, relief=tk.FLAT) text.insert(tk.INSERT, "Escolha a cor do seu jogador.") text.configure(state=tk.DISABLED) text.pack(padx=8, pady=8, side=tk.TOP) # Cor Branca white_color = tk.Button(self.win, text="Brancas", height=2, width=15, command=self.__set_bot_black) white_color.pack(padx=8, pady=8, side=tk.LEFT) # Cor Negra black_color = tk.Button(self.win, text="Negras", height=2, width=15, command=self.__set_bot_white) black_color.pack(padx=8, pady=8, side=tk.RIGHT) def __set_bot_black(self): self.bot_color = 'BLACK' self.win.destroy() self.new_game() def __set_bot_white(self): self.bot_color = 'WHITE' self.win.destroy() self.new_game()