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

2018-05-13 本文已影响0人 zxx_emmm

学习目标

强化面向对象程序设计
体验使用 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()

注意：

英雄向上飞行，当英雄完全从上方飞出屏幕后
将飞机移动到屏幕的底部

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、使用游戏精灵和精灵组创建敌机

导入 plane_sprites 模块
```
 from plane_sprites import *
```
修改初始化部分代码

# 创建敌机精灵和精灵组
enemy1 = GameSprite("./images/enemy1.png")
enemy2 = GameSprite("./images/enemy1.png", 2)
enemy2.rect.x = 200
enemy_group = pygame.sprite.Group(enemy1, enemy2)

修改游戏循环部分代码

# 让敌机组调用 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、敌机出场

定义事件

在 plane_sprites.py 的顶部定义事件常量

# 敌机的定时器事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

在 PlaneGame 的初始化方法中创建用户事件

# 4. 设置定时器事件 - 每秒创建一架敌机
pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)

监听定时器事件

在 __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()

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

学习目标

安装 pygame

验证安装

1.1、 游戏的初始化和退出

1.2、 理解游戏中的坐标系

1.3、 创建游戏主窗口

1.4、 简单的游戏循环

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