My adult son (35 years old) is a network administrator for the company he works for. He works with a huge amount of servers – handling all the network needs of his company and their employees. I started teaching him about computers when he was 10 years old. He (with a very little bit of help from me) built his first computer from a motherboard, hard drive, two floppy drives and a video card. At that point, I was selling custom-built computers and he did all the basic building with the exception of the CPU and memory boards. He is also an avid gamer. Back when he was 10, I was the mean old dad who wouldn’t let him have a game console (I think it was a Nintendo) because most of the games he wanted to play, he could play on his computer. For a couple of years, it really didn’t sink into his brain, but he was partially placated as long as I would provide more and more complicated games as he grew in his skills. I, on the other hand, never really was able to play the games that he enjoyed. The game controller(s) confused me, and I never could figure out which darn button to press when. (Thanks to https://www.bestproducts.com/tech/gadgets/g821/best-pc-game-controllers/ for the image above.)
Mon fils adulte (35 ans) est administrateur de réseau pour la société pour laquelle il travaille. Il travaille avec un grand nombre de serveurs et répond à tous les besoins de son entreprise et des employés en matière de réseau. J'ai commencé à lui enseigner l'informatique lorsqu'il avait 10 ans. Il a (avec un tout petit peu d'aide de ma part) construit son premier ordinateur à partir d'une carte mère, d'un disque dur, de deux lecteurs de disquettes et d'une carte vidéo. À cette époque, je vendais des ordinateurs sur mesure et c'est lui qui s'est chargé de la construction de base, à l'exception des cartes CPU et mémoire. Il est également un joueur passionné. Quand il avait 10 ans, j'étais le vieux père méchant qui ne voulait pas le laisser avoir une console de jeu (je crois que c'était une Nintendo) parce que, pour la plupart des jeux auxquels il voulait jouer, il pouvait le faire sur son ordinateur. Pendant quelques années, il ne s'est pas vraiment rendu compte de la situation, mais il était partiellement apaisé tant que je lui fournissais des jeux de plus en plus compliqués au fur et à mesure qu'il devenait plus habile. De mon côté, je n'ai jamais vraiment pu jouer aux jeux qu'il appréciait. La ou les manettes de jeu me déroutaient et je n'arrivais jamais à savoir sur quel bouton il fallait appuyer. (Merci à https://www.bestproducts.com/tech/gadgets/g821/best-pc-game-controllers/ pour l'image ci-dessus).
I admit it. When it comes to game controllers, I’m a klutz. Even those games that can be played on the computer keyboard, I’m horrible at. Up until a couple of years ago, if you gave me a guitar, I could pick and chord with almost anyone who wasn’t a professional. But hand me a game controller, and I’d put it back on the table as fast as I could. I’ve wanted to do an article on creating games in Python for a long time, and, a few months ago (FCM168 part 116 April 2021), I showed a simple text based game when I talked about Pattern Matching coming up in Python 3.10. Text based games, I can pretty much play. I also remember talking about PyGame many, many years ago. FINALLY I get to start talking about (as my son would say) REAL games, with graphics and everything. I’m talking about the Arcade library for Python. Before we get into actually using and installing Arcade, we need to discuss virtual environments.
Je l'avoue. Quand il s'agit de manettes de jeux, je suis un empoté. Je suis nul, même aux jeux qui peuvent être joués sur un clavier d'ordinateur. Jusqu'à il y a quelques années, si vous me donniez une guitare, je pouvais jouer et faire des accords avec presque n'importe quel non-professionnel. Mais si vous me donnez une manette de jeu, je la repose sur la table aussi vite que je peux.
Cela fait longtemps que je voulais faire un article sur la création de jeux en Python et, il y a quelques mois (FCM168 partie 116 avril 2021), j'ai montré un jeu simple basé sur du texte lorsque j'ai parlé de la correspondance de motifs qui arrive dans Python 3.10. Les jeux en mode texte, je peux y jouer. Je me souviens aussi d'avoir parlé de PyGame il y a de nombreuses années. ENFIN, je peux commencer à parler (comme mon fils le dirait) de VRAIS jeux, avec des graphismes et tout le reste. Je parle de la bibliothèque Arcade pour Python.
Avant d'aborder l'utilisation et l'installation d'Arcade, nous devons parler des environnements virtuels.
Virtual Environments We all know that Python uses pip to install libraries (unless you are using Anaconda and then you usually use Conda). However, many times a package you want to try out or develop with will have dependencies that conflict with packages that you already have installed. Often you won’t know that there are problems until something fails. Python, pyenv and Anaconda all provide virtual environments to get around this issue. Basically, when you create a virtual environment, you get a clean version of Python with just the bare minimum packages installed. I’ll show how to set up a virtual environment for pyenv and Python. If you use Anaconda, it’s easy to find the steps with a simple web search. Pyenv If you are using pyenv, it’s very easy to get a virtual environment up and running. Here’s the steps. Create a folder for your virtual environment and cd into it. Eg: $ mkdir Pyenv-Virt1 $ cd Pyenv-Virt1 Decide what version of Python you want to use for the virtual environment. For this project, I’m going to use 3.7.9 . Set the version for this folder. $ pyenv local 3.7.9
Environnements virtuels
Nous savons tous que Python utilise pip pour installer les bibliothèques (à moins que vous n'utilisiez Anaconda, auquel cas vous utilisez généralement Conda). Cependant, il arrive souvent qu'un paquet que vous voulez essayer ou utiliser pour le développement ait des dépendances qui entrent en conflit avec des paquets que vous avez déjà installés. Souvent, vous ne saurez pas qu'il y a des problèmes jusqu'à ce que quelque chose échoue. Python, pyenv et Anaconda fournissent tous des environnements virtuels pour contourner ce problème. En gros, lorsque vous créez un environnement virtuel, vous obtenez une version propre de Python avec juste le strict minimum de paquets installés. Je vais vous montrer comment configurer un environnement virtuel pour pyenv et Python. Si vous utilisez Anaconda, il est facile de trouver les étapes avec une simple recherche sur le Web.
Pyenv
Si vous utilisez pyenv, il est très facile de mettre en place un environnement virtuel et de le faire fonctionner. Voici les étapes à suivre.
Créez un dossier pour votre environnement virtuel et accédez-y. Par exemple :
$ mkdir Pyenv-Virt1
$ cd Pyenv-Virt1
Décidez de la version de Python que vous voulez utiliser pour l'environnement virtuel. Pour ce projet, je vais utiliser la version 3.7.9. Définissez la version pour ce dossier.
$ pyenv local 3.7.9
Create the virtual environment and name it. You can name it pretty much anything you want. I like to preface the name with “venv” so I can easily remember it. $ pyenv virtualenv 3.7.9 venv379 Looking in links: /tmp/tmplwbkpo45 Requirement already satisfied: setuptools in /home/greg/.pyenv/versions/3.7.9/envs/venv379/lib/python3.7/site-packages (47.1.0) Requirement already satisfied: pip in /home/greg/.pyenv/versions/3.7.9/envs/venv379/lib/python3.7/site-packages (20.1.1) greg@earth:~/Desktop/Pyenv-Virt1$ Activate the virtual environment and do a pip list to verify it’s brand new. $ pyenv activate venv379 pyenv-virtualenv: prompt changing will be removed from future release. configure `export PYENV_VIRTUALENV_DISABLE_PROMPT=1' to simulate the behavior. (venv379) greg@earth:~/Desktop/Pyenv-Virt1$ (venv379) greg@earth:~/Desktop/Pyenv-Virt1$ pip list Package Version ———- ——- pip 21.2.4 setuptools 47.1.0 (venv379) greg@earth:~/Desktop/Pyenv-Virt1$
Créez l'environnement virtuel et donnez-lui un nom. Vous pouvez lui donner à peu près le nom que vous voulez. J'aime faire précéder le nom de « venv » pour pouvoir m'en souvenir facilement.
$ pyenv virtualenv 3.7.9 venv379
Looking in links: /tmp/tmplwbkpo45
Requirement already satisfied: setuptools in /home/greg/.pyenv/versions/3.7.9/envs/venv379/lib/python3.7/site-packages (47.1.0)
Requirement already satisfied: pip in /home/greg/.pyenv/versions/3.7.9/envs/venv379/lib/python3.7/site-packages (20.1.1)
greg@earth:~/Desktop/Pyenv-Virt1$
Activez l'environnement virtuel et faites un pip list pour vérifier qu'il est tout neuf.
$ pyenv activate venv379
pyenv-virtualenv: prompt changing will be removed from future release. configure `export PYENV_VIRTUALENV_DISABLE_PROMPT=1' to simulate the behavior.
(venv379) greg@earth:~/Desktop/Pyenv-Virt1$
(venv379) greg@earth:~/Desktop/Pyenv-Virt1$ pip list
Package Version ———- ——- pip 21.2.4
setuptools 47.1.0
(venv379) greg@earth:~/Desktop/Pyenv-Virt1$
Notice that your terminal prompt has changed. This verifies that you are in a virtual environment. After this, you can install whatever packages you want. When you are done, deactivate the virtual environment with pyenv deactivate. Your prompt will return to normal. Python Make a new folder for your virtual environment and change directory into it. Call it whatever you like. greg@earth:~$ cd /home/greg/Desktop greg@earth:~/Desktop$ mkdir Python-Virt1 greg@earth:~/Desktop$ cd Python-Virt1 greg@earth:~/Desktop/Python-Virt1$ Make sure that your python installation has the virtual environment library installed. Do a pip install virtualenv . greg@earth:~/Desktop/Python-Virt1$ pip install virtualenv
Notez que l'invite de votre terminal a changé, ce qui vérifie que vous êtes dans un environnement virtuel. Après cela, vous pouvez installer tous les paquets que vous voulez. Lorsque vous avez terminé, désactivez l'environnement virtuel avec pyenv deactivate. Votre invite revient à la normale.
Python
Créez un nouveau dossier pour votre environnement virtuel et changez de répertoire. Appelez-le comme vous le souhaitez.
greg@earth:~$ cd /home/greg/Desktop
greg@earth:~/Desktop$ mkdir Python-Virt1
greg@earth:~/Desktop$ cd Python-Virt1
greg@earth:~/Desktop/Python-Virt1$
Assurez-vous que la bibliothèque d'environnement virtuel est installée sur votre installation python. Faites un pip install virtualenv.
greg@earth:~/Desktop/Python-Virt1$ pip install virtualenv
Collecting virtualenv Downloading virtualenv-20.7.2-py2.py3-none-any.whl (5.3 MB) |████████████████████████████████| 5.3 MB 2.6 MB/s Requirement already satisfied: importlib-metadata>=0.12 in /home/greg/.pyenv/versions/3.7.9/lib/python3.7/site-packages (from virtualenv) (4.6.3) … Successfully installed backports.entry-points-selectable-1.1.0 distlib-0.3.2 filelock-3.0.12 platformdirs-2.3.0 six-1.16.0 virtualenv-20.7.2 greg@earth:~/Desktop/Python-Virt1$ Create your virtual environment with python -m venv env This will create an env folder. Now you can activate your virtual environment. greg@earth:~/Desktop/Python-Virt1$ source env/bin/activate (env) greg@earth:~/Desktop/Python-Virt1$ Just as pyenv changes the terminal prompt, the “normal” Python virtual environment does as well. To deactivate the Python virtual environment, all you have to do is use the command deactivate. (env) greg@earth:~/Desktop/Python-Virt1$ deactivate greg@earth:~/Desktop/Python-Virt1$
Collecting virtualenv
Downloading virtualenv-20.7.2-py2.py3-none-any.whl (5.3 MB) |████████████████████████████████| 5.3 MB 2.6 MB/s
Requirement already satisfied: importlib-metadata>=0.12 in /home/greg/.pyenv/versions/3.7.9/lib/python3.7/site-packages (from virtualenv) (4.6.3) … Successfully installed backports.entry-points-selectable-1.1.0 distlib-0.3.2 filelock-3.0.12 platformdirs-2.3.0 six-1.16.0 virtualenv-20.7.2
greg@earth:~/Desktop/Python-Virt1$
Créez votre environnement virtuel avec :
python -m venv env
Cela va créer un dossier env. Vous pouvez maintenant activer votre environnement virtuel.
greg@earth:~/Desktop/Python-Virt1$ source env/bin/activate
(env) greg@earth:~/Desktop/Python-Virt1$
Tout comme pyenv change l'invite du terminal, l'environnement virtuel Python « normal » le fait aussi.
Pour désactiver l'environnement virtuel Python, il suffit d'utiliser la commande deactivate.
(env) greg@earth:~/Desktop/Python-Virt1$ deactivate
greg@earth:~/Desktop/Python-Virt1$
Installing Arcade Now that we have our virtual environment set up, we can finally install the Arcade package. Remember to activate the environment. For the purposes of this article, I’ll be using the “standard” Python virtual environment rather than the pyenv version. Use pip to install Arcade into your virtual environment. $ pip install arcade If everything goes well, your next step will be to download the platformer tutorial. You can find it at https://github.com/pythonarcade/arcade. I suggest that you get the entire repository by using the download zip option. Once you have the repository downloaded, unpack it and navigate to the tutorial which is located within the repository at /arcade/examples/platform_tutorial. Copy the entire folder into the folder you have set up for your virtual environment. Finally, using a terminal window, change to your virtual environment and then into the platform_tutorial folder. You should see about 17 files in your folder. There is an entire tutorial that walks through most of these files at https://api.arcade.academy/en/latest/examples/platform_tutorial/index.html. Each step in the tutorial is centered around one of the source files. Instead of just pointing you to the tutorial and telling you to learn completely on your own, I’ll attempt to distill some of the information by looking at the first two provided program source code files. We’ll start off by looking at the very first file 01_open_window.py.
Installation d'Arcade
Maintenant que notre environnement virtuel est configuré, nous pouvons enfin installer le paquet Arcade. N'oubliez pas d'activer l'environnement. Pour les besoins de cet article, je vais utiliser l'environnement virtuel Python « standard » plutôt que la version pyenv.
Utilisez pip pour installer Arcade dans votre environnement virtuel.
$ pip install arcade
Si tout se passe bien, votre prochaine étape sera de télécharger le tutoriel de plateforme. Vous pouvez le trouver à l'adresse https://github.com/pythonarcade/arcade. Je vous suggère d'obtenir le dépôt complet en utilisant l'option download zip. Une fois que vous avez téléchargé le dépôt, décompressez-le et accédez au tutoriel qui s'y trouve à l'adresse /arcade/examples/platform_tutorial. Copiez l'ensemble du dossier dans le dossier que vous avez créé pour votre environnement virtuel. Enfin, à l'aide d'une fenêtre de terminal, passez dans votre environnement virtuel, puis dans le dossier platform_tutorial.
Vous devriez voir environ 17 fichiers dans le dossier. Il existe un tutoriel complet qui traite de la plupart de ces fichiers à l'adresse https://api.arcade.academy/en/latest/examples/platform_tutorial/index.html. Chaque étape du tutoriel est centrée sur l'un des fichiers source. Au lieu de vous indiquer le tutoriel et de vous dire d'apprendre par vous-même, je vais essayer de distiller certaines informations en examinant les deux premiers fichiers de code source fournis. Nous allons commencer par examiner le tout premier fichier 01_open_window.py.
This file is a skeleton that creates a simple window and sets the background color. It provides you a nice starting point for creating your own games. import arcade # Constants SCREEN_WIDTH = 1000 SCREEN_HEIGHT = 650 SCREEN_TITLE = “Platformer” As you can see, the window will be 1000 pixels wide and 650 pixels high and will have the title Platformer. Simple enough. The next thing that gets done is to create a Python Class that will hold your actual game. You can see that the init function holds the code that sets the actual screen and sets the background color and the setup function starts/restarts the game. When you run the skeleton program, you will see a window pop up with the cornflower blue background. $ python 01_open_window.py You will have to click the x in the title bar or do a <ctrl> c in the terminal to close the window.
Ce fichier est un squelette qui crée une fenêtre simple et définit sa couleur de fond. Il vous fournit un bon point de départ pour créer vos propres jeux.
import arcade
# Constants SCREEN_WIDTH = 1000 SCREEN_HEIGHT = 650 SCREEN_TITLE = “Platformer”
Comme vous pouvez le voir, la fenêtre aura une largeur de 1 000 pixels et une hauteur de 650 pixels et portera le titre Platformer (Plateforme). C'est assez simple. La prochaine chose à faire est de créer une classe Python qui contiendra votre vrai jeu. Vous pouvez voir que la fonction init contient le code qui définit le véritable écran et la couleur de fond et que la fonction setup démarre/redémarre le jeu.
Lorsque vous exécutez le programme squelette, vous verrez une fenêtre s'ouvrir avec un fond d'un bleu bleuet.
$ python 01_open_window.py
Vous devrez cliquer sur le x dans la barre de titre ou faire un <ctrl> c dans le terminal pour fermer la fenêtre.
We will need to add some code in order to make the program show something other than just a pretty blue background. In your IDE or text editor, open the file 02_draw_sprites.py . This file is an expansion of the skeleton that we just ran. Between the constants at the top of the source code and the beginning of the class, you’ll see the following additional lines… # Constants used to scale our sprites from their original size CHARACTER_SCALING = 1 TILE_SCALING = 0.5 These lines set the scaling for both the character sprite and the tiles. In the class, some code has been added to the class that sets up the character and some props. Between the super().init line and the arcade.set_background_color line, you will see the following lines… # These are 'lists' that keep track of our sprites. Each sprite should (Voici des « listes » qui gardent un suivi de nos sprites) # go into a list. (entrer dans une liste) self.wall_list = None self.player_list = None
Il faut ajouter un peu de code pour que le programme affiche autre chose qu'un joli fond bleu. Dans votre IDE ou votre éditeur de texte, ouvrez le fichier 02_draw_sprites.py. Ce fichier est une expansion du squelette que nous venons d'exécuter. Entre les constantes en haut du code source et le début de la classe, vous verrez les lignes supplémentaires suivantes :
# Constants used to scale our sprites from their original size (Les constantes utilisées pour redimensionner nos sprites à partir de leur taille originale)
CHARACTER_SCALING = 1
TILE_SCALING = 0.5
Ces lignes définissent la mise à l'échelle à la fois pour le sprite du personnage et pour les tuiles. Dans la classe, du code a été ajouté à la classe qui met en place le personnage et certains accessoires. Entre la ligne super().init et la ligne arcade.set_background_color, vous verrez les lignes suivantes :
# These are 'lists' that keep track of our sprites. Each sprite should (Voici des « listes » pour pouvoir suivre nos sprites. Chaque sprite devrait aller dans une liste.)
# go into a list.
self.wall_list = None
self.player_list = None
# Separate variable that holds the player sprite self.player_sprite = None As you can tell from the comments, this defines a couple of lists, one for the wall and one for the player, and a variable for the player sprite image. # Create the Sprite lists self.player_list = arcade.SpriteList() self.wall_list = arcade.SpriteList(use_spatial_hash=True) The next part of the code is very important in that it creates the player sprite. The actual sprite image can be anything you like. To help new users along, the good people that created Arcade, included a few sprite images that you might need in the actual distribution package. If you look in your virtual environment at the /env/lib/pythonx/site-packages/arcade/resources/images folder, you will see a number of subfolders that include various images that are already set up for you. Getting back to the code, you can see that the image locations are referenced when each image is defined as an arcade.Sprite. First, the player sprite is created.
# Separate variable that holds the player sprite (Variable séparée qui tient le sprite du joueur)
self.player_sprite = None
Comme vous pouvez le voir dans les commentaires, ceci définit deux listes, une pour le mur et une pour le joueur, et une variable pour l'image du sprite du joueur.
# Create the Sprite lists
self.player_list = arcade.SpriteList()
self.wall_list = arcade.SpriteList(use_spatial_hash=True)
La partie suivante du code est très importante, car elle crée le sprite du joueur. L'image réelle du sprite peut être ce que vous voulez. Pour aider les nouveaux utilisateurs, les personnes qui ont créé Arcade ont inclus dans le paquet de distribution quelques images de sprites dont vous pourriez avoir besoin. Si vous regardez dans votre environnement virtuel dans le dossier /env/lib/pythonx/site-packages/arcade/resources/images, vous verrez un certain nombre de sous-dossiers qui incluent diverses images déjà configurées pour vous. Pour en revenir au code, vous pouvez voir que les emplacements des images sont référencés lorsque chaque image est définie comme un arcade.Sprite. Tout d'abord, le sprite du joueur est créé.
Finally, the on_draw function of our class is modified by adding the following lines to the bottom of the function (after the start_render() call)… # Draw our sprites self.wall_list.draw() self.player_list.draw() While this doesn’t create anything but a static image, you can see that, with a bit of planning and forethought, it is fairly simple to get the basics of a game. When you run program 02_draw_sprites.py, you will see something that looks like this (bottom left) … You can work through the rest of the tutorial which will get you a very basic, somewhat playable game in the file 17_views.py . When you run it, it should look something like this (bottom right) …
Enfin, la fonction on_draw de notre classe est modifiée en ajoutant les lignes suivantes au bas de la fonction (après l'appel start_render()) :
# Draw our sprites (Dessiner nos sprites) self.wall_list.draw() self.player_list.draw()
Bien que cela ne crée rien d'autre qu'une image statique, vous pouvez voir qu'avec un peu de préparation et de réflexion, il est assez simple d'obtenir les bases d'un jeu. Lorsque vous exécutez le programme 02_draw_sprites.py, vous voyez quelque chose qui ressemble à ce qui est montré en bas à gauche.
Vous pouvez suivre le reste du tutoriel qui vous permettra d'obtenir un jeu très basique et un peu jouable dans le fichier 17_views.py . Lorsque vous l'exécutez, il devrait ressembler à quelque chose comme ce qui est présenté en bas à droite.
There is another program you should consider downloading, which is a map editor. Step 9 of the tutorial gives you some basic instructions on using the map editor and where you can download it. They also give you a link to the documentation for the tile/map editor to help you along. I will provide a zip file for all 17 source files of the tutorial code that you need to get started on my repository, but I strongly suggest that you download the arcade repository. There is a tremendous amount of sample files that will not only give you a large amount of information, but also should spark some inspiration for moving forward. You can find the code at my github repository at https://github.com/gregwa1953/FCM-173. Until next time, as always; stay safe, healthy, positive and creative!
Il existe un autre programme que vous devriez envisager de télécharger, à savoir un éditeur de cartes. L'étape 9 du tutoriel vous donne des instructions de base sur l'utilisation de l'éditeur de cartes et vous indique où le télécharger. Elle vous donne également un lien vers la documentation de l'éditeur de tuiles et de cartes pour vous aider.
Je fournirai sur mon dépôt un fichier zip pour les 17 fichiers sources du code du tutoriel dont vous avez besoin pour commencer, mais je vous suggère fortement de télécharger le dépôt d'Arcade. Il y a une quantité énorme d'exemples de fichiers qui, non seulement vous donneront une grande quantité d'informations, mais aussi devraient vous inspirer pour aller de l'avant. Vous pouvez trouver le code sur mon dépôt github à l'adresse https://github.com/gregwa1953/FCM-173.
Jusqu'à la prochaine fois, comme toujours, restez en sécurité, en bonne santé, positif et créatif !
Textes en noir dans les encadrés : p. 16 : The main function instantiates the class, calls the setup function and then the game runs. La fonction principale instancie la classe, appelle la fonction setup, puis le jeu démarre.
p 17 : The ground that the character and any props are located is also set as a sprite. Le sol, où sont placés le personnage et tous les accessoires, est aussi paramétré comme un sprite.
Then some crates are placed on the ground and added to the game object. Puis quelques caisses sont placées sur le sol et ajoutées à l'objet game.