如何用Python做一个飞机大战（超详细）

前言

最近在学习Python，便用Pygame做了一个经典游戏——飞机大战。有兴趣的朋友可以参考一下。

---

注：本文很长，若只是想要代码或已经学会pygame的朋友只要看图片资源、代码、文件目录、实现效果

---

运行环境

1.一台可以使用的windows电脑
2.含有python运行环境（安装了python编译器）

---

安装Pygame

1.打开命令提示符

点击快捷键win+r，进入运行界面：

输入“cmd”,单击确定：

会出现类似这样的一个黑窗口（当然我演示的系统是win7,其他win版本可能略有不同)

pip安装pygame

输入命令“pip install pygame”，点击回车

稍等片刻即可完成

如果速度太慢，可以输入pip install pygame -i http://pypi.mirrors.ustc.edu.cn/simple/ 来临时更换pip源，加快pip速度，详见：让你的pip从龟速到豹速

---

图片资源

链接：https://pan.baidu.com/s/1pMM0beb

---

游戏原理&注意事项

玩过飞机大战的朋友应该都知道，自己通过方向键来控制飞机，发射炮弹摧毁敌机，若敌机碰到自己的飞机，自己牺牲。
通过玩法，可以写出这样的一个大if：

这个大if就是游戏的根本思想。
根据用户按键控制飞机左右移动，我们要捕获用户按键，改变飞机位置；

扫描二维码关注公众号，回复： 12123952 查看本文章

英雄子弹碰撞敌机敌机牺牲或英雄碰到敌机英雄牺牲，我们要进行碰撞检测；

为了更好的控制敌机、英雄、子弹，我们要建立精灵组；

代码采用面向对象的编写方式，要有类/对象基础；

代码分两个文件编写，一个叫Plane_Game(游戏主程序)，一个叫PlaneSprite(负责游戏精灵和工具编写)

这是游戏的精髓。如果你对这几种都掌握了，了解目标后，我们开始编写代码吧！

编写代码

1.导入模块

Plane_Game.py

#导入pygame和工具文件
import pygame
from PlaneSprites import *

PlaneSprite.py

import random,pygame

2.完成框架

(1)确定职责

我们在主文件中，根据要实现的不同目标，设立了几个方法，避免某一个方法的代码写得太过冗长：

游戏初始化 —— init() 会调用以下方法：

方法	职责
__create_sprites(self)	创建所有精灵和精灵组

主循环 start_game() 会调用以下方法：

方法	职责
__event_handler(self)	事件监听
__check_collide(self)	碰撞检测 —— 子弹销毁敌机、敌机撞毁英雄
__update_sprites(self)	精灵组更新和绘制
__game_over()	游戏结束

完成类的创建

if name == 'main’的意思是：当.py文件被直接运行时，if name == 'main’之下的代码块将被运行；当.py文件以模块形式被导入时，if name == 'main’之下的代码块不被运行。

#类继承自object基类
class PlaneGame(object):
    """飞机大战主游戏"""
    #完成初始化方法框架
    def __init__(self):
        print("游戏初始化")
    #完成开始游戏框架
    def start_game(self):
        print("开始游戏...")

#if __name__ == '__main__'的意思是：当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。
if __name__ == '__main__':
    # 创建游戏对象
    game = PlaneGame()

    # 启动游戏
    game.start_game()

完成__init__()创建

self.clock = pygame.time.Clock() 创建时钟对象，用来设置刷新帧率，60就能达到非常好的效果了

def __init__(self):
    print("游戏初始化")
    
    # 1. 创建游戏的窗口
    self.screen = pygame.display.set_mode((480, 700))
    # 2. 创建游戏的时钟
    self.clock = pygame.time.Clock()
    # 3. 调用私有方法，精灵和精灵组的创建
    self.__create_sprites()

def __create_sprites(self):
    pass

把固定数值设为常量

• 代码调整

plane_sprites.py 中增加常量定义

import pygame
# 游戏屏幕大小
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)

修改 plane_main.py 中的窗口大小

#矩形对象的size就是它的宽和高（x,y）
self.screen = pygame.display.set_mode(SCREEN_RECT.size)

完善游戏循环框架

pygame.event.get()是获取到当前事件的队列 因为我们要处理这个队列的所有事件，
一般我们都会设置一个循环，就可以去处理内部一个一个的event

def start_game(self):
        """开始游戏"""
        while True:
            #1.设置刷新帧率
            self.clock.tick(60)
            #2.事件监听
            self.__event_handler()
            #3.碰撞检测
            self.__check_collide()
            #4.更新/绘制精灵组
            self.__update_sprite()
            #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()

确定精灵组

创建精灵组方法
Plane_Game.py

def __create_sprites(self):
    """创建精灵组"""
    
    # 背景组
    self.back_group = pygame.sprite.Group()
    # 敌机组
    self.enemy_group = pygame.sprite.Group()
    # 英雄组
    self.hero_group = pygame.sprite.Group()

更新精灵组方法

def __update_sprites(self):
    """更新精灵组"""
    
    for group in [self.back_group, self.enemy_group, self.hero_group]:
    
        group.update()
        group.draw(self.screen)

PlaneSprites.py
因为以后创建的精灵都基于这个精灵组，所以就先写出来

class GameSprite(pygame.sprite.Sprite):
    """飞机大战精灵"""
    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

    def update(self):
        self.rect.y += self.speed

实现背景精灵

背景交替滚动的思路确定

飞机大战背景图像会连续不断地向下方移动 在 视觉上 产生英雄的飞机不断向上方飞行的错觉 这是在很多跑酷类游戏中常用的套路

• 游戏的背景 不断变化
• 游戏的主角 位置保持不变

实现方法：
拿两张一样的背景图片，让一张背景图片向下移动，判断移出屏幕后，把这张图片重新放在屏幕上方，一直反复
具体实现和背景精灵组我就不讲解，你们就直接看注释吧
PlaneSprites.py

class Background(GameSprite):
    """游戏背景精灵"""
    def __init__(self,is_alt=False):
        #1.调用父类方法，传一个image_name参数
        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\images\background.png")
        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

实现敌机精灵

01. 使用定时器添加敌机

游戏效果： 游戏启动后，每隔 1 秒 会 出现一架敌机 每架敌机 向屏幕下方飞行，飞行 速度各不相同 每架敌机出现的 水平位置 也不尽相同
当敌机 从屏幕下方飞出，不会再飞回到屏幕中

设置定时器

在 plane_sprites.py 的顶部定义 事件常量

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

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

# 4. 设置定时器事件 - 每秒创建一架敌机
pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)

在 __event_handler 方法中增加以下代码：

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("敌机出场...")

创建敌机精灵组

class Enemy(GameSprite):
    """敌机精灵"""
    def __init__(self):
        # 1. 调用父类方法，创建敌机精灵，并且指定敌机的图像
        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\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)
        
    def update(self):
        #1.使用父类中垂直方向飞行功能
        super().update()
        #2.判断是否飞出屏幕，如果是，从精灵组里删除
        if self.rect.y >= SCREEN_RECT.height:
            self.kill()
    def __del__(self):
        #print("敌机挂了 %s" % self.rect)
        pass

设置英雄和子弹

英雄需求

游戏启动后，英雄 出现在屏幕的 水平中间 位置，距离 屏幕底部 120 像素
英雄 每隔 0.5 秒发射一次子弹，每次 连发三枚子弹
英雄 默认不会移动，需要通过 左/右 方向键，控制 英雄 在水平方向移动

子弹需求

子弹 从 英雄 的正上方发射 沿直线 向 上方 飞行
飞出屏幕后，需要从 精灵组 中删除

英雄精灵组代码

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

    def __init__(self):
        #1.调用父类方法，设置image_name&speed

        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\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
    def fire(self):
        print("发射子弹...")
        for i in (0,1,2):
            #1.创建子弹精灵
            bullet = Bullet()
            #2.设置精灵位置
            #(1)让子弹在英雄上方20像素
            bullet.rect.bottom = self.rect.y - i*20
            #（2）让英雄和子弹对齐
            bullet.rect.centerx = self.rect.centerx
            #3.把精灵添加到精灵组
            self.bullets.add(bullet)

在 plane_main.py 的顶部定义 发射子弹 事件常量

# 英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1

在 init 方法末尾中添加 发射子弹 事件

# 每隔 0.5 秒发射一次子弹
pygame.time.set_timer(HERO_FIRE_EVENT, 500)

在 __event_handler 方法中让英雄发射子弹

elif event.type == HERO_FIRE_EVENT:
    self.hero.fire()

敌机精灵组

初始化方法

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

PlaneSprites.py

class Bullet(GameSprite):
    """子弹精灵"""
    def __init__(self):
        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\images\bullet1.png",-2)
        
    def update(self):
        super().update()
        if self.rect.bottom < 0:
            self.kill()
    def __del__(self):
        print("子弹被销毁...")
            

碰撞检测

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

代码

Plane_Game.py

import pygame
from PlaneSprites import *


class PlaneGame(object):
    """飞机大战游戏"""
    def __init__(self):
        #1.创建游戏窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        #2.创建游戏时钟对象
        self.clock = pygame.time.Clock()
        #3.调用完成精灵精灵组创建的私有方法
        self.__create_sprites()
        #4.设置定时器事件——创建敌机 1s启动一次事件，创建一架敌机
        pygame.time.set_timer(CREATE_ENEMY_EVENT,1000)
        #5.设置定时器事件——发射子弹 0.5s启动一次事件，发射一次子弹
        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.hero=Hero()
        #创建英雄精灵组
        self.hero_group = pygame.sprite.Group(self.hero)
    def start_game(self):
        """开始游戏"""
        while True:
            #1.设置刷新帧率
            self.clock.tick(FRAME_PER_SEC)
            #2.事件监听
            self.__event_handler()
            #3.碰撞检测
            self.__check_collide()
            #4.更新/绘制精灵组
            self.__update_sprite()
            #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()
                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:
            self.hero.speed = 0
        
    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()
    def __update_sprite(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():
        #游戏结束
        pygame.quit()
        exit()
if __name__ == '__main__':

    game = PlaneGame()
    
    #启动游戏
    game.start_game()

PlaneSprites.py

import random
import pygame
#设置屏幕大小
SCREEN_RECT = pygame.Rect(0,0,480,700)
#刷新的帧率
FRAME_PER_SEC = 60
#敌机的定时器事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
#英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1

class GameSprite(pygame.sprite.Sprite):
    """飞机大战精灵"""
    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

    def update(self):
        self.rect.y += self.speed


class Background(GameSprite):
    """游戏背景精灵"""
    def __init__(self,is_alt=False):
        #1.调用父类方法，传一个image_name参数
        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\images\background.png")
        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__(r"C:\Users\Administrator\Desktop\飞机大战\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)
        
    def update(self):
        #1.使用父类中垂直方向飞行功能
        super().update()
        #2.判断是否飞出屏幕，如果是，从精灵组里删除
        if self.rect.y >= SCREEN_RECT.height:
            self.kill()
    def __del__(self):
        #print("敌机挂了 %s" % self.rect)
        pass
class Hero(GameSprite):
    """英雄精灵"""

    def __init__(self):
        #1.调用父类方法，设置image_name&speed

        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\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
    def fire(self):
        print("发射子弹...")
        for i in (0,1,2):
            #1.创建子弹精灵
            bullet = Bullet()
            #2.设置精灵位置
            #(1)让子弹在英雄上方20像素
            bullet.rect.bottom = self.rect.y - i*20
            #（2）让英雄和子弹对齐
            bullet.rect.centerx = self.rect.centerx
            #3.把精灵添加到精灵组
            self.bullets.add(bullet)
        
class Bullet(GameSprite):
    """子弹精灵"""
    def __init__(self):
        super().__init__(r"C:\Users\Administrator\Desktop\飞机大战\images\bullet1.png",-2)
        
    def update(self):
        super().update()
        if self.rect.bottom < 0:
            self.kill()
    def __del__(self):
        print("子弹被销毁...")
            

文件目录

代码采用路径：C:\Users\Administrator\Desktop\飞机大战
注：第28、43、67、98行涉及到路径，若和我路径不一样的朋友请更改

实现效果