def moveForLongNotation(self, notation) :
transTable = str.maketrans('abcdefgh', '01234567')
humanInput = humanInput.translate(transTable)
humanInput = [int(c) for c in humanInput]
oldPos = C(humanInput[0], humanInput[1])
newPos = C(humanInput[2], humanInput[3])
return Move(oldPos, newPos)
def getPossibleMoves(self):
currentPosition = self.position
directions = [C(1, 1), C(1, -1), C(-1, 1), C(-1, -1)]
for direction in directions:
for move in self.movesInDirectionFromPos(currentPosition,
direction, self.side):
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 providing a list
# of directions to the 'movesInDirectionFromPos' function which then
# returns the moves to be yielded.
pos = self.position
directions = [C(1, 1), C(-1, -1), C(-1, 1), C(1, -1)]
for direction in directions:
for move in self.movesInDirectionFromPos(pos, direction,
self.side):
yield move
def makeUnicodeStringRep(self, pieces):
DISPLAY_LOOKUP = {
"R": "♜",
"N": "♞",
"B": "♝",
"K": "♚",
"Q": "♛",
"P": "♟",
}
stringRep = ''
for y in range(7, -1, -1):
for x in range(8):
piece = None
for p in pieces:
if p.position == C(x, y):
piece = p
break
on_color = 'on_cyan' if y % 2 == x % 2 else 'on_yellow'
pieceRep = colored(' ', on_color=on_color)
if piece:
side = piece.side
color = 'white' if side == WHITE else 'grey'
pieceRep = colored(piece.stringRep + ' ',
color=color,
on_color=on_color)
stringRep += pieceRep
stringRep += '\n'
return stringRep.rstrip()
def makeUnicodeStringRep(self, pieces):
DISPLAY_LOOKUP = {
"R": '♜',
"N": '♞',
"B": '♝',
"K": '♚',
"Q": '♛',
"P": '♟',
}
stringRep = ''
for y in range(7, -1, -1):
for x in range(8):
piece = None
for p in pieces:
if p.position == C(x, y):
piece = p
break
on_color = 'on_cyan' if y % 2 == x % 2 else 'on_yellow'
pieceRep = colored(' ', on_color=on_color)
if piece:
side = piece.side
color = 'white' if side == WHITE else 'grey'
pieceRep = colored(DISPLAY_LOOKUP[piece.stringRep] + ' ',
color=color,
on_color=on_color)
else:
if (x + y) % 2 == 0:
pieceRep = 'X'
else:
pieceRep = ' '
stringRep += pieceRep + ' '
stringRep += '\n'
return stringRep.rstrip()
def movesInDirectionFromPos(self, pos, direction, side) :
for dis in range(1, 8) :
movement = C(dis * direction[X], dis * direction[Y])
newPos = pos + movement
if self.board.isValidPos(newPos) :
pieceAtNewPos = self.board.pieceAtPosition(newPos)
if pieceAtNewPos is None :
yield Move(self, newPos)
elif pieceAtNewPos is not None :
if pieceAtNewPos.side != side :
yield Move(self, newPos, pieceToCapture = pieceAtNewPos)
return
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 loadGame(self, filename):
board = Board()
board.pieces.clear()
parserWhite = InputParser(board, WHITE)
parserBlack = InputParser(board, BLACK)
gameFile = open(filename, "r")
lines = []
for line in gameFile:
lines.append(line)
gameFile.close()
histStr = lines[8]
currentSide = ('W' == histStr[0])
board.currentSide = currentSide
pieceDict = dict.fromkeys(['p', '0', '1', '6', '7'], Pawn)
pieceDict.update(dict.fromkeys(['k'], Knight))
pieceDict.update(dict.fromkeys(['b'], Bishop))
pieceDict.update(dict.fromkeys(['r', '2', '3', '8', '9'], Rook))
pieceDict.update(dict.fromkeys(['q'], Queen))
pieceDict.update(dict.fromkeys(['k', '4', '5', 'm'], King))
for i in range(8):
for j, p in enumerate(lines[i]):
if p == '-':
continue
coords = C(j, i)
movesMade = 0
if p.isalpha():
side = p.isupper() #WHITE if True, else BLACK
if p.lower() == 'm': #king on either side
movesMade = 2
#movesMade += 1 + int(p.isupper()) #movesMade = 1 or 2 based on p's case
#if p.lower() in "ab" and ((side == WHITE and coords[1] == 1) \
# or (side == BLACK and coords[1] == 6)): #proves p is a pawn that hasn't moved
# movesMade = 0
else:
numP = int(p)
side = (numP % 2 == 0) #WHITE if True, else BLACK
movesMade = 1 + int(numP > 5)
board.pieces.extend(pieceDict[p.lower()](board, side, coords,
movesMade))
#TODO: Process last move to enter into board.history
return board
def makeStringRep(self, pieces):
stringRep = ''
for y in range(7, -1, -1):
for x in range(8):
piece = None
for p in pieces:
if p.position == C(x, y):
piece = p
break
pieceRep = ''
if piece:
side = piece.side
color = 'blue' if side == WHITE else 'red'
pieceRep = piece.stringRep
else:
pieceRep = '·'
stringRep += pieceRep + ' '
stringRep += '\n'
return stringRep.rstrip()
def getPossibleMoves(self):
board = self.board
currentPos = self.position
movements = [
C(2, 1),
C(2, -1),
C(-2, 1),
C(-2, -1),
C(1, 2),
C(1, -2),
C(-1, -2),
C(-1, 2)
]
for movement in movements:
newPos = currentPos + movement
if board.isValidPos(newPos):
pieceAtNewPos = board.pieceAtPosition(newPos)
if pieceAtNewPos is None:
yield Move(self, newPos)
elif pieceAtNewPos.side != self.side:
yield Move(self, newPos, pieceToCapture=pieceAtNewPos)
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.
board = self.board
pos = self.position
movements = [
C(2, 1),
C(2, -1),
C(-2, 1),
C(-2, -1),
C(1, 2),
C(1, -2),
C(-1, 2),
C(-1, -2)
]
for movement in movements:
newPos = pos + movement
if board.isValidPos(newPos):
pieceAtNewPos = board.pieceAtPosition(newPos)
if pieceAtNewPos is None:
yield Move(self, newPos)
elif pieceAtNewPos.side != self.side:
yield Move(self, newPos, pieceToCapture=pieceAtNewPos)
def makeStringRep(self, pieces):
# This creates the raw printable board before it is passed to the
# wrapping function. It goes through each 'spot' on the board and
# depending on whether there is a piece assigned to said 'spot',
# it will either add a simple white '-' or else add either a red
# or a blue letter depending on the type of the piece.
stringRep = ''
for y in range(7, -1, -1):
for x in range(8):
piece = None
for p in pieces:
if p.position == C(x, y):
piece = p
break
if piece:
side = piece.side
color = 'cyan' if side == WHITE else 'red'
pieceRep = colored(piece.stringRep, color)
else:
pieceRep = colored('-', 'white')
stringRep += pieceRep + ' '
stringRep += '\n'
stringRep = stringRep.strip()
return stringRep
def getPositionOfPiece(self, piece):
for y in range(8):
for x in range(8):
if self.boardArray[y][x] is piece:
return C(x, 7 - y)
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 __init__(self,
mateInOne=False,
castleBoard=False,
pessant=False,
promotion=False):
self.pieces = []
self.history = []
self.points = 0
self.currentSide = WHITE
self.movesMade = 0
self.checkmate = False
if not mateInOne and not castleBoard and not pessant and not promotion:
self.pieces.extend([
Rook(self, BLACK, C(0, 7)),
Knight(self, BLACK, C(1, 7)),
Bishop(self, BLACK, C(2, 7)),
Queen(self, BLACK, C(3, 7)),
King(self, BLACK, C(4, 7)),
Bishop(self, BLACK, C(5, 7)),
Knight(self, BLACK, C(6, 7)),
Rook(self, BLACK, C(7, 7))
])
for x in range(8):
self.pieces.append(Pawn(self, BLACK, C(x, 6)))
for x in range(8):
self.pieces.append(Pawn(self, WHITE, C(x, 1)))
self.pieces.extend([
Rook(self, WHITE, C(0, 0)),
Knight(self, WHITE, C(1, 0)),
Bishop(self, WHITE, C(2, 0)),
Queen(self, WHITE, C(3, 0)),
King(self, WHITE, C(4, 0)),
Bishop(self, WHITE, C(5, 0)),
Knight(self, WHITE, C(6, 0)),
Rook(self, WHITE, C(7, 0))
])
elif promotion:
pawnToPromote = Pawn(self, WHITE, C(1, 6))
pawnToPromote.movesMade = 1
kingWhite = King(self, WHITE, C(4, 0))
kingBlack = King(self, BLACK, C(3, 2))
self.pieces.extend([pawnToPromote, kingWhite, kingBlack])
elif pessant:
pawn = Pawn(self, WHITE, C(1, 4))
pawn2 = Pawn(self, BLACK, C(2, 6))
kingWhite = King(self, WHITE, C(4, 0))
kingBlack = King(self, BLACK, C(3, 2))
self.pieces.extend([pawn, pawn2, kingWhite, kingBlack])
self.history = []
self.currentSide = BLACK
self.points = 0
self.movesMade = 0
self.checkmate = False
firstMove = Move(pawn2, C(2, 4))
self.makeMove(firstMove)
self.currentSide = WHITE
return
def humanCoordToPosition(self, coord):
transTable = str.maketrans('abcdefgh', '12345678')
coord = coord.translate(transTable)
coord = [int(c) - 1 for c in coord]
pos = C(coord[0], coord[1])
return pos
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
def __init__(self,
mateInOne=False,
castleBoard=False,
passant=False,
promotion=False):
self.pieces = []
self.history = []
self.points = 0
self.currentSide = WHITE
self.movesMade = 0
self.checkmate = False
if not mateInOne and not castleBoard and not passant and not promotion:
self.pieces.extend([
Rook(self, BLACK, C(0, 7)),
Knight(self, BLACK, C(1, 7)),
Bishop(self, BLACK, C(2, 7)),
Queen(self, BLACK, C(3, 7)),
King(self, BLACK, C(4, 7)),
Bishop(self, BLACK, C(5, 7)),
Knight(self, BLACK, C(6, 7)),
Rook(self, BLACK, C(7, 7))
])
for x in range(8):
self.pieces.append(Pawn(self, BLACK, C(x, 6)))
for x in range(8):
self.pieces.append(Pawn(self, WHITE, C(x, 1)))
self.pieces.extend([
Rook(self, WHITE, C(0, 0)),
Knight(self, WHITE, C(1, 0)),
Bishop(self, WHITE, C(2, 0)),
Queen(self, WHITE, C(3, 0)),
King(self, WHITE, C(4, 0)),
Bishop(self, WHITE, C(5, 0)),
Knight(self, WHITE, C(6, 0)),
Rook(self, WHITE, C(7, 0))
])
elif mateInOne:
kingW = King(self, WHITE, C(4, 0))
kingB = King(self, BLACK, C(4, 7))
rook1 = Rook(self, WHITE, C(3, 0))
rook2 = Rook(self, WHITE, C(5, 0))
queen = Queen(self, WHITE, C(7, 1))
self.pieces.extend([kingW, kingB, rook1, rook2, queen])
elif castleBoard:
kingW = King(self, WHITE, C(4, 0))
kingB = King(self, BLACK, C(4, 7))
rook1 = Rook(self, WHITE, C(0, 0))
rook2 = Rook(self, WHITE, C(7, 0))
pawn1 = Pawn(self, WHITE, C(1, 3))
pawn2 = Pawn(self, WHITE, C(2, 1))
bshp = Bishop(self, WHITE, C(3, 3))
queen = Queen(self, BLACK, C(2, 4))
self.pieces.extend(
[kingW, kingB, rook1, rook2, pawn1, pawn2, bshp, queen])
elif promotion:
pawn1 = Pawn(self, WHITE, C(1, 6))
pawn1.movesMade = 1
pawn2 = Pawn(self, WHITE, C(2, 6))
pawn3 = Pawn(self, WHITE, C(3, 5))
pawnB = Pawn(self, BLACK, C(2, 7))
kingWhite = King(self, WHITE, C(4, 0))
kingBlack = King(self, BLACK, C(3, 2))
self.pieces.extend(
[pawn1, pawn2, pawn3, pawnB, kingWhite, kingBlack])
elif passant:
pawn = Pawn(self, WHITE, C(1, 4))
pawn2 = Pawn(self, BLACK, C(2, 6))
kingWhite = King(self, WHITE, C(4, 0))
kingBlack = King(self, BLACK, C(3, 2))
self.pieces.extend([pawn, pawn2, kingWhite, kingBlack])
self.history = []
self.currentSide = BLACK
self.points = 0
self.movesMade = 0
self.checkmate = False
firstMove = Move(pawn2, C(2, 4))
self.makeMove(firstMove)
self.currentSide = WHITE
return
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 __init__(self):
# The initialising function of the 'Board' class. Assigns all of the
# attributes their starting values before creating all of the pieces
# needed for the game.
self.pieces = []
self.history = []
self.points = 0
self.currentSide = WHITE
self.movesMade = 0
for x in range(8):
self.pieces.append(Pawn(self, BLACK, C(x, 6)))
self.pieces.append(Pawn(self, WHITE, C(x, 1)))
self.pieces.extend([
Rook(self, WHITE, C(0, 0)),
Knight(self, WHITE, C(1, 0)),
Bishop(self, WHITE, C(2, 0)),
King(self, WHITE, C(3, 0)),
Queen(self, WHITE, C(4, 0)),
Bishop(self, WHITE, C(5, 0)),
Knight(self, WHITE, C(6, 0)),
Rook(self, WHITE, C(7, 0)),
Rook(self, BLACK, C(0, 7)),
Knight(self, BLACK, C(1, 7)),
Bishop(self, BLACK, C(2, 7)),
King(self, BLACK, C(3, 7)),
Queen(self, BLACK, C(4, 7)),
Bishop(self, BLACK, C(5, 7)),
Knight(self, BLACK, C(6, 7)),
Rook(self, BLACK, C(7, 7))
])