python学习第八天——超详细飞机大战程序

在跟视频编写飞机大战程序的时候，忽然对self的用法有点懵逼，经过多番思考并查看资料后，对self有如下理解：
首先要明确self永远指调用时类的实例本身，而不是类本身。在类封装的方法内部，self 就表示 前调用方法的对象自己。比如创建了一个Hero类，里面封装了许多方法，创建Hero类的实例：hero = Hero(),此时，Hero类里面封装的所有属性和方法中的self,指的都是hero这个对象。如果使用该类创建两个不同对象：

class Hero(object):
    def __init__(self,name):
        self.name = name
hero1 = Hero("英雄一号")
hero2 = Hero("英雄二号")
print(hero1.name)

输出结果为：

英雄一号

调用哪个对象时，Hero中的self就是谁。
在类的外部，通过变量名. 访问对象的属性和方法；在 类封装的方法中，通过 self. 访问对象的属性和方法
下面放上全面的、超详细的、可运行的飞机大战程序：
第一部分plase_sprites,封装游戏中所有需要使用的精灵子类提供游戏的相关工具

import random
import pygame

#定义屏幕大小常量
SCREEN_RECT = pygame.Rect(0,0,480,700)
#定义刷新帧率
FRAME_PER_SEC = 60
#创建敌机的定时器常量
"""
pygame的定时器使用套路非常固定：
定义定时器常量 —— eventid
在初始化方法中调用 set_timer方法设置定时器事件
在游戏循环中，监听定时器事件
"""
#创建敌机事件
CREATE_ENEMY_ENVENT = pygame.USEREVENT
#英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT+1
#定义一个精灵类
class GameSprite(pygame.sprite.Sprite):
    #飞机大战游戏精灵
    #初始化
    def __init__(self,image_name,speed=1):
        #调用父类初始化方法,初始化方法扩展，
        # 如果不调用父类方法，则原来父类初始化中的很多属性被覆盖
        super().__init__()
        #定义对象属性
        #要想在图像文件中加载数据，使用pygame.image.load()
        self.image = pygame.image.load(image_name)
        #rect默认大小为刚加载出来的图片大小
        #image的getrect()方法可以返回刚刚加载的图像大小
        self.rect = self.image.get_rect()
        self.speed = speed
        #重写update方法，实现不同精灵不同移动速度
    def update(self):
        self.rect.y += self.speed
class Background(GameSprite):
    """游戏背景精灵"""
    #False表示第一张图片
    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.指定敌机初始飞行随机速度
        self.speed = random.randint(1,3)
        #3.指定敌机初始飞行位置
        #bottom = y + height,bottom = 0即y = -height
        self.rect.x = random.randint(0,SCREEN_RECT.width-self.rect.width)
        self.rect.bottom = 0
    def update(self):
        #1.调用父类方法，保持垂直飞行
        super().update()
        #2.判断是否飞出屏幕，如果是，删除精灵
        if self.rect.y >= SCREEN_RECT.height:
            #使用kill可以将精灵从精灵组中销毁。
            self.kill()
           # print("飞出屏幕，需要删除敌机精灵。。。")
    def __del__(self):
        #print("敌机挂了%s"%self.rect)
        pass
class Hero(GameSprite):
    """英雄精灵"""
    def __init__(self):
        #1.调用父类方法设置Image和初始速度speed
        super().__init__("./images/me1.png",0)
        #2.设置英雄初始位置，距离屏幕底端120点的中央位置
        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
        if self.rect.right >= SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right
        elif self.rect.x <= 0:
            self.rect.x = 0

    def fire(self):
        print("发射子弹")
        for i in (0,1,2):
            #1.创建子弹精灵
            bullet = Bullet()
            #2.创建子弹位置，位于英雄正上方
            bullet.rect.bottom = self.rect.y - 20 * i
            bullet.rect.centerx = self.rect.centerx
            #3.将精灵添加到精灵组
            self.bullets.add(bullet)
class Bullet(GameSprite):
    """子弹精灵"""
    def __init__(self):
        #调用父类方法设置子弹图片和初始速度speed
        super().__init__("./images/bullet1.png",-2)

    def update(self):
        #调用父类方法让子弹沿垂直方向发射
        super().update()
        #判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            #使用kill可以将精灵从精灵组中销毁。
            self.kill()
    def __del__(self):
        print("子弹被销毁")

第二部分，plane_main，封装主游戏类、创建游戏对象、启动游戏

import pygame
from plase_sprites import *
class PlaneGame(object):
    #飞机大战主游戏
    def __init__(self):
        print("游戏初始化")
        #1.创建游戏窗口
        #取用SCREEN_RECT.size是为了返回一个set_mode需要的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        #2.创建游戏时钟
        self.clock = pygame.time.Clock()
        #3.调用私有方法完成精灵精灵组创建
        self.__create_sprites()
        #4.设置定时器事件
        pygame.time.set_timer(CREATE_ENEMY_ENVENT,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.给属性命名
        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_qollide()
            #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_ENVENT:
                #print("敌军出场。。。")
                #1.创建敌机精灵
                enemy = Enemy()
                #2.将精灵添加到精灵组中
                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("向右移动。。。")
        #使用键盘模块提供方法获取键盘按键 ，返回按键元组，为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:
            self.hero.speed = 0
    def __check_qollide(self):
        #子弹摧毁敌机
        #groupcollide(group1, group2, dokill1, dokill2, collided = None) -> Sprite_dict
        #如果将dokill设置为True，则发生碰撞的精灵将被自动移除
        pygame.sprite.groupcollide(self.hero.bullets,self.enemy_group,True,True)
        #敌机撞毁英雄
        #spritecollide(sprite, group, dokill, collided = None) -> Sprite_list
        #如果将 dokill 设置为 True，则 指定精灵组 中 发生碰撞的精灵将被自动移除
        #返回 精灵组 中跟 精灵 发生碰撞的 精灵列表
        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()