飞机大战（雷电）思路分析-跟着源码走

飞机大战（雷电）思路分析-跟着源码走

飞机大战-雷电 基础版，详细注释，带有学习过程：
飞机大战_雷电基础版

- 为了进一步改进飞机大战（雷电），我觉得先分析好原来的做法思路，再进行下一步

不多说，以下：

一、主程序plane_main.py
1、
if __name__ == "__main__":
    # 创建游戏对象
    game = PlaneGame()

    # 开始游戏
    game.start_game()

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

3、
PlaneGame类：
def __init__(self):
    """游戏初始化"""

4、
PlaneGame类：
def start_game(self):
    """开始游戏"""

5、
PlaneGame类：
def start_game(self):
    """开始游戏"""

    while True:
        # 1. 设置刷新帧率
        self.clock.tick(60)

        # 2. 事件监听
        self.__event_handler()

        # 3. 碰撞检测
        self.__check_collide()

        # 4. 更新精灵组
        self.__update_sprites()

        # 5. 更新屏幕显示
        pygame.display.update()

6、
PlaneGame类：
def __init__(self):
    """游戏初始化"""

    # 1. 创建游戏的窗口
    """
    1> Rect.size 属性会返回矩形区域的 (宽, 高) 元组
    2> set_mode(resolution=(0, 0), flags=0, depth=0)
        参数
        - resolution 指定屏幕的 宽 和 高，默认创建的窗口大小和屏幕大小一致
        - flags 参数指定屏幕的附加选项，例如是否全屏等等，默认不需要传递
        - depth 参数表示颜色的位数，默认自动匹配
    """
    self.screen = pygame.display.set_mode(SCREEN_RECT.size)
    # 2. 创建游戏时钟
    self.clock = pygame.time.Clock()
    # 3. 调用私有方法，精灵和精灵组的创建
    self.__create_sprites()
    # 4. 创建定时器事件 - 每秒创建一架敌机
    # pygame.time.set_timer(事件常量, 每隔多少毫秒触发事件)
    pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
    # 每隔 0.5 秒发射一次子弹
    pygame.time.set_timer(HERO_FIRE_EVENT, 500)

7、
根据PlaneGame类->开始游戏的函数：
def start_game(self):
    """开始游戏"""

while True:
    # 1. 设置刷新帧率
    self.clock.tick(60)

    # 2. 事件监听
    self.__event_handler()

    # 3. 碰撞检测
    self.__check_collide()

    # 4. 更新精灵组
    self.__update_sprites()

    # 5. 更新屏幕显示
    pygame.display.update()

（1）
# 1. 设置刷新帧率
self.clock.tick(60)
|
PlaneGame.__init__:
# 2. 创建游戏时钟
self.clock = pygame.time.Clock()

（2）
# 2. 事件监听
self.__event_handler()
|
def __event_handler(self):
    """事件监听"""


    # pygame中通过pygame.event.get()可以获得用户当前所做动作的事件列表
    for event in pygame.event.get():
        # 退出
        if event.type == pygame.QUIT:
            PlaneGame.__game_over()
        # 检测敌机事件增加敌机
        elif event.type == CREATE_ENEMY_EVENT:
            self.enemy_group.add(Enemy())
        # 检测英雄开火事件，检测到，就开火
        elif event.type == HERO_FIRE_EVENT:
            self.hero.fire()
    # 左右移动
    # 返回所有按键的元组，如果某个键被按下，对应的值会是1
    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:
        # else上面不可以使用多行注释，否则会找不到if和else，会报错（无效语法）
        self.hero.speed = 0

（3）
# 3. 碰撞检测
self.__check_collide()
|
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()
        #  结束游戏
        self.__game_over()

(4)
# 4. 更新精灵组
self.__update_sprites()
|
def __update_sprites(self):
    """更新精灵组"""
    #精灵组的draw方法和update方法
    for group in [self.back_group, self.enemy_group, self.hero_group, self.hero.bullets]:

        group.update()
        # group.draw(需要进行绘制的屏幕对象) --> 将图像按照坐标绘制在屏幕上
        group.draw(self.screen)

8、
根据PlaneGame类->初始化游戏的函数：
# 3. 调用私有方法，精灵和精灵组的创建
self.__create_sprites()
|
需要在PlaneGame类中写：
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)

9、由于事件监听的方法中提及退出游戏：
def __event_handler(self):
    """事件监听"""
↓
if event.type == pygame.QUIT:
    PlaneGame.__game_over()
|
@staticmethod
def __game_over():
    """游戏结束"""

    pygame.quit()
"""exit(num)，不指定时，num默认为0,参数为0表示正常退出，
参数为1表示程序遇到了某个错误而导致退出。实际运用中参数可以使用任何整型数据，
表示不同的自定义错误类型。"""
    exit()

10、最后：定义几个全局变量：
(1)定义定时器事件常量
plane_sprites.py
# 敌机的定时器事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
Plane_main.py
HERO_FIRE_EVENT = pygame.USEREVENT + 1
(2)
plane_sprites.py
# 游戏屏幕大小
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)

二、自定义模块plane_sprites.py
模块功能：定义精灵

11、定义游戏精灵基类
class GameSprite(pygame.sprite.Sprite):
    """游戏精灵基类"""

    def __init__(self, image_name, speed=1):

        # 调用父类初始化方法
        super().__init__()

        # 加载图像
        self.image = pygame.image.load(image_name)
        # 返回初始rect(0， 0， 图片宽度， 图片高度)
        self.rect = self.image.get_rect()
        # 记录速度
        self.speed = speed


    def update(self):

        # 默认在垂直方向上移动
        self.rect.y += self.speed

 - ***精灵类和精灵组的分析图片这里显示不出，我放在上面了，这代码块上面。***

11、定义各种精灵：子弹、敌机、英雄、背景

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

    def __init__(self, is_alt=False):

        image_name = "./images/background.png"
        super().__init__(image_name)

        # 判断是否交替图片，如果是，将图片设置到屏幕顶部
        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

分析：
1、update方法：更新rect
2、__init__方法：
1>继承游戏精灵基类
（1）确定图片地址
（2）确定初始rect（0， 0， 图片width， 图片height）
（3）确定速度
2> 对初始的rect进行更改

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

    def __init__(self):

        # 1. 调用父类方法，创建敌机精灵，并且指定敌机的图像
        super().__init__("./images/enemy1.png")

        # 2. 设置敌机随机初始速度
        self.speed = random.randint(1, 3)

        # 3. 设置敌机的随机初始位置
        # bottom = y + height
        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:
            # 将精灵从所在的组中删除
            self.kill()

分析：
1、update方法：更新rect，并对rect的情况进行处理（飞出屏幕就从组中删除）
2、__init__方法：
1> 继承游戏精灵基类
（4）确定图片地址
（5）确定初始rect（0， 0， 图片width， 图片height）
（6）设定初始速度
2> 对初始的rect和速度进行更改

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

    def __init__(self):

        # 1. 调用父类方法，创建英雄精灵，并且指定英雄的图像
        super().__init__("./images/me1.png", 0)

        # centerx = x + 0.5 * width, centery = y + 0.5 * height, bottom = y + height
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - 120

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


    def update(self):

        # 飞机水平移动
        self.rect.x += self.speed

        # 判断屏幕边界
        # rect.left = x, rect.top = y, rect.right = x + weight
        if self.rect.left < 0:
            self.rect.left = 0
        if self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right


    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)

分析：
1、update方法：更新rect
2、__init__方法：
1> 继承游戏精灵基类
（1）确定图片地址
（2）确定初始rect（0， 0， 图片width， 图片height）
（3）设定初始速度
2> 对初始的rect进行更改
3> 创造子弹精灵组
3、fire方法：
1> 创建子弹精灵对象
2> 设置精灵位置
3> 将精灵添加到精灵组

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

    def __init__(self):

        # 1. 调用父类方法，创建子弹精灵，并且指定子弹的图像和速度
        super().__init__("./images/bullet1.png", -2)


    def update(self):

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

        # 2. 判断是否飞出屏幕
        if self.rect.bottom < 0:
            # 将精灵从所在的组中删除
            self.kill()

总结：
1、update方法：更新rect，并且对rect进行处理（飞出去，kill）
2、__init__方法：
1> 继承游戏精灵基类
（1）确定图片地址
（2）确定初始rect（0， 0， 图片width， 图片height）
（3）设定初始速度

对于各种游戏精灵基类的子类的总结：
1、update方法：更新rect，并且对rect进行处理
2、__init__方法：
1> 继承游戏精灵基类
（1）确定图片地址
（2）确定初始rect（0， 0， 图片width， 图片height）
（3）设定初始速度
2> 改变图片的地址和初始rect以及初始速度

<END>