Comment créer des ennemis dans les jeux d'arcade Python

Les ennemis jouent un rôle crucial dans la création de jeux engageants et stimulants. Ils fournissent des obstacles et des adversaires aux joueurs, rendant l'expérience de jeu plus excitante. La bibliothèque Python's Arcade offre un moyen simple d'incorporer des ennemis dans vos jeux.

Créer un jeu simple

Avant de commencer, assurez-vous d'avoir pip installé sur votre appareil. Utilisez cette commande pour installer le arcade bibliothèque:

pip installer arcade

Après cela, commencez par créer un jeu simple où le joueur peut se déplacer à gauche et à droite à l'aide des touches fléchées.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

importer arcade
# Dimensions de la fenêtre
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Attributs du joueur
PLAYER_RADIUS = 25
PLAYER_SPEED = 5
classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 arcade.set_background_color (arcade.color. BLANC)
 self.player_x = largeur // 2





instagram viewer

définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color. BLEU)
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= PLAYER_SPEED
elif clé == arcade.clé. DROITE:
 self.player_x += PLAYER_SPEED
définitivementmise à jour(soi, delta_time):
passer
définitivementprincipal():
 window = GameWindow (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
si __nom__ == "__principal__":
 principal()

Créer un ennemi simple

Pour créer un ennemi qui tue le joueur lors d'une collision, créez un autre cercle sur l'écran. Dans le on_draw fonction, vous pouvez dessiner ce cercle ennemi et vérifier les collisions dans le mise à jour méthode. Vous pouvez aussi utiliser des sprites pour les ennemis.

# Ajouter à la classe GameWindow
classeFenêtre de jeu(arcade. Fenêtre):
# ...
définitivement__init__(soi, largeur, hauteur):
# ...
# Attributs ennemis
 self.enemy_x = largeur // 2
 self.enemy_y = hauteur - PLAYER_RADIUS
 self.enemy_radius = 20
définitivementon_draw(soi):
# ...
 arcade.draw_circle_filled (self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color. ROUGE)
définitivementmise à jour(soi, delta_time):
si self.is_collision (self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
 imprimer("Jeu terminé!")

définitivementest_collision(soi, x1, y1, x2, y2, rayon1, rayon2):
 distance_au carré = (x1 - x2) ** 2 + (y1 - y2) ** 2
 rayon_somme_carré = (rayon1 + rayon2) ** 2
retour distance_squared <= radius_sum_squared

Faire en sorte que l'ennemi suive le joueur

Dans certains jeux, les ennemis peuvent chasser le joueur, ajoutant un élément dynamique au gameplay. Pour créer un ennemi suivant, vous devez mettre à jour sa position en fonction de la position du joueur. Chaque fois que le joueur bouge, l'ennemi se déplace dans la même direction. Vous pouvez y parvenir en modifiant le mise à jour méthode. Créer un nouveau fichier nommé ennemi-suivre-joueur.py et ajoutez le code avec les mises à jour ci-dessous :

# Ajouter à la classe GameWindow
classeFenêtre de jeu(arcade. Fenêtre):
# ...
définitivementmise à jour(soi, delta_time):
si self.player_x < self.enemy_x :
 self.enemy_x -= PLAYER_SPEED
elif self.player_x > self.enemy_x :
 self.enemy_x += PLAYER_SPEED
si self.is_collision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 JOUEUR_RADIUS, ENEMY_RADIUS) :
 imprimer("Jeu terminé!")

définitivementest_collision(soi, x1, y1, x2, y2, rayon1, rayon2):
 distance_au carré = (x1 - x2) ** 2 + (y1 - y2) ** 2
 rayon_somme_carré = (rayon1 + rayon2) ** 2
retour distance_squared <= radius_sum_squared

Ci-dessous la sortie :

Ajout de balles ennemies

Pour créer un ennemi qui tire des balles, créez un Balle classe et une liste pour garder une trace des puces actives. L'ennemi créera périodiquement une nouvelle balle et mettra à jour sa position. Créer un nouveau fichier nommé balles.py et ajoutez le code avec les mises à jour ci-dessous :

# Ajouter à la classe GameWindow
classeBalle:
définitivement__init__(soi, x, y, rayon, vitesse):
 soi.x = x
 soi.y = y
 self.radius = rayon
 auto.vitesse = vitesse
définitivementmise à jour(soi):
 self.y -= self.speed
classeFenêtre de jeu(arcade. Fenêtre):
# ...
définitivement__init__(soi, largeur, hauteur):
# ...
# Attributs ennemis
 self.bullets = []
 self.bullet_radius = 5
 self.bullet_speed = 3
 self.bullet_cooldown = 60# Nombre d'images entre les apparitions de balles
 self.bullet_timer = 0
définitivementon_draw(soi):
# ...
pour balle dans auto.puces :
 arcade.draw_circle_filled (bullet.x, bullet.y, 
 self.bullet_radius, arcade.color. NOIR)
définitivementmise à jour(soi, delta_time):
# ...
 self.bullet_timer += 1
si self.bullet_timer >= self.bullet_cooldown :
 self.bullets.append (Puce (self.enemy_x, self.enemy_y - self.enemy_radius, 
self.bullet_radius, self.bullet_speed))
 self.bullet_timer = 0
pour balle dans auto.puces :
 bullet.update()
si self.is_collision (self.player_x, self.player_y, self.enemy_x, 
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
 imprimer("Jeu terminé!")

définitivementest_collision(soi, x1, y1, x2, y2, rayon1, rayon2):
 distance_au carré = (x1 - x2) ** 2 + (y1 - y2) ** 2
 rayon_somme_carré = (rayon1 + rayon2) ** 2
retour distance_squared <= radius_sum_squared

Ci-dessous la sortie :

Ajout de points de vie pour les ennemis

Dans de nombreux jeux, les ennemis peuvent posséder des points de santé (HP), leur permettant de subir plusieurs coups avant d'être vaincus. L'ajout de points de santé aux ennemis peut introduire des éléments de gameplay stratégiques et donner un sentiment de progression et de défi. Créer un nouveau fichier nommé heath-point.py et ajoutez le code avec les mises à jour ci-dessous :

# Dimensions de la fenêtre
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Attributs du joueur
PLAYER_RADIUS = 25
PLAYER_SPEED = 5
# Attributs ennemis
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100
classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 arcade.set_background_color (arcade.color. BLANC)
 self.player_x = largeur // 2
 self.player_y = hauteur // 2
 self.enemy_x = largeur // 2
 self.enemy_y = hauteur - PLAYER_RADIUS
 self.enemy_health = ENEMY_HEALTH
 imprimer (self.enemy_health)
définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 PLAYER_RADIUS,
 arcade.color. BLEU)
si self.enemy_health > 0:
 arcade.draw_circle_filled (self.enemy_x,
 self.enemy_y,
 ENEMY_RADIUS,
 arcade.color. ROUGE)
définitivementmise à jour(soi, delta_time):
si self.is_collision (self.player_x, self.player_y,
 self.enemy_x, self.enemy_y,
 JOUEUR_RADIUS, ENEMY_RADIUS) :
 self.enemy_health -= 10
 imprimer (self.enemy_health)

Le ENEMY_HEALTH constante a une valeur de 100 pour représenter les points de vie initiaux de l'ennemi. Lorsque le joueur entre en collision avec l'ennemi, vous pouvez déduire certains points de la santé de l'ennemi. Pour afficher la valeur de santé mise à jour, vous pouvez imprimer un objet texte self.health_text qui montre la santé actuelle de l'ennemi.

En incorporant des points de santé pour les ennemis, vous pouvez introduire une couche de défi et de stratégie pour les joueurs. La valeur de santé affichée fournit un retour visuel et permet aux joueurs de suivre la santé restante de l'ennemi.

De plus, vous pouvez étendre le code en ajoutant une logique et des visuels supplémentaires, tels que l'affichage de barres de santé ou la mise en œuvre de conditions de défaite lorsque la santé de l'ennemi atteint zéro.

Meilleures pratiques pour créer des ennemis

Lors de la conception d'ennemis pour votre jeu, il est important de prendre en compte plusieurs bonnes pratiques pour s'assurer qu'elles contribuent à une expérience de jeu stimulante et agréable. Voici quelques directives à suivre lors de la création d'ennemis :

Attributs divers

Créez des ennemis avec des attributs variés tels que la vitesse, la taille, la santé et la puissance d'attaque. Différents types d'ennemis devraient poser différents niveaux de difficulté, obligeant les joueurs à adapter leurs stratégies en conséquence. En introduisant un mélange d'attributs ennemis, vous pouvez garder le gameplay frais et engageant.

Comportements uniques

Donnez à chaque type d'ennemi ses propres modèles de comportement uniques. Certains ennemis peuvent se déplacer de manière prévisible, tandis que d'autres peuvent présenter des mouvements plus complexes ou erratiques. Envisagez d'incorporer des algorithmes d'IA ennemis pour rendre leur comportement plus intelligent et imprévisible, en ajoutant une couche supplémentaire de défi pour les joueurs.

Points de santé (PV)

Mettez en place des points de santé pour les ennemis afin d'introduire un sentiment de progression et de durabilité. Cela permet aux ennemis de subir plusieurs coups avant d'être vaincus. En attribuant différentes quantités de HP à différents types d'ennemis, vous pouvez créer une hiérarchie de difficulté et encourager les joueurs à élaborer des stratégies et à hiérarchiser leurs cibles.

Rendre les jeux plus amusants avec les ennemis

L'ajout d'ennemis à vos jeux peut améliorer considérablement l'expérience de jeu. Ils introduisent des défis et motivent les joueurs à améliorer leurs compétences. Les ennemis peuvent prendre différentes formes, allant de simples obstacles à des adversaires complexes pilotés par l'IA. En implémentant efficacement les ennemis, vous pouvez rendre vos jeux plus attrayants et plus agréables pour les joueurs.