def simulateUnmove (self, board1, move):
moved = []
new = []
dead = []
if move.flag == NULL_MOVE:
return moved, new, dead
cord0, cord1 = move.cords
if self.variant == ATOMICCHESS and (board1[cord1] or move.flag == ENPASSANT):
piece = board1[cord0].piece
cord = self.getHoldingCord(self.color, piece)
moved.append( (self[cord], cord) )
self[cord].opacity = 1
dead.append( self[cord] )
elif not (self.variant == FISCHERRANDOMCHESS and move.flag in (QUEEN_CASTLE, KING_CASTLE)):
moved.append( (self[cord1], cord1) )
if board1[cord1] and not (self.variant == FISCHERRANDOMCHESS and move.flag in (QUEEN_CASTLE, KING_CASTLE)):
piece = PAWN if self.variant == CRAZYHOUSECHESS and board1[cord1].promoted else board1[cord1].piece
cord = self.getHoldingCord(1-self.color, piece)
moved.append( (self[cord], cord) )
self[cord].opacity = 1
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead.append( self[cord] )
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = board1[acord]
if piece and piece.piece != PAWN and acord != cord0:
piece.opacity = 0
cord = self.getHoldingCord(1-piece.color, piece.piece)
moved.append( (self[cord], cord) )
self[cord].opacity = 1
dead.append( self[cord] )
if move.flag in (QUEEN_CASTLE, KING_CASTLE):
side = move.flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
rook = self.board.fin_rooks[board1.color][side]
moved.append( (self[Cord(rook)], Cord(rook)) )
elif move.flag in PROMOTIONS:
newPiece = board1[cord0]
moved.append( (newPiece, cord1) )
new.append( newPiece )
elif move.flag == ENPASSANT:
cord = self.getHoldingCord(1-self.color, PAWN)
moved.append( (self[cord], cord) )
self[cord].opacity = 1
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead.append( self[cord] )
return moved, new, dead
def simulateUnmove(self, board1, move):
moved = []
new = []
dead = []
if move.flag == NULL_MOVE:
return moved, new, dead
cord0, cord1 = move.cords
if self.variant == ATOMICCHESS and (board1[cord1]
or move.flag == ENPASSANT):
piece = board1[cord0].piece
cord = self.getHoldingCord(self.color, piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
else:
moved.append((self[cord1], cord1))
if board1[cord1]:
piece = PAWN if self.variant == CRAZYHOUSECHESS and board1[
cord1].promoted else board1[cord1].piece
cord = self.getHoldingCord(1 - self.color, piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = board1[acord]
if piece and piece.piece != PAWN and acord != cord0:
piece.opacity = 0
cord = self.getHoldingCord(1 - piece.color,
piece.piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
if move.flag in (QUEEN_CASTLE, KING_CASTLE):
side = move.flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
rook = self.board.fin_rooks[board1.color][side]
moved.append((self[Cord(rook)], Cord(rook)))
elif move.flag in PROMOTIONS:
newPiece = board1[cord0]
moved.append((newPiece, cord1))
new.append(newPiece)
elif move.flag == ENPASSANT:
cord = self.getHoldingCord(1 - self.color, PAWN)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
return moved, new, dead
def move(self, move, lboard=None):
""" Creates a new Board object cloning itself then applying
the move.move to the clone Board's lboard.
If lboard param was given, it will be used when cloning,
and move will not be applyed, just the high level Piece
objects will be adjusted."""
# Sequence nubers of next newHoldingCord of WHITE and BLACK
nth = [0, 0]
flag = FLAG(move.move)
if flag != DROP:
assert self[move.cord0], "%s %s" % (move, self.asFen())
newBoard = self.clone(lboard=lboard)
if lboard is None:
newBoard.board.applyMove(move.move)
cord0, cord1 = move.cords
if self[move.cord1] is not None or flag == ENPASSANT:
if self.variant == CRAZYHOUSECHESS:
piece = PAWN if flag == ENPASSANT or self[
move.cord1].promoted else self[move.cord1].piece
new_piece = Piece(self.color, piece, captured=True)
else:
piece = PAWN if flag == ENPASSANT else self[move.cord1].piece
new_piece = Piece(1 - self.color, piece, captured=True)
nth[self.color] += 1
newBoard[self.newHoldingCord(self.color,
nth[self.color])] = new_piece
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(move.cord1):
piece = self[acord]
if piece and piece.piece != PAWN and acord != cord0:
new_piece = Piece(piece.color,
piece.piece,
captured=True)
nth[1 - piece.color] += 1
newBoard[self.newHoldingCord(
1 - piece.color, nth[1 - piece.color])] = new_piece
newBoard[acord] = None
if flag == DROP:
piece = FCORD(move.move)
hc = self.getHoldingCord(self.color, piece)
if hc is None:
newBoard[cord1] = Piece(self.color, piece)
else:
newBoard[cord1] = newBoard[self.getHoldingCord(
self.color, piece)]
newBoard[self.getHoldingCord(self.color, piece)] = None
else:
if self.variant == ATOMICCHESS and (flag == ENPASSANT or
self[move.cord1] is not None):
piece = self[move.cord0].piece
new_piece = Piece(self.color, piece, captured=True)
nth[1 - self.color] += 1
newBoard[self.newHoldingCord(1 - self.color,
nth[1 - self.color])] = new_piece
newBoard[cord1] = None
else:
newBoard[cord1] = newBoard[cord0]
if flag != NULL_MOVE and flag != DROP:
newBoard[cord0] = None
if flag in (QUEEN_CASTLE, KING_CASTLE):
side = flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
inirook = self.board.ini_rooks[self.color][side]
finrook = self.board.fin_rooks[self.color][side]
newBoard[Cord(finrook)] = newBoard[Cord(inirook)]
newBoard[Cord(inirook)] = None
if flag in PROMOTIONS:
new_piece = Piece(self.color, PROMOTE_PIECE(flag))
new_piece.promoted = True
newBoard[cord1] = new_piece
elif flag == ENPASSANT:
newBoard[Cord(cord1.x, cord0.y)] = None
return newBoard
def simulateMove(self, board1, move):
moved = []
new = []
dead = []
if move.flag == NULL_MOVE:
return moved, new, dead
cord0, cord1 = move.cords
if move.flag == DROP:
piece = FCORD(move.move)
cord0 = self.getHoldingCord(self.color, piece)
moved.append((self[cord0], cord0))
return moved, new, dead
if self.variant == ATOMICCHESS and (self[cord1]
or move.flag == ENPASSANT):
# Sequence nubers of next newHoldingCord of WHITE and BLACK
nth = [0, 0]
piece = self[cord0]
nth[1 - piece.color] += 1
cord = self.newHoldingCord(1 - piece.color, nth[1 - piece.color])
moved.append((board1[cord], cord0))
new.append(board1[cord])
else:
moved.append((self[cord0], cord0))
if self[cord1]:
piece = PAWN if self.variant == CRAZYHOUSECHESS and self[
cord1].promoted else self[cord1].piece
cord = self.newHoldingCord(self.color)
moved.append((board1[cord], cord1))
new.append(board1[cord])
if self.variant == ATOMICCHESS:
nth[self.color] += 1
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = self[acord]
if piece and piece.piece != PAWN and acord != cord0:
nth[1 - piece.color] += 1
cord = self.newHoldingCord(1 - piece.color,
nth[1 - piece.color])
moved.append((board1[cord], acord))
new.append(board1[cord])
if move.flag in (QUEEN_CASTLE, KING_CASTLE):
side = move.flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
rook = self.board.ini_rooks[self.color][side]
moved.append((self[Cord(rook)], Cord(rook)))
elif move.flag in PROMOTIONS:
newPiece = board1[cord1]
moved.append((newPiece, cord0))
new.append(newPiece)
elif move.flag == ENPASSANT:
shift = -1 if self.color == WHITE else 1
ep_cord = Cord(cord1.x, cord1.y + shift)
moved.append((self[ep_cord], ep_cord))
cord = self.newHoldingCord(self.color)
new.append(board1[cord])
return moved, new, dead
def move (self, move, lboard=None):
""" Creates a new Board object cloning itself then applying
the move.move to the clone Board's lboard.
If lboard param was given, it will be used when cloning,
and move will not be applyed, just the high level Piece
objects will be adjusted."""
# Sequence nubers of next newHoldingCord of WHITE and BLACK
nth = [0, 0]
flag = FLAG(move.move)
if flag != DROP:
assert self[move.cord0], "%s %s" % (move, self.asFen())
newBoard = self.clone(lboard=lboard)
if lboard is None:
newBoard.board.applyMove (move.move)
cord0, cord1 = move.cords
if (self[move.cord1] is not None or flag == ENPASSANT) and \
not (self.variant == FISCHERRANDOMCHESS and flag in (QUEEN_CASTLE, KING_CASTLE)):
if self.variant == CRAZYHOUSECHESS:
piece = PAWN if flag == ENPASSANT or self[move.cord1].promoted else self[move.cord1].piece
new_piece = Piece(self.color, piece, captured=True)
else:
piece = PAWN if flag == ENPASSANT else self[move.cord1].piece
new_piece = Piece(1-self.color, piece, captured=True)
nth[self.color] += 1
newBoard[self.newHoldingCord(self.color, nth[self.color])] = new_piece
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(move.cord1):
piece = self[acord]
if piece and piece.piece != PAWN and acord != cord0:
new_piece = Piece(piece.color, piece.piece, captured=True)
nth[1-piece.color] += 1
newBoard[self.newHoldingCord(1-piece.color, nth[1-piece.color])] = new_piece
newBoard[acord] = None
if flag == DROP:
piece = FCORD(move.move)
hc = self.getHoldingCord(self.color, piece)
if hc is None:
newBoard[cord1] = Piece(self.color, piece)
else:
newBoard[cord1] = newBoard[hc]
newBoard[cord1].captured = False
newBoard[hc] = None
else:
if self.variant == ATOMICCHESS and (flag == ENPASSANT or self[move.cord1] is not None):
piece = self[move.cord0].piece
new_piece = Piece(self.color, piece, captured=True)
nth[1-self.color] += 1
newBoard[self.newHoldingCord(1-self.color, nth[1-self.color])] = new_piece
newBoard[cord1] = None
else:
if self.variant == FISCHERRANDOMCHESS and flag in (QUEEN_CASTLE, KING_CASTLE):
king = newBoard[cord0]
else:
newBoard[cord1] = newBoard[cord0]
if flag != NULL_MOVE and flag != DROP:
newBoard[cord0] = None
if flag in (QUEEN_CASTLE, KING_CASTLE):
side = flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
inirook = self.board.ini_rooks[self.color][side]
finrook = self.board.fin_rooks[self.color][side]
newBoard[Cord(finrook)] = newBoard[Cord(inirook)]
newBoard[Cord(inirook)] = None
if self.variant == FISCHERRANDOMCHESS:
finking = self.board.fin_kings[self.color][side]
newBoard[Cord(finking)] = king
if flag in PROMOTIONS:
new_piece = Piece(self.color, PROMOTE_PIECE(flag))
new_piece.promoted = True
newBoard[cord1] = new_piece
elif flag == ENPASSANT:
newBoard[Cord(cord1.x, cord0.y)] = None
if flag == DROP or flag == ENPASSANT or self[move.cord1] is not None:
newBoard.reorderHolding(self.color)
return newBoard
def simulateMove (self, board1, move):
moved = []
new = []
dead = []
if move.flag == NULL_MOVE:
return moved, new, dead
cord0, cord1 = move.cords
if move.flag == DROP:
piece = FCORD(move.move)
cord0 = self.getHoldingCord(self.color, piece)
moved.append( (self[cord0], cord0) )
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead = new
return moved, new, dead
if self.variant == ATOMICCHESS and (self[cord1] or move.flag == ENPASSANT):
# Sequence nubers of next newHoldingCord of WHITE and BLACK
nth = [0, 0]
piece = self[cord0]
nth[1-piece.color] += 1
cord = self.newHoldingCord(1-piece.color, nth[1-piece.color])
moved.append( (board1[cord], cord0) )
new.append( board1[cord] )
else:
moved.append( (self[cord0], cord0) )
if self[cord1] and not (self.variant == FISCHERRANDOMCHESS and move.flag in (QUEEN_CASTLE, KING_CASTLE)):
piece = PAWN if self.variant == CRAZYHOUSECHESS and self[cord1].promoted else self[cord1].piece
cord = self.newHoldingCord(self.color)
moved.append( (board1[cord], cord1) )
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
new.append( board1[cord] )
if self.variant == ATOMICCHESS:
nth[self.color] += 1
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = self[acord]
if piece and piece.piece != PAWN and acord != cord0:
nth[1-piece.color] += 1
cord = self.newHoldingCord(1-piece.color, nth[1-piece.color])
moved.append( (board1[cord], acord) )
new.append( board1[cord] )
if move.flag in (QUEEN_CASTLE, KING_CASTLE):
side = move.flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
rook = self.board.ini_rooks[self.color][side]
moved.append( (self[Cord(rook)], Cord(rook)) )
elif move.flag in PROMOTIONS:
newPiece = board1[cord1]
moved.append( (newPiece, cord0) )
new.append( newPiece )
elif move.flag == ENPASSANT:
shift = -1 if self.color == WHITE else 1
ep_cord = Cord(cord1.x, cord1.y + shift)
moved.append( (self[ep_cord], ep_cord) )
cord = self.newHoldingCord(self.color)
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
new.append( board1[cord] )
return moved, new, dead
def simulateUnmove(self, board1, move):
moved = []
new = []
dead = []
if move.flag == NULL_MOVE:
return moved, new, dead
cord0, cord1 = move.cords
if cord0 == cord1 and self.variant == SITTUYINCHESS:
return moved, new, dead
if self.variant == ATOMICCHESS and (board1[cord1]
or move.flag == ENPASSANT):
piece = board1[cord0].piece
cord = self.getHoldingCord(self.color, piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
elif not (self.variant == FISCHERRANDOMCHESS
and move.flag in (QUEEN_CASTLE, KING_CASTLE)):
moved.append((self[cord1], cord1))
if board1[cord1] and not (self.variant == FISCHERRANDOMCHESS and
move.flag in (QUEEN_CASTLE, KING_CASTLE)):
piece = (PAWN if self.variant == CRAZYHOUSECHESS
and board1[cord1].promoted else board1[cord1].piece)
cord = self.getHoldingCord(1 - self.color, piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead.append(self[cord])
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = board1[acord]
if piece and piece.piece != PAWN and acord != cord0:
piece.opacity = 0
cord = self.getHoldingCord(1 - piece.color,
piece.piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
if move.flag in (QUEEN_CASTLE, KING_CASTLE):
side = move.flag - QUEEN_CASTLE
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS,
WILDCASTLESHUFFLECHESS,
):
side = 0 if side == 1 else 1
rook = self.board.fin_rooks[board1.color][side]
moved.append((self[Cord(rook)], Cord(rook)))
elif move.flag in PROMOTIONS:
newPiece = board1[cord0]
moved.append((newPiece, cord1))
new.append(newPiece)
elif move.flag == ENPASSANT:
cord = self.getHoldingCord(1 - self.color, PAWN)
moved.append((self[cord], cord))
self[cord].opacity = 1
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead.append(self[cord])
return moved, new, dead
def move(self, move, lboard=None):
""" Creates a new Board object cloning itself then applying
the move.move to the clone Board's lboard.
If lboard param was given, it will be used when cloning,
and move will not be applyed, just the high level Piece
objects will be adjusted."""
# Sequence nubers of next newHoldingCord of WHITE and BLACK
nth = [0, 0]
flag = FLAG(move.move)
if flag != DROP:
assert self[move.cord0], "%s %s" % (move, self.asFen())
newBoard = self.clone(lboard=lboard)
if lboard is None:
newBoard.board.applyMove(move.move)
cord0, cord1 = move.cords
kcastle = flag == KING_CASTLE or (self.variant == SCHESS and (
(self[move.cord0].piece == KING and cord0.x - cord1.x == -2) or
(flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)
and cord0.x - cord1.x > 0)))
qcastle = flag == QUEEN_CASTLE or (self.variant == SCHESS and (
(self[move.cord0].piece == KING and cord0.x - cord1.x == 2) or
(flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)
and cord0.x - cord1.x < 0)))
if kcastle or qcastle:
gcord = cord0 # save gating cord
# capture
if (self[move.cord1] is not None or flag == ENPASSANT) and \
not (cord0 == cord1 and flag != DROP and flag != QUEEN_PROMOTION) and \
not (kcastle or qcastle):
if self.variant == CRAZYHOUSECHESS:
piece = PAWN if flag == ENPASSANT or self[
move.cord1].promoted else self[move.cord1].piece
new_piece = Piece(self.color, piece, captured=True)
else:
piece = PAWN if flag == ENPASSANT else self[move.cord1].piece
new_piece = Piece(1 - self.color, piece, captured=True)
nth[self.color] += 1
newBoard[self.newHoldingCord(self.color,
nth[self.color])] = new_piece
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(move.cord1):
piece = self[acord]
if piece and piece.piece != PAWN and acord != cord0:
new_piece = Piece(piece.color,
piece.piece,
captured=True)
nth[1 - piece.color] += 1
newBoard[self.newHoldingCord(
1 - piece.color, nth[1 - piece.color])] = new_piece
newBoard[acord] = None
if flag == DROP:
piece = FCORD(move.move)
holding_coord = self.getHoldingCord(self.color, piece)
if holding_coord is None:
newBoard[cord1] = Piece(self.color, piece)
else:
newBoard[cord1] = newBoard[holding_coord]
newBoard[cord1].captured = False
newBoard[holding_coord] = None
else:
if self.variant == ATOMICCHESS and (
flag == ENPASSANT or self[move.cord1]
is not None) and (flag not in (QUEEN_CASTLE, KING_CASTLE)):
piece = self[move.cord0].piece
new_piece = Piece(self.color, piece, captured=True)
nth[1 - self.color] += 1
newBoard[self.newHoldingCord(1 - self.color,
nth[1 - self.color])] = new_piece
newBoard[cord1] = None
else:
if kcastle or qcastle:
if flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK):
king = newBoard[cord1]
else:
king = newBoard[cord0]
else:
newBoard[cord1] = newBoard[cord0]
if cord0 != cord1 and flag != DROP and flag != HAWK_GATE_AT_ROOK and flag != ELEPHANT_GATE_AT_ROOK:
newBoard[cord0] = None
if kcastle or qcastle:
side = 0 if qcastle else 1
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
inirook = self.board.ini_rooks[self.color][side]
finrook = self.board.fin_rooks[self.color][side]
newBoard[Cord(finrook)] = newBoard[Cord(inirook)]
if inirook != finrook:
newBoard[Cord(inirook)] = None
if flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK):
newBoard[cord1] = None
finking = self.board.fin_kings[self.color][side]
newBoard[Cord(finking)] = king
if flag in GATINGS:
gpiece = HAWK if flag in (HAWK_GATE,
HAWK_GATE_AT_ROOK) else ELEPHANT
holding_coord = self.getHoldingCord(self.color,
gpiece,
piece_color=self.color)
newBoard[gcord if
(kcastle or qcastle) else cord0] = newBoard[holding_coord]
newBoard[holding_coord] = None
if flag in PROMOTIONS:
new_piece = Piece(self.color, PROMOTE_PIECE(flag))
new_piece.promoted = True
newBoard[cord1] = new_piece
elif flag == ENPASSANT:
newBoard[Cord(cord1.x, cord0.y)] = None
if flag == DROP or flag == ENPASSANT or self[move.cord1] is not None:
newBoard.reorderHolding(self.color)
return newBoard
def simulateUnmove(self, board1, move):
moved = []
new = []
dead = []
cord0, cord1 = move.cords
flag = FLAG(move.move)
# null move or SITTUYINCHESS in place promotion
if cord0 == cord1 and flag != DROP and flag != QUEEN_PROMOTION:
return moved, new, dead
if self.variant == ATOMICCHESS and (board1[cord1]
or flag == ENPASSANT):
piece = board1[cord0].piece
cord = self.getHoldingCord(self.color, piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
elif not (self.variant == FISCHERRANDOMCHESS
and flag in (QUEEN_CASTLE, KING_CASTLE)):
moved.append((self[cord1], cord1))
kcastle = flag == KING_CASTLE or (self.variant == SCHESS and (
(self[move.cord1] is not None and self[move.cord1].piece == KING
and cord0.x - cord1.x == -2) or
(flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)
and cord0.x - cord1.x > 0)))
qcastle = flag == QUEEN_CASTLE or (self.variant == SCHESS and (
(self[move.cord1] is not None and self[move.cord1].piece == KING
and cord0.x - cord1.x == 2) or
(flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)
and cord0.x - cord1.x < 0)))
# capture
if board1[cord1] and not (flag in (QUEEN_CASTLE, KING_CASTLE,
HAWK_GATE_AT_ROOK,
ELEPHANT_GATE_AT_ROOK)):
piece = PAWN if self.variant == CRAZYHOUSECHESS and board1[
cord1].promoted else board1[cord1].piece
cord = self.getHoldingCord(1 - self.color, piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead.append(self[cord])
if self.variant == ATOMICCHESS:
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = board1[acord]
if piece and piece.piece != PAWN and acord != cord0:
piece.opacity = 0
cord = self.getHoldingCord(1 - piece.color,
piece.piece)
moved.append((self[cord], cord))
self[cord].opacity = 1
dead.append(self[cord])
if kcastle or qcastle:
side = 0 if qcastle else 1
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
rook = self.board.fin_rooks[board1.color][side]
moved.append((self[Cord(rook)], Cord(rook)))
elif flag in PROMOTIONS:
newPiece = board1[cord0]
moved.append((newPiece, cord1))
new.append(newPiece)
elif flag == ENPASSANT:
cord = self.getHoldingCord(1 - self.color, PAWN)
moved.append((self[cord], cord))
self[cord].opacity = 1
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(self.color)
dead.append(self[cord])
elif flag in GATINGS:
# add all gated pieces to "new" list to enforce repainting them after a possible reordering
new = self.getHoldingPieces(1 - self.color)
return moved, new, dead
def simulateMove(self, board1, move):
moved = []
new = []
dead = []
cord0, cord1 = move.cords
flag = FLAG(move.move)
# null move or SITTUYINCHESS in place promotion
if cord0 == cord1 and flag != DROP and flag != QUEEN_PROMOTION:
return moved, new, dead
if flag == DROP:
piece = FCORD(move.move)
cord0 = self.getHoldingCord(self.color, piece)
moved.append((self[cord0], cord0))
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = board1.getHoldingPieces(self.color)
dead = new
return moved, new, dead
kcastle = flag == KING_CASTLE or (self.variant == SCHESS and (
(self[move.cord0].piece == KING and cord0.x - cord1.x == -2) or
(flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)
and cord0.x - cord1.x > 0)))
qcastle = flag == QUEEN_CASTLE or (self.variant == SCHESS and (
(self[move.cord0].piece == KING and cord0.x - cord1.x == 2) or
(flag in (HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)
and cord0.x - cord1.x < 0)))
if self.variant == ATOMICCHESS and (self[cord1] or flag == ENPASSANT):
# Sequence nubers of next newHoldingCord of WHITE and BLACK
nth = [0, 0]
piece = self[cord0]
nth[1 - piece.color] += 1
cord = self.newHoldingCord(1 - piece.color, nth[1 - piece.color])
moved.append((board1[cord], cord0))
new.append(board1[cord])
else:
if flag in PROMOTIONS:
dead.append(self[cord0])
else:
moved.append((self[cord0], cord0))
# capture
if self[cord1] and not (flag
in (QUEEN_CASTLE, KING_CASTLE,
HAWK_GATE_AT_ROOK, ELEPHANT_GATE_AT_ROOK)):
piece = PAWN if self.variant == CRAZYHOUSECHESS and self[
cord1].promoted else self[cord1].piece
cord = board1.getHoldingCord(self.color, piece)
moved.append((board1[cord], cord1))
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = board1.getHoldingPieces(self.color)
if self.variant == ATOMICCHESS:
nth[self.color] += 1
from pychess.Variants.atomic import cordsAround
for acord in cordsAround(cord1):
piece = self[acord]
if piece and piece.piece != PAWN and acord != cord0:
nth[1 - piece.color] += 1
cord = self.newHoldingCord(1 - piece.color,
nth[1 - piece.color])
moved.append((board1[cord], acord))
new.append(board1[cord])
if kcastle or qcastle:
side = 0 if qcastle else 1
if FILE(cord0.x) == 3 and self.board.variant in (
WILDCASTLECHESS, WILDCASTLESHUFFLECHESS):
side = 0 if side == 1 else 1
rook = self.board.ini_rooks[self.color][side]
moved.append((self[Cord(rook)], Cord(rook)))
elif flag in PROMOTIONS:
newPiece = board1[cord1]
moved.append((newPiece, cord0))
new.append(newPiece)
elif flag == ENPASSANT:
shift = -1 if self.color == WHITE else 1
ep_cord = Cord(cord1.x, cord1.y + shift)
moved.append((self[ep_cord], ep_cord))
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = board1.getHoldingPieces(self.color)
if flag in GATINGS:
gpiece = HAWK if flag in (HAWK_GATE,
HAWK_GATE_AT_ROOK) else ELEPHANT
cord0 = self.getHoldingCord(self.color, gpiece)
moved.append((self[cord0], cord0))
# add all captured pieces to "new" list to enforce repainting them after a possible reordering
new = board1.getHoldingPieces(self.color)
return moved, new, dead
