Résultats de 1 à 8 sur 8

Sujet : Bug code d\'un labyrhinte avec allegro

  1. #1
    Membre MP
    Inscrit
    août 2013
    Messages
    1
    Salut,
    J\'ai un probleme avec le code suivant qui doit generer un labyrinthe aléatoire (main.c utilise les bibliothèques allegro et mur.bmp est un simple bitmap 20*20 pxls)

    main.c :
    Code:
    #include <stdlib.h> 
    #include \"gen_laby.h\" 
    #include <allegro.h> 
    
    int laby[40][30],a,b; 
    BITMAP *mur; 
    
    // Fonction main 
    int main() 
    { 
    // Initialisation d\'allegro 
    allegro_init(); 
    
    // Mise en place du clavier 
    install_keyboard(); 
    
    // Mise en place de la souris 
    if (install_mouse() == -1) 
    { 
    allegro_message(\"Erreur ! %s\", allegro_error) ; 
    return 1 ; 
    } 
    
    // Définition de la profondeur de couleur 
    set_color_depth(16); 
    
    // Mise en place du mode graphique 
    if (set_gfx_mode(GFX_AUTODETECT, 800, 600, 0, 0) != 0) 
    { 
    set_gfx_mode(GFX_TEXT, 0, 0, 0, 0); 
    allegro_message(\"Impossible d\'initialiser le mode vidéo !\\n%s\\n\", allegro_error); 
    return 1; 
    } 
    
    mur=load_bitmap(\"mur.bmp\",NULL); 
    
    genere_laby(38,28,&laby[0][0],100); 
    for (b=0;b<28;b++) 
    for (a=0;a<38;a++) 
    { 
    if (laby[a][b]==MUR) 
    draw_sprite(screen,mur,a*20,b*20); 
    } 
    
    // Boucle principale 
    while (!key[KEY_ESC]) 
    { 
    } 
    return 0; 
    
    ********************************** 
    gen_laby.h : 
    #include <stdlib.h> 
    #include <mem.h> 
    
    #define HAUT 1 
    #define DROITE 2 
    #define BAS 3 
    #define GAUCHE 4 
    
    #define VIDE 0 
    #define MUR 1 
    
    // Fonction qui génère le labyrinthe de dimension dim_x, dim_y 
    // à enregistrer dans le tableau de taille [dim_x][dim_y] vers 
    // lequel pointe *lab à partir de la clef. 
    void genere_laby(int dim_x, int dim_y, int *lab, int clef) 
    { 
    int init[dim_x][dim_y], laby[dim_x][dim_y], poss[4], nbr_poss, a, b, c; 
    int x, y, direction; 
    
    // Initialisation du generateur de nombres aleatoires 
    srand(clef); 
    
    // Initialisations 
    memset(poss, 0, 4*sizeof(int) ); 
    memset(init, 0, dim_x*dim_y*sizeof(int) ); 
    memset(laby, MUR, dim_x*dim_y*sizeof(int)) ; 
    
    // Premier tunnel 
    x=1; 
    y=1; 
    init[x][y]=1; 
    laby[x][y]=VIDE; 
    while (1) 
    { 
    nbr_poss=0; 
    c=0; 
    if ((y-2>=0)&&(y-2<dim_y)) 
    if (init[x][y-2]==0) 
    { 
    nbr_poss++; 
    poss[c]=HAUT; 
    c++; 
    } 
    if ((y+2>=0)&&(y+2<dim_y)) 
    if (init[x][y+2]==0) 
    { 
    nbr_poss++; 
    poss[c]=BAS; 
    c++; 
    } 
    if ((x-2>=0)&&(x-2<dim_x)) 
    if (init[x-2][y]==0) 
    { 
    nbr_poss++; 
    poss[c]=GAUCHE; 
    c++; 
    } 
    if ((x+2>=0)&&(x+2<dim_x)) 
    if (init[x+2][y]==0) 
    { 
    nbr_poss++; 
    poss[c]=DROITE; 
    c++; 
    } 
    if (nbr_poss==0) 
    break; 
    direction=rand()%nbr_poss; 
    if (poss[direction]==HAUT) 
    { 
    init[x][y-2]=1; 
    laby[x][y-1]=VIDE; 
    laby[x][y-2]=VIDE; 
    y=y-2; 
    } 
    if (poss[direction]==BAS) 
    { 
    init[x][y+2]=1; 
    laby[x][y+1]=VIDE; 
    laby[x][y+2]=VIDE; 
    y=y+2; 
    } 
    if (poss[direction]==DROITE) 
    { 
    init[x+2][y]=1; 
    laby[x+1][y]=VIDE; 
    laby[x+2][y]=VIDE; 
    x=x+2; 
    } 
    if (poss[direction]==GAUCHE) 
    { 
    init[x-2][y]=1; 
    laby[x-1][y]=VIDE; 
    laby[x-2][y]=VIDE; 
    x=x-2; 
    } 
    } 
    
    // On creuse le labyrinthe 
    for (a=0;a<dim_x;a++) 
    for (b=0;b<dim_y;b++) 
    if (init[a][b]==0) 
    { 
    
    // Initialisation du tunnel 
    x=a; 
    y=b; 
    init[x][y]=1; 
    laby[x][y]=VIDE; 
    nbr_poss=0; 
    c=0; 
    
    // On relie le tunnel au labyrinthe 
    if ((y-2>=0)&&(y-2<dim_y)) 
    if ((laby[x][y-1]+laby[x][y-2])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=HAUT; 
    c++; 
    } 
    if ((y+2>=0)&&(y+2<dim_y)) 
    if ((laby[x][y+1]+laby[x][y+2])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=BAS; 
    c++; 
    } 
    if ((x-2>=0)&&(x-2<dim_x)) 
    if ((laby[x-1][y]+laby[x-2][y])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=GAUCHE; 
    c++; 
    } 
    if ((x+2>=0)&&(x+2<dim_x)) 
    if ((laby[x+1][y]+laby[x+2][y])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=DROITE; 
    c++; 
    } 
    direction=rand()%nbr_poss; 
    if (poss[direction]==HAUT) 
    { 
    laby[x][y-1]=VIDE; 
    laby[x][y-2]=VIDE; 
    } 
    if (poss[direction]==BAS) 
    { 
    laby[x][y+1]=VIDE; 
    laby[x][y+2]=VIDE; 
    } 
    if (poss[direction]==DROITE) 
    { 
    laby[x+1][y]=VIDE; 
    laby[x+2][y]=VIDE; 
    } 
    if (poss[direction]==GAUCHE) 
    { 
    laby[x-1][y]=VIDE; 
    laby[x-2][y]=VIDE; 
    } 
    
    // On creuse le tunnel 
    while (1) 
    { 
    nbr_poss=0; 
    c=0; 
    if ((y-2>=0)&&(y-2<dim_y)) 
    if (init[x][y-2]==0) 
    { 
    nbr_poss++; 
    poss[c]=HAUT; 
    c++; 
    } 
    if ((y+2>=0)&&(y+2<dim_y)) 
    if (init[x][y+2]==0) 
    { 
    nbr_poss++; 
    poss[c]=BAS; 
    c++; 
    } 
    if ((x-2>=0)&&(x-2<dim_x)) 
    if (init[x-2][y]==0) 
    { 
    nbr_poss++; 
    poss[c]=GAUCHE; 
    c++; 
    } 
    if ((x+2>=0)&&(x+2<dim_x)) 
    if (init[x+2][y]==0) 
    { 
    nbr_poss++; 
    poss[c]=DROITE; 
    c++; 
    } 
    if (nbr_poss==0) 
    break; 
    direction=rand()%nbr_poss; 
    if (poss[direction]==HAUT) 
    { 
    init[x][y-2]=1; 
    laby[x][y-1]=VIDE; 
    laby[x][y-2]=VIDE; 
    y=y-2; 
    } 
    if (poss[direction]==BAS) 
    { 
    init[x][y+2]=1; 
    laby[x][y+1]=VIDE; 
    laby[x][y+2]=VIDE; 
    y=y+2; 
    } 
    if (poss[direction]==DROITE) 
    { 
    init[x+2][y]=1; 
    laby[x+1][y]=VIDE; 
    laby[x+2][y]=VIDE; 
    x=x+2; 
    } 
    if (poss[direction]==GAUCHE) 
    { 
    init[x-2][y]=1; 
    laby[x-1][y]=VIDE; 
    laby[x-2][y]=VIDE; 
    x=x-2; 
    } 
    } 
    
    // On relie la fin du tunnel au labyrinthe 
    if ((y-2>=0)&&(y-2<dim_y)) 
    if ((laby[x][y-1]+laby[x][y-2])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=HAUT; 
    c++; 
    } 
    if ((y+2>=0)&&(y+2<dim_y)) 
    if ((laby[x][y+1]+laby[x][y+2])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=BAS; 
    c++; 
    } 
    if ((x-2>=0)&&(x-2<dim_x)) 
    if ((laby[x-1][y]+laby[x-2][y])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=GAUCHE; 
    c++; 
    } 
    if ((x+2>=0)&&(x+2<dim_x)) 
    if ((laby[x+1][y]+laby[x+2][y])==(MUR+VIDE)) 
    { 
    nbr_poss++; 
    poss[c]=DROITE; 
    c++; 
    } 
    direction=rand()%nbr_poss; 
    if (poss[direction]==HAUT) 
    { 
    laby[x][y-1]=VIDE; 
    laby[x][y-2]=VIDE; 
    } 
    if (poss[direction]==BAS) 
    { 
    laby[x][y+1]=VIDE; 
    laby[x][y+2]=VIDE; 
    } 
    if (poss[direction]==DROITE) 
    { 
    laby[x+1][y]=VIDE; 
    laby[x+2][y]=VIDE; 
    } 
    if (poss[direction]==GAUCHE) 
    { 
    laby[x-1][y]=VIDE; 
    laby[x-2][y]=VIDE; 
    } 
    } 
    memmove(lab, laby, dim_x*dim_y*sizeof(int) ); 
    return; 
    }
    lors de l\'éxecution, windows renvoie une erreur.
    Merci de m\'aider.

  2. #2
    Membre MP
    Inscrit
    août 2013
    Messages
    627
    Arf il n y a que moi qui ne vois pas tout le code?

    c est quoi l erreur que ca te retourne?
    ... Until then, we're better off dead
    A smile on the lips and a hole in the head ...

  3. #3
    Membre MP
    Inscrit
    août 2013
    Messages
    1 012
    Nothing -> Moi je vois le code, je sais pas s\'il est entie parce qu\'il y a quelques choses qui sont fausses :s mais je les dis plus bas

    LXir ->

    Code:
    while (!key[KEY_ESC]) 
    { 
    
    }
    euh je sais que c\'est la boucle du programme mais généralement on exécute une fonction ou qqc de la sorte dedans

    et puis tu as oulbié de fermer ta boucle fonction main( ) (probablement un pb de copier\\coller..)...

    Ensuite tu devrais p-e nous donner l\'erreur qui en résulte car je ne sais pas après quoi je dois regarder.... et j\'ai pas envie de lire TOUT le code.. lol

    Ciao
    Grégory S.

    eVias Web & Software Solutions.

    Développement Web et logiciel en tout genre et Open Source.

    FOSDEM 2008. Venez -y nombreux !

  4. #4
    Visiteur MP
    Visiteur MP
    L\'erreur est : \"GENERATEUR a causé une erreur de division dans le module GENERATEUR.EXE à 015F:004019BC\"
    (vachement explicite... :cry: )

    Il est normal que la boucle principale du programme ne continne aucune fonction car c\'est un programme d\'essai qui affiche le labyrinthe généré. Elle permet donc juste d\'attendre que l\'utilisateur appuye sue echap.

  5. #5
    Membre MP
    Inscrit
    août 2013
    Messages
    1 012
    Ok pour la boucle :wink:

    et puis ben pour l\'erreur je vois pas ske sait, j\'ai jamais eu ça en tout cas :s

    désolé de pas pouvoir t\'aider sur ce point... :s

    une erreur pareille peut p-e venir de l\'interne donc du compilateur et non pas du code,... :s je sais pas...

    Ciao
    Grégory S.

    eVias Web & Software Solutions.

    Développement Web et logiciel en tout genre et Open Source.

    FOSDEM 2008. Venez -y nombreux !

  6. #6
    Membre MP
    Inscrit
    août 2013
    Messages
    329
    Salut,

    Un premier conseil : debugge ton code et essaie de déterminer exactement d\'où vient l\'erreur (en supprimant/commentant certaines parties).

    Erreur de division : vérifie que tu n\'as aucune division par 0 dans ton code : si c\'est le cas, ajoute un test, une division par zéro entraîne des sortes de segfaults.

    Essaie de debugger ton code et repostes qd tu auras une idée plus précise du problème :wink:

  7. #7
    Visiteur MP
    Visiteur MP

    Bug code d\'un labyrhinte avec allegro

    Apres avoir inserer des sorties de texte pour trouver précisement l\'erreur, je l\'ai finalement trouvé :
    direction=rand()%nbr_poss;
    il se trouve que pour une raison qu\'il faut que je trouve (j\'ai qq idées mais n\'ai pas eut le temps de vérifier: je pense qu\'il y a un probleme au niveau de la constante MUR) nbr_poss peut prendre la valeur 0 (ce qui ne devrait pas etre le cas normalement vu la structure du programme) et on obtient alors une erreur divide by 0 (d\'ailleur les textes sur la programmation ne precisent jamais de ne pas utiliser la valeur 0 pour un modulo...).

    Merci pour vos réponses,
    LXir

  8. #8
    Membre MP
    Inscrit
    août 2013
    Messages
    329
    Content que tu aies trouvé Juste une chose : les docs ne précisent pas d\'utiliser 0 pour un modulo ? Voyons voir :

    Le modulo est le reste d\'une division euclidienne. Donc pour trouver ce reste le programme va effectuer une division : pour trouver 4 mod 2 tu es bien obligé de diviser par 2, donc 4 mod 0 divisera par 0 :wink:

Informations du sujet

Utilisateur(s) parcourant ce sujet

il y a actuellement 1 utilisateur(s) parcourant ce sujet. (0 membre(s) et 1 visiteur(s))

Règles des messages

  • Vous ne pouvez pas créer de sujets
  • Vous ne pouvez pas répondre aux sujets
  • Vous ne pouvez pas importer de fichiers joints
  • Vous ne pouvez pas éditer vos messages
  •  
  • Les BB codes sont Activés
  • Les Smileys sont Activés
  • Le BB code [IMG] est Activé
  • Le code [VIDEO] est Activé
  • Le code HTML est Désactivé