Bonjour à tous!
Nous continuons à partager avec vous des choses intéressantes trouvées sur le petit python. Aujourd'hui, nous avons décidé de nous occuper des jeux 2D. Bien sûr, c'est un peu plus simple que ce que nous avons dans notre cours de
développeur Python , mais ce n'est certainement pas moins intéressant.
TRANSFERTArticle original - opensource.com/article/18/4/easy-2d-game-creation-python-and-arcade
Publié par Paul Vincent CravenAllons-y.
Python est un langage exceptionnel pour les débutants pour apprendre la programmation. Il est également idéal pour ceux qui veulent «simplement prendre et faire» plutôt que de passer une tonne de temps sur le code passe-partout.
Arcade est une bibliothèque Python pour créer des jeux 2D, avec un seuil d'entrée bas, mais très fonctionnel entre des mains expérimentées. Dans cet article, je vais vous expliquer comment commencer à utiliser Python et Arcade pour programmer des jeux.
J'ai commencé à développer sur Arcade après avoir enseigné les bases de la bibliothèque
PyGame aux étudiants. J'enseigne PyGames en personne depuis près de 10 ans et j'ai également développé
ProgramArcadeGames.com pour l'apprentissage en ligne. PyGames est génial, mais à un moment donné, j'ai réalisé que j'étais fatigué de perdre du temps à justifier des bugs
qui ne seraient jamais corrigés.
J'étais inquiet d'enseigner des choses comme la
boucle d'événements , qui n'étaient presque jamais utilisées. Et il y avait
toute une section dans laquelle j'ai expliqué pourquoi les coordonnées y tournaient dans la direction opposée. PyGames était rarement mis à jour et était basé sur l'ancienne
bibliothèque SDL 1 , plutôt que sur quelque chose de plus moderne comme
OpenGL . Je ne comptais pas sur un brillant avenir.
Dans mes rêves, il y avait une bibliothèque simple et puissante qui utiliserait de nouvelles fonctionnalités de Python 3, par exemple, des décorateurs et des indications de type. Elle s'est avérée être Arcade. Voyons comment commencer à l'utiliser.
L'installation
Arcade, comme de nombreux autres packages, est disponible sur
PyPi , ce qui signifie que vous pouvez installer Arcade à l'aide de la commande pip (ou
pipenv ). Si Python est déjà installé, vous pouvez très probablement simplement ouvrir l'invite de commande Windows et écrire:
pip install arcade
Et sous Linux et MacOS:
pip3 install arcade
Pour des instructions d'installation plus détaillées, lisez la
documentation d' installation d'Arcade.
Dessin simple
Vous pouvez ouvrir la fenêtre et dessiner un dessin simple avec seulement quelques lignes de code. À titre d'exemple, dessinons un smiley, comme dans l'image ci-dessous:
Le script ci-dessous montre comment procéder à l'aide des
commandes de dessin Arcade. Notez que vous n'avez pas besoin de savoir comment utiliser des classes ou définir des fonctions. La programmation avec un retour visuel rapide est un bon début pour ceux qui ne font qu'apprendre.
import arcade
Utilisation des fonctions
Bien sûr, écrire du code dans un contexte global n'est pas le meilleur moyen. Heureusement, l'utilisation de fonctions vous aidera à améliorer votre code. Voici un exemple de la façon de dessiner un arbre dans les coordonnées données (x, y) en utilisant la fonction:
def draw_pine_tree(x, y): """ """
Pour un exemple complet, voir le
dessin avec fonctions .
Les programmeurs plus expérimentés savent que les programmes modernes téléchargent d'abord des informations graphiques sur la carte vidéo, puis lui demandent de dessiner un fichier de commandes.
L'arcade est prise en charge . Le dessin individuel de 10 000 rectangles prend 0,8 seconde. Le dessin de la même quantité avec un fichier de commandes prendra moins de 0,001 seconde.
Classe de fenêtre
Les grands programmes sont généralement basés sur la classe
Window ou utilisent des
décorateurs . Cela permet au programmeur d'écrire du code qui contrôle le rendu, la mise à jour et le traitement des entrées utilisateur. Vous trouverez ci-dessous un modèle de programme basé sur Windows.
import arcade SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 class MyGame(arcade.Window): """ . """ def __init__(self, width, height): super().__init__(width, height) arcade.set_background_color(arcade.color.AMAZON) def setup(self):
La classe Window a plusieurs méthodes que vos programmes peuvent remplacer pour fournir des fonctionnalités. Voici une liste de celles qui sont utilisées le plus souvent:
- on_draw: Tout le code pour rendre l'écran est ici.
- mise à jour: Tout le code pour déplacer des objets et élaborer la logique du jeu est ici. Appelé environ 60 fois par seconde.
- on_key_press: gère les événements lorsqu'un bouton est enfoncé, par exemple, le mouvement d'un personnage.
- on_key_release: gère les événements lorsqu'un bouton est relâché, comme l'arrêt d'un personnage.
- 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 scrollers lorsque le monde est beaucoup plus grand que ce qui est visible sur un écran. L'appel à set_viewport permet au programmeur de spécifier la partie de l'écran qui sera visible.
Sprites
Les sprites sont un moyen facile de créer des fonctionnalités bitmap 2D dans Arcade. Il a des méthodes qui facilitent le dessin, le déplacement et l'animation des sprites. Vous pouvez également utiliser des sprites pour suivre les collisions entre les objets.
Création de sprite
La création d'une instance Arcite
Sprite est très simple. Le programmeur n'a besoin que du nom du fichier image sur lequel le sprite sera basé et, éventuellement, du nombre de fois pour agrandir ou réduire l'image. Par exemple:
SPRITE_SCALING_COIN = 0.2 coin = arcade.Sprite("coin_01.png", SPRITE_SCALING_COIN)
Ce code crée un sprite en utilisant l'image coin_01.png. L'image sera réduite à 20% de l'original.
Liste de sprites
Les sprites sont généralement organisés en listes. Ils contribuent à simplifier leur gestion. Les sprites de la liste utiliseront OpenGl pour le rendu par lots de groupe. Le code ci-dessous configure le jeu, où il y a un joueur et beaucoup de pièces que le joueur doit collecter. Nous utilisons deux listes - une pour le joueur et une pour les pièces.
def setup(self): """ . """
Nous pouvons facilement dessiner toutes les pièces de la liste des pièces:
def on_draw(self): """ """ arcade.start_render() self.coin_list.draw() self.player_list.draw()
Suivre les collisions de sprites
La fonction check_for_collision_with_list vous permet de voir si un sprite rencontre un autre sprite de la liste. Nous l'utilisons pour voir toutes les pièces que le sprite du joueur recoupe. En utilisant un simple cycle, vous pouvez vous débarrasser de la pièce dans le jeu et augmenter le score.
def update(self, delta_time):
Un exemple complet peut être trouvé dans
collect_coins.py .
Physique du jeu
De nombreux jeux ont la physique sous une forme ou une autre. Le plus simple, par exemple, est que les jeux descendants ne permettent pas au joueur de passer à travers les murs. Les plates-formes ajoutent de la complexité à la gravité et aux plates-formes mobiles. Certains jeux utilisent des moteurs 2D physiques à part entière avec des masses, des frottements, des ressorts, etc.
Jeux descendants
Pour les jeux simples avec une vue de dessus, le programme Arcade a besoin d'une liste de murs (ou quelque chose de similaire) à travers lesquels le joueur ne pourra pas passer. Je l'appelle généralement wall_list. Ensuite, un moteur physique est créé dans le code d'installation de la classe Window:
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 cas d'utilisation simple consiste à déplacer un joueur à l'aide du clavier.
MOVEMENT_SPEED = 5 def on_key_press(self, key, modifiers): """ """ 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): """, """ 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: self.player_sprite.change_x = 0
Malgré le fait que ce code règle la vitesse du joueur, il ne la déplace pas. La méthode de mise à jour de la classe Window appelle physics_engine.update (), ce qui fera bouger le joueur, mais pas à travers les murs.
def update(self, delta_time): """ """ self.physics_engine.update()
L'exemple complet se trouve dans
sprite_move_walls.py .
Plateformes
Passer à un jeu de plateforme avec une vue latérale est assez simple. Le programmeur doit commuter le moteur physique sur PhysicsEnginePlatformer et ajouter la constante gravitationnelle.
self.physics_engine = arcade.PhysicsEnginePlatformer(self.player_sprite, self.wall_list, gravity_constant=GRAVITY)
Pour ajouter les tuiles et les blocs dont le niveau sera composé, vous pouvez utiliser un programme comme
Tiled .
Un exemple est disponible sur
sprite_tiled_map.py.Apprenez d'un exemple
L'apprentissage par l'exemple est l'une des meilleures méthodes. La bibliothèque Arcade possède une grande liste d'
exemples de programmes sur lesquels vous pouvez vous concentrer lors de la création d'un jeu. Ces exemples révèlent les concepts de jeux que mes étudiants en ligne et hors ligne demandent depuis plusieurs années.
Exécuter des démos avec Arcade installé n'est pas du tout difficile. Au début du programme pour chaque exemple, il y a un commentaire avec la commande que vous devez entrer sur la ligne de commande pour exécuter cet exemple. Par exemple:
python -m arcade.examples.sprite_moving_platforms
LA FIN
Comme toujours, nous attendons vos commentaires et questions que vous pouvez laisser ici ou aller à
Stas lors d'une
journée portes ouvertes .