pygame 模块进行简单游戏开发-----飞机大战

学习目标

  • 强化 面向对象 程序设计
  • 体验使用 pygame 模块进行 游戏开发
安装 pygame
 sudo pip3 install pygame
验证安装
python3 -m pygame.examples.aliens
1.1、 游戏的初始化和退出
import pygame
pygame.init()
# 游戏代码... 
pygame.quit()
1.2、 理解游戏中的坐标系
  • 定义 hero_rect 矩形描述 英雄的位置和大小
  • 输出英雄的 坐标原点(x 和 y)
  • 输出英雄的 尺寸(宽度 和 高度)
hero_rect = pygame.Rect(100, 500, 120, 126)
print("坐标原点 %d %d" % (hero_rect.x, hero_rect.y))
print("英雄大小 %d %d" % (hero_rect.width, hero_rect.height))  
# size 属性会返回矩形区域的 (宽, 高) 元组
print("英雄大小 %d %d" % hero_rect.size)
1.3、 创建游戏主窗口
# 创建游戏主窗口
screen = pygame.display.set_mode((480, 700))
1.4、 简单的游戏循环
# 创建游戏主窗口
screen = pygame.display.set_mode((480, 700))

# 游戏循环
while True:
    pass

2、 理解 图像 并实现图像绘制

2.1、绘制背景图像
# 绘制背景图像
# 1> 加载图像
bg = pygame.image.load("./images/background.png")
# 2> 绘制在屏幕
screen.blit(bg, (0, 0))
# 3> 更新显示
pygame.display.update()
2.2、绘制英雄图像
# 1> 加载图像
hero = pygame.image.load("./images/me1.png")
# 2> 绘制在屏幕
screen.blit(hero, (200, 500))
# 3> 更新显示
pygame.display.update()

可以在 screen 对象完成 所有 blit 方法之后,统一调用一次 display.update 方法,同样可以在屏幕上 看到最终的绘制结果

案例调整
# 绘制背景图像
# 1> 加载图像
bg = pygame.image.load("./images/background.png")
# 2> 绘制在屏幕
screen.blit(bg, (0, 0))
# 绘制英雄图像
# 1> 加载图像
hero = pygame.image.load("./images/me1.png")
# 2> 绘制在屏幕
screen.blit(hero, (200, 500))
# 3> 更新显示 - update 方法会把之前所有绘制的结果,一次性更新到屏幕窗口上
pygame.display.update()

3. 创建游戏时钟对象

3.1、游戏时钟
clock = pygame.time.Clock()
i = 0
# 游戏循环
while True:
    # 设置屏幕刷新帧率
    clock.tick(60)
    print(i)
    i += 1
3.2、 英雄的简单动画实现
    # 4. 定义英雄的初始位置
    hero_rect = pygame.Rect(150, 500, 102, 126)
    while True:
            # 可以指定循环体内部的代码执行的频率
            clock.tick(60)
            # 更新英雄位置
            hero_rect.y -= 1
            # 如果移出屏幕,则将英雄的顶部移动到屏幕底部
            if hero_rect.y <= 0:
                    hero_rect.y = 700
            # 绘制背景图片
            screen.blit(bg, (0, 0))
            # 绘制英雄图像
            screen.blit(hero, hero_rect)
            # 更新显示
            pygame.display.update()
注意:
  1. 英雄向上飞行,当 英雄完全从上方飞出屏幕后
  2. 将飞机移动到屏幕的底部
if hero_rect.bottom <= 0:
    hero_rect.y = 700
3.3、 在游戏循环中 监听 事件
    # 游戏循环
    while True:
          # 设置屏幕刷新帧率
          clock.tick(60)
          #  事件监听
          for event in pygame.event.get():
                # 判断用户是否点击了关闭按钮
                if event.type == pygame.QUIT:
                      print("退出游戏...")
                      pygame.quit()
                      # 直接退出系统
                      exit()
4.1、 精灵 和 精灵组
import pygame
class GameSprite(pygame.sprite.Sprite):
 """游戏精灵基类"""
    def __init__(self, image_name, speed=1):
    # 调用父类的初始化方法
        super().__init__()
        # 加载图像
        self.image = pygame.image.load(image_name)
        # 设置尺寸
        self.rect = self.image.get_rect()
       # 记录速度
        self.speed = speed
    def update(self, *args):
        # 默认在垂直方向移动
        self.rect.y += self.speed
4.2、 使用 游戏精灵 和 精灵组 创建敌机
  1. 导入 plane_sprites 模块

     from plane_sprites import *
    
  2. 修改初始化部分代码

# 创建敌机精灵和精灵组
enemy1 = GameSprite("./images/enemy1.png")
enemy2 = GameSprite("./images/enemy1.png", 2)
enemy2.rect.x = 200
enemy_group = pygame.sprite.Group(enemy1, enemy2)
  1. 修改游戏循环部分代码
# 让敌机组调用 update 和 draw 方法
enemy_group.update()
enemy_group.draw(screen)
# 更新屏幕显示
pygame.display.update()
5.1、实现飞机大战主游戏类
import pygame
from plane_sprites import *
class PlaneGame(object):
"""飞机大战主游戏"""
    def __init__(self):
        print("游戏初始化")
    def start_game(self):
        print("开始游戏...")
if __name__ == '__main__':
    # 创建游戏对象
    game = PlaneGame()
    # 开始游戏
    game.start_game()
5.2、 游戏初始化部分
  • 完成 init() 代码如下:

      def __init__(self):
          print("游戏初始化")
          # 1. 创建游戏的窗口
          self.screen = pygame.display.set_mode((480, 700))
          # 2. 创建游戏的时钟
          self.clock = pygame.time.Clock()
          # 3. 调用私有方法,精灵和精灵组的创建
          self.__create_sprites()
      def __create_sprites(self):
          pass
    
5.3、使用 常量 代替固定的数值
  • 在 plane_sprites.py 中增加常量定义

      import pygame
      # 游戏屏幕大小
      SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
    
  • 修改 plane_main.py 中的窗口大小

     self.screen = pygame.display.set_mode(SCREEN_RECT.size)
    
5.4、 游戏循环部分
  • 完成 start_game() 基础代码如下:

      def start_game(self):
      """开始游戏"""
          print("开始游戏...")
          while True:
              # 1. 设置刷新帧率
              self.clock.tick(60)
              # 2. 事件监听
              self.__event_handler()
              # 3. 碰撞检测
              self.__check_collide()
              # 4. 更新精灵组
              self.__update_sprites()
              # 5. 更新屏幕显示
              pygame.display.update()
      def __event_handler(self):
      """事件监听"""
          for event in pygame.event.get():
              if event.type == pygame.QUIT:
                  PlaneGame.__game_over()
      def __check_collide(self):
      """碰撞检测"""
          pass
      def __update_sprites(self):
        """更新精灵组"""
          pass
    
      @staticmethod
      def __game_over(): 
      """游戏结束"""
    
           print("游戏结束")
           pygame.quit()
           exit()
    
5.5、准备游戏精灵组
  • 创建精灵组方法

      def __create_sprites(self):
       """创建精灵组"""
          # 背景组
          self.back_group = pygame.sprite.Group()
          # 敌机组
          self.enemy_group = pygame.sprite.Group()
          # 英雄组
          self.hero_group = pygame.sprite.Group()
    
  • 更新精灵组方法

     def __update_sprites(self):
     """更新精灵组"""
          for group in [self.back_group, self.enemy_group, self.hero_group]:
              group.update()
              group.draw(self.screen)
    
6.1、 背景精灵的基本实现
  • 在 plane_sprites 新建 Background 继承自 GameSprite

       class Background(GameSprite):
       """游戏背景精灵"""
          def update(self):
          # 1. 调用父类的方法实现
              super().update()
              # 2. 判断是否移出屏幕,如果移出屏幕,将图像设置到屏幕的上方
              if self.rect.y >= SCREEN_RECT.height:
                  self.rect.y = -self.rect.height
    
6.2、 在 plane_main.py 中显示背景精灵

__create_sprites 方法

def __create_sprites(self):
# 创建背景精灵和精灵组
    bg1 = Background("./images/background.png")
    bg2 = Background("./images/background.png")
    bg2.rect.y = -bg2.rect.height
    self.back_group = pygame.sprite.Group(bg1, bg2)

__update_sprites 方法

def __update_sprites(self):
    self.back_group.update()
    self.back_group.draw(self.screen)
6.3、 利用初始化方法,简化背景精灵创建

在 plane_sprites.py 中实现 Background 的 初始化方法

def __init__(self, is_alt=False):
    image_name = "./images/background.png"
    super().__init__(image_name)
    # 判断是否交替图片,如果是,将图片设置到屏幕顶部
    if is_alt:
        self.rect.y = -self.rect.height
  • 修改 plane_main 的 __create_sprites 方法

    # 创建背景精灵和精灵组
    bg1 = Background()
    bg2 = Background(True)
    self.back_group = pygame.sprite.Group(bg1, bg2)
    
7.1、敌机出场
  1. 定义事件
  • 在 plane_sprites.py 的顶部定义 事件常量

    # 敌机的定时器事件常量
    CREATE_ENEMY_EVENT = pygame.USEREVENT
    
  • 在 PlaneGame 的 初始化方法 中 创建用户事件

    # 4. 设置定时器事件 - 每秒创建一架敌机
    pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
    
  1. 监听定时器事件
  • 在 __event_handler 方法中增加以下代码:

    def __event_handler(self):
       for event in pygame.event.get():
           # 判断是否退出游戏
           if event.type == pygame.QUIT:
               PlaneGame.__game_over()
               elif event.type == CREATE_ENEMY_EVENT:
               print("敌机出场...")
    
7.2、设计 Enemy 类
class Enemy(GameSprite):
"""敌机精灵"""
    def __init__(self):
        # 1. 调用父类方法,创建敌机精灵,并且指定敌机的图像
        super().__init__("./images/enemy1.png")
        # 2. 设置敌机的随机初始速度
        # 3. 设置敌机的随机初始位置
    def update(self):
        # 1. 调用父类方法,让敌机在垂直方向运动
        super().update()
        # 2. 判断是否飞出屏幕,如果是,需要将敌机从精灵组删除
        if self.rect.y >= SCREEN_RECT.height:
            print("敌机飞出屏幕...")
7.3、创建敌机
  • 修改 plane_main 的 __create_sprites 方法

    # 敌机组
    self.enemy_group = pygame.sprite.Group()
    
  • 修改 plane_main 的 __update_sprites 方法

    self.enemy_group.update()
    self.enemy_group.draw(self.screen)
    
  • 定时出现敌机

    elif event.type == CREATE_ENEMY_EVENT:
    self.enemy_group.add(Enemy())
    
  • 修改 plane_sprites.py 增加 random 的导入

     import random
    
7.4、随机速度
  def __init__(self):
      # 1. 调用父类方法,创建敌机精灵,并且指定敌机的图像
      super().__init__("./images/enemy1.png")
      # 2. 设置敌机的随机初始速度 1 ~ 3
      self.speed = random.randint(1, 3)
      # 3. 设置敌机的随机初始位置
      self.rect.bottom = 0
      max_x = SCREEN_RECT.width - self.rect.width
      self.rect.x = random.randint(0, max_x)
7.5、移出屏幕销毁敌机
def update(self):
    super().update()
    # 判断敌机是否移出屏幕
    if self.rect.y >= SCREEN_RECT.height:
        # 将精灵从所有组中删除
        self.kill()
8.1、准备英雄类
class Hero(GameSprite):
"""英雄精灵"""
    def __init__(self):
        super().__init__("./images/me1.png", 0)
        # 设置初始位置
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - 120
8.2、 绘制英雄
  • 修改 __create_sprites 方法如下:

    # 英雄组
    self.hero = Hero()
    self.hero_group = pygame.sprite.Group(self.hero)
    
  • 修改 __update_sprites 方法如下:

    self.hero_group.update()
    self.hero_group.draw(self.screen)
    
8.3、移动英雄位置
 # 返回所有按键的元组,如果某个键被按下,对应的值会是1
 keys_pressed = pygame.key.get_pressed()
 # 判断是否按下了方向键
 if keys_pressed[pygame.K_RIGHT]:
     print("向右移动...")
  • 在 Hero 类,重写 update() 方法,根据速度水平移动 英雄的飞机

    def update(self):
    # 飞机水平移动
    self.rect.x += self.speed
    
  • 调整键盘按键代码

    # 获取用户按键
    keys_pressed = pygame.key.get_pressed()
    if keys_pressed[pygame.K_RIGHT]:
        self.hero.speed = 2
    elif keys_pressed[pygame.K_LEFT]:
        self.hero.speed = -2
    else:
        self.hero.speed = 0
    
8.4、控制英雄运动边界
 def update(self):
     # 飞机水平移动
     self.rect.x += self.speed
     # 判断屏幕边界
     if self.rect.left < 0:
         self.rect.left = 0
     if self.rect.right > SCREEN_RECT.right:
         self.rect.right = SCREEN_RECT.right
9.1、发射子弹
  • 在 Hero 中定义 fire 方法

    def fire(self):
    print("发射子弹...")
    
  • 在 plane_main.py 的顶部定义 发射子弹 事件常量

    # 英雄发射子弹事件
    HERO_FIRE_EVENT = pygame.USEREVENT + 1
    
  • init 方法末尾中添加 发射子弹 事件

    # 每隔 0.5 秒发射一次子弹
    pygame.time.set_timer(HERO_FIRE_EVENT, 500)
    
  • 在 __event_handler 方法中让英雄发射子弹

    elif event.type == HERO_FIRE_EVENT:
        self.hero.fire()
    
9.2、定义子弹类
class Bullet(GameSprite):
   """子弹精灵"""
    def __init__(self):
        super().__init__("./images/bullet1.png", -2)
    def update(self):
        super().update()
        # 判断是否超出屏幕,如果是,从精灵组删除
        if self.rect.bottom < 0:
            self.kill()
9.3、发射子弹
  • 初始化方法

    # 创建子弹的精灵组
    self.bullets = pygame.sprite.Group()
    
  • 修改 fire() 方法

    def fire(self):
        # 1. 创建子弹精灵
        bullet = Bullet()
        # 2. 设置精灵的位置
        bullet.rect.bottom = self.rect.y - 20
        bullet.rect.centerx = self.rect.centerx
        # 3. 将精灵添加到精灵组
        self.bullets.add(bullet)
    

10、碰撞实现

  def __check_collide(self):
      # 1. 子弹摧毁敌机
      pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)
      # 2. 敌机撞毁英雄
      enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)
      # 判断列表时候有内容
      if len(enemies) > 0:
          # 让英雄牺牲
         self.hero.kill()
         # 结束游戏
         PlaneGame.__game_over()

游戏界面效果:

推荐阅读更多精彩内容