一、pygame简介

pygame是一种流行的Python游戏开发库，具有良好的跨平台支持，可以在多个操作系统上运行，例如Windows，MacOS和Linux，免费、开源和跨平台。

pygame是一组专为编写视频游戏而设计的 Python 模块，使开发人员可以轻松创建2D游戏。 它在优秀的 Simple DirectMedia Library (SDL) 的库之上添加了功能，可以创建功能齐全的游戏和多媒体程序。

二、pygame模块与能力详解

2.1 基本编程框架

初始化pygame--> 定义显示窗口-->定义循环（刷新游戏界面）-->关闭游戏

import pygame
import sys
#初始化内部各功能模块进行初始化
pygame.init()  
#定义显示窗口
size = width,height = 800,600  
screen = pygame.display.set_mode(size)  
#设置显示窗口的标题内容等
pygame.display.set_caption("小游戏程序")  
#定义循环，用于抓取事件、刷新游戏界面
while True:  
    #获取事件（鼠标、键盘、操作系统）
    for event in pygame.event.get():  
        if event.type == pygame.QUIT:  
            sys.exit()      
    #对游戏界面执行更新，窗口全部重绘    
    pygame.display.update()

2.2 pygame基本模块详解

2.2.1 pygame.display: 控制显示窗口和屏幕

• pygame.display.set_mode(size, flags, depth, display, vsync)

size：表示 Surface 对象的矩形区域大小，是一个以像素为单位的宽度和高度的元组。 如果未设置 size，则表面将具有当前分辨率的尺寸。

flags: 控制由以下预定义常量表示的显示类型。

Depth：指定像素的颜色深度，默认为自适应模式。

Display： 索引 0 表示使用默认显示，否则可能会被环境变量覆盖。

vsync：设置为 1，则有可能获得具同步功能的显示器，但不保证一定能获得。 当pygame.OPENGL 或 pygame.SCALED模式下有效。

pygame默认是采用的笛卡尔坐标系。左上角的顶点是(0,0)，向下向左正值增加。

• pygame.display 模块其他方法

2.2.2 Surface模块用来新建图像的

• 语法：Surface=pygame.Surface(size=(width,height),flags,depth)

size：表示 Surface 对象的矩形区域大小。

flags：有两个可选参数值 HWSURFACE 和 SPCALPHA，前者代表将创建的 Surface 对象存放于显存中，后者表示让图像的每一个像素都包含一个 alpha 通道。

depth：指定像素的颜色深度，默认为自适应模式。

• 方法列表

2.2.3 Event事件模块：接收用户产生的各种操作构

事件是构建整个游戏程序的核心，鼠标点击、键盘敲击、游戏窗口移动、调整窗口大小、触发特定的情节、退出游戏等等都可以看做是事件。

Event用事件队列来处理事件，遵循“先到先处理”的基本原则，通过事件队列，我们可以有序的、逐一的处理用户的操作。

常用的方法：

2.2.4 Draw绘图：绘制一些简单的图形状

• 绘制矩形：pygame.draw.rect(surface, color, rect, width)

surface：指主游戏窗口，无特殊情况，一般都会绘制在主屏幕上。

color：该参数用于该图形着色。

通过以下三种方式来传递 color 参数值：

• 使用 pygame.color 对象

Color(r, g, b, a=255) -> RBG值，a：透明度，255表示不透明

Color(color_value) -> Color

• RGB 三元组

附：基本颜色：

rect：绘制图形的位置和尺寸大小。

width：可选参数，指定边框的宽度，默认为 0，表示填充该矩形区域。

• 绘制图形形状方法列表

2.2.5 Locals 模块：各种常量的定义

pygame中的常量是在各自的模块中定义的，但从 locals 模块中使用它们会变得更容易。常量定义主要用于以下几个方面：

• 事件像键盘鼠标等的名称、值等。
• Pygame中定义的颜色、特效等值。
• Pygame中所支持的字体的名称和样式。
• 屏幕的尺寸和特效。

例如，键、鼠标事件为KEYDOWN、MOUSEBUTTONDOWN

2.2.6 其他模块功能

pygame._sdl2.touch：使用触摸输入

pygame.camera：使用相机

pygame.cdrom：音频cdrom控制

pygame.cursors：游标资源

pygame.fastevent：与来自多个线程的事件和队列交互。

pygame.font：加载和渲染字体

pygame.freetype：加载和渲染计算机字体

pygame.gfxdraw：绘制形状

pygame.image：图像传输

pygame.joystick：与操纵杆、游戏手柄和轨迹球交互。

pygame.key：使用键盘

pygame.mask：图像遮罩。

pygame.math向量类

pygame.midi：与 MIDI 输入和输出交互。

pygame.mixer：加载和播放声音

pygame.mixer.music：控制流式音频

pygame.mouse：使用鼠标

pygame.pixelcopy ：一般像素阵列复制

pygame.scrap：剪贴板支持。

pygame.sndarray：访问声音样本数据

pygame.sprite：基本游戏对象类

pygame.surfarray：使用数组接口访问表面像素数据

pygame.tests：单元测试套件包

pygame.time：监听时间，控制游戏的帧率、动画速度等

pygame.transform：转换表面

三、游戏编程示例 - 简易五子棋

3.1 游戏设计

3.1规则

• 五子棋棋盘由18条横线18条竖线组成
• 棋子要下在线的交叉点上，方格中不能放入棋子
• 双方分别使用黑白两色的棋子
• 横、竖、上斜、下斜先形成五子连珠方获胜

3.2 编程设计

• 程序主流程

• 设计关键环节

1）线的编号就是坐标取值(0~17)，共计18条线，间隔位置参考下图

2）五子连线赢棋四种策略，参考绿色底色编号示意(实际位置在交叉点上)

3）落子点就是用坐标值表示(x,y)

4）获取鼠标位置，据所在范围，标识落子点，避免点错

5）棋子分黑白，画图获取的位置和大小，就以交叉点坐标为圆心，18px为半径画出（2px作为棋子间隔）

3.3 代码实现

• 源码

# -*- coding: utf-8 -*-
import pygame
import sys
import time
from pygame import locals
#棋盘尺寸预定义,单位px
QIPAN_EDGE_LENGTH :int = 20
QIPAN_SIZE_OF_CHESS_PIECES :int = 18
QIPAN_GAP_OF_CHESS_PIECES :int = 2
QIPAN_GAP_OF_TWO_LINE :int = 40
QIPAN_LENGHT :int = 720
QIPAN_TOTAL_NUM_OF_CHESS = QIPAN_SIZE_OF_CHESS_PIECES * QIPAN_SIZE_OF_CHESS_PIECES
#棋盘颜色，RGB
QIPAN_COLOR = [238, 154, 73]
#棋盘画线黑色
QIPAN_LINE_COLOR = [0,0,0]
#线粗细
QIPAN_BOLD_LINE_SIZE :int = 4
QIPAN_NORMAL_LINE_SIZE :int = 2
#棋子颜色
CHESS_PIECES_WHITE = (255,255,255)
CHESS_PIECES_BLACK = (0,0,0)
#字体STXIHEI.TTF，如果本地没有字体，可以注释字体相关代码
#window字体默认存储位置：C:\Windows\Fonts\STXIHEI.TTF
WATERMARK_CONTENT = '山狗学会'
WATERMARK_FONT = 'STXIHEI.TTF'
WATERMARK_FONT_SIZE = 15
class Wuziqi(object):
    #记录落子的位置,currentStausOfWuziqi[(x_point,y_point)] = （True, True)
    #key: 坐标；Value：是否落子，是否黑子
    currentStausOfWuziqi = {}
    def __init__(self):
        self.startGame()
       
    def startGame(self):
        #初始化pygame环境
        pygame.init()
        #画棋盘
        #游戏主窗口
        qipan_screen = pygame.display.set_mode((QIPAN_LENGHT, QIPAN_LENGHT))
       
        #用于记录是否赢棋
        result = (False, [])
       
        #持续刷新游戏画面
        while True:
            for event in pygame.event.get():
                #获取事件，如果鼠标点击右上角关闭按钮，关闭
                if event.type == locals.QUIT:
                    sys.exit()
           
            #已和局或者赢棋，不再刷新界面      
            if (len(self.currentStausOfWuziqi) >= QIPAN_TOTAL_NUM_OF_CHESS) or result[0]:
                continue                
                       
            #每次画图都要刷新棋盘，否则会留下“轨迹”
            #刷新棋盘：棋盘颜色，RGB        
            qipan_screen.fill(QIPAN_COLOR)                                  
            #新棋盘画线，18*18的棋盘，边白20px，线间隔40px；
            #起始坐标位置20px，间隔40px（18+2），总长720px
            for i in range(20,720, 40):
                #先画竖线，边框略粗
                if i == QIPAN_EDGE_LENGTH or i == QIPAN_LENGHT - QIPAN_EDGE_LENGTH:
                    #起点坐标至终点坐标，画线
                    pygame.draw.line(qipan_screen, QIPAN_LINE_COLOR,
                                    [i, QIPAN_EDGE_LENGTH], [i,QIPAN_LENGHT - QIPAN_EDGE_LENGTH],
                                    QIPAN_BOLD_LINE_SIZE
                                    )
                #正常棋盘线
                else:
                    pygame.draw.line(qipan_screen, QIPAN_LINE_COLOR,
                                    [i, QIPAN_EDGE_LENGTH],[i, QIPAN_LENGHT - QIPAN_EDGE_LENGTH],
                                    QIPAN_NORMAL_LINE_SIZE
                                    )
                   
                #再画横线
                ##起点坐标至终点坐标，画线
                if i == QIPAN_EDGE_LENGTH or i == QIPAN_LENGHT - QIPAN_EDGE_LENGTH:
                    pygame.draw.line(qipan_screen, QIPAN_LINE_COLOR,
                                    [QIPAN_EDGE_LENGTH, i], [QIPAN_LENGHT - QIPAN_EDGE_LENGTH, i],
                                    QIPAN_BOLD_LINE_SIZE
                                    )
                else:
                    pygame.draw.line(qipan_screen, QIPAN_NORMAL_LINE_SIZE,
                                    [QIPAN_EDGE_LENGTH, i], [QIPAN_LENGHT - QIPAN_EDGE_LENGTH, i],
                                    QIPAN_NORMAL_LINE_SIZE
                                    )
           
            #新棋盘上加上水印
            watermar_font = pygame.font.Font('STXIHEI.TTF', WATERMARK_FONT_SIZE)
            # 字体对象.render(文字内容,True,文字颜色,背景颜色)
            text = watermar_font.render(WATERMARK_CONTENT, True, (255, 255, 255),(238, 154, 73))
            qipan_screen.blit(text, (QIPAN_LENGHT/2-40, QIPAN_LENGHT/2-40))
           
            #获取鼠标坐标信息
            x, y = pygame.mouse.get_pos()
            #获取落子的点
            x_point, y_point = self.getChessPiecesPosition(x, y)
            #画一个圆圈，参数：棋盘，颜色，位置和尺寸，半径
            pygame.draw.circle(qipan_screen, (0, 255, 0),
                               (x_point, y_point),
                               20,
                               QIPAN_BOLD_LINE_SIZE)
           
            #点击鼠标落子，记录落子成功
            if (pygame.mouse.get_pressed()[0]):
                if not ((x_point,y_point) in self.currentStausOfWuziqi):
                    if len(self.currentStausOfWuziqi) % 2 == 0:
                        self.currentStausOfWuziqi[(x_point,y_point)] = (True, True)
                    else:
                        self.currentStausOfWuziqi[(x_point,y_point)] = (True, False)
                       
                #避免连续点击鼠标，暂停
                time.sleep(0.2)
               
            #重新画一遍已落下的棋子
            self.drawAllChessPieces(qipan_screen)
            #检查是否赢棋
            result = self.ifWin()
            if result[0]:
                # print(result[0],result[1])
                for p in result[1]:
                    pygame.draw.circle(qipan_screen, (0, 255, 0),
                               (p[0], p[1]),
                               20,
                               QIPAN_BOLD_LINE_SIZE)
                pygame.display.update()
           
            #刷新游戏界面
            pygame.display.update()
   
    def drawAllChessPieces(self, qipan_screen):        
        for coord, check  in self.currentStausOfWuziqi.items():
            if check[1]:
                pygame.draw.circle(qipan_screen, CHESS_PIECES_BLACK, (coord[0], coord[1]),QIPAN_SIZE_OF_CHESS_PIECES,0)
            else:
                pygame.draw.circle(qipan_screen, CHESS_PIECES_WHITE, (coord[0], coord[1]),QIPAN_SIZE_OF_CHESS_PIECES,0)
   
    #根据鼠标位置，获取落子位置（棋盘落子点）
    #鼠标位置肯定会落在棋盘上的一个“方格”内，将2个对边中心点相连，就将方格隔离出来四个区域
    #如果坐标落在左上角区域，那么落子点就是“方格”的左上角定点，以此类推
    def getChessPiecesPosition(self, x, y):
        #向下取整：整除"//"
        n_x = (x - QIPAN_EDGE_LENGTH) // QIPAN_GAP_OF_TWO_LINE
        n_y = (y - QIPAN_EDGE_LENGTH) // QIPAN_GAP_OF_TWO_LINE
        #取余（%）
        n_x_left = (x - QIPAN_EDGE_LENGTH) % QIPAN_GAP_OF_TWO_LINE
        n_y_left = (y - QIPAN_EDGE_LENGTH) % QIPAN_GAP_OF_TWO_LINE
       
        #左上角顶点
        if n_x_left <= QIPAN_GAP_OF_TWO_LINE/2 and n_y_left <= QIPAN_GAP_OF_TWO_LINE/2:
            x = n_x
            y = n_y
        #左下角顶点
        elif n_x_left <= QIPAN_GAP_OF_TWO_LINE/2 and n_y_left > QIPAN_GAP_OF_TWO_LINE/2:
            x = n_x
            y = n_y + 1
        #右上角顶点
        elif n_x_left > QIPAN_GAP_OF_TWO_LINE/2 and n_y_left <= QIPAN_GAP_OF_TWO_LINE/2:
            x = n_x + 1
            y = n_y
        #左下角顶点
        else:
            x = n_x + 1
            y = n_y + 1
       
        return x * QIPAN_GAP_OF_TWO_LINE + QIPAN_EDGE_LENGTH, y * QIPAN_GAP_OF_TWO_LINE + QIPAN_EDGE_LENGTH
   
    def ifWin(self):                  
        #如果尚未落子，就直接返回未赢
        if (len(self.currentStausOfWuziqi) < 1):
            return (False, [])
       
        #获取最后一个棋子的坐标，并判断最后一个棋子是否赢棋;dict转换位list，是按照元素添加顺序来确定顺序的
        coord = list(self.currentStausOfWuziqi.keys())[-1]    
        x_point = coord[0]
        y_point = coord[1]
       
       
        #如果落子坐标不在已落子坐标内，则返回
        if not ((x_point,y_point) in self.currentStausOfWuziqi):
            return (False, [])
           
        chess_color = self.currentStausOfWuziqi[(x_point,y_point )][1]
       
        #横向五子连线判断，先往右遍历，再往左遍历
        #初始化游标，用于判断是否五子连线，记录赢棋记录
        x_cursor = 0
        y_cursor = 0
        #首个棋子是当前棋子
        no_cursor = 1
        res_list = []
        #首先向右判断,纵坐标不变
        y_cursor = y_point
        for i in range (1, 6):  
            #如果已经是右边边框落子，直接终止向右
            if x_point == QIPAN_LENGHT - QIPAN_EDGE_LENGTH:
                break
            #游标移动
            x_cursor = x_point + QIPAN_GAP_OF_TWO_LINE * i
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
           
        #如果五子连线返回结果，不用进一步分析棋局
        if no_cursor >= 5:
            return (True, res_list)
           
        #然后向左判断，纵坐标保持不变
        for i in range (1, 6):  
            #如果已经是左边边框落子，直接终止向左
            if x_point == QIPAN_EDGE_LENGTH:
                break
            #游标移动
            x_cursor = x_point - QIPAN_GAP_OF_TWO_LINE * i
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
           
        #如果五子连线返回结果，不用进一步分析棋局
        if no_cursor >= 5:
            return (True, res_list)
           
        #纵向五子连线判断，先往下遍历，再往上遍历
        #初始化游标，用于判断是否五子连线
        x_cursor = 0
        y_cursor = 0
        #首个棋子是当前棋子
        no_cursor = 1
        res_list = []
        #首先向下判断,横坐标不变
        x_cursor = x_point
        for i in range (1, 6):  
            #如果已经是下边边框落子，直接终止向下
            if y_point == QIPAN_LENGHT - QIPAN_EDGE_LENGTH:
                break
            #游标移动
            y_cursor = y_point + QIPAN_GAP_OF_TWO_LINE * i
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
           
        #如果五子连线返回结果，不用进一步分析棋局
        if no_cursor >= 5:
            # print('纵向',True, res_list)
            return (True, res_list)
           
        #然后向上判断，横坐标保持不变
        for i in range (1, 6):  
            #如果已经是上边边框落子，直接终止向上
            if y_point == QIPAN_EDGE_LENGTH:
                break
            #游标移动
            y_cursor = y_point - QIPAN_GAP_OF_TWO_LINE * i
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
        #如果五子连线返回结果，不用进一步分析棋局
        if no_cursor >= 5:
            return (True, res_list)
       
        #斜下五子连线判断，先往斜下遍历，再往斜后遍历
        #初始化游标，用于判断是否五子连线
        x_cursor = 0
        y_cursor = 0
        #首个棋子是当前棋子
        no_cursor = 1
        res_list = []
        #首先斜下判断        
        for i in range (1, 6):  
            #如果已经是下边边框落子，直接终止向下
            if (x_point == QIPAN_LENGHT - QIPAN_EDGE_LENGTH) or (y_point == QIPAN_LENGHT - QIPAN_EDGE_LENGTH) :
                break
            #游标移动
            x_cursor = x_point + QIPAN_GAP_OF_TWO_LINE * i
            y_cursor = y_point + QIPAN_GAP_OF_TWO_LINE * i
           
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
           
        #然后斜后判断        
        for i in range (1, 6):  
            #如果已经是上边边框落子，直接终止向上
            if (x_point == QIPAN_EDGE_LENGTH) or (y_point == QIPAN_EDGE_LENGTH) :
                break
            #游标移动
            x_cursor = x_point - QIPAN_GAP_OF_TWO_LINE * i
            y_cursor = y_point - QIPAN_GAP_OF_TWO_LINE * i
           
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
        #如果五子连线返回结果，不用进一步分析棋局
        if no_cursor >= 5:
            return (True, res_list)      
       
        #斜上五子连线判断，先往斜上遍历，再往斜后遍历
        #初始化游标，用于判断是否五子连线
        x_cursor = 0
        y_cursor = 0
        #首个棋子是当前棋子
        no_cursor = 1
        res_list = []
        #首先斜下判断        
        for i in range (1, 6):  
            #如果已经是边框落子，直接终止
            if (x_point == QIPAN_LENGHT - QIPAN_EDGE_LENGTH) or (y_point == QIPAN_EDGE_LENGTH) :
                break
            #游标移动
            x_cursor = x_point + QIPAN_GAP_OF_TWO_LINE * i
            y_cursor = y_point - QIPAN_GAP_OF_TWO_LINE * i
           
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
           
        #然后斜后判断        
        for i in range (1, 6):  
            #如果已经是边框落子，直接终止
            if (x_point == QIPAN_EDGE_LENGTH) or (y_point == QIPAN_LENGHT - QIPAN_EDGE_LENGTH) :
                break
            #游标移动
            x_cursor = x_point - QIPAN_GAP_OF_TWO_LINE * i
            y_cursor = y_point + QIPAN_GAP_OF_TWO_LINE * i
           
            #游标所在坐标有棋子            
            if (x_cursor,y_cursor) in self.currentStausOfWuziqi:
                #且棋子颜色与最后一个棋子颜色一致，则连续棋子数量加1
                if chess_color == self.currentStausOfWuziqi[(x_cursor,y_cursor)][1]:
                    no_cursor = no_cursor + 1
                    res_list.append((x_cursor,y_cursor))
                else:
                    break
            else:
                break
        #如果五子连线返回结果，不用进一步分析棋局
        #如果四种赢棋方式均未赢棋，则返回False
        if no_cursor >= 5:
            return (True, res_list)  
        else:
            return (False, res_list)    
     
#为了标识执行代码的入口和避免文件被导入时被执行，我们可以将执行代码放入main函数中。
if __name__ == '__main__':
    Wuziqi()

• 验证结果

PS D:\Shangouxuehui_Git> & D:/Python312/python.exe d:/Shangouxuehui_Git/PythonBasicCases/pygame_wuziqi.py

https://github.com/ShanGouXueHui/PythonBasicCases

##山狗学会 License Start##

转载请注明出处，"今日头条"创作者"山狗学会“ ，注明出处即授权，未注明出处罚款100万元

主页链接：山狗学会主页

##山狗学会 License End##