Animer des objets de jeu avec Arcade Library

L'animation joue un rôle essentiel dans l'amélioration de l'attrait visuel et de l'engagement des jeux vidéo. La bibliothèque Arcade est un framework Python pour créer des jeux 2D. Il offre un moyen simple et efficace d'intégrer des animations dans vos projets de jeux.

Vous pouvez utiliser la bibliothèque Arcade pour créer des animations de mouvement de base et des animations synchronisées avec des événements de jeu.

Créer un jeu simple

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

pip installer arcade

Après cela, créez un fichier Python nommé jeu-simple.py et commencez par mettre en place un jeu où le joueur peut se déplacer à gauche et à droite.

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

À l'aide de la bibliothèque Arcade, vous pouvez créer une fenêtre, configurer l'environnement de jeu et gérer les entrées des joueurs. Voici un extrait de code pour commencer :

importer arcade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mon jeu")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
définitivementon_draw(soi):
 arcade.start_render()
 col = arcade.couleur. BLEU
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col)
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= 10
elif clé == arcade.clé. DROITE:
 self.player_x += 10
définitivementprincipal():
 jeu = MonJeu()
 arcade.run()
si __nom__ == "__principal__":
 principal()

Ajouter une animation de mouvement de base

Maintenant, poussez votre jeu un peu plus loin et ajoutez une animation de mouvement de base à l'objet joueur. Pour animer le joueur en mouvement, créez 3 cercles différents et parcourez-les de manière séquentielle lorsque le joueur commence à bouger. Voici l'extrait de code mis à jour pour le mouvement-animation.py déposer:

classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mon jeu")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
définitivementon_draw(soi):
 arcade.start_render()
 col1 = arcade.couleur. BLEU
 col2 = arcade.couleur. VERT
 col3 = arcade.couleur. ROUGE
si self.frame_counter < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col1 )
elif self.frame_counter < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col2 )
autre:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
elif clé == arcade.clé. DROITE:
 self.player_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

Voici un exemple de trame de sortie :

Contrôle de la vitesse et de la direction de l'animation

Pour contrôler la vitesse d'animation, vous pouvez introduire un système de fréquence d'images. Vous pouvez également modifier l'ordre des images en fonction de la direction de déplacement du joueur. Lorsque le joueur se déplace de gauche à droite, les images s'affichent dans l'ordre inverse.

Voici l'extrait de code modifié pour le frame-rate.py déposer:

classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mon jeu")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arcade.couleur. BLEU
 col2 = arcade.couleur. VERT
 col3 = arcade.couleur. ROUGE
 self.frames = [col1, col2, col3]
 self.frame_rate = 10
définitivementon_draw(soi):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
si self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (self.frames) - 1 - frame_index
 index = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, indice)
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= 10
 self.frame_counter += 1
elif clé == arcade.clé. DROITE:
 self.player_x += 10
 self.frame_counter += 1

Utiliser l'opérateur module % avec len (self.frames) pour s'assurer que le frame_index reste toujours dans la plage des images disponibles. Cela empêche le Erreur d'index de se produire lorsque l'animation parcourt les images.

Ajuste le frame_rate pour contrôler la vitesse d'animation et profiter du mouvement animé de vos objets de jeu.

Inclure des fonctionnalités supplémentaires

La bibliothèque Arcade fournit diverses fonctionnalités pour améliorer vos animations.

Effets de particules

Vous pouvez créer des effets de particules, comme des explosions ou de la fumée, pour ajouter du réalisme à votre jeu. Créer un fichier nommé particule.py et ajoutez le code ci-dessous pour une implémentation simple du système de particules en utilisant Python et la bibliothèque d'arcade :

importer arcade
importer aléatoire
# Dimensions de l'écran
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Couleurs
BLANC = (255, 255, 255)
# Classe de particules
classeParticule:
définitivement__init__(soi, x, y, dx, dy, rayon, couleur, durée de vie):
 soi.x = x
 soi.y = y
 soi.dx = dx
 self.dy = dy
 self.radius = rayon
 self.color = couleur
 self.lifespan = durée de vie
définitivementmise à jour(soi):
 soi.x += soi.dx
 soi.y += soi.dy
 auto.durée de vie -= 1
définitivementdessiner(soi):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# Classe de jeu
classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur, "Exemple de particules")
 self.particules = []
définitivementinstallation(soi):
# Créer des particules
pour _ dans gamme(100):
 x = random.randrange (SCREEN_WIDTH)
 y = random.randrange (ÉCRAN_HAUTEUR)
 dx = aléatoire.uniforme(-1, 1)
 dy = aléatoire.uniforme(-1, 1)
 rayon = random.uniform(2, 5)
 couleur = arcade.couleur. BLANC
 durée de vie = random.randint(60, 120)
 particule = Particule (x, y, dx, dy, rayon, couleur, durée de vie)
 self.particles.append (particule)
définitivementon_draw(soi):
 arcade.start_render()
pour particule dans self.particules :
 particule.dessiner()
définitivementmise à jour(soi, delta_time):
pour particule dans self.particules :
 particule.update()
si particule.lifespan <= 0:
 self.particles.remove (particule)
définitivementprincipal():
 jeu = MonJeu (SCREEN_WIDTH, SCREEN_HEIGHT)
 jeu.setup()
 arcade.run()
si __nom__ == "__principal__":
 principal()

Vous devriez voir une animation qui implique de nombreuses particules en mouvement :

Animations interactives

Implémentez des animations interactives qui répondent aux entrées de l'utilisateur ou aux événements du jeu. Par exemple, lorsque le joueur interagit avec un objet, il peut s'animer, changer de couleur ou se transformer d'une manière ou d'une autre. Ces animations interactives fournissent des commentaires et améliorent l'engagement du joueur avec le jeu. Voici le code pour le animation-interactive.py déposer:

importer arcade
# Dimensions de l'écran
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# Couleurs
BLANC = (255, 255, 255)
ROUGE = (255, 0, 0)
classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur, "Animations interactives")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = ROUGE
 self.animation_radius = 60
 self.animation_color = BLANC
 self.animation_active = FAUX
définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.player_radius,
 self.player_color)
si self.animation_active :
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.animation_radius,
 self.animation_color)
définitivementon_mouse_press(soi, x, y, bouton, modificateurs):
si (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius et
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = Vrai
définitivementmise à jour(soi, delta_time):
si self.animation_active :
 self.animation_radius += 1
si self.animation_radius > 100:
 self.animation_active = FAUX
 self.animation_radius = 0
définitivementprincipal():
 jeu = MonJeu (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
si __nom__ == "__principal__":
 principal()

Remplacez les méthodes nécessaires, telles que on_draw, on_mouse_press, et mise à jour, pour gérer le dessin du lecteur et de l'animation, la gestion des clics de souris et la mise à jour de l'animation.

Pour dessiner le joueur, utilisez le arcade.draw_circle_filled fonction, qui prend la (x, y) coordonnées du centre, du rayon et de la couleur comme arguments. La fonction draw_circle_filled est l'une des Les outils d'Arcade que vous pouvez utiliser pour dessiner des éléments de jeu. Dans ce cas, vous pouvez dessiner un cercle croissant en faisant varier le rayon dans le temps.

Le on_mouse_press La méthode s'exécute lorsque l'utilisateur clique sur la souris. Il vérifie si les coordonnées de la souris sont dans les limites de l'objet joueur et active l'animation si elles le sont.

Meilleures pratiques pour l'ajout d'animation

Lorsque vous ajoutez une animation à vos jeux, tenez compte des bonnes pratiques suivantes :

Limiter le nombre d'animations

Avoir de nombreuses animations avec de nombreuses images peut avoir un impact sur les performances. Envisagez de minimiser le nombre d'animations ou d'images nécessaires, en particulier pour les éléments non critiques du jeu. La simplification des animations peut aider à maintenir une fréquence d'images constante et à optimiser l'utilisation des ressources.

Rendu par lots d'objets similaires

Regroupez des objets similaires partageant les mêmes images d'animation et textures et affichez-les sous forme de lot. Le traitement par lots réduit le nombre d'appels de dessin, ce qui améliore les performances. Cette technique est particulièrement utile lors de l'animation d'objets utilisant la même feuille de sprites ou ayant des séquences d'animation similaires.

Utiliser l'interpolation pour une animation fluide

Appliquez des techniques d'interpolation, telles que l'interpolation linéaire (lerping), pour obtenir des transitions d'animation fluides. L'interpolation calcule les valeurs intermédiaires entre les images clés d'animation pour créer des mouvements fluides. Cette approche empêche les sauts soudains ou les mouvements saccadés entre les images, ce qui se traduit par des animations plus attrayantes visuellement.

Considérez la vitesse et le timing de l'animation

Expérimentez avec différentes vitesses d'animation et différents timings pour trouver le bon équilibre pour votre jeu. Ajustez la durée de l'image ou utilisez différentes séquences d'animation pour créer des variations de vitesse, d'accélération ou de décélération. Ces ajustements peuvent ajouter de la profondeur et du caractère aux animations de votre jeu.

Tester et optimiser

Testez régulièrement vos animations sur différents appareils et surveillez les performances. Recherchez les goulots d'étranglement ou les ralentissements potentiels et optimisez en conséquence. Ce processus permet de garantir des expériences d'animation fluides et cohérentes sur une large gamme d'appareils.

Rendre les jeux plus attrayants avec l'animation

L'ajout d'animations à vos jeux peut considérablement améliorer l'engagement et l'immersion des joueurs. Les animations fournissent un retour visuel aux actions des joueurs, rendant le gameplay plus intuitif et agréable. Ils donnent vie aux mondes du jeu, créant un sentiment de réalisme et d'excitation.

Qu'il s'agisse d'un personnage qui court, d'un objet qui explose ou d'un simple effet de transition, les animations contribuent à une expérience de jeu plus dynamique et captivante.