{"id":364,"date":"2022-03-17T21:42:28","date_gmt":"2022-03-17T21:42:28","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=364"},"modified":"2022-03-21T18:33:29","modified_gmt":"2022-03-21T18:33:29","slug":"c-et-c-tp7","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-tp7\/","title":{"rendered":"C et C++ : TP7"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><h1>C et C++ TP7<\/h1>\n<h1>PUZZLE inspir\u00e9 du jeu Eternity II<\/h1>\n<p>Dans ce TP, nous allons r\u00e9aliser un jeu dont le but est de reconstituer un puzzle en faisant tourner des pi\u00e8ces carr\u00e9es.<\/p>\n<p>Nous utiliserons le buffer d&rsquo;affichage ASCII du TP pr\u00e9c\u00e9dent.<\/p>\n<h2>Principe du jeu<\/h2>\n<p>Voici un affichage d&rsquo;une configuration d&rsquo;un puzzle de dimension 3. Il y a 9 pi\u00e8ces carr\u00e9es, chacune identifi\u00e9e par une lettre de A \u00e0 I inscrite en son centre. Chacun des 4 cot\u00e9s d&rsquo;une pi\u00e8ce a une valeur (appel\u00e9e aussi couleur), qui est un chiffre compris entre 1 et 4.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/tp7-1.png\" alt=\"tp7-1\"><\/p>\n<p>Il y a <strong>discordance<\/strong> lorsque deux cot\u00e9s contigus n&rsquo;ont pas la m\u00eame valeur. Par convention, le cot\u00e9 droit de la pi\u00e8ce la plus \u00e0 droite d&rsquo;une ligne est contigu avec le cot\u00e9 gauche de la pi\u00e8ce le plus \u00e0 gauche de cette ligne. De m\u00eame, haut de la pi\u00e8ce la plus haute d&rsquo;une colonne est contigu avec le bas de la pi\u00e8ce la plus basse.<\/p>\n<p>Cette configuration comporte donc 6 discordances :<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/tp7-2.png\" alt=\"tp7-2\"><\/p>\n<p>Le but du jeu est de faire tourner des pi\u00e8ces dans le sens horaire de fa\u00e7on \u00e0 obtenir une solution, c&rsquo;est \u00e0 dire une configuration sans discordance.<\/p>\n<p>On fait d&rsquo;abord tourner la pi\u00e8ce H d&rsquo;un quart de tour.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/tp7-5.png\" alt=\"tp7-5\"><\/p>\n<p>Puis on fait tourner la pi\u00e8ce C de un demi tour, puis F d&rsquo;un quart de tour, et on obtient une solution.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/tp7-3.png\" alt=\"tp7-3\"><\/p>\n<p>Pour r\u00e9aliser un coup, le joueur ou la joueuse saisit au clavier la lettre identifiant une pi\u00e8ce et presse la touche <code>entr\u00e9e<\/code>. La pi\u00e8ce d\u00e9sign\u00e9e tourne de 90 degr\u00e9s dans le sens horaire et la nouvelle configuration est affich\u00e9e, ainsi que son nombre de discordances.<\/p>\n<p>Le programme \u00e0 r\u00e9aliser doit permettre de jouer avec des grilles de dimension 2, 3, 4 ou 5. Il doit  permettre de cr\u00e9er des configurations initiales al\u00e9atoires dont les cot\u00e9s des pi\u00e8ces peuvent avoir de 2 \u00e0 8 valeurs diff\u00e9rentes.<\/p>\n<h2>Programme \u00e0 r\u00e9aliser<\/h2>\n<h3>Fichiers du projet<\/h3>\n<p>L&rsquo;application \u00e0 d\u00e9velopper est constitu\u00e9e de trois fichiers :<\/p>\n<ul>\n<li><code>buffer.c<\/code>, qui contient le code source du buffer d&rsquo;affichage d\u00e9velopp\u00e9 dans le TP5.<\/li>\n<li><code>buffer.h<\/code>, qui contient les d\u00e9clarations des fonctions de gestion du buffer d&rsquo;affichage d\u00e9finies dans <code>buffer.c<\/code>.<\/li>\n<li><code>puzzle.c<\/code>, qui contient le code source du jeu.<\/li>\n<\/ul>\n<p>La compilation se fait avec la ligne :<\/p>\n<pre><code>gcc buffer.c puzzle.c -o puzzle -Wall -Wfatal-errors -Werror\n<\/code><\/pre>\n<p>Voici le contenu du fichier <code>buffer.h<\/code> :<\/p>\n<pre><code class=\"language-c\">#ifndef ETERNITY_BUFFER_H\n#define ETERNITY_BUFFER_H\n\nchar** creeBuffer(int hauteur, int largeur);\nvoid affiche(char** buffer);\nvoid deleteBuffer(char** buffer);\nvoid effaceBuffer(char** buffer);\n\n#endif \/\/ETERNITY_BUFFER_H\n<\/code><\/pre>\n<p>Voici le contenu du fichier <code>buffer.c<\/code> :<\/p>\n<pre><code class=\"language-c\">#include &lt;string.h&gt;\n#include &lt;stdlib.h&gt;\n#include &lt;stdio.h&gt;\n#include &quot;buffer.h&quot;\n\nchar* creeString(char c, int n)\n{\n    char* out = (char*) malloc((n+1) * sizeof(char));\n    for(int i=0; i&lt;n; i++)\n    {\n        out[i] = c;\n    }\n    out[n] = 0;\n    return out;\n}\n\nchar** creeBuffer(int hauteur, int largeur)\n{\n    char** out = (char**) malloc((hauteur + 1) * sizeof(char*));\n    for(int i=0; i&lt;hauteur; i++)\n    {\n        out[i] = creeString(' ', largeur);\n\n    }\n    out[hauteur] = NULL;\n    return out;\n}\n\nvoid affiche(char** buffer)\n{\n    int i = 0;\n    while(buffer[i] != NULL)\n    {\n        printf(&quot;%s\\n&quot;, buffer[i]);\n        i++;\n    }\n}\n\nvoid deleteBuffer(char** buffer)\n{\n    int i = 0;\n    while(buffer[i] != NULL)\n    {\n        free(buffer[i]);\n        i++;\n    }\n    free(buffer);\n}\n\nvoid rempliString(char* dest, char c)\n{\n    int n = (int)strlen(dest);\n    for(int i=0; i&lt;n; i++)\n    {\n        dest[i] = c;\n    }\n}\n\nvoid effaceBuffer(char** buffer)\n{\n    int i = 0;\n    while(buffer[i] != NULL)\n    {\n        rempliString(buffer[i], ' ');\n        i++;\n    }\n}\n<\/code><\/pre>\n<h3>Structures de donn\u00e9es<\/h3>\n<p>Vous devez compl\u00e9ter le fichier <code>puzzle.c<\/code> qui commence par le code suivant :<\/p>\n<pre><code class=\"language-c\">#include &lt;stdio.h&gt;\n#include &lt;stdlib.h&gt;\n#include &lt;time.h&gt;\n\n#include &quot;buffer.h&quot;\n\nunsigned char saisiChar()\n{\n    static char buffer[3];\n    fgets(buffer, 3, stdin);\n    if(buffer[0]=='\\n') return 0;\n    else return buffer[0];\n}\n\ntypedef struct\n{\n    char id;\n    char faces[4];\n}piece;\n\ntypedef struct\n{\n    int dim;\n    piece** tab;\n}puzzle;\n<\/code><\/pre>\n<p>La fonction <code>saisiChar<\/code> permet de saisir un caract\u00e8re au clavier. Il ne vous est pas demand\u00e9 de comprendre son code. Elle attend une saisie au clavier :<\/p>\n<ul>\n<li>soit d&rsquo;un caract\u00e8re suivi de la touche <code>entr\u00e9e<\/code>,<\/li>\n<li>soit de la touche <code>entr\u00e9e<\/code>.<\/li>\n<\/ul>\n<p>Dans le premier cas, la valeur de retour est le code <code>ASCII<\/code> du caract\u00e8re saisi. Dans le deuxi\u00e8me cas, la valeur 0 est retourn\u00e9e.<\/p>\n<p>La structure <code>piece<\/code> repr\u00e9sente une pi\u00e8ce.<\/p>\n<ul>\n<li>Le champ <code>id<\/code> est le caract\u00e8re d\u00e9signant la pi\u00e8ce, c&rsquo;est \u00e0 dire la lettre qui s&rsquo;affiche au milieu de la pi\u00e8ce.<\/li>\n<li>Le champ <code>faces<\/code> contient les valeurs (couleurs) des 4 cot\u00e9s de la pi\u00e8ce dans l&rsquo;ordre suivant : droite, bas, gauche, haut.<\/li>\n<\/ul>\n<p>La structure <code>puzzle<\/code> repr\u00e9sente une configuration du puzzle.<\/p>\n<ul>\n<li>Le champ <code>dim<\/code> a pour valeur le nombre de pi\u00e8ces par ligne et par colonne. Si par exemple il vaut 3, alors le puzzle comporte 9 pi\u00e8ces.<\/li>\n<li>Le champ <code>piece<\/code> pointe un tableaux \u00e0 deux dimensions, situ\u00e9 dans le tas, dont chaque cellule contient une pi\u00e8ce.<\/li>\n<\/ul>\n<p>Voici un exemple de repr\u00e9sentation d&rsquo;un puzzle de dimension 2.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/03\/tp7-4.png\" alt=\"tp7-4\"><\/p>\n<h3>Fonctions \u00e0 impl\u00e9menter<\/h3>\n<h4>Affichage<\/h4>\n<p>La fonction d&rsquo;affichage vous est <strong>donn\u00e9e<\/strong> pour vous permettre de tester les fonctions de cr\u00e9ation d&rsquo;un puzzle. Faites vos premiers tests sur de petits puzzles de dimension 2.<\/p>\n<pre><code class=\"language-c\">\/\/ Buffer d'affichage. Doit \u00eatre initialis\u00e9 avant utilisation\n\/\/ de la fonction affichePuzzle avec largeur 6*DIM et hauteur 3*DIM\n\/\/ pour un puzzle de dimension DIM.\nchar** Buffer = NULL; \n\nvoid affichePuzzle(puzzle* p)\n{\n    effaceBuffer(Buffer);\n    for(int i=0; i&lt;p-&gt;dim; i++)\n    {\n        for(int j=0; j&lt;p-&gt;dim; j++)\n        {\n            int refJ = 6*j + 2;\n            int refI = 3*i + 1;\n            Buffer[refI][refJ] = p-&gt;tab[i][j].id;\n            Buffer[refI][refJ + 2] = p-&gt;tab[i][j].faces[0];\n            Buffer[refI][refJ - 2] = p-&gt;tab[i][j].faces[2];\n            Buffer[refI - 1][refJ] = p-&gt;tab[i][j].faces[3];\n            Buffer[refI + 1][refJ] = p-&gt;tab[i][j].faces[1];\n        }\n    }\n    affiche(Buffer);\n}\n<\/code><\/pre>\n<p>Pour pouvoir utiliser cette fonction, il faut avoir cr\u00e9\u00e9 un buffer d&rsquo;affichage. Ce buffer n&rsquo;est pas cr\u00e9\u00e9 par la fonction pour des raisons d&rsquo;efficacit\u00e9. La fonction ci-dessous, moins efficace, vous permettra de r\u00e9aliser des affichages sans avoir \u00e0 g\u00e9rer cette contrainte. \u00c0 utiliser pour la mise au point des fonctions de cr\u00e9ation de puzzle.<\/p>\n<pre><code class=\"language-c\">void afficheDebug(puzzle* p)\n{\n    Buffer = creeBuffer(3 * p-&gt;dim, 6 * p-&gt;dim);\n    affichePuzzle(p);\n    deleteBuffer(Buffer);\n}\n<\/code><\/pre>\n<h4>Cr\u00e9ation d&rsquo;un puzzle<\/h4>\n<pre><code class=\"language-c\">puzzle* creePuzzle(int dim);\n<\/code><\/pre>\n<p>Cr\u00e9e un puzzle de dimension <code>dim<\/code> compl\u00e8tement dans le tas. Les lettres identifiant les pi\u00e8ces sont assign\u00e9es aux pi\u00e8ces dans l&rsquo;ordre <code>'A'<\/code>, <code>'B'<\/code>, <code>'C'<\/code>, etc. Les couleurs des cot\u00e9s des pi\u00e8ces sont assign\u00e9es \u00e0 &lsquo;#&rsquo;. Leur valeurs d\u00e9finitives seront d\u00e9termin\u00e9es par la fonction de g\u00e9n\u00e9ration d&rsquo;une solution al\u00e9atoire.<\/p>\n<pre><code class=\"language-c\">void genRandPuzzle(puzzle* p, int nCouleurs);\n<\/code><\/pre>\n<p>Cette fonction accepte en param\u00e8tre l&rsquo;adresse d&rsquo;un puzzle existant ayant \u00e9t\u00e9 cr\u00e9\u00e9 par la fonction <code>creePuzzle<\/code> et assigne les valeurs des cot\u00e9 des pi\u00e8ces de mani\u00e8re \u00e0 former une solution al\u00e9atoire. Le param\u00e8tre <code>nCouleurs<\/code> donne le nombre de valeurs possibles pour les cot\u00e9s. Par exemple, si <code>nCouleurs<\/code> vaut 4, alors les valeurs \u00e0 utiliser sont <code>'1'<\/code>, <code>'2'<\/code>, <code>'3'<\/code>, et <code>'4'<\/code>.<\/p>\n<p>La configuration produite doit \u00eatre aussi al\u00e9atoire que possible mais sans discordance. Vous devzz trouver un algorithme appropri\u00e9.<\/p>\n<pre><code class=\"language-c\">void deletePuzzle(puzzle* p);\n<\/code><\/pre>\n<p>Lib\u00e8re toute la m\u00e9moire occup\u00e9e par le puzzle d\u00e9sign\u00e9 par <code>p<\/code>.<\/p>\n<h4>Brouillage d&rsquo;un puzzle<\/h4>\n<p>La fonction <code>genRandPuzzle<\/code> vue pr\u00e9c\u00e9demment remplit un puzzle avec une solution al\u00e9atoire. Il faut appliquer \u00e0 chaque pi\u00e8ce, al\u00e9atoirement, entre 0 et trois rotations de 90 degr\u00e9s pour obtenir une configuration de d\u00e9part du jeu. C&rsquo;est le but de la fonction <code>brouillePuzzle<\/code>. Voici les fonctions \u00e0 r\u00e9aliser pour bien d\u00e9composer l&rsquo;op\u00e9ration de brouillage.<\/p>\n<pre><code class=\"language-c\">void tournePiece(piece* m);\n<\/code><\/pre>\n<p>Tourne la pi\u00e8ce d\u00e9sign\u00e9e par <code>m<\/code> de 90 degr\u00e9s dans le sens horaire. L&rsquo;ancienne valeur du cot\u00e9 haut devient celle de droite, l&rsquo;ancienne de droite celle du bas, etc.<\/p>\n<pre><code class=\"language-c\">void randTournePiece(piece* m)\n<\/code><\/pre>\n<p>R\u00e9alise al\u00e9atoirement de 0 \u00e0 3 rotations de 90 degr\u00e9s de la pi\u00e8ce d\u00e9sign\u00e9e par <code>m<\/code>.<\/p>\n<pre><code class=\"language-c\">void brouillePuzzle(puzzle* p);\n<\/code><\/pre>\n<p>R\u00e9alise un rotation al\u00e9atoire de chacune des pi\u00e8ces du puzzle d\u00e9sign\u00e9 par <code>p<\/code>.<\/p>\n<h4>Calcul du nombre de discordances<\/h4>\n<pre><code class=\"language-c\">int nbDiscord(puzzle* p)\n<\/code><\/pre>\n<p>Retourne le nombre de discordances du puzzle d\u00e9sign\u00e9 par <code>p<\/code>.<\/p>\n<h4>Boucle de jeu<\/h4>\n<p>La fonction qui encha\u00eene les tours de jeu vous est donn\u00e9e. Si les fonctions pr\u00e9c\u00e9dentes ont \u00e9t\u00e9 correctement programm\u00e9es, vous pouvez donc imm\u00e9diatement tester le jeu. Vous pouvez modifier cette fonction, par exemple pour que le jeu s&rsquo;arr\u00eate et affiche <code>&quot;Victoire&quot;<\/code> quand une solution est trouv\u00e9e, ou encore pour que le nombre de coups pour trouver la solution soit affich\u00e9 \u00e0 la fin de la partie.<\/p>\n<p>La fonction auxiliaire <code>condChar<\/code> v\u00e9rifie qu&rsquo;un caract\u00e8re d\u00e9signe bien une pi\u00e8ce, et le cas \u00e9ch\u00e9ant transforme une lettre minuscule en majuscule. La valeur du caract\u00e8re est remplac\u00e9e par 0 s&rsquo;il ne d\u00e9signe pas une pi\u00e8ce du puzzle.<\/p>\n<pre><code class=\"language-c\">void condChar(unsigned char* c, int dim)\n{\n    unsigned char cMax = 'A' + dim*dim - 1;\n    if((*c&gt;='a')&amp;&amp;(*c&lt;='z'))\n    {\n        *c = *c + 'A'-'a';\n    }\n    if((*c&lt;'A')||(*c&gt;cMax))\n    {\n        *c = 0;\n    }\n}\n<\/code><\/pre>\n<pre><code class=\"language-c\">void runJeu(int dim, nCols)\n{\n    Buffer = creeBuffer(3 * dim, 6 * dim);\n    unsigned char cIn;\n    puzzle* p = creePuzzle(dim);\n    genRandPuzzle(p, nCols);\n    brouillePuzzle(p);\n    printf(&quot;\\n\\n\\n\\n\\n&quot;);\n    affichePuzzle(p);\n    printf(&quot;%d discordances\\n&quot;, nbDiscord(p));\n    cIn = saisiChar();\n    condChar(&amp;cIn, dim);\n\n    while(cIn != 0)\n    {\n        int rang = cIn-'A';\n        int i = rang\/dim;\n        int j = rang%dim;\n        tournePiece(&amp;(p-&gt;tab[i][j]));\n        printf(&quot;\\n\\n\\n\\n\\n&quot;);\n        affichePuzzle(p);\n        printf(&quot;%d discordances\\n&quot;, nbDiscord(p));\n        cIn = saisiChar();\n        condChar(&amp;cIn, dim);\n    }\n    deletePuzzle(p);\n    deleteBuffer(Buffer);\n}\n<\/code><\/pre>\n<p>Il reste \u00e0 compl\u00e9ter le programme avec une fonction principale qui lance la boucle de jeu. Dans l&rsquo;exemple suivant, le puzzle est de dimension 2 et les cot\u00e9s des pi\u00e8ces peuvent avoir 4 valeurs.<\/p>\n<pre><code class=\"language-c\">int main()\n{\n    srand(time(NULL));\n    runJeu(2,4);\n    return 0;\n}\n<\/code><\/pre>\n<hr>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-364","post","type-post","status-publish","format-standard","hentry","category-c-et-cpp","entry"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/364","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/comments?post=364"}],"version-history":[{"count":6,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/364\/revisions"}],"predecessor-version":[{"id":398,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/364\/revisions\/398"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=364"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=364"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=364"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}