Les ennemis jouent un rôle crucial dans la création de jeux attrayants et stimulants. Ils constituent des obstacles et des adversaires pour les joueurs, ce qui rend l’expérience de jeu plus excitante. La bibliothèque Arcade de Python offre un moyen simple d’incorporer des ennemis dans vos jeux.
Créer un jeu simple
Avant de commencer, assurez-vous que pip est installé sur votre appareil. Utilisez cette commande pour installer le programme arcade bibliothèque :
pip install arcade Ensuite, 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 dépôt GitHub et est libre d’utilisation sous la licence MIT.
import arcade
# Window dimensions
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Player attributes
PLAYER_RADIUS = 25
PLAYER_SPEED = 5
class GameWindow(arcade.Window):
def __init__(self, width, height):
super().__init__(width, height)
arcade.set_background_color(arcade.color.WHITE)
self.player_x = width // 2
def on_draw(self):
arcade.start_render()
arcade.draw_circle_filled(self.player_x, PLAYER_RADIUS, PLAYER_RADIUS, arcade.color.BLUE)
def on_key_press(self, key, modifiers):
if key == arcade.key.LEFT:
self.player_x -= PLAYER_SPEED
elif key == arcade.key.RIGHT:
self.player_x += PLAYER_SPEED
def update(self, delta_time):
pass
def main():
window = GameWindow(SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
if __name__ == "__main__":
main() Création d’un ennemi simple
Pour créer un ennemi qui tue le joueur en cas de collision, créez un autre cercle sur l’écran. Dans le on_draw vous pouvez dessiner ce cercle d’ennemis et vérifier les collisions dans la fonction mise à jour méthode. Vous pouvez également utiliser des sprites pour les ennemis.
# Add to GameWindow class
class GameWindow(arcade.Window):
# ...
def __init__(self, width, height):
# ...
# Enemy attributes
self.enemy_x = width // 2
self.enemy_y = height - PLAYER_RADIUS
self.enemy_radius = 20
def on_draw(self):
# ...
arcade.draw_circle_filled(self.enemy_x, self.enemy_y, self.enemy_radius, arcade.color.RED)
def update(self, delta_time):
if self.is_collision(self.player_x, self.player_y, self.enemy_x, self.enemy_y, PLAYER_RADIUS, self.enemy_radius):
print("Game Over!")
def is_collision(self, x1, y1, x2, y2, radius1, radius2):
distance_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
radius_sum_squared = (radius1 + radius2) ** 2
return distance_squared <= radius_sum_squared Faire en sorte que l’ennemi suive le joueur
Dans certains jeux, les ennemis peuvent suivre le joueur, ajoutant ainsi un élément dynamique au gameplay. Pour créer un ennemi qui suit le joueur, vous devez mettre à jour sa position en fonction de celle du joueur. Chaque fois que le joueur se déplace, l’ennemi se déplace dans la même direction. Vous pouvez y parvenir en modifiant la propriété mise à jour méthode. Créez un nouveau fichier nommé ennemi-suivi-joueur.py et ajoutez le code avec les mises à jour ci-dessous :
# Add to GameWindow class
class GameWindow(arcade.Window):
# ...
def update(self, delta_time):
if self.player_x < self.enemy_x:
self.enemy_x -= PLAYER_SPEED
elif self.player_x > self.enemy_x:
self.enemy_x += PLAYER_SPEED
if self.is_collision(self.player_x, self.player_y,
self.enemy_x, self.enemy_y,
PLAYER_RADIUS, ENEMY_RADIUS):
print("Game Over!")
def is_collision(self, x1, y1, x2, y2, radius1, radius2):
distance_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
radius_sum_squared = (radius1 + radius2) ** 2
return distance_squared <= radius_sum_squared Voici le résultat :
Ajout de balles ennemies
Pour créer un ennemi qui tire des balles, créez un fichier Balle et une liste pour garder une trace des balles actives. L’ennemi créera périodiquement une nouvelle balle et mettra à jour sa position. Créez un nouveau fichier nommé bullets.py et ajoutez le code avec les mises à jour ci-dessous :
# Add to GameWindow class
class Bullet:
def __init__(self, x, y, radius, speed):
self.x = x
self.y = y
self.radius = radius
self.speed = speed
def update(self):
self.y -= self.speed
class GameWindow(arcade.Window):
# ...
def __init__(self, width, height):
# ...
# Enemy attributes
self.bullets = []
self.bullet_radius = 5
self.bullet_speed = 3
self.bullet_cooldown = 60 # Number of frames between bullet spawns
self.bullet_timer = 0
def on_draw(self):
# ...
for bullet in self.bullets:
arcade.draw_circle_filled(bullet.x, bullet.y,
self.bullet_radius, arcade.color.BLACK)
def update(self, delta_time):
# ...
self.bullet_timer += 1
if 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
for bullet in self.bullets:
bullet.update()
if self.is_collision(self.player_x, self.player_y, self.enemy_x,
self.enemy_y, PLAYER_RADIUS, ENEMY_RADIUS):
print("Game Over!")
def is_collision(self, x1, y1, x2, y2, radius1, radius2):
distance_squared = (x1 - x2) ** 2 + (y1 - y2) ** 2
radius_sum_squared = (radius1 + radius2) ** 2
return distance_squared <= radius_sum_squared Voici le résultat :
Ajout de points de vie pour les ennemis
Dans de nombreux jeux, les ennemis peuvent posséder des points de vie (PV), ce qui leur permet d’encaisser plusieurs coups avant d’être vaincus. L’ajout de points de vie aux ennemis permet d’introduire des éléments stratégiques dans le jeu et de donner un sentiment de progression et de défi. Créez un nouveau fichier nommé heath-point.py et ajoutez le code avec les mises à jour ci-dessous :
# Window dimensions
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Player attributes
PLAYER_RADIUS = 25
PLAYER_SPEED = 5
# Enemy attributes
ENEMY_RADIUS = 20
ENEMY_HEALTH = 100
class GameWindow(arcade.Window):
def __init__(self, width, height):
super().__init__(width, height)
arcade.set_background_color(arcade.color.WHITE)
self.player_x = width // 2
self.player_y = height // 2
self.enemy_x = width // 2
self.enemy_y = height - PLAYER_RADIUS
self.enemy_health = ENEMY_HEALTH
print(self.enemy_health)
def on_draw(self):
arcade.start_render()
arcade.draw_circle_filled(self.player_x,
self.player_y,
PLAYER_RADIUS,
arcade.color.BLUE)
if self.enemy_health > 0:
arcade.draw_circle_filled(self.enemy_x,
self.enemy_y,
ENEMY_RADIUS,
arcade.color.RED)
def update(self, delta_time):
if self.is_collision(self.player_x, self.player_y,
self.enemy_x, self.enemy_y,
PLAYER_RADIUS, ENEMY_RADIUS):
self.enemy_health -= 10
print(self.enemy_health)
Le ENEMY_HEALTH La constante ENEMY_HEALTH 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, il est possible de déduire quelques 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 indique la santé actuelle de l’ennemi.
En incorporant des points de vie 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 l’évolution de la santé restante de l’ennemi.
En outre, vous pouvez développer le code en ajoutant d’autres éléments logiques et visuels, tels que l’affichage de barres de santé ou la mise en place de conditions de défaite lorsque la santé de l’ennemi atteint zéro.
Meilleures pratiques pour la création d’ennemis
Lorsque vous concevez des ennemis pour votre jeu, il est important de prendre en compte plusieurs bonnes pratiques afin de vous assurer qu’ils contribuent à une expérience de jeu stimulante et agréable. Voici quelques conseils à suivre lors de la création d’ennemis :
Des attributs variés
Créez des ennemis aux attributs variés tels que la vitesse, la taille, la santé et la puissance d’attaque. Les différents types d’ennemis doivent présenter différents niveaux de difficulté, ce qui oblige les joueurs à adapter leurs stratégies en conséquence. En introduisant un mélange d’attributs d’ennemis, vous pouvez garder le gameplay frais et engageant.
Comportements uniques
Donnez à chaque type d’ennemi un comportement unique. 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 pour rendre le comportement des ennemis plus intelligent et imprévisible, afin d’ajouter un niveau de difficulté supplémentaire pour les joueurs.
Points de vie (PV)
Des points de vie ont été ajoutés aux ennemis afin d’introduire un sentiment de progression et de durabilité. Les ennemis peuvent ainsi encaisser plusieurs coups avant d’être vaincus. En attribuant des quantités variables de points de vie aux différents types d’ennemis, vous pouvez créer une hiérarchie de difficulté et encourager les joueurs à élaborer des stratégies et à donner la priorité à leurs cibles.
Rendre les jeux plus amusants grâce aux ennemis
L’ajout d’ennemis à vos jeux peut considérablement améliorer l’expérience de jeu. Ils présentent des défis et motivent les joueurs à améliorer leurs compétences. Les ennemis peuvent prendre différentes formes, de simples obstacles à des adversaires complexes pilotés par l’IA. En intégrant des ennemis de manière efficace, vous pouvez rendre vos jeux plus attrayants et plus agréables pour les joueurs.