Python飞船大战—完整源代码超详细注释（可运行）_python飞船代码

---

前言

因为作者刚开始真正地去学python，该游戏作为第一个项目，真的很用心的对每一处代码都进行了注释，该程序也可以完美运行。可以通过阅读我的代码注释，了解整个小项目，甚至可以随意添加一些自己的想法。（本环境为python3.70，pygame2.0.1）

---

一、准备工作

1.Pygame的安装

本游戏是基于pygame制作的，因此第一步是要安装pygame。可以直接打开Anaconda Prompt，激活相应的虚拟环境，通过下列代码便可完成安装。

pip install pygame
1

2.素材

该游戏除了主体，还需要三样东西：1、飞船和外星人的照片 2、击打音效 3、显示中文所需的字体。

其中，1、照片很好搞，搞到之后用系统的画图直接将背景改成游戏的背景色即可。2、击打音效自己录制就可以，但是需要注意：如果录制的声音源格式不是wav的，需要使用 Audacity (下载链接: https://pc.qq.com/search.html#!keyword=Audacity)另存为wav格式即可使用 pygame.mixer.Sound()正常加载。
步骤如下：
a、打开Audacity，选择文件–>导入–>音频，选择你需要转换的音频。
b、选择文件–>导出–>WAV即可。
3、中文显示字体，可查看我的上一篇文章说明搞定。
PS:high_score_record.txt是为了重启游戏仍能够保留最高分存在的，第一次运行程序便可自动生成。

3.操作说明

左右键可控制飞船左右移动；空格键发生子弹；Q键退出游戏；P键开始游戏

二、游戏运行效果

射击、击杀和死亡是可以正常发出声音的，下面两幅图是游戏中的截图。

三、飞船大战源代码

1.主体（main.py）【运行】

import sys #里面有工具用于退出
from time import sleep# 引入sleep以便飞船在外星人撞到后可以暂停一会

import pygame
from setting import Settings
from  game_stats import GameStats
from ship import Ship
from bullet import Bullet
from alien import Alien
from button import Button
from scoreboard import Scoreboard

class AlienInvasion:
    '''管理游戏资源和行为的类'''
    def __init__(self):
        '''初始化游戏并创造游戏类'''
        pygame.init()#初始化背景设置
        #引入设置，并将屏幕初始化
        self.settings = Settings()
        '''全屏游戏的设置
        self.screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN)
        self.settings.screen_width = self.screen.get_rect().width
        self.settings.screen_height = self.screen.get_rect().height
        '''
        self.screen = pygame.display.set_mode(
            (self.settings.screen_width,self.settings.screen_height)
        )
        #self.screen = pygame.display.set_mode((1200,800))#创建一个显示的窗口（目前为宽1200，长800）
        pygame.display.set_caption("Alien Invasion")#游戏窗口名称
        #引入储存游戏的统计信息
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)  # 引入计分板
        #引入飞船
        self.ship = Ship(self)
        #引入子弹,这是利用pygame创造了一个编组，可以储存所有有效子弹，以便管理发出去的子弹
        self.bullets = pygame.sprite.Group()
        #引入外星人（同子弹）
        self.aliens = pygame.sprite.Group()
        self._creat_fleet()#这里直接调用，是为了立即创造出外星人,因为打开敌人就要出现
        #创建play按钮
        self.play_button = Button(self, "开始")
        #设置特效的音量（子弹、击中、被击中）
        self.bullet_sound = pygame.mixer.Sound("sound/bullet.wav")
        self.bullet_sound.set_volume(0.2)#音量的设置
        self.hit_sound = pygame.mixer.Sound("sound/hit.wav")
        self.hit_sound.set_volume(0.2)  # 音量的设置
        self.dead_sound = pygame.mixer.Sound("sound/dead.wav")
        self.dead_sound.set_volume(0.2)  # 音量的设置
        #第24行将由单独的设置界面导入背景色self.bg_color = (230,230,230)#设置背景色（三个分量对应着RGB）
    def run_game(self):#该run game可拆分成两个辅助方法，check events和update screen
        '''开始游戏主循环'''
        while True:
            #监视键盘和鼠标事件。
            self._check_events()
            self._update_screen()
            if self.stats.game_active:#由此可限制当游戏状态为0后，就不再更新新得东西，但能退出
                self.ship.update()#自程序运行，就要一直查看飞船是否发生移动
                self._update_bullets()#辅助方法——更新子弹
                self._update_aliens()


    def _creat_fleet(self):
        '''创建外星人群'''
        # 创建一个外星人，这里的创建只是为了得到外星人的长和宽，以便下面计算一行能容纳的外星人个数
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size  # 以免反复rect
        #计算屏幕中一行可以容纳多少外星人（外星人间距为外星人宽度）
        available_space_x = self.settings.screen_width - (2 * alien_width)
        number_aliens_x = available_space_x // (2 * alien_width)
        # 计算屏幕可以容纳多少行外星人
        ship_height = self.ship.rect.height
        available_space_y = (self.settings.screen_height -
                             (3 * alien_height) - ship_height)
        number_row = available_space_y // (2 * alien_height)
        #创造外星人群
        for row_number in range(number_row):
            for alien_number in range(number_aliens_x):
                # 创建一个外星人并将其加入当前行
                self._creat_alien(alien_number, row_number)

    def _creat_alien(self,alien_number, row_number):
        '''创建一个外星人并将其放在当前行上'''
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size  # 以免反复rect
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
        self.aliens.add(alien)
    def _check_fleet_edges(self):
        '''右外星人到达边缘就采用相应的措施'''
        for alien in self.aliens.sprites():
            if alien.check_edges():
                self._change_fleet_direction()
                break
    def _change_fleet_direction(self):
        '''将整体外星人下移，并改变他们的方向'''
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.fleet_drop_speed
        self.settings.fleet_direction *= -1 # 因为这个辅助方法是针对一个外星人调用的
    def _check_events(self):
        for event in pygame.event.get():  # 此处的get是侦听，所有键鼠事件都会引起循环
            if event.type == pygame.QUIT:  # 即点击游戏窗口的关闭按钮后，游戏将结束
                self._exit_game()
            elif event.type == pygame.KEYDOWN:#按下键盘按键时的操作
                if event.key == pygame.K_RIGHT:
                    '''此举会因为按一下方向键右键，而使飞船右移动一个像素，效率较低，姑去ship设置新变量
                    通过标志的TorF来使飞船实现持续移动
                    self.ship.rect.x +=1'''
                    self.ship.moving_right = True
                elif event.key == pygame.K_LEFT:
                    self.ship.moving_left = True
                elif event.key == pygame.K_SPACE:#当按下空格时，创建一发子弹，并将其加入编组bullets中
                    if len(self.bullets) < self.settings.bullet_allowed:
                        self.bullet_sound.play()
                        new_bullet = Bullet(self)
                        self.bullets.add(new_bullet)
                elif event.key == pygame.K_q:#按下Q键则可退出游戏
                    self._exit_game()
                elif event.key == pygame.K_p:#按下P键即可开始游戏
                    # 重置游戏统计信息
                    self.settings.initialize_dynamic_settings()
                    self.stats.reset_stats()
                    self.stats.game_active = True
                    self.sb.prep_score()
                    self.sb.prep_level()  # 初始化游戏等级
                    self.sb.prep_ships()  # 生成左上角的命数
                    # 清空余下的外星人和子弹
                    self.aliens.empty()
                    self.bullets.empty()
                    # 创建一群新的外星人并让飞船居中
                    self._creat_fleet()
                    self.ship.center_ship()
                    # 隐藏鼠标的光标
                    pygame.mouse.set_visible(False)
            elif event.type == pygame.KEYUP:#松开键盘按键时的操作
                if event.key == pygame.K_RIGHT:
                    self.ship.moving_right = False
                elif event.key == pygame.K_LEFT:
                    self.ship.moving_left = False
            elif event.type == pygame.MOUSEBUTTONDOWN:#按下鼠标时的操作
                mouse_pos = pygame.mouse.get_pos()#获得鼠标点击位置的坐标，再与play按钮进行“碰撞”对比
                self._check_play_button(mouse_pos)
    def _check_play_button(self, mouse_pos):
        '''在玩家单击Play按钮时开始新游戏'''
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:# 解决放置按钮消失后，点击按钮位置仍重置游戏的问题
            # 重置游戏统计信息
            self.settings.initialize_dynamic_settings()  # 重置游戏难度
            self.stats.reset_stats()
            self.stats.game_active = True
            self.sb.prep_score()#初始化显示计数板
            self.sb.prep_level()#初始化游戏等级
            self.sb.prep_ships()#生成左上角的命数
            # 清空余下的外星人和子弹
            self.aliens.empty()
            self.bullets.empty()
            #创建一群新的外星人并让飞船居中
            self._creat_fleet()
            self.ship.center_ship()
            # 隐藏鼠标的光标
            pygame.mouse.set_visible(False)
    def _update_screen(self):
        self.screen.fill(self.settings.bg_color)  # 每次循环将设定的背景颜色写入
        # 绘制飞船
        self.ship.blitme()
        #绘制外星人
        self.aliens.draw(self.screen)
        #遍历编组的所有sprite，并将子弹全部绘制出来
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()
        #显示得分
        self.sb.show_score()
        #当游戏非活动状态时，绘制play按钮
        if not self.stats.game_active:
            self.play_button.draw_button()
        # 让最近绘制的屏幕可见
        pygame.display.flip()  # 此举将不断刷新屏幕，显示元素的新位置，营造平滑移动效果
    def _update_bullets(self):
        '''更新子弹位置并删除消失窗口的子弹'''
        self.bullets.update()  # 更新子弹位置，会对编组所有sprite进行一次更新
        # 删除消失的子弹
        for bullet in self.bullets.copy():  # for的循环遍历无法修改列表，因此遍历副本，而删除编组中对应的子弹
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)
        # print(len(self.bullets)) 可检查实时的子弹数量
        self._check_bullet_alien_collisions()#调用检查是否发生碰撞的辅助方法
    def _check_bullet_alien_collisions(self):
        # 检查是否有子弹集中外星人，如果发生“碰撞”，就删除相应的子弹以及外星人(两个True的用处)
        collisions = pygame.sprite.groupcollide(
            self.bullets,self.aliens,True,True
        )
        if collisions:  # 若碰撞则加分(防止一个子弹消灭多个外星人时只加入一个分数)
            self.hit_sound.play()
            for aliens in collisions.values():  # 因为发生碰撞的值 是一个列表
                self.stats.score += self.settings.alien_point * len(aliens)
                self.sb.prep_score()    # 绘制分数
                self.sb.check_high_score()  # 检查目前得分是否是最高分（以此及时更新）
        if not self.aliens:
            # 如果一群外星人被消灭后，那么删除现有的子弹并新建一群外星人
            self.bullets.empty()
            self._creat_fleet()
            # 提高游戏难度
            self.settings.increase_speed()
            self.stats.level +=1  # 提高等级
            self.sb.prep_level()    # 将新等级显示出来
    def _update_aliens(self):
        '''检查外星人是否位于屏幕边缘，并更新外星人的位置'''
        self._check_fleet_edges()
        self.aliens.update()
        # 检测外星人与飞船是否发生碰撞,是则去相应
        if pygame.sprite.spritecollideany(self.ship,self.aliens):
            self._ship_hit()
        # 检查外星人是否到达了底部
        self._check_aliens_bottom()
    def _ship_hit(self):
        '''响应飞船被外星人碰撞(先看有没有命，没命了就结束)'''
        if self.stats.ships_left > 0:
            # 将剩余的飞船数减1并更新计命器
            self.stats.ships_left -= 1
            self.sb.prep_ships()
            # 清空剩余的所有外星人以及子弹
            self.aliens.empty()
            self.bullets.empty()
            # 创建新的外星人，并将飞船放置在屏幕底部的中间
            self._creat_fleet()
            self.ship.center_ship()  # 调用方法去重新放置
            # 暂停,结束后，由于while循环，开始进行update_screen
            sleep(1)
        else:
            self.stats.game_active = False
            # 播放死亡音效
            self.dead_sound.play()
            pygame.mouse.set_visible(True)# 游戏结束后，让鼠标的光标重新亮起来
    def _check_aliens_bottom(self):
        '''检查是否有外星人到达了屏幕底部'''
        screen_rect = self.screen.get_rect()
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= screen_rect.bottom:
                # 碰到底等同于碰到飞船
                self._ship_hit()
                break
    def _exit_game(self):
        '''退出游戏时，将最高得分记录给记忆，下次打开时仍有该记录'''
        with open('high_score_record.txt','w') as file_object:
            file_object.write(str(self.stats.high_score))
        sys.exit()


if __name__ == '__main__':
    # 创建游戏实例并运行游戏
    ai = AlienInvasion()
    ai.run_game()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252

2.外星人（alien.py）

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
    '''表示单个外星人的类'''

    def __init__(self, ai_game):
        '''初始化外星人并设置其初始位置'''
        super().__init__()
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        # 加载外星人图像并设置其rect属性
        self.image = pygame.image.load('images/alien.bmp')
        self.rect = self.image.get_rect()

        # 每个外星人最初都在屏幕的左上角附近
        self.rect.x = self.rect.width
        self.rect.y = self.rect.height

        #储存外星人的精确水平位置,以便精确外星人的水平移动速度
        self.x = float(self.rect.x)
    def check_edges(self):
        '''如果外星人位于屏幕边缘，就返回True'''
        screen_rect = self.screen.get_rect()
        if self.rect.right >= screen_rect.right or self.rect.left <= 0:
            return True
    def update(self):
        '''向右移动外星人'''
        self.x += (self.settings.alien_speed * self.settings.fleet_direction)
        self.rect.x = self.x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3.子弹（bullet.py）

import pygame
from pygame.sprite import Sprite

class Bullet(Sprite):
    ''' 管理飞船发射子弹的类 '''
    def __init__(self,ai_game):
        '''在飞船的当前位置创建一个子弹的对象'''
        super().__init__()# 这里是由Bullet继承了Sprite
        self.screen = ai_game.screen
        self.settings = ai_game.settings
        self.color = ai_game.settings.bullet_color
        # 在（0，0）处创建一个代表子弹的矩形，再设置正确的位置
        self.rect = pygame.Rect(0,0,self.settings.bullet_width,
                                self.settings.bullet_height)  # 这里从setting中获得子弹的宽度和高度
        self.rect.midtop = ai_game.ship.rect.midtop  # 将子弹的真正位置放置在飞船上，看起来是从飞船的顶部出发
        # 存储用小数表示的子弹位置，这样可以微调子弹的速度
        self.y = float(self.rect.y)
    def update(self):
        '''向上移动子弹'''
        # 更新表示子弹位置的小数值
        self.y -= self.settings.bullet_speed
        self.rect.y = self.y
    def draw_bullet(self):
        '''在屏幕上绘制子弹'''
        pygame.draw.rect(self.screen,self.color,self.rect)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4.飞船（ship.py）

import pygame
from pygame.sprite import Sprite
class Ship(Sprite):
    '''管理飞船的类'''
    def __init__(self,ai_game):
        super().__init__()
        '''初始化飞船并设置其初始位置'''
        self.screen = ai_game.screen#获得初始的实例屏幕，以供绘制飞船
        self.setting = ai_game.settings#主要是设置其飞船的移动速度
        self.screen_rect = ai_game.screen.get_rect()#获得屏幕的rect属性，以便将飞船放在屏幕的底中部
        #加载飞船图像并获取其外接矩形
        self.image = pygame.image.load('images/ship.bmp')
        self.rect = self.image.get_rect()#获得飞船的rect以便移动飞船位置
        #对于每艘新飞船，都将放在其最底部的中间。
        self.rect.midbottom = self.screen_rect.midbottom#pygame使用此处的rect属性来放置飞船图像
        #允续飞船的属性x（坐标）中存储小数值,以便以更精确的速度进行移动,由于不能直接改变rect，因此加入中介
        self.x = float(self.rect.x)
        #移动标志
        self.moving_right = False
        self.moving_left = False
    def blitme(self):
        '''在指定位置绘制飞船'''
        self.screen.blit(self.image,self.rect)
    def update(self):
        '''根据移动标志来调整飞船的位置（加个and是防止飞到窗口外面）'''
        if self.moving_right and self.rect.right < self.screen_rect.right:
            self.x += self.setting.ship_speed
        if self.moving_left and self.rect.left > 0:
            self.x -= self.setting.ship_speed
        #根据self.x，将其数值再跟更新至屏幕上,但注意，其实rect只提取整数部分
        self.rect.x = self.x
    def center_ship(self):
        '''放置飞船在屏幕底部中央'''
        self.rect.midbottom = self.screen_rect.midbottom
        self.x = float(self.rect.x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

5.设置（setting.py）

class Settings:
    '''储存游戏中所有设置的类'''
    def __init__(self):
        '''初始化游戏的静态设置'''
        # 屏幕设置
        self.screen_width = 1200
        self.screen_height = 750
        self.bg_color = (230,230,230)
        # 飞船设置
        self.ship_limit = 3
        # 子弹设置
        self.bullet_width = 3
        self.bullet_height = 15
        self.bullet_color = (60, 60, 60)
        self.bullet_allowed = 3  # 限制最大的子弹数量
        # 外星人设置
        self.fleet_drop_speed = 10 # 外星人撞到屏幕时向下的速度
        # fleet_direction为1表示右移，为-1表示左移
        self.fleet_direction = 1
        #将外星人消灭干净后，将加快游戏的节奏
        self.speedup_scale = 1.1 #游戏速度提高值
        self.score_scale = 1.5 #增分速度提高值
        self.initialize_dynamic_settings()
    def initialize_dynamic_settings(self):
        '''初始化随游戏进行变化的设置'''
        self.ship_speed = 1.5
        self.bullet_speed = 3.0
        self.alien_speed = 1.0
        self.fleet_direction = 1  # 外星人向右跑
        # 计分
        self.alien_point = 50
    def increase_speed(self):
        '''提高速度设置和外星人分数'''
        self.ship_speed *= self.speedup_scale
        self.bullet_speed *= self.speedup_scale
        self.alien_speed *= self.speedup_scale
        self.alien_point = int(self.alien_point * self.score_scale) #为了让分数成为整数，因此使用int

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

6.画面上方的各项计分板（scoreboard.py）

import  pygame.font
from pygame.sprite import Group

from ship import Ship
class Scoreboard:
    '''显示得分信息的类'''
    def __init__(self,ai_game):
        '''初始化显示得分设计的属性'''
        self.ai_game = ai_game
        self.screen = ai_game.screen
        self.screen_rect = self.screen.get_rect()
        self.settings = ai_game.settings
        self.stats = ai_game.stats

        # 显示得分信息时使用的字体
        self.text_color = (30, 30, 30)
        self.font = pygame.font.Font('楷体_GB2312.ttf', 30)   #为显示中文做的准备
        #准备初始得分图像
        self.prep_score()
        self.prep_high_score()
        self.prep_level()
        self.prep_ships()
    def prep_score(self):
        '''将得分转化为一幅渲染的图片'''
        rounded_score = round(self.stats.score, -1)  # 第二个本应时指定小数位，但负数表示
        # round将舍入最近的10整数倍
        score_str ="得分："+ "{:,}".format(rounded_score)#字符串格式设置指令，将数值转换为字符串时插入逗号
        self.score_image = self.font.render(
            score_str, True, self.text_color, self.settings.bg_color
        )
        # 在屏幕右上角显示得分
        self.score_rect = self.score_image.get_rect()
        self.score_rect.right = self.screen_rect.right - 20
        self.score_rect.top = 20
    def show_score(self):
        '''在屏幕上显示得分、最高分、等级和余下的飞船数'''
        self.screen.blit(self.score_image,self.score_rect)
        self.screen.blit(self.high_score_image, self.high_score_rect)
        self.screen.blit(self.level_image, self.level_rect)
        self.ships.draw(self.screen)
    def prep_high_score(self):
        '''将最高得分转换为渲染的图像'''
        high_score = round(self.stats.high_score, -1)
        high_score_str = "历史最高得分："+"{:,}".format(high_score)
        self.high_score_image = self.font.render(high_score_str, True,
                                                 self.text_color, self.settings.bg_color)\
        #将最高得分放在屏幕顶部的中央
        self.high_score_rect = self.high_score_image.get_rect()
        self.high_score_rect.centerx = self.screen_rect.centerx
        self.high_score_rect.top = self.score_rect.top
    def check_high_score(self):
        '''检查是否诞生了新的最高分'''
        if self.stats.score > self.stats.high_score:
            self.stats.high_score = self.stats.score
            self.prep_high_score()
    def prep_level(self):
        '''将等级转换为渲染的图像。'''

        level_str = "等级："+str(self.stats.level)
        self.level_image = self.font.render(level_str, True
                                            , self.text_color, self.settings.bg_color)
        #将等级放在得分的下面
        self.level_rect = self.level_image.get_rect()
        self.level_rect.right = self.score_rect.right
        self.level_rect.top = self.score_rect.bottom + 10
    def prep_ships(self):
        '''显示还余下多少艘飞船，即显示飞船的剩余命数'''
        self.ships = Group()    # 创建一个空编组
        for ship_number in range(self.stats.ships_left):
            ship = Ship(self.ai_game)
            ship.rect.x = 10 + ship_number * ship.rect.width  # 无论有多少个都能排列开
            ship.rect.y = 10
            self.ships.add(ship)    # 将每艘新飞船加入到ships以供显示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

7.游戏内的统计信息（game_stats.py）

class GameStats:
    '''跟踪游戏的统计信息'''
    def __init__(self,ai_game):
        '''初始化统计信息'''
        self.settings = ai_game.settings
        self.reset_stats()
        # 游戏刚启动时处于非活动状态（等点击“开始”）
        self.game_active = False
        #最高得分记录（任何情况下不重置）
        self.high_score = 0
        self._update_high_score()
    def reset_stats(self):
        '''初始化在游戏运行期间可以变化的统计信息'''
        self.ships_left = self.settings.ship_limit# 一开始玩家拥有的飞船数
        self.score = 0
        self.level = 1
    def _update_high_score(self):
        with open('high_score_record.txt') as file_object:
            self.high_score = int(file_object.read())
        if not self.high_score:
            self.high_score = 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8.开始按钮（button.py）

import pygame.font

class Button:

    def __init__(self, ai_game, msg):
        '''初始化按钮的属性'''
        self.screen = ai_game.screen
        self.screen_rect = self.screen.get_rect()

        # 设置按钮的尺寸和其他属性
        self.width, self.height = 200, 50
        self.button_color = (0, 255, 0)
        self.text_color = (255, 255, 255)
        self.font = pygame.font.Font('楷体_GB2312.ttf', 30)# None指的是默认字体，48指的是文本的字号
        #创建按钮的rect对象，并使其居中
        self.rect = pygame.Rect(0, 0, self.width, self.height)
        self.rect.center = self.screen_rect.center
        #按钮的标签只需创造一次
        self._prep_msg(msg)
    def _prep_msg(self,msg):
        '''将msg渲染为图像，并使其在按钮上居中'''
        # font.render函数将存储在msg中的文本转换成图像，再将图像存储在self.msg_image中
        self.msg_image = self.font.render(msg, True, self.text_color,
                                          self.button_color)  # True为反锯齿效果打开（平滑文本边缘）
        self.msg_image_rect = self.msg_image.get_rect()
        self.msg_image_rect.center = self.rect.center
    def draw_button(self):
        # 绘制一个用颜色填充的按钮，再绘制文本
        self.screen.fill(self.button_color,self.rect)
        self.screen.blit(self.msg_image,self.msg_image_rect)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30