def loadAll(self, screen, width, height):
for row in range(len(self.board)):
for col in range(len(self.board[row])):
thing = self.board[row][col]
if thing != 0:
temp = Pieces([row, col],
self.board_to_physical(
width, height, row, col),
self.str_to_info(thing))
temp.load_image(screen, width, height)
def __init__(self, bin="", last_move=None):
self.pieces = Pieces()
self.whoseTurn = "D"
self.max_x = 7
self.max_y = 7
self.bin_str = bin
self.last_moved = last_move
if self.bin_str:
self.from_binary(self.bin_str)
def game_begin(self):
from Pieces import Pieces
uniDict = {
"white": {
"Pawn": "♙",
"Rook": "♖",
"Knight": "♘",
"Bishop": "♗",
"King": "♔",
"Queen": "♕"
},
"black": {
"Pawn": "♟",
"Rook": "♜",
"Knight": "♞",
"Bishop": "♝",
"King": "♚",
"Queen": "♛"
}
}
pieces_list = [
"Rook", "Knight", "Bishop", "Queen", "King", "Bishop", "Knight",
"Rook"
]
for i in range(0, 8):
# board(y,x)
self.board[(i, 0)] = Pieces(x=0,
y=i,
colour="white",
name=uniDict["white"][pieces_list[i]],
direction=1,
category=pieces_list[i])
self.board[(i, 1)] = Pieces(x=1,
y=i,
colour="white",
name=uniDict["white"]["Pawn"],
direction=1,
category="Pawn")
self.board[(i, 6)] = Pieces(x=1,
y=i,
colour="black",
name=uniDict["black"]["Pawn"],
direction=-1,
category="Pawn")
self.board[(i, 7)] = Pieces(x=7,
y=i,
colour="black",
name=uniDict["black"][pieces_list[i]],
direction=1,
category=pieces_list[i])
return self.board
def __init__(self, destination: pygame.Surface, board: Board):
"""
This function is default c'tor and it loads the pieces and other
graphics relevant to the board.
"""
self.pieces_graphics = Pieces.load_pieces()
self.destination = destination
self.board = board
def init_Game(self):
"""
Starts a new game.
Here is the normal start state of a standard 8 by 8 checkerboard
0 1 2 3 4 5 6 7
0 __ B __ B __ B __ B
1 B __ B __ B __ B __
2 __ B __ B __ B __ B
3 __ __ __ __ __ __ __ __
4 __ __ __ __ __ __ __ __
5 R __ R __ R __ R __
6 __ R __ R __ R __ R
7 R __ R __ R __ R __
"""
size = self.size
for i in range(size):
if i % 2 == 0:
self.board[(i, 5)] = Pieces(i, 5, RED)
self.board[(i, 7)] = Pieces(i, 7, RED)
self.board[(i, 1)] = Pieces(i, 1, BLUE)
else:
self.board[(i, 0)] = Pieces(i, 0, BLUE)
self.board[(i, 2)] = Pieces(i, 2, BLUE)
self.board[(i, 6)] = Pieces(i, 6, RED)
def get_piece_color_at(self, row, col):
"""
This function returns piece color on coordinates row x col. If there is
no piece, then the function returns the color of cell.
:param: row, is the row of the cell.
:param: col, is the col of the cell.
:return: The color of the piece, if there is one. If no, the color of
the cell.
"""
piece = self.get_piece_at(row, col)
if piece == Pieces.NONE:
return self.get_cell_color_at(row, col)
return Pieces.get_piece_color(piece)
def __init__(self,
copy=False,
size=None,
turn=None,
board=None,
piece_taken=None):
"""
Initializes the board
"""
if copy:
self.size = size
self.turn = turn
self.board = board
self.piece_taken = piece_taken
else:
self.size = 8
self.turn = RED
self.board = dict([((x, y), Pieces(x, y, 0))
for x in range(self.size)
for y in range(self.size)])
self.init_Game()
self.piece_taken = False
def __init__(self, color, x, y, grid):
Pieces.__init__(self, x, y, color, grid)
def __init__(self, name = "King", color="BLACK", position = (0,0)): Pieces.__init__(self, name, color, position) self.checked = False self.checkmated = False self.type = "King"
def __init__(self, color, x, y, grid):
Pieces.__init__(self, x, y, color, grid)
self.prevx = self.revWidth.get(self.width.get(self.x) - 1)
self.nextx = self.revWidth.get(self.width.get(self.x) + 1)
def move(self, curr_piece, move):
"""
:param curr_piece: A piece object
:param move: A tuple holding the change in coordinates (dx, dy) of the given piece
:return: The next state of the board after the move is played
"""
if curr_piece.get_team() == 0:
raise ValueError("Invalid Move, Blank spot has no piece")
# Checking so that a non-king piece is not moving backwards
if curr_piece.get_team() * move[1] < 0 and not curr_piece.is_king():
raise ValueError("Invalid Move, not a king")
# Checking so that a move strictly diagonal and within a 1 or 2 unit radius
if abs(move[1]) != abs(move[0]) or (abs(move[0]) > 2 or move[0] == 0):
raise ValueError("Invalid Move, bad move")
if abs(move[0]) == 1 and self.force_jump():
raise ValueError("You must take the opponent's piece!")
curr_pos = curr_piece.get_position()
# new_spot is the new location of the curr_piece
new_spot = (curr_pos[0] + move[0], curr_pos[1] + move[1])
# Checks if the new_spot is within the board's boundaries
if not self.inBounds(new_spot):
raise ValueError("Invalid Move, out of bounds")
# Checking so that moves are valid
# Checking if a piece is not currently at the new_spot
if self.board[new_spot].get_team() != 0:
raise ValueError("Invalid Move, new spot is occupied")
# Calculate the current and opposite teams
curr_team = curr_piece.get_team()
opp_team = RED
if curr_team == RED:
opp_team = BLUE
opp_index = int((opp_team + 1) / 2)
if abs(move[0]) == 1:
curr_piece.change_position(new_spot[0], new_spot[1])
self.board[curr_pos] = Pieces(curr_pos[0], curr_pos[1], 0)
promotion_row = (opp_index * (self.size - 1) - self.size + 1) * -1
if new_spot[1] == promotion_row and not curr_piece.is_king():
curr_piece.promote()
self.board[new_spot] = curr_piece.deep_copy_piece()
self.piece_taken = False
self.turn *= -1
return
# A jump is taking place, so an opposing color piece must be in between the jump
else:
# Calculate the space on the board that is jumped over
jump_spot = (curr_pos[0] + (move[0] / 2),
curr_pos[1] + (move[1] / 2))
if self.board[jump_spot].get_team() == self.turn * -1:
curr_piece.change_position(new_spot[0], new_spot[1])
self.board[curr_pos] = Pieces(curr_pos[0], curr_pos[1], 0)
promotion_row = (opp_index *
(self.size - 1) - self.size + 1) * -1
if new_spot[1] == promotion_row and not curr_piece.is_king():
curr_piece.promote()
self.board[jump_spot] = Pieces(jump_spot[0], jump_spot[1], 0)
self.board[curr_pos] = Pieces(curr_pos[0], curr_pos[1], 0)
self.board[new_spot] = curr_piece.deep_copy_piece()
if not self.force_jump():
self.turn *= -1
self.piece_taken = True
return
# Program reaches here if there is no opposing team's piece is in the jump_spot
raise ValueError("Invalid Move, empty jump")
def __init__(self, x, y, grid):
Pieces.__init__(self, x, y, "n", grid)
class BoardState:
def __init__(self, bin="", last_move=None):
self.pieces = Pieces()
self.whoseTurn = "D"
self.max_x = 7
self.max_y = 7
self.bin_str = bin
self.last_moved = last_move
if self.bin_str:
self.from_binary(self.bin_str)
# TODO: how can a move know if it's valid without the pieces?
def resolve_move(self, last_move):
if not last_move.is_valid(): # There's a smell here
return
moved_piece = self.pieces.get_piece_at(last_move.end_loc)
if not moved_piece: # No piece at end of move... throw?
return
piece_loc = moved_piece.get_location()
for dir in DIRECTIONS:
neighbor_loc = piece_loc + dir
far_neighbor_loc = neighbor_loc + dir
neighbor_piece = self.pieces.get_piece_at(neighbor_loc)
if neighbor_piece and moved_piece.is_enemy(neighbor_piece):
far_neighbor_piece = self.pieces.get_piece_at(far_neighbor_loc)
if far_neighbor_piece and not moved_piece.is_enemy(
far_neighbor_piece):
pass
# TODO: Capture neighbor piece
# Take in a string of 1's and 0's as passed as a board state
def from_binary(self, boardBits):
kingX = int(boardBits[0:3], 2)
kingY = int(boardBits[3:6], 2)
self.pieces.add_piece(King(x=kingX, y=kingY))
locIndex = 0
strIndex = 6
while locIndex < 44:
if boardBits[strIndex] == '1': # piece found here
newLoc = BoardLocations.gen_from_index(locIndex)
if boardBits[strIndex + 1] == '1':
self.pieces.add_piece(Attacker(location=newLoc))
else:
self.pieces.add_piece(Defender(location=newLoc))
strIndex += 1 # advance one for the data payload
locIndex += 1
strIndex += 1
self.whoseTurn = "D"
if boardBits[-2] == "1":
self.whoseTurn = "A"
def is_attacker_turn(self):
return self.whoseTurn == "A"
def is_defender_turn(self):
return self.whoseTurn == "D"
def dump(self):
self.pieces.dump_pieces()
# Emit a string of 1's and 0's as passed as a board state
def to_binary(self):
ret = ""
ret += self.pieces.king.to_binary()
non_king_piece_count = 0
for locIndex in range(44):
location = BoardLocations.gen_from_index(locIndex)
piece = self.pieces.get_piece_at(location)
if piece:
if piece.is_king():
ret += "0"
else:
ret += piece.to_binary()
non_king_piece_count += 1
else:
ret += "0"
# Add on zeros for captured pieces as padding
for i in range(12 - non_king_piece_count):
ret += "0"
# Add on the bit for whose turn it is
if self.whoseTurn == "A":
ret += "1"
else:
ret += "0"
ret += "0" # Reserved padding bit
return ret
# TODO: Change this to functions, geez Crandall
def gen_child_states(self):
ret = []
moveList = None
realTurn = self.whoseTurn
if self.whoseTurn == "A": # Move attackers
moveList = self.pieces.attackers
self.whoseTurn = "D"
else: # Move Defenders
moveList = self.pieces.defenders
self.whoseTurn = "A"
for currPiece in moveList:
start_location = currPiece.get_location()
startX = start_location.x
startY = start_location.y
# print("Startx = {0} , Starty = {1}".format(startX, startY))
maxX = 7
minX = -1
maxY = 7
minY = -1
if not currPiece.is_king():
if startY == 0 or startY == 6: # corners
maxX = 6
minX = 0
if startX == 0 or startX == 6: # corners
maxY = 6
minY = 0
for curr_x in range(startX + 1, maxX): # move right
new_loc = Location(x=curr_x, y=startY)
print(new_loc)
piece = self.pieces.get_piece_at(new_loc)
if not piece:
currPiece.set_location(new_loc)
ret.append(self.to_binary())
else:
break # hit another piece
currPiece.set_location(start_location)
for curr_x in range(startX - 1, minX, -1): # move left
new_loc = Location(x=curr_x, y=startY)
print(new_loc)
piece = self.pieces.get_piece_at(new_loc)
if not piece:
currPiece.set_location(new_loc)
ret.append(self.to_binary())
else:
break # hit another piece
currPiece.set_location(start_location)
for curr_y in range(startY - 1, minY, -1): # move upwards
new_loc = Location(x=startX, y=curr_y)
print(new_loc)
piece = self.pieces.get_piece_at(new_loc)
if not piece:
currPiece.set_location(new_loc)
ret.append(self.to_binary())
else:
break # hit another piece - stop looping
currPiece.set_location(start_location)
for curr_y in range(startY + 1, maxY): # move downwards
new_loc = Location(x=startX, y=curr_y)
print(new_loc)
piece = self.pieces.get_piece_at(new_loc)
if not piece:
currPiece.set_location(new_loc)
ret.append(self.to_binary())
else:
break # hit another piece - stop looping
currPiece.set_location(start_location)
self.whoseTurn = realTurn
return ret
# Create a metrics object from the current board state for heuristics use
def generate_metrics(self):
metrics = BoardMetrics()
metrics.update_metrics(self.pieces)
return metrics
# Returns a string representing the board visually for terminal output
def get_terminal_string(self, indicies=False):
# pragma: nocover
ret = ""
if indicies is True:
ret += " X "
for i in range(self.max_x):
ret += "{:<2}".format(i)
ret += "\n"
for y in range(self.max_y):
if indicies is True:
if y == 0:
ret += "Y "
else:
ret += " "
ret += "+-" * self.max_x + "+\n"
if indicies is True:
ret += "{:<2}".format(y)
for x in range(self.max_x):
currLoc = Location(x=x, y=y)
piece = self.pieces.get_piece_at(currLoc)
draw = " "
if currLoc in KING_TILES: # Really, a total hack
draw = chr(0x2318)
if piece:
draw = piece.get_terminal_string()
ret += "|" + draw
ret += "|\n"
if indicies is True:
ret += " "
ret += "+-" * self.max_x + "+\n"
return ret
from board import Board
from Pieces import Pieces
pygame.init()
# Constants
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 800
win = pygame.display.set_mode((SCREEN_WIDTH,SCREEN_HEIGHT))
pygame.display.set_caption(('Chess'))
running = True
board = Board(win)
board.draw_board()
piece1 = Pieces(*board.boxes[0].center,'B',0,0,board)
piece2 = Pieces(*board.boxes[1].center,'W',1,0,board)
board.boards[0][0] = [1,piece1]
board.boards[1][0] = [1,piece2]
all_pieces = pygame.sprite.Group()
all_pieces.add(piece1)
all_pieces.add(piece2)
while running:
for event in pygame.event.get():
all_pieces.update(event)
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
elif event.type == QUIT:
def __init__(self, name = "Knight", color="BLACK", position = (0,0)): Pieces.__init__(self, name, color, position) self.weight = 15 self.type = "Knight"
def __init__(self, name = "Pawn", color="BLACK", position = (0,0)): Pieces.__init__(self, name, color, position) self.weight = 10 self.threat = 10 self.type = "Pawn"
