Trois meilleurs déplacements simples possibles

La fonction "MeilleurDeplacementUnitaire" a été remodifiée en "TroisMeilleursDeplacements". Et corrigée parce qu'il y manquait pas mal de choses.

Description:
void TroisMeilleursDeplacements(int joueur, int ld, int cd,int Plateau[17][25],int Meilleursdeplacementsunitaires[3][20])

Le tableau Meilleursdeplacementsunitaires[3][20] est en fait modifié par la fonction. Chacune de ses lignes correspond à un des meilleurs déplacements unitaires:
- la ligne comprend deux éléments (translation horizontale puis verticale) s'il s'agit d'un déplacement simple,
- elle comprend un nombre pair d'éléments (toujours des translations) allant de 0 à 2*nbresauts, où nbresauts est le nombre de sauts consécutifs qui ont été exécutés.

int nbresaut=0,l,c;
SAUT Sauts[10][6];
/*------------------------------------------------------------------------*/
/* Initialisation de la matrice Sauts */
/*------------------------------------------------------------------------*/
for(l=0;l<10;l++) //Pour chaque ligne de la matrice Sauts(pour chaque saut),
{
for(c=0;c<24;c++) //Et pour chaque colonne(pour chaque coordonnee du saut),
{ //On initialise a 0.
Sauts[l][c].la=0;
Sauts[l][c].ca=0;
Sauts[l][c].transhz=0;
Sauts[l][c].transvert=0;
}
}

/*------------------------------------------------------------------------*/
/* Etude de chaque possibilite de deplacement simple */
/*------------------------------------------------------------------------*/
DEPLACEMENT Deplacementsimple[6],Meilleursdeplacementssimples[3];
int nbredeplacementpossibles=0;
nbredeplacementpossible=ListeDeplacementSimple(joueur,ld,cd,Plateau,Deplacementsimple);

/*-----------------------------------------------------------*/
/* Meilleur deplacement simple possible */
/*-----------------------------------------------------------*/
int cpt=0,avancementmax=0,cpt2=0,marqueur[2]=0;
for(cpt=0;cpt<nbredeplacementpossible; cpt++)
{
if ( abs(Deplacementsimple[cpt].la-ld) > avancementmax )
{
avancementmax=abs(Deplacementsimple[cpt].la-ld);
}
}
avancement=avancementmax;
while(cpt2<3)
{
for(cpt=0;cpt<nbredeplacementpossible; cpt++)
{
if ( abs(Deplacementsimple[cpt].la-ld) == avancementmax )
{
Meilleursdeplacementssimples[cpt2]=Deplacementsimple[cpt];
}
cpt2++;
}
avancementmax--;
marqueur[cpt2-1]=cpt2-1; //Note à quelle ligne on réduit l'avancement max
}
//Marqueur est un tableau de deux valeurs, car pour trois meilleurs déplacements simples possibles,
//l'avancement maximal peut être diminué (de 1) deux fois.
//A ce nieveau, le tableau MeilleurDeplacementssimples comporte trois éléments, qui sont les trois meilleurs déplacements trouvés.

/*------------------------------------------------------------------------*/
/* Etude des déplacements par sauts possibles */
/*------------------------------------------------------------------------*/
int nbresauts=0;
SAUT Meilleurssauts[3];
nbresauts=ListeDeplacementSauts(joueur,n,ld,cd,Plateau,Sauts);
/*------------------------------------------------------------------------*/
/* Meilleur déplacement possible sous forme de sauts */
/*------------------------------------------------------------------------*/
int avancementsautmax=0,avancementsaut;
int Suitesauts[3][20];
int li=0, ci=0;
int i=0,marqueursaut[2]=0; //Ligne et colonne intermédiaires
ListeDeplacementSauts(joueur,nbresaut,ld,cd,Plateau,Sauts);
//Parcours de la dernière ligne de la matrice Sauts (dernier saut effectué) pour avoir l'avencement maximum
for(c=0; c<6; c++)
{
if(abs(Sauts[nbresauts][c].la-ld)>avancementsautmax)
{
avancementsautmax=abs(Sauts[nbresauts][c].la-ld);
}
}
avancementsaut=avancementsautmax;
cpt2=0;
while(cpt2<3){
for(c=0; c<6; c++)
{
if(abs(Sauts[nbresauts][c].la-ld) == avancementsautmax)
{
Meilleurssauts[cpt2]=Sauts[nbresauts][c];
}
cpt2++;
}
avancementsautmax--;
marqueursaut[cpt2-1]=cpt2-1; //Note à quel indice on réduit l'avancement max
}
//L'avancement maximal est pour les sauts finaux enregistrés dans le tableau Meilleurssauts
//On recherche la suite de sauts qui a mené à ces avancement maximums
for(i=0;i<3;i++)
{
for(c=0; c<6; c++)
{
if( Sauts[nbresauts][c] == Meilleurssauts[i] )
{
li=Sauts[nbresauts][c].la-Sauts[nbresauts][c].transvert;
ci=Sauts[nbresauts][c].ca-Sauts[nbresauts][c].transhz;
Suitesauts[i][2*nbresauts-1]=Sauts[nbresauts][c].transvert; //Stockage de la translation verticale du dernier saut
Suitesauts[i][2*nbresauts-2]=Sauts[nbresauts][c].transhz;
for(l=n-2;n>=0;n--)
{
for(c=0;c<6;c++)
{
if(Sauts[l][c]==li && Sauts[l][c+1]==ci) //Stockage des couples (translation horizontale, translation verticale) dans le tableau Suitesauts
{
li=Sauts[l][c].la+Sauts[l][c].transvert;
ci=Sauts[l][c].ca+Sauts[l][c].transhz;
Suitesauts[i][2*nbresauts-i]=Sauts[l][c].transvert;
Suitesauts[i][2*nbresauts-(i+1)]=Sauts[l][c].transhz;
i+=2;
}
}
}
}
}
}
//A ce stade, les meilleurs avancements par sauts sont stockés dans la matrice Suitesauts,
//qui comprend une suite de sauts (ou un déplacement) possible par ligne.

/*-------------------------------------------------------------*/
/* Meilleur déplacement unitaire possible */
/*-------------------------------------------------------------*/
cpt=0;
int i=0,j=0;
//On choisit de retourner une matrice donnant les trois meilleurs déplacements unitaires possibles.
//On choisit ici la forme de matrice de 20 colonnes et trois lignes car il y a plus de chance de
//retourner trois déplacements par sauts que trois déplacements simples.
while(cpt<2)
{
if (avancementsaut > avancement)
{
for (c=O;c<2*nbresauts;c+=2)
{
Meilleursdeplacementsunitaires[cpt][c]=Suitesauts[i][c].transhz;
Meilleursdeplacementsunitaires[cpt][c+1]=Suitesauts[i][c].transvert;
i++;
}
}
if (avancement > avancementsaut)
{
Meilleursdeplacementsunitaires[cpt][0]=Meilleursdeplacementssimples[j].translationhorizontale;
Meilleursdeplacementsunitaires[cpt][1]=Meilleursdeplacementssimples[j].translationhorizontale;
j++;
}
cpt2++;
}

J'avoue que tous les commentaires sont pas à jour.

La fonction fait appel à deux autres fonctions:
-ListeDeplacementSimple(joueur,ld,cd,Plateau,Deplacementsimple), qui renvoie le nombre de déplacements simples possibles pour le pion du joueur considéré. Deplacementsimple y est un tableau de type DEPLACEMENT (cf partie En-tête du forum si oubli).
- ListeDeplacementSauts(joueur,n,ld,cd,Plateau,Sauts) qui renvoie le nomnre de sauts consécutifs "effectuables", nbresauts. Les sauts y sont répertoriés dans une matrice Saut, de type SAUT (même remarque).

Dernier message, et non le moindre:

Je serai reconnaissante à la personne motivée qui voudrait bien relire tout ça. J'ai fait de mon mieux, mais je sais que je suis un peu claquée et pas très fiable.
Je veux bien vous envoyer les trois fichiers pour que vous puissiez regarder ça tranquillement et en couleurs pour faciliter la relecture. Marie, je me permet de les déposer dans ton dossier sur G/Tout le monde/Mellyra/Brouillons, si ça ne t'ennuie pas.

D'avance merci.

Bien sûr, le dossier est fait pour ca, pas de probleme.

Par contre, j'ay ai travaillé un bon moment, et j'ai presque tout débuggé, mais il reste une erreur et je n'ai plus le courage de m'y remettre, il faudrait que tu regardes ca par toi-même car je n'ai pas tout dans la tête en ce qui concerne tes fonctions, donc je n'arrive pas a voir ce qu'il faudrait mettre.
Tu sais que tu peux lancer la compilation de tes fonctions meme si tu ne les appelles pas dans le main: ca te permet de corriger les erreurs comme celles sur les noms de variables ou les fautes de declarations, tout ca... Parce qu'il y en avait quelques unes.
Comme je n'ai pas reussi a tout debuggé, je n'ai pas modifié la fonction du jau à deux pour le moment.
Si tu arrives a tout debugger de ton coté, je verifierai si ca marche dans la foinction de jeu a 2^^.(normalement, il ne reste qu'une erreur comme je te le disais, mais qui nécessite de savoir de quoi ca parle a cet endroit là)
Je te poste les fonctions debuggees dans un dossier dans "brouillons" ^^.

Sinon, c'est du beau travail je pense!

Au fait, SI tu n'as pas le courage de corriger ta fonction, il parait que tous les autres groupes ont envoyé leurs fonctionsq ui ne marchaient pas a la prof, et elle les leur a débuggées, donc au pire, c'est une solution que l'on pourra envisager si on a des problemes...
C'est notre joker^^!

Yep
j'ai débugué toutes les fonctions et complété le header (il t'en manquait).

Reste un petit problème avec le fonction TroisMeilleursChemins: dans un "if", la condition "==" lui convient pas.. et parfois, c'est le "&&".

Si tu as une explication, je prend.
Si tu as une solution, je t'adorre.

Sinon, j'envoie à la prof.. ^^

euh, c'est a quelle ligne de ton programme? (j'ai relu celui qui est audessus, je ne vois pas de probleme)

Ah, si, ca y est, j'ai trouvé:
ta matrice Sauts est une structure, et parfois tu as oublié de mettre .la (ou .autrechose, j'ai pas fait attention).

ex:

if(Sauts[l][c]==li && Sauts[l][c+1]==ci)

J'ai remarqué qu'on ne peut pas comparer 2 structures, mais je ne sait pas pourquoi... Il faut comparer chaque element de la structure un a un:
on peut pas ecrire if(Sauts[l][c]== Sauts[l][c+1]) par exemple... c'est trop chiant^^.

C'est normal: tes comparateurs sont des "opérateurs arithmétiques", ça ne s'applique donc qu'aux nombres. Donc aux éléments de la structure et pas à la structure elle-même.

Raté pour la matrice Sauts, si je me souviens bien, c'est une matrice d'entiers.