python学习笔记2-黑马项目实战飞机大战第一篇---游戏框架的搭建

2. 游戏框架搭建

（1） 封装文件框架

 plane_main:封装主游戏类；创建游戏对象；启动游戏

import pygame
from plane_sprites import *
class PlaneGame(object):
    """飞机大战主游戏"""
    def __init__(self):
        self.screen=pygame.display.set_mode((SCREEN_RECT.size))      # 1. 创建游戏窗口,传输的窗口大小做变量输入方便修改数据
        self.clock = pygame.time.Clock()                             # 2. 创建游戏的时钟
        self.__create_sprites()                                      # 3. 调用私有方法，精灵和精灵组的创建
    def start_game(self):
        """开始游戏"""
        print("开始游戏...")
        while True:
            self.clock.tick(60)                                     # 1. 设置刷新帧率
            self.__event_handler()                                  # 2. 事件监听
            self.__check_collide()                                  # 3. 碰撞检测
            self.__update_sprites()                                 # 4. 更新精灵组
            pygame.display.update()                                 # 5. 更新屏幕显示
    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()
"""
内置属性__name__：如果被其他文件导入时，输出的是导入模块名;如果不是是模块内部输出__main__;
利用__name__的特点可将测试代码写在main函数下，判断__name__的输出即可以知道是否执行测试代码
"""
if __name__ == '__main__':
    game = PlaneGame()      # 创建游戏对象
    game.start_game()       # 开始游戏
	plane_sprites：封装游戏中所有需要使用的精灵子类；提供游戏的相关工具
import pygame
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)			#方便数据灵活变化，以参数形式传递
class GameSprite(pygame.sprite.Sprite):
    """游戏精灵基类"""
    def __init__(self, image_name, speed=1):
        super().__init__()                              # 所有不是继承基类object的类，都应该调用父类的初始化方法
        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                       # 默认在垂直方向移动

（2） 背景图实现
注：背景图需要用两张一样的图片做一个交替轮播的效果
 在plane_main中创建背景精灵和精灵组：

def __create_sprites(self):
    # 创建背景精灵和精灵组
    bg1 = Background()
    bg2 = Background(True)
    self.back_group = pygame.sprite.Group(bg1, bg2)
def __update_sprites(self):
    self.back_group.update()
    self.back_group.draw(self.screen)
	在plane_sprites中创建游戏背景精灵
class Background(GameSprite):
    """游戏背景精灵"""
    def __init__(self, is_alt=False):
	# 1. 调用父类方法实现精灵的创建(image/rect/speed)
        super().__init__("./images/background.png")    
        if is_alt:               		# 2. 判断是否是交替图像，如果是，需要设置初始位置
            self.rect.y = -self.rect.height
    def update(self):
        super().update()                    # 1. 调用父类的方法实现
		# 2. 判断是否移出屏幕，如果移出屏幕，将图像设置到屏幕的上方
        if self.rect.y >= SCREEN_RECT.height:  

（3） 实现敌机
需要让敌机隔一段时间出现，添加定时器；
pygame.time.set_timer(参数1：基于pygame.USEREVENT来指定事件名称，参数2：事件触发间隔的毫秒值)
定义监听创建敌机的定时器事件，通过pygame.event.get()可以获取时间列表，遍历事件列表，判断事件类型event.type是否等于eventid（定时器常量），则触发监听定时器事件；
• 在 plane_sprites.py 的顶部定义 事件常量

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

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

# 4. 设置定时器事件 - 每秒创建一架敌机
pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
监听定时器事件：判断事件类型是pygame.QUIT则结束游戏，如果不被结束就继续创建敌机，调用敌机定时器事件；
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()

创建敌机精灵类，和背景类一样，继承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)
更新图像方法：判断敌机是否飞出屏幕，飞出屏幕则调用内置的kill方法将敌机精灵摧毁
def update(self):
    # 1. 调用父类方法，保持垂直方向的飞行
    super().update()
    # 2. 判断是否飞出屏幕，如果是，需要从精灵组删除敌机
    if self.rect.y >= SCREEN_RECT.height:
        # print("飞出屏幕，需要从精灵组删除...")
        # kill方法可以将精灵从所有精灵组中移出，精灵就会被自动销毁
        self.kill()

（4） 实现英雄飞机
需要重新设置父类的初始方法，但延续父类已有的，设置英雄初始位置，距离下屏幕120像素，屏幕居中，更新方法由于和父类固有的完全不同，所以不延续，重写一个让英雄飞机能够左右移动的，判断英雄的水平位置不让英雄离开屏幕，补充一个发射子弹的方法

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
发射子弹类，让子弹位置和英雄飞机一样，并且连续发射3颗子弹
    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)

（5） 实现子弹以及子弹检测
子弹的实现同样式调用父类的初始化方法，但是在更新上面需要调用kill来让子弹溢出屏幕后销毁

class Bullet(GameSprite):
    """子弹精灵"""
    def __init__(self):
        # 调用父类方法，设置子弹图片，设置初始速度
        super().__init__("./images/bullet1.png", -2)
    def update(self):
        # 调用父类方法，让子弹沿垂直方向飞行
        super().update()
        # 判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            self.kill()

pygame 提供了 两个非常方便 的方法可以实现碰撞检测：

 pygame.sprite.groupcollide()

两个精灵组 中 所有的精灵 的碰撞检测
groupcollide(group1, group2, dokill1, dokill2, collided = None) -> Sprite_dict
如果将 dokill 设置为 True，则 发生碰撞的精灵将被自动移除
collided 参数是用于 计算碰撞的回调函数
如果没有指定，则每个精灵必须有一个 rect 属性

 pygame.sprite.spritecollide()

判断 某个精灵 和 指定精灵组 中的精灵的碰撞
spritecollide(sprite, group, dokill, collided = None) -> Sprite_list
如果将 dokill 设置为 True，则 指定精灵组 中 发生碰撞的精灵将被自动移除
collided 参数是用于 计算碰撞的回调函数
如果没有指定，则每个精灵必须有一个 rect 属性
返回 精灵组 中跟 精灵 发生碰撞的 精灵列表

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