python中飞机相撞不爆炸是为什么 如何简述python飞机大战

飞机大战（python）

• 项目目标
• 项目流程

• 主程序
• 精灵组
• 基本事件函数
• 奖励机制

• 总结

项目目标

重点如下：1.熟练掌握对类的使用（比如，在pygame中主要分成两种类别：
英雄类，精灵类）
2.对调用的模块pygame具有一定了解

最基本的创建思路可以划分成两个模块：
一个封装基本的操作，调用主程序
另一个存储基本精灵类

项目流程

主程序

首先介绍主程序
基本事件的定义
我们导入精灵组模块plane2的所有内容
初始化pygame

from plane2 import *
pygame.init()

class PlaneGame(object):
    """飞机大战"""
    def __init__(self):
        print("游戏初始化")
        #1.游戏窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        #加上size属性 就是一个元组
        #定义常量 通过 大写字母赋值
        
        #2.创建游戏时钟
        self.clock = pygame.time.Clock()
        
        #3.调用私有方法，创建精灵组
        self.__create_sprites()
        
        #4.创建定时器事件，创建敌机
        pygame.time.set_timer(CREATE_ENEMY_EVENT, 100)
        pygame.time.set_timer(HERO_FIRE_EVENT, 50)

精灵组

在最开始的时候，我们定义初始函数，写入基本属性，定义以下方法：
游戏窗口，游戏时钟，精灵组和定时器事件
首先创建一个Σ(っ °Д °;)っ背景精灵组
我们定义两张图片，令它们上下拼接，以定义的speed滑动，就可以实现飞机的视觉移动。

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)

基本事件函数

设定一个游戏基本事件函数

• 实现以下功能
  刷新帧率， 事件监听， 碰撞检测， 更新绘制精灵组， 更新显示
  a.对于所谓的帧率，其实就是简单的图像覆盖，我们设置60帧，也就是说这些图片以60张每秒的speed映入我们的眼中，达到了连环画的效果。
  b.子弹和敌机接触导致敌机毁灭，就需要定义一个碰撞检测，pygame中定义了一个事件监听，可以读取到使用者的指令信息

def start_game(self):
        print("游戏开始...")
        
        while True:
            #刷新帧率， 事件监听， 碰撞检测， 更新绘制精灵组， 更新显示 
            self.clock.tick(FRAME_PRE_SEC)
            
            self.__event_handler()
            
            self.__check_collide()
            
            self.__update_sprites()
            
            pygame.display.update()

            pass
            
    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("敌机 appering")
                #创建敌机精灵
                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()
            #判断元组中对应的按键索引值
            if keys_pressed[pygame.K_d]:
                self.hero.speed = 10
            elif keys_pressed[pygame.K_a]:
                self.hero.speed = -10    
            else:
                self.hero.speed = 0
                
            if keys_pressed[pygame.K_s]:
                self.hero.speed2 = 10
            elif keys_pressed[pygame.K_w]:
                self.hero.speed2 = -10
            else:
                self.hero.speed2 = 0
                
        #通过调用类名来调用静态方法

奖励机制

其实在这里可以更新一个新的内容，叫做奖励机制，我们设定一个新的道具精灵组，如果发生碰撞，可以触发新的事件，这是后续需要更新的。

def __check_collide(self):
        
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)
        
        #judage if context in list
        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)
# import sys
# btn3 = Button(root, text='退出', command=sys.exit)
    @staticmethod #静态方法修饰器 
    def __game_over():
        #静态方法 不需要对象属性或者类的属性
        print("游戏结束")
        
        pygame.quit()
        exit()

if __name__ == '__main__':
    #创建游戏对象
    game = PlaneGame()
    game.start_game()
    #启动游戏

接下来是精灵组模块：``

class GameSprite(pygame.sprite.Sprite):
    def __init__(self, image_name, speed=2):
    
        #调用父类的初始化方法 
        super().__init__()
        #属性
        self.image = pygame.image.load(image_name)
        self.rect = self.image.get_rect()
        #get_rect()默认返回(0, 0, 长, 宽) 
        self.speed = speed
        
    def update(self):
        #屏幕的垂直方向移动
        self.rect.y += self.speed

class Background(GameSprite):
    
    def __init__(self, is_alt=False):
        #父类方法实现精灵的创建
        #判断是否是交替图像
        super().__init__("./images/space star.jpg")
        
        if is_alt:
            self.rect.y = -self.rect.height
            

    def update(self):
        #调用父类的方法实现背景滑动
        super().update()
        #移出屏幕 设置到屏幕上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height
        pass

创建敌机的默认过程：
调用父类方法，创建敌机精灵，指定敌机图片

class Enemy(GameSprite):
    
    def __init__(self):
        
        #调用父类方法，创建敌机精灵，指定敌机图片
        super().__init__("./images/enemy1.png")
        
        #敌机初始速度
        self.speed = random.randint(1, 30)
        
        #敌机初始位置
        self.rect.bottom = 0
        max_x = SCREEN_RECT.width - self.rect.width
        self.rect.x = random.randint(0, max_x)
    
    def update(self):
        
        #调用父类方法。保持垂直方向飞行
        super().update()
        #判断是否飞出屏幕，从精灵组中删除敌机，释放内存
        if self.rect.y >= SCREEN_RECT.height:
            print("飞出屏幕，删除敌机")
            # kill方法可以将精灵从所有精灵组中移出，使其自动销毁
            self.kill()

用完的子弹和飞机需要移除，来释放空间

def __del__(self):
      print("enemy has been destoried %s" % self.rect)

class Hero(GameSprite):
    
    def __init__(self):
        #调用父类方法，设置位置和速度，初始位置
        super().__init__("./images/me1.png", 0)
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - 100
        self.bullets = pygame.sprite.Group()
        
    def update(self):
        self.rect.x += self.speed
        self.rect.y += self.speed2
        
        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):
        
        for i in range(5):
            # for v in range(2):
            bullet = Bullet()
            
            bullet.rect.bottom = self.rect.y - i * 20
            bullet.rect.centerx = self.rect.centerx
            self.bullets.add(bullet)

class Bullet(GameSprite):
    
    def __init__(self):
        #调用父类方法,设置子弹图片,设置初始速度
        super().__init__("./images/bullet1.png", -20)
        
    def update(self):
        #调用父类方法,让子弹垂直飞行
        super().update()
        #judage bullet out of screen
        if self.rect.bottom < 0:
            self.kill()
        
    def __del__(self):
        print("bullet has been destroy")

总结

飞机大战和坦克大战很相像，下一步，可以动手，设计一个用python实现坦克大战的小游戏。