import tkinter as tk
from tkinter import messagebox
from tkinter import Button
from functools import partial
class Position:
def __init__(self, row, col):
self.row = row
self.col = col
def match(self,list_pos):
for pos in list_pos:
if pos.row == self.row and pos.col == self.col:
return True
return False
class Piece:
def __init__(self, color, board, position=None):
self.color = color
self.board = board
self.has_moved = False
self.position = position
def __str__(self):
pass
class King(Piece):
def __init__(self,color,board,position=None):
super().__init__(color,board,position)
self.piece_type = "king"
def possible_moves(self):
moves = []
offsets = [(1, 0), (0, 1), (-1, 0), (0, -1),
(1, 1), (-1, 1), (1, -1), (-1, -1)]
for dr, dc in offsets:
new_pos = Position(self.position.row + dr, self.position.col + dc)
if self.board.is_inside_board(new_pos) and (self.board.is_square_empty(new_pos) or self.board.is_enemy_piece(new_pos, self.color)):
moves.append(new_pos)
# Castling
if not self.board.board[self.position.row][self.position.col].has_moved:
# Check kingside castling
if self.board.board[self.position.row][7] and not self.board.board[self.position.row][7].has_moved:
if all(self.board.is_square_empty(Position(self.position.row, c)) for c in range(self.position.col + 1, 7)):
moves.append(Position(self.position.row, self.position.col + 2))
# Check queenside castling
if self.board.board[self.position.row][0] and not self.board.board[self.position.row][0].has_moved:
if all(self.board.is_square_empty(Position(self.position.row, c)) for c in range(1, self.position.col)):
moves.append(Position(self.position.row, self.position.col - 2))
return moves
def move(self,end_pos):
a = self.possible_moves()
for pos in a:
if pos.row == end_pos.row and pos.col == end_pos.col:
return True
return False
def __str__(self):
if self.color == "White":
return "K"
return "k"
class Bishop(Piece):
def __init__(self,color,board,position=None):
super().__init__(color,board,position)
self.piece_type = "bishop"
def possible_moves(self):
moves = []
directions = [(-1, -1), (-1, 1), (1, 1), (1, -1)]
for dr, dc in directions:
temp = self.position
while True:
new_pos = Position(temp.row + dr, temp.col + dc)
temp = new_pos
if self.board.is_inside_board(new_pos) == False:
break
if self.board.is_inside_board(new_pos) and (self.board.is_square_empty(new_pos) or self.board.is_enemy_piece(new_pos, self.color)):
moves.append(new_pos)
if self.board.is_enemy_piece(new_pos, self.color):
break
return moves
def move(self,end_pos):
a = self.possible_moves()
for pos in a:
if pos.row == end_pos.row and pos.col == end_pos.col:
return True
return False
def __str__(self):
if self.color == "White":
return "B"
return "b"
class Pawn(Piece):
def __init__(self,color,board,position=None):
super().__init__(color,board,position)
self.piece_type = "pawn"
def possible_moves(self):
moves = []
direction = 1 if self.color == "White" else -1
start_row = 1 if self.color == "White" else 6
# Moves for regular pawn advance
temp = self.position
count = 0
while count < 2:
new_pos = Position(temp.row + direction, temp.col)
temp = new_pos
if self.board.is_inside_board(new_pos) and self.board.is_square_empty(new_pos):
moves.append(new_pos)
else:
break
count += 1
# Moves for capturing diagonally
temp = self.position
new_pos = Position(temp.row + direction, temp.col - 1)
if self.board.is_inside_board(new_pos):
if self.board.is_enemy_piece(new_pos, self.color):
moves.append(new_pos)
new_pos = Position(temp.row + direction, temp.col + 1)
if self.board.is_inside_board(new_pos):
if self.board.is_enemy_piece(new_pos, self.color):
moves.append(new_pos)
return moves
def move(self,end_pos):
a = self.possible_moves()
for pos in a:
if pos.row == end_pos.row and pos.col == end_pos.col:
return True
return False
def __str__(self):
if self.color == "White":
return "P"
return "p"
class Rook(Piece):
def __init__(self,color,board,positi
super().__init__(color,board,position)
self.piece_type = "rook"
def possible_moves(self):
moves = []
directi 0), (-1, 0), (0, 1), (0, -1)]
for dr, dc in directions:
temp = self.position
while True:
new_pos = Position(temp.row + dr, temp.col + dc)
temp = new_pos
if self.board.is_inside_board(new_pos) == False:
break
if self.board.is_inside_board(new_pos) and (self.board.is_square_empty(new_pos) or self.board.is_enemy_piece(new_pos, self.color)):
moves.append(new_pos)
if self.board.is_enemy_piece(new_pos, self.color):
break
return moves
def move(self,end_pos):
a = self.possible_moves()
for pos in a:
if pos.row == end_pos.row and pos.col == end_pos.col:
return True
return False
def __str__(self):
if self.color == "White":
return "R"
return "r"
class Knight(Piece):
def __init__(self,color,board,positi
super().__init__(color,board,position)
self.piece_type = "knight"
def possible_moves(self):
moves = []
ends = [(-2, 1), (-2, -1), (2, -1), (2, 1), (1, 2), (-1, 2), (1, -2), (-1, -2)]
temp = self.position
for er, ec in ends:
new_pos = Position(temp.row + er, temp.col + ec)
print(new_pos.row, new_pos.col)
if self.board.is_inside_board(new_pos) and (self.board.is_square_empty(new_pos) or self.board.is_enemy_piece(new_pos, self.color)):
moves.append(new_pos)
return moves
def move(self,end_pos):
a = self.possible_moves()
for pos in a:
if pos.row == end_pos.row and pos.col == end_pos.col:
return True
return False
def __str__(self):
if self.color == "White":
return "N"
return "n"
class Queen(Piece):
def __init__(self,color,board,positi
super().__init__(color,board,position)
self.piece_type = "queen"
def possible_moves(self):
moves = []
directi -1), (-1, 1), (1, 1), (1, -1), (1, 0), (-1, 0), (0, 1), (0, -1)]
for dr, dc in directions:
temp = self.position
while True:
new_pos = Position(temp.row + dr, temp.col + dc)
temp = new_pos
if self.board.is_inside_board(new_pos):
if self.board.is_square_empty(new_pos) or self.board.is_enemy_piece(new_pos, self.color):
moves.append(new_pos)
if not self.board.is_inside_board(new_pos):
break
if self.board.is_enemy_piece(new_pos, self.color) or self.board.is_inside_board(new_pos) == False:
break
return moves
def move(self,end_pos):
a = self.possible_moves()
for pos in a:
if pos.row == end_pos.row and pos.col == end_pos.col:
return True
return False
def __str__(self):
if self.color == "White":
return "Q"
return "q"
class Board:
def __init__(self):
self.board = [[None for _ in range(8)] for _ in range(8)] #initialize the board
self.butt for _ in range(8)] for _ in range(8)]
self.left_click = [[0 for _ in range(8)] for _ in range(8)]
self.right_click = [[0 for _ in range(8)] for _ in range(8)]
for i in range(8):
for j in range(8):
bt = Button(master, text = f'{i} {j}', height = 5, width = 10)
bt.bind("<Button-1>", partial(self.lft, i, j))
bt.bind("<Button-2>", partial(self.rgt, i, j))
self.buttons[i][j] = bt
bt.grid(row = i, column = j)
def lft(self, i, j):
# global current_player
for ii in range(8):
for jj in range(8):
self.left_click[ii][jj] = 0
# if self.board[i][j].color == current_player:
self.left_click[i][j] = 1
def rgt(self, i, j):
flag = False
for ii in range(8):
for jj in range(8):
if self.left_click[ii][jj] == 1:
flag = True
if flag == True:
for ii in range(8):
for jj in range(8):
self.right_click[ii][jj] = 0
self.right_click[i][j] = 1
def place_piece(self, piece, position):
self.board[position.row][position.col] = piece
self.buttons[position.row][position.col].config(text = f'{piece.piece_type}')
piece.position = position
def remove_piece(self, piece):
self.board[piece.position.row][piece.position.col] = None
self.buttons[piece.position.row][piece.position.col].config(text = '')
def move_piece(self, start_pos, end_pos):
piece = self.board[start_pos.row][start_pos.col]
if piece:
if piece.move(end_pos):
#TODO (remove piece, place the piece at the end_pos and set has_moved to True)
self.remove_piece(piece)
self.place_piece(piece, end_pos)
piece.has_moved = True
piece.position = end_pos
return True
else:
print("No piece at the starting position.")
return False
def is_square_empty(self, position):
return self.board[position.row][position.col] is None
def is_enemy_piece(self, position, color):
if not self.is_square_empty(position):
if self.board[position.row][position.col].color == color:
return False
return True
return False
def is_inside_board(self, position):
if position.row > 7 or position.col > 7 or position.row < 0 or position.col < 0:
return False
return True
def print_board(self):
print(" | a b c d e f g h")
print("------------------")
for i, row in enumerate(self.board):
row_str = str(i) + "| "
for piece in row:
if piece:
row_str += f"{piece} "
else:
row_str += ". "
print(row_str)
print("\n")
class ChessSet:
def __init__(self):
self.board = Board()
self.setup_board()
def setup_board(self):
# Place white pieces
self.board.place_piece(Rook("White",self.board), Position(0, 0))
self.board.place_piece(Knight("White",self.board), Position(0, 1))
self.board.place_piece(Bishop("White",self.board), Position(0, 2))
self.board.place_piece(Queen("White",self.board), Position(0, 3))
self.board.place_piece(King("White",self.board), Position(0, 4))
self.board.place_piece(Bishop("White",self.board), Position(0, 5))
self.board.place_piece(Knight("White",self.board), Position(0, 6))
self.board.place_piece(Rook("White",self.board), Position(0, 7))
for col in range(8):
self.board.place_piece(Pawn("White", self.board), Position(1, col))
# Place black pieces
self.board.place_piece(Rook("Black",self.board), Position(7, 0))
self.board.place_piece(Knight("Black",self.board), Position(7, 1))
self.board.place_piece(Bishop("Black",self.board), Position(7, 2))
self.board.place_piece(Queen("Black",self.board), Position(7, 3))
self.board.place_piece(King("Black",self.board), Position(7, 4))
self.board.place_piece(Bishop("Black",self.board), Position(7, 5))
self.board.place_piece(Knight("Black",self.board), Position(7, 6))
self.board.place_piece(Rook("Black",self.board), Position(7, 7))
for col in range(8):
self.board.place_piece(Pawn("Black", self.board), Position(6, col))
def print_board(self):
self.board.print_board()
class Chess:
def __init__(self):
self.chess_set = ChessSet()
def start_game(self):
# print("Welcome to Chess!\n")
current_player = "White"
bt = Button(master, text = f"{current_player}'s turn:")
bt.grid(row = 4, column = 8)
while True:
self.chess_set.print_board()
if self.is_checkmate(current_player):
# print(current_player + " lost")
messagebox.showinfo("finish", f'{current_player} lost')
break
# print(f"\n{current_player}'s turn:")
bt.config(text = f"{current_player}'s turn:")
while True:
# start_pos = input("Enter the position of the piece you want to move (e.g., 'a2'): ")
end_pos = None
while end_pos == None:
for i in range(8):
for j in range(8):
if self.chess_set.board.right_click[i][j] == 1:
end_pos = Position(i, j)
for i in range(8):
for j in range(8):
if self.chess_set.board.left_click[i][j] == 1:
start_pos = Position(i, j)
# start_pos = Position(1,0)
# end_pos = Position(2,0)
print("salam")
# for i in self.chess_set.board.board[start_pos.row][start_pos.col].possible_moves():
# print(i.col, i.row)
if self.chess_set.board.board[start_pos.row][start_pos.col]:
if not self.chess_set.board.board[start_pos.row][start_pos.col].move(end_pos):
messagebox.showerror("wrong move", "cant move")
continue
self.chess_set.board.move_piece(start_pos, end_pos)
if self.is_check(current_player):
self.chess_set.board.move_piece(end_pos, start_pos)
continue
current_player = "Black" if current_player == "White" else "White"
break
break
#TODO - check if the input is according to the expected format
#TODO - move the piece if it is possible, otherwise notify the user to select other moves
#TODO - print the board
#TODO - check if the king is in checkmate (much simpler than real-world chess)
#TODO - check the king is in check
#TODO - switch the turns
def is_valid_input(self, start_pos, end_pos):
#TODO - check each of the inputs have length of two elements and the first letter is an alphabet and the second one is a digit
if len(start_pos) != 2 or len(end_pos) != 2:
return False
c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
if not (start_pos[0] in c) or not (end_pos[0] in c):
return False
c = ['0', '1', '2', '3', '4', '5', '6', '7']
if not (start_pos[1] in c) or not (end_pos[1] in c):
return False
return True
def is_check(self, current_player):
#TODO - find current_player's king on the board, check if the king is in check
enemy = "Black" if current_player == "White" else "White"
for i in range(8):
for j in range(8):
piece = self.chess_set.board.board[i][j]
if piece:
if piece.color == enemy:
if piece.possible_moves():
for pos in piece.possible_moves():
if self.chess_set.board.board[pos.row][pos.col]:
if self.chess_set.board.board[pos.row][pos.col].piece_type == "king":
return True
return False
def is_checkmate(self, current_player):
# For simplicity, we consider losing the king as checkmate
enemy = "Black" if current_player == "White" else "White"
for i in range(8):
for j in range(8):
piece = self.chess_set.board.board[i][j]
if piece and piece.piece_type == "king" and piece.color == enemy:
return False
return True
def from_algebraic(self,algebraic_notation):
col = ord(algebraic_notation[0]) - ord('a')
row = int(algebraic_notation[1])
return Position(row,col)
if __name__ == "__main__":
master = tk.Tk()
master.geometry("850x680")
chess_game = Chess()
chess_game.start_game()
master.mainloop()
