#! /usr/bin/python3

import pygame
from plane_sprites import *

敌机出现事件

CREATE_ENEMY_EVENT = pygame.USEREVENT

发射子弹事件

HERO_FIRE_EVENT = pygame.USEREVENT + 1

class PlaneGame:
“”“飞机大战游戏类”""

def __init__(self):
    print("游戏初始化...")

    pygame.init()

    self.screen = pygame.display.set_mode(SCREEN_RECT.size)
    self.clock = pygame.time.Clock()

    self.__create_sprites()
    PlaneGame.__create_user_events()

def __create_sprites(self):
    """创建精灵组"""

    self.back_group = pygame.sprite.Group(Background(), Background(True))

    self.hero = Hero()
    self.hero_group = pygame.sprite.Group(self.hero)

    self.enemy_group = pygame.sprite.Group()
    self.destroy_group = pygame.sprite.Group()

@staticmethod
def __create_user_events():
    """创建用户事件"""

    # 每秒添加一架敌机
    pygame.time.set_timer(CREATE_ENEMY_EVENT, 1 * 1000)

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

def start_game(self):
    """开启游戏循环"""

    while True:
        self.clock.tick(60)
        self.__event_handler()
        self.__update_sprites()
        self.__check_collide()
        pygame.display.update()

def __check_collide(self):
    """碰撞检测"""

    # 子弹摧毁敌机
    enemies = pygame.sprite.groupcollide(self.enemy_group,
                                         self.hero.bullets,
                                         False,
                                         True).keys()
    for enemy in enemies:
        enemy.life -= 1

        if enemy.life <= 0:
            enemy.add(self.destroy_group)
            enemy.remove(self.enemy_group)

            enemy.destroied()

    # 敌机撞毁英雄
    for hero in pygame.sprite.spritecollide(self.hero,
                                            self.enemy_group,
                                            True):
        print("英雄牺牲了...")
        self.hero.destroied()

def __event_handler(self):
    """事件处理"""

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            PlaneGame.__finished_game()
        elif event.type == HERO_FIRE_EVENT:
            self.hero.fire()
        elif event.type == CREATE_ENEMY_EVENT:
            self.enemy_group.add(Enemy())
        # 按下 b 英雄自爆
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_b:
            # self.hero.destroied()

            # 集体自爆
            for enemy in self.enemy_group.sprites():
                enemy.destroied()

    # 判断英雄是否已经被销毁，如果是，游戏结束！
    if self.hero.can_destroied:
        PlaneGame.__finished_game()

    # 通过 pygame.key 获取用户按键
    keys_pressed = pygame.key.get_pressed()
    dir = keys_pressed[pygame.K_RIGHT] - keys_pressed[pygame.K_LEFT]

    # 根据移动方向设置英雄的速度
    self.hero.speed = dir * 2

def __update_sprites(self):
    """更新/绘制精灵组"""

    for group in [self.back_group, self.hero_group,
                  self.hero.bullets, self.enemy_group,
                  self.destroy_group]:
        group.update()
        group.draw(self.screen)

@staticmethod
def __finished_game():
    """退出游戏"""

    print("退出游戏")
    pygame.quit()
    exit()
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

if name == ‘main’:
PlaneGame().start_game()

import random
import pygame

屏幕尺寸

SCREEN_RECT = pygame.Rect(0, 0, 480, 700)

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, *args):
    self.rect.top += self.speed

@staticmethod
def image_names(prefix, count):
    names = []
    for i in range(1, count + 1):
        names.append("./images/" + prefix + str(i) + ".png")

    return names
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Background(GameSprite):
“”“背景精灵”""

def __init__(self, is_alt=False):
    super().__init__("./images/background.png")

    if is_alt:
        self.rect.bottom = 0

def update(self, *args):
    super().update(args)

    if self.rect.top >= SCREEN_RECT.height:
        self.rect.bottom = 0
1
2
3
4
5
6
7
8
9
10
11

class PlaneSprite(GameSprite):
“”“飞机精灵，包括敌机和英雄”""

def __init__(self, image_names, destroy_names, life, speed):

    image_name = image_names[0]
    super().__init__(image_name, speed)

    # 生命值
    self.life = life

    # 正常图像列表
    self.__life_images = []
    for file_name in image_names:
        image = pygame.image.load(file_name)
        self.__life_images.append(image)

    # 被摧毁图像列表
    self.__destroy_images = []
    for file_name in destroy_names:
        image = pygame.image.load(file_name)
        self.__destroy_images.append(image)

    # 默认播放生存图片
    self.images = self.__life_images
    # 显示图像索引
    self.show_image_index = 0
    # 是否循环播放
    self.is_loop_show = True
    # 是否可以被删除
    self.can_destroied = False

def update(self, *args):
    self.update_images()

    super().update(args)

def update_images(self):
    """更新图像"""

    pre_index = int(self.show_image_index)
    self.show_image_index += 0.05
    count = len(self.images)

    # 判断是否循环播放
    if self.is_loop_show:
        self.show_image_index %= len(self.images)
    elif self.show_image_index > count - 1:
        self.show_image_index = count - 1
        self.can_destroied = True

    current_index = int(self.show_image_index)

    if pre_index != current_index:
        self.image = self.images[current_index]

def destroied(self):
    """飞机被摧毁"""

    # 默认播放生存图片
    self.images = self.__destroy_images
    # 显示图像索引
    self.show_image_index = 0
    # 是否循环播放
    self.is_loop_show = False
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

class Hero(PlaneSprite):
“”“英雄精灵”""

def __init__(self):

    image_names = GameSprite.image_names("me", 2)
    destroy_names = GameSprite.image_names("me_destroy_", 4)

    super().__init__(image_names, destroy_names, 0, 0)

    # 设置初始位置
    self.rect.centerx = SCREEN_RECT.centerx
    self.rect.bottom = SCREEN_RECT.bottom - 120

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

def update(self, *args):
    self.update_images()

    # 飞机水平移动
    self.rect.left += self.speed

    # 超出屏幕检测
    if self.rect.left < 0:
        self.rect.left = 0
    if self.rect.right > SCREEN_RECT.right:
        self.rect.right = SCREEN_RECT.right

def fire(self):
    """发射子弹"""

    # bullet_count = len(self.bullets.sprites())
    # print("子弹数量 %d" % bullet_count)

    for i in range(0, 3):
        # 创建子弹精灵
        bullet = Bullet()

        # 设置子弹位置
        bullet.rect.bottom = self.rect.top - i * 20
        bullet.rect.centerx = self.rect.centerx

        # 将子弹添加到精灵组
        self.bullets.add(bullet)
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

class Bullet(GameSprite):
“”“子弹精灵”""

def __init__(self):
    image_name = "./images/bullet1.png"
    super().__init__(image_name, -2)

def update(self, *args):
    super().update(args)

    # 判断是否超出屏幕
    if self.rect.bottom < 0:
        self.kill()
1
2
3
4
5
6
7
8
9
10

class Enemy(PlaneSprite):
“”“敌机精灵”""

def __init__(self):
    image_names = ["./images/enemy1.png"]
    destroy_names = GameSprite.image_names("enemy1_down", 4)
    super().__init__(image_names, destroy_names, 2, 1)

    # 随机敌机出现位置
    width = SCREEN_RECT.width - self.rect.width
    self.rect.left = random.randint(0, width)
    self.rect.bottom = 0

    # 随机速度
    self.speed = random.randint(1, 3)

def update(self, *args):
    super().update(args)

    # 判断敌机是否移出屏幕
    if self.rect.top >= SCREEN_RECT.height:
        # 将精灵从所有组中删除
        self.kill()

    # 判断敌机是否已经被销毁
    if self.can_destroied:
        self.kill()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24