Python 如何使用groupcollide？

所以我一直想知道如何使用pygame groupcollide。我现在完全被难住了。因为我使用的是collide_rect，这很好。但是对于groupcollide，我似乎不知道如何调用该组中项目的属性。我不能做碰撞矩形，因为会有很多子弹

def check_blast_collisions(player,bullet):
    hits = pg.sprite.groupcollide(player,bullet,False,True)
    for hit in hits:
        print (hits)
        if hit.vx == 20:
            player.vx += 40
        elif hit.vx == -20:
            player.vx += -40

下面是我尝试使用groupcollide的一个片段。 在我完成这个功能后，子弹甚至都没有出现。（子弹应该被称为爆炸，但我在这个函数中忘记了。）

将pygame导入为pg
#背景
描述=“击退竞技场”
分辨率=1600900
宽度=分辨率[0]
高度=分辨率[1]
FPS=60
运动员\跳跃\高度=30
玩家\最大\坠落\速度=30
玩家下降速度增加=2
玩家_寿命=5
射击冷却时间=500
#初始化pygame
第init页（）
pg.mixer.init（）
pg.font.init
屏幕=pg.display.set_模式（分辨率）
pg.display.set_标题（标题）
时钟=pg.time.clock（）
#精灵
课堂讲台（第三页：雪碧、雪碧）：
定义初始值（自、x、y、宽度、高度、r、g、b）：
精灵精灵。精灵。精灵初始（自我）
self.image=pg.Surface（（宽度、高度））
自映像填充（（r，g，b））
self.rect=self.image.get_rect（）
self.rect.center=（x，y）
职业玩家（第三页精灵）：
定义初始（self，r，g，b，x，y）：
精灵精灵。精灵。精灵初始（自我）
self.image=pg.Surface（（40100））
自映像填充（（r，g，b））
self.rect=self.image.get_rect（）
self.rect.center=（x，y）
self.startx=x
self.starty=y
self.vx=0
self.vy=5
self.vy\u max=玩家\u max\u坠落\u速度
self.vy\u增加=玩家\u下降\u速度\u增加
self.lifes=玩家生命
self.last_shot=0
self.face_right=错误
self.faceting_left=False
def更新（自我）：
self.rect.x+=self.vx
self.rect.y+=self.vy
如果self.vy>=self.vy\u max：
self.vy=self.vy\u max
self.vy_增加=0
如果self.vy=高度：
self.rect.x=self.startx
self.rect.y=self.starty
self.lifes-=1
如果self.lifes=宽度：
self.rect.right=宽度
self.vx=0
如果self.rect.left=main_platform.rect.top：
self.vy-=玩家\跳跃\高度
如果self.rect.bottom>=高度：
self.vy-=玩家\跳跃\高度
def喷射（自）：
如果pg.time.get_ticks（）-self.last_shot>=射击冷却时间：
如果self.faceting_left==真：
返回“左射”
elif self.faceting_right==真：
返回“右击”
其他：
返回“cd未完成”
班级爆炸（第三页精灵）：
定义初始（自我、玩家、方向）：
精灵精灵。精灵。精灵初始（自我）
self.image=pg.Surface（（20,10））
self.image.fill（（0255255））
self.rect=self.image.get_rect（）
self.rect.center=（player.rect.center）
方向
如果self.direction==0：
self.vx=-20
elif self.direction==1：
self.vx=20
def更新（自我）：
self.rect.x+=self.vx
如果self.rect.right<0：
self.kill（）
如果self.rect.left>宽度：
self.kill（）
#功能
def检查碰撞（玩家、平台）：
hits=pg.sprite.collide_rect（玩家、平台）
如果点击：
如果命中率和player.vy>0：
player.rect.bottom=platform.rect.top
player.vy=0
def检查爆炸碰撞（玩家、子弹）：
hits=pg.sprite.groupcollide（玩家、子弹、假、真）
点击率：
打印（点击数）
如果hit.vx==20：
player.vx+=40
elif hit.vx==-20：
player.vx+=-40
font=pg.font.font（'font/Roboto-Light.ttf'，30）
所有精灵=pg.sprite.Group（）
玩家=pg.sprite.Group（）
平台=pg.sprite.Group（）
blasts=pg.sprite.Group（）
主平台=平台（宽度/26501000100,0200,0）
玩家_1=玩家（0,0255，宽度/2+-100200）
游戏者2=游戏者（255,0,0，宽度/2+100200）
平台。添加（主平台）
玩家。添加（玩家1）
玩家。添加（玩家2）
所有精灵。添加（玩家1）
所有精灵。添加（玩家2）
所有精灵。添加（主平台）
菜单=真
运行=真
运行时：
#检查车窗是否关闭
对于pg.event.get（）中的事件：
如果event.type==pg.KEYDOWN：
如果event.key==pg.K_w：
玩家_1.跳跃（）
如果event.key==pg.K_a：
玩家_1.vx=-10
玩家1.面向左=正确
玩家1.面向右=错误
elif event.key==pg.K_d:
玩家_1.vx=10
玩家1.面向右=正确
玩家1.面向左=错误
如果event.key==pg.K_UP：
玩家_2.跳跃（）
如果event.key==pg.K_左：
玩家_2.vx=-10
玩家2.面向左=正确
玩家2.面向右=错误
elif event.key==pg.K_RIGHT:
播放器_2.vx=10
玩家2.面向右=正确
玩家2.面向左=错误
如果event.key==pg.K_j：
如果玩家_1.shoot（）=“shoot_left”：
b=爆炸（玩家1,0）
所有精灵。添加（b）
添加（b）
elif player_1.shoot（）=“向右射击”：
b=爆炸（玩家_1,1）
所有精灵。添加（b）
添加（b）
如果event.key==pg.K_KP1：
如果玩家2.shoot（）=“shoot_left”：
b=爆炸（玩家2,0）
所有精灵。添加（b）
添加（b）
elif player_2.shoot（）=“shoot”
import pygame as pg

#settings

CAPTION = "Knockback Arena"
resolution = 1600,900
WIDTH = resolution[0]
HEIGHT = resolution[1]
FPS = 60

player_jump_height = 30
player_max_fall_speed = 30
player_fall_speed_increase = 2
player_lives = 5

shoot_cooldown = 500

#initialize pygame
pg.init()
pg.mixer.init()
pg.font.init
screen = pg.display.set_mode(resolution)
pg.display.set_caption(CAPTION)
clock = pg.time.Clock()

#sprites
class Platform(pg.sprite.Sprite):
    def __init__(self,x,y,width,height,r,g,b):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((width,height))
        self.image.fill((r,g,b))
        self.rect = self.image.get_rect()
        self.rect.center = (x,y)

class Player(pg.sprite.Sprite):
    def __init__(self,r,g,b,x,y):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((40, 100))
        self.image.fill((r,g,b))
        self.rect = self.image.get_rect()
        self.rect.center = (x, y)
        self.startx = x
        self.starty = y
        self.vx = 0
        self.vy = 5
        self.vy_max = player_max_fall_speed
        self.vy_increase = player_fall_speed_increase
        self.lives = player_lives
        self.last_shot = 0
        self.facing_right = False
        self.facing_left = False

    def update(self):
        self.rect.x += self.vx
        self.rect.y += self.vy
        if self.vy >= self.vy_max:
            self.vy = self.vy_max
            self.vy_increase = 0
        if self.vy < self.vy_max:
            self.vy_increase = player_fall_speed_increase
        if self.rect.bottom < HEIGHT:
            self.vy += self.vy_increase
        if self.rect.top >= HEIGHT:
            self.rect.x = self.startx
            self.rect.y = self.starty
            self.lives -= 1
            if self.lives <= 0:
                self.kill()
        if self.rect.right >= WIDTH:
            self.rect.right = WIDTH
            self.vx = 0
        if self.rect.left <= 0:
            self.rect.left = 0
            self.vx = 0

    def jump(self):
        if self.rect.bottom >= main_platform.rect.top:
            self.vy -= player_jump_height
        if self.rect.bottom >= HEIGHT:
            self.vy -= player_jump_height

    def shoot(self):
        if pg.time.get_ticks() - self.last_shot >= shoot_cooldown:
            if self.facing_left == True:
                return "shoot_left"
            elif self.facing_right == True:
                return "shoot_right"
        else:
            return "cd_not_done"

class Blast(pg.sprite.Sprite):
    def __init__(self,player,direction):
        pg.sprite.Sprite.__init__(self)
        self.image = pg.Surface((20,10))
        self.image.fill((0,255,255))
        self.rect = self.image.get_rect()
        self.rect.center = (player.rect.center)
        self.direction = direction
        if self.direction == 0:
            self.vx = -20
        elif self.direction == 1:
            self.vx = 20
    def update(self):
        self.rect.x += self.vx
        if self.rect.right < 0:
            self.kill()
        if self.rect.left > WIDTH:
            self.kill()

#functions
def check_for_collisions(player,platform):
    hits = pg.sprite.collide_rect(player,platform)
    if hits:
        if hits and player.vy > 0:
            player.rect.bottom = platform.rect.top
            player.vy = 0

def check_blast_collisions(player,bullet):
    hits = pg.sprite.groupcollide(player,bullet,False,True)
    for hit in hits:
        print (hits)
        if hit.vx == 20:
            player.vx += 40
        elif hit.vx == -20:
            player.vx += -40

font = pg.font.Font('font/Roboto-Light.ttf', 30)

all_sprites = pg.sprite.Group()
players = pg.sprite.Group()
platforms = pg.sprite.Group()
blasts = pg.sprite.Group()

main_platform = Platform(WIDTH/2,650,1000,100,0,200,0)
player_1 = Player(0,0,255,WIDTH/2 + -100,200)
player_2 = Player(255,0,0,WIDTH/2 + 100,200)

platforms.add(main_platform)
players.add(player_1)
players.add(player_2)
all_sprites.add(player_1)
all_sprites.add(player_2)
all_sprites.add(main_platform)

menu = True
run = True
while run:
    #check for closing window
    for event in pg.event.get():
        if event.type == pg.KEYDOWN:
            if event.key == pg.K_w:
                player_1.jump()
            if event.key == pg.K_a:
                player_1.vx = -10
                player_1.facing_left = True
                player_1.facing_right = False
            elif event.key == pg.K_d:
                player_1.vx = 10
                player_1.facing_right = True
                player_1.facing_left = False

            if event.key == pg.K_UP:
                player_2.jump()
            if event.key == pg.K_LEFT:
                player_2.vx = -10
                player_2.facing_left = True
                player_2.facing_right = False
            elif event.key == pg.K_RIGHT:
                player_2.vx = 10
                player_2.facing_right = True
                player_2.facing_left = False

            if event.key == pg.K_j:
                if player_1.shoot() == "shoot_left":
                    b = Blast(player_1,0)
                    all_sprites.add(b)
                    blasts.add(b)
                elif player_1.shoot() == "shoot_right":
                    b = Blast(player_1,1)
                    all_sprites.add(b)
                    blasts.add(b)
            if event.key == pg.K_KP1:
                if player_2.shoot() == "shoot_left":
                    b = Blast(player_2,0)
                    all_sprites.add(b)
                    blasts.add(b)
                elif player_2.shoot() == "shoot_right":
                    b = Blast(player_2,1)
                    all_sprites.add(b)
                    blasts.add(b)

        elif event.type == pg.KEYUP:
            if event.key == pg.K_a:
                player_1.vx = 0
            if event.key == pg.K_d:
                player_1.vx = 0

            if event.key == pg.K_LEFT:
                player_2.vx = 0
            if event.key == pg.K_RIGHT:
                player_2.vx = 0
        if event.type == pg.QUIT:
            pg.quit()
            exit()

    #update all sprites
    all_sprites.update()
    check_for_collisions(player_1,main_platform)
    check_for_collisions(player_2,main_platform)
    check_blast_collisions(players,blasts)

    #draw sprites
    screen.fill((255,255,255))
    all_sprites.draw(screen)

    #draw other stuff
    p1lives = font.render(str(player_1.lives), False, (0,0,255))
    screen.blit(p1lives,(20,50))

    p2lives = font.render(str(player_2.lives), False, (255,0,0))
    screen.blit(p2lives,(1580,50))

    clock.tick(FPS)
    pg.display.flip()