使用pygame实现基于A*算法的五子棋

好的，下面是使用pygame实现基于A*算法的五子棋的步骤：

1. 确定游戏界面大小和棋盘大小，并初始化pygame窗口。

2. 创建一个棋盘类来表示游戏棋盘，包括棋盘大小、落子情况等属性和方法。

3. 创建一个AI类来实现A*算法，寻找最优解决方案。

4. 定义游戏主循环，包括玩家落子、AI落子、判断胜负等操作。

5. 实现鼠标点击事件和键盘事件，让玩家可以进行操作。

6. 在窗口中绘制游戏棋盘和棋子。

7. 在游戏结束时，显示胜利方并提供重新开始游戏的选项。

下面是示例代码：

import pygame
from queue import PriorityQueue

# 定义棋盘大小和格子大小
BOARD_SIZE = 15
GRID_SIZE = 40

# 定义棋子类型
EMPTY = 0
BLACK = 1
WHITE = 2

# 定义颜色
BLACK_COLOR = (0, 0, 0)
WHITE_COLOR = (255, 255, 255)
GREY_COLOR = (150, 150, 150)

class Board:
    def __init__(self):
        self.board = [[EMPTY] * BOARD_SIZE for _ in range(BOARD_SIZE)]
        self.turn = BLACK
    
    def get_legal_moves(self):
        legal_moves = []
        for i in range(BOARD_SIZE):
            for j in range(BOARD_SIZE):
                if self.board[i][j] == EMPTY:
                    legal_moves.append((i, j))
        return legal_moves
    
    def get_winner(self):
        # 判断横向是否连5个
        for i in range(BOARD_SIZE):
            for j in range(BOARD_SIZE - 4):
                if self.board[i][j] == self.board[i][j+1] == self.board[i][j+2] == self.board[i][j+3] == self.board[i][j+4] and self.board[i][j] != EMPTY:
                    return self.board[i][j]
        
        # 判断纵向是否连5个
        for i in range(BOARD_SIZE - 4):
            for j in range(BOARD_SIZE):
                if self.board[i][j] == self.board[i+1][j] == self.board[i+2][j] == self.board[i+3][j] == self.board[i+4][j] and self.board[i][j] != EMPTY:
                    return self.board[i][j]
        
        # 判断左上到右下是否连5个
        for i in range(BOARD_SIZE - 4):
            for j in range(BOARD_SIZE - 4):
                if self.board[i][j] == self.board[i+1][j+1] == self.board[i+2][j+2] == self.board[i+3][j+3] == self.board[i+4][j+4] and self.board[i][j] != EMPTY:
                    return self.board[i][j]
        
        # 判断右上到左下是否连5个
        for i in range(BOARD_SIZE - 4):
            for j in range(4, BOARD_SIZE):
                if self.board[i][j] == self.board[i+1][j-1] == self.board[i+2][j-2] == self.board[i+3][j-3] == self.board[i+4][j-4] and self.board[i][j] != EMPTY:
                    return self.board[i][j]
        
        # 判断是否平局
        for i in range(BOARD_SIZE):
            for j in range(BOARD_SIZE):
                if self.board[i][j] == EMPTY:
                    return None
        return EMPTY

class AI:
    def __init__(self, board):
        self.board = board
    
    def heuristic(self, move):
        # 计算当前落子位置的得分
        score = 0
        x, y = move
        dx, dy = [-1, -1, 0, 1, 1, 1, 0, -1], [0, 1, 1, 1, 0, -1, -1, -1]
        for d in range(8):
            cnt, block = 0, 0
            for step in range(1, 5):
                nx, ny = x + step * dx[d], y + step * dy[d]
                if nx < 0 or nx >= BOARD_SIZE or ny < 0 or ny >= BOARD_SIZE or self.board.board[nx][ny] == self.board.turn:
                    cnt += 1
                    if block:
                        block = 0
                        break
                elif self.board.board[nx][ny] == EMPTY:
                    if block:
                        break
                    block = 1
                else:
                    break
            if cnt == 4:
                score += 100
            elif cnt == 3:
                score += 5
            elif cnt == 2:
                score += 2
            elif cnt == 1:
                score += 1
        return score
    
    def a_star_search(self):
        # 使用A*算法搜索最优解决方案
        pq = PriorityQueue()
        visited = set()
        pq.put((0, self.board.get_legal_moves()[0]))
        visited.add(self.board.get_legal_moves()[0])
        while not pq.empty():
            _, move = pq.get()
            x, y = move
            if self.board.turn == BLACK:
                self.board.board[x][y] = BLACK
            else:
                self.board.board[x][y] = WHITE
            winner = self.board.get_winner()
            if winner == BLACK:
                self.board.board[x][y] = EMPTY
                return move
            elif winner == WHITE:
                self.board.board[x][y] = EMPTY
                return move
            legal_moves = self.board.get_legal_moves()
            for new_move in legal_moves:
                if new_move not in visited:
                    visited.add(new_move)
                    priority = self.heuristic(new_move)
                    pq.put((priority, new_move))
            self.board.board[x][y] = EMPTY

    def get_move(self):
        # 获取AI的落子位置
        return self.a_star_search()

def draw_board(screen, board):
    # 绘制棋盘和棋子
    screen.fill(GREY_COLOR)
    for i in range(BOARD_SIZE):
        pygame.draw.line(screen, BLACK_COLOR, (GRID_SIZE//2, GRID_SIZE//2+i*GRID_SIZE), (GRID_SIZE//2+(BOARD_SIZE-1)*GRID_SIZE, GRID_SIZE//2+i*GRID_SIZE), 1)
        pygame.draw.line(screen, BLACK_COLOR, (GRID_SIZE//2+i*GRID_SIZE, GRID_SIZE//2), (GRID_SIZE//2+i*GRID_SIZE, GRID_SIZE//2+(BOARD_SIZE-1)*GRID_SIZE), 1)
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            if board.board[i][j] == BLACK:
                pygame.draw.circle(screen, BLACK_COLOR, (GRID_SIZE//2+j*GRID_SIZE, GRID_SIZE//2+i*GRID_SIZE), GRID_SIZE//2-2, 0)
            elif board.board[i][j] == WHITE:
                pygame.draw.circle(screen, WHITE_COLOR, (GRID_SIZE//2+j*GRID_SIZE, GRID_SIZE//2+i*GRID_SIZE), GRID_SIZE//2-2, 0)

def main():
    pygame.init()
    screen = pygame.display.set_mode((GRID_SIZE*BOARD_SIZE, GRID_SIZE*BOARD_SIZE))
    pygame.display.set_caption("五子棋")
    board = Board()
    ai = AI(board)
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                return
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if board.turn == BLACK:
                    x, y = event.pos
                    row, col = y // GRID_SIZE, x // GRID_SIZE
                    if board.board[row][col] == EMPTY:
                        board.board[row][col] = BLACK
                        board.turn = WHITE
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_r:
                    board.__init__()
                    ai.__init__(board)
        if board.turn == WHITE:
            move = ai.get_move()
            board.board[move[0]][move[1]] = WHITE
            board.turn = BLACK
        draw_board(screen, board)
        winner = board.get_winner()
        if winner is not None:
            font = pygame.font.Font(None, 30)
            text = font.render("黑方获胜" if winner == BLACK else "白方获胜" if winner == WHITE else "平局", True, BLACK_COLOR)
            screen.blit(text, (GRID_SIZE*BOARD_SIZE//2-60, GRID_SIZE*BOARD_SIZE//2-15))
            font = pygame.font.Font(None, 20)
            text = font.render("按R重新开始", True, BLACK_COLOR)
            screen.blit(text, (GRID_SIZE*BOARD_SIZE//2-50, GRID_SIZE*BOARD_SIZE//2+15))
        pygame.display.update()

if __name__ == '__main__':
    main()

这样就实现了基于A*算法的五子棋游戏，玩家可以和AI进行对战。