for key in boards:
board = boards[key].replace(' ', '').split().__reversed__()
board = array('u', ''.join(row + '_' * 8 for row in board))
assert len(board) == 128
boards[key] = board
# print(len(list(ai.moves(position, True))))
assert abs(ai.evaluate(boards['initialPosition'])) < 0.000001
assert len(list(ai.moves(boards['initialPosition'], True))) == 20
assert len(list(ai.moves(boards['difficultPosition'], True))) == 42
assert len(list(ai.moves(boards['pawnTakePosition1'], True))) == 2
assert len(list(ai.moves(boards['pawnTakePosition1'], False))) == 3
assert len(list(ai.moves(boards['pawnTakePosition2'], True))) == 3
assert len(list(ai.moves(boards['pawnTakePosition2'], False))) == 2
assert len(list(ai.moves(boards['castlingPosition'], True))) == 16
assert len(list(ai.moves(boards['castlingPosition'], False))) == 16
assert not ai.is_check(boards['kingSavePosition'], True)
assert not ai.is_check(boards['kingSavePosition'], False)
assert not ai.is_check(boards['kingThreat'], True)
assert ai.is_check(boards['kingThreat'], False)
assert ai.position_value['N'][3 + 4 * 16] == ai.position_value['N'][4 + 3 * 16]
assert ai.position_value['N'][3 + 4 * 16] == -ai.position_value['n'][3 + 4 * 16]
assert ai.position_value['P'][16] < ai.position_value['P'][5 * 16]
assert ai.position_value['p'][6 * 16] > ai.position_value['p'][2 * 16]
assert ai.position_value['P'][4 * 16] < ai.position_value['P'][4 + 4 * 16]
# the king can be taken in 5 ply
assert ai.search(boards['findCheckMate'], 4, ai.evaluate(boards['findCheckMate']), True, -99999, 99999)[1] < 10000
assert ai.search(boards['findCheckMate'], 5, ai.evaluate(boards['findCheckMate']), True, -99999, 99999)[1] > 10000
def performance_test():
ai.transpositionTable = dict()
def match(white, black, repeat):
"""This plays a single match between the white and black players and records the result."""
print(
f'\nMatch {repeat} between {white.__name__} on white and {black.__name__} on black'
)
# -------- turns and time -------
black_moves = white_moves = 0
black_time_taken = white_time_taken = 0
history = [[[piece for piece in line]
for line in initialBoard.replace(' ', '').split()]]
history[0].reverse()
to_record = {
'score': 0.5,
'cause': 'Draw due to reaching {} turns'.format(turnsToPlayFor)
}
for turn in range(1, 1 + turnsToPlayFor):
player_is_white = turn % 2
start_time = time.process_time()
white_time = initialTime + white_moves * (
timePerMove + (repeat - 1) * extraRepeatTime) - white_time_taken
black_time = initialTime + black_moves * (
timePerMove + (repeat - 1) * extraRepeatTime) - black_time_taken
try:
chosen_move = (white if player_is_white else black).main(
copy.deepcopy(history), white_time, black_time)
except shared.ThreeFoldRepetition:
to_record = {
'score':
0.5,
'cause':
'{} called a draw with the threefold repetition rule'.format(
'White' if player_is_white else 'Black')
}
break
except shared.FiftyMoveException:
to_record = {
'score':
0.5,
'cause':
'{} called a draw with the 50 move rule'.format(
'White' if player_is_white else 'Black')
}
break
run_time = time.process_time() - start_time
assert isinstance(chosen_move, list)
assert len(chosen_move) == 8
for row in chosen_move:
assert isinstance(row, list)
assert len(row) == 8
for char in row:
assert isinstance(char, str)
assert len(char) == 1
assert char in 'KQRBNP.pnbrqk'
if player_is_white:
white_time_taken += run_time
white_time = initialTime + white_moves * (
timePerMove +
(repeat - 1) * extraRepeatTime) - white_time_taken
white_moves += 1
else:
black_time_taken += run_time
black_time = initialTime + black_moves * (
timePerMove +
(repeat - 1) * extraRepeatTime) - black_time_taken
black_moves += 1
print_state(turn, chosen_move, run_time, white_time, black_time, white,
black, repeat)
if chosen_move not in legal_moves(history, player_is_white):
if player_is_white:
to_record = {
'score': 0,
'cause': 'Black won because white made an illegal move'
}
else:
to_record = {
'score': 1,
'cause': 'White won because black made an illegal move'
}
break
# is_check can fail if it is is handed an illegal move
# so these print statements are after the legal move check
if ai.is_check(ai.to_array(chosen_move), True):
print('white is in check')
if ai.is_check(ai.to_array(chosen_move), False):
print('black is in check')
print()
if ai.is_checkmate(ai.to_array(chosen_move), True):
to_record = {'score': 0, 'cause': 'Black won by checkmate'}
break
if ai.is_checkmate(ai.to_array(chosen_move), False):
to_record = {'score': 1, 'cause': 'White won by checkmate'}
break
if ai.is_stalemate(ai.to_array(chosen_move)):
to_record = {'score': 0.5, 'cause': 'Draw due to stalemate'}
break
if white_time < 0:
to_record = {
'score': 0,
'cause': 'Black won due to white running out of time'
}
break
if black_time < 0:
to_record = {
'score': 1,
'cause': 'White won due to black running out of time'
}
break
# once the move has been shown valid add it to the history
history.append(chosen_move)
to_record['white_time_taken'] = white_time_taken
to_record['black_time_taken'] = black_time_taken
to_record['white_moves'] = white_moves
to_record['black_moves'] = black_moves
print(to_record['cause'])
open(make_file_name(white, black, repeat),
'w').write(current_versions + str(to_record))