Algorithme "main gauche" pour labyrinthe

Algorithme "main gauche" pour labyrinthe - C - Programmation

Marsh Posté le 11-05-2009 à 21:29:02    

Voila.
On a pour projet de dévellopper un programme simple générant un labyrinthe, l'affichant(SDL) et le résolvant, sans critère d'optimisation.
Notre labyrinthe est dit "à ilots", c'est à dire qu'il n'a pas de chemin unique.

 

J'ai utilisé une structure de 4 integers de valeur 0 ou 1 :
laby.nord laby.sud etc...
puis créé une matrice de ceux ci.
Dans la génération je me suis débrouilé pour avoir les bords pleins à tout les coups et à éviter d'avoir des "doubles" murs.
probleme : au niveau du codage de l'algorithme, y'a un pépin : il ne passe pas dans certaines portes, et fini souvent bloqué...
EN particulier :
-S'il viens de gauche, il refuse d'aller au nord
-S'il viens de droite, il refuse d'aller autre part qu'à l'ouest

 

Je suis assez préssé par le temps et je n'ai plus vraiment le temps de revoir complètement ma structure du problème et j'aimerai juste faire fonctionner mon algo...

 

le code complet :

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <SDL/SDL.h>
  6. typedef struct
  7. {
  8. int nord,sud,est,ouest;
  9. } bloc ;
  11. typedef struct
  12. {
  13. int x , y ;
  14. }pos;
  16. void pause();
  18. int main(int argc,char *argv[])
  19. {
  20.   // Initialisation des nombres aléatoires
  21.   srand(time(NULL));
  22.   //Définition des variables
  23.   int lo;                   //largeur du labyrinthe (verticale)
  24.   int la;                            //Longeur du labyrinthe (horizontale)
  25.   int lop;                  //Creation de "lop" pour les lignes ajoutées
  26.   int lot,lat;
  27.   int t,i,j;                //Compteurs
  29. /*
  30.   printf("Longueur du labyrinthe ? " );
  31.   scanf("%d",&lo);
  32.   printf("Largeur du labyrinthe ? " );
  33.   scanf("%d",&la);
  34. */
  35.   lo=8;                  //DEFINITION
  36.   la=8;                  //ARBITRAIRE
  37.   lop=lo+2;
  38.   lot=lo-1;
  39.   lat=la-1;
  40.  
  42.   //Création du labyrinthe : matrice de cases
  43.   bloc laby[la][lop];
  45.   //Initialisation de toutes les portes à 0
  46.   for(j=0;j<lop;j++)
  47.   {
  48.       for(i=0;i<la;i++)
  49.       {
  50.         laby[i][j].nord=0;
  51.         laby[i][j].ouest=0;
  52.         laby[i][j].est=0;
  53.         laby[i][j].sud=0;
  54.       }
  55.   }
  56.  
  57.   //Génération des portes
  58.   for(j=0;j<lop;j++)
  59.   {
  60.       for(i=0;i<la;i++)
  61.       {             
  62.        if ( i==0 && j<=lot && j!=0) // cases latérales ouest
  63.           {
  64.            laby[i][j].nord=0;
  65.            laby[i][j].ouest=1;
  66.            laby[i][j].est=rand()%2*rand()%2;
  67.            laby[i][j].sud=rand()%2*rand()%2;
  68.           }
  69.        else if ( i==lat && j>1 && j<=lot ) // cases latérales est
  70.           {
  71.            laby[i][j].nord=0;
  72.            laby[i][j].ouest=0;
  73.            laby[i][j].est=1;
  74.            laby[i][j].sud=rand()%2*rand()%2;
  75.           }
  76.        else if ( i!=0 && j==1 && i!=lat) // cases latérales nord
  77.           {
  78.            laby[i][j].nord=1;
  79.            laby[i][j].ouest=0;
  80.            laby[i][j].est=rand()%2*rand()%2;
  81.            laby[i][j].sud=rand()%2*rand()%2;
  82.           }
  83.        else if ( i!=0 && j==lo && i!=lat)// cases latérales sud
  84.           {
  85.            laby[i][j].nord=0;
  86.            laby[i][j].ouest=0;
  87.            laby[i][j].est=rand()%2*rand()%2;
  88.            laby[i][j].sud=1;
  89.           }
  90.        else if ( i==0 && j==lo)// case coin sud-ouest
  91.           {
  92.            laby[i][j].nord=0;
  93.            laby[i][j].ouest=1;
  94.            laby[i][j].est=rand()%2*rand()%2;
  95.            laby[i][j].sud=1;
  96.           }
  97.        else if ( i==lat && j==1)// case coin nord-est
  98.           {
  99.            laby[i][j].nord=1;
  100.            laby[i][j].ouest=0;
  101.            laby[i][j].est=1;
  102.            laby[i][j].sud=rand()%2*rand()%2;
  103.           }
  104.         else if ( i!=0 && i!=lat && j>1 && j<=lot) // Cases centrales
  105.           {
  106.            laby[i][j].nord=0;
  107.            laby[i][j].ouest=0;
  108.            laby[i][j].est=rand()%2*rand()%2;
  109.            laby[i][j].sud=rand()%2*rand()%2;
  110.           }
  111.         else if ( i==lat && j==lo )// case "finale" sud-est
  112.          {
  113.            laby[i][j].nord=0;
  114.            laby[i][j].ouest=0;
  115.            laby[i][j].est=1;
  116.            laby[i][j].sud=0;
  117.          }
  118.       }
  119. }
  120.     //===================Dessinage=======================
  121.     SDL_Surface * ecran = NULL;
  122.     SDL_Init(SDL_INIT_VIDEO);
  123.     SDL_Surface *bhorizontale = NULL;
  124.     SDL_Surface *bverticale = NULL;
  125.     SDL_Surface *point = NULL;
  126.     ecran = SDL_SetVideoMode(80*la+10,80*lop+10,32,SDL_HWSURFACE);
  127.     SDL_WM_SetCaption("Labyrinthe",NULL);
  128.    
  129.     //++++++++++++++Coloriage du fond++++++++++++++++++++
  130.     Uint32 rouge = SDL_MapRGB(ecran->format,255,0,0);
  131.     SDL_FillRect(ecran, NULL, rouge);
  132.    
  133.     //++++++++++++++Mise en place des barreaux+++++++++++
  134.     Uint32 vert = SDL_MapRGB(ecran->format,0,255,0);
  135.     bhorizontale = SDL_CreateRGBSurface(SDL_SWSURFACE,70,10,32,0,0,0,0);
  136.     SDL_FillRect(bhorizontale, NULL, vert);
  137.     bverticale = SDL_CreateRGBSurface(SDL_SWSURFACE,10,70,32,0,0,0,0);
  138.     SDL_FillRect(bverticale, NULL, vert);
  139.    
  140.     //++++++++++++++création du dégradé de bleu++++++++++
  141.     Uint32 bleu[255];
  142.     for(i=0;i<256;i++)
  143.      {
  144.        bleu[i] = SDL_MapRGB(ecran->format,0,0,i);
  145.      }
  146.    
  147.     //==================Affichage du labyrinthe=================
  148.     point = SDL_CreateRGBSurface(SDL_SWSURFACE,10,10,32,0,0,0,0);
  149.     SDL_FillRect(point, NULL, vert);
  151.     for(j=0;j<lop;j++)
  152.     {
  153.       for(i=0;i<la;i++)
  154.       {     
  155.        if (j!=0) // Placement de points aux angles des murs pour avoir un dessin continu
  156.        {
  157.        SDL_Rect positionijs;
  158.        positionijs.x =80*i;
  159.        positionijs.y=80*j;
  160.        SDL_BlitSurface(point,NULL,ecran,&positionijs);
  161.        positionijs.x =80*(i+1);
  162.        positionijs.y=80*j;
  163.        SDL_BlitSurface(point,NULL,ecran,&positionijs);
  164.        SDL_Flip(ecran);                     
  165.        }
  167.        if (laby[i][j].nord==1)
  168.        {
  169.         SDL_Rect positionijs;
  170.         positionijs.x =80*i+10;
  171.         positionijs.y=80*j;
  172.         SDL_BlitSurface(bhorizontale,NULL,ecran,&positionijs);
  173.         SDL_Flip(ecran);
  174.        }
  175.        if (laby[i][j].sud==1)
  176.        {
  177.         SDL_Rect positionijs;
  178.         positionijs.x =80*i+10;
  179.         positionijs.y=80*j+80;
  180.         SDL_BlitSurface(bhorizontale,NULL,ecran,&positionijs);
  181.         SDL_Flip(ecran);
  182.        }
  183.        if (laby[i][j].ouest==1)
  184.        {
  185.         SDL_Rect positionijs;
  186.         positionijs.x =80*i;
  187.         positionijs.y=80*j+10;
  188.         SDL_BlitSurface(bverticale,NULL,ecran,&positionijs);
  189.         SDL_Flip(ecran);
  190.        }
  191.        if (laby[i][j].est==1)
  192.        {
  193.         SDL_Rect positionijs;
  194.         positionijs.x =80*i+80;
  195.         positionijs.y=80*j+10;
  196.         SDL_BlitSurface(bverticale,NULL,ecran,&positionijs);
  197.         SDL_Flip(ecran);
  198.        }
  199.       }
  200.     }
  202.  
  203.   //=====================Fin du dessin==============================
  204.   pos caseij;
  205.   int deplact_h=0,deplact_v=1;
  206.   caseij.x=0;
  207.   caseij.y=1;
  208.   t=0;
  210.   //==================Algorithme=====================================
  211.    do
  212.   {       
  213.        SDL_Rect positionijs;
  214.        positionijs.x =80*caseij.x+40;
  215.        positionijs.y=80*caseij.y+40;
  216.        SDL_FillRect(point, NULL, bleu[12*t]);
  217.        SDL_BlitSurface(point,NULL,ecran,&positionijs);
  218.        SDL_Flip(ecran); 
  219.      
  220.        i=caseij.x;
  221.        j=caseij.y;
  222.      
  223.        if(deplact_v=1)
  224.          {
  225.           if(laby[i][j].est==0)
  226.             {
  227.               caseij.x++;
  228.               deplact_h=1;
  229.               deplact_v=0;                           
  230.             }
  231.            else if(laby[i][j].sud==0)
  232.             {
  233.               caseij.y++;
  234.               deplact_h=0;
  235.               deplact_v=1;
  236.             }
  237.            else if((laby[i][j].ouest==0) && (laby[i-1][j].est==0))
  238.             {
  239.               caseij.x--;
  240.               deplact_h=-1;
  241.               deplact_v=0;
  242.             }
  243.            else
  244.             {
  245.               caseij.y--;
  246.               deplact_h=0;
  247.               deplact_v=-1;
  248.             }
  249.          }
  250.        else if(deplact_v=-1)
  251.          {
  252.           if((laby[i][j].ouest==0) && (laby[i-1][j].est==0))
  253.             {
  254.               caseij.x--;
  255.               deplact_h=-1;
  256.               deplact_v=0;
  257.             }
  258.            else if((laby[i][j].nord==0) && (laby[i][j-1].sud==0))
  259.             {
  260.               caseij.y--;
  261.               deplact_h=0;
  262.               deplact_v=-1;
  263.             }
  264.           else if(laby[i][j].est==0)
  265.             {
  266.               caseij.x++;
  267.               deplact_h=1;
  268.               deplact_v=0;
  269.             }
  270.            else
  271.             {
  272.               caseij.y++;
  273.               deplact_h=0;
  274.               deplact_v=1;
  275.             }                     
  276.           }
  277.        else if(deplact_h=-1)
  278.          {
  279.           if(laby[i][j].sud==0)
  280.             {
  281.               caseij.y++;
  282.               deplact_h=0;
  283.               deplact_v=1;
  284.             }
  285.           else if(laby[i][j].ouest==0 && laby[i-1][j].est==0)
  286.             {
  287.               caseij.x--;
  288.               deplact_h=-1;
  289.               deplact_v=0;
  290.             }
  291.           else if(laby[i][j].nord==0 && laby[i][j-1].sud==0)
  292.             {
  293.               caseij.y--;
  294.               deplact_h=0;
  295.               deplact_v=-1;
  296.             }
  297.           else
  298.             {
  299.               caseij.x++;
  300.               deplact_h=1;
  301.               deplact_v=0;
  302.             }
  303.          }
  304.        else if(deplact_h=1)
  305.          {
  306.           if(laby[i][j].nord==0 && laby[i][j-1].sud==0)
  307.             {
  308.               caseij.y--;
  309.               deplact_h=0;
  310.               deplact_v=-1;
  311.             }
  312.           else if(laby[i][j].est==0)
  313.             {
  314.               caseij.x++;
  315.               deplact_h=1;
  316.               deplact_v=0;
  317.             }
  318.           else if(laby[i][j].sud==0)
  319.             {
  320.               caseij.y++;
  321.               deplact_h=0;
  322.               deplact_v=1;
  323.             }                   
  324.           else
  325.             {
  326.               caseij.x--;
  327.               deplact_h=-1;
  328.               deplact_v=0;
  329.             }
  330.                                          
  331.           } 
  332.           t++;   
  333.   }while(t<=20);//((caseij.x!=la && caseij.y!=lop)||(caseij.x!=0 && caseij.y!=0));
  335.  
  336.  
  337.   //====================Fin du programme============================           
  338.   pause();   
  339.   SDL_FreeSurface(bhorizontale);
  340.   SDL_FreeSurface(bverticale);
  341.   SDL_FreeSurface(ecran);
  342.   SDL_Quit();
  343.   return 0;
  344. }
  346. void pause()
  347. {
  348.      int continuer=1;
  349.      SDL_Event event;
  350.    
  351.      while(continuer)
  352.         {
  353.  SDL_WaitEvent(&event);
  354.          switch(event.type)
  355.             {
  356.               case SDL_QUIT : continuer = 0;
  357.             }
  358.         }
  359. }


Suis conscient que la programmation n'est pas très catholique mais prenez ça comme l'oeuvre d'un débutant qu'a essayer d'imaginer le truc de A à Z seul... jusqu'à maintenant...

 

AU niveau de mon do-while je changerai la condition plus tard à un "tant que tu n'est ni arrivé ni revenu à la case 0,0"

 

J'vous en supplie, trouvez mon erreur...

 


Message édité par kwaio le 11-05-2009 à 22:13:01
Reply

Marsh Posté le 11-05-2009 à 21:29:02   

Reply

Marsh Posté le 11-05-2009 à 22:32:05    

Mouais, erreur que tous les débutants sur cette planète et ailleurs ont fait : l'affectation en C est ==, pas =.
 
Edit: ouais et sinon ton algo pour créer le labyrinthe n'est pas terrible. À une époque, qui commence à être lointaine, j'avais fait un économiseur d'écran de ce type. L'algo de génération était un peu mieux foutu, du style :

  • Choisi un point d'entrée et un point de sortie.
  • Trace un chemin récusivement et aléatoirement jusqu'à ce que toutes les cases soient visitées une et une seule fois.
  • Quand tu tombes sur une impasse, dépile jusqu'à pouvoir avancer.


Ça donne des résultats bien plus réalistes et scotchant à regarder.


Message édité par tpierron le 11-05-2009 à 22:37:12
Reply

Marsh Posté le 11-05-2009 à 22:40:42    

Oui j'ai trouvé ce genre de trucs après mais comme j'ai dit, j'ai plus trop le temps...
je vérifie mes affectations/tests

 

SUPER ça marche
Merde c'était tout bête et je me suis cassé la tête tout le week end.
Merci beaucoup


Message édité par kwaio le 11-05-2009 à 22:42:30
Reply

Marsh Posté le 11-05-2009 à 22:46:08    

on a le droit de faire un "while( (condition) || (autre condition) )" ?
ça ne semble pas marcher...

 

J'aimerai qu'il s'arrete quand il a fini maintenant ^^

Message cité 1 fois
Message édité par kwaio le 11-05-2009 à 22:51:02
Reply

Marsh Posté le 11-05-2009 à 22:48:37    

Oui on a le droit. Le while() continuera tant qu'au moins l'une des deux conditions est vraie.

Reply

Marsh Posté le 11-05-2009 à 22:53:09    

kwaio a écrit :

on a le droit de faire un "while( (condition) || (autre condition) )" ?
ça ne semble pas marcher...


 
Effectivement, il ne termine pas non plus chez moi. Qui plus est pour éviter un segfault, il faut aussi changer la ligne 216 :

Code :
  1. SDL_FillRect(point, NULL, bleu[12*t]);


en

Code :
  1. SDL_FillRect(point, NULL, bleu[(12*t)%256]);


Reply

Marsh Posté le 11-05-2009 à 23:17:56    

AH, oui, ça évite les points blancs ou verts, pas bête, merci.
J'ai essayé de bidouiller mon "tant que" y'a un probleme.
Je continue de potasser.

Reply

Marsh Posté le 12-05-2009 à 01:00:55    

PAS moyen d'empécher la boucle d'etre infinie.
J'me suis planté où, cette fois ?

Reply

Marsh Posté le 12-05-2009 à 05:54:02    

Arf, je vois que dans ton code tu ne gardes pas la trace des cases visitées. C'est clair que tu vas boucler dans des cas comme celui-ci :

────┐
─ ▪ │
────┘


 
Bon, j'ai vraiment que ça à faire en ce moment. Je viens de dépoussiérer mon code qui devait dater de 1998. L'algo utilise une méthode de backtracking récursive pour la construction et la recherche. C'est ce qu'il y a de plus simple.

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <SDL/SDL.h>
  6. typedef uint8_t **     maze_t;
  7. typedef uint8_t *      mrow_t;
  9. #define    MAKE_POS(x, y)   ((y << 16) | (x))
  10. #define    BLOC_W           10
  11. #define    BLOC_H           10
  13. enum
  14. {
  15.     MZF_NORD  = 0x01,
  16.     MZF_EST   = 0x02,
  17.     MZF_SUD   = 0x04,
  18.     MZF_OUEST = 0x08,
  19.     MZF_NSOE  = 0x0f,
  20.     MZF_VISIT = 0x10
  21. };
  23. void pause();
  25. static int opposite[] = {0, MZF_SUD, MZF_OUEST, 0, MZF_NORD, 0, 0, 0, MZF_EST};
  27. maze_t alloc_maze(int w, int h)
  28. {
  29.     maze_t maze = calloc(w * h + h * sizeof *maze, 1);
  30.     mrow_t mem  = (mrow_t) (maze + h);
  31.     int    i;
  33.     memset(mem, MZF_NSOE, w * h);
  35.     for (i = 0; i < h; maze[i] = mem, mem += w, i ++);
  37.     return maze;
  38. }
  40. void SDL_DrawLine(SDL_Surface * ecran, uint32_t color, int x, int y, int x2, int y2)
  41. {
  42.     SDL_Rect r = {x, y, x2 - x + 1, y2 - y + 1};
  44.     SDL_FillRect(ecran, &r, color);
  45. }
  47. Uint32 SDL_PushTicks(Uint32 interval, void * unused)
  48. {
  49.     SDL_Event tick;
  50.     memset(&tick, 0, sizeof tick);
  51.     tick.type = SDL_USEREVENT;
  52.     SDL_PushEvent(&tick);
  53.     return interval;
  54. }
  56. int main(int argc,char *argv[])
  57. {
  58.     // Initialisation des nombres aléatoires
  59.     srand(time(NULL));
  61.     //Définition des variables
  62.     int w;                    // largeur du labyrinthe (verticale)
  63.     int h;                    // Longeur du labyrinthe (horizontale)
  64.     int t,i,j;                // Compteurs
  65.     int xs, ys;               // Position de départ
  66.     int xe, ye;               // Position de fin
  68.     w = argc > 1 ? atoi(argv[1]) : 40;
  69.     h = argc > 2 ? atoi(argv[2]) : 40;
  71.     fprintf(stderr, "Generating maze %dx%d...\n", w, h);
  73.     // Sélection d'un point d'entrée et de sortie
  74.     switch (rand() % 2) {
  75.     case 0: ys = 0; xs = rand() % w; ye = h - 1; xe = rand() % w; i = MZF_NORD;  break;
  76.     case 1: xs = 0; ys = rand() % h; xe = w - 1; ye = rand() % h; i = MZF_OUEST; break;
  77.     }
  79.     //Création du labyrinthe : matrice de cases
  80.     maze_t laby  = alloc_maze(w, h);
  81.     int *  stack = calloc(sizeof *stack, w * h);
  83.     laby[ys][xs] &= ~i;
  84.     laby[ye][xe] &= ~opposite[i];
  85.     stack[0] = MAKE_POS(xs, ys);
  87.     //Génération des portes via algo de backtracking récursif.
  88.     for (i = 0, j = 1; j > 0; i ++)
  89.     {
  90.         int x = stack[j - 1] & 0xffff;
  91.         int y = stack[j - 1] >> 16;
  92.         int f = 0;
  94.         laby[y][x] |= MZF_VISIT;
  96.         //On visite toutes les cellules avoisinantes de manière alélatoire
  97.         while (f != MZF_NSOE)
  98.         {
  99.             int dir = 1 << (rand() % 4); //Choisi une direction parmi les 4 possibles
  100.             int nx, ny;
  102.             //Ajuste si on est déjà passé par là
  103.             if (f & dir)
  104.             {
  105.                 if ((f & (dir-1)) < dir-1) while (f & dir) dir >>= 1;
  106.                 else                       while (f & dir) dir <<= 1;
  107.             }
  109.             switch (dir) {
  110.             case MZF_NORD:  nx = x; ny = y - 1; break;
  111.             case MZF_EST:   ny = y; nx = x + 1; break;
  112.             case MZF_SUD:   nx = x; ny = y + 1; break;
  113.             case MZF_OUEST: ny = y; nx = x - 1; break;
  114.             }
  116.             //Dèjà visité ou visitable ?
  117.             if (0 <= nx && nx < w && 0 <= ny && ny < h && ! (laby[ny][nx] & MZF_VISIT))
  118.             {
  119.                 //Visite cette cellule, en créant un chemin de (x, y) à (nx, ny)
  120.                 laby[y][x] &= ~dir;
  121.                 laby[ny][nx] &= ~opposite[dir];
  122.                 stack[j++] = MAKE_POS(nx, ny);
  123.                 break;
  124.             }
  125.             else f |= dir;
  126.         }
  128.         //On a visité toutes les cellules avoisinante: backtrack
  129.         if (f == MZF_NSOE) j --;
  130.     }
  132.     //===================Dessin=======================
  133.     SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);
  135.     SDL_Surface * ecran = SDL_SetVideoMode(BLOC_W * w + 20, BLOC_H * h + 20, 32, SDL_HWSURFACE);
  136.     SDL_TimerID   timer;
  138.     SDL_WM_SetCaption("Labyrinthe", NULL);
  140.     //++++++++++++++Coloriage du fond++++++++++++++++++++
  141.     uint32_t back = SDL_MapRGB(ecran->format, 0,   0, 0);
  142.     uint32_t vert = SDL_MapRGB(ecran->format, 0, 255, 0);
  143.     uint32_t dead = SDL_MapRGB(ecran->format, 0, 128, 0);
  145.     SDL_FillRect(ecran, NULL, back);
  147.     //==================Affichage du labyrinthe=================
  148.     for (j = 0; j < h; j++)
  149.     {
  150.         for (i = 0; i < w; i++)
  151.         {
  152.             int f  = laby[j][i];
  153.             int x  = 10 + i * BLOC_W;
  154.             int y  = 10 + j * BLOC_H;
  155.             int x2 = x + BLOC_W - 1;
  156.             int y2 = y + BLOC_H - 1;
  158.             if (j > 0) f &= ~MZF_NORD;
  159.             if (i > 0) f &= ~MZF_OUEST;
  161.             laby[j][i] &= ~MZF_VISIT;
  163.             // Placement de points aux angles des murs pour avoir un dessin continu
  164.             if (f & MZF_NORD)  SDL_DrawLine(ecran, vert, x,  y,  x2, y);
  165.             if (f & MZF_EST)   SDL_DrawLine(ecran, vert, x2, y,  x2, y2);
  166.             if (f & MZF_SUD)   SDL_DrawLine(ecran, vert, x,  y2, x2, y2);
  167.             if (f & MZF_OUEST) SDL_DrawLine(ecran, vert, x,  y,  x,  y2);
  168.         }
  169.     }
  170.     SDL_UpdateRect(ecran, 0, 0, 0, 0);
  171.     timer = SDL_AddTimer(100, SDL_PushTicks, NULL);
  173.     //=====================Fin du dessin==============================
  175.     //===================Parcours=====================================
  176.     stack[0] = MAKE_POS(xs, ys);
  177.     j = 1;
  179.     while (! (xs == xe && ys == ye) && j > 0)
  180.     {
  181.         SDL_Event event;
  182.         SDL_WaitEvent(&event);
  184.         switch (event.type) {
  185.         case SDL_KEYDOWN:
  186.             if (event.key.state != SDL_PRESSED || event.key.keysym.sym != SDLK_ESCAPE)
  187.                 continue;
  188.         case SDL_QUIT:
  189.             j = -1; continue;
  190.         case SDL_USEREVENT:
  191.             break;
  192.         default:
  193.             continue;
  194.         }
  196.         int x = stack[j - 1] & 0xffff;
  197.         int y = stack[j - 1] >> 16;
  198.         int f = laby[y][x] & ~MZF_VISIT;
  200.         SDL_Rect path = {10 + x * BLOC_W, 10 + y * BLOC_H, BLOC_W, BLOC_H};
  202.         if (f & MZF_NORD)  path.y += 2, path.h -= 2;
  203.         if (f & MZF_OUEST) path.x += 2, path.w -= 2;
  204.         if (f & MZF_SUD)   path.h -= 2;
  205.         if (f & MZF_EST)   path.w -= 2;
  207.         SDL_FillRect(ecran, &path, vert);
  208.         SDL_UpdateRect(ecran, 0, 0, 0, 0);
  210.         laby[y][x] |= MZF_VISIT;
  211.         xs = x; ys = y;
  213.         //Avance dans le labyrinthe
  214.         while (f != MZF_NSOE)
  215.         {
  216.             int dir = 1 << (rand() % 4); //Choisi une direction parmi les 4 possibles
  217.             int nx, ny;
  219.             //Ajuste si on est déjà passé par là
  220.             if (f & dir)
  221.             {
  222.                 if ((f & (dir-1)) < dir-1) while (f & dir) dir >>= 1;
  223.                 else                       while (f & dir) dir <<= 1;
  224.             }
  226.             switch (dir) {
  227.             case MZF_NORD:  nx = x; ny = y - 1; break;
  228.             case MZF_EST:   ny = y; nx = x + 1; break;
  229.             case MZF_SUD:   nx = x; ny = y + 1; break;
  230.             case MZF_OUEST: ny = y; nx = x - 1; break;
  231.             }
  233.             //Dèjà visité ou visitable ?
  234.             if (0 <= nx && nx < w && 0 <= ny && ny < h && ! (laby[ny][nx] & MZF_VISIT))
  235.             {
  236.                 stack[j++] = MAKE_POS(nx, ny);
  237.                 break;
  238.             }
  239.             else f |= dir; t ++;
  240.         }
  242.         if (f == MZF_NSOE)
  243.         {
  244.             SDL_FillRect(ecran, &path, dead);
  245.             j --;
  246.         }
  247.     }
  248.     SDL_RemoveTimer(timer);
  250.     //====================Fin du programme============================
  251.     if (j == 0)
  252.     {
  253.         fprintf(stderr, "Parcours terminé...\n" );
  254.         pause();
  255.     }
  256.     SDL_FreeSurface(ecran);
  257.     SDL_Quit();
  259.     return 0;
  260. }
  262. void pause()
  263. {
  264.     int continuer = 1;
  265.     SDL_Event event;
  267.     while(continuer)
  268.     {
  269.         SDL_WaitEvent(&event);
  270.         switch(event.type) {
  271.         case SDL_KEYDOWN:
  272.         case SDL_QUIT: continuer = 0;
  273.         }
  274.     }
  275. }
  277. #ifdef    WIN32
  278. #include <windows.h>
  279. int WINAPI WinMain(
  280.     HINSTANCE hInstance,
  281.     HINSTANCE hPrevInstance,
  282.     LPSTR lpCmdLine,
  283.     int nCmdShow)
  284. {
  285.     return main(0, NULL);
  286. }
  287. #endif


Reply

Marsh Posté le 12-05-2009 à 19:45:07    

C'est bien joli, et sympa, même mais je n'ai aucune envie de faire un copier/collé du travail d'un autre, ni même de m'inspirer de sa technique.
J'assume la médiocrité de la méthode, les irrégularités de synthaxe, je souhaite juste que ça fonctionne.
 
Ceci dit, j'ai rendu mon travail aujourd'hui =)

Reply

Marsh Posté le 12-05-2009 à 19:45:07   

Reply

Marsh Posté le 12-05-2009 à 20:19:12    

Arf, c'était pour un TP, je pensais que c'était pour le fun.
 
Sinon, par curiosité, comment as-tu résolu le problème de bouclage (si tu as eu le temps de le résoudre [:dawa] ) ?

Reply

Marsh Posté le 13-05-2009 à 15:00:27    

J'ai aps eu le temps.
J'avais genre 3 devoirs à rendre pour le lendemain.
càd mon projet d'info plus deux autres travaux de groupes.
Donc j'ai encore le temps de réparer ça pour la soutenance, mais sinon j'ai rendu un programme qui se ferme tout seul une fois fini.

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed