Tutoriels >> Nos tutoriels sur la programmation Nos tutoriels sur la programmation >> Langage C Langage C >> Créer un RPG en 2D avec la SDL et FMOD en C Créer un RPG en 2D avec la SDL et FMOD en C

Créer un RPG en 2D avec la SDL et FMOD en C






Chapitre 1: Au commencement...



Introduction au tutoriel



Vous vous apprêtez à lire un tutoriel sur la création d'un RPG en 2D. Celui-ci aura pour but de vous apprendre à créer étape par étape votre jeu.

Nous utiliserons le langage C et les deux librairies( à l'avenir j'utiliserai le mot lib ;) ) suivantes : SDL et FMOD. Ce sont des lib très répandue dans le domaine du jeux vidéo 2D.
Nous verrons dans le prochain chapitre à quoi elles servent et comment les installer.

Personne a dit que la création d'un jeu de rôle en C était chose simple, ainsi, nous serons invité à utiliser diverses notions du C et des deux lib utilisées. Des points rappels seront fait au cours du tuto sur certaines de ces notions. Cependant ce tuto peut être considéré comme de la pratique !



De mon côté je tacherai à ce que le code soit compréhensible de tous.

Qu'est-ce que l'on va développer?



Une très bonne question à laquelle il y a beaucoup à répondre.

Quand vous jouez à un jeu-vidéo, vous ne faites pas attention à tous les systèmes en fond qui tournent, et croyais moi ils sont nombreux. Même plus nombreux que vous le croyais.

Tout d'abord nous devons développé le système de cartes du jeu, avec un éditeur de cartes pour pouvoir crée ses propres cartes !
Dès que l'on a nos cartes, il faut créer nos persos, nos coffres etc.

Ce qui sera le plus "simple" dans l'histoire.

Le plus dur après : créer ce que l'on appelle des événements tel que la téléportation, l'ouverture d'un coffre...
Créer le système de combat, de boutique, système de sauvegarde, de chargement ...

Intéressant, n'est-il pas? ?

Finalement, après tout ceci, il ne restera plus que le scénario de votre jeu.

Le scénario étant personnel, je ne peux que vous donnez des idées. A chacun selon ces envies, son but.


Tout çà donne l'eau à la bouche!
Et si on se mettait au travail?

Allons-y! Let's go!!

Dans le prochain chapitre nous allons voir du vocabulaire dans le domaine des jeux vidéo, et nous allons installer la SDL et FMOD

Chapitre 2: Vocabulaire et Installation des outils nécessaires



Vous savez ce que nous allons faire dans les grandes lignes dans ce tuto. Cependant, il faut que vous ayez un certain vocabulaire pour comprendre ce que je vais dire.

Du vocabulaire ?? gne


Oui, rassuré vous. Il n'y aura pas grand chose !

Après le vocabulaire, nous attaquerons la partie sur les libs et leur installation.

Vocabulaire du jeu-vidéo



Cela va être quelques mots rien de bien méchant rassuré vous ;)

RPG : " Role Playing Game" ou "Jeu de Rôle" en français. Désigne l'ensemble des jeux vidéo présentant des similitudes avec les jeux de rôle papier (Magic, etc.). Ceux-ci ont en général pour points communs un scénario long, des personnages variés et une gestion des points d'expérience et des caractéristiques des personnages. Dans une volonté de tout classifier, certains parlent également de A-RPG (mélange de jeu d'aventure et de RPG), de Tactic-RPG (mélange de stratégie et de RPG), de MMORPG ("Massive Multiplayer Online Role Playing Game" ou en french "Jeu de rôle massivement online").
Vous connaissez surtout des MMORPG comme Dofus ou encore World of Warcraft.

Gameplay : La traduction littérale donne "jouer à un jeu", mais signifie réellement "maniabilité". C'est la facilité de la prise en main d'un jeu, d'évoluer dans l'environnement de ce jeu.

Pixel : C'est le plus petit élément graphique (l'équivalent d'un point). Sa couleur dépend des propriétés d'affichage de la console ou du PC.

Plaquage de textures : En 2D, les graphismes du jeu sont dessinés comme sur un planche à dessin. Le détail est alors facile à gérer car étant vu "à plat", de manière fixe.

Sprite : Élément graphique en 2D de taille variable : 16x16 pixels, 32x32 pixels ou 64x64 pixels, etc. Par exemple, le personnage de Mario dans "Super Mario Bros."

Map : En anglais "carte", c'est la surface de jeu.

Chipset : Palette d'images fragmentées de décors qui une fois assemblées permettront de créer vos décors.

Charset : Même chose que pour le chipset sauf que là il s'agit des personnages.

Événement ( ou event) : C'est tout ce qui va faire appelle à vos doigts pour coder toute sorte d'action : changer de carte, ouvrir un coffre ...

Il y en a bien d'autre mais l'essentiel est là, si vous connaissez ceux là, vous vous en sortirez !

Voyons maintenant les libs que nous allons utilisé.

SDL et FMOD



Ce sont des libs très connu dans le domaine du jeux vidéo. Elles sont réputée pour être accessible au débutant

SDL gère tout ce qui est multimédia et FMOD lui le son.

Pourquoi prendre une autre lib pour le son, alors que la SDL gère le son?


La réponse est très simple : FMOD prend en charge beaucoup plus de format que la SDL.

C'est payant??

Non, rassurez-vous. SDL est sous licence Libre et donc gratuit :p Quant à FMOD lui il est juste gratuit.

Installation de la SDL





Ne travaillant qu'avec Code::Blocks, les procédures d'installation seront données pour cet IDE uniquement.


Commencez par aller sur le site : http://www.libsdl.org/
Allez dans la section Download dans le menu de gauche puis choisissez SDL 1.2.

Descendez jusqu'à Developement Libraries. Suivant votre OS choisissez Linux, Win32 ou Mac OS.
Pour ceux qui ont Code::Blocks sous windows, prenait la version Mingw32.

Pour ceux qui trouverais pas voici le lien : Télécharger la SDL pour Windows avec Code::Blocks

Utilisez un logiciel tel que Winrar ou 7-zip pour extraire le contenue de l'archive dans le répertoire : C:\Program Files\CodeBlocks\.
Pour moi le répertoire d'extraction est : C:\Program Files\CodeBlocks\SDL-1.2.13

Dans le dossier, SDL-1.2.13, allez dans le répertoire include/SDL et copier le contenu dans le répertoire C:\Program Files\Codeblocks\SDL-1.2.13\include.

Oui, je sais c'est le répertoire contenant le dossier dans lequel il y a les fichiers que je vous ai demandé de copier.

Nous avons fini de l'installé.

Configurons notre projet sous code::blocks.

Créez un nouveau projet et choisissez SDL Project.


La fenêtre suivante s'ouvre :


Donner un nom à votre projet(Project Title), un répertoire dans lequel enregistrer le projet(Folder to create project in). Le reste se fait automatiquement.

Appuyez sur suivant, vous avez cette fenêtre :


Appuyez sur ....

Vous devez simplement remplir le champ Base. Indiquez le dossier où vous avez décompressé la SDL. Dans mon cas, c'est : C:\Program Files\CodeBlocks\SDL-1.2.13
Cliquez sur Close.

Une nouvelle fenêtre apparaît. Cliquez sur Annuler. Puis appuyez sur Next et enfin Finish.

Là Code::Blocks vous propose un code, compilez le voir si l'installation de la SDL à fonctionner. En le lançant, il vous met un joli message d'erreur : L'application n'a pas pu démarrer SDL.dll est introuvable.
Il faut mettre alors le fichier SDL.dll dans le répertoire de votre projet.
Cette DLL se situe dans C:\Program Files\Codeblocks\SDL-1.2.13\bin.

Lancez le programme, et magiquement, la fenetre suivante s'ouvre :


Cela signifie que l'installation de SDL est finie.

Gardez sous la main se projet, c'est de lui dont nous nous servirons.

Il ne reste plus qu'a installé FMOD.

Installation de FMOD





Pour télécharger FMOD, allez sur le site officiel : http://www.fmod.org

Allez sur la page des téléchargements (Downloads) et prenez FMOD 3.
Attention, il y a plusieurs versions de FMOD, en particulier une plus récente et appelée FMOD Ex (il s'agit en fait de FMOD 4). Toutefois, FMOD Ex est une bibliothèque C++, contrairement à FMOD 3 qui est une bibliothèque C.
Choisissez ensuite la version suivant votre système d'exploitation.

Ouvrez l'archive obtenue.

Vous avez un dossier API contenant fmod.dll. Extrayez là vers le répertoire de votre projet.

Si vous êtes sur une machine tournant avec un processeur 64 bits, vous devez prendre fmod64.dll qui est adapté à ce type de machine. Mais le plus couramment, ce sont des ordinateurs 32 bits et donc la dll à choisir est fmod.dll


Dans le dossier api/inc, vous trouverez les .h. Placez-les à côté des autres .h dans le dossier de votre IDE. Par exemple Code Blocks/mingw/include/FMOD(j'ai créé un dossier spécial pour FMOD)

Dans le dossier api/lib, récupérez le fichier libfmod.a qui correspond à MinGW, le compilateur de Code::Blocks. Et mettez le dans le dossier CodeBlocks/Mingw/lib.

Maintenant, il ne reste plus qu'à configurer le projet. Dans le projet que nous avons créer avec SDL. Allez dans le menu Project puis Build Option.

Allez dans Linker Settings et ajouté le fichier libfmod.a. Il vous demande Keep as a relative path dite non.

Voici ce que vous devez avoir :

Voilà FMOD est installé, on va pouvoir commencé à programmer !





Chapitre 3: Initialisation des outils nécessaires



Dans ce chapitre, on va organisé notre projet, car vous allez voir des fichiers va y en avoir beaucoup, puis on va créer le main et initialiser la SDL et FMOD

Un certain niveau est requis pour comprendre à partir de maintenant le tuto. Voici un cours sur le C fait par un membre du site pour ceux qui ne sont pas encore tout à fait au point : Cours sur le C


Organisation du projet



Rendez-vous dans le dossier de votre projet.
Vous devez y trouver : un dossier bin, un dossier obj, cb.bmp, main.c ( ne vous en faite pas s'il est marqué C++), rpg.cbp, rpg en fichier LAYOUT, et vos deux DLL : sdl.dll et fmod.dll.

Dans un premier temps, vous allez supprimer le fichier cb.bmp. Il ne nous servira à rien.

Deux cas s'offre à vous :
Soit vous savez déjà quels médias vous allez utilisez et dans ce cas : dans le dossier de votre projet, vous allez créer 9 dossiers :

- ai, le dossier contenant toutes les images concernant les boss et toutes les autres choses concernant ce qui est contrôlé par une intelligence artificielle.
- img, le dossier contenant toutes sortes d'images.
- map, le dossier contenant nos cartes.
- musique, le dossier contenant les musiques.
- save, le dossier contenant les sauvegardes de l'utilisateur.
- son, le dossier contenant les effets sonores du jeu.
- sprites, le dossier contenant les animations des coups, les personnages...
- tiles, le dossier contenant les tuiles de notre jeu.
- video, le dossier contenant les vidéos.

C'est quoi les tuiles?

c'est les images qui compose la carte.

Soit si vous n'avez aucune idée des médias que vous allez utiliser, vous pouvez prendre ce pack :Pack de ressource du tuto

Mais à la fin, il faut que votre dossier de votre projet ressemble à çà :


Les dossiers map et save doivent être vide.

Voilà fini, la partie dossier et installation, on peut attaquer la programmation et on commence par le main.

Le main


Maintenant, on passe au chose sérieuse, rendez-vous dans Code::Blocks.
Ouvrez votre projet et allez dans le dossier source puis main.cpp.
Supprimez moi tout çà !

Et mettez simplement ce bout de code :

Code c:
 
/* Fichier main.c : fonction main et initialisation des différentes librairies. */
#include "main.h"
 
int main(int argc, char **argv)
{
  return 0;
}


Comme vous pouvez le constater, j'ai inclus un fichier main.h.

Créer ce nouveau fichier. Veillez à le mettre dans le répertoire du projet.
Ce fichier comprend l'inclusion des libs SDL et FMOD et des libs standard en C.
Vous remarquez que code::blocks affiche le code suivant :

Code c:
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED



#endif


Ce code permet d'éviter les inclusions multiples lors de la compilation du projet.
Entre ces lignes vous allez donc inclure les fichiers : sdl.h, fmod.h et fmod_errors.h, les deux fichiers concernant FMOD sont situé dans le répertoire FMOD.
fmod_errors.h sert à la gestion des erreurs.

Ainsi le fichier main.h devient :
Code c:
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED


#include "sdl.h"
#include "FMOD/fmod.h"
#include "FMOD/fmod_errors.h"

#endif


Il faut maintenant inclure les deux librairies standard : stdio.h et stdlib.h

Finalement, le fichier main.h ressemble à çà :

Code c:
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED


#include "sdl.h"
#include "FMOD/fmod.h"
#include "FMOD/fmod_errors.h"

# include <stdio.h>
# include <stdlib.h>

#endif


Nous avons fini de poser la structure de notre fichier main. Passons à l'initialisation de la SDL et FMOD.

Initialisation de la SDL et de FMOD


Nous allons faire une fonction pour l'initialisation de la SDL et FMOD.
Elle ne prendra aucun argument et sera de type int.

je vais l'appelé init_sdl_fmod. Son prototype a placé dans le fichier main.h est alors :

Code c:
int init_sdl_fmod();


Vous devez placer ce prototype de fonction après le #endif pour finalement avoir ce fichier :
Code c:
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED


#include "sdl.h"
#include "FMOD/fmod.h"
#include "FMOD/fmod_errors.h"

# include <stdio.h>
# include <stdlib.h>

#endif

int init_sdl_fmod();


La fonction est du type int car on va retourner la valeur 0 pour dire que tout c'est bien passé lors de l'initialisation.

Retournons dans notre fichier main.c pour coder la fonction.

Pour initialiser SDL et FMOD, nous devons créer un pointeur sur la surface de la fenêtre, dire quel module de la SDL nous utilisons et donner un titre et des dimensions à la fenetre de notre jeu.
J'ai choisi les dimension 800*600 en mode 32 bits par pixel.
Pour FMOD, j'ai choisi d'initialiser en mettant du son qualité CD donc une valeur de 44100Hz, je prend 64 canaux. La fonction d'initialisation de FMOD : FSOUND_init prend aussi en argument flags : vous mettez 0.

Voici ceux à quoi ressemble la fonction init_sdl_fmod :
Code c:
int init_sdl_fmod()
{
    SDL_Surface *ecran; //Pointeur sur la surface de la fenetre

    //On initialise la SDL en mode vidéo
    if(SDL_Init(SDL_INIT_VIDEO)==-1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError()); //On écrit l'erreur dans stderr
        exit(EXIT_FAILURE);
    }

    //On initialise une fenetre en résolution 800*600 et 32 bits/pixel avec le mode mémoire vidéo et double buffering
    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    if (ecran == NULL) // Si l'ouverture de la fenetre a échoué, on écrit l'erreur et on arrête le programme
    {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    //On donne un titre et on a pas d'icone donc on met NULL pour l'argument concernant l'icône
    SDL_WM_SetCaption("Tuto Création RPG", NULL);

    //on initialise FMOD avec un son de qualité CD(44100 Hz) et 64 canaux
    if (!FSOUND_Init(44100, 64, 0))
    {
        fprintf(stderr,"Erreur à l'initialisation de FMOD: %s\n", FMOD_ErrorString(FSOUND_GetError()));
        exit(EXIT_FAILURE);
    }


    return 0;

}


Il n'y a rien de particulier à signaler, si ce n'est que j'ai pris en charge la gestion des erreurs.
fprintf est une fonction permettant d'écrire dans un fichier. Elle prend en argument le nom du fichier, et ce que l'on doit y écrire.

Sinon retenir les fonction suivante dans l'initialisation de SDL et FMOD :
SDL_Init qui prend en argument les modules initialisés, ici la vidéo, car pour l'audio on a FMOD.
SDL_SetVideoMode qui prend en argument la résolution le nombre de bits par pixel et les mode.
SDL_WM_SetCaption qui prend en argument le titre de la fenêtre et l'icône.
FSOUND_Init qui prend en argument la qualité du son, le nombre de canaux et le flags.

Il ne nous reste plus qu'a libérer SDL et FMOD à la fin du programme.

La libération de SDL et FMOD



Comme pour l'initialisation, nous allons créer une fonction qui va libérer la mémoire à la fois pour la SDL et pour FMOD.

Je l'appelle free_sdl_fmod().

Son prototype est alors :
Code c:
void free_sdl_fmod();


Pour libérer SDL, la fonction est on ne peut plus simple : SDL_Quit().
Pour libérer FMOD, la fonction est très parlante : FSOUND_Close().

Pour FMOD, il faudra libérer le son à quand on aura fini de s'en servir.


La fonction est alors vite codée :

Code c:
void free_sdl_fmod()
{
     SDL_Quit();
     FMOD_Close();
}


Finalement, votre main.c ressemble à çà :
Code c:
/* Fichier main.c : fonction main et initialisation des différentes librairies. */
#include "main.h"

int main(int argc, char **argv)
{
  return 0;
}

int init_sdl_fmod()
{
    SDL_Surface *ecran; //Pointeur sur la surface de la fenetre

    //On initialise la SDL en mode vidéo
    if(SDL_Init(SDL_INIT_VIDEO)==-1)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError()); //On écrit l'erreur dans stderr
        exit(EXIT_FAILURE);
    }

    //On initialise une fenetre en résolution 800*600 et 32 bits/pixel avec le mode mémoire vidéo et double buffering
    ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    if (ecran == NULL) // Si l'ouverture de la fenetre a échoué, on écrit l'erreur et on arrête le programme
    {
        fprintf(stderr, "Impossible de charger le mode vidéo : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    //On donne un titre et on a pas d'icone donc on met NULL pour l'argument concernant l'icône
    SDL_WM_SetCaption("Tuto Création RPG", NULL);

    //on initialise FMOD avec un son de qualité CD(44100 Hz) et 64 canaux
    if (!FSOUND_Init(44100, 64, 0))
    {
        fprintf(stderr,"Erreur à l'initialisation de FMOD: %s\n", FMOD_ErrorString(FSOUND_GetError()));
        exit(EXIT_FAILURE);
    }


    return 0;

}

void free_sdl_fmod()
{
    SDL_Quit();
    FSOUND_Close();
}


Et votre main.h à ceci :
Code c:
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED


#include "sdl.h"
#include "FMOD/fmod.h"
#include "FMOD/fmod_errors.h"

# include <stdio.h>
# include <stdlib.h>

#endif

int init_sdl_fmod();
void free_sdl_fmod();


Vous pouvez compiler le code, le programme ne fait rien pour l'instant.

Voilà nous avons fini d'initialiser la SDL et FMOD, la partie la plus intéressante commence au prochain chapitre avec la création de map.
Créer un RPG en 2D avec la SDL et FMOD en C
Auteur Bart Simpson
Date de création 10/08/2009 à 00h11
Dernière date d'édition 27/01/2010 à 22h10
Avancement 5 %
Nombre de fois consultés 72718
Commentaires Ajouter un commentaire
Affichage complet du tutorial
Connecté(s) 1 connectés (0 membres, 1 invités)