井字棋（人机对战）

基于pygame实现的井字棋（人机对战）游戏

这款井字棋小游戏中，你将对战很笨的人工智能NanaGo。后续有时间将会对AI内部函数进行完善，make NanaGo great again。

AI内部函数

这个ai很笨，只会按照顺序落子。他的核心逻辑就只是for循环。

def __computer_chess(self):
      """
      电脑下棋。从左上角开始依次遍历，然后下到第一个empty的地方
      
      """
      for c in range(3):
          for r in range(3):
              if self.__chess_map[r][c] == ChessType.EMPTY:
                  self.__chess_map[r][c] = ChessType.FORK
                  return
 

完整代码

import enum
import random
from typing import List, Tuple, Optional

import pygame # 需先手动下载pygame库：pip install pygame

BG_COLOR = pygame.Color("#EEEEEE") # 背景
BOARD_COLAR = pygame.Color("#E96666") # 边框
CIRCLE_CHESS_COLOR = pygame.Color("#3CA273") # 画圈圈的棋子的颜色
FORK_CHESS_COLOR = pygame.Color("#5570C2") # 画叉的棋子的颜色
WIN_LINE_COLOR = pygame.Color("#FFA801") # 获胜划线
CIRCLE_WIN_HINT_TEXT_COLOR = pygame.Color("#029999") # 画圈获胜文本
FORK_WIN_HINT_TEXT_COLOR = pygame.Color("#E94466") # 画叉获胜文本
TIE_HINT_TEXT_COLOR = pygame.Color("#FAC888") # 平局文本
RESTART_HINT_TEXT_COLOR = pygame.Color("#91CBBB") #重新开始


def main():
    # 初试化
    pygame.init()
    pygame.display.set_caption("井字棋AI_NanaGo")
    screen = pygame.display.set_mode((500,500))
    clock = pygame.time.Clock()

    scene = GameScene()
    
    while True:
        for event in pygame.event.get():
            # 退出判断
            if event.type == pygame.QUIT:
                pygame.quit()
                return
            
            # 处理鼠标的输入，传递到我的场景中进行处理
            if event.type == pygame.MOUSEBUTTONDOWN:
                if event.dict["button"] == pygame.BUTTON_LEFT:
                    pos = event.dict["pos"] #pos is a tuple
                    scene.on_mouse_left_button_down(pos[0], pos[1])
            
            elif event.type == pygame.MOUSEMOTION:
                #鼠标移动
                pos = event.dict["pos"] #pos is a tuple
                scene.on_mouse_motion(pos[0], pos[1])


        #绘制场景
        scene.draw(screen)

        #更新屏幕
        pygame.display.flip()

        #限制帧率
        clock.tick(30)
            


class ChessType(enum.Enum):
    """
    棋子类型，画圈圈的是人类，画叉的是电脑AI
    """
    EMPTY = 0
    """空位，没有被下子"""

    CIRCLE = 1
    FORK = 2


class GameStatus(enum.Enum):
    """
    游戏状态
    """
    PLAYING = 0
    CIRCLE_WIN = 1
    FORK_WIN = 2

    TIE = 3
    """平局"""



class GameScene:
    """
    游戏场景
    """
    __game_status: GameStatus = None
    __chess_map: List[List[ChessType]] = None
    __curr_mouse_down_pos: Optional[Tuple[int, int]] = None
    __curr_mouse_motion_pos: Optional[Tuple[int, int]] = None
    __win_pos_start: Optional[Tuple[int, int]] = None
    __win_pos_end: Optional[Tuple[int, int]] = None
    __circle_win_hint_text: pygame.Surface = None
    __fork_win_hint_text: pygame.Surface = None
    __tie_hint_text: pygame.Surface = None
    __restart_text: pygame.Surface = None


    def __init__(self):
        font = pygame.font.Font(pygame.font.get_default_font(), 25)
        self.__circle_win_hint_text = font.render("You Win", True, CIRCLE_WIN_HINT_TEXT_COLOR)
        self.__fork_win_hint_text = font.render("NanaGo Win", True, FORK_WIN_HINT_TEXT_COLOR)
        self.__tie_hint_text = font.render("Tie", True, TIE_HINT_TEXT_COLOR)
        self.__restart_text = font.render("Click for a new game", True, RESTART_HINT_TEXT_COLOR)
        self.__init()


    def __init(self):
        print("初始化ing")
        self.__game_status = GameStatus.PLAYING

        self.__chess_map = [
            [ChessType.EMPTY,ChessType.EMPTY,ChessType.EMPTY],
            [ChessType.EMPTY,ChessType.EMPTY,ChessType.EMPTY],
            [ChessType.EMPTY,ChessType.EMPTY,ChessType.EMPTY]
        ]

        self.__curr_mouse_down_pos = None
        self.__win_pos_start = None
        self.__win_pos_end = None


        if random.random() > 0.5:
            print("电脑先手")
            self.__computer_chess()
            self.__check_game_over()
        else:
            print("人类先手")



    def __computer_chess(self):
        """
        电脑下棋。从左上角开始依次遍历，然后下到第一个empty的地方
        
        """
        for c in range(3):
            for r in range(3):
                if self.__chess_map[r][c] == ChessType.EMPTY:
                    self.__chess_map[r][c] = ChessType.FORK
                    return

        

    def __check_game_over(self):
        for c in range(3):
            circle_count = 0
            fork_count = 0
            for r in range(3):
                if self.__chess_map[r][c] == ChessType.CIRCLE:
                    circle_count += 1
                elif self.__chess_map[r][c] == ChessType.FORK:
                    fork_count += 1
            
            if circle_count == 3:
                self.__game_status = GameStatus.CIRCLE_WIN
                self.__win_pos_start = (0, c)
                self.__win_pos_end = (2, c)
                print("人类获胜")
                break

            if fork_count == 3:
                self.__game_status = GameStatus.FORK_WIN
                self.__win_pos_start = (0, c)
                self.__win_pos_end = (2, c)
                print("电脑获胜")
                break
        
        if self.__game_status != GameStatus.PLAYING:
            return
        
        for r in range(3):
            circle_count = 0
            fork_count = 0
            for c in range(3):
                if self.__chess_map[r][c] == ChessType.CIRCLE:
                    circle_count += 1
                elif self.__chess_map[r][c] == ChessType.FORK:
                    fork_count += 1
            
            if circle_count == 3:
                self.__game_status = GameStatus.CIRCLE_WIN
                self.__win_pos_start = (r, 0)
                self.__win_pos_end = (r, 2)
                print("人类获胜")
                break

            if fork_count == 3:
                self.__game_status = GameStatus.FORK_WIN
                self.__win_pos_start = (r, 0)
                self.__win_pos_end = (r, 2)
                print("电脑获胜")
                break
          
        if self.__game_status != GameStatus.PLAYING:
            return     

        if self.__chess_map[0][0] == ChessType.CIRCLE and self.__chess_map[1][1] == ChessType.CIRCLE and self.__chess_map[2][2] == ChessType.CIRCLE:
            self.__game_status = GameStatus.CIRCLE_WIN
            self.__win_pos_start = (0,0)
            self.__win_pos_end = (2,2)
        elif self.__chess_map[0][0] == ChessType.FORK and self.__chess_map[1][1] == ChessType.FORK and self.__chess_map[2][2] == ChessType.FORK:
            self.__game_status = GameStatus.FORK_WIN
            self.__win_pos_start = (0,0)
            self.__win_pos_end = (2,2)
        elif self.__chess_map[2][0] == ChessType.CIRCLE and self.__chess_map[1][1] == ChessType.CIRCLE and self.__chess_map[0][2] == ChessType.CIRCLE:
            self.__game_status = GameStatus.CIRCLE_WIN
            self.__win_pos_start = (2,0)
            self.__win_pos_end = (0, 2)
        elif self.__chess_map[2][0] == ChessType.FORK and self.__chess_map[1][1] == ChessType.FORK and self.__chess_map[0][2] == ChessType.FORK:
            self.__game_status = GameStatus.FORK_WIN
            self.__win_pos_start = (2,0)
            self.__win_pos_end = (0,2)

        if self.__game_status != GameStatus.PLAYING:
            return
        
        has_empty = False
        for r in range(3):
            for c in range(3):
                if self.__chess_map[r][c] == ChessType.EMPTY:
                    has_empty = True
                    break
            if has_empty == True:
                break
        if not has_empty:
            self.__game_status == GameStatus.TIE

    def __get_mouse_on_board_pos(self,
                                 board_pos: Tuple[int, int],
                                 cell_size: int,
                                 mouse_pos:Tuple[int, int]) ->Tuple[int, int]:
        """
        获取当前鼠标位置在棋盘中的行列位置(index)(eg(0,0)(0,1)(0,2),...(2,0)(2,1)(2,2))，鼠标没有在棋盘中返回(-1,-1)
        """

        assert self #为了防止报错或者warning
        board_x, board_y = board_pos[0], board_pos[1]
        mouse_x, mouse_y = mouse_pos[0], mouse_pos[1]

        x, y = mouse_x - board_x, mouse_y - board_y #用相对距离

        if x < 0 or y < 0 or x >= cell_size * 3 or y >= cell_size * 3:
            return -1, -1
        # 竖直方向表示行，水平方向表示列
        return y // cell_size, x // cell_size
    
    def on_mouse_left_button_down(self, pos_x: int, pos_y: int):
        """
        鼠标左键按下
        """
        self.__curr_mouse_down_pos = (pos_x, pos_y)

    def on_mouse_motion(self, pos_x:int, pos_y:int):
        self.__curr_mouse_motion_pos = (pos_x, pos_y)


    def draw(self, screen: pygame.Surface):
        #填充背景
        screen.fill(BG_COLOR)

        #绘制棋盘
        board_cell_size = 100
        board_x = round(screen.get_width() / 2 - (3 * board_cell_size) / 2)
        board_y = round(screen.get_height() / 2 - (3 * board_cell_size) / 2)
        self.__draw_board(screen, (board_x,board_y),board_cell_size,3)

        # 如果处于游戏中，判断鼠标（人类）是否有落子
        if self.__game_status == GameStatus.PLAYING and self.__curr_mouse_down_pos:
            row, col = self.__get_mouse_on_board_pos((board_x, board_y), board_cell_size, self.__curr_mouse_down_pos)
            # 人类落子
            self.__chess_map[row][col] = ChessType.CIRCLE
            print(f"人类(点击落子):({row}, {col}) <- 圈")
            self.__check_game_over()
            if self.__game_status == GameStatus.PLAYING:
                self.__computer_chess()
                self.__check_game_over()
            self.__curr_mouse_down_pos = None

        if self.__game_status != GameStatus.PLAYING and self.__curr_mouse_down_pos:
            self.__init()

        self.__draw_chess(screen, (board_x,board_y),board_cell_size,20,5)
        self.__draw_win_line(screen, (board_x,board_y),board_cell_size,3)
        self.__draw_hint_text(screen, (board_x,board_y),board_cell_size)

    def __draw_board(self, screen:pygame.Surface, board_pos:Tuple[int, int], cell_size:int, line_width:int):
        """
        绘制棋盘
        """
        assert self
        x, y = board_pos[0],  board_pos[1]
        #横线
        x1 = x
        x2 = x + 3 * cell_size
        y1 = y + cell_size
        y2 = y + 2 * cell_size
        pygame.draw.line(screen,BOARD_COLAR,(x1,y1),(x2, y1),line_width)
        pygame.draw.line(screen,BOARD_COLAR,(x1,y2),(x2, y2),line_width)


        y1 = y
        y2 = y + 3 * cell_size
        x1 = x + cell_size
        x2 = x + 2 * cell_size
        pygame.draw.line(screen,BOARD_COLAR,(x1,y1),(x1, y2),line_width)
        pygame.draw.line(screen,BOARD_COLAR,(x2,y1),(x2, y2),line_width)
    

    def __draw_chess(self,
                        screen:pygame.Surface,
                        board_pos:Tuple[int,int],
                        board_cell_size:int,
                        padding:int,
                        border_width:int):
        """
        绘制棋子
        """

        board_x, board_y = board_pos[0], board_pos[1]
        for r in range(len(self.__chess_map)):
            row = self.__chess_map[r]
            for c in range(len(row)):
                chess = row[c]
                if chess == ChessType.CIRCLE:
                    self.__draw_circle_chess(screen,
                                                (board_x + c * board_cell_size, board_y + r * board_cell_size),
                                                board_cell_size,
                                                padding,
                                                border_width)
                elif chess == ChessType.FORK:
                    self.__draw_fork_chess(screen,
                                                (board_x + c * board_cell_size, board_y + r * board_cell_size),
                                                board_cell_size,
                                                padding,
                                                border_width)

    def __draw_circle_chess(self,
                            screen:pygame.Surface,
                            chess_pos:Tuple[int,int],
                            board_cell_size:int,
                            padding:int,
                            border_width:int):
        """
        绘制圆棋子
        """
        assert self
        chess_x, chess_y = chess_pos[0], chess_pos[1]
        center = round(chess_x + board_cell_size / 2),  round(chess_y + board_cell_size / 2)
        radius = round(board_cell_size / 2 - padding)
        pygame.draw.circle(screen, CIRCLE_CHESS_COLOR, center, radius, border_width)

    def __draw_fork_chess(self,
                            screen:pygame.Surface,
                            chess_pos:Tuple[int,int],
                            board_cell_size:int,
                            padding:int,
                            border_width:int):
        """
        绘制叉棋子
        """
        assert self
        chess_x, chess_y = chess_pos[0], chess_pos[1]
        pygame.draw.line(screen, FORK_CHESS_COLOR, (chess_x + padding, chess_y + padding), (chess_x + board_cell_size - padding, chess_y + board_cell_size - padding ), border_width)
        pygame.draw.line(screen, FORK_CHESS_COLOR, (chess_x + board_cell_size - padding, chess_y + padding), (chess_x + padding, chess_y + board_cell_size - padding ), border_width)


    def __draw_win_line(self, 
                        screen:pygame.Surface,
                        board_pos:Tuple[int,int],
                        cell_size:int,
                        line_width:int):
        """
        绘制获胜曲线
        """
        if (not self.__win_pos_start) or (not self.__win_pos_end):
            return
        
        board_x, board_y = board_pos[0], board_pos[1]
        pos_start_row, pos_start_col = self.__win_pos_start[0], self.__win_pos_start[1]
        pos_end_row, pos_end_col = self.__win_pos_end[0], self.__win_pos_end[1]

        half_cell_size = round(cell_size / 2)

        start = (board_x + pos_start_col * cell_size + half_cell_size, board_y + pos_start_row * cell_size + half_cell_size)
        end = (board_x + pos_end_col * cell_size + half_cell_size, board_y + pos_end_row * cell_size + half_cell_size)

        pygame.draw.line(screen, WIN_LINE_COLOR, start, end, line_width)




    def __draw_hint_text(self, 
                        screen:pygame.Surface,
                        board_pos:Tuple[int,int],
                        cell_size:int,
                        ):
        board_y = board_pos[1]

        if self.__game_status == GameStatus.CIRCLE_WIN:
            screen.blit(self.__circle_win_hint_text, (screen.get_width() / 2 - self.__circle_win_hint_text.get_width() / 2, board_y / 2 - self.__circle_win_hint_text.get_height() / 2))
        elif self.__game_status == GameStatus.FORK_WIN:
            screen.blit(self.__fork_win_hint_text, (screen.get_width() / 2 - self.__fork_win_hint_text.get_width() / 2, board_y / 2 - self.__fork_win_hint_text.get_height() / 2))
        elif self.__game_status == GameStatus.TIE:
            screen.blit(self.__tie_hint_text, (screen.get_width() / 2 - self.__tie_hint_text.get_width() / 2, board_y / 2 - self.__tie_hint_text.get_height() / 2))


        if self.__game_status != GameStatus.PLAYING:
            #重新开始的提示
            screen.blit(self.__restart_text, (screen.get_width() / 2 - self.__restart_text.get_width() / 2, (screen.get_height() + (board_y + cell_size * 3)) / 2 - self.__restart_text.get_height() / 2))




if __name__ == "__main__":
    main()