Skip to content
Snippets Groups Projects
Commit 9229a021 authored by remi.greub's avatar remi.greub
Browse files

mise au propre du programme

parent 83ab08dc
Branches
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
puissance4_GRB/puissance4.c
+ 190
− 38
View file @ 9229a021
......@@ -2,14 +2,15 @@
#include <stdint.h>
#include <stdio.h>
/***********************************
/******************************************************************
* function : Create_grid2D
* arguments : taille de grille hauteur x largeur
*
* return value : cell_t** -> la grille mise à jour et allouée
* initialise les valeurs de la grille
* et alloue la mémoire dynamiquement
***********************************/
* return value : cell** -> la grille mise à jour et allouée
*
* Description : initialise les valeurs de la grille et alloue la
* mémoire dynamiquement
******************************************************************/
struct cell **Create_grid2D(int height, int width){
struct cell** cells = malloc(width*sizeof(struct cell*));
for(int k =0; k<width; k++){
......@@ -26,18 +27,19 @@ struct cell **Create_grid2D(int height, int width){
return cells;
}
void print_cells(struct cell **cell, int height, int width){
for(int i=0; i<width; i++){
for(int j=0; j<height; j++){
printf("%d, ", cell[i][j].symbol);
}
printf("\n");
}
}
void print_gameCells(struct game game){
print_cells(game.cells, game.height, game.width);
}
/******************************************************************
* function : init_puissance4
* arguments : la structure du jeu struct game
* hauteur du plateau virtuel
* largeur du plateau virtuel
*
* return value : 0 -> si tout a fonctionné
* -1 -> si erreur
*
* Description : prends le jeu alloué en paramètre, puis l'initialiser
* en tenant compte de la taille du plateau souhaité
******************************************************************/
int init_puissance4(struct game *game, int height, int width){
if(game == NULL){
return -1;
......@@ -62,19 +64,84 @@ int init_puissance4(struct game *game, int height, int width){
}
}
/******************************************************************
* function : print_cells
* arguments : le tableau 2D type cell**, hauteur, largeur
*
* return value : -
* Description : affiche simplement le contenu du tableau 2D cell**
******************************************************************/
void print_cells(struct cell **cell, int height, int width){
for(int i=0; i<width; i++){
for(int j=0; j<height; j++){
printf("%d, ", cell[i][j].symbol);
}
printf("\n");
}
}
/******************************************************************
* function : print_gameCells
* arguments : structure du jeu "struct game"
*
* return value : -
* Description : affiche le contenu du tableau 2D cell** contenu dans
* la structure game
******************************************************************/
void print_gameCells(struct game game){
print_cells(game.cells, game.height, game.width);
}
/******************************************************************
* function : cell_destroy
* arguments : tableau 2D struct cell**
* largeur du tableau
*
* return value : -
*
* Description : détruit et libère la mémoire allouée sur le tableau
* 2D du tableau alloué avec Create_grid2D
******************************************************************/
void cell_destroy(struct cell **cells, int width){
for(int i=0; i<width; i++){
free(cells[i]);
}
free(cells);
}
/******************************************************************
* function : kill_game
* arguments : struct game** (structure du jeu)
*
* return value : 0 -> tout fonctionne
* -1 -> erreur
*
* Description : détruit et libère la mémoire allouée de la structure
* du jeu si non NULL.
******************************************************************/
int kill_game(struct game **game){
if(*game==NULL){
return -1;
}
cell_destroy((*game)->cells, (*game)->width);
free(*game);
*game=NULL;
return EXIT_SUCCESS;
}
/******************************************************************
* function : put_free_cell
* arguments : struct game* (structure du jeu)
* int j_p -> colonne sélectionnée par le joueur
* symbol_t symbol -> symbole du joueur
*
* return value : [0-x] -> valeur de la ligne du tableau où placer le jeton
* -1 -> il n'y a pas de case disponible dans la colonne selectionée
*
* Description : place le jeton du joueur correspondant au symbol_t
* dans la case j_p, puis le place dans la dernière case vide si il
* y en a une.
******************************************************************/
int put_free_cell(struct game *game, int j_p, symbol_t symbol){
int i=0;
if((i = is_cell_free(game, j_p, 0, game->players[game->curr_player].symbol)) != -1){
......@@ -84,11 +151,19 @@ int put_free_cell(struct game *game, int j_p, symbol_t symbol){
return i;
}
/*
retourne la ligne d'une cellule de libre dans une
colonne donnée
(si il y en a une, retourn -1 si il n'y en a aucune)
*/
/******************************************************************
* function : is_cell_free
* arguments : struct game* (structure du jeu)
* int j_p -> colonne sélectionnée par le joueur
* int i -> doit être = à 0 au premier appel ! pour la recursion
* symbol_t symbol -> symbole du joueur
*
* return value : [0-x] -> valeur de la ligne du tableau où placer le jeton
* -1 -> il n'y a pas de case disponible dans la colonne selectionée
*
* Description : trouve dans la colonne donnée la ligne disponible
* pour placer le jeton.
******************************************************************/
int is_cell_free(struct game *game, int j_p, int i, symbol_t symbol){
if(game->cells[j_p][i].symbol == EMPTY){
//retourne la ligne disponible
......@@ -97,12 +172,20 @@ int is_cell_free(struct game *game, int j_p, int i, symbol_t symbol){
if(i<(game->height-1)){
return is_cell_free(game, j_p, i+1, symbol);
}else{
//printf("il n'y a plus de case de disponible sur cette colonne\n");
return -1;
}
}
}
/******************************************************************
* function : Launch_puissance4
* arguments : struct game* (structure du jeu)
*
* return value : retourne le resultat du gagnant de la partie
* ou -1 si il y a une erreur
*
* Description : Jeu du puissance4 en mode 2players (deux joueurs)
******************************************************************/
int Launch_puissance4(struct game *game){
symbol_t winner=EMPTY;
int chiffre=0;
......@@ -164,6 +247,17 @@ int Launch_puissance4(struct game *game){
return winner;
}
/******************************************************************
* function : Launch_puissance4_randBot
* arguments : struct game* (structure du jeu)
* int seed -> graine de generation pseudo-aléatoire
*
* return value : retourne le resultat du gagnant de la partie
* ou -1 si il y a une erreur
*
* Description : Jeu du puissance4 en mode joueur vs bot,
* mais le bot a un algorithme pseudo aléatoire.
******************************************************************/
int Launch_puissance4_randBot(struct game *game, int seed){
if(game == NULL){
return -1;
......@@ -231,6 +325,19 @@ int Launch_puissance4_randBot(struct game *game, int seed){
return winner;
}
/******************************************************************
* function : Launch_puissance4_smartBot
* arguments : struct game* (structure du jeu)
* int seed -> graine de generation pseudo-aléatoire
*
* return value : retourne le resultat du gagnant de la partie
* ou -1 si il y a une erreur
*
* Description : Jeu du puissance4 en mode joueur vs smart-bot,
* le bot peux trouver un coup gagnant si il peux en jouer un,
* bloquer un coup du joueur adversaire si il peux
* sinon, joue en mode pseudo-aléatoire.
******************************************************************/
int Launch_puissance4_smartBot(struct game *game, int seed){
if(game == NULL){
return -1;
......@@ -294,6 +401,17 @@ int Launch_puissance4_smartBot(struct game *game, int seed){
return winner;
}
/******************************************************************
* function : SmartBot
* arguments : struct game* (structure du jeu)
*
* return value : retourne le prochain coup joué par le bot
*
* Description : algorithme smartBot utilisé dans le mode de jeu 2
* le bot peux trouver un coup gagnant si il peux en jouer un,
* bloquer un coup du joueur adversaire si il peux
* sinon, joue en mode pseudo-aléatoire.
******************************************************************/
int SmartBot(struct game *game){
int pos=0;
int chfr1 = -1, chfr2 = -1;
......@@ -333,21 +451,33 @@ int SmartBot(struct game *game){
}
}
/******************************************************************
* function : Is_Grid_full
* arguments : struct game (structure du jeu)
*
* return value : retourne si la partie est egalité ou non
* (si la grille est pleine ou non)
*
* Description : Lorsque le jeu est lancé, cette fonction est utilisée
* pour savoir si la grille de jeu est pleine (ou si c'est un égalité)
******************************************************************/
bool Is_Grid_full(struct game game){
return game.gamePlayed == 0;
}
/***********************************
/******************************************************************
* function : Find_winner
* arguments : grid[][],
* cellule jouée,
* taille de grille (ex: 3 pour 3x3)
* arguments : struct game (structure du jeu)
* struct cell** : grille a tester
* struct cell : cellule jouée,
*
* return value : symbole -> gagnant ou EMPTY
* Cherche si il y a un gagnant,
* (cherche des suites de cases gagnantes)
* !!! Fonctionne avec CheckWin_in_a_direction !!!
***********************************/
*
* Description :
* Cherche si il y a un gagnant selon le dernier coup
* joué.
* !!! Fonctionne avec CheckWin_in_a_direction !!!
******************************************************************/
symbol_t Find_winner(struct game *game, struct cell **grid, struct cell cellPlayed){
//int grid_len = game.height*game.width;
int k[4][2]={
......@@ -377,18 +507,17 @@ symbol_t Find_winner(struct game *game, struct cell **grid, struct cell cellPlay
return EMPTY; // pas de winner pour l'instant
}
/***********************************
/******************************************************************
* function : CheckWin_in_a_direction
* arguments : grid[][],
* cellule jouée,
* taille de grille (ex: 3 pour 3x3)
* arguments : struct game* (structure du jeu)
* int dir[2] : direction 2D où chercher une suite
* struct cell : cellule jouée
*
* return value : symbole -> gagnant ou EMPTY si non
*
* Va chercher des suites de cases gagnantes
* recursivement, dans une seule direction
* à l'aide des var globale cross et circle
***********************************/
* Description : Va chercher des suites de cases gagnantes
* recursivement, dans une seule direction selon le dernier jeton joué
******************************************************************/
symbol_t CheckWin_in_a_direction(struct game *game, int dir[2], struct cell **grid, struct cell cell){
int x1 = cell.i_pos+dir[0];
int x2 = cell.j_pos+dir[1];
......@@ -414,6 +543,29 @@ symbol_t CheckWin_in_a_direction(struct game *game, int dir[2], struct cell **gr
return result;
}
/******************************************************************
* function : print_game
* arguments : struct game (structure du jeu)
*
* return value : -
* Description : fonction d'affichage du jeu de la manière suivante :
* (ex pour un jeu 6x7)
* ┌─┬─┬─┬─┬─┬─┬─┐
* │ │ │ │ │ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │ │ │ │ │ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │ │ │ │X│ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │ │ │X│O│ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │O│X│X│O│ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │X│O│X│O│ │ │ │
* └─┴─┴─┴─┴─┴─┴─┘
* 1 2 3 4 5 6 7
*
******************************************************************/
void print_game(struct game game){
//printf("h:%d, w:%d\n", game.height, game.width);
//affiche ┌─┬─┬─┬─┬─┬─┬─┐
......
puissance4_GRB/puissance4.h
+ 197
− 6
View file @ 9229a021
......@@ -33,29 +33,220 @@ struct game{
int curr_player;
};
struct cell **Create_grid2D(); //on pourrait peut être créer une autre librairie CELL.h pour gérer les cellules maybe ?
/******************************************************************
* function : Create_grid2D
* arguments : taille de grille hauteur x largeur
*
* return value : cell** -> la grille mise à jour et allouée
*
* Description : initialise les valeurs de la grille et alloue la
* mémoire dynamiquement
******************************************************************/
struct cell **Create_grid2D(int height, int width);
void print_cells(struct cell **cell, int height, int width);
void print_gameCells(struct game game);
/******************************************************************
* function : init_puissance4
* arguments : la structure du jeu struct game
* hauteur du plateau virtuel
* largeur du plateau virtuel
*
* return value : 0 -> si tout a fonctionné
* -1 -> si erreur
*
* Description : prends le jeu alloué en paramètre, puis l'initialiser
* en tenant compte de la taille du plateau souhaité
******************************************************************/
int init_puissance4(struct game *game, int height, int width);
//void Show_grid(struct cell** cell); //partie graphique a venir
/******************************************************************
* function : print_cells
* arguments : le tableau 2D type cell**, hauteur, largeur
*
* return value : -
* Description : affiche simplement le contenu du tableau 2D cell**
******************************************************************/
void print_cells(struct cell **cell, int height, int width);
/******************************************************************
* function : print_gameCells
* arguments : structure du jeu "struct game"
*
* return value : -
* Description : affiche le contenu du tableau 2D cell** contenu dans
* la structure game
******************************************************************/
void print_gameCells(struct game game);
/******************************************************************
* function : cell_destroy
* arguments : tableau 2D struct cell**
* largeur du tableau
*
* return value : -
*
* Description : détruit et libère la mémoire allouée sur le tableau
* 2D du tableau alloué avec Create_grid2D
******************************************************************/
void cell_destroy(struct cell **cells, int width);
/******************************************************************
* function : kill_game
* arguments : struct game** (structure du jeu)
*
* return value : 0 -> tout fonctionne
* -1 -> erreur
*
* Description : détruit et libère la mémoire allouée de la structure
* du jeu si non NULL.
******************************************************************/
int kill_game(struct game **game);
/******************************************************************
* function : put_free_cell
* arguments : struct game* (structure du jeu)
* int j_p -> colonne sélectionnée par le joueur
* symbol_t symbol -> symbole du joueur
*
* return value : [0-x] -> valeur de la ligne du tableau où placer le jeton
* -1 -> il n'y a pas de case disponible dans la colonne selectionée
*
* Description : place le jeton du joueur correspondant au symbol_t
* dans la case j_p, puis le place dans la dernière case vide si il
* y en a une.
******************************************************************/
int put_free_cell(struct game *game, int j_p, symbol_t symbol);
/******************************************************************
* function : is_cell_free
* arguments : struct game* (structure du jeu)
* int j_p -> colonne sélectionnée par le joueur
* int i -> doit être = à 0 au premier appel ! pour la recursion
* symbol_t symbol -> symbole du joueur
*
* return value : [0-x] -> valeur de la ligne du tableau où placer le jeton
* -1 -> il n'y a pas de case disponible dans la colonne selectionée
*
* Description : trouve dans la colonne donnée la ligne disponible
* pour placer le jeton.
******************************************************************/
int is_cell_free(struct game *game, int j_p, int i, symbol_t symbol);
/******************************************************************
* function : Launch_puissance4
* arguments : struct game* (structure du jeu)
*
* return value : retourne le resultat du gagnant de la partie
* ou -1 si il y a une erreur
*
* Description : Jeu du puissance4 en mode 2players (deux joueurs)
******************************************************************/
int Launch_puissance4(struct game *game);
/******************************************************************
* function : Launch_puissance4_randBot
* arguments : struct game* (structure du jeu)
* int seed -> graine de generation pseudo-aléatoire
*
* return value : retourne le resultat du gagnant de la partie
* ou -1 si il y a une erreur
*
* Description : Jeu du puissance4 en mode joueur vs bot,
* mais le bot a un algorithme pseudo aléatoire.
******************************************************************/
int Launch_puissance4_randBot(struct game *game, int seed);
/******************************************************************
* function : Launch_puissance4_smartBot
* arguments : struct game* (structure du jeu)
* int seed -> graine de generation pseudo-aléatoire
*
* return value : retourne le resultat du gagnant de la partie
* ou -1 si il y a une erreur
*
* Description : Jeu du puissance4 en mode joueur vs smart-bot,
* le bot peux trouver un coup gagnant si il peux en jouer un,
* bloquer un coup du joueur adversaire si il peux
* sinon, joue en mode pseudo-aléatoire.
******************************************************************/
int Launch_puissance4_smartBot(struct game *game, int seed);
/******************************************************************
* function : SmartBot
* arguments : struct game* (structure du jeu)
*
* return value : retourne le prochain coup joué par le bot
*
* Description : algorithme smartBot utilisé dans le mode de jeu 2
* le bot peux trouver un coup gagnant si il peux en jouer un,
* bloquer un coup du joueur adversaire si il peux
* sinon, joue en mode pseudo-aléatoire.
******************************************************************/
int SmartBot(struct game *game);
bool Is_Grid_full(struct game game);
void print_game(struct game game);
/******************************************************************
* function : Is_Grid_full
* arguments : struct game (structure du jeu)
*
* return value : retourne si la partie est egalité ou non
* (si la grille est pleine ou non)
*
* Description : Lorsque le jeu est lancé, cette fonction est utilisée
* pour savoir si la grille de jeu est pleine (ou si c'est un égalité)
******************************************************************/
bool Is_Grid_full(struct game game);
/******************************************************************
* function : Find_winner
* arguments : struct game (structure du jeu)
* struct cell** : grille a tester
* struct cell : cellule jouée,
*
* return value : symbole -> gagnant ou EMPTY
*
* Description :
* Cherche si il y a un gagnant selon le dernier coup
* joué.
* !!! Fonctionne avec CheckWin_in_a_direction !!!
******************************************************************/
symbol_t Find_winner(struct game *game, struct cell **grid, struct cell cellPlayed);
/******************************************************************
* function : CheckWin_in_a_direction
* arguments : struct game* (structure du jeu)
* int dir[2] : direction 2D où chercher une suite
* struct cell : cellule jouée
*
* return value : symbole -> gagnant ou EMPTY si non
*
* Description : Va chercher des suites de cases gagnantes
* recursivement, dans une seule direction selon le dernier jeton joué
******************************************************************/
symbol_t CheckWin_in_a_direction(struct game *game, int dir[2], struct cell **grid, struct cell cell);
/******************************************************************
* function : print_game
* arguments : struct game (structure du jeu)
*
* return value : -
* Description : fonction d'affichage du jeu de la manière suivante :
* (ex pour un jeu 6x7)
* ┌─┬─┬─┬─┬─┬─┬─┐
* │ │ │ │ │ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │ │ │ │ │ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │ │ │ │X│ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │ │ │X│O│ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │O│X│X│O│ │ │ │
* ├─┼─┼─┼─┼─┼─┼─┤
* │X│O│X│O│ │ │ │
* └─┴─┴─┴─┴─┴─┴─┘
* 1 2 3 4 5 6 7
*
******************************************************************/
void print_game(struct game game);
#endif
\ No newline at end of file
puissance4_GRB/unit_tests.c
+ 3
− 7
View file @ 9229a021
......@@ -131,14 +131,14 @@ int main(){
i = put_free_cell(games, 0, CROSS);
i = put_free_cell(games, 4, CIRCLE);
printf("return should be : true, returned=%s \n",Is_Grid_full(*games) ? "true":"false" );
print_game(*games);
assert(games->gamePlayed==0);
assert(Is_Grid_full(*games)==true);
printf("\ngrid overflow passed\n");
printf("winner test should return equal/empty (2) : returns %d\n",Find_winner(games, games->cells, games->cells[4][i]));
printf("winner test should return EMPTY (2/3) : returns %d\n",Find_winner(games, games->cells, games->cells[4][i]));
printf("===================================================\n\n");
//test de wins(CROIX, CERCLES ou si il y a une suite plus grande que 4)
printf("===================================================\n");
games->cells[5][0].symbol = CROSS;
assert(Find_winner(games, games->cells, games->cells[5][0])==CROSS);
......@@ -149,7 +149,7 @@ int main(){
printf("should return CIRCLE wins (0) : returns=%d\n",Find_winner(games, games->cells, games->cells[4][4]));
games->cells[4][4].symbol = CROSS;
assert(Find_winner(games, games->cells, games->cells[4][4])==EMPTY);
printf("should return EQUAL/EMPTY wins (2) : returns=%d\n",Find_winner(games, games->cells, games->cells[4][4]));
printf("should return EMPTY wins (2) : returns=%d\n",Find_winner(games, games->cells, games->cells[4][4]));
games->cells[1][2].symbol = CIRCLE;
assert(Find_winner(games, games->cells, games->cells[1][2])==CIRCLE);
printf("should return CIRCLE wins (0) : returns=%d\n",Find_winner(games, games->cells, games->cells[1][2]));
......@@ -157,9 +157,5 @@ int main(){
printf("===================================================\n\n");
kill_game(&games);
printf("Tests tous reussis !\n");
//test de detection de wins
//test is cell free
//test put cells ?? (pas obligé je dis)
//
return EXIT_SUCCESS;
}
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment