def ResizeCanvas(self, canvasSize):
# Save position of current pieces
currentPositions = dict()
for coordinate, piece in State().GetChessPiecePositions().items():
currentPositions[coordinate] = piece
# Recalculate parameters
Parameters().CalculateDimensionParam(canvasSize)
self.canvas.config(width=canvasSize, height=canvasSize)
for ChessType in Parameters().GetTypesOfChess():
ImgProcessor().ResizeChessPieceImages(ChessType)
# Clear all objects
self.ClearPiecesFromBoard()
for object in self.chessboardObjects:
self.canvas.delete(object)
# Call functions to draw the chess board
if State().GetChessType() == 'Chess':
self.DrawChessBoard()
elif State().GetChessType() == 'XiangQi':
self.DrawXiangQiBoard()
else:
logging.error('Wrong "ChessType" when calling ResizeCanvas!')
exit(1)
# Add pieces to board
for coordinate, chessPiece in currentPositions.items():
self.AddPieceToBoard(chessPiece['PlayerColor'],
chessPiece['PieceType'], coordinate)
def RookMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
PlayerColor = CurrentMove.GetPlayerColor()
isValidMove = False
if coordinate[0] == CurrentMove.GetStartPos()[0]:
isValidMove = True
CheckRange = (coordinate[1], CurrentMove.GetStartPos()[1])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((coordinate[0], i)):
isValidMove = False
break
elif coordinate[1] == CurrentMove.GetStartPos()[1]:
isValidMove = True
CheckRange = (coordinate[0], CurrentMove.GetStartPos()[0])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((i, coordinate[1])):
isValidMove = False
break
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
if CurrentMove.GetStartPos()[0] == 0 and self.GetCastlingStatus(
PlayerColor, 'Long'):
self.SetCastlingStatus(PlayerColor, 'Long', False)
self.GetCurrentMove().SetDisabledCastleTypes('Long')
elif CurrentMove.GetStartPos()[0] == 7 and self.GetCastlingStatus(
PlayerColor, 'Short'):
self.SetCastlingStatus(PlayerColor, 'Short', False)
self.GetCurrentMove().SetDisabledCastleTypes('Short')
return True
return False
def ClearPiecesFromBoard(self):
for coordinate in State().GetChessPiecePositions():
self.canvas.delete(self.chesspiecesObjects[coordinate][0])
self.chesspiecesObjects.pop(coordinate)
State().ClearChessPiecePositions()
State().ClearMoveList()
self.RemoveHighlights()
def JuMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
isValidMove = False
if (coordinate[0] == CurrentMove.GetStartPos()[0]):
isValidMove = True
CheckRange = (coordinate[1], CurrentMove.GetStartPos()[1])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((coordinate[0], i)):
isValidMove = False
break
elif (coordinate[1] == CurrentMove.GetStartPos()[1]):
isValidMove = True
CheckRange = (coordinate[0], CurrentMove.GetStartPos()[0])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((i, coordinate[1])):
isValidMove = False
break
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def lmb_callback(self, event):
ChessType = State().GetChessType()
CellSize = Parameters().GetCellSize(ChessType)
BoardXStart, BoardXEnd = Parameters().GetBoardXLimits(ChessType)
BoardYStart, BoardYEnd = Parameters().GetBoardYLimits(ChessType)
# Handle events within the chessboard
if BoardXStart < event.x < BoardXEnd and BoardYStart < event.y < BoardYEnd:
x = int((event.x - BoardXStart) / CellSize)
y = int((event.y - BoardYStart) / CellSize)
# Check if x,y are allowed values
if x < 0: x = 0
if x >= Parameters().GetChessBoardXArray(ChessType):
x = Parameters().GetChessBoardXArray(ChessType) - 1
if y < 0: y = 0
if y >= Parameters().GetChessBoardYArray(ChessType):
y = Parameters().GetChessBoardYArray(ChessType) - 1
coordinate = (x, y)
if State().IsGameOngoing():
MoveHandler().Process(coordinate)
else:
self.ChangePieceOnBoard(coordinate)
def Process(self, coordinate):
SelectedPiece = State().GetChessPieceAtPosition(coordinate)
PlayerColor, PieceType = None, None
if SelectedPiece != None:
PlayerColor = SelectedPiece['PlayerColor']
PieceType = SelectedPiece['PieceType']
if self.GetCurrentMove().GetStartPiece() == None:
if PieceType != None and (
self.GetMoveIndex() == 0
or self.GetPreviousMove().GetPlayerColor() != PlayerColor):
self.GetCurrentMove().SetStartPieceAndPos(
PlayerColor, PieceType, coordinate)
self.__ChessBoard.RemoveHighlights()
self.__ChessBoard.AddHighlight(coordinate)
else:
if PieceType != None and PlayerColor == self.GetCurrentMove(
).GetPlayerColor():
self.GetCurrentMove().SetStartPieceAndPos(
PlayerColor, PieceType, coordinate)
self.__ChessBoard.RemoveHighlights()
self.__ChessBoard.AddHighlight(coordinate)
else:
ChessType = State().GetChessType()
if ChessType == 'Chess':
self.ChessMove(coordinate)
elif ChessType == 'XiangQi':
self.XiangQiMove(coordinate)
def ChangeChessType(self, target_type):
State().SetChessType(target_type)
self.ChessBoard.ClearPiecesFromBoard()
self.ChessBoard.InitChessBoard()
self.chesspieces.InitializeMenu()
State().ClearMoveList()
self.ChessBoard.RemoveHighlights()
def AddPieceToBoard(self, PlayerColor, PieceType, coordinate):
State().AddChessPieceToPosition(PlayerColor, PieceType, coordinate)
ChessType = State().GetChessType()
img = ImgProcessor().GetPhotoImage(ChessType,
PlayerColor + '_' + PieceType)
self.chesspiecesObjects[coordinate] = [
self.canvas.create_image(Parameters().GetCellCenter(
ChessType, coordinate),
image=img), img
]
def quickload():
self.ChessBoard.ClearPiecesFromBoard()
for coordinate, piece in State().GetQuickSavePosition().items():
self.ChessBoard.AddPieceToBoard(piece['PlayerColor'],
piece['PieceType'], coordinate)
State().ClearMoveList()
self.ChessBoard.RemoveHighlights()
self.CaptionPanel.delete(0, tkinter.END)
self.CaptionPanel.insert(0, State().GetSavedCaption())
def InitChessBoard(self):
self.ClearPiecesFromBoard()
for object in self.chessboardObjects:
self.canvas.delete(object)
if State().GetChessType() == 'Chess':
self.DrawChessBoard()
elif State().GetChessType() == 'XiangQi':
self.DrawXiangQiBoard()
self.StartingPositions()
def callback():
if State().GetSelectedPieceToAddToBoard() != var.get():
if var.get() != 'deselect':
State().ClearMoveList()
self.ChessBoard.RemoveHighlights()
State().SetSelectedPieceToAddToBoard(var.get())
if var.get() == 'deselect':
State().SetGameIsOngoing(True)
else:
State().SetGameIsOngoing(False)
def LoadFromFile():
filename = filedialog.askopenfilename(
initialdir='.',
filetypes=(('Comma Separated Values', '*.csv*'), ('all files',
'*.*')))
if filename != '':
data = dict()
file = open(filename, 'r')
lines = file.read().split('\n')
self.CaptionPanel.delete(0, tkinter.END)
self.CaptionPanel.insert(0, lines[0])
for line in lines[1:]:
if line:
x, y, piece = line.split(',')
data[(int(x), int(y))] = piece
file.close()
# Get types of chess pieces
chess_piece_types = set()
for chess_piece in data.values():
chess_piece_types.add(chess_piece.split('_')[1])
# Find out what type of chess it is
ChessType = 'Chess'
for piece in chess_piece_types:
if ChessType == 'Chess' and piece not in Parameters(
).GetTypesOfChessPieces('Chess'):
ChessType = 'XiangQi'
# Change chess type if neccessary
if ChessType != State().GetChessType():
self.chess_type_var.set(ChessType)
self.ChangeChessType(ChessType)
# Update chess pieces
self.ChessBoard.ClearPiecesFromBoard()
for coordinate, piece in data.items():
if 0 <= coordinate[0] < Parameters().GetChessBoardXArray(
ChessType) and 0 <= coordinate[1] < Parameters(
).GetChessBoardYArray(ChessType):
self.ChessBoard.AddPieceToBoard(
piece['PlayerColor'], piece['PieceType'],
coordinate)
else:
msg = 'Coordinate ' + str(
coordinate
) + ' is out of range!\nThe piece will be ignored.'
messagebox.showerror('Warning', msg)
State().ClearMoveList()
self.ChessBoard.RemoveHighlights()
def AddMenu(self):
ChessType = State().GetChessType()
PlayerColors = Parameters().GetPlayerColors(ChessType)
TypesOfChessPieces = Parameters().GetTypesOfChessPieces(ChessType)
State().SetGameIsOngoing(True)
var = tkinter.StringVar(value='deselect')
def callback():
if State().GetSelectedPieceToAddToBoard() != var.get():
if var.get() != 'deselect':
State().ClearMoveList()
self.ChessBoard.RemoveHighlights()
State().SetSelectedPieceToAddToBoard(var.get())
if var.get() == 'deselect':
State().SetGameIsOngoing(True)
else:
State().SetGameIsOngoing(False)
for piece in TypesOfChessPieces:
RadiobtnFrame = tkinter.Frame(self.frame)
RadiobtnFrame.pack(anchor='w')
for PlayerColor in PlayerColors:
ChessPieceString = PlayerColor + '_' + piece
img = ImgProcessor().GetImage(ChessType, ChessPieceString)
LongerSide = img.size[
0] if img.size[0] > img.size[1] else img.size[1]
ScalingFactor = self.__RadiobtnSize / LongerSide
ScaledSize = (int(ScalingFactor * img.size[0]),
int(ScalingFactor * img.size[1]))
img = ImageTk.PhotoImage(img.resize(ScaledSize))
Radiobtn = tkinter.Radiobutton(RadiobtnFrame,
command=callback,
variable=var,
value=ChessPieceString,
image=img,
indicatoron=0,
width=self.__RadiobtnSize,
height=self.__RadiobtnSize)
Radiobtn.image = img
Radiobtn.pack(side=tkinter.LEFT)
tkinter.Radiobutton(self.frame,
command=callback,
variable=var,
value='remove',
text='Remove').pack(anchor='w')
tkinter.Radiobutton(self.frame,
command=callback,
variable=var,
value='deselect',
text='Deselect').pack(anchor='w')
def StartingPositions(self):
self.ClearPiecesFromBoard()
ChessType = State().GetChessType()
if ChessType == 'Chess':
order = ('rook', 'knight', 'bishop', 'queen', 'king', 'bishop',
'knight', 'rook')
for i in range(len(order)):
self.AddPieceToBoard('white', order[i], (i, 7))
self.AddPieceToBoard('white', 'pawn', (i, 6))
self.AddPieceToBoard('black', order[i], (i, 0))
self.AddPieceToBoard('black', 'pawn', (i, 1))
elif ChessType == 'XiangQi':
order = ('ju', 'ma', 'xiang', 'shi', 'shuai', 'shi', 'xiang', 'ma',
'ju')
for i in range(len(order)):
self.AddPieceToBoard('red', order[i], (i, 9))
self.AddPieceToBoard('black', order[i], (i, 0))
for i in (1, 7):
self.AddPieceToBoard('red', 'pao', (i, 7))
self.AddPieceToBoard('black', 'pao', (i, 2))
for i in range(0, 9, 2):
self.AddPieceToBoard('red', 'bing', (i, 6))
self.AddPieceToBoard('black', 'bing', (i, 3))
MoveHandler(self).ClearMoveList()
self.RemoveHighlights()
def PaoMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
isValidMove = False
if (coordinate[0] == CurrentMove.GetStartPos()[0]):
CollisionCount = 0
CheckRange = (coordinate[1], CurrentMove.GetStartPos()[1])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((coordinate[0], i)):
CollisionCount += 1
if CollisionCount >= 2:
return False
if not State().PieceExistsAtPosition(coordinate):
if CollisionCount == 0:
isValidMove = True
elif CollisionCount == 1:
isValidMove = True
elif (coordinate[1] == CurrentMove.GetStartPos()[1]):
CollisionCount = 0
CheckRange = (coordinate[0], CurrentMove.GetStartPos()[0])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((i, coordinate[1])):
CollisionCount += 1
if CollisionCount >= 2:
return False
if not State().PieceExistsAtPosition(coordinate):
if CollisionCount == 0:
isValidMove = True
elif CollisionCount == 1:
isValidMove = True
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def ShuaiMove(self, coordinate):
ChessType = 'XiangQi'
CurrentMove = self.GetCurrentMove()
PlayerColor = CurrentMove.GetPlayerColor()
isValidMove = False
xCoordinateLim = (3, 5)
yCoordinateLim = (0, 2)
if PlayerColor == Parameters().GetPlayerColors(ChessType)[0]:
yCoordinateLim = (Parameters().GetChessBoardYArray(ChessType) - 1 -
yCoordinateLim[1],
Parameters().GetChessBoardYArray(ChessType) - 1 -
yCoordinateLim[0])
if abs(coordinate[0] - CurrentMove.GetStartPos(
)[0]) == 1 and coordinate[1] == CurrentMove.GetStartPos(
)[1] and xCoordinateLim[0] <= coordinate[0] <= xCoordinateLim[1]:
isValidMove = True
elif abs(coordinate[1] - CurrentMove.GetStartPos(
)[1]) == 1 and coordinate[0] == CurrentMove.GetStartPos(
)[0] and yCoordinateLim[0] <= coordinate[1] <= yCoordinateLim[1]:
isValidMove = True
else:
EnemyKing = State().GetChessPieceAtPosition(coordinate)
if EnemyKing != None and EnemyKing[
'PlayerColor'] != CurrentMove.GetPlayerColor(
) and EnemyKing['PieceType'] == 'shuai':
isBlocked = False
CheckRange = (coordinate[1], CurrentMove.GetStartPos()[1])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((coordinate[0], i)):
isBlocked = True
break
if not isBlocked:
isValidMove = True
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def MaMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
isValidMove = False
xDiff = abs(coordinate[0] - CurrentMove.GetStartPos()[0])
yDiff = abs(coordinate[1] - CurrentMove.GetStartPos()[1])
if xDiff == 1 and yDiff == 2:
BlockPos = (CurrentMove.GetStartPos()[0],
(coordinate[1] + CurrentMove.GetStartPos()[1]) // 2)
if not State().PieceExistsAtPosition(BlockPos):
isValidMove = True
elif xDiff == 2 and yDiff == 1:
BlockPos = ((coordinate[0] + CurrentMove.GetStartPos()[0]) // 2,
CurrentMove.GetStartPos()[1])
if not State().PieceExistsAtPosition(BlockPos):
isValidMove = True
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def QueenMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
isValidMove = False
if coordinate[0] == CurrentMove.GetStartPos()[0]:
isValidMove = True
CheckRange = (coordinate[1], CurrentMove.GetStartPos()[1])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().GetChessPieceAtPosition((coordinate[0], i)) != None:
isValidMove = False
break
elif coordinate[1] == CurrentMove.GetStartPos()[1]:
isValidMove = True
CheckRange = (coordinate[0], CurrentMove.GetStartPos()[0])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((i, coordinate[1])):
isValidMove = False
break
elif abs(coordinate[0] - CurrentMove.GetStartPos()[0]) == abs(
coordinate[1] - CurrentMove.GetStartPos()[1]):
isValidMove = True
x, y = CurrentMove.GetStartPos()
xDirection = 1 if CurrentMove.GetStartPos(
)[0] < coordinate[0] else -1
yDirection = 1 if CurrentMove.GetStartPos(
)[1] < coordinate[1] else -1
for i in range(1,
abs(CurrentMove.GetStartPos()[0] - coordinate[0])):
if State().GetChessPieceAtPosition(
(x + i * xDirection, y + i * yDirection)) != None:
isValidMove = False
break
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def SaveToFile():
filename = filedialog.asksaveasfilename(
initialdir='.',
title='Select a File',
defaultextension='.csv',
filetypes=(('csv files', '*.csv*'), ('all files', '*.*')))
if filename != '':
file = open(filename, 'w')
file.write(self.CaptionPanel.get() + '\n')
for key, value in State().GetChessPiecePositions().items():
file.write(
str(key[0]) + ',' + str(key[1]) + ',' + str(value) +
'\n')
file.close()
def ResetCastlingStatus(self):
for color, KingYCoordinate in {'white': 7, 'black': 0}.items():
KingPiece = State().GetChessPieceAtPosition((4, KingYCoordinate))
if KingPiece is None:
break
if KingPiece['PlayerColor'] == color and KingPiece[
'PieceType'] == 'king':
for CastleType, RookXCoordinate in {
'Long': 0,
'Short': 7
}.items():
RookPiece = State().GetChessPieceAtPosition(
(RookXCoordinate, KingYCoordinate))
if RookPiece == None:
continue
if RookPiece['PlayerColor'] == color and RookPiece[
'PieceType'] == 'rook':
self.SetCastlingStatus(color, CastleType, True)
else:
self.SetCastlingStatus(color, CastleType, False)
else:
for CastleType in ('Long', 'Short'):
self.SetCastlingStatus(color, CastleType, False)
def KingMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
PlayerColor = CurrentMove.GetPlayerColor()
isValidMove = False
if abs(coordinate[0] - CurrentMove.GetStartPos()[0]) <= 1 and abs(
coordinate[1] - CurrentMove.GetStartPos()[1]) <= 1:
isValidMove = True
elif abs(coordinate[0] - CurrentMove.GetStartPos()[0]
) == 2 and coordinate[1] == CurrentMove.GetStartPos()[1]:
CastleType = {2: 'Long', 6: 'Short'}
RookPos = {'Long': 0, 'Short': 7}
if coordinate[0] in CastleType.keys() and self.GetCastlingStatus(
PlayerColor, CastleType[coordinate[0]]):
isBlocked = False
CheckRange = (coordinate[0],
RookPos[CastleType[coordinate[0]]])
CheckRange = (min(CheckRange), max(CheckRange))
for i in range(CheckRange[0] + 1, CheckRange[1]):
if State().PieceExistsAtPosition((i, coordinate[1])):
isBlocked = True
break
if not isBlocked:
self.__ChessBoard.RemovePieceFromBoard(
(RookPos[CastleType[coordinate[0]]], coordinate[1]))
RookEndCoordinate = (
(coordinate[0] + CurrentMove.GetStartPos()[0]) // 2,
coordinate[1])
self.__ChessBoard.AddPieceToBoard(PlayerColor, 'rook',
RookEndCoordinate)
isValidMove = True
if isValidMove:
for CastleType in ('Long', 'Short'):
self.SetCastlingStatus(PlayerColor, CastleType, False)
self.GetCurrentMove().SetDisabledCastleTypes(CastleType)
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def BishopMove(self, coordinate):
CurrentMove = self.GetCurrentMove()
isValidMove = False
if abs(coordinate[0] - CurrentMove.GetStartPos()[0]) == abs(
coordinate[1] - CurrentMove.GetStartPos()[1]):
isValidMove = True
x, y = CurrentMove.GetStartPos()
xDirection = 1 if CurrentMove.GetStartPos(
)[0] < coordinate[0] else -1
yDirection = 1 if CurrentMove.GetStartPos(
)[1] < coordinate[1] else -1
for i in range(1,
abs(CurrentMove.GetStartPos()[0] - coordinate[0])):
if State().GetChessPieceAtPosition(
(x + i * xDirection, y + i * yDirection)) != None:
isValidMove = False
break
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def XiangMove(self, coordinate):
ChessType = 'XiangQi'
CurrentMove = self.GetCurrentMove()
PlayerColor = CurrentMove.GetPlayerColor()
isValidMove = False
yCoordinateLim = (0, 4)
if PlayerColor == Parameters().GetPlayerColors(ChessType)[0]:
yCoordinateLim = (Parameters().GetChessBoardYArray(ChessType) - 1 -
yCoordinateLim[1],
Parameters().GetChessBoardYArray(ChessType) - 1 -
yCoordinateLim[0])
if (abs(coordinate[0] - CurrentMove.GetStartPos()[0]) == 2
and abs(coordinate[1] - CurrentMove.GetStartPos()[1]) == 2
and yCoordinateLim[0] <= coordinate[1] <= yCoordinateLim[1]):
midpoint = ((coordinate[0] + CurrentMove.GetStartPos()[0]) // 2,
(coordinate[1] + CurrentMove.GetStartPos()[1]) // 2)
if State().GetChessPieceAtPosition(midpoint) == None:
isValidMove = True
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
return True
return False
def quicksave():
State().SetQuickSavePosition()
State().SetSavedCaption(self.CaptionPanel.get())
def RemovePieceFromBoard(self, coordinate):
if coordinate in State().GetChessPiecePositions():
self.canvas.delete(self.chesspiecesObjects[coordinate][0])
self.chesspiecesObjects.pop(coordinate)
State().RemoveChessPieceFromPosition(coordinate)
def callback():
if State().GetChessType() != self.chess_type_var.get():
self.ChangeChessType(self.chess_type_var.get())
def SetEndPos(self, Position):
ChessPiece = State().GetChessPieceAtPosition(Position)
if ChessPiece != None:
self.SetTakenPieceAndPos(ChessPiece, Position)
self.__EndPiece = self.GetStartPiece()
self.__EndPos = Position
def PawnMove(self, coordinate):
PieceType = 'pawn'
CurrentMove = self.GetCurrentMove()
PlayerColor = CurrentMove.GetPlayerColor()
isValidMove = False
if PlayerColor == 'white':
StartingRow = 6
MoveDirection = -1
else:
StartingRow = 1
MoveDirection = 1
# Check if pawn is moving straight
if coordinate[0] == CurrentMove.GetStartPos()[0]:
StepsTaken = coordinate[1] - CurrentMove.GetStartPos()[1]
if StepsTaken == MoveDirection:
isValidMove = True
elif CurrentMove.GetStartPos(
)[1] == StartingRow and StepsTaken == MoveDirection * 2:
isValidMove = True
# Check if pawn is taking another piece
elif abs(coordinate[0] -
CurrentMove.GetStartPos()[0]) == 1 and coordinate[
1] - CurrentMove.GetStartPos()[1] == MoveDirection:
if State().PieceExistsAtPosition(coordinate):
isValidMove = True
# En passant
else:
EnPassantEndingRow = {'white': 2, 'black': 5}
if coordinate[1] == EnPassantEndingRow[PlayerColor]:
EnemyPawnPos = (coordinate[0],
CurrentMove.GetStartPos()[1])
EnemyPawn = State().GetChessPieceAtPosition(EnemyPawnPos)
if EnemyPawn != None and EnemyPawn[
'PlayerColor'] != PlayerColor and EnemyPawn[
'PieceType'] == PieceType:
if self.GetMoveIndex() == 0:
self.GetCurrentMove().SetTakenPieceAndPos(
PieceType, coordinate)
isValidMove = True
elif self.GetPreviousMove().GetStartPiece(
) == PieceType and self.GetPreviousMove().GetEndPos(
)[0] == coordinate[0] and abs(
self.GetPreviousMove().GetStartPos()[1] -
self.GetPreviousMove().GetEndPos()[1]) == 2:
self.GetCurrentMove().SetTakenPieceAndPos(
PieceType, EnemyPawnPos)
isValidMove = True
def PawnPromotion(color):
class PromotionPrompt:
def __init__(self):
root = Parameters().GetRoot()
self.PieceToPromoteTo = None
self.PromotionWindow = tkinter.Toplevel(root)
self.PromotionWindow.title('Promotion')
def callback(ChosenPiece):
self.PieceToPromoteTo = ChosenPiece
self.PromotionWindow.destroy()
for PieceType in Parameters().GetTypesOfChessPieces(
'Chess'):
if PieceType != 'king' and PieceType != 'pawn':
ImgName = color + '_' + PieceType
ButtonSize = Parameters().GetCellSize('Chess')
img = ImgProcessor().GetPhotoImage(
'Chess', ImgName)
bt = tkinter.Button(
self.PromotionWindow,
image=img,
command=lambda s=PieceType: callback(s),
width=ButtonSize,
height=ButtonSize)
bt.image = img
bt.pack(side=tkinter.LEFT)
root.wait_window(self.PromotionWindow)
promotion = PromotionPrompt()
if promotion.PieceToPromoteTo == None:
return 'queen'
return promotion.PieceToPromoteTo
if isValidMove:
self.GetCurrentMove().SetEndPos(coordinate)
PromotionRow = {'white': 0, 'black': 7}
if coordinate[1] == PromotionRow[PlayerColor]:
self.GetCurrentMove().SetEndPiece(PawnPromotion(PlayerColor))
return True
return False
def AddHighlight(self, square):
if square != 0:
ChessType = State().GetChessType()
linewidth = Parameters().GetHighlightLinewidth()
color = Parameters().GetHighlightColor(ChessType)
x, y = Parameters().GetCellCenter(ChessType, square)
size = 0.5 * Parameters().GetCellSize(ChessType)
length = 0.6 * size
offset = 0.1 * linewidth
# Top left corner
self.active_square_objects.append(
self.canvas.create_rectangle(x - size + offset,
y - size + offset,
x - size + length,
y - size + linewidth,
width=0,
fill=color))
self.active_square_objects.append(
self.canvas.create_rectangle(x - size + offset,
y - size + offset,
x - size + linewidth,
y - size + length,
width=0,
fill=color))
# Top right corner
self.active_square_objects.append(
self.canvas.create_rectangle(x + size - offset,
y - size + offset,
x + size - length,
y - size + linewidth,
width=0,
fill=color))
self.active_square_objects.append(
self.canvas.create_rectangle(x + size - offset,
y - size + offset,
x + size - linewidth,
y - size + length,
width=0,
fill=color))
# Bottom left corner
self.active_square_objects.append(
self.canvas.create_rectangle(x - size + offset,
y + size - offset,
x - size + length,
y + size - linewidth,
width=0,
fill=color))
self.active_square_objects.append(
self.canvas.create_rectangle(x - size + offset,
y + size - offset,
x - size + linewidth,
y + size - length,
width=0,
fill=color))
# Bottom right corner
self.active_square_objects.append(
self.canvas.create_rectangle(x + size - offset,
y + size - offset,
x + size - length,
y + size - linewidth,
width=0,
fill=color))
self.active_square_objects.append(
self.canvas.create_rectangle(x + size - offset,
y + size - offset,
x + size - linewidth,
y + size - length,
width=0,
fill=color))
def SetupLogging():
logDirName = 'log'
if not os.path.exists(logDirName):
os.makedirs(logDirName)
logging.basicConfig(
filename=logDirName + os.path.sep + date.today().strftime('%Y%m%d') +
'.log',
encoding='utf-8',
format='%(asctime)s %(levelname)-8s %(module)-30s: %(message)s',
level=logging.INFO,
datefmt='%Y-%m-%d %H:%M:%S',
)
if __name__ == '__main__':
SetupLogging()
logging.info('Program has started')
Parameters()
State()
ImgProcessor()
root = tkinter.Tk()
root.state('zoomed')
Parameters().SetRoot(root)
MainWindow = MainWindow(root)
root.mainloop()