Introduza elementos como dano ao jogador, mecânica de cura e muito mais, incorporando um sistema de saúde em seus jogos.
A implementação de um sistema de saúde em um jogo pode melhorar muito a experiência de jogo e adicionar uma camada adicional de desafio e estratégia. O PyGame fornece um conjunto robusto de ferramentas e funções para incorporar o sistema de saúde, facilitando a criação de experiências interativas.
Crie um jogo simples
Antes de começar, certifique-se de ter pip instalado em seu sistema. Use este comando para instalar o pygame biblioteca:
pip instalar pygameDepois disso, crie um arquivo chamado simple-game.py e comece criando um jogo simples onde o jogador pode se mover para a esquerda e para a direita.
O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.
Neste loop básico de jogo, o objetivo do jogador será evitar a colisão com o inimigo.
importar pygame
importar aleatório# Inicializa o PyGame
pygame.init()# Configure a janela do jogo
window_width, window_height = 800, 600
window = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Demonstração do Sistema de Saúde")# Atributos do jogador
player_width, player_height = 50, 50
player_x, player_y = window_width // 2, altura_da_janela - altura_do_jogador - 10
jogador_velocidade = 1# Atributos inimigos
largura_inimiga, altura_inimiga = 50, 50
inimigo_x, inimigo_y = random.randint(0, window_width - inimigo_width), 0
inimigo_velocidade = 0.3# Repetição do jogo
correndo = Verdadeiro
enquanto correndo:
para evento em pygame.event.get():
se event.type == pygame. DESISTIR:
correndo = Falso# Mova o jogador para a esquerda ou para a direita
keys = pygame.key.get_pressed()
se keys[pygame. K_LEFT] e jogador_x > 0:
jogador_x -= jogador_velocidade
se keys[pygame. K_RIGHT] e player_x < window_width - player_width:
jogador_x += jogador_velocidade# Mova o inimigo para baixo
inimigo_y += inimigo_velocidade# Desenhe objetos do jogo
window.fill((0, 0, 0)) # Limpa a tela
pygame.draw.rect (janela, (255, 0, 0),
(jogador_x, jogador_y,
player_width, player_height))
pygame.draw.rect (janela, (0, 255, 0),
(inimigo_x, inimigo_y,
largura_inimiga, altura_inimiga)) # Desenhe o inimigo
pygame.display.update()
pygame.quit()
Execute o código e você verá uma janela com um personagem do jogador que você pode controlar usando as teclas de seta para a esquerda e para a direita.
Agora que você tem uma configuração básica do jogo, defina as variáveis e constantes relacionadas à saúde do jogador. Você pode usar um sistema de saúde simples onde pode representar a saúde de um jogador por um valor numérico. Você também pode definir constantes para a saúde máxima do jogador e a quantidade de dano infligido pelo inimigo.
Defina a saúde inicial do jogador para 100, defina a saúde máxima como 100 e defina o dano do inimigo para 20. Esses valores podem ser ajustados de acordo com as necessidades específicas do seu jogo.
# Saúde do jogador
player_health = 100
max_health = 100
dano_inimigo = 20Implementando Mecânica de Dano e Cura
Para introduzir a mecânica de dano e cura, você precisa detectar colisões entre o jogador e o inimigo e lidar com as mudanças de saúde correspondentes. Você também pode implementar um mecanismo para curar o jogador quando ele sair da tela.
Verifique se existe um colisão entre o jogador e o inimigo comparando seus retângulos delimitadores. Se uma colisão for detectada, subtraia o valor de dano do inimigo da saúde do jogador.
Além disso, se o jogador sair do topo da tela (jogador_y < 0), adicione 10 à sua saúde e certifique-se de que não exceda o máximo de saúde. Isso cria uma mecânica de cura e redefine a posição do jogador para a parte inferior da tela.
Crie um novo arquivo chamado dano-e-cura.py e adicione o código com as atualizações abaixo:
# Dentro do loop do jogo, após atualizar a posição do inimigo
# Detectar colisão entre o jogador e o inimigo
se jogador_x < inimigo_x + inimigo_largura e \
player_x + player_width > inimigo_x e \
player_y < inimigo_y + altura_do_inimigo \
e jogador_y + altura_do_jogador > inimigo_y:
player_health -= inimigo_dano
imprimir (jogador_saúde)
# Cure o jogador quando ele sair da tela
se jogador_y < 0:
player_health += 10
imprimir (jogador_saúde)
se player_health > max_health:
player_health = max_health
player_y = window_height - player_height - 10
Abaixo está a saída:
Gerenciando Cenários de Morte de Jogadores e Fim de Jogo
Para lidar com os cenários de morte e fim do jogo do jogador, você precisa verificar se a saúde do jogador chega a zero. Em caso afirmativo, exiba um Game Over mensagem e reinicie o jogo.
Adicione uma verificação para ver se a saúde do jogador cai abaixo ou é igual a zero. Se esta condição for verdadeira, imprima Game Over e redefina a saúde e a posição do jogador.
Crie um novo arquivo chamado manage-player-death.py e modifique o código com as atualizações abaixo:
# Depois de atualizar a posição do jogador
# Verifique se a saúde do jogador chega a zero
se player_health <= 0:
imprimir("Game Over")
player_health = max_health
player_x = window_width // 2
player_y = window_height - player_height - 10
Incluindo Recursos Adicionais
Para aprimorar ainda mais o sistema de saúde, você pode incorporar recursos adicionais. Abaixo está um exemplo:
Power-ups
Defina os atributos do power-up, como suas dimensões e posição. Além disso, defina um valor de saúde que o jogador ganhará ao colidir com o power-up.
Dentro do loop do jogo, detecte colisões entre o jogador e o power-up. Se ocorrer uma colisão, aumente a saúde do jogador pelo valor de saúde do power-up, certificando-se de que não exceda o máximo de saúde. Em seguida, reposicione o power-up aleatoriamente na tela. Por fim, desenhe o objeto de inicialização na tela usando um retângulo azul.
Crie um novo arquivo chamado power-up.py e adicione o código com as atualizações abaixo:
# Definir atributos de inicialização
power_up_width, power_up_height = 30, 30
power_up_x, power_up_y = 200,200
power_up_health_value = 50# Dentro do loop do jogo, após atualizar a posição do jogador
# Detecta colisão entre o jogador e o power-up
se player_x < power_up_x + power_up_width e\
player_x + player_width > power_up_x \
e player_y < power_up_y + power_up_height\
e player_y + player_height > power_up_y:
player_health += power_up_health_value
se player_health > max_health:
player_health = max_health
power_up_x, power_up_y = 200,200
# Desenhe o objeto de inicialização
pygame.draw.rect (janela, (0, 0, 255),
(power_up_x, power_up_y,
power_up_width,
power_up_height))
Abaixo está a saída:
Para cada recurso adicional, você pode definir as variáveis e constantes necessárias e implementar a mecânica correspondente dentro do loop do jogo.
Melhores Práticas para o Sistema de Saúde
Ao implementar um sistema de integridade no PyGame, lembre-se das seguintes práticas recomendadas:
Implementar sistemas orientados a eventos
Em vez de verificar continuamente se há colisões ou alterações de integridade no loop do jogo, considere o uso de sistemas orientados a eventos. O PyGame fornece recursos de manipulação de eventos, permitindo acionar ações relacionadas à integridade com base em eventos específicos, como eventos de colisão ou eventos de coleta de energia.
Equilibrar valores de saúde
Ajuste os valores de saúde, valores de dano e taxas de cura em seu jogo para garantir uma experiência de jogo equilibrada. O teste de jogo e a coleta de feedback dos jogadores podem ajudá-lo a ajustar esses valores para uma jogabilidade ideal.
Dar uma resposta
Certifique-se de que o jogador receba feedback claro e significativo sobre seu estado de saúde. Exiba a barra de saúde com destaque na tela, use dicas visuais, como mudanças de cor ou animações para indicar dano ou cura e fornecer pistas de áudio ou visuais quando a saúde do jogador atinge níveis críticos.
Seguindo essas práticas recomendadas, você pode criar um sistema de saúde robusto e envolvente que contribui para uma experiência de jogo envolvente.
Torne os jogos mais envolventes com a barra de saúde
A implementação de um sistema de saúde não apenas adiciona uma camada de desafio, mas também torna os jogos mais envolventes para os jogadores. Ao incorporar representações visuais de saúde, como barras de saúde, os jogadores podem avaliar facilmente seu status atual e tomar decisões estratégicas. Além disso, adicionar níveis ao seu jogo pode melhorar ainda mais a experiência de jogo.