Dale sabor a tus juegos de arcade introduciendo enemigos.

Los enemigos juegan un papel crucial en la creación de juegos atractivos y desafiantes. Proporcionan obstáculos y adversarios para los jugadores, lo que hace que la experiencia de juego sea más emocionante. La biblioteca Arcade de Python ofrece una forma sencilla de incorporar enemigos en tus juegos.

Crea un juego simple

Antes de comenzar, asegúrese de tener pip instalado en su dispositivo. Use este comando para instalar el arcada biblioteca:

pip instalar arcade

Después de eso, comience creando un juego simple en el que el jugador pueda moverse hacia la izquierda y hacia la derecha usando las teclas de flecha.

El código utilizado en este artículo está disponible en este repositorio GitHub y es gratis para su uso bajo la licencia MIT.

importar arcada
# Dimensiones de la ventana
ANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600


# Atributos del jugador
RADIO_JUGADOR = 25
VELOCIDAD DEL JUGADOR = 5


claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):





instagram viewer


 super().__init__(ancho, alto)
 arcade.set_background_color (arcade.color. BLANCO)
 self.jugador_x = ancho // 2


definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. AZUL)


definitivamenteon_key_press(auto, clave, modificadores):
si clave == arcade.clave. IZQUIERDA:
 self.player_x -= PLAYER_SPEED
elif clave == arcade.clave. BIEN:
 self.player_x += PLAYER_SPEED


definitivamenteactualizar(uno mismo, delta_time):
aprobar


definitivamenteprincipal():
 ventana = GameWindow (PANTALLA_ANCHO, PANTALLA_ALTO)
 arcade.ejecutar()
si __nombre__ == "__principal__":
 principal()

Crear un enemigo simple

Para crear un enemigo que mate al jugador al chocar, crea otro círculo en la pantalla. En el en_dibujar función, puede dibujar este círculo enemigo y comprobar si hay colisiones en el actualizar método. Tú también puedes usa sprites para los enemigos.

# Agregar a la clase GameWindow
claseventana de juego(arcada. Ventana):
# ...


definitivamente__en eso__(uno mismo, ancho, alto):
# ...


# Atributos enemigos
 self.enemy_x = ancho // 2
 self.enemy_y = altura - PLAYER_RADIUS
 self.enemy_radius = 20


definitivamenteen_dibujar(ser):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. ROJO)
definitivamenteactualizar(uno mismo, delta_time):
si self.is_colision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 imprimir("¡Juego terminado!")

definitivamentees_colisión(uno mismo, x1, y1, x2, y2, radio1, radio2):
 distancia_cuadrada = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radio_sum_cuadrado = (radio1 + radio2) ** 2
devolver distancia_cuadrada <= radio_suma_cuadrada

Hacer que el enemigo siga al jugador

En algunos juegos, los enemigos pueden perseguir al jugador, agregando un elemento dinámico al juego. Para crear un enemigo seguidor, debes actualizar su posición en función de la posición del jugador. Cuando sea el jugador se mueve, el enemigo se mueve en la misma dirección. Puede lograr esto modificando el actualizar método. Crear un nuevo archivo llamado enemigo-sigue-jugador.py y agregue el código con las siguientes actualizaciones:

# Agregar a la clase GameWindow
claseventana de juego(arcada. Ventana):
# ...


definitivamenteactualizar(uno mismo, delta_time):
si self.jugador_x < self.enemy_x:
 self.enemy_x -= PLAYER_SPEED
elif self.jugador_x > self.enemigo_x:
 self.enemy_x += PLAYER_SPEED
si self.es_colisión (self.player_x, self.player_y,
 yo.enemigo_x, yo.enemigo_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 imprimir("¡Juego terminado!")

definitivamentees_colisión(uno mismo, x1, y1, x2, y2, radio1, radio2):
 distancia_cuadrada = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radio_sum_cuadrado = (radio1 + radio2) ** 2
devolver distancia_cuadrada <= radio_suma_cuadrada

A continuación se muestra la salida:

Adición de balas enemigas

Para crear un enemigo que dispare balas, crea un Bala clase y una lista para realizar un seguimiento de las viñetas activas. El enemigo creará periódicamente una nueva bala y actualizará su posición. Crear un nuevo archivo llamado balas.py y agregue el código con las siguientes actualizaciones:

# Agregar a la clase GameWindow
claseBala:
definitivamente__en eso__(yo, x, y, radio, velocidad):
 self.x = x
 self.y = y
 self.radius = radio
 self.velocidad = velocidad


definitivamenteactualizar(ser):
 self.y -= self.velocidad


claseventana de juego(arcada. Ventana):
# ...


definitivamente__en eso__(uno mismo, ancho, alto):
# ...


# Atributos enemigos
 self.viñetas = []
 self.bullet_radius = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Número de fotogramas entre engendros de balas
 self.bullet_timer = 0


definitivamenteen_dibujar(ser):
# ...
para bala en auto.viñetas:
 arcade.draw_circle_filled (viñeta.x, viñeta.y, 
 self.bullet_radius, arcada.color. NEGRO)


definitivamenteactualizar(uno mismo, delta_time):
# ...


 self.bullet_timer += 1
si self.bullet_timer >= self.bullet_cooldown:
 self.bullets.append (Bullet (self.enemy_x, self.enemy_y - self.enemy_radius, 
self.bullet_radius, self.bullet_speed))
 self.bullet_timer = 0
para bala en auto.viñetas:
 bala.actualizar()
si self.is_colision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 imprimir("¡Juego terminado!")

definitivamentees_colisión(uno mismo, x1, y1, x2, y2, radio1, radio2):
 distancia_cuadrada = (x1 - x2) ** 2 + (y1 - y2) ** 2
 radio_sum_cuadrado = (radio1 + radio2) ** 2
devolver distancia_cuadrada <= radio_suma_cuadrada

A continuación se muestra la salida:

Adición de puntos de salud para los enemigos

En muchos juegos, los enemigos pueden poseer puntos de salud (HP), lo que les permite recibir múltiples golpes antes de ser derrotados. Agregar puntos de salud a los enemigos puede introducir elementos de juego estratégicos y brindar una sensación de progresión y desafío. Crear un nuevo archivo llamado heath-point.py y agregue el código con las siguientes actualizaciones:

# Dimensiones de la ventana
ANCHO_PANTALLA = 800
PANTALLA_ALTURA = 600
# Atributos del jugador
RADIO_JUGADOR = 25
VELOCIDAD DEL JUGADOR = 5


# Atributos enemigos
ENEMIGO_RADIO = 20
ENEMIGO_SALUD = 100


claseventana de juego(arcada. Ventana):
definitivamente__en eso__(uno mismo, ancho, alto):
 super().__init__(ancho, alto)
 arcade.set_background_color (arcade.color. BLANCO)
 self.jugador_x = ancho // 2
 self.jugador_y = altura // 2
 self.enemy_x = ancho // 2
 self.enemy_y = altura - PLAYER_RADIUS
 self.enemy_health = ENEMIGO_SALUD
 imprimir (self.enemy_health)
definitivamenteen_dibujar(ser):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.jugador_y,
 JUGADOR_RADIO,
 arcade.color. AZUL)
si self.enemy_health > 0:
 arcade.draw_circle_filled (self.enemy_x,
 self.enemy_y,
 ENEMIGO_RADIO,
 arcade.color. ROJO)
definitivamenteactualizar(uno mismo, delta_time):
si self.es_colisión (self.player_x, self.player_y,
 yo.enemigo_x, yo.enemigo_y,
 PLAYER_RADIUS, ENEMY_RADIUS):
 self.enemy_health -= 10
 imprimir (self.enemy_health)

El ENEMIGO_SALUD La constante tiene un valor de 100 para representar los puntos de salud iniciales del enemigo. Cuando el jugador choca con el enemigo, puedes deducir algunos puntos de la salud del enemigo. Para mostrar el valor de salud actualizado, puede imprimir un objeto de texto self.health_text que muestra la salud actual del enemigo.

Al incorporar puntos de salud para los enemigos, puedes introducir una capa de desafío y estrategia para los jugadores. El valor de salud que se muestra proporciona información visual y permite a los jugadores realizar un seguimiento de la salud restante del enemigo.

Además, puede expandir el código agregando más lógica e imágenes, como mostrar barras de salud o implementar condiciones de derrota cuando la salud del enemigo llega a cero.

Mejores prácticas para crear enemigos

Cuando diseñes enemigos para tu juego, es importante tener en cuenta varias prácticas recomendadas para garantizar que contribuyan a una experiencia de juego divertida y desafiante. Aquí hay algunas pautas a seguir al crear enemigos:

Atributos Diversos

Crea enemigos con distintos atributos, como velocidad, tamaño, salud y poder de ataque. Los diferentes tipos de enemigos deberían presentar diferentes niveles de dificultad, lo que requiere que los jugadores adapten sus estrategias en consecuencia. Al introducir una combinación de atributos enemigos, puedes mantener el juego fresco y atractivo.

Comportamientos únicos

Dale a cada tipo de enemigo sus propios patrones de comportamiento únicos. Algunos enemigos pueden moverse de manera predecible, mientras que otros pueden exhibir movimientos más complejos o erráticos. Considere incorporar algoritmos de IA enemigos para hacer que su comportamiento sea más inteligente e impredecible, agregando una capa adicional de desafío para los jugadores.

Puntos de salud (HP)

Implemente puntos de salud para los enemigos para introducir una sensación de progresión y durabilidad. Esto permite que los enemigos sufran múltiples golpes antes de ser derrotados. Al asignar diferentes cantidades de HP a diferentes tipos de enemigos, puedes crear una jerarquía de dificultad y animar a los jugadores a crear estrategias y priorizar sus objetivos.

Haz que los juegos sean más divertidos con los enemigos

Agregar enemigos a tus juegos puede mejorar significativamente la experiencia de juego. Presentan desafíos y motivan a los jugadores a mejorar sus habilidades. Los enemigos pueden presentarse de varias formas, desde simples obstáculos hasta complejos adversarios impulsados ​​por IA. Al implementar enemigos de manera efectiva, puede hacer que sus juegos sean más atractivos y divertidos para los jugadores.