def _set_default(self):
# unfortunately python doesn't have real 2D lists
board = [[
pieces.Rook(0, 0),
pieces.Knight(0, 1),
pieces.Bishop(0, 2),
pieces.Queen(0, 3),
pieces.King(0, 4),
pieces.Bishop(0, 5),
pieces.Knight(0, 6),
pieces.Rook(0, 7)
]]
board.append([pieces.Pawn(1, i) for i in range(8)])
board.extend([['o' for _ in range(8)] for __ in range(4)])
board.append([pieces.Pawn(6, i, player.Color.BLACK) for i in range(8)])
board.append([
pieces.Rook(7, 0, player.Color.BLACK),
pieces.Knight(7, 1, player.Color.BLACK),
pieces.Bishop(7, 2, player.Color.BLACK),
pieces.Queen(7, 3, player.Color.BLACK),
pieces.King(7, 4, player.Color.BLACK),
pieces.Bishop(7, 5, player.Color.BLACK),
pieces.Knight(7, 6, player.Color.BLACK),
pieces.Rook(7, 7, player.Color.BLACK)
])
return board
def set_pieces(self):
black = []
black.append(pieces.Rook(0, 0, BLACK))
black.append(pieces.Rook(0, 7, BLACK))
black.append(pieces.Knight(0, 1, BLACK))
black.append(pieces.Knight(0, 6, BLACK))
black.append(pieces.Bishop(0, 2, BLACK))
black.append(pieces.Bishop(0, 5, BLACK))
black.append(pieces.Queen(0, 3, BLACK))
black.append(pieces.King(0, 4, BLACK))
for x in range(8):
black.append(pieces.Pawn(1, x, BLACK))
white = []
white.append(pieces.Rook(7, 0, WHITE))
white.append(pieces.Rook(7, 7, WHITE))
white.append(pieces.Knight(7, 1, WHITE))
white.append(pieces.Knight(7, 6, WHITE))
white.append(pieces.Bishop(7, 2, WHITE))
white.append(pieces.Bishop(7, 5, WHITE))
white.append(pieces.Queen(7, 3, WHITE))
white.append(pieces.King(7, 4, WHITE))
for x in range(8):
white.append(pieces.Pawn(6, x, WHITE))
self.pieces = black + white
def init_pieces(self):
piece_list = []
back_row = 0
# add pawns
for row in range(8):
if self.player == "white":
self.piece_list.append(pieces.Pawn(row, 1, self.player))
elif self.player == "black":
self.piece_list.append(pieces.Pawn(row, 6, self.player))
else:
raise Exception("Player must be white or black")
# set row depending on color
if self.player == "black":
back_row = 7
self.piece_list.append(pieces.Rook(0, back_row, self.player))
self.piece_list.append(pieces.Rook(7, back_row, self.player))
self.piece_list.append(pieces.Knight(1, back_row, self.player))
self.piece_list.append(pieces.Knight(6, back_row, self.player))
self.piece_list.append(pieces.Bishop(2, back_row, self.player))
self.piece_list.append(pieces.Bishop(5, back_row, self.player))
self.piece_list.append(pieces.Queen(3, back_row, self.player))
self.piece_list.append(pieces.King(4, back_row, self.player))
return piece_list
def new(cls):
chess_pieces = [[0 for x in range(Board.WIDTH)] for y in range(Board.HEIGHT)]
# Create pawns.
for x in range(Board.WIDTH):
chess_pieces[x][Board.HEIGHT-2] = pieces.Pawn(x, Board.HEIGHT-2, pieces.Piece.WHITE)
chess_pieces[x][1] = pieces.Pawn(x, 1, pieces.Piece.BLACK)
# Create rooks.
chess_pieces[0][Board.HEIGHT-1] = pieces.Rook(0, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[Board.WIDTH-1][Board.HEIGHT-1] = pieces.Rook(Board.WIDTH-1, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[0][0] = pieces.Rook(0, 0, pieces.Piece.BLACK)
chess_pieces[Board.WIDTH-1][0] = pieces.Rook(Board.WIDTH-1, 0, pieces.Piece.BLACK)
# Create Knights.
chess_pieces[1][Board.HEIGHT-1] = pieces.Knight(1, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[Board.WIDTH-2][Board.HEIGHT-1] = pieces.Knight(Board.WIDTH-2, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[1][0] = pieces.Knight(1, 0, pieces.Piece.BLACK)
chess_pieces[Board.WIDTH-2][0] = pieces.Knight(Board.WIDTH-2, 0, pieces.Piece.BLACK)
# Create Bishops.
chess_pieces[2][Board.HEIGHT-1] = pieces.Bishop(2, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[Board.WIDTH-3][Board.HEIGHT-1] = pieces.Bishop(Board.WIDTH-3, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[2][0] = pieces.Bishop(2, 0, pieces.Piece.BLACK)
chess_pieces[Board.WIDTH-3][0] = pieces.Bishop(Board.WIDTH-3, 0, pieces.Piece.BLACK)
# Create King & Queen.
chess_pieces[4][Board.HEIGHT-1] = pieces.King(4, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[3][Board.HEIGHT-1] = pieces.Queen(3, Board.HEIGHT-1, pieces.Piece.WHITE)
chess_pieces[4][0] = pieces.King(4, 0, pieces.Piece.BLACK)
chess_pieces[3][0] = pieces.Queen(3, 0, pieces.Piece.BLACK)
return cls(chess_pieces, False, False)
def initialize_board():
board = np.ndarray((8, 8), dtype=np.object)
for i in range(0, 8):
pieces.append(pcs.Pawn('b', (1, i)))
for i in range(0, 8):
pieces.append(pcs.Pawn('w', (6, i)))
pieces.append(pcs.Beeshop('b', (0, 2)))
pieces.append(pcs.Beeshop('b', (0, 5)))
pieces.append(pcs.Beeshop('w', (7, 2)))
pieces.append(pcs.Beeshop('w', (7, 5)))
pieces.append(pcs.Knight('b', (0, 1)))
pieces.append(pcs.Knight('b', (0, 6)))
pieces.append(pcs.Knight('w', (7, 1)))
pieces.append(pcs.Knight('w', (7, 6)))
pieces.append(pcs.Rook('b', (0, 0)))
pieces.append(pcs.Rook('b', (0, 7)))
pieces.append(pcs.Rook('w', (7, 0)))
pieces.append(pcs.Rook('w', (7, 7)))
pieces.append(pcs.Queen('b', (0, 3)))
pieces.append(pcs.Queen('w', (7, 3)))
pieces.append(pcs.King('b', (0, 4)))
pieces.append(pcs.King('w', (7, 4)))
for piece in pieces:
board[piece.pos] = piece
return board, pieces
def testAddPiece(self):
board = ChessBoard.ChessBoard()
pawn1 = pieces.Pawn(PieceColor.WHITE)
pawn2 = pieces.Pawn(PieceColor.BLACK)
rook1 = pieces.Rook(PieceColor.WHITE)
rook2 = pieces.Rook(PieceColor.BLACK)
bishop1 = pieces.Bishop(PieceColor.BLACK)
bishop2 = pieces.Bishop(PieceColor.WHITE)
knight1 = pieces.Knight(PieceColor.BLACK)
knight2 = pieces.Knight(PieceColor.WHITE)
queen1 = pieces.Queen(PieceColor.BLACK)
queen2 = pieces.Queen(PieceColor.WHITE)
king1 = pieces.King(PieceColor.BLACK)
king2 = pieces.King(PieceColor.WHITE)
self.assertTrue(board.addPiece('2a', pawn1))
self.assertTrue(board.addPiece('7a', pawn2))
self.assertTrue(board.addPiece('1a', rook1))
self.assertTrue(board.addPiece('8a', rook2))
self.assertTrue(board.addPiece('8b', knight1))
self.assertTrue(board.addPiece('1b', knight2))
self.assertTrue(board.addPiece('8c', bishop1))
self.assertTrue(board.addPiece('1c', bishop2))
self.assertTrue(board.addPiece('8d', queen1))
self.assertTrue(board.addPiece('1d', queen2))
self.assertTrue(board.addPiece('8e', king1))
self.assertTrue(board.addPiece('1e', king2))
#try to add piece at invalid coordinates
self.assertFalse(board.addPiece('9e', king2))
self.assertFalse(board.addPiece('9a', king2))
#try to add piece at non empty cell
self.assertFalse(board.addPiece('1d', queen2))
self.assertFalse(board.addPiece('1e', king2))
def setup_pieces(self):
# Top team
for num in range(0, 8):
self.board.set_piece(Vec2(num, 1), pieces.Pawn(team=2))
self.board.set_piece(Vec2(0, 0), pieces.Rook(team=2))
self.board.set_piece(Vec2(7, 0), pieces.Rook(team=2))
self.board.set_piece(Vec2(1, 0), pieces.Knight(team=2))
self.board.set_piece(Vec2(6, 0), pieces.Knight(team=2))
self.board.set_piece(Vec2(2, 0), pieces.Bishop(team=2))
self.board.set_piece(Vec2(5, 0), pieces.Bishop(team=2))
self.p2_king = self.board.set_piece(Vec2(3, 0), pieces.King(team=2))
self.board.set_piece(Vec2(4, 0), pieces.Queen(team=2))
# Bottom Team
for num in range(0, 8):
self.board.set_piece(Vec2(num, 6), pieces.Pawn(team=1))
self.board.set_piece(Vec2(0, 7), pieces.Rook(team=1))
self.board.set_piece(Vec2(7, 7), pieces.Rook(team=1))
self.board.set_piece(Vec2(1, 7), pieces.Knight(team=1))
self.board.set_piece(Vec2(6, 7), pieces.Knight(team=1))
self.board.set_piece(Vec2(2, 7), pieces.Bishop(team=1))
self.board.set_piece(Vec2(5, 7), pieces.Bishop(team=1))
self.p1_king = self.board.set_piece(Vec2(4, 7), pieces.King(team=1))
self.board.set_piece(Vec2(3, 7), pieces.Queen(team=1))
# cool stuff
self.board.print_all_moves_for_piece(Vec2(4, 7))
def createBoard(self):
board = [['.']*8 for _ in range(8)]
board[0][0] = p.Rook(0, 0, 'B')
board[0][1] = p.Knight(0, 1, 'B')
board[0][2] = p.Bishop(0, 2, 'B')
board[0][3] = p.Queen(0, 3, 'B')
board[0][4] = p.King(0, 4, 'B')
board[0][5] = p.Bishop(0, 5, 'B')
board[0][6] = p.Knight(0, 6, 'B')
board[0][7] = p.Rook(0, 7, 'B')
for i in range(0,8):
board[1][i] = p.Pawn(1, i, 'B')
board[7][0] = p.Rook(7, 0, 'W')
board[7][1] = p.Knight(7, 1, 'W')
board[7][2] = p.Bishop(7, 2, 'W')
board[7][3] = p.Queen(7, 3, 'W')
board[7][4] = p.King(7, 4, 'W')
board[7][5] = p.Bishop(7, 5, 'W')
board[7][6] = p.Knight(7, 6, 'W')
board[7][7] = p.Rook(7, 7, 'W')
for i in range(0,8):
board[6][i] = p.Pawn(6, i, 'W')
return board
def resetGlobal():
globVar.player = "W"
globVar.playerCount = 0
globVar.w_NumPieces = 16
globVar.b_NumPieces = 16
globVar.r_w_NumPieces = 1
globVar.r_b_NumPieces = 1
globVar.w_check = False
globVar.b_check = False
globVar.removed = False
globVar.removed_label = -1
globVar.removed_color = "none"
globVar.last_row = -1
globVar.last_col = -1
globVar.scanning = False
globVar.r_avail_Num = 1
globVar.r_w_pieces = [pieces.Pawn("none", "none")]
globVar.r_b_pieces = [pieces.Pawn("none", "none")]
globVar.r_avail = [
Square(False, "none", pieces.Pawn("none", "none"), -1, -1)
]
globVar.p_w_Moves = []
globVar.p_b_Moves = []
globVar.p_w_Num = -1
globVar.p_b_Num = -1
globVar.w_pieces = []
globVar.b_pieces = []
globVar.firstPawns = []
def fen_to_board(fen):
"""Returns list of pieces from FEN position
Args:
fen ([str]): [description]
Raises:
Exception: [Print 'ass' in polish on unwanted case]
Returns:
[list]: FEN is the standard chess notation.
It is used to describe position of chess game
FEN can be stored in single line string"""
board = []
i, j = 0, 0
for char in fen:
if char.isalpha():
if char == 'p':
board.append(pieces.Pawn(i, j, is_black=True))
elif char == 'P':
board.append(pieces.Pawn(i, j, is_black=False))
elif char == 'n':
board.append(pieces.Knight(i, j, is_black=True))
elif char == 'N':
board.append(pieces.Knight(i, j, is_black=False))
elif char == 'b':
board.append(pieces.Bishop(i, j, is_black=True))
elif char == 'B':
board.append(pieces.Bishop(i, j, is_black=False))
elif char == 'r':
board.append(pieces.Rook(i, j, is_black=True))
elif char == 'R':
board.append(pieces.Rook(i, j, is_black=False))
elif char == 'q':
board.append(pieces.Queen(i, j, is_black=True))
elif char == 'Q':
board.append(pieces.Queen(i, j, is_black=False))
elif char == 'k':
board.append(pieces.King(i, j, is_black=True))
elif char == 'K':
board.append(pieces.King(i, j, is_black=False))
i += 1
elif char == '/':
j += 1
i = 0
elif 1 <= int(char) <= 8:
i += int(char)
else:
raise Exception("dupa")
return board
def reset_board(with_pieces=True):
def generate_pieces(colour):
return [pieces.Rook(colour), pieces.Knight(colour), pieces.Bishop(colour), pieces.Queen(colour),
pieces.King(colour), pieces.Bishop(colour), pieces.Knight(colour), pieces.Rook(colour)]
board = [[None for x in range(8)] for x in range(8)]
if with_pieces:
board[0] = generate_pieces("black")
board[7] = generate_pieces("white")
board[1] = [pieces.Pawn("black") for square in board[1]]
board[6] = [pieces.Pawn("white") for square in board[6]]
return board
def readPiecesArrays(save, c):
wp_array = save.readline().split(',')
k = 0
if c == "W":
globVar.w_pieces = []
n = globVar.w_NumPieces
else:
globVar.b_pieces = []
n = globVar.b_NumPieces
for i in range(n):
color = wp_array[k]
k += 1
selected = wp_array[k]
if selected == "True":
sl = True
else:
sl = False
k += 1
type = wp_array[k]
k += 1
label = int(wp_array[k])
k += 1
row = int(wp_array[k])
k += 1
col = int(wp_array[k])
k += 1
if type == "none":
pc = pieces.Pawn("none", "none")
elif type == "pawn":
pc = pieces.Pawn(color, type)
elif type == "rook":
pc = pieces.Rook(color, type)
elif type == "bishop":
pc = pieces.Bishop(color, type)
elif type == "queen":
pc = pieces.Queen(color, type)
elif type == "king":
pc = pieces.King(color, type)
elif type == "knight":
pc = pieces.Knight(color, type)
pc.selected = sl
pc.label = label
pc.row = row
pc.col = col
if c == "W":
globVar.w_pieces.append(pc)
else:
globVar.b_pieces.append(pc)
def initialize_board(self):
# initialize pawns
for x in [1 ,6]:
for y in range(8):
if x == 1:
self.pieces_one.append(pieces.Pawn('pawn', x, y))
self.board[x][y] = 'p1'
else:
self.pieces_two.append(pieces.Pawn('pawn', x, y))
self.board[x][y] = 'p2'
# initialize rooks
for x in [0, 7]:
for y in [0,7]:
if x == 0:
self.pieces_one.append(pieces.Rook('rook', x, y))
self.board[x][y] = 'r1'
else:
self.pieces_two.append(pieces.Rook('rook', x, y))
self.board[x][y] = 'r2'
# initialize horse
for y in [1,6]:
if x == 0:
self.pieces_one.append(pieces.Horse('horse', x, y))
self.board[x][y] = 'h1'
else:
self.pieces_two.append(pieces.Horse('horse', x, y))
self.board[x][y] = 'h2'
# initialize bishop
for y in [2,5]:
if x == 0:
self.pieces_one.append(pieces.Bishop('bishop', x, y))
self.board[x][y] = 'b1'
else:
self.pieces_two.append(pieces.Bishop('bishop', x, y))
self.board[x][y] = 'b2'
# initialize queen
self.pieces_one.append(pieces.Queen('queen', 0, 4))
self.board[0][4] = 'q1'
self.pieces_two.append(pieces.Queen('queen', 7, 4))
self.board[7][4] = 'q2'
# initialize king
self.pieces_one.append(pieces.King('king', 0, 3))
self.board[0][3] = 'k1'
self.pieces_two.append(pieces.King('king', 7, 3))
self.board[7][3] = 'k2'
def make_piece(self, piece, ra, fi, color):
x = self.file_to_x(fi)
y = self.rank_to_y(ra)
if piece == "":
piece = pieces.Pawn(ra, fi, color)
elif piece == "R":
piece = pieces.Rook(ra, fi, color)
elif piece == "N":
piece = pieces.Knight(ra, fi, color)
elif piece == "B":
piece = pieces.Bishop(ra, fi, color)
elif piece == "K":
piece = pieces.King(ra, fi, color)
elif piece == "Q":
piece = pieces.Queen(ra, fi, color)
elif piece == 0:
return
piece.set_rect(x, y, self.space_height)
piece.set_image(self.space_height)
self.board[ra][fi] = piece
def __init__(self, player):
self.king = pieces.King(4, 7 if (player.color == "black") else 0,
player)
self.queen = pieces.Queen(3, 7 if (player.color == "black") else 0,
player)
self.pawns = []
self.knights = []
self.bishops = []
self.rooks = []
self.knights.append(
pieces.Knight(1, 7 if (player.color == "black") else 0, player))
self.knights.append(
pieces.Knight(6, 7 if (player.color == "black") else 0, player))
self.bishops.append(
pieces.Bishop(2, 7 if (player.color == "black") else 0, player))
self.bishops.append(
pieces.Bishop(5, 7 if (player.color == "black") else 0, player))
self.rooks.append(
pieces.Rook(0, 7 if (player.color == "black") else 0, player))
self.rooks.append(
pieces.Rook(7, 7 if (player.color == "black") else 0, player))
for i in range(8):
self.pawns.append(
pieces.Pawn(i, 6 if (player.color == "black") else 1, player))
self.allPieces = self.pawns + self.bishops + self.knights + self.rooks + [
self.queen, self.king
]
def test_scan(self):
# Define position of pawn
pos = [12, 1]
# Generate empty chess board
test_board = board
test_board.grid = []
for i in range(16):
test_board.grid.append([])
for j in range(16):
test_board.grid[i].append(
Square(False, "b", pieces.Piece("none", "none"), i, j))
standard_moves = [[pos[0] - 1, pos[1]]]
other_moves = [[pos[0] - 1, pos[1]], [pos[0] - 2, pos[1]]]
test_board.grid[pos[0]][pos[1]].piece = pieces.Pawn("W", "Pawn")
test_board.grid[pos[0]][pos[1]].piece.row = pos[0]
test_board.grid[pos[0]][pos[1]].piece.col = pos[1]
#test_board.grid[pos[0]][pos[1]].piece.firstMove = True
found_moves = test_board.grid[pos[0]][pos[1]].piece.scan()
#print(found_moves[0].row, ", ", found_moves[0].col)
assert (pos[0] == found_moves[0].row + 1)
assert (pos[1] == found_moves[0].col)
def pieceConstructor(clr, type):
if type == "none":
pc = pieces.Pawn("none", "none")
elif type == "pawn":
pc = pieces.Pawn(clr, type)
elif type == "rook":
pc = pieces.Rook(clr, type)
elif type == "bishop":
pc = pieces.Bishop(clr, type)
elif type == "queen":
pc = pieces.Queen(clr, type)
elif type == "king":
pc = pieces.King(clr, type)
elif type == "knight":
pc = pieces.Knight(clr, type)
return pc
def create_board(self):
"""
Creates the initial game board required for Chess.
Populated spaces are filled with respective pieces from pieces.py.
Vacant spaces are filled with 0s.
#TODO replace the strings with actual pieces from the pieces class
"""
board = [[0 for y in range(8)] for x in range(8)]
#Placing the Rooks
board[0][0] = pieces.Rook('B')
board[0][7] = pieces.Rook('B')
board[7][0] = pieces.Rook('W')
board[7][7] = pieces.Rook('W')
#Placing the Knights
board[0][1] = pieces.Knight('B')
board[0][6] = pieces.Knight('B')
board[7][1] = pieces.Knight('W')
board[7][6] = pieces.Knight('W')
#Placing the Bishops
board[0][2] = pieces.Bishop('B')
board[0][5] = pieces.Bishop('B')
board[7][2] = pieces.Bishop('W')
board[7][5] = pieces.Bishop('W')
#Placing the Queens
board[0][3] = pieces.Queen('B')
board[7][3] = pieces.Queen('W')
#Placing the Kings
board[0][4] = pieces.King('B')
board[7][4] = pieces.King('W')
#Placing the Pawns
for i in range(8):
board[1][i] = pieces.Pawn('B')
board[6][i] = pieces.Pawn('W')
return board
def from_fen(cls, fen):
""""""
# Parse FEN
position, color, castling, en_passant, halfmove, fullmove = fen.split()
# Parse position
setup = list()
# Loop over all ranks in FEN
for rank in position.split('/'):
# Start new rank
setup.append(list())
# Loop over each individual piece
for piece in rank:
# Get color from piece
if piece.islower():
piece_color = pieces.Color.BLACK
else:
piece_color = pieces.Color.WHITE
# Set specific piece
if piece.lower() == 'p':
setup[-1].append(pieces.Pawn(piece_color))
elif piece.lower() == 'n':
setup[-1].append(pieces.Knight(piece_color))
elif piece.lower() == 'b':
setup[-1].append(pieces.Bishop(piece_color))
elif piece.lower() == 'r':
setup[-1].append(pieces.Rook(piece_color))
elif piece.lower() == 'q':
setup[-1].append(pieces.Queen(piece_color))
elif piece.lower() == 'k':
setup[-1].append(pieces.King(piece_color))
else:
for _ in range(int(piece)):
setup[-1].append(None)
# Setup board as numpy array
setup = np.asarray(setup, dtype=object)
# Ensure we have 2 dimensions
assert setup.ndim == 2, "FEN notation differed per rank."
# Create board
board = cls(
n_files=setup.shape[0],
n_ranks=setup.shape[1],
)
# Setup board
board.board = setup
board.color = color
board.castling = castling
board.en_passant = en_passant
board.halfmove = int(halfmove)
board.fullmove = int(fullmove)
# Return result
return board
def new_game(self):
"""Sets up a new game state by clearing off board and making all new pieces."""
# Clear board and player states
self.board = [[None] * 8 for i in range(8)]
self.capturedWhite = []
self.capturedBlack = []
self.playerWhite.clear()
self.playerBlack.clear()
# Create all the White pieces and put those objects on the board and add them to the White player
temp_pieces = [
p.Rook(self.playerWhite, (0, 0)),
p.Knight(self.playerWhite, (0, 1)),
p.Bishop(self.playerWhite, (0, 2)),
p.Queen(self.playerWhite, (0, 3)),
p.King(self.playerWhite, (0, 4)),
p.Bishop(self.playerWhite, (0, 5)),
p.Knight(self.playerWhite, (0, 6)),
p.Rook(self.playerWhite, (0, 7))
]
temp_pieces += [p.Pawn(self.playerWhite, (1, i)) for i in range(8)]
for cp in temp_pieces:
cp.set_board(self.board)
self.playerWhite.add_piece(cp)
self.board[cp.get_row()][cp.get_col()] = cp
self.playerWhite.set_king(temp_pieces[4])
# Create all the Black pieces and put those objects on the board and add them to the Black player
temp_pieces = [
p.Rook(self.playerBlack, (7, 0)),
p.Knight(self.playerBlack, (7, 1)),
p.Bishop(self.playerBlack, (7, 2)),
p.Queen(self.playerBlack, (7, 3)),
p.King(self.playerBlack, (7, 4)),
p.Bishop(self.playerBlack, (7, 5)),
p.Knight(self.playerBlack, (7, 6)),
p.Rook(self.playerBlack, (7, 7))
]
temp_pieces += [p.Pawn(self.playerBlack, (6, i)) for i in range(8)]
for cp in temp_pieces:
cp.set_board(self.board)
self.playerBlack.add_piece(cp)
self.board[cp.get_row()][cp.get_col()] = cp
self.playerBlack.set_king(temp_pieces[4])
def recordFirstPawns():
globVar.firstPawnsNum = 0
globVar.firstPawns = [pieces.Pawn("none", "none")]
for i in range(8):
for j in range(8):
if (board.Grid(i, j).piece.type == "pawn"
and board.Grid(i, j).piece.firstMove
and board.Grid(i, j).piece.color != "none"):
globVar.firstPawns.append(board.Grid(i, j).piece)
globVar.firstPawnsNum = len(globVar.firstPawns)
def __init__(self):
self.board = [["BR", "BH", "BB", "BQ", "BK", "BB", "BH", "BR"],
["BP", "BP", "BP", "BP", "BP", "BP", "BP", "BP"],
["EE", "EE", "EE", "EE", "EE", "EE", "EE", "EE"],
["EE", "EE", "EE", "EE", "EE", "EE", "EE", "EE"],
["EE", "EE", "EE", "EE", "EE", "EE", "EE", "EE"],
["EE", "EE", "EE", "EE", "EE", "EE", "EE", "EE"],
["WP", "WP", "WP", "WP", "WP", "WP", "WP", "WP"],
["WR", "WH", "WB", "WQ", "WK", "WB", "WH", "WR"]]
self.black_vision = set()
self.white_vision = set()
self.current_player = "W"
self.turn_count = 0
# Initialize board with Piece objects
for x in range(8):
for y in range(8):
piece = self.board[x][y]
if piece == "EE": continue
color = piece[0]
p_type = piece[1]
if p_type == "Q":
self.board[x][y] = pieces.Queen(color, x, y)
elif p_type == "R":
self.board[x][y] = pieces.Rook(color, x, y)
elif p_type == "B":
self.board[x][y] = pieces.Bishop(color, x, y)
elif p_type == "P":
self.board[x][y] = pieces.Pawn(color, x, y)
elif p_type == "K":
self.board[x][y] = pieces.King(color, x, y)
elif p_type == "H":
self.board[x][y] = pieces.Knight(color, x, y)
self.white_king = self.board[7][4]
self.black_king = self.board[0][4]
current_vision = set()
other_vision = set()
for y in range(8):
for x in range(8):
piece = self.get_piece(x, y)
if str(piece)[0] == self.current_player:
current_vision.add((y, x))
current_vision = current_vision.union(
self.board[y][x].vision(self))
elif str(piece) != "EE":
other_vision.add((y, x))
other_vision = other_vision.union(
self.board[y][x].vision(self))
self.white_vison = current_vision
self.black_vision = other_vision
def testTranslate(self):
g = main.Game()
g.boardy.printBoard()
self.assertEqual((0, 7), g.translate("a1"))
self.assertRaises(
pieces.MoveException,
g.translate,
"99999999999999999999999")
self.assertIsInstance(g.boardy["a2"], pieces.Pawn)
self.assertIsInstance(g.boardy["b3"], pieces.EmptySpace)
g.boardy["b3"] = pieces.Pawn(1)
self.assertIsInstance(g.boardy["b3"], pieces.Pawn)
def __init__(self):
self.r = 8
self.c = 8
self.pieces = []
for row in range(0, self.r):
for column in range(0, self.c):
if row == 1:
self.pieces.append(pieces.Pawn(column, row, "white"))
elif row == 6:
self.pieces.append(pieces.Pawn(column, row, "black"))
if row == 0:
if column == 0 or column == 7:
self.pieces.append(pieces.Rook(column, row, "white"))
self.pieces.append(pieces.Pawn(4, 0, "white"))
self.print_board()
# start intial pawn line up
self.print_board()
def __init_piece_by_name(self, n, white):
white = int(white)
if n == 'P':
return p.Pawn(white)
elif n == 'R':
return p.Rook(white)
elif n == 'N':
return p.Knight(white)
elif n == 'B':
return p.Bishop(white)
elif n == 'Q':
return p.Queen(white)
elif n == 'K':
return p.King(white)
def _populate_board(self):
squares = {
Square(i, j): None
for i in range(BOARDSIZE) for j in range(BOARDSIZE)
}
order = (pieces.Rook, pieces.Knight, pieces.Bishop, pieces.Queen,
pieces.King, pieces.Bishop, pieces.Knight, pieces.Rook)
for j in range(8):
white_heavy = Square(0, j)
squares[white_heavy] = order[j](self, white_heavy, True)
white_pawn = Square(1, j)
squares[white_pawn] = pieces.Pawn(self, white_pawn, True)
black_pawn = Square(6, j)
squares[black_pawn] = pieces.Pawn(self, black_pawn, False)
black_heavy = Square(7, j)
squares[black_heavy] = order[j](self, black_heavy, False)
return squares
def initialise_board(self):
"empty spaces"
self._board.loc[[3, 4, 5, 6]] = None
"pawns"
for board_file in self._board.columns.values:
self._board.loc[2] = pieces.Pawn(WHITE, board_file, 2)
self._board.loc[7] = pieces.Pawn(BLACK, board_file, 7)
"rooks"
self._board.loc[1, 'A'] = pieces.Rook(WHITE, 'A', 1)
self._board.loc[8, 'A'] = pieces.Rook(BLACK, 'A', 8)
self._board.loc[1, 'H'] = pieces.Rook(WHITE, 'H', 1)
self._board.loc[8, 'H'] = pieces.Rook(BLACK, 'H', 8)
"knights"
self._board.loc[1, 'B'] = pieces.Knight(WHITE, 'B', 1)
self._board.loc[8, 'B'] = pieces.Knight(BLACK, 'B', 8)
self._board.loc[1, 'G'] = pieces.Knight(WHITE, 'G', 1)
self._board.loc[8, 'G'] = pieces.Knight(BLACK, 'G', 8)
"bishops"
self._board.loc[1, 'C'] = pieces.Bishop(WHITE, 'C', 1)
self._board.loc[8, 'C'] = pieces.Bishop(BLACK, 'C', 8)
self._board.loc[1, 'F'] = pieces.Bishop(WHITE, 'F', 1)
self._board.loc[8, 'F'] = pieces.Bishop(BLACK, 'F', 8)
"queens"
self._board.loc[1, 'D'] = pieces.Queen(WHITE, 'D', 1)
self._board.loc[8, 'D'] = pieces.Queen(BLACK, 'D', 8)
"kings"
self._board.loc[1, 'E'] = pieces.King(WHITE, 'E', 1)
self._board.loc[8, 'E'] = pieces.King(BLACK, 'E', 8)
print(self._board)
def makeGrid():
# global grid
colorSwitcher = {"white": "black", "black": "white"}
# If playerColor = White, tileColor = black, and vice versa
tileColor = "black"
for row in range(0, 8):
rowTiles = []
for col in range(0, 8):
rowTiles.append(Square(None, tileColor))
tileColor = colorSwitcher[tileColor]
grid.append(rowTiles)
tileColor = colorSwitcher[tileColor]
# init pawns
for col in range(0, 8):
grid[1][col].piece = pieces.Pawn("W", 1, col)
grid[6][col].piece = pieces.Pawn("B", 6, col)
# init rest of pieces
grid[0][0].piece = pieces.Rook("W", 0, 0)
grid[0][1].piece = pieces.Knight("W", 0, 1)
grid[0][2].piece = pieces.Bishop("W", 0, 2)
grid[0][3].piece = pieces.Queen("W", 0, 3)
grid[0][4].piece = pieces.King("W", 0, 4)
grid[0][5].piece = pieces.Bishop("W", 0, 5)
grid[0][6].piece = pieces.Knight("W", 0, 6)
grid[0][7].piece = pieces.Rook("W", 0, 7)
grid[7][0].piece = pieces.Rook("B", 6, 0)
grid[7][1].piece = pieces.Knight("B", 6, 1)
grid[7][2].piece = pieces.Bishop("B", 6, 2)
grid[7][3].piece = pieces.Queen("B", 6, 3)
grid[7][4].piece = pieces.King("B", 6, 4)
grid[7][5].piece = pieces.Bishop("B", 6, 5)
grid[7][6].piece = pieces.Knight("B", 6, 6)
grid[7][7].piece = pieces.Rook("B", 6, 7)
def set_up(self):
for x in range(8):
self.add(pieces.Pawn(x, 1, True))
self.add(pieces.Pawn(x, 1, False))
for x in [0, 7]:
self.add(pieces.Rook(x, 0, True))
self.add(pieces.Rook(x, 0, False))
for x in [1, 6]:
self.add(pieces.Knight(x, 0, True))
self.add(pieces.Knight(x, 0, False))
for x in [2, 5]:
self.add(pieces.Bishop(x, 0 ,True))
self.add(pieces.Bishop(x, 0, False))
self.add(pieces.Queen(3, 0, True))
self.add(pieces.Queen(3, 0, False))
self.add(pieces.King(4, 0, True))
self.add(pieces.King(4, 0, False))
return self
def __init_piece(self, row, col, white):
piece = None
if row in (1, 6):
piece = p.Pawn(white)
elif row in (0, 7):
if col in (0, 7):
piece = p.Rook(white)
elif col in (1, 6):
piece = p.Knight(white)
elif col in (2, 5):
piece = p.Bishop(white)
elif col == 3:
piece = p.Queen(white)
elif col == 4:
piece = p.King(white)
return piece
