Apimente seus jogos de fliperama apresentando inimigos.

Os inimigos desempenham um papel crucial na criação de jogos envolventes e desafiadores. Eles fornecem obstáculos e adversários para os jogadores, tornando a experiência de jogo mais emocionante. A biblioteca Arcade do Python oferece uma maneira direta de incorporar inimigos em seus jogos.

Crie um jogo simples

Antes de começar, certifique-se de ter pip instalado no seu dispositivo. Use este comando para instalar o videogames biblioteca:

pip instalar fliperama

Depois disso, comece criando um jogo simples onde o jogador pode se mover para a esquerda e para a direita usando as setas do teclado.

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

importar videogames
# Dimensões da janela
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


# Atributos do jogador
PLAYER_RADIUS = 25
PLAYER_SPEED = 5


aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 arcade.set_background_color (arcade.color. BRANCO)
 self.player_x = largura // 2







instagram viewer



defon_draw(auto):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. AZUL)


defon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
 self.player_x -= PLAYER_SPEED
elif chave == arcade.key. CERTO:
 self.player_x += PLAYER_SPEED


defatualizar(auto, delta_time):
passar


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

Criando um inimigo simples

Para criar um inimigo que mata o jogador na colisão, crie outro círculo na tela. No on_draw função, você pode desenhar este círculo inimigo e verificar se há colisões no atualizar método. Você também pode usar sprites para inimigos.

# Adicionar à classe GameWindow
aulaGameWindow(videogames. Janela):
# ...


def__iniciar__(auto, largura, altura):
# ...


# Atributos inimigos
 self.enemy_x = largura // 2
 self.enemy_y = altura - PLAYER_RADIUS
 self.enemy_radius = 20


defon_draw(auto):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. VERMELHO)
defatualizar(auto, delta_time):
se self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 imprimir("Game Over!")

defis_collision(próprio, x1, y1, x2, y2, raio1, raio2):
 distância ao quadrado = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (radius1 + radius2) ** 2
retornar distance_squared <= radius_sum_squared

Fazendo o inimigo seguir o jogador

Em alguns jogos, os inimigos podem perseguir o jogador, adicionando um elemento dinâmico à jogabilidade. Para criar um inimigo seguinte, você precisa atualizar sua posição com base na posição do jogador. Em qualquer momento o jogador se move, o inimigo se move na mesma direção. Você pode conseguir isso modificando o atualizar método. Crie um novo arquivo chamado inimigo-follow-player.py e adicione o código com as atualizações abaixo:

# Adicionar à classe GameWindow
aulaGameWindow(videogames. Janela):
# ...


defatualizar(auto, delta_time):
se self.player_x < self.enemy_x:
 self.enemy_x -= PLAYER_SPEED
elif self.player_x > self.enemy_x:
 self.enemy_x += PLAYER_SPEED
se self.is_collision (self.player_x, self.player_y,
 self.inimigo_x, self.inimigo_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 imprimir("Game Over!")

defis_collision(próprio, x1, y1, x2, y2, raio1, raio2):
 distância ao quadrado = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (radius1 + radius2) ** 2
retornar distance_squared <= radius_sum_squared

Abaixo está a saída:

Adicionando balas inimigas

Para criar um inimigo que atira balas, crie um Bala classe e uma lista para acompanhar os marcadores ativos. O inimigo criará periodicamente uma nova bala e atualizará sua posição. Crie um novo arquivo chamado bullets.py e adicione o código com as atualizações abaixo:

# Adicionar à classe GameWindow
aulaBala:
def__iniciar__(auto, x, y, raio, velocidade):
 auto.x = x
 self.y = y
 self.radius = raio
 self.speed = velocidade


defatualizar(auto):
 self.y -= self.speed


aulaGameWindow(videogames. Janela):
# ...


def__iniciar__(auto, largura, altura):
# ...


# Atributos inimigos
 self.bullets = []
 self.bullet_radius = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Número de quadros entre a geração de balas
 self.bullet_timer = 0


defon_draw(auto):
# ...
para bala em self.bullets:
 arcade.draw_circle_filled (bullet.x, bullet.y, 
 self.bullet_radius, arcade.color. PRETO)


defatualizar(auto, delta_time):
# ...


 self.bullet_timer += 1
se self.bullet_timer >= self.bullet_cooldown:
 self.bullets.append (Bala (self.enemy_x, self.enemy_y - self.enemy_radius, 
self.bullet_radius, self.bullet_speed))
 self.bullet_timer = 0
para bala em self.bullets:
 bullet.update()
se self.is_collision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 imprimir("Game Over!")

defis_collision(próprio, x1, y1, x2, y2, raio1, raio2):
 distância ao quadrado = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radius_sum_squared = (radius1 + radius2) ** 2
retornar distance_squared <= radius_sum_squared

Abaixo está a saída:

Adicionando pontos de saúde para inimigos

Em muitos jogos, os inimigos podem possuir pontos de saúde (HP), permitindo-lhes sustentar vários golpes antes de serem derrotados. Adicionar pontos de saúde aos inimigos pode introduzir elementos de jogabilidade estratégicos e fornecer uma sensação de progressão e desafio. Crie um novo arquivo chamado heath-point.py e adicione o código com as atualizações abaixo:

# Dimensões da janela
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Atributos do jogador
PLAYER_RADIUS = 25
PLAYER_SPEED = 5


# Atributos inimigos
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100


aulaGameWindow(videogames. Janela):
def__iniciar__(auto, largura, altura):
 super().__init__(largura, altura)
 arcade.set_background_color (arcade.color. BRANCO)
 self.player_x = largura // 2
 self.player_y = altura // 2
 self.enemy_x = largura // 2
 self.enemy_y = altura - PLAYER_RADIUS
 self.enemy_health = ENEMY_HEALTH
 imprimir (self.enemy_health)
defon_draw(auto):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 PLAYER_RADIUS,
 arcade.color. AZUL)
se self.enemy_health > 0:
 arcade.draw_circle_filled (self.enemy_x,
 auto.inimigo_y,
 ENEMY_RADIUS,
 arcade.color. VERMELHO)
defatualizar(auto, delta_time):
se self.is_collision (self.player_x, self.player_y,
 self.inimigo_x, self.inimigo_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 self.enemy_health -= 10
 imprimir (self.enemy_health)

O ENEMY_HEALTH constante tem um valor de 100 para representar os pontos de saúde iniciais do inimigo. Quando o jogador colide com o inimigo, você pode deduzir alguns pontos da saúde do inimigo. Para exibir o valor de saúde atualizado, você pode imprimir um objeto de texto self.health_text que mostra a saúde atual do inimigo.

Ao incorporar pontos de saúde para os inimigos, você pode introduzir uma camada de desafio e estratégia para os jogadores. O valor de saúde exibido fornece feedback visual e permite aos jogadores rastrear a saúde restante do inimigo.

Além disso, você pode expandir o código adicionando mais lógica e recursos visuais, como exibir barras de saúde ou implementar condições de derrota quando a saúde do inimigo chegar a zero.

Melhores práticas para criar inimigos

Ao criar inimigos para o seu jogo, é importante considerar várias práticas recomendadas para garantir que elas contribuam para uma experiência de jogo desafiadora e agradável. Aqui estão algumas diretrizes a seguir ao criar inimigos:

Diversos Atributos

Crie inimigos com atributos variados, como velocidade, tamanho, saúde e poder de ataque. Diferentes tipos de inimigos devem representar diferentes níveis de dificuldade, exigindo que os jogadores adaptem suas estratégias de acordo. Ao introduzir uma mistura de atributos inimigos, você pode manter a jogabilidade nova e envolvente.

Comportamentos únicos

Dê a cada tipo de inimigo seus próprios padrões de comportamento únicos. Alguns inimigos podem se mover de maneira previsível, enquanto outros podem exibir movimentos mais complexos ou erráticos. Considere incorporar algoritmos de IA inimigos para tornar seu comportamento mais inteligente e imprevisível, adicionando uma camada extra de desafio para os jogadores.

Pontos de Saúde (HP)

Implemente pontos de saúde para os inimigos para introduzir uma sensação de progressão e durabilidade. Isso permite que os inimigos sustentem vários golpes antes de serem derrotados. Ao atribuir quantidades variáveis ​​de HP a diferentes tipos de inimigos, você pode criar uma hierarquia de dificuldade e incentivar os jogadores a criar estratégias e priorizar seus alvos.

Torne os jogos mais divertidos com os inimigos

Adicionar inimigos aos seus jogos pode melhorar significativamente a experiência de jogo. Eles introduzem desafios e motivam os jogadores a melhorar suas habilidades. Os inimigos podem vir de várias formas, desde simples obstáculos até complexos adversários controlados por IA. Ao implementar os inimigos de forma eficaz, você pode tornar seus jogos mais envolventes e agradáveis ​​para os jogadores.