python实现人机对战的五子棋游戏

安装必要的库

为了实现这个五子棋游戏，我们需要用到一些Python库，如numpy、Tkinter。因此，需要确保这些库已经安装好了。可以通过以下命令在命令行中安装：

pip install numpy

python -m tkinter

创建游戏界面

我们使用Tkinter库来实现游戏的GUI界面。在前面的代码中，我们首先导入了Tkinter库，然后创建了一个顶层窗口，并设置了标题。接下来，我们创建了一个Canvas，作为棋盘的背景。

import tkinter as tk

class GameState:
    def __init__(self):
        self.width = 15 # 棋盘宽度
        self.height = 15 # 棋盘高度
        self.board = [0] * self.width * self.height # 棋盘数组，记录棋子位置和状态
        self.current_player = 1 # 当前玩家
        self.win = False # 是否有玩家胜出
        self.steps = [] # 存储所有走过的步数（当前棋子在数组中的位置）

class GameView:

    def __init__(self, master, gamestate, cell_size=30, line_width=2, padding_x=50, padding_y=50):
        self.master = master
        self.gamestate = gamestate
        self.cell_size = cell_size
        self.line_width = line_width
        self.padding_x = padding_x
        self.padding_y = padding_y

        self.canvas_width = cell_size * gamestate.width
        self.canvas_height = cell_size * gamestate.height

        # 创建棋盘的背景画布
        self.canvas = tk.Canvas(self.master, width=self.canvas_width + 2*self.padding_x,
                                height=self.canvas_height + 2*self.padding_y, bg="#FCE5B5")
        self.canvas.pack()

        self.draw_board()

    # 画棋盘
    def draw_board(self):
        w = self.gamestate.width
        h = self.gamestate.height

        for i in range(w):
            x0, y0 = self.cell_to_pixels(i, 0)
            x1, y1 = self.cell_to_pixels(i, h-1)
            self.canvas.create_line(x0, y0, x1, y1, width=self.line_width)

        for j in range(h):
            x0, y0 = self.cell_to_pixels(0, j)
            x1, y1 = self.cell_to_pixels(w-1, j)
            self.canvas.create_line(x0, y0, x1, y1, width=self.line_width)

    # 将单元格的坐标（i，j）转换为像素坐标
    def cell_to_pixels(self, i, j):
        x = i * self.cell_size + self.padding_x
        y = j * self.cell_size + self.padding_y
        return x, y

    # 打印棋子
    def draw_piece(self, i, j, color):
        x, y = self.cell_to_pixels(i, j)
        r = self.cell_size/2
        self.canvas.create_oval(x-r, y-r, x+r, y+r, fill=color)

实现游戏逻辑

有了这个游戏界面之后，我们可以开始构建游戏逻辑了。在这个游戏中，我们需要处理以下几个方面：

• 玩家点击界面上的单元格时，如何判断他/他是否胜利，并有哪些棋子应该被画上去？
• 计算机博弈时应按照哪些策略来走棋？

对于第一个问题，我们可以创建一个GameState类来存储游戏的状态，它包括当前棋盘的状态，当前玩家和走过的步数。在每轮游戏过程中，玩家点击一个棋盘上的单元格，该单元格会相应地被标记为当前玩家的棋子并添加到步数列表中。然后我们就可以检查当前玩家是否取得了胜利，如果是，游戏就结束。如果没有，就将当前玩家切换为下一个玩家。

对于第二个问题，我们可以实现一个简单的“随机走棋”策略。具体实现方法可以是，对于每一个空位置，我们随机选择一些数字，然后将当前棋子放在这些位置中的一个位置上。

示例代码1：下棋并判断玩家胜利

class GameView:

    ...

    # 处理玩家点击单元格事件
    def on_click(self, event):
        if self.gamestate.win:
            return

        # 将像素坐标转换为单元格坐标
        x, y = event.x - self.padding_x, event.y - self.padding_y
        if x < 0 or y < 0:
            return
        i, j = int(x / self.cell_size), int(y / self.cell_size)

        index = self.gamestate.width * j + i
        if self.gamestate.board[index] != 0:
            return

        self.gamestate.board[index] = self.gamestate.current_player
        self.gamestate.steps.append(index)
        self.draw_piece(i, j, self.get_color())

        if self.check_win(i, j):
            self.gamestate.win = True
            print("Player {} wins!".format(self.gamestate.current_player))
            return

        self.gamestate.current_player = 2 if self.gamestate.current_player == 1 else 1

    # 判断当前玩家是否胜利
    def check_win(self, i, j):
        player = self.gamestate.current_player
        board = self.gamestate.board
        w = self.gamestate.width

        row_count = sum([1 for x in range(w) if board[w * j + x] == player])
        if row_count == w:
            return True

        col_count = sum([1 for y in range(w) if board[w * y + i] == player])
        if col_count == w:
            return True

        diag_count = sum([1 for x in range(w) 
                          if (x + j - i >= 0 and x + j - i < w and 
                              board[w * (x+j-i) + x] == player)])
        if diag_count == w:
            return True

        rev_diag_count = sum([1 for x in range(w) 
                              if (j - x + i >= 0 and j - x + i < w and 
                                  board[w * (j-x+i) + x] == player)])
        if rev_diag_count == w:
            return True

        return False

示例代码2：实现计算机简单“随机走棋”策略

class SimpleAIPlayer:
    def __init__(self):
        self.name = "SimpleAIPlayer"

    def move(self, gamestate):
        empty_cells = [i for i, x in enumerate(gamestate.board) if x == 0]
        if empty_cells:
            index = np.random.choice(empty_cells)
            gamestate.board[index] = 2
            gamestate.steps.append(index)
            return True
        else:
            return False

开发主程序，运行游戏

我们还需要一个主程序来运行这个游戏。在这个程序中，我们创建一个GameState类的实例和GameView类的实例，并调用Tkinter库的mainloop()函数来保持游戏处于运行状态。如果是人类玩家，程序会在用户点击棋盘时调用GameView的"in_click"函数，而如果是AI玩家，程序会调用SimpleAIPlayer对象的move()函数。

示例代码3：实现主程序

if __name__ == "__main__":
    gamestate = GameState()
    root = tk.Tk()
    root.title("Five in a Row")
    game = GameView(root, gamestate)
    ai_player = SimpleAIPlayer()

    def on_game_close():
        root.destroy()

    # 将玩家点击单元格的事件绑定到事件处理函数上
    game.canvas.bind("<Button-1>", game.on_click)

    game_running = True
    while game_running:
        if gamestate.current_player == 2:
            ai_player.move(gamestate)
            game.draw_board()
            if gamestate.win:
                print("AI wins!")
                game_running = False
        root.update()

    root.protocol("WM_DELETE_WINDOW", on_game_close)
    root.mainloop()