import pygame
import sys
import traceback
import myplane  # 调用myplane.py
import enemy  # 调用enemy.py
import bullet  # 调用bullet.py
import supply  # 调用supply.py
from pygame.locals import *
from random import *
import random

pygame.init()  # 初始化游戏
pygame.mixer.init()  # 初始化声音模块

bg_size = width, height = 800, 600  # 游戏区域的大小
screen = pygame.display.set_mode(bg_size)
pygame.display.set_caption('基于打飞机的算术题')

background = pygame.image.load('images/timg.png').convert()  # 设置背景图片

# 定义常量，代表颜色
BLACK = (0, 0, 0)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
WHITE = (255, 255, 255)

myfont = pygame.font.Font(None, 80)

# 载入音乐
# pygame.mixer用于加载和播放声音的pygame模块
pygame.mixer.music.load('sound/game_music.ogg')  # 加载背景音乐
pygame.mixer.music.set_volume(0.2)  # 设置背景音乐音量为0.2

bullet_sound = pygame.mixer.Sound('sound/bullet.wav')  # 创建普通子弹音效对象
bullet_sound.set_volume(0.2)  # 设置音效音量为0.2

bomb_sound = pygame.mixer.Sound('sound/use_bomb.wav')  # 创建使用炸弹音效
bomb_sound.set_volume(0.2)

supply_sound = pygame.mixer.Sound('sound/supply.wav')  #
supply_sound.set_volume(0.2)

get_bomb_sound = pygame.mixer.Sound('sound/get_bomb.wav')  # 创建捡到炸弹补给音效
get_bomb_sound.set_volume(0.2)

get_bullet_sound = pygame.mixer.Sound('sound/get_bullet.wav')
get_bullet_sound.set_volume(0.2)

upgrade_sound = pygame.mixer.Sound('sound/upgrade.wav')
upgrade_sound.set_volume(0.2)

enemy3_fly_sound = pygame.mixer.Sound('sound/enemy3_flying.wav')
enemy3_fly_sound.set_volume(0.6)

enemy1_down_sound = pygame.mixer.Sound('sound/enemy1_down.wav')
enemy1_down_sound.set_volume(0.2)

enemy2_down_sound = pygame.mixer.Sound('sound/enemy2_down.wav')
enemy2_down_sound.set_volume(0.2)

enemy3_down_sound = pygame.mixer.Sound('sound/enemy3_down.wav')
enemy3_down_sound.set_volume(0.2)

me_down_sound = pygame.mixer.Sound('sound/me_down.wav')  # 设置我方飞机坠毁音效
me_down_sound.set_volume(0.2)


"""
def get_random_word():
    color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))  # 颜色随机
    x = random.randint(100, width - 100)  # x坐标从左右边距各100之间随机
    y = 0
    a = random.randint(65, 90)
    # list = ['+', '*']  # 序列 可以增加减法和除法，但无法控制正负和整数
    b = random.randint(48, 57)
    c = [a, b]
    # word = a + b + c
    word = random.choice(c)
    return x, y, word, color
"""
def get_random_word():
    color = (random.randint(0, 255),random.randint(0, 255),random.randint(0, 255)) # 颜色随机
    x = random.randint(100, width-100) # x坐标从左右边距各100之间随机
    y = 0
    a=chr(random.randint(48, 53))
    #list=['+','*']  #序列 可以增加减法和除法，但无法控制正负和整数
    #b=random.choice(list)
    b="+"
    c=chr(random.randint(48, 52))
    word1 = str(a+b+c) #5以内加减法保证结果为一位数

    return x,y,word1,color


# 敌方飞机分为大中小3种，速度依次增加减小
# def add_small_enemies(group1, group2, num):  # 添加小号飞机
#     for i in range(num):
#         e1 = enemy.SmallEnemy(bg_size)  # 调用enemy.py里的SmallEnemy方法，
#         group1.add(e1)
#         group2.add(e1)
#
#
# def add_mid_enemies(group1, group2, num):  # 添加中号飞机
#     for i in range(num):
#         e2 = enemy.MidEnemy(bg_size)
#         group1.add(e2)
#         group2.add(e2)
#
#
# def add_big_enemies(group1, group2, num):  # 添加大号飞机
#     for i in range(num):
#         e3 = enemy.BigEnemy(bg_size)
#         group1.add(e3)
#         group2.add(e3)


def inc_speed(target, inc):
    for each in target:
        each.speed += inc


def main():
    #设定字母，20ms移动一格
    diff_ticks = 20
    ticks = pygame.time.get_ticks() + diff_ticks

    word_diff_ticks = 1000
    word_ticks = pygame.time.get_ticks() + word_diff_ticks

    # 播放音乐
    pygame.mixer.music.play(-1)  # 无限重复播放

    # 实例我方飞机
    me = myplane.MyPlane(bg_size=bg_size)  # 调用mylpane文件中的MyPlane方法，实例我方飞机

    # 实例敌方飞机
    # enemies = pygame.sprite.Group()   # 定义一个Group组
    #
    # # 实例敌方小型飞机15个
    # small_enemies = pygame.sprite.Group()    # pygame.sprite.Group()，用于保存和管理多个Sprite对象的容器类
    # add_small_enemies(small_enemies, enemies, 15)   # 往small_enemies, enemies都添加15个敌机
    #
    # # 实例敌方中型飞机4个
    # mid_enemies = pygame.sprite.Group()
    # add_mid_enemies(mid_enemies, enemies, 4)
    #
    # # 实例敌方大型飞机2个
    # big_enemies = pygame.sprite.Group()
    # add_big_enemies(big_enemies, enemies, 2)
    '''
    此处实例小中大敌机分别为15、4、2个，以此可以控制三种类型敌机的出现频率，可以简单的理解为出现15个小型敌机的过程中，会出现4个中型敌机，2个大型敌机
    '''

    # 实例普通子弹
    bullet1 = []  # 建立一个列表用于把生成的子弹都放到这个bullet1列表里边去
    bullet1_index = 0  # 一个一个生成我们需要从这个bullet1列表里边里边索引，所以我们先bullet1_index = 0给他一个用来索引列表的变量
    BULLET1_NUM = 4  # 定义总共有4颗子弹，因为我们发现只用4颗子弹在加上他这个速度刚好就完成了屏幕大约80%的射程
    # 添加4个普通子弹
    for i in range(BULLET1_NUM):  # 依次生成子弹，实例化子弹对象
        # me.rect.midtop其实是在画布中展示这样的效果： 飞机的正中间发射出子弹
        bullet1.append(bullet.Bullet1(me.rect.midtop))  # 调用bullet.py里的Bullet1方法；把实例化后的子弹都添加到bullet1=[]列表

    # 实例超级子弹
    bullet2 = []
    bullet2_index = 0
    BULLET2_NUM = 8
    # 添加4个超级子弹
    for i in range(BULLET2_NUM // 2):
        bullet2.append(bullet.Bullet2((me.rect.centerx - 33, me.rect.centery)))
        bullet2.append(bullet.Bullet2((me.rect.centerx + 30, me.rect.centery)))

    arr = []
    arr.append(get_random_word())
    clear_word = 0

    # 设置难度
    level = 1  # 初始化难度为1 ，以后分数越高，难度越大
    level_font = pygame.font.Font("font/font.ttf", 36)  # 设置字体及字号

    game_state = 1  # 1.进行中 2.游戏失败
    sign = 1

    # 中弹图片索引
    e1_destroy_index = 0
    e2_destroy_index = 0
    e3_destroy_index = 0
    me_destroy_index = 0

    # 统计得分
    score = 0
    score_font = pygame.font.Font("font/font.ttf", 36)  # 设置字体及字号

    # 标志是否暂停游戏
    paused = False  # paused变量，用于表示暂停的标志
    paused_nor_image = pygame.image.load("images/pause_nor.png").convert_alpha()
    paused_pressed_image = pygame.image.load("images/pause_pressed.png").convert_alpha()
    resume_nor_image = pygame.image.load('images/resume_nor.png').convert_alpha()
    resume_pressed_image = pygame.image.load('images/resume_pressed.png').convert_alpha()
    paused_rect = paused_nor_image.get_rect()
    paused_rect.left, paused_rect.top = width - paused_rect.width - 10, 10  # 使暂停图标位于右上角
    paused_image = paused_nor_image  # 设置默认显示的图标为上面第一张

    # 全屏炸弹
    bomb_image = pygame.image.load('images/bomb.png').convert_alpha()
    bomb_rect = bomb_image.get_rect()
    bomb_font = pygame.font.Font("font/font.ttf", 48)
    bomb_num = 3

    # 每隔30秒会有一个随机的道具补给,分为两种道具, 全屏炸弹和双倍子弹
    #bullet_supply = supply.Bullet_Supply(bg_size)  # 调用supply.py文件里的Bullet_Supply函数
    bomb_supply = supply.Bomb_Supply(bg_size)  # 调用supply.py文件里的Bomb_Supply函数
    # 定义为键盘鼠标事件
    SUPPLY_TIME = pygame.USEREVENT  # 设置一个定时器，然后这个是我们自定义事件，叫做USEREVENT 后面再有的话，命名就会变成USEREVENT+1，再有自定义事件就USEREVENT+2，以此类推…
    pygame.time.set_timer(SUPPLY_TIME, 30 * 1000)  # 第一个参数是自定义事件USEREVENT，设定为30s，1000的单位是毫秒

    # 超级子弹定时器
    #DOUBLE_BULLTET_TIME = pygame.USEREVENT + 1

    # 解除我方重生无敌定时器
    INVINCIBLE_TIME = pygame.USEREVENT + 2

    # 标志是否使用超级子弹
    is_double_bullet = False

    # 生命数量
    # life_image = pygame.image.load('images/life.png').convert_alpha()
    # life_rect = life_image.get_rect()
    # life_num = 3

    # 用于切换我方飞机图片
    switch_plane = True  # 布尔类型的变量，接着在绘制玩家飞机的时候，那么我们就通过判断和变换这个变量，不断切换地绘制两张图片

    # 游戏结束画面
    gameover_font = pygame.font.Font("font/font.TTF", 48)
    again_image = pygame.image.load("images/again.png").convert_alpha()
    again_rect = again_image.get_rect()
    gameover_image = pygame.image.load("images/gameover.png").convert_alpha()
    gameover_rect = gameover_image.get_rect()

    # 用于延迟切换
    delay = 100

    # 限制打开一次记录文件
    recorded = False

    clock = pygame.time.Clock()
    running = True  # 用来控制游戏结束的

    # 这里是游戏的正式部分，游戏循环 -> 意味着游戏的正式开始！
    while running:
        # 监听用户事件
        for event in pygame.event.get():
            if event.type == QUIT:  # 判断用户是否点击了关闭按钮
                pygame.quit()
                sys.exit()

            elif event.type == MOUSEBUTTONDOWN:  # 鼠标按下
                if event.button == 1 and paused_rect.collidepoint(
                        event.pos):  # 检查鼠标左键是否被按下，并且鼠标位置是否在一个名为 paused_rect 的矩形区域内
                    paused = not paused  # 这里判断到鼠标左键按下暂停键，则赋值取反，表示状态转换
                    if paused:  # 如果状态变为暂停
                        pygame.time.set_timer(SUPPLY_TIME, 0)  # 定时器时间，0即不发生
                        pygame.mixer.music.pause()  # 音乐暂停
                        pygame.mixer.pause()  # 暂停播放所有通道
                        game_state = 3
                    else:
                        pygame.time.set_timer(SUPPLY_TIME, 30 * 1000)
                        word_ticks = pygame.time.get_ticks()
                        pygame.mixer.music.unpause()  # 恢复音乐播放
                        pygame.mixer.unpause()  # 恢复播放所有通道
                        game_state = 1

            elif event.type == MOUSEMOTION:  # 通过响应 MOUSEMOTION 事件，我们可以改变按钮的样式。就是当我们mousemotion，鼠标的位置刚好在这个按钮上方的话，就会对应变成颜色比较深的图片按钮
                if paused_rect.collidepoint(event.pos):  # 鼠标在暂停键按钮上方
                    if paused:  # 如果此时为暂停状态
                        paused_image = resume_pressed_image  # 图标变为颜色较深的resume_pressed.png
                    else:  # 如果此时为运行状态
                        paused_image = paused_pressed_image  # 图标变为颜色较深的paused_pressed.png
                else:  # 鼠标已移开
                    if paused:  # 游戏暂停
                        paused_image = resume_nor_image  # 切换图标
                    else:
                        paused_image = paused_nor_image

            elif event.type == KEYDOWN:  # 判断是不是按键按下事件
                if event.key == K_SPACE:  # 是否按下空格
                    if bomb_num:  # 炸弹数量>0
                        bomb_num -= 1  # 判定为释放炸弹，数量减1
                        bomb_sound.play()  # 播放炸弹音效
                        arr.clear()
                        # for each in enemies:    #检测所有敌机
                        #     if each.rect.bottom > 0:  #如果敌机的bottom>0，即已经在屏幕上
                        #         each.active = False   #所有敌机都死
                #if game_state == 1 and len(arr) > 0:
                    #if event.key == arr[0][2] + 32 or event.key == arr[0][2]:  # 大小写字母差32
                if len(arr) > 0 :  # 判断输入字符是否与生成一致
                    if event.key == eval(f"{arr[0][2]}") + 48:
                        score = score+1
                        arr.pop(0)
                        clear_word += 1
                        if clear_word >= level * 10:
                            level += 1
                            pygame.display.set_caption('typing level:%d' % level)
                            diff_ticks = diff_ticks * 0.9
                            word_diff_ticks = word_diff_ticks * 0.95

            elif event.type == SUPPLY_TIME:  # 检测补给包定时器自定义事件
                supply_sound.play()
                if choice([True, False]):  # 我们设置两种补给，所以在True和False中随机选择，若选到True，炸弹补给
                    bomb_supply.reset()
                # else:
                #     bullet_supply.reset()  # 选到False，双倍子弹补给

            # elif event.type == DOUBLE_BULLTET_TIME:  # 双倍子弹事件
            #     is_double_bullet = False
            #     pygame.time.set_timer(DOUBLE_BULLTET_TIME, 0)

            elif event.type == INVINCIBLE_TIME:  # 响应解除我方重生无敌定时器事件
                me.invincible = False
                pygame.time.set_timer(INVINCIBLE_TIME, 0)

        screen.fill((255, 255, 255))
        screen.blit(background, (0, 0))  # 将背景图片渲染到屏幕上
        for i in range(len(arr)):  # 绘制这些字母
            x, y, word, c = arr[i]
            if i == 0 and sign:
                c = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
            textImage = myfont.render(str(word), True, c)
            screen.blit(textImage, (x, y))

        if game_state == 3:
            textImage = myfont.render("Wait a minute", True, (123, 43, 226))
            sw, sh = textImage.get_size()
            screen.blit(textImage, ((width - sw) / 2, (height - sh) / 2))  # 居中显示

        # if game_state == 2:
        #      textImage = myfont.render("Level%d fail" % level, True, (255, 0, 0))
        #      sw, sh = textImage.get_size()
        #      screen.blit(textImage, ((width - sw) / 2, (height - sh) / 2))  # 居中显示

        if game_state == 1:
            if pygame.time.get_ticks() >= word_ticks:  # 计时增加新字母
                word_ticks += word_diff_ticks
                arr.append(get_random_word())

            if pygame.time.get_ticks() >= ticks:
                ticks += diff_ticks
                sign = 1 - sign
                for i in range(len(arr)):
                    x, y, word, c = arr[i]
                    arr[i] = (x, y + 1, word, c)
                if len(arr) > 0 and arr[0][1] > height: game_state = 2

        if game_state == 2:

            # 背景音乐停止
            pygame.mixer.music.stop()

            # 停止全部音效
            pygame.mixer.stop()

            # 停止发放补给
            pygame.time.set_timer(SUPPLY_TIME, 0)

            if not recorded:
                recorded = True
                # 读取历史最高分
                with open('record.txt', 'r') as f:
                    record_score = int(f.read())

                # 判断是否高于历史最高分
                if score > record_score:
                    with open('record.txt', 'w') as f:
                        f.write(str(score))

            # 绘制结束界面
            record_score_text = score_font.render("Best : %d" % record_score, True, (0, 0, 0))
            screen.blit(record_score_text, (10, 80))

            gameover_text1 = gameover_font.render("Your Score", True, (0, 0, 0))
            gameover_text1_rect = gameover_text1.get_rect()
            gameover_text1_rect.left, gameover_text1_rect.top = \
                (width - gameover_text1_rect.width) // 2, height // 3
            screen.blit(gameover_text1, gameover_text1_rect)

            gameover_text2 = gameover_font.render(str(score), True, (0, 0, 0))
            gameover_text2_rect = gameover_text2.get_rect()
            gameover_text2_rect.left, gameover_text2_rect.top = \
                (width - gameover_text2_rect.width) // 2, \
                gameover_text1_rect.bottom + 10
            screen.blit(gameover_text2, gameover_text2_rect)

            again_rect.left, again_rect.top = \
                (width - again_rect.width) // 2, \
                gameover_text2_rect.bottom + 50
            screen.blit(again_image, again_rect)

            gameover_rect.left, gameover_rect.top = \
                (width - again_rect.width) // 2, \
                again_rect.bottom + 10
            screen.blit(gameover_image, gameover_rect)

            # 检测用户的鼠标操作
            # 如果用户按下鼠标左键
            if pygame.mouse.get_pressed()[0]:
                # 获取鼠标坐标
                pos = pygame.mouse.get_pos()
                # 如果用户点击“重新开始”
                if again_rect.left < pos[0] < again_rect.right and \
                        again_rect.top < pos[1] < again_rect.bottom:
                    # 调用main函数，重新开始游戏
                    main()
                # 如果用户点击“结束游戏”
                elif gameover_rect.left < pos[0] < gameover_rect.right and \
                        gameover_rect.top < pos[1] < gameover_rect.bottom:
                    # 退出游戏
                    pygame.quit()
                    sys.exit()

        # 根据用户得分增加难度
        # if level == 1 and score > 50000:
        #     level = 2
        #     upgrade_sound.play()   # 播放音乐
        #     # 增加3架小型敌机, 2架中型敌机和1架大型敌机
        #     add_small_enemies(small_enemies, enemies, 3)
        #     add_mid_enemies(mid_enemies, enemies, 2)
        #     add_big_enemies(big_enemies, enemies, 1)
        #     # 提升小型敌机的速度以提高难度
        #     inc_speed(target=small_enemies, inc=1)
        #
        # elif level == 2 and score > 300000:
        #     level = 3
        #     upgrade_sound.play()
        #     # 增加5架小型敌机, 3架中型敌机和2架大型敌机
        #     add_small_enemies(small_enemies, enemies, 5)
        #     add_mid_enemies(mid_enemies, enemies, 3)
        #     add_big_enemies(big_enemies, enemies, 2)
        #     # 提升小中型敌机的速度
        #     inc_speed(target=small_enemies, inc=1)
        #     inc_speed(target=mid_enemies, inc=1)
        #
        # elif level == 3 and score > 600000:
        #     level = 4
        #     upgrade_sound.play()
        #     # 增加5架小型敌机, 3架中型敌机和2架大型敌机
        #     add_small_enemies(small_enemies, enemies, 5)
        #     add_mid_enemies(mid_enemies, enemies, 3)
        #     add_big_enemies(big_enemies, enemies, 2)
        #     # 提升小中型敌机的速度
        #     inc_speed(target=small_enemies, inc=1)
        #     inc_speed(target=mid_enemies, inc=1)
        #
        # elif level == 4 and score > 1000000:
        #     level = 5
        #     upgrade_sound.play()
        #     # 增加5架小型敌机, 3架中型敌机和2架大型敌机
        #     add_small_enemies(small_enemies, enemies, 5)
        #     add_mid_enemies(mid_enemies, enemies, 3)
        #     add_big_enemies(big_enemies, enemies, 2)
        #     # 提升小中大型敌机的速度
        #     inc_speed(target=small_enemies, inc=1)
        #     inc_speed(target=mid_enemies, inc=1)
        #     inc_speed(target=big_enemies, inc=1)
        if not paused and game_state != 3:  # 3条命没用完，且游戏进行中
            # 检测键盘操作
            key_pressed = pygame.key.get_pressed()
            # 可以按上下左右控制方向，也可以wsaf控制方向
            if key_pressed[K_UP]:
                me.moveUp()
            if key_pressed[K_DOWN]:
                me.moveDown()
            if key_pressed[K_LEFT]:
                me.moveLeft()
            if key_pressed[K_RIGHT]:
                me.moveRight()

            # 绘制全屏炸弹补给
            if bomb_supply.active:  # active为Ture，即存在该补给
                bomb_supply.move()
                screen.blit(bomb_supply.image, bomb_supply.rect)  # 绘制
                if pygame.sprite.collide_mask(me, bomb_supply):  # 冲突检测，即画面碰撞到一起
                    get_bomb_sound.play()  # 播放音乐
                    if bomb_num < 3:  # 最多只有3个全屏炸弹
                        bomb_num += 1
                    bomb_supply.active = False  # 补给被获得，从屏幕上消失

            # 绘制超级子弹
            # if bullet_supply.active:
            #     bullet_supply.move()
            #     screen.blit(bullet_supply.image, bullet_supply.rect)
            #     if pygame.sprite.collide_mask(me, bullet_supply):
            #         get_bullet_sound.play()
            #         # 发射超级子弹
            #         is_double_bullet = True
            #         pygame.time.set_timer(DOUBLE_BULLTET_TIME, 18 * 1000)  # 超级子弹持续18s
            #         bullet_supply.active = False

            # 发射子弹
            # if not (delay % 10):  # 是这延迟100
            #     bullet_sound.play()
            #     if is_double_bullet:
            #         bullets = bullet2
            #         bullets[bullet2_index].reset((me.rect.centerx - 33, me.rect.centery))
            #         bullets[bullet2_index + 1].reset((me.rect.centerx + 30, me.rect.centery))
            #         bullet2_index = (bullet2_index + 2) % BULLET2_NUM
            #     else:
            #         bullets = bullet1
            #         bullets[bullet1_index].reset(me.rect.midtop)
            #         bullet1_index = (
            #                                     bullet1_index + 1) % BULLET1_NUM  # 把bullet1_index指向下一个索引，且最多不能超过4，所以 % BULLET1_NUM 就可以完成了

            # 检测子弹是否击中敌机
            # for b in bullets:
            #     if b.active:  # 只有活动的子弹才可能击中敌机
            #         b.move()  # 让子弹飞起来
            #         screen.blit(b.image, b.rect)  # 把子弹画出来
            #         enemy_hit = pygame.sprite.spritecollide(b, enemies, False, pygame.sprite.collide_mask)   # 检测是否碰撞
            #         if enemy_hit:
            #             b.active = False  # 碰撞到里则隐藏该子弹
            #             for each in enemy_hit:
            #                 each.hit = True
            #                 each.energy -= 1
            #                 if each.energy == 0:   # 血槽清0则敌机生命结束，消失
            #                     each.active = False

            # 绘制敌方大型机
            # for each in big_enemies:
            #     if each.active:
            #         each.move()
            #         if each.hit:      #如果被打到
            #             screen.blit(each.image_hit, each.rect)  # 绘制碰撞特效
            #             each.hit = False
            #         else:
            #             if switch_plane:  # 切换飞机图片
            #                 screen.blit(each.image1, each.rect)
            #             else:
            #                 screen.blit(each.image2, each.rect)
            #
            #         # 绘制血槽
            #         pygame.draw.line(screen, BLACK,      #画在screen 对象上，黑色
            #                          (each.rect.left, each.rect.top - 5),  #开始：飞机矩形对象左上角往上大概5个像素的距离
            #                          (each.rect.right, each.rect.top - 5),  #结束：飞机矩形对象左上角往上大概5个像素的距离
            #                          2)   #直线宽度为2
            #
            #         # 当生命大于20%显示绿色, 否则显示红色
            #         energy_remain = each.energy / enemy.BigEnemy.energy   #计算剩余生命值比例
            #         if energy_remain > 0.2:
            #             energy_color = GREEN   #血量>20%显示为绿色
            #         else:
            #             energy_color = RED   #否则显示为红色
            #         #绘制血条
            #         pygame.draw.line(screen, energy_color,
            #                          (each.rect.left, each.rect.top - 5),
            #                          (each.rect.left + each.rect.width * energy_remain,   #血条总长等于全血，则血量为血条长度*比例
            #                           each.rect.top - 5),
            #                          2)
            #
            #         # 即将出现在画面, 播放音效
            #         if each.rect.bottom == -10:
            #             enemy3_fly_sound.play(-1)
            #             each.appear = True
            #         # 离开画面, 关闭音效
            #         if each.rect.bottom < -10 and each.appear:
            #             enemy3_fly_sound.stop()
            #             each.appear = False
            #     else:
            #         # 毁灭
            #         if e3_destroy_index == 0:
            #             enemy3_down_sound.play()
            #         if not(delay % 2):     #每隔两帧
            #             screen.blit(each.destroy_images[e3_destroy_index], each.rect) #每一个飞机对象调用他的当前索引值索引得到的毁灭图片
            #             e3_destroy_index = (e3_destroy_index + 1) % 6  #因为大型敌机毁灭图片一共有6张图片，所以这里%6,那么这个表达式得到的值就永远是0-5之间，当e3_destroy_index=5，在加1等于6,6再%6就等于0.刚好切换会第一张毁灭的图片
            #             if e3_destroy_index == 0:
            #                 enemy3_fly_sound.stop()
            #                 score += 10000
            #                 each.reset()

            # 绘制敌方中型机
            # for each in mid_enemies:
            #     if each.active:
            #         each.move()
            #         if each.hit:    #如果被打到
            #             screen.blit(each.image_hit, each.rect)   #绘制碰撞特效
            #             each.hit = False
            #         else:
            #             screen.blit(each.image, each.rect)
            #
            #         # 绘制血槽
            #         pygame.draw.line(screen, BLACK,
            #                          (each.rect.left, each.rect.top - 5),
            #                          (each.rect.right, each.rect.top - 5),
            #                          2)
            #
            #         # 当生命大于20%显示绿色, 否则显示红色
            #         energy_remain = each.energy / enemy.MidEnemy.energy
            #         if energy_remain > 0.2:
            #             energy_color = GREEN
            #         else:
            #             energy_color = RED
            #         pygame.draw.line(screen, energy_color,
            #                          (each.rect.left, each.rect.top - 5),
            #                          (each.rect.left + each.rect.width * energy_remain,
            #                           each.rect.top - 5),
            #                          2)
            #     else:
            #         # 毁灭
            #         if e2_destroy_index == 0:
            #             enemy2_down_sound.play()
            #         if not(delay % 2):
            #             screen.blit(each.destroy_images[e2_destroy_index], each.rect)
            #             e2_destroy_index = (e2_destroy_index + 1) % 4
            #             if e2_destroy_index == 0:
            #                 score += 6000
            #                 each.reset()

            # 绘制敌方小型机
            # for each in small_enemies:
            #     if each.active:
            #         each.move()
            #         screen.blit(each.image, each.rect)
            #     else:
            #         # 毁灭
            #         if e1_destroy_index == 0:
            #             enemy1_down_sound.play()
            #         if not(delay % 2):
            #             screen.blit(each.destroy_images[
            #                         e1_destroy_index], each.rect)
            #             e1_destroy_index = (e1_destroy_index + 1) % 4
            #             if e1_destroy_index == 0:
            #                 score += 1000
            #                 each.reset()

            # 检测我方飞机碰撞
            # enemies_down = pygame.sprite.spritecollide(
            #     me, enemies, False, pygame.sprite.collide_mask)
            # # 我方飞机碰撞到敌人飞机，两者都消失
            # if enemies_down and not me.invincible:
            #     me.active = False
            #     for each in enemies_down:
            #         each.active = False

            # 绘制我方飞机
            if me.active:
                if switch_plane:
                    screen.blit(me.image1, me.rect)
                else:
                    screen.blit(me.image2, me.rect)
            # else:
            #     # 毁灭
            #     if me_destroy_index == 0:
            #         me_down_sound.play()
            #     if not (delay % 2):
            #         screen.blit(me.destroy_images[me_destroy_index], me.rect)
            #         me_destroy_index = (me_destroy_index + 1) % 4
            #         if me_destroy_index == 0:
            #             life_num -= 1  # 生命数量-1
            #             me.reset()  # 重新回到起点
            #             pygame.time.set_timer(INVINCIBLE_TIME, 3 * 1000)  #

            # 绘制全屏炸弹数量
            bomb_text = bomb_font.render("× %d" % bomb_num, True,
                                         BLACK)  # 用render渲染成一个surface对象，才能画到屏幕上，显示样式就是炸弹图片X 炸弹数量，然后渲染成surface对象
            text_rect = bomb_text.get_rect()  # 来获取它的矩形对象
            screen.blit(bomb_image, (10, height - 10 - bomb_rect.height))  # 画炸弹图片
            screen.blit(bomb_text, (20 + bomb_rect.width, height - 5 - text_rect.height))  # 画文本

            # #绘制剩余生命数量
            # if life_num:
            #     for i in range(life_num):
            #         screen.blit(life_image,
            #                     ((width - 10 - (i + 1) * life_rect.width),
            #                      height - 10 - life_rect.height))

            # 绘制得分
            score_text = score_font.render('Score : %d' % score, True, BLACK)
            screen.blit(score_text, (10, 5))
            #绘制游戏等级
            level_text = level_font.render('Level  : %d' % level, True, BLACK)
            screen.blit(level_text, (10, 40))


        # 绘制暂停按钮
        screen.blit(paused_image, paused_rect)

        # 用于切换图片
        if not (delay % 11):
            switch_plane = not switch_plane

        delay -= 1
        if not delay:
            delay = 100

        pygame.display.flip()
        clock.tick(60)


if __name__ == '__main__':  # 函数执行入口
    try:
        main()

    except SystemExit:
        pass

    except:
        traceback.print_exc()
        pygame.quit()
        input()