Structure basique d’un jeu avec la SDL
Julien 23 mars 2012Introduction
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;
}
[/code]
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;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
Loading ...