飞机大战有很多种，但是那些都不够眼熟，今天来一手微信同款飞机大战。

一、用到的软件和模块

1、软件
Python
pycharm

2、模块
pygame
sys
os
random

导入模块

import pygame
import sys
import os
import random

素材文件的路径地址

source_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'material_images')

初始化pygame

pygame.init()
pygame.display.init()
pygame.font.init()

简单的封装上，下，左，右变量

class Direction():
    UP = 1
    DOWN = 2
    LEFT = 3
    RIGHT = 4

显示飞机自毁动画的Mixin类, 可用于飞机和敌机的自毁动画显示

class DestroyAnimationMixin():
    def show_destroy_animation(self, time_passed, destroy_time=200):
        ''' 显示自毁动画 动画其实就是几张图片切换的比较快，我们的眼睛识别不出来，所以认为他是动态的，也就是动画 :param time_passed: 距离上次绘制图像到现在的时间，单位ms :param destroy_time: 自毁动画总共显示时间，单位ms '''

因为我们的自毁图片有四张，需要依次显示，首先动画的效果
self.destroy_image_position 表示第几章自毁图片，从零开始
如果大于等于4了，说明自毁动画显示完成，设置self.destroyed变量为True, 方便别处调用

if self.destroy_image_position >= 4:
    self.destroyed = True
    return

依次加载自毁图片

if self.time_passed >= destroy_time / 4:
    self.image = pygame.image.load(os.path.join(source_dir, self.destroy_images[self.destroy_image_position])).convert_alpha()
    self.destroy_image_position += 1
    self.time_passed = 0
else:
    self.time_passed += time_passed

敌机类，继承DestroyAnimationMixin，方便使用显示自毁动画的函数

class Enemy(DestroyAnimationMixin):
    def __init__(self, image_path=os.path.join(source_dir, 'enemy1.png'), speed=2000, background_size=(480, 700)):
        ''' :param image_path: 敌机图片地址 :param speed: 敌机移动整个窗口需要的时间，单位ms，也就是速度 :param background_size: 游戏窗口的尺寸 '''
        self.image = pygame.image.load(image_path).convert_alpha()
        self.speed = background_size[1] / speed
        self.background_size = background_size
        self.position = [random.randint(0, background_size[0]-self.image.get_size()[0]), -self.image.get_size()[1]]
        # 开始自毁
        self.start_destroy = False
        # 自毁完成
        self.destroyed = False
        # 自毁图片路径
        self.destroy_images = ['enemy1_down1.png', 'enemy1_down2.png', 'enemy1_down3.png', 'enemy1_down3.png']
        # 距离上次绘制图像到现在的时间
        self.time_passed = 0
        # 自毁图片在self.destroy_images的位置
        self.destroy_image_position = 0
    def update(self, time_passed):
        ''' 更新敌机的位置 :param time_passed: 距离上次绘制图像到现在的时间 :return: '''
        # 敌机如果跑出游戏窗口，设置self.position[1] = -100， 方便其他位置使用
        if self.position[1] >= self.background_size[1]:
            self.position[1] = -100
            return
        # 如果开始自毁， 调用自毁函数,显示动画,如果没有，改变位置
        if self.start_destroy:
            self.show_destroy_animation(time_passed)
        else:
            self.position[1] += self.speed * time_passed

飞机子弹类

class Bullet():
    def __init__(self, image_path=os.path.join(source_dir,'bullet.png'), background_size=(480, 700), plan=None, speed=1000):
        ''' :param image_path: 子弹的图片地址 :param background_size: 游戏窗口大小 :param plan: 飞机对象 :param speed: 子弹飞行速度 '''
        self.image = pygame.image.load(image_path).convert_alpha()
        self.background_size = background_size
        self.speed = background_size[1] / speed
        # 子弹是否击中敌机
        self.destroyed = False
        self.position = self._get_position(plan)
    def _get_position(self, plan):
        ''' 根据plan得到子弹发出位置 :param plan: 飞机对象 '''
        bullet_size = self.image.get_size()
        plan_width = plan.image_size[0]
        x = (plan_width-bullet_size[0]) / 2
        return [plan.position[0] + x, plan.position[1]]
    def update(self, time_passed):
        ''' 改变子弹位置 :param time_passed: 距离上次绘制图像到现在的时间 '''
        # 如果子弹超出屏幕或者击中敌机，就设置self.position[1]为-100,在plan.draw的时候就移除它
        if self.position[1] + self.image.get_size()[1] <= 0 or self.destroyed:
            self.position[1] = -100
            return
        # 改变的距离 = 时间 * 速率
        self.position[1] -= time_passed * self.speed

飞机类，继承DestroyAnimationMixin，方便使用显示自毁动画的函数

飞机图片地址

class Plan(DestroyAnimationMixin):
    def __init__(self, image_path=os.path.join(source_dir,'plan.png'), background_size=(480, 700)):
        ''' :param image_path: :param background_size: 游戏窗口大小 '''
        self.background_size = background_size
        self.image = pygame.image.load(image_path).convert_alpha()
        self.image_size = self.image.get_size()
        self.position = [(background_size[0]-self.image_size[0]) / 2, 500]
        # 飞机每次移动的距离
        self.every_time_move_distance = 0.5
        # 飞机的子弹
        self.bullets = []
        # destroy association attributes， 自毁相关属性
        # 开始自毁
        self.start_destroy = False
        # 自毁结束
        self.destroyed = False
        # 自毁图片
        self.destroy_images = ['me_destroy_1.png', 'me_destroy_2.png', 'me_destroy_3.png', 'me_destroy_4.png']
        # 自毁图片位置
        self.destroy_image_position = 0
        # 距离上次绘制图像到现在的时间
        self.time_passed = 0

更新飞机位置

def update(self, direction):
        ''' :param direction: 飞机移动方向 '''
        if direction == 1:
            if self.position[1] <= 0:
                return
            self.position[1] -= self.every_time_move_distance
        elif direction == 2:
            if self.position[1] + self.image_size[1] >= self.background_size[1]:
                return
            self.position[1] += self.every_time_move_distance
        elif direction == 3:
            if self.position[0] <= 0:
                return
            self.position[0] -= self.every_time_move_distance
        else:
            if self.position[0] + self.image_size[0] >= self.background_size[0]:
                return
            self.position[0] += self.every_time_move_distance

飞机发射子弹

def shut(self, image_path=os.path.join(source_dir,'bullet.png')):
        ''' :param image_path: 子弹图片 '''
        bullet = Bullet(image_path, plan=self)
        self.bullets.append(bullet)

绘制飞机的所有子弹

def draw_bullets(self, time_passed, screen):
        ''' :param time_passed: 距离上次绘制图像到现在的时间 :param screen: 绘制到哪一个窗口中 '''
        # 清理消失的子弹
        for bullet in self.bullets:
            if bullet.position[1] == -100:
                self.bullets.remove(bullet)
        # 更新每个子弹的位置
        for bullet in self.bullets:
            bullet.update(time_passed)
        # 绘制每个子弹
        for bullet in self.bullets:
            screen.blit(bullet.image, bullet.position)

param background_image_path: 背景图片的路径地址
param size: 游戏窗口的大小
param title: 游戏窗口的标题
param font_name: 指定字体
param font_size: 指定字体大小
param speed: 背景图滚动整个窗口一次所用时间，单位为ms

class Game():
    def __init__(self, background_image_path, size=(480, 700), title='飞机大战', font_name='方正舒体', font_size=30, speed=2000):
        self.size = size
        self.screen = pygame.display.set_mode(size)
        self.title = title
        self.background_image_path = background_image_path
        self.background = pygame.image.load(self.background_image_path).convert()
        # 设置字体对象，得到系统中的字体
        self.font = pygame.font.SysFont(font_name, font_size)
        # 得到Clock对象，我们可以使用它来获取距离上次绘制图像的时间
        self.clock = pygame.time.Clock()
        # 背景图初始位置
        self.height = 0
        # 使用窗口的高度处于滚动的时间，就能得到每ms滚动的距离
        self.every_ms_move_distance = self.size[1] / speed   # 2秒
        # 分数
        self.score = 0
        # 存放所有的敌机
        self.enemies = []

显示分数, 在窗口的的最上方距离上边距10px，左右居中。

def show_score(self):
        # 是否开启锯齿模式 字体颜色 背景颜色
        score = self.font.render(f'得分 : {self.score} ', True, (0,0,0), (255,255,255))
        score_position_x = (self.size[0]-score.get_size()[0]) / 2
        score_position_y = 10
        self.screen.blit(score, (score_position_x, score_position_y))

控制画的帧

def set_time_passed(self):
        # 控制画 的帧， 越大越快
        # self.clock.tick(1000)
        # 得到上一次绘制图像到到现在的时间, ms
        self.time_passed = self.clock.tick()

绘制背景图片，一直向下滚动，营造飞机一直往上面飞的感觉

def draw_background(self):
        # 每次移动的距离 = 每ms移动的距离 * 上次到现在的时间（ms）
        move_distance = self.every_ms_move_distance * self.time_passed
        self.height += move_distance
        # 如果超出窗口的高度，将height重置为零
        if self.height >= self.size[1]:
            self.height = 0
        # 两张背景图一起显示，营造背景图不间断的一直滚动的效果
        self.screen.blit(self.background, (0, -self.size[1] + self.height))
        self.screen.blit(self.background, (0, self.height))

创建敌机

def create_enemy(self, image_path=os.path.join(source_dir,'enemy1.png'), enemy_number=5):
        ''' :param image_path: 敌机的图片地址 :param enemy_number: 最多有几个敌机在屏幕上 '''
        if len(self.enemies) >= enemy_number:
            return
        enemy = Enemy(image_path=image_path)
        self.enemies.append(enemy)

绘制敌机到屏幕上，清理跑出窗口的敌机。

def draw_enemies(self, time_passed, screen):
        ''' :param time_passed: 上次绘制导向现在经过的时间 :param screen: 绘制的窗口对象 '''
        # 清理跑出范围的敌机
        for enemy in self.enemies:
            # 当敌机跑出范围时，就将enemy.position[1]设置为-100了，所以我们这里判断enemy.position[1]==-100的，就是跑出范围的敌机
            # enemy.destroyed 为True, 表示敌机被子弹击中，也需要清理这个enemy
            if enemy.position[1] == -100 or enemy.destroyed:
                self.enemies.remove(enemy)
        # 更新敌机位置
        for enemy in self.enemies:
            # 调用每一个敌机的update方法，改变敌机的位置
            enemy.update(time_passed)
        # 绘制敌机
        for enemy in self.enemies:
            # 根据敌机的位置，绘制敌机
            screen.blit(enemy.image, enemy.position)

检测子弹是否击中敌机

def bullet_and_enemy_crash_detection(self, bullets):
        ''' :param bullets: 飞机的所有子弹 '''
        for bullet in bullets:
            # 遍历每一个子弹
            for enemy in self.enemies:
                # 遍历每一个敌机，判断是否被击中
                if bullet.position[0] >= enemy.position[0] and bullet.position[0] <= enemy.position[0]+enemy.image.get_size()[0]:
                    if bullet.position[1] >= enemy.position[1] and bullet.position[1] <= enemy.position[1] + enemy.image.get_size()[1]:
                        # 如果被击中，敌机开始自毁
                        enemy.start_destroy = True
                        # 子弹自毁，消失
                        bullet.destroyed = True
                        # 分数加一
                        self.score += 1

检测敌机与飞机是否相撞

def plan_and_enemy_crash_detection(self, plan, allow_crash_size=None):
        ''' :param plan: 飞机对象 :param allow_crash_size: 允许飞机碰撞的大小，只有左右有效 '''
        # 如果没有传入这个参数，赋值为飞机宽度的 10%
        if allow_crash_size is None:
            allow_crash_size = 0.1 * plan.image_size[0]
        for enemy in self.enemies:
            # 遍历每一个敌机， 检测是否碰撞
            if enemy.position[0]+enemy.image.get_size()[0] - allow_crash_size >= plan.position[0] and enemy.position[0] <= plan.position[0]+plan.image.get_size()[0] - allow_crash_size:
                if enemy.position[1] + enemy.image.get_size()[1] >= plan.position[1] and enemy.position[1] <= plan.position[1] + plan.image.get_size()[1]:
                    # 检测到碰撞，飞机开始自毁
                    plan.start_destroy = True

绘制飞机

def draw_plan(self, plan, time_passed):
        ''' :param plan: 飞机对象 :param time_passed: 距离上次绘制的时间 :return: '''
        # 如果飞机开始自毁，调用自毁函数，显示自毁动画
        if plan.start_destroy:
            plan.show_destroy_animation(time_passed, destroy_time=1000)
        self.screen.blit(plan.image, plan.position)

游戏结束

def game_over(self):
        while True:
            # 绘制背景图
            self.set_time_passed()
            self.draw_background()
            text = self.font.render(f'游戏结束，得分 : {self.score} ', True, (0, 0, 0), (255, 255, 255))
            text_position_x = (self.size[0] - text.get_size()[0]) / 2
            text_position_y = (self.size[1] - text.get_size()[1]) / 2
            self.screen.blit(text, (text_position_x, text_position_y))
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        pygame.quit()
                        sys.exit()
            pygame.display.update()

游戏入口函数，开始函数

def run(self):
        ''' :return: '''
        # 设置游戏窗口的大小
        pygame.display.set_caption(self.title)
        # 初始化一个飞机对象
        plan = Plan()
        while True:
            # 如果飞机自毁完成, 游戏结束, 调用game_over函数
            if plan.destroyed:
                self.game_over()
                break
            # 检测监听事件
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        pygame.quit()
                        sys.exit()
                # 如果用户的空格键弹起，说明用户按下过空格键，发射一颗子弹
                elif event.type == pygame.KEYUP:
                    if event.key == pygame.K_SPACE:
                        # 调用plan.shut函数
                        plan.shut()
            # 检测上下左右的移动案件.
            # w,a,s,d 和 上,下,左,右键都可以
            # 然后执行plan.update函数，改变飞机的位置
            key_pressed = pygame.key.get_pressed()
            if key_pressed[pygame.K_w] or key_pressed[pygame.K_UP]:
                plan.update(direction=Direction.UP)
            elif key_pressed[pygame.K_s] or key_pressed[pygame.K_DOWN]:
                plan.update(direction=Direction.DOWN)
            elif key_pressed[pygame.K_a] or key_pressed[pygame.K_LEFT]:
                plan.update(direction=Direction.LEFT)
            elif key_pressed[pygame.K_d] or key_pressed[pygame.K_RIGHT]:
                plan.update(direction=Direction.RIGHT)
            # 子弹和敌机的碰撞检测
            self.bullet_and_enemy_crash_detection(plan.bullets)
            # 飞机与敌机的碰撞检测
            self.plan_and_enemy_crash_detection(plan)
            # 设置属性time_passed的值， 距离上次的时间，方便后面使用
            self.set_time_passed()
            # 绘制背景图片
            self.draw_background()
            # 显示分数
            self.show_score()
            # 生成敌机
            self.create_enemy()
            # 绘制敌机
            self.draw_enemies(time_passed=self.time_passed, screen=self.screen)
            # 绘制飞机
            self.draw_plan(plan=plan, time_passed=self.time_passed)
            # 绘制子弹
            plan.draw_bullets(time_passed=self.time_passed, screen=self.screen)
            # 显示我们的图像
            pygame.display.update()

背景图片地址

if __name__ == '__main__':
    # 背景图图片地址
    background_image_path = os.path.join(source_dir, 'background.png')
    game = Game(background_image_path=background_image_path)

加上 game.run() 开始游戏

兄弟萌学废了吗？
python福利教程（包含本文完整源码、本文要用的素材、电子书、其它视频教程、解答）
领取方式：
1、点赞+评论（勾选“同时转发”）
2、关注小编。并私信回复关键字【飞机大战】
（一定要私信哦~点击我的头像就能看到私信按钮了）

Python游戏开发：这款曾经几亿人上瘾的小游戏，经典飞机大战，大家应该都玩过

一、用到的软件和模块

相关文章

热门标签

最新文章