（十）通过pygame来进行碰撞检测_pygame.sprite.groupcollide

---

python飞机大战系列文章（按顺序）
（一）通过pygame 将自己的图像添加到游戏中
（二）通过pygame让游戏人物 动起来
（三）通过pygame处理用户的鼠标键盘操作（事件和监听
（四）详解pygame中的精灵和精灵组
（五）通过pygame搭建游戏框架
（六）通过pygame让游戏背景图像实现交替滚动
（七）通过pygame来设置飞机大战中 敌机 的速度、位置等
（八）通过pygame来操控游戏人物的移动
（九）通过pygame使游戏人物发射子弹
（十）通过pygame来进行碰撞检测

---

---

什么是碰撞检测

pygame提供了两个方法可以实现碰撞检测

方法一：pygame.sprite.groupcollide（）

• pygame.sprite.groupcollide（）–两个精灵组中所有精灵的碰撞检测

groundcollide(group1,group2,dokill1,dokill2,collided = None)
1

解读：
若dokill1=True：如果group1和group2发生碰撞，group1中的精灵就会被自动销毁

若dokill2=True：如果group1和group2发生碰撞，group2中的精灵就会被自动销毁

【我们在飞机大战中，当子弹碰到敌机，两者应该都同时被销毁。所以dokill1=True,dokill2=True】

collided参数是用于计算碰撞的回调函数，如果没有指定，则每个精灵必须有一个rect属性

代码如下：

def __check_collide(self):

    #子弹摧毁敌机
    pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)
1
2
3
4

方法二： pygame.sprite.spritecollide()

• pygame.sprite.spritecollide() —判断某个精灵和指定精灵组中的精灵的碰撞

spritecollide(sprite, group, dokill, collided = Noone)
1

解读：
若dokill值为True，则指定精灵组中发生碰撞的精灵会被自动移除

collided参数是用于计算碰撞的回调函数，如果没有指定，则每个精灵必须有一个rect属性

返回值是 精灵组 中跟 精灵 发生碰撞的精灵列表

注意： 这里只能设置当敌机撞到英雄后，敌机被自动销毁，但是这显然不符合游戏需求，我们要求的是 当敌机撞到英雄时：英雄牺牲，并且结束游戏，那么需要怎么做呢？-----因为spritecollide的返回值是 精灵组 中跟 精灵 发生碰撞的精灵列表，我们可以来接收列表的值，如果列表有值，那么我们就让英雄牺牲，并且结束游戏

代码如下：

#敌机撞英雄
enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)
#判断是否有内容
if len(enemies) > 0:

    #牺牲英雄飞机
    self.hero.kill()
    #结束游戏
    PlaneGame.__game_over()
1
2
3
4
5
6
7
8
9

至此，plane_sprites.py完整代码为：

import random
import pygame

#屏幕大小的常量
SCREEN_RECT = pygame.Rect(0,0,480,700)
#刷新的帧率
FRAME_PER_SEC = 60
#创建敌机的定时器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
#英雄发射子弹事件
HERO_FIRE_EVENT = pygame.USEREVENT + 1

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):

        #在屏幕垂直方向上移动
        self.rect.y += self.speed


class Background(GameSprite):
    """游戏背景精灵"""

    def __init__(self, is_alt=False):

        # 调用父类方法实现精灵的创建（image/rect/speed）
        super().__init__("./images/background.png")

        # 判断是否是交替图像，如果是，需要设置初始位置
        if is_alt:
            self.rect.y = -self.rect.height

    def update(self):

        #调用父类的方法实现：垂直移动
        super().update()

        #判断是否移出屏幕，若移出屏幕，应该将图像设置到图像上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height


class Enemy(GameSprite):
    """敌机精灵"""

    def __init__(self):
        #调用父类方法，创建敌机精灵，同时指定敌机图片
        super().__init__("./images/enemy1.png")
        #指定敌机的初始随机速度
        self.speed = random.randint(1,3)

        #指定敌机的初始随机位置
        max_x = SCREEN_RECT.width - self.rect.width
        self.rect.x = random.randint(0,max_x)

    def update(self):

        #调用父类方法，保持垂直方向上的飞行
        super().update()
        #判断是否飞出屏幕，如果是，需要从精灵组删除敌机
        if self.rect.y >= SCREEN_RECT.height:
            #print("飞出屏幕，需要从精灵组删除")
            #kill 方法可以将精灵从所有精灵组中移出，精灵就会被自动销毁
            self.kill()

    def __del__(self):
       # print("敌机挂了 %s" %self.rect)
        pass

class Hero(GameSprite):
    """英雄精灵"""

    def __init__(self):

        #调用父类方法，设置image speed
        super().__init__("./images/me1.png", 0)

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

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


    def update(self):

        #英雄在水平方向移动
        self.rect.x += self.speed

        #控制英雄不能离开屏幕
        if self.rect.x < 0:
            self.rect.x = 0

        elif self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right

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

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

            #设置精灵的位置
            bullet.rect.bottom = self.rect.y - i*20
            bullet.rect.centerx = self.rect.centerx

            #将精灵添加到精灵组
            self.bullets.add(bullet)


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

    def __init__(self):

        #调用父类方法设施子弹图片 初始速度
        super().__init__("./images/bullet1.png", -2)

    def update(self):

        #调用父类方法，让子弹沿垂直方向飞行
        super().update()

        #判断子弹是否飞出屏幕
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        print("子弹被销毁")
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

plane_main.py完整代码为：

import pygame
from plane_sprites import *


class PlaneGame(object):
    """飞机大战主游戏"""

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

        #创建游戏窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)
        #创建游戏的时钟
        self.clock = pygame.time.Clock()
        #调用私有方法，精灵和精灵组的创建
        self.__create_sprites()
        #设置定时器事件：创建敌机事件
        pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)
        pygame.time.set_timer(HERO_FIRE_EVENT, 500)

    def __create_sprites(self):

        #创建背景精灵和精灵组
        bg1 = Background()
        bg2 = Background(is_alt=True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        #创建敌机的精灵组
        self.enemy_group = pygame.sprite.Group()

        #创建英雄的精灵和精灵组
        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):
        print("游戏开始")

        while True:
            #设置刷新帧率
            self.clock.tick(FRAME_PER_SEC)
            #事件监听
            self.__event_handler()
            #碰撞检测
            self.__check_collide()
            #更新/绘制精灵组
            self.__update_sprites()
            #更新显示
            pygame.display.update()

    def __event_handler(self):

        for event in pygame.event.get():

            #判断是否退出游戏
            if event.type == pygame.QUIT:
                PlaneGame.__game_over()

            elif event.type == CREATE_ENEMY_EVENT:
                #print("敌机出场")
                #创建敌机精灵
                enemy = Enemy()

                #将敌机精灵添加到敌机精灵组
                self.enemy_group.add(enemy)
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()

        #使用键盘提供的方法获取键盘按键 --按键元组
        keys_pressed = pygame.key.get_pressed()
        #判断元组中对应的按键索引值 1
        if keys_pressed[pygame.K_RIGHT]:
            self.hero.speed = 2
        elif keys_pressed[pygame.K_LEFT]:
            self.hero.speed = -2
        else:
            self.hero.speed = 0





    def __check_collide(self):

        #子弹摧毁敌机
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)

        #敌机撞英雄
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)
        #判断是否有内容
        if len(enemies) > 0:

            #牺牲英雄飞机
            self.hero.kill()
            #结束游戏
            PlaneGame.__game_over()


    def __update_sprites(self):

        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    #没有使用对象属性和类属性，所以定义为静态方法
    @staticmethod
    def __game_over():
        print("游戏结束")

        pygame.quit()
        exit()


if __name__ == '__main__':

    #创建游戏对象
    game = PlaneGame()

    #启动游戏
    game.start_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