Olhando para aperfeiçoar a manipulação de perigo do seu jogo? Transforme vidas em saúde e adicione uma dimensão extra ao seu jogo.

Adicionar um sistema de saúde ao seu jogo de fliperama pode aprimorar a experiência do jogador e adicionar uma camada extra de desafio e engajamento. Você pode criar uma experiência de jogo mais envolvente com uma exibição da saúde e da mecânica do jogador para danos e cura.

Felizmente, implementar um sistema de saúde em Python usando a biblioteca Arcade é simples e requer apenas algumas etapas.

Crie um jogo simples

Primeiro, instale o pip no seu dispositivo e use o comando abaixo para instalar a biblioteca arcade:

pip instalar fliperama

Depois disso, comece criando um jogo simples usando a biblioteca Arcade. Este jogo apresentará um personagem do jogador que pode se mover para a esquerda, direita, para cima e para baixo e um objeto inimigo que representa uma ameaça para o jogador.

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

instagram viewer

Crie um novo arquivo chamado simple-game.py e adicione o código abaixo:

importar videogames
# Defina as dimensões da janela
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Defina a velocidade de movimento do jogador
PLAYER_MOVEMENT_SPEED = 5
branco = arcade.color. BRANCO
azul = arcade.color. AZUL
vermelho = arcade.color. VERMELHO


aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 arcade.set_background_color (branco)


# Crie jogadores e objetos inimigos
 self.player = arcada. SpriteCircle(30, azul)
 self.inimigo = arcada. SpriteCircle(30, vermelho)
 self.player.center_x = 100
 self.player.center_y = 100
 self.enemy.center_x = 400
 self.enemy.center_y = 300


defon_draw(auto):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()


defatualizar(auto, delta_time):
passar


defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player.center_x -= PLAYER_MOVEMENT_SPEED
elif chave == arcade.key. CERTO:
 self.player.center_x += PLAYER_MOVEMENT_SPEED
elif chave == arcade.key. ACIMA:
 self.player.center_y += PLAYER_MOVEMENT_SPEED
elif chave == arcade.key. ABAIXO:
 self.player.center_y -= PLAYER_MOVEMENT_SPEED


defprincipal():
 jogo = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
se __nome__ == "__principal__":
 principal()

Você deve ver uma janela contendo dois caracteres, representados por círculos azuis e vermelhos:

Para implementar o sistema de saúde, defina variáveis ​​e constantes relacionadas à saúde. Você os usará para acompanhar a saúde atual do jogador e determinar as regras de dano e cura. Adicione o seguinte código dentro do GameWindow aula:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
# ...
# Variáveis ​​e constantes relacionadas à saúde
 self.player_health = 100
# pontos de saúde curados por segundo
 self.heal_rate = 1


# Temporizador para cura
 self.heal_timer = 0


defatualizar(auto, delta_time):
# ...
# Atualize o cronômetro de cura
 self.heal_timer += delta_time


# Cura a saúde do jogador a cada 2 segundos
se self.heal_timer >= 2:
 self.player_health += self.heal_rate
 self.heal_timer = 0
# Certifique-se de que a saúde não exceda o valor máximo
se self.player_health > 100:
 self.player_health = 100

Implementando Mecânica de Dano e Cura

Para implementar a mecânica de dano e cura, detectar colisões entre o jogador e o inimigo. Reduza a saúde do jogador quando ele colidir com o inimigo e cure a saúde do jogador a cada 2 segundos quando não estiver colidindo. Modifique o atualizar() método e adicione o seguinte código:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
# ...
defatualizar(auto, delta_time):
# Detecta colisões entre o jogador e o inimigo
se arcade.check_for_collision (self.player, self.enemy):
 self.player_health -= 5
# ...

Gerenciando Cenários de Morte de Jogadores e Fim de Jogo

Para gerenciar os cenários de morte e fim do jogo do jogador, verifique se a saúde do jogador chega a zero ou menos. Se a saúde cair para zero, considere o jogador morto e encerre o jogo. Modifique o atualizar() método com o seguinte código:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
# ...
defatualizar(auto, delta_time):
# ...


# Verifique se a saúde do jogador é zero ou abaixo
se self.player_health <= 0:
# Terminar o jogo
 arcade.close_window()
# ...

Visualizando a Barra de Saúde

Uma representação visual da saúde do jogador pode melhorar muito a experiência de jogo. Crie uma barra de saúde usando retângulos para mostrar o nível de saúde atual. Crie um novo arquivo chamado health-bar.py e adicione o código com as atualizações abaixo:

aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
# ...
defon_draw(auto):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()
 cinza = arcade.color. CINZA CLARO
 verde = arcade.color. VERDE


# Desenhe a barra de saúde
 arcade.draw_rectangle_filled (SCREEN_WIDTH // 2, 20, 
 SCREEN_WIDTH, 20, cinza)


 health_width = self.player_health / 100 * SCREEN_WIDTH
 arcade.draw_rectangle_filled (health_width // 2, 20, 
 largura_saúde, 20, verde)

Abaixo está a saída:

Incluindo Recursos Adicionais

Você pode aprimorar ainda mais o sistema de saúde com mais recursos, como os abaixo.

Exibição Numérica de Saúde

Além da barra de integridade, você pode exibir a integridade restante como um valor numérico na tela. Isso fornece uma indicação precisa do estado de saúde do jogador. Adicione o seguinte código dentro do on_draw() método:

# Dentro do método on_draw()
preto = arcade.color. PRETO
texto = f"Saúde: {self.player_health}"
arcade.draw_text (texto, 10, 10, preto, 14)

Power-ups de Saúde

Para introduzir power-ups de saúde, você pode criar objetos especiais que aumentam a saúde do jogador quando colidem com eles. Aqui está um exemplo de como você pode implementar esse recurso:

# Dentro do método update()
se arcade.check_for_collision (self.player, self.power_up):
 self.player_health += 20
# Remova o power-up do jogo
 self.power_up.kill()

Tipos de inimigos variados

Para adicionar profundidade ao seu jogo, você pode introduzir diferentes tipos de inimigos que infligem vários níveis de dano ao jogador. Isso adiciona um elemento estratégico e permite experiências de jogo mais diversificadas. Aqui está uma implementação deste recurso:

# Dentro do método update()
se arcade.check_for_collision (self.player, self.enemy):
se self.enemy.type == "fraco":
 self.player_health -= 5
elif self.enemy.type == "forte":
 self.player_health -= 20

Ao incorporar esses recursos adicionais à implementação do sistema de saúde, você pode criar experiências de jogo mais dinâmicas e desafiadoras para seus jogadores.

Boas Práticas para o Sistema de Saúde

Ao implementar um sistema de saúde em seu jogo de fliperama, é importante seguir as práticas recomendadas para garantir que o sistema seja robusto e eficiente. Aqui estão algumas das melhores práticas a serem lembradas:

Torná-lo modular

Mantenha a funcionalidade do sistema de saúde em uma classe ou módulo separado para mantê-lo modular e facilmente reutilizável em diferentes projetos de jogos. Isso promove a organização do código e a separação de preocupações.

Validação de entrada e salvaguardas

Implemente a validação de entrada para impedir que seu código atribua valores de integridade inválidos. As mesmas salvaguardas devem proteger contra valores de saúde inválidos quando ocorrer dano ou cura.

Mecanismo de Salvar e Carregar

Implemente um mecanismo de salvar e carregar que inclua o estado de saúde do jogador. Isso permite que os jogadores retomem o jogo com seu progresso intacto, incluindo sua saúde, mesmo depois de sair do jogo.

Teste e tratamento de erros

Testar minuciosamente a implementação do Sistema de Saúde para verificar sua correção e confiabilidade. Use técnicas apropriadas de tratamento de erros para lidar com exceções e casos extremos de forma eficaz.

Feedback de saúde consistente

Forneça feedback consistente e claro ao jogador sobre seu estado de saúde. Você pode adicionar efeitos de áudio, dicas visuais ou mesmo feedback tátil, garantindo que os jogadores conheçam sua condição de saúde no jogo e possam tomar decisões informadas durante o jogo.

Ao seguir essas práticas recomendadas, você pode criar um sistema de saúde robusto e eficaz que aprimora a experiência de jogo do seu jogo de fliperama, mantendo a qualidade e a legibilidade do código.

Torne os jogos mais divertidos com o sistema de saúde

Adicionar um sistema de saúde ao seu jogo pode melhorar significativamente a experiência geral do jogador. Introduz um elemento de risco e desafio, tornando a jogabilidade mais envolvente e recompensadora.

Uma representação visual da saúde permite que os jogadores avaliem facilmente seu estado atual, aumentando a imersão e a tomada de decisões estratégicas.