Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

-- coding: utf-8 -- """ Created on Thu Oct 17 10:35:29 2024 @author: Administrator """…

  1. User

    -- coding: utf-8 --

    """ Created on Thu Oct 17 10:35:29 2024

    @author: Administrator """

    import tkinter as tk from tkinter import messagebox import math import random import time

    游戏常量定义

    BOARD_SIZE = 8 Computer = 'B' # 黑棋 Human = 'W' # 白棋 Max_time = 60

    class Othello: def init(self): self.window = tk.Tk() self.window.title("Othello") self.cell_size = 60 self.board = self.init_board() # 初始化棋盘 self.current_player = Human # 白棋先行

        # 创建画布
        self.canvas = tk.Canvas(self.window, width=BOARD_SIZE * self.cell_size, height=BOARD_SIZE * self.cell_size)
        self.canvas.pack()
        self.canvas.bind("<Button-1>", self.click_handler)
        
        self.draw_board()  # 绘制棋盘
        self.window.mainloop()
    
    def init_board(self):
        board = [[None for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
        mid = BOARD_SIZE // 2
        board[mid - 1][mid - 1] = Human
        board[mid][mid] = Computer
        board[mid - 1][mid] = Computer
        board[mid][mid - 1] = Human
        return board
    
    def draw_board(self):
        self.canvas.delete("all")
        for row in range(BOARD_SIZE):
            for col in range(BOARD_SIZE):
                x1 = col * self.cell_size
                y1 = row * self.cell_size
                x2 = x1 + self.cell_size
                y2 = y1 + self.cell_size
                self.canvas.create_rectangle(x1, y1, x2, y2, outline="black")
                if self.board[row][col] == Human:
                    self.canvas.create_oval(x1, y1, x2, y2, fill="white")  # 绘制白棋
                elif self.board[row][col] == Computer:
                    self.canvas.create_oval(x1, y1, x2, y2, fill="black")  # 绘制黑棋
    
    def click_handler(self, event):
        col = event.x // self.cell_size
        row = event.y // self.cell_size
        if self.is_valid_move(row, col, self.current_player):
            self.make_move(row, col, self.current_player)
            if self.end_game_check():  # 检查游戏是否结束
                return
            self.current_player = Human if self.current_player == Computer else Computer  # 切换玩家
            if self.current_player == Computer:
                self.AI_move()  # 计算机执行自动落子
        else:
            messagebox.showinfo("非法落子", "该位置无法落子,请重新选择。")
    
    def is_valid_move(self, row, col, player):
        if self.board[row][col] is not None:  # 检查目标位置是否为空
            return False
        opponent = Human if player == Computer else Computer
        directions = [(-1, 0), (1, 0), (0, -1), (0, 1), 
                      (-1, -1), (-1, 1), (1, -1), (1, 1)]
        for dr, dc in directions:
            r, c = row + dr, col + dc
            has_opponent_between = False
            while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == opponent:
                has_opponent_between = True
                r += dr
                c += dc
            if has_opponent_between and 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == player:
                return True
        return False
    
    def make_move(self, row, col, player):
        self.board[row][col] = player
        opponent = Human if player == Computer else Computer
        directions = [(-1, 0), (1, 0), (0, -1), (0, 1), 
                      (-1, -1), (-1, 1), (1, -1), (1, 1)]
        for dr, dc in directions:
            r, c = row + dr, col + dc
            cells_to_flip = []
            while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == opponent:
                cells_to_flip.append((r, c))
                r += dr
                c += dc
            if cells_to_flip and 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == player:
                for r, c in cells_to_flip:
                    self.board[r][c] = player
    
        self.draw_board()  # 更新棋盘显示
    
    def end_game_check(self):
        if not any(self.is_valid_move(r, c, self.current_player) for r in range(BOARD_SIZE) for c in range(BOARD_SIZE)):
            if not any(self.is_valid_move(r, c, Human if self.current_player == Computer else Computer) for r in range(BOARD_SIZE) for c in range(BOARD_SIZE)):
                self.end_game()
                return True
        return False
    
    def end_game(self):
        black_count = sum(row.count(Computer) for row in self.board)
        white_count = sum(row.count(Human) for row in self.board)
        if black_count > white_count:
            winner = "黑棋获胜!"
        elif white_count > black_count:
            winner = "白棋获胜!"
        else:
            winner = "平局!"
        messagebox.showinfo("游戏结束", f"{winner}\n黑棋: {black_count}, 白棋: {white_count}")
        self.window.quit()
    
    def AI_move(self):
        stone_pos = self.monte_carlo_tree_search(Computer)
        if stone_pos:
            self.animate_move(stone_pos[0], stone_pos[1], Computer)
    
    def monte_carlo_tree_search(self, player):
        possible_moves = [(r, c) for r in range(BOARD_SIZE) for c in range(BOARD_SIZE) if self.is_valid_move(r, c, player)]
        if possible_moves:
            return random.choice(possible_moves)  # 随机选择一个合法位置
        return None
    
    def animate_move(self, row, col, player):
        target_x = col * self.cell_size + self.cell_size // 2
        target_y = row * self.cell_size + self.cell_size // 2
    
        # 创建一个初始的棋子在目标上方
        oval = self.canvas.create_oval(target_x, target_y - 100, target_x + 30, target_y - 70, fill="black" if player == Computer else "white")
    
        # 动画函数
        def move_to_target(step=0):  # 动画步伐
            if step < 10:  # 控制动画步数
                self.canvas.move(oval, 0, 10)  # 向下移动
                self.canvas.after(50, move_to_target, step + 1)  # 每50ms移动一次
            else:
                self.place_move(row, col, player)  # 放置棋子
    
        move_to_target()  # 开启动画
    

    if name == "main": Othello() 这个是什么游戏

  2. Assistant

    这个代码实现的是一个简化版的 Othello,也叫黑白棋(Reversi)的游戏。Othello 是一个经典的棋盘游戏,棋盘为标准的 8x8 格子,两名玩家使用两面不同颜色的棋子进行对抗,目标是让自己颜色的棋子在棋盘上占据多数。

    游戏规则:

    1. 棋子颜色:游戏由两个玩家进行,一个玩家执白棋 (W),另一个玩家执黑棋 (B)。
    2. 落子规则:玩家轮流将自己的棋子放在棋盘上的空格处,每次落子必须夹住至少一个对方的棋子才能翻转(既必须在两端形成一个夹击)。
    3. 翻转棋子:被夹在落子棋子和另一己方棋子之间的对方棋子将被翻转为己方棋子。
    4. 游戏结束:当双方棋子都无法进行合法的落子,游戏结束。棋盘上棋子数量多的一方获胜。

    程序功能:

    • 使用 Tkinter 库进行图形界面的绘制。玩家通过鼠标点击自己想落子的地方进行操作。
    • 初始化一个默认状态的棋盘,并画出初始棋局。
    • 实现了基本的落子检查(是否合法)和翻转棋子的逻辑。
    • 在程序中设定白棋(人类玩家)先行,黑棋(计算机)后行。
    • 使用简单的随机策略进行计算机的决策(即蒙特卡洛树搜索中随机选择合法位置)。
    • 通过 simple animation 展示棋子落下的过程。
    • 能够判断游戏结束以及展示最终的结果。

    此程序提供了一个简单的界面来体验 Othello 游戏,对于初学者来说是一个不错的选择去熟悉游戏AI和界面交互的基本逻辑。然而,它使用了简化的AI策略,不具备复杂的战术计算。

  3. User

    现在这个程序有bug,帮我检查

  4. Assistant

    当然,我会为你指出这个程序中可能存在的一些问题,并给出相关建议:

    1. Player Piece Colors:

      • 在初始化时,self.current_player = Human 表示 Human(白棋)先行。但在棋盘初始化的位置上,(3, 3) 和 (4, 4) 却分别是白棋和黑棋,不完全符合 Othello 的初始设置(通常以白棋 W 在 (3,3), (4,4) 和黑棋 B 在 (3,4), (4,3) 开始)。虽然你的代码符合开局设置,但确保在不同配置时符合开局规则。
    2. End Game Logic:

      • self.end_game_check() 判断游戏是否结束的逻辑可能存在问题。如果当前玩家无法落子,只检查当前玩家但没有检查对手也无法落子的情况下,也会立即触发游戏结束。两者都无合法移动时,才应判定比赛结束。
    3. AI Logic:

      • monte_carlo_tree_search 函数仅简单地从合法位置中随机选择一个作为 AI 的移动,虽然说是‘蒙特卡洛树搜索’,但实际上并没有进行真正的模拟与选择。可能需要补全算法才能更智能地主动策略。
    4. Animation:

      • 在 animate_move() 函数中,棋子在落下时的动画由 canvas.move() 方法按步数控制。此动画仅作视觉效果,与游戏机理无关。如果动画出现问题,比如看不到棋子移动,确保步数和时间控制变量能准确延时和逐步移动。
    5. MessageBox Display:

      • 游戏过程中会给出现非法位置的提醒, 但若用户一直点击非法位置, 多次出现MessageBox, 这会对游戏体验造成干扰。可能需要改善处理方式或者提示信息。

    请确保你使用了一个关于最新 Python 和 Tkinter 版本的运行环境,并在合适环境下测试代码。如果在实现更复杂的 AI 策略时出现困难,可以从简单的贪心算法开始改进 AI 的回合策略。

  5. User

    修改,给我全部新代码

  6. Assistant

    好的,我将为你提供一个修正并略微优化的 Othello 游戏代码,其中包括改善的游戏结束条件和更合适的 AI 决策逻辑。请注意,这个版本的 AI 仍然是相对简单的,只是稍微智能化了一些。

    import tkinter as tk
    from tkinter import messagebox
    import random
    
    # 游戏常量定义
    BOARD_SIZE = 8
    COMPUTER = 'B'  # 黑棋
    HUMAN = 'W'     # 白棋
    
    class Othello:
        def __init__(self):
            self.window = tk.Tk()
            self.window.title("Othello")
            self.cell_size = 60
            self.board = self.init_board()  # 初始化棋盘
            self.current_player = HUMAN  # 白棋先行
            
            # 创建画布
            self.canvas = tk.Canvas(self.window, width=BOARD_SIZE * self.cell_size, height=BOARD_SIZE * self.cell_size)
            self.canvas.pack()
            self.canvas.bind("<Button-1>", self.click_handler)
            
            self.draw_board()  # 绘制棋盘
            self.window.mainloop()
    
        def init_board(self):
            board = [[None for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
            mid = BOARD_SIZE // 2
            board[mid - 1][mid - 1] = HUMAN
            board[mid][mid] = HUMAN
            board[mid - 1][mid] = COMPUTER
            board[mid][mid - 1] = COMPUTER
            return board
    
        def draw_board(self):
            self.canvas.delete("all")
            for row in range(BOARD_SIZE):
                for col in range(BOARD_SIZE):
                    x1 = col * self.cell_size
                    y1 = row * self.cell_size
                    x2 = x1 + self.cell_size
                    y2 = y1 + self.cell_size
                    self.canvas.create_rectangle(x1, y1, x2, y2, outline="black")
                    if self.board[row][col] == HUMAN:
                        self.canvas.create_oval(x1 + 5, y1 + 5, x2 - 5, y2 - 5, fill="white")
                    elif self.board[row][col] == COMPUTER:
                        self.canvas.create_oval(x1 + 5, y1 + 5, x2 - 5, y2 - 5, fill="black")
    
        def click_handler(self, event):
            col = event.x // self.cell_size
            row = event.y // self.cell_size
            if self.is_valid_move(row, col, self.current_player):
                self.make_move(row, col, self.current_player)
                if self.end_game_check():  # 检查游戏是否结束
                    return
                self.current_player = HUMAN if self.current_player == COMPUTER else COMPUTER  # 切换玩家
                if self.current_player == COMPUTER:
                    self.AI_move()  # 计算机执行自动落子
            else:
                messagebox.showinfo("非法落子", "该位置无法落子,请重新选择。")
    
        def is_valid_move(self, row, col, player):
            if self.board[row][col] is not None:
                return False
            opponent = HUMAN if player == COMPUTER else COMPUTER
            directions = [(-1, 0), (1, 0), (0, -1), (0, 1), 
                          (-1, -1), (-1, 1), (1, -1), (1, 1)]
            for dr, dc in directions:
                r, c = row + dr, col + dc
                has_opponent_between = False
                while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == opponent:
                    has_opponent_between = True
                    r += dr
                    c += dc
                if has_opponent_between and 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == player:
                    return True
            return False
    
        def make_move(self, row, col, player):
            self.board[row][col] = player
            opponent = HUMAN if player == COMPUTER else COMPUTER
            directions = [(-1, 0), (1, 0), (0, -1), (0, 1), 
                          (-1, -1), (-1, 1), (1, -1), (1, 1)]
            for dr, dc in directions:
                r, c = row + dr, col + dc
                cells_to_flip = []
                while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == opponent:
                    cells_to_flip.append((r, c))
                    r += dr
                    c += dc
                if cells_to_flip and 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == player:
                    for r, c in cells_to_flip:
                        self.board[r][c] = player
    
            self.draw_board()  # 更新棋盘显示
    
        def end_game_check(self):
            current_valid_moves = any(self.is_valid_move(r, c, self.current_player) for r in range(BOARD_SIZE) for c in range(BOARD_SIZE))
            opponent_valid_moves = any(self.is_valid_move(r, c, HUMAN if self.current_player == COMPUTER else COMPUTER) for r in range(BOARD_SIZE) for c in range(BOARD_SIZE))
    
            if not current_valid_moves and not opponent_valid_moves:
                self.end_game()
                return True
            elif not current_valid_moves:
                self.current_player = HUMAN if self.current_player == COMPUTER else COMPUTER
                if self.current_player == COMPUTER:
                    self.AI_move()
            return False
    
        def end_game(self):
            black_count = sum(row.count(COMPUTER) for row in self.board)
            white_count = sum(row.count(HUMAN) for row in self.board)
            if black_count > white_count:
                winner = "黑棋获胜!"
            elif white_count > black_count:
                winner = "白棋获胜!"
            else:
                winner = "平局!"
            messagebox.showinfo("游戏结束", f"{winner}\n黑棋: {black_count}, 白棋: {white_count}")
            self.window.quit()
    
        def AI_move(self):
            stone_pos = self.find_best_move(COMPUTER)
            if stone_pos:
                self.make_move(stone_pos[0], stone_pos[1], COMPUTER)
    
        def find_best_move(self, player):
            # 简单的贪心策略:选择翻转对手棋子最多的移动
            max_flips = -1
            best_move = None
            for r in range(BOARD_SIZE):
                for c in range(BOARD_SIZE):
                    if self.is_valid_move(r, c, player):
                        flips = self.count_flips(r, c, player)
                        if flips > max_flips:
                            max_flips = flips
                            best_move = (r, c)
            return best_move
    
        def count_flips(self, row, col, player):
            opponent = HUMAN if player == COMPUTER else COMPUTER
            directions = [(-1, 0), (1, 0), (0, -1), (0, 1), 
                          (-1, -1), (-1, 1), (1, -1), (1, 1)]
            num_flips = 0
            for dr, dc in directions:
                r, c = row + dr, col + dc
                cells_to_flip = 0
                while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == opponent:
                    cells_to_flip += 1
                    r += dr
                    c += dc
                if cells_to_flip and 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == player:
                    num_flips += cells_to_flip
            return num_flips
    
    if __name__ == "__main__":
        Othello()
    

    改进的部分:

    • 修正了游戏规则:确保了初始棋盘状态在游戏启动时准确展现。

    • 修改了AI策略:AI使用简单的“贪心”策略,即选择能够翻转最多对手棋子的落子位置。这比原来的随机选择策略更具挑战性。

    • 游戏结束检测:检测当前玩家和对手是否有合法的移动,并在玩家没有合法位置时自动跳过当前玩家。

    希望这些改动能够使游戏更好地运行并且有一个更好的游戏体验!如果有进一步的问题或者性能优化需求,可以继续沟通。