idle python五子棋人机智能源码

以下是一个简单的五子棋人机对战的 Python 代码示例，使用 Pygame 进行图形化界面的展示。这个示例只涉及到基本的人机对战逻辑，没有实现更加复杂的算法和优化，仅供参考。

import pygame
import random

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

# 定义颜色
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

# 初始化 Pygame
pygame.init()
pygame.font.init()

# 设置窗口大小和标题
size = (BOARD_SIZE * GRID_SIZE, BOARD_SIZE * GRID_SIZE)
screen = pygame.display.set_mode(size)
pygame.display.set_caption("五子棋")

# 加载字体
font = pygame.font.SysFont('Arial', 20)

# 绘制棋盘
def draw_board():
    for i in range(BOARD_SIZE):
        pygame.draw.line(screen, BLACK, [GRID_SIZE // 2, GRID_SIZE // 2 + i * GRID_SIZE], [GRID_SIZE // 2 + (BOARD_SIZE - 1) * GRID_SIZE, GRID_SIZE // 2 + i * GRID_SIZE], 2)
        pygame.draw.line(screen, BLACK, [GRID_SIZE // 2 + i * GRID_SIZE, GRID_SIZE // 2], [GRID_SIZE // 2 + i * GRID_SIZE, GRID_SIZE // 2 + (BOARD_SIZE - 1) * GRID_SIZE], 2)
    pygame.display.flip()

# 绘制棋子
def draw_piece(x, y, color):
    pygame.draw.circle(screen, color, [GRID_SIZE // 2 + x * GRID_SIZE, GRID_SIZE // 2 + y * GRID_SIZE], GRID_SIZE // 2 - 2)
    pygame.display.flip()

# 判断是否有五子连珠
def is_win(x, y, color, board):
    directions = ((0, 1), (1, 0), (1, 1), (1, -1))
    for dx, dy in directions:
        count = 0
        for i in range(5):
            tx, ty = x + i * dx, y + i * dy
            if tx < 0 or tx >= BOARD_SIZE or ty < 0 or ty >= BOARD_SIZE:
                break
            if board[tx][ty] != color:
                break
            count += 1
        if count >= 5:
            return True
    return False

# 判断是否平局
def is_draw(board):
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            if board[i][j] == 0:
                return False
    return True

# 人机对战
def play():
    board = [[0 for j in range(BOARD_SIZE)] for i in range(BOARD_SIZE)]
    turn = random.randint(1, 2)
    message = "黑方先行"
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if turn == 1:
                    x, y = event.pos[0] // GRID_SIZE, event.pos[1] // GRID_SIZE
                    if x >= 0 and x < BOARD_SIZE and y >= 0 and y < BOARD_SIZE and board[x][y] == 0:
                        draw_piece(x, y, BLACK)
                        board[x][y] = 1
                        if is_win(x, y, 1, board):
                            message = "黑方获胜"
                            pygame.display.set_caption(message)
                            return
                        elif is_draw(board):
                            message = "平局"
                            pygame.display.set_caption(message)
                            return
                        turn = 2
                        message = "白方回合"
                else:
                    x, y = random.randint(0, BOARD_SIZE - 1), random.randint(0, BOARD_SIZE - 1)
                    while board[x][y] != 0:
                        x, y = random.randint(0, BOARD_SIZE - 1), random.randint(0, BOARD_SIZE - 1)
                    draw_piece(x, y, WHITE)
                    board[x][y] = 2
                    if is_win(x, y, 2, board):
                        message = "白方获胜"
                        pygame.display.set_caption(message)
                        return
                    elif is_draw(board):
                        message = "平局"
                        pygame.display.set_caption(message)
                        return
                    turn = 1
                    message = "黑方回合"

        screen.fill(WHITE)
        draw_board()
        for i in range(BOARD_SIZE):
            for j in range(BOARD_SIZE):
                if board[i][j] == 1:
                    draw_piece(i, j, BLACK)
                elif board[i][j] == 2:
                    draw_piece(i, j, WHITE)
        text_surface = font.render(message, True, BLACK)
        screen.blit(text_surface, (10, size[1] - 30))
        pygame.display.flip()

# 开始游戏
play()
pygame.quit()

这个示例使用随机算法作为电脑的下棋逻辑，因此电脑的水平相对较低。如果需要实现更加优秀的 AI 算法，可以参考一些经典的算法，如 AlphaGo 和 AlphaZero 等。