Déplacement de robot - code à corriger

Version imprimable

Déplacer un robot, dans une grille cellulaire de taille 15*15, partant d’un point de départ (donné) jusque un point d’arrivé (donné aussi).
Et le déplacement d’une cellule à une autre se fait par un choix aléatoire dans le voisinage de cette cellule (les 8 cellules tournant de cette cellule).
Le robot se déplace pas à pas.
Une cellule a les coordonnées (x, y).
Le déplacement d’une cellule à une autre se fait de telle façon que :
x2<=x1<=x, et y2<=y1<=y (dans le cas où les coordonnées de cellule de départ supérieur aux celles d’arrivées).

(x1, y1) : coordonnées de cellule courante.
(x, y) : coordonnées de cellule de départ.
(x2, y2) : coordonnées de cellule d’arrivée.
J’ai une fonction mais je ne sais pas si elle est correcte ou non, parce que quand je l’ai testé le programme cesse de fonctionner.
voilà le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
void deplacer_agent(float **g, int *px,int *py,int *px2,int *py2,bool ** cd,int dep1,int tg, bool *init)
{
    int k;
 
 
    if((&px2>&px) && (&py2>&py))
    {
        k=*px;
        *px=*px2;
        *px2=k;
    }
 
    if(*init&&*px!=-1&&*py!=-1)
    {
 
        cd[*px][*py]=false;
        *init=false;
    }
 
    else
    {
        if(*init&&*px==-1&&*py==-1)
 
        {
 
            *px=rand() %10;
            *py=rand() %10;
            cd[*px][*py]=false;
            *init=false;
        }
        else
        {
            int px1=*px;
            int py1=*py;
 
            if(dep1==-1)
            {
 
                px1=*px;
                py1=*py;
                int compt=0;
                while(((px1<0||px1>tg-1||py1<0||py1>tg-1)||((dep1==-1)) )&&compt<20)
                {
 
                    compt++;
                    px1=*px;
                    py1=*py;
 
                    do
                    {
                        dep1=rand() %8;
                        {
                            if(dep1==0 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1-1; }
                            if(dep1==1 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1-1;px1=px1-1;}
                            if(dep1==2 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){px1=px1-1;}
                            if(dep1==3 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1+1;px1=px1-1;}
                            if(dep1==4 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1+1;}
                            if(dep1==5 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1+1;px1=px1+1;}
                            if(dep1==6 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){px1=px1+1;}
                            if(dep1==7 && (*px2<=px1<=*px) && (*py2<=py1<=*py)){py1=py1-1;px1=px1+1;}
                        }
                    }
                    while((*px2<=px1<=*px) && (*py2<=py1<=*py));
 
                    if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
                    {
                        if(!cd[px1][py1]){px1=-1;py1=-1;}
                    }
 
 
                }
                if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
                    {cd[px1][py1]=false;*px=px1;*py=py1;   }
                else
                    {*px=-1; *py=-1; }
 
            }
        }
    }
}

08/09/2014, 09h39
LittleWhite

Bonjour,

Citation:

J’ai une fonction mais je ne sais pas si elle est correcte ou non, parce que quand je l’ai testé le programme cesse de fonctionner.

Donc, votre fonction est fausse ,car elle entraine le crash (erreur de segmentation) du programme. Il faut maintenant la déboguer.

Code:

if((&px2>&px) && (&py2>&py))

Ceci est ultra étrange. Je pense que vous maitrisez les pointeurs : http://chgi.developpez.com/pointeur/

Code:

if(*init&&*px==-1&&*py==-1)

Vous testez si *init ET *px est "vrai" (souvent != 0) et le résultat, soit "vrai", soit "faux", vous le comparez à -1. Ce qui est totalement plus que totalement incorrect.

Pour faire votre algorithme, commencez par l'écrire (son comportement) sur une feuille de papier.
08/09/2014, 12h36
ternel

A priori, un crash, c'est quasiment toujours un *NULL ou un free() d'un pointeur déjà libéré.

Comme ton code est bourré de pointeur, le problème vient de là.

Je te recommande fortement d'utiliser une structure de position
typedef struct position {
int x, y;
} position;

Tu as trop de pointeurs.
Seul les variables sur d'énorme structures (pointeurs constants) et les arguments à modifier (pointeurs non-constants) devraient être passé par pointeurs.
Pour les tableaux, je recommande d'utiliser la notation [] dans les arguments.

void deplacer_agent(float **g, int *px,int *py,int *px2,int *py2,bool ** cd,int dep1,int tg, bool *init)devrait être
void deplacer_agent(float const grille[][], int const taille_grille, position actuelle, position const cible, position const source, bool const cd[][], int dep1, bool *init).
Et encore, je ne comprends ni init, ni cd ni dep1, les noms sont mal donné.

N'hésite jamais à marquer const tout argument un peu complexe (tableau, structure, pointeur) qui n'a pas vocation à être modifié.
08/09/2014, 15h12
gangsoleil

Bonjour,

En plus des commentaires précédents : lorsque tu écris cela : (*px2<=px1<=*px) tu veux vérifier que px1 est compris entre *px2 et *px ? Si oui, il faut que tu sépares ça en deux tests distincts.

Citation:

Comme ton code est bourré de pointeur, le problème vient de là.

Citation:

Tu as trop de pointeurs.

Voilà cette fonction (deplacer_agent) qui travaille sans problèmes portant qu’elle utilise plusieurs pointeurs.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
void deplacer_agent(float **g, int *px,int *py,bool ** cd,int dep1,int tg, bool *init)
{
 
    if(*init&&*px!=-1&&*py!=-1)
    {
       cd[*px][*py]=false;
       *init=false;
 
    }
    else
    {
        if(*init&&*px==-1&&*py==-1)
        {
          *px=rand() %10;
          *py=rand() %10;
          cd[*px][*py]=false;
          *init=false;
          }
          else
          {
 
         int px1=*px;
           int py1=*py;
 
 
        if(dep1==-1)
          {
           px1=*px;
           py1=*py;
           int compt=0;
    while(((px1<0||px1>tg-1||py1<0||py1>tg-1)||((dep1==-1)) )&&compt<20)
                {
 
               compt++;
           px1=*px;
           py1=*py;
                  dep1=rand() %8;
        if(dep1==0){py1=py1-1; }
        if(dep1==1){py1=py1-1;px1=px1-1;}
        if(dep1==2){px1=px1-1;}
        if(dep1==3){py1=py1+1;px1=px1-1;}
        if(dep1==4){py1=py1+1;}
        if(dep1==5){py1=py1+1;px1=px1+1;}
        if(dep1==6){px1=px1+1;}
        if(dep1==7){py1=py1-1;px1=px1+1;}
 
        if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
        {
        if(!cd[px1][py1]){px1=-1;py1=-1;}
        }
 
 
 
                }
      if(px1>=0&&px1<=tg-1&&py1>=0&&py1<=tg-1)
        {cd[px1][py1]=false;*px=px1;*py=py1;   }
      else
        {*px=-1; *py=-1; }
 
           }
 
 
    }
}
}

En fait la fonction deplacer_agent2 () c’est la fonction deplacer_agent () avec modification, j’essaie de la modifier pour arriver à programmer le problème écrite dans la discussion.

11/09/2014, 12h00
ternel
On va jouer à un jeu.
Tu vas donner de vrais noms à chaque variable et surtout à chaque paramètre.

Et en plus, tu as un devoir supplémentaire:
tu nous fais la liste des variables de l'utilisateur de la fonction qui doivent être modifiés par l'appel.
Code:

1 2 3 4 5 6 if(dep1==0){py1=py1-1; } if(dep1==1){py1=py1-1;px1=px1-1;} if(dep1==2){px1=px1-1;} if(dep1==3){py1=py1+1;px1=px1-1;} if(dep1==4){py1=py1+1;}
Ca, c'est très très moche.
Ca se remplace par un switch sur dep1, et surtout un commentaire avant, genre, "faire un déplacement".

et puis px1 devrait probablement etre source_x, dest_x ou current_x
11/09/2014, 16h50
Médinoc

De plus, on dirait que tu fais un effort pour réduire la lisibilité de ton code. Les espaces coûtent cher, chez toi?