class Queen: def __init__(self, piece_moving): self.utils = Utils() self.piece_moving = piece_moving def move_is_possible(self, start_tag, end_tag, max_turn, all_turns_pieces_position, piece=None): return end_tag in self.get_all_allowed_moves( start_tag=start_tag, max_turn=max_turn, all_turns_pieces_position=all_turns_pieces_position) def get_all_allowed_moves(self, start_tag, max_turn, all_turns_pieces_position, piece=None): current_coordinate_number = int( self.utils.get_current_number(start_tag)) print(f"current_coordinate_number: {current_coordinate_number}") current_coordinate_letter = self.utils.get_current_letter(start_tag) print(f"current_coordinate_letter: {current_coordinate_letter}") vertical_moves = Rook(self.piece_moving).get_vertical_moves_possible( current_coordinate_letter=current_coordinate_letter, current_coordinate_number=current_coordinate_number, pieces_position=all_turns_pieces_position[max_turn]) horizontal_moves = Rook( self.piece_moving).get_horizontal_moves_possible( current_coordinate_letter=current_coordinate_letter, current_coordinate_number=current_coordinate_number, pieces_position=all_turns_pieces_position[max_turn]) up_rightwards = Bishop(self.piece_moving).move_up_rightwards( current_coordinate_letter=current_coordinate_letter, current_coordinate_number=current_coordinate_number, pieces_position=all_turns_pieces_position[max_turn]) up_leftwards = Bishop(self.piece_moving).move_up_leftwards( current_coordinate_letter=current_coordinate_letter, current_coordinate_number=current_coordinate_number, pieces_position=all_turns_pieces_position[max_turn]) down_leftwards = Bishop(self.piece_moving).move_down_leftwards( current_coordinate_letter=current_coordinate_letter, current_coordinate_number=current_coordinate_number, pieces_position=all_turns_pieces_position[max_turn]) down_rightwards = Bishop(self.piece_moving).move_down_rightwards( current_coordinate_letter=current_coordinate_letter, current_coordinate_number=current_coordinate_number, pieces_position=all_turns_pieces_position[max_turn]) all_moves = vertical_moves + horizontal_moves + up_rightwards + up_leftwards + down_leftwards + down_rightwards print(all_moves) return all_moves
class Knight: def __init__(self, piece_moving): self.utils = Utils() self.piece_moving = piece_moving def move_is_possible(self, start_tag, end_tag, all_turns_pieces_position, max_turn): return end_tag in self.get_all_allowed_moves( start_tag=start_tag, all_turns_pieces_position=all_turns_pieces_position, max_turn=max_turn) def get_all_allowed_moves(self, start_tag, max_turn, all_turns_pieces_position, piece=None): current_coordinate_number = int( self.utils.get_current_number(start_tag)) print(f"current_coordinate_number: {current_coordinate_number}") current_coordinate_letter = self.utils.get_current_letter(start_tag) print(f"current_coordinate_letter: {current_coordinate_letter}") current_letter_number = self.utils.letter_to_number( current_coordinate_letter) all_moves = [] """ Combinations by 2 up """ if current_coordinate_number + 2 in range(1, 9): """ Try 2 down, 1 right """ if current_letter_number + 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 1)}{current_coordinate_number + 2}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Try 2 down, 1 left """ if current_letter_number - 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 1)}{current_coordinate_number + 2}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Combinations by 2 down """ if current_coordinate_number - 2 in range(1, 9): """ Try 2 down, 1 right """ if current_letter_number + 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 1)}{current_coordinate_number - 2}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Try 2 down, 1 left """ if current_letter_number - 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 1)}{current_coordinate_number - 2}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Combinations by 2 right""" if current_letter_number + 2 in range(1, 9): """ Try 2 right, 1 up """ if current_coordinate_number + 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 2)}{current_coordinate_number + 1}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Try 2 right, 1 down """ if current_coordinate_number - 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 2)}{current_coordinate_number - 1}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Combinations by 2 left""" if current_letter_number - 2 in range(1, 9): """ Try 2 left, 1 up """ if current_coordinate_number + 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 2)}{current_coordinate_number + 1}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) """ Try 2 left, 1 down """ if current_coordinate_number - 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 2)}{current_coordinate_number - 1}" if (self.utils.end_position_is_free( move, all_turns_pieces_position[max_turn]) or (self.utils.end_position_contains_opponent_piece( self.piece_moving, move, all_turns_pieces_position[max_turn]))): all_moves.append(move) print(all_moves) return all_moves
class King: def __init__(self, piece_moving): self.utils = Utils() self.piece_moving = piece_moving def move_is_possible(self, start_tag, end_tag, all_turns_pieces_position, max_turn): return end_tag in self.get_all_allowed_moves( start_tag=start_tag, max_turn=max_turn, all_turns_pieces_position=all_turns_pieces_position) def get_all_allowed_moves(self, start_tag, all_turns_pieces_position, max_turn, piece=None): current_coordinate_number = int( self.utils.get_current_number(start_tag)) print(f"current_coordinate_number: {current_coordinate_number}") current_coordinate_letter = self.utils.get_current_letter(start_tag) print(f"current_coordinate_letter: {current_coordinate_letter}") all_moves = self.horizontal_moves(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) + \ self.vertical_moves(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) + \ self.diagonal_moves(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) print(all_moves) return all_moves def horizontal_moves(self, number, letter, pieces_position): moves = [] current_letter_number = self.utils.letter_to_number(letter) if current_letter_number + 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 1)}{number}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) if current_letter_number - 1 in range(1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 1)}{number}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) return moves def vertical_moves(self, number, letter, pieces_position): moves = [] if number + 1 in range(1, 9): move = f"{letter}{number + 1}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) if number - 1 in range(1, 9): move = f"{letter}{number - 1}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) return moves def diagonal_moves(self, number, letter, pieces_position): moves = [] current_letter_number = self.utils.letter_to_number(letter) """ Up - rightwards: letter + 1, number + 1 """ if current_letter_number + 1 in range(1, 9) and number + 1 in range( 1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 1)}{number + 1}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) """ down - leftwards: letter - 1, number - 1 """ if current_letter_number - 1 in range(1, 9) and number - 1 in range( 1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 1)}{number - 1}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) """ up - leftwards: letter - 1, number + 1 """ if current_letter_number - 1 in range(1, 9) and number + 1 in range( 1, 9): move = f"{self.utils.number_to_letter(current_letter_number - 1)}{number + 1}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) """ down - rightwards: letter + 1, number - 1 """ if current_letter_number + 1 in range(1, 9) and number - 1 in range( 1, 9): move = f"{self.utils.number_to_letter(current_letter_number + 1)}{number - 1}" if (self.utils.end_position_is_free(move, pieces_position)) or ( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position)): moves.append(move) return moves
class Pawn: def __init__(self, piece_moving): self.piece_moving = piece_moving self.utils = Utils() def move_is_possible(self, start_tag, end_tag, all_turns_pieces_position, max_turn): return end_tag in self.get_all_allowed_moves( start_tag, all_turns_pieces_position, max_turn) def get_all_allowed_moves(self, start_tag, all_turns_pieces_position, max_turn, piece=None): current_coordinate_number = int( self.utils.get_current_number(start_tag)) current_coordinate_letter = self.utils.get_current_letter(start_tag) print(f"max_turn: {max_turn}") print(f"all_turns_pieces_position: {all_turns_pieces_position}") current_pieces_position = all_turns_pieces_position[max_turn] all_moves = [] if self.utils.is_white_moving(self.piece_moving): if current_coordinate_number == 2: if current_coordinate_number + 2 in range(1, 9): possible_move_coordinate = f"{current_coordinate_letter}{current_coordinate_number + 2}" in_between_coordinate = f"{current_coordinate_letter}{current_coordinate_number + 1}" if (self.utils.end_position_is_free( possible_move_coordinate, current_pieces_position) ) and (self.utils.end_position_is_free( in_between_coordinate, current_pieces_position)): all_moves.append(possible_move_coordinate) if current_coordinate_number + 1 in range(1, 9): possible_move_coordinate = f"{current_coordinate_letter}{current_coordinate_number + 1}" if self.utils.end_position_is_free(possible_move_coordinate, current_pieces_position): all_moves.append(possible_move_coordinate) else: if current_coordinate_number == 7: if current_coordinate_number - 2 in range(1, 9): in_between_coordinate = f"{current_coordinate_letter}{current_coordinate_number - 1}" possible_move_coordinate = f"{current_coordinate_letter}{current_coordinate_number - 2}" if (self.utils.end_position_is_free( possible_move_coordinate, current_pieces_position) ) and (self.utils.end_position_is_free( in_between_coordinate, current_pieces_position)): all_moves.append(possible_move_coordinate) if current_coordinate_number - 1 in range(1, 9): possible_move_coordinate = f"{current_coordinate_letter}{current_coordinate_number - 1}" if self.utils.end_position_is_free(possible_move_coordinate, current_pieces_position): all_moves.append(possible_move_coordinate) all_moves = all_moves + \ self.take_diagonally_up(current_coordinate_number, current_coordinate_letter, current_pieces_position) en_passant_moves = list( self.en_passant(start_tag, all_turns_pieces_position, max_turn).keys()) if len(en_passant_moves) > 0: all_moves += en_passant_moves print(f"all pown moves: {all_moves}") return all_moves def en_passant(self, start_tag, all_turns_pieces_position, max_turn): output = {} if max_turn == 0: return output number = int(self.utils.get_current_number(start_tag)) letter = self.utils.get_current_letter(start_tag) current_pieces_position = all_turns_pieces_position[max_turn] previous_turn_pieces_position = all_turns_pieces_position[max_turn - 1] current_letter_number = self.utils.letter_to_number(letter) start_number_required = 4 en_passant_move_number = number - 1 if self.utils.is_white_moving(self.piece_moving): start_number_required = 5 en_passant_move_number = number + 1 previous_turn_number_required = number - 2 if self.utils.is_white_moving(self.piece_moving): previous_turn_number_required = number + 2 if number == start_number_required and (current_letter_number in range( 2, 9)): same_line_left = f"{self.utils.number_to_letter(current_letter_number - 1)}{number}" piece_to_remove = same_line_left en_passant_move = f"{self.utils.number_to_letter(current_letter_number - 1)}{en_passant_move_number}" potential_initial_opponent_position = f"{self.utils.number_to_letter(current_letter_number - 1)}" \ f"{previous_turn_number_required}" print(f"piece_to_remove on left: {piece_to_remove}") if ((same_line_left in all_turns_pieces_position[max_turn]) and (self.utils.end_position_contains_opponent_piece( self.piece_moving, same_line_left, current_pieces_position)) and (current_pieces_position[same_line_left].lower() == "p") and (potential_initial_opponent_position in previous_turn_pieces_position.keys()) and (previous_turn_pieces_position[ potential_initial_opponent_position].lower() == "p")): output[en_passant_move] = piece_to_remove if number == start_number_required and (current_letter_number in range( 1, 8)): same_line_right = f"{self.utils.number_to_letter(current_letter_number + 1)}{number}" piece_to_remove = same_line_right print(f"piece_to_remove on right: {piece_to_remove}") en_passant_move = f"{self.utils.number_to_letter(current_letter_number + 1)}{en_passant_move_number}" potential_initial_opponent_position = f"{self.utils.number_to_letter(current_letter_number + 1)}" \ f"{previous_turn_number_required}" if ((same_line_right in all_turns_pieces_position[max_turn]) and (self.utils.end_position_contains_opponent_piece( self.piece_moving, same_line_right, current_pieces_position)) and (current_pieces_position[same_line_right].lower() == "p") and (potential_initial_opponent_position in previous_turn_pieces_position.keys()) and (previous_turn_pieces_position[ potential_initial_opponent_position].lower() == "p")): output[en_passant_move] = piece_to_remove return output def take_diagonally_up(self, number, letter, pieces_position): moves = [] current_letter_number = self.utils.letter_to_number(letter) if self.utils.is_white_moving(self.piece_moving): """ Take up left """ if number + 1 in range( 1, 9) and current_letter_number - 1 in range(1, 9): possible_coordinate = f"{self.utils.number_to_letter(current_letter_number - 1)}{number + 1}" if self.utils.end_position_contains_opponent_piece( self.piece_moving, possible_coordinate, pieces_position): moves.append(possible_coordinate) """ Take up right """ if number + 1 in range( 1, 9) and current_letter_number + 1 in range(1, 9): possible_coordinate = f"{self.utils.number_to_letter(current_letter_number + 1)}{number + 1}" if self.utils.end_position_contains_opponent_piece( self.piece_moving, possible_coordinate, pieces_position): moves.append(possible_coordinate) else: """ Take down left """ if number - 1 in range( 1, 9) and current_letter_number - 1 in range(1, 9): possible_coordinate = f"{self.utils.number_to_letter(current_letter_number - 1)}{number - 1}" if self.utils.end_position_contains_opponent_piece( self.piece_moving, possible_coordinate, pieces_position): moves.append(possible_coordinate) """ Take down right """ if number - 1 in range( 1, 9) and current_letter_number + 1 in range(1, 9): possible_coordinate = f"{self.utils.number_to_letter(current_letter_number + 1)}{number - 1}" if self.utils.end_position_contains_opponent_piece( self.piece_moving, possible_coordinate, pieces_position): moves.append(possible_coordinate) return moves
class Bishop: def __init__(self, piece_moving): self.utils = Utils() self.piece_moving = piece_moving def move_is_possible(self, start_tag, end_tag, all_turns_pieces_position, max_turn): print(f"all allowed bshop moves: {self.get_all_allowed_moves(start_tag, all_turns_pieces_position, max_turn)}") return end_tag in self.get_all_allowed_moves(start_tag, all_turns_pieces_position, max_turn) def get_all_allowed_moves(self, start_tag, all_turns_pieces_position, max_turn, piece=None): current_coordinate_number = int(self.utils.get_current_number(start_tag)) current_coordinate_letter = self.utils.get_current_letter(start_tag) all_moves = self.move_up_rightwards(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) + \ self.move_up_leftwards(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) + \ self.move_down_leftwards(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) + \ self.move_down_rightwards(current_coordinate_number, current_coordinate_letter, all_turns_pieces_position[max_turn]) print(f"all bishop moves: {all_moves}") return all_moves def move_up_rightwards(self, current_coordinate_number, current_coordinate_letter, pieces_position): """ Moving diagonally up, toward right upper corner: - Number increases by 1, if within range 1, 8 and next square is free . - Letter 'increases' by 1, if within range 1, 8 """ possible_moves = [] current_number = current_coordinate_number current_letter_number = self.utils.letter_to_number(current_coordinate_letter) while (current_number + 1 in range(1, 9)) and (current_letter_number + 1 in range(1, 9)): possible_move_coordinate = f"{self.utils.number_to_letter(current_letter_number + 1)}{current_number + 1}" if self.utils.end_position_is_free(possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) current_number += 1 current_letter_number += 1 elif self.utils.end_position_contains_opponent_piece(self.piece_moving, possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) break else: break return possible_moves def move_up_leftwards(self, current_coordinate_number, current_coordinate_letter, pieces_position): """ Moving diagonally up, toward left upper corner: - Number increases by 1, if within range 1, 8. - Letter 'decreases' by 1, if within range 1, 8 """ possible_moves = [] current_number = current_coordinate_number current_letter_number = self.utils.letter_to_number(current_coordinate_letter) while current_number + 1 in range(1, 9) and current_letter_number - 1 in range(1, 9): possible_move_coordinate = f"{self.utils.number_to_letter(current_letter_number - 1)}{current_number + 1}" if self.utils.end_position_is_free(possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) current_number += 1 current_letter_number -= 1 elif self.utils.end_position_contains_opponent_piece(self.piece_moving, possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) break else: break return possible_moves def move_down_leftwards(self, current_coordinate_number, current_coordinate_letter, pieces_position): """ Moving diagonally up, toward left upper corner: - Number decreases by 1, if within range 1, 8. - Letter 'decreases' by 1, if within range 1, 8 """ possible_moves = [] current_number = current_coordinate_number current_letter_number = self.utils.letter_to_number(current_coordinate_letter) while current_number - 1 in range(1, 9) and current_letter_number - 1 in range(1, 9): possible_move_coordinate = f"{self.utils.number_to_letter(current_letter_number - 1)}{current_number - 1}" if self.utils.end_position_is_free(possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) current_number -= 1 current_letter_number -= 1 elif self.utils.end_position_contains_opponent_piece(self.piece_moving, possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) break else: break return possible_moves def move_down_rightwards(self, current_coordinate_number, current_coordinate_letter, pieces_position): """ Moving diagonally up, toward left upper corner: - Number decreases by 1, if within range 1, 8. - Letter 'increases' by 1, if within range 1, 8 """ possible_moves = [] current_number = current_coordinate_number current_letter_number = self.utils.letter_to_number(current_coordinate_letter) while current_number - 1 in range(1, 9) and current_letter_number + 1 in range(1, 9): possible_move_coordinate = f"{self.utils.number_to_letter(current_letter_number + 1)}{current_number - 1}" if self.utils.end_position_is_free(possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) current_number -= 1 current_letter_number += 1 elif self.utils.end_position_contains_opponent_piece(self.piece_moving, possible_move_coordinate, pieces_position): possible_moves.append(possible_move_coordinate) break else: break return possible_moves
class Rook: def __init__(self, piece_moving): self.utils = Utils() self.piece_moving = piece_moving def move_is_possible(self, start_tag, end_tag, all_turns_pieces_position, max_turn): return end_tag in self.get_all_allowed_moves( start_tag=start_tag, all_turns_pieces_position=all_turns_pieces_position, max_turn=max_turn) def get_all_allowed_moves(self, start_tag, all_turns_pieces_position, max_turn, piece=None): """ Rook can only move vertically or horizontally. Returns combination of all theoretically possible vertical or horizontal moves. """ current_coordinate_number = int( self.utils.get_current_number(start_tag)) current_coordinate_letter = self.utils.get_current_letter(start_tag) vertical_moves = self.get_vertical_moves_possible( current_coordinate_letter, current_coordinate_number, all_turns_pieces_position[max_turn]) horizontal_moves = self.get_horizontal_moves_possible( current_coordinate_letter, current_coordinate_number, all_turns_pieces_position[max_turn]) all_moves = vertical_moves + horizontal_moves print(f"all rook moves: {all_moves}") return all_moves def get_horizontal_moves_possible(self, current_coordinate_letter, current_coordinate_number, pieces_position): """ Horizontal move: letter changes, number remains the same. """ start_tag_letter_number = int( self.utils.letter_to_number(current_coordinate_letter)) # print("start_tag_letter_number: {}".format(start_tag_letter_number)) # print("end_tag_letter_number: {}".format(end_tag_letter_number)) possible_moves = [] if 1 <= start_tag_letter_number < 8: """ Look at available moves to the right """ for i in range(start_tag_letter_number + 1, 9, +1): # print("i: {}".format(i)) move = f"{self.utils.number_to_letter(i)}{current_coordinate_number}" print(f"move: {move}") if self.utils.end_position_is_free(move, pieces_position): print( f"self.utils.end_position_is_free(move, pieces_position): {self.utils.end_position_is_free(move, pieces_position)}" ) possible_moves.append(move) elif self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position): print( f"self.utils.end_position_contains_opponent_piece(self.piece_moving, move, pieces_position): {self.utils.end_position_contains_opponent_piece(self.piece_moving, move, pieces_position)}" ) possible_moves.append(move) break else: break if 1 < start_tag_letter_number <= 8: """ Look at available moves to the left """ for i in range(start_tag_letter_number - 1, 0, -1): move = f"{self.utils.number_to_letter(i)}{current_coordinate_number}" # print(move) if self.utils.end_position_is_free(move, pieces_position): print( "self.utils.end_position_is_free(move, pieces_position): {}" .format( self.utils.end_position_is_free( move, pieces_position))) possible_moves.append(move) elif self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position): print( "self.utils.end_position_contains_opponent_piece(self.piece_moving, move, pieces_position): {}" .format( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position))) possible_moves.append(move) break else: break return possible_moves def get_vertical_moves_possible(self, current_coordinate_letter, current_coordinate_number, pieces_position): """ Vertical move: letter stays the same, number can increase or decrease. """ possible_moves = [] if 1 <= current_coordinate_number < 8: """ Look at available moves upwards """ # print("end_tag_letter_number > start_tag_letter_number: {}".format(end_tag_letter_number > start_tag_letter_number)) for i in range(current_coordinate_number + 1, 9, +1): # print("i: {}".format(i)) move = f"{current_coordinate_letter}{i}" print(f"move: {move}") if self.utils.end_position_is_free(move, pieces_position): print( f"self.utils.end_position_is_free(move, pieces_position): {self.utils.end_position_is_free(move, pieces_position)}" ) possible_moves.append(move) elif self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position): print( f"self.utils.end_position_contains_opponent_piece(self.piece_moving, move, pieces_position): {self.utils.end_position_contains_opponent_piece(self.piece_moving, move, pieces_position)}" ) possible_moves.append(move) break else: break if 1 < current_coordinate_number <= 8: """ Look at available moves downwards """ # print("end_tag_letter_number < start_tag_letter_number") for i in range(current_coordinate_number - 1, 0, -1): move = "{}{}".format(current_coordinate_letter, i) # print(move) if self.utils.end_position_is_free(move, pieces_position): print( "self.utils.end_position_is_free(move, pieces_position): {}" .format( self.utils.end_position_is_free( move, pieces_position))) possible_moves.append(move) elif self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position): print( "self.utils.end_position_contains_opponent_piece(self.piece_moving, move, pieces_position): {}" .format( self.utils.end_position_contains_opponent_piece( self.piece_moving, move, pieces_position))) possible_moves.append(move) break else: break return possible_moves