飞越天际：Python与面向对象思维的完美邂逅

于 2024-08-08 17:46:32 发布
阅读量691 收藏 20
点赞数 14
文章标签： python pygame 开发语言 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56146092/article/details/141031038
版权

小项目实战 —— 飞机大战

目标

  • 强化 面向对象 程序设计
  • 体验使用 pygame 模块进行 游戏开发
  • 官方网站：https://www.pygame.org/
    安装 pygame

$ sudo pip3 install pygame

验证安装

$ python3 -m pygame.examples.aliens

游戏框架搭建

目标 —— 使用 面相对象 设计 飞机大战游戏类

目标

  • 明确主程序职责
  • 实现主程序类
  • 准备游戏精灵组
  1. 明确主程序职责
  • 回顾 快速入门案例，一个游戏主程序的 职责 可以分为两个部分：
    • 游戏初始化
    • 游戏循环
  • 根据明确的职责，核心设计 PlaneGame 类如下：
    请添加图片描述请添加图片描述

实现飞机大战主游戏类

2.1 明确文件职责

请添加图片描述

  • plane_main.py
    1. 封装 主游戏类
    2. 创建 游戏对象
    3. 启动游戏
  • plane_sprites.py
    • 封装游戏中 所有 需要使用的 精灵子类
    • 提供游戏的 相关工具

何为精灵以及精灵组的概念:

在Pygame中，Sprite类和Group类是游戏开发中非常重要的概念，它们帮助开发者有效地管理和渲染大量的游戏对象，同时简化了碰撞检测等复杂任务。

Sprite（精灵）子类

Sprite是pygame.sprite模块中的一个基础类，它定义了一个游戏实体应该具备的基本行为和属性。然而，这个类本身并不具备任何具体的图形或逻辑，它只是一个抽象的基础框架。为了在游戏中创建具体的对象，比如游戏角色、敌人、道具等，你需要创建Sprite的子类。

创建精灵子类

创建Sprite的子类涉及以下步骤：

  1. 定义子类：从Sprite类继承，创建一个新的类。
  2. 初始化方法：重写__init__方法，在其中加载精灵的图像，设置初始位置等。
  3. 更新方法：可以定义update方法来更新精灵的位置或其他状态，这通常在游戏的主循环中被调用。
  4. 其他方法：根据需要，你还可以定义更多的方法来控制精灵的行为，如攻击、跳跃等。

例如：

import pygame

class MySprite(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.image.load("my_sprite_image.png")
        self.rect = self.image.get_rect()
        self.rect.x = 0
        self.rect.y = 0

    def update(self):
        # 在这里编写更新精灵状态的代码
        pass

Group（精灵组）

Group类是一个容器，用来存储和管理多个Sprite实例。它提供了一种高效的方式来处理大量的游戏对象，比如一群敌人、子弹、爆炸效果等。

使用精灵组

使用Group的主要好处包括：

  1. 批量操作：可以对组内的所有精灵执行批量操作，如更新状态、绘制到屏幕、碰撞检测等。
  2. 性能优化：使用精灵组可以避免不必要的计算，如只对可能相交的精灵进行碰撞检测。
  3. 简化代码：通过精灵组，可以减少代码量，使游戏逻辑更清晰。

创建和使用Group的基本步骤如下：

  1. 创建精灵组：使用pygame.sprite.Group()创建一个新的精灵组。
  2. 添加精灵：使用add方法将精灵添加到组中。
  3. 更新精灵：调用update方法来更新组内所有精灵的状态。
  4. 绘制精灵：调用draw方法将所有精灵绘制到屏幕上。
  5. 碰撞检测：使用spritecollide、groupcollide等方法进行精灵间的碰撞检测。

例如：

# 创建精灵组
all_sprites = pygame.sprite.Group()

# 创建精灵实例
player = MySprite()

# 添加精灵到组
all_sprites.add(player)

# 游戏主循环中
all_sprites.update()
all_sprites.draw(screen)

通过结合使用Sprite子类和Group，你可以构建出复杂而高效的游戏场景，同时保持代码的整洁和模块化。

代码实现

  • 新建 plane_main.py 文件，并且设置为可执行
  • 编写 基础代码
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()

游戏初始化部分

  • 完成 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

使用 常量 代替固定的数值

  • 常量 —— 不变化的量
  • 变量 —— 可以变化的量

应用场景

  • 在开发时，可能会需要使用 固定的数值，例如 屏幕的高度 是 700
  • 这个时候，建议 不要 直接使用固定数值，而应该使用 常量
  • 在开发时，为了保证代码的可维护性，尽量不要使用 魔法数字

常量的定义

  • 定义 常量 和 定义 变量 的语法完全一样，都是使用 赋值语句
  • 常量 的 命名 应该 所有字母都使用大写，单词与单词之间使用下划线连接

常量的好处

  • 阅读代码时，通过 常量名 见名之意，不需要猜测数字的含义
  • 如果需要 调整值，只需要 修改常量定义 就可以实现 统一修改

提示：Python 中并没有真正意义的常量，只是通过命名的约定 —— 所有字母都是大写的就是常量，开发时不要轻易的修改！

代码调整

  • 在 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)

游戏循环部分（主体部分）

  • 完成 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()

准备游戏精灵组（也就是客体所需要的抽象的对象）请添加图片描述代码实现

  • 创建精灵组方法
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)

首先是游戏背景

  • 背景交替滚动的思路确定
  • 显示游戏背景
  1. 背景交替滚动的思路确定
  • 游戏启动后，背景图像 会 连续不断地 向下方 移动
  • 在 视觉上 产生英雄的飞机不断向上方飞行的 错觉 —— 在很多跑酷类游戏中常用的套路
    • 游戏的背景 不断变化
    • 游戏的主角 位置保持不变

实现思路分析

解决办法

  1. 创建两张背景图像精灵
    • 第 1 张 完全和屏幕重合
    • 第 2 张在 屏幕的正上方
  2. 两张图像 一起向下方运动
    • self.rect.y += self.speed
  3. 当 任意背景精灵 的 rect.y >= 屏幕的高度 说明已经 移动到屏幕下方
  4. 将 移动到屏幕下方的这张图像 设置到 屏幕的正上方
    • rect.y = -rect.height

1.2 设计背景类

  • 初始化方法
    • 直接指定 背景图片
    • is_alt 判断是否是另一张图像
      • False 表示 第一张图像，需要与屏幕重合
      • True 表示 另一张图像，在屏幕的正上方
  • update() 方法
    • 判断 是否移动出屏幕，如果是，将图像设置到 屏幕的正上方，从而实现 交替滚动

继承 如果父类提供的方法，不能满足子类的需求：

  • 派生一个子类
  • 在子类中针对特有的需求，重写父类方法，并且进行扩展

显示游戏背景

背景精灵的基本实现

  • 在 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

在 plane_main.py 中显示背景精灵

  1. 在 __create_sprites 方法中创建 精灵 和 精灵组
  2. 在 __update_sprites 方法中，让 精灵组 调用 update() 和 draw() 方法

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

其次是英雄登场

  • 设计 英雄 和 子弹 类
  • 使用 pygame.key.get_pressed() 移动英雄
  • 发射子弹
  1. 设计 英雄 和 子弹 类

英雄需求

  1. 游戏启动后，英雄 出现在屏幕的 水平中间 位置，距离 屏幕底部 120 像素
  2. 英雄 每隔 0.5 秒发射一次子弹，每次 连发三枚子弹
  3. 英雄 默认不会移动，需要通过 左/右 方向键，控制 英雄 在水平方向移动
    请添加图片描述

子弹需求

  1. 子弹 从 英雄 的正上方发射 沿直线 向 上方 飞行
  2. 飞出屏幕后，需要从 精灵组 中删除

请添加图片描述

Hero —— 英雄

  • 初始化方法
    • 指定 英雄图片
    • 初始速度 = 0 —— 英雄默认静止不动
    • 定义 bullets 子弹精灵组 保存子弹精灵
  • 重写 update() 方法
    • 英雄需要 水平移动
    • 并且需要保证不能 移出屏幕
  • 增加 bullets 属性，记录所有 子弹精灵
  • 增加 fire 方法，用于发射子弹

Bullet —— 子弹

  • 初始化方法
    • 指定 子弹图片
    • 初始速度 = -2 —— 子弹需要向上方飞行
  • 重写 update() 方法
    • 判断 是否飞出屏幕，如果是，从 精灵组 删除
  1. 创建英雄

2.1 准备英雄类

  • 在 plane_sprites 新建 Hero 类

  • 重写 初始化方法，直接指定 图片名称，并且将初始速度设置为 0

  • 设置 英雄的初始位置

  • centerx = x + 0.5 * width

  • centery = y + 0.5 * height

  • bottom = y + height

请添加图片描述

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

2.2 绘制英雄

  1. 在 __create_sprites，添加 英雄精灵 和 英雄精灵组
    • 后续要针对 英雄 做 碰撞检测 以及 发射子弹
    • 所以 英雄 需要 单独定义成属性
  2. 在 __update_sprites，让 英雄精灵组 调用 update 和 draw 方法

代码实现

  • 修改 __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)
  1. 移动英雄位置

在 pygame 中针对 键盘按键的捕获，有 两种 方式

  • 第一种方式 判断 event.type == pygame.KEYDOWN
  • 第二种方式
    1. 首先使用 pygame.key.get_pressed() 返回 所有按键元组
    2. 通过 键盘常量，判断元组中 某一个键是否被按下 —— 如果被按下，对应数值为 1

提问 这两种方式之间有什么区别呢？

  • 第一种方式
elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
    print("向右移动...")

  • 第二种方式

    返回所有按键的元组，如果某个键被按下，对应的值会是1

    keys_pressed = pygame.key.get_pressed()

    判断是否按下了方向键

    if keys_pressed[pygame.K_RIGHT]:
    print(“向右移动…”)

结论

  • 第一种方式 event.type 用户 必须要抬起按键 才算一次 按键事件，操作灵活性会大打折扣
  • 第二种方式 用户可以按住方向键不放，就能够实现持续向某一个方向移动了，操作灵活性更好

3.1 移动英雄位置

演练步骤

  1. 在 Hero 类中重写 update 方法
    • 用 速度 speed 和 英雄 rect.x 进行叠加
    • 不需要调用父类方法 —— 父类方法只是实现了单纯的垂直运动
  2. 在 __event_handler 方法中根据 左右方向键 设置英雄的 速度
    • 向右 => speed = 2
    • 向左 => speed = -2
    • 其他 => speed = 0

代码演练

  • 在 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

3.2 控制英雄运动边界

  • 在 Hero 类的 update() 方法判断 英雄 是否超出 屏幕边界

  • right = x + width 利用 right 属性可以非常容易的针对右侧设置精灵位置

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
  1. 发射子弹

需求回顾 —— 英雄需求

  1. 游戏启动后，英雄 出现在屏幕的 水平中间 位置，距离 屏幕底部 120 像素
  2. 英雄 每隔 0.5 秒发射一次子弹，每次 连发三枚子弹
  3. 英雄 默认不会移动，需要通过 左/右 方向键，控制 英雄 在水平方向移动

4.1 添加发射子弹事件

pygame 的 定时器 使用套路非常固定：

  1. 定义 定时器常量 —— eventid
  2. 在 初始化方法 中，调用 set_timer 方法 设置定时器事件
  3. 在 游戏循环 中，监听定时器事件

代码实现

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

4.2 定义子弹类

需求回顾 —— 子弹需求

  1. 子弹 从 英雄 的正上方发射 沿直线 向 上方 飞行
  2. 飞出屏幕后，需要从 精灵组 中删除

Bullet —— 子弹

  • 初始化方法
    • 指定 子弹图片
    • 初始速度 = -2 —— 子弹需要向上方飞行
  • 重写 update() 方法
    • 判断 是否飞出屏幕，如果是，从 精灵组 删除

定义子弹类

  • 在 plane_sprites 新建 Bullet 继承自 GameSprite

  • 重写 初始化方法，直接指定 图片名称，并且设置 初始速度

  • 重写 update() 方法，判断子弹 飞出屏幕从精灵组删除

    class Bullet(GameSprite):

"""子弹精灵"""

def __init__(self):
    
    super().__init__("./images/bullet1.png", -2)
 
def update(self):

    super().update()
    
    # 判断是否超出屏幕，如果是，从精灵组删除
    if self.rect.bottom < 0:
        self.kill()

4.3 发射子弹

演练步骤

  1. 在 Hero 的 初始化方法 中创建 子弹精灵组 属性
  2. 修改 plane_main.py 的 __update_sprites 方法，让 子弹精灵组 调用 update 和 draw 方法
  3. 实现 fire() 方法
    • 创建子弹精灵
    • 设置初始位置 —— 在 英雄的正上方
    • 将 子弹 添加到精灵组

代码实现

  • 初始化方法

    创建子弹的精灵组

    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)

一次发射三枚子弹

请添加图片描述

  • 修改 fire() 方法，一次发射三枚子弹
def fire(self):

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

最后即是敌机出场

  • 使用 定时器 添加敌机==》因为每隔一个时间间隔出现敌机
  • 设计 Enemy 类
  1. 使用定时器添加敌机

思路

  1. 游戏启动后，每隔 1 秒 会 出现一架敌机
  2. 每架敌机 向屏幕下方飞行，飞行 速度各不相同
  3. 每架敌机出现的 水平位置 也不尽相同
  4. 当敌机 从屏幕下方飞出，不会再飞回到屏幕中
  • 在 pygame 中可以使用 pygame.time.set_timer() 来添加 定时器
  • 所谓 定时器，就是 每隔一段时间，去 执行一些动作

定时器事件的监听

  • 通过 pygame.event.get() 可以获取当前时刻所有的 事件列表
  • 遍历列表 并且判断 event.type 是否等于 eventid，如果相等，表示 定时器事件 发生

定义并监听创建敌机的定时器事件

pygame 的 定时器 使用套路非常固定：

  1. 定义 定时器常量 —— eventid
  2. 在 初始化方法 中，调用 set_timer 方法 设置定时器事件
  3. 在 游戏循环 中，监听定时器事件
  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("敌机出场...")
  1. 设计 Enemy 类
  2. 游戏启动后，每隔 1 秒 会 出现一架敌机
  3. 每架敌机 向屏幕下方飞行，飞行 速度各不相同
  4. 每架敌机出现的 水平位置 也不尽相同
  5. 当敌机 从屏幕下方飞出，不会再飞回到屏幕中
  • 初始化方法
    • 指定 敌机图片
    • 随机 敌机的 初始位置 和 初始速度
  • 重写 update() 方法
    • 判断 是否飞出屏幕，如果是，从 精灵组 删除

2.1 敌机类的准备

  • 在 plane_sprites 新建 Enemy 继承自 GameSprite
  • 重写 初始化方法，直接指定 图片名称
  • 暂时 不实现 随机速度 和 随机位置 的指定
  • 重写 update 方法，判断是否飞出屏幕
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("敌机飞出屏幕...")

创建敌机

演练步骤

  1. 在 __create_sprites，添加 敌机精灵组
    • 敌机是 定时被创建的，因此在初始化方法中，不需要创建敌机
  2. 在 __event_handler，创建敌机，并且 添加到精灵组
    • 调用 精灵组 的 add 方法可以 向精灵组添加精灵
  3. 在 __update_sprites，让 敌机精灵组 调用 update 和 draw 方法
  • 修改 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())

设置随机敌机位置与速度

请添加图片描述

`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)`
  • 断敌机是否飞出屏幕，如果是，调用 kill() 方法从所有组中删除
def update(self):
    super().update()
    
    # 判断敌机是否移出屏幕
    if self.rect.y >= SCREEN_RECT.height:
        # 将精灵从所有组中删除
        self.kill()

完整代码与数据：

giteee地址

import pygame
from plane_sprites import *


class PlaneGame(object):
    """飞机大战主游戏"""

    def __init__(self):
        print("游戏初始化")

        # 1. 创建游戏的窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2. 创建游戏的时钟
        self.clock = pygame.time.Clock()
        # 3. 调用私有方法，精灵和精灵组的创建
        self.__create_sprites()

        # 4. 设置定时器事件 - 创建敌机　1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
        pygame.time.set_timer(HERO_FIRE_EVENT, 500)

    def __create_sprites(self):

        # 创建背景精灵和精灵组
        bg1 = Background()
        bg2 = Background(True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        # 创建敌机的精灵组
        self.enemy_group = pygame.sprite.Group()

        # 创建英雄的精灵和精灵组
        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):
        print("游戏开始...")

        while True:
            # 1. 设置刷新帧率
            self.clock.tick(FRAME_PER_SEC)
            # 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()
            elif event.type == CREATE_ENEMY_EVENT:
                # print("敌机出场...")
                # 创建敌机精灵
                enemy = Enemy()

                # 将敌机精灵添加到敌机精灵组
                self.enemy_group.add(enemy)
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()
            # elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
            #     print("向右移动...")

        # 使用键盘提供的方法获取键盘按键 - 按键元组
        keys_pressed = pygame.key.get_pressed()
        # 判断元组中对应的按键索引值 1
        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

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

    def __update_sprites(self):

        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    @staticmethod
    def __game_over():
        print("游戏结束")

        pygame.quit()
        exit()

if __name__ == '__main__':

    # 创建游戏对象
    game = PlaneGame()

    # 启动游戏
    game.start_game()


import random
import pygame

# 屏幕大小的常量
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
# 刷新的帧率
FRAME_PER_SEC = 60
# 创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1


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):

        # 在屏幕的垂直方向上移动
        self.rect.y += self.speed


class Background(GameSprite):
    """游戏背景精灵"""

    def __init__(self, is_alt=False):

        # 1. 调用父类方法实现精灵的创建(image/rect/speed)
        super().__init__("./images/background.png")

        # 2. 判断是否是交替图像，如果是，需要设置初始位置
        if is_alt:
            self.rect.y = -self.rect.height

    def update(self):

        # 1. 调用父类的方法实现
        super().update()

        # 2. 判断是否移出屏幕，如果移出屏幕，将图像设置到屏幕的上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height


class Enemy(GameSprite):
    """敌机精灵"""

    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)

    def update(self):

        # 1. 调用父类方法，保持垂直方向的飞行
        super().update()

        # 2. 判断是否飞出屏幕，如果是，需要从精灵组删除敌机
        if self.rect.y >= SCREEN_RECT.height:
            # print("飞出屏幕，需要从精灵组删除...")
            # kill方法可以将精灵从所有精灵组中移出，精灵就会被自动销毁
            self.kill()

    def __del__(self):
        # print("敌机挂了 %s" % self.rect)
        pass


class Hero(GameSprite):
    """英雄精灵"""

    def __init__(self):

        # 1. 调用父类方法，设置image&speed
        super().__init__("./images/me1.png", 0)

        # 2. 设置英雄的初始位置
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - 120

        # 3. 创建子弹的精灵组
        self.bullets = pygame.sprite.Group()

    def update(self):

        # 英雄在水平方向移动
        self.rect.x += self.speed

        # 控制英雄不能离开屏幕
        if self.rect.x < 0:
            self.rect.x = 0
        elif self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right

    def fire(self):
        print("发射子弹...")

        for i in (0, 1, 2):
            # 1. 创建子弹精灵
            bullet = Bullet()

            # 2. 设置精灵的位置
            bullet.rect.bottom = self.rect.y - i * 20
            bullet.rect.centerx = self.rect.centerx

            # 3. 将精灵添加到精灵组
            self.bullets.add(bullet)


class Bullet(GameSprite):
    """子弹精灵"""

    def __init__(self):

        # 调用父类方法，设置子弹图片，设置初始速度
        super().__init__("./images/bullet1.png", -2)

    def update(self):

        # 调用父类方法，让子弹沿垂直方向飞行
        super().update()

        # 判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        print("子弹被销毁...")
百年孤独_
关注
24.面向对象六大原则
杨充
06-03 308
00.面向对象六大原则01.代码单一职责原则02.代码开放封闭原则03.代码里氏替换原则04.代码依赖倒置原则05.代码接口隔离原则06.代码迪米特原则单一职责原则的英文名称是Single Responsibility Principle，简称SRP。它的定义是：就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。就像《设计模式之禅》中说的：“这是一个备受争议却又及其重要的原则。
python 飞机大战
03-24
这是python入门小教程，串联python知识，祝大家好运
Python——飞机大战（day10）
清园暖歌的博客
07-03 1688
目录面向过程实现：plane pro需求的描述：存在四个对象： 我方飞机、敌方飞机、我方子弹、敌方子弹 功能:背景音乐的添加我方飞机可以移动【根据按键来控制的】 敌方飞机也可以移动【随机的自动移动】双方飞机都可以发送子弹步骤: 1.创建一个窗口 2.创建一个我方飞机 根据方向键左右的移动 3.给我方飞机添加发射子弹的功能【按下空格键去发送】 4.创建一个敌人飞机 5.敌人飞机可以自由的移动 6.敌人飞机可以自动的发射子弹在安装pygame模块的时候尤其要注意一下：如果在pychram中安装不成功 如下错误
hamilton-circuits:Python中最近的邻居和回溯算法以查找汉密尔顿电路
04-21
最近的邻居和回溯Python实现 最接近邻居和回溯算法的python实现，以便找到权重最小的汉密尔顿电路。 该代码和报告是作为2018年Spring离散数学课程的一部分编写的。其概念是飞越Jupyter的7颗卫星，然后返回家中。 :...
pysattracker:用于计算卫星飞越的方位角、仰角、多普勒频移等的 Python 库
07-04
用于计算卫星飞越的方位角、仰角、多普勒频移等的 Python 库。 #dependencies sudo pip install pyephem #install 没有可用的特殊库安装。 只需将其克隆到您的项目目录中即可。 git clone ...
控制台面向对象飞行棋
09-12
《C#控制台——面向对象实现的飞行棋游戏》 在计算机编程领域，面向对象编程（Object-Oriented Programming，OOP）是一种重要的编程范式，它基于“对象”的概念，将数据和处理数据的方法封装在一起，使得代码更加...
一日一技：用Python做游戏有多简单 （2）
m0_59485658的博客
07-16 6432
现在用Python来制作游戏越来越方便，虽然某些方面有所限制。但是利用Pygame工具包基本能制作所有的2D游戏在制作的同时对游戏的理解也会更加深刻，因为本质上都是对图片的定位和图片碰撞的判断，从而以此为原理衍生出各种各样的游戏类型。...
python飞机大战
03-24
一个简单的小游戏,python初级的一个总结性案例
python编写的飞机大战，供初学者做实验用。
06-06
可以供初学python的同学使用，提供了源码和图片，可直接运行。前提安装上了pygame。里面有三个模块，飞机，子弹，主文件。
Python 飞机大战
Aron的专栏
09-26 897
Python飞机大战小练习 完整源码请参考（内含所有游戏素材和源码）：https://github.com/Aron-X/plane_game.git
Python飞机大战
struct{SB}
12-21 1598
图片素材：https://pan.baidu.com/s/1pMM0beb plane_sprites.py import random import pygame # 屏幕大小的常量 SCREEN_RECT = pygame.Rect(0, 0, 480, 700) # 刷新的帧率 FRAME_PER_SEC = 60 # 创建敌机的定时器常量 CREATE_ENEMY_EVENT = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值