Python 项目实战 ----飞机大战游戏

最新推荐文章于 2023-08-30 16:55:38 发布
最新推荐文章于 2023-08-30 16:55:38 发布
阅读量1k 收藏 7
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lilygg/article/details/102572321
版权

一、游戏框架搭建

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

 

01.命令主程序职责

一个游戏主程序的职责可以分为以下两个部分：

● 游戏初始化

● 游戏循环

根据明确的职责，设计PlanGame类：

 

02.实现飞机大战主游戏类

 

1.明确文件职责

● plane_main 

1.封装主游戏类

2.创建游戏对象

3.启动游戏

● plane_sprites

1.封装游戏中所有需要使用的精灵子类

2.提供游戏的相关工具

 

代码实现：

1.新建 plane_main.py 文件，并且设置为可执行

2.编写基础代码

 

2.游戏初始化

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口
        self.screen = pygame.display.set_mode((350,573))
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法
        self.__create_sprites()
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        pass
    def start_game(self):
        print("游戏开始...")

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

3.常量的使用

常量：不变化的量      变量：可以变化的量

应用场景：

● 在开发时，可能会需要使用固定的数值，例如：屏幕的高度是700

● 在这个时侯，建议不要直接使用固定数值，而应该使用常量

● 在开发时，为了保证代码的可维护性，尽量不要使用魔法数字

常量的定义：

● 定义常量和定义变量的语法完全一样，都是使用赋值语句

● 常量的命名应该所有字母都使用大写，单词与单词之间使用下划线连接

常量的好处：

● 阅读代码时，通过常量名见名知意，不需要猜测数字的含义

● 如果需要调整值，只需要修改常量定义就可以实现统一修改

改进：使用 常量 代替 固定的数值

plane_sprites.py文件内容：

import pygame

## 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,350,573)

"""飞机大战游戏精灵"""

# 继承pygame.sprite.Sprite父类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上移动
        self.rect.y += self.speed

plane_mian.py文件内容：

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size：获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法
        self.__create_sprites()
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        pass
    def start_game(self):
        print("游戏开始...")
        while True:
            pass

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

 

4.搭建启动游戏方法结构 

plane_sprites.py文件添加内容：

# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

plane_mian.py文件内容：

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法
        self.__create_sprites()
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        pass

    def start_game(self):
        print("游戏开始...")
        # 游戏循环
        while True:
            # 1.设置刷新帧率
            self.clock.tick(FRAME_PRE_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()
    def __check_collide(self):
        pass
    def __update_sprites(self):
        pass
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

二、游戏背景

目标：显示游戏背景交替滚动

 

01.背景交替滚动的思路确定

● 游戏启动后，背景图像会连续不断的向下方移动

● 在视觉上产生英雄的飞机不断向上方飞行的错觉，在很多跑酷类游戏中常用的套路

   游戏的背景 不断变化

   游戏的主角 位置保持不变

 

1.实现思路分析

1.创建两张背景图像精灵

  ● 第一张完全和屏幕重合

  ● 第二张在屏幕的正上方

2.两张图像一起向下运动

   ● self.rect.y += self.speed

3.当任意一张背景精灵的rect.y >= 屏幕的高度 说明已经移动到屏幕下方

4.将移动到屏幕下方的这张图像设置到屏幕的正上方

   ● rect.y = -rect.height

 

2.设计背景类

初始化方法：

● 直接指定背景图片

● is_alt 判断是否设另一张图像：False表示第一张图像，需要与屏幕重合；True表示另一张图像，在屏幕的正上方

update()方法：

● 判断是否移出屏幕，如果是，将图像设置到屏幕的正上方，从而实现交替滚动

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

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

 

02.显示游戏背景

 

1.背景精灵的基本实现

在 plane_sprites.py文件中 新建 Background类 继承自 GameSprite类

import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,350,573)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def update(self):
        # 1.调用父类的方法实现
        super().update()
        # 2.判断是否移出屏幕
        if self.rect.y >= SCREEN_RECT.height:
            # 如果移出屏幕，则将图像设置到屏幕的上方
            self.rect.y = -self.rect.height

2.在 plane_main.py 中显示背景精灵

实现步骤：

1.在 __create_sprites 方法中，创建精灵和精灵组

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

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法
        self.__create_sprites()
    
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background("./images/background.png")
        bg2 = Background("./images/background.png")
        # 将第二张图像的初始位置设置到屏幕的正上方
        bg2.rect.y = -bg2.rect.height
        # 创建背景精灵组
        self.back_ground = pygame.sprite.Group(bg1,bg2)
    
    def start_game(self):
        print("游戏开始...")
        # 游戏循环
        while True:
            # 1.设置刷新帧率
            self.clock.tick(FRAME_PRE_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()
    def __check_collide(self):
        pass
    
    def __update_sprites(self):
        # 精灵组调用 update 和 draw 方法
        self.back_ground.update()
        self.back_ground.draw(self.screen)
    
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

3.利用初始化方法，简化背景精灵创建

思考：

● 在主程序中，创建的两个背景精灵，传入了相同的图像文件路径

● 创建第二个背景精灵时，在主程序中，设置背景精灵的图像位置

改进：精灵的初始位置的设置，应该由主程序负责

● 根据面向对象设计原则，应该将对象的职责，封装到类的代码内部

● 尽量简化程序调用一方的代码调用

初始化方法：

● 直接指定背景图片

● is_alt 判断是否为另一张图像

  False --- 表示第一张图像，需要与屏幕重合

  True  --- 表示另一张图像，在屏幕的正上方

在 plane_sprites.py 中实现 Background 的初始化方法

import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,350,573)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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

简化 plane_mian.py 文件内容

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法
        self.__create_sprites()

    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):  
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=True)
        # 创建背景精灵组
        self.back_group = pygame.sprite.Group(bg1,bg2)
    
    def start_game(self):
        print("游戏开始...")
        # 游戏循环
        while True:
            # 1.设置刷新帧率
            self.clock.tick(FRAME_PRE_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()
    def __check_collide(self):
        pass
    def __update_sprites(self):
        self.back_group.update()
        self.back_group.draw(self.screen)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

三、敌机出场

目标：

● 使用 定时器 添加敌机

● 设计 Enemy 类

 

01.使用定时器添加敌机

根据飞机大战游戏，观察敌机规律：

1.游戏启动后，每隔1秒会出现一架敌机

2.每架敌机向屏幕下方飞行，飞行速度各不相同

3.每架飞机出现的水平位置也不尽相同

4.当敌机从屏幕下方飞出，不会再飞回到屏幕中

 

1.定时器

● 在 pygame 中可以使用 pygame.time.set_timer() 来添加 定时器

● 所谓定时器，就是每隔一段时间，去执行一些动作

set_timer(eventid,milliseconds)

set_timer 可以创建一个事件，可以在游戏循环的事件监听方法中捕获到该事件

eventid：事件代号，需要基于常量 pygame.USEREVENT 来指定；USEREVENT是一个整数，再增加的事件可以使用USEREVENT+1指定
milliseconds：事件触发间隔的毫秒值

定时器事件的监听

● 通过 pygame.event.get() 可以获取当前时刻所有的事件列表

● 遍历列表并且判断 event.type 是否等于 eventid，如果相等，表示定时器事件发生

 

2.定义并监听创建敌机事件

定时器的使用：

1.定义定时器常量：eventid

2.在初始化方法中，调用 set_timer 方法 设置定时器事件

3.在游戏循环中，监听定时器事件

 

02.设计 Enemy 类

● 初始化方法

指定 敌机图片

指定 随机敌机的 初始位置 和 初始速度

● 重写 update() 方法

判断是否飞出屏幕，若是，则从精灵组删

 

1.敌机类的准备

import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始随机速度
        # 3.指定敌机的初始位置
    def update(self):
        # 1.调用父类方法
        super().update()
        # 2.判断是否飞出屏幕，若是，则需从精灵组删除敌机
        if self.rect.y >= SCREEN_RECT.height:
            print("飞出屏幕，需从精灵组删除...")

2.创建敌机

演练步骤：

1.在 __create_sprites，添加敌机精灵组

   ● 敌机是定时被创建的，因此在初始化方法中，不需要创建敌机

2.在 __event_handler，创建敌机，并添加到精灵组

    ● 调用精灵组的 add 方法 可以向精灵组添加精灵

3.在 __update_sprites，让敌机精灵组调用 update 和 draw 方法

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件，创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=True)
        # 创建背景精灵组
        self.back_group = pygame.sprite.Group(bg1,bg2)
        
        # 创建敌机精灵组
        self.enemy_group = pygame.sprite.Group()
    
    def start_game(self):
        print("游戏开始...")
        # 游戏循环
        while True:
            # 1.设置刷新帧率
            self.clock.tick(FRAME_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
    def __check_collide(self):
        pass
    def __update_sprites(self):
        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)
        
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

3.随机敌机位置和速度

(1).导入模块

     ● 在导入模块时，建议按照以下顺序导入

         1.官方标准模块

         2.第三方模块

         3.应用程序模块

注意：pygame 属于第三方模块，random 属于官方标准模块

(2).随机位置

使用 pygame.Rect 提供的 bottom 属性，在指定敌机初始位置时，会比较方便

● bottom = y + height

● y = bottom - height

即  y = -height  等价于  bottom = 0

(3).代码实习

修改初始化方法，随机敌机出现速度和位置

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，需从精灵组删除...")

 

4.移出屏幕销毁敌机

● 敌机移出屏幕之后，如果没有撞到英雄，敌机的历史使命已经终结

● 需要从敌机组删除，否则会造成内存浪费

检测敌机被销毁

● __del__ 内置方法会在对象被销毁前调用，在开发中，可以用于判断对象是否被销毁

判断敌机是否飞出屏幕，若是，则调用 kill() 方法从所有组中删除

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            self.kill()
    def __del__(self):
        print("敌机挂了 %s" % self.rect)

四、英雄登场

目标

● 设计英雄和子弹类

● 使用 pygame.key.get_pressed() 移动英雄

● 发射子弹

 

01.设计英雄和子弹类

英雄需求：

1.游戏启动后，英雄出现在屏幕的水平中间位置，距离屏幕底部120像素

2.英雄每隔0.5秒发射一次子弹，每次连发三枚子弹

3.英雄默认不会移动，需要通过左/右方向键，控制英雄在水平方向移动

子弹需求：

1.子弹从英雄的正上方发射沿直线向上飞行

2.飞出屏幕后，需要从精灵组中删除

Hero 英雄

● 初始化方法

指定英雄图片

初始速度 = 0 --- 英雄默认静止不动

定义 bullets 子弹精灵组 保存子弹精灵

● 重写 update() 方法

英雄需要水平移动

并且需要保证不能移出屏幕

● 增加 bullers 属性，记录所有子弹精灵

● 增加 fire 方法，用于发射子弹 

 

Bullet 子弹

● 初始化方法

指定子弹图片

初始速度 = -2  ---- 子弹需要向上方飞行

● 重写 update() 方法

判断是否飞出屏幕，如果是，从精灵组删除

 

02.创建英雄

 

1.准备英雄类

● 在 plane_sprites 新建 Hero类

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

● 设置英雄的初始位置

centerx = x + 0.5 * width

centery = y + 0.5 * height

bottom = y + height

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            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.设置英雄的初始位置
        # 水平位置 x
        self.rect.centerx = SCREEN_RECT.centerx
        # 垂直位置 y
        self.rect.bottom = SCREEN_RECT.bottom -120

2.绘制英雄

操作步骤：

1.在 __create_sprites 方法中，添加 英雄精灵 和 英雄精灵组

   ● 后续要针对英雄做 碰撞检测 以及 发射子弹，所以 英雄 需要单独定义成属性 

2.在 __update_sprites 方法中，让英雄精灵组调用 update 和 draw 方法

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件，创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=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_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
    def __check_collide(self):
        pass
    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)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

03.移动英雄位置

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

第一种方式：判断 event.type == pygame.KEYDOWN

elif event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT:
    print("向右移动...")

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

# 使用键盘提供的方法获取按键
keys_pressed = pygame.key.get_pressed()
# 判断元组中对应的按键索引值 1
if keys_pressed[pygame.K_RIGHT]:
    print("向右移动...")

区别：

第一种方式，用户必须要抬起按键才能算一次按键事件，操作灵活性会大打折扣

第二种方式，用户可以按住方向键不放，就能够实现持续向某一个方向移动了，操作灵活性更好

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件，创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=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_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
            # 捕获键盘按键
            # 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]:
            print("向右移动...")

    def __check_collide(self):
        pass
    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)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

1.移动英雄位置

演练步骤：

1.在 Hero 类中重写 update 方法

   ● 用速度 speed 和 英雄 rect.x 进行叠加

   ● 不需要调用父类方法 --- 父类方法只是实现了单纯的垂直运动 

2.在__event_handler 方法中根据 左右方向键 设置英雄的 速度

   ● 向右  speed = 2

   ● 向左  speed =-2

   ● 其他  speed = 0

plane_sprites.py 文件内容：

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            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.设置英雄的初始位置
        # 水平位置 x
        self.rect.centerx = SCREEN_RECT.centerx
        # 垂直位置 y
        self.rect.bottom = SCREEN_RECT.bottom -120
    def update(self):
        # 水平方向移动
        self.rect.x += self.speed

plane_mian.py 文件内容：

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件，创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=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_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
            # 捕获键盘按键
            # 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):
        pass
    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)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

2.控制英雄运动边界

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

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

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            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.设置英雄的初始位置
        # 水平位置 x
        self.rect.centerx = SCREEN_RECT.centerx
        # 垂直位置 y
        self.rect.bottom = SCREEN_RECT.bottom -120
    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

04.发射子弹

 

1.添加发射子弹事件

定时器的使用，套路非常固定

1.定义定时器常量：eventid

2.在初始化方法中，调用 set_timer 方法 设置定时器事件

3.在游戏循环中，监听定时器事件

 

先在 Hero类 中 定义 fire 方法，并定义定时器常量

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 定义英雄发射子弹的定时器常量
HERO_FIRE_EVENT = pygame.USEREVENT + 1

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上向下移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            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.设置英雄的初始位置
        # 水平位置 x
        self.rect.centerx = SCREEN_RECT.centerx
        # 垂直位置 y
        self.rect.bottom = SCREEN_RECT.bottom -120
    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("发射子弹...")

在 plane_mian.py 文件中，设置 并 监听 定时器事件

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件
        # 创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
        # 创建英雄子弹；500ms=0.5s
        pygame.time.set_timer(HERO_FIRE_EVENT,500)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=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_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
            # 定时发射子弹
            # 判断事件类型是否为“英雄发射子弹的定时器常量”
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()

        # 使用键盘提供的方法获取按键
        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):
        pass
    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)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

2.定义子弹类

子弹需求：

1.子弹从英雄的正上方发射沿直线向上飞行

2.飞出屏幕后，需要从精灵组中删除

 

定义子弹类

● 在 plane_sprites.py文件中 新建 Bullet类 继承自 GameSprite类

● 重写 初始化方法，直接指定图片名称，并且设置初始速度为 -2（因为子弹需要向上方飞行）

● 重写 update() 方法，判断子弹是否飞出屏幕，若是，则从精灵组删除

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 定义英雄发射子弹的定时器常量
HERO_FIRE_EVENT = pygame.USEREVENT + 1

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，敌机精灵需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            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.设置英雄的初始位置
        # 水平位置 x
        self.rect.centerx = SCREEN_RECT.centerx
        # 垂直位置 y
        self.rect.bottom = SCREEN_RECT.bottom -120
    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("发射子弹...")


"""子弹精灵"""

class Bullet(GameSprite):
    def __init__(self):
        # 调用父类方法，设置子弹图像和初始速度
        super().__init__("./images/bullet1.png",-2)
    def update(self):
        # 1.调用父类方法，让子弹沿垂直方向向上飞行（因为速度为负值）
        super().update()
        # 2.判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            # print("飞出屏幕，子弹精灵需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            self.kill()
    def __del__(self):
        print("子弹被销毁...")

3.发射子弹

演练步骤：

1. 在 Hero 的 初始化方法 中 创建 子弹精灵组 属性

2.修改 plane_main.py 的 __update_sprites 方法，让子弹精灵组调用 update 和 draw 方法

3.实现 fire() 方法

● 创建子弹精灵

● 设置初始位置 --- 在英雄的正上方

● 将子弹添加到精灵组

plane_sprites.py文件内容：

import random
import pygame

# 定义屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,346,567)
# 定义刷新帧率的常量
FRAME_PRE_SEC = 60

# 定义创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 定义英雄发射子弹的定时器常量
HERO_FIRE_EVENT = pygame.USEREVENT + 1

"""飞机大战游戏精灵"""

# 继承系统自带的pygame.sprite.Sprite类
class GameSprite(pygame.sprite.Sprite):
    # 1.初始化方法：定义属性
    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
    # 2.定义方法
    def update(self):
        # 在屏幕的垂直方向上移动
        self.rect.y += self.speed

"""背景精灵"""

# 继承GameSprite类
class Background(GameSprite):
    def __init__(self,is_alt=False):
        # 1.调用父类的方法实现精灵的创建
        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.指定敌机的初始位置
        # 垂直方向 y
        self.rect.bottom = 0
        # 水平方向 x
        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("飞出屏幕，敌机精灵需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            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.设置英雄的初始位置
        # 水平位置 x
        self.rect.centerx = SCREEN_RECT.centerx
        # 垂直位置 y
        self.rect.bottom = SCREEN_RECT.bottom -120
        # 3.创建子弹的精灵组
        self.bullets_group = 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("发射子弹...")
        # 1.创建子弹精灵
        bullet = Bullet()
        # 2.设置精灵的初始位置
        bullet.rect.bottom = self.rect.y - 20
        bullet.rect.centerx = self.rect.centerx
        # 3.将精灵添加到精灵组
        self.bullets_group.add(bullet)


"""子弹精灵"""

class Bullet(GameSprite):
    def __init__(self):
        # 调用父类方法，设置子弹图像和初始速度
        super().__init__("./images/bullet1.png",-2)
    def update(self):
        # 1.调用父类方法，让子弹沿垂直方向向上飞行（因为速度为负值）
        super().update()
        # 2.判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            # print("飞出屏幕，子弹精灵需从精灵组删除...")
            # 将精灵从所有的精灵组中移出，精灵便会被自动销毁
            self.kill()
    def __del__(self):
        print("子弹被销毁...")
        pass

plane_main.py 文件内容：

import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件
        # 创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
        # 创建英雄子弹；500ms=0.5s
        pygame.time.set_timer(HERO_FIRE_EVENT,500)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=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_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
            # 定时发射子弹
            # 判断事件类型是否为“英雄发射子弹的定时器常量”
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()

        # 使用键盘提供的方法获取按键
        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):
        pass
    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_group.update()
        self.hero.bullets_group.draw(self.screen)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

修改 fire() 方法，一次发射三枚子弹：

def fire(self):
    print("发射子弹...")
    for i in range(3):
        # 1.创建子弹精灵
        bullet = Bullet()
        # 2.设置精灵的初始位置
        bullet.rect.bottom = self.rect.y - 20*i
        bullet.rect.centerx = self.rect.centerx
        # 3.将精灵添加到精灵组
        self.bullets.add(bullet)

五、碰撞检测

 

1.碰撞检测方法

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

子弹撞毁敌机：

● pygame.sprite.groupcollide()    检测 两个精灵组中所有精灵是否发生碰撞

groupcollide(group1, group2, dokill1, dokill2, collided = None) 


dokill1, dokill2 的数据类型均为 布尔型，且 group1 和 dokill1 的对应，group2 和 dokill2 的对应

如果将 dokill 设置为 True，则发生碰撞的精灵将被自动移除，即若 dokill1 为 True，则group1中的精灵与group2中的精灵发生碰撞，则group1中的精灵将被销毁

collided 参数是用于 计算碰撞的回调函数，如果没有指定，则每隔精灵必须有一个 rect 属性

敌机撞毁英雄：

● pygame.sprite.spritecollide()    判断 某个精灵和指定的精灵组中的精灵的碰撞

spritecollide(sprite, group, dokill, collided = None)


如果将 dokill 设置为 True，则指定精灵组中发生碰撞的精灵将被自动移除

collided 参数适用于计算碰撞的回调函数，如果没有指定，则每个精灵必须有一个 rect 属性

返回 精灵组 中跟 精灵 发生碰撞的 精灵列表
import pygame
from plane_sprites import *

"""飞机大战主游戏 """
class PlaneGame(object):
    def __init__(self):
        print("游戏初始化")
        # 1.创建游戏窗口；SCREEN_RECT.size:获取矩形对象中的元组
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        # 2.创建游戏时钟
        self.clock = pygame.time.Clock()
        # 3.调用私有方法，创建精灵和精灵组
        self.__create_sprites()
        # 设置定时器事件
        # 创建敌机；1000ms=1s
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
        # 创建英雄子弹；500ms=0.5s
        pygame.time.set_timer(HERO_FIRE_EVENT,500)
    # 定义私有方法，创建精灵和精灵组
    def __create_sprites(self):
        # 创建背景精灵
        bg1 = Background()
        bg2 = Background(is_alt=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_PRE_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 = Enemy()
                # 将敌机精灵添加到敌机精灵组中
                self.enemy_group.add(enemy)
            # 定时发射子弹
            # 判断事件类型是否为“英雄发射子弹的定时器常量”
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()
        # 使用键盘提供的方法获取按键
        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_group,self.enemy_group,True,True)
        # 2.敌机撞毁英雄；返回结果为列表
        enemies = pygame.sprite.spritecollide(self.hero,self.enemy_group,True)
        # 判断列表是否有内容
        if len(enemies) > 0:
            # 1.英雄牺牲
            self.hero.kill()
            # 2.结束游戏
            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_group.update()
        self.hero.bullets_group.draw(self.screen)
    @staticmethod      # 静态方法
    def __game__over():
        print("游戏结束")
        pygame.quit()
        exit()

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

奋斗吧，青年！
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python-基础-飞机大战-背景图像(三十二)
weixin_37571268的博客
03-06 1017
1. 背景交替滚动的思路确定 运行 备课代码, 观察 背景图像的显示效果: 游戏启动后, 背景图像 会 连续不断地 向下方 移动 在 视觉上 产生英雄的飞机不断向上方飞行的 错觉 在很多跑酷类游戏中常用的套路 游戏的背景 不断变化 游戏的主角 位置保持不变 1.1 实现思路分析 解决办法 创建两张背景图像经理 第 1 张 完全和屏幕重合 第 2 张在 屏幕的正上方 ...
python3飞机大战源码及源码使用教程（让小白做出第一个小游戏）
热门推荐
gudada010的博客
07-11 5万+
python3飞机大战 一.源代码使用教程及环境配置 1.环境配置 打开pycharm，进入file，打开settings 打开project interpreter，点击右上方 + 号 搜索pygame模块并导入 到此环境就配置好了。 2.源代码使用教程 创建一个新的python文件夹命名为“飞机” 在新文件夹下再创建一个文件夹命名为“images”,用来存放游戏所需图片 将以下图片下载...
python飞机大战简书_python中的小游戏——飞机大战
weixin_39806948的博客
12-05 166
精灵类---plane_sprites#这个模块放一些常用的工具和基础类和精灵类#在其他模块调用import pygameimport random#设置游戏屏幕大小 这是一个常量SCREEN_RECT = pygame.Rect(0,0,580,700)#敌机的定时器事件常量CREATE_ENEMY_EVENT = pygame.USEREVENT#定制一个精灵类，需要继承pygame提供的精灵...
Python飞机大战小游戏
Lamb的博客
08-30 4276
【代码】Python飞机大战小游戏。
pygame.rect中 Rect类 属性示意
weixin_43338239的博客
04-08 1068
部分pygame.rect源代码如下 class Rect(object): x: int y: int top: int left: int bottom: int right: int topleft: Tuple[int, int] bottomleft: Tuple[int, int] topright: Tuple[int, int] bottomright: Tuple[int, int] midtop: T
python实战项目源码-彩图版飞机大战
01-28
python实战项目源码——彩图版飞机大战
python编程实战-----飞机大战.md
02-15
该代码实现飞船大战外星人，而且随着难度的提升，飞船得分不断加大，最高分会显示在游戏屏幕顶部中心，飞船有三条命，该游戏可以帮助小主打法无聊的时光呢，希望大大们能得高分呦！
python-飞机大战项目实战
03-30
压缩包中包含整套飞机大战项目的代码，每一步都通过基础python语言实现。对入门小白来说是一个福音。
Python 小实战 ——飞机大战python_Aircraft-Wars.zip
最新发布
05-12
五子棋游戏想必大家都非常熟悉，游戏规则十分简单。游戏开始后,玩家在游戏设置中选择人机对战，则系统执黑棋，玩家自己执白棋。双方轮流下一棋，先将横、竖或斜线的5个或5个以上同色棋子连成不间断的一排者为胜。 ...
python实战项目源码-飞机大战-含可执行文件.zip
11-30
python实战项目源码-飞机大战-含可执行文件.zip
planegame飞机大战
05-17
基于vs MFC实现飞机大战planegame飞机大战planegame飞机大战
pygame飞机大战源码和素材（Python版）完整版
02-22
Python:pygame飞机大战源码和素材
Python飞机大战项目终篇（一步一步实现---最全笔记）
m0_67391121的博客
06-12 283
前一篇博客为游戏实现前所用的基础知识介绍 Python飞机大战项目前篇 此篇为飞机大战游戏项目的整个实现过程。从游戏框架的搭建、游戏背景的设置、英雄飞机和敌机的设定，再到飞机发生碰撞时的检测（子弹摧毁敌机，敌机撞毁英雄）等详细的笔记描述游戏初始化 —— 会调用以下方法：方法职责创建所有精灵和精灵组游戏循环 —— 会调用以下方法：方法职责事件监听碰撞检测 —— 子弹销毁敌机、敌机撞毁英雄精灵组更新和绘制游戏结束新建plane_main.py文件和plane_sprites.py文件记得导入图片素材（如图）
python飞机大战简书_pygame 模块进行简单游戏开发-----飞机大战
weixin_39661405的博客
12-05 224
学习目标强化 面向对象 程序设计体验使用 pygame 模块进行 游戏开发安装 pygamesudo pip3 install pygame验证安装python3 -m pygame.examples.aliens1.1、 游戏的初始化和退出import pygamepygame.init()# 游戏代码...pygame.quit()1.2、 理解游戏中的坐标系定义 hero_rect 矩形描述...
python | 基础学习（六）pygame游戏开发：飞机大战
qq_44250700的博客
09-09 1万+
文章目录一、pygame模块1、安装：2、使用pygame创建图形窗口（1）新建项目`飞机大战`（2）新建文件`pygame.py`（3）建立游戏窗口：①pygame的初始化和退出②pygame的坐标系③创建游戏主窗口pygame.display④导入游戏背景图片⑤把一些精致的图像绘制到游戏窗口中3、游戏循环①动画效果——游戏时钟②动画的简单实现③在游戏循环中监听事件④精灵sprite.Sprite和精灵组sprite.Group⑤派生精灵子类⑥使用 游戏精灵 和 精灵组 创建敌机4、游戏框架搭建（1）明确
Python版飞机大战游戏的设计（三）-----游戏背景
击水三千里的专栏
08-14 1313
游戏背景 目标 背景交替滚动的思路确定 显示游戏背景 01. 背景交替滚动的思路确定 运行备课代码，观察背景图像的显示效果： 游戏启动后，背景图像会连续不断地向下方移动 在视觉上产生英雄的飞机不断向上方飞行的错觉—— 在很多跑酷类游戏中常用的套路 游戏的背景不断变化 游戏的主角位置保持不变 1.1 实现思路分析 解决办法 创建两张背景图像...
python飞机大战笔记（7）--游戏背景滚动显示
qq_26126831的博客
11-19 1063
背景交替滚动： 游戏启动后，背景图像会连续不断地向下方移动； 在视觉上产生英雄的飞机不断向上方飞行的错觉； 即：游戏的背景不断变化；游戏的主角未知保持不变； 在屏幕上，竖直叠放两张背景图像；将第一个图像一处屏幕后，将第一张图像凭借到第二个图像的上方； 当第二张图像移出屏幕后 ，第一张接到上方，以此循环。 1）创建两张背景图像； 第一张完全和屏幕重合；第二张在屏幕的正上方； 2）两张图像一起向下运动...
Python学习日记-第二十三天-飞机大战（游戏背景设计思路）
arizia的博客
10-22 1376
这一章节是讲述的飞机大战游戏背景的设计思路细节。
pycharm快捷键
布谷鸟
09-16 217
1、编辑（Editing） Ctrl + Space 基本的代码完成（类、方法、属性） Ctrl + Alt + Space 快速导入任意类 Ctrl + Shift + Enter 语句完成 Ctrl + P 参数信息（在方法中调用参数） Ctrl + Q 快速查看文档 Shift + F1 外部文档 Ctrl + 鼠标 简介 Ctrl + F1 显示错误描述或警告信息 Alt + Insert 自动生成代码 Ctrl + O 重新方法 Ctrl + Alt + T 选中 Ctrl + / 行注释 Ctr
python-django-vue项目实战
03-10
Python-Django-Vue项目实战是一种常见的全栈发模式，结合了Python的Django框架和Vue.js前端框架。下面是一个简单的介绍： Python-Django是一个强大的Web开发框架，它使用Python语言编写，提供了一系列的工具和库来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值