async def show_hint(self, channel: TextChannel): cursor = self.client.connection.cursor(buffered=True) get_puzzle = "SELECT c.PuzzleId, c.fen, puzzles.Themes, c.Moves " \ "FROM channel_puzzles AS c LEFT JOIN puzzles ON c.PuzzleId = puzzles.PuzzleId " \ "WHERE ChannelId = %s;" cursor.execute(get_puzzle, (str(channel.id), )) try: puzzle_id, fen, themes, moves = cursor.fetchall()[0] moves = moves.split() with open(f"{self.client.config.base_dir}/src/themes.json", "r") as f: themes_dict = json.loads(f.read()) themes = list( filter( None, [themes_dict.get(theme, None) for theme in themes.split()])) except IndexError: return # No active puzzle board = chess.Board(fen) next_move_uci = moves[0] move = board.parse_uci(next_move_uci) piece_to_move = chess.piece_name(board.piece_type_at( move.from_square)).capitalize() embed = Embed(title="Hints :bulb:", colour=0xff781f) embed.add_field(name="Piece to move", value=f"||{piece_to_move}||") embed.add_field(name="Puzzle themes", value="||" + ", ".join(themes) + "||", inline=False) await channel.send(embed=embed)
def piece_code(piece_type): fullname = chess.piece_name(piece_type) if fullname == 'knight': return 'N' if fullname == 'pawn': return 'p' return fullname[0].upper()
def promote_test(): """ Detects promotion """ hi = HardwareImplementation() while True: piece = hi.promotion_piece() print(chess.piece_name(piece)) sleep(1)
def post_options(board, tweet_id): order = [chess.QUEEN, chess.KING, chess.ROOK, chess.BISHOP, chess.KNIGHT, chess.PAWN] moves = {chess.piece_name(p).title(): [] for p in order} piece_map = board.piece_map() for m in list(board.legal_moves): piece = chess.piece_name(piece_map[m.from_square].piece_type).title() moves[piece].append(m) poll_ids = [] for p in moves: if len(moves[p]) <= 0: continue op = [] for m in moves[p]: f = chess.square_name(m.from_square).upper() t = chess.square_name(m.to_square).upper() if m.promotion: prom = chess.piece_name(m.promotion).title() op.append(move_msg_prom.format(p, f, t, prom)) continue op.append(move_msg.format(p, f, t)) # Make sure we don't leave a poll with only 1 options (tweeter doesn't accept this) if len(op) % 4 == 1: op.append(filler_text) op = [op[i:i + 4] for i in range(0, len(op), 4)] head_tweet_id = post_tweet(p + " Moves:", reply_id=tweet_id, entries=op.pop(0)) if not head_tweet_id: poll_ids.append(tweet_id) panic_clean_tweets(poll_ids) poll_ids.append(head_tweet_id) for poll_ops in op: head_tweet_id = post_tweet(p + " cont...", reply_id=head_tweet_id, entries=poll_ops) if not head_tweet_id: poll_ids.append(tweet_id) panic_clean_tweets(poll_ids) poll_ids.append(head_tweet_id) return poll_ids
def __move_to_words(self, board, move): start_square = move.from_square starting_square_string = self.__chessSquareToCoordinate(start_square) end_square = move.to_square end_square_string = self.__chessSquareToCoordinate(end_square) chess_piece = board.piece_map()[start_square] chess_piece_name = chess.piece_name(chess_piece.piece_type) chess_piece_colour = "White" if chess_piece.color else "Black" return chess_piece_colour + " " + chess_piece_name + " move from " + starting_square_string + " to " + end_square_string
def parse_piece(piece): if piece is None: return {} else: piece_type = piece.piece_type data = { "color": "WHITE" if piece.color else "BLACK", "type": piece_type, "name": piece_name(piece_type), "symbol": piece_symbol(piece_type), "value": PIECE_VALUES[piece_type], } return data
def format_coord(x, y): x, y = int(round(x)), int(round(y)) x_ = x % widthx y_ = y % widthy piece_type = (y_ + 16) // 64 piece_name = "{} {}".format( "white" if x_ // (widthx // 2) == 0 else "black", chess.piece_name(piece_type + 1)) x_ = x_ % (widthx // 2) y_ = (y_ + 16) % 64 if y_ >= 48 else y_ + 8 if default_order: # Piece centric, flipped king. piece_square_name = chess.square_name(x_ // 8 + 8 * (7 - y_ // 8)) king_square_name = chess.square_name(7 - (x_ % 8) + 8 * (y_ % 8)) else: # King centric. if piece_type == 0: piece_square_name = chess.square_name(x_ % 8 + 8 * (6 - ((y_ - 8) % 6))) king_square_name = chess.square_name(x_ // 8 + 8 * (7 - (y_ - 8) // 6)) else: piece_square_name = chess.square_name(x_ % 8 + 8 * (7 - (y_ % 8))) king_square_name = chess.square_name(x_ // 8 + 8 * (7 - y_ // 8)) neuron_id = int(numx * (y // widthy) + x // widthx) if self.args.sort_input_neurons: neuron_label = "sorted neuron {} (original {})".format( neuron_id, self.sorted_input_neurons[neuron_id]) else: neuron_label = "neuron {}".format(neuron_id) return "{}, {} on {}, white king on {}".format( neuron_label, piece_name, piece_square_name, king_square_name)
def promotion_piece(self) -> chess.Piece: """ Which piece to promote to Reads input button to select promotion piece, writes selected piece to display and waits for confirmation :return: Piece to promote to """ piece = chess.QUEEN while True: if self._perform_safe(getattr)(self._buttons[0], 'value'): piece = chess.QUEEN if self._perform_safe(getattr)(self._buttons[1], 'value'): piece = chess.ROOK if self._perform_safe(getattr)(self._buttons[2], 'value'): piece = chess.BISHOP if self._perform_safe(getattr)(self._buttons[3], 'value'): piece = chess.KNIGHT self.display(chess.piece_name(piece)) if self._perform_safe(getattr)(self._buttons[4], 'value'): return piece
buffer = io.BytesIO() svg2png(bytestring=chessboard_svg, write_to=buffer) # Chessboard to PNG in memory chessboard = Image.open(buffer) new_im = Image.new('RGB', (1920, 1080)) new_im.paste(chessboard, (0,0,400,400)) if image: new_im.paste(image, (400,0)) if is_check: new_im.paste(images["king_under_threat"], (0, 400)) new_im.save(filename) board = first_game.board() svg = chess.svg.board(board=board) render_image("render/0.jpg", svg) audio = AudioSegment.silent(duration=1000) moves = list(first_game.mainline_moves()) for i, move in enumerate(tqdm(moves)): board.push(move) if board.is_game_over(): print(board.result()) piece_type = chess.piece_name(board.piece_type_at(move.to_square)) svg = chess.svg.board(board=board, lastmove=move, size=400) render_image(f"render/{i + 1}.jpg", svg, images[piece_type], board.is_check()) clip = audio_clips[piece_type] if board.is_check(): clip = clip.overlay(audio_clips["alert"]) audio += clip audio.export("audio.mp3", format="mp3")
for move in board.legal_moves: if move.promotion == None or move.promotion == 5: entry = move.from_square * 73 + move.to_square else: diff = abs(move.from_square-move.to_square) - 8 if diff < 0: diff = 1 elif diff > 0: diff = 2 entry = move.from_square*73 + 63 + diff*3 + (move.promotion-1) lmvs[entry] = move print('{0} - {1}, {2}, {3}, {4}'.format(move, move.from_square,move.to_square, move.promotion, move.uci())) print(entry) chess.piece_name(4) chessenv = Game() memory = Memory(config.MEMORY_SIZE) memory.commit_stmemory(env.identities,env.gameState,env.actionSpace) memory.stmemory pool = multiprocessing.Pool(2) out = zip(pool.map(_selfplay, range(0, 2))) t = tuple(out) len(t) chessenv.action_size
async def run_engine(uid, ws): game: GameObject = games[uid] board = game.board.copy() await start_engine(game, ws) if not game.should_run(): return # Reset old arrows when engine is about to run game.arrows.clear() # print(board) limit: chess.engine.Limit = chess.engine.Limit() use_depth = settings.config.getboolean("gui", "use_depth") use_time = settings.config.getboolean("gui", "use_time") use_nodes = settings.config.getboolean("gui", "use_nodes") if use_depth: limit.depth = settings.config.getint("gui", "depth") if use_time: limit.time = settings.config.getfloat("gui", "time") if use_nodes: limit.nodes = settings.config.getint("gui", "nodes") if not use_depth and not use_time and not use_nodes: limit.depth = 8 await ws.send( serialize_message("error", "No limit set, using default depth of 8")) if settings.config.getboolean("gui", "clear_log"): try: debug_log_file = settings.engine_config.get( "engine", "debug log file") open(debug_log_file, "w").close() except Exception: pass # Set latest ECO for current board eco_name = eco.get_name(board.epd()) if eco_name != "": game.eco = eco_name # Look for opening moves from books opening_moves = [] if settings.config.getboolean("gui", "use_book"): bookfiles = books.load_books("books") for bookfile in bookfiles: read_book(bookfile, opening_moves, board, [], 0) if len(opening_moves) > 0: opening_moves = sorted(opening_moves, key=lambda x: sum([y.weight for y in x]), reverse=True) best_san = board.san(opening_moves[0][0].move) best_piece = chess.piece_name( board.piece_at( opening_moves[0][0].move.from_square).piece_type).capitalize() mate_in = None opening_dict = defaultdict(list) for move, *reply in opening_moves: reply = reply[0] if len(reply) > 0 else None raw_keys = [x.raw_move for x in opening_dict] raw_key = move.raw_move # If the raw has already been added if raw_key in raw_keys: # No need to do anything if there is no reply anyway if reply: # Find the raw move and append reply to there instead existing_key = None for key in opening_dict: if key.raw_move == raw_key: existing_key = key if existing_key: # Check if the list contains raw_move of the reply already raw_moves = [ x.raw_move for x in opening_dict[existing_key] ] raw_move = reply.raw_move if raw_move not in raw_moves: opening_dict[key].append(reply) else: if reply: opening_dict[move].append(reply) else: opening_dict[move] = [] multi_pv = [] list_index = 0 for move, replies in opening_dict.items(): list_index += 1 score = move.weight pv = [] lan = [] pv.append(board.san(move.move)) lan.append(board.lan(move.move)) arrow = drawing.get_arrow(move.move, board.turn, 0) game.arrows[list_index].append(arrow) board.push(move.move) # Get EPD after the first push is moved epd = board.epd() opponents_turn = board.turn for reply in replies: pv.append(board.san(reply.move)) lan.append(board.lan(reply.move)) arrow = drawing.get_arrow(reply.move, opponents_turn, 1) game.arrows[list_index].append(arrow) # Unwind the move stack board.pop() line = { "multipv": list_index, "score": score, "pv": pv, "lan": lan, "eco": eco.get_name(epd), } multi_pv.append(line) await ws.send( serialize_message( "multipv", { "multipv": multi_pv, "turn": board.turn, "current_eco": game.eco, "book": True, "best_piece": best_piece })) else: # If there no opening moves were found, use engine to analyse instead if game.engine is None: print( "Trying to analyse but engine has not been initialized, check engine path." ) await ws.send( serialize_message( "error", "Trying to analyse but engine has not been initialized, check engine path." )) return multi_pv = settings.config.getint("gui", "multipv") print("Starting analysis with limit", limit, "for", multi_pv, "pv(s)") try: game.analysing = True results = await game.engine.analyse(board=board, limit=limit, multipv=multi_pv, game=uid, info=chess.engine.INFO_ALL) except Exception as err: print("Engine analysis failed.") if DEBUG: print(err) return finally: game.analysing = False if results is None or results[0] is None: print("Analysis stopped before results, returning...") return best_move = results[0].pv[0] best_san = board.san(best_move) best_piece = chess.piece_name( board.piece_at(best_move.from_square).piece_type).capitalize() mate_in = results[0].score.relative.moves if results[0].score.is_mate( ) else None multipv_data = [] for multi_pv in results: move_counter = 0 pv = [] lan_pv = [] epd = "" for index, move in enumerate(multi_pv.pv): san = board.san(move) lan = board.lan(move) arrow = drawing.get_arrow(move, board.turn, move_counter // 2) pv_index = 1 if multi_pv.multipv is None else multi_pv.multipv game.arrows[pv_index].append(arrow) pv.append(san) lan_pv.append(lan) board.push(move) # Get EPD for the first move if index == 0: epd = board.epd() move_counter += 1 for _ in range(move_counter): board.pop() if multi_pv.score.is_mate(): score = "#" + str(multi_pv.score.relative.moves) else: score = multi_pv.score.relative.cp unit = { "multipv": multi_pv.multipv, "pv": pv, "lan": lan_pv, "score": score, "eco": eco.get_name(epd), } multipv_data.append(unit) await ws.send( serialize_message( "multipv", { "multipv": multipv_data, "turn": board.turn, "current_eco": game.eco, "book": False, "best_piece": best_piece }, )) if DEBUG: print( "Best move:", best_piece if settings.config.getboolean( "gui", "piece_only") else best_san) if mate_in is not None: print("Mate in", mate_in) if settings.config.getboolean("gui", "draw_board"): svg = drawing.draw_svg_board(game, 1) await ws.send(serialize_message("board", svg)) if settings.config.getboolean("gui", "use_voice"): if settings.config.getboolean("gui", "piece_only"): voice.say(best_piece, True) else: voice.say(best_san, False) game.missed_moves = False
def sequenceGenerator(uciMove, board): ''' INPUT: uciMove -> Move in UCI format to analyze it. board -> Game state, this is a chess.Board() object. OUTPUT: result -> Is empty if a valid move is not detected, if it is detected then it is a dictionary data structure with two values: "seq": String with a sequence of chess coordinates to guide th robot movement. "type": String with type of movement, Castling-Promotion-Move-Capture-Passant. ''' result = {} move = chess.Move.from_uci(uciMove) first = uciMove[:2] second = uciMove[2:4] last = uciMove[-1] graveyard = "k0" if last < '1' or last > '8': # Promotion Evaluation: Check if last char is a letter. if board.is_capture(move): result["seq"] = second + graveyard + first + second else: result["seq"] = first + second result["type"] = "Promotion" elif board.turn and uciMove == "e1g1" and chess.piece_name( board.piece_type_at(chess.SQUARE_NAMES.index( "e1"))) == "king": #White King side castling result["seq"] = first + second + "h1f1" result["type"] = "White King Side Castling" elif board.turn and uciMove == "e1c1" and chess.piece_name( board.piece_type_at(chess.SQUARE_NAMES.index( "e1"))) == "king": #White Queen side castling result["seq"] = first + second + "a1d1" result["type"] = "White Queen Side Castling" elif not board.turn and uciMove == "e8g8" and chess.piece_name( board.piece_type_at(chess.SQUARE_NAMES.index( "e8"))) == "king": #Black King side castling result["seq"] = first + second + "h8f8" result["type"] = "Black King Side Castling" elif not board.turn and uciMove == "e8c8" and chess.piece_name( board.piece_type_at(chess.SQUARE_NAMES.index( "e8"))) == "king": #Black Queen side castling result["seq"] = first + second + "a8d8" result["type"] = "White Queen Side Castling" elif board.is_en_passant(move): # En Passant if board.turn: squareFile = chess.square_file(chess.SQUARE_NAMES.index(first)) squareRank = chess.square_rank(chess.SQUARE_NAMES.index(first)) result["seq"] = chess.SQUARE_NAMES[chess.square( squareFile - 1, squareRank)] + graveyard + first + second result["type"] = "Passant" else: squareFile = chess.square_file(chess.SQUARE_NAMES.index(first)) squareRank = chess.square_rank(chess.SQUARE_NAMES.index(first)) result["seq"] = chess.SQUARE_NAMES[chess.square( squareFile + 1, squareRank)] + graveyard + first + second result["type"] = "Passant" elif board.is_capture(move): # Capture move result["seq"] = second + graveyard + first + second result["type"] = "Capture" else: # Normal move result["seq"] = uciMove result["type"] = "Move" return result
def piece_to_name(self, piece): name = chess.piece_name(piece.piece_type) color = "_w" if piece.color == chess.WHITE else "_b" return f"{name}{color}"