def get_long_castling_move(self, board):
if (self.color == Piece.WHITE and board.white_king_moved):
return 0
if (self.color == Piece.BLACK and board.black_king_moved):
return 0
piece = board.get_piece(self.x - 4, self.y)
if (piece != 0):
if (piece.color == self.color
and piece.piece_type == Rook.PIECE_TYPE):
if (board.get_piece(self.x - 1, self.y) == 0
and board.get_piece(self.x - 2, self.y) == 0
and board.get_piece(self.x - 3,
self.y) == 0): #1st condition
#The 2nd condition break the IA, if commented the IA will stop crushing
#This may be due to the amount of memory
#if( not board.is_check(self.color) ): #2nd condition
if (not (self.moved)
and not (piece.moved)): #3nd condition
if (board.imaginary_check(self.color, self.x - 1,
self.y) == False
and board.imaginary_check(
self.color, self.x - 2, self.y) == False
and board.imaginary_check(
self.color, self.x - 3,
self.y) == False): #4th condition
#print("You can performe Long castling")
return ai.Move(self.x, self.y, self.x - 2, self.y,
True)
return 0
def get_possible_horizontal_moves(self, board):
moves = []
# Moves to the right of the piece.
for i in range(1, 8 - self.x):
piece = board.get_piece(self.x + i, self.y)
moves.append(self.get_move(board, self.x + i, self.y))
if (piece != 0):
break
# Moves to the left of the piece.
for i in range(1, self.x + 1):
piece = board.get_piece(self.x - i, self.y)
moves.append(self.get_move(board, self.x - i, self.y))
if (piece != 0):
break
# Downward moves.
for i in range(1, 8 - self.y):
piece = board.get_piece(self.x, self.y + i)
moves.append(self.get_move(board, self.x, self.y + i))
if (piece != 0):
break
# Upward moves.
for i in range(1, self.y + 1):
piece = board.get_piece(self.x, self.y - i)
moves.append(self.get_move(board, self.x, self.y - i))
if (piece != 0):
break
return self.remove_null_from_list(moves)
def get_short_castling_move(self, board):
if (self.color == Piece.WHITE and board.white_king_moved):
return 0
if (self.color == Piece.BLACK and board.black_king_moved):
return 0
piece = board.get_piece(self.x + 3, self.y)
if (piece != 0):
if (piece.color == self.color
and piece.piece_type == Rook.PIECE_TYPE):
if (board.get_piece(self.x + 1, self.y) == 0
and board.get_piece(self.x + 2,
self.y) == 0): #1st condition
if (not board.is_check(self.color)): #2nd condition
if (not (self.moved)
and not (piece.moved)): #3nd condition
if (board.imaginary_check(self.color, self.x + 1,
self.y) == False
and board.imaginary_check(
self.color, self.x + 2,
self.y) == False): #4th condition
#print("You can performe Short castling")
return ai.Move(self.x, self.y, self.x + 2,
self.y, True)
return 0
def get_possible_horizontal_moves(self, board):
moves = []
# Right
for i in range(1, 8 - self.x):
piece = board.get_piece(self.x + i, self.y)
moves.append(self.get_move(board, self.x + i, self.y))
if (piece != 0):
break
# Left
for i in range(1, self.x + 1):
piece = board.get_piece(self.x - i, self.y)
moves.append(self.get_move(board, self.x - i, self.y))
if (piece != 0):
break
# Down
for i in range(1, 8 - self.y):
piece = board.get_piece(self.x, self.y + i)
moves.append(self.get_move(board, self.x, self.y + i))
if (piece != 0):
break
# Up
for i in range(1, self.y + 1):
piece = board.get_piece(self.x, self.y - i)
moves.append(self.get_move(board, self.x, self.y - i))
if (piece != 0):
break
return self.remove_null_from_list(moves)
def step_possible(self, pieces, column_step_multiplier, row_step_multiplier, step_limit=None, allow_capture=True, allow_non_capture=True):
moves = []
while True:
try_steps = len(moves) + 1
column = self.column + try_steps * column_step_multiplier
row = self.row + try_steps * row_step_multiplier
box = board.get_box(row, column)
capture = board.get_piece(pieces, box)
move = board.get_move(self, box, capture, None)
if not (0 <= row <= 7) or not (0 <= column <= 7):
break
piece = board.get_piece(pieces, box)
if piece and piece.color != self.color and allow_capture:
moves.append(move)
break
if not piece and allow_non_capture:
moves.append(move)
if step_limit and len(moves) >= step_limit:
break
else:
break
return moves
def get_possible_moves(self, board):
moves = []
# Direction the pawn can move in.
direction = -1
if (self.color == Piece.BLACK):
direction = 1
# The general 1 step forward move.
if (board.get_piece(self.x, self.y + direction) == 0):
moves.append(self.get_move(board, self.x, self.y + direction))
# The Pawn can take 2 steps as the first move.
if (self.is_starting_position()
and board.get_piece(self.x, self.y + direction) == 0
and board.get_piece(self.x, self.y + direction * 2) == 0):
moves.append(self.get_move(board, self.x, self.y + direction * 2))
# Eating pieces.
piece = board.get_piece(self.x + 1, self.y + direction)
if (piece != 0):
moves.append(self.get_move(board, self.x + 1, self.y + direction))
piece = board.get_piece(self.x - 1, self.y + direction)
if (piece != 0):
moves.append(self.get_move(board, self.x - 1, self.y + direction))
return self.remove_null_from_list(moves)
def get_bottom_castling_move(self, board):
if (self.color == Piece.WHITE and board.white_king_moved):
return 0
if (self.color == Piece.BLACK and board.black_king_moved):
return 0
piece = board.get_piece(self.x, self.y+4)
if (piece != 0):
if (piece.color == self.color and piece.piece_type == Rook.PIECE_TYPE):
if (board.get_piece(self.x, self.y+1) == 0 and board.get_piece(self.x, self.y+2) == 0 and board.get_piece(self.x, self.y+3) == 0):
return ai.Move(self.x, self.y, self.x, self.y+2, True)
return 0
def moveIsTaken(self, board: board.Board, row: int, column: int) -> bool:
"checks if move is empty on the board"
piece = board.get_piece(row, column)
if piece.get_kind() == '.':
return False
else:
return True
def handle_turn(self, pieces, turn, click, enemy):
if not click:
return
selected_move = None
for move in self.possible_from_selected:
if move['box'] == click:
selected_move = move
break
if selected_move:
self.selected = None
self.possible_from_selected = []
turn(selected_move)
else:
piece = board.get_piece(pieces, click)
if piece and piece.color == self.color:
self.selected = click
self.possible_from_selected = [
move
for move in filter(lambda move: move['piece'] == piece,
self.possible_moves)
]
else:
self.selected = None
self.possible_from_selected = []
def get_move(self, board, xto, yto):
move = 0
if (board.in_bounds(xto, yto)):
piece = board.get_piece(xto, yto)
if (piece != 0):
if (piece.color != self.color):
move = ai.Move(self.x, self.y, xto, yto, False)
else:
move = ai.Move(self.x, self.y, xto, yto, False)
return move
def get_possible_diagonal_moves(self, board):
moves = []
for i in range(1, 8):
if (not board.in_bounds(self.x + i, self.y + i)):
break
piece = board.get_piece(self.x + i, self.y + i)
moves.append(self.get_move(board, self.x + i, self.y + i))
if (piece != 0):
break
for i in range(1, 8):
if (not board.in_bounds(self.x + i, self.y - i)):
break
piece = board.get_piece(self.x + i, self.y - i)
moves.append(self.get_move(board, self.x + i, self.y - i))
if (piece != 0):
break
for i in range(1, 8):
if (not board.in_bounds(self.x - i, self.y - i)):
break
piece = board.get_piece(self.x - i, self.y - i)
moves.append(self.get_move(board, self.x - i, self.y - i))
if (piece != 0):
break
for i in range(1, 8):
if (not board.in_bounds(self.x - i, self.y + i)):
break
piece = board.get_piece(self.x - i, self.y + i)
moves.append(self.get_move(board, self.x - i, self.y + i))
if (piece != 0):
break
return self.remove_null_from_list(moves)
def allyFoundAtLineEnd(self, board: board.Board, enemy_line: list,
row_delta: int, col_delta: int,
ally_kind: str) -> bool:
"used in get flippable enemies function"
last_piece = enemy_line[len(enemy_line) - 1]
search_row = last_piece.get_row() + row_delta
search_col = last_piece.get_col() + col_delta
if not rules.Rules().moveIsOnGrid(board, search_row, search_col):
return False
piece = board.get_piece(search_row, search_col)
if not piece.get_kind() == ally_kind:
return False
return True
def getAdjacentPieces(self, board: board.Board, row: int,
column: int) -> list:
"list of all adjacent pieces givent a row,column coordinate"
pieces = []
for i in range(3):
row_delta = i - 1
for j in range(3):
col_delta = j - 1
search_row = row + row_delta
search_col = column + col_delta
if (rules.Rules().moveIsOnGrid(board, search_row, search_col)):
piece = board.get_piece(search_row, search_col)
pieces.append(piece)
return pieces
def possible_moves(self, pieces):
possible_moves = []
possible_moves += self.step_possible(pieces, 1, 0, 1)
possible_moves += self.step_possible(pieces, -1, 0, 1)
possible_moves += self.step_possible(pieces, 0, 1, 1)
possible_moves += self.step_possible(pieces, 0, -1, 1)
possible_moves += self.step_possible(pieces, 1, 1, 1)
possible_moves += self.step_possible(pieces, 1, -1, 1)
possible_moves += self.step_possible(pieces, -1, 1, 1)
possible_moves += self.step_possible(pieces, -1, -1, 1)
if not self.has_moved:
castle_rooks = []
row = 0 if self.color == PieceColor.BLACK else 7
for piece in pieces:
if piece.color == self.color and piece.piece_type == PieceType.ROOK and not piece.has_moved:
castle_rooks.append(piece)
for rook in castle_rooks:
lowest_column = min(rook.column + 1, self.column + 1)
highest_column = max(rook.column, self.column)
possible = True
for column in range(lowest_column, highest_column):
piece = board.get_piece(pieces, board.get_box(row, column))
if piece:
possible = False
break
if board.is_chess(
board.pieces_after_move(
pieces,
board.get_move(self,
board.get_box(row, column),
None, None)), self.color):
possible = False
break
if possible:
direction = 1 if self.column < rook.column else -1
extra_move = board.get_move(
rook,
board.get_box(
row, self.column + direction * 2 + direction * -1),
None, None)
move = board.get_move(
self, board.get_box(row, self.column + direction * 2),
None, extra_move)
possible_moves.append(move)
return possible_moves
def possible_moves(self, pieces):
direction = -1 if self.color == PieceColor.WHITE else 1
steps = 2 if not self.has_moved else 1
moves = []
moves += self.step_possible(pieces, 0, direction, steps, False)
moves += self.step_possible(pieces, 1, direction, 1, True, False)
moves += self.step_possible(pieces, -1, direction, 1, True, False)
if self.row == (3 if direction == -1 else 4):
to_right = board.get_piece(
pieces, board.get_box(self.row, self.column + 1))
if to_right and to_right.color != self.color and to_right.piece_type == PieceType.PAWN and to_right.can_be_en_passented:
move = self.step_possible(pieces, 1, direction, 1, False)[0]
move['capture'] = to_right
moves.append(move)
to_left = board.get_piece(pieces,
board.get_box(self.row, self.column - 1))
if to_left and to_left.color != self.color and to_left.piece_type == PieceType.PAWN and to_left.can_be_en_passented:
move = self.step_possible(pieces, -1, direction, 1, False)[0]
move['capture'] = to_left
moves.append(move)
return moves
def get_possible_moves(self, board):
moves = []
direction = -1
if (self.color == Piece.BLACK):
direction = 1
if (board.get_piece(self.x, self.y + direction) == 0):
moves.append(self.get_move(board, self.x, self.y + direction))
if (self.is_starting_position()
and board.get_piece(self.x, self.y + direction) == 0
and board.get_piece(self.x, self.y + direction * 2) == 0):
moves.append(self.get_move(board, self.x, self.y + direction * 2))
piece = board.get_piece(self.x + 1, self.y + direction)
if (piece != 0):
moves.append(self.get_move(board, self.x + 1, self.y + direction))
piece = board.get_piece(self.x - 1, self.y + direction)
if (piece != 0):
moves.append(self.get_move(board, self.x - 1, self.y + direction))
return self.remove_null_from_list(moves)
def getAllMoves(self, board: board.Board, enemy_kind, ally_kind) -> list:
"list of all available moves pieces on ally_kind"
move = []
for row in range(board.get_rows()):
for col in range(board.get_columns()):
if rules.Rules().moveIsTaken(board, row, col) == True:
continue
if rules.Rules().moveIsOnGrid(board, row, col) == False:
continue
if rules.Rules().moveHasFlippableEnemies(
board, row, col, ally_kind, enemy_kind) == False:
continue
move.append(board.get_piece(row, col))
return move
def getEnemiesInLine(self, board: board.Board, first_enemy: piece.Piece,
row_delta: int, col_delta: int) -> list:
'runs at least once and updates the current piece at the end of looop'
"used in getFlippableEnemies"
pieces = []
current_piece = first_enemy
while True:
if not current_piece.get_kind() == first_enemy.get_kind():
break
pieces.append(current_piece)
search_row = current_piece.get_row() + row_delta
search_col = current_piece.get_col() + col_delta
if not rules.Rules().moveIsOnGrid(board, search_row, search_col):
break
current_piece = board.get_piece(search_row, search_col)
return pieces
