def square_clicked(self, event):
col_size = row_size = self.dim_square
if not self.source:
try:
self.source = ChessPosition._from_position(
Position(int(event.y / row_size), int(event.x / col_size)))
self.focused = self.__chess_match.possible_move(self.source)
self.draw_board()
except ChessException.ChessException as e:
self.current_player_label.configure(text=e)
self.source = None
else:
try:
target = ChessPosition._from_position(
Position(int(event.y / row_size), int(event.x / col_size)))
captured_piece = self.__chess_match.perform_chess_move(
self.source, target)
self.draw_captured_pieces(captured_piece)
self.current_player_label.configure(
text='Vez das ' +
('Brancas' if self.__chess_match.current_player ==
'WHITE' else 'Negras'))
if self.thread != None and self.thread.is_alive():
self.cpu_suggestions.terminate()
self.thread.join(0)
except ChessException.ChessException as e:
self.current_player_label.configure(text=e)
self.source = None
self.focused = None
self.__stockfish.set_fen_position(
self.__chess_match.get_fen_notation())
if self.__chess_match.current_player == self.__chess_match.bot_color:
moviment = self.__stockfish.get_best_move()
captured_piece = self.__chess_match.perform_chess_move(
ChessPosition(moviment[0], int(moviment[1])),
ChessPosition(moviment[2], int(moviment[3])))
self.draw_captured_pieces(captured_piece)
self.current_player_label.configure(
text='Vez das ' +
('Brancas' if self.__chess_match.current_player ==
'WHITE' else 'Negras'))
# Evita que entre em processo de threading
if not self.__chess_match.checkmate and not self.__chess_match.draw:
self.cpu_suggestions = Suggestion(self.__chess_match)
self.thread = threading.Thread(
target=self.cpu_suggestions.calculate_suggestions,
args=(self, ))
self.thread.start()
self.lateral_suggestions.delete(0, tk.END)
self.lateral_suggestions.insert(1, "Calculando Sugestões...")
self.draw_board()
self.draw_pieces()
self.show_match_moves()
if self.__chess_match.checkmate or self.__chess_match.draw:
self.on_closing()
def square_clicked(self, event):
col_size = row_size = self.dim_square
if not self.source:
try:
self.source = ChessPosition._from_position(
Position(int(event.y / row_size), int(event.x / col_size)))
self.focused = self.__chess_match.possible_move(self.source)
self.draw_board()
except ChessException.ChessException as e:
self.source = None
print(e)
else:
try:
target = ChessPosition._from_position(
Position(int(event.y / row_size), int(event.x / col_size)))
captured_piece = self.__chess_match.perform_chess_move(
self.source, target)
if self.thread.is_alive():
self.cpu_suggestions.terminate()
self.thread.join(0)
except ChessException.ChessException as e:
print(e)
self.source = None
self.focused = None
self.__stockfish.set_fen_position(
self.__chess_match.get_fen_notation())
if self.__chess_match.current_player == self.__chess_match.bot_color:
moviment = self.__stockfish.get_best_move()
captured_piece = self.__chess_match.perform_chess_move(
ChessPosition(moviment[0], int(moviment[1])),
ChessPosition(moviment[2], int(moviment[3])))
self.cpu_suggestions = Suggestion(self.__chess_match)
self.thread = threading.Thread(
target=self.cpu_suggestions.calculate_suggestions,
args=(self, ))
self.thread.start()
self.lateral_suggestions.delete(0, tk.END)
self.lateral_suggestions.insert(1, "Calculando Sugestões...")
self.draw_board()
self.draw_pieces()
self.show_match_moves()
if self.__chess_match.checkmate or self.__chess_match.draw:
if self.thread.is_alive():
self.cpu_suggestions.terminate()
self.thread.join(0)
self.parent.quit()
def possible_moves(self):
mat = Lista.Lista(8, copy.copy(Lista.Lista(8, False)))
# Movimentos pra cima
p = Position(self._position.row - 1, self._position.column)
while self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(p):
mat[p.row][p.column] = True
p.row -= 1
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimentos pra baixo
p = Position(self._position.row + 1, self._position.column)
while self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(p):
mat[p.row][p.column] = True
p.row += 1
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimentos pra direita
p = Position(self._position.row, self._position.column + 1)
while self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(p):
mat[p.row][p.column] = True
p.column += 1
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimentos pra esquerda
p = Position(self._position.row, self._position.column - 1)
while self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(p):
mat[p.row][p.column] = True
p.column -= 1
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
return mat
def possible_moves(self):
mat = Lista.Lista(8, copy.copy(Lista.Lista(8, False)))
# Movimentos pra cima/direita
p = Position(self._position.row - 2, self._position.column + 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra direita/cima
p = Position(self._position.row - 1, self._position.column + 2)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra direita/baixo
p = Position(self._position.row + 1, self._position.column + 2)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra baixo/direita
p = Position(self._position.row + 2, self._position.column + 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra baixo/esquerda
p = Position(self._position.row + 2, self._position.column - 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra esquerda/baixo
p = Position(self._position.row + 1, self._position.column - 2)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra esquerda/cima
p = Position(self._position.row - 1, self._position.column - 2)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra cima/esquerda
p = Position(self._position.row - 2, self._position.column - 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
return mat
def _undo_move(self, source, target, captured_piece):
p = self.__board.remove_piece(target)
p.decrease_move_count()
self.__board.place_piece(p, source)
if captured_piece != None:
self.__board.place_piece(captured_piece, target)
self.__captured_pieces.excluir_posicao(captured_piece)
self.__pieces_on_the_board.insere_final(captured_piece)
# Movimento especial rook pelo lado do rei
if isinstance(p, King.King) and target.column == source.column + 2:
source_tower = Position(source.row, source.column + 3)
target_tower = Position(source.row, source.column + 1)
rook = self.__board.remove_piece(target_tower)
self.__board.place_piece(rook, source_tower)
rook.decrease_move_count()
# Movimento especial rook pelo lado da rainha
if isinstance(p, King.King) and target.column == source.column - 2:
source_tower = Position(source.row, source.column - 4)
target_tower = Position(source.row, source.column - 1)
rook = self.__board.remove_piece(target_tower)
self.__board.place_piece(rook, source_tower)
rook.decrease_move_count()
# Movimento especial en passant
if isinstance(p, Pawn.Pawn):
if source.column != target.column and captured_piece == self.__en_passant_vulnerable:
pawn = self.__board.remove_piece(target)
if p.color == 'WHITE':
pawn_positon = Position(3, target.column)
else:
pawn_positon = Position(4, target.column)
self.__board.place_piece(pawn, pawn_positon)
def __test_checkmate(self, color):
if not self.__test_check(color):
return False
for i in range(len(self.__pieces_on_the_board)):
p = self.__pieces_on_the_board[i]
if p.color == color:
mat = p.possible_moves()
for j in range(len(mat)):
for k in range(len(mat)):
if mat[j][k]:
source = p.chess_position()._to_position()
target = Position(j, k)
captured_piece = self._make_move(source, target)
test_check = self.__test_check(color)
self._undo_move(source, target, captured_piece)
if not test_check:
return False
return True
def __test_draw(self):
# Falta de material (B e K vs K, N e K vs K, K vs K)
if len(self.__pieces_on_the_board) == 3:
for i in range(len(self.__pieces_on_the_board)):
p = self.__pieces_on_the_board[i]
if isinstance(p, Knight.Knight) or isinstance(
p, Bishop.Bishop):
return True
elif len(self.__pieces_on_the_board) == 2:
return True
else:
# Afogamento
for i in range(len(self.__pieces_on_the_board)):
p = self.__pieces_on_the_board[i]
if p.color == self._opponent_color(self.__current_player):
if p.is_there_any_possible_move() and not isinstance(
p, King.King):
return False
elif isinstance(p, King.King):
mat = p.possible_moves()
for j in range(len(mat)):
for k in range(len(mat)):
if mat[j][k]:
source = p.chess_position()._to_position()
target = Position(j, k)
captured_piece = self._make_move(
source, target)
test_check = self.__test_check(
self._opponent_color(
self.__current_player))
self._undo_move(source, target,
captured_piece)
if not test_check:
return False
return True
return False
def _make_move(self, source, target):
p = self.__board.remove_piece(source)
p.increase_move_count()
captured_piece = self.__board.remove_piece(target)
self.__board.place_piece(p, target)
if captured_piece != None:
self.__pieces_on_the_board.excluir_posicao(captured_piece)
self.__captured_pieces.insere_final(captured_piece)
# Movimento especial rook pelo lado do rei
if isinstance(p, King.King) and target.column == source.column + 2:
source_tower = Position(source.row, source.column + 3)
target_tower = Position(source.row, source.column + 1)
rook = self.__board.remove_piece(source_tower)
self.__board.place_piece(rook, target_tower)
rook.increase_move_count()
# Movimento especial rook pelo lado da rainha
if isinstance(p, King.King) and target.column == source.column - 2:
source_tower = Position(source.row, source.column - 4)
target_tower = Position(source.row, source.column - 1)
rook = self.__board.remove_piece(source_tower)
self.__board.place_piece(rook, target_tower)
rook.increase_move_count()
# Movimento especial en passant
if isinstance(p, Pawn.Pawn):
if source.column != target.column and captured_piece == None:
if p.color == 'WHITE':
pawn_positon = Position(target.row + 1, target.column)
else:
pawn_positon = Position(target.row - 1, target.column)
captured_piece = self.__board.remove_piece(pawn_positon)
self.__captured_pieces.insere_final(captured_piece)
self.__pieces_on_the_board.excluir_posicao(captured_piece)
return captured_piece
def possible_moves(self):
mat = Lista.Lista(8, copy.copy(Lista.Lista(8, False)))
# Movimentos pra cima
p = Position(self._position.row - 1, self._position.column)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra baixo
p = Position(self._position.row + 1, self._position.column)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra direita
p = Position(self._position.row, self._position.column + 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra esquerda
p = Position(self._position.row, self._position.column - 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra cima/direita
p = Position(self._position.row - 1, self._position.column + 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra cima/esquerda
p = Position(self._position.row - 1, self._position.column - 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra baixo/direita
p = Position(self._position.row + 1, self._position.column + 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimentos pra baixo/esquerda
p = Position(self._position.row + 1, self._position.column - 1)
if self.board.is_position_exists(p.row,
p.column) and self.__can_move(p):
mat[p.row][p.column] = True
# Movimento especial Rook
if self.move_count == 0 and not self.__chess_match.check:
# Rook pelo lado do rei
position_tower = Position(self._position.row,
self._position.column + 3)
if self.__test_rook(position_tower):
p1 = Position(self._position.row, self._position.column + 1)
p2 = Position(self._position.row, self._position.column + 2)
if self.board.piece(p1.row,
p1.column) == None and self.board.piece(
p2.row, p2.column) == None:
mat[self._position.row][self._position.column + 2] = True
# Rook pelo lado da rainha
position_tower = Position(self._position.row,
self._position.column - 4)
if self.__test_rook(position_tower):
p1 = Position(self._position.row, self._position.column - 1)
p2 = Position(self._position.row, self._position.column - 2)
p3 = Position(self._position.row, self._position.column - 3)
if self.board.piece(
p1.row, p1.column) == None and self.board.piece(
p2.row, p2.column) == None and self.board.piece(
p3.row, p3.column) == None:
mat[self._position.row][self._position.column - 2] = True
return mat
def possible_moves(self):
mat = Lista.Lista(8, copy.copy(Lista.Lista(8, False)))
if self.color == 'WHITE':
# Movimento para cima (1 casa)
p = Position(self._position.row - 1, self._position.column)
if self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(p):
mat[p.row][p.column] = True
# Movimento para cima (2 casa)
p = Position(self._position.row - 2, self._position.column)
p2 = Position(self._position.row - 1, self._position.column)
if self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(
p) and self.board.is_position_exists(
p2.row,
p2.column) and not self.board.is_there_a_piece(
p2) and self.move_count == 0:
mat[p.row][p.column] = True
# Movimento para comer peça adversária (esquerda)
p = Position(self._position.row - 1, self._position.column - 1)
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimento para comer peça adversária (direita)
p = Position(self._position.row - 1, self._position.column + 1)
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimento especial en passant
if self._position.row == 3:
left_pawn = Position(self._position.row,
self._position.column - 1)
if self.board.is_position_exists(
left_pawn.row,
left_pawn.column) and self._is_there_opponent_piece(
left_pawn) and self.board.piece(
left_pawn.row, left_pawn.column
) == self.__chess_match.en_passant_vulnerable:
mat[left_pawn.row - 1][left_pawn.column] = True
right_pawn = Position(self._position.row,
self._position.column + 1)
if self.board.is_position_exists(
right_pawn.row,
right_pawn.column) and self._is_there_opponent_piece(
right_pawn) and self.board.piece(
right_pawn.row, right_pawn.column
) == self.__chess_match.en_passant_vulnerable:
mat[right_pawn.row - 1][right_pawn.column] = True
else:
# Movimento para cima (1 casa)
p = Position(self._position.row + 1, self._position.column)
if self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(p):
mat[p.row][p.column] = True
# Movimento para cima (2 casa)
p = Position(self._position.row + 2, self._position.column)
p2 = Position(self._position.row + 1, self._position.column)
if self.board.is_position_exists(
p.row, p.column) and not self.board.is_there_a_piece(
p) and self.board.is_position_exists(
p2.row,
p2.column) and not self.board.is_there_a_piece(
p2) and self.move_count == 0:
mat[p.row][p.column] = True
# Movimento para comer peça adversária (esquerda)
p = Position(self._position.row + 1, self._position.column - 1)
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimento para comer peça adversária (direita)
p = Position(self._position.row + 1, self._position.column + 1)
if self.board.is_position_exists(
p.row, p.column) and self._is_there_opponent_piece(p):
mat[p.row][p.column] = True
# Movimento especial en passant
if self._position.row == 4:
left_pawn = Position(self._position.row,
self._position.column - 1)
if self.board.is_position_exists(
left_pawn.row,
left_pawn.column) and self._is_there_opponent_piece(
left_pawn) and self.board.piece(
left_pawn.row, left_pawn.column
) == self.__chess_match.en_passant_vulnerable:
mat[left_pawn.row + 1][left_pawn.column] = True
right_pawn = Position(self._position.row,
self._position.column + 1)
if self.board.is_position_exists(
right_pawn.row,
right_pawn.column) and self._is_there_opponent_piece(
right_pawn) and self.board.piece(
right_pawn.row, right_pawn.column
) == self.__chess_match.en_passant_vulnerable:
mat[right_pawn.row + 1][right_pawn.column] = True
return mat
def _to_position(self):
return Position(8 - self.__row, ord(self.__column) - ord('a'))