MeilleurChemin

salut, c'est pas terrible ce que je vais mettre mais voila:c'est un début de début de programmation de la fonction qui doit évaluer the best pion qu'il faut déplacer avec les réactions de l'autre.J'essayerai de mettre l'algo (mis au point par audrey ) ce soir

/*-------------------------------*/
/* # include */
/*-------------------------------*/

#include<stdio.h>
#include<stdlib.h>
#include<math.h>


typedef struct DEPLACEMENT{
int translationhorizontale;
int translationverticale;
int ld;
int la;
};

typedef struct SAUT{
int la;
int ca;
int transhz;
int transvert;
};

/*typedef struct PIONS_SELECTIONNES{
int ld1, cd1;
int ld2, cd2;
int ld3, cd3;
int n=3;
}*/


void MeilleurChemin(int joueur-1, int joueur1, int Plateau[17][25],int TroisMeilleursDeplacements[3][20] /*PIONS_SELECTIONNES Pions_selec[8]*/)
{
int PlateauVirtuel[17][25];
int PionsSelection[3][22]; //tableau dans lequel on range les ld, les cd et les 3 meilleurs déplacements possibles des 3 pions séléctionnés pour le joueur -1
int PionsSelection[1][22];//tableau dans lequel on range ld, cd et les 3 meilleurs déplacements possibles du pion séléctionné pour le joueur 1
int c, l, ld, cd;


//c'est au joueur -1 de jouer

/*------------------------------------------------------------------------*/
/* Parcours de la matrice Plateau pour sélectionner 3 pions de -1 */
/*------------------------------------------------------------------------*/

for(l=0;l<17;l++)
{
for(c=0;c<25;c++)
{
while (n<=3) //correspond au nombre de pions que l'on va sélectionner
{
switch (Plateau[l][c])
{
case 0: //s'il n'y a personne sur la case...
Platau[l][c+1]; //...on regarde la case juste à côté
break;

case 7: //si la case est occuppée par des pions qui n'appartiennent pas au joueur...
Platau[l][c+1]; //...on regarde la case juste à côté
break;

case 1: //si la case est occuppée par des pions de l'adversaire...
Platau[l][c+1]; //...on regarde la case juste à côté
break;

case -1: //s'il y a un des pions du joueur -1...
TroisMeilleursDeplacements(int joueur-1, int l, int c,int Plateau[17][25],int Meilleursdeplacementsunitaires[3][20]);
//...on regarde les trois meilleurs déplacements qu'il peut faire
if (TroisMeilleursDeplacements(int joueur-1, int l, int c,int Plateau[17][25],int Meilleursdeplacementsunitaires[3][20])!=NULL)
{
n++;

/*Pions_selec.ld[n]=l;//on rentre les coordonnées des pions successifs dans la structure PIONS_SELECTIONE
Pions_selec.cd[n]=c; */
PionsSelection[n][0]=l; //on remplit la matrice PionsSelection
PionsSelection[n][1]=c;
PionsSelection[n][2]=Meilleursdeplacementsunitaires[n][0];
PionsSelection[n][3]=Meilleursdeplacementsunitaires[n][1];
PionsSelection[n][2]=Meilleursdeplacementsunitaires[n][2];
} //fin if

else Plateau[l][c+1];

break;
} //fin switch
} //fin while
} //fin for c
} // fin for l

/*------------------------------------------------------------------------*/
/* on a donc 3 pions qui ont eux même 3 déplacements possibles */
/*------------------------------------------------------------------------*/

/*------------------------------------------------------------------------*/
/* Initialisation de la matrice PlateauVirtuel */
/*------------------------------------------------------------------------*/

PlateauVirtuel[17][25]=Plateau[17][25];

for (n=1;n<=3;n++)
{
/*on change l'état de jeu*/
a=PionsSelection[n][0];
b=PionsSelection[n][1];
d=PionsSelection[n][2];
e=PionsSelection[n][3];

PlateauVirtuel[a][b]=0; //je veux effacer virtuellement pion -1 séléctionné
PlateauVirtuel[a+d][b+e]=-1; //je veux placer virtuellement un pion -1 après avoir fait le 1er déplacementpossible

/*on s'interesse à la réaction du joueur 1*/

/*------------------------------------------------------------------------*/
/* indiquer qu'on change de main? */
/* selection du pion le plus en retrait chez le joueur 1 */
/*------------------------------------------------------------------------*/

int PionsSelection1[1][24];

for(l=17;l>0;l--)
{
for(c=0;c<25;c++)
{

switch (PlateauVirtuel[l][c])
{
case 0: //s'il n'y a personne sur la case...
Platau[l][c+1]; //...on regarde la case juste à côté
break;

case 7: //si la case est occuppée par des pions qui n'appartiennent pas au joueur...
Platau[l][c+1]; //...on regarde la case juste à côté
break;

case -1: //si la case est occuppée par des pions de l'adversaire...
Platau[l][c+1]; //...on regarde la case juste à côté
break;

case 1: //s'il y a un des pions du joueur 1...
TroisMeilleursDeplacements(int joueur-1, int l, int c,int PlateauVirtuel[17][25],int Meilleursdeplacementsunitaires[3][20]);
//...on regarde les trois meilleurs déplacements qu'il peut faire
if (TroisMeilleursDeplacements(int joueur-1, int l, int c,int PlateauVirtuel[17][25],int Meilleursdeplacementsunitaires[3][20])!=NULL)
{

/*Pions_selec.ld[n]=l;//on rentre les coordonnées des pions successifs dans la structure PIONS_SELECTIONE
Pions_selec.cd[n]=c; */

PionsSelection1[1][0]=l; //on remplit la matrice PionsSelection1
PionsSelection1[1][1]=c;
PionsSelection1[1][2]=Meilleursdeplacementsunitaires[n][0];
PionsSelection1[1][3]=Meilleursdeplacementsunitaires[n][1];
PionsSelection1[1][2]=Meilleursdeplacementsunitaires[n][2];
} //fin if

else Plateau[l][c+1];

break;
} //fin switch
} //fin while
} //fin for c
} // fin for l


//PROBLEME DE MATRICE!!!!!

Merci, je regarderai en rentrant ^^.

En attendant, je vais me concentrer sur la mise de pointeurs dans le menu, ce qui m'evitera de trop faire de gymnastique pour recuperer un petit int de rien du tout (mais je galere avec les pointeurs^^)

Bonne aprem!

ok!
mon pb, c'est que je sais pas si c'est mieux de faire des structures dans un tableau, des listes, ou "juste" une matrice, avec laquelle j'ai du mal à ranger les données...
pour le menu t'as ce qu'il te faut dans la partie rédaction?
de toutes facons, je vas rentrer donc le forum is over for me tonight!
tchao!

Moi, mon pb, c'est que j'ai déjà une fonction qui fait tout ça..
Désolé si je ne l'ai pas dit.

Pour les remarques autres, tu les as eues de vive voix, mais je recommence pour Marie:

- stocker les trois pions obtenus dans un tableau de structure PION (cf le header que j'ai dû mettre en ligne)
Au final, ça te donne un tableau 1D de trois cases.

-changer le switch en un if(Plateau[l][c]==joueur)
(le truc du Plateau[l][c+1] ne permettant pas de se déplacer -on le fait avec les deux for-et étant une action "inutile", dans le sens où ça n'effectue rien, sinon le breack qui suit)

M'en veux pas Sarah s'il te plait.

Autre solution (mais termine ta fonction quand même!):

Prendre les trois pions les plus reculés sur le plateau qui peuvent être déplacés.
D'accord, je regarde pas si leur déplacement est optimal, mais ça fait partie de ma stratégie de remonter en priorité les pions les plus bas sur le plateau.
L'examen des meilleurs chemins possibles est effectué ensuite, avec la fonction "TroisMeilleursChemins" (aussi écrite qque part..)

Au final j'ai deux fonctions qui compilent: une qui sélectionne pour l'un ou l'autre joueur, l'une qui le fait que pour la CPU.

Je les met à la suite, mais ils seront aussi dans G/Tout le monde/Mellyra, avec les brouillons.

/*--------------------------------------------------------*/
/* FONCTION ChoixPionsDeplaçables */
/* */
/* On parcourt le plateau de jeu dans un sens donné, */
/* dépendant du joueur concerné. La fonction renvoie un */
/* tableau de trois pions déplpaçables, en les */
/* sélectionnant à partir de l'arrière du plateau pour ne */
/* pas laisser de pions en arrière. */
/* Données: joueur,Plateau[l][c],nbrepions */
/* Resultat: tableau Pionchoisis[nbrepions] de type PION */
/* */
/*--------------------------------------------------------*/
int ChoixPionsDeplacables( int joueur, int Plateau[17][25],PION Pionschoisis[3])
{
int cpt=0, l=0, c=0;
if (joueur == 1) //Cas du joueur humain
{
while (cpt<3)
{
for(l=24;l>=0;l--) //On parcourt le plateau depuis la dernière ligne
{
for(c=0;c<17;c++)
{
if( Plateau[l][c]==joueur) //Quand on apperçoit un pion appartenant au joueur humain
{
if(Plateau[l][c-2]==0 || Plateau[l][c+2]==0) //Déplacement simple possible à gauche ou à droite
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
if(Plateau[l-1][c-1]==0 || Plateau[l-1][c+1]==0) //Déplacement simple possible à gauche ou droite en diagonale
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
if(Plateau[l][c-4]==0 || Plateau[l][c+4]==0) //Saut possible à gaucge ou à droite
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
if(Plateau[l-2][c-2]==0 || Plateau[l-2][c+2]==0) //Saut possible à gaucge ou à droite en diagonale
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
}
}
}
}
}
if (joueur == -1) //Cas de l'ordinateur
{
while(cpt<3)
{
for(l=0;l<=24;l++) //On parcourt le plateau depuis la première ligne
{
for(c=0;c<17;c++)
{
if( Plateau[l][c]==joueur) //Quand on apperçoit un pion appartenant au CPU
{
if(Plateau[l][c-2]==0 || Plateau[l][c+2]==0) //Déplacement simple possible à gauche ou à droite
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
if(Plateau[l+1][c-1]==0 || Plateau[l+1][c+1]==0) //Déplacement simple possible à gauche ou droite en diagonale
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
if(Plateau[l][c-4]==0 || Plateau[l][c+4]==0) //Saut possible à gaucge ou à droite
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
if(Plateau[l+2][c-2]==0 || Plateau[l+2][c+2]==0) //Saut possible à gaucge ou à droite en diagonale
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=joueur;
cpt++;
}
}
}
}
}
}

}

void ChoixPionsDeplacablesCPU( int Plateau[17][25],PION Pionschoisis[3])
{
int cpt=0, l=0, c=0;
while(cpt<3)
{
for(l=0;l<=24;l++) //On parcourt le plateau depuis la première ligne
{
for(c=0;c<17;c++)
{
if( Plateau[l][c]==-1) //Quand on apperçoit un pion appartenant au CPU
{
if(Plateau[l][c-2]==0 || Plateau[l][c+2]==0) //Déplacement simple possible à gauche ou à droite
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=-1;
cpt++;
}
if(Plateau[l+1][c-1]==0 || Plateau[l+1][c+1]==0) //Déplacement simple possible à gauche ou droite en diagonale
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=-1;
cpt++;
}
if(Plateau[l][c-4]==0 || Plateau[l][c+4]==0) //Saut possible à gauche ou à droite
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=-1;
cpt++;
}
if(Plateau[l+2][c-2]==0 || Plateau[l+2][c+2]==0) //Saut possible à gauche ou à droite en diagonale
{
Pionschoisis[cpt].ligne=l;
Pionschoisis[cpt].colonne=c;
Pionschoisis[cpt].joueur=-1;
cpt++;
}
}
}
}
}

}

J'ai pas inventé le fil à couper le beurre, la 2e n'est qu'un copié-collé de la première... Inutile de s'énnerver sur les 2, donc.

Marie, on attend tes commentaires ^^