def fmtbrd(board: chess.Board, color):
flip = True if color == 'black' else False
colors = {
'square dark': '#769656',
'sqaure light': '#eeeed2',
'arrow green': '#2a52be',
'arrow blue': '#2a52be',
'arrow red': '#2a52be',
'arrow yellow': '#2a52be'
}
try:
last = board.peek().uci()
arrows = [
chess.svg.Arrow(chess.parse_square(last[0:2]),
chess.parse_square(last[2:4]))
]
f = BytesIO(
bytes(chess.svg.board(board,
flipped=flip,
colors=colors,
arrows=arrows),
encoding='utf-8'))
except IndexError:
f = BytesIO(
bytes(chess.svg.board(board, flipped=flip, colors=colors),
encoding='utf-8'))
f.seek(0)
new_f = BytesIO()
drawing = svg2rlg(f)
renderPM.drawToFile(drawing, new_f)
new_f.seek(0)
return discord.File(fp=new_f, filename='board.png')
def exceptions(board, move):
u = 0
# Book Moves no começo do jogo é bom
if board.fullmove_number < 3 and move in [
"e7e5", "e7e6", "d7d5", "d7d6", "g8f6", "b8c6", "c7c5", "g7g5"
]:
u += 1
# Se um movimento coloca o rei do adversário em xeque, é muito bom
if board.gives_check(move):
u += 5
# Se um movimento é uma captura, a utilidade dessa captura é o quanto eu ganho com ela
if board.is_capture(move):
my = chess.BaseBoard.piece_at(board, chess.parse_square(str(move)[:2]))
xs = chess.BaseBoard.piece_at(board,
chess.parse_square(str(move)[2:4]))
if board.is_en_passant(move):
if my.color == chess.BLACK:
xs = chess.Piece.from_symbol("P")
else:
xs = chess.Piece.from_symbol("p")
if xs.piece_type - my.piece_type >= 0:
u += (xs.piece_type - my.piece_type)
# Se o movimento me leva a um quadrado que está sendo atacado por alguém, é um movimento ruim
if len(chess.BaseBoard.attacks(board, chess.parse_square(
str(move)[2:4]))) > 0:
u -= 1
# Se o movimento ou o estado já tiver ocorrido nas ultimas 10 rodadas, é um movimento muito ruim
board.push(move)
if chess.BaseBoard.board_fen(board) in lastTenStates or str(
move) in lastTenMoves:
u -= 10
board.pop()
# retorna o resultado da análise dessas exceções
return u
def make_move(self,
is_white: bool,
from_square: str,
to_square: str,
promotion=None):
piece_positions = self.get_piece_positions(is_white)
if from_square not in piece_positions:
raise Exception(
"Attempted to make move from a square that doesn't have one of the player's pieces."
)
square_1 = chess.parse_square(from_square)
square_2 = chess.parse_square(to_square)
board = self.get_board()
move = board.find_move(square_1, square_2)
board.push(move)
# insert into DB table
new_fen = board.fen()
vals_to_insert = list()
vals_to_insert.append('NULL')
vals_to_insert.append(str(int(time.time())))
vals_to_insert.append("'" + from_square + "'")
vals_to_insert.append("'" + to_square + "'")
vals_to_insert.append("'" + new_fen + "'")
vals_to_insert_appended = " VALUES ( " + ', '.join(
vals_to_insert) + ')'
script = "INSERT INTO " + _MOVES_TABLE_NAME + vals_to_insert_appended + ';'
self.conn.execute(script)
self.conn.commit()
def attacker(_user_id, _attacker, _color, _square):
"""
checks whether a piece is being attacked by another piece.
"""
_board = boards[_user_id]
_attackers = _board.attackers(convert(_color), chess.parse_square(_square))
return chess.parse_square(_attacker) in _attackers
def from_pgn(cls, pgn: str) -> Arrow:
"""
Parses an arrow from the format used by ``[%csl ...]`` and
``[%cal ...]`` PGN annotations, e.g., ``Ga1`` or ``Ya2h2``.
Also allows skipping the color prefix, defaulting to green.
:raises: :exc:`ValueError` if the format is invalid.
"""
if pgn.startswith("G"):
color = "green"
pgn = pgn[1:]
elif pgn.startswith("R"):
color = "red"
pgn = pgn[1:]
elif pgn.startswith("Y"):
color = "yellow"
pgn = pgn[1:]
elif pgn.startswith("B"):
color = "blue"
pgn = pgn[1:]
else:
color = "green"
tail = chess.parse_square(pgn[:2])
head = chess.parse_square(pgn[2:]) if len(pgn) > 2 else tail
return cls(tail, head, color=color)
def isAlgebraicNotation(alg_notation: str) -> bool:
try:
chess.parse_square(alg_notation)
except ValueError:
return False
return True
def merge_processed_moves(first_moves, second_moves):
bug_board = BughouseBoard()
all_raw_moves = first_moves + second_moves
all_raw_moves.sort(key=op.itemgetter(-1))
all_moves = []
#this is an assumption, need to really look at time control...
times = [
{
chess.WHITE: 1800,
chess.BLACK: 1800,
},
{
chess.WHITE: 1800,
chess.BLACK: 1800,
},
]
moving_players = [chess.WHITE, chess.WHITE]
for raw_move in all_raw_moves:
board_num, hite_name, black_name, white_elo, black_elo, moving_player, move, move_time, total_time = raw_move
#print(raw_move)
prev_move_time = times[board_num][moving_player]
delta_move_time = prev_move_time - move_time
other_moving_player = moving_players[not board_num]
times[board_num][moving_player] = move_time
#times[not board_num][other_moving_player] -= delta_move_time
#print(board_num, moving_player, move)
move_obj = chess.Move(
from_square=chess.parse_square(move["from"])
if move["from"] != None else chess.A1,
to_square=chess.parse_square(move["to"]),
promotion=chess.Piece.from_symbol(move["promotion"]).piece_type
if move["promotion"] != None else None,
drop=chess.Piece.from_symbol(move["drop"]).piece_type
if move["drop"] != None else None,
)
#print(move)
bug_board.move(board_num, move_obj)
fens = bug_board.get_fens()
first_board_fen, second_board_fen = fens
#print(fens)
processed_move = {
"board_num": board_num,
"moving_player": moving_player,
"from_square": move["from"],
"to_square": move["to"],
"drop": move["drop"],
"promotion": move["promotion"],
"first_white_time": times[0][chess.WHITE],
"first_black_time": times[0][chess.BLACK],
"second_white_time": times[1][chess.WHITE],
"second_black_time": times[1][chess.BLACK],
"first_board_fen": first_board_fen,
"second_board_fen": second_board_fen,
}
all_moves.append(processed_move)
return all_moves
def make_svg(self, request):
try:
board = chess.Board(request.query["fen"])
except KeyError:
raise aiohttp.web.HTTPBadRequest(reason="fen required")
except ValueError:
raise aiohttp.web.HTTPBadRequest(reason="invalid fen")
try:
size = min(max(int(request.query.get("size", 360)), 16), 1024)
except ValueError:
raise aiohttp.web.HTTPBadRequest(reason="size is not a number")
try:
uci = request.query.get("lastMove") or request.query["lastmove"]
lastmove = chess.Move.from_uci(uci)
except KeyError:
lastmove = None
except ValueError:
raise aiohttp.web.HTTPBadRequest(reason="lastMove is not a valid uci move")
try:
check = chess.parse_square(request.query["check"])
except KeyError:
check = None
except ValueError:
raise aiohttp.web.HTTPBadRequest(reason="check is not a valid square name")
try:
arrows = [chess.svg.Arrow.from_pgn(s.strip()) for s in request.query.get("arrows", "").split(",") if s.strip()]
except ValueError:
raise aiohttp.web.HTTPBadRequest(reason="invalid arrow")
try:
squares = chess.SquareSet(chess.parse_square(s.strip()) for s in request.query.get("squares", "").split(",") if s.strip())
except ValueError:
raise aiohttp.web.HTTPBadRequest(reason="invalid squares")
flipped = request.query.get("orientation", "white") == "black"
coordinates = request.query.get("coordinates", "0") in ["", "1", "true", "True", "yes"]
try:
colors = THEMES[request.query.get("colors", "lichess-brown")]
except KeyError:
raise aiohttp.web.HTTPBadRequest(reason="theme colors not found")
return chess.svg.board(board,
coordinates=coordinates,
flipped=flipped,
lastmove=lastmove,
check=check,
arrows=arrows,
squares=squares,
size=size,
colors=colors)
def darJugadaParam(self, move):
try:
movida = chess.Move(chess.parse_square(move[0:2]),
chess.parse_square(move[2:4]))
if movida in self.tablero.legal_moves:
return movida
else:
raise Exception
except:
return "Jugada inválida"
def darJugada(self, ins):
# while True:
#ins = input("Da la movida que quieras hacer con el formato a1a2\n")
try:
movida = chess.Move(chess.parse_square(ins[0:2]),
chess.parse_square(ins[2:4]))
if movida in self.tablero.legal_moves:
return movida
else:
raise Exception
except:
#print("Jugada inválida")
return "Jugada invalida"
def update_button(self, button):
self.move_str += button.id
# print(self.move_str)
if len(self.move_str) == 4:
Cache.remove('kv.image')
Cache.remove('kv.texture')
move = chess.Move(from_square=chess.parse_square(
self.move_str[:2]),
to_square=chess.parse_square(self.move_str[2:4]))
move = self.check_pawn_promotion(move)
print(f"Your move: {move}")
if move in self.board.legal_moves:
self.board.push(move)
[
Path(m).unlink(missing_ok=True)
for m in list(Path("moves/").glob("chess*"))
]
save_name = f'moves/chess_{str(move)}_{self.board.turn}.png'
svg2png(bytestring=chess.svg.board(self.board, size=350),
write_to=save_name)
self.rect.source = save_name
if self.board.is_game_over():
return self.declare_winner()
# ai_move = np.random.choice(list(self.board.legal_moves))
# ai_move = list(self.board.legal_moves)[0]
# print(ai_move)
ai_move = self.engine.make_move(self.board)
print(f"AI move: {ai_move}")
if isinstance(ai_move, chess.Move):
self.board.push(ai_move)
else:
return self.declare_winner()
if self.board.is_game_over():
return self.declare_winner()
[
Path(m).unlink(missing_ok=True)
for m in list(Path("moves/").glob("chess*"))
]
save_name = f'moves/chess_{str(move)}_{self.board.turn}.png'
svg2png(bytestring=chess.svg.board(self.board, size=350),
write_to=save_name)
self.rect.source = save_name
self.move_str = ""
def attacks(_user_id, _square):
"""
displays attacks on a piece.
"""
_board = boards[_user_id]
_attacks = _board.attacks(chess.parse_square(_square))
generate_image(_board, _squares=_attacks)
def attackers(_user_id, _color, _square):
"""
displays attackers for a piece.
"""
_board = boards[_user_id]
squares = _board.attackers(convert(_color), chess.parse_square(_square))
generate_image(_board, _squares=squares)
def get_eval_data(args, eval_examples):
random.seed(42)
output_dir = args.output_dir
output_file_end = path.join(output_dir, f"end_{args.prefix_size}.jsonl")
output_file_start = path.join(output_dir,
f"start_{args.prefix_size}.jsonl")
with open(output_file_end, 'w') as end_w, open(output_file_start,
'w') as start_w:
for info_dict in eval_examples:
output_dict = OrderedDict()
output_dict["prefix"] = info_dict["prefix"]
output_dict["oracle_prefix"] = info_dict["oracle_prefix"]
# Ending Square tasks
# Moves starting with actual starting square
output_dict["piece_type"] = info_dict["actual_piece_type"]
output_dict["starting_square"] = info_dict[
"actual_starting_square"]
output_dict["ending_square"] = info_dict[
"actual_ending_square"] # ExM
output_dict["legal_ending_square"] =\
info_dict["legal_ending_square"][output_dict["starting_square"]] # LgM
# Other LgM
all_start_squares = list(info_dict["legal_ending_square"].keys())
all_start_squares.remove(output_dict["starting_square"])
# Sort before random choice to ensure reproducibility
other_starting_square = random.choice(sorted(all_start_squares))
piece_type_at_other_square = info_dict["board"].piece_type_at(
chess.parse_square(other_starting_square))
output_dict["other_piece_type"] = chess.PIECE_SYMBOLS[
piece_type_at_other_square].upper()
output_dict["other_starting_square"] = other_starting_square
output_dict["other_ending_square"] = info_dict[
"legal_ending_square"][other_starting_square]
end_w.write(json.dumps(output_dict) + "\n")
# Starting square data
output_dict = OrderedDict()
output_dict["prefix"] = info_dict["prefix"]
output_dict["oracle_prefix"] = info_dict["oracle_prefix"]
# Moves for the given piece type
output_dict["piece_type"] = info_dict["actual_piece_type"]
output_dict["starting_square"] = info_dict[
"actual_starting_square"] # ExM
# LgM - convert set to list
output_dict["legal_starting_square"] = list(
info_dict["legal_starting_square"][output_dict["piece_type"]])
# Other LgM
all_piece_types = list(info_dict["legal_starting_square"].keys())
all_piece_types.remove(info_dict["actual_piece_type"])
other_piece_type = random.choice(sorted(all_piece_types))
output_dict["other_piece_type"] = other_piece_type
# set to list
output_dict["other_starting_square"] = list(
info_dict["legal_starting_square"][other_piece_type])
start_w.write(json.dumps(output_dict) + "\n")
def findMove():
# set counter for resUP
global moveCounter
moveCounter += 1
move_found = compareImages(MyMovePath)
while not move_found:
print("ERROR images are the same, trying again")
time.sleep(1.5)
move_found = compareImages(MyMovePath)
#find the opponents move origin
cv2_px = cv2Move("OpMove.png", "pieceImages\Highlight.png", 0.97)
chess_str_1 = PxtoGrid(cv2_px[0], cv2_px[1])
#find the corresponding piece move
chess_square_index = chess.parse_square(chess_str_1)
if board.piece_at(chess_square_index) is None:
playsound('Warning.mp3')
Op_piece_moved = input(
"Base move missed, what square did it originate from:")
time.sleep(3)
else:
Op_piece_moved = board.piece_at(chess_square_index).symbol().lower()
print(str(Op_piece_moved))
print(Op_piece_moved, "was moved by opponent with comparison file at ",
imageDict[Op_piece_moved][0])
targetPath = "pieceImages\\" + imageDict[Op_piece_moved][0]
cv2_px = cv2Move("OpMove.png", targetPath, imageDict[Op_piece_moved][1])
chess_str_2 = PxtoGrid(cv2_px[0], cv2_px[1])
full_str = chess_str_1 + chess_str_2
print('Resolved string', full_str)
return full_str
def moves_to_consider(self, board):
vis_board = board.copy()
new_game = FogChess(board)
if board.turn:
our_board = new_game.white_board
else:
our_board = new_game.black_board
if our_board in moves_to_consider:
return moves_to_consider[our_board]
for i in range(0, len(our_board), 2):
if our_board[i] == "?":
vis_board.remove_piece_at(
chess.parse_square(index_to_chess_pos[i]))
move_scores = {}
for move in board.pseudo_legal_moves:
h = self.move_heuristic(move, vis_board)
move_scores[move] = h
# print("moves considered")
moves_to_consider[our_board] = list(
dict(
sorted(move_scores.items(), key=itemgetter(1),
reverse=True)[:NUM_MOVES_CONSIDERING]).keys())
return moves_to_consider[our_board]
def handle_move(move):
global user_ids
print(move)
board = user_ids[request.sid]
if board.is_game_over():
print('game over')
emit('move_validation', {'valid': False})
game_move = chess.Move(chess.parse_square(move['from_square']),
chess.parse_square(move['to_square']),
promotion=5)
if game_move in board.legal_moves:
board.push(random.choice(list(board.legal_moves)))
print(board.fen())
emit('botMove', {'fen': board.fen()})
else:
print('invalid move')
emit('move_validation', {'valid': False})
def check_pawn_promotion(self, move):
move_str = str(move)
move_from = move_str[:2]
piece_to_move = str(self.board.piece_at(chess.parse_square(move_from)))
if piece_to_move not in ["p", "P"]:
return move
move_to = move_str[2:]
if move_from[1] in ["2", "7"] and move_to[1] in ["1", "8"]:
move.promotion = chess.QUEEN
return move
def mostraTabuleiroBonitinho():
colunas = ["a", "b", "c", "d", "e", "f", "g", "h"]
print(""" a b c d e f g h """)
for linha in range(8,0,-1):
print(f"{linha} ", end='', flush=True)
for coluna in colunas:
square = chess.parse_square(coluna + linha.__str__())
print(f"{BACKGROUND[square % 2, linha % 2]}{acharPeca(square)}", Style.RESET_ALL, end='', flush=True)
print()
def test_trapped(self):
self.assertFalse(
util.is_trapped(
chess.Board("q3k3/7p/8/4N2q/3PP3/4B3/8/4K2R b - - 0 1"),
parse_square("h5")))
self.assertTrue(
util.is_trapped(
chess.Board("q3k3/7p/8/4N2q/3PP3/4B3/7R/4K2R b - - 0 1"),
parse_square("h5")))
self.assertFalse(
util.is_trapped(
chess.Board("q3k3/7p/8/4N2b/3PP3/4B3/7R/4K2R b - - 0 1"),
parse_square("h5")))
self.assertFalse(
util.is_trapped(
chess.Board("4k3/7p/8/4N2q/3PP2p/4B3/8/4K3 b - - 0 1"),
parse_square("h5")))
self.assertTrue(
util.is_trapped(chess.Board("8/3P4/8/4N2b/7p/6N1/8/4K3 b - - 0 1"),
parse_square("h5")))
def sortPerPiece(legalMoves):
pieces = []
for _ in range(7):
pieces.append([])
for move in legalMoves:
square = chess.parse_square(move[:2])
p = jogo.board.piece_at(square)
pieces[p.piece_type].append(move)
for piece in range(1, 7):
print(f"{ev.pieceName[piece]} = {pieces[piece]}")
def helper_adv(G, piece, square_name, node_name):
board = chess.Board(None)
piece = chess.Piece.from_symbol(piece)
square = chess.parse_square(square_name)
board.set_piece_at(square, piece)
attacks = board.attacks(square)
for sq in attacks:
square_name = chess.square_name(sq)
for node in G.nodes():
if node.endswith(square_name):
G.add_edge(node, node_name)
def shalloweval(self, piececolor):
if (self.draw):
return 0
eval = 0
is_endgame = self.e.is_endgame(self.getfen())
valfinder = SquareValue()
#loop through each square of the board
#If a piece exists, add it's value to the eval
outcome = self.board.outcome(claim_draw=False)
if (outcome):
if (outcome.winner == piececolor): #bot wins
eval = 20000
elif (outcome.winner == (not piececolor)): #opponent wins
eval = -20000
else:
eval = 0
else:
i = 0
while (i < 64):
piece = self.getpiece(i)
if (piece):
value = valfinder.getpiecevalue(i, piececolor, piece,
is_endgame)
eval += value
if ((piece.piece_type > 1) and piece.piece_type < 6):
if (piece.color != self.board.turn):
attackers = list(
self.board.attackers(
(not (piece.color)),
chess.parse_square(chess.square_name(i))))
#defenders = list(self.board.attackers((piece.color), chess.parse_square(chess.square_name(i))))
j = 0
while (j < len(attackers)):
#if len(defenders) == 0:
# eval -= value
# break
att = abs(
valfinder.getpiecevalue(
attackers[j], piececolor,
self.board.piece_at(attackers[j]),
is_endgame))
#att = self.getpiece(attackers[j]).piece_type
if (abs(value) > att):
#if piece.piece_type >= att:
if (abs(value) - abs(att) >= 100):
eval -= value
break
j += 1
i = i + 1
return eval
def findmove():
# Find available moves in sorted order
l = []
# Start with last best moves follow up ✓
# With current scoring, this is slower
# Prioritize capture of last moved piece ✓
if len(board.move_stack) > 0:
last = str(board.peek())
piece = chess.parse_square(last[2:4])
froms = board.attackers(board.turn, piece)
move = [chess.Move(i, piece) for i in froms]
l.extend([m for m in move if board.is_legal(m)])
ours = [board.pieces(j, board.turn) for j in range(1, 7)]
for ptypes in ours:
for froms in ptypes:
# Killer moves: capture threatining pieces ✓
attackers = board.attackers(not board.turn, froms)
attacks = board.attacks(froms)
moves = [
chess.Move(froms, to) for to in attacks
if attackers.__contains__(to)
]
# Other captures: if you can capture do it ✓
moves.extend([
chess.Move(froms, to) for to in attacks
if not attackers.__contains__(to)
])
l.extend([move for move in moves if board.is_legal(move)])
# Pawn promotion: try to promte pawn ✓/✓
if board.turn:
moves = [
chess.Move(pawn, pawn + 8, 5) for pawn in ours[0] if pawn >= 8 * 6
]
else:
moves = [
chess.Move(pawn, pawn - 8, 5) for pawn in ours[0] if pawn < 8 * 2
]
l.extend([m for m in moves if board.is_legal(m)])
# All other moves ✓
ll = list(board.legal_moves)
l.extend(ll)
l = list(OrderedDict.fromkeys(l))
if len(l) is not len(ll): # Checks if list has illegal moves
print("Illigal move detected", len(ll), len(l))
l = [i for i in l if board.is_legal(i)]
return l
def get_move_direction(move):
print(move)
turn = board.turn
tile1 = move[0:2]
tile2 = move[2:4]
ptile1 = chess.parse_square(tile1)
ptile2 = chess.parse_square(tile2)
# print(f'color {board.color_at(ptile1)}')
# print(f'color {board.color_at(ptile2)}')
print(f'turn {turn}, tile1 {tile1}, tile2 {tile2}')
if turn:
# White's turn, white possible moves: W -> B or W -> None
zerotile = (tile1 if board.color_at(ptile1) else tile2)
onetile = (tile2 if board.color_at(ptile1) else tile1)
else:
zerotile = (tile1 if not board.color_at(ptile1) else tile2)
onetile = (tile2 if not board.color_at(ptile1) else tile1)
move = f'{zerotile}{onetile}'
print(f'Move direction: {move}')
return move
def update_board(self, board_pos):
for coord in self.BOARD_COORDS.keys():
piece = board_pos.piece_at(chess.parse_square(coord))
vec_coords = self.BOARD_COORDS[coord]
pygame.draw.rect(
self.WIN, vec_coords[1],
pygame.Rect(vec_coords[0], (CELL_SIZE, CELL_SIZE)))
if piece is None:
pass
else:
piece_code = PIECE_TRANSLATION[str(piece)]
piece_img = pygame.transform.scale(
pygame.image.load(
os.path.join(ASSETS_DIR, piece_code + '.png')),
(CELL_SIZE, CELL_SIZE))
self.WIN.blit(piece_img, vec_coords[0])
pygame.display.update()
def open_board(game):
board = game.board
board.clear()
white_king = chess.Piece(6, True)
black_king = chess.Piece(6, False)
board.set_piece_at(chess.parse_square("a1"), white_king)
board.set_piece_at(chess.parse_square("h8"), black_king)
white_queen = chess.Piece(5, True)
black_queen = chess.Piece(5, False)
white_knight = chess.Piece(2, True)
black_knight = chess.Piece(2, False)
board.set_piece_at(chess.parse_square("b1"), white_queen)
board.set_piece_at(chess.parse_square("g8"), black_queen)
board.set_piece_at(chess.parse_square("b2"), white_knight)
board.set_piece_at(chess.parse_square("g7"), black_knight)
white_bishop = chess.Piece(3, True)
black_bishop = chess.Piece(3, False)
board.set_piece_at(chess.parse_square("a2"), white_bishop)
board.set_piece_at(chess.parse_square("h7"), black_bishop)
def test_simulate_move(
move_history: str,
requested_move: str,
expected_taken_move: str,
expected_capture_square: Optional[str],
):
board = chess.Board()
for move in move_history.split():
move = chess.Move.from_uci(move)
assert move == chess.Move.null() or board.is_pseudo_legal(
move
), f"Move history is invalid! Move {move} is not pseudo-legal on board\n{board}"
board.push(move)
assert simulate_move(board, chess.Move.from_uci(requested_move)) == (
chess.Move.from_uci(expected_taken_move),
None
if expected_capture_square is None
else chess.parse_square(expected_capture_square),
)
def black_checkmate(game):
board = game.board
board.clear()
board.turn = False
white_pawn1 = chess.Piece(1, True)
white_pawn2 = chess.Piece(1, True)
white_knight = chess.Piece(2, True)
white_king = chess.Piece(6, True)
black_king = chess.Piece(6, False)
black_rook = chess.Piece(4, False)
board.set_piece_at(chess.parse_square("a2"), white_pawn1)
board.set_piece_at(chess.parse_square("b2"), white_pawn2)
board.set_piece_at(chess.parse_square("a1"), white_king)
board.set_piece_at(chess.parse_square("b3"), white_knight)
board.set_piece_at(chess.parse_square("h8"), black_king)
board.set_piece_at(chess.parse_square("h7"), black_rook)
async def game_update(self, member, move):
if member == self.current_turn:
try:
square = chess.parse_square(move[:2])
color = self.board.color_at(square=square)
except ValueError:
return "Invalid Move"
if (member == self.playerTwo and color) or (
member == self.playerOne and not color
):
try:
self.board.push_san(move)
except ValueError:
return "Invalid Move"
self.swap_turns()
p, r = self.check_end()
winner, loser, tie = None, None, False
if p != 0:
if p == 1:
tie = True
else:
winner, loser = p[0]
await self.end_game(winner=winner, loser=loser, tie=tie)
content, embed = self.create_content_embed(
winner=winner, tie=tie, result=r
)
await self.update_message(content=content, embed=embed)
return
else:
return "Not Your Piece"
else:
return "It's Not Your Turn"
