[Linux] Mon fils dans un jeu vidéo (programmé avec la librairie SDL2)

Aujourd’hui je mets en ligne le début d’un petit jeu type Mario bros que j’ai commencé à programmer pour faire marrer mon gamin, parce que le Mario héro de mon jeu de plateforme en 2D … c’est lui !

Il faut dire que j’ai été bercé dans ma jeunesse par les jeux de plateforme en 2D et que j’adore ça. Je crois même pouvoir dire que ce sont mes jeux préférés. Je me souviens des heures passées à jouer aux jeux d’Apogée comme Vinyl goddess of Mars, Xargon, Bio menace, et autres Jack jazzrabbit.

A l’époque moderne, ces jeux de plateforme en 2D sont maintenant incarnés par la série des Mario bros donc je m’en suis inspiré puisque c’est la référence que mon gamin a.

Voilà à quoi ça ressemble une fois compilé (le personnage bouge au joystick. Le niveau se termine quand le personnage de mon fils a réussi à délivrer sa maman) :

La méthodologie de développement a été simple : j’ai d’abord photographié la figure de mon fils dans diverses positions, y compris avec un saladier sur la tête, puis j’ai dessiné des corps stylisés sous ces figures pour en faire des images destinées à être animées. L’animation du personnage principal n’avait donc plus qu’à être programmée en C.

Le saladier sur la tête, c’est un clin d’oeil. En effet, dans tout jeu de plateforme en 2D qui se respecte, le personnage principal se met à faire le con lorsqu’on ne joue plus depuis un petit moment. Ici il se met un saladier sur la tête, vous pourrez essayer si vous compilez ce jeu.

J’ai ensuite récupéré sur Internet quelque uns des sons originaux du jeu Mario bros, puis j’ai dessiné quelques tuiles comme on dit dans le monde des jeux de plateforme en 2D, à savoir des images destinées à être reproduites plusieurs fois à l’écran pour créer une surface pavée.

Une fois ces briques de base réunies, il a fallu créer un fichier décrivant intégralement le monde dans lequel le personnage évolue. Il s’agit d’un simple fichier texte (level001.dat) dans lequel j’ai défini une manière de décrire le niveau : quelle est la taille du niveau, d’où le personnage principal part, quels sont les endroits où il y a des tuiles, ces tuiles sont elles traversables ou non, ces tuiles sont elles à l’avant plan ou à l’arrière plan du personnage, etc.

Évidemment, le programme C qui va exploiter ce fichier va ensuite s’évertuer à faire apparaître à l’écran le monde tel qu’il est décrit dans ce fichier, et ce quel que soit l’endroit où l’on se trouve puisque le principe dans les jeux de plateforme en 2D, c’est que le monde est bien plus vaste que l’écran.

Pour réaliser le codage du jeu, j’ai opté pour du langage C s’appuyant sur la librairie graphique SDL2. SDL est une librairie graphique bien connue, performante, et permettant avec le même code source en C de créer un jeu Windows, Linux, ou même Mac.

Le jeu que je vous propose ici, on va le compiler sous Linux puisque c’est l’OS qui nous intéresse, mais il compile (en théorie, je n’ai pas essayé) aussi sous Windows et sur Mac.

Si vous compilez ce « jeu », vous vous rendrez vite compte qu’il est injouable. Il n’y a qu’un seul niveau qui est proposé, il est tout petit (plus grand que l’écran tout de même), et il n’y a aucun ennemi dans le niveau.

Pourtant tout y est, et c’est tout l’intérêt d’en partager le code source avec vous. Par tout y est, j’entends que toutes les techniques de base pour programmer un jeu sont là et récupérables pour qui veut apprendre à faire un jeu : comment on ouvre une fenêtre, comment on anime un sprite, comment on récupère les événements, comment on lit le joystick, etc.

Même la physique du personnage y est : il saute et retombe par la gravité, il monte aux échelles.

Tout cela tient dans un petit fichier C de 1100 lignes seulement.

En fait, par manque de temps, j’ai abandonné la programmation de ce jeu quand j’en suis arrivé à l’étape où il fallait que je mette des méchants dans mon monde. Là ça commençait à être difficile de programmer ça en dilettante ; les méchants il en a de plein de types dans ce genre de jeux : des qui volent, des qui marchent, des qui tirent, des qui ne tirent pas, des qui restent dans la même zone, des qui parcourent le niveau. Ça se complique très vite.

Le nombre de lignes de code pour animer des méchants peut vite exploser. J’ai renoncé, honte à moi.

Installation et compilation du jeu

Il faut au préalable installer la librairie SDL2. Sous Ubuntu 18.04, on tape :

sudo apt-get install libsdl2-dev libsdl2-gfx-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-net-dev libsdl2-ttf-dev libpng-dev

sudo cp /usr/lib/x86_64-linux-gnu/*.so /usr/lib

Pour compiler le jeu, il suffit d’aller dans le répertoire du jeu et de taper :

./compile

Utilisation de la librairie SDL

Faire un cours complet sur l’utilisation de SDL n’est pas possible dans le cadre d’un article. J’ai prévu d’écrire un bouquin sur le sujet bientôt. Il sera disponible sur Amazon comme tous mes bouquins.

Pour vous y retrouver dans le code, voici tout de même quelques tuyaux qui permettent de se repérer.

Tout d’abord, pour pouvoir utiliser la librairie SDL, on doit inclure les headers C correspondants :

#include <SDL2/SDL.h>

#include <SDL2/SDL_image.h>

#include <SDL2/SDL_ttf.h>

#include <SDL2/SDL_mixer.h>

Voici ensuite les fonctions SDL utilisées, et leur utilité dans le programme :

SDL_InitSubSystem(SDL_INIT_JOYSTICK); // Initialise les joysticks

SDL_NumJoysticks(); // Donne le nombre de joysticks détectés

SDL_JoystickOpen(0); // Ouvre le premier joystick

SDL_CreateWindow(“Eliot”,SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,SCREEN_WIDTH, SCREEN_HEIGHT,SDL_WINDOW_SHOWN);

SDL_CreateRenderer(screen, -1, SDL_RENDERER_PRESENTVSYNC); // Ouvre la fenêtre du jeu à l’écran

IMG_Init(IMG_INIT_PNG | IMG_INIT_JPG) ; // Initialise la gestion des images png et jpg

SDL_ShowCursor(SDL_DISABLE); // Désactive le curseur dans la fenêtre du jeu

TTF_Init() // Initialise les fontes

Mix_Init(MIX_INIT_MP3); // Initialise les sons mp3

Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024) ; // Initialise les fichiers wav

Mix_AllocateChannels(32); // Alloue 32 pistes pour le mixage des sons

IMG_Load(“./gfx/level1back.jpg”) ; // Charge le fichier jpg correspondant

SDL_CreateTextureFromSurface(getrenderer(), image); // Crée une texture à partir de l’image chargée

SDL_FreeSurface(image); // Efface en mémoire l’image chargée

Mix_LoadWAV(“sound/saut.wav”) ; // Charge un son wav en mémoire

SDL_QueryTexture(texture, NULL, NULL, &dest.w, &dest.h);

SDL_RenderCopy(getrenderer(), texture, NULL, &dest); // Affichage d’un sprite à l’écran

SDL_RenderPresent(getrenderer());

SDL_RenderClear(getrenderer()); // Envoi vers l’écran réelle de l’image préparée en mémoire

SDL_PollEvent(&event) ; // Lecture des événements

SDL_KEYDOWN // Événement touche appuyée

SDL_KEYUP // Événement touche relâchée

SDL_JOYBUTTONDOWN // Événement bouton de joystick appuyé

SDL_JOYAXISMOTION // Événement axe de joystick bougé

Mix_PlayChannel(-1,son_saut, 0); // Jouer un son wav

Fermeture propre de SDL :

Mix_CloseAudio();

Mix_Quit();

SDL_DestroyRenderer(renderer);

SDL_DestroyWindow(screen);

TTF_Quit();

SDL_Quit();

Avec ces quelques fonctions et un peu d’imagination, on fait un jeu multi-plateformes 🙂

Le fichier zip contenant le code source en C, les sons, les images et tout ce qu’il faut pour le compiler et le faire tourner est disponible ici.

Have fun !

Tagués avec : , , , , ,

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée.

Résoudre : *
24 ⁄ 8 =