class Game: def __init__(self, win): ''' de facto wywolanie _init() przypisanie zmiennej win która jest naszym oknem ''' self.win = win self._init() def update(self): ''' funkcja update uruchamiana w każdym obiegu głównej funkcji main, rysuje ustawienie szachownicy jak i samą szachownicę dozwolone ruchy o ile istnieją po części obłsuguje wyjątki poprzez printowanie tekstów "wywoływanych" przez wyjątki za pomocą zmiany stanów zmiennych kontrolowanie czy któryś z graczy nie wygrał meczu poprzez sprawdzanie zmienne winner, jesli tak obsługuje printa z informacja kto wygrał ''' self.board.draw(self.win) self.printing_moves() self.draw_valid_moves(self.valid_moves) if self.bad_move_exce: self.bad_move_exe() pygame.time.delay(1000) self.bad_move_exce = False if self.outside_board_exce: self.outside_board_exe() pygame.time.delay(1000) self.outside_board_exce = False if self.winner() != None: if self.winner() == WHITE: pygame.draw.rect( self.win, GREY, (1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE, 5 * SQUARE_SIZE, SQUARE_SIZE + 5)) self.show_text("WHITE HAS WON", 4, 1.5, WHITE) else: pygame.draw.rect( self.win, GREY, (1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE, 5 * SQUARE_SIZE, SQUARE_SIZE + 5)) self.show_text("RED HAS WON", 4, 2, WHITE) pygame.display.update() def show_text(self, content, x, y, rgb): ''' printowanie tekstu o zadanym kolorze rgb na ekranie w konkretnym miejscu ''' text = FONT2.render(content, True, rgb) self.win.blit(text, (y * SQUARE_SIZE + SQUARE_SIZE // 4 + 5, x * SQUARE_SIZE + SQUARE_SIZE // 4 + 5)) def _init(self): ''' de facto funkcja inicjalizująca wywoływana w __init__(), było to potrzebne aby łatwo robić resety mamy takie parametry jak selected - zaznaczony item (typu zwykła bierka/król) stworzenie obiektu Board (nasza plansza) aktualna tura dostępne ruchy do funkcji valid_moves pola dla wyjątków do obsługi nieco zawiłej procedury printowania wyjątków na ekranie gry pygame ''' self.selected = None self.board = Board(self.win) self.turn = RED self.valid_moves = {} self.bad_move_exce = False self.outside_board_exce = False def reset(self): ''' resetowanie gry poprzez ponowne wywołanie funkcji _init() :return: ''' self._init() def select(self, row, col): ''' wybranie konkretnego itemu z naszej tablicy (szachownica ma dostępne pola 0 - puste, Piece - obiekt podsatwowej bierki, King - bierka król) wybieranie przebiega na podsatwie zmiennych row,col które symbolizują pola 8x8 planszy obsługa dwóch wyjątków - łapanie wyjątku odnośnie "bad move" kliknięcie podczas tury ruchu pole które nie jest dozwolonym ruchem oraz podnoszenie wyjątku o kliknięciu w dolny pasek który nie jest responsywny a jest jedynie tłem w dodatku metoda obsługuje restart gry gdy przekazane współrzędne odpowiadają naszemu przyciskowi ''' if row != 8: # jeśli mamy już coś zaznaczonego (bierkę) próbujemy zrobić ruch if self.selected: try: result = self._move(row, col) if not result: self.selected = None self.select(row, col) except BadMoveExceptions: self.bad_move_exce = True print("bad move") # pobieramy wartość z pod konkretnego indeksu na tablicy piece = self.board.get_piece(row, col) # jeżeli obiekt != znaczy ze jest to jakaś bierka, sprawdzamy czy to nasza tura # i czy mamy jakieś ruchy dla tej konkretnej instacji (bierki) # jeśli tak zracamy true, jesli nie false if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True elif piece != 0 and piece.color != self.turn: print("zly kolor") return False # jeżeli klikniecie jest w 8 rząd czyli poniżej planszy (0-7 rzędy) sprawdzamy czy kliknęliśmy w guzik elif col == 0 or col == 1: self.restart_game() # jeśli kliknęlismy poza plansze ale nie w guzik wyrzucamy błąd else: raise OutsideBoardExceptions() def bad_move_exe(self): ''' obsługa printu dla niedozwolonego ruchu ''' pygame.draw.rect(self.win, GREY, (1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE, 5 * SQUARE_SIZE, SQUARE_SIZE + 5)) self.show_text("BAD MOVE", 4, 1.5, BLACK) def outside_board_exe(self): ''' obsługa printu dla kliknięcie poza obszar planszy który jednak dalej jest w oknie gry ''' pygame.draw.rect(self.win, GREY, (1 * SQUARE_SIZE + SQUARE_SIZE // 2, 4 * SQUARE_SIZE, 5 * SQUARE_SIZE, SQUARE_SIZE + 5)) self.show_text("Outside board", 4, 1.5, BLACK) def restart_game(self): ''' metoda restartująca poprzez ponowne wywołanie inita który inicjalizuje wartości ''' print("restart") self._init() def _move(self, row, col): ''' metoda sprawdzająca czy czy pod podanymi współrzędnymi znajduje się się 0 czyli brak jakiegoś obiektu i czy można tam przestawić naszą bierkę ''' piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: if piece == 0: raise BadMoveExceptions() return True def change_turn(self): ''' metoda która zmienia turę bazując na obecnej turze :return: ''' self.valid_moves = {} if self.turn == RED: self.turn = WHITE elif self.turn == WHITE: self.turn = RED def draw_valid_moves(self, moves): ''' na podstawie elementów w valid_moves = możliwe ruchy rysujemy niebieskie kropki w tych punktach ''' for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 12) def winner(self): ''' metoda zwracająca zwycięzce na podstawie zmiennych zawartych w klasie ''' return self.board.winner() def printing_moves(self): ''' obsługa printowania tury gracza na dole ekranu z grą ''' if self.turn == RED: self.show_text("RED's MOVE", 7.8, 2, BLACK) else: self.show_text("WHITE's MOVE", 7.8, 2, BLACK)
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() # _init makes it a private method of the class def _init(self): self.selected = None self.board = Board() self.turn = RED self.valid_moves = {} def winner(self): return self.board.winner() def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def change_turn(self): self.valid_moves = {} if self.turn == RED: self.turn = WHITE else: self.turn = RED
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.drawValidMoves(self.validMoves) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = creamWhite self.validMoves = {} def winner(self): return self.board.winner() def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.getPiece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.validMoves = self.board.getValidMoves(piece) return True return False def _move(self, row, col): piece = self.board.getPiece(row, col) if self.selected and piece == 0 and (row, col) in self.validMoves: self.board.move(self.selected, row, col) skipped = self.validMoves[(row, col)] if skipped: self.board.remove(skipped) self.changeTurn() else: return False return True def drawValidMoves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def changeTurn(self): self.validMoves = {} if self.turn == creamWhite: self.turn = WHITE else: self.turn = creamWhite def getBoard(self): return self.board def aiMove(self, board): self.board = board self.changeTurn()
class Game: def __init__(self, win): self._init() self.win = win # Update pygame display using this method def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() # Initilizing => private method init def _init(self): self.selected = None self.board = Board() self.turn = RED # dictionary of valid possible moves that can be taken from a position self.valid_moves = {} # Reset the game def reset(self): self._init() # When select something => call the select method, tell the row and col selected and do something based on that def select(self, row, col): # Move the already selected piece to the desired row,col if self.selected: result = self._move(row, col) # If incorrect/invalid move => reset the selection and reselect row and col if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) # not selecting an empty piece and the color of the piece is same as the turn if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False # Move currently selected piece to the row and col def _move(self, row, col): piece = self.board.get_piece(row, col) # If we have selected something and the piece that we selected is empty and the row, col is a valid move then we can move it if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True # Change the turn after the move def change_turn(self): self.valid_moves = [] if self.turn == RED: self.turn = WHITE else: self.turn = RED def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def winner(self): return self.board.winner()
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win, self.turn) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = WHITE self.valid_moves = {} def reset(self): self._init() def select(self, pos): x, y = pos row = y // SQUARE_SIZE col = x // SQUARE_SIZE if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(pos) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def change_turn(self): self.valid_moves = [] if self.turn == WHITE: self.turn = BLACK else: self.turn = WHITE def winner(self): return self.board.winner() def draw(self): for row in self.board.board: for piece in row: if piece != 0 and piece.color == self.turn and len( self.board.get_valid_moves(piece)) > 0: return self.draw self.draw = True return self.draw def get_board(self): return self.board def highlight_move(self, new_board): old_board = self.board for row in range(ROWS): for col in range(COLS): if old_board.board[row][ col] == 0 and new_board.board[row][col] != 0: pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 40, width=5) if new_board.board[row][ col] == 0 and old_board.board[row][col] != 0: pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 40, width=5) pygame.display.update() def ai_move(self, new_board): self.highlight_move(new_board) pygame.time.delay(1000) self.board = new_board self.change_turn()
class Game: def __init__(self, window): self._init() self.window = window # the Game window on your device def update(self): self.board.draw(self.window) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None # which piece is selected self.board = Board( ) # the game will happen on the board so we initialize it inside the Game class self.turn = YELLOW # which player's turn self.valid_moves = { } # what the current valid moves are for whatever player is playing # to reinitialize the game def reset(self): self._init() def winner(self): return self.board.winner() def select(self, row, col): # this is a recursive method if self.selected: # in case user pressed on some piece result = self._move(row, col) # move the selected piece from row and col of the select method to row and col of the move method if not result: # if the result is not valid (an empty square selected for example) self.selected = None # nothing is selected self.select( row, col ) # user has to select a new piece (so this is to call the method again) piece = self.board.get_piece( row, col) # define the piece correspond to selected row and col if piece != 0 and piece.color == self.turn: # if the selected piece exists and corresponds to the player's color: self.selected = piece # the piece is selected self.valid_moves = self.board.get_valid_moves(piece) return True # the selection is valid return False # the selected piece is not valid, try again def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: #(piece == 0 to make sure that where we are going to move the piece is an empty square with no piece on it already!) self.board.move(self.selected, row, col) # move the valid selected piece skipped = self.valid_moves[(row, col)] if skipped: self.board.remove( skipped) # remove the eaten pieces from the board self.change_turn() # change turn so the second player can play else: return False return True def draw_valid_moves(self, moves): for move in moves: row, col = move # since moves is a dictionary of tuples (row, col) pygame.draw.circle(self.window, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), radius=15) def change_turn(self): self.valid_moves = {} if self.turn == WHITE: self.turn = YELLOW else: self.turn = WHITE
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None self.human_player = False self.board = Board() self.turn = RED self.valid_moves = {} self.display_buttons() def multiplayer(self): self.human_player = True def singleplayer(self): self.human_player = False def display_buttons(self): game_reset = tk.Button(root, text='New Game ', image=newgame, compound=TOP, font='Raleway', command=self.reset, relief=GROOVE) game_reset.place(relx=0.2, rely=0.6) multiplayer = tk.Button(root, text='Multiplayer ', image=multi, compound=TOP, font='Raleway', command=self.multiplayer, relief=GROOVE) multiplayer.place(relx=0.2, rely=0.72) singleplayer = tk.Button(root, text='Singleplayer', image=single, compound=TOP, font='Raleway', command=self.singleplayer, relief=GROOVE) singleplayer.place(relx=0.2, rely=0.84) def winner(self): return self.board.winner() def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_legal_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def draw_valid_moves(self, moves): for move in moves: row, col = move self.win.blit(circle, (col * square_size + 25, row * square_size + 25)) def change_turn(self): self.valid_moves = {} if self.turn == RED: self.turn = WHITE else: self.turn = RED def get_board(self): return self.board def algorithm_move(self, board): self.board = board self.change_turn()
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = RED self.valid_moves = {} def winner(self): return self.board.winner() def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def get_board(self): return self.board def ai_move(self, board): #will be passed the changed board the entire board will be returned and the board the player sees will #be updated to include the new board self.board = board self.change_turn() def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def change_turn(self): self.valid_moves = {} if self.turn == RED: self.turn = WHITE else: self.turn = RED
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) # pygame.draw.circle(win, GREY, (self.x, self.y), radius+self.OUTLINE) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = RED self.valid_moves = {} def winner(self): return self.board.winner() def reset(self): self._init() self.board.draw(self.win) pygame.display.update() def select(self, row, col, win): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col, win) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: # print(piece.x, piece.y) # pygame.draw.circle(win, GREEN, (piece.x, piece.y), 15) self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def draw_valid_moves(self, moves): # print(self.selected) for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def change_turn(self): self.valid_moves = {} if self.turn == RED: self.turn = BLACK else: self.turn = RED def get_board(self): return self.board def ai_move(self, board): self.board = board self.change_turn()
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = WHITE self.valid_moves = {} def winner(self): return self.board.winner() def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_checker(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_checker(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.rect(self.win, GREEN, (col * SQUARE_SIZE, row * SQUARE_SIZE, SQUARE_SIZE, SQUARE_SIZE)) def change_turn(self): self.valid_moves = {} if self.turn == WHITE: self.turn = BLACK else: self.turn = WHITE
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) # to increase difficulty let deactivate this function pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = GREEN self.valid_moves = {} def winner(self): return self.board.winner() def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] # if skipped: # self.board.remove(skipped) self.change_turn() else: return False return True # to increase difficulty let deactivate this function(): def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE//2, row * SQUARE_SIZE + SQUARE_SIZE//2), 15) def change_turn(self): self.valid_moves = {} if self.turn == GREEN: self.turn = WHITE else: self.turn = GREEN
class Game: def __init__(self, win): self._init() self.win = win def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = RED self.valid_moves = {} def winner(self): if self.board.winner() == WHITE: winner = 'White' elif self.board.winner() == RED: winner = 'Red' else: winner = None return winner def reset(self): self._init() def select(self, row, col): if self.selected: result = self._move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) if piece != 0 and piece.color == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def _move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and ( row, col ) in self.valid_moves: #s-a selectat un patrat care nu e gol # si linia si coloana la care se va feca mutarea e valida self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] #piesa peste care s-a sarit if skipped: self.board.remove( skipped) #se elimina piesa peste care s-a sarit self.change_turn() else: return False return True def draw_valid_moves(self, moves): ''' Marcheaza toate mutarile pe care piesa selectata le poate face :param moves: mutarile valide :return: ''' for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE // 2, row * SQUARE_SIZE + SQUARE_SIZE // 2), 15) def change_turn(self): self.valid_moves = {} if self.turn == RED: self.turn = WHITE else: self.turn = RED
class Game: def __init__(self, win): self._init() self.win = win #updates the display and draws it def update(self): self.board.draw(self.win) self.draw_valid_moves(self.valid_moves) pygame.display.update() def _init(self): self.selected = None self.board = Board() self.turn = RED self.valid_moves = {} #if someone wins the game def winner(self): return self.board.winner() #method to reset the game def reset(self): self._init() #if selection is valid, move the piece #otherwise reset the selection and reselect a row and col def select(self, row, col): if self.selected: result = self.move(row, col) if not result: self.selected = None self.select(row, col) piece = self.board.get_piece(row, col) if piece != 0 and piece.colour == self.turn: self.selected = piece self.valid_moves = self.board.get_valid_moves(piece) return True return False def move(self, row, col): piece = self.board.get_piece(row, col) if self.selected and piece == 0 and (row, col) in self.valid_moves: self.board.move(self.selected, row, col) skipped = self.valid_moves[(row, col)] if skipped: self.board.remove(skipped) self.change_turn() else: return False return True def draw_valid_moves(self, moves): for move in moves: row, col = move pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE//2, row * SQUARE_SIZE + SQUARE_SIZE//2), 15) #if red turn, change to black, else change to red def change_turn(self): self.valid_moves = {} if self.turn == RED: self.turn = BLACK else: self.turn = RED def get_board(self): return self.board def ai_move(self, board): self.board = board self.change_turn()