玩转pygame——游戏开发

使用pygame进行游戏开发

Pygame是一个开源的Python模块，专门用于多媒体应用（如电子游戏）的开发，其中包含对图像、声音、视频、事件、碰撞等的支持。Pygame建立在SDL的基础上，SDL是一套跨平台的多媒体开发库，用C语言实现，被广泛的应用于游戏、模拟器、播放器等的开发。而Pygame让游戏开发者不再被底层语言束缚，可以更多的关注游戏的功能和逻辑。
具体功能可以查看pygame的官方网站

五子棋游戏制作

制作游戏窗口

可以通过pygame中draw模块的函数在窗口上绘图，可以绘制的图形包括：线条、矩形、多边形、圆、椭圆、圆弧等。需要说明的是，屏幕坐标系是将屏幕左上角设置为坐标原点(0, 0)，向右是x轴的正向，向下是y轴的正向，在表示位置或者设置尺寸的时候，我们默认的单位都是像素。所谓像素就是屏幕上的一个点，你可以用浏览图片的软件试着将一张图片放大若干倍，就可以看到这些点。pygame中表示颜色用的是色光三原色表示法，即通过一个元组或列表来指定颜色的RGB值，每个值都在0~255之间，因为是每种原色都用一个8位（bit）的值来表示，三种颜色相当于一共由24位构成，这也就是常说的“24位颜色表示法”。

import pygame


def main():
    # 初始化导入的pygame中的模块
    pygame.init()
   screen = pygame.display.set_mode([640, 640]) # 初始化用于显示的窗口并设置窗口尺寸
    pygame.display.set_caption('五子棋')  # 设置当前窗口的标题
    screen.fill([218, 165, 105])  # 填充背景色 红绿蓝三原色
    running = True
    while running:  # 开启一个事件循环处理发生的事件
        for event in pygame.event.get():  # 从消息队列中获取事件并对事件进行处理
            if event.type == pygame.QUIT:
                running = False

if __name__ == '__main__':
    main()

画棋盘

创建棋子类对象和棋盘类对象，棋盘类里面创建一个15*15的数组的属性，再写一个重置棋盘的方法，令这个棋盘数组全部等于空，还有画棋盘的方法，通过pygame的draw模块在窗口上绘画棋盘、天元、边框和棋子，还有一个判断该位置是否有棋子，可以下的方法

class Chess(object):
    """棋子类"""
    def __init__(self, x, y, is_black):
        self._is_black = is_black
        self._row = x
        self._col = y

    @property
    def is_black(self):
        return self._is_black

    @property
    def row(self):
        return self._row

    @property
    def col(self):
        return self._col

class RenjuBoard(object):
    """棋盘类"""
    def __init__(self):
        self._board = [[]] * 15
        self.reset()

    def reset(self):
        """重置棋盘"""
        for row in range(len(self._board)):
            self._board[row] = [EMPTY] * 15

    def move(self, row, col, is_black):
        """判断是否有棋子"""
        if self._board[row][col] == EMPTY:
            self._board[row][col] = BLACK if is_black else WHITE
            return True
        return False

    def draw(self, screen):
        """画棋盘"""
        for i in range(1, 16):  # 画格子：窗口，颜色，起始位置，结束位置，粗细
            pygame.draw.line(screen, black_color, [40, 40 * i], [600, 40 * i], 1)
            pygame.draw.line(screen, black_color, [40 * i, 40], [40 * i, 600], 1)
        pygame.draw.rect(screen, black_color, [36, 36, 568, 568], 4)  # 画边框
        # 画圆 窗口，颜色，位置，半径，0实心
        pygame.draw.circle(screen, black_color, [320, 320], 4, 0)
        pygame.draw.circle(screen, black_color, [160, 160], 3, 0)
        pygame.draw.circle(screen, black_color, [160, 480], 3, 0)
        pygame.draw.circle(screen, black_color, [480, 480], 3, 0)
        pygame.draw.circle(screen, black_color, [480, 160], 3, 0)
        for row in range(len(self._board)):
            for col in range(len(self._board[row])):
                if self._board[row][col] != EMPTY:
                    ccolor = black_color if self._board[row][col] == BLACK else white_color
                    pos = [40 * (col + 1), 40 * (row + 1)]
                    pygame.draw.circle(screen, ccolor, pos, 20, 0)

完善主函数 事件处理

判断输赢，绘画文字，获取鼠标点击事件，绘画棋盘等

def main():
    board = RenjuBoard()  # 创建棋盘对象
    chess = [[EMPTY] * 16 for _ in range(16)]  # 棋子位置
    is_black = True  # 黑白棋分辨变量
    pygame.init()  # 初始化pygame
    screen = pygame.display.set_mode([640, 640])  # 初始化用于显示的窗口并设置窗口尺寸
    pygame.display.set_caption('五子棋')  # 设置当前窗口的标题
    screen.fill([218, 165, 105])  # 填充背景色 红绿蓝三原色
    board.draw(screen)  # 画棋盘
    pygame.display.flip()  # 刷新窗口
    runing = True  # 是否退出游戏变量
    gameover = True  # 游戏是否结束变量
    while runing:  # 开启一个事件循环处理发生的事件
        for event in pygame.event.get():  # 从消息队列中获取事件并对事件进行处理
            if event.type == pygame.QUIT:
                runing = False
            elif event.type == pygame.KEYUP:
                if event.key == pygame.K_F2:
                    board.reset()
                    gameover = True
                    is_black = True
                    pygame.display.flip()
            elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and gameover:  # 鼠标点击事件
                x, y = event.pos
                if 20 < x <= 600 and 20 < y < 600:
                    row = round((y - 40) / 40)
                    col = round((x - 40) / 40)
                    if board.move(row, col, is_black):
                        screen.fill([218, 165, 105])
                        board.draw(screen)
                        chess[col][row] = 1 if is_black else 2
                        pygame.display.flip()
                        if board.who_wins(col, row, chess):
                            my_font = pygame.font.SysFont("宋体", 60)  # 字体，大小
                            if is_black:
                                position = my_font.render('game over, black win', True,
                                                          (255, 0, 0))  # 内容，抗锯齿，颜色，背景色（可选）
                            else:
                                position = my_font.render('game over, white win', True, (255, 0, 0))
                            screen.blit(position, (120, 310))
                            pygame.display.flip()
                            gameover = False
                            chess = [[EMPTY] * 16 for _ in range(16)]
                        is_black = not is_black
    pygame.quit()

判断输赢

    def who_wins(self, x, y, chess):
        """判断输赢"""
        # 三维数组记录横向，纵向，左斜，右斜
        dir = [[[-1, 0], [1, 0]], [[0, -1], [0, 1]], [[-1, -1], [1, 1]], [[1, -1], [-1, 1]]]
        tempx = x
        tempy = y
        # 循环四个大方向
        for i in range(4):
            count = 1
            # 循环两边方向
            for j in range(2):
                flag = True  # 一直向一个方向遍历，有相同的，count+1，否则置flag为False
                while flag:
                    tempx += dir[i][j][0]
                    tempy += dir[i][j][1]
                    if chess[x][y] == chess[tempx][tempy]:
                        count += 1
                    else:
                        flag = False
                tempx = x
                tempy = y
                if count >= 5:
                    return True
        return False

还可以有很多拓展，比如添加背景音乐和下棋时的音乐，可以使用pygame的music和mixer，还可以写成联网游戏，用网络编程来实现
如果开发3d游戏，可以使用Panda3D
运行结果图

sjx.png

飞机大战游戏

我自己结合所学知识用pygame做的一个小游戏，用了一些老师没就讲的碰撞精灵和音乐知识
首先，我创建了一个游戏对象的大类，有横坐标，纵坐标，速度，图片四个公共属性，并写成抽象类，然后分别创建了玩家类，敌机类，背景类，子弹类，并让他们继承来游戏对象类，除背景外，因为要用到碰撞精灵，所以使用了多重继承让他们还继承了pygame.sprite.Sprite。并重写了update精灵行为方法

from abc import ABCMeta,abstractclassmethod
import pygame

class GameObject(object, metaclass=ABCMeta):
    """游戏对象"""
    def __init__(self, x=0, y=0,speed=0, image=None):
        self._x = x
        self._y = y
        self._speed = speed
        self._image = image

    @property
    def image(self):
        return self._image

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y

    @property
    def speed(self):
        return self._speed

    @x.setter
    def x(self,x):
        self._x = x

    @y.setter
    def y(self, y):
        self._y = y

    @speed.setter
    def speed(self, speed):
        self._speed = speed

    @image.setter
    def image(self, image):
        self._image = image

class Player(GameObject, pygame.sprite.Sprite):
    """玩家"""
    def __init__(self):
        super().__init__(260, 600, 6)
        pygame.sprite.Sprite.__init__(self)
        self._image = pygame.image.load('picture/Player01.png')
        self.rect = self._image.get_rect()
        self.rect.topleft = (self._x, self._y)
        self._score = 0  # 分数

    def draw(self, screen):
        """绘制玩家"""
        screen.blit(self._image, (self.rect.left, self.rect.top))

    def update(self,dir,screen):
        """玩家移动"""
        if dir[pygame.K_d] and self.rect.left + self._speed < 520:
            self.rect.left += self._speed
        if dir[pygame.K_a] and self.rect.left + self._speed > 0:
            self.rect.left -= self._speed
        if dir[pygame.K_w] and self.rect.top > 0:
            self.rect.top -= self._speed
        if dir[pygame.K_s] and self.rect.top +self._speed < 645:
            self.rect.top += self._speed
        self.draw(screen)

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self,score):
        self._score = score

class Enemy(GameObject,pygame.sprite.Sprite):
    """敌机类"""
    def __init__(self, x, y, speed):
        super().__init__(x, y, speed)
        pygame.sprite.Sprite.__init__(self)
        self._image = pygame.image.load('picture/enemy_0.png')
        self.rect = self._image.get_rect()
        self.rect.topleft = (self._x,self._y)

    def update(self):
        self.rect.top += self._speed
        if self.rect.top > 680:
            self.kill()


class Background(GameObject):
    """背景类"""
    def __init__(self):
        super().__init__(0, 0, 2)
        bg_color1 = pygame.image.load('picture/Background.png')
        bg_color2 = pygame.image.load('picture/Background.png')
        self._image = [bg_color1, bg_color2]

    def move(self, screen):
        """背景移动"""
        self._y += self._speed
        if self._y >= 960:
            self._image = self._image[1:] + self._image[:1]
            self._y = 0
        screen.blit(self._image[0], (self._x, self._y))
        screen.blit(self._image[1], (self._x, self._y - 960))


class Bullet(GameObject,pygame.sprite.Sprite):
    """子弹类"""
    def __init__(self, x, y, image, speed, speed2=0):
        super().__init__(x, y, speed, image)
        pygame.sprite.Sprite.__init__(self)
        self._speed2 = speed2
        self.rect = self._image.get_rect()
        self.rect.topleft = (self._x, self._y)

    def update(self):
        self.rect.top -= self._speed
        self.rect.left += self._speed2
        if self.rect.top < 0 or self.rect.top > 680:
            self.kill()

主函数

首先用pygame创建窗口，窗口名，背景色，玩家对象，玩家子弹精灵组，敌机子弹精灵组，敌机精灵组，死亡敌机精灵组（因为要在死亡时产生爆炸效果），爆炸效果图片数组
创建了一个播放音乐的方法，然后用线程启动它，首先用mixer.music.load('dfj.MP3')来加载音乐文件，然后用mixer.music.play启动音乐
创建背景对象，在while循环里调用对象的move进行移动
编写方法：创建玩家子弹并移动和绘画，创建敌机子弹并移动和绘画，创建敌机并移动和绘画，绘画使用精灵的内部方法draw方法，把精灵组的全部精灵绘画到窗口上
然后在主函数判断游戏是否结束，如果没有，就获取键盘输入事件，再调用上面所创建的方法进行绘画和移动
接着检测玩家子弹与敌机是否相碰，两个精灵组相碰用的是sprite的groupcollide方法，相碰的话两者都消失，并把相碰的敌机添加到死亡敌机精灵组，再遍历敌机精灵组，绘画爆炸效果，就是五张图片连续播放出来
继续检测敌机子弹或敌机是否与玩家相撞，一个精灵与一组精灵相撞，使用sprite的spritecollideany的方法，如果相撞，gameover置为True游戏结束，游戏结束会绘画一段字体在屏幕上，按f2会重开游戏，鼠标点击窗口关闭按钮会退出游戏
代码如下：

import pygame
from threading import Thread
from random import *
import GameObject

def main():
    def creat_player_bullet(dir):
        """创建玩家子弹"""
        nonlocal count2
        count2 += 1
        if dir[pygame.K_j] and count2 % 10 == 0:
            speed = 3
            image = pygame.image.load('picture/shotw_0.png')
            bullet_player = GameObject.Bullet(player.rect.left + 14, player.rect.top, image, speed, 0)
            bullet_player_group.add(bullet_player)
        bullet_player_group.update()  # 玩家子弹移动
        bullet_player_group.draw(screen)  # 绘制玩家子弹

    def creat_enemy():
        """创建敌机"""
        if randint(1, 20) == 1:
            x = randint(20, 520)
            enemy_group.add(GameObject.Enemy(x, 0, randint(3, 5)))
        enemy_group.update()  # 敌机移动
        enemy_group.draw(screen)  # 绘制敌机

    def creat_enemy_bullet():
        """创建敌机子弹"""
        nonlocal count1
        count1 += 1
        if count1 % 50 == 0:
            for i in enemy_group:
                speed = -6
                speed2 = int((player.rect.left - i.rect.left) * 0.008571428571428572)
                image = pygame.image.load('picture/Bullet.png')
                bullet_enemy = GameObject.Bullet(i.rect.left, i.rect.top, image, speed, speed2)
                bullet_enemy_group.add(bullet_enemy)
        bullet_enemy_group.update()
        bullet_enemy_group.draw(screen)

    def resetgame():
        """重置游戏"""
        nonlocal player, bullet_enemy_group, bullet_player_group, enemy_group, gameover
        player = GameObject.Player()
        bullet_player_group = pygame.sprite.Group()
        bullet_enemy_group = pygame.sprite.Group()
        enemy_group = pygame.sprite.Group()
        pygame.display.update()
        gameover = False

    def music_play():
        """播放音乐"""
        pygame.mixer.music.load('dfj.MP3')
        pygame.mixer.music.play(loops=0, start=0.0)

    pygame.init()
    player = GameObject.Player()  # 创建玩家
    bullet_player_group = pygame.sprite.Group()  # 创建玩家子弹精灵组
    bullet_enemy_group = pygame.sprite.Group()  # 创建敌机子弹精灵组
    enemy_group = pygame.sprite.Group()  # 创建敌机精灵组
    enemy_hit_group = pygame.sprite.Group()  # 死亡敌机精灵组
    enemy_bomb_picture = []  # 爆炸效果图片数组
    for i in range(6):
        enemy_bomb_picture.append(pygame.image.load('picture/bomb_enemy_%d.png' % i))
    background = GameObject.Background()  # 创建背景
    screen = pygame.display.set_mode((540, 680))  # 创建游戏窗口
    pygame.display.set_caption('雷电')  # 窗口名
    screen.fill((230, 230, 230))  # 填充背景色
    Thread(target=music_play, daemon=True).start()
    gameover = False
    running = True
    count = count1 = count2 = 0
    while running:
        background.move(screen)  # 背景移动
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            if event.type == pygame.KEYUP:
                if event.key == pygame.K_F2:  # f2重置游戏
                    resetgame()
        if not gameover:
            dir = pygame.key.get_pressed() # 获取键盘事件
            player.update(dir,screen)  # 玩家移动并绘画
            creat_player_bullet(dir)  # 创建玩家子弹并移动和绘画
            creat_enemy()  # 创建敌机并移动和绘画
            creat_enemy_bullet()  # 创建敌机子弹
            if enemy_hit_group.add(pygame.sprite.groupcollide\
                    (enemy_group, bullet_player_group, True, True)):  # 检测玩家子弹与敌机碰撞
                player.score += 1
            if pygame.sprite.spritecollideany(player,bullet_enemy_group) \
                or pygame.sprite.spritecollideany(player, enemy_group):  # 检测玩家与敌机和敌机子弹碰撞
                gameover = True
            for enemy_hit in enemy_hit_group:  # 爆炸
                screen.blit(enemy_bomb_picture[count], enemy_hit.rect)
                # time.sleep(0.001)
                if count < 5:
                    count += 1
                else:
                    enemy_hit_group.remove(enemy_hit)
            pygame.display.flip()
        else:
            my_font1 = pygame.font.SysFont("宋体", 60)
            position1 = my_font1.render('game over', True, (255, 0, 0))
            screen.blit(position1, (200, 300))
            pygame.display.flip()

    pygame.quit()


if __name__ == '__main__':
    main()

游戏运行截图：

dfj.png

贪吃蛇

上面两个一个没动，一个连续移动，所以没用帧数控制，而贪吃蛇需要一节一节的动，就需要用帧数控制
蛇是由一个一个蛇节点对象构成，移动的时候把最后的节点删除，然后在头部新增一个头结点
吃食物使用头结点判断，然后添加在尾节点上
其他逻辑没什么想说的，直接上代码。。。

import pygame
import json
from threading import Thread
from random import *
from abc import ABCMeta, abstractclassmethod
BLACK_COLOR = (0, 0, 0)
FOOD_COLOR = (236, 189, 187)
GREEN_COLOR = (0, 255, 0)
UP = 0
RIGHT = 1
DOWN = 2
LEFT = 3


class GameObject(object, metaclass=ABCMeta):
    """游戏对象"""
    def __init__(self, x=0, y=0, color=BLACK_COLOR):
        self._x = x
        self._y = y
        self._color = color

    @abstractclassmethod
    def draw(self, screen):
        pass

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y


class Wall(GameObject):
    """围墙类"""
    def __init__(self, x, y, lenth, width, color=BLACK_COLOR):
        super().__init__(x, y, color)
        self._lenth = lenth
        self._width = width

    def draw(self, screen):
        pygame.draw.rect(screen, self._color, (self._x, self._y, self._width, self._lenth), 4)

    @property
    def lenth(self):
        return self._lenth

    @property
    def width(self):
        return self._width


class Food(GameObject):
    """食物类"""
    def __init__(self, x, y, length, color=FOOD_COLOR):
        super().__init__(x, y, color)
        self._length = length
        self._hidden = False  # 是否隐藏

    def draw(self, screen):
        if not self._hidden:
            pygame.draw.circle(screen, self._color,
                               (self._x + self._length // 2, self._y + self._length // 2),
                               self._length // 2, 0)
        self._hidden = not self._hidden


class SnakeNode(GameObject):
    """蛇身节点类"""
    def __init__(self, x, y, size, color=GREEN_COLOR):
        super().__init__(x, y, color)
        self._size = size

    def draw(self, screen):
        pygame.draw.rect(screen, self._color,
                         (self._x, self._y, self._size, self._size), 0)
        pygame.draw.rect(screen, BLACK_COLOR,
                         (self._x, self._y, self._size, self._size), 1)

    @property
    def size(self):
        return self._size


class Snake(GameObject):
    """蛇"""
    def __init__(self):
        super().__init__()
        self._dir = LEFT  # 方向
        self._nodes = []  # 身体数组
        for index in range(5):
            node = SnakeNode(290 + index * 20, 250, 20)
            self._nodes.append(node)

    def collide(self, wall):
        """撞墙"""
        head = self.head
        return head.x < wall.x or head.y < wall.y or head.x + head.size > wall.x + wall.lenth\
            or head.y + head.size > wall.y + wall.width

    def eat_food(self, food):
        """吃食物"""
        if self.head.x == food.x and self.head.y == food.y:
            tail = self._nodes[-1]
            self._nodes.append(tail)
            return True
        return False

    def eat_self(self):
        for i in range(4, len(self.nodes)):
            if self.head.x == self.nodes[i].x and self.head.y == self.nodes[i].y:
                return True
        return False

    def draw(self, screen):
        """画蛇"""
        for node in self._nodes:
            node.draw(screen)

    def move(self):
        """移动"""
        head = self.head
        snake_dir = self._dir
        x, y, size = head.x, head.y, head.size
        if snake_dir == UP:
            y -= size
        elif snake_dir == RIGHT:
            x += size
        elif snake_dir == DOWN:
            y += size
        else:
            x -= size
        new_head = SnakeNode(x, y, size)
        self._nodes.insert(0, new_head)
        self._nodes.pop()

    @property
    def dir(self):
        return self._dir

    @property
    def nodes(self):
        return self._nodes

    @property
    def head(self):
        return self._nodes[0]

    def change_dir(self, new_dir):
        if (self._dir + new_dir) % 2 != 0:
            self._dir = new_dir


def main():
    def refresh():
        """刷新游戏窗口"""
        screen.fill((242, 242, 242))
        wall.draw(screen)  # 画围墙
        food.draw(screen)  # 画食物
        snake.draw(screen)  # 画蛇
        show_info(screen, snake)
        pygame.display.flip()

    def reset_game():
        nonlocal food, snake, gameover, rank
        food = creat_food()
        snake = Snake()
        gameover = False

    def handle_key_event(key_event):
        """处理按键事件"""
        key = key_event.key
        new_dir = snake.dir
        if key == pygame.K_w or key == pygame.K_UP:
            new_dir = UP
        if key == pygame.K_d or key == pygame.K_RIGHT:
            new_dir = RIGHT
        if key == pygame.K_s or key == pygame.K_DOWN:
            new_dir = DOWN
        if key == pygame.K_a or key == pygame.K_LEFT:
            new_dir = LEFT
        if key == pygame.K_F2:
            reset_game()
            return
        if new_dir != snake.dir:
            snake.change_dir(new_dir)

    def creat_food():
        """吃食物"""
        row = randint(0, 29)
        col = randint(0, 29)
        return Food(10 + 20 * col, 10 + 20 * row, 20)

    def show_info(screen1, snake1):
        """展示分数"""
        my_font2 = pygame.font.SysFont("宋体", 30)
        position3 = my_font2.render('high score: %d' % max(rank), True, (255, 0, 0))
        screen1.blit(position3, (453, 10))
        position2 = my_font2.render('score: %d' % (len(snake1.nodes) - 5), True, (255, 0, 0))
        screen1.blit(position2, (500, 30))
        pygame.display.flip()
    try:
        with open('rank.json', 'r', encoding='utf-8') as fs:
            if len(fs.read()) == 0:
                rank = [0]  # 排行榜
            else:
                with open('rank.json', 'r', encoding='utf-8') as fs2:
                    rank = json.load(fs2)
    except IOError as e:
        print(e)
    pygame.init()
    screen = pygame.display.set_mode((620, 620))  # 创建游戏窗口
    pygame.display.set_caption('贪吃蛇')  # 窗口名
    screen.fill((242, 242, 242))  # 填充背景色
    pygame.display.flip()  # 刷新窗口
    clock = pygame.time.Clock()  # 创建计时器，控制帧数
    wall = Wall(10, 10, 600, 600)  # 围墙
    food = creat_food()  # 食物
    snake = Snake()  # 蛇
    running = True
    gameover = False
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                try:
                    with open('rank.json', 'w', encoding='utf-8') as fs:
                        json.dump(rank, fs)
                except IOError as e:
                    print(e)
                running = False
            elif event.type == pygame.KEYDOWN:
                handle_key_event(event)
            elif event.type == pygame.MOUSEBUTTONDOWN:
                pass
        if not gameover:
            Thread(target=refresh,daemon=True).start()
            snake.move()
            if snake.collide(wall) or snake.eat_self():
                gameover = True
            if snake.eat_food(food):
                food = creat_food()
            if gameover:
                rank.append(len(snake.nodes) - 5)
        else:
            my_font1 = pygame.font.SysFont("宋体", 60)
            position1 = my_font1.render('game over', True, (255, 0, 0))
            screen.blit(position1, (200, 300))
            pygame.display.flip()
        clock.tick(6)  # 6帧
    pygame.quit()


if __name__ == '__main__':
    main()

游戏运行结果：

snake.png