ساخت بازی شطرنج با پایتون

# ایجاد صفحه شطرنج به صورت یک ماتریس 8x8
chess_board = [[None for _ in range(8)] for _ in range(8)]
# ایجاد صفحه شطرنج به صورت یک ماتریس 8x8
chess_board = [[None for _ in range(8)] for _ in range(8)]اجرای کد

def initialize_board():
    board = [[None for _ in range(8)] for _ in range(8)]
    for row in range(8):
        for col in range(8):
            if (row + col) % 2 == 0:
                board[row][col] = 'white'
            else:
                board[row][col] = 'black'
    return board
def initialize_board():
    board = [[None for _ in range(8)] for _ in range(8)]
    for row in range(8):
        for col in range(8):
            if (row + col) % 2 == 0:
                board[row][col] = 'white'
            else:
                board[row][col] = 'black'
    return boardاجرای کد

import pygame

# تنظیمات اولیه Pygame
pygame.init()
screen = pygame.display.set_mode((800, 800))
pygame.display.set_caption("Chess Game")

# رنگ‌ها
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

def draw_board(screen, board):
    for row in range(8):
        for col in range(8):
            color = WHITE if board[row][col] == 'white' else BLACK
            pygame.draw.rect(screen, color, (col * 100, row * 100, 100, 100))

# حلقه اصلی بازی
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill((0, 0, 0))
    draw_board(screen, initialize_board())
    pygame.display.flip()

pygame.quit()
import pygame

# تنظیمات اولیه Pygame
pygame.init()
screen = pygame.display.set_mode((800, 800))
pygame.display.set_caption("Chess Game")

# رنگ‌ها
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

def draw_board(screen, board):
    for row in range(8):
        for col in range(8):
            color = WHITE if board[row][col] == 'white' else BLACK
            pygame.draw.rect(screen, color, (col * 100, row * 100, 100, 100))

# حلقه اصلی بازی
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill((0, 0, 0))
    draw_board(screen, initialize_board())
    pygame.display.flip()

pygame.quit()اجرای کد

class Piece:
    def __init__(self, color):
        self.color = color

    def is_valid_move(self, start, end, board):
        raise NotImplementedError("Subclasses should implement this method")

class Pawn(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت سرباز
        pass

class Rook(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت رخ
        pass

class Knight(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت اسب
        pass

class Bishop(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت فیل
        pass

class Queen(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت وزیر
        pass

class King(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت شاه
        pass
class Piece:
    def __init__(self, color):
        self.color = color

    def is_valid_move(self, start, end, board):
        raise NotImplementedError("Subclasses should implement this method")

class Pawn(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت سرباز
        pass

class Rook(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت رخ
        pass

class Knight(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت اسب
        pass

class Bishop(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت فیل
        pass

class Queen(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت وزیر
        pass

class King(Piece):
    def is_valid_move(self, start, end, board):
        # پیاده‌سازی قوانین حرکت شاه
        passاجرای کد

class Pawn(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end
        direction = -1 if self.color == 'white' else 1

        # حرکت به جلو
        if start_col == end_col:
            if start_row + direction == end_row:
                return board[end_row][end_col] is None
            if start_row + 2 * direction == end_row and start_row == (1 if self.color == 'white' else 6):
                return board[end_row][end_col] is None and board[start_row + direction][start_col] is None

        # گرفتن مهره حریف به صورت مورب
        if abs(start_col - end_col) == 1 and start_row + direction == end_row:
            return board[end_row][end_col] is not None and board[end_row][end_col].color != self.color

        return False
class Pawn(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end
        direction = -1 if self.color == 'white' else 1

        # حرکت به جلو
        if start_col == end_col:
            if start_row + direction == end_row:
                return board[end_row][end_col] is None
            if start_row + 2 * direction == end_row and start_row == (1 if self.color == 'white' else 6):
                return board[end_row][end_col] is None and board[start_row + direction][start_col] is None

        # گرفتن مهره حریف به صورت مورب
        if abs(start_col - end_col) == 1 and start_row + direction == end_row:
            return board[end_row][end_col] is not None and board[end_row][end_col].color != self.color

        return Falseاجرای کد

class Rook(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        if start_row != end_row and start_col != end_col:
            return False

        if start_row == end_row:
            step = 1 if end_col > start_col else -1
            for col in range(start_col + step, end_col, step):
                if board[start_row][col] is not None:
                    return False
        else:
            step = 1 if end_row > start_row else -1
            for row in range(start_row + step, end_row, step):
                if board[row][start_col] is not None:
                    return False

        return True
class Rook(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        if start_row != end_row and start_col != end_col:
            return False

        if start_row == end_row:
            step = 1 if end_col > start_col else -1
            for col in range(start_col + step, end_col, step):
                if board[start_row][col] is not None:
                    return False
        else:
            step = 1 if end_row > start_row else -1
            for row in range(start_row + step, end_row, step):
                if board[row][start_col] is not None:
                    return False

        return Trueاجرای کد

class Knight(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        row_diff = abs(start_row - end_row)
        col_diff = abs(start_col - end_col)

        return (row_diff == 2 and col_diff == 1) or (row_diff == 1 and col_diff == 2)
class Knight(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        row_diff = abs(start_row - end_row)
        col_diff = abs(start_col - end_col)

        return (row_diff == 2 and col_diff == 1) or (row_diff == 1 and col_diff == 2)اجرای کد

class Bishop(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        if abs(start_row - end_row) != abs(start_col - end_col):
            return False

        row_step = 1 if end_row > start_row else -1
        col_step = 1 if end_col > start_col else -1

        row, col = start_row + row_step, start_col + col_step
        while row != end_row and col != end_col:
            if board[row][col] is not None:
                return False
            row += row_step
            col += col_step

        return True
class Bishop(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        if abs(start_row - end_row) != abs(start_col - end_col):
            return False

        row_step = 1 if end_row > start_row else -1
        col_step = 1 if end_col > start_col else -1

        row, col = start_row + row_step, start_col + col_step
        while row != end_row and col != end_col:
            if board[row][col] is not None:
                return False
            row += row_step
            col += col_step

        return Trueاجرای کد

class Queen(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        if start_row == end_row or start_col == end_col:
            return Rook(self.color).is_valid_move(start, end, board)
        elif abs(start_row - end_row) == abs(start_col - end_col):
            return Bishop(self.color).is_valid_move(start, end, board)
        else:
            return False
class Queen(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        if start_row == end_row or start_col == end_col:
            return Rook(self.color).is_valid_move(start, end, board)
        elif abs(start_row - end_row) == abs(start_col - end_col):
            return Bishop(self.color).is_valid_move(start, end, board)
        else:
            return Falseاجرای کد

class King(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        row_diff = abs(start_row - end_row)
        col_diff = abs(start_col - end_col)

        return row_diff <= 1 and col_diff <= 1
class King(Piece):
    def is_valid_move(self, start, end, board):
        start_row, start_col = start
        end_row, end_col = end

        row_diff = abs(start_row - end_row)
        col_diff = abs(start_col - end_col)

        return row_diff <= 1 and col_diff <= 1اجرای کد

class ChessGame:
    def __init__(self):
        self.board = initialize_board()
        self.current_player = 'white'  # بازیکن سفید شروع می‌کند

    def switch_player(self):
        self.current_player = 'black' if self.current_player == 'white' else 'white'
class ChessGame:
    def __init__(self):
        self.board = initialize_board()
        self.current_player = 'white'  # بازیکن سفید شروع می‌کند

    def switch_player(self):
        self.current_player = 'black' if self.current_player == 'white' else 'white'اجرای کد

def is_in_check(self, player):
    king_position = None
    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if isinstance(piece, King) and piece.color == player:
                king_position = (row, col)
                break
        if king_position:
            break

    if not king_position:
        return False

    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if piece and piece.color != player:
                if piece.is_valid_move((row, col), king_position, self.board):
                    return True

    return False
def is_in_check(self, player):
    king_position = None
    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if isinstance(piece, King) and piece.color == player:
                king_position = (row, col)
                break
        if king_position:
            break

    if not king_position:
        return False

    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if piece and piece.color != player:
                if piece.is_valid_move((row, col), king_position, self.board):
                    return True

    return Falseاجرای کد

def is_checkmate(self, player):
    if not self.is_in_check(player):
        return False

    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if piece and piece.color == player:
                for move in self.get_all_possible_moves((row, col)):
                    if not self.would_be_in_check((row, col), move, player):
                        return False

    return True
def is_checkmate(self, player):
    if not self.is_in_check(player):
        return False

    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if piece and piece.color == player:
                for move in self.get_all_possible_moves((row, col)):
                    if not self.would_be_in_check((row, col), move, player):
                        return False

    return Trueاجرای کد

def is_stalemate(self, player):
    if self.is_in_check(player):
        return False

    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if piece and piece.color == player:
                for move in self.get_all_possible_moves((row, col)):
                    if not self.would_be_in_check((row, col), move, player):
                        return False

    return True
def is_stalemate(self, player):
    if self.is_in_check(player):
        return False

    for row in range(8):
        for col in range(8):
            piece = self.board[row][col]
            if piece and piece.color == player:
                for move in self.get_all_possible_moves((row, col)):
                    if not self.would_be_in_check((row, col), move, player):
                        return False

    return Trueاجرای کد

def get_all_possible_moves(self, position):
    row, col = position
    piece = self.board[row][col]
    if not piece:
        return []

    possible_moves = []
    for r in range(8):
        for c in range(8):
            if piece.is_valid_move((row, col), (r, c), self.board):
                possible_moves.append((r, c))

    return possible_moves

def would_be_in_check(self, start, end, player):
    # حرکت را انجام می‌دهیم و بررسی می‌کنیم آیا بازیکن در کیش قرار می‌گیرد
    original_piece = self.board[end[0]][end[1]]
    self.board[end[0]][end[1]] = self.board[start[0]][start[1]]
    self.board[start[0]][start[1]] = None

    in_check = self.is_in_check(player)

    # حرکت را به حالت اولیه برمی‌گردانیم
    self.board[start[0]][start[1]] = self.board[end[0]][end[1]]
    self.board[end[0]][end[1]] = original_piece

    return in_check
def get_all_possible_moves(self, position):
    row, col = position
    piece = self.board[row][col]
    if not piece:
        return []

    possible_moves = []
    for r in range(8):
        for c in range(8):
            if piece.is_valid_move((row, col), (r, c), self.board):
                possible_moves.append((r, c))

    return possible_moves

def would_be_in_check(self, start, end, player):
    # حرکت را انجام می‌دهیم و بررسی می‌کنیم آیا بازیکن در کیش قرار می‌گیرد
    original_piece = self.board[end[0]][end[1]]
    self.board[end[0]][end[1]] = self.board[start[0]][start[1]]
    self.board[start[0]][start[1]] = None

    in_check = self.is_in_check(player)

    # حرکت را به حالت اولیه برمی‌گردانیم
    self.board[start[0]][start[1]] = self.board[end[0]][end[1]]
    self.board[end[0]][end[1]] = original_piece

    return in_checkاجرای کد

import time

class ChessGame:
    def __init__(self):
        self.board = initialize_board()
        self.current_player = 'white'
        self.white_time = 600  # 10 دقیقه به ثانیه
        self.black_time = 600  # 10 دقیقه به ثانیه
        self.last_move_time = time.time()

    def switch_player(self):
        now = time.time()
        elapsed_time = now - self.last_move_time

        if self.current_player == 'white':
            self.white_time -= elapsed_time
        else:
            self.black_time -= elapsed_time

        self.last_move_time = now
        self.current_player = 'black' if self.current_player == 'white' else 'white'

    def check_time(self):
        if self.white_time <= 0:
            return 'black'  # بازیکن سفید زمان خود را تمام کرده است
        if self.black_time <= 0:
            return 'white'  # بازیکن سیاه زمان خود را تمام کرده است
        return None
import time

class ChessGame:
    def __init__(self):
        self.board = initialize_board()
        self.current_player = 'white'
        self.white_time = 600  # 10 دقیقه به ثانیه
        self.black_time = 600  # 10 دقیقه به ثانیه
        self.last_move_time = time.time()

    def switch_player(self):
        now = time.time()
        elapsed_time = now - self.last_move_time

        if self.current_player == 'white':
            self.white_time -= elapsed_time
        else:
            self.black_time -= elapsed_time

        self.last_move_time = now
        self.current_player = 'black' if self.current_player == 'white' else 'white'

    def check_time(self):
        if self.white_time <= 0:
            return 'black'  # بازیکن سفید زمان خود را تمام کرده است
        if self.black_time <= 0:
            return 'white'  # بازیکن سیاه زمان خود را تمام کرده است
        return Noneاجرای کد

import pickle

def save_game(game, filename='chess_game.pkl'):
    with open(filename, 'wb') as f:
        pickle.dump(game, f)
import pickle

def save_game(game, filename='chess_game.pkl'):
    with open(filename, 'wb') as f:
        pickle.dump(game, f)اجرای کد

def load_game(filename='chess_game.pkl'):
    with open(filename, 'rb') as f:
        return pickle.load(f)
def load_game(filename='chess_game.pkl'):
    with open(filename, 'rb') as f:
        return pickle.load(f)اجرای کد

import pygame.mixer

pygame.mixer.init()
move_sound = pygame.mixer.Sound('move.wav')
check_sound = pygame.mixer.Sound('check.wav')

def play_move_sound():
    move_sound.play()

def play_check_sound():
    check_sound.play()
import pygame.mixer

pygame.mixer.init()
move_sound = pygame.mixer.Sound('move.wav')
check_sound = pygame.mixer.Sound('check.wav')

def play_move_sound():
    move_sound.play()

def play_check_sound():
    check_sound.play()اجرای کد

def display_message(screen, message):
    font = pygame.font.Font(None, 74)
    text = font.render(message, True, (255, 0, 0))
    screen.blit(text, (200, 300))
    pygame.display.flip()
    time.sleep(2)  # نمایش پیام به مدت ۲ ثانیه
def display_message(screen, message):
    font = pygame.font.Font(None, 74)
    text = font.render(message, True, (255, 0, 0))
    screen.blit(text, (200, 300))
    pygame.display.flip()
    time.sleep(2)  # نمایش پیام به مدت ۲ ثانیهاجرای کد