[Conseil] Format .x

Je commence par un petit post de présentation du truc.
Ca fait un bout de temps déjà que je code en c++ et que je me suis familiarisé avec la SDL. Je ne connais pas tout évidemment, je n'en connais même que très peu. Mais il me semble que je tire qqch de très bénéfique du tuto de FVIRTMAN dans lequel j'ai appris la SDL (et que je remercie au passage cheers

)

J'ai donc monté petit à petit des fonctions que j'utilise tout le temps, et des classes fort utiles. Je vais vous les présenter ici.
Ce tuto n'a pas pour but de vous apprendre à utiliser la SDL, celui de FVIRTMAN est tout à fait adapté à cela, mais je vais vous apprendre à utiliser les fonctions que j'ai construit...

Je tiens à signaler que je souhaite que mon nom de programmeur (Duche) reste présent dans les fonctions que je vous présente. Je ne vous empèche pas de les utiliser, je vous y encourage même, mais par contre je ne souhaite pas vous voir vous attitrer leur création.
Vous pouvez oublier mon nom si vous changer radicalement mes fonctions (comme je l'ai fait pour certaines de FVIRTMAN qu'il reconnaitra surement Wink

)

Commençons par la structure de projet que j'utilise.

* J'ai un fichier main.cpp qui contient uniquement la fonction main et éventuellement quelques variables globales.
C'est dans cette fonction que je vais faire les chagement de fichier d'initialisation de jeu et compagnie...

* J'ai un fichier audio.h et audio.cpp
Vous gérez l'audio comme vous voulez. Ici j'utiliserai fmod (il est expliqué sur le tuto de FVIRTMAN comment installer et utiliser cette librairie)
Pour que ce soit compatible avec mes fonctions SDL, il faut juste que vous ayez une fonction

Code:: Play_Sound(int ref);

où ref est une référence à la piste que vous voulez jouer (prédéfinie dans le fichier audio.cpp comme vous la désirez...)

Voici ce que j'utilise:

Fichier "scrabble_audio.h"

Code:: ////////////////////////////////////////////////////////////////////////////////
//////++++++//////++//////++//////++++++//++//////++//++++++++//////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++//////++//++//////++//++//////////++++++++++//++++++////////////////////
//////++//////++//++//////++//++//////////++//////++//++////////////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++++++////////++++++////////++++++//++//////++//++++++++//Production ////
////////////////////////////////////////////////////////////////////////////////
// //
// Ecrit par Duche. //
// Contact: le_grand_duche@hotmail.com //
// //
// Date de dernière modification : 29/11/2005 //
// //
////////////////////////////////////////////////////////////////////////////////
// scrabble_audio.h //////////////////////////////////////////////////////////

#ifndef _SCRABBLE_AUDIO_H
#define _SCRABBLE_AUDIO_H

////////////////////////////////////////////////////////////////////////////////
// FICHIERS À JOUER //////////////////////////////////////////////////////////

#define SOUND_BLIP "blip.mp3"
#define SOUND_SHACK "shack.mp3"
#define SOUND_END "shhh.mp3"
#define BLIP 0
#define SHACK 1
#define END 2
#define NBR_SND 3
#define NO_SOUND -1

////////////////////////////////////////////////////////////////////////////////
// FONCTIONS /////////////////////////////////////////////////////////////////

void InitAudio(bool);
void CloseAudio();
void Play_Sound(int);

////////////////////////////////////////////////////////////////////////////////

#endif

Fichier "scrabble_audio.cpp"

Code:: ////////////////////////////////////////////////////////////////////////////////
//////++++++//////++//////++//////++++++//++//////++//++++++++//////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++//////++//++//////++//++//////////++++++++++//++++++////////////////////
//////++//////++//++//////++//++//////////++//////++//++////////////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++++++////////++++++////////++++++//++//////++//++++++++//Production ////
////////////////////////////////////////////////////////////////////////////////
// //
// Ecrit par Duche. //
// Contact: le_grand_duche@hotmail.com //
// //
// Date de dernière modification : 29/11/2005 //
// //
////////////////////////////////////////////////////////////////////////////////
// scrabble_audio.cpp ////////////////////////////////////////////////////////

#include "scrabble_audio.h"
#include <fmod/fmod.h>

////////////////////////////////////////////////////////////////////////////////
// FLUX //////////////////////////////////////////////////////////////////////

FSOUND_STREAM* sound[NBR_SND];
bool AudioActif;

////////////////////////////////////////////////////////////////////////////////
// FONCTIONS /////////////////////////////////////////////////////////////////

void InitAudio(bool b)
{ /* fonction écrite par Duche */
AudioActif = b;
if(AudioActif)
{
   FSOUND_Init(44100,NBR_SND,0);
   FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
   FSOUND_SetDriver(0);
   sound[BLIP] = FSOUND_Stream_Open(SOUND_BLIP,0,0,0);
   sound[SHACK] = FSOUND_Stream_Open(SOUND_SHACK,0,0,0);
   sound[END] = FSOUND_Stream_Open(SOUND_END,0,0,0);
}
}

void CloseAudio()
{ /* fonction écrite par Duche */
if(AudioActif)
   for(int i=0;i<NBR_SND;i++)
      FSOUND_Stream_Close(sound[i]);
}

void Play_Sound(int i)
{ /* fonction écrite par Duche */
if(AudioActif && (i != NO_SOUND))
{
   FSOUND_Stream_Stop(sound[i]);
   FSOUND_Stream_Play(i,sound[i]);
}
}

////////////////////////////////////////////////////////////////////////////////

On arrive maintenant aux choses interessantes.
Pour vous donner tout de suite l'eau à la bouche, je vous montre ceci:

Fichier "scrabble_graphisme.h"

Code:: ////////////////////////////////////////////////////////////////////////////////
//////++++++//////++//////++//////++++++//++//////++//++++++++//////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++//////++//++//////++//++//////////++++++++++//++++++////////////////////
//////++//////++//++//////++//++//////////++//////++//++////////////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++++++////////++++++////////++++++//++//////++//++++++++//Production ////
////////////////////////////////////////////////////////////////////////////////
// //
// © Ecrit par Duche. //
// Contact: le_grand_duche@hotmail.com //
// //
// Date de dernière modification : 17/03/2006 //
// //
////////////////////////////////////////////////////////////////////////////////
// scrabble_graphisme.h //////////////////////////////////////////////////////

#ifndef _SCRABBLE_GRAPHISME_H
#define _SCRABBLE_GRAPHISME_H

////////////////////////////////////////////////////////////////////////////////

#include <SDL/SDL.h>
#include <sdl/sdl_ttf.h>
#include <windows.h>

////////////////////////////////////////////////////////////////////////////////
// CONSTANTES DU FICHIER scrabble_graphisme.cpp //////////////////////////////

#define LOGO "\251 Duche Production 2006."

#define CLAVIER_INCONNU 0
#define CLAVIER_FRANCE 1
#define CLAVIER_BELGIQUE 2
#define CLAVIER_ANGLETERRE 3

#define TCH_INCONNU 0
#define TCH_ESC 1
#define TCH_F1 2
#define TCH_F2 3
#define TCH_F3 4
#define TCH_F4 5
#define TCH_F5 6
#define TCH_F6 7
#define TCH_F7 8
#define TCH_F8 9
#define TCH_F9 10
#define TCH_F10 11
#define TCH_F11 12
#define TCH_F12 13
#define TCH_PRINTSCR 14
#define TCH_PAUSE 15
#define TCH_CARRE 16
#define TCH_CUBE 17
#define TCH_ET 18
#define TCH_1 19
#define TCH_OU 20
#define TCH_eAIG 21
#define TCH_2 22
#define TCH_AT 23
#define TCH_GUILLEMETS 24
#define TCH_3 25
#define TCH_DIESE 26
#define TCH_APOSTROPHE 27
#define TCH_4 28
#define TCH_PARENTG 29
#define TCH_5 30
#define TCH_PARAGR 31
#define TCH_6 32
#define TCH_CIRCIMM 33
#define TCH_eGRAV 34
#define TCH_7 35
#define TCH_EXCLAM 36
#define TCH_8 37
#define TCH_cCEDILLE 38
#define TCH_9 39
#define TCH_ACCOLG 40
#define TCH_aGRAV 41
#define TCH_0 42
#define TCH_ACCOLD 43
#define TCH_PARENTD 44
#define TCH_DEGRE 45
#define TCH_MOINS 46
#define TCH_UNDERSCORE 47
#define TCH_BACK 48
#define TCH_INSERT 49
#define TCH_HOME 50
#define TCH_PAGEUP 51
#define TCH_NUMLOCK 52
#define TCH_SLASH 53
#define TCH_STAR 54
#define TCH_TAB 55
#define TCH_a 56
#define TCH_A 57
#define TCH_z 58
#define TCH_Z 59
#define TCH_e 60
#define TCH_E 61
#define TCH_EURO 62
#define TCH_r 63
#define TCH_R 64
#define TCH_t 65
#define TCH_T 66
#define TCH_y 67
#define TCH_Y 68
#define TCH_u 69
#define TCH_U 70
#define TCH_i 71
#define TCH_I 72
#define TCH_o 73
#define TCH_O 74
#define TCH_p 75
#define TCH_P 76
#define TCH_CIRC 77
#define TCH_TREMA 78
#define TCH_CROCHETG 79
#define TCH_DOLLAR 80
#define TCH_CROCHETD 81
#define TCH_ENTER 82
#define TCH_DELETE 83
#define TCH_END 84
#define TCH_PAGEDOWN 85
#define TCH_PLUS 86
#define TCH_q 87
#define TCH_Q 88
#define TCH_s 89
#define TCH_S 90
#define TCH_d 91
#define TCH_D 92
#define TCH_f 93
#define TCH_F 94
#define TCH_g 95
#define TCH_G 96
#define TCH_h 97
#define TCH_H 98
#define TCH_j 99
#define TCH_J 100
#define TCH_k 101
#define TCH_K 102
#define TCH_l 103
#define TCH_L 104
#define TCH_m 105
#define TCH_M 106
#define TCH_uGRAV 107
#define TCH_P100 108
#define TCH_AIG 109
#define TCH_MU 110
#define TCH_LIVRE 111
#define TCH_GRAV 112
#define TCH_w 113
#define TCH_W 114
#define TCH_x 115
#define TCH_X 116
#define TCH_c 117
#define TCH_C 118
#define TCH_v 119
#define TCH_V 120
#define TCH_b 121
#define TCH_B 122
#define TCH_n 123
#define TCH_N 124
#define TCH_VIRGULE 125
#define TCH_INTERRO 126
#define TCH_POINTVIRGULE 127
#define TCH_POINT 128
#define TCH_2POINTS 129
#define TCH_EGAL 130
#define TCH_TILDE 131
#define TCH_UP 132
#define TCH_ESPACE 133
#define TCH_LEFT 134
#define TCH_DOWN 135
#define TCH_RIGHT 136

#define IN_VOID 0
#define IN_NUM 1
#define IN_MAJ 2
#define IN_MAJ_NUM 3
#define IN_ALTGR 4
#define IN_ALTGR_NUM 5
#define IN_ALTGR_MAJ 6
#define IN_ALTGR_MAJ_NUM 7

#define ACCENT_NONE 0
#define ACCENT_AIGU 1
#define ACCENT_GRAVE 2
#define ACCENT_CIRC 3
#define ACCENT_TREMA 4
#define ACCENT_TILDE 5

#define BT_MOUSE_OUT 0
#define BT_MOUSE_ON 1
#define BT_CLICKED 2
#define BT_POST_CLICKED 3
#define BT_DBL_CLICKED 4

#define BT_NO_CLICK 0
#define BT_CLICK 1
#define BT_DBL_CLICK 2

#define AUCUN_CHOIX 0
#define NOUVELLE_PARTIE 1
#define CHARGER_PARTIE 2
#define REVOIR_PARTIE 3
#define RESOUDRE_SITUATION 4
#define STATS 5
#define OPTIONS 6
#define AIDE 7
#define QUITTER 8

////////////////////////////////////////////////////////////////////////////////
// DÉCLARATIONS DES CLASSES ET STRUCTURES UTILISÉES //////////////////////////

#ifndef uchar
typedef unsigned char uchar;
#endif

         class strms01
         { /* classe écrite par Duche */
            friend class Souris;
            int condx;
            int condy;
            int condw;
            int condh;
            SDL_Surface* source;
            int sx;
            int sy;
            int sw;
            int sh;
            int centerx;
            int centery;
            strms01* ptrs;
         };

class Souris
{ /* classe écrite par Duche */
public:
   Souris();
   ~Souris();
   int posX(int=0);
   int posY(int=0);
   int relX();
   int relY();
   bool bt(int);
   void deleteParams();
   void paramInit(SDL_Surface*,int,int,int,int,int,int);
   void paramInit(SDL_Surface*);
   void newParam(int,int,int,int,SDL_Surface*,int,int,int,int,int,int);
   void newParam(int,int,int,int,SDL_Surface*);
   bool inRect(int,int,int,int);
   void blit(SDL_Surface*);
   friend void UpdateEvents();
private:
   int x;
   int y;
   int rel_x;
   int rel_y;
   bool btn[10];
   SDL_Surface* default_Surface;
   int defaultx;
   int defaulty;
   int defaultw;
   int defaulth;
   int defaultctrx;
   int defaultctry;
   strms01* prm;
};

         class _Champ
         { /* classe écrite par Duche */
            friend class Clavier;
            friend void Ajoute(char);
            friend void writer(int);
            bool actif;
            char* tab;
            int long_txt;
            int long_max_txt;
            int pos_curs;
            int mem_acc;
         };

class Clavier
{ /* classe écrite par Duche */
public:
   Clavier(int=CLAVIER_INCONNU);
   ~Clavier();
   bool key(int);
   int waitKey();
   void writeIn(char*,int,int,int);
   void stopWrite();
   int type();
   void type(int);
   friend void UpdateEvents();
private:
   void preUpdate();
   void postUpdate();
   bool keys[400];
   int typ;
   bool insert; //Mode intertion
   _Champ ch; //Champ d'écriture
   bool compar[400];
   friend void writer(int);
   friend void Ajoute(char);
};

         class strblitpt
         { /* classe écrite par Duche */
            friend class Bouton;
            SDL_Surface* surface;
            int sx,sy,sw,sh;
            int dx,dy;
            strblitpt* pts;
         };

class Bouton
{ /* classe écrite par Duche */
public:
   Bouton(int,int); //Constructeur
   ~Bouton(); //Destructeur
   int dimW(); //Renvoie les dimensions du bouton
   int dimH(); //
   void positionne(int,int); //Repositionne le bouton
   int posX(); //Renvoie la position du bouton
   int posY(); //
   void addSurface(int,int,int,SDL_Surface*,int,int,int,int); //Défini les surfaces
   void clearSurface(int); //Réinitialise les surfaces
   void addSound(int,int); //Définit un son
   void clearSound(int); //Supprime le son
   void defineTimeClick(long); //Défini le temps maximum du double-click
   int update(); //Actualise le bouton (selon la dernière actualisation)
   void blit(SDL_Surface*); //Affiche le bouton
private:
   int PosX,PosY; //Position du bouton
   int DimW,DimH; //Dimensions du bouton
   strblitpt* Out; //Images pour le bouton
   strblitpt* On; //
   strblitpt* Clicked; //
   int Sound_Out; //Sons pour le bouton
   int Sound_On; //
   int Sound_Click; //
   int Sound_Unclick; //
   int Etat; //Etat du bouton
   long LastClick; //Moment du dernier click
   long TimeClick; //Temp maximum pour le double click
};

class PoliceTTF
{ /* classe écrite par Duche */
public:
   PoliceTTF(char*,int,bool,bool,bool);
   ~PoliceTTF();
private:
   TTF_Font* font;
friend void PrintSDLTTF(const PoliceTTF&,int,int,int,SDL_Surface*,int,int,char*,...);
friend void WriteSDLTTF(const PoliceTTF&,int,int,int,SDL_Surface*,int,int,char*,int);
};

////////////////////////////////////////////////////////////////////////////////
// FONCTIONS UTILISABLES /////////////////////////////////////////////////////

void InitGraphisme(int);
void CloseGraphisme();

void CinematiqueIntro();
void CinematiqueEnd();

int MenuRacine();

////////////////////////////////////////////////////////////////////////////////
#endif

C'est assez indigeste comme ca. Et ca mérite quelques commentaires.
Mais je viens d voir l'heure inquiétante. Et je posterai la suite de mon tuto demain.
(je vous demanderais de ne pas encore y réagir, de facon à ce qu'il tienne d'un seul bloc...)

Me revoilà cheers

Explications concerant le fichier "scrabble_graphisme.h"

*Tout d'abord, vous découvrez la classe

Code:: class strms01

Elle ne vous est absolument pas utile, elle est utilisée exclusivement par la classe

Code:: class Souris

Vous ne devrez jamais déclarer un objet de type strms01.

*Utilisation de la classe class Souris:

Constructeur et destructeur tout à fait habituels.

Code:: int posX(int=0);
int posY(int=0);

renvoient la position de la souris.
On peut ajouter un paramètre, si vous souhaitez que la position renvoyée soit translatée, c'est à dire si vous voulez que le point (0,0) se trouve autre part qu'en haut à gauche de l'écran.

Code:: int relX();
int relY();

renvoient la position de la souris par rapport à la position précédente. Ca vous fourni donc la vitesse de déplacement de la souris.

Code:: bool bt(int);

renvoie true si le bouton dont on donne le numéro est enfoncé, renvoie false sinon.

Code:: void deleteParams();

Réinitialise les paramètres d'image de la souris (que l'on va définir ci-dessous)

Code:: void paramInit(SDL_Surface*,int,int,int,int,int,int);

Définit l'image par défaut de la souris. Les paramètre sont:
Une Image SDL source, le x de la découpe sur l'image, le y de la découpe, la largeur de la découpe, la hauteur de la decoupe, le centre significatif en x, le centre significatif en y.
Le centre significatif, c'est le point de votre souris PONCTUELLE, c'est à dire le point de l'image qui sera a l'endroit exact de la souris.

Code:: void paramInit(SDL_Surface*);

Même fonction, mais on prend toute l'image fournie et le centre significatif est placé en (0,0) sur l'image donnée.

Code:: void newParam(int,int,int,int,SDL_Surface*,int,int,int,int,int,int);

Ajoute un nouveau paramètre de la souris. en fait ceci permet de définir des zones dans lesquelles le curseur de la souris sera différent du curseur par défaut (défini par paramInit)
Les paramètres sont:
Les coordonnées x,y,larg,haut de la nouvelle zone, les paramètre suivant sont les meme que ci-dessus.

Code:: void newParam(int,int,int,int,SDL_Surface*);

Même variante que ci-dessus.

Code:: bool inRect(int,int,int,int);

renvoie true si la souris est dans le rectangle dont les coordonnées sont données.

Code:: void blit(SDL_Surface*);

Colle l'image de la souris sur la surface donnée.

La souris est actualisée par la fonction

Code:: void UpdateEvents();

ui sera décrite dans le fichier "scrabble_graphisme.cpp"

*A nouveau, la classe

Code:: class Champ;

n'est pas utilisable par l'utilisateur, mais uniquement pour la classe

Code:: class Clavier;

*Utilisation de la classe class Clavier:

Constructeur: vous lui fournissez le type de clavier que vous voulez utiliser (clavier francais, belge, anglais (voir dans les #include en haut de fichier)). Pour l'instant, seul le clavier belge est utilisable. Si vous voulez utiliser les autres, vous pouvez soit attendre tois ans et demi que je trouve le courrage de le faire, soit le coder vous meme en comprennant ce que j'ai fait pour la clavier Belge.

Code:: bool key(int);

renvoie true si la touche spécifiée est enfoncée.

Code:: int waitKey();

Attend que l'utilisateur presse une touche, et renvoie cette touche.

Code:: void writeIn(char*,int,int,int);

Permet de stoquer ce qui est tappé au clavier dans un vecteur fourni en premier paramètre. Les autres paramètres sont la longueur du texte, la longeur max permise, et l'endroit ou se trouve le curseur.
Un seul vecteur peut etre sélectionné à la fois...

Code:: void stopWrite();

Arrete d'écrire.
(notons que l'arret d'écriture était déja possible par la pression de l'utilisateur sur ENTER ou ESC)

Code:: int type();

Renvoie le type de clavier utilisé.

Code:: void type(int);

Modifie le type de clavier utilisé.

L'actualisation du clavier est faite par la fonction

Code:: void UpdateEvents();

*Et encore une fois, vous ne devez pas utiliser la classe

Code:: class strblitpt

*Utilisation de la classe Bouton:

Constructeur: vous fournissez les dimentions du bouton (largeur, hauteur)

Code:: void addSurface(int,int,int,SDL_Surface*,int,int,int,int);

Ajoute une surface pour le bouton.
Les paramètres sont:
L'état du bouton (normal, avec la souris dessus, cliqué,...), l'endroit (x,y) sur le bouton, puis l'image et ses dimentions...

Le reste en en commentaires dans la source...

J'ai oublier le zip...
J'en ferai un demain et je le posterai ici...

Nombre de messages : 57 Date d'inscription : 10/02/2006

Bonjour j ai commencer le developpement de mon loader de fichier .x, et je voudrais des conseils sur des choses peut etre a arranger ou autres.

Voici le fichier .h : http://rafb.net/paste/results/cR2fOb72.html
Voici le fichier .cpp : http://rafb.net/paste/results/irXZq727.html

deja comment je pourrais ameliorer les char ? (c est tres moche la)

enfin si vous voyez des trucs a ameliorer n hesite pas, car il doit y en avoir une belle liste Wink

» Format des fichiers sources