def __generate_chess_moves_tree(self, parent_node, chess_board: chess.Board, depth):
player_color = 'black' if parent_node['player_color'] == 'white' else 'white'
if chess_board.legal_moves.count == 0:
## parent'ın yapabilecegi hamle yok demek
## parent final node demek, o yüzden bu node icin gidip value hesaplanacak
board_fen = parent_node['board_fen']
piece_map = chess_board.piece_map()
value = self.__evaluate_chess_board(board_fen, chess_board.is_check(), parent_node['player_color'], piece_map)
parent_node['value'] = value
if depth == self.__max_depth: ## buna benzer bir islemi eger herhangi bir legal moves yoksa da yapmak lazim ...
for possible_move in list(chess_board.legal_moves):
chess_board.push(possible_move)
board_fen = chess_board.board_fen()
piece_map = chess_board.piece_map()
child = self.__create_node(possible_move, board_fen, player_color, depth)
parent_node['children'].append(child)
# her bir child icin value hesapla
value = self.__evaluate_chess_board(board_fen, chess_board.is_check(), player_color, piece_map)
child['value'] = value
chess_board.pop()
return
for possible_move in list(chess_board.legal_moves):
chess_board.push(possible_move)
board_fen = chess_board.board_fen()
child = self.__create_node(possible_move, board_fen, player_color, depth)
parent_node['children'].append(child)
self.__generate_chess_moves_tree(child, chess_board, depth + 1)
chess_board.pop()
def y(self, chess_board: chess.Board):
print('Ai started thinking !')
print('Finding all possible moves within next ' + str(self.__max_depth) + ' moves')
root = self.__create_node(None, chess_board.board_fen(), 'white', 0)
self.__generate_chess_moves_tree(root, chess_board, 1)
node = root
i = 0
while i < self.__max_depth:
print('Move Count: ' + str(node['depth']))
print('Player color:' + node['player_color'])
print('Chess Move:' + str(node['chess_move']))
print('Board Fen:' + node['board_fen'])
print('Value: ' + str(node['value']))
print('--------------------------------------')
node = node['children'][0]
i = i+1
print('Move Count: ' + str(node['depth']))
print('Player color:' + node['player_color'])
print('Chess Move:' + str(node['chess_move']))
print('Board Fen:' + node['board_fen'])
print('Value: ' + str(node['value']))
print('--------------------------------------')
return root
def _oldstyle_fen(game: chess.Board):
builder = []
builder.append(game.board_fen())
builder.append('w' if game.turn == chess.WHITE else 'b')
builder.append(game.castling_xfen())
builder.append(chess.SQUARE_NAMES[game.ep_square] if game.ep_square else '-')
builder.append(str(game.halfmove_clock))
builder.append(str(game.fullmove_number))
return ' '.join(builder)
def _oldstyle_fen(game: chess.Board):
builder = []
builder.append(game.board_fen())
builder.append('w' if game.turn == chess.WHITE else 'b')
builder.append(game.castling_xfen())
builder.append(
chess.SQUARE_NAMES[game.ep_square] if game.ep_square else '-')
builder.append(str(game.halfmove_clock))
builder.append(str(game.fullmove_number))
return ' '.join(builder)
def board_evaluation(board: Board, add_mobility: bool = False) -> float:
"""
Function for evaluating a chess position, given its board.
It returns positive values for white evaluation.
157 µs ± 1.87 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)"""
score = float()
fen = board.board_fen()
for piece, value in VALUE_DICT.items():
score += value * (fen.count(piece.upper()) - fen.count(piece))
if add_mobility:
mobility = get_mobility(board)
if not board.turn:
mobility *= -1
score += mobility
return score
def render_board(board: chess.Board, turn: chess.Color, output_file: Path):
scene = bpy.context.scene
# Setup rendering
scene.render.engine = "CYCLES"
scene.render.image_settings.file_format = "PNG"
scene.render.filepath = str(output_file)
scene.render.resolution_x = 1200
scene.render.resolution_y = 800
corner_coords = None
while not corner_coords:
camera_params = setup_camera(turn)
lighting_params = setup_lighting()
corner_coords = get_corner_coordinates(scene)
# Create a collection to store the position
if COLLECTION_NAME not in bpy.data.collections:
collection = bpy.data.collections.new("Chess position")
scene.collection.children.link(collection)
collection = bpy.data.collections["Chess position"]
# Remove all objects from the collection
bpy.ops.object.delete({"selected_objects": collection.objects})
piece_data = []
for square, piece in board.piece_map().items():
obj = add_piece(piece, square, collection)
piece_data.append({
"piece": piece.symbol(),
"square": chess.square_name(square),
"box": get_bounding_box(scene, obj)
})
# Write data output
data = {
"fen": board.board_fen(),
"white_turn": turn,
"camera": camera_params,
"lighting": lighting_params,
"corners": corner_coords,
"pieces": piece_data
}
with (output_file.parent / (output_file.stem + ".json")).open("w") as f:
json.dump(data, f)
# Perform the rendering
bpy.ops.render.render(write_still=1)
def put(self, board: chess.Board, move_stack, depth: int):
val = self.hash(board)
fen = board.board_fen()
#if an entry already exists in the table for the given hash key,
#check if it is the same position or not. If it is, overwrite it if the new entry is at a higher depth.
#if it is not, overwrite it.
if val in self.table:
if self.table[val][0] == fen:
if self.table[val][2] < depth:
self.table[val] = [fen, move_stack, depth, board.turn]
return
else:
return
self.table[val] = [fen, move_stack, depth, board.turn]
def heuristic(self, board: chess.Board) -> float:
result = board.result()
return AIController.RESULT_MAP[result] if result in AIController.RESULT_MAP \
else np.sum([AIController.PIECE_MAP[char] if char in AIController.PIECE_MAP else 0 for char in board.board_fen()])
'''
# test for speed
import time
loop_count = 10000
t0 = time.time()
for i in range(loop_count):
w.evaluation(b)
t1 = time.time()
print('python code time: {}'.format(t1-t0))
t0 = time.time()
for i in range(loop_count):
x = b.result()
y = b.board_fen()
z = len(y)
e.evaluation(x, y, z)
t1 = time.time()
print('c code time: {}'.format(t1-t0))
t0 = time.time()
x = list(b.legal_moves)[0]
for i in range(loop_count):
for j in range(30):
b.push(x)
b.pop()
t1 = time.time()
print('chess board legal_moves code time: {}'.format(t1-t0))
def update_history(self, board: Board, value: float) -> None:
self.evaluations[board.board_fen()] = value
def launchSf(
self,
pars,
fen,
tablebases,
):
board = Board(fen, chess960=False)
wdl = None
drawPlyCnt, resignPlyCnt = 0, 0
whiteIdx = 1
turnIdx = whiteIdx ^ (board.turn == chess.BLACK)
uciEngines = init_engines(pars)
info_handler = uci.InfoHandler()
for u in uciEngines:
u.info_handlers.append(info_handler)
u.ucinewgame()
try:
while (not board.is_game_over(claim_draw=True)):
if board.castling_rights == 0:
if len(re.findall(r"[rnbqkpRNBQKP]",
board.board_fen())) < 6:
wdl = tablebases.probe_wdl(board)
if wdl is not None:
break
uciEngines[turnIdx].position(board)
bestmove, score = uciEngines[turnIdx].go(depth=9)
score = info_handler.info["score"][1].cp
# print(score)
if score is not None:
# Resign adjudication
if abs(score) >= Resign['score']:
resignPlyCnt += 1
if resignPlyCnt >= 2 * Resign['movecount']:
break
else:
resignPlyCnt = 0
# Draw adjudication
if abs(score
) <= Draw['score'] and board.halfmove_clock > 0:
drawPlyCnt += 1
if drawPlyCnt >= 2 * Draw['movecount'] \
and board.fullmove_number >= Draw['movenumber']:
break
else:
drawPlyCnt = 0
else:
# Disable adjudication over mate scores
drawPlyCnt, resignPlyCnt = 0, 0
board.push(bestmove)
turnIdx ^= 1
result = board.result(True)
if result == '*':
if resignPlyCnt >= 2 * Resign['movecount']:
if score > 0:
result = '1-0' if board.turn == chess.WHITE else '0-1'
else:
result = '0-1' if board.turn == chess.WHITE else '1-0'
elif wdl is not None:
if wdl <= -1:
result = '1-0' if board.turn == chess.WHITE else '0-1'
elif wdl >= 1:
result = '0-1' if board.turn == chess.WHITE else '1-0'
else:
result = '1/2-1/2'
# print('tb draw')
else:
result = '1/2-1/2'
# print('draw')
# print(board.fen())
# print(re.findall(r"[rnbqkpRNBQKP]", board.board_fen()))
for u in uciEngines:
u.quit(0)
except (MemoryError, SystemError, KeyboardInterrupt, OverflowError,
OSError, ResourceWarning):
for u in uciEngines:
u.quit(1)
return result
# print(result)
exit(0)
