Probleme Programmation C

Sujet: Re: Probleme Programmation C Lun 29 Nov 2010 - 14:48

en fait je suis pas sur de pouvoir travailler dessus, j ai pas le meme prof que d habitude mais promis j essayerais ^^

Sujet: Re: Probleme Programmation C Lun 29 Nov 2010 - 16:27

Sujet: Re: Probleme Programmation C Lun 29 Nov 2010 - 16:54

je comprend meme pas ta fonction

deja je trouve bizarre qu'elles soit pas symetrique et en plus je voit pas de quoi est constituer ta barriere. ( je voit ce qu'est ton (char) 4.)

en fait si tu pouvait m expliquer un peu comment fonctionne ton programme ce serait plus facile.

Code:: void creation_mur(char *tab, int ligne, int colonne)
{
int i,j;

for(j=0;j<ligne;j++)
{
*(tab+j*colonne)=(char) 4;
*(tab+colonne*(j-1)+1)=(char) 4;
}

for(i=0;i<colonne;i++)
{
*(tab+i)=(char) 4;
*(tab+colonne*(ligne-1)+i)=(char) 4;
}

}

Sujet: Re: Probleme Programmation C Lun 29 Nov 2010 - 17:09

le char 4 c'est un losange, c'est juste un symbole qui marque les cases sur lequels le robot n'a pas le droit d'aller mais sans etre un obstacle ( 'X' ) sinon il essaierai de le contourner ...

La fonction créer mur :

en gros si le mur est représenté par les cases avec un o :

o o o o o o o o --> colonne
o - - - - - - - - o
o - - - - - - - - o
o - - - - - - - - o
o - - - - - - - - o
o o o o o o o o

| lignes
v
en gros...

Donc je veux des char 4 dans la 1ere ligne ( d'offset 0 à colonne )
dans la derniere ( d'offset ligne*colonne+ de 0 à colonne )
dans la 1ere colonne ( d'offset (de 0 à ligne)*colonne )
dans la derniere colonne ( d'offset ( de 0 à ligne)*colonne + colonne)

( Je me suis peut etre trompé dans les offsets )

Sujet: Re: Probleme Programmation C Lun 29 Nov 2010 - 17:53

bon j'ai modifié quelques trucs et ça marche bien maintenant Smile

( ça devait etre une inversion entre colonne et ligne quelque part )

Encore merci de ton aide et d'y avoir passé du temps ...

Emissaire Nombre de messages : 84 Age : 33 Date d'inscription : 14/11/2010

Code:: #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int define(int);
void orientation(char*, int, int, int, int);
void creation_mur(char*, int, int);
void position_obstacle(char*, int, int);
void mise_a_jour(char*, int, int, int, int, int);
int test_grille(char*, int, int, int);
int analyse(char*, int, int, int, int);
int deplacement_cas1(char*, int, int*, int*, int*, int);
int deplacement_cas2(char*, int, int*, int*, int*, int);
int variation_energie(int, int);
void affiche(char*, int, int);

int main()
{
srand (time(0));
int ligne=0, colonne=0, ligne_robot=0, colonne_robot=0, orient=0;
ligne = define(ligne);
colonne = define(colonne);
char tab[ligne][colonne];

//initialisation du tableau par des espaces vides
memset(tab[0], ' ', sizeof(tab));

ligne_robot = define(ligne_robot);
colonne_robot = define(colonne_robot);
orient = define(orient);

orientation(*tab, colonne, ligne_robot, colonne_robot, orient);

creation_mur(*tab, ligne, colonne);

position_obstacle(*tab, ligne, colonne);

affiche(*tab, ligne, colonne);

mise_a_jour(*tab, ligne, colonne, ligne_robot, colonne_robot, orient);

affiche(*tab, ligne, colonne);

return 0;
}

int define(int x)
{
static int k, X, Y;

switch (k)
{
case 0 :
printf("\n Entrez la dimension verticale");
printf(" de l'espace ( nombre de lignes ) : ");
do (scanf("%d", &x)); while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
X=x;
break;
case 1 :
printf("\n Entrez la dimension horizontale de l'espace ");
printf("( nombre de colonnes ) : ");
do (scanf("%d", &x)); while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
Y=x;
break;
case 2 :
printf("\n Entrez l'abscisse du robot : ");
do (scanf("%d", &x)); while ((x<=0||x>X)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 3 :
printf("\n Entrez l'ordonnee du robot : ");
do (scanf("%d", &x)); while ((x<=0||x>Y)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 4 :
printf("\n Entrez l'orientation du robot : ");
do (scanf("%d", &x)); while ((x<0||x>3)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
break;
}

k++;
return x;
}

void orientation(char *tab, int colonne, int ligne_robot,
int colonne_robot ,int orient)
{
switch(orient)
{
case 0 :
*(tab+colonne*ligne_robot+colonne_robot)='|';
break;
case 1 :
*(tab+colonne*ligne_robot+colonne_robot)='/';
break;
case 2 :
*(tab+colonne*ligne_robot+colonne_robot)='-';
break;
case 3 :
*(tab+colonne*ligne_robot+colonne_robot)='\';
break;
}

}

void creation_mur(char *tab, int ligne, int colonne)
{
int i,j;

for(j=0;j<ligne;j++)
{
*(tab+j*colonne)='X';
*(tab+colonne*j+colonne)='X';
}

for(i=0;i<colonne;i++)
{
*(tab+i)='X';
*(tab+colonne*ligne-i)='X';
}

}

void position_obstacle(char *tab, int ligne, int colonne)
{
int a=0, b=0;

while(1)
{
printf("\n Entrez l'abscisse de l'obstacle ");
printf("(ou -1 si pour ne pas ajouter d'obstable) : ");
scanf("%d", &a);
if(a==-1)
break;
a=a+1;
printf("\n Entrez l'ordonnee de l'obstacle : ");
scanf("%d", &b);
b=b+1;

if ((0<a)&&(a<=ligne-1)&&(0<b)&&(b<=colonne-1))
switch (*(tab+colonne*a+b))
{
case ' ':
*(tab+colonne*a+b)='X';
break;
case 'X':
printf("\n ! Il y a des obstacles à la meme position. ! ");
break;
case ((char) 4):
printf("\n ! L'obstacle ne peut se trouver sur un mur ! ");
break;
default :
printf("\n ! Des obstacles sont à la meme position ");
printf("que le robot et n'apparaitrons pas ! ");
}
else
{
printf("\n Erreur : L'obstacle n'est pas dans l'espace. ");
printf("Il n'y apparaitra donc pas.");
break;
}
}
}

void mise_a_jour(char *tab, int ligne, int colonne, int ligne_robot, int colonne_robot, int orient)
{
int test=0, perception=0, nbr_maj=0, energie=5200;

while(nbr_maj < 5000 && energie >= 0 && test!=1)
{
nbr_maj++;
test=0;
perception=0;

test=test_grille(tab, ligne, colonne, test);

perception=analyse(tab, colonne, ligne_robot, colonne_robot, perception);

if(perception==0)
energie=deplacement_cas1(tab, colonne, &ligne_robot, &colonne_robot, &orient, energie);
else if(perception==1)
energie=deplacement_cas2(tab, colonne, &ligne_robot, &colonne_robot, &orient, energie);
else
{
printf("\n Aucun déplacement n'est possible ! \n");
break;
}

}

if(nbr_maj==5000)
printf("Time Out");
else if(energie==0)
printf("Plus d'Energie !");
else
printf("Succes !");

printf("\n Nombre de mises a jour : %d", nbr_maj);
printf("\n Energie restante : %d", energie);
}
// fonction marche pas encore

int test_grille(char* tab, int ligne, int colonne, int test)
{
test=0;

int x,y;
for(x=0; x<(ligne); x++)
{
for(y=0; y<(colonne); y++)
{
if (*(tab+(colonne)*x+y) == ' ')
test++;
}
}

if (test==0)
test=1;
else
test=0;

return test;
}

int analyse(char *tab, int colonne, int ligne_robot, int colonne_robot, int perception)
{

int h,f;
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f) == ' ')
{
perception=0;
break;
}

else
perception=1;
}
}

if (perception!=0)
{
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f)!='X')
{
perception=1;
break;
}

else
perception=2;
}
}
}

return perception;
}

int deplacement_cas1(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie)
{
int alea=0, orient_av, var_energie=0;
energie-=1;
orient_av=orient;

alea=rand()%8;
switch(alea)
{
case 0 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)-1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot-=1;
orient=3;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 1 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == ' ')
{
*colonne_robot-=1;
orient=0;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)-1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot-=1;
orient=1;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == ' ')
{
*ligne_robot+=1;
orient=2;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)+1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot+=1;
orient=3;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 5 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == ' ')
{
*colonne_robot+=1;
orient=0;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)+1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot+=1;
orient=1;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == ' ')
{
*ligne_robot-=1;
orient=2;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}

energie=(energie-1)-var_energie;

return energie;
}

int deplacement_cas2(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie)
{
int alea=0, orient_av, var_energie=0;
energie-=1;

orient_av=orient;

alea=rand()%8;
switch(alea)
{
case 0 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)-1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot-=1;
orient=3;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 1 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*colonne_robot-=1;
orient=0;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)-1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot-=1;
orient=1;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X')
{
*ligne_robot+=1;
orient=2;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)+1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot+=1;
orient=3;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 5 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*colonne_robot+=1;
orient=0;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)+1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot+=1;
orient=1;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X')
{
*ligne_robot-=1;
orient=2;
var_energie=variation_energie(&orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}

energie=(energie-1)-var_energie;

return energie;
}

int variation_energie(int orient, int orient_av)
{
int cout_rotation;

switch(orient_av)
{
case 0:
if(orient==0)
cout_rotation=0;
else if(orient==1)
cout_rotation=1;
else if(orient==2)
cout_rotation=2;
else if(orient==3)
cout_rotation=1;
break;
case 1:
if(orient==0)
cout_rotation=1;
else if(orient==1)
cout_rotation=0;
else if(orient==2)
cout_rotation=1;
else if(orient==3)
cout_rotation=2;
break;
case 2:
if(orient==0)
cout_rotation=2;
else if(orient==1)
cout_rotation=1;
else if(orient==2)
cout_rotation=0;
else if(orient==3)
cout_rotation=1;
break;
case 3:
if(orient==0)
cout_rotation=1;
else if(orient==1)
cout_rotation=2;
else if(orient==2)
cout_rotation=1;
else if(orient==3)
cout_rotation=0;
break;
}
return cout_rotation;
}

//fonction affiche : affichage du tableau
void affiche(char *tab, int ligne, int colonne)
{
//declaration des variables
int i, j;

//affichage du tableau avec bordures
for(i=1;i<(ligne-1);i++)
{
printf("\n");

for(j=1;j<(colonne-1);j++)
printf("----");

printf("-");
printf("\n");

for(j=1;j<(colonne-1);j++)
printf(": %c ", *(tab+colonne*i+j));

if(j==(colonne-1))
printf(":");
}
printf("\n");

for(j=1;j<(colonne-1);j++)
{
printf("----");
}
printf("-");

printf("\n");

}

Emissaire Nombre de messages : 143 Age : 33 Date d'inscription : 22/09/2010

Code:: #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int define(int);
void orientation(char*, int, int, int, int);
void creation_mur(char*, int, int);
void position_obstacle(char*, int, int);
void mise_a_jour(char*, int, int, int, int, int);
int test_grille(char*, int, int, int);
int analyse(char*, int, int, int, int);
int deplacement_cas1(char*, int, int*, int*, int*, int);
int deplacement_cas2(char*, int, int*, int*, int*, int);
int variation_energie(int, int);
void affiche(char*, int, int);

int main()
{
srand (time(0));
int ligne=0, colonne=0, ligne_robot=0, colonne_robot=0, orient=0;
ligne = define(ligne);
colonne = define(colonne);
char tab[ligne][colonne];

//initialisation du tableau par des espaces vides
memset(tab[0], ' ', sizeof(tab));

ligne_robot = define(ligne_robot);
colonne_robot = define(colonne_robot);
orient = define(orient);

orientation(*tab, colonne, ligne_robot, colonne_robot, orient);

creation_mur(*tab, ligne, colonne);

position_obstacle(*tab, ligne, colonne);

affiche(*tab, ligne, colonne);

mise_a_jour(*tab, ligne, colonne, ligne_robot, colonne_robot, orient);

affiche(*tab, ligne, colonne);

return 0;
}

int define(int x)
{
static int k, X, Y;

switch (k)
{
case 0 :
printf("\n Entrez la dimension verticale");
printf(" de l'espace ( nombre de lignes ) : ");
do (scanf("%d", &x)); while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
X=x;
break;
case 1 :
printf("\n Entrez la dimension horizontale de l'espace ");
printf("( nombre de colonnes ) : ");
do (scanf("%d", &x)); while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
Y=x;
break;
case 2 :
printf("\n Entrez l'abscisse du robot : ");
do (scanf("%d", &x)); while ((x<=0||x>X)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 3 :
printf("\n Entrez l'ordonnee du robot : ");
do (scanf("%d", &x)); while ((x<=0||x>Y)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 4 :
printf("\n Entrez l'orientation du robot : ");
do (scanf("%d", &x)); while ((x<0||x>3)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
break;
}

k++;
return x;
}

void orientation(char *tab, int colonne, int ligne_robot,
int colonne_robot ,int orient)
{
switch(orient)
{
case 0 :
*(tab+colonne*ligne_robot+colonne_robot)='|';
break;
case 1 :
*(tab+colonne*ligne_robot+colonne_robot)='/';
break;
case 2 :
*(tab+colonne*ligne_robot+colonne_robot)='-';
break;
case 3 :
*(tab+colonne*ligne_robot+colonne_robot)='92';
break;
}

}

void creation_mur(char *tab, int ligne, int colonne)
{
int i,j;

for(j=0;j<ligne;j++)
{
*(tab+j*colonne)='X';
*(tab+colonne*j+colonne)='X';
}

for(i=0;i<colonne;i++)
{
*(tab+i)='X';
*(tab+colonne*ligne-i)='X';
}

}

void position_obstacle(char *tab, int ligne, int colonne)
{
int a=0, b=0;

while(1)
{
printf("\n Entrez l'abscisse de l'obstacle ");
printf("(ou -1 si pour ne pas ajouter d'obstable) : ");
scanf("%d", &a);
if(a==-1)
break;
a=a+1;
printf("\n Entrez l'ordonnee de l'obstacle : ");
scanf("%d", &b);
b=b+1;

if ((0<a)&&(a<=ligne-1)&&(0<b)&&(b<=colonne-1))
switch (*(tab+colonne*a+b))
{
case ' ':
*(tab+colonne*a+b)='X';
break;
case 'X':
printf("\n ! Il y a des obstacles à la meme position. ! ");
break;
case ((char) 4):
printf("\n ! L'obstacle ne peut se trouver sur un mur ! ");
break;
default :
printf("\n ! Des obstacles sont à la meme position ");
printf("que le robot et n'apparaitrons pas ! ");
}
else
{
printf("\n Erreur : L'obstacle n'est pas dans l'espace. ");
printf("Il n'y apparaitra donc pas.");
break;
}
}
}

void mise_a_jour(char *tab, int ligne, int colonne, int ligne_robot, int colonne_robot, int orient)
{
int test=0, perception=0, nbr_maj=0, energie=5200;

while(nbr_maj < 5000 && energie >= 0 && test!=1)
{
nbr_maj++;
test=0;
perception=0;

test=test_grille(tab, ligne, colonne, test);

perception=analyse(tab, colonne, ligne_robot, colonne_robot, perception);

if(perception==0)
energie=deplacement_cas1(tab, colonne, &ligne_robot, &colonne_robot, &orient, energie);
else if(perception==1)
energie=deplacement_cas2(tab, colonne, &ligne_robot, &colonne_robot, &orient, energie);
else
{
printf("\n Aucun déplacement n'est possible ! \n");
break;
}

}

if(nbr_maj==5000)
printf("Time Out");
else if(energie==0)
printf("Plus d'Energie !");
else
printf("Succes !");

printf("\n Nombre de mises a jour : %d", nbr_maj);
printf("\n Energie restante : %d", energie);
}
// fonction marche pas encore

int test_grille(char* tab, int ligne, int colonne, int test)
{
test=0;

int x,y;
for(x=0; x<(ligne); x++)
{
for(y=0; y<(colonne); y++)
{
if (*(tab+(colonne)*x+y) == ' ')
test++;
}
}

if (test==0)
test=1;
else
test=0;

return test;
}

int analyse(char *tab, int colonne, int ligne_robot, int colonne_robot, int perception)
{

int h,f;
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f) == ' ')
{
perception=0;
break;
}

else
perception=1;
}
}

if (perception!=0)
{
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f)!='X')
{
perception=1;
break;
}

else
perception=2;
}
}
}

return perception;
}

int deplacement_cas1(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie)
{
int alea=0, orient_av, var_energie=0;
energie-=1;
orient_av=*orient;

alea=rand()%8;
switch(alea)
{
case 0 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)-1)) == ' '
&& *(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*ligne_robot-=1;
*colonne_robot-=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '';
}
break;
case 1 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == ' ')
{
*colonne_robot-=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)-1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot-=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == ' ')
{
*ligne_robot+=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)+1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot+=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '';
}
break;
case 5 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == ' ')
{
*colonne_robot+=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)+1)) == ' '
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot+=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == ' ')
{
*ligne_robot-=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}

energie=(energie-1)-var_energie;

return energie;
}

int deplacement_cas2(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie)
{
int alea=0, orient_av, var_energie=0;
energie-=1;

orient_av=*orient;

alea=rand()%8;
switch(alea)
{
case 0 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)-1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot-=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '';
}
break;
case 1 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*colonne_robot-=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)-1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot-=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X')
{
*ligne_robot+=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)+1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot+=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '';
}
break;
case 5 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*colonne_robot+=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)+1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot+=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X')
{
*ligne_robot-=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}

energie=(energie-1)-var_energie;

return energie;
}

int variation_energie(int orient, int orient_av)
{
int cout_rotation;

switch(orient_av)
{
case 0:
if(orient==0)
cout_rotation=0;
else if(orient==1)
cout_rotation=1;
else if(orient==2)
cout_rotation=2;
else if(orient==3)
cout_rotation=1;
break;
case 1:
if(orient==0)
cout_rotation=1;
else if(orient==1)
cout_rotation=0;
else if(orient==2)
cout_rotation=1;
else if(orient==3)
cout_rotation=2;
break;
case 2:
if(orient==0)
cout_rotation=2;
else if(orient==1)
cout_rotation=1;
else if(orient==2)
cout_rotation=0;
else if(orient==3)
cout_rotation=1;
break;
case 3:
if(orient==0)
cout_rotation=1;
else if(orient==1)
cout_rotation=2;
else if(orient==2)
cout_rotation=1;
else if(orient==3)
cout_rotation=0;
break;
}
return cout_rotation;
}

//fonction affiche : affichage du tableau
void affiche(char *tab, int ligne, int colonne)
{
//declaration des variables
int i, j;

//affichage du tableau avec bordures
for(i=1;i<(ligne-1);i++)
{
printf("\n");

for(j=1;j<(colonne-1);j++)
printf("----");

printf("-");
printf("\n");

for(j=1;j<(colonne-1);j++)
printf(": %c ", *(tab+colonne*i+j));

if(j==(colonne-1))
printf(":");
}
printf("\n");

for(j=1;j<(colonne-1);j++)
{
printf("----");
}
printf("-");

printf("\n");

}

Emissaire Nombre de messages : 84 Age : 33 Date d'inscription : 14/11/2010

Code:: #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int define(int);
void orientation(char*, int, int, int, int);
void creation_mur(char*, int, int);
void position_obstacle(char*, int, int);
void mise_a_jour(char*, int, int, int, int, int);
int test_grille(char*, int, int, int);
int analyse(char*, int, int, int, int);
int deplacement_cas(char*, int, int*, int*, int*, int, int);
int variation_energie(int, int);
void affiche(char*, int, int);

int main()
{
printf("\n Projet ASPIRATOR ! \n");
printf(" realise par Alexandre Simard, EPFL : Microtechniques\n");

srand (time(0));
int ligne=0, colonne=0, ligne_robot=0, colonne_robot=0, orient=0;
ligne = define(ligne);
colonne = define(colonne);
char tab[ligne][colonne];

//initialisation du tableau par des espaces vides
memset(tab[0], ' ', sizeof(tab));

/* appel de la fonction pour entrer les valeurs
necessaires au programme */
ligne_robot = define(ligne_robot);
colonne_robot = define(colonne_robot);
orient = define(orient);

// appel de la fonction interpretant l'orientation du robot
orientation(*tab, colonne, ligne_robot, colonne_robot, orient);

/* appel de la fonction qui crée un mur fictif d'obstacle
autour de la grille */
creation_mur(*tab, ligne, colonne);

// appel de la fonction qui place les obstacles
position_obstacle(*tab, ligne, colonne);

/* appel de la fonction qui regroupe l'analyse,
le déplacement et l'affichage à la fin */
mise_a_jour(*tab,ligne,colonne,ligne_robot,colonne_robot,orient);

return 0;
}

// fonction define : attribue les entrees aux variables du programme
int define(int x)
{
/* ce sont des variables temporaires destinees a conserver
certaines saisies pour cette fonction */
static int k, X, Y;

switch (k)
{
case 0 :
printf("\n Entrez la dimension verticale");
printf(" de l'espace ( nombre de lignes ) : ");
do (scanf("%d", &x));
while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
X=x;
break;
case 1 :
printf("\n Entrez la dimension horizontale de l'espace ");
printf("( nombre de colonnes ) : ");
do (scanf("%d", &x));
while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
Y=x;
break;
case 2 :
printf("\n Entrez l'abscisse du robot : ");
do (scanf("%d", &x));
while ((x<0||x>X)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 3 :
printf("\n Entrez l'ordonnee du robot : ");
do (scanf("%d", &x));
while ((x<0||x>Y)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 4 :
printf("\n Entrez l'orientation du robot : ");
do (scanf("%d", &x));
while ((x<0||x>3)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
break;
}

k++;
return x;
}

/* fonction orientation : enregistre la direction initiale
du robot dans le tableau */
void orientation(char *tab, int colonne, int ligne_robot,
int colonne_robot ,int orient)
{
switch(orient)
{
case 0 :
*(tab+colonne*ligne_robot+colonne_robot)='|';
break;
case 1 :
*(tab+colonne*ligne_robot+colonne_robot)='/';
break;
case 2 :
*(tab+colonne*ligne_robot+colonne_robot)='-';
break;
case 3 :
*(tab+colonne*ligne_robot+colonne_robot)='\';
break;
}

}

/* fonction creation_mur : cree un mur d'obstacle pour
empecher le robot de sortir du tableau */
void creation_mur(char *tab, int ligne, int colonne)
{
int i,j;

for(j=0; j<ligne; j++)
{
*(tab+j*colonne)='X';
*(tab+colonne*j+colonne)='X';
}

for(i=0; i<colonne; i++)
{
*(tab+i)='X';
*(tab+colonne*ligne-i)='X';
}

}

/* fonction position_obstacle : saisie et affectation
dans la grille des obstacles */
void position_obstacle(char *tab, int ligne, int colonne)
{
int a=0, b=0;

while(1)
{
printf("\n Entrez l'abscisse de l'obstacle ");
printf("(ou -1 si pour ne pas ajouter d'obstable) : ");
scanf("%d", &a);
if(a==-1)
break;
a=a+1;
printf("\n Entrez l'ordonnee de l'obstacle : ");
scanf("%d", &b);
b=b+1;

if ((0<a)&&(a<=ligne-1)&&(0<b)&&(b<=colonne-1))
switch (*(tab+colonne*a+b))
{
case ' ':
*(tab+colonne*a+b)='X';
break;
case 'X':
printf("\n ! Il y a des obstacles à la ");
printf("meme position. ! ");
break;
case ((char) 4):
printf("\n ! L'obstacle ne peut se trouver ");
printf("sur un mur ! ");
break;
default :
printf("\n ! Des obstacles sont à la ");
printf("meme position ");
printf("que le robot et n'apparaitrons pas ! ");
}
else
{
printf("\n Erreur : L'obstacle n'est pas dans l'espace. ");
printf("Il n'y apparaitra donc pas.");
break;
}
}
}

/* fonction mise_a_jour : boucle qui regroupe les fonctions
d'analyse, de déplacement et d'affichage */
void mise_a_jour(char *tab, int ligne, int colonne, int ligne_robot,
int colonne_robot, int orient)
{
int test=0,perception=0,nbr_maj=0,energie=5200;
int case_visite=0, nombre_obstacle=0;
case_visite=colonne*ligne;

while(nbr_maj < 5000 && energie > 3 && test!=1)
{
nbr_maj++;
test=0;
perception=0;

test=test_grille(tab, ligne, colonne, test);

perception=analyse(tab, colonne, ligne_robot,
colonne_robot, perception);

if (perception != 2)
energie=deplacement_cas_un(tab,colonne,&ligne_robot,&colonne_robot,
&orient, energie, perception);
}

test=0;
int x,y;
for(x=0; x<ligne; x++)
{
for(y=0; y<(colonne); y++)
{
if (*(tab+(colonne)*x+y) == 'X')
nombre_obstacle++;
if (*(tab+(colonne)*x+y) == ' ')
case_visite-=1;
}
}

affiche(tab, ligne, colonne);

printf("\n Cases visitees : %d / %d", case_visite,
((colonne-1)*(ligne))-nombre_obstacle);
printf("\n Nombre de mises a jour : %d", nbr_maj);
printf("\n Energie restante : %d", energie);

if(nbr_maj==5000)
printf("\n Time Out \n");
else if(energie<=3)
printf("\n Echec \n");
else
printf("\n Succes ! \n");

}

// fonction test_grille : indique si il reste des cases non visitées
int test_grille(char* tab, int ligne, int colonne, int test)
{
test=0;

int x,y;
for(x=0; x<(ligne); x++)
{
for(y=0; y<(colonne); y++)
{
if (*(tab+(colonne)*x+y) == ' ')
test++;
}
}

if (test==0)
test=1;
else
test=0;

return test;
}

// fonction analyse : interprete les 8 cases autour du robot
int analyse(char *tab, int colonne, int ligne_robot,
int colonne_robot, int perception)
{

int h,f;
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f) == ' ')
{
perception=0;
break;
}

else
perception=1;
}
}

if (perception!=0)
{
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f)!='X')
{
perception=1;
break;
}

else
perception=2;
}
}
}

return perception;
}

/* fonction deplacement : deplace le robot et calcule
le cout de ce deplacement */
int deplacement_cas(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie, int perception)
{
int alea=0, orient_av, var_energie=0,n,m;
char contenu=0;
energie-=1;
orient_av=*orient;
n=*ligne_robot;
m=*colonne_robot;

if(perception==0)
contenu==' ';
else if(perception==1)
contenu==' '

do
{
alea=rand()%8;
switch(alea)
{
case 0 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)-1)) == contenu
&& *(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*ligne_robot-=1;
*colonne_robot-=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))='\';
}
break;
case 1 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == contenu)
{
*colonne_robot-=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)-1)) == contenu
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot-=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == contenu)
{
*ligne_robot+=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)+1)) == contenu
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot+=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 5 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == contenu)
{
*colonne_robot+=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)+1)) == contenu
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot+=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == contenu )
{
*ligne_robot-=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}
}
while(n==*ligne_robot && m==*colonne_robot);

energie=(energie-1)-var_energie;

return energie;
}

// fonction deplacement : deplace le robot et calcule le cout de ce deplacement
int deplacement_cas_deux(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie)
{
int alea=0, orient_av, var_energie=0,n,m;
energie-=1;
orient_av=*orient;
n=*ligne_robot;
m=*colonne_robot;

do
{
alea=rand()%8;
switch(alea)
{
case 0 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)-1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot-=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 1 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*colonne_robot-=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)-1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot-=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X')
{
*ligne_robot+=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (*(tab+colonne*((*ligne_robot)+1)+((*colonne_robot)+1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) == 'X'))
{
*ligne_robot+=1;
*colonne_robot+=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 5 :
if (*(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*colonne_robot+=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (*(tab+colonne*((*ligne_robot)-1)+((*colonne_robot)+1)) != 'X'
&& !(*(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) == 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) == 'X'))
{
*ligne_robot-=1;
*colonne_robot+=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (*(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X')
{
*ligne_robot-=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}
}
while(n==*ligne_robot && m==*colonne_robot);

energie=(energie-1)-var_energie;
return energie;
}

// fonction variation_energie : calcul du cout en energie de la rotation
int variation_energie(int orient, int orient_av)
{
int cout_rotation, temp;
temp=orient-orient_av;

if(temp==1 || temp==-1 || temp==3 || temp==-3 )
cout_rotation=1;
else if(temp==0)
cout_rotation=0;
else if(temp==2 || temp==-2)
cout_rotation=2;

return cout_rotation;
}

//fonction affiche : affichage du tableau
void affiche(char *tab, int ligne, int colonne)
{
int i, j;

for(i=1; i<(ligne-1); i++)
{
printf("\n");

for(j=1; j<(colonne-1); j++)
printf("----");

printf("-");
printf("\n");

for(j=1; j<(colonne-1); j++)
printf(": %c ", *(tab+colonne*i+j));

if(j==(colonne-1))
printf(":");
}
printf("\n");

for(j=1; j<(colonne-1); j++)
{
printf("----");
}
printf("-");

printf("\n");

}

Emissaire Nombre de messages : 143 Age : 33 Date d'inscription : 22/09/2010

Code:: int verification(char *tab,int colonne,int **ligne_robot,int **colonne_robot, int perception){
if(perception==0
&&(*(tab+colonne*((*ligne_robot))+((*colonne_robot))) == ' ')
return 1;
else if(perception==1
&&*(tab+colonne*((*ligne_robot))+((*colonne_robot))) == '-'
&&*(tab+colonne*((*ligne_robot))+((*colonne_robot))) == '|'
&&*(tab+colonne*((*ligne_robot))+((*colonne_robot))) == '/'
&&*(tab+colonne*((*ligne_robot))+((*colonne_robot))) == ' ')
return 1;
else
return 0;
}

Emissaire Nombre de messages : 84 Age : 33 Date d'inscription : 14/11/2010

Code:: #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int define(int);
void orientation(char*, int, int, int, int);
void creation_mur(char*, int, int);
void position_obstacle(char*, int, int);
void mise_a_jour(char*, int, int, int, int, int);
int test_grille(char*, int, int, int);
int analyse(char*, int, int, int, int);
int deplacement(char*, int, int*, int*, int*, int, int);
int variation_energie(int, int);
int verification(char*,int,int,int,int);
void affiche(char*, int, int);

int main()
{
printf("\n Projet ASPIRATOR ! \n");
printf(" realise par Alexandre Simard, EPFL : Microtechniques\n");

srand (time(0));
int ligne=0, colonne=0, ligne_robot=0, colonne_robot=0, orient=0;
ligne = define(ligne);
colonne = define(colonne);
char tab[ligne][colonne];

//initialisation du tableau par des espaces vides
memset(tab[0], ' ', sizeof(tab));

/* appel de la fonction pour entrer les valeurs
necessaires au programme */
ligne_robot = define(ligne_robot);
colonne_robot = define(colonne_robot);
orient = define(orient);

// appel de la fonction interpretant l'orientation du robot
orientation(*tab, colonne, ligne_robot, colonne_robot, orient);

/* appel de la fonction qui crée un mur fictif d'obstacle
autour de la grille */
creation_mur(*tab, ligne, colonne);

// appel de la fonction qui place les obstacles
position_obstacle(*tab, ligne, colonne);

/* appel de la fonction qui regroupe l'analyse,
le déplacement et l'affichage à la fin */
mise_a_jour(*tab,ligne,colonne,ligne_robot,colonne_robot,orient);

return 0;
}

// fonction define : attribue les entrees aux variables du programme
int define(int x)
{
/* ce sont des variables temporaires destinees a conserver
certaines saisies pour cette fonction */
static int k, X, Y;

switch (k)
{
case 0 :
printf("\n Entrez la dimension verticale");
printf(" de l'espace ( nombre de lignes ) : ");
do (scanf("%d", &x));
while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
X=x;
break;
case 1 :
printf("\n Entrez la dimension horizontale de l'espace ");
printf("( nombre de colonnes ) : ");
do (scanf("%d", &x));
while (x<=0
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+2;
Y=x;
break;
case 2 :
printf("\n Entrez l'abscisse du robot : ");
do (scanf("%d", &x));
while ((x<0||x>X)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 3 :
printf("\n Entrez l'ordonnee du robot : ");
do (scanf("%d", &x));
while ((x<0||x>Y)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
x=x+1;
break;
case 4 :
printf("\n Entrez l'orientation du robot : ");
do (scanf("%d", &x));
while ((x<0||x>3)
&&printf("Erreur la valeur entree est incorrecte. ")
&&printf("Veuillez l'entrer à nouveau."));
break;
}

k++;
return x;
}

/* fonction orientation : enregistre la direction initiale
du robot dans le tableau */
void orientation(char *tab, int colonne, int ligne_robot,
int colonne_robot ,int orient)
{
switch(orient)
{
case 0 :
*(tab+colonne*ligne_robot+colonne_robot)='|';
break;
case 1 :
*(tab+colonne*ligne_robot+colonne_robot)='/';
break;
case 2 :
*(tab+colonne*ligne_robot+colonne_robot)='-';
break;
case 3 :
*(tab+colonne*ligne_robot+colonne_robot)='\';
break;
}

}

/* fonction creation_mur : cree un mur d'obstacle pour
empecher le robot de sortir du tableau */
void creation_mur(char *tab, int ligne, int colonne)
{
int i,j;

for(j=0; j<ligne; j++)
{
*(tab+j*colonne)='X';
*(tab+colonne*j+colonne)='X';
}

for(i=0; i<colonne; i++)
{
*(tab+i)='X';
*(tab+colonne*ligne-i)='X';
}

}

/* fonction position_obstacle : saisie et affectation
dans la grille des obstacles */
void position_obstacle(char *tab, int ligne, int colonne)
{
int a=0, b=0;

while(1)
{
printf("\n Entrez l'abscisse de l'obstacle ");
printf("(ou -1 si pour ne pas ajouter d'obstable) : ");
scanf("%d", &a);
if(a==-1)
break;
a=a+1;
printf("\n Entrez l'ordonnee de l'obstacle : ");
scanf("%d", &b);
b=b+1;

if ((0<a)&&(a<=ligne-1)&&(0<b)&&(b<=colonne-1))
switch (*(tab+colonne*a+b))
{
case ' ':
*(tab+colonne*a+b)='X';
break;
case 'X':
printf("\n ! Il y a des obstacles à la ");
printf("meme position. ! ");
break;
case ((char) 4):
printf("\n ! L'obstacle ne peut se trouver ");
printf("sur un mur ! ");
break;
default :
printf("\n ! Des obstacles sont à la ");
printf("meme position ");
printf("que le robot et n'apparaitrons pas ! ");
}
else
{
printf("\n Erreur : L'obstacle n'est pas dans l'espace. ");
printf("Il n'y apparaitra donc pas.");
break;
}
}
}

/* fonction mise_a_jour : boucle qui regroupe les fonctions
d'analyse, de déplacement et d'affichage */
void mise_a_jour(char *tab, int ligne, int colonne, int ligne_robot,
int colonne_robot, int orient)
{
int test=0,perception=0,nbr_maj=0,energie=5200;
int case_visite=0, nombre_obstacle=0;
case_visite=(colonne-2)*(ligne-2);

while(nbr_maj < 5000 && energie > 3 && test!=1)
{
nbr_maj++;
test=0;
perception=0;

test=test_grille(tab, ligne, colonne, test);

perception=analyse(tab, colonne, ligne_robot,
colonne_robot, perception);

if (perception != 2)
energie=deplacement(tab,colonne,&ligne_robot,&colonne_robot,
&orient, energie, perception);

printf("test3\n");
}

test=0;
int x,y;
for(x=0; x<ligne; x++)
{
for(y=0; y<(colonne); y++)
{
if (*(tab+(colonne)*x+y) == 'X')
nombre_obstacle++;
if (*(tab+(colonne)*x+y) == ' ')
case_visite-=1;
}
}

printf("test4\n");

affiche(tab, ligne, colonne);

printf("\n Cases visitees : %d / %d", case_visite,
((colonne)*(ligne))- nombre_obstacle);
printf("\n Nombre de mises a jour : %d", nbr_maj);
printf("\n Energie restante : %d", energie);

if(nbr_maj==5000)
printf("\n Time Out \n");
else if(energie<3)
printf("\n Echec \n");
else
printf("\n Succes ! \n");

}

// fonction test_grille : indique si il reste des cases non visitées
int test_grille(char* tab, int ligne, int colonne, int test)
{
test=0;

int x,y;
for(x=0; x<(ligne); x++)
{
for(y=0; y<(colonne); y++)
{
if (*(tab+(colonne)*x+y) == ' ')
test++;
}
}

if (test==0)
test=1;
else
test=0;

return test;
}

// fonction analyse : interprete les 8 cases autour du robot
int analyse(char *tab, int colonne, int ligne_robot,
int colonne_robot, int perception)
{

int h,f;
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f) == ' ')
{
perception=0;
break;
}

else
perception=1;
}
}

if (perception!=0)
{
for(h=ligne_robot-1; h<(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<(colonne_robot+1); f++)
{
if (*(tab+h*colonne+f)!='X')
{
perception=1;
break;
}

else
perception=2;
}
}
}

return perception;
}

/* fonction deplacement : deplace le robot et calcule
le cout de ce deplacement */
int deplacement(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie, int perception)
{
int alea=0, orient_av, var_energie=0,n,m;
energie-=1;
orient_av=*orient;
n=*ligne_robot;
m=*colonne_robot;

printf("test6\n");
do
{
alea=rand()%8;
switch(alea)
{
case 0 :
if (verification(tab,colonne,(*ligne_robot)-1,(*colonne_robot)-1,perception)
&& *(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*ligne_robot-=1;
*colonne_robot-=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))='\';
}
break;
case 1 :
if (verification(tab,colonne,(*ligne_robot)-1,(*colonne_robot),perception))
{
*colonne_robot-=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (verification(tab,colonne,(*ligne_robot)-1,(*colonne_robot)+1,perception)
&& *(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*ligne_robot+=1;
*colonne_robot-=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (verification(tab,colonne,*ligne_robot,(*colonne_robot)+1,perception))
{
*ligne_robot+=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (verification(tab,colonne,(*ligne_robot)+1,(*colonne_robot)+1,perception)
&& *(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*ligne_robot+=1;
*colonne_robot+=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '\';
}
break;
case 5 :
if (verification(tab,colonne,(*ligne_robot)+1,*colonne_robot,perception))
{
*colonne_robot+=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (verification(tab,colonne,(*ligne_robot)+1,(*colonne_robot)-1,perception)
&& *(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*ligne_robot-=1;
*colonne_robot+=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (verification(tab,colonne,*ligne_robot,(*colonne_robot)-1,perception))
{
*ligne_robot-=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}
}
while(n==*ligne_robot && m==*colonne_robot);

energie=(energie-1)-var_energie;

printf("test1\n");
return energie;
}

// fonction variation_energie : calcul du cout en energie de la rotation
int variation_energie(int orient, int orient_av)
{
int cout_rotation, temp;
temp=orient-orient_av;

if(temp==1 || temp==-1 || temp==3 || temp==-3 )
cout_rotation=1;
else if(temp==0)
cout_rotation=0;
else if(temp==2 || temp==-2)
cout_rotation=2;

return cout_rotation;
}

int verification(char *tab,int colonne,int ligne_robot,int colonne_robot, int perception)
{
printf("test5\n");
if(perception==0
&& (*(tab+colonne*(ligne_robot)+(colonne_robot)) == ' '))
return 1;
else if(perception==1
&& (*(tab+colonne*(ligne_robot)+(colonne_robot)) == '-'
|| *(tab+colonne*(ligne_robot)+(colonne_robot)) == '|'
|| *(tab+colonne*(ligne_robot)+(colonne_robot)) == '/'
|| *(tab+colonne*(ligne_robot)+(colonne_robot)) == '\'))
return 1;
else
return 0;
}

//fonction affiche : affichage du tableau
void affiche(char *tab, int ligne, int colonne)
{
int i, j;

for(i=1; i<(ligne-1); i++)
{
printf("\n");

for(j=1; j<(colonne-1); j++)
printf("----");

printf("-");
printf("\n");

for(j=1; j<(colonne-1); j++)
printf(": %c ", *(tab+colonne*i+j));

if(j==(colonne-1))
printf(":");
}
printf("\n");

for(j=1; j<(colonne-1); j++)
{
printf("----");
}
printf("-");

printf("\n");

}

Emissaire Nombre de messages : 143 Age : 33 Date d'inscription : 22/09/2010

Ellidan pendant ce week end j'ai plancher sur ton programme et j'ai fini l'optimisationVoici le code qui marche (remet des antislash ,meme sur le fofo il aime pas j arrive pas a metre le '', a la place des '(' )
ton probleme ce situait ici (ligne 288-291)

Code:: for(h=ligne_robot-1; h<=(ligne_robot+1); h++)
{
for(f=colonne_robot-1; f<=(colonne_robot+1); f++)
{

tu avait oublier le egale le robot allait par concéquent toujours a gauche.
et tu avait inverser ligne et colonne dans la modification des coordonné dans tes If du switch

Code:: int deplacement(char *tab, int colonne, int *ligne_robot,
int *colonne_robot, int *orient,
int energie, int perception)
{
int alea=0, orient_av, var_energie=0,n,m;
energie-=1;
orient_av=*orient;
n=*ligne_robot;
m=*colonne_robot;

printf("test6\n");
do
{
alea=rand()%8;
switch(alea)
{
case 0 :
if (verification(tab,colonne,(*ligne_robot)-1,(*colonne_robot)-1,perception)
&& *(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*ligne_robot-=1;
*colonne_robot-=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))='(';
}
break;
case 1 :
if (verification(tab,colonne,(*ligne_robot)-1,(*colonne_robot),perception))
{
*ligne_robot-=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 2 :
if (verification(tab,colonne,(*ligne_robot)-1,(*colonne_robot)+1,perception)
&& *(tab+colonne*((*ligne_robot)-1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*ligne_robot-=1;
*colonne_robot+=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 3 :
if (verification(tab,colonne,*ligne_robot,(*colonne_robot)+1,perception))
{
*colonne_robot+=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
case 4 :
if (verification(tab,colonne,(*ligne_robot)+1,(*colonne_robot)+1,perception)
&& *(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)+1)) != 'X')
{
*ligne_robot+=1;
*colonne_robot+=1;
*orient=3;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '(';
}
break;
case 5 :
if (verification(tab,colonne,(*ligne_robot)+1,*colonne_robot,perception))
{
*ligne_robot+=1;
*orient=0;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '|';
}
break;
case 6 :
if (verification(tab,colonne,(*ligne_robot)+1,(*colonne_robot)-1,perception)
&& *(tab+colonne*((*ligne_robot)+1)+(*colonne_robot)) != 'X'
&& *(tab+colonne*(*ligne_robot)+((*colonne_robot)-1)) != 'X')
{
*ligne_robot+=1;
*colonne_robot-=1;
*orient=1;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '/';
}
break;
case 7 :
if (verification(tab,colonne,*ligne_robot,(*colonne_robot)-1,perception))
{
*colonne_robot-=1;
*orient=2;
var_energie=variation_energie(*orient, orient_av);
*(tab+colonne*(*ligne_robot)+(*colonne_robot))= '-';
}
break;
}
}
while(n==*ligne_robot && m==*colonne_robot);
energie=(energie-1)-var_energie;
printf("test1\n");
return energie;
}

J'ai tester le code et j'ai fait un joli 98/100 ^^

» probleme a la REconnection
» probleme de realmlist
» Probleme avec le QG