Comment programmer des jeux informatiques (avec des images)

2024 Auteur: Robert Blare | [email protected]. Dernière modifié: 2024-01-31 12:15

Vous avez une idée de jeu vidéo et souhaitez la concrétiser ? Ou vous êtes-vous déjà demandé comment les jeux informatiques sont écrits ? Ce wikiHow vous apprend à écrire trois jeux informatiques de base en Python. Vous aurez besoin d'une compréhension de base de Python et des concepts de programmation généraux pour développer votre premier jeu.

Pas

Partie 1 sur 3: Créer un jeu basé sur du texte

Étape 1. Choisissez un langage de programmation

Tous les langages de programmation sont différents, vous devrez donc décider lequel utiliser pour écrire votre jeu. Chaque langage de programmation majeur prend en charge la saisie de texte, la sortie de texte et les constructions if (les principales choses dont vous avez besoin pour un jeu textuel simple), alors explorez les options et décidez avec laquelle vous vous sentez le plus à l'aise et dédié à l'apprentissage. Voici quelques facteurs à considérer:

A quoi sert la langue le plus souvent ?

Certains langages de programmation, comme JavaScript, sont conçus pour être utilisés pour le Web, tandis que d'autres, comme Python, C ou C++, sont conçus pour exécuter des programmes informatiques. Pour votre jeu, visez un langage avec une gamme d'utilisation plus large, comme Python, C, C++ ou JavaScript.
Est-ce difficile d'apprendre ?

Bien que l'écriture d'un programme devrait être assez facile après une certaine pratique dans n'importe quel langage de programmation normal (c'est-à-dire pas un langage spécifiquement conçu pour être déroutant comme Malbolge), certains sont plus conviviaux pour les débutants que d'autres. Java et C, par exemple, vous demanderont de comprendre des concepts de programmation plus approfondis que quelque chose comme Python, qui est connu pour sa syntaxe plus accessible et plus simple.
Où puis-je l'utiliser ?

Vous voulez probablement que les gens sur différents systèmes, tels que Linux, Mac ou Windows, puissent tous jouer à votre jeu. Vous ne devez donc pas utiliser un langage qui n'est pris en charge que sur quelques systèmes, comme Visual Basic, qui n'est pris en charge que sous Windows.

Cet article utilisera Python pour les exemples d'un jeu basé sur du texte, mais vous pouvez rechercher comment les concepts sont élaborés dans n'importe quel autre langage de programmation.

Étape 2. Préparez votre ordinateur

Les deux principaux composants dont vous aurez besoin sont un éditeur de texte, dans lequel vous écrirez votre code, et un compilateur, que vous utiliserez pour le transformer en jeu. Si vous souhaitez suivre l'exemple de cet article, vous devez installer Python et apprendre à exécuter des programmes. Si vous le souhaitez, vous pouvez configurer un IDE (Integraded Desktop Environment), qui combine l'édition, la compilation et le débogage dans un seul programme. L'IDE de Python s'appelle IDLE. Mais vous pouvez également utiliser n'importe quel éditeur de texte prenant en charge le texte brut, tel que le Bloc-notes pour Windows, TextEdit pour macOS ou Vim pour Linux.

Étape 3. Écrivez du code pour saluer le joueur

Le joueur voudra savoir ce qui se passe et ce qu'il doit faire, vous devez donc imprimer du texte pour lui.

Cela se fait avec la fonction print() en Python. Pour l'essayer, ouvrez un nouveau fichier avec l'extension.py, saisissez-y le code suivant, enregistrez-le et exécutez-le:
```
print("Bienvenue dans le jeu de devinettes !") print("Entrez un nombre entier entre 1 et 1000:")
```

Étape 4. Générez un nombre aléatoire

Créons un jeu textuel qui demande au joueur de deviner le bon nombre. La première chose que nous devrons faire est de générer un nombre aléatoire au début du jeu afin que le joueur ne devine pas toujours le même nombre. Étant donné que le nombre restera le même tout au long du programme, vous voudrez stocker le nombre aléatoire dans une variable.

Python n'a pas de fonction de nombre aléatoire intégrée, mais il a une bibliothèque standard (cela signifie que l'utilisateur n'aura rien à installer en plus) qui le fait. Allez donc au début de votre code (avant les fonctions print()) et tapez la ligne import random.
Utilisez la fonction aléatoire. Il s'appelle randint(), se trouve dans la bibliothèque aléatoire que vous venez d'importer, et prend la valeur minimale et maximale que le nombre peut avoir comme argument. Revenez donc à la fin de votre code et entrez la ligne suivante:
```
rightNum = random.randint(0, 1000)
```

Étape 5. Obtenez l'entrée du joueur

Dans un jeu, le joueur veut faire quelque chose ou interagir avec quelque chose. Dans un jeu basé sur du texte, cela est possible en saisissant du texte. Maintenant que nous avons un nombre aléatoire, nos prochaines lignes de code devraient demander au joueur de saisir sa meilleure estimation.

Étant donné que le code que vous avez entré imprime l'instruction d'entrer un numéro au joueur, il doit également lire le numéro qu'il a entré. Cela se fait avec input() dans Python 3 et raw_input() dans Python 2. Vous devriez écrire en Python 3, car Python 2 deviendra bientôt obsolète. Ajoutez la ligne suivante à votre code pour stocker l'entrée du joueur dans une variable appelée numéro:
```
userNum = input()
```

Étape 6. Transformez l'entrée du lecteur en un type de données utilisable

Le joueur a entré un numéro, et maintenant ?

Donnez un nombre à l'entrée du joueur. Maintenant, cela peut sembler déroutant car ils viennent d'entrer un numéro. Mais il y a une bonne raison: Python suppose que toutes les entrées sont du texte, ou une "chaîne", comme on l'appelle en programmation. Ce texte contient le numéro que vous souhaitez obtenir. Python a une fonction qui convertit une chaîne qui ne contient qu'un nombre en nombre à l'intérieur. Taper:
```
userNum = int(userNum)
```

Étape 7. Comparez le numéro du joueur au numéro correct

Une fois que le joueur a entré son numéro, vous devrez le comparer à celui qui a été généré aléatoirement. Si les numéros ne sont pas les mêmes, votre jeu peut obliger le joueur à essayer un autre numéro. Si les chiffres correspondent, vous pouvez dire au joueur qu'il a deviné correctement et quitter le programme. Cela se fait avec le code suivant:

tandis que userNum != rightNum: userNum = int(input())

Étape 8. Donnez votre avis au joueur

Bien que vous ayez déjà traité leur entrée, le joueur ne le verra pas. Vous devrez réellement imprimer les résultats au joueur afin qu'il comprenne ce qui se passe.

Vous pourriez sûrement dire au joueur si son numéro est bon ou mauvais. Mais avec cette approche, le joueur pourrait avoir à deviner 1000 fois dans le pire des cas, ce qui serait très ennuyeux.
Dites donc au joueur si son nombre est trop petit ou trop grand. Cela réduira considérablement leur nombre de suppositions. Si, par exemple, le joueur devine 500 en premier et que le jeu répond "Trop gros. Réessayez", il n'y aura que 500 nombres possibles au lieu de 1000. Ceci est fait avec des constructions if, alors remplacez print("Mauvais. Essayez à nouveau.") avec un.
Sachez que vérifier si deux nombres sont identiques se fait avec ==, pas avec =. = affecte la valeur à droite de celui-ci à la variable à gauche de celui-ci !

if userNum < rightNum: print("Trop petit. Essayez à nouveau:") if userNum > rightNum: print("Trop gros. Essayez encore:")

Étape 9. Testez votre code

En tant que programmeur, vous devez être sûr que votre code fonctionne avant de le considérer comme terminé.

Lors de la programmation en python, assurez-vous que les indentations sont correctes. Votre code devrait ressembler à ceci:

import random print("Bienvenue dans le jeu de devinettes !") print("Entrez un nombre entier entre 1 et 1000:") rightNum = random.randint(0, 1000) userNum = input() userNum = int(userNum) while userNum != rightNum: if userNum < rightNum: print("Trop petit. Essayez à nouveau:") if userNum > rightNum: print("Trop gros. Essayez à nouveau:") userNum = int(input()) print("Vous avez deviné correctement.")

Étape 10. Validez la saisie

Le joueur ne devrait pas être en mesure de casser votre jeu en entrant simplement la mauvaise chose. "Valider la saisie" signifie s'assurer que le joueur a saisi la bonne chose avant de la traiter.

Ouvrez à nouveau le jeu et essayez d'entrer tout ce qui n'est pas un nombre. Le jeu se terminera avec une ValueError. Pour éviter cela, vous pouvez implémenter un moyen de vérifier si l'entrée était un nombre.
Définir une fonction. Étant donné que la validation de l'entrée est assez longue et que vous devez le faire plusieurs fois, vous devez définir une fonction. Il ne prendra aucun argument et retournera un nombre. Tout d'abord, écrivez def numInput(): en haut de votre code, directement sous l'import random.
Obtenez l'entrée du joueur une fois. Utilisez la fonction input() et affectez le résultat à la variable inp.
Lorsque l'entrée du joueur n'est pas un nombre, demandez-lui d'entrer un nombre. Pour vérifier si une chaîne est un nombre, utilisez les fonctions isdigit(), qui n'autorisent qu'un nombre entier, vous n'aurez donc pas à vérifier cela séparément.
Si l'entrée est un nombre, convertissez-le de chaîne en nombre et renvoyez le résultat. Utilisez la fonction int() pour convertir la chaîne en un entier. Cela rendra la conversion dans le code principal inutile, et vous devez la supprimer à partir de là.
Remplacez tous les appels à input() dans le code principal par des appels à numInput().
Le code de la fonction numInput() ressemblera à ceci:

def numInput(): inp = input() sans inp.isdigit(): print("On vous a dit d'entrer un nombre entier ! Entrez un nombre entier:") inp = input() return int(inp)

Étape 11. Testez à nouveau le jeu

Entrez volontairement les mauvaises choses pour voir ce qui se passe, puis corrigez les erreurs au fur et à mesure qu'elles surviennent.

Essayez de saisir du texte lorsque le programme vous demande un numéro. Maintenant, au lieu de quitter avec un message d'erreur, le programme vous demandera à nouveau un numéro

Étape 12. Suggérez de redémarrer le jeu à la fin

De cette façon, le joueur pourrait jouer à votre jeu plus longtemps sans avoir à le redémarrer constamment.

Mettez tout le code à l'exception de l'importation et de la définition de la fonction dans une boucle while. Définissez True comme condition: ce sera toujours vrai, donc la boucle continuera indéfiniment.
Demandez au joueur s'il veut rejouer après avoir deviné le numéro correctement. Utilisez la fonction print().
S'ils répondent "Non", sortez du regard. S'ils répondent à autre chose, continuez. La sortie d'une boucle se fait avec l'instruction break.
Déplacez le "Bienvenue dans le jeu de devinettes" en dehors de la boucle while. Le joueur ne veut probablement pas être accueilli à chaque fois qu'il joue au jeu. Déplacez l'instruction print("Bienvenue dans le jeu de devinettes !" au-dessus de la valeur while True:, elle ne sera donc imprimée qu'une seule fois, lorsque l'utilisateur commencera le premier jeu.

Étape 13. Testez le jeu

Vous devrez tester votre jeu à chaque fois que vous implémenterez une nouvelle fonctionnalité.

Assurez-vous de répondre à la fois « Oui » et « Non » au moins une fois pour vous assurer que les deux options fonctionnent. Voici à quoi devrait ressembler votre code:

import random def numInput(): inp = input() sans inp.isdigit(): print("On vous a dit d'entrer un nombre entier ! Entrez un nombre entier:") inp = input() return int(inp) print ("Bienvenue dans le jeu de devinettes !") while True: print("Entrez un nombre entier entre 1 et 1000:") rightNum = random.randint(0, 1000) userNum = numInput() while userNum != rightNum: if userNum < rightNum: print("Trop petit. Essayez à nouveau:") if userNum > rightNum: print("Trop gros. Essayez à nouveau:") userNum = numInput() print("Vous avez deviné correctement.") print("Avez-vous voulez jouer à nouveau? Entrez Non pour quitter.") if input() == "No": pause

Étape 14. Écrivez d'autres jeux textuels

Que diriez-vous d'écrire une aventure textuelle ensuite ? Ou un jeu-questionnaire ? Sois créatif.

Conseil: Il est parfois utile de consulter la documentation si vous n'êtes pas sûr de la façon dont quelque chose est fait ou de la façon dont une fonction est utilisée. La documentation Python 3 se trouve sur https://docs.python.org/3/. Parfois, rechercher ce que vous voulez faire sur Internet donne également de bons résultats.

Partie 2 sur 3: Créer un jeu avec des graphiques 2D

Étape 1. Choisissez une bibliothèque graphique

La création de graphiques est très compliquée et la plupart des langages de programmation (y compris Python, C++, C, JavaScript) ne fournissent qu'une prise en charge minimale, voire inexistante, des graphiques dans le noyau ou les bibliothèques standard. Vous devrez donc utiliser une bibliothèque externe pour pouvoir faire des graphiques, par exemple Pygame pour Python.

Même avec une bibliothèque graphique, vous devrez vous soucier de choses comme comment afficher un menu, comment vérifier sur quoi le joueur a cliqué, comment afficher les tuiles, etc. Si vous préférez vous concentrer sur le développement du jeu réel, vous pouvez utiliser une bibliothèque de moteur de jeu comme Unity, qui implémente facilement ces choses

Cet article utilisera Python avec Cocos2D pour montrer comment créer un jeu de plateforme 2D simple. Certains des concepts mentionnés peuvent ne pas exister dans d'autres moteurs de jeu. Reportez-vous à leur documentation pour plus d'informations.

Étape 2. Installez la bibliothèque graphique que vous avez choisie

Cocos2D pour Python est facile à installer. Vous pouvez l'obtenir à partir de https://python.cocos2d.org/index.html, ou en exécutant sudo pip3 install cocos2d si vous utilisez Linux.

Étape 3. Créez un nouveau répertoire pour votre jeu et vos médias

Vous utiliserez des éléments tels que des images et des sons dans votre jeu. Gardez ces éléments dans le même répertoire que le programme. Ce répertoire ne doit rien contenir d'autre afin que vous puissiez facilement voir quels actifs vous avez dans le jeu.

Étape 4. Créez un nouveau fichier de code dans le nouveau répertoire

Appelez-le main, avec l'extension de fichier pour votre langage de programmation. Si vous écrivez un programme volumineux et complexe où il est logique d'avoir plusieurs fichiers de programme, cela vous montrera quel est le fichier principal.

Dans cet exemple, nous allons créer un fichier appelé main.py qui contiendra tout notre code

Étape 5. Créez la fenêtre de jeu

C'est le prérequis de base pour un jeu avec des graphismes.

Importez les sous-modules cocos2d nécessaires: cocos.director, cocos.scene et cocos.layer. Cela se fait avec from subModuleName import *, où sub-Module name est le sous-module que vous souhaitez importer. La différence entre from … import * et import … est que vous n'avez pas besoin de mettre le nom du module devant tout ce que vous utilisez à partir de ce module avec le premier.
Définissez une sous-classe MainMenuBgr de ColorLayer. Cela signifie essentiellement que tout arrière-plan du menu principal que vous créez se comportera comme un calque de couleur avec quelques modifications que vous apporterez.
Démarrez le directeur des cocos. Cela vous donnera une nouvelle fenêtre. Si vous ne définissez pas de légende, la fenêtre aura la même légende que le nom du fichier (main.py), ce qui n'aura pas l'air professionnel. Autorisez le redimensionnement de la fenêtre en définissant redimensionnable sur True.
Définissez une fonction showMainMenu. Vous devez mettre le code pour afficher le menu principal dans une fonction car cela vous permettra de revenir facilement au menu principal en appelant à nouveau la fonction.
Créer une scène. La scène se compose pour l'instant d'une couche, qui est un objet de la classe MainMenuBgr que vous avez définie.
Exécutez cette scène dans la fenêtre.

de cocos.director import * de cocos.scene import * de cocos.layer import * class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenu, self)._init_(0, 200, 255, 255) def showMainMenu(): menuSc = Scene(MainMenuBgr()) director.run(menuSc) director.init(caption="IcyPlat - un simple jeu de plateforme", resizable=True) showMainMenu()

Étape 6. Ajoutez un menu principal à la fenêtre

Outre le jeu lui-même, vous devrez ajouter un menu que le joueur pourra utiliser pour fermer la fenêtre, parmi d'autres éléments que vous pourrez ajouter plus tard.

Importez cocos.menu (toujours avec l'instruction from) et pyglet.app (cette fois avec import).
Définissez MainMenu comme une sous-classe de Menu.
Réglez l'alignement du menu principal. Vous devez définir l'alignement vertical et horizontal séparément.
Créez une liste d'éléments de menu et ajoutez-les au menu. Vous devriez avoir au moins les éléments de menu "Démarrer le jeu" et "Quitter". Chaque élément de menu doit être placé entre parenthèses. Chaque élément doit avoir une étiquette et une fonction de rappel qui détermine ce qui se passe lorsque le joueur clique dessus. Pour l'élément "Start Game", utilisez la fonction startGame (vous l'écrirez bientôt), pour l'élément "Quit", utilisez "pyglet.app.exit" (existe déjà). Créez le menu réel en appelant self.create_menu(menuItems).
Définissez startGame(). Mettez simplement pass dans la définition pour le moment, vous le remplacerez lorsque vous écrivez le jeu réel.
Allez à l'endroit dans votre code où vous avez créé la scène menuSc et ajoutez-y un objet MainMenu.

Votre code entier devrait maintenant ressembler à ceci:

de cocos.director import * de cocos.menu import * de cocos.scene import * de cocos.layer import * import pyglet.app class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem("Démarrer le jeu ", startGame)), (MenuItem("Quitter", pyglet.app.exit))] self.create_menu(menuItems) def startGame(): pass def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu()) director.run(menuSc) director.init(caption="IcyPlat - un simple jeu de plateforme", resizable=True) showMainMenu()

Étape 7. Testez votre code

Testez le code tôt, alors qu'il est encore court et relativement simple. Ensuite, vous pouvez identifier et corriger toute erreur dans la structure de base avant que les choses ne deviennent trop compliquées.

Le code des instructions devrait ouvrir une fenêtre intitulée "IcyPlat - a simple platformer". L'arrière-plan est bleu clair et vous pouvez redimensionner la fenêtre. Lorsque vous cliquez sur "Démarrer le jeu" dans le menu, rien ne devrait (encore) se passer. Lorsque vous cliquez sur "Quitter", la fenêtre se ferme

Étape 8. Créez un sprite

Un sprite est un "objet de jeu" ou une image en 2 dimensions. Les sprites peuvent être des objets du jeu, des icônes, des décorations d'arrière-plan, des personnages et tout ce que vous pouvez représenter avec une image dans le jeu. Nous allons commencer par créer un sprite pour un personnage avec lequel le joueur peut interagir.

Importez le sous-module cocos.sprite avec l'expression from-import.
Trouvez une image pour représenter le sprite. Vous ne pouvez pas afficher un sprite si vous n'avez pas d'image pour lui. Vous pouvez en dessiner un, ou vous pouvez en obtenir un sur Internet (attention aux licences, cependant, si vous envisagez de publier votre jeu). Pour cet exemple, rendez-vous sur https://opengameart.org/content/tux-classic-hero-style et enregistrez l'image-p.webp" />
Créez un calque en tant que nouvel objet de la classe ScrollableLayer. Ensuite, créez le sprite en tant qu'objet Sprite et définissez sa position sur (8, 250). Pour référence, le point (0, 0) est dans le coin inférieur gauche. C'est assez élevé, mais cela fera en sorte que le pingouin ne reste pas coincé dans la glace.
Ajoutez le sprite au calque du sprite.
Créez une nouvelle scène à partir du calque du sprite et exécutez-la.

def startGame(): figLayer = ScrollableLayer() fig = Sprite('pingu.png') fig.position = (75, 100) figLayer.add(fig) # gameSc = Scene(figLayer) director.run(gameSc)

Exécutez le code. Vous devriez voir une petite figure de pingouin (ou tout ce que vous avez dessiné) sur un fond noir après avoir cliqué Démarrer jeu.

Étape 9. Imaginez votre paysage

Dans la plupart des jeux, vos sprites ne devraient pas simplement flotter dans le vide. Ils devraient en fait se tenir sur une surface, avec quelque chose autour d'eux. Dans les jeux 2D, cela se fait souvent avec un jeu de tuiles et une carte de tuiles. L'ensemble de tuiles indique essentiellement quel type de carrés de surface et de carrés d'arrière-plan existent et à quoi ils ressemblent.

Créez un ensemble de tuiles. L'ensemble de tuiles pour ce jeu sera très basique: une tuile pour la glace et une tuile pour le ciel. La tuile de glace utilisée dans cet exemple provient d'ici, sous CC-BY-SA 3.0.
Créez une image de jeu de tuiles. C'est une image de toutes les tuiles, qui doivent toutes être de la même taille (éditez-les si elles ne le sont pas) et avoir la taille que vous voulez voir dans le jeu, les unes à côté des autres. Enregistrez votre image sous le nom icyTiles.png.
Créez la description du jeu de tuiles. C'est un fichier XML. Le fichier XML contient des informations sur la taille des tuiles dans l'image de l'ensemble de tuiles, quelle image utiliser et où trouver quelle tuile là-bas. Créez un fichier XML nommé icyTiles.xml avec le code ci-dessous:
```
     
```

Étape 10. Créez une carte en mosaïque pour votre paysage

Une carte de tuiles est une carte qui définit quelle tuile est à quelle position dans votre niveau. Dans l'exemple, vous devez définir une fonction pour générer des cartes de tuiles car la conception de cartes de tuiles à la main est très fastidieuse. Un jeu plus avancé aurait généralement une sorte d'éditeur de niveau, mais pour se familiariser avec le développement de jeux 2D, un algorithme peut fournir des niveaux suffisamment bons.

Découvrez combien de lignes et de colonnes sont nécessaires. Pour cela, divisez la taille de l'écran par la taille de la tuile à la fois horizontalement (colonnes) et verticalement (lignes). Arrondissez le nombre vers le haut; vous avez besoin d'une fonction du module mathématique pour cela, alors ajoutez du ceil d'importation mathématique aux importations en haut de votre code.
Ouvrez un fichier en écriture. Cela effacera tout le contenu précédent du fichier, alors choisissez un nom qu'aucun fichier du répertoire n'a encore, comme levelMap.xml.
Écrivez les balises d'ouverture dans le fichier.
Générez une carte de tuiles selon l'algorithme. Vous utilisez celui dans le code ci-dessous, ou vous pouvez en créer un vous-même. Assurez-vous d'importer la fonction randint du module random: elle est nécessaire pour que le code ci-dessous fonctionne, et tout ce que vous proposerez aura probablement aussi besoin d'entiers aléatoires. Assurez-vous également de mettre des tuiles ciel et des tuiles glace en différentes couches: la glace est solide, le ciel ne l'est pas.
Écrivez les balises de fermeture dans le fichier et fermez le fichier.

def generateTilemap(): colAmount = ceil(800/16)*3 # (largeur de l'écran / taille de la tuile) * 3 rowAmount = ceil(600/16) # hauteur de l'écran / taille de la tuile tileFile = open("levelMap.xml", " w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) for i in range(0, colAmount): tileFile.write('') makeHole = False si randint(0, 50) == 10 et i != 0: # n'autorise pas les trous au point d'apparition makeHole = True for j in range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # empêche les tuiles d'aller trop bas iceHeight = randint(1, 5) if iceHeight > rowAmount: # limite les tuiles d'aller trop haut iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n') tileFile.write ('\n\n') for i in range(0, colAmount): tileFile.write('') for j in range(0, rowAmount): tileFile.write('\n') tileFile.write('\ n') tileFile.write('\n\n') tileFile.close()

Étape 11. Affichez la carte des tuiles

Importez tout de cocos.tiles puis allez dans la fonction startGame pour cela.

Au début de votre fonction startGame, générez une carte de tuiles en utilisant la fonction que vous avez définie pour cela.
Créez un nouveau gestionnaire de défilement. Faites-le directement sous la ligne où vous ajoutez le sprite à son calque.
Créez une nouvelle couche contenant les tuiles, qui seront chargées à partir de la carte de tuiles levelMap.xml générée par votre fonction generateTilemap.
Ajoutez le calque non solide, le calque solide et le calque sprite au gestionnaire de défilement, exactement dans cet ordre. Vous pouvez ajouter une position z si vous le souhaitez.
Au lieu de créer la scène à partir du calque de sprite, créez-la à partir du gestionnaire de défilement.

Votre fonction startGame devrait maintenant ressembler à ceci:

def startGame(): generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z =1) # gameSc = Scene(scrMang) director.run(gameSc)

Étape 12. Testez votre code

Vous devriez tester votre code souvent pour vous assurer que les nouvelles fonctionnalités que vous avez implémentées fonctionnent vraiment.

Le code de l'exemple devrait maintenant montrer un paysage glacé derrière le pingouin. Si le pingouin semble planer loin au-dessus de la glace, vous n'avez rien fait de mal et cela sera corrigé à l'étape suivante

Étape 13. Ajoutez les contrôles

Le joueur a beaucoup plus de façons d'interagir avec le programme dans un jeu en 2D que dans un jeu basé sur du texte. Une règle courante consiste à déplacer leur silhouette lorsque la bonne touche est enfoncée.

Importez tout de cocos.mapcolliders et de cocos.actions. Importez également la clé de pyglet.window.
"Déclarer" certaines variables globales. Les variables globales sont partagées entre les fonctions. Vous ne pouvez pas vraiment déclarer de variables en Python, mais vous devez dire qu'une variable globale existe dans le code principal avant de l'utiliser. Vous pouvez attribuer 0 comme valeur car une fonction s'occupera d'attribuer la valeur correcte plus tard. Ajoutez donc sous les expressions d'importation:
```
# "déclarer" les variables globales clavier = 0 scrMang = 0
```

Ajustez votre fonction startGame:

Disons que vous utilisez les variables globales keyboard et scrMang. Pour ce faire, écrivez le clavier global, scrMang en haut de la fonction.
Faites en sorte que la fenêtre écoute les événements du clavier.
Dites au personnage d'agir en fonction d'un PlatformerController. Vous allez bientôt implémenter ce PlatformerController.
Créez un collisionneur de carte pour gérer les collisions entre les tuiles pleines et la figure.

def startGame(): clavier global, scrMang generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # keyboard = key. KeyStateHandler() director.window.push_handlers(keyboard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump ='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z= 1) # gameSc = Scene(scrMang) director.run(gameSc)

Créez un contrôleur de plateforme. C'est ce qui va déplacer la figure en fonction de vos pressions sur les touches.
- Définissez le contrôleur de plate-forme comme une sous-classe d'Action.
- Définissez la vitesse de déplacement, la vitesse de saut et la gravité.
- Définir la fonction de démarrage. Cette fonction est appelée une fois, lorsque le contrôleur de plateforme est connecté à la figure. Il doit régler sa vitesse à 0 à la fois dans la direction x et dans la direction y.
- Définir la fonction de pas. Il sera répété pendant l'exécution de la scène.
- Dites à la fonction step d'utiliser les variables globales keyboard et scrMang.
- Obtenez et modifiez la vitesse. Enregistrez la vitesse x et y dans des variables distinctes. Réglez la vélocité x sur 1 ou -1 (selon que la touche gauche ou droite a été enfoncée) multipliée par la vitesse de déplacement. Ajoutez la gravité à la vitesse y. Multipliez-le par le temps d'arrêt pour qu'il fonctionne de la même manière sur les appareils plus lents. Si la touche espace est enfoncée et que le personnage se tient au sol, sautez en changeant la vitesse y en vitesse de saut.
- Calculez jusqu'où la figure doit se déplacer. Laissez ensuite le gestionnaire de collision ajuster cette position si elle se trouve à l'intérieur d'un carreau solide. Enfin, déplacez la figure vers la nouvelle position ajustée.
- Placez le focus du gestionnaire de défilement sur la figure. Cela fait que la caméra se déplace de manière raisonnable lorsque le personnage bouge.
```
class PlatformerController(Action): clavier global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start(self): self.target.velocity = (0, 0) def step(self, dt): clavier global, scroller if dt > 0.1: # ne faites rien pendant le temps d'arrêt vers un grand retour vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard[key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt si self.on_ground et clavier[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y += dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(*new.center)
```

Étape 14. Testez votre code

Si vous avez suivi l'exemple, vous devriez maintenant pouvoir déplacer le pingouin avec les touches fléchées et sauter en appuyant sur la barre d'espace. De plus, le pingouin devrait maintenant tomber au lieu de planer au-dessus du sol.

Étape 15. Créez une fin pour le jeu

Même les jeux qui peuvent durer indéfiniment devraient avoir la possibilité de perdre. Puisque le niveau que vous avez fait dans l'exemple avec une fonction a une fin, vous devrez également permettre de gagner en venant à cette fin. Sinon, le joueur ne ferait que sauter sur les blocs de glace, ce qui deviendrait ennuyeux.

À l'intérieur du contrôleur de plate-forme, après la mise au point, obtenez les positions x et y de la figure. Si la position y est inférieure à 0, appelez la fonction finishGame() (vous l'écrirez plus tard) avec "Game Over" comme argument. Si la position x est plus grande que la taille de l'écran multipliée par 3 (vous l'aviez déjà définie comme taille de niveau).
```
posX, posY = self.target.position if posY < 0: finishGame("Game Over") return if posX > 800*3: # level size finishGame("Level Completed") return
```
Définissez une classe finishMenu. Cela devrait être comme la classe du menu principal que vous avez définie auparavant, mais au lieu d'avoir une chaîne vide comme titre, il devrait utiliser un texte variable que la fonction _init_ prend comme argument. Les éléments de menu doivent être étiquetés "Réessayer" et "Quitter" maintenant, mais les fonctions qu'ils appellent restent les mêmes.
```
class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Essayer à nouveau", startGame)), (MenuItem("Quitter", pyglet.app.exit))] self.create_menu(menuItems)
```
Définissez la fonction finishGame(). Il doit prendre le texte comme argument. Il devrait faire une scène à partir de l'arrière-plan du menu principal, un FinishMenu avec l'argument texte transmis à ce menu. Ensuite, il devrait exécuter cette scène.
```
def finishGame(text): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text)) director.run(menuSc)
```

Étape 16. Ajoutez des crédits

C'est là que vous obtenez le mérite de votre code génial, ainsi que de toute autre personne qui vous a aidé en cours de route. Si vous avez utilisé une image d'un autre site Web (avec autorisation), assurez-vous d'attribuer cette image à son créateur.

Créez un fichier CREDITS et saisissez-y tous vos crédits, comme ceci:

Pingouin: Kelvin Shadewing, sous CC0 Bloc de glace: Michał Banas digit1024 sur opengameart.org sous CC-BY-SA 3.0

Revenez à votre code Python et importez Label depuis cocos.text.

Définir une sous-classe Crédits de Couche. Dans sa fonction _init_, lisez le fichier CREDITS et créez une étiquette de texte à la bonne position sur chaque ligne de celui-ci.

class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n ") pour i dans la plage (0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i +1)*40 self.add(credLabel)

Accédez à votre classe de menu principal et ajoutez un élément de menu intitulé "Crédits" qui appelle la fonction showCredits lorsque vous cliquez dessus.
Définissez une sous-classe BackToMainMenuButton de Menu. Faites-en un menu avec un élément, intitulé "Retour", qui appelle la fonction showMainMenu. Ce "menu", qui ressemble plus à un bouton, doit être aligné verticalement vers le bas et horizontalement vers le haut.
```
class BackToMainMenuButton(Menu): def _init_(self): super(BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self. create_menu(menuItems)
```
Définissez la fonction showCredits. Il devrait créer une scène à partir d'une couche MainMenuBgr et d'une couche Credits et exécuter cette scène.
```
def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton()) director.run(credSc)
```

Étape 17. Vérifiez votre code

Lorsque vous pensez que vous avez terminé votre code, vous devriez le revoir en entier. Cela peut vous aider à remarquer si quelque chose peut être optimisé ou s'il y a des lignes inutiles que vous avez oublié de supprimer. Si vous avez suivi l'exemple, votre code entier devrait maintenant ressembler à ceci:

de cocos.director import * de cocos.menu import * de cocos.scene import * de cocos.layer import * de cocos.sprite import * de cocos.tiles import * de cocos.mapcolliders import * de cocos.actions import * de cocos.text import Label import pyglet.app depuis pyglet.window import key from math import ceil from random import randint # "déclarant" les variables globales keyboard = 0 scrMang = 0 class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem("Start Game", startGame)), (MenuItem("Credits", showCredits)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n") pour i dans la plage (0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i+1)*40 self.add(credLabel) classe BackToMainMenuButton(Menu): def _init_(self): super (BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self.create_menu(menuItems) class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTRE self.menu_halign = CENTRE menuItems = [(MenuItem("Essayer à nouveau", startGame)), (MenuItem("Quitter", pyglet. app.exit))] self.create_menu(menuItems) class PlatformerController(Action): clavier global, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start(self): self.target.velocity = (0, 0) def step(self, dt): clavier global, scroller si dt > 0.1: # ne rien faire pendant le temps d'arrêt trop grand return vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - clavier [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt si self.on _ground et clavier[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(* new.center) posX, posY = self.target.position if posY < 0: finishGame("Game Over") return if posX > 800*3: # level size finishGame("Level Completed") return def finishGame(text): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text)) director.run(menuSc) def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton()) director.run(credSc) def generateTilemap(): colAmount = ceil(800/16)*3 # (largeur de l'écran/taille de la tuile) * 3 rowAmount = ceil(600/16) # hauteur de l'écran/taille de la tuile tileFile = open ("levelMap.xml", "w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) for i in range(0, colAmount): tileFile.write('') makeHole = Faux si rand int(0, 50) == 10 and i != 0: # n'autorise pas les trous au point de spawn makeHole = True for j in range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # limite les tuiles d'aller aussi low iceHeight = randint(1, 5) if iceHeight > rowAmount: # limite les tuiles d'aller trop haut iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n ') tileFile.write('\n\n') for i in range(0, colAmount): tileFile.write('') for j in range(0, rowAmount): tileFile.write('\n') tileFile.write('\n') tileFile.write('\n\n') tileFile.close() def startGame(): clavier global, scrMang generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers(keybo ard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scr add(solidTiles, z=0) scrMang.add(figLayer, z=1) # gameSc = Scene(scrMang) director.run(gameSc) def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu()) director.run(menuSc) window = director.init(caption="IcyPlat - un simple platformer", resizable=True) showMainMenu()

Cela fait 168 lignes au total, et 152 lignes si vous ne comptez que le code. Cela semble beaucoup, mais pour un jeu aussi complexe, c'est en fait une petite quantité.

Étape 18. Terminé

Testez maintenant le jeu. Lorsque vous programmez quelque chose, vous devez vérifier si cela fonctionne chaque fois que vous avez implémenté quelque chose de nouveau. De plus, vous aimeriez peut-être jouer au jeu que vous avez écrit pendant un certain temps.

Partie 3 sur 3: Publier un jeu

Étape 1. Notez les dépendances

Quiconque utilise un autre ordinateur n'aura pas les mêmes logiciels et bibliothèques installés que vous. Vous devrez donc vous assurer que tous ceux qui installe votre jeu savent exactement ce dont ils auront besoin pour l'exécuter. Vous n'êtes pas obligé d'écrire toutes les dépendances de toutes les dépendances de toutes les dépendances et ainsi de suite, mais vous devez au moins écrire les dépendances de vos packages et leurs dépendances.

Étape 2. Assurez-vous d'avoir la permission d'utiliser tous les médias

Cela s'applique à tous les graphiques, y compris les modèles 3D, la musique, les dialogues, la musique, les bibliothèques et les frameworks que vous avez utilisés pour votre jeu. Tout ce que vous n'avez pas écrit vous-même.

Souvent, il y a certaines conditions, comme devoir créditer l'auteur ou partager des modifications du média sous la même licence. Parfois, vous pourrez utiliser des graphiques sans attribuer les créateurs tant que vous ne facturez pas le jeu. Si vous devez créditer l'auteur, faites-le dans un endroit bien visible, comme un onglet "Crédits" dans votre jeu.
Il existe également des supports avec droits d'auteur revendiqués et sans licence spécifiée, parfois avec un texte comme "Tous droits réservés". Si tel est le cas, vous devez obtenir l'autorisation explicite de l'auteur avant de l'inclure dans votre jeu.
Les bibliothèques sont généralement publiées sous des licences qui leur permettent d'être utilisées comme bibliothèque. Une exception notable est la GPL sans exception de liaison: une telle licence ne permet de l'utiliser que dans un programme avec certaines licences. Et vous devriez toujours lire au moins les points de base de la licence pour vous assurer que tout ce que vous faites avec le média ou la bibliothèque est autorisé.

Avertissement: L'utilisation de médias ou de bibliothèques d'une manière que la licence ne permet pas dans un jeu que vous publiez peut vous causer de graves problèmes juridiques. Donc, demandez à l'auteur ou évitez complètement le média si vous n'êtes pas sûr que votre utilisation soit autorisée.

Étape 3. Décidez des conditions dans lesquelles vous souhaitez publier votre jeu

Vendrez-vous votre jeu ? Voulez-vous permettre aux autres d'utiliser vos images et vos idées ? Bien que vous deviez faire attention aux médias que vous utilisez dans votre projet, vous pouvez généralement décider de la manière dont vous souhaitez autoriser les autres à utiliser votre jeu. Vous pouvez utiliser une licence Creative Commons CC0 pour publier votre jeu dans le domaine public. Pour autoriser la distribution et la modification sous certaines conditions tout en conservant certains droits, essayez la licence publique générale Gnu (GPL) ou la licence Berkeley Software Distribution (BSD). Ou, vous pouvez rendre votre logiciel propriétaire, ce qui signifie que personne n'est autorisé à le distribuer ou à le modifier sans votre permission.

Bien qu'il soit possible de gagner de l'argent en vendant des jeux, il est peu probable que les gens achètent votre premier jeu qui a généralement peu de fonctionnalités et rien de spécial. De plus, si un programme gratuit ne fonctionne pas, les personnes qui l'ont téléchargé seront simplement déçues. S'ils ont payé pour cela, cependant, ils demanderont leur argent, ce qui causera plus de problèmes pour vous et les utilisateurs. Pensez donc à rendre vos premiers programmes disponibles gratuitement

Étape 4. Décidez comment vous souhaitez publier votre jeu

Chaque méthode a des avantages et des inconvénients, vous devez donc décider vous-même.

La publier sur un site Web:

Si vous avez un site Web, vous pouvez télécharger votre jeu pour le rendre disponible au téléchargement. Assurez-vous de fournir des instructions claires sur la façon d'installer le logiciel, ainsi que toutes les dépendances requises. L'inconvénient est que les joueurs devront installer les dépendances manuellement, ce qui peut être difficile pour certaines personnes.
Créer un package pour un gestionnaire de packages:

Il existe différents gestionnaires de packages, comme apt, Yum et Homebrew, qui permettent aux utilisateurs d'installer facilement des applications dans des environnements Linux et Linux. Ils ont tous des formats d'emballage différents. L'avantage des packages est qu'ils installent automatiquement toutes les dépendances (si vous les configurez correctement). Ainsi, le joueur n'a qu'à installer votre package et peut ensuite jouer au jeu. Le problème est qu'il existe de nombreux gestionnaires de packages différents sur différentes plates-formes, vous devrez donc vous efforcer de fournir des packages pour tous les plus courants.

Étape 5. Attirez l'attention sur votre programme

Envisagez de télécharger votre programme dans un référentiel de paquets majeur, comme ceux maintenus par Ubuntu et Debian, pour permettre des installations faciles. Publiez également sur des forums appropriés, comme la section projets de GameDev ou une partie de tigSource. Mais ne soyez pas déçu si vos premiers jeux ne deviennent pas célèbres. Si vous avez une idée que beaucoup de gens aiment, votre jeu peut devenir bien connu.

Des astuces

Soyez patient et prêt à apprendre. La programmation peut parfois être frustrante !
Si vous vous demandez comment quelque chose est fait dans un autre jeu et que le jeu est open source, vous pouvez regarder son code source.
Lorsque vous recherchez des médias, essayez de trouver du contenu qui appartient au domaine public. Recherchez des images et de la musique « Creative Commons » ou « Public Domain », et utilisez des sites Web comme https://opengameart.org ou
Ne copiez pas de gros morceaux de code sans vérifier la licence. Il est souvent interdit, et sinon, nécessite généralement une attribution.
Ne faites pas de spam ou ne publiez pas dans des endroits inappropriés lorsque vous faites la promotion de votre jeu. Cela risque de vous bloquer la page, est tout simplement ennuyeux et nuira à votre réputation.