def setUp(self):
"""
setup the test with 1 piece on a board.
:return: None.
"""
self.piece = Piece()
self.piece.board = Board(4, 4, [self.piece])
class TestPieceNoBoard(unittest.TestCase):
"""
Testing piece functionality without a board set to it.
"""
def setUp(self):
"""
setup the test with Piece class.
:return: None.
"""
self.piece = Piece()
def test_row(self):
"""
test the row getter.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.row
def test_set_row(self):
"""
test the row setter.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.row = 1
def test_column(self):
"""
test the column getter.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.column
def test_set_column(self):
"""
test the column setter.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.column = 1
def test_set_position(self):
"""
test the position setting functionality.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.set_position(1, 1)
def test_get_moves(self):
"""
test getting the available moves of a piece.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.get_moves()
def test_update_column_status(self):
"""
test updating the column `taken` value.
:return: None.
"""
self.assertEqual(self.piece.update_column_status(), None)
def test_can_move(self):
"""
test the can_move functionality of a piece.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.can_move(1, 1, 1)
def test_move(self):
"""
test the move functionality of a piece.
:return: None.
"""
with self.assertRaises(InvalidSetupException):
self.piece.move(1, 1)
def test_invalid_move_down_right(self):
self.piece.set_coordinates('e', 7)
self.board[8]['e'] = Piece('red', 'e', 8)
self.assertFalse(self.piece.valid_move('f', 9, self.board))
def test_invalid_move_piece_in_the_way_4(self):
piece = self.klass('black', 'c', 10)
self.board[9]['b'] = Piece('black', 'b', 9)
self.assertFalse(piece.valid_move('a', 8, self.board))
def test_invalid_move_column_not_empty(self):
self.board[2]['a'] = Piece('red', 'a', 2)
self.assertFalse(self.piece.valid_move('a', 3, self.board))
def test_valid_move_column_not_empty(self):
self.board[4]['b'] = Piece('red', 'b', 4)
self.board[5]['b'] = Piece('black', 'b', 5)
self.assertTrue(self.piece.valid_move('b', 5, self.board))
def test_invalid_move_column_not_empty(self):
self.board[4]['b'] = Piece('red', 'b', 4)
self.assertFalse(self.piece.valid_move('b', 5, self.board))
def test_invalid_move_row_not_empty_2(self):
self.board[3]['c'] = Piece('red', 'c', 3)
self.board[3]['d'] = Piece('red', 'd', 3)
self.board[3]['e'] = Piece('black', 'e', 3)
self.assertFalse(self.piece.valid_move('e', 3, self.board))
def __init__(self, colour, coordinate, name):
Piece.__init__(self, colour, coordinate, name)
self.x = coordinate[0]
self.y = coordinate[1]
def __init__(self, color, row, col):
Piece.__init__(self, color, row, col, "p")
def __init__(self, color, type):
self.firstMove = False
Piece.__init__(self, color, type)
def randomPieceGenerator():
return [Piece.getRandomPiece() for _ in range(3)]
def create_piece(self, color, piece_type, position):
piece = Piece(color, piece_type, self.display_surf)
piece.set_position(position)
return piece
def hips(self, colour, part = "970"):
# Displacement from torso
displacement = self.matrix * Vector(0, 32, 0)
return Piece(colour, self.position + displacement, self.matrix, part,
self.group)
def backpack(self, colour, displacement = Vector(0, 0, 0), part = "3838"):
# Displacement from torso
displacement = self.matrix * displacement
return Piece(colour, self.position + displacement, self.matrix, part,
self.group)
class TestPiece(unittest.TestCase):
"""
Testing a piece functionality with a board set to it.
"""
def setUp(self):
"""
setup the test with 1 piece on a board.
:return: None.
"""
self.piece = Piece()
self.piece.board = Board(4, 4, [self.piece])
def test_row(self):
"""
test the row getter.
:return: None.
"""
self.assertEqual(self.piece.row, 0)
def test_set_row(self):
"""
test the row setter.
:return: None.
"""
self.setUp()
self.piece.row = 2
self.assertEqual(self.piece.row, 2)
with self.assertRaises(InvalidMoveException):
self.piece.row = -1
with self.assertRaises(InvalidMoveException):
self.piece.row = 4
def test_column(self):
"""
test the column getter.
:return: None.
"""
self.assertEqual(self.piece.column, 0)
def test_set_column(self):
"""
test the column setter.
:return: None.
"""
self.setUp()
self.piece.column = 2
self.assertEqual(self.piece.column, 2)
with self.assertRaises(InvalidMoveException):
self.piece.column = -1
with self.assertRaises(InvalidMoveException):
self.piece.column = 4
def test_set_position(self):
"""
test the position setting functionality.
:return: None.
"""
self.setUp()
self.piece.set_position(2, 2)
self.assertEqual(self.piece.row, 2)
self.assertEqual(self.piece.column, 2)
with self.assertRaises(InvalidMoveException):
self.piece.set_position(-1, 2)
with self.assertRaises(InvalidMoveException):
self.piece.set_position(2, -1)
with self.assertRaises(InvalidMoveException):
self.piece.set_position(-1, -1)
with self.assertRaises(InvalidMoveException):
self.piece.set_position(4, 2)
with self.assertRaises(InvalidMoveException):
self.piece.set_position(2, 4)
with self.assertRaises(InvalidMoveException):
self.piece.set_position(4, 4)
def test_get_moves(self):
"""
test getting the available moves of a piece.
:return: None.
"""
self.assertEqual(self.piece.get_moves(), [])
def test_update_column_status(self):
"""
test updating the column `taken` value.
:return: None.
"""
self.setUp()
self.piece.update_column_status()
self.assertEqual(self.piece.board[0, 1].taken, False)
def test_can_move(self):
"""
test the can_move functionality of a piece.
:return: None.
"""
self.assertEqual(self.piece.can_move(0, 0, 1), True)
def test_move(self):
"""
test the move functionality of a piece.
:return: None.
"""
self.setUp()
self.piece.move(0, 1)
self.assertEqual(self.piece.row, 0)
self.assertEqual(self.piece.column, 1)
self.assertEqual(self.piece.board[0, 1].piece, self.piece)
def torso(self, colour, part = "973"):
return Piece(colour, self.position, self.matrix, part, self.group)
count += 1
print(peer_tag, f"Did not connect because {e}")
# raise
thread_obj.join()
except Exception as e:
pass
i += 1
#time.sleep(5 * n_l)
l1 = this_client._splitPieces()
q = rarestFirstQueue()
for i in range(this_client.num_of_pieces):
if i == this_client.num_of_pieces - 1:
p1 = Piece(l1[i][0], i, this_client.last_piece_len, bytes())
else:
p1 = Piece(l1[i][0], i, this_client.piece_length, bytes())
for peer in this_client.global_piece_list:
m = len(this_client.global_piece_list[peer])
if i >= m:
continue
if this_client.global_piece_list[peer][i] == '1':
p1.occurrence += 1
q.insertPiece(p1)
print(len(q.piecesQueue))
time.sleep(2)
for p in q.piecesQueue:
peer_list = []
for peer in this_client.global_piece_list:
if this_client.global_piece_list[peer][p.index] == '1':
def test_valid_move_row_not_empty(self):
self.board[3]['c'] = Piece('red', 'c', 3)
self.board[3]['d'] = Piece('black', 'd', 3)
self.assertTrue(self.piece.valid_move('d', 3, self.board))
def main(white_king, black_king):
'''
Representation of the chess board in an array
Each number in the array represents a piece:
0 - Empty Space
1 - Pawn
2 - Knight
3 - Bishop
4 - Rook
5 - Queen
6 - King
Positive values indicate white pieces
Negative values indicate black pieces
'''
# Chess board
board = [[-4, -2, -3, -5, -6, -3, -2, -4],
[-1, -1, -1, -1, -1, -1, -1, -1], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1],
[4, 2, 3, 5, 6, 3, 2, 4]]
# Important variables
running = True
isClicked = False
curr = 0
color = 1
valid = []
cm = False
counter = 1
curr_piece = 10
canCastle = False
curr_x, curr_y = 10, 10
# Setting a gameloop
while running:
# Stuff that will run in the background
createBoard(board, white_king, black_king, valid)
piece = pieceUnderMouse(board)
if curr_piece != 0:
color = curr_piece // abs(curr_piece)
x, y = getMousePos()
for event in pygame.event.get():
# Exits program
if event.type == pygame.QUIT:
running = False
# Checking if the mouse has been pressed
if event.type == pygame.MOUSEBUTTONDOWN:
if piece != 0 and not isClicked:
# Set the clicked piece as the current piece
curr_piece = piece
curr_x, curr_y = x, y
isClicked = True
# Checking if the mouse has been released
if event.type == pygame.MOUSEBUTTONUP:
if isClicked:
# Animation stuff
board[curr_x][curr_y] = curr_piece
lastPiece = board[x][y]
capture = board[x][y]
# Checks if the desired move is valid
if [curr_x, curr_y, x, y] in valid:
# Update the king's positions
if abs(curr_piece) == 6:
if color > 0:
white_king = [x, y]
else:
black_king = [x, y]
Piece.placePiece(board, curr_x, curr_y, x, y, 0)
inCheck = check(board, white_king, black_king)
counter *= -1
if inCheck != 0:
"""
This part checks if there is a checkmate or not
It looks one move into the future to determine if
a side has any possible moves that can be played
"""
if inCheck > 0:
val = validWhite(board)
else:
val = validBlack(board)
count = 0
# Looping through all the possible moves
for i in val:
x1, y1, x2, y2 = i
last = board[x2][y2]
"""
Here, we simulate all the possible moves that a side can
play by taking its "validMove" list and placing all of the
moves on the board, one by one.
We then check if the king is in check if that move is played
and then reset the move so as to not disturb the game
"""
Piece.placePiece(board, x1, y1, x2, y2, 0)
if abs(board[x2][y2]) == 6:
if color < 0:
white_king = [x2, y2]
elif color > 0:
black_king = [x2, y2]
inCheck = check(board, white_king, black_king)
if inCheck != 0:
count += 1
# Reseting the moves
Piece.placePiece(board, x2, y2, x1, y1, last)
if abs(board[x1][y1]) == 6:
if color < 0:
white_king = [x1, y1]
elif color > 0:
black_king = [x1, y1]
# Checking for checkmate
if count == len(val):
cm = True
else:
cm = False
# If a side puts itself in check
if color == inCheck:
Piece.placePiece(board, x, y, curr_x, curr_y,
lastPiece)
counter *= -1
elif color != inCheck:
if cm:
sys.exit()
if capture == 0:
pygame.mixer.Sound.play(move_sound)
else:
pygame.mixer.Sound.play(capture_sound)
curr_piece = board[x][y]
isClicked = False
# If the mouse button is clicked
if isClicked:
board[curr_x][curr_y] = curr_piece
curr = createPiece(board, curr_piece, curr_x, curr_y)
valid = curr.validMoves()
board[curr_x][curr_y] = 0
# Using drag n' drop functionality to move the piece
movePiece(curr_piece)
else:
# Pawn Promotion functionality
if abs(curr_piece) == 1 and curr_piece == piece:
pr = 5
if canPromote(x):
board[x][y] = pr * color
curr_piece = board[x][y]
pygame.display.update()
def test_invalid_move_column_not_empty_2(self):
self.board[4]['b'] = Piece('red', 'b', 4)
self.board[5]['b'] = Piece('red', 'b', 5)
self.board[6]['b'] = Piece('black', 'b', 6)
self.assertFalse(self.piece.valid_move('b', 6, self.board))
def square_attacked_by(self, piece, attacker, board=None):
""" Returns True if square is attacked by inputted piece """
#print(f"Entered square_attacked_by({piece._id} on {Board.square_name((piece.rank, piece.file))}, attacked by {attacker}?)")
if not board:
board = self.board
file = piece.file
rank = piece.rank
attacker = Piece(attacker)
if attacker.name == PAWN:
if attacker.colour == WHITE:
movements = [SW, SE]
else:
movements = [NW, NE]
else:
movements = attacker.movements
for movement in movements:
#print(movement)
distance = 0
possible_file = file
possible_rank = rank
while distance != attacker.max_distance:
#print(distance)
#board.print_board()
possible_file += movement[1]
possible_rank += movement[0]
# If passed edge of board
if possible_file < 0 or possible_file > 7 or \
possible_rank < 0 or possible_rank > 7:
#print("off edge of board")
break
#print(board.BOARD[possible_rank][possible_file])
# If square is occupied
if board.BOARD[possible_rank][possible_file] is not EMPTY:
# If own piece in the way
if board.BOARD[possible_rank][
possible_file].colour == piece.colour:
#print(f"own piece in way: {board.BOARD[possible_rank][possible_file]}")
break
# If opposition piece in the way
else:
# If is attacker we are searching for
if board.BOARD[possible_rank][
possible_file].name == attacker.name:
#print(f"Attacker found: {attacker.name}")
return True
# If attacker is Rook or Bishop, we also search for a Queen
elif attacker.name is ROOK or attacker.name is BISHOP:
if board.BOARD[possible_rank][
possible_file].name is QUEEN:
#print("Queen found while searching for R or B")
return True
# If is a different piece
else:
#print("different piece found")
break
# Square not occupied
distance += 1
def test_invalid_move_row_not_empty(self):
self.board[1]['b'] = Piece('red', 'b', 1)
self.assertFalse(self.piece.valid_move('d', 1, self.board))
def get_possible_squares(self, piece=None, square=None):
""" Returns a list of possible squares availale to move to.
Input needed: One of: piece or square, or both
piece can be one of: string - 'K'
Piece - Piece('K')
square can be one of: string - 'E4'
array coordinates - [3,5]
Usage: get_possible_squares(piece='K', square='E4')
get_possible_squares(square='E4')
get_possible_squares(piece=<Piece>) // Piece with .file and .rank
get_possible_squares(square=<Piece>) // Piece with .file and .rank
"""
#print(f"piece:{piece}, square:{square}")
# if both piece and square are None
if not piece and not square:
return None
# piece can be string or Piece object or empty
if type(piece) is str:
piece_obj = Piece(piece)
elif type(piece) is Piece:
piece_obj = piece
else:
piece_obj = self.board.BOARD[RANK[square[1]]][FILE[square[0]]]
# square can be empty, string or array coordinates
if not square:
file = piece_obj.file
rank = piece_obj.rank
elif type(square) is str:
file = FILE[square[0]]
rank = RANK[square[1]]
else:
file = square[1]
rank = square[0]
# If no piece enterred and square is EMPTY:
if not piece and self.board.BOARD[rank][file] is EMPTY:
return None
# If piece is newly created without file and rank
if not piece_obj.file:
piece_obj.file = file
piece_obj.rank = rank
# If not active colour
if piece_obj.colour is not self.whose_move():
return None
#print(f"get_possible_squares({piece_obj._id} on {Board.square_name((piece_obj.rank, piece_obj.file))})")
# Loop through directions of piece movements
possible_squares = []
for movement in piece_obj.movements:
distance = 0
possible_file = file
possible_rank = rank
max_distance = piece_obj.max_distance
# Loop until range of piece is exceeded
while distance != max_distance:
# If pawn on starting position
if piece_obj.name is PAWN:
if piece_obj.colour == WHITE and rank == 1 or \
piece_obj.colour == BLACK and rank == 6:
max_distance = 2
# copy board for testing in_check conditions
possible_board = Board(self.board.BOARD)
possible_file += movement[1]
possible_rank += movement[0]
# If passed edge of board
if possible_file < 0 or possible_file > 7 or \
possible_rank < 0 or possible_rank > 7:
#print("Can't move: off edge of board")
break
possible_square = possible_board.BOARD[possible_rank][
possible_file]
# If square is occupied
if possible_square is not EMPTY:
# If own piece in the way
if possible_square.colour == piece_obj.colour:
break
# If opposition piece in the way
else:
# If moving piece is a pawn
if piece_obj.name == PAWN:
# If forward pawn move
if movement in piece_obj.normal_movements:
break
# Test for putting self in check
possible_board.remove_piece((rank, file))
possible_board.place_piece(square=possible_square,
piece=piece_obj._id)
if self.in_check(board=possible_board,
colour=piece_obj.colour):
break
# Can capture piece
else:
possible_squares.append(
[possible_rank, possible_file])
break
# Square not occupied
else:
# If pawn
if piece_obj.name == PAWN:
# Can't move diagonal if not capturing unless en-passant
if movement in piece_obj.capture_movements:
if not self.en_passant_sq:
break
elif self.en_passant_sq and \
Board.square_name((possible_rank, possible_file)) != self.en_passant_sq.upper():
break
# If not on 2nd rank(WHITE) or 7th rank(BLACK): Can't move two squares
if piece_obj.colour == WHITE and rank != 1 and distance == 1 or \
piece_obj.colour == BLACK and rank != 6 and distance == 1:
break
# If Castling King
if piece_obj.name is KING and piece_obj.colour is WHITE:
if movement is E and self.castling_rights[0]:
if max_distance == 1:
max_distance = 2
if movement is W and self.castling_rights[1]:
if max_distance == 1:
max_distance = 2
elif piece_obj.name is KING and piece_obj.colour is BLACK:
if movement is E and self.castling_rights[2]:
if max_distance == 1:
max_distance = 2
if movement is W and self.castling_rights[3]:
if max_distance == 1:
max_distance = 2
# Test for putting self in check
possible_board.remove_piece((rank, file))
possible_board.place_piece(square=(possible_rank,
possible_file),
piece=piece_obj._id)
if not self.in_check(board=possible_board,
colour=piece_obj.colour):
possible_squares.append([possible_rank, possible_file])
else:
# Can't castle through a check
if piece_obj.name is KING:
max_distance = 1
distance += 1
if not possible_squares:
return None
else:
return possible_squares
def test_invalid_move_piece_in_the_way_2(self):
self.board[2]['d'] = Piece('red', 'd', 2)
self.assertFalse(self.piece.valid_move('e', 3, self.board))
def __init__(self, pos, color):
Piece.__init__(self, pos, color)
self.p_type = 'pawn'
def test_valid_move_to_see_other_general_red(self):
self.board[10]['d'] = self.klass('black', 'd', 9)
self.board[9]['d'] = Piece('black', 'd', 9)
self.assertTrue(self.piece.valid_move('d', 1, self.board))
def __init__(self, tile, team):
Piece.__init__(self, tile, team)
def test_invalid_move_up_left(self):
self.piece.set_coordinates('e', 7)
self.board[6]['e'] = Piece('red', 'e', 6)
self.assertFalse(self.piece.valid_move('d', 5, self.board))
def __init__(self, tile, player):
Piece.__init__(self, tile, player)
self.is_first_move = True
def setUp(self):
"""
setup the test with Piece class.
:return: None.
"""
self.piece = Piece()
def __init__(self, color, type):
Piece.__init__(self, color, type)
def test_piece_constructor_abstract(self):
"""Check an abstract piece cannot be created."""
self.assertRaises(TypeError, Piece())
def _possible_moves_(self, piece: Piece) -> List[Move]:
# returns valid moves the piece of the player [current turn] can make
return [
move for move in piece.possible_moves()
if self._can_make_move_(move)
]
