Créez un jeu de plateforme en Python avec Arcade – Real Python

Qu'est-ce qu'un jeu de plateforme?

Il y a quelques caractéristiques qui séparent les jeux de plateforme des autres types de jeux:

• Le joueur saute et grimpe entre différentes plates-formes sur le terrain de jeu.
• Les plates-formes présentent souvent un terrain inégal et des emplacements en hauteur inégaux.
• Des obstacles sont placés sur le chemin du joueur et doivent être surmontés pour atteindre un objectif.

Ce ne sont là que les exigences minimales pour un jeu de plateforme, et vous êtes libre d'ajouter d'autres fonctionnalités à votre guise, notamment:

• Plusieurs niveaux de difficulté croissante
• Récompenses disponibles tout au long du jeu
• Vie de plusieurs joueurs
• Capacité à détruire les obstacles du jeu

Le plan de jeu développé dans ce didacticiel comprend une difficulté et des récompenses croissantes.

Histoire du jeu

Tous les bons jeux ont une histoire, même si elle est simple:

Votre jeu bénéficie d'une histoire qui relie les actions entreprises par le joueur à un objectif primordial.

Pour ce didacticiel, l'histoire du jeu concerne un voyageur de l'espace nommé Roz, qui s'est écrasé sur un monde extraterrestre. Avant que leur vaisseau ne s'écrase, Roz a été projeté à l'écart et doit maintenant trouver son vaisseau spatial, le réparer et rentrer chez lui.

Pour ce faire, Roz doit voyager de son emplacement actuel à la sortie de chaque niveau, ce qui les rapproche du navire. En cours de route, Roz peut collecter des pièces, qui sont utilisées pour réparer l'engin endommagé. Depuis que Roz a été éjecté du vaisseau, ils n'ont pas d'armes et doivent donc éviter tout obstacle dangereux sur le chemin.

Bien que cette histoire puisse sembler idiote, elle sert le but important de informer la conception de vos niveaux et personnages. Cela vous aide à prendre des décisions lors de la mise en œuvre des fonctionnalités:

• Puisque Roz n'a pas d'armes, il n'y a aucun moyen de tirer sur les ennemis qui peuvent apparaître.
• Roz s'est écrasé sur un monde extraterrestre, de sorte que les ennemis peuvent être n'importe où et n'importe quoi.
• Parce que la planète est extraterrestre, la gravité peut être différente, ce qui peut affecter les capacités de saut et de mouvement de Roz.
• Roz doit réparer son vaisseau spatial endommagé, ce qui nécessite de collecter des objets pour le faire. À l'heure actuelle, les pièces sont disponibles, mais d'autres objets peuvent être disponibles plus tard.

Lors de la conception d'un jeu, vous pouvez rendre l'histoire aussi simple ou complexe que vous le souhaitez.

Mécanique de jeu

Avec une conception approximative à l'esprit, vous pouvez également commencer à planifier la façon dont vous contrôlerez le gameplay. Déplacer Roz sur le terrain de jeu nécessite un moyen de contrôler plusieurs mouvements différents:

• La gauche et Droite se déplacer sur une plate-forme
• En haut et Vers le bas grimper aux échelles entre les plates-formes
• Sautez pour collecter des pièces, éviter les ennemis ou vous déplacer entre les plates-formes

Traditionnellement, les joueurs sont contrôlés à l'aide des quatre touches fléchées pour le mouvement directionnel, ainsi que Espace pour sauter. Vous pouvez également utiliser des clés telles que IJKL, IJKM ou WASD si vous le souhaitez.

Vous n'êtes pas limité non plus à une simple saisie au clavier. le arcade La bibliothèque inclut la prise en charge des manettes de jeu et des contrôleurs de jeu, que vous découvrirez plus tard. Une fois qu'un joystick est connecté à votre ordinateur, vous pouvez déplacer Roz en vérifiant la position des axes X et Y du bâton et sauter en vérifiant les pressions de bouton spécifiques.

Actifs du jeu

Maintenant que vous avez une idée de la façon dont le jeu devrait fonctionner, vous devez prendre des décisions sur l'apparence et le son du jeu. Les images, les sprites, les sons et même le texte utilisés pour afficher la partition sont collectivement appelés les atouts. Ils définissent votre jeu aux yeux de vos joueurs. Leur création peut être un défi, prenant autant de temps, sinon plus, que d'écrire le code du jeu.

Plutôt que de créer vos propres actifs, vous pouvez télécharger des actifs gratuits ou à faible coût à utiliser dans votre jeu. De nombreux artistes et concepteurs fournissent des sprites, des arrière-plans, des polices, des sons et d'autres contenus que les créateurs de jeux peuvent utiliser. Voici quelques sources de musique, de son et d'art dans lesquelles vous pouvez rechercher du contenu utile:

Pour le jeu décrit dans ce didacticiel, vous utiliserez des images de tuiles de carte disponibles gratuitement et des sprites créés par Kenney.nl. Les effets sonores fournis dans le code source téléchargeable ont été créés par l'auteur à l'aide de MuseScore et Audacity.

La dernière étape avant de pouvoir commencer à écrire du code consiste à décider comment vous allez tout structurer et tout stocker.

Définition de la structure du jeu en Python arcade

Votre jeu utilise toutes les capacités orientées objet de arcade. Pour ce faire, vous définissez une nouvelle classe basée sur arcade.Fenêtre, puis remplacez les méthodes de cette classe pour mettre à jour et rendre les graphismes de votre jeu.

Voici un squelette de base de ce à quoi pourrait ressembler un jeu fini. Vous construirez sur ce squelette au fur et à mesure que le jeu progressera:

    1"" "
    2Plateforme d'arcade
    3
    4Démontrer les capacités de l'arcade dans un jeu de plateforme
    5Soutenir l'article Arcade Platformer
    6à https://realpython.com/platformer-python-arcade/
    7
    8Toutes les illustrations de jeu de www.kenney.nl
    9Sons du jeu et cartes de tuiles par auteur
dix"" "
11
12importer arcade
13
14classer Plateforme(arcade.La fenêtre):
15    def __init__(soi):
16        passe
17
18    def mettre en place(soi):
19        "" "Configure le jeu pour le niveau actuel" ""
20        passe
21
22    def on_key_press(soi, clé: int, modificateurs: int):
23        "" "Traite les pressions sur les touches
24
25                                Arguments:
26                                                key int - Quelle touche a été enfoncée
27                                                modifiers int - Quels modificateurs étaient en panne à ce moment-là
28                                "" "
29
30    def on_key_release(soi, clé: int, modificateurs: int):
31        "" "Traite les versions clés
32
33                                Arguments:
34                                                key int - Quelle clé a été libérée
35                                                modifiers int - Quels modificateurs étaient en panne à ce moment-là
36                                "" "
37
38    def on_update(soi, delta_time: flotter):
39        "" "Met à jour la position de tous les objets du jeu
40
41                                Arguments:
42                                                delta_time float - Combien de temps depuis le dernier appel
43                                "" "
44        passe
45
46    def on_draw(soi):
47        passe
48
49si __Nom__ == "__principale__":
50    la fenêtre = Plateforme()
51    la fenêtre.mettre en place()
52    arcade.Cours()

Cette structure de base fournit presque tout ce dont vous avez besoin pour construire un jeu de plateforme 2D:

• Ligne 12 importe le arcade bibliothèque.

• Ligne 14 définit la classe utilisée pour exécuter l'ensemble du jeu. Les méthodes de cette classe sont appelées pour mettre à jour l'état du jeu, traiter les entrées de l'utilisateur et dessiner des éléments à l'écran.

• Ligne 15 définit .__ init __ (), qui initialise l'objet de jeu. Vous ajoutez du code ici pour gérer les actions qui ne doivent être effectuées que lorsque le jeu démarre pour la première fois.

• Ligne 18 définit .mettre en place(), qui configure le jeu pour commencer à jouer. Vous ajoutez du code à cette méthode qui devra peut-être être répété tout au long du jeu. Par exemple, c'est un excellent endroit pour initialiser de nouveaux niveaux en cas de succès ou pour réinitialiser le niveau actuel en cas d'échec.

• Lignes 22 et 30 définir .on_key_press () et .on_key_release (), qui vous permettent de traiter les entrées au clavier indépendamment. arcade traite les pressions sur les touches et les relâchements de touches séparément, ce qui permet d'éviter les problèmes de répétition automatique du clavier.

• Ligne 38 définit .on_update (), où vous mettez à jour l'état de votre jeu et tous les objets qu'il contient. C'est là que les collisions entre les objets sont gérées, la plupart des effets sonores sont joués, les scores sont mis à jour et les sprites sont animés. Cette méthode est l'endroit où tout dans votre jeu se passe réellement, il y a donc généralement beaucoup de code ici.

• Ligne 46 définit .on_draw (), où tout ce qui est affiché dans votre jeu est dessiné. Contrairement à .on_update (), cette méthode ne contient généralement que quelques lignes de code.

• Lignes 49 à 52 définissez le point d'entrée principal de votre jeu. C'est là que vous:

  • Créer l'objet de jeu la fenêtre en fonction de votre classe définie à la ligne 13
  • Configurez le jeu en appelant window.setup ()
  • Lancez la boucle de jeu en appelant arcade.run ()

Cette structure de base fonctionne bien pour la plupart des Python arcade Jeux.

Au fur et à mesure de votre progression dans ce didacticiel, vous découvrirez chacune de ces méthodes et en ajouterez de nouvelles pour implémenter les fonctionnalités de votre jeu.

Ajout de la fonctionnalité de jeu initiale

La première chose à faire lors du démarrage du jeu est d'ouvrir la fenêtre du jeu. À la fin de cette section, votre jeu ressemblera à ceci:

Vous pouvez voir les modifications apportées au squelette de votre jeu dans arcade_platformer / 02_open_game_window.py:

11importer arcade
12importer pathlib
13
14# Constantes du jeu
15# Dimensions de la fenêtre
16SCREEN_WIDTH = 1000
17SCREEN_HEIGHT = 650
18SCREEN_TITLE = "Arcade Platformer"
19
20# Chemin des actifs
21ASSETS_PATH = pathlib.Chemin(__déposer__).résoudre().parent.parent / "les atouts"
22
23classer Plateforme(arcade.La fenêtre):
24    def __init__(soi) -> Rien:
25        super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
26
27        # Ces listes contiendront différents ensembles de sprites
28        soi.pièces de monnaie = Rien
29        soi.Contexte = Rien
30        soi.des murs = Rien
31        soi.échelles = Rien
32        soi.buts = Rien
33        soi.ennemis = Rien
34
35        # Un sprite pour le joueur, rien de plus n'est nécessaire
36        soi.joueur = Rien
37
38        # Nous avons également besoin d'un moteur physique
39        soi.moteur_physique = Rien
40
41        # Quelque part pour garder le score
42        soi.But = 0
43
44        # À quel niveau sommes-nous?
45        soi.niveau = 1
46
47        # Chargez nos sons ici
48        soi.coin_sound = arcade.load_sound(
49            str(ASSETS_PATH / "des sons" / "coin.wav")
50        )
51        soi.jump_sound = arcade.load_sound(
52            str(ASSETS_PATH / "des sons" / "jump.wav")
53        )
54        soi.Victoire_Sound = arcade.load_sound(
55            str(ASSETS_PATH / "des sons" / "victoire.wav")
56        )

Voici une ventilation:

• Lignes 11 et 12 importer le arcade et pathlib bibliothèques dont vous avez besoin.

• Lignes 16 à 18 définir plusieurs constantes de fenêtre de jeu qui seront utilisées pour ouvrir la fenêtre de jeu ultérieurement.

• Ligne 21 enregistre le chemin de votre les atouts dossier, en utilisant le chemin du fichier actuel comme base. Étant donné que vous utiliserez ces ressources tout au long du jeu, il est essentiel de savoir où elles se trouvent. Utilisant pathlib garantit que vos chemins fonctionneront correctement sous Windows, Mac ou Linux.

• Ligne 25 configure votre fenêtre de jeu en appelant la classe parente » .__ init __ () méthode utilisant super() et les constantes définies ci-dessus aux lignes 16 à 18.

• Lignes 28 à 33 définir six listes de sprites différentes pour contenir les différents sprites utilisés dans le jeu. Il n’est pas strictement nécessaire de les déclarer et de les définir ici, car ils seront correctement et entièrement définis ultérieurement dans .mettre en place(). La déclaration des propriétés des objets est un héritage de langages comme C ++ ou Java. Chaque niveau aura un ensemble différent d'objets, qui sont remplis dans .mettre en place():

  • pièces de monnaie sont des objets de collection que Roz peut trouver tout au long du jeu.

  • Contexte les objets sont présentés à des fins d'intérêt visuel uniquement et n'interagissent avec rien.

  • des murs sont des objets dans lesquels Roz ne peut pas se déplacer. Il s'agit notamment des murs réels et des plates-formes sur lesquelles Roz marche et saute.

  • échelles sont des objets qui permettent à Roz de monter ou de descendre.

  • buts sont des objets que Roz doit trouver pour passer au niveau suivant.

  • ennemis sont des objets que Roz doit éviter tout au long du jeu. Le contact avec un ennemi mettra fin à la partie.

• Ligne 36 déclare l'objet joueur, qui sera correctement défini dans .mettre en place().

• Ligne 39 déclare un moteur physique utilisé pour gérer les mouvements et les collisions.

• Ligne 42 définit une variable pour suivre le score actuel.

• Ligne 45 définit une variable pour suivre le niveau de jeu actuel.

• Lignes 48 à 56 Utilisez le ASSETS_PATH constante définie précédemment pour localiser et charger les fichiers son utilisés pour collecter des pièces, sauter et terminer chaque niveau.

Vous pouvez en ajouter plus ici si vous le souhaitez, mais rappelez-vous que .__ init __ () n'est exécuté que lorsque le jeu démarre pour la première fois.

Roz doit pouvoir marcher, sauter et grimper dans le monde du jeu. Gérer quand et comment cela se produit est le travail du moteur physique.

Qu'est-ce qu'un moteur physique?

Dans la plupart des plateformes, l'utilisateur déplace le joueur à l'aide d'un joystick ou du clavier. Ils peuvent faire sauter le joueur ou le faire sortir d'une plate-forme. Une fois que le joueur est dans les airs, l'utilisateur n'a rien d'autre à faire pour le faire tomber sur une plate-forme inférieure. Contrôler où un joueur peut marcher et comment il tombe après avoir sauté ou quitté une plate-forme est géré par le moteur physique.

Dans un jeu, le moteur physique fournit une approximation des forces physiques qui agissent sur les joueurs et autres objets du jeu. Ces forces peuvent communiquer ou avoir un impact sur le mouvement des objets du jeu, y compris les mouvements de saut, d'escalade, de chute et de blocage.

Il y a trois moteurs physiques inclus dans Python arcade:

1. arcade.PhysicsEngineSimple est un moteur très basique qui gère le mouvement et les interactions d'un sprite solo et d'une liste de sprites de murs. Ceci est utile pour les jeux descendants, où la gravité n'est pas un facteur.

2. arcade.PhysicsEnginePlatformer est un moteur plus complexe conçu pour être utilisé dans les jeux de plateforme. En plus du mouvement de base, il fournit une force de gravité qui tire les objets vers le bas de l'écran. Il fournit également au joueur un moyen de sauter et de gravir des échelles.

3. arcade.PymunkPhysiqueMoteur est construit sur Pymunk, une bibliothèque de physique 2D qui utilise la bibliothèque Chipmunk. Pymunk met à disposition des calculs physiques extrêmement réalistes arcade applications.

Pour ce didacticiel, vous utiliserez le arcade.PhysicsEnginePlatformer.

Afin de configurer correctement le arcade.PhysicsEnginePlatformer, vous devez fournir le sprite du joueur ainsi que deux listes de sprites contenant les murs et les échelles avec lesquels le joueur interagit. Étant donné que les murs et les échelles varient en fonction du niveau, vous ne pouvez pas définir formellement le moteur physique tant que le niveau n'est pas configuré, ce qui se produit dans .mettre en place().

En parlant de niveaux, comment les définissez-vous de toute façon? Comme pour la plupart des choses, il existe plusieurs façons de faire le travail.

Téléchargement et démarrage de Tiled

Avant d'exécuter Tiled, vous devez le télécharger. La version actuelle au moment de la rédaction était la version 1.4.3 de Tiled, qui était disponible pour Windows, Mac et Linux dans une variété de formats. Lors du téléchargement, pensez à soutenir sa maintenance continue en faisant également un don.

Une fois que vous avez téléchargé Tiled, vous pouvez le démarrer pour la première fois. Vous verrez la fenêtre suivante:

Cliquez sur Nouvelle carte pour créer la carte de tuiles pour votre premier niveau. La boîte de dialogue suivante apparaîtra:

Ces propriétés de carte de tuiles par défaut sont idéales pour les jeux de plate-forme et représentent les meilleures options pour un arcade Jeu. Voici une brève description des autres options que vous pouvez sélectionner:

• Orientation spécifie comment la carte est affichée et modifiée.
  • Orthogonal les cartes sont carrées et sont utilisées pour les jeux de haut en bas et de plate-forme. arcade fonctionne mieux avec les cartes orthogonales.
  • Isométrique les cartes déplacent le point de vue pour être un angle non carré par rapport au champ de jeu, fournissant une vue pseudo-3D du monde 2D. Échelonné les cartes isométriques spécifient que le bord supérieur de la carte est le bord supérieur de la vue.
  • Hexagonal les cartes utilisent des hexagones plutôt que des carrés pour chaque tuile de carte (bien que Tiled affiche des carrés dans l'éditeur).
• Format de couche de tuile spécifie comment la carte est stockée sur le disque. La compression à l'aide de zlib permet d'économiser de l'espace disque.
• Ordre de rendu des tuiles spécifie comment les tuiles sont stockées dans le fichier et finalement comment elles sont rendues par le moteur de jeu.
• Taille de la carte définit la taille de la carte à stocker, en unités de tuiles. Spécifier la carte comme Infini indique à Tiled de déterminer la taille finale en fonction des modifications effectuées.
• Taille de la tuile spécifie la taille de chaque tuile en pixels. Si vous utilisez une illustration provenant d'une source externe, définissez-la sur la taille des tuiles de cet ensemble. L'illustration fournie pour ce didacticiel utilise des sprites carrés mesurant 128 × 128 pixels. Cela signifie que chaque tuile comprend environ 16 000 pixels et qu'ils peuvent être stockés sur disque et en mémoire de manière à augmenter les performances du jeu si nécessaire.

Cliquez sur Enregistrer sous pour enregistrer le niveau. Puisqu'il s'agit d'un élément du jeu, enregistrez-le sous arcade_platformer / assets / platform_level_01.tmx.

Les cartes de tuiles consistent en un ensemble de tuiles placées sur des couches de carte spécifiques. Pour commencer à définir une carte de mosaïques pour un niveau, vous devez d'abord définir le jeu de mosaïques à utiliser et les couches sur lesquelles ils apparaissent.

Créer un jeu de tuiles

Les tuiles utilisées pour créer votre niveau sont contenues dans un ensemble de tuiles. Le jeu de tuiles est associé à la carte de tuiles et fournit toutes les images de sprite nécessaires pour définir le niveau.

Vous définissez et interagissez avec un jeu de mosaïques à l'aide du Ensembles de tuiles vue, située dans le coin inférieur droit de la fenêtre Mosaïque:

Clique le Nouveau jeu de tuiles pour définir le jeu de mosaïques pour ce niveau. Tiled présente une boîte de dialogue demandant des informations sur le nouveau jeu de mosaïques à créer:

Vous disposez des options suivantes pour votre nouveau jeu de mosaïques:

• Nom est le nom de votre ensemble de tuiles. Appelez celui-ci arcade_platformer.
• Taper spécifie comment le jeu de mosaïques sera défini:
  • Collection d'images indique que chaque vignette est contenue dans une seule image distincte sur le disque. Vous devez sélectionner cette option, comme arcade fonctionne mieux avec des images de tuiles individuelles.
  • Basé sur l'image de l'ensemble de tuiles indique que toutes les tuiles sont combinées en une seule grande image que Tiled doit traiter pour localiser chaque image individuelle. Sélectionnez cette option uniquement si les ressources que vous utilisez le nécessitent.
• Incorporer dans la carte demande à Tiled de stocker l'ensemble de tuiles dans la carte de tuiles. Ne cochez pas cette case, car vous allez enregistrer et utiliser le jeu de mosaïques en tant que ressource distincte dans plusieurs cartes de mosaïques.

Cliquez sur Enregistrer sous et enregistrez-le sous assets / arcade_platformer.tsx. Pour réutiliser ce jeu de mosaïques sur les futures cartes de mosaïques, sélectionnez Carte → Ajouter un jeu de tuiles externe pour l'inclure.

Définition du jeu de mosaïques

Votre nouvel ensemble de tuiles est initialement vide, vous devez donc le remplir avec des tuiles. Vous faites cela en localisant vos images de tuiles et en les ajoutant à l'ensemble. Chaque image doit avoir les mêmes dimensions que le Taille de la tuile défini lors de la création de la carte de tuiles.

Cet exemple suppose que vous avez téléchargé les ressources du jeu pour ce didacticiel. Vous pouvez le faire en cliquant sur le lien ci-dessous:

Vous pouvez également télécharger le Platformer Pack Redux (360 Assets) et déplacer le contenu du PNG dossier à votre arcade-platformer / actifs / images dossier. Rappelez-vous que votre carte de tuiles se trouve sous arcade-platformer / actifs, car cela sera important plus tard.

Dans la barre d'outils, cliquez sur le signe plus bleu (+) ou sélectionnez Jeu de tuiles → Ajouter des tuiles pour commencer le processus. La boîte de dialogue suivante vous sera présentée:

À partir de là, accédez aux dossiers répertoriés ci-dessous pour ajouter les ressources spécifiées à votre jeu de mosaïques:

Lorsque vous avez terminé d'ajouter des fichiers, votre jeu de mosaïques doit ressembler à ceci:

Si vous ne voyez pas toutes vos vignettes, cliquez sur le bouton Envelopper dynamiquement les carreaux sur la barre d'outils pour les afficher tous.

Enregistrez votre nouveau jeu de mosaïques avec Ctrl+S ou alors Déposer → Sauvegarder dans le menu et revenez à votre carte de tuiles. Vous verrez le nouveau jeu de mosaïques en bas à droite de l'interface Mosaïque, prêt à être utilisé pour définir votre carte de mosaïques!

Définition des couches de carte

Chaque élément d'un niveau a un objectif spécifique:

• Le sol et les murs définissent où et comment votre joueur peut se déplacer.
• Les pièces et autres objets de collection marquent des points et débloquent des succès.
• Les échelles permettent au joueur de grimper sur de nouvelles plates-formes mais ne bloquent pas le mouvement autrement.
• Les éléments d'arrière-plan fournissent un intérêt visuel et peuvent fournir des informations.
• Les ennemis fournissent des obstacles que le joueur doit éviter.
• Les objectifs fournissent une raison de se déplacer dans le niveau.

Chacun de ces différents types d'articles nécessite une manipulation différente dans arcade. Par conséquent, il est logique de les garder séparés lors de leur définition dans Tiled. Tiled vous permet de faire exactement cela en utilisant couches de carte. En plaçant différents types d'éléments sur différentes couches de carte et en traitant chaque couche séparément, vous pouvez suivre et gérer chaque type de sprite différemment.

Pour définir un calque, ouvrez d'abord le Couches vue dans le coin supérieur droit de l'écran Mosaïque:

Le calque par défaut est déjà défini et sélectionné. Renommez ce calque en terre en cliquant sur le calque, puis en modifiant le Nom dans le Propriétés vue à gauche. Vous pouvez également double-cliquer sur le nom pour le modifier directement dans le Couches panneau:

Ce calque contiendra vos tuiles de sol, y compris les murs à travers lesquels le joueur ne peut pas marcher.

La création de nouveaux calques vous oblige à définir non seulement le nom du calque, mais également le type de calque. Tiled propose quatre types de couches:

1. Couches de tuiles vous permettent de placer des tuiles de votre ensemble de tuiles sur la carte. Le placement est limité aux emplacements de la grille et les tuiles doivent être placées comme défini.
2. Couches d'objets te permettre de placer objets comme des objets de collection ou des déclencheurs sur la carte. Les objets peuvent être des tuiles de la carte de tuiles ou des formes librement dessinées, et ils peuvent être visibles ou non. Chaque objet peut être librement positionné, mis à l'échelle et pivoté.
3. Couches d'image vous permettent de placer des images sur la carte pour les utiliser comme image d'arrière-plan ou de premier plan.
4. Grouper les couches vous permettent de regrouper les couches en groupes pour une gestion simplifiée des cartes.

Pour ce didacticiel, vous utiliserez une couche d'objets pour placer des pièces de monnaie sur la carte et des couches de tuiles pour tout le reste.

Pour créer les nouvelles couches de tuiles, cliquez sur Nouvelle Couche dans le Couches afficher, puis sélectionnez Couche de tuile:

Créez trois nouvelles couches de tuiles nommées échelles, Contexte, et but.

Ensuite, créez un nouveau calque d'objet appelé pièces de monnaie pour contenir vos objets de collection:

Vous pouvez organiser les calques dans l'ordre de votre choix à l'aide des boutons fléchés en bas de la vue des calques. Vous pouvez maintenant commencer à définir votre niveau!

Concevoir un niveau

Dans le livre Classic Game Design, l'auteur et développeur de jeux Franz Lanzinger définit huit règles pour la conception de jeux classiques. Voici les trois premières règles:

1. Rester simple.
2. Démarrez le jeu immédiatement.
3. Rampe de difficulté de facile à difficile.

De même, le développeur de jeux vétéran Steve Goodwin parle de jeux d'équilibrage dans son livre Polished Game Development. Il souligne qu'un bon équilibre du jeu commence avec le niveau 1, qui «devrait être le premier développé et le dernier terminé».

Avec ces idées à l'esprit, voici quelques conseils pour concevoir vos niveaux de plateforme:

1. Le premier niveau du jeu devrait présenter à l'utilisateur les fonctionnalités et les commandes de base du jeu.
2. Rendez les premiers obstacles faciles à surmonter.
3. Rendez les premiers objets de collection impossibles à manquer et les suivants plus difficiles à obtenir.
4. N'introduisez pas d'obstacles qui nécessitent de la finesse à surmonter tant que l'utilisateur n'a pas appris à naviguer dans le monde.
5. N'introduisez pas d'ennemis tant que l'utilisateur n'a pas appris à surmonter les obstacles.

Vous trouverez ci-dessous un examen plus approfondi d'un premier niveau conçu avec ces directives à l'esprit. Dans les documents téléchargeables, cette conception de niveau complète se trouve sous assets / platform_level_01.tmx:

Le joueur commence par la gauche et procède vers la droite, indiqué par la flèche pointant vers la droite. Au fur et à mesure que le joueur se déplace à droite, il trouve une pièce de bronze, ce qui augmentera son score. Une deuxième pièce de bronze se trouve plus tard suspendue plus haut dans les airs, ce qui démontre au joueur que les pièces peuvent être n'importe où. Ensuite, le joueur trouve une pièce d'or, qui a une valeur en points différente.

Le joueur monte alors une rampe, ce qui démontre qu'il y a plus de monde au-dessus d'eux. Au sommet de la colline se trouve la dernière pièce d'or, qu'ils doivent sauter pour obtenir. De l'autre côté de la colline se trouve la sortie, qui est également marquée.

Ce niveau simple permet de montrer à l'utilisateur comment se déplacer et sauter. Cela montre qu'il existe des objets de collection dans le monde qui valent des points. Il montre également des éléments informatifs ou décoratifs avec lesquels le joueur n'interagit pas, tels que le signe de la flèche, le panneau de sortie et les touffes d'herbe. Enfin, il leur montre à quoi ressemble l'objectif.

Une fois le travail acharné de conception de votre premier niveau terminé, vous pouvez maintenant le créer dans Tiled.

Construire un niveau

Avant de pouvoir placer des pièces et le but, vous devez savoir comment y arriver. La première chose à définir est donc l'emplacement du sol. Avec votre carte de tuiles sélectionnée dans Tiled, sélectionnez le terre couche à construire.

Dans votre jeu de mosaïques, sélectionnez le herbeCentre tuile. Ensuite, cliquez dans n'importe quelle grille de la rangée inférieure de votre carte de tuiles pour mettre cette tuile en place:

Avec le premier jeu de tuiles, vous pouvez faire glisser sur la ligne du bas pour tout définir sur herbeCentre. Ensuite, sélectionnez le herbeMid tuile pour dessiner le dessus herbeux du niveau à travers la deuxième rangée:

Continuez à construire le niveau en utilisant les tuiles d'herbe pour construire une colline de deux tuiles en commençant environ à mi-chemin à travers le monde. Laissez un espace de quatre tuiles sur le bord droit pour permettre au joueur de descendre la colline et pour le panneau de sortie et le portail de sortie.

Ensuite, passez à la but couche et placez les tuiles du portail de sortie dans une tuile à partir du bord extrême droit:

Une fois la plate-forme de base et l'objectif en place, vous pouvez placer des éléments d'arrière-plan. Passer au Contexte couche, placez une flèche sur le côté gauche pour indiquer au joueur où aller et un panneau de sortie à côté du portail. Vous pouvez également placer des touffes d’herbe à l’endroit de votre choix sur la carte:

Vous pouvez maintenant définir où placer les pièces. Passez à votre pièces de monnaie couche pour le faire. N'oubliez pas qu'il s'agit d'un calque d'objets, vous n'êtes donc pas limité à placer des pièces de monnaie sur la grille. Sélectionnez la pièce de bronze et placez-la près de la flèche de départ. Placez une deuxième pièce de bronze un peu plus à droite et un peu plus haut:

Repeat this process with two gold coins, placing one just before the hill and one on top, at least three tiles above the top of the hill:

The different coins should score different point values when the player collects them. There are a couple of ways you can do this, but for this tutorial you’ll set a custom property to track each coin’s point value.

Defining Custom Properties

One of the benefits of using an object layer is the ability to set custom properties on objects on that layer. Custom properties are defined by you and represent any value you wish. In this case, you’ll use them to specify the point value for each coin on the layer.

With the coins layer selected, press S to begin selecting objects. Then right-click the first bronze coin you placed, and select Object Properties from the context menu to view its properties:

Predefined object properties are shown at the top of the Object Properties view, while custom properties are shown below. Currently there are no custom properties, so you need to add one. Click the blue plus sign at the bottom of the Object Properties view to add a new custom property:

You define both the name and the type of the custom property. In this case, you set the property as an int and the name as point_value.

With the custom property defined, you can set its value in the Object Properties view:

Perform these same steps for each of the coins in your level, setting the values to dix for bronze coins and 20 for gold coins. Don’t forget to save the level, because next you’ll learn how to read it into arcade.

Reading Game Levels

Defining a game level in Tiled is great, but unless you can read it into arcade, it’s not very useful. Luckily, arcade natively supports reading Tiled tile maps and processing the layers. Once done, your game will look like this:

Reading your game level is handled completely in .setup(). This code can be found in the file arcade_platformer/03_read_level_one.py.

First, you add a few more constants:

# Game constants
# Window dimensions
SCREEN_WIDTH = 1000
SCREEN_HEIGHT = 650
SCREEN_TITLE = "Arcade Platformer"

# Scaling constants
MAP_SCALING = 1.0

# Player constants
GRAVITY = 1.0
PLAYER_START_X = 65
PLAYER_START_Y = 256

These constants define the scaling factor for your maps as well as the starting position of your player and the strength of gravity in your world. These constants are used to define the level in .setup():

def setup(self) -> Rien:
    """Sets up the game for the current level"""

    # Get the current map based on the level
    map_name = F"platform_level_self.level:02.tmx"
    map_path = ASSETS_PATH / map_name

    # What are the names of the layers?
    wall_layer = "ground"
    coin_layer = "coins"
    goal_layer = "goal"
    background_layer = "background"
    ladders_layer = "ladders"

    # Load the current map
    game_map = arcade.tilemap.read_tmx(str(map_path))

    # Load the layers
    self.background = arcade.tilemap.process_layer(
        game_map, layer_name=background_layer, scaling=MAP_SCALING
    )
    self.goals = arcade.tilemap.process_layer(
        game_map, layer_name=goal_layer, scaling=MAP_SCALING
    )
    self.walls = arcade.tilemap.process_layer(
        game_map, layer_name=wall_layer, scaling=MAP_SCALING
    )
    self.ladders = arcade.tilemap.process_layer(
        game_map, layer_name=ladders_layer, scaling=MAP_SCALING
    )
    self.coins = arcade.tilemap.process_layer(
        game_map, layer_name=coin_layer, scaling=MAP_SCALING
    )

    # Set the background color
    background_color = arcade.color.FRESH_AIR
    si game_map.background_color:
        background_color = game_map.background_color
    arcade.set_background_color(background_color)

    # Create the player sprite if they're not already set up
    si ne pas self.player:
        self.player = self.create_player_sprite()

    # Move the player sprite back to the beginning
    self.player.center_x = PLAYER_START_X
    self.player.center_y = PLAYER_START_Y
    self.player.change_x = 0
    self.player.change_y = 0

    # Load the physics engine for this map
    self.physics_engine = arcade.PhysicsEnginePlatformer(
        player_sprite=self.player,
        platforms=self.walls,
        gravity_constant=GRAVITY,
        ladders=self.ladders,
    )

First, you build the name of the current tile map using the current level. The format string self.level:02 results in a two-digit level number and allows you to define up to ninety-nine different map levels.

Next, using pathlib syntax, define the full path to your maps. This allows arcade to properly locate all your game resources.

Next, define the names of your layers, which you will use shortly. Make sure these match the layer names you defined in Tiled.

Now you open the tile map so you can process the previously named layers. The function arcade.tilemap.process_layer() takes a number of arguments, but you will provide only three of them:

1. le game_map, which contains the layer to be processed
2. The name of the layer to read and process
3. Any scaling to apply to the tiles

arcade.tilemap.process_layer() returns a SpriteList populated with Sprite objects representing the tiles in the layer. Any custom properties defined for a tile, such as point_value for the tiles in the coins layer, are stored with the Sprite in a dictionary called .properties. You’ll see how to access them later.

You also set the background color of the level. You can define your own background color in Tiled using Map → Map Properties and defining the Background Color property. If a background color isn’t set in Tiled, you use the predefined .FRESH_AIR color.

Next, check to see if a player is already created. This might be the case if you call .setup() to restart the level or move to the next level. If not, you call a method to create the player sprite (more on that a little later). If there is a player, then you place the player into position and ensure it’s not moving.

Finally, you can define the physics engine to use, passing in the following parameters:

1. The player sprite
2. UNE SpriteList containing walls
3. A constant defining gravity
4. UNE SpriteList containing ladders

Walls determine where the player can move and when they can jump, and ladders enable climbing. The gravity constant controls how fast or slow the player falls.

Of course, running this code now won’t work, as you still need to define the player.

Updating and Drawing

Updating the state of your game occurs in .on_update(), which arcade calls roughly sixty times per second. This method handles the following actions and events:

• Moving player and enemy sprites
• Detecting collisions with enemies or collectibles
• Updating scores
• Animating sprites

In short, everything that makes your game playable occurs in .on_update(). After everything has been updated, arcade calls .on_draw() to render everything to the screen.

This separation of game logic from game display means you can add or modify features in your game freely without affecting code that displays the game. In fact, because most of the game logic occurs in .on_update(), your .on_draw() method is often very short.

You can find all the code below in arcade_platformer/05_update_and_draw.py in the downloadable materials. Add .on_draw() to your Platformer class:

def on_draw(self) -> Rien:
    arcade.start_render()

    # Draw all the sprites
    self.background.draw()
    self.walls.draw()
    self.coins.draw()
    self.goals.draw()
    self.ladders.draw()
    self.player.draw()

After the obligatory call to arcade.start_render(), you call .draw() on all your sprite lists, followed by the player sprite. Note the order in which items are drawn. You should start with sprites that appear farthest back and proceed forward. Now when you run the code, it should look like this:

The only thing missing is proper placement of the player sprite. Pourquoi? Because animated sprites need to be updated to select the proper texture to display and proper placement on the screen, and you haven’t updated anything yet. Here’s what that looks like:

def on_update(self, delta_time: float) -> Rien:
    """Updates the position of all game objects

                Arguments:
                                delta_time float -- How much time since the last call
                """

    # Update the player animation
    self.player.update_animation(delta_time)

    # Update player movement based on the physics engine
    self.physics_engine.update()

    # Restrict user movement so they can't walk off screen
    si self.player.la gauche < 0:
        self.player.la gauche = 0

    # Check if we've picked up a coin
    coins_hit = arcade.check_for_collision_with_list(
        sprite=self.player, sprite_list=self.coins
    )

    for coin dans coins_hit:
        # Add the coin score to our score
        self.score += int(coin.properties[[[["point_value"])

        # Play the coin sound
        arcade.play_sound(self.coin_sound)

        # Remove the coin
        coin.remove_from_sprite_lists()

    # Now check if we're at the ending goal
    goals_hit = arcade.check_for_collision_with_list(
        sprite=self.player, sprite_list=self.goals
    )

    si goals_hit:
        # Play the victory sound
        self.victory_sound.jouer()

        # Set up the next level
        self.level += 1
        self.setup()

To make sure your game operates at a constant speed no matter the actual frame rate, .on_update() takes a single float parameter called delta_time, which indicates the time since the last update.

The first thing to do is to animate the player sprite. Based on the player’s movement, .update_animation() automatically selects the correct texture to use.

Next, you update the movement of everything that can move. Since you defined a physics engine in .setup(), it makes sense to let it handle movement. However, the physics engine will let the player run off the left side of the game map, so you also need to take steps to prevent that.

Now that the player has moved, you check if they have collided with a coin. If so, that counts as collecting the coin, so you increment the player’s score using the point_value custom property you defined in Tiled. Then you play a sound and remove the coin from the play field.

You also check if the player has reached the final goal. If so, you play the victory sound, increment the level, and call .setup() again to load the next map and reset the player in it.

But how does the user reach that final goal? The physics engine will make sure Roz doesn’t fall through the floor and can jump, but it doesn’t actually know where to move Roz or when to jump. That’s something the user should decide, and you need to provide a way for them to do that.

Moving the Player Sprite

In the early days of computer gaming, the only input device available was the keyboard. Even today, many games—including this one—still provide keyboard control.

Moving the player using the keyboard can be done in a variety of ways. There are many different popular keyboard arrangements, including:

Of course, there are many other keyboard arrangements to choose from.

Since you need to allow Roz to move in all four directions as well as jump, for this game you’ll use the arrow and IJKL keys for movement and the space bar for jumping:

All keyboard input in arcade is handled by .on_key_press() et .on_key_release(). You can find the code for making Roz move via the keyboard in arcade_platformer/06_keyboard_movement.py.

First, you need two new constants:

23# Player constants
24GRAVITY = 1.0
25PLAYER_START_X = 65
26PLAYER_START_Y = 256
27PLAYER_MOVE_SPEED = dix
28PLAYER_JUMP_SPEED = 20

These constants control how fast Roz moves. PLAYER_MOVE_SPEED controls their movement left, right, and up and down ladders. PLAYER_JUMP_SPEED indicates how high Roz can jump. By setting these values as constants, you can tweak them to dial in the proper gameplay during testing.

You use those constants in .on_key_press():

def on_key_press(self, key: int, modifiers: int) -> Rien:
    """Arguments:
                key -- Which key was pressed
                modifiers -- Which modifiers were down at the time
                """

    # Check for player left or right movement
    si key dans [[[[arcade.key.LEFT, arcade.key.J]:
        self.player.change_x = -PLAYER_MOVE_SPEED
    elif key dans [[[[arcade.key.RIGHT, arcade.key.L]:
        self.player.change_x = PLAYER_MOVE_SPEED

    # Check if player can climb up or down
    elif key dans [[[[arcade.key.UP, arcade.key.je]:
        si self.physics_engine.is_on_ladder():
            self.player.change_y = PLAYER_MOVE_SPEED
    elif key dans [[[[arcade.key.DOWN, arcade.key.K]:
        si self.physics_engine.is_on_ladder():
            self.player.change_y = -PLAYER_MOVE_SPEED

    # Check if player can jump
    elif key == arcade.key.SPACE:
        si self.physics_engine.can_jump():
            self.player.change_y = PLAYER_JUMP_SPEED
            # Play the jump sound
            arcade.play_sound(self.jump_sound)

There are three major components to this code:

1. You handle horizontal movement by checking for the Left et Right arrows and the J et L keys from your IJKL arrangement. You then set the .change_x property appropriately.

2. You handle vertical movement by checking for the En haut et Down arrows as well as the je et K keys. However, since Roz can only move up and down on ladders, you verify that using .is_on_ladder() before moving up or down.

3. You handle jumping via the Space key. To prevent Roz from jumping in midair, you check if Roz can jump using .can_jump(), which returns True only if Roz is standing on a wall. If so, you move the player up and play the jump sound.

When you release a key, Roz should stop moving. You set that up in .on_key_release():

def on_key_release(self, key: int, modifiers: int) -> Rien:
    """Arguments:
                key -- The key which was released
                modifiers -- Which modifiers were down at the time
                """

    # Check for player left or right movement
    si key dans [[[[
        arcade.key.LEFT,
        arcade.key.J,
        arcade.key.RIGHT,
        arcade.key.L,
    ]:
        self.player.change_x = 0

    # Check if player can climb up or down
    elif key dans [[[[
        arcade.key.UP,
        arcade.key.je,
        arcade.key.DOWN,
        arcade.key.K,
    ]:
        si self.physics_engine.is_on_ladder():
            self.player.change_y = 0

This code follows a similar pattern to .on_key_press():

1. You check if any of the horizontal movement keys were released. If so, then Roz’s change_x is set to 0.
2. You check if the vertical movement keys were released. Again, since Roz needs to be on a ladder to move up and down, you need to check .is_on_ladder() here as well. If not, a player could jump and then press and release En haut, leaving Roz hanging in midair!

Note that you don’t need to check if the jump key was released.

OK, now you can move Roz around, but why does Roz just walk out of the window to the right? You need a way to keep Roz visible in the game world as they move around, and that’s where viewports come in.