245 lines
11 KiB
Python
245 lines
11 KiB
Python
from square import Square
|
|
from pawn import Pawn
|
|
from knight import Knight
|
|
from bishop import Bishop
|
|
from rook import Rook
|
|
from queen import Queen
|
|
from king import King
|
|
import random
|
|
|
|
class Board:
|
|
def __init__(self):
|
|
self.boardlist = [[0, 0, 0, 0, 0, 0, 0, 0] for x in range(8)]
|
|
#creating board
|
|
for row in range(8):
|
|
for column in range(8):
|
|
self.boardlist[row][column] = Square(row, column)
|
|
self._add_pieces('white')
|
|
self._add_pieces('black')
|
|
|
|
def _add_pieces(self, color):
|
|
if color == 'white':
|
|
self.pawn_row = 6
|
|
self.other_row = 7
|
|
else:
|
|
self.pawn_row = 1
|
|
self.other_row = 0
|
|
#pawns
|
|
#self.boardlist[5][1] = Square(5, 1, King(color)) #DO USUNIĘCIA
|
|
for column in range(8):
|
|
self.boardlist[self.pawn_row][column] = Square(self.pawn_row, column, Pawn(color)) #do kazdego square przypisuje poczatkowy pawn
|
|
#rooks
|
|
self.boardlist[self.other_row][0] = Square(self.other_row, 0, Rook(color))
|
|
self.boardlist[self.other_row][7] = Square(self.other_row, 7, Rook(color))
|
|
#knigths
|
|
self.boardlist[self.other_row][1] = Square(self.other_row, 1, Knight(color))
|
|
self.boardlist[self.other_row][6] = Square(self.other_row, 6, Knight(color))
|
|
#bishops
|
|
self.boardlist[self.other_row][2] = Square(self.other_row, 2, Bishop(color))
|
|
self.boardlist[self.other_row][5] = Square(self.other_row, 5, Bishop(color))
|
|
#queen
|
|
self.boardlist[self.other_row][3] = Square(self.other_row, 3, Queen(color))
|
|
#king
|
|
self.boardlist[self.other_row][4] = Square(self.other_row, 4, King(color))
|
|
|
|
def calc_moves(self, piece, row, column):
|
|
def knight_moves():
|
|
#piece.delete_moves()
|
|
self.possible_moves = [
|
|
(row + 2, column - 1),
|
|
(row + 2, column + 1),
|
|
(row + 1, column + 2),
|
|
(row - 1, column + 2),
|
|
(row - 2, column + 1),
|
|
(row - 2, column - 1),
|
|
(row - 1, column - 2),
|
|
(row + 1, column - 2)
|
|
]
|
|
for self.possible_move in self.possible_moves:
|
|
self.possible_row, self.possible_column = self.possible_move
|
|
if Square.on_board(self.possible_row, self.possible_column):
|
|
if self.boardlist[self.possible_row][self.possible_column].empty_or_rival(piece.color):
|
|
self.final = (self.possible_row, self.possible_column)
|
|
piece.add_moves(self.final)
|
|
def pawn_moves():
|
|
#piece.delete_moves()
|
|
if piece.moved == True:
|
|
self.steps = 1
|
|
else:
|
|
self.steps = 2
|
|
|
|
if self.steps == 2:
|
|
self.final = row + (piece.pawn_direction * (self.steps))
|
|
self.previous = row + (piece.pawn_direction * (self.steps - 1))
|
|
if Square.on_board(self.final, column) is True:
|
|
if self.boardlist[self.final][column].has_piece() is False:
|
|
if self.boardlist[self.previous][column].has_piece() is False:
|
|
piece.add_moves((self.final, column))
|
|
self.steps = 1
|
|
self.final = row + (piece.pawn_direction * (self.steps))
|
|
#problem z wierszem
|
|
#if self.final>7 or self.final<0 or column>7 or column <0:
|
|
#print(piece.name)
|
|
#print(self.final, column)
|
|
if Square.on_board(self.final, column) is True and self.boardlist[self.final][column].has_piece() is False:
|
|
piece.add_moves((self.final, column))
|
|
|
|
#diagonal
|
|
#czy wychodzi poza tablice i czy stoi rywal
|
|
self.possible_row = row + piece.pawn_direction
|
|
self.possible_columns = []
|
|
self.possible_columns = [column-1, column+1]
|
|
for possible_column in self.possible_columns:
|
|
if Square.on_board(self.possible_row, possible_column) is True:
|
|
if self.boardlist[self.possible_row][possible_column].is_rival(piece.color) is True:
|
|
piece.add_moves((self.possible_row, possible_column))
|
|
def straightline_moves(isvertical):
|
|
if isvertical is True:
|
|
self.direction = [
|
|
(0, 1),
|
|
(0, -1),
|
|
(1, 0),
|
|
(-1, 0)]
|
|
else:
|
|
self.direction = [
|
|
(1, 1),
|
|
(-1, -1),
|
|
(1, -1),
|
|
(-1, 1)
|
|
]
|
|
for dir in self.direction:
|
|
self.left, self.right = dir
|
|
self.possible_row = row + self.left
|
|
self.possible_column = column + self.right
|
|
while True:
|
|
if Square.on_board(self.possible_row, self.possible_column) is True:
|
|
if self.boardlist[self.possible_row][self.possible_column].has_piece() is False:
|
|
piece.add_moves((self.possible_row, self.possible_column))
|
|
self.possible_row = self.possible_row + self.left
|
|
self.possible_column = self.possible_column + self.right
|
|
elif self.boardlist[self.possible_row][self.possible_column].is_rival(piece.color) is True:
|
|
piece.add_moves((self.possible_row, self.possible_column))
|
|
break
|
|
else:
|
|
break
|
|
else:
|
|
break
|
|
def king_moves():
|
|
#piece.delete_moves()
|
|
self.direction = [
|
|
(0, 1),
|
|
(0, -1),
|
|
(1, 0),
|
|
(-1, 0),
|
|
(1, 1),
|
|
(-1, -1),
|
|
(1, -1),
|
|
(-1, 1)
|
|
]
|
|
for dir in self.direction:
|
|
self.left, self.right = dir
|
|
self.possible_row = row + self.left
|
|
self.possible_column = column + self.right
|
|
if Square.on_board(self.possible_row, self.possible_column) is True:
|
|
if self.boardlist[self.possible_row][self.possible_column].has_piece() is False:
|
|
piece.add_moves((self.possible_row, self.possible_column))
|
|
elif self.boardlist[self.possible_row][self.possible_column].is_rival(piece.color) is True:
|
|
piece.add_moves((self.possible_row, self.possible_column))
|
|
#calculate possible moves for specific piece
|
|
if piece.name == 'rook':
|
|
#piece.delete_moves()
|
|
straightline_moves(True)
|
|
elif piece.name == 'pawn':
|
|
pawn_moves()
|
|
elif piece.name == 'knight':
|
|
knight_moves()
|
|
elif piece.name == 'bishop':
|
|
#piece.delete_moves()
|
|
straightline_moves(False)
|
|
elif piece.name == 'queen':
|
|
#piece.delete_moves()
|
|
straightline_moves(True)
|
|
straightline_moves(False)
|
|
elif piece.name == 'king':
|
|
king_moves()
|
|
def move_rival(self, from_row, from_column, to_row, to_column):
|
|
#update
|
|
self.x = self.board.boardlist[from_row][from_column].piece
|
|
self.board.boardlist[from_row][from_column].piece = None
|
|
if (self.board.boardlist[to_row][to_column].has_piece()):
|
|
if (self.board.boardlist[to_row][to_column].piece.name == 'king'):
|
|
self.board.boardlist[to_row][to_column].piece = self.x
|
|
exit(0)
|
|
self.board.boardlist[to_row][to_column].piece = self.x
|
|
self.board.boardlist[to_row][to_column].piece.moved = True
|
|
self.board.boardlist[to_row][to_column].piece.delete_moves()
|
|
return self.board.boardlist[to_row][to_column].piece.color
|
|
def move_boot(self, color):
|
|
self.boot_piece = []
|
|
self.piece_row_column = []
|
|
for r in range(0, 8):
|
|
for c in range(0, 8):
|
|
if self.board.boardlist[r][c].piece != None:
|
|
if self.board.boardlist[r][c].piece.color != color:
|
|
self.boot_piece.append(self.board.boardlist[r][c])
|
|
|
|
self.value = random.randrange(0, len(self.boot_piece))
|
|
self.initial = self.boot_piece[self.value]
|
|
while len(self.initial.piece.valid_moves) == 0:
|
|
self.value = random.randrange(0, len(self.boot_piece))
|
|
self.initial = self.boot_piece[self.value]
|
|
self.initial_row=self.initial.row
|
|
self.initial_column = self.initial.column
|
|
self.value = random.randrange(0, len(self.initial.piece.valid_moves))
|
|
self.final = self.initial.piece.valid_moves[self.value]
|
|
self.final_row = self.final[0]
|
|
self.final_column = self.final[1]
|
|
self.x = self.board.boardlist[self.initial_row][self.initial_column].piece
|
|
self.board.boardlist[self.initial_row][self.initial_column].piece = None
|
|
if (self.board.boardlist[self.final_row][self.final_column].has_piece()):
|
|
if (self.board.boardlist[self.final_row][self.final_column].piece.name== 'king'):
|
|
self.board.boardlist[self.final_row][self.final_column].piece = self.x
|
|
exit(0)
|
|
self.board.boardlist[self.final_row][self.final_column].piece = self.x
|
|
#pawn promotion
|
|
if isinstance(self.x, Pawn):
|
|
if (self.final_row==0) or (self.final_row==7):
|
|
self.board.boardlist[self.final_row][self.final_column].piece = Queen(self.x.color)
|
|
self.board.boardlist[self.final_row][self.final_column].piece.moved = True
|
|
self.board.boardlist[self.final_row][self.final_column].piece.delete_moves()
|
|
|
|
if self.initial_column == 0:
|
|
self.initial_column = "A"
|
|
elif self.initial_column == 1:
|
|
self.initial_column = "B"
|
|
elif self.initial_column == 2:
|
|
self.initial_column = "C"
|
|
elif self.initial_column == 3:
|
|
self.initial_column = "D"
|
|
elif self.initial_column == 4:
|
|
self.initial_column = "E"
|
|
elif self.initial_column == 5:
|
|
self.initial_column = "F"
|
|
elif self.initial_column == 6:
|
|
self.initial_column = "G"
|
|
elif self.initial_column == 7:
|
|
self.initial_column = "H"
|
|
|
|
if self.final_column == 0:
|
|
self.final_column = "A"
|
|
elif self.final_column == 1:
|
|
self.final_column = "B"
|
|
elif self.final_column == 2:
|
|
self.final_column = "C"
|
|
elif self.final_column == 3:
|
|
self.final_column = "D"
|
|
elif self.final_column == 4:
|
|
self.final_column = "E"
|
|
elif self.final_column == 5:
|
|
self.final_column = "F"
|
|
elif self.final_column == 6:
|
|
self.final_column = "G"
|
|
elif self.final_column == 7:
|
|
self.final_column = "H"
|
|
self.ruch = str(self.initial_column) + str(self.initial_row) + ' ' + str(self.final_column) + str(self.final_row)
|
|
return self.ruch |