def test_move(PosY, PosX, DestPosY, DestPosX): game_state = ChessEngine.GameState() move = ChessEngine.Move([PosY, PosX], [DestPosX, DestPosY], game_state.board) game_state.make_move(move) piece = game_state.board[DestPosX][DestPosY] return piece
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) screen.fill(p.Color("white")) gs = ChessEngine.GameState() loadImages() running = True selectedSq = () playerClicks = [] validMoves = [] while running: for e in p.event.get(): if e.type == p.QUIT: running = False if e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() col = location[0]//SQ_SIZE row = location[1]//SQ_SIZE selectedSq = (row, col) playerClicks.append((row, col)) if len(playerClicks) == 1: if gs.board[row][col][0] == ("w" if gs.whiteToMove else "b"): #Valid selection validMoves = gs.generateValidMoves(row, col) else: playerClicks = [] elif len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0][0], playerClicks[0][1], row, col) if gs.checkValidMove(move, validMoves): gs.makeMove(move) playerClicks = [] drawGameState(screen, gs, selectedSq, validMoves) p.display.flip()
def main(): p.init() screen=p.display.set_mode((Width,Height)) clock = p.time.Clock() screen.fill(p.Color("white")) gs=ChessEngine.GameState() print(gs.board)
def main(): pygame.init() screen = pygame.display.set_mode((WIDTH, HEIGHT)) clock = pygame.time.Clock() screen.fill(pygame.Color("white")) game_state = ChessEngine.GameState() # GAME_STATE validMoves = game_state.getValidMoves() moveMade = False # flag variable for when a move is made load_images() running = True sqSelected = () # Square clicked by user tuple(row, col) playerClicks = [] # Where user clicked after list[(row, col), (row2,col2)] while running: for e in pygame.event.get(): if e.type == pygame.QUIT: running = False # mouse handler elif e.type == pygame.MOUSEBUTTONDOWN: location = pygame.mouse.get_pos() # (x,y) location of mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == ( row, col): # The user clicked the same square twice sqSelected = () # unselect playerClicks = [] # clear clicks else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: # after 2nd click move = ChessEngine.Move(playerClicks[0], playerClicks[1], game_state.board) print(move.get_chess_notation()) for i in range(len(validMoves)): if move == validMoves[i]: game_state.make_move(validMoves[i]) moveMade = True sqSelected = () # Reset clicks playerClicks = [] # Reset clicks if not moveMade: playerClicks = [sqSelected] # key handler elif e.type == pygame.KEYDOWN: if e.key == pygame.K_z: # "z" pressed game_state.undo_move() moveMade = True # Create new valid moves after move if moveMade: validMoves = game_state.getValidMoves() moveMade = False drawGameState(screen, game_state) clock.tick(15) pygame.display.flip()
def test_move(PosY, PosX, DestPosY, DestPosX, figure): game_state = ChessEngine.GameState() game_state.clearBoard() game_state.set_figure_in_position(PosY, PosX, figure) move = ChessEngine.Move([PosY, PosX], [DestPosX, DestPosY], game_state.board) game_state.make_move(move) piece = game_state.board[DestPosX][DestPosY] return piece
def main(): # initialise pygame p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False #flag to check the move made loadImages() running = True sqSelected = () #keeps track of last click of the user, Tuple playerClicks = [] #keeps a track of player clicks, Two tuples. ( while running: for e in p.event.get(): if e.type == p.QUIT: running = False #Mouse Listener elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() # x,y cords of mouse click col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == (row, col): sqSelected = () # deselect playerClicks = [] # clear player clicks else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(move) moveMade = True sqSelected = () # reset clicks playerClicks = [] if not moveMade: playerClicks = [sqSelected] # Keyboard Listener elif e.type == p.KEYDOWN: if e.key == p.K_z: #Undo when z is pressed gs.UndoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False #flag variable for when a move is made load_images() running = True sqSelected = () #keeps track of the last click of the user playerClicks = [] #keeps track of player clicks while (running): for e in p.event.get(): if e.type == p.QUIT: running = False #clicking elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() #x and y location of mousezx col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == (row, col): #clicking the same square cancels sqSelected = () playerClicks = [] else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) for i in range(len(validMoves)): if move == validMoves[i]: print(validMoves[i].getChessNotation()) gs.makeMove(validMoves[i]) moveMade = True sqSelected = () #reset user click playerClicks = [] if not moveMade: print('Invalid Move') sqSelected = () playerClicks = [] #key press elif e.type == p.KEYDOWN: if e.key == p.K_z: gs.undoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False draw_gamestate(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("White")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False loadImages() running = True sqSelected = () playerClicks = [] while running: for e in p.event.get(): if e.type == p.QUIT: running = False #souris elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() #(x,y) position de la souris col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == ( row, col ): #l'utilisateur clique sur le même carré deux fois sqSelected = () #déselectionne la case playerClicks = [] #efface/enlève le click du joueur else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: #après le deuxième click move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(validMoves[i]) moveMade = True sqSelected = () #reset le click playerClicks = [] if not moveMade: playerClicks = [sqSelected] #clavier elif e.type == p.KEYDOWN: if e.key == p.K_z: #annule le coup quand w(w = z en qwerty) est pressé gs.undoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False loadImages() running = True sqSelected = () #no square is selected playerClicks = [] #keep trac k of player place while running: for e in p.event.get(): if e.type == p.QUIT: running = False elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == (row, col): # clicks same square twice sqSelected = () playerClicks = [] else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(validMoves[i]) moveMade = True sqSelected = () playerClicks = [] if not moveMade: playerClicks = [sqSelected] elif e.type == p.KEYDOWN: if e.key == p.K_z: gs.undoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False #flag variable for when a move is made loadImages() #Load once, move images around running = True sqSelected = ( ) #Intial selection is empty, tracks last click of user (row, col) playerClicks = [] #list with 2 tuples: [(6, 5), (4, 4)] pawn move tracked while running: for e in p.event.get(): if e.type == p.QUIT: #exit strategy running = FALSE #MouseFunctions elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() #Where is the mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == ( row, col ): #this clears the selection after a 2nd click on a square sqSelected = () Playerclicks = [] else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks ) == 2: #Make a move on the second unique click move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) if move in validMoves: gs.makeMove(move) moveMade = True sqSelected = () #reset the click count playerClicks = [] #Key functions elif e.type == p.KEYDOWN: if e.key == p.K_z: #undo when keyboard z is pressed gs.undoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() movemade = False drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False #flag varible for when a move is made loadImages() running = True sqSelected = () #nosquare is selected at first. Keeps track of the last click of the user playerClicks = [] #keeps track of player's clicks while running: for e in p.event.get(): if e.type == p.QUIT: running = False #mouse handler elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() col = location[0]//SQ_SIZE row = location[1]//SQ_SIZE if sqSelected == (row, col): #if the user clicks the smae square twice sqSelected = () playerClicks =[] else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2 : move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(playerClicks) print(move.getChessNotation()) if move in validMoves: gs.makeMove(move) moveMade = True sqSelected = () #reset clicks playerClicks = [] #key handler elif e.type == p.KEYDOWN: if e.key == p.K_z: #undo when 'z' is pressed gs.undoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color('white')) gs = ChessEngine.GameState() valid_moves = gs.get_valid_moves() move_made = False # flag variable for when a move is made load_images() # only do this once, before the while loop running = True sq_selected: Tuple = () # no square is selected, keep track of the last click of the user (tuple: (row, col)) player_clicks = [] # keep track of player clicks (two tuples: [(6, 4), (4, 4)]) while running: for e in p.event.get(): if e.type == p.QUIT: running = False # mouse handler elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() # (x,y) location of mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sq_selected == (row, col): # the user clicked the same square twice sq_selected = () # unselect player_clicks = [] # clear player clicks else: sq_selected = (row, col) player_clicks.append(sq_selected) # append for both 1st and 2nd clicks if len(player_clicks) == 2: # after 2nd click move = ChessEngine.Move(player_clicks[0], player_clicks[1], gs.board) print(move.get_chess_notation()) if move in valid_moves: gs.make_move(move) move_made = True sq_selected = () # reset user clicks player_clicks = [] # key handlers elif e.type == p.KEYDOWN: if e.key == p.K_z: # undo when 'z' is pressed gs.undo_move() move_made = True if move_made: valid_moves = gs.get_valid_moves() move_made = False draw_game_state(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): ''' Main ''' screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() load_images() running = True while running: for e in p.event.get(): if e.type == p.QUIT: running = False draw_game_state(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() loadImages() running = True sqSelected = () # no square is selected initially - one tuple:(row,col) playerClicks = [ ] # keep tracks of the player clicks - two tuples: [(6,4),(4,4)] while running: for e in p.event.get(): if e.type == p.QUIT: running = False p.quit() elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos( ) # (x, y) coordinates for the mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE #check if the user already selected this square, as it wqould be an undo if sqSelected == (row, col): sqSelected = () #Unselect the square playerClicks = [] #reset the clicks else: sqSelected = (row, col) playerClicks.append( sqSelected ) # we append both the first and second clicks #was this the user's second click? if len(playerClicks) == 2: #after the second click move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) gs.makeMove(move) sqSelected = () # reset the user clicks playerClicks = [] drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): """ The main driver for our code. This will handle user input and updating the graphics. """ p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color('white')) gs = ChessEngine.GameState() load_images() # only do this once, before the while loop running = True while running: for e in p.event.get(): if e.type == p.QUIT: running = False draw_game_state(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color('white')) gs = ChessEngine.GameState() loadImages() running = True sqSelected = () # no square selected, keep track of last click of the user tuples: (row, col) playerClicks = [] # keep track of player clicks, [(6,4), (4,4)] while running: for e in p.event.get(): if e.type == p.QUIT: running = False elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() # (x,y) position of mouse col = location[0]//SQ_SIZE row = location[1]//SQ_SIZE if sqSelected == (row, col): sqSelected = () # deselect playerClicks = [] # clear the clicks else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: # after second click move the pawn move = ChessEngine.Move( playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) gs.makeMove(move=move) sqSelected = () playerClicks = [] drawGameState(screen, gs) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMove() moveMade = False ChessEngine.print_text_board(gs.board) loadImages() running = True sqSelected = () # box clicked by the user (row,col) playerClicks = [] # all clicks by user [(row,col),(row,col)] gameOver = False p.display.set_caption(turnText(gs.whiteToMove)) flag = 1 choice = 1 while running: if flag: flag = 0 choice = OptionWindow(screen, gs) if choice == 0: break for event in p.event.get(): if not gs.whiteToMove and choice == 2: move = aimove(gs, 3) gs.makeMove(move) moveMade = True p.display.set_caption(turnText(gs.whiteToMove)) print(len(gs.moveLog)) if event.type == p.QUIT: running = False # mouse handel # mouse press elif event.type == p.MOUSEBUTTONDOWN and (gs.whiteToMove or choice == 1): if gameOver == True: break location = p.mouse.get_pos() col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == (row, col): sqSelected = () playerClicks = [] else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: # two box selected move the piece move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) print(playerClicks) for i in range(len(validMoves)): if move == validMoves[i]: print("moved here:", move.endRow, move.endCol) if validMoves[i].isPawnPromotion: print("Promote to:") new_piece = input().upper() validMoves[ i].promotionChoice = new_piece if new_piece in ( "Q", "R", "N", "B") else "Q" gs.makeMove(validMoves[i]) moveMade = True p.display.set_caption(turnText(gs.whiteToMove)) sqSelected = () playerClicks = [] break if not moveMade: playerClicks = [sqSelected] elif event.type == p.KEYDOWN: if event.key == p.K_z: # z to undo move print(gs.moveLog) gs.undoMove() if not gs.whiteToMove and choice == 2: gs.undoMove() moveMade = True p.display.set_caption(turnText(gs.whiteToMove)) if event.key == p.K_c: # c to clear variables sqSelected = () playerClicks = [] if event.key == p.K_f: # f to print valid moves for i in validMoves: print(i.startRow, i.startCol, i.endRow, i.endCol) if event.key == p.K_r: gs = ChessEngine.GameState() validMoves = gs.getValidMove() playerClicks = [] sqSelected = () moveMade = False p.display.set_caption(turnText(gs.whiteToMove)) if moveMade: validMoves = gs.getValidMove() moveMade = False p.display.set_caption(turnText(gs.whiteToMove)) drawGameState(screen, gs, validMoves, sqSelected) if gs.checkMate: gameOver = True if gs.whiteToMove: drawText(screen, "Black WON by checkmate") else: drawText(screen, "White WON by checkmate") clock.tick(MAX_FPS) p.display.flip()
def main(): """ Main driver. Handles user input and updating the board """ p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() valid_moves = gs.get_valid_moves() move_made = False # Flag variable for when a move is made animate = False # Flag variable for when to animate load_images() running = True square_selected = () # no square selected initially, keeps track of the last user click player_clicks = [] # keeps track of player clicks [(1,2),(2,2)] game_over = False while running: for e in p.event.get(): if e.type == p.QUIT: running = False # mouse handlers elif e.type == p.MOUSEBUTTONDOWN: if not game_over: location = p.mouse.get_pos() # (x,y) location of mouse column = location[0]//SQ_SIZE row = location[1]//SQ_SIZE if square_selected == (row, column): # checking if user clicks the same square twice square_selected = () # deselects player_clicks = [] # clear player clicks else: square_selected = (row, column) player_clicks.append(square_selected) if len(player_clicks) == 2: move = ChessEngine.Move(player_clicks[0], player_clicks[1], gs.board) for i in range(len(valid_moves)): if move == valid_moves[i]: gs.make_move(valid_moves[i]) print(move.get_chess_notation()) move_made = True animate = True # reset user clicks square_selected = () player_clicks = [] if not move_made: player_clicks = [square_selected] # key handlers elif e.type == p.KEYDOWN: if e.key == p.K_z: gs.undo_move() move_made = True animate = False game_over = False if e.key == p.K_r: gs = ChessEngine.GameState() valid_moves = gs.get_valid_moves() square_selected = () player_clicks = [] move_made = False animate = False game_over = False if move_made: if animate: animate_move(gs.move_log[-1], screen, gs.board, clock) valid_moves = gs.get_valid_moves() move_made = False animate = False draw_game_state(screen, gs, valid_moves, square_selected) if gs.checkmate: game_over = True if gs.white_to_move: draw_text(screen, "Black wins by checkmate") else: draw_text(screen, "White wins by checkmate") elif gs.stalemate: game_over = True draw_text(screen, "Stalemate") clock.tick(MAX_FPS) p.display.flip()
def main(): """ The main driver for our code. This will handle user input and updating the graphics. """ p.init() screen = p.display.set_mode( (BOARD_WIDTH + MOVE_LOG_PANEL_WIDTH, BOARD_HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) game_state = ChessEngine.GameState() valid_moves = game_state.getValidMoves() move_made = False # flag variable for when a move is made animate = False # flag variable for when we should animate a move loadImages() # do this only once before while loop running = True square_selected = ( ) # no square is selected initially, this will keep track of the last click of the user (tuple(row,col)) player_clicks = [] # this will keep track of player clicks (two tuples) game_over = False ai_thinking = False move_undone = False move_finder_process = None move_log_font = p.font.SysFont("Arial", 14, False, False) player_one = True # if a human is playing white, then this will be True, else False player_two = False # if a hyman is playing white, then this will be True, else False while running: human_turn = (game_state.white_to_move and player_one) or (not game_state.white_to_move and player_two) for e in p.event.get(): if e.type == p.QUIT: p.quit() sys.exit() # mouse handler elif e.type == p.MOUSEBUTTONDOWN: if not game_over: location = p.mouse.get_pos( ) # (x, y) location of the mouse col = location[0] // SQUARE_SIZE row = location[1] // SQUARE_SIZE if square_selected == ( row, col ) or col >= 8: # user clicked the same square twice square_selected = () # deselect player_clicks = [] # clear clicks else: square_selected = (row, col) player_clicks.append( square_selected ) # append for both 1st and 2nd click if len(player_clicks ) == 2 and human_turn: # after 2nd click move = ChessEngine.Move(player_clicks[0], player_clicks[1], game_state.board) for i in range(len(valid_moves)): if move == valid_moves[i]: game_state.makeMove(valid_moves[i]) move_made = True animate = True square_selected = () # reset user clicks player_clicks = [] if not move_made: player_clicks = [square_selected] # key handler elif e.type == p.KEYDOWN: if e.key == p.K_z: # undo when 'z' is pressed game_state.undoMove() move_made = True animate = False game_over = False if ai_thinking: move_finder_process.terminate() ai_thinking = False move_undone = True if e.key == p.K_r: # reset the game when 'r' is pressed game_state = ChessEngine.GameState() valid_moves = game_state.getValidMoves() square_selected = () player_clicks = [] move_made = False animate = False game_over = False if ai_thinking: move_finder_process.terminate() ai_thinking = False move_undone = True # AI move finder if not game_over and not human_turn and not move_undone: if not ai_thinking: ai_thinking = True return_queue = Queue() # used to pass data between threads move_finder_process = Process(target=ChessAI.findBestMove, args=(game_state, valid_moves, return_queue)) move_finder_process.start() if not move_finder_process.is_alive(): ai_move = return_queue.get() if ai_move is None: ai_move = ChessAI.findRandomMove(valid_moves) game_state.makeMove(ai_move) move_made = True animate = True ai_thinking = False if move_made: if animate: animateMove(game_state.move_log[-1], screen, game_state.board, clock) valid_moves = game_state.getValidMoves() move_made = False animate = False move_undone = False drawGameState(screen, game_state, valid_moves, square_selected) if not game_over: drawMoveLog(screen, game_state, move_log_font) if game_state.checkmate: game_over = True if game_state.white_to_move: drawEndGameText(screen, "Black wins by checkmate") else: drawEndGameText(screen, "White wins by checkmate") elif game_state.stalemate: game_over = True drawEndGameText(screen, "Stalemate") clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((BOARD_WIDTH+MOVE_LOG_PANEL_WIDTH, BOARD_HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) currState = ChessEngine.GameState() validMoves = currState.get_all_valid_moves() moveLogFont = p.font.SysFont("Times New Roman", 15, False, False) moveMade = False animate = False gameOver = False load_images() running = True squareSelected = () playerClicks = [] humanIsWhite = True # If a human is playing white, this flag will be true, else False humanIsBlack = True # If a human is playing black, this flag will be true, else False while running: humanTurn = (currState.whiteToMove and humanIsWhite) or (not currState.whiteToMove and humanIsBlack) for e in p.event.get(): if e.type == p.QUIT: running = False # handle mouse clicks elif e.type == p.MOUSEBUTTONDOWN: if not gameOver and humanTurn: location = p.mouse.get_pos() col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if squareSelected == (row, col) or col >= 8: # user clicked the same square or user clicked side panel => UNDO squareSelected = () playerClicks = [] else: squareSelected = (row, col) playerClicks.append(squareSelected) if len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0], playerClicks[1], currState.board) for i in range(len(validMoves)): if move == validMoves[i]: moveMade = True animate = True currState.make_move(validMoves[i]) # reset squareSelected = () playerClicks = [] if not moveMade: # set the first square as the last selected square playerClicks = [squareSelected] # handle key presses elif e.type == p.KEYDOWN: if e.key == p.K_z: # if 'z' is pressed, undo move currState.undo_move() moveMade = True animate = False gameOver = False if e.key == p.K_r: # if 'r' is pressed, reset board currState = ChessEngine.GameState() validMoves = currState.get_all_valid_moves() squareSelected = () playerClicks = [] moveMade = False animate = False gameOver = False if not gameOver and not humanTurn: AIMove = ChessAI.find_best_move_nega_max_alpha_beta(currState, validMoves) if AIMove is None: AIMove = ChessAI.find_random_move(validMoves) currState.make_move(AIMove) moveMade = True animate = True if moveMade: if animate: animate_move(currState.moveLog[-1], screen, currState.board, clock) validMoves = currState.get_all_valid_moves() moveMade = False draw_game_state(screen, currState, validMoves, squareSelected, moveLogFont) if currState.checkmate or currState.stalemate or currState.repetition or currState.fiftyMovesDone: gameOver = True text = "Draw by stalemate!" if currState.stalemate else "Draw by repetition!" if currState.repetition else "Draw by 50-move rule!" if currState.fiftyMovesDone\ else "0-1 : Black wins by checkmate!" if currState.whiteToMove else "1-0 : White wins by checkmate!" draw_game_end_text(screen, text) p.display.flip() clock.tick(MAX_FPS)
import ChessEngine game = ChessEngine.GameState() moves = [] game.KnightMove(4,4,4,moves) board = [ ["bR", "bN", "bB", "bQ", "bK", "bB", "bN", "bR"], ["bP", "bP", "bP", "bP", "bP", "bP", "bP", "bP"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["wP", "wP", "wP", "wP", "wP", "wP", "wP", "wP"], ["wR", "wN", "wB", "wK", "wQ", "wB", "wN", "wR"] ] board16 = [ ["bR", "bR", "bN", "bN", "bB", "bB", "bQ", "bQ", "bK", "bQ", "bB", "bB", "bN", "bN", "bR", "bR"], ["bP", "bP", "bP", "bP", "bP", "bP", "bP", "bP", "bP", "bP", "bP", "bV", "bV", "bP", "bP", "bP"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"],
def main(): p.init() screen = p.display.set_mode((width,height)) clock = p.time.Clock() screen.fill(p.Color("White")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False loadImages() running = True sqSelected = () playerClicks = [] while running: for e in p.event.get(): if e.type == p.QUIT: running = False elif e.type == p.MOUSEBUTTONDOWN and gs.whiteToMove: location = p.mouse.get_pos() col = location[0]//sqsize row = location[1]//sqsize if sqSelected == (row,col): sqSelected = () playerClicks = [] else: sqSelected = (row,col) playerClicks.append(sqSelected) if len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0],playerClicks[1], gs.board) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(validMoves[i]) moveMade = True sqSelected = () playerClicks = [] if not moveMade: playerClicks = [sqSelected] elif e.type == p.KEYDOWN: if e.key == p.K_z: gs.undoMove() sqSelected = () playerClicks = [] moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False drawGameState(screen, gs) clock.tick(maxfps) p.display.flip() if gs.checkMate and not gs.AIturn: print("Black wins by checkmate") if gs.whiteToMove else print("White wins by checkmate") running = False if gs.stalemate and not gs.AIturn: print("Draw by stalemate") running = False if not gs.whiteToMove and len(validMoves) != 0 and not moveMade: x = gs.getBestMove(2, False) gs.makeMove(x) moveMade = True
def main(): """ Main function that handles user input and graphics """ # PyGame initialization pg.init() clock = pg.time.Clock() screen = pg.display.set_icon(IMAGES['logo']) # add icon to the pg window screen = pg.display.set_caption(' Chess') # add title to the pg window screen = pg.display.set_mode((BOARD_WIDTH + MOVE_LOG_PANEL_WIDTH, BOARD_HEIGHT)) # set size of the pg window screen.fill(pg.Color("black")) # add background color to the pg window move_log_font = pg.font.SysFont("Arial", 13, True, False) # GameEngine initialization game_state = ChessEngine.GameState() running = True sq_selected = () # store last click of the user player_click = [] # store clicks up to two clicks move_finder_process = None # allow multi processing valid_moves = game_state.get_all_valid_moves() move_made = False # flag variable for when a move is made animate = False # flag variable for when a move needs to be animated game_over = False # flag variable for when game is over ai_thinking = False # flag variable for when the AI is finding best move move_undone = False # flag variable for when the move is undone # if a human is playing white, then this will be True, else False player_one = False # if a human is playing black, then this will be True, else False player_two = False # infinite loop while running: human_turn = (game_state.white_to_move and player_one) or ( not game_state.white_to_move and player_two ) # check if the human is controlling the turn for e in pg.event.get(): # for each event in event queue if e.type == pg.QUIT: # trigger for ending infinite loop pg.quit() sys.exit() elif not game_over and e.type == pg.MOUSEBUTTONDOWN: if not game_over and human_turn: location = pg.mouse.get_pos( ) # (x, y) location fot the mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE # storing player clicks if sq_selected == ( row, col ) or col >= 8: # in case the click is same as previous click, reset player clicks sq_selected = () player_click.clear() else: # else update the new click position sq_selected = (row, col) player_click.append(sq_selected) if len(player_click ) == 2: # when 2 unique clicks have been identified move = ChessEngine.Move(player_click[0], player_click[1], game_state.board) for i in range(len(valid_moves)): if move == valid_moves[i]: game_state.make_move(valid_moves[i]) move_made = True animate = True # reset input sq_selected = () player_click.clear() break else: player_click = [sq_selected] elif e.type == pg.KEYDOWN and e.key == pg.K_z: # trigger for undoing a move game_state.undo_move() move_made = True animate = False game_over = False if ai_thinking: move_finder_process.terminate() ai_thinking = False move_undone = True elif e.type == pg.KEYDOWN and e.key == pg.K_r: # trigger for resetting the board game_state = ChessEngine.GameState() valid_moves = game_state.get_all_valid_moves() sq_selected = () player_click.clear() move_made = False animate = False game_over = False if ai_thinking: move_finder_process.terminate() ai_thinking = False move_undone = True # AI move finder if not game_over and not human_turn and not move_undone: if not ai_thinking: ai_thinking = True return_queue = Queue() # store and pass data between threads move_finder_process = Process(target=ChessAI.find_best_move, args=(game_state, valid_moves, return_queue)) move_finder_process.start() if not move_finder_process.is_alive(): ai_move = return_queue.get() if ai_move is None: ai_move = ChessAI.findRandomMove(valid_moves) game_state.make_move(ai_move) move_made = True animate = True ai_thinking = False if move_made: if animate: animate_move(game_state.move_log[-1], screen, game_state.board, clock) # animate the move made by the user valid_moves = game_state.get_all_valid_moves() move_made = False animate = False move_undone = False if not game_over: draw_GameState(screen, game_state, valid_moves, sq_selected, move_log_font) if game_state.check_mate or game_state.stale_mate: game_over = True win_txt = 'Stalemate' if game_state.stale_mate else 'Black wins by checkmate.' if game_state.white_to_move else 'White wins by checkmate.' draw_end_game_text(screen, win_txt) clock.tick(MAX_FPS) pg.display.flip()
def main(): p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() p.display.set_caption('Chess') # Game state gs = ChessEngine.GameState() minmaxPruning = ChessEngine.MinMaxPruning() validMoves = gs.getValidMoves() moveMade = False loadImages() # loadImage() running = True sqSelected = () # tuple (row, col) playerClicks = [] while running: if gs.whiteToMove: for e in p.event.get(): if e.type == p.QUIT: running = False # mouse handler elif e.type == p.MOUSEBUTTONDOWN: location = p.mouse.get_pos() # (x, y) location of mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == (row, col): # player clicked the same square sqSelected = () # deselect playerClicks = [] # clear player click else: sqSelected = (row, col) playerClicks.append( sqSelected) # apend fot 1st and 2nd click if len(playerClicks) == 2: # after player's 2nd click move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) if move in validMoves: gs.makeMove(move) moveMade = True sqSelected = () # reset player clicks playerClicks = [] else: playerClicks = [sqSelected] # key handler elif e.type == p.KEYDOWN: if e.key == p.K_z: gs.undoMove() moveMade = True if moveMade: validMoves = gs.getValidMoves() moveMade = False else: # print(minmaxPruning.minmaxRoot(2, gs)) bestMove = minmaxPruning.minmaxRoot(3, gs) gs.makeMove(bestMove) print("best move: ", bestMove.getChessNotation()) moveMade = True sqSelected = () # reset player clicks playerClicks = [] print("luot cua trang: ", gs.whiteToMove) # drawGameState(screen, gs) drawGameState(screen, gs, validMoves, sqSelected) clock.tick(MAX_FPS) p.display.flip()
def main(): screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("pink")) #GameState object will keep track of the game and determine valid moves gs = ChessEngine.GameState() #Generate valid moves for pieces. Expensive operation!! Only call when necessary!! validMoves = gs.getValidMoves() promotionMoves = gs.getPawnPromotionMoves() moveMade = False highlight = [0, 0, 0, validMoves] #Just loading the images once instead of loading after each move loadImages() #Keeping track of the last square that the user has clicked (initially none) sqSelected = () #Keeping track of up to two of the squares last clicked (two tuples) playerClicks = [] running = True while running: if gs.checkMate: color = "black" if gs.whiteToMove else "white" drawText(screen, "CHECKMATE", color) elif gs.staleMate: drawText(screen, "STALEMATE", "red") #If we press X on the window stop this while -loop for e in p.event.get(): if e.type == p.QUIT: running = False #key handlers elif e.type == p.KEYDOWN: #If key 'z' is pressed, undo previous move and make sure valid moves are checked again if e.key == p.K_z: gs.undoMove() moveMade = True elif e.key == p.K_r: gs = ChessEngine.GameState() validMoves = gs.getValidMoves() promotionMoves = gs.getPawnPromotionMoves() highlight = [0, 0, 0, validMoves] playerClicks = [] sqSelected = () #mouse handler elif e.type == p.MOUSEBUTTONDOWN: #Use the location of the mouse to determine which of squares has been clicked location = p.mouse.get_pos() col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE #If the user clicked the same square twice, don't make a move. Clear sqSelected and playerClicks if sqSelected == (row, col): sqSelected = () playerClicks = [] highlight = [0, 0, 0, validMoves] elif len(playerClicks) == 0 and gs.board[row][col] == "--": print("SELECT A PIECE INSTEAD") #If not, keep track of this click else: sqSelected = (row, col) playerClicks.append(sqSelected) #If this was the players 1st click highlight square if len(playerClicks) == 1: highlight = [row, col, 1, validMoves] #If this was the players 2nd click and the move will be valid, move the piece and cancel highlight if len(playerClicks) == 2: highlight = [0, 0, 0, validMoves] move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) for i in range(len(validMoves)): if move == validMoves[i]: print(move.getChessNotation()) if move in promotionMoves: gs.makeMove(validMoves[i]) pieceColor = gs.board[playerClicks[1][0]][ playerClicks[1][1]][0] piece = choosePromotionPiece( screen, pieceColor) gs.makePawnPromotion( playerClicks[1][0], playerClicks[1][1], piece) else: gs.makeMove(validMoves[i]) moveMade = True sqSelected = () playerClicks = [] #If a move has been made since the last time valid moves were checked, check them again if moveMade: validMoves = gs.getValidMoves() promotionMoves = gs.getPawnPromotionMoves() moveMade = False #To run slower wait the amount of millisecond in MAX_FPS clock.tick(MAX_FPS) #Update the contents of the display p.display.flip() drawGameState(screen, gs, highlight)
def game(): global drag_move, vs_ai, vs_ml p.init() screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() valid_moves = gs.getValidMoves() move_made = False # flag variable for when a move is made undo_made = False playing = True sq_selected = ( ) # initially no square is selected, keeps track of last selected click (6, 4) player_clicks = [] # keeps track of the players clicks [(6, 4) , (4, 4)] game_over = False drag = False selected = None piece_selected_rect = [] for piece in pieces: piece_selected_rect.append(IMAGES[piece].get_rect()) draw_gamestate( screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos ) # initial draw of gamestate as it only updates on player clicks while playing: for e in p.event.get(): if e.type == p.QUIT: playing = False # Mouse Presses # elif drag_move: if e.type == p.MOUSEBUTTONDOWN: if e.button == 1: col, row = e.pos[0] // SQ_SIZE, e.pos[1] // SQ_SIZE sq_selected = (row, col) piece_selected = gs.board[row][col] if gs.whiteToMove and piece_selected[ 0] == 'w' or not gs.whiteToMove and piece_selected[ 0] == 'b': if piece_selected != '--': piece_rect = IMAGES[piece_selected].get_rect() gs.board[row][ col] = "--" # removes piece from current pos draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) drag = True # time to drag offset_x = piece_rect.x - e.pos[ 0] # offset between mouse and center of item offset_y = piece_rect.y - e.pos[1] piece_rect.x = col * SQ_SIZE + e.pos[0] + offset_x piece_rect.y = row * SQ_SIZE + e.pos[1] + offset_y screen.blit(IMAGES[piece_selected], piece_rect) elif e.type == p.MOUSEBUTTONUP: if e.button == 1: drag = False sq_released = (int(e.pos[1] / SQ_SIZE), int(e.pos[0] / SQ_SIZE)) if sq_released == sq_selected: gs.board[sq_selected[0]][ sq_selected[1]] = piece_selected sq_selected = () player_clicks = [] draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) else: player_clicks = [sq_selected, sq_released] draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) if len(player_clicks) == 2: move = ChessEngine.Move(player_clicks[0], player_clicks[1], gs.board) poly_move = str( chess.Move.from_uci( ChessEngine.Move.getChessNotation(move))) for i in range(len(valid_moves)): if move == valid_moves[i]: gs.board[player_clicks[0][0]][ player_clicks[0][1]] = piece_selected gs.makeMove(valid_moves[i]) ChessAI.polyboard.push( chess.Move.from_uci(poly_move)) move_made = True ChessAI.Calculations.best_move = 0 ChessAI.Calculations.opening_move = 0 draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) if not move_made: gs.board[sq_selected[0]][ sq_selected[1]] = piece_selected sq_selected = () player_clicks = [] draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) elif e.type == p.MOUSEMOTION: if drag: # if item is clicked on piece_rect.x = col * SQ_SIZE + e.pos[ 0] + offset_x # update the pos of the item to mouse pos piece_rect.y = row * SQ_SIZE + e.pos[1] + offset_y draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos=(e.pos[0], e.pos[1])) screen.blit(IMAGES[piece_selected], piece_rect) elif e.type == p.KEYDOWN: if e.key == p.K_ESCAPE: main() if move_made: if not vs_ml and not vs_ai: valid_moves = gs.getValidMoves() sq_selected = () draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, undo_made, move_made, drag, mouse_pos) draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) player_clicks = [] move_made = False if vs_ml or vs_ai: move_made = False if vs_ml: ml_thread = threading.Thread(target=ChessAI.AI.get_ai_move) ml_thread.daemon = True ml_thread.start() while ml_thread.is_alive: if ChessAI.Calculations.best_move != 0: ml_thread.is_alive = False else: p.display.update() time.sleep(1) best_move, poly_move = ChessAI.Calculations.best_move, ChessAI.Calculations.opening_move elif vs_ai: ai_thread = threading.Thread(target=ChessAI.AI.get_ai_move) ai_thread.daemon = True ai_thread.start() while ai_thread.is_alive: if ChessAI.Calculations.best_move != 0: ai_thread.is_alive = False else: p.display.update() time.sleep(1) best_move, poly_move = ChessAI.Calculations.best_move, ChessAI.Calculations.opening_move if best_move == poly_move == "N": if gs.inCheck(): gs.checkmate = True break else: gs.stalemate = True break gs.makeMove(best_move) ChessAI.polyboard.push(poly_move) valid_moves = gs.getValidMoves() draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) draw_gamestate(screen, gs, valid_moves, sq_selected, player_clicks, move_made, undo_made, drag, mouse_pos) if gs.checkmate: game_over = True if gs.whiteToMove: draw_text(screen, text_location='center', text='Black wins by Checkmate') else: draw_text(screen, text_location='center', text='White wins by Checkmate') elif gs.stalemate: game_over = True draw_text(screen, text_location='center', text='Stalemate') clock.tick(MAX_FPS) p.display.flip()
def __init__(self): self.gs = ChessEngine.GameState() self.WhitetoMove = self.gs.WhiteToMove self.allMoves = self.gs.getValidMoves() self.gameOver = False self.whiteWin = False self.blackWIn = False self.previousCastleMove = False self.whiteToTurnRight = True self.castleRule = ChessMain.castleRule self.castlingCopy = () self.board = np.array([ ["bR", "bN", "bB", "bQ", "bK", "bB", "bN", "bR"], ["bp", "bp", "bp", "bp", "bp", "bp", "bp", "bp"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["--", "--", "--", "--", "--", "--", "--", "--"], ["wp", "wp", "wp", "wp", "wp", "wp", "wp", "wp"], ["wR", "wN", "wB", "wQ", "wK", "wB", "wN", "wR"]]) self.whitePawnPositionValue = [ [1, 1, 1, 1, 1, 1, 1, 1], [1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5], [1.1, 1.1, 1.2, 1.3, 1.3, 1.2, 1.1, 1.], [1.05, 1.05, 1.1, 1.25, 1.25, 1.1, 1.05, 1.05], [1, 1, 1, 1.5, 1.5, 1, 1, 1], [1.05, 0.95, 0.9, 1.05, 1.05, 0.9, 0.95, 1.05], [1.05, 1.1, 1.1, 0.8, 0.8, 1.1, 1.1, 1.05], [1, 1, 1, 1, 1, 1, 1, 1]] self.blackPawnPositionValue = [ [1, 1, 1, 1, 1, 1, 1, 1], [1.05, 1.1, 1.1, 0.8, 0.8, 1.1, 1.1, 1.05], [1.05, 0.95, 0.9, 1.05, 1.05, 0.9, 0.95, 1.05], [1, 1, 1, 1.5, 1.5, 1, 1, 1], [1.05, 1.05, 1.1, 1.25, 1.25, 1.1, 1.05, 1.05], [1.1, 1.1, 1.2, 1.3, 1.3, 1.2, 1.1, 1.], [1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5, 1.5], [1, 1, 1, 1, 1, 1, 1, 1]] self.KnightPositionValue = [ [0.5, 0.6, 0.7, 0.7, 0.7, 0.7, 0.6, 0.50], [0.6, 0.8, 1, 1, 1, 1, 0.8, 0.6], [0.7, 1, 1.1, 1.15, 1.15, 1.1, 1, 0.7], [0.7, 1.05, 1.15, 1.2, 1.2, 1.15, 1.05, 0.7], [0.7, 1.05, 1.15, 1.2, 1.2, 1.15, 1.05, 0.7], [0.7, 1, 1.1, 1.15, 1.15, 1.1, 1, 0.7], [0.6, 0.8, 1, 1, 1, 1, 0.8, 0.6], [-50, -40, -30, -30, -30, -30, -40, -50]] self.BishopPositionValue = [ [0.8, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.8], [0.9, 1, 1, 1, 1, 1, 1, 0.9], [0.9, 1, 1.05, 1.1, 1.1, 1.05, 1, 0.9], [0.9, 1.05, 1.05, 1.1, 1.1, 1.05, 1.05, 0.9], [0.9, 1.05, 1.05, 1.1, 1.1, 1.05, 1.05, 0.9], [0.9, 1, 1.05, 1.1, 1.1, 1.05, 1, 0.9], [0.9, 1, 1, 1, 1, 1, 1, 0.9], [0.8, 0.9, 0.9, 0.9, 0.9, 0.9, 0.9, 0.8]] self.RookPositionValue = [ [1, 1, 1, 1, 1, 1, 1, 1], [1.05, 1.1, 1.1, 1.1, 1.1, 1.1, 1.1, 1.05], [0.95, 1, 1, 1, 1, 1, 1, 0.95], [0.95, 1, 1, 1, 1, 1, 1, 0.95], [0.95, 1, 1, 1, 1, 1, 1, 0.95], [0.95, 1, 1, 1, 1, 1, 1, 0.95], [1.05, 1.1, 1.1, 1.1, 1.1, 1.1, 1.1, 1.05], [1, 1, 1, 5, 5, 1, 1, 1]] self.QueenPositionValue = [ [0.8, 0.9, 0.9, 0.95, 0.95, 0.90, 0.9, 0.8], [0.9, 1, 1, 1, 1, 1, 1, 0.9], [0.9, 1, 1.5, 1.5, 1.5, 1.5, 1, 0.9], [0.95, 1, 1.5, 1.5, 1.5, 1.5, 1, 0.95], [0.95, 1, 1.5, 1.5, 1.5, 1.5, 1, 0.95], [0.9, 1, 1.5, 1.5, 1.5, 1.5, 1, 0.9], [0.9, 1, 1, 1, 1, 1, 1, 0.9], [0.8, 0.9, 0.9, 0.95, 0.95, 0.90, 0.9, 0.8]] self.KingPositionValue = [ [1.2, 1.1, 1.1, 1.05, 1.05, 1.1, 1.2, 1.2], [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1], [1.2, 1.1, 1.1, 1.05, 1.05, 1.1, 1.2, 1.2]]
def chess_game(game_kind, board_type, countdown_len): countdown_start = countdown_len * 60 * 60 screen = p.display.set_mode((WIDTH + 200, HEIGHT)) clock = p.time.Clock() #built in pygame screen.fill(p.Color("grey")) gs = ChessEngine.GameState( ) #now all the fields within the ChessEngine.py file can be called using gs. board = gs.board validMoves = gs.getValidMoves() #get initial valid moves moveMade = False #flag varable for when a move is made. Until a move is made, we don't want to regenerate the valid #moves function whiteToMove = 1 #keep track of whose turn it is loadImages(board_type) #only do this once, before the while loop running = True sqSelected = ( ) #no square is selected, keep track of the last click of the user (tuple: (row,col)) playerClicks = [ ] #keep track of player clicks (two tuples: [(6,4), (4,4)]) first clicks on (6,4) and #later on (4,4) to move the pawn gameOver = False time_black = countdown_start time_white = countdown_start start_ticks = p.time.get_ticks() stop_clocks = False while running: milliseconds_past = ( p.time.get_ticks() - start_ticks ) / 15 #define time relative to each loop and divide by 15 if not stop_clocks: if whiteToMove % 2 == 0: #alternate clock depending on who'e turn it is time_black = time_black - milliseconds_past else: time_white = time_white - milliseconds_past timer_visualize(screen, time_black, time_white) #load clock screen start_ticks = p.time.get_ticks() #ensure time does not accelerate # if time_white/(60*60) <=0: #end game if time runs out # gameOver = True # stop_clocks = True # # elif time_black/(60*60) <= 0: # gameOver = True # stop_clocks = True for e in p.event.get(): if e.type == p.QUIT: running = False ## The below takes care of AI moves from the black side. elif whiteToMove % 2 == 0 and game_kind == "Human vs. NPC Chess": #When it's blacks turn if not gameOver: bestMove = gs.minimax( 3, -999999999, 999999999, False ) #call the minimax function which returns the best move gs.makeMove(bestMove[1]) #do best move moveMade = True #set to True so we can get the valid moves for white next else: #in case we make a check mate to black and we want to go back, we need to include this piece of code if e.type == p.KEYDOWN: if e.key == p.K_z: # undo when "z" is pressed gs.undoMove() moveMade = True if gameOver: gameOver = False break if e.key == p.K_r: # reset the board gs = ChessEngine.GameState() validMoves = gs.getValidMoves() sqSelected = () playerClicks = [] whiteToMove = 1 moveMade = False if gameOver: gameOver = False break #mouse handler elif e.type == p.MOUSEBUTTONDOWN: if not gameOver and p.mouse.get_pos()[0] < WIDTH: bestMove = gs.minimax( 1, -999999999, 999999999, True ) # call the minimax function which returns the best move location = p.mouse.get_pos() #(x,y) location of the mouse col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == ( row, col ): #this means the user clicked the same square twice sqSelected = () #deselect playerClicks = [] #clear player clicks else: sqSelected = (row, col) playerClicks.append( sqSelected) #append for both 1st and 2nd clicks if len( playerClicks ) == 2: #after the second click, we want to make the move move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) ## See that creating the move is pretty inexpensive, we are just creating 4 variables and accessing ## two elements of an array print(move.getChessNotation()) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(validMoves[i]) # whiteToMove = whiteToMove + 1 animateMove(gs.moveLog[-1], screen, gs.board, clock, board_type) moveMade = True #a move was made, so now go ahead and regenerate the list of valid moves sqSelected = () #reset user clicks playerClicks = [] if not moveMade: #this allows to select a new piece and dislect the previous one playerClicks = [sqSelected] #key handler elif e.type == p.KEYDOWN: if e.key == p.K_z: #undo when "z" is pressed gs.undoMove() moveMade = True if gameOver: gameOver = False break if e.key == p.K_r: #reset the board gs = ChessEngine.GameState() validMoves = gs.getValidMoves() sqSelected = () playerClicks = [] moveMade = False if gameOver: gameOver = False stop_clocks = False #restart the clocks time_black = countdown_start time_white = countdown_start start_ticks = p.time.get_ticks() whiteToMove = 1 #reset white's turn if moveMade: validMoves = gs.getValidMoves() moveMade = False whiteToMove = whiteToMove + 1 #counter for AI drawGameState(screen, gs, validMoves, sqSelected, board_type) if gs.checkMate: gameOver = True drawText(screen, "Checkmate") stop_clocks = True elif gs.staleMate: gameOver = True drawText(screen, "Stalemate") stop_clocks = True elif gameOver: drawText(screen, "Time out") clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() screen = p.display.set_mode((BOARD_WIDTH+MOVE_LOG_PANEL_WIDTH, BOARD_HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) moveLogFont = p.font.SysFont("Arial", 12, False, False) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False #flag variable for when a move is made animate = False #flag for when to animate #print(gs.board) loadImages() #only do once, before while loop running = True sqSelected = () #no square selected initially, keep track of last click of user (tuple: (row,col)) prevSqSelected = () secondPrevSqSelected = () playerClicks = [] #keeps track of player clicks (two tuples: [(6,4),(4,4)]) gameOver = False playerOne = -1 #if human is playing white,then this will be true. If AI is playing, then false #can also make this an integer value, 0 being human 1-10 being difficulty of AI playerTwo = -1 #Same as above but for black while running: humanTurn = (gs.whiteToMove and playerOne == -1) or (not gs.whiteToMove and playerTwo == -1) for e in p.event.get(): if e.type == p.QUIT: running = False #handles mouse elif e.type == p.MOUSEBUTTONDOWN: if not gameOver and humanTurn: location = p.mouse.get_pos() #(x,y) location of mouse col = location[0]//SQ_SIZE #to get col, integer divide x coord on board w size of each square row = location[1]//SQ_SIZE #to get row, integer divide y coord on board w size of each square if sqSelected == (row,col) or col >= 8: #user clicked same square twice, so unselect or user clicked mouse log sqSelected = () #deselect playerClicks = [] #clear player clicks else: sqSelected = (row,col) playerClicks.append(sqSelected) #append for both 1st and 2nd clicks if len(playerClicks) == 2: #after 2nd click move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(validMoves[i]) print(str(gs.moveLog[-1])) moveMade = True animate = True prevSqSelected = playerClicks[-1] secondPrevSqSelected = playerClicks[-2] sqSelected = () #reset uer clicks playerClicks = [] if not moveMade: playerClicks = [sqSelected] #handles keys elif e.type == p.KEYDOWN: if e.key == p.K_z: #undo when 'z' is pressed gs.undoMove() moveMade = True animate = False gameOver = False if e.key == p.K_r: #reset when 'r' is pressed gs = ChessEngine.GameState() validMoves = gs.getValidMoves() sqSelected = () prevSqSelected = () secondPrevSqSelected = () moveMade = False gameOver = False animate = False #Chess AI if not gameOver and not humanTurn: if gs.whiteToMove: AIMove = chessAI.findBestMove(gs, validMoves, playerOne) else: AIMove = chessAI.findBestMove(gs, validMoves, playerTwo) if AIMove is None: if(len(validMoves) != 0): AIMove = chessAI.findRandomMove(validMoves) else: break gs.makeMove(AIMove) print(str(gs.moveLog[-1])) moveMade = True animate = True if moveMade: if animate: animateMove(gs.moveLog[-1], screen, gs.board, clock) validMoves = gs.getValidMoves() moveMade = False #print(prevSqSelected) drawGameState(screen,gs, validMoves, sqSelected, prevSqSelected, secondPrevSqSelected, moveLogFont) if gs.checkMate or gs.staleMate: gameOver = True text = 'Draw by stalemate' if gs.staleMate else ('Black wins by checkmate' if gs.whiteToMove else 'White wins by checkmate') drawEndGameText(screen, text) clock.tick(MAX_FPS) p.display.flip()
def main(): p.init() p.display.set_caption('Pysah') screen = p.display.set_mode((WIDTH, HEIGHT)) clock = p.time.Clock() screen.fill(p.Color("white")) gs = ChessEngine.GameState() validMoves = gs.getValidMoves() moveMade = False animate = False loadImages() running = True sqSelected = () playerClicks = [] gameOver = False while running: for e in p.event.get(): if e.type == p.QUIT: running = False elif e.type == p.MOUSEBUTTONDOWN: if not gameOver: location = p.mouse.get_pos() col = location[0] // SQ_SIZE row = location[1] // SQ_SIZE if sqSelected == (row, col): sqSelected = () playerClicks = [] else: sqSelected = (row, col) playerClicks.append(sqSelected) if len(playerClicks) == 2: move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board) print(move.getChessNotation()) for i in range(len(validMoves)): if move == validMoves[i]: gs.makeMove(validMoves[i]) if move.isPawnPromotion: gs.whiteToMove = not gs.whiteToMove pieceType = getChoice(screen, gs) gs.board[move.endRow][ move.endCol] = move.pieceMoved[ 0] + pieceType gs.whiteToMove = not gs.whiteToMove moveMade = True animate = True sqSelected = () playerClicks = [] if not moveMade: playerClicks = [sqSelected] elif e.type == p.KEYDOWN: if e.key == p.K_z: gs.undoMove() moveMade = True animate = False if e.key == p.K_r: gs = ChessEngine.GameState() validMoves = gs.getValidMoves() sqSelected = () playerClicks = [] moveMade = False animate = False if moveMade: if animate: animatedMove(gs.movelog[-1], screen, gs.board, clock) validMoves = gs.getValidMoves() moveMade = False animate = False drawGameState(screen, gs, validMoves, sqSelected) if gs.checkMate: gameOver = True if gs.whiteToMove: drawText(screen, 'Black wins by checkmate') else: drawText(screen, 'White wins by checkmate') elif gs.staleMate: gameOver = True drawText(screen, 'Stalemate') clock.tick(MAX_FPS) p.display.flip()