Paris8/Othello
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

add tests

Browse source
This commit is contained in:
Mylloon 2022-12-04 18:25:35 +01:00
parent 652b718b2b
commit afcf0f07a4
Signed by: Anri
GPG key ID: A82D63DFF8D1317F
9 changed files with 91 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
includes/alphabeta.h
View file

@ -4,7 +4,7 @@
#include "minimax.h"
/* Joue le tour d'après l'algorithme alpha-beta */
void action_joueur_alphabeta(Jeu *jeu, const int couleur);
void action_joueur_alphabeta(Jeu *jeu, const int couleur, const int profondeur);
/* Décide d'une case à jouer via l'algorithme alpha-beta */
void _action_joueur_alphabeta(Jeu *jeu, int profondeur, int couleur,

3
includes/jeu.h
View file

@ -5,6 +5,7 @@
#include <stdlib.h>
#include "liste.h"
#include "test.h"
typedef struct joueur Joueur;
@ -47,7 +48,7 @@ Jeu *nouvelle_partie(void);
/* Lance et joue une partie */
void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE noir,
const enum PLAYER_TYPE blanc);
const enum PLAYER_TYPE blanc, const Test_Data *test);
/* Coups possibles d'un joueur */
struct coups {

2
includes/minimax.h
View file

@ -6,7 +6,7 @@
#include "joueur.h"
/* Joue le tour d'après l'algorithme minimax */
void action_joueur_minimax(Jeu *jeu, const int couleur);
void action_joueur_minimax(Jeu *jeu, const int couleur, const int profondeur);
/* Décide d'une case à jouer via l'algorithme minimax */
void _action_joueur_minimax(Jeu *jeu, int profondeur, const int couleur,

14
includes/test.h
View file

@ -1,6 +1,20 @@
#ifndef OTHELLO_TEST_H
#define OTHELLO_TEST_H 1
#include <time.h>
struct test_data {
int test;
int profondeur;
};
typedef struct test_data Test_Data;
/* Initialise un Test_Data */
Test_Data *nouveau_test_data(int test, int profondeur);
/* Libère un Test_Data de la mémoire */
void free_test_data(Test_Data *test_data);
/* Run the tests */
void run_tests(void);

7
src/alphabeta.c
View file

@ -1,9 +1,10 @@
#include "../includes/alphabeta.h"
void action_joueur_alphabeta(Jeu *jeu, const int couleur) {
void action_joueur_alphabeta(Jeu *jeu, const int couleur,
const int profondeur) {
int ligne, colonne, score = INT_MAX;
_action_joueur_alphabeta(jeu, 9, couleur, couleur, &ligne, &colonne, &score,
0, VIDE);
_action_joueur_alphabeta(jeu, profondeur, couleur, couleur, &ligne,
&colonne, &score, 0, VIDE);
jeu_joueur(jeu, ligne, colonne, couleur);
}

47
src/jeu.c
View file

@ -39,17 +39,22 @@ Jeu *nouvelle_partie(void) {
}
void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
const enum PLAYER_TYPE type_blanc) {
const enum PLAYER_TYPE type_blanc,
const Test_Data *test) {
Joueur *tour = jeu->j1->couleur == NOIR ? jeu->j1 : jeu->j2;
while (!partie_finie(jeu)) {
affiche_plateau(jeu->plateau);
if (!test->test) {
affiche_plateau(jeu->plateau);
}
Coups *possibilites =
action_possible_joueur(jeu->plateau, tour->couleur);
if (possibilites->taille_liste > 0) {
// Si le joueur peut jouer
printf("Tour des jetons %ss !\n", tour->nom);
if (!test->test) {
printf("Tour des jetons %ss !\n", tour->nom);
}
if (tour->couleur == NOIR) {
switch (type_noir) {
@ -61,10 +66,11 @@ void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
action_joueur_humain(jeu, tour->couleur);
break;
case MINIMAX:
action_joueur_minimax(jeu, tour->couleur);
action_joueur_minimax(jeu, tour->couleur, test->profondeur);
break;
case ALPHABETA:
action_joueur_alphabeta(jeu, tour->couleur);
action_joueur_alphabeta(jeu, tour->couleur,
test->profondeur);
break;
default:
fprintf(stderr, "Erreur: Joueur noir non supporté.");
@ -81,17 +87,20 @@ void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
action_joueur_humain(jeu, tour->couleur);
break;
case MINIMAX:
action_joueur_minimax(jeu, tour->couleur);
action_joueur_minimax(jeu, tour->couleur, test->profondeur);
break;
case ALPHABETA:
action_joueur_alphabeta(jeu, tour->couleur);
action_joueur_alphabeta(jeu, tour->couleur,
test->profondeur);
break;
default:
fprintf(stderr, "Erreur: Joueur blanc non supporté.");
}
}
} else {
printf("Pas de coup jouable.\n");
if (!test->test) {
printf("Pas de coup jouable.\n");
}
}
free_coups(possibilites);
@ -99,15 +108,19 @@ void deroulement_partie(Jeu *jeu, const enum PLAYER_TYPE type_noir,
tour = jeu->j1->couleur == tour->couleur ? jeu->j2 : jeu->j1;
}
affiche_plateau(jeu->plateau);
int resultat[3];
if (selection_gagnant(jeu, resultat)) {
printf("Fin de partie ! Le joueur %s a gagné %d contre %d !\n",
jeu->j1->couleur == resultat[0] ? jeu->j1->nom : jeu->j2->nom,
resultat[1], resultat[2]);
} else {
printf("Égalité parfaite, %d contre %d !\n", jeu->j1->nb_jeton,
jeu->j2->nb_jeton);
if (!test->test) {
affiche_plateau(jeu->plateau);
int resultat[3];
if (selection_gagnant(jeu, resultat)) {
printf("Fin de partie ! Le joueur %s a gagné %d contre %d !\n",
jeu->j1->couleur == resultat[0] ? jeu->j1->nom
: jeu->j2->nom,
resultat[1], resultat[2]);
} else {
printf("Égalité parfaite, %d contre %d !\n", jeu->j1->nb_jeton,
jeu->j2->nb_jeton);
}
}
}

4
src/main.c
View file

@ -74,14 +74,16 @@ int main(int argc, char const *argv[]) {
}
Jeu *jeu = nouvelle_partie();
Test_Data *test = nouveau_test_data(0, 3);
printf("Le jeu commence avec les noirs en tant %s et les blancs en "
"tant %s.\n",
joueur_type_str(noirs), joueur_type_str(blancs));
deroulement_partie(jeu, noirs, blancs);
deroulement_partie(jeu, noirs, blancs, test);
free_jeu(jeu);
free_test_data(test);
return EXIT_SUCCESS;
}

5
src/minimax.c
View file

@ -1,8 +1,9 @@
#include "../includes/minimax.h"
void action_joueur_minimax(Jeu *jeu, const int couleur) {
void action_joueur_minimax(Jeu *jeu, const int couleur, const int profondeur) {
int ligne, colonne, score = INT_MAX;
_action_joueur_minimax(jeu, 5, couleur, couleur, &ligne, &colonne, &score);
_action_joueur_minimax(jeu, profondeur, couleur, couleur, &ligne, &colonne,
&score);
jeu_joueur(jeu, ligne, colonne, couleur);
}

35
src/test.c
View file

@ -1,3 +1,34 @@
#include "../includes/test.h"
#include "../includes/jeu.h"
void run_tests(void) {}
Test_Data *nouveau_test_data(int test, int profondeur) {
Test_Data *res = malloc(sizeof(Test_Data));
res->test = test;
res->profondeur = profondeur;
return res;
}
void free_test_data(Test_Data *test_data) { free(test_data); }
void run_tests(void) {
printf("Test alphabeta...\n");
Jeu *jeu = nouvelle_partie();
Test_Data *test = nouveau_test_data(1, 8);
clock_t ta, td;
td = clock();
// Lance le jeu en mode test avec 2 alpha-bêta
deroulement_partie(jeu, ALPHABETA, ALPHABETA, test);
ta = clock();
printf("Alphabêta : %ld\n", ta - td);
free_jeu(jeu);
free_test_data(test);
}