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 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 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 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