500行代码，教你用Python写个微信飞机大战

这几天在重温微信小游戏的飞机大战，玩着玩着就在思考人生了，这飞机大战怎么就可以做的那么好，操作简单，简单上手。

帮助蹲厕族、YP族、饭圈女孩在无聊之余可以有一样东西让他们振作起来!让他们的左手 / 右手有节奏有韵律的朝着同一个方向来回移动起来!

这是史诗级的发明，是浓墨重彩的一笔，是……

在一阵抽搐后，我结束了游戏，瞬时觉得一切都索然无味，正在我进入贤者模式时，突然想到，如果我可以让更多人已不同的方式体会到这种美轮美奂的感觉岂不美哉?

所以我打开电脑，创建了一个 plan_game.py……

先看效果图

操作环境

• 操作系统：windows10
• python版本：python 3.7
• 代码编辑器：pycharm 2018.2
• 使用模块：os,sys,random,pygame

因为实现代码使用到了一个pygame的第三方模块，没有的先 pip install 一下，这里顺便提供一个比较好的pygame的教程.

https://eyehere.net/2011/python-pygame-novice-professional-index/

具体实现

首先我们先指定素材文件的文件目录.方便我们后面的使用。

1. import os 
2.  
3. # 得到当前文件夹下面的material_images目录的路径 
4. source_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'material_images') 

实现一个Game类，用来完成这个游戏的主要逻辑。

1. import pygame 
2.  
3.  
4. class Game(): 
5.     def __init__(self, background_image_path, size=(480, 700), title='飞机大战', font_name='方正舒体', font_size=30, speed=2000): 
6.         ''' 
7.         :param background_image_path: 背景图片的路径地址 
8.         :param size: 游戏窗口的大小 
9.         :param title: 游戏窗口的标题 
10.         :param font_name: 指定字体 
11.         :param font_size: 指定字体大小 
12.         :param speed: 背景图滚动整个窗口一次所用时间，单位为ms 
13.         ''' 
14.         self.size = size 
15.         self.screen = pygame.display.set_mode(size) 
16.         self.title = title 
17.         self.background_image_path = background_image_path 
18.         self.background = pygame.image.load(self.background_image_path).convert() 
19.         # 设置字体对象，得到系统中自带的字体 
20.         self.font = pygame.font.SysFont(font_name, font_size) 
21.         # 得到Clock对象，我们可以使用它来获取距离上次绘制图像的时间 
22.         self.clock = pygame.time.Clock() 
23.         # 背景图初始位置 
24.         self.height = 0 
25.         # 使用窗口的高度处于滚动的时间，就能得到每ms滚动的距离 
26.         self.every_ms_move_distance = self.size[1] / speed   # 2秒 
27.         # 分数 
28.         self.score = 0 
29.         # 存放所有的敌机 
30.         self.enemies = [] 
31.  
32.  
33.     def show_score(self): 
34.         ''' 
35.         显示分数, 在窗口的的最上方距离上边距10px， 左右居中 
36.         ''' 
37.         pass 
38.  
39.  
40.     def set_time_passed(self): 
41.         # 控制画 的帧， 越大越快 
42.         # 得到上一次绘制图像到到现在的时间, ms 
43.         self.time_passed = self.clock.tick() 
44.  
45.  
46.     def draw_background(self): 
47.         ''' 
48.         绘制背景图片，一直向下滚动，营造飞机一直往上面飞的感觉 
49.         ''' 
50.         # 每次移动的距离 = 每ms移动的距离 * 上次到现在的时间（ms） 
51.         pass 
52.  
53.  
54.     def create_enemy(self, image_path=os.path.join(source_dir,'enemy1.png'), enemy_number=5): 
55.         ''' 
56.         创建敌机 
57.         :param image_path: 敌机的图片地址 
58.         :param enemy_number: 最多有几个敌机在屏幕上 
59.         ''' 
60.         pass 
61.  
62.  
63.     def draw_enemies(self, time_passed, screen): 
64.         ''' 
65.         绘制敌机到屏幕上，清理跑出窗口的敌机， 
66.         :param time_passed: 上次绘制导向现在经过的时间 
67.         :param screen: 绘制的窗口对象 
68.         ''' 
69.         pass 
70.  
71.  
72.     def bullet_and_enemy_crash_detection(self, bullets): 
73.         ''' 
74.         检测子弹是否击中敌机 
75.         :param bullets: 飞机的所有子弹 
76.         ''' 
77.         pass 
78.  
79.  
80.     def plan_and_enemy_crash_detection(self, plan, allow_crash_size=None): 
81.         ''' 
82.         检测敌机与飞机是否相撞 
83.         :param plan: 飞机对象 
84.         :param allow_crash_size: 允许飞机碰撞的大小，只有左右有效 
85.         ''' 
86.         pass 
87.  
88.  
89.     def draw_plan(self, plan, time_passed): 
90.         ''' 
91.         绘制飞机 
92.         :param plan: 飞机对象 
93.         :param time_passed: 距离上次绘制的时间 
94.         :return: 
95.         ''' 
96.         pass 
97.  
98.  
99.     def game_over(self): 
100.         ''' 
101.         游戏结束 
102.         ''' 
103.         while True: 
104.             # 绘制背景图 
105.             pass 
106.  
107.  
108.     def run(self): 
109.         ''' 
110.         游戏入口函数，开始函数，主体函数 
111.         :return: 
112.         ''' 
113.  
114.         # 设置游戏窗口的大小 
115.         pygame.display.set_caption(self.title) 
116.         # 初始化一个飞机对象 
117.         plan = Plan() 
118.  
119.         while True: 
120.             # 如果飞机自毁完成, 游戏结束, 调用game_over函数 
121.             pass 
122.  
123.             # 检测监听事件 
124.             pass 
125.  
126.             # 检测上下左右的移动案件. 
127.             # w,a,s,d 和 上,下,左,右键都可以 
128.             # 然后执行plan.update函数，改变飞机的位置 
129.             pass 
130.  
131.             # 子弹和敌机的碰撞检测 
132.             self.bullet_and_enemy_crash_detection(plan.bullets) 
133.             # 飞机与敌机的碰撞检测 
134.             self.plan_and_enemy_crash_detection(plan) 
135.             # 设置属性time_passed的值， 距离上次的时间，方便后面使用 
136.             self.set_time_passed() 
137.             # 绘制背景图片 
138.             self.draw_background() 
139.             # 显示分数 
140.             self.show_score() 
141.             # 生成敌机 
142.             self.create_enemy() 
143.             # 绘制敌机 
144.             self.draw_enemies(time_passed=self.time_passed, screen=self.screen) 
145.             # 绘制飞机 
146.             self.draw_plan(plan=plan, time_passed=self.time_passed) 
147.             # 绘制子弹 
148.             plan.draw_bullets(time_passed=self.time_passed, screen=self.screen) 
149.             # 显示我们的图像 
150.             pygame.display.update() 
151.  
152. 这里说以下怎样查看自己的系统中有哪些自带的字体. 
153. pygame.font.get_fonts()，这个函数就能够得到系统中所有的自带字体文件。不过，当我们游戏中有中文的时候，我们也得选择支持中文的字体，否则的话是显示不出中文的。 
     

实现DestroyAnimationMixin类，这个类主要是用来显示飞机或敌机的自毁动画

1. # 显示飞机自毁动画的Mixin类, 可用于飞机和敌机的自毁动画显示 
2. class DestroyAnimationMixin(): 
3.  
4.     def show_destroy_animation(self, time_passed, destroy_time=200): 
5.         ''' 
6.         显示自毁动画 
7.         动画其实就是几张图片切换的比较快，我们的眼睛识别不出来，所以认为他是动态的，也就是动画 
8.         :param time_passed: 距离上次绘制图像到现在的时间，单位ms 
9.         :param destroy_time: 自毁动画总共显示时间，单位ms 
10.         ''' 
11.  
12.         # 因为我们的自毁图片有四张，需要依次显示，首先动画的效果 
13.         # self.destroy_image_position 表示第几章自毁图片，从零开始 
14.         # 如果大于等于4了，说明自毁动画显示完成，设置self.destroyed变量为True, 方便别处调用 
15.         if self.destroy_image_position >= 4: 
16.             self.destroyed = True 
17.             return 
18.  
19.         # 依次加载自毁图片 
20.         if self.time_passed >= destroy_time / 4: 
21.             self.image = pygame.image.load(os.path.join(source_dir, self.destroy_images[self.destroy_image_position])).convert_alpha() 
22.             self.destroy_image_position += 1 
23.             self.time_passed = 0 
24.         else: 
25.             self.time_passed += time_passed 

实现飞机类，完成飞机的主要操作。飞机的操作包括：飞机位置、飞机子弹、发射子弹等。

1. # 飞机类，继承DestroyAnimationMixin， 方便使用显示自毁动画的函数 
2. class Plan(DestroyAnimationMixin): 
3.     def __init__(self, image_path=os.path.join(source_dir,'plan.png'), background_size=(480, 700)): 
4.         ''' 
5.         :param image_path: 飞机图片地址 
6.         :param background_size: 游戏窗口大小 
7.         ''' 
8.         self.background_size = background_size 
9.         self.image = pygame.image.load(image_path).convert_alpha() 
10.         self.image_size = self.image.get_size() 
11.         self.position = [(background_size[0]-self.image_size[0]) / 2, 500] 
12.         # 飞机每次移动的距离 
13.         self.every_time_move_distance = 0.5 
14.         # 飞机的子弹 
15.         self.bullets = [] 
16.         # destroy association attributes， 自毁相关属性 
17.         # 开始自毁 
18.         self.start_destroy = False 
19.         # 自毁结束 
20.         self.destroyed = False 
21.         # 自毁图片 
22.         self.destroy_images = ['me_destroy_1.png', 'me_destroy_2.png', 'me_destroy_3.png', 'me_destroy_4.png'] 
23.         # 自毁图片位置 
24.         self.destroy_image_position = 0 
25.         # 距离上次绘制图像到现在的时间 
26.         self.time_passed = 0 
27.  
28.     def update(self, direction): 
29.         ''' 
30.         更新飞机位置 
31.         :param direction: 飞机移动方向 
32.         ''' 
33.         pass 
34.  
35.     def shut(self, image_path=os.path.join(source_dir,'bullet.png')): 
36.         ''' 
37.         飞机发射子弹 
38.         :param image_path: 子弹图片 
39.         ''' 
40.         pass 
41.  
42.     def draw_bullets(self, time_passed, screen): 
43.         ''' 
44.         绘制飞机的所有子弹 
45.         :param time_passed: 距离上次绘制图像到现在的时间 
46.         :param screen: 绘制到哪一个窗口中 
47.         ''' 
48.         pass 

实现敌机类，完成敌机的主要操作。主要是用来更新位置。

1. # 敌机类，继承DestroyAnimationMixin， 方便使用显示自毁动画的函数 
2. class Enemy(DestroyAnimationMixin): 
3.     def __init__(self, image_path=os.path.join(source_dir, 'enemy1.png'), speed=2000, background_size=(480, 700)): 
4.         ''' 
5.         :param image_path: 敌机图片地址 
6.         :param speed: 敌机移动整个窗口需要的时间，单位ms，也就是速度 
7.         :param background_size: 游戏窗口的尺寸 
8.         ''' 
9.         self.image = pygame.image.load(image_path).convert_alpha() 
10.         self.speed = background_size[1] / speed 
11.         self.background_size = background_size 
12.         self.position = [random.randint(0, background_size[0]-self.image.get_size()[0]), -self.image.get_size()[1]] 
13.         # 开始自毁 
14.         self.start_destroy = False 
15.         # 自毁完成 
16.         self.destroyed = False 
17.         # 自毁图片路径 
18.         self.destroy_images = ['enemy1_down1.png', 'enemy1_down2.png', 'enemy1_down3.png', 'enemy1_down3.png'] 
19.         # 距离上次绘制图像到现在的时间 
20.         self.time_passed = 0 
21.         # 自毁图片在self.destroy_images的位置 
22.         self.destroy_image_position = 0 
23.  
24.     def update(self, time_passed): 
25.         ''' 
26.         更新敌机的位置 
27.         :param time_passed: 距离上次绘制图像到现在的时间 
28.         :return: 
29.         ''' 
30.         pass 

实现子弹类，完成子弹的主要操作

1. # 飞机子弹类 
2. class Bullet(): 
3.     def __init__(self, image_path=os.path.join(source_dir,'bullet.png'), background_size=(480, 700), plan=None, speed=1000): 
4.         ''' 
5.         :param image_path: 子弹的图片地址 
6.         :param background_size: 游戏窗口大小 
7.         :param plan: 飞机对象 
8.         :param speed: 子弹飞行速度 
9.         ''' 
10.         self.image = pygame.image.load(image_path).convert_alpha() 
11.         self.background_size = background_size 
12.         self.speed = background_size[1] / speed 
13.         # 子弹是否击中敌机 
14.         self.destroyed = False 
15.         self.position = self._get_position(plan) 
16.  
17.     def _get_position(self, plan): 
18.         ''' 
19.         根据plan得到子弹发出位置 
20.         :param plan: 飞机对象 
21.         ''' 
22.         bullet_size = self.image.get_size() 
23.         plan_width = plan.image_size[0] 
24.         x = (plan_width-bullet_size[0]) / 2 
25.         return [plan.position[0] + x, plan.position[1]] 
26.  
27.     def update(self, time_passed): 
28.         ''' 
29.         改变子弹位置 
30.         :param time_passed: 距离上次绘制图像到现在的时间 
31.         ''' 
32.         # 如果子弹超出屏幕或者击中敌机，就设置self.position[1]为-100,在plan.draw的时候就移除它 
33.         if self.position[1] + self.image.get_size()[1] <= 0 or self.destroyed: 
34.             self.position[1] = -100 
35.             return 
36.  
37.         # 改变的距离 = 时间 * 速率 
38.         self.position[1] -= time_passed * self.speed