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

pip install pygame

chess-game/
├── ChessGame.py          # فایل اصلی رابط کاربری
├── ChessEngine.py        # موتور بازی و منطق شطرنج
└── images/               # پوشه تصاویر مهره‌ها
    ├── wp.png           # سرباز سفید
    ├── wR.png           # رخ سفید
    ├── wN.png           # اسب سفید
    ├── wB.png           # فیل سفید
    ├── wQ.png           # وزیر سفید
    ├── wK.png           # شاه سفید
    ├── bp.png           # سرباز سیاه
    ├── bR.png           # رخ سیاه
    ├── bN.png           # اسب سیاه
    ├── bB.png           # فیل سیاه
    ├── bQ.png           # وزیر سیاه
    ├── bK.png           # شاه سیاه
    └── icon.ico         # آیکون برنامه

import pygame as p
import ChessEngine
import os

WIDTH = HEIGHT = 512
DIMENSIONS = 8
SQ_SIZE = HEIGHT // DIMENSIONS
MAX_FPS = 15
IMAGES = {}

try:
    icon_path = os.path.join("images", "icon.ico")
    icon = p.image.load(icon_path)
    p.display.set_icon(icon)
except FileNotFoundError:
    print("Warning: Icon file not found. Continuing without icon.")
except Exception as e:
    print(f"Warning: Could not load icon: {e}")

p.display.set_caption("Chess Game")

def loadImages():
    pieces = ['wp', 'wR', 'wN', 'wB', 'wQ', 'wK', 'bp', 'bR', 'bN', 'bB', 'bQ', 'bK']
    for piece in pieces:
        try:
            image_path = os.path.join("images", piece + ".png")
            IMAGES[piece] = p.transform.scale(p.image.load(image_path), (SQ_SIZE, SQ_SIZE))
        except FileNotFoundError:
            print(f"Warning: Image for {piece} not found at {image_path}")
        except Exception as e:
            print(f"Warning: Could not load image for {piece}: {e}")

def main():
    p.init()
    screen = p.display.set_mode((WIDTH, HEIGHT + 50))
    clock = p.time.Clock()
    screen.fill(p.Color("white"))
    gs = ChessEngine.GameState()
    validMoves = gs.getValidMoves()
    moveMade = False
    animate = False
    loadImages()
    running = True
    sqSelected = ()
    playerClicks = []
    gameOver = False

    if not IMAGES:
        print("Error: No game piece images were loaded. The game may not display correctly.")

    while running: 
        for e in p.event.get():
            if e.type == p.QUIT:
                running = False
            elif e.type == p.MOUSEBUTTONDOWN:
                if not gameOver:
                    location = p.mouse.get_pos()
                    col = location[0] // SQ_SIZE
                    row = (location[1] - 50) // SQ_SIZE  
                    if 0 <= row < 8 and 0 <= col < 8:
                        if sqSelected == (row, col):
                            sqSelected = ()
                            playerClicks = []
                        else:
                            sqSelected = (row, col)
                            playerClicks.append(sqSelected)
                        if len(playerClicks) == 1 and (gs.board[row][col] == "--"): 
                            sqSelected = ()
                            playerClicks = []
                        if len(playerClicks) == 2:
                            move = ChessEngine.Move(playerClicks[0], playerClicks[1], gs.board)
                            for i in range(len(validMoves)):
                                if move == validMoves[i]:
                                    gs.makeMove(move)
                                    moveMade = True
                                    animate = True
                                    sqSelected = ()
                                    playerClicks = []
                            if not moveMade:
                                playerClicks = [sqSelected]
            elif e.type == p.KEYDOWN:
                if e.key == p.K_z:
                    gs.undoMove()
                    moveMade = True
                    animate = False
                if e.key == p.K_r:
                    gs = ChessEngine.GameState()
                    validMoves = gs.getValidMoves()
                    sqSelected = ()
                    playerClicks = []
                    moveMade = False
                    animate = False
        if moveMade:
            if animate:
                animatedMoves(gs.moveLog[-1], screen, gs.board, clock)
            validMoves = gs.getValidMoves()
            moveMade = False
            animate = False

        score = calculateScore(gs.board)
        drawScoreAndTurn(screen, score, gs.whiteToMove, gs.checkMate, gs.staleMate)
        drawGameState(screen, gs, validMoves, sqSelected)

        if gs.checkMate:
            gameOver = True
            if gs.whiteToMove:
                drawText(screen, 'Black wins by checkmate')
            else:
                drawText(screen, 'White wins by checkmate')
        elif gs.staleMate:
            gameOver = True
            drawText(screen, 'Stalemate')
        clock.tick(MAX_FPS)
        p.display.flip()

def highlightSquares(screen, gs, validMoves, sqSelected):
    if sqSelected != ():
        r, c = sqSelected
        if gs.board[r][c][0] == ('w' if gs.whiteToMove else 'b'):
            s = p.Surface((SQ_SIZE, SQ_SIZE))
            s.set_alpha(100)
            s.fill(p.Color('blue'))
            screen.blit(s, (c*SQ_SIZE, r*SQ_SIZE + 50))
            s.fill(p.Color("yellow"))
            for moves in validMoves:
                if moves.startRow == r and moves.startCol == c:
                    screen.blit(s, (SQ_SIZE*moves.endCol, SQ_SIZE*moves.endRow + 50))

def drawGameState(screen, gs, validMoves, sqSelected):
    drawBoard(screen)
    highlightSquares(screen, gs, validMoves, sqSelected)
    drawPieces(screen, gs.board)

def drawBoard(screen):
    global colors
    colors = [p.Color("white"), p.Color("grey")]
    for r in range(DIMENSIONS):
        for c in range(DIMENSIONS):
            color = colors[(r+c) % 2]
            p.draw.rect(screen, color, p.Rect(c*SQ_SIZE, r*SQ_SIZE + 50, SQ_SIZE, SQ_SIZE))

def drawPieces(screen, board):
    for r in range(DIMENSIONS):
        for c in range(DIMENSIONS):
            piece = board[r][c]
            if piece != "--" and piece in IMAGES:
                screen.blit(IMAGES[piece], p.Rect(c*SQ_SIZE, r*SQ_SIZE + 50, SQ_SIZE, SQ_SIZE))

def animatedMoves(move, screen, board, clock):
    global colors
    dR = move.endRow - move.startRow
    dC = move.endCol - move.startCol
    framesPerSquare = 5
    frameCount = (abs(dR) + abs(dC)) * framesPerSquare
    for frame in range(frameCount + 1):
        r, c = (move.startRow + dR*frame/frameCount, move.startCol + dC*frame/frameCount)
        drawBoard(screen)
        drawPieces(screen, board)
        color = colors[(move.endRow + move.endCol) % 2]
        endSquare = p.Rect(move.endCol*SQ_SIZE, move.endRow*SQ_SIZE + 50, SQ_SIZE, SQ_SIZE)
        p.draw.rect(screen, color, endSquare)
        if move.pieceCaptured != "--" and move.pieceCaptured in IMAGES:
            screen.blit(IMAGES[move.pieceCaptured], endSquare)
        if move.pieceMoved in IMAGES:
            screen.blit(IMAGES[move.pieceMoved], p.Rect(c*SQ_SIZE, r*SQ_SIZE + 50, SQ_SIZE, SQ_SIZE))
        p.display.flip()
        clock.tick(60)

def drawText(screen, text):
    font = p.font.SysFont("Helvetica", 32, True, False)
    textObject = font.render(text, True, p.Color('Gray'))
    textLocation = p.Rect(0, 50, WIDTH, HEIGHT).move(WIDTH/2 - textObject.get_width()/2, HEIGHT/2 - textObject.get_height()/2)
    screen.blit(textObject, textLocation)
    textObject = font.render(text, True, p.Color("Black"))
    screen.blit(textObject, textLocation.move(2, 2))

def calculateScore(board):
    pieceValues = {
        'p': 1,   # pawn
        'N': 3,   # knight
        'B': 3,   # bishop
        'R': 5,   # rook
        'Q': 9,   # queen
        'K': 0    # king (not counted in material score)
    }
    whiteScore = 0
    blackScore = 0
    for row in board:
        for piece in row:
            if piece != "--":
                color = piece[0]
                pieceType = piece[1]
                value = pieceValues.get(pieceType, 0)
                if color == 'w':
                    whiteScore += value
                else:
                    blackScore += value
    return whiteScore, blackScore

def drawScoreAndTurn(screen, score, whiteToMove, checkMate, staleMate):
    whiteScore, blackScore = score
    scoreDifference = whiteScore - blackScore
    infoHeight = 50
    infoSurface = p.Surface((WIDTH, infoHeight))
    infoSurface.fill(p.Color("lightgray"))
    smallFont = p.font.SysFont("Helvetica", 16)
    boldFont = p.font.SysFont("Helvetica", 16, True)
    scoreText = f"White: {whiteScore}  |  Black: {blackScore}"
    scoreSurface = smallFont.render(scoreText, True, p.Color("black"))
    infoSurface.blit(scoreSurface, (10, 5))
    if scoreDifference > 0:
        advantageText = f"White +{scoreDifference}"
        advantageColor = p.Color("darkblue")
    elif scoreDifference < 0:
        advantageText = f"Black +{abs(scoreDifference)}"
        advantageColor = p.Color("darkred")
    else:
        advantageText = "Material equal"
        advantageColor = p.Color("darkgreen")
    advantageSurface = boldFont.render(advantageText, True, advantageColor)
    infoSurface.blit(advantageSurface, (10, 25))
    if not checkMate and not staleMate:
        turnText = "White's turn" if whiteToMove else "Black's turn"
        turnColor = p.Color("white")
        turnSurface = smallFont.render(turnText, True, turnColor)
        turnBgWidth = turnSurface.get_width() + 20
        turnBgHeight = turnSurface.get_height() + 10
        turnBg = p.Surface((turnBgWidth, turnBgHeight))
        turnBg.fill(p.Color("darkgreen" if whiteToMove else "darkred"))
        turnBgX = WIDTH - turnBgWidth - 10
        turnBgY = (infoHeight - turnBgHeight) // 2
        infoSurface.blit(turnBg, (turnBgX, turnBgY))
        infoSurface.blit(turnSurface, (turnBgX + 10, turnBgY + 5))
    screen.blit(infoSurface, (0, 0))

if __name__ == "__main__":
    main()

class GameState: 
        
        def __init__(self):
                self.board = [
                        ["bR", "bN", "bB", "bQ", "bK", "bB", "bN", "bR"],
                        ["bp", "bp", "bp", "bp", "bp", "bp", "bp", "bp"],
                        ["--", "--", "--", "--", "--", "--", "--", "--"],
                        ["--", "--", "--", "--", "--", "--", "--", "--"],
                        ["--", "--", "--", "--", "--", "--", "--", "--"],
                        ["--", "--", "--", "--", "--", "--", "--", "--"],
                        ["wp", "wp", "wp", "wp", "wp", "wp", "wp", "wp"],
                        ["wR", "wN", "wB", "wQ", "wK", "wB", "wN", "wR"]]
                self.moveFunctions = {'p': self.getPawnMoves, 'R': self.getRookMoves, 'N': self.getKnightMoves,
                                      'B': self.getBishopMoves, 'Q': self.getQueenMoves, 'K': self.getKingMoves}
                self.whiteToMove = True,
                self.moveLog = []
                self.whiteKingLocation = (7, 4)
                self.blackKingLocation = (0, 4)
                self.checkMate = False
                self.staleMate = False

        def makeMove(self, move):
                self.board[move.startRow][move.startCol] = "--"
                self.board[move.endRow][move.endCol] = move.pieceMoved
                self.moveLog.append(move)
                self.whiteToMove = not self.whiteToMove
                if move.pieceMoved == "wK":
                        self.whiteKingLocation = (move.endRow, move.endCol)
                elif move.pieceMoved == "bK":
                        self.blackKingLocation = (move.endRow, move.endCol)

                if move.isPawnPromotion:
                        self.board[move.endRow][move.endCol] = move.pieceMoved[0] + "Q"


        def undoMove(self):
                if len(self.moveLog) != 0:
                        move = self.moveLog.pop()
                        self.board[move.startRow][move.startCol] = move.pieceMoved
                        self.board[move.endRow][move.endCol] = move.pieceCaptured
                        self.whiteToMove = not self.whiteToMove
                        if move.pieceMoved == "wK":
                                self.whiteKingLocation = (move.startRow, move.startCol)
                        if move.pieceMoved == "bK":
                                self.blackKingLocation = (move.startRow, move.startCol)
        """
        All move considering checks
        """
        def getValidMoves(self):
                moves = self.getAllPossibleMoves()
                for i in range(len(moves)-1, -1, -1):
                        self.makeMove(moves[i])
                        self.whiteToMove = not self.whiteToMove
                        if self.inCheck():
                                moves.remove(moves[i])
                        self.whiteToMove = not self.whiteToMove
                        self.undoMove()
                if len(moves) == 0:
                        if self.inCheck():
                                self.checkMate = True
                        else:
                                self.staleMate = True
                else:
                        self.checkMate = False
                        self.staleMate = False

                return moves 

        def inCheck(self):
                if self.whiteToMove:
                        return self.squareUnderAttack(self.whiteKingLocation[0], self.whiteKingLocation[1])
                else:
                        return self.squareUnderAttack(self.blackKingLocation[0], self.blackKingLocation[1])

        def squareUnderAttack(self, r, c):
                self.whiteToMove = not self.whiteToMove
                oppMoves = self.getAllPossibleMoves()
                self.whiteToMove  = not self.whiteToMove
                for move in oppMoves:
                        if move.endRow == r and move.endCol == c:
                                return True
                return False




        """
        All move without considering checks
        """
        def getAllPossibleMoves(self):
                moves = []
                for r in range(len(self.board)):
                        for c in range(len(self.board[r])):
                                turn = self.board[r][c][0] # b or w based on turn
                                if(turn == 'w' and self.whiteToMove) or (turn == 'b' and not self.whiteToMove):
                                        piece = self.board[r][c][1]
                                        self.moveFunctions[piece](r,c, moves)
                return moves


        def getPawnMoves(self, r, c, moves):
                if self.whiteToMove:
                        if self.board[r-1][c] == "--":
                                moves.append(Move((r, c),(r-1, c), self.board))
                                if r == 6 and self.board[r-2][c] == "--":
                                        moves.append(Move((r, c),(r-2, c), self.board))
                        if c-1 >= 0:
                                if self.board[r-1][c-1][0] == 'b':
                                        moves.append(Move((r, c),(r-1, c-1), self.board))
                        if c+1 <= 7:
                                if self.board[r-1][c+1][0] == 'b':
                                        moves.append(Move((r, c),(r-1, c+1), self.board))
                
                else:
                        if self.board[r+1][c] == "--":
                                moves.append(Move((r, c),(r+1, c), self.board))
                                if r == 1 and self.board[r+2][c] == "--":
                                        moves.append(Move((r, c),(r+2, c), self.board))
                        if c-1 >= 0:
                                if self.board[r+1][c-1][0] == 'w':
                                        moves.append(Move((r, c),(r+1, c-1), self.board))
                        if c+1 <= 7:
                                if self.board[r+1][c+1][0] == 'w':
                                        moves.append(Move((r, c),(r+1, c+1), self.board))

        def getRookMoves(self, r, c, moves):
                directions = ((-1, 0), (0, -1), (1, 0), (0, 1))
                enemyColor = "b" if self.whiteToMove else "w"
                for d in directions:
                        for i in range(1, 8):
                                endRow = r + d[0] * i
                                endCol = c + d[1] * i
                                if 0 <= endRow < 8 and 0 <= endCol < 8:
                                        endPiece = self.board[endRow][endCol]
                                        if endPiece == "--":
                                                moves.append(Move((r,c), (endRow, endCol), self.board))
                                        elif endPiece[0] == enemyColor:
                                                moves.append(Move((r,c), (endRow, endCol), self.board))
                                                break
                                        else:
                                                break
                                else:
                                        break

        def getKnightMoves(self, r,c,moves):
                knightMoves = ((-2, -1), (-2, 1), (-1, -2), (-1, 2), (1, -2), (1, 2), (2, -1), (2,1))
                allyColor = "w" if self.whiteToMove else "b"
                for m in knightMoves:
                        endRow = r + m[0]
                        endCol = c + m[1]
                        if 0 <= endRow < 8 and 0 <= endCol < 8:
                                endPiece = self.board[endRow][endCol]
                                if endPiece[0] != allyColor:
                                        moves.append(Move((r,c), (endRow, endCol), self.board))

        def getBishopMoves(self, r,c,moves):
                directions = ((-1, -1), (-1, 1), (1, -1), (1, 1))
                enemyColor = "b" if self.whiteToMove else "w"
                for d in directions:
                        for i in range(1, 8):
                                endRow = r + d[0] * i
                                endCol = c + d[1] * i
                                if 0 <= endRow < 8 and 0 <= endCol < 8:
                                        endPiece = self.board[endRow][endCol]
                                        if endPiece == "--":
                                                moves.append(Move((r,c), (endRow, endCol), self.board))
                                        elif endPiece[0] == enemyColor:
                                                moves.append(Move((r,c), (endRow, endCol), self.board))
                                                break
                                        else:
                                                break
                                else:
                                        break

        def getQueenMoves(self, r,c,moves):
                self.getRookMoves(r, c, moves)
                self.getBishopMoves(r, c, moves)

        def getKingMoves(self, r,c,moves):
                kingMoves = ((-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1,1) )
                allyColor = "w" if self.whiteToMove else "b"
                for i in range(8):
                        endRow = r + kingMoves[i][0]
                        endCol = c + kingMoves[i][1]
                        if 0 <= endRow < 8 and 0 <= endCol < 8:
                                endPiece = self.board[endRow][endCol]
                                if endPiece[0] != allyColor:
                                        moves.append(Move((r,c), (endRow, endCol), self.board))
class Move():

        ranksToRow = {"1": 7, "2": 6, "3": 5, "4": 4,
                      "5": 3, "6": 2, "7": 1, "8": 0}
        rowsToRanks = {v: k for k, v in ranksToRow.items()}
        filesToCols = {"a": 0, "b": 1, "c": 2, "d": 3,
                      "e": 4, "f": 5, "g": 6, "h": 7}
        colsToFiles = {v: k for k, v in filesToCols.items()}

        def __init__(self, startSq, endSq, board):
                self.startRow = startSq[0]
                self.startCol = startSq[1]
                self.endRow = endSq[0] 
                self.endCol = endSq[1]
                self.pieceMoved = board[self.startRow][self.startCol]
                self.pieceCaptured = board[self.endRow][self.endCol]
                self.isPawnPromotion = False
                if (self.pieceMoved == 'wp' and self.endRow == 0) or (self.pieceMoved == 'bp' and self.endRow == 7):
                        self.isPawnPromotion = True
                self.moveID = self.startRow * 1000 + self.startCol * 100 + self.endRow * 10 + self.endCol

        def __eq__(self, other):
                if isinstance(other, Move):
                        return self.moveID  == other.moveID
                return False


        def getChessNotation(self):
                return self.getRankFile(self.startRow, self.startCol) + self.getRankFile(self.endRow, self.endCol)

        def getRankFile(self, r, c):
                return  self.colsToFiles[c] + self.rowsToRanks[r]

python ChessGame.py