Lolokai – Supervision, systèmes, réseaux, base de données…

0

Structure basique d’un jeu avec la SDL

Julien 23 mars 2012

Introduction

Dans cet article nous allons parler de la structure basique d’un jeu vidéo. Par basique, j’entends  le code de base qui serait utilisé à chaque fois que l’ont veut créer un jeu-vidéo utilisant la SDL.  L’EDI Eclipse permet de créer des templates de projets, qui peuvent fournir directement le code, le linkage automatique des librairies, et autres. Ce qui évite les fastidieuses recopies de code. La création de template étant une science en soit, je ne pourrais pas vous l’expliquer ici. Si vous êtes intéressez, je vous invite à regarder tout ça sur la documentation d’Eclipse qui est relativement bien écrite.

Modèle de classe

Nous allons commencer par réfléchir aux modèles de la classe. Chaque méthode de cette classe aura une fonction bien précise qui peut rappeler un peu le pattern Modèle-Vue-Contrôleur.

Le modèle correspond aux données tels que les variables. La Vue serait la méthode qui permet d’afficher des éléments à l’écran. Et enfin, le contrôleur serait géré par la méthode de boucle.
Cette structure offre une parfaite organisation. Chaque élément effectue des opérations bien à part.

Les différentes opérations que doit effectuer notre classe:

  • Initialisation: Gestion des différentes initialisations des librairies qui le nécessite tels que la SDL et certaine de ces extensions comme SDL_tff par exemple. Cette méthode devra renvoyer un booléen qui permettra de savoir si le programme à la capacité de pouvoir s’exécuter convenablement ou non.
  • Evènement: Gestions des évènements générés par un clavier, la souris et autres joysticks.
  • Boucle: Cette méthode effectuera des opérations sur les données, comme des conditions, des mises à jour.
  • Rendu: Le rendu sera effectuer par cette méthode, elle ne fera qu’afficher des éléments à l’écran.
  • Quitter: Cette méthode sert à fermer les librairies ouverte dans la méthode Init et aussi à libéré la mémoire. Elle doit être appelée avant la fermeture de l’application.
  • Exécute: Et enfin la dernière méthode qui appellera toutes les méthodes précédentes.

Création de la classe

Nous allons commencer par créer une nouvelle classe nommé Application avec l’assistant d’Eclipse.

Application.h

#ifndef APPLICATION_H
#define APPLICATION_H

class Application {

public:

//Constructeur
Application();

//Destructeur
virtual ~Application();
}

#endif /* APPLICATION_H */

Application.cpp

#include "Application.h"

//Constructeur
Application::Application() {}

//Destructeur
Application::~Application() {}

J’ai supprimé les commentaires générés automatiquement par Eclipse pour ne garder que l’essentiel.

Ajout des méthodes

Initialisation

Dans cette méthode, on initialise les librairies et autres variables.

Application.h

bool Init();

Application.cpp

bool Application::OnInit() {

Application::run = true;

if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
cout << SDL_GetError();
return false;
}

if(SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF) == NULL) {
cout << SDL_GetError();
return false;
}

SDL_WM_SetCaption(GAME_TITLE, GAME_ICON);

return true;
}

&#91;/code&#93;

On commence par mettre l'application en mode marche. On test si la SDL a pu être initialisée, il faut savoir que si il y a une erreur la SDL retourne -1. S'il y a une erreur, on l'affiche dans la console et retourne l'impossibilité d'initialiser la SDL.

Après on test si on peut créer la fenêtre principale de notre application. Si il y a une erreur, on fait comme pour SDL_Init(); Puis on définit le titre de notre fenêtre. Comme il n'y a pas eu d'erreur on retourne le succès de l'initialisation.

<span style="text-decoration: underline; color: #3366ff;">Evènement</span>

<em>Application.h</em>



bool Event();

Application.cpp

void Application::Event() {

SDL_Event event;

while(SDL_PollEvent(&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;event)) {

if(event->type == SDL_QUIT) {

Application::run = false;

}

}

}

Loop

Cette méthode effectue des actions sur les données.

Application.h

void Loop();

Application.cpp

void Application::OnLoop() {

//Logique ici

}

Cette méthode ne fait aucune action particulière dans la classe Application. Vous pourrez ajouter directement votre code ici.

Rendu

Méthode affichant des éléments graphiques à l'écran.

Application.h

void Render();

Application.cpp

void Application::Render() {

SDL_FillRect(SDL_GetVideoSurface(), 0, SDL_MapRGB(SDL_GetVideoSurface()->format, 26, 62, 137));

//Logique de rendu ici

SDL_Flip(SDL_GetVideoSurface());
}

Dans cette méthode, on commence par remplir la fenêtre par un couleur uni. Ce que l'on peut appeler de nettoyage de l'écran.

Votre logique ce place juste après, tout ce qui dit collage.

Et enfin on dessine à l'écran tous les éléments qui ont été collé précédemment.

Quitter

Permet de libéré la mémoire.

Application.h

void Quit();

Application.cpp

void Application::Quit() {

SDL_Quit();
}

Cette méthode est assez simple, ici on libère la mémoire utilisé par la librairie SDL, en appelant sa fonction qui se charge de ça. Certaine extension de SDL possède aussi une fonction pour libéré la mémoire. Il faut bien veillez à le faire.

Exécute

Cette méthode correspond au tronc principale de notre classe Application, tout vient se greffé ici.

Application.h

int Execute();

Application.cpp

int Application::Execute() {

if(!this->Init()) return EXIT_FAILURE;

while(Application::run) {
this->Event();

this->Loop();

this->Render();
}

this->Quit();

return EXIT_SUCCESS;
}

On commence par l’initialisation de la classe, si celui-ci retourne un échec, on ne peut plus continuer le programme. On retourne un EXIT_FAILURE, et donc le programme s'arrête.
Sinon, on passe dans la boucle principale du programme, dont la condition est que tant que l'application est en mode marche. On appelle les méthodes à chaque tour.
Lorsque mode passe en mode arrêt, on appelle la méthode Quit qui nettoiera la mémoire et on retourne EXIT_SUCCESS.

Initialisation de l'Application

Le code composant le point d'entrée de notre programme est très simple.

#include "Application.h"

int main(int argc, char** argv) {

Application app;

return app.Execute();
}

On instancie la classe Application et on l'exécute. Le point d'entrée retournant un int, la méthode Exécute renvoie un int définissant l'état dans laquelle le programme s'est terminée, soit EXIT_SUCCESS soit EXIT_FAILURE.

Conclusion

Voilà maintenant vous avez un exemple de structure basique SDL qui peut être réutilisé dans vos projets. Cette structure peut être réutilisée avec d’autres librairies autres que SDL.

Utilisez-vous une autre méthode ? Avez-vous des informations à rajouter à cet article ? La parole est à vous :)Julien

Laisser un commentaire

Login to your account

Can't remember your Password ?

Register for this site!