def getPossibleMoves(self):
# Function run to yield a group of all possible legal and illegal
# 'Move' objects to the calling function. Does this by running through
# a list of movements and testing for valid moves before yielding them.
# Also handles the promotion of pieces and the ability for a piece to
# move two spaces forward on its first move.
pos = self.position
movement = C(0, 1) if self.side == WHITE else C(0, -1)
advanceOnePos = pos + movement
if self.board.isValidPos(advanceOnePos):
if self.board.pieceAtPosition(advanceOnePos) is None:
col = advanceOnePos[1]
if col in [7, 0]:
piecesForPromotion = \
[Rook(self.board, self.side, advanceOnePos),
Knight(self.board, self.side, advanceOnePos),
Bishop(self.board, self.side, advanceOnePos),
Queen(self.board, self.side, advanceOnePos)]
for piece in piecesForPromotion:
move = Move(self, advanceOnePos)
move.promotion = True
piece.movesMade = self.movesMade
move.specialMovePiece = piece
yield move
else:
yield Move(self, advanceOnePos)
if self.movesMade == 0:
advanceTwoPos = pos + movement + movement
if self.board.isValidPos(advanceTwoPos):
if self.board.pieceAtPosition(advanceTwoPos) is None and \
self.board.pieceAtPosition(advanceOnePos) is None:
yield Move(self, advanceTwoPos)
movements = [C(1, 1), C(
-1, 1)] if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
newPos = self.position + movement
if self.board.isValidPos(newPos):
pieceToTake = self.board.pieceAtPosition(newPos)
if pieceToTake and pieceToTake.side != self.side:
col = newPos[1]
if col in [7, 0]:
piecesForPromotion = \
[Rook(self.board, self.side, newPos),
Knight(self.board, self.side, newPos),
Bishop(self.board, self.side, newPos),
Queen(self.board, self.side, newPos)]
for piece in piecesForPromotion:
move = Move(self,
newPos,
pieceToCapture=pieceToTake)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, newPos, pieceToCapture=pieceToTake)
def getPossibleMoves(self):
currentPos = self.position
movements = [C(0, 1), C(0, -1), C(1, 0), C(-1, 0), C(1, 1), C(1, -1), C(-1, 1), C(-1, -1)]
for movement in movements:
newPos = currentPos + movement
if self.board.isValidPos(newPos):
pieceAtNewPos = self.board.pieceAtPosition(newPos)
if self.board.pieceAtPosition(newPos) is None:
yield Move(self, newPos)
elif pieceAtNewPos.side != self.side:
yield Move(self, newPos, pieceToCapture=pieceAtNewPos)
# Castling
if self.movesMade == 0:
inCheck = False
kingsideCastleBlocked = False
queensideCastleBlocked = False
kingsideCastleCheck = False
queensideCastleCheck = False
kingsideRookMoved = True
queensideRookMoved = True
kingsideCastlePositions = [self.position + C(1, 0), self.position + C(2, 0)]
for pos in kingsideCastlePositions:
if self.board.pieceAtPosition(pos):
kingsideCastleBlocked = True
queensideCastlePositions = [self.position - C(1, 0), self.position - C(2, 0), self.position - C(3, 0)]
for pos in queensideCastlePositions:
if self.board.pieceAtPosition(pos):
queensideCastleBlocked = True
if kingsideCastleBlocked and queensideCastleBlocked:
return
otherSideMoves = self.board.getAllMovesUnfiltered(not self.side, includeKing=False)
for move in otherSideMoves:
if move.newPos == self.position:
inCheck = True
break
if move.newPos == self.position + C(1, 0) or move.newPos == self.position + C(2, 0):
kingsideCastleCheck = True
if move.newPos == self.position - C(1, 0) or move.newPos == self.position - C(2, 0):
queensideCastleCheck = True
kingsideRookPos = self.position + C(3, 0)
kingsideRook = self.board.pieceAtPosition(kingsideRookPos) if self.board.isValidPos(kingsideRookPos) else None
if kingsideRook and kingsideRook.stringRep == 'R' and kingsideRook.movesMade == 0:
kingsideRookMoved = False
queensideRookPos = self.position - C(4, 0)
queensideRook = self.board.pieceAtPosition(queensideRookPos) if self.board.isValidPos(queensideRookPos) else None
if queensideRook and queensideRook.stringRep == 'R' and queensideRook.movesMade == 0:
queensideRookMoved = False
if not inCheck:
if not kingsideCastleBlocked and not kingsideCastleCheck and not kingsideRookMoved:
move = Move(self, self.position + C(2, 0))
rookMove = Move(self.position, self.position + C(1, 0))
move.specialMovePiece = self.board.pieceAtPosition(kingsideRookPos)
move.kingsideCastle = True
move.rookMove = rookMove
yield move
if not queensideCastleBlocked and not queensideCastleCheck and not queensideRookMoved:
move = Move(self, self.position - C(2, 0))
rookMove = Move(self.position, self.position - C(1, 0))
move.specialMovePiece = self.board.pieceAtPosition(queensideRookPos)
move.queensideCastle = True
move.rookMove = rookMove
yield move
def get_possible_moves(self):
pos = self.position
# Pawn moves one up
movement = C(0, 1) if self.side == WHITE else C(0, -1)
up_pos = pos + movement
if self.board.is_valid_pos(up_pos):
# Promotion moves
if self.board.get_piece_at_pos(up_pos) is None:
col = up_pos[1]
if col == 7 or col == 0:
piecesForPromotion = \
[Rook(self.board, self.side, up_pos),
Knight(self.board, self.side, up_pos),
Bishop(self.board, self.side, up_pos),
Queen(self.board, self.side, up_pos)]
for piece in piecesForPromotion:
move = Move(self, up_pos)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, up_pos)
# Pawn moves two up
if self.movesMade == 0:
movement = C(0, 2) if self.side == WHITE else C(0, -2)
up2_pos = pos + movement
if self.board.is_valid_pos(up2_pos):
if self.board.get_piece_at_pos(up2_pos) is None and \
self.board.get_piece_at_pos(up_pos) is None:
yield Move(self, up2_pos)
# Pawn takes
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
new_pos = self.position + movement
if self.board.is_valid_pos(new_pos):
pieceToTake = self.board.get_piece_at_pos(new_pos)
if pieceToTake and pieceToTake.side != self.side:
col = new_pos[1]
# Promotions
if col == 7 or col == 0:
piecesForPromotion = \
[Rook(self.board, self.side, new_pos),
Knight(self.board, self.side, new_pos),
Bishop(self.board, self.side, new_pos),
Queen(self.board, self.side, new_pos)]
for piece in piecesForPromotion:
move = Move(self, up_pos)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, new_pos,
piece_to_capture=pieceToTake)
# En pessant
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
posBesidePawn = self.position + C(movement[0], 0)
if self.board.is_valid_pos(posBesidePawn):
pieceBesidePawn = self.board.get_piece_at_pos(posBesidePawn)
lastPieceMoved = self.board.getLastPieceMoved()
lastMoveWasAdvanceTwo = False
lastMove = self.board.getLastMove()
if lastMove:
if lastMove.new_pos - lastMove.old_pos == C(0, 2) or \
lastMove.new_pos - lastMove.old_pos == C(0, -2):
lastMoveWasAdvanceTwo = True
if pieceBesidePawn and \
pieceBesidePawn.stringRep == 'p' and \
pieceBesidePawn.side != self.side and \
lastPieceMoved is pieceBesidePawn and \
lastMoveWasAdvanceTwo:
move = Move(self, self.position + movement,
piece_to_capture=pieceBesidePawn)
move.pessant = True
move.specialMovePiece = pieceBesidePawn
yield move
def getPossibleMoves(self):
currentPosition = self.position
# Pawn moves one up
movement = C(0, 1) if self.side == WHITE else C(0, -1)
advanceOnePosition = currentPosition + movement
if self.board.isValidPos(advanceOnePosition):
#Check if piece at position to move to
if self.board.pieceAtPosition(advanceOnePosition) is None:
col = advanceOnePosition[1]
if col == 7 or col == 0:
#print("promotion is happening without a capture")
'''
piecesForPromotion = \
[Rook(self.board, self.side, advanceOnePosition, self.number), #added self.number to these
Knight(self.board, self.side, advanceOnePosition, self.number),
Bishop(self.board, self.side, advanceOnePosition, self.number),
Queen(self.board, self.side, advanceOnePosition, self.number)]
for piece in piecesForPromotion:
'''
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = Queen(self.board, self.side, advanceOnePosition, self.number)
#print(move.specialMovePiece)
#print(move)
yield (move)
else:
yield (Move(self, advanceOnePosition))
# Pawn moves two up
if self.movesMade == 0:
movement = C(0, 2) if self.side == WHITE else C(0, -2)
advanceTwoPosition = currentPosition + movement
if self.board.isValidPos(advanceTwoPosition):
if self.board.pieceAtPosition(advanceTwoPosition) is None and \
self.board.pieceAtPosition(advanceOnePosition) is None:
yield Move(self, advanceTwoPosition)
# Pawn takes
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
# Pawn captures another piece
for m in movements:
newPosition = self.position + m
if self.board.isValidPos(newPosition):
pieceToTake = self.board.pieceAtPosition(newPosition)
if pieceToTake and pieceToTake.side != self.side:
col = newPosition[1]
#print("Piece for pawn to take: ")
#print(pieceToTake)
#print(pieceToTake.board)
# Promotion with a capture
if col == 7 or col == 0:
#print("promotion is happening with capture")
'''
piecesForPromotion = \
[Knight(self.board, self.side, newPosition, self.number),
Rook(self.board, self.side, newPosition, self.number),
Bishop(self.board, self.side, newPosition, self.number),
Queen(self.board, self.side, newPosition, self.number)]
for piece in piecesForPromotion:
'''
move = Move(self, newPosition, pieceToCapture=pieceToTake)
move.promotion = True
move.specialMovePiece = Queen(self.board, self.side, newPosition, self.number)
#print("reset special move piece")
#print(move.specialMovePiece)
#print(move)
yield (move)
else:
yield (Move(self, newPosition,
pieceToCapture=pieceToTake))
# En pessant
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
posBesidePawn = self.position + C(movement[0], 0)
if self.board.isValidPos(posBesidePawn):
pieceBesidePawn = self.board.pieceAtPosition(posBesidePawn)
lastPieceMoved = self.board.getLastPieceMoved()
lastMoveWasAdvanceTwo = False
lastMove = self.board.getLastMove()
if lastMove:
if lastMove.newPos - lastMove.oldPos == C(0, 2) or \
lastMove.newPos - lastMove.oldPos == C(0, -2):
lastMoveWasAdvanceTwo = True
if pieceBesidePawn and \
pieceBesidePawn.stringRep == 'p' and \
pieceBesidePawn.side != self.side and \
lastPieceMoved is pieceBesidePawn and \
lastMoveWasAdvanceTwo:
move = Move(self, self.position + movement,
pieceToCapture=pieceBesidePawn)
move.pessant = True
move.specialMovePiece = pieceBesidePawn
yield (move)
def getPossibleMoves(self):
currentPosition = self.position
# Pawn moves one up
movement = C(0, 1) if self.side == WHITE else C(0, -1)
advanceOnePosition = currentPosition + movement
if self.board.isValidPos(advanceOnePosition):
#Promotion moves
if self.board.pieceAtPosition(advanceOnePosition) is None:
col = advanceOnePosition[1]
if col == 7 or col == 0:
piecesForPromotion = [
Rook(self.board, self.side, advanceOnePosition),
Knight(self.board, self.side, advanceOnePosition),
Bishop(self.board, self.side, advanceOnePosition),
Queen(self.board, self.side, advanceOnePosition)
]
for piece in piecesForPromotion:
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, advanceOnePosition)
#Pawn moves two up
if self.movesMade == 0:
movement = C(0, 2) if self.side == WHITE else C(0, -2)
advanceTwoPosition = currentPosition + movement
if self.board.isValidPos(advanceTwoPosition):
if self.board.pieceAtPosition(
advanceTwoPosition
) is None and self.board.pieceAtPosition(
advanceOnePosition) is None:
yield Move(self, advanceTwoPosition)
#Pawn takes
movements = [C(1, 1), C(
-1, 1)] if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
newPosition = self.position + movement
if self.board.isValidPos(newPosition):
pieceToTake = self.board.pieceAtPosition(newPosition)
if pieceToTake and pieceToTake.side != self.side:
col = newPosition[1]
#Promotions
if col == 7 or col == 0:
piecesForPromotion = [
Rook(self.board, self.side, newPosition),
Knight(self.board, self.side, newPosition),
Bishop(self.board, self.side, newPosition),
Queen(self.board, self.side, newPosition)
]
for piece in piecesForPromotion:
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self,
newPosition,
pieceToCapture=pieceToTake)
#En pessant
movements = [C(1, 1), C(
-1, 1)] if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
posBesidePawn = self.position + C(movement[0], 0)
if self.board.isValidPos(posBesidePawn):
pieceBesidePawn = self.board.pieceAtPosition(posBesidePawn)
lastPieceMoved = self.board.getLastPieceMoved()
lastMoveWasAdvanceTwo = False
lastMove = self.board.getLastMove()
if lastMove:
if lastMove.newPos - lastMove.oldPos == C(
0, 2) or lastMove.newPos - lastMove.oldPos == C(
0, -2):
lastMoveWasAdvanceTwo = True
if pieceBesidePawn and pieceBesidePawn.stringRep == 'p' and pieceBesidePawn.side != self.side and lastPieceMoved is pieceBesidePawn and lastMoveWasAdvanceTwo:
move = Move(self,
self.position + movement,
pieceToCapture=pieceBesidePawn)
move.pessant = True
move.specialMovePiece = pieceBesidePawn
yield move
def getPossibleMoves(self) :
currentPosition = self.position
# Pawn moves one up
movement = C(0, 1) if self.side == WHITE else C(0, -1)
advanceOnePosition = currentPosition + movement
if self.board.isValidPos(advanceOnePosition) :
#Promotion moves
if self.board.pieceAtPosition(advanceOnePosition) is None :
col = advanceOnePosition[1]
if col == 7 or col == 0:
piecesForPromotion = [Rook(self.board, self.side, advanceOnePosition), Knight(self.board, self.side, advanceOnePosition), Bishop(self.board, self.side, advanceOnePosition), Queen(self.board, self.side, advanceOnePosition)]
for piece in piecesForPromotion :
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = piece
yield move
else :
yield Move(self, advanceOnePosition)
#Pawn moves two up
if self.movesMade == 0 :
movement = C(0, 2) if self.side == WHITE else C(0, -2)
advanceTwoPosition = currentPosition + movement
if self.board.isValidPos(advanceTwoPosition) :
if self.board.pieceAtPosition(advanceTwoPosition) is None and self.board.pieceAtPosition(advanceOnePosition) is None:
yield Move(self, advanceTwoPosition)
#Pawn takes
movements = [C(1,1), C(-1,1)] if self.side == WHITE else [C(1,-1), C(-1,-1)]
for movement in movements :
newPosition = self.position + movement
if self.board.isValidPos(newPosition) :
pieceToTake = self.board.pieceAtPosition(newPosition)
if pieceToTake and pieceToTake.side != self.side :
col = newPosition[1]
#Promotions
if col == 7 or col == 0:
piecesForPromotion = [Rook(self.board, self.side, newPosition), Knight(self.board, self.side, newPosition), Bishop(self.board, self.side, newPosition), Queen(self.board, self.side, newPosition)]
for piece in piecesForPromotion :
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = piece
yield move
else :
yield Move(self, newPosition, pieceToCapture = pieceToTake)
#En pessant
movements = [C(1,1), C(-1,1)] if self.side == WHITE else [C(1,-1), C(-1,-1)]
for movement in movements :
posBesidePawn = self.position + C(movement[0], 0)
if self.board.isValidPos(posBesidePawn) :
pieceBesidePawn = self.board.pieceAtPosition(posBesidePawn)
lastPieceMoved = self.board.getLastPieceMoved()
lastMoveWasAdvanceTwo = False
lastMove = self.board.getLastMove()
if lastMove :
if lastMove.newPos - lastMove.oldPos == C(0,2) or lastMove.newPos - lastMove.oldPos == C(0,-2) :
lastMoveWasAdvanceTwo = True
if pieceBesidePawn and pieceBesidePawn.stringRep == 'p' and pieceBesidePawn.side != self.side and lastPieceMoved is pieceBesidePawn and lastMoveWasAdvanceTwo:
move = Move(self, self.position + movement, pieceToCapture = pieceBesidePawn)
move.pessant = True
move.specialMovePiece = pieceBesidePawn
yield move
def getPossibleMoves(self):
currentPosition = self.position
# Движение пешки вперед на 1 клетку
movement = C(0, 1) if self.side == WHITE else C(0, -1)
advanceOnePosition = currentPosition + movement
if self.board.isValidPos(advanceOnePosition):
# Продвижение
if self.board.pieceAtPosition(advanceOnePosition) is None:
col = advanceOnePosition[1]
if col == 7 or col == 0:
piecesForPromotion = \
[Rook(self.board, self.side, advanceOnePosition),
Knight(self.board, self.side, advanceOnePosition),
Bishop(self.board, self.side, advanceOnePosition),
Queen(self.board, self.side, advanceOnePosition)]
for piece in piecesForPromotion:
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, advanceOnePosition)
# Пешка ходит вперед на 2 клетки
if self.movesMade == 0:
movement = C(0, 2) if self.side == WHITE else C(0, -2)
advanceTwoPosition = currentPosition + movement
if self.board.isValidPos(advanceTwoPosition):
if self.board.pieceAtPosition(advanceTwoPosition) is None and \
self.board.pieceAtPosition(advanceOnePosition) is None:
yield Move(self, advanceTwoPosition)
# Пешка ест фигуру противника
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
newPosition = self.position + movement
if self.board.isValidPos(newPosition):
pieceToTake = self.board.pieceAtPosition(newPosition)
if pieceToTake and pieceToTake.side != self.side:
col = newPosition[1]
# достижения другого конца доски, выбор новой фигуры
if col == 7 or col == 0:
piecesForPromotion = \
[Rook(self.board, self.side, newPosition),
Knight(self.board, self.side, newPosition),
Bishop(self.board, self.side, newPosition),
Queen(self.board, self.side, newPosition)]
for piece in piecesForPromotion:
move = Move(self, advanceOnePosition)
move.promotion = True
move.specialMovePiece = piece
yield move
else:
yield Move(self, newPosition,
pieceToCapture=pieceToTake)
#
movements = [C(1, 1), C(-1, 1)] \
if self.side == WHITE else [C(1, -1), C(-1, -1)]
for movement in movements:
posBesidePawn = self.position + C(movement[0], 0)
if self.board.isValidPos(posBesidePawn):
pieceBesidePawn = self.board.pieceAtPosition(posBesidePawn)
lastPieceMoved = self.board.getLastPieceMoved()
lastMoveWasAdvanceTwo = False
lastMove = self.board.getLastMove()
if lastMove:
if lastMove.newPos - lastMove.oldPos == C(0, 2) or \
lastMove.newPos - lastMove.oldPos == C(0, -2):
lastMoveWasAdvanceTwo = True
if pieceBesidePawn and \
pieceBesidePawn.stringRep == 'p' and \
pieceBesidePawn.side != self.side and \
lastPieceMoved is pieceBesidePawn and \
lastMoveWasAdvanceTwo:
move = Move(self, self.position + movement,
pieceToCapture=pieceBesidePawn)
move.pessant = True
move.specialMovePiece = pieceBesidePawn
yield move
def getPossibleMoves(self):
# Function run to yield a group of all possible legal and illegal
# 'Move' objects to the calling function. Does this by running through
# a list of movements and testing for valid moves before yielding them.
# Also goes through another special algorithm to test if it can also
# perform another special type of move, a 'castle'.
pos = self.position
movements = [
C(0, 1),
C(-1, -1),
C(1, 0),
C(-1, 0),
C(1, 1),
C(1, -1),
C(-1, 1),
C(0, -1)
]
for movement in movements:
newPos = pos + movement
if self.board.isValidPos(newPos):
pieceAtNewPos = self.board.pieceAtPosition(newPos)
if self.board.pieceAtPosition(newPos) is None:
yield Move(self, newPos)
elif pieceAtNewPos.side != self.side:
yield Move(self, newPos, pieceToCapture=pieceAtNewPos)
if self.movesMade == 0: # CASTLING, HIGHLY WIP
inCheck = False
kingSideCastleBlocked = False
queenSideCastleBlocked = False
kingSideCastleCheck = False
queenSideCastleCheck = False
kingSideRookMoved = True
queenSideRookMoved = True
kingSideCastlePositions = [
self.position - C(1, 0), self.position - C(2, 0)
]
for position in kingSideCastlePositions:
if self.board.pieceAtPosition(position):
kingSideCastleBlocked = True
queenSideCastlePositions = [
self.position + C(1, 0), self.position + C(2, 0),
self.position + C(3, 0)
]
for position in queenSideCastlePositions:
if self.board.pieceAtPosition(position):
queenSideCastleBlocked = True
if kingSideCastleBlocked and queenSideCastleBlocked:
return
opponentMoves = self.board.getAllMovesUnfiltered(not self.side,
includeKing=False)
for move in opponentMoves:
if move.newPos == self.position:
inCheck = True
break
if move.newPos == self.position - C(1, 0) or \
move.newPos == self.position - C(2, 0):
kingSideCastleCheck = True
if move.newPos == self.position + C(1, 0) or \
move.newPos == self.position + C(2, 0):
queenSideCastleCheck = True
kingSideRookPos = self.position - C(3, 0)
kingSideRook = self.board.pieceAtPosition(kingSideRookPos) \
if self.board.isValidPos(kingSideRookPos) else None
if kingSideRook and \
kingSideRook.stringRep == 'R' and \
kingSideRook.movesMade == 0:
kingSideRookMoved = False
queenSideRookPos = self.position + C(4, 0)
queenSideRook = self.board.pieceAtPosition(queenSideRookPos) \
if self.board.isValidPos(kingSideRookPos) else None
if queenSideRook and \
queenSideRook.stringRep == 'R' and \
queenSideRook.movesMade == 0:
queenSideRookMoved = False
if not inCheck:
if not kingSideCastleBlocked and \
not kingSideCastleCheck and \
not kingSideRookMoved:
move = Move(self, self.position - C(2, 0))
move.specialMovePiece = self.board.pieceAtPosition(
kingSideRookPos)
rookMove = Move(move.specialMovePiece,
self.position - C(1, 0))
move.kingSideCastle = True
move.rookMove = rookMove
move.castle = True
yield move
if not queenSideCastleBlocked and \
not queenSideCastleCheck and \
not queenSideRookMoved:
move = Move(self, self.position + C(2, 0))
move.specialMovePiece = self.board.pieceAtPosition(
queenSideRookPos)
rookMove = Move(move.specialMovePiece,
self.position + C(1, 0))
move.queenSideCastle = True
move.rookMove = rookMove
move.castle = True
yield move
