Adicionando efeitos especiais a jogos Pygame: sistemas de partículas e aprimoramentos visuais

Pygame é uma biblioteca popular para desenvolver jogos usando Python. Ao criar jogos, adicionar efeitos especiais pode melhorar muito o apelo visual e a experiência geral dos jogadores.

Os sistemas de partículas são uma técnica poderosa para criar efeitos dinâmicos e visualmente interessantes, como nuvens de poeira, explosões, neblina e muito mais.

Crie um jogo simples

Antes de mergulhar nos sistemas de partículas e aprimoramentos visuais, comece criando um jogo simples usando o Pygame. Crie um novo arquivo chamado simple-game.py e comece importando as bibliotecas necessárias e inicializando o Pygame. Configure a janela do jogo com largura e altura especificadas.

O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.

Dentro do loop principal do jogo, gerencie os eventos do usuário e atualize a posição do jogador com base no pressionamento de teclas.

Desenhe um retângulo para o objeto jogador usando pygame.draw.rect().

Finalmente, atualize a janela do jogo usando pygame.display.flip() e saia do jogo quando o jogador sair do loop. Este jogo simples servirá como base para adicionar efeitos especiais usando sistemas de partículas.

Você deve ver um quadrado branco representando o jogador que você pode mover para a esquerda e para a direita:

Criando vários tipos de partículas

Agora que você configurou seu jogo simples, pode adicionar diferentes sistemas de partículas. Crie classes de partículas para cada efeito e uma classe de sistema de partículas para gerenciar e atualizar as partículas.

Efeito de partícula quando o jogador está se movendo

O primeiro efeito de partícula será um rastro de partículas de poeira emitidas pelas costas do jogador quando ele começar a mover usando entrada de mouse ou teclado. Além disso, a direção das partículas de poeira mudará quando o jogador mudar de direção.

Definir um Partícula classe que representa uma partícula individual. Cada partícula tem uma posição inicial (x e y), uma velocidade aleatória (dx e morrer) e um tempo de vida que determina quanto tempo a partícula existirá.

Além disso, defina um Sistema de partículas classe que gerencia uma coleção de partículas. Você pode adicionar uma nova partícula ao sistema usando o add_particle() método. O atualizar() O método atualiza todas as partículas no sistema e remove as partículas que atingiram o fim de sua vida útil.

# Classe de partícula
aulaPartícula:
def__iniciar__(eu, x, y):
 auto.x = x
 self.y = y
 self.dx = random.uniform(-1, 1)
 self.dy = random.uniform(-1, 1)
 self.lifetime = 60
defatualizar(auto):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defempate(auto, janela):
 cor = (200, 200, 200)
 posição = (int (self.x), int (self.y))
 pygame.draw.circle (janela, cor, posição, 2)
# Classe do sistema de partículas
aulaSistema de partículas:
def__iniciar__(auto):
 self.particles = []
defadd_particle(eu, x, y):
 self.particles.append (Partícula (x, y))
defatualizar(auto):
para partícula em auto.partículas:
 partícula.atualização()
se partícula.vida <= 0:
 self.particles.remove (partícula)
defempate(auto, janela):
para partícula em auto.partículas:
 partícula.desenho (janela)

Para integrar o sistema de partículas ao seu jogo, você precisa fazer algumas modificações no loop principal do jogo. Crie um novo arquivo chamado partículas de movimento.py e adicione o código com as atualizações abaixo:

# Criar sistema de partículas
sistema_partícula = Sistema_partícula()
# Loop principal do jogo
correndo = Verdadeiro
clock = pygame.time. Relógio()
enquanto correndo:
 dt = clock.tick(60) / 1000.0
para evento em pygame.event.get():
se event.type == pygame. DESISTIR:
 correndo = Falso
 partícula_y = player_y + player_height // 2
 partícula_x = player_x + player_width
 keys = pygame.key.get_pressed()
 limite = player_x < window_width - player_width
se keys[pygame. K_LEFT] e jogador_x > 0:
 jogador_x -= 5
 partícula_sistema.add_particle (partícula_x, partícula_y)
se keys[pygame. K_RIGHT] e limite:
 jogador_x += 5
 partícula_sistema.add_particle (jogador_x, partícula_y)
 partícula_sistema.atualização()
 window.fill (PRETO)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (janela, WHITE, player_pos)
 partícula_sistema.desenhar (janela)
 pygame.display.flip()
# Sair do jogo
pygame.quit()

Ao mover o objeto do jogador agora, você verá partículas enfatizando o movimento:

Efeito Explosão

O próximo efeito de partícula será um efeito de explosão que ocorre quando o jogador atira uma bala. O efeito da explosão consistirá em partículas vermelhas emitidas da posição da bala.

Definir um Partícula classe semelhante à anterior, mas desta vez inclua um cor parâmetro para representar a cor da partícula.

Além disso, atualize o Sistema de partículas para lidar com o novo tipo de partícula. O add_particle() método agora leva um adicional cor parâmetro e cria partículas com a cor especificada.

# Classe de partícula
aulaPartícula:
def__iniciar__(próprio, x, y, cor):
 auto.x = x
 self.y = y
 self.dx = random.uniform(-2, 2)
 self.dy = random.uniform(-2, 2)
 self.lifetime = 30
 self.color = cor
defatualizar(auto):
 self.x += self.dx
 self.y += self.dy
 self.lifetime -= 1
defempate(auto, janela):
 posição = (int (self.x), int (self.y))
 pygame.draw.circle (janela, self.color, posição, 3)
# Classe do sistema de partículas
aulaSistema de partículas:
def__iniciar__(auto):
 self.particles = []
defadd_particle(próprio, x, y, cor):
 self.particles.append (Partícula (x, y, cor)
defatualizar(auto):
para partícula em auto.partículas:
 partícula.atualização()
se partícula.vida <= 0:
 self.particles.remove (partícula)
defempate(auto, janela):
para partícula em auto.partículas:
 partícula.desenho (janela)

Para integrar o efeito de explosão em seu jogo, você precisa fazer algumas modificações no loop principal do jogo. Crie um novo nome de arquivo shoot-particle.py e adicione o código com as atualizações abaixo:

# Criar sistema de partículas
sistema_partícula = Sistema_partícula()
# Loop principal do jogo
correndo = Verdadeiro
clock = pygame.time. Relógio()
enquanto correndo:
 dt = clock.tick(60) / 1000.0
para evento em pygame.event.get():
se event.type == pygame. DESISTIR:
 correndo = Falso
 keys = pygame.key.get_pressed()
 limite = player_x < window_width - player_width
se keys[pygame. K_LEFT] e jogador_x > 0:
 jogador_x -= 5
se keys[pygame. K_RIGHT] e limite:
 jogador_x += 5
se keys[pygame. K_SPACE]:
 bullet_x = player_x + player_width // 2
 marcador_y = jogador_y
 article_system.add_particle (bullet_x, bullet_y, RED)
 partícula_sistema.atualização()
 window.fill (PRETO)
 player_pos = (player_x, player_y, player_width, player_height)
 pygame.draw.rect (janela, WHITE, player_pos)
 partícula_sistema.desenhar (janela)
 pygame.display.flip()
# Sair do jogo
pygame.quit()

Aqui está a saída:

Quando a barra de espaço ( pygame. K_SPACE) é pressionado, adicione uma partícula ao sistema de partículas na posição do projétil. Isso cria o efeito de explosão com partículas vermelhas.

Efeito de poeira

O aprimoramento visual final que você pode implementar é um efeito de fundo empoeirado. O efeito de poeira consistirá em pequenas partículas cinzas movendo-se em um padrão circular, criando um fundo dinâmico e empoeirado.

Atualize o Partícula classe para incluir um ângulo e velocidade para cada partícula. O ângulo determina a direção do movimento e a velocidade controla a velocidade com que as partículas se movem em seu padrão circular. Modifique o atualizar() método para atualizar a posição de cada partícula com base em seu ângulo e velocidade.

Além disso, atualize o Sistema de partículas classe para lidar com o novo comportamento da partícula. As partículas agora se movem em um padrão circular dentro da janela do jogo.

# Classe de partícula
aulaPartícula:
def__iniciar__(próprio, x, y, raio):
 auto.x = x
 self.y = y
 self.radius = raio
 self.angle = random.uniform(0, 2 *math.pi)
 self.speed = random.uniform(0.5, 1.5)
defatualizar(auto):
 auto.ângulo += 0.02
 self.x += math.cos (self.angle) * self.speed
 self.y += math.sin (self.angle) * self.speed
se self.x < 0:
 self.x = window_width
elif self.x > window_width:
 auto.x = 0
se self.s < 0:
 self.y = window_height
elif self.y > window_height:
 self.y = 0
defempate(auto, janela):
 cor = (128, 128, 128)
 pos = (int (self.x), int (self.y))
 raio = int (self.radius)
 pygame.draw.circle (janela, cor, pos, raio)
# Classe do sistema de partículas
aulaSistema de partículas:
def__iniciar__(auto):
 self.particles = []
defadd_particle(próprio, x, y, raio):
 self.particles.append (Partícula (x, y, raio))
defatualizar(auto):
para partícula em auto.partículas:
 partícula.atualização()
defempate(auto, janela):
para partícula em auto.partículas:
 partícula.desenho (janela)

Para integrar o efeito de poeira em seu jogo, você precisa fazer algumas modificações no loop principal do jogo. Crie um novo arquivo chamado poeira-partícula.py e adicione o código com as atualizações abaixo:

# Criar sistema de partículas para efeito de poeira
sistema_partícula = Sistema_partícula()
# Loop principal do jogo
correndo = Verdadeiro
clock = pygame.time. Relógio()
enquanto correndo:
 dt = clock.tick(60) / 1000.0
para evento em pygame.event.get():
se event.type == pygame. DESISTIR:
 correndo = Falso
 partícula_x = random.randint(0, largura_janela)
 partícula_y = random.randint(0, janela_altura)
 partícula_sistema.add_particle (partícula_x, partícula_y, 1)
 partícula_sistema.atualização()
 window.fill((0, 0, 0))
 partícula_sistema.desenhar (janela)
 pygame.display.flip()
# Sair do jogo
pygame.quit()

Adicione partículas aleatoriamente na janela do jogo usando o botão randint() função. Cada partícula tem um raio inicial de 1. Atualize e desenhe o sistema de partículas na janela do jogo, criando um efeito de fundo dinâmico e empoeirado.

Você deve ver muitas partículas na tela, movendo-se aleatoriamente, mas suavemente:

Práticas recomendadas para efeitos especiais

Ao adicionar efeitos especiais ao seu jogo Pygame, considere as seguintes práticas recomendadas:

Otimização de performance

Os sistemas de partículas podem envolver um grande número de partículas, o que pode afetar o desempenho do jogo. Implemente técnicas como particionamento espacial (por exemplo, Quadtree) para otimizar atualizações e desenhos de partículas.

Reciclagem de Partículas

Em vez de criar e destruir partículas em cada quadro, considere a reutilização de partículas redefinindo suas propriedades quando chegarem ao fim de sua vida útil. Isso ajuda a minimizar a alocação e desalocação de memória.

Agrupamento de partículas

Mantenha um pool de partículas pré-alocadas para evitar a sobrecarga de criar novas instâncias durante o tempo de execução. Isso pode melhorar o desempenho e reduzir a fragmentação da memória.

Limite de Contagem de Partículas

Para evitar que os sistemas de partículas sobrecarreguem a tela do jogo, defina limites para o número máximo de partículas e remova-as quando atingirem esse limite. Isso garante que os efeitos permaneçam visualmente atraentes sem atrapalhar a jogabilidade.

Consistência Visual

Mantenha um estilo visual consistente em todo o jogo, incluindo efeitos de partículas. Certifique-se de que as cores, tamanhos e padrões de movimento das partículas sejam coerentes com o tema geral e o estilo artístico.

Efeitos sonoros

Adicionar efeitos sonoros para complementar seus efeitos de partículas. Por exemplo, reproduza sons de explosão quando ocorrer um efeito de explosão ou sons do ambiente quando os efeitos de névoa ou poeira estiverem ativos.

Torne os jogos mais divertidos com efeitos especiais

Adicionar efeitos especiais, como sistemas de partículas, aos seus jogos Pygame pode melhorar muito a experiência do jogador e tornar seus jogos mais envolventes e divertidos para os jogadores. Ao implementar efeitos de partículas como rastros, explosões, neblina e poeira, você pode criar ambientes visualmente deslumbrantes e dinâmicos.

Lembre-se de considerar a otimização de desempenho, a reciclagem de partículas e a consistência visual ao incorporar efeitos especiais em seus jogos. Com criatividade e experimentação, você pode levar seus jogos Pygame para o próximo nível e cativar os jogadores com experiências envolventes e emocionantes.