Dê aos seus jogadores algo para pegar enquanto progridem no jogo.

Power-ups e colecionáveis ​​são elementos essenciais do jogo que podem aprimorar a experiência de jogo e adicionar emoção aos jogos de fliperama. Eles fornecem aos jogadores habilidades, recompensas e desafios adicionais. Com a biblioteca de fliperama, você poderá criar jogos envolventes com power-ups e colecionáveis ​​rapidamente.

Crie um jogo simples

Comece com uma configuração básica onde o jogador pode se mover em quatro direções (esquerda, direita, para cima e para baixo) usando as entradas do teclado. Além disso, introduza um objeto inimigo para fornecer interação no ambiente do jogo.

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

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

importar videogames
azul = arcade.color. AZUL
vermelho = arcade.color. VERMELHO
preto = arcade.color. PRETO
branco = arcade.color. BRANCO
amarelo = arcade.color. AMARELO
verde = arcade.color. VERDE
laranja = arcade.color. LARANJA







instagram viewer



aulaJogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 arcade.set_background_color (preto)


 self.player = arcada. SpriteCircle(20, azul)
 self.player.center_x = largura // 2
 self.player.center_y = altura // 2


 self.inimigo = arcada. SpriteSolidColor(20, 20, vermelho)
 self.enemy.center_x = largura // 4
 self.enemy.center_y = altura // 4


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 -= 10
elif chave == arcade.key. CERTO:
 self.player.center_x += 10
elif chave == arcade.key. ACIMA:
 self.player.center_y += 10
elif chave == arcade.key. ABAIXO:
 self.player.center_y -= 10


defprincipal():
 jogo = Jogo(800, 600)
 arcade.run()
se __nome__ == "__principal__":
 principal()

Execute este código e você terá um jogo básico com movimento do jogador e um objeto inimigo.

Criando estados de jogo

Para incorporar power-ups e colecionáveis, você precisa estabelecer os estados do jogo, como pontuação e saúde. Você pode gerenciar pontuação e saúde usando uma variável separada. Modifique o código para incluir esses recursos. A saúde do jogador diminuirá quando ele colidir com o objeto inimigo.

aulaJogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.score = 0
 auto.saúde = 100


defon_draw(auto):
 arcade.draw_text(f"Pontuação: {self.score}", 10, 10, branco)
 arcade.draw_text(f"Saúde: {auto.saúde}", 10, 30, branco)


defatualizar(auto, delta_time):
se arcade.check_for_collision (self.player, self.enemy):
 auto.saúde -= 10


se auto.saúde <= 0:
 self.game_over()
defgame Over(auto):
# Adicione game over logic aqui
passar

Agora, a saúde do jogador diminui em 10 ao colidir com o inimigo, e os valores de pontuação e saúde são exibidos na tela.

Adicionando itens colecionáveis

Em seguida, crie colecionáveis ​​que aumentarão a pontuação do jogador em 10 quando coletados. Esses itens colecionáveis ​​terão formas diferentes para variedade visual. Crie um novo arquivo chamado colecionáveis.py e adicione o código com a atualização abaixo:

aulaJogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.collectibles = arcada. SpriteList()


para _ em faixa(5):
 colecionável = arcade. SpriteSolidColor(20, 40, amarelo)
 collectible.center_x = random.randint(0, largura)
 collectible.center_y = random.randint(0, altura)
 self.collectibles.append (colecionável)


defon_draw(auto):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()
 self.collectibles.draw()
 arcade.draw_text(f"Pontuação: {self.score}", 10, 10, branco)
 arcade.draw_text(f"Saúde: {auto.saúde}", 10, 30, branco)
defatualizar(auto, delta_time):
para colecionável em auto.colecionáveis:
se arcade.check_for_collision (self.player, colecionável):
 auto.pontuação += 10
 collectible.remove_from_sprite_lists()

Crie uma lista de colecionáveis ​​com cinco instâncias, cada uma representada por um retângulo amarelo. Quando o jogador colide com um colecionável, sua pontuação aumenta em 10 e o colecionável é removido da lista de sprites.

Adicionando power-ups

Agora, você pode adicionar power-ups ao seu jogo. Quando o jogador coleta um power-up, um escudo aparecerá ao seu redor por 10 segundos. Durante este tempo, se o jogador colide com o inimigo, eles destruirão o inimigo. Crie um novo arquivo chamado power-ups.py e adicione o código com a atualização abaixo:

aulaJogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 self.power_up = arcada. SpriteSolidColor(50, 20, verde)
 self.power_up.center_x = random.randint(0, largura)
 self.power_up.center_y = random.randint(0, altura)


 self.shield_active = Falso
 self.shield_duration = 10
 self.shield_timer = 0


defon_draw(auto):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()
 self.collectibles.draw()
 self.power_up.draw()
 arcade.draw_text(f"Pontuação: {self.score}", 10, 10, branco)
 arcade.draw_text(f"Saúde: {auto.saúde}", 10, 30, branco)


defatualizar(auto, delta_time):
se arcade.check_for_collision (self.player, self.enemy):
senão self.shield_active:
 auto.saúde -= 10
se auto.saúde <= 0:
 self.game_over()
outro:
 self.enemy.remove_from_sprite_lists()


se self.shield_active:
 self.shield_timer += delta_time


se self.shield_timer >= self.shield_duration:
 self.shield_active = Falso
 self.shield_timer = 0


para colecionável em auto.colecionáveis:
se arcade.check_for_collision (self.player, colecionável):
 auto.pontuação += 10
 collectible.remove_from_sprite_lists()
se arcade.check_for_collision (self.player, self.power_up):
 self.shield_active = Verdadeiro
 self.power_up.remove_from_sprite_lists()

Abaixo está a saída:

Incluindo Recursos Adicionais

Você pode aprimorar ainda mais o sistema de power-ups e colecionáveis ​​adicionando recursos adicionais. Por exemplo, você pode criar um power-up de cronômetro que estende o tempo de jogo quando coletado. Crie um novo arquivo chamado timer-power-up.py e adicione o código com a atualização abaixo:

aulaJogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 arcade.set_background_color (preto)
 self.player = arcada. SpriteCircle(20, azul)
# ...


 self.timer_power_up = fliperama. SpriteSolidColor(40, 20, laranja)
 self.timer_power_up.center_x = random.randint(0, largura)
 self.timer_power_up.center_y = random.randint(0, altura)


 self.game_time = 60# Tempo inicial de jogo em segundos
 self.timer_power_up_duration = 10


# ...

defatualizar(auto, delta_time):
# ...


se arcade.check_for_collision (self.player, self.timer_power_up):
 self.game_time += self.timer_power_up_duration
 self.timer_power_up.remove_from_sprite_lists()


# ...


defprincipal():
 jogo = Jogo(800, 600)
 arcade.run()
se __nome__ == "__principal__":
 principal()

Práticas recomendadas para power-ups e itens colecionáveis

Power-ups e colecionáveis ​​desempenham um papel crucial no aprimoramento da experiência de jogo dos jogos de arcade. Para garantir que esses elementos sejam agradáveis ​​e bem integrados ao jogo, é essencial seguir algumas práticas recomendadas:

Clareza visual e consistência

Use sprites distintos e visualmente atraentes para power-ups e itens colecionáveis ​​para destacá-los de outros elementos do jogo. Certifique-se de que a aparência de power-ups e colecionáveis ​​esteja alinhada com seus efeitos e propósito no jogo.

Mantenha a consistência no design, esquemas de cores e tamanho para power-ups e colecionáveis ​​ao longo do jogo.

Equilíbrio e Desafio

Ajuste a raridade e distribuição de power-ups e colecionáveis ​​para manter um senso de desafio e recompensa para os jogadores. Evite sobrecarregar os jogadores com muitos power-ups ou itens colecionáveis, pois isso pode diminuir o impacto e a emoção de encontrá-los.

Equilibre cuidadosamente a eficácia e a duração dos power-ups para evitar que sejam muito poderosos ou insatisfatórios.

Indicadores claros e feedback

Forneça indicadores visuais e de áudio claros quando o jogador coletar um power-up ou colecionável. Exiba efeitos visuais temporários, como animações ou partículas, para indicar a ativação de power-ups e sua duração.

Relação desafio-recompensa

Certifique-se de que power-ups e itens colecionáveis ​​forneçam recompensas significativas ao jogador, como pontuação aumentada, habilidades adicionais ou tempo de jogo estendido. Alinhe a dificuldade de obter power-ups e colecionáveis ​​com os benefícios que eles oferecem. Tarefas mais desafiadoras devem render recompensas mais valiosas.

Playtesting e balanceamento

Teste o jogo extensivamente para observar como os jogadores interagem com power-ups e itens colecionáveis. Use o feedback do jogador para ajustar a distribuição, duração e efeitos de power-ups e colecionáveis ​​para criar uma experiência equilibrada e agradável.

Ao seguir essas práticas recomendadas, você pode criar um sistema de power-up e colecionáveis ​​cativante e bem equilibrado que aprimora a experiência de jogo e mantém os jogadores envolvidos em seu jogo de arcade.

Torne os jogos mais divertidos com power-ups e itens colecionáveis

Power-ups e colecionáveis ​​adicionam uma camada extra de emoção e envolvimento aos jogos de fliperama. Eles não apenas fornecem aos jogadores novas habilidades e recompensas, mas também criam desafios interessantes e escolhas estratégicas.

Ao incorporar esses recursos usando a biblioteca Python Arcade, você pode tornar seus jogos mais divertidos e aprimorar a experiência geral de jogo para seus jogadores. Lembre-se de experimentar, iterar e liberar sua criatividade para criar power-ups e itens colecionáveis ​​únicos e cativantes que se alinham com o tema e a mecânica do seu jogo.