Implementando Física Básica e Detecção de Colisão no Pygame

Implementando Física Básica e Detecção de Colisão no Pygame. 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, True)

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:

collision_dict = pygame.sprite.groupcollide(group1, group2, True, True)

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 começar, instale o módulo pygame usando pip:

pip install pygame

Depois disso, crie classes simples para Player e Platform, ambas herdadas 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 módulo pygame.sprite.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.

import pygame

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.rect = self.image.get_rect(topleft=(x, y))
        self.y_velocity = 0

    def update(self):
        self.rect.y += self.y_velocity

Classe de plataforma

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

class Platform(pygame.sprite.Sprite):
    def __init__(self, x, y, width, height):
        super().__init__()
        self.image = pygame.Surface((width, height))
        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 640×480. 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.

player = Player(100, 300)
player_group = pygame.sprite.Group()
player_group.add(player)

platform = Platform(50, 400, 100, 20)
platform_group = pygame.sprite.Group()
platform_group.add(platform)


pygame.init()
screen = pygame.display.set_mode((640, 480))


running = True

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
    
    player_group.update()
    collided = pygame.sprite.spritecollide(player, platform_group, False)

    if collided:
        player.y_velocity = 0
    screen.fill((255, 255, 255))
    player_group.draw(screen)
    platform_group.draw(screen)
    pygame.display.flip()

pygame.quit()

Abaixo está a saída:

Implementando Gravidade e Comportamento de Salto

Contudo 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. Assim Para fazer isso você pode usar o método update dentro da classe Player e adicionar o seguinte trecho de código:

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.rect = self.image.get_rect(topleft=(x, y))
        self.y_velocity = 0

    def update(self):
        self.rect.y += self.y_velocity
        self.y_velocity += GRAVITY

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.

De fato 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. Contudo O trecho de código a seguir é um exemplo de como pular quando um jogador pressiona a barra de espaço.

JUMP_VELOCITY = -10


if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
    player.y_velocity = JUMP_VELOCITY

Contudo 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

Assim 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.

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

FRICTION = 0.9

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.rect = self.image.get_rect(topleft=(x, y))
        self.y_velocity = 0
        self.x_velocity = 0

    def update(self):
        self.rect.y += self.y_velocity
        self.rect.x += self.x_velocity
        self.y_velocity += GRAVITY
        self.x_velocity *= FRICTION

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:

ACCELERATION = 0.5
player_movement = 0

if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_LEFT:
        player_movement = -1
    elif event.key == pygame.K_RIGHT:
        player_movement = 1
elif event.type == pygame.KEYUP:
    if event.key in (pygame.K_LEFT, pygame.K_RIGHT):
        player_movement = 0
        
player.x_velocity += player_movement * ACCELERATION

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.

De fato 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.

Aqui Você pode encontrar o código completo no repositório do GitHub.

Abaixo está a saída:

Melhore o envolvimento do usuário com colisões

Contudo 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.

Por fim 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.

Similar Posts