Comment créer un jeu 2D avec Python et une bibliothèque d'arcade

Bonjour, Habr! Je vous présente la traduction de l'article Comment créer un jeu 2D avec Python et la bibliothèque Arcade de Paul Vincent Craven

Comment créer un jeu 2D avec Python et une bibliothèque d'arcade

Découvrez comment démarrer avec Arcade, une bibliothèque Python facile à utiliser pour créer des jeux vidéo 2D.

Phython est un excellent langage pour les personnes qui apprennent la programmation, et est idéal pour ceux qui veulent "faire quelque chose" et ne pas passer une tonne de temps sur du code passe-partout. Arcade est une bibliothèque Python pour créer des jeux vidéo 2D, qui est facile à utiliser et très efficace lorsque vous gagnez en expérience. Dans cet article, je vais vous expliquer comment commencer à utiliser Python et Arcade pour programmer des jeux vidéo.

J'ai commencé le développement sur Arcade après avoir enseigné aux étudiants à l'aide de la bibliothèque PyGame . J'ai enseigné personnellement en utilisant PyGame pendant près de 10 ans, et j'ai développé ProgramArcadeGames .com pour enseigner en ligne. PyGame est génial, mais au final, j'avais l'impression de perdre du temps à couvrir des erreurs qui n'ont jamais été corrigées .
J'étais inquiet d'enseigner des choses comme la boucle d' événements , qui n'était plus la façon dont nous codions. J'avais une section entière dans laquelle j'ai expliqué pourquoi les coordonnées Y étaient inversées. Étant donné que PyGame était rarement mis à jour et qu'il est basé sur l'ancienne bibliothèque SDL 1, et non sur quelque chose comme une bibliothèque plus moderne, comme OpenGL , je n'avais pas beaucoup d'espoir pour l'avenir.

Je voulais créer une bibliothèque plus facile à utiliser, plus puissante et utiliser certaines des nouvelles fonctionnalités de Python 3, telles que les décorateurs et les astuces de type. Ceci est une arcade. Et voici comment commencer.

L'installation

Arcade, comme de nombreux autres packages, est disponible via PyPi , ce qui signifie que vous pouvez installer Arcade à l'aide de la commande pip (ou commande pipenv). Si vous avez déjà installé Python, vous pouvez probablement simplement ouvrir une invite de commande sous Windows et taper:

pip install arcade 

Ou sur MacOS et Linux:

 pip3 install arcade 

Pour des instructions d'installation plus détaillées, vous pouvez vous référer à la documentation d'installation d'Arcade .

Dessin simple

Vous pouvez ouvrir la fenêtre et créer des dessins simples avec seulement quelques lignes de code. Créons un exemple qui dessine un smiley, comme indiqué dans l'image ci-dessous:

L'algorithme ci-dessous montre comment vous pouvez utiliser les commandes de dessin Arcade pour ce faire. Notez que vous n'avez pas besoin de savoir comment utiliser les classes ou même définir des fonctions. La programmation avec un retour visuel rapide est idéale pour ceux qui veulent commencer à apprendre la programmation.

 import arcade # Set constants for the screen size SCREEN_WIDTH = 600 SCREEN_HEIGHT = 600 # Open the window. Set the window title and dimensions (width and height) arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Drawing Example") # Set the background color to white. # For a list of named colors see: # http://arcade.academy/arcade.color.html # Colors can also be specified in (red, green, blue) format and # (red, green, blue, alpha) format. arcade.set_background_color( arcade.color.WHITE) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Draw the face x = 300 y = 300 radius = 200 arcade.draw_circle_filled( x, y, radius, arcade.color.YELLOW) # Draw the right eye x = 370 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the left eye x = 230 y = 350 radius = 20 arcade.draw_circle_filled( x, y, radius, arcade.color.BLACK) # Draw the smile x = 300 y = 280 width = 120 height = 100 start_angle = 190 end_angle = 350 arcade.draw_arc_outline( x, y, width, height, arcade.color.BLACK, start_angle, end_angle, 10) # Finish drawing and display the result arcade.finish_render() # Keep the window open until the user hits the 'close' button arcade.run() 

Utilisation des fonctions

Bien sûr, écrire du code dans un contexte global n'est pas une bonne forme. Heureusement, l'amélioration de votre programme avec des fonctionnalités est facile. Ici, nous pouvons voir un exemple de dessin du pin dans un endroit spécifique (x, y) en utilisant la fonction:

 def draw_pine_tree(x, y) : """ This function draws a pine tree at the specified location. """ # Draw the triangle on top of the trunk. # We need three x, y points for the triangle. arcade.draw_triangle_filled( x + 40, y, # Point 1 x, y - 100, # Point 2 x + 80, y - 100, # Point 3 arcade.color.DARK_GREEN) # Draw the trunk arcade.draw_lrtb_rectangle_filled( x + 30, x + 50, y - 100, y - 140 , arcade.color.DARK_BROWN) 

Pour un exemple complet, voir dessin avec fonctions .

Un programmeur plus expérimenté saura que les programmes graphiques modernes téléchargent d'abord des informations graphiques sur la carte vidéo, puis demandent à la carte vidéo de les dessiner plus tard sous forme de package. Arcade prend également cela en charge. Le dessin de 10 000 rectangles individuellement prend environ 0,800 seconde. Les dessiner sous forme de package prend moins de 0,001 seconde.

classe de fenêtre

Les programmes plus volumineux héritent généralement de la classe Window ou utilisent des décorateurs . Cela permet au programmeur d'écrire du code pour gérer le dessin, la mise à jour et le traitement des entrées utilisateur. Le modèle de lancement du programme Windows est illustré ci-dessous.

 import arcade SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 class MyGame( arcade.Window): """ Main application class. """ def __init__(self, width, height) : super( ) .__init__(width, height) arcade.set_background_color( arcade.color.AMAZON) def setup( self) : # Set up your game here pass def on_draw(self) : """ Render the screen. """ arcade.start_render() # Your drawing code goes here def update(self, delta_time) : """ All the logic to move, and the game logic goes here. """ pass def main( ) : game = MyGame( SCREEN_WIDTH, SCREEN_HEIGHT) game.setup( ) arcade.run() if __name__ = = "__main__": main() 

La classe Window a plusieurs méthodes que vos programmes peuvent remplacer pour fournir des fonctionnalités de programme. Voici quelques-uns des plus couramment utilisés:

on_draw: tout le code pour dessiner un écran va ici.
Mise à jour: tout le code pour déplacer vos objets et exécuter la logique du jeu est ici. Cela s'appelle environ 60 fois par seconde.
on_key_press: gère les événements quand une touche est enfoncée, par exemple, donne la vitesse au joueur.
on_key_release: traite lorsque la touche est relâchée, ici vous pouvez arrêter le mouvement du joueur.
on_mouse_motion: appelé chaque fois que la souris se déplace.
on_mouse_press: appelé lorsque le bouton de la souris est cliqué.
set_viewport: cette fonction est utilisée dans les jeux à défilement lorsque votre monde est beaucoup plus grand que ce que vous pouvez voir sur un seul écran. L'appel set_viewport permet au programmeur de définir quelle partie de ce monde est actuellement visible.

Sprites

Les sprites sont un moyen simple de créer un objet raster en deux dimensions dans Arcade. Arcade propose des méthodes qui facilitent le dessin, le déplacement et l'animation des sprites. Vous pouvez également facilement utiliser des sprites pour détecter les collisions entre les objets.

Création de sprite

La création d'une instance de la classe Sprite Arcade à partir de graphiques est facile. Le programmeur n'a besoin que du nom du fichier image pour que l'image-objet soit basée et, éventuellement, d'un nombre, pour augmenter ou diminuer l'image. Par exemple:

 SPRITE_SCALING_COIN = 0,2 coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN) 

Ce code créera un sprite en utilisant l'image stockée dans coin_01.png. L'image sera réduite à 20% de sa hauteur et de sa largeur d'origine.

Listes de sprites

Les sprites sont généralement organisés en listes. Ces listes facilitent la gestion des sprites. Les sprites de la liste utiliseront OpenGL pour dessiner des sprites par lots en tant que groupe. Le code ci-dessous met en place un jeu avec un joueur et un tas de pièces que le joueur recueille. Nous utilisons deux listes, une pour le joueur et une pour les pièces.

 def setup(self): """ Set up the game and initialize the variables. """ # Create the sprite lists self.player_list = arcade.SpriteList() self.coin_list = arcade.SpriteList() # Score self.score = 0 # Set up the player # Character image from kenney.nl self. player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER) self.player_sprite.center_x = 50 # Starting position self.player_sprite.center_y = 50 self.player_list.append(self.player_sprite) # Create the coins for i in range( COIN_COUNT): # Create the coin instance # Coin image from kenney.nl coin = arcade.Sprite("images/coin_01.png", SPRITE_SCALING_COIN) # Position the coin coin.center_x = random.randrange(SCREEN_WIDTH) coin.center_y = random.randrange(SCREEN_HEIGHT) # Add the coin to the lists self.coin_list.append(coin) 

Nous pouvons facilement dessiner toutes les pièces dans les listes de pièces:

 def on_draw(self): """ Draw everything """ arcade.start_render() self.coin_list.draw() self.player_list.draw() 

Détection de collision Sprite

Détection de collision Sprite
La fonction check_for_collision_with_list nous permet de voir si un sprite rencontre un autre sprite dans la liste. Nous pouvons l'utiliser pour voir toutes les pièces avec lesquelles le sprite du joueur est en contact. En utilisant une simple boucle for, nous pouvons nous débarrasser de la pièce du jeu et augmenter notre score.

 def update(self, delta_time): # Generate a list of all coin sprites that collided with the player. coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list) # Loop through each colliding sprite, remove it, and add to the score. for coin in coins_hit_list: coin.kill() self.score += 1 

Pour un exemple complet, voir collect_coins.py .

Physique du jeu

De nombreux jeux incluent une sorte de physique. Les plus simples sont des programmes descendants qui empêchent le joueur de traverser les murs. Les plates-formes ajoutent plus de complexité à la gravité et aux plateformes mobiles. Certains jeux utilisent un moteur physique 2D à part entière avec masse, friction, ressorts, etc.

Jeux descendants

Pour les jeux top-down simples, le programme d'arcade a besoin d'une liste de murs à travers lesquels le joueur (ou toute autre chose) ne peut pas passer. Je l'appelle généralement wall_list. Ensuite, le moteur physique est créé dans le code d'installation de la classe Window en utilisant:

 self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list) 

Player_sprite reçoit un vecteur de mouvement avec deux attributs: change_x et change_y. Un exemple simple est de déplacer un joueur à l'aide du clavier. Par exemple, cela pourrait être dans un enfant personnalisé de la classe Window:

 MOVEMENT_SPEED = 5 def on_key_press(self, key, modifiers) : """Called whenever a key is pressed. """ if key = = arcade.key.UP: self.player_sprite.change_y = MOVEMENT_SPEED elif key = = arcade.key.DOWN: self.player_sprite.change_y = -MOVEMENT_SPEED elif key = = arcade.key.LEFT: self.player_sprite.change_x = -MOVEMENT_SPEED elif key = = arcade.key.RIGHT: self.player_sprite.change_x = MOVEMENT_SPEED def on_key_release(self, key, modifiers) : """Called when the user releases a key. """ if key = = arcade.key.UP or key = = arcade.key.DOWN: self.player_sprite.change_y = 0 elif key = = arcade.key.LEFT or key = = arcade.key.RIGHT: selfplayer_sprite.change_x = 0 

Bien que ce code règle la vitesse du lecteur, il ne déplace pas le lecteur. Dans la méthode de mise à jour de la classe Window, lors de l'appel de Physics_engine.update (), le joueur se déplacera, mais pas à travers les murs.

 def update(self, delta_time): """ Movement and game logic """ self.physics_engine.update() 

Pour un exemple complet, voir sprite_move_walls.py .

Plateformes

Passer à un jeu de plateforme avec une vue latérale est assez simple. Le programmeur a juste besoin de basculer le moteur physique vers PhysicsEnginePlatformer et d'ajouter la constante gravitationnelle.

 self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant= GRAVITY) 

Vous pouvez utiliser un programme comme Tiled pour poser les tuiles / blocs qui composent votre niveau.

Pour un exemple, voir sprite_tiled_map.py .

Pour une physique 2D complète, vous pouvez intégrer la bibliothèque PyMunk.

Apprenez d'un exemple

Un des meilleurs moyens d'apprendre est un exemple. La bibliothèque Arcade possède une longue liste d' exemples de programmes que les gens peuvent utiliser pour créer des jeux. Chacun de ces exemples montre le concept d'un jeu que les élèves ont demandé dans mes cours ou sur Internet au fil des ans.

L'exécution de l'une de ces démos est facile après l'installation d'Arcade. Chacun des exemples a un commentaire au début du programme avec une commande que vous pouvez entrer sur la ligne de commande pour exécuter l'exemple, par exemple:

 python -m arcade.examples.sprite_moving_platforms 

Informations brèves

Arcade vous permet de commencer à programmer des graphiques et des jeux avec un code facile à comprendre. De nombreux nouveaux programmeurs ont créé d'excellents jeux peu de temps après le début. Essayez-le!