game: remove useless checks

it is safe to pass a null pointer to SDL_FreeSurface()

BTW: change the format of the files from dos to unix

Signed-off-by: Olivier Gayot <duskcoder@gmail.com>

1 files changed, 350 insertions, 382 deletions

diff --git a/main.c b/main.c
index 3406771..864e329 100644
--- a/main.c
+++ b/main.c
@@ -1,382 +1,350 @@
-/* ********************************************************************

-    WARCRAFT BATTLE : Jeu au tour par tour similaire à Final Fantasy

-    développé entièrement par moi :p pour le plaisir^^

-    Je sais c'est du beau quand même sa fait plaisir de faire un programme

-    assez complet avec pour seule aide un clavier et une souris (et encore là

-    j'ai pas de souris je programme sur pc portable xD)

-    Enfin bref voilà ma création :)

-    Fais en bon usage et bon jeu à toi ;)

-

-PS : Et surtout copyright :p pas touche à mon code pas de désassemblage ni rien

-hein ;) MON PROGRAMME ! :o)

-

-@+++ amuse toi bien */

-

-

-

-#include <stdlib.h>

-#include <stdio.h>

-#include <SDL/SDL.h>

-#include "structures.h"

-#include "constantes.h"

-#include <SDL/SDL_image.h>

-#include <SDL/SDL_ttf.h>

-#include "prototypes.h"

-#include <time.h>

-

-int main (int argc, char *argv[])

-{

-    srand (time(NULL));

-    SURFACES surfaces;

-    POSITIONS positions;

-    Finitialisersurfaces (&surfaces);

-    if (SDL_Init (SDL_INIT_VIDEO) == -1)

-    {

-        fprintf(stderr, "Erreur lors de l'ouverture de la SDL : %s", SDL_GetError());

-        exit (EXIT_FAILURE);

-    }

-    surfaces.Pecran = SDL_SetVideoMode (XWIN,YWIN,32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_NOFRAME|SDL_FULLSCREEN);

-    if (surfaces.Pecran == NULL)

-    {

-        fprintf(stderr,"Impossible de charger la mémoire vidéo : %s", SDL_GetError());

-        exit (EXIT_FAILURE);

-    }

-    SDL_EnableUNICODE (1);

-    TTF_Init();

-    SDL_WM_SetCaption ("WARCRAFT BATTLE",NULL);

-    SDL_ShowCursor(SDL_DISABLE);

-    Fchargerimages (&surfaces);

-    Finitialiserpositions (&positions,&surfaces);

-    Fmenuprincipal (&surfaces, &positions);

-

-

-    //une fois le jeu quitté

-    Fdechargerimages (&surfaces);

-    SDL_EnableUNICODE (0);

-    TTF_Quit();

-    SDL_Quit();

-

-

-    return 0;

-}

-

-void Finitialisersurfaces (SURFACES *surfaces)

-{

-    int i;

-    surfaces->Pcurseurennemis=NULL;

-    surfaces->Pcurseurallies=NULL;

-    surfaces->Pchoixvoleur=NULL;

-    surfaces->Pchoixpretre=NULL;

-    surfaces->Pchoixpaladin=NULL;

-    surfaces->Pecran=NULL;

-    surfaces->Pgobelin=NULL;

-    surfaces->Ppaladin=NULL;

-    surfaces->Ppretre=NULL;

-    surfaces->Pvoleur=NULL;

-    surfaces->Pmenujouer=NULL;

-    surfaces->Pmenuoptions=NULL;

-    surfaces->Pmenuquitter=NULL;

-    surfaces->Pfondjeu=NULL;

-    surfaces->Ppvpersos=NULL;

-    surfaces->Ppmpersos=NULL;

-    for (i=0;i<3;i++)

-        surfaces->Tperso[i]=NULL;

-    for (i=0;i<5;i++)

-        surfaces->Tennemi[i]=NULL;

-    for (i=0;i<3;i++)

-        surfaces->Pnomactions[i]=NULL;

-    surfaces->Ptextechoixmenu=NULL;

-    surfaces->Pnbdegats=NULL;

-    surfaces->Pcadrecible=NULL;

-    surfaces->Pnomcible=NULL;

-    surfaces->Pactive=NULL;

-    surfaces->Pdesactive=NULL;

-    surfaces->Ppvcible=NULL;

-    surfaces->Ppmcible=NULL;

-    surfaces->Pcadreactions=NULL;

-    surfaces->Pactionselectionnee=NULL;

-    surfaces->Pactiondesactivee=NULL;

-    surfaces->Pmort=NULL;

-    for (i=0;i<3;i++)

-        surfaces->Pquantite[i]=NULL;

-}

-

-void Finitialiserpositions (POSITIONS *positions, SURFACES *surfaces)

-{

-    int i,y=0,z=0;

-    positions->Vpositionmenu.x = 0;

-    positions->Vpositionmenu.y = 0;

-    positions->Vpositionmenupretre.x = XWIN/2 - surfaces->Ppretre->w/2;

-    positions->Vpositionmenupretre.y = YWIN - 20 - surfaces->Ppretre->h;

-    positions->Vpositionmenupaladin.x = positions->Vpositionmenupretre.x/2 - surfaces->Ppaladin->w/2;

-    positions->Vpositionmenupaladin.y = YWIN - 20 - surfaces->Ppaladin->h;

-    positions->Vpositionmenuvoleur.x = XWIN/4*3 - surfaces->Pvoleur->w/2;

-    positions->Vpositionmenuvoleur.y = YWIN - 20 - surfaces->Pvoleur->h;

-    positions->Vpositiontextemenu.y = 362;

-    positions->Vpositioncurseurennemis.x=1024;

-    positions->Vpositioncurseurennemis.y=768;

-    positions->Vpositioncurseurallies.x=1024;

-    positions->Vpositioncurseurallies.y=768;

-    positions->Vpositioncurseurennemis.w = surfaces->Pcurseurennemis->w;

-    positions->Vpositioncurseurennemis.h = surfaces->Pcurseurennemis->h;

-    positions->Vpositioncadrecible.y = 15;

-    positions->Vpositioncadrecible.x = XWIN/2-50-surfaces->Pcadrecible->w/2;

-    positions->Vpositioncadrecible.w = surfaces->Pcadrecible->w;

-    positions->Vpositioncadrecible.h = surfaces->Pcadrecible->h;

-    positions->Vpositioncadreactions.y = YWIN-surfaces->Pcadreactions->h;

-    positions->Vpositioncadreactions.x = XWIN/2-50-surfaces->Pcadreactions->w/2;

-    positions->Vpositioncadreactions.w = surfaces->Pcadreactions->w;

-    positions->Vpositioncadreactions.h = surfaces->Pcadreactions->h;

-    positions->Vpositionpvcible.x = 380;

-    positions->Vpositionpvcible.y = 185;

-    positions->Vpositionpmcible.x = 545;

-    positions->Vpositionpmcible.y = 185;

-    positions->Vpositiondegats.x=1024;

-    positions->Vpositiondegats.y=768;

-    for(i=0;i<3;i++)

-    {

-        positions->Vpositionactionselectionnee[i].x=positions->Vpositioncadreactions.x+5;

-        positions->Vpositionactionselectionnee[i].y=positions->Vpositioncadreactions.y+5+44*i;

-        positions->Vpositionnomactions[i].x=positions->Vpositioncadreactions.x+15;

-        positions->Vpositionnomactions[i].y=positions->Vpositioncadreactions.y+12+44*i;

-        positions->Vpositionquantite[i].y=positions->Vpositionnomactions[i].y;

-        positions->Vpositionquantite[i].x=positions->Vpositioncadreactions.x+surfaces->Pcadreactions->w-45;

-    }

-    for (i=0;i < 16;i++)

-    {

-        positions->Vpositionactivedesactive[i].x = 471+51*y;

-        positions->Vpositionactivedesactive[i].y = 101+19*z;

-        if (y < 3)

-            y++;

-        else

-        {

-            y=0;

-            z++;

-        }

-    }

-}

-

-void Fchargerimages (SURFACES *surfaces)

-{

-    int i;

-    surfaces->Pgobelin = IMG_Load ("images/gobelin.bmp");

-    surfaces->Ppaladin = IMG_Load ("images/paladin.bmp");

-    surfaces->Ppretre = IMG_Load ("images/prêtre.bmp");

-    surfaces->Pvoleur = IMG_Load ("images/voleur.bmp");

-    surfaces->Pmenujouer = IMG_Load ("images/menu_principal/jouer.bmp");

-    surfaces->Pmenuoptions = IMG_Load ("images/menu_principal/options.bmp");

-    surfaces->Pmenuquitter = IMG_Load ("images/menu_principal/quitter.bmp");

-    surfaces->Pchoixvoleur = IMG_Load ("images/menu_choix_classe/voleur.bmp");

-    surfaces->Pchoixpretre = IMG_Load ("images/menu_choix_classe/pretre.bmp");

-    surfaces->Pchoixpaladin = IMG_Load ("images/menu_choix_classe/paladin.bmp");

-    surfaces->Pcurseurennemis = IMG_Load ("images/jeu/curseur.bmp");

-    surfaces->Pcurseurallies = IMG_Load ("images/jeu/curseurpersos.bmp");

-    surfaces->Pcadrecible = IMG_Load ("images/jeu/cadre_cible.bmp");

-    surfaces->Pactive = IMG_Load ("images/jeu/active.bmp");

-    surfaces->Pdesactive = IMG_Load ("images/jeu/desactive.bmp");

-    surfaces->Pcadreactions = IMG_Load ("images/jeu/cadre_actions.bmp");

-    surfaces->Pactionselectionnee=IMG_Load ("images/jeu/cadre_actions_select.bmp");

-    surfaces->Pactiondesactivee=IMG_Load("images/jeu/cadre_actions_unactive.bmp");

-    surfaces->Pmort=IMG_Load("images/jeu/mort.bmp");

-    for (i = 0;i < 5;i++)

-        surfaces->Tennemi[i] = surfaces->Pgobelin;

-

-    //définition de la transparence alpha dans les surfaces

-    SDL_SetColorKey(surfaces->Pgobelin,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,0,255,18));

-    SDL_SetColorKey(surfaces->Ppretre,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,39,189,31));

-    SDL_SetColorKey(surfaces->Ppaladin,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,189,31,31));

-    SDL_SetColorKey(surfaces->Pvoleur,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,39,189,31));

-    SDL_SetColorKey(surfaces->Pcurseurennemis,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));

-    SDL_SetColorKey(surfaces->Pcurseurallies,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));

-    SDL_SetColorKey(surfaces->Pactive,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));

-    SDL_SetColorKey(surfaces->Pdesactive,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));

-    SDL_SetColorKey(surfaces->Pmort,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));

-}

-

-void Fdechargerimages (SURFACES *surfaces)//dechargement des surfaces alouées

-{

-    int i;

-    if(surfaces->Pecran!=NULL)

-        SDL_FreeSurface(surfaces->Pecran);

-    if(surfaces->Pgobelin!=NULL)

-        SDL_FreeSurface (surfaces->Pgobelin);

-    if(surfaces->Ppaladin!=NULL)

-        SDL_FreeSurface (surfaces->Ppaladin);

-    if(surfaces->Ppretre!=NULL)

-        SDL_FreeSurface (surfaces->Ppretre);

-    if(surfaces->Pvoleur!=NULL)

-        SDL_FreeSurface (surfaces->Pvoleur);

-    if(surfaces->Pmenujouer!=NULL)

-        SDL_FreeSurface (surfaces->Pmenujouer);

-    if(surfaces->Pmenuoptions!=NULL)

-        SDL_FreeSurface (surfaces->Pmenuoptions);

-    if(surfaces->Pmenuquitter!=NULL)

-        SDL_FreeSurface (surfaces->Pmenuquitter);

-    if(surfaces->Pchoixpretre!=NULL)

-        SDL_FreeSurface (surfaces->Pchoixpretre);

-    if(surfaces->Ppaladin!=NULL)

-        SDL_FreeSurface (surfaces->Pchoixpaladin);

-    if(surfaces->Pvoleur!=NULL)

-        SDL_FreeSurface (surfaces->Pchoixvoleur);

-    if(surfaces->Pcurseurennemis!=NULL)

-        SDL_FreeSurface (surfaces->Pcurseurennemis);

-    if(surfaces->Pcurseurallies!=NULL)

-        SDL_FreeSurface (surfaces->Pcurseurallies);

-    if(surfaces->Pcadrecible!=NULL)

-        SDL_FreeSurface (surfaces->Pcadrecible);

-    if(surfaces->Pactive!=NULL)

-        SDL_FreeSurface (surfaces->Pactive);

-    if(surfaces->Pdesactive!=NULL)

-        SDL_FreeSurface (surfaces->Pdesactive);

-    if(surfaces->Pcadreactions!=NULL)

-        SDL_FreeSurface (surfaces->Pcadreactions);

-    if(surfaces->Pactionselectionnee!=NULL)

-        SDL_FreeSurface (surfaces->Pactionselectionnee);

-    if(surfaces->Pactionselectionnee!=NULL)

-        SDL_FreeSurface (surfaces->Pactiondesactivee);

-    if(surfaces->Pmort!=NULL)

-        SDL_FreeSurface (surfaces->Pmort);

-    if(surfaces->Pfondjeu != NULL)

-        SDL_FreeSurface (surfaces->Pfondjeu);

-    if(surfaces->Ptextechoixmenu!=NULL)

-        SDL_FreeSurface(surfaces->Ptextechoixmenu);

-    if(surfaces->Pnbdegats!=NULL)

-        SDL_FreeSurface(surfaces->Pnbdegats);

-    if(surfaces->Pnomcible!=NULL)

-        SDL_FreeSurface(surfaces->Pnomcible);

-    if(surfaces->Ppvcible!=NULL)

-        SDL_FreeSurface(surfaces->Ppvcible);

-    if(surfaces->Ppmcible!=NULL)

-        SDL_FreeSurface(surfaces->Ppmcible);

-    if(surfaces->Ppvpersos!=NULL)

-        SDL_FreeSurface(surfaces->Ppvpersos);

-    if(surfaces->Ppmpersos!=NULL)

-        SDL_FreeSurface(surfaces->Ppmpersos);

-    for(i = 0;i < 3;i++)

-    {

-        if(surfaces->Tperso[i]!=NULL)

-            SDL_FreeSurface(surfaces->Tperso[i]);

-    }

-    for(i=0;i<5;i++)

-    {

-        if(surfaces->Tennemi[i]!=NULL)

-            SDL_FreeSurface(surfaces->Tennemi[i]);

-    }

-    for(i=0;i<3;i++)

-    {

-        if(surfaces->Pnomactions[i]!=NULL)

-            SDL_FreeSurface (surfaces->Pnomactions[i]);

-    }

-    for(i=0;i<3;i++)

-    {

-        if(surfaces->Pquantite[i]!=NULL)

-            SDL_FreeSurface (surfaces->Pquantite[i]);

-    }

-}

-

-void inverse(int *bool)

-{

-    if (*bool)

-        *bool=0;

-    else if (!*bool)

-        *bool=1;

-}

-

-

-/* ********************************************************************* */

-/*obtenirPixel : permet de récupérer la couleur d'un pixel

-Paramètres d'entrée/sortie :

-SDL_Surface *surface : la surface sur laquelle on va récupérer la couleur d'un pixel

-int x : la coordonnée en x du pixel à récupérer

-int y : la coordonnée en y du pixel à récupérer

-

-Uint32 resultat : la fonction renvoie le pixel aux coordonnées (x,y) dans la surface

-*/

-Uint32 obtenirPixel(SDL_Surface *surface, int x, int y)

-{

-    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.

-    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur

-    de l'image : 8, 16, 24 ou 32 bits.*/

-    int nbOctetsParPixel = surface->format->BytesPerPixel;

-    /* Ici p est l'adresse du pixel que l'on veut connaitre */

-    /*surface->pixels contient l'adresse du premier pixel de l'image*/

-    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

-

-    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/

-    switch(nbOctetsParPixel)

-    {

-        case 1:

-            return *p;

-

-        case 2:

-            return *(Uint16 *)p;

-

-        case 3:

-            /*Suivant l'architecture de la machine*/

-            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)

-                return p[0] << 16 | p[1] << 8 | p[2];

-            else

-                return p[0] | p[1] << 8 | p[2] << 16;

-

-        case 4:

-            return *(Uint32 *)p;

-

-        /*Ne devrait pas arriver, mais évite les erreurs*/

-        default:

-            return 0;

-    }

-}

-

-/* ********************************************************************* */

-/*definirPixel : permet de modifier la couleur d'un pixel

-Paramètres d'entrée/sortie :

-SDL_Surface *surface : la surface sur laquelle on va modifier la couleur d'un pixel

-int x : la coordonnée en x du pixel à modifier

-int y : la coordonnée en y du pixel à modifier

-Uint32 pixel : le pixel à insérer

-*/

-void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)

-{

-    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.

-    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur

-    de l'image : 8, 16, 24 ou 32 bits.*/

-    int nbOctetsParPixel = surface->format->BytesPerPixel;

-    /*Ici p est l'adresse du pixel que l'on veut modifier*/

-    /*surface->pixels contient l'adresse du premier pixel de l'image*/

-    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;

-

-    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/

-    switch(nbOctetsParPixel)

-    {

-        case 1:

-            *p = pixel;

-            break;

-

-        case 2:

-            *(Uint16 *)p = pixel;

-            break;

-

-        case 3:

-            /*Suivant l'architecture de la machine*/

-            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)

-            {

-                p[0] = (pixel >> 16) & 0xff;

-                p[1] = (pixel >> 8) & 0xff;

-                p[2] = pixel & 0xff;

-            }

-            else

-            {

-                p[0] = pixel & 0xff;

-                p[1] = (pixel >> 8) & 0xff;

-                p[2] = (pixel >> 16) & 0xff;

-            }

-            break;

-

-        case 4:

-            *(Uint32 *)p = pixel;

-            break;

-    }

-}

-

-

-

+/* ********************************************************************
+    WARCRAFT BATTLE : Jeu au tour par tour similaire à Final Fantasy
+    développé entièrement par moi :p pour le plaisir^^
+    Je sais c'est du beau quand même sa fait plaisir de faire un programme
+    assez complet avec pour seule aide un clavier et une souris (et encore là
+    j'ai pas de souris je programme sur pc portable xD)
+    Enfin bref voilà ma création :)
+    Fais en bon usage et bon jeu à toi ;)
+
+PS : Et surtout copyright :p pas touche à mon code pas de désassemblage ni rien
+hein ;) MON PROGRAMME ! :o)
+
+@+++ amuse toi bien */
+
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <SDL/SDL.h>
+#include "structures.h"
+#include "constantes.h"
+#include <SDL/SDL_image.h>
+#include <SDL/SDL_ttf.h>
+#include "prototypes.h"
+#include <time.h>
+
+int main (int argc, char *argv[])
+{
+    srand (time(NULL));
+    SURFACES surfaces;
+    POSITIONS positions;
+    Finitialisersurfaces (&surfaces);
+    if (SDL_Init (SDL_INIT_VIDEO) == -1)
+    {
+        fprintf(stderr, "Erreur lors de l'ouverture de la SDL : %s", SDL_GetError());
+        exit (EXIT_FAILURE);
+    }
+    surfaces.Pecran = SDL_SetVideoMode (XWIN,YWIN,32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_NOFRAME|SDL_FULLSCREEN);
+    if (surfaces.Pecran == NULL)
+    {
+        fprintf(stderr,"Impossible de charger la mémoire vidéo : %s", SDL_GetError());
+        exit (EXIT_FAILURE);
+    }
+    SDL_EnableUNICODE (1);
+    TTF_Init();
+    SDL_WM_SetCaption ("WARCRAFT BATTLE",NULL);
+    SDL_ShowCursor(SDL_DISABLE);
+    Fchargerimages (&surfaces);
+    Finitialiserpositions (&positions,&surfaces);
+    Fmenuprincipal (&surfaces, &positions);
+
+
+    //une fois le jeu quitté
+    Fdechargerimages (&surfaces);
+    SDL_EnableUNICODE (0);
+    TTF_Quit();
+    SDL_Quit();
+
+
+    return 0;
+}
+
+void Finitialisersurfaces (SURFACES *surfaces)
+{
+    int i;
+    surfaces->Pcurseurennemis=NULL;
+    surfaces->Pcurseurallies=NULL;
+    surfaces->Pchoixvoleur=NULL;
+    surfaces->Pchoixpretre=NULL;
+    surfaces->Pchoixpaladin=NULL;
+    surfaces->Pecran=NULL;
+    surfaces->Pgobelin=NULL;
+    surfaces->Ppaladin=NULL;
+    surfaces->Ppretre=NULL;
+    surfaces->Pvoleur=NULL;
+    surfaces->Pmenujouer=NULL;
+    surfaces->Pmenuoptions=NULL;
+    surfaces->Pmenuquitter=NULL;
+    surfaces->Pfondjeu=NULL;
+    surfaces->Ppvpersos=NULL;
+    surfaces->Ppmpersos=NULL;
+    for (i=0;i<3;i++)
+        surfaces->Tperso[i]=NULL;
+    for (i=0;i<5;i++)
+        surfaces->Tennemi[i]=NULL;
+    for (i=0;i<3;i++)
+        surfaces->Pnomactions[i]=NULL;
+    surfaces->Ptextechoixmenu=NULL;
+    surfaces->Pnbdegats=NULL;
+    surfaces->Pcadrecible=NULL;
+    surfaces->Pnomcible=NULL;
+    surfaces->Pactive=NULL;
+    surfaces->Pdesactive=NULL;
+    surfaces->Ppvcible=NULL;
+    surfaces->Ppmcible=NULL;
+    surfaces->Pcadreactions=NULL;
+    surfaces->Pactionselectionnee=NULL;
+    surfaces->Pactiondesactivee=NULL;
+    surfaces->Pmort=NULL;
+    for (i=0;i<3;i++)
+        surfaces->Pquantite[i]=NULL;
+}
+
+void Finitialiserpositions (POSITIONS *positions, SURFACES *surfaces)
+{
+    int i,y=0,z=0;
+    positions->Vpositionmenu.x = 0;
+    positions->Vpositionmenu.y = 0;
+    positions->Vpositionmenupretre.x = XWIN/2 - surfaces->Ppretre->w/2;
+    positions->Vpositionmenupretre.y = YWIN - 20 - surfaces->Ppretre->h;
+    positions->Vpositionmenupaladin.x = positions->Vpositionmenupretre.x/2 - surfaces->Ppaladin->w/2;
+    positions->Vpositionmenupaladin.y = YWIN - 20 - surfaces->Ppaladin->h;
+    positions->Vpositionmenuvoleur.x = XWIN/4*3 - surfaces->Pvoleur->w/2;
+    positions->Vpositionmenuvoleur.y = YWIN - 20 - surfaces->Pvoleur->h;
+    positions->Vpositiontextemenu.y = 362;
+    positions->Vpositioncurseurennemis.x=1024;
+    positions->Vpositioncurseurennemis.y=768;
+    positions->Vpositioncurseurallies.x=1024;
+    positions->Vpositioncurseurallies.y=768;
+    positions->Vpositioncurseurennemis.w = surfaces->Pcurseurennemis->w;
+    positions->Vpositioncurseurennemis.h = surfaces->Pcurseurennemis->h;
+    positions->Vpositioncadrecible.y = 15;
+    positions->Vpositioncadrecible.x = XWIN/2-50-surfaces->Pcadrecible->w/2;
+    positions->Vpositioncadrecible.w = surfaces->Pcadrecible->w;
+    positions->Vpositioncadrecible.h = surfaces->Pcadrecible->h;
+    positions->Vpositioncadreactions.y = YWIN-surfaces->Pcadreactions->h;
+    positions->Vpositioncadreactions.x = XWIN/2-50-surfaces->Pcadreactions->w/2;
+    positions->Vpositioncadreactions.w = surfaces->Pcadreactions->w;
+    positions->Vpositioncadreactions.h = surfaces->Pcadreactions->h;
+    positions->Vpositionpvcible.x = 380;
+    positions->Vpositionpvcible.y = 185;
+    positions->Vpositionpmcible.x = 545;
+    positions->Vpositionpmcible.y = 185;
+    positions->Vpositiondegats.x=1024;
+    positions->Vpositiondegats.y=768;
+    for(i=0;i<3;i++)
+    {
+        positions->Vpositionactionselectionnee[i].x=positions->Vpositioncadreactions.x+5;
+        positions->Vpositionactionselectionnee[i].y=positions->Vpositioncadreactions.y+5+44*i;
+        positions->Vpositionnomactions[i].x=positions->Vpositioncadreactions.x+15;
+        positions->Vpositionnomactions[i].y=positions->Vpositioncadreactions.y+12+44*i;
+        positions->Vpositionquantite[i].y=positions->Vpositionnomactions[i].y;
+        positions->Vpositionquantite[i].x=positions->Vpositioncadreactions.x+surfaces->Pcadreactions->w-45;
+    }
+    for (i=0;i < 16;i++)
+    {
+        positions->Vpositionactivedesactive[i].x = 471+51*y;
+        positions->Vpositionactivedesactive[i].y = 101+19*z;
+        if (y < 3)
+            y++;
+        else
+        {
+            y=0;
+            z++;
+        }
+    }
+}
+
+void Fchargerimages (SURFACES *surfaces)
+{
+    int i;
+    surfaces->Pgobelin = IMG_Load ("images/gobelin.bmp");
+    surfaces->Ppaladin = IMG_Load ("images/paladin.bmp");
+    surfaces->Ppretre = IMG_Load ("images/prêtre.bmp");
+    surfaces->Pvoleur = IMG_Load ("images/voleur.bmp");
+    surfaces->Pmenujouer = IMG_Load ("images/menu_principal/jouer.bmp");
+    surfaces->Pmenuoptions = IMG_Load ("images/menu_principal/options.bmp");
+    surfaces->Pmenuquitter = IMG_Load ("images/menu_principal/quitter.bmp");
+    surfaces->Pchoixvoleur = IMG_Load ("images/menu_choix_classe/voleur.bmp");
+    surfaces->Pchoixpretre = IMG_Load ("images/menu_choix_classe/pretre.bmp");
+    surfaces->Pchoixpaladin = IMG_Load ("images/menu_choix_classe/paladin.bmp");
+    surfaces->Pcurseurennemis = IMG_Load ("images/jeu/curseur.bmp");
+    surfaces->Pcurseurallies = IMG_Load ("images/jeu/curseurpersos.bmp");
+    surfaces->Pcadrecible = IMG_Load ("images/jeu/cadre_cible.bmp");
+    surfaces->Pactive = IMG_Load ("images/jeu/active.bmp");
+    surfaces->Pdesactive = IMG_Load ("images/jeu/desactive.bmp");
+    surfaces->Pcadreactions = IMG_Load ("images/jeu/cadre_actions.bmp");
+    surfaces->Pactionselectionnee=IMG_Load ("images/jeu/cadre_actions_select.bmp");
+    surfaces->Pactiondesactivee=IMG_Load("images/jeu/cadre_actions_unactive.bmp");
+    surfaces->Pmort=IMG_Load("images/jeu/mort.bmp");
+    for (i = 0;i < 5;i++)
+        surfaces->Tennemi[i] = surfaces->Pgobelin;
+
+    //définition de la transparence alpha dans les surfaces
+    SDL_SetColorKey(surfaces->Pgobelin,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,0,255,18));
+    SDL_SetColorKey(surfaces->Ppretre,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,39,189,31));
+    SDL_SetColorKey(surfaces->Ppaladin,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,189,31,31));
+    SDL_SetColorKey(surfaces->Pvoleur,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,39,189,31));
+    SDL_SetColorKey(surfaces->Pcurseurennemis,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
+    SDL_SetColorKey(surfaces->Pcurseurallies,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
+    SDL_SetColorKey(surfaces->Pactive,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
+    SDL_SetColorKey(surfaces->Pdesactive,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
+    SDL_SetColorKey(surfaces->Pmort,SDL_SRCCOLORKEY,SDL_MapRGB(surfaces->Pecran->format,255,255,255));
+}
+
+void Fdechargerimages (SURFACES *surfaces)//dechargement des surfaces alouées
+{
+    int i;
+    SDL_FreeSurface(surfaces->Pecran);
+    SDL_FreeSurface (surfaces->Pgobelin);
+    SDL_FreeSurface (surfaces->Ppaladin);
+    SDL_FreeSurface (surfaces->Ppretre);
+    SDL_FreeSurface (surfaces->Pvoleur);
+    SDL_FreeSurface (surfaces->Pmenujouer);
+    SDL_FreeSurface (surfaces->Pmenuoptions);
+    SDL_FreeSurface (surfaces->Pmenuquitter);
+    SDL_FreeSurface (surfaces->Pchoixpretre);
+    SDL_FreeSurface (surfaces->Pchoixpaladin);
+    SDL_FreeSurface (surfaces->Pchoixvoleur);
+    SDL_FreeSurface (surfaces->Pcurseurennemis);
+    SDL_FreeSurface (surfaces->Pcurseurallies);
+    SDL_FreeSurface (surfaces->Pcadrecible);
+    SDL_FreeSurface (surfaces->Pactive);
+    SDL_FreeSurface (surfaces->Pdesactive);
+    SDL_FreeSurface (surfaces->Pcadreactions);
+    SDL_FreeSurface (surfaces->Pactionselectionnee);
+    SDL_FreeSurface (surfaces->Pactiondesactivee);
+    SDL_FreeSurface (surfaces->Pmort);
+    SDL_FreeSurface (surfaces->Pfondjeu);
+    SDL_FreeSurface(surfaces->Ptextechoixmenu);
+    SDL_FreeSurface(surfaces->Pnbdegats);
+    SDL_FreeSurface(surfaces->Pnomcible);
+    SDL_FreeSurface(surfaces->Ppvcible);
+    SDL_FreeSurface(surfaces->Ppmcible);
+    SDL_FreeSurface(surfaces->Ppvpersos);
+    SDL_FreeSurface(surfaces->Ppmpersos);
+    for(i = 0;i < 3;i++)
+    {
+        SDL_FreeSurface(surfaces->Tperso[i]);
+    }
+    for(i=0;i<5;i++)
+    {
+        SDL_FreeSurface(surfaces->Tennemi[i]);
+    }
+    for(i=0;i<3;i++)
+    {
+        SDL_FreeSurface (surfaces->Pnomactions[i]);
+    }
+    for(i=0;i<3;i++)
+    {
+        SDL_FreeSurface (surfaces->Pquantite[i]);
+    }
+}
+
+void inverse(int *bool)
+{
+    if (*bool)
+        *bool=0;
+    else if (!*bool)
+        *bool=1;
+}
+
+
+/* ********************************************************************* */
+/*obtenirPixel : permet de récupérer la couleur d'un pixel
+Paramètres d'entrée/sortie :
+SDL_Surface *surface : la surface sur laquelle on va récupérer la couleur d'un pixel
+int x : la coordonnée en x du pixel à récupérer
+int y : la coordonnée en y du pixel à récupérer
+
+Uint32 resultat : la fonction renvoie le pixel aux coordonnées (x,y) dans la surface
+*/
+Uint32 obtenirPixel(SDL_Surface *surface, int x, int y)
+{
+    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
+    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
+    de l'image : 8, 16, 24 ou 32 bits.*/
+    int nbOctetsParPixel = surface->format->BytesPerPixel;
+    /* Ici p est l'adresse du pixel que l'on veut connaitre */
+    /*surface->pixels contient l'adresse du premier pixel de l'image*/
+    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
+
+    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
+    switch(nbOctetsParPixel)
+    {
+        case 1:
+            return *p;
+
+        case 2:
+            return *(Uint16 *)p;
+
+        case 3:
+            /*Suivant l'architecture de la machine*/
+            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+                return p[0] << 16 | p[1] << 8 | p[2];
+            else
+                return p[0] | p[1] << 8 | p[2] << 16;
+
+        case 4:
+            return *(Uint32 *)p;
+
+        /*Ne devrait pas arriver, mais évite les erreurs*/
+        default:
+            return 0;
+    }
+}
+
+/* ********************************************************************* */
+/*definirPixel : permet de modifier la couleur d'un pixel
+Paramètres d'entrée/sortie :
+SDL_Surface *surface : la surface sur laquelle on va modifier la couleur d'un pixel
+int x : la coordonnée en x du pixel à modifier
+int y : la coordonnée en y du pixel à modifier
+Uint32 pixel : le pixel à insérer
+*/
+void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
+{
+    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
+    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
+    de l'image : 8, 16, 24 ou 32 bits.*/
+    int nbOctetsParPixel = surface->format->BytesPerPixel;
+    /*Ici p est l'adresse du pixel que l'on veut modifier*/
+    /*surface->pixels contient l'adresse du premier pixel de l'image*/
+    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
+
+    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
+    switch(nbOctetsParPixel)
+    {
+        case 1:
+            *p = pixel;
+            break;
+
+        case 2:
+            *(Uint16 *)p = pixel;
+            break;
+
+        case 3:
+            /*Suivant l'architecture de la machine*/
+            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+            {
+                p[0] = (pixel >> 16) & 0xff;
+                p[1] = (pixel >> 8) & 0xff;
+                p[2] = pixel & 0xff;
+            }
+            else
+            {
+                p[0] = pixel & 0xff;
+                p[1] = (pixel >> 8) & 0xff;
+                p[2] = (pixel >> 16) & 0xff;
+            }
+            break;
+
+        case 4:
+            *(Uint32 *)p = pixel;
+            break;
+    }
+}
+
+
+