C et C++ TP7
PUZZLE inspiré du jeu Eternity II
Dans ce TP, nous allons réaliser un jeu dont le but est de reconstituer un puzzle en faisant tourner des pièces carrées.
Nous utiliserons le buffer d’affichage ASCII du TP précédent.
Principe du jeu
Voici un affichage d’une configuration d’un puzzle de dimension 3. Il y a 9 pièces carrées, chacune identifiée par une lettre de A à I inscrite en son centre. Chacun des 4 cotés d’une pièce a une valeur (appelée aussi couleur), qui est un chiffre compris entre 1 et 4.

Il y a discordance lorsque deux cotés contigus n’ont pas la même valeur. Par convention, le coté droit de la pièce la plus à droite d’une ligne est contigu avec le coté gauche de la pièce le plus à gauche de cette ligne. De même, haut de la pièce la plus haute d’une colonne est contigu avec le bas de la pièce la plus basse.
Cette configuration comporte donc 6 discordances :

Le but du jeu est de faire tourner des pièces dans le sens horaire de façon à obtenir une solution, c’est à dire une configuration sans discordance.
On fait d’abord tourner la pièce H d’un quart de tour.

Puis on fait tourner la pièce C de un demi tour, puis F d’un quart de tour, et on obtient une solution.

Pour réaliser un coup, le joueur ou la joueuse saisit au clavier la lettre identifiant une pièce et presse la touche entrée. La pièce désignée tourne de 90 degrés dans le sens horaire et la nouvelle configuration est affichée, ainsi que son nombre de discordances.
Le programme à réaliser doit permettre de jouer avec des grilles de dimension 2, 3, 4 ou 5. Il doit permettre de créer des configurations initiales aléatoires dont les cotés des pièces peuvent avoir de 2 à 8 valeurs différentes.
Programme à réaliser
Fichiers du projet
L’application à développer est constituée de trois fichiers :
buffer.c, qui contient le code source du buffer d’affichage développé dans le TP5.buffer.h, qui contient les déclarations des fonctions de gestion du buffer d’affichage définies dansbuffer.c.puzzle.c, qui contient le code source du jeu.
La compilation se fait avec la ligne :
gcc buffer.c puzzle.c -o puzzle -Wall -Wfatal-errors -Werror
Voici le contenu du fichier buffer.h :
#ifndef ETERNITY_BUFFER_H
#define ETERNITY_BUFFER_H
char** creeBuffer(int hauteur, int largeur);
void affiche(char** buffer);
void deleteBuffer(char** buffer);
void effaceBuffer(char** buffer);
#endif //ETERNITY_BUFFER_H
Voici le contenu du fichier buffer.c :
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "buffer.h"
char* creeString(char c, int n)
{
char* out = (char*) malloc((n+1) * sizeof(char));
for(int i=0; i<n; i++)
{
out[i] = c;
}
out[n] = 0;
return out;
}
char** creeBuffer(int hauteur, int largeur)
{
char** out = (char**) malloc((hauteur + 1) * sizeof(char*));
for(int i=0; i<hauteur; i++)
{
out[i] = creeString(' ', largeur);
}
out[hauteur] = NULL;
return out;
}
void affiche(char** buffer)
{
int i = 0;
while(buffer[i] != NULL)
{
printf("%s\n", buffer[i]);
i++;
}
}
void deleteBuffer(char** buffer)
{
int i = 0;
while(buffer[i] != NULL)
{
free(buffer[i]);
i++;
}
free(buffer);
}
void rempliString(char* dest, char c)
{
int n = (int)strlen(dest);
for(int i=0; i<n; i++)
{
dest[i] = c;
}
}
void effaceBuffer(char** buffer)
{
int i = 0;
while(buffer[i] != NULL)
{
rempliString(buffer[i], ' ');
i++;
}
}
Structures de données
Vous devez compléter le fichier puzzle.c qui commence par le code suivant :
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "buffer.h"
unsigned char saisiChar()
{
static char buffer[3];
fgets(buffer, 3, stdin);
if(buffer[0]=='\n') return 0;
else return buffer[0];
}
typedef struct
{
char id;
char faces[4];
}piece;
typedef struct
{
int dim;
piece** tab;
}puzzle;
La fonction saisiChar permet de saisir un caractère au clavier. Il ne vous est pas demandé de comprendre son code. Elle attend une saisie au clavier :
- soit d’un caractère suivi de la touche
entrée, - soit de la touche
entrée.
Dans le premier cas, la valeur de retour est le code ASCII du caractère saisi. Dans le deuxième cas, la valeur 0 est retournée.
La structure piece représente une pièce.
- Le champ
idest le caractère désignant la pièce, c’est à dire la lettre qui s’affiche au milieu de la pièce. - Le champ
facescontient les valeurs (couleurs) des 4 cotés de la pièce dans l’ordre suivant : droite, bas, gauche, haut.
La structure puzzle représente une configuration du puzzle.
- Le champ
dima pour valeur le nombre de pièces par ligne et par colonne. Si par exemple il vaut 3, alors le puzzle comporte 9 pièces. - Le champ
piecepointe un tableaux à deux dimensions, situé dans le tas, dont chaque cellule contient une pièce.
Voici un exemple de représentation d’un puzzle de dimension 2.

Fonctions à implémenter
Affichage
La fonction d’affichage vous est donnée pour vous permettre de tester les fonctions de création d’un puzzle. Faites vos premiers tests sur de petits puzzles de dimension 2.
// Buffer d'affichage. Doit être initialisé avant utilisation
// de la fonction affichePuzzle avec largeur 6*DIM et hauteur 3*DIM
// pour un puzzle de dimension DIM.
char** Buffer = NULL;
void affichePuzzle(puzzle* p)
{
effaceBuffer(Buffer);
for(int i=0; i<p->dim; i++)
{
for(int j=0; j<p->dim; j++)
{
int refJ = 6*j + 2;
int refI = 3*i + 1;
Buffer[refI][refJ] = p->tab[i][j].id;
Buffer[refI][refJ + 2] = p->tab[i][j].faces[0];
Buffer[refI][refJ - 2] = p->tab[i][j].faces[2];
Buffer[refI - 1][refJ] = p->tab[i][j].faces[3];
Buffer[refI + 1][refJ] = p->tab[i][j].faces[1];
}
}
affiche(Buffer);
}
Pour pouvoir utiliser cette fonction, il faut avoir créé un buffer d’affichage. Ce buffer n’est pas créé par la fonction pour des raisons d’efficacité. La fonction ci-dessous, moins efficace, vous permettra de réaliser des affichages sans avoir à gérer cette contrainte. À utiliser pour la mise au point des fonctions de création de puzzle.
void afficheDebug(puzzle* p)
{
Buffer = creeBuffer(3 * p->dim, 6 * p->dim);
affichePuzzle(p);
deleteBuffer(Buffer);
}
Création d’un puzzle
puzzle* creePuzzle(int dim);
Crée un puzzle de dimension dim complètement dans le tas. Les lettres identifiant les pièces sont assignées aux pièces dans l’ordre 'A', 'B', 'C', etc. Les couleurs des cotés des pièces sont assignées à ‘#’. Leur valeurs définitives seront déterminées par la fonction de génération d’une solution aléatoire.
void genRandPuzzle(puzzle* p, int nCouleurs);
Cette fonction accepte en paramètre l’adresse d’un puzzle existant ayant été créé par la fonction creePuzzle et assigne les valeurs des coté des pièces de manière à former une solution aléatoire. Le paramètre nCouleurs donne le nombre de valeurs possibles pour les cotés. Par exemple, si nCouleurs vaut 4, alors les valeurs à utiliser sont '1', '2', '3', et '4'.
La configuration produite doit être aussi aléatoire que possible mais sans discordance. Vous devzz trouver un algorithme approprié.
void deletePuzzle(puzzle* p);
Libère toute la mémoire occupée par le puzzle désigné par p.
Brouillage d’un puzzle
La fonction genRandPuzzle vue précédemment remplit un puzzle avec une solution aléatoire. Il faut appliquer à chaque pièce, aléatoirement, entre 0 et trois rotations de 90 degrés pour obtenir une configuration de départ du jeu. C’est le but de la fonction brouillePuzzle. Voici les fonctions à réaliser pour bien décomposer l’opération de brouillage.
void tournePiece(piece* m);
Tourne la pièce désignée par m de 90 degrés dans le sens horaire. L’ancienne valeur du coté haut devient celle de droite, l’ancienne de droite celle du bas, etc.
void randTournePiece(piece* m)
Réalise aléatoirement de 0 à 3 rotations de 90 degrés de la pièce désignée par m.
void brouillePuzzle(puzzle* p);
Réalise un rotation aléatoire de chacune des pièces du puzzle désigné par p.
Calcul du nombre de discordances
int nbDiscord(puzzle* p)
Retourne le nombre de discordances du puzzle désigné par p.
Boucle de jeu
La fonction qui enchaîne les tours de jeu vous est donnée. Si les fonctions précédentes ont été correctement programmées, vous pouvez donc immédiatement tester le jeu. Vous pouvez modifier cette fonction, par exemple pour que le jeu s’arrête et affiche "Victoire" quand une solution est trouvée, ou encore pour que le nombre de coups pour trouver la solution soit affiché à la fin de la partie.
La fonction auxiliaire condChar vérifie qu’un caractère désigne bien une pièce, et le cas échéant transforme une lettre minuscule en majuscule. La valeur du caractère est remplacée par 0 s’il ne désigne pas une pièce du puzzle.
void condChar(unsigned char* c, int dim)
{
unsigned char cMax = 'A' + dim*dim - 1;
if((*c>='a')&&(*c<='z'))
{
*c = *c + 'A'-'a';
}
if((*c<'A')||(*c>cMax))
{
*c = 0;
}
}
void runJeu(int dim, nCols)
{
Buffer = creeBuffer(3 * dim, 6 * dim);
unsigned char cIn;
puzzle* p = creePuzzle(dim);
genRandPuzzle(p, nCols);
brouillePuzzle(p);
printf("\n\n\n\n\n");
affichePuzzle(p);
printf("%d discordances\n", nbDiscord(p));
cIn = saisiChar();
condChar(&cIn, dim);
while(cIn != 0)
{
int rang = cIn-'A';
int i = rang/dim;
int j = rang%dim;
tournePiece(&(p->tab[i][j]));
printf("\n\n\n\n\n");
affichePuzzle(p);
printf("%d discordances\n", nbDiscord(p));
cIn = saisiChar();
condChar(&cIn, dim);
}
deletePuzzle(p);
deleteBuffer(Buffer);
}
Il reste à compléter le programme avec une fonction principale qui lance la boucle de jeu. Dans l’exemple suivant, le puzzle est de dimension 2 et les cotés des pièces peuvent avoir 4 valeurs.
int main()
{
srand(time(NULL));
runJeu(2,4);
return 0;
}