Leitores como você ajudam a apoiar o MUO. Quando você faz uma compra usando links em nosso site, podemos ganhar uma comissão de afiliado. Consulte Mais informação.

O Pygame fornece várias funções integradas para detectar colisões entre objetos do jogo. Isso é inestimável porque descobrir exatamente quando e como os objetos em movimento se sobrepõem pode ser uma tarefa complicada.

Aprenda como adicionar física básica e colisões em seu jogo usando o módulo pygame.

Funções internas de detecção de colisão do Pygame

A função de detecção de colisão integrada mais básica é spritecollide. Ele recebe um sprite, um grupo de sprites e um valor booleano indicando se os sprites devem ou não "morrer" (ser removidos) quando colidem. Esta função retorna uma lista de sprites que colidiram. Aqui está um exemplo de como usá-lo:

collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, Verdadeiro)

Outra função útil de detecção de colisão é groupcollide, que aceita dois grupos de sprites e também um valor booleano. Esta função retorna um dicionário com os sprites colididos como chaves e os sprites com os quais eles colidiram como valores. Aqui está um exemplo de como usá-lo:

instagram viewer 

colisão_dict = pygame.sprite.groupcollide (grupo1, grupo2, Verdadeiro, Verdadeiro)

Criando um jogo de plataforma básico usando a função spritecollide

Para criar um jogo de plataforma básico usando o Pygame, você precisará criar um sprite de jogador que o usuário possa controlar e um sprite de plataforma para o jogador se posicionar. Você pode usar a função spritecollide para detectar quando o sprite do jogador colide com o sprite da plataforma e evitar que o jogador caia na plataforma.

Para iniciar, instale o módulo pygame usando pip:

pip instalar pygame

Depois disso, criar classes simples para o Player e Platform, sendo que ambos devem herdar da classe Sprite do Pygame. A classe Player deve ter um método de atualização para manipular a posição do jogador com base na velocidade. Além disso, deve ter uma variável y_velocity para aplicar o efeito de gravidade. A classe Platform deve ter um método __init__ que pega as coordenadas da plataforma e cria uma superfície com esse tamanho.

Classe do jogador

Você pode criar uma classe Player usando o pygame.sprite. Módulo Sprite. Essa classe inicializará o jogador com as coordenadas x e y dadas. Em seguida, o método update atualizará a posição do jogador incrementando o valor de y_velocity.

importar pygame
aulaJogador(pygame.sprite. Sprite):
def__iniciar__(eu, x, y):
 super().__init__()
 self.image = pygame. Superfície((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
defatualizar(auto):
 self.rect.y += self.y_velocity

Classe de plataforma

A classe Platform também usa o pygame.sprite. Módulo Sprite. Essa classe inicializará a plataforma com as coordenadas x e y dadas, bem como largura e altura.

aulaPlataforma(pygame.sprite. Sprite):
def__iniciar__(auto, x, y, largura, altura):
 super().__init__()
 self.image = pygame. Superfície((largura, altura))
 self.rect = self.image.get_rect (topleft=(x, y))

O ciclo do jogo

O loop do jogo permitirá que você crie uma janela com um tamanho de 640x480. Em seguida, ele executará um loop que verificará quaisquer eventos, como um comando quit. Ele também verificará se há colisões entre o jogador e a plataforma. Por fim, ele preencherá a tela com a cor branca, desenhará o jogador e a plataforma e, em seguida, inverterá o visor.

jogador = jogador(100, 300)
player_group = pygame.sprite. Grupo()
player_group.add (jogador)
plataforma = plataforma(50, 400, 100, 20)
platform_group = pygame.sprite. Grupo()
platform_group.add (plataforma)


# Inicializa o pygame e cria a janela
pygame.init()
tela = pygame.display.set_mode((640, 480))


# Loop principal do jogo
correndo = Verdadeiro


enquanto correndo:
para evento em pygame.event.get():
se event.type == pygame. DESISTIR:
 correndo = Falso

 player_group.update()
 colidiu = pygame.sprite.spritecollide (jogador, platform_group, Falso)


se colidiu:
 player.y_velocity = 0
 tela.fill((255, 255, 255))
 player_group.draw (tela)
 platform_group.draw (tela)
 pygame.display.flip()
pygame.quit()

Abaixo está a saída:

Implementando Gravidade e Comportamento de Salto

Para implementar gravidade e comportamento de salto em seu jogo de plataforma, você precisará adicionar uma velocidade y ao sprite do jogador e atualizar sua posição y em cada quadro. Para fazer isso você pode usar o método update dentro da classe Player e adicionar o seguinte trecho de código:

aulaJogador(pygame.sprite. Sprite):
def__iniciar__(eu, x, y):
 super().__init__()
 self.image = pygame. Superfície((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
defatualizar(auto):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVIDADE # Aplicar gravidade à velocidade y

Agora, toda vez que você chamar o método de atualização, ele atualizará a posição do jogador de acordo com sua velocidade e gravidade.

Para fazer o sprite do jogador pular, você pode vincular a ação de pular a uma tecla ou botão específico e atualizar a velocidade y do jogador com um valor negativo. O trecho de código a seguir é um exemplo de como pular quando um jogador pressiona a barra de espaço.

JUMP_VELOCITY = -10
# dentro do loop do jogo
se event.type == pygame. KEYDOWN e event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

Observe que você precisará verificar o event.type para certificar-se de que o evento é um evento KEYDOWN antes de verificar o valor da chave.

Adicionando Física Básica, como Atrito e Aceleração

Para adicionar física básica, como fricção e aceleração, ao seu jogo de plataforma, você precisará atualizar a velocidade x do sprite do jogador em cada quadro. Você pode adicionar a velocidade x à classe do jogador e atualizá-la da mesma forma que a velocidade y. Para implementar o atrito, você pode diminuir a velocidade x do sprite do jogador em uma pequena quantidade em cada quadro. Por exemplo, você pode adicionar o seguinte trecho de código dentro do método update da classe Player:

FRICÇÃO = 0.9
aulaJogador(pygame.sprite. Sprite):
def__iniciar__(eu, x, y):
 super().__init__()
 self.image = pygame. Superfície((32, 32))
 self.rect = self.image.get_rect (topleft=(x, y))
 self.y_velocity = 0
 self.x_velocity = 0
defatualizar(auto):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVIDADE # Aplicar gravidade à velocidade y
 self.x_velocity *= FRICÇÃO # Aplique atrito à velocidade x

Para implementar a aceleração, você pode definir uma variável, player_movement, para o movimento horizontal e atualizar a velocidade x do sprite do jogador de acordo com o valor do player_movement. Você pode fazer isso vinculando o movimento a teclas ou botões específicos e atualizando a velocidade x do jogador no loop de eventos, por exemplo:

ACELERAÇÃO = 0.5
jogador_movimento = 0
se event.type == pygame. TECLA PARA BAIXO:
se event.key == pygame. K_ESQUERDA:
 jogador_movimento = -1
elif event.key == pygame. K_RIGHT:
 jogador_movimento = 1
elif event.type == pygame. TECLA:
se evento.chave em (pygame. K_LEFT, pygame. K_RIGHT):
 jogador_movimento = 0

player.x_velocity += player_movement * ACELERAÇÃO

Ao usar essas técnicas, você pode criar um jogo de plataforma simples, porém divertido, usando as funções de detecção de colisão integradas e a física básica do Pygame. Com um pouco de criatividade e experimentação, você pode usar essas técnicas para criar uma variedade de jogos e mecânicas de jogo diferentes.

Você pode encontrar o código completo no Repositório GitHub.

Abaixo está a saída:

Melhore o envolvimento do usuário com colisões

Muitos jogos requerem alguma forma de detecção de colisão. Você pode usar colisões para criar uma ampla variedade de mecânicas de jogo, desde jogos de plataforma simples até simulações complexas baseadas em física.

A implementação de física básica, como gravidade, fricção e aceleração, também pode melhorar muito o envolvimento do usuário, adicionando realismo e sensação de peso aos objetos do jogo.