Partage
  • Partager sur Facebook
  • Partager sur Twitter

Program received signal SIGSEGV, Segmentation fault.

BRUCELLA
    23 novembre 2007 à 12:14:17

    Bonjour,

    comme dit dans le titre, mon programme me renvoie un : "Program received signal SIGSEGV, Segmentation fault." J'ai lancé le debugger pour trouver d'où ça venait mais ne sachant pas trop comment m'en servir ni trop ce que signifie ce type de problème, je viens vous demander de l'aide.
    Voici ce que j'obtiens avec le débugger :

    Debugger name and version: GNU gdb 6.3
    Child process PID: 3524
    Program received signal SIGSEGV, Segmentation fault.
    In ntdll!RtlpWaitForCriticalSection () (ntdll.dll)
    In ntdll!LdrDisableThreadCalloutsForDll () (ntdll.dll)
    In ntdll!LdrFindCreateProcessManifest () (ntdll.dll)
    In ntdll!RtlCheckRegistryKey () (ntdll.dll)
    In ntdll!LdrFindCreateProcessManifest () (ntdll.dll)
    In ntdll!RtlCheckRegistryKey () (ntdll.dll)
    In ntdll!LdrFindCreateProcessManifest () (ntdll.dll)
    In ntdll!RtlUnhandledExceptionFilter () (ntdll.dll)
    In ntdll!LdrFindCreateProcessManifest () (ntdll.dll)
    In ntdll!RtlInitAnsiString () (ntdll.dll)
    In ntdll!RtlAppendStringToString () (ntdll.dll)
    In strchr () (ntdll.dll)
    In ntdll!RtlAppendStringToString () (ntdll.dll)
    Program received signal SIGSEGV, Segmentation fault.
    In ntdll!RtlpWaitForCriticalSection () (ntdll.dll)
    Debugger finished with status 0


    je met ici un lien vers mon dossier en .zip qui contient tous mes fichiers pour que ceux qui souhaitent m'aider puisse le faire : http://www.gigasize.com/get.php/3196072177/RPG_Creation.zip

    Ha une dernière information il me semble que le problème viennent dés le début de ma fonction Save_Sprites.

    Si quelqu'un pouvait m'aider ça serait super, je commence à m'arracher les cheveux à ne pas voir d'où vient le problème...

    Merci par avance
    • Partager sur Facebook
    • Partager sur Twitter
    Vince33
      23 novembre 2007 à 13:06:45

      Salut,

      Je te conseil de publier ton code avec les balises zcode. Tu auras beaucoup plus de réponses.
      • Partager sur Facebook
      • Partager sur Twitter
      BRUCELLA
        23 novembre 2007 à 13:14:03

        Bon ba galère mais bon puisque qu'il faut mettre le code dans des balises allons-y ... mais pour les images et autre fichier lié au code je fais comment ? entre balise ? :p

        alors le main.c
        1. /*
        2. ** Projet commencé le 13/10/07
        3. **
        4. ** Dernière modfification : 21/11/07
        5. **
        6. ** main.c
        7. **
        8. ** Fichier principal
        9. **
        10. ** Role :
        11. ** - initialisation des bibliothèques
        12. ** - fonction main()
        13. **
        14. */
        15. #include "main.h"
        16. int main(int argc, char* argv[])
        17. {
        18.     SDL_Event evenement;
        19.     S_Carte Carte;
        20.     S_lib_sprite lib_sprite;
        21.     unsigned int fin=0;
        22.     /* initialisation de SDL, FMOD et autres */
        23.     if(Init()>0)
        24.     {
        25.         return 1;
        26.     }
        27.     /* lancement de la fonction aléatoire pour initialisé la carte
        28.     Carte_Aleatoire(&Carte, 100, 100, "tuiles\\mchip0.bmp"); */
        29.     /* sauvegarde la carte aléatoire
        30.     Save_Carte(&Carte, "map\\save.map", "musique\\Opening1.mid", "tuiles\\mchip0.bmp"); */
        31.     Initialisation_Sprites(&lib_sprite);
        32.     Sprites_DonneesStatic(&lib_sprite);
        33.     Save_Sprites(&lib_sprite, "sprites\\player.bmp", "map\\truc.txt");
        34.     /*
        35.     Load_Sprites(&lib_sprite, "map\\01.sprite");
        36.     Load_Carte(&Carte, "map\\01.map");*/
        37.     SDL_EnableKeyRepeat(10,10);
        38.     /* gestion des événements */
        39.     while(!fin)
        40.     {
        41.         while(SDL_PollEvent (&evenement))
        42.         {
        43.             /* lancement de la gestion des événements de la carte */
        44.             Evenement_Carte(&evenement, &Carte);
        45.             Event_SpriteJoueur(&evenement, &Carte, &lib_sprite);
        46.             /* gestion des événements du main */
        47.             switch (evenement.type)
        48.             {
        49.                 case SDL_KEYDOWN:
        50.                     switch (evenement.key.keysym.sym)
        51.                     {
        52.                         case SDLK_ESCAPE:
        53.                             fin=1;
        54.                             break;
        55.                         case SDLK_F1:
        56.                             SDL_SaveBMP(SDL_GetVideoSurface(), "screenshot.bmp");
        57.                             break;
        58.                         default:
        59.                             ;
        60.                     }
        61.                     break;
        62.                 case SDL_QUIT:
        63.                     fin=1;
        64.                     break;
        65.                 default:
        66.                     ;
        67.             }
        68.         }
        69.         /* affichage de la carte */
        70.         Affichage_Carte(&Carte);
        71.         Affichage_GlobalSprites(&lib_sprite, &Carte);
        72.         SDL_Flip(SDL_GetVideoSurface());
        73.     }
        74.     Liberation_Carte(&Carte);
        75.     Free_Sprites(&lib_sprite);
        76.     return 0;
        77. }


        le main.h
        1. #ifndef MAIN_H_INCLUDED
        2. #define MAIN_H_INCLUDED
        3. #include <SDL/SDL.h>
        4. #include <FMOD/fmod.h>
        5. #include <FMOD/fmod_errors.h>
        6. #include <stdio.h>
        7. #include <stdlib.h>
        8. #include "carte.h"
        9. #include "sprites.h"
        10. /*
        11. ** Prototype des fonctions du main.c
        12. */
        13. int Init(void);
        14. void Sortie(void);
        15. /*
        16. **initialisation de SDL et FMOD**
        17. */
        18. int Init(void)
        19. {
        20.     /* ecran pointera vers la surface représentant la fenêtre de l'application */
        21.     SDL_Surface *ecran=NULL;
        22.     /* appel la fonction Free quand on quitte le programme */
        23.     atexit(Sortie);
        24.     /* initialisation de video SDL */
        25.     if(SDL_Init(SDL_INIT_VIDEO)==-1)
        26.     {
        27.         perror("l'initialisation de la SDL n'a pas réussit, erreur");
        28.         exit(EXIT_FAILURE);
        29.     }
        30.     /* initialisation de la fenêtre */
        31.     ecran=SDL_SetVideoMode(LARGEUR_AFFICHAGE, HAUTEUR_AFFICHAGE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
        32.     if (ecran==NULL)
        33.     {
        34.         perror("erreur lors de l'initialisation de la fenetre");
        35.         exit(EXIT_FAILURE);
        36.     }
        37.     /* titre de la fenêtre et de l'icone */
        38.     SDL_WM_SetCaption("RPG Creation", "RPG Creation");
        39.     /* initialisation de FMOD
        40.     ** mais avant vérification de la version de FMOD.h et de la FMOD.dll*/
        41.     if(FSOUND_GetVersion () < FMOD_VERSION)
        42.     {
        43.         fprintf(stderr, "mauvaise version de la bibliothèque FMOD, utilisez la version %.02f", FMOD_VERSION);
        44.         exit(EXIT_FAILURE);
        45.     }
        46.     if(!FSOUND_Init(32000, 32, 0))
        47.     {
        48.         fprintf(stderr, "Erreur d'initialisation de FSOUND : %s\n", FMOD_ErrorString(FSOUND_GetError()));
        49.         exit(EXIT_FAILURE);
        50.     }
        51.     return 0;
        52. }
        53. /*
        54. **libération du programme**
        55. */
        56. void Sortie()
        57. {
        58.     SDL_Quit();
        59. }
        60. #endif /* MAIN_H_INCLUDED */


        ensuite le carte.c
        1. /*
        2. ** Dernière modification le 23/10/07
        3. **
        4. ** carte.c
        5. **
        6. ** Gestion des cartes
        7. **
        8. ** Roles :
        9. **
        10. ** - chargement / sauvegardes des cartes
        11. ** - affichage des cartes
        12. ** - génération aléatoire d'une carte
        13. ** - affichage de la carte
        14. ** - chargement d'une carte
        15. ** - gestion événement de la carte
        16. **
        17. */
        18. #include "carte.h"
        19. /************************
        20. ** Initiation de Carte **
        21. ************************/
        22. void Initialisation_Carte(S_Carte *Carte)
        23. {
        24.     Carte->largeur = Carte->hauteur = Carte->nb_Tuiles = Carte->decalageX = Carte->decalageY = 0;
        25.     Carte->donnees = NULL;
        26.     Carte->surface_GroupeTuiles=NULL;
        27.     Carte->musique_DeFond=NULL;
        28. }
        29. /**************************************
        30. ** Liberation des pointeurs de carte **
        31. **************************************/
        32. void Liberation_Carte(S_Carte *Carte)
        33. {
        34.     SDL_FreeSurface(Carte->surface_GroupeTuiles);
        35.     free(Carte->donnees);
        36.     free(Carte->pointeur_SurGroupeTuiles);
        37.     FMUSIC_StopSong(Carte->musique_DeFond);
        38.     free(Carte->musique_DeFond);
        39. }
        40. /*************************************
        41. ** Génération Aléatoire d'une carte **
        42. *************************************/
        43. void Carte_Aleatoire (struct S_Carte *Carte, unsigned int largeur_Carte, unsigned int hauteur_Carte, char const *tuiles)
        44. {
        45.     unsigned int i=0;
        46.     unsigned int x=0;
        47.     unsigned int y=0;
        48.     /* initialisation de la fonction aléatoire */
        49.     srand(time(NULL));
        50.     /* Initiation de la carte */
        51.     Initialisation_Carte(Carte);
        52.     /* Chargement de la surface contenant les tuiles (Groupe_Tuiles)
        53.     ** Réglage transparence de cette surface en fixant la couleur de transparence
        54.     */
        55.     Carte->surface_GroupeTuiles=SDL_LoadBMP(tuiles);
        56.     SDL_SetColorKey(Carte->surface_GroupeTuiles, SDL_SRCCOLORKEY, SDL_MapRGB(Carte->surface_GroupeTuiles->format, 8, 33, 82));
        57.     /* Calcul du nombre de tuiles pouvant être utilisés dans la carte */
        58.     Carte->nb_Tuiles=(Carte->surface_GroupeTuiles->h/HAUTEUR_TUILE)*(Carte->surface_GroupeTuiles->w/LARGEUR_TUILE);
        59.     /* Allocation dynamique du tableau contenant les caractéristiques des tuiles */
        60.     Carte->pointeur_SurGroupeTuiles=calloc (Carte->nb_Tuiles, sizeof *Carte->pointeur_SurGroupeTuiles);
        61.     /* Remplissage du tableau des caractéristiques des tuiles de la carte */
        62.     for (i=0; i<Carte->nb_Tuiles; i++)
        63.     {
        64.         Carte->pointeur_SurGroupeTuiles[i].x=x;
        65.         Carte->pointeur_SurGroupeTuiles[i].y=y;
        66.         Carte->pointeur_SurGroupeTuiles[i].collision= 0;
        67.         Carte->pointeur_SurGroupeTuiles[i].tuile_Suivante= 0;
        68.         x=x+LARGEUR_TUILE;
        69.         if (x>(Carte->surface_GroupeTuiles->w-LARGEUR_TUILE))
        70.         {
        71.             x=0;
        72.             y=y+HAUTEUR_TUILE;
        73.         }
        74.     }
        75.     /* Définition largeur et hauteur de la carte */
        76.     Carte->largeur = largeur_Carte;
        77.     Carte->hauteur = hauteur_Carte;
        78.     /* Allocation dynamique du tableau de données de la carte */
        79.     Carte->donnees=malloc (Carte->largeur * Carte->hauteur * sizeof *Carte->donnees);
        80.     /* Remplissage du tableau données de la carte */
        81.     for(x=0; x<Carte->largeur; x++)
        82.     {
        83.         for (y=0; y<Carte->hauteur; y++)
        84.         {
        85.             Carte->donnees[x+y*Carte->largeur] = rand()%(Carte->nb_Tuiles);
        86.         }
        87.     }
        88. }
        89. /***************************
        90. ** Affichage de la carte
        91. ***************************/
        92. void Affichage_Carte(struct S_Carte *Carte)
        93. {
        94.     int x, y, tx, ty;
        95.     SDL_Rect source, destination;
        96.     y=-(Carte->decalageY%HAUTEUR_TUILE);
        97.     ty=Carte->decalageY/HAUTEUR_TUILE;
        98.     while (y<HAUTEUR_AFFICHAGE)
        99.     {
        100.         x=-(Carte->decalageX%LARGEUR_TUILE);
        101.         tx=Carte->decalageX/LARGEUR_TUILE;
        102.         while (x<LARGEUR_AFFICHAGE)
        103.         {
        104.             source.x=Carte->pointeur_SurGroupeTuiles[GET_TUILE(tx,ty,Carte)].x;
        105.             source.y=Carte->pointeur_SurGroupeTuiles[GET_TUILE(tx,ty,Carte)].y;
        106.             destination.x=x;
        107.             destination.y=y;
        108.             source.w=destination.w=LARGEUR_TUILE;
        109.             source.h=destination.h=HAUTEUR_TUILE;
        110.             /* affichage après déplacement affichage via les flèches */
        111.             if (destination.x<0)
        112.             {
        113.                 source.x-=x;
        114.                 source.w+=x;
        115.                 destination.w+=x;
        116.                 destination.x=0;
        117.             }
        118.             if (destination.y<0)
        119.             {
        120.                 source.y-=y;
        121.                 source.h+=y;
        122.                 destination.h+=y;
        123.                 destination.y=0;
        124.             }
        125.             /* Blit des surface */
        126.             SDL_BlitSurface(Carte->surface_GroupeTuiles, &source, SDL_GetVideoSurface(), &destination);
        127.             x+=LARGEUR_TUILE;
        128.             tx++;
        129.         }
        130.         y+=HAUTEUR_TUILE;
        131.         ty++;
        132.     }
        133. }
        134. /************************
        135. ** Sauvegarde de carte **
        136. ************************/
        137. void Save_Carte (struct S_Carte *Carte, char const *nom_Fichier, char const *musique_DeFond, char const *image_Tuiles)
        138. {
        139.     FILE *fichier=NULL;
        140.     unsigned int i, x, y;
        141.     char tampon [256];
        142.     /* test de carte */
        143.     if (!Carte)
        144.     {
        145.         printf ("pas carte à sauvegarder");
        146.         return;
        147.     }
        148.     /* ouverture du fichier de sauvegarde et test de l'ouverture */
        149.     fichier=fopen(nom_Fichier, "wb");
        150.     if (!fichier)
        151.     {
        152.         printf("problème d'ouverture de fichier de sauvegarde");
        153.         return;
        154.     }
        155.     /* save de la musique de fond */
        156.     memset(&tampon, 0, sizeof(tampon));
        157.     strcpy(tampon, musique_DeFond);
        158.     fwrite(&tampon, 255, sizeof(char), fichier);
        159.     /* save de l'image des tuiles utilisés */
        160.     memset (&tampon, 0, sizeof(tampon));
        161.     strcpy(tampon, image_Tuiles);
        162.     fwrite(&tampon, 255, sizeof(char), fichier);
        163.     /* save des composantes de base de la carte */
        164.     fwrite(&Carte->largeur, 1, sizeof(unsigned int), fichier);
        165.     fwrite(&Carte->hauteur, 1, sizeof(unsigned int), fichier);
        166.     fwrite(&Carte->nb_Tuiles, 1, sizeof(unsigned int), fichier);
        167.     fwrite(&Carte->decalageX, 1, sizeof(unsigned int), fichier);
        168.     fwrite(&Carte->decalageY, 1, sizeof(unsigned int), fichier);
        169.     /* save des caractéristique des tuiles */
        170.     for(i=0; i<Carte->nb_Tuiles; i++)
        171.     {
        172.         fwrite(&Carte->pointeur_SurGroupeTuiles[i].x, 1, sizeof(unsigned int), fichier);
        173.         fwrite(&Carte->pointeur_SurGroupeTuiles[i].y, 1, sizeof(unsigned int), fichier);
        174.         fwrite(&Carte->pointeur_SurGroupeTuiles[i].collision, 1, sizeof(unsigned char), fichier);
        175.         fwrite(&Carte->pointeur_SurGroupeTuiles[i].tuile_Suivante, 1, sizeof(int), fichier);
        176.     }
        177.     /* save de la disposition des tuiles sur la carte */
        178.     for (x=0; x<Carte->largeur; x++)
        179.     {
        180.         for (y=0; y<Carte->hauteur; y++)
        181.         {
        182.             fwrite(&GET_TUILE(x,y,Carte), 1, sizeof(unsigned int), fichier);
        183.         }
        184.     }
        185.     fclose(fichier);
        186. }
        187. /***************************
        188. ** Chargement d'une carte **
        189. ***************************/
        190. void Load_Carte(struct S_Carte *Carte, char const *nom_Fichier)
        191. {
        192.     FILE *fichier;
        193.     unsigned int i, x, y;
        194.     char tampon [256];
        195.     /* ouverture du fichier à charger */
        196.     fichier=fopen(nom_Fichier, "rb");
        197.     if (!fichier)
        198.     {
        199.         printf("problème d'ouverture du fichier de sauvegarde");
        200.     }
        201.     /* chargement de la musique de fond */
        202.     memset(&tampon, 0, sizeof(tampon));
        203.     fread(&tampon, 255, sizeof(char), fichier);
        204.     Carte->musique_DeFond=FMUSIC_LoadSong(tampon);
        205.     if (!Carte->musique_DeFond)
        206.     {
        207.         printf("problème de chargement de musique de fond");
        208.     }
        209.     /* chargement de l'image contenant les tuiles */
        210.     memset(&tampon, 0, sizeof(tampon));
        211.     fread(&tampon, 255, sizeof(tampon), fichier);
        212.     Carte->surface_GroupeTuiles=SDL_LoadBMP(tampon);
        213.     SDL_SetColorKey(Carte->surface_GroupeTuiles, SDL_SRCCOLORKEY, SDL_MapRGB(Carte->surface_GroupeTuiles->format,8,33,82));
        214.     /* chargement des caractéristique de la carte */
        215.     fread(&Carte->largeur, 1, sizeof(unsigned int), fichier);
        216.     fread(&Carte->hauteur, 1, sizeof(unsigned int), fichier);
        217.     fread(&Carte->nb_Tuiles, 1, sizeof(unsigned int), fichier);
        218.     fread(&Carte->decalageX, 1, sizeof(unsigned int), fichier);
        219.     fread(&Carte->decalageY, 1, sizeof(unsigned int), fichier);
        220.     /* chargement des caractéristiques des tuiles */
        221.     Carte->pointeur_SurGroupeTuiles= calloc (Carte->nb_Tuiles, sizeof *Carte->pointeur_SurGroupeTuiles);
        222.     for (i=0; i<Carte->nb_Tuiles; i++)
        223.     {
        224.         fread(&Carte->pointeur_SurGroupeTuiles[i].x, 1, sizeof(unsigned int), fichier);
        225.         fread(&Carte->pointeur_SurGroupeTuiles[i].y, 1, sizeof(unsigned int), fichier);
        226.         fread(&Carte->pointeur_SurGroupeTuiles[i].collision, 1, sizeof(unsigned char), fichier);
        227.         fread(&Carte->pointeur_SurGroupeTuiles[i].tuile_Suivante, 1, sizeof(unsigned int), fichier);
        228.     }
        229.     /* chargement des tuiles sur la carte */
        230.     Carte->donnees=calloc((Carte->largeur*Carte->hauteur), sizeof *Carte->donnees);
        231.     for (x=0; x<Carte->largeur; x++)
        232.     {
        233.         for (y=0; y<Carte->hauteur; y++)
        234.         {
        235.             fread(&GET_TUILE(x,y,Carte), 1, sizeof(unsigned int), fichier);
        236.             if (GET_TUILE (x,y,Carte)>Carte->nb_Tuiles)
        237.             {
        238.                 printf("carte corrompue");
        239.                 GET_TUILE (x,y,Carte)=0;
        240.             }
        241.         }
        242.     }
        243.     fclose (fichier);
        244.     FMUSIC_PlaySong(Carte->musique_DeFond);
        245. }
        246. /***************************************
        247. ** Gestion des événements de la carte **
        248. ***************************************/
        249. void Evenement_Carte(SDL_Event *evenement, struct S_Carte *Carte)
        250. {
        251. }


        et le carte.h
        1. /*
        2. ** Dernière modification le 21/11/07
        3. **
        4. ** carte.h
        5. **
        6. ** Header du fichier de Gestion des cartes (carte.c)
        7. **
        8. ** Roles :
        9. **
        10. ** - inclusion des bibliothèques
        11. ** - définition des constantes
        12. **
        13. ** - définition des macros
        14. ** - définition des structures : Groupe_Tuiles et Carte
        15. **
        16. ** - définition des prototypes des fonctions : * Initiation_Carte
        17. **                                             * Liberation_Carte
        18. **                                             * Carte_Aleatoire
        19. **                                             * Affichage_Carte
        20. **                                             * Save_Carte
        21. **                                             * Load_Carte
        22. **
        23. */
        24. #ifndef CARTE_H_INCLUDED
        25. #define CARTE_H_INCLUDED
        26. /*
        27. ** Liste des include
        28. */
        29. #include <stdlib.h>
        30. #include <stdio.h>
        31. #include <string.h>
        32. #include <time.h>
        33. #include <SDL/SDL.h>
        34. #include <FMOD/fmod.h>
        35. #include <FMOD/fmod_errors.h>
        36. /*
        37. ** Liste des define
        38. */
        39. #define LARGEUR_TUILE 32u
        40. #define HAUTEUR_TUILE 32u
        41. #define HAUTEUR_AFFICHAGE 600
        42. #define LARGEUR_AFFICHAGE 800
        43. #define GET_TUILE(x,y,Carte) Carte->donnees[x+(y)*Carte->largeur] /* Macro pour atteindre plus simplement la tuile dans la carte */
        44. /********************************************************************************************
        45. **********************  STRUCTURES **********************************************************
        46. *********************************************************************************************/
        47. /* Définition de la structure du groupe de tuile */
        48. typedef struct Groupe_Tuiles Groupe_Tuiles;
        49. struct Groupe_Tuiles
        50. {
        51.     /* coordonnées de la tuile dans le groupe */
        52.     unsigned int x;
        53.     unsigned int y;
        54.     /* caractéristique de collision, 1 si intraversable */
        55.     unsigned char collision;
        56.     /* animation : -1 si pas d'animation, sinon tuile suivante pour l'animation */
        57.     int tuile_Suivante;
        58. };
        59. /* Définition de la structure carte */
        60. typedef struct S_Carte S_Carte;
        61. struct S_Carte
        62. {
        63.     /* largeur et hauteur carte */
        64.     unsigned int largeur;
        65.     unsigned int hauteur;
        66.     /* nb de tuiles différentes pouvant composer la carte */
        67.     unsigned int nb_Tuiles;
        68.     /* pointeur sur la structure groupe de tuiles */
        69.     Groupe_Tuiles *pointeur_SurGroupeTuiles;
        70.     /* pointeur sur la surface contenant le groupe_tuile */
        71.     SDL_Surface *surface_GroupeTuiles;
        72.     /* pointeur sur la carte */
        73.     unsigned int *donnees;
        74.     /* pointeur sur musique de fond de la carte */
        75.     FMUSIC_MODULE *musique_DeFond;
        76.     /* décalage en X et Y lors de l'affichage de la carte (déplacement affichage via flèches */
        77.     unsigned int decalageX;
        78.     unsigned int decalageY;
        79. };
        80. /********************************************************************************************
        81. **********************  PROTOTYPES FONCTIONS ************************************************
        82. *********************************************************************************************/
        83. /* Initiation de Carte */
        84. void Initialisation_Carte(S_Carte *Carte);
        85. /* Liberation des pointeurs de carte */
        86. void Liberation_Carte(S_Carte *Carte);
        87. /* Génération aléatoire d'une carte */
        88. void Carte_Aleatoire (struct S_Carte *Carte, unsigned int largeur_Carte, unsigned int hauteur_Carte, char const *tuiles);
        89. /* Affichage d'une carte */
        90. void Affichage_Carte(struct S_Carte *Carte);
        91. /* Sauvegarde de carte */
        92. void Save_Carte (struct S_Carte *Carte, char const *nom_Fichier, char const *musique_DeFond, char const *image_Tuiles);
        93. /* Chargement de carte */
        94. void Load_Carte(struct S_Carte *Carte, char const *nom_Fichier);
        95. /* Gestion des événement d'une carte */
        96. void Evenement_Carte(SDL_Event *evenement, struct S_Carte *Carte);
        97. #endif /* CARTE_H_INCLUDED */


        et le sprites.c
        1. /*
        2. ** Dernière modification le 21/11/07
        3. **
        4. ** sprites.c
        5. **
        6. ** Gestion des sprites
        7. **
        8. ** Roles :
        9. **
        10. ** - initialisation et libération des sprites
        11. ** - affichage des sprites
        12. ** - gestion des événements associés aux sprites
        13. **
        14. */
        15. # include "sprites.h"
        16. /*
        17. ** initialisation des sprites
        18. */
        19. void Initialisation_Sprites (struct S_lib_sprite *lib_sprite)
        20. {
        21.     lib_sprite->nb_sprites=0;
        22.     lib_sprite->sprites=NULL;
        23. }
        24. /*
        25. ** libération des éléments alloués pour les sprites
        26. */
        27. void Free_Sprites (struct S_lib_sprite *lib_sprite)
        28. {
        29.     int i, anim;
        30.     for (i=0; i<lib_sprite->nb_sprites; i++)
        31.     {
        32.         SDL_FreeSurface(lib_sprite->sprites[i].surface_sprites);
        33.         for(anim=0; anim<lib_sprite->sprites[i].anim[anim].nb_frame; anim++)
        34.         {
        35.             free(lib_sprite->sprites[i].anim[anim].frame);
        36.         }
        37.         free(lib_sprite->sprites[i].anim);
        38.     }
        39.     free (lib_sprite->sprites);
        40.     lib_sprite->nb_sprites=0;
        41. }
        42. /*
        43. ** chargement statique des données images
        44. */
        45. void Sprites_DonneesStatic (struct S_lib_sprite *lib_sprite)
        46. {
        47.     lib_sprite->nb_sprites=1;
        48.     /* on alloue la mémoire des sprites de lib_sprite */
        49.     lib_sprite->sprites=malloc (lib_sprite->nb_sprites * sizeof lib_sprite->sprites);
        50.     /***********************************************
        51.     ************* SPRITE 0 : Joueur ****************
        52.     ***********************************************/
        53.     /* coordonées du sprites sur la carte */
        54.     lib_sprite->sprites[0].x=256;
        55.     lib_sprite->sprites[0].y=86;
        56.     /* marge du sprite */
        57.     lib_sprite->sprites[0].margeH=20;
        58.     lib_sprite->sprites[0].margeB=10;
        59.     lib_sprite->sprites[0].margeG=4;
        60.     lib_sprite->sprites[0].margeD=15;
        61.     /* on charge la surface contenant le sprite */
        62.     lib_sprite->sprites[0].surface_sprites=SDL_LoadBMP("sprites\\player.bmp");
        63.     SDL_SetColorKey(lib_sprite->sprites[0].surface_sprites, SDL_SRCCOLORKEY,
        64.         SDL_MapRGB(lib_sprite->sprites[0].surface_sprites->format, 0,0,0));
        65.     /* on définit les propriétés du sprite */
        66.     lib_sprite->sprites[0].largeur=24;
        67.     lib_sprite->sprites[0].hauteur=32;
        68.     lib_sprite->sprites[0].nb_anim=4;
        69.     lib_sprite->sprites[0].anim_actu=ANIMATION_BAS;
        70.     lib_sprite->sprites[0].pause_anim=1;
        71.     /* on alloue la mémoire pour les animations du sprite 0 */
        72.     lib_sprite->sprites[0].anim=malloc(lib_sprite->sprites[0].nb_anim * sizeof (lib_sprite->sprites[0].anim));
        73.         /***************** SPRITE 0 : ANIMATION 0 (HAUT) *******************/
        74.         /* on définit les propriétés de cette animation */
        75.         lib_sprite->sprites[0].anim[0].nb_frame=3;
        76.         lib_sprite->sprites[0].anim[0].frame_actu=0;
        77.         lib_sprite->sprites[0].anim[0].last_update=SDL_GetTicks();
        78.         lib_sprite->sprites[0].anim[0].delai_frame=100;
        79.         /* on alloue la mémoire pour les images de l'animation 0 de ce sprite 0 */
        80.         lib_sprite->sprites[0].anim[0].frame=malloc(lib_sprite->sprites[0].anim[0].nb_frame * sizeof (lib_sprite->sprites[0].anim[0].frame));
        81.             /********************* FRAMES DE L'ANIMATION 0 DU SPRITE 0 *********************/
        82.             /* on définit les propriété des frames de l'animation */
        83.             lib_sprite->sprites[0].anim[0].frame[0].x=144;
        84.             lib_sprite->sprites[0].anim[0].frame[0].y=0;
        85.             lib_sprite->sprites[0].anim[0].frame[1].x=168;
        86.             lib_sprite->sprites[0].anim[0].frame[1].y=0;
        87.             lib_sprite->sprites[0].anim[0].frame[2].x=192;
        88.             lib_sprite->sprites[0].anim[0].frame[2].y=0;
        89.         /***************** SPRITE 0 : ANIMATION 1 (BAS) *******************/
        90.         /* on définit les propriétés de cette animation */
        91.         lib_sprite->sprites[0].anim[1].nb_frame=3;
        92.         lib_sprite->sprites[0].anim[1].frame_actu=0;
        93.         lib_sprite->sprites[0].anim[1].last_update=SDL_GetTicks();
        94.         lib_sprite->sprites[0].anim[1].delai_frame=100;
        95.         /* on alloue la mémoire pour les images de l'animation 0 de ce sprite 0 */
        96.         lib_sprite->sprites[0].anim[1].frame=malloc(lib_sprite->sprites[0].anim[1].nb_frame * sizeof (lib_sprite->sprites[0].anim[1].frame));
        97.             /********************* FRAMES DE L'ANIMATION 1 DU SPRITE 0 *********************/
        98.             /* on définit les propriété des frames de l'animation */
        99.             lib_sprite->sprites[0].anim[1].frame[0].x=144;
        100.             lib_sprite->sprites[0].anim[1].frame[0].y=96;
        101.             lib_sprite->sprites[0].anim[1].frame[1].x=168;
        102.             lib_sprite->sprites[0].anim[1].frame[1].y=96;
        103.             lib_sprite->sprites[0].anim[1].frame[2].x=192;
        104.             lib_sprite->sprites[0].anim[1].frame[2].x=96;
        105.         /***************** SPRITE 0 : ANIMATION 2 (GAUCHE) *******************/
        106.         /* on définit les propriétés de cette animation */
        107.         lib_sprite->sprites[0].anim[2].nb_frame=3;
        108.         lib_sprite->sprites[0].anim[2].frame_actu=0;
        109.         lib_sprite->sprites[0].anim[2].last_update=SDL_GetTicks();
        110.         lib_sprite->sprites[0].anim[2].delai_frame=100;
        111.         /* on alloue la mémoire pour les images de l'animation 0 de ce sprite 0 */
        112.         lib_sprite->sprites[0].anim[2].frame=malloc(lib_sprite->sprites[0].anim[2].nb_frame * sizeof (lib_sprite->sprites[0].anim[2].frame));
        113.             /********************* FRAMES DE L'ANIMATION 2 DU SPRITE 0 *********************/
        114.             /* on définit les propriété des frames de l'animation */
        115.             lib_sprite->sprites[0].anim[2].frame[0].x=144;
        116.             lib_sprite->sprites[0].anim[2].frame[0].y=64;
        117.             lib_sprite->sprites[0].anim[2].frame[1].x=168;
        118.             lib_sprite->sprites[0].anim[2].frame[1].y=64;
        119.             lib_sprite->sprites[0].anim[2].frame[2].x=192;
        120.             lib_sprite->sprites[0].anim[2].frame[2].x=64;
        121.         /***************** SPRITE 0 : ANIMATION 3 (DROITE) *******************/
        122.         /* on définit les propriétés de cette animation */
        123.         lib_sprite->sprites[0].anim[3].nb_frame=3;
        124.         lib_sprite->sprites[0].anim[3].frame_actu=0;
        125.         lib_sprite->sprites[0].anim[3].last_update=SDL_GetTicks();
        126.         lib_sprite->sprites[0].anim[3].delai_frame=100;
        127.         /* on alloue la mémoire pour les images de l'animation 0 de ce sprite 0 */
        128.         lib_sprite->sprites[0].anim[3].frame=malloc(lib_sprite->sprites[0].anim[3].nb_frame * sizeof (lib_sprite->sprites[0].anim[3].frame));
        129.             /********************* FRAMES DE L'ANIMATION 3 DU SPRITE 0 *********************/
        130.             /* on définit les propriété des frames de l'animation */
        131.             lib_sprite->sprites[0].anim[3].frame[0].x=144;
        132.             lib_sprite->sprites[0].anim[3].frame[0].y=32;
        133.             lib_sprite->sprites[0].anim[3].frame[1].x=168;
        134.             lib_sprite->sprites[0].anim[3].frame[1].y=32;
        135.             lib_sprite->sprites[0].anim[3].frame[2].x=192;
        136.             lib_sprite->sprites[0].anim[3].frame[2].x=32;
        137. }
        138. /*
        139. ** sauvegarde des informations concernants les sprites
        140. */
        141. void Save_Sprites(struct S_lib_sprite *lib_sprite, char const *charset, char const *Save)
        142. {
        143.     FILE *fichier=NULL;
        144.     int i, anim, frame;
        145.     char tampon[256];
        146.     if(!lib_sprite)
        147.     {
        148.         printf("pas de lib_sprite");
        149.         return;
        150.     }
        151.     fichier=fopen(Save, "wb");
        152.     if (!fichier)
        153.     {
        154.         printf("problème d'ouverture de fichier de sauvegarde");
        155.         return;
        156.     }
        157.     /* on enregistre les données des structures en binaire dans le fichier */
        158.     fwrite(&lib_sprite->nb_sprites, sizeof (lib_sprite->nb_sprites), 1, fichier);
        159.     for (i=0; i<lib_sprite->nb_sprites; i++)
        160.     {
        161.         fwrite(&lib_sprite->sprites[i].x, sizeof (lib_sprite->sprites[i].x), 1, fichier);
        162.         fwrite(&lib_sprite->sprites[i].y, sizeof (lib_sprite->sprites[i].y), 1, fichier);
        163.         fwrite(&lib_sprite->sprites[i].largeur, sizeof (lib_sprite->sprites[i].largeur), 1, fichier);
        164.         fwrite(&lib_sprite->sprites[i].hauteur, sizeof (lib_sprite->sprites[i].hauteur), 1, fichier);
        165.         fwrite(&lib_sprite->sprites[i].nb_anim, sizeof (lib_sprite->sprites[i].nb_anim), 1, fichier);
        166.         fwrite(&lib_sprite->sprites[i].pause_anim, sizeof (lib_sprite->sprites[i].pause_anim), 1, fichier);
        167.         fwrite(&lib_sprite->sprites[i].anim_actu, sizeof (lib_sprite->sprites[i].anim_actu), 1, fichier);
        168.         fwrite(&lib_sprite->sprites[i].margeH, sizeof (lib_sprite->sprites[i].margeH), 1, fichier);
        169.         fwrite(&lib_sprite->sprites[i].margeB, sizeof (lib_sprite->sprites[i].margeB), 1, fichier);
        170.         fwrite(&lib_sprite->sprites[i].margeG, sizeof (lib_sprite->sprites[i].margeG), 1, fichier);
        171.         fwrite(&lib_sprite->sprites[i].margeD, sizeof (lib_sprite->sprites[i].margeD), 1, fichier);
        172.         memset(&tampon, 0, sizeof(tampon));
        173.         strcpy(tampon, charset);
        174.         fwrite(&tampon, 255, sizeof(char), fichier);
        175.         for (anim=0; i<lib_sprite->sprites[i].nb_anim; anim++)
        176.         {
        177.             fwrite(&lib_sprite->sprites[i].anim[anim].nb_frame, sizeof(&lib_sprite->sprites[i].anim[anim].nb_frame), 1, fichier);
        178.             fwrite(&lib_sprite->sprites[i].anim[anim].frame_actu, sizeof(&lib_sprite->sprites[i].anim[anim].frame_actu), 1, fichier);
        179.             fwrite(&lib_sprite->sprites[i].anim[anim].last_update, sizeof(&lib_sprite->sprites[i].anim[anim].last_update), 1, fichier);
        180.             fwrite(&lib_sprite->sprites[i].anim[anim].delai_frame, sizeof(&lib_sprite->sprites[i].anim[anim].delai_frame), 1, fichier);
        181.             for (frame=0; frame<lib_sprite->sprites[i].anim[anim].nb_frame; frame++)
        182.             {
        183.                 fwrite(&lib_sprite->sprites[i].anim[anim].frame[frame].x, sizeof(lib_sprite->sprites[i].anim[anim].frame[frame].x), 1, fichier);
        184.                 fwrite(&lib_sprite->sprites[i].anim[anim].frame[frame].y, sizeof(lib_sprite->sprites[i].anim[anim].frame[frame].y), 1, fichier);
        185.             }
        186.         }
        187.     }
        188.     fclose (fichier);
        189. }
        190. /*
        191. ** chargement des informations concernant les sprites
        192. */
        193. void Load_Sprites(struct S_lib_sprite *lib_sprite, char const *fichierLoad_Sprites)
        194. {
        195.     int i, anim, frame;
        196.     char tampon[256];
        197.     FILE *fichier=NULL;
        198.     if(!lib_sprite)
        199.     {
        200.         printf("pas de lib_sprite");
        201.         return;
        202.     }
        203.     fichier=fopen(fichierLoad_Sprites, "rb");
        204.     if (!fichier)
        205.     {
        206.         printf("prob d'ouverture de fichier");
        207.         return;
        208.     }
        209.     fread(&lib_sprite->nb_sprites, sizeof(lib_sprite->nb_sprites), 1, fichier);
        210.     lib_sprite->sprites=malloc(lib_sprite->nb_sprites * sizeof(lib_sprite->sprites));
        211.     for(i=0; i < lib_sprite->nb_sprites; i++)
        212.     {
        213.         fread(&lib_sprite->sprites[i].x, sizeof (lib_sprite->sprites[i].x), 1, fichier);
        214.         fread(&lib_sprite->sprites[i].y, sizeof (lib_sprite->sprites[i].y), 1, fichier);
        215.         fread(&lib_sprite->sprites[i].largeur, sizeof (lib_sprite->sprites[i].largeur), 1, fichier);
        216.         fread(&lib_sprite->sprites[i].hauteur, sizeof (lib_sprite->sprites[i].hauteur), 1, fichier);
        217.         fread(&lib_sprite->sprites[i].nb_anim, sizeof (lib_sprite->sprites[i].nb_anim), 1, fichier);
        218.         fread(&lib_sprite->sprites[i].pause_anim, sizeof (lib_sprite->sprites[i].pause_anim), 1, fichier);
        219.         fread(&lib_sprite->sprites[i].anim_actu, sizeof (lib_sprite->sprites[i].anim_actu), 1, fichier);
        220.         fread(&lib_sprite->sprites[i].margeH, sizeof (lib_sprite->sprites[i].margeH), 1, fichier);
        221.         fread(&lib_sprite->sprites[i].margeB, sizeof (lib_sprite->sprites[i].margeB), 1, fichier);
        222.         fread(&lib_sprite->sprites[i].margeG, sizeof (lib_sprite->sprites[i].margeG), 1, fichier);
        223.         fread(&lib_sprite->sprites[i].margeD, sizeof (lib_sprite->sprites[i].margeD), 1, fichier);
        224.         memset(&tampon, 0, sizeof(tampon));
        225.         fread(&tampon, 255, sizeof(char), fichier);
        226.         lib_sprite->sprites[i].surface_sprites=SDL_LoadBMP(tampon);
        227.         SDL_SetColorKey(lib_sprite->sprites[i].surface_sprites, SDL_SRCCOLORKEY, SDL_MapRGB(lib_sprite->sprites[i].surface_sprites->format,0,0,0));
        228.         lib_sprite->sprites[i].anim=malloc(lib_sprite->sprites[i].nb_anim * sizeof(lib_sprite->sprites[i].anim));
        229.         for(anim=0; anim < lib_sprite->sprites[i].nb_anim; anim++)
        230.         {
        231.             fread(&lib_sprite->sprites[i].anim[anim].nb_frame, sizeof(&lib_sprite->sprites[i].anim[anim].nb_frame), 1, fichier);
        232.             fread(&lib_sprite->sprites[i].anim[anim].frame_actu, sizeof(&lib_sprite->sprites[i].anim[anim].frame_actu), 1, fichier);
        233.             fread(&lib_sprite->sprites[i].anim[anim].last_update, sizeof(&lib_sprite->sprites[i].anim[anim].last_update), 1, fichier);
        234.             fread(&lib_sprite->sprites[i].anim[anim].delai_frame, sizeof(&lib_sprite->sprites[i].anim[anim].delai_frame), 1, fichier);
        235.             lib_sprite->sprites[i].anim[anim].frame=malloc(lib_sprite->sprites[i].anim[anim].nb_frame * sizeof(lib_sprite->sprites[i].anim[anim].frame));
        236.             for (frame=0; frame < lib_sprite->sprites[i].anim[anim].nb_frame; frame++)
        237.             {
        238.                 fread(&lib_sprite->sprites[i].anim[anim].frame[frame].x, sizeof(lib_sprite->sprites[i].anim[anim].frame[frame].x), 1, fichier);
        239.                 fread(&lib_sprite->sprites[i].anim[anim].frame[frame].y, sizeof(lib_sprite->sprites[i].anim[anim].frame[frame].y), 1, fichier);
        240.             }
        241.         }
        242.     }
        243.     fclose(fichier);
        244. }
        245. /*
        246. ** affichage des sprites de façon globale
        247. */
        248. void Affichage_GlobalSprites(struct S_lib_sprite *lib_sprite, struct S_Carte *carte)
        249. {
        250.     int i;
        251.     /* On centre la vue sur le perso si cela est possible */
        252.     /* Centrage en X */
        253.     if (lib_sprite->sprites[0].x < (LARGEUR_AFFICHAGE/2))   carte->decalageX=0;
        254.     else
        255.     {
        256.         carte->decalageX = lib_sprite->sprites[0].x - (LARGEUR_AFFICHAGE / 2);
        257.         if (carte->decalageX > (carte->largeur * LARGEUR_TUILE - LARGEUR_AFFICHAGE))
        258.         {
        259.             carte->decalageX=carte->largeur * LARGEUR_TUILE - LARGEUR_AFFICHAGE;
        260.         }
        261.     }
        262.     /* Centrage en Y */
        263.     if (lib_sprite->sprites[0].y < (HAUTEUR_AFFICHAGE/2)) carte->decalageY=0;
        264.     else
        265.     {
        266.         carte->decalageY= lib_sprite->sprites[0].y - (HAUTEUR_AFFICHAGE /2);
        267.         if (carte->decalageY > (carte->hauteur * HAUTEUR_TUILE - HAUTEUR_AFFICHAGE))
        268.         {
        269.             carte->decalageY = carte->hauteur * HAUTEUR_TUILE - HAUTEUR_AFFICHAGE;
        270.         }
        271.     }
        272.     /* ensuite on appelle la fonction d'affichage des tuiles 1 par 1 */
        273.     for (i=0; i<lib_sprite->nb_sprites; i++)
        274.     {
        275.         Affichage_Sprite (&lib_sprite->sprites[i], carte);
        276.     }
        277. }
        278. /* fonction d'affichage des sprites 1 à 1 */
        279. void Affichage_Sprite (struct S_sprites *sprite, struct S_Carte *carte)
        280. {
        281.     SDL_Rect source, destination;
        282.     /* on test si le sprite est animé et si oui si le delai entre 2 images est passé et si oui on change l'image de l'anim */
        283.     if(!sprite->pause_anim)
        284.     {
        285.         if(SDL_GetTicks()- sprite->anim[sprite->anim_actu].last_update > sprite->anim[sprite->anim_actu].delai_frame)
        286.         {
        287.             sprite->anim[sprite->anim_actu].frame_actu=((sprite->anim[sprite->anim_actu].frame_actu+1) % sprite->anim[sprite->anim_actu].nb_frame);
        288.             sprite->anim[sprite->anim_actu].last_update=SDL_GetTicks();
        289.         }
        290.     }
        291.     /* on cherche le sprite à la source et on l'envoie aux coordonnées de destination */
        292.     source.x = sprite->anim[sprite->anim_actu].frame[sprite->anim[sprite->anim_actu].frame_actu].x;
        293.     source.y = sprite->anim[sprite->anim_actu].frame[sprite->anim[sprite->anim_actu].frame_actu].y;
        294.     source.w = destination.w = sprite->largeur;
        295.     source.h = destination.h = sprite->hauteur;
        296.     destination.x = sprite->x - carte->decalageX;
        297.     destination.y = sprite->y - carte->decalageY;
        298.     /* on vérifie que le sprite est affiché à l'écran */
        299.     if(destination.x < -destination.w) return;
        300.     if(destination.y < -destination.y) return;
        301. /* test si ça déborde à droite ou en bas, pas sur que ça fonctionne bien */
        302.     if(destination.x > LARGEUR_AFFICHAGE) return;
        303.     if(destination.y > HAUTEUR_AFFICHAGE) return;
        304.     if (destination.x < 0)
        305.     {
        306.         source.x -= destination.x;
        307.         source.w += destination.x;
        308.         destination.w += destination.x;
        309.         destination.x = 0;
        310.     }
        311.     if (destination.y < 0)
        312.     {
        313.         source.y -= destination.y;
        314.         source.w += destination.y;
        315.         destination.w += destination.y;
        316.         destination.y = 0;
        317.     }
        318.     SDL_BlitSurface(sprite->surface_sprites, &source, SDL_GetVideoSurface(), &destination);
        319. }
        320. /*
        321. ** fonction qui met à jour le sprite à chaque changement d'animation
        322. */
        323. void Changement_AnimSprite(struct S_sprites *sprite, int anim, int pause_anim)
        324. {
        325.     sprite->anim_actu = anim;
        326.     sprite->pause_anim = pause_anim;
        327.     sprite->anim[sprite->anim_actu].frame_actu = 0;
        328.     sprite->anim[sprite->anim_actu].delai_frame = SDL_GetTicks();
        329. }
        330. /*
        331. ** déplacement des sprites et test de collision
        332. */
        333. void Deplacement_Sprite(struct S_sprites *sprite, unsigned int x, unsigned int y, struct S_Carte *carte)
        334. {
        335.     /* h = haut, b = bas, d = droit, g = gauche */
        336.     int hgx, hgy, bgx, bgy, hdx, hdy, bdx, bdy;
        337.     /* calcule sur quelle tuile se trouve les coins (sans les bordures du sprite) */
        338.     hgx = (x + sprite->margeG) / LARGEUR_TUILE;
        339.     hgy = (y + sprite->margeH) / HAUTEUR_TUILE;
        340.     bgx = (x + sprite->margeG) / LARGEUR_TUILE;
        341.     bgy = (y + sprite->hauteur - sprite->margeB) / HAUTEUR_TUILE;
        342.     hdx = (x + sprite->largeur - sprite->margeD) / LARGEUR_TUILE;
        343.     hdy = (y + sprite->margeH) / HAUTEUR_TUILE;
        344.     bdx = (x + sprite->largeur - sprite->margeD) / LARGEUR_TUILE;
        345.     bdy = (y + sprite->hauteur - sprite->margeB) / HAUTEUR_TUILE;
        346.     /* on test si les tuiles sur lesquelles sont les coins sont traversables */
        347.     if (    (carte->pointeur_SurGroupeTuiles[GET_TUILE(hgx, hgy, carte)].collision == 0)
        348.         &&  (carte->pointeur_SurGroupeTuiles[GET_TUILE(bgx, bgy, carte)].collision == 0)
        349.         &&  (carte->pointeur_SurGroupeTuiles[GET_TUILE(hdx, hdy, carte)].collision == 0)
        350.         &&  (carte->pointeur_SurGroupeTuiles[GET_TUILE(bdx, bdy, carte)].collision == 0))
        351.     {
        352.         /* on vérifie qu'on est bien dans les limites de la carte (le bord gauche et haut de la carte sont oublié ?? bug possible ?? ou pas nécessaire)*/
        353.         if (x > (carte->largeur * LARGEUR_TUILE - sprite->largeur)) x = (carte->largeur * LARGEUR_TUILE);
        354.         if (y > (carte->hauteur * HAUTEUR_TUILE - sprite->hauteur)) y = (carte->hauteur * HAUTEUR_TUILE);
        355.         sprite->x = x;
        356.         sprite->y = y;
        357.     }
        358. }
        359. /* traitement des événements de déplacement du sprite joueur */
        360. void Event_SpriteJoueur(SDL_Event *evenement , struct S_Carte *carte, struct S_lib_sprite *lib_sprite)
        361. {
        362.     if(!evenement) return;
        363.     /* on met en pause l'animation pour traiter l'événement */
        364.     lib_sprite->sprites[0].pause_anim = 1;
        365.     if ((evenement->type == SDL_KEYDOWN) && (evenement->key.state == SDL_PRESSED))
        366.     {
        367.         switch (evenement->key.keysym.sym)
        368.         {
        369.             case SDLK_RIGHT:
        370.                 /* si cette touche est enfoncée, on lance la fonction de déplacement du sprite */
        371.                 Deplacement_Sprite(&lib_sprite->sprites[0], lib_sprite->sprites[0].x+1, lib_sprite->sprites[0].y, carte);
        372.                 /* on regarde si l'animation était déjà celle correspondant au déplacement et on lance le changement
        373.                    d'anim si c'est pas le cas */
        374.                 if (lib_sprite->sprites[0].anim_actu != ANIMATION_DROIT)
        375.                 {
        376.                     Changement_AnimSprite(&lib_sprite->sprites[0], ANIMATION_DROIT, 0);
        377.                 }
        378.                 else /* si l'anim était bonne on enlève la pause */
        379.                 {
        380.                     lib_sprite->sprites[0].pause_anim = 0;
        381.                 }
        382.                 break;
        383.             case SDLK_LEFT:
        384.                 Deplacement_Sprite(&lib_sprite->sprites[0], lib_sprite->sprites[0].x-1, lib_sprite->sprites[0].y, carte);
        385.                 if (lib_sprite->sprites[0].anim_actu != ANIMATION_GAUCHE)
        386.                 {
        387.                     Changement_AnimSprite(&lib_sprite->sprites[0], ANIMATION_GAUCHE, 0);
        388.                 }
        389.                 else
        390.                 {
        391.                     lib_sprite->sprites[0].pause_anim = 0;
        392.                 }
        393.                 break;
        394.             case SDLK_UP:
        395.                 Deplacement_Sprite(&lib_sprite->sprites[0], lib_sprite->sprites[0].x, lib_sprite->sprites[0].y-1, carte);
        396.                 if (lib_sprite->sprites[0].anim_actu != ANIMATION_HAUT)
        397.                 {
        398.                     Changement_AnimSprite(&lib_sprite->sprites[0], ANIMATION_HAUT, 0);
        399.                 }
        400.                 else
        401.                 {
        402.                     lib_sprite->sprites[0].pause_anim = 0;
        403.                 }
        404.                 break;
        405.             case SDLK_DOWN:
        406.                 Deplacement_Sprite(&lib_sprite->sprites[0], lib_sprite->sprites[0].x, lib_sprite->sprites[0].y+1, carte);
        407.                 if (lib_sprite->sprites[0].anim_actu != ANIMATION_BAS)
        408.                 {
        409.                     Changement_AnimSprite(&lib_sprite->sprites[0], ANIMATION_BAS, 0);
        410.                 }
        411.                 else
        412.                 {
        413.                     lib_sprite->sprites[0].pause_anim = 0;
        414.                 }
        415.                 break;
        416.             default:
        417.             ;
        418.         }
        419.     }
        420. }


        et enfin le sprites.h
        1. /*
        2. ** Dernière modification le 21/11/07
        3. **
        4. ** sprites.h
        5. **
        6. ** Header du fichier de gestion des sprites (sprites.c)
        7. **
        8. ** Roles :
        9. **
        10. ** - inclusions des bibliothèques
        11. ** - définitions des constantes
        12. ** - définitions des structures : S_lib_sprite
        13. **                                S_sprites
        14. **                                S_anim
        15. **                                S_frames
        16. **
        17. ** - définitions des prototypes des fonctions : * Initialisation_Sprites
        18. **                                              * Free_Sprites
        19. **                                              * Sprites_DonneesStatic
        20. **                                              * Save_Sprites
        21. **                                              * Load_Sprites
        22. **                                              * Affichage_GlobalSprites
        23. **                                              * Affichage_Sprite
        24. **                                              * Changement_AnimSprite
        25. **                                              * Deplacement_Sprite
        26. **                                              * Event_SpriteJoueur
        27. **
        28. **
        29. */
        30. #ifndef SPRITES_H_INCLUDED
        31. #define SPRITES_H_INCLUDED
        32. /* Listes des includes */
        33. # include <stdlib.h>
        34. # include <stdio.h>
        35. # include <SDL\SDL.h>
        36. # include "carte.h"
        37. /* Listes des defines */
        38. # define ANIMATION_HAUT 0
        39. # define ANIMATION_BAS 1
        40. # define ANIMATION_GAUCHE 2
        41. # define ANIMATION_DROIT 3
        42. /*****************************************************
        43. *************** Définition des structures ************
        44. *****************************************************/
        45. /*
        46. ** Définition de la structure général des sprites : S_lib_sprite
        47. */
        48. typedef struct S_lib_sprite S_lib_sprite;
        49. struct S_lib_sprite
        50. {
        51.     /* nombre de sprites dans la librairie de sprites */
        52.     int nb_sprites;
        53.     /* pointeur vers la structure des sprites contenant les caractéristiques de ceux ci */
        54.     struct S_sprites *sprites;
        55. };
        56. /*
        57. ** Définition de la structure décrivant chaques sprites
        58. */
        59. typedef struct S_sprites S_sprite;
        60. struct S_sprites
        61. {
        62.     int largeur;
        63.     int hauteur;
        64.     /* coordonnées du sprites dans la carte */
        65.     int x;
        66.     int y;
        67.     /* nb d'animation du sprite */
        68.     int nb_anim;
        69.     /* n° de l'animation en cours */
        70.     int anim_actu;
        71.     /* indique si l'animation du sprite est en pause */
        72.     int pause_anim;
        73.     /* marge autour du sprite */
        74.     int margeH;
        75.     int margeB;
        76.     int margeG;
        77.     int margeD;
        78.     /* pointeur vers la surface contenant les sprites : le charset */
        79.     SDL_Surface *surface_sprites;
        80.     /* pointeur vers la structure des animations */
        81.     struct S_anim *anim;
        82. };
        83. /*
        84. ** Définition de la structure décrivant les animations
        85. */
        86. typedef struct S_anim S_anim;
        87. struct S_anim
        88. {
        89.     /* nb d'image dans l'animation */
        90.     int nb_frame;
        91.     /* numéro de l'image en cours */
        92.     int frame_actu;
        93.     /* moment où l'image de l'animation a été affiché */
        94.     int last_update;
        95.     /* durée entre deux images */
        96.     unsigned int delai_frame;
        97.     /* pointeur vers la structure des images */
        98.     struct S_frame *frame;
        99. };
        100. /*
        101. ** Définition de la structure décrivant les images
        102. */
        103. typedef struct S_frame S_frame;
        104. struct S_frame
        105. {
        106.     /* coordonnées de la frames dans la surface */
        107.     int x;
        108.     int y;
        109. };
        110. /*********************************************************************
        111. ***************** PROTOTYPES DES FONCTIONS ***************************
        112. *********************************************************************/
        113. /* initialisation des sprites */
        114. void Initialisation_Sprites (struct S_lib_sprite *lib_sprite);
        115. /* libération des éléments alloués pour les sprites */
        116. void Free_Sprites (struct S_lib_sprite *lib_sprite);
        117. /* chargement statique des données images */
        118. void Sprites_DonneesStatic (struct S_lib_sprite *lib_sprite);
        119. /* sauvegarde des informations concernant les sprites */
        120. void Save_Sprites(struct S_lib_sprite *lib_sprite, char const *charset, char const *Save);
        121. /* chargement des informations concernant les sprites */
        122. void Load_Sprites(struct S_lib_sprite *lib_sprite, char const *fichierLoad_Sprites);
        123. /* affichage des sprites de façon globale */
        124. void Affichage_GlobalSprites(struct S_lib_sprite *lib_sprite, struct S_Carte *carte);
        125. /* fonction d'affichage des sprites 1 à 1 */
        126. void Affichage_Sprite (struct S_sprites *sprite, struct S_Carte *carte);
        127. /* fonction qui met à jour le sprite à chaque changement d'animation */
        128. void Changement_AnimSprite(struct S_sprites *sprite, int anim, int pause_anim);
        129. /* déplacement des sprites et test de collision */
        130. void Deplacement_Sprite(struct S_sprites *sprite, unsigned int x, unsigned int y, struct S_Carte *carte);
        131. /* traitement des événements de déplacement du sprite joueur */
        132. void Event_SpriteJoueur(SDL_Event *evenement , struct S_Carte *carte, struct S_lib_sprite *lib_sprite);
        133. #endif /* SPRITES_H_INCLUDED */
        • Partager sur Facebook
        • Partager sur Twitter
        Kr00pS
          23 novembre 2007 à 13:28:51

          Le code est pas superbement organisé, tu vas galérer plus tard (en même temps, un jeu en C c'est pas forcement la solution la plus judicieuse).

          Pour ton segfault, c'est toujours pareil (j'ai pas lu ton code en détail) mais apprend à debugger. Debugger est essentiel (surtout dans les jeux)

          Passe serieusement sous Visual C++ (t'es sous Windows apparement, rien ne t'empeche de recompiler sous Linux tes sources) si tu veux faire des jeux, même si c'est pour les faire en C car le debugger de MinGW très peu pour moi.

          A verifier: pointeurs (valeurs + adresse) / retour des fonctions / deroulement des I/O avec les fichiers / verification des algorithmes

          Pour les pointeurs, tu verifies les adresses, si une adresse est du genre 0xcdcdcdcd ça veut dire que ton objet n'est pas initialisé, 0xfeeefeee signifie que ton objet est déjà effacé, et 0x00000000 veut dire que ton objet n'est pas alloué. T'as des blagues du genre 0xbaadf00d pour des soucis avec les tableaux par exemple.

          En savoir plus

          En gros, t'es obligé de debugger pour ce genre de problèmes courant en C et C++. :)
          • Partager sur Facebook
          • Partager sur Twitter
          Fvirtman
          • Langage C
            23 novembre 2007 à 13:32:13

            Le debuggueur devrait te dire exactement ou ça crash, tu dois pouvoir trouver.
            • Partager sur Facebook
            • Partager sur Twitter

            Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

            BRUCELLA
              23 novembre 2007 à 13:51:33

              merci Kr00pS , je fais ce truc juste pour apprendre :) merci pour le lien :) Mais pourquoi passer sous VisualC++ il a quoi de mieux ?
              Faut vraiment que j'apprenne à debugger oui mais pour Fvirtman, mon debugger me dit pas ou y a un prob exactement ... et c'est pour cela que je demande de l'aide ici d'ailleurs tu vois ou ça bug toi avec ce que m'a écrit le debugger (cf premier message) ?. Je suis, j'étais à court de solution...
              • Partager sur Facebook
              • Partager sur Twitter
              Fvirtman
              • Langage C
                23 novembre 2007 à 14:00:58

                c'est quoi le debuggueur que tu utilises ?
                les messages qui sont la ne sont pas tres clairs.

                regarde, sous ton IDE, une fois que tu plantes, ou il s'arrete, tu dois pouvoir dépiler, regarder le code.... Quel IDE utilises tu ?
                • Partager sur Facebook
                • Partager sur Twitter

                Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

                BRUCELLA
                  23 novembre 2007 à 16:55:07

                  J'utilise code blocks comme IDE, et le debugger est :
                  Debugger name and version: GNU gdb 6.3

                  Quand je plante il me dit en ouvrant une fenetre : program received signal SIGSEGV, Segmentation fault. Do you want to view the backtrace ?

                  Là je repond oui et j'obtiens dans la partie debugger de mon écran ce message :
                  In ntdll!RtlpWaitForCriticalSection () (ntdll.dll) avec une fenetre qui s'ouvre, la fenetre call stack à laquelle je ne comprends rien d'ou mon appel à l'aide..

                  mais si une ame charitable pouvait tester mon code ça serait plus simple peut etre car je sais pas trop ce qui est important à dire ou non :(
                  • Partager sur Facebook
                  • Partager sur Twitter
                  Anonyme
                    23 novembre 2007 à 16:57:54

                    Dans le code que t'as posté, dans main.c, il y a 2 fonctions main() ?
                    • Partager sur Facebook
                    • Partager sur Twitter
                    BRUCELLA
                      23 novembre 2007 à 17:22:21

                      lol oui tu as l'oeeil said78vf , en effet y a deux main à cause d'un mauvais copié-coller :p je corrige ça de suite
                      • Partager sur Facebook
                      • Partager sur Twitter
                      Anonyme
                        23 novembre 2007 à 17:28:02

                        Désolé toujours pas bon, si tu indentais ton codes tu verrais tout de suite le problème dans le switch :
                        1. /*
                        2. ** Projet commencé le 13/10/07
                        3. **
                        4. ** Dernière modfification : 21/11/07
                        5. **
                        6. ** main.c
                        7. **
                        8. ** Fichier principal
                        9. **
                        10. ** Role :
                        11. ** - initialisation des bibliothèques
                        12. ** - fonction main()
                        13. **
                        14. */
                        15. #include "main.h"
                        16. int main (int argc, char *argv[])
                        17. {
                        18.    SDL_Event evenement;
                        19.    S_Carte Carte;
                        20.    S_lib_sprite lib_sprite;
                        21.    unsigned int fin = 0;
                        22.    /* initialisation de SDL, FMOD et autres */
                        23.    if (Init () > 0)
                        24.    {
                        25.       return 1;
                        26.    }
                        27.    /* lancement de la fonction aléatoire pour initialisé la carte
                        28.       Carte_Aleatoire(&Carte, 100, 100, "tuiles\\mchip0.bmp"); */
                        29.    /* sauvegarde la carte aléatoire
                        30.       Save_Carte(&Carte, "map\\save.map", "musique\\Opening1.mid", "tuiles\\mchip0.bmp"); */
                        31.    Initialisation_Sprites (&lib_sprite);
                        32.    Sprites_DonneesStatic (&lib_sprite);
                        33.    Save_Sprites (&lib_sprite, "sprites\\player.bmp", "map\\truc.txt");
                        34.    /*
                        35.       Load_Sprites(&lib_sprite, "map\\01.sprite");
                        36.       Load_Carte(&Carte, "map\\01.map"); */
                        37.    SDL_EnableKeyRepeat (10, 10);
                        38.    /* gestion des événements */
                        39.    while (!fin)
                        40.    {
                        41.       while (SDL_PollEvent (&evenement))
                        42.       {
                        43.          /* lancement de la gestion des événements de la carte */
                        44.          Evenement_Carte (&evenement, &Carte);
                        45.          Event_SpriteJoueur (&evenement, &Carte, &lib_sprite);
                        46.          /* gestion des événements du main */
                        47.          switch (evenement.type)
                        48.          {
                        49.          case SDLK_F1:
                        50.             SDL_SaveBMP (SDL_GetVideoSurface (), "screenshot.bmp");
                        51.             break;
                        52.          default:
                        53.             ;
                        54.          }
                        55.          break;
                        56. case SDL_QUIT:
                        57.          fin = 1;
                        58.          break;
                        59. default:
                        60.          ;
                        61.       }
                        62.    }
                        63.    /* affichage de la carte */
                        64.    Affichage_Carte (&Carte);
                        65.    Affichage_GlobalSprites (&lib_sprite, &Carte);
                        66.    SDL_Flip (SDL_GetVideoSurface ());
                        67. }
                        68. Liberation_Carte (&Carte);
                        69. Free_Sprites (&lib_sprite);
                        70. return 0;
                        71. }
                        • Partager sur Facebook
                        • Partager sur Twitter
                        BRUCELLA
                          23 novembre 2007 à 17:32:58

                          je sais pas ce qui se passe, c'est surtout si je faisais un copier coller correct plus que mon indentation je crois je corrige encore donc et désolé de ne pas avoir bien vérifié que ça correspondait à ce que j'ai dans IDE.
                          • Partager sur Facebook
                          • Partager sur Twitter
                          Anonyme
                            23 novembre 2007 à 17:59:53

                            J'ai aussi besoin des ressources comme les .bmp.
                            • Partager sur Facebook
                            • Partager sur Twitter
                            BRUCELLA
                              23 novembre 2007 à 18:03:44

                              ba heu tout est dans le lien que j'ai mis plus haut :)
                              • Partager sur Facebook
                              • Partager sur Twitter
                              Ceylo
                                23 novembre 2007 à 18:25:10

                                Le lien est incorrect.
                                • Partager sur Facebook
                                • Partager sur Twitter
                                BRUCELLA
                                  23 novembre 2007 à 21:23:31

                                  j'ai du encore boulété en effet en cliquant sur le lien on tombe sur la page : Vous venez de tomber sur une page qui n'existe pas ou n'existe plus..
                                  Si le problème persiste, veuillez contacter l'équipe du site sur le formulaire de contact : Formulaire de contact

                                  Pour revenir au site : Site du Zéro

                                  L'équipe du site.
                                  ...

                                  par contre quand on copie colle l'adresse donnée plus haut (http://www.gigasize.com/get.php/3196072177/RPG_Creation.zip) on tombe bien sur la page pour récup mon .zip ... je comprends pas ??!!
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  Ceylo
                                    23 novembre 2007 à 21:35:58

                                    Pas envie de m'inscrire pour pouvoir télécharger l'archive (horreur de ce genre de sites bourré de pubs).
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    BRUCELLA
                                      23 novembre 2007 à 22:31:05

                                      si tu en as un autre gratuit pour héberger mes fichier je prend, j'ai trouver ça en vitesse :) sinon pas besoin de s'inscrire pour télécharger heureusement !!
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      Ceylo
                                        23 novembre 2007 à 22:41:55

                                        Ah désolé, je n'avais pas trouvé comment télécharger (j'ai loupé la zone sur la droite).
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                        Kr00pS
                                          23 novembre 2007 à 22:42:56

                                          Le debugger de Visual C++ est une merveille (et je pèse mes mots). Je pense qu'a lui seul il justifie l'utilisation de l'IDE (en plus de L'intellisense qui est pas mal utile).

                                          Gratos avec la version Express, pas de limite. :)
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          Ceylo
                                            24 novembre 2007 à 0:18:40

                                            Avec GDB j'obtiens ça :
                                            Program received signal EXC_BAD_ACCESS, Could not access memory.
                                            0x00003c78 in Sprites_DonneesStatic ()


                                            Sinon j'ai regardé un peu ton code, manque beaucoup de vérifications pour la sécurité (allocations). J'ai aussi vu ça dans sprites.c ligne 59 :
                                            1. lib_sprite->sprites=malloc (lib_sprite->nb_sprites * sizeof lib_sprite->sprites);

                                            Tu alloues la taille d'un pointeur, au lieu de la taille de la structure……… c'est déjà le premier bug.

                                            Ensuite après avoir corrigé ça, l'erreur m'est signalée dans le même fichier vers la ligne 234, là où tu as cette boucle :
                                            1. for (frame=0; frame<lib_sprite->sprites[i].anim[anim].nb_frame; frame++)
                                            2. {
                                            3.     fwrite(&lib_sprite->sprites[i].anim[anim].frame[frame].x,
                                            4.            sizeof(lib_sprite->sprites[i].anim[anim].frame[frame].x),
                                            5.            1, fichier);
                                            6.     fwrite(&lib_sprite->sprites[i].anim[anim].frame[frame].y,
                                            7.            sizeof(lib_sprite->sprites[i].anim[anim].frame[frame].y),
                                            8.            1, fichier);
                                            9. }


                                            Là je n'ai pas trop envie d'approfondir, donc je te laisse voir.
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            BRUCELLA
                                              24 novembre 2007 à 2:07:03

                                              merci de ton aide, je pense que les allocations sont pas au top :s
                                              Pour les vérifications je sais pas trop comment on fait. Aurais tu un exemple ? ou peut etre un lien vers un site l'expliquant ou sinon des titres de livres bien que là ce soit plus complexe j'ai peu de moyen financier en ce moment...

                                              Je connais très peu le c, je débute et je cherche à comprendre et apprendre au fur et à mesure de mes erreurs :)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                              Anonyme
                                                24 novembre 2007 à 10:42:39

                                                Commence par ce site : http://mapage.noos.fr/emdel/.
                                                Cordialement.
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                Ceylo
                                                  24 novembre 2007 à 11:20:22

                                                  Je ne pense pas que le site d'ed soit adapté, il est plutôt fait pour approfondir.

                                                  Sinon pour les vérifications je pense à quelque chose de très simple :
                                                  1. typedef struct {
                                                  2.     int membre;
                                                  3.     float x, y;
                                                  4.     char visible;
                                                  5. } Structure;
                                                  6. Structure *nouveauModele(void) {
                                                  7.     Structure *new = NULL;
                                                  8.     new = malloc(sizeof (*new));
                                                  9.     if (new != NULL) { // <-- voilà ce qui manque chez toi !!
                                                  10.         membre = 0;
                                                  11.         x = 0;
                                                  12.         y = 0;
                                                  13.         visible = 0;
                                                  14.     } else { // <-- et en cas d'erreur
                                                  15.         puts("*** nouveauModele(): erreur d'allocation");
                                                  16.     }
                                                  17.     return new;
                                                  18. }


                                                  En fait le problème est que si tu tentes d'accéder aux membres de la structure alors que l'allocation de mémoire à échoué, tu te retrouves avec une jolie erreur de segmentation.
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                  Anonyme
                                                    24 novembre 2007 à 11:33:17

                                                    Citation : Soltic Lucas

                                                    Je ne pense pas que le site d'ed soit adapté, il est plutôt fait pour approfondir.


                                                    Alors tu ne connais pas le site d'Emmanuel.
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    Ceylo
                                                      24 novembre 2007 à 11:38:16

                                                      Je connais le site d'Emmanuel, et je pense qu'il n'est pas fait pour les débutants.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      Anonyme
                                                        24 novembre 2007 à 11:39:36

                                                        tiré du site d'Emmanuel :

                                                        Citation : Emmanuel Delahaye

                                                        Le but de ce site est de fournir au programmeur les moyens de réaliser du code correct, fiable et maintenable. Il s'adresse autant aux débutants qu'aux programmeurs C avertis.

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        BRUCELLA
                                                          24 novembre 2007 à 11:51:11

                                                          merci pour le site, y a des trucs interessant pour un débutant comme moi :) mais je rejoins la remarque de soltic, il n'est pas si accessible que ça pour un débutant.

                                                          Et en complément de cette remarque, je crois que quand on commence à avoir une connaissance assez poussé d'un thème on a tendance à oublié combien il peut etre dur de comprendre pour une personne débutante et combien on leur demande d'acquérir de chose en même temps.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          Ceylo
                                                            24 novembre 2007 à 12:28:09

                                                            Citation : said78vf

                                                            tiré du site d'Emmanuel :

                                                            Citation : Emmanuel Delahaye

                                                            Le but de ce site est de fournir au programmeur les moyens de réaliser du code correct, fiable et maintenable. Il s'adresse autant aux débutants qu'aux programmeurs C avertis.



                                                            Emmanuel a peut-être essayé de créer quelque chose d'accessible aux débutants, et même si c'est ce qu'il dit avoir fait, je pense qu'il y a encore du boulot.

                                                            En attendant le Site du Zér0 et beaucoup de pratique suffisent dans un premier temps.

                                                            Donc pour revenir au sujet Brucella, je te conseille de relire tout ton code et de voir où il manque des mesures de sécurité. Une fois que tu auras fait ça, réfléchis à la cause du problème dans la boucle (débordement ? mauvaise allocation ?).
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                            BRUCELLA
                                                              24 novembre 2007 à 12:56:27

                                                              j'ai trouvé de jolies bourdes avec les allocations, comme tu l'avais souligné, je donnais comme taille celle du pointeur et pas celle de la structure vers lequel le pointeur pointait.
                                                              EX : "lib_sprite->sprites=malloc (lib_sprite->nb_sprites * sizeof lib_sprite->sprites); " alors que j'aurais du écrire il me semble :
                                                              "lib_sprite->sprites=malloc (lib_sprite->nb_sprites * sizeof *lib_sprite->sprites);

                                                              je vais mettre des mesures de sécurité maintenant que je vois à peu près comment faire et je vais m'attaquer à la boucle :)

                                                              Merci

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              Program received signal SIGSEGV, Segmentation fault.

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur ●
                                                              • Markdown