// deciderCoup :Décide d'un coup à jouer en fonction de l'Etat du plateau
// et de la profondeur limite déterminée par "dureeLimite"
// (analyse tous les coups possibles tant qu'ils prennent un temps total
// inférieur à dureeLimite)
Coup deciderCoup(Etat *plateau, float dureeLimite) {
int nbCoups, i, numCoupAJouer;
float heuristique, heuristiqueMax, tempsLimite = dureeLimite + plateau->temps;
Coup coupAJouer;
Coup *coupsListe = coupsPossibles(plateau, &nbCoups);
Etat plateauCopie = (*plateau);
assert(jouerCoup(&plateauCopie, &(coupsListe[0])) == true);
heuristiqueMax = deciderCoupRec(&plateauCopie, tempsLimite);
numCoupAJouer = 0;
for (i = 0; i < nbCoups; i++) {
plateauCopie = (*plateau);
assert(jouerCoup(&plateauCopie, &(coupsListe[i])) == true);
heuristique = deciderCoupRec(&plateauCopie, tempsLimite);
if (heuristique > heuristiqueMax) {
numCoupAJouer = i;
heuristiqueMax = heuristique;
}
}
coupAJouer = coupsListe[numCoupAJouer];
free(coupsListe);
return (coupAJouer);
}
// Appel récursif initié par deciderCoup
float deciderCoupRec(Etat *plateau, float tempsLimite) { // tempsLimite = temps initial + dureeLimite
if (plateau->temps >= tempsLimite || plateau->nbPions==0) {
return (Etat_heuristique(plateau));
}
int nbCoups, i;
float heuristique, heuristiqueMax;
Coup *coupsListe = coupsPossibles(plateau, &nbCoups);
Etat plateauCopie = (*plateau);
assert(jouerCoup(&plateauCopie, &(coupsListe[0])) == true);
heuristiqueMax = deciderCoupRec(&plateauCopie, tempsLimite);
for (i = 1; i < nbCoups; i++) {
plateauCopie = (*plateau);
assert(jouerCoup(&plateauCopie, &(coupsListe[i])) == true);
heuristique = deciderCoupRec(&plateauCopie, tempsLimite);
if (heuristique > heuristiqueMax) {
heuristiqueMax = heuristique;
}
}
free(coupsListe);
return heuristiqueMax;
}
void * jouer_radio_VS(void * rdy_p)
{
extern sem_t * mutex_play_a;
extern char coup_jouer[13];
char *coup;
struct coup * pere;
char joueur;
int i;
/* close(pipeDes[0]); */
pion ** grille;
initMap();
joueur = 'A';
grille = initGrille();
coup = malloc(sizeof(char) * 13);
for (i = 0; i < 13; i++)
{
coup[i] = 0;
}
int mode = 2;
int difficulter = 1;
int type = 0;
updateMap(grille);
sem_post(mutex_play_a);
while (!victoire)
{
ready_to_play = 0;
if (joueur == 'A')
{
/* updateMap(grille); */
//affiche()
pere = malloc(sizeof(struct coup));
pere->proto = NULL;
pere->coupSuivant = NULL;
pere = coupsPossibles(grille, 'A', pere);
/* write(pipeDes_read[1],"ready",strlen("ready")); */
printf("UNLOCK1\n");
fflush(stdout);
sem_post(mutex_play_a);
interaction(coup, grille, &joueur, mode, pere);
if (action(grille, coup, pere, 1) == -1)
jouerCoupIA(grille, 'A', difficulter, 0, 0, type, coup);
copy_str(coup_jouer, coup);
printf("UNLOCK2\n");
fflush(stdout);
sem_post(mutex_play_a);
freeCoup(pere, 1);
joueur = 'B';
}
if (joueur == 'B')
{
updateMap(grille);
//affiche();
if (!victoire)
{
//affiche()
pere = malloc(sizeof(struct coup));
pere->proto = NULL;
pere->coupSuivant = NULL;
pere = coupsPossibles(grille, 'B', pere);
/* write(pipeDes_read[1],"ready",strlen("ready")); */
printf("UNLOCK3\n");
fflush(stdout);
sem_post(mutex_play_a);
interaction(coup, grille, &joueur, mode, pere);
if (action(grille, coup, pere, 1) == -1)
jouerCoupIA(grille, 'B', difficulter, 0, 0, type, coup);
copy_str(coup_jouer, coup);
printf("UNLOCK4\n");
fflush(stdout);
sem_post(mutex_play_a);
freeCoup(pere, 1);
joueur = 'A';
}
}
}
freeMap();
free(grille);
free(coup);
return NULL;
}
void * jouer_radio_IA(void * rdy_p)
{
char *coup;
void ** rdy = (void **)rdy_p;
int * desc_pipe_write = (int *)rdy[0];
int * desc_pipe_read = (int *)rdy[1];
struct coup * pere;
char joueur;
int i;
int pipeDes_write[2];
pipe(pipeDes_write);
int pipeDes_read[2];
pipe(pipeDes_read); /* close(pipeDes[0]); */
pion ** grille;
initMap();
joueur = 'A';
grille = initGrille();
coup = malloc(sizeof(char) * 13);
for (i = 0; i < 13; i++)
{
coup[i] = 0;
}
int mode = 2;
int difficulter = 1;
int type = 0;
* desc_pipe_write = pipeDes_write[1];
* desc_pipe_read = pipeDes_read[0];
free(rdy_p);
updateMap(grille);
while (!victoire)
{
ready_to_play = 0;
if (joueur == 'A')
{
/* updateMap(grille); */
//affiche();
pere = malloc(sizeof(struct coup));
pere->proto = NULL;
pere->coupSuivant = NULL;
pere = coupsPossibles(grille, 'A', pere);
/* updateMap(grille); */
do
{
write(pipeDes_read[1], "ready", strlen("ready"));
interaction(coup, grille, &joueur, mode, pere);
if (action(grille, coup, pere, 1) != -1)break;
/* updateMap(grille); */
write(pipeDes_read[1], "bad_coup_in", strlen("bad_coup_in_"));
}
while (42);
freeCoup(pere, 1);
joueur = 'B';
}
if (joueur == 'B')
{
/* updateMap(grille); */
//affiche();
if (!victoire)
{
jouerCoupIA(grille, 'B', difficulter, 0, 0, type, coup);
joueur = 'A';
updateMap(grille);
write(pipeDes_read[1], coup, strlen(coup));
}
}
}
freeMap();
free(grille);
free(coup);
close(pipeDes_write[1]);
close(pipeDes_write[0]);
close(pipeDes_read[1]);
close(pipeDes_read[0]);
return NULL;
}
void test2() {
/*
* - plateau vide
* - joueur 1: 30
* - joueur 2: 24,25
*/
printf("debut test2 (cas particulier):\n");
joueur j1;
j1.est_humain = 1;
joueur j2;
j2.est_humain = 0;
plateau p = nouveau_plateau(j1,j2);
/* pour vider le plateau */
int i = 1;
while(i < 52) {
p.cases[i++].est_libre = 1;
}
pion dujoueur1;
dujoueur1.couleur = blanc;
dujoueur1.est_dame = 0;
pion dujoueur2;
dujoueur2.couleur = noir;
dujoueur2.est_dame = 0;
p.cases[30].est_libre = 0;
p.cases[30].pion = dujoueur1;
p.cases[25].est_libre = 0;
p.cases[25].pion = dujoueur2;
p.cases[24].est_libre = 0;
p.cases[24].pion = dujoueur2;
coup *liste = coupsPossibles(get_case_plateau(9,6,p),p);
printf("\n\n\nEnumeration des coups possibles:\n");
coup *ptr = liste;
int cpt = 1;
while((ptr->old_case != 0) && (ptr->new_case != 0)) {
printf("\n------------[%d]------------\n", cpt);
printCoup(*ptr);
printf("----------------------------\n");
ptr++;cpt++;
}
printf("\n\n\nEnumeration des coups max:\n");
ptr = getCoupsMax(liste);
cpt = 1;
while((ptr->old_case != 0) && (ptr->new_case != 0)) {
printf("\n------------[%d]------------\n", cpt);
printCoup(*ptr);
printf("----------------------------\n");
ptr++;cpt++;
}
}
