Génération d'un labyrinthe amovible en C Fermé

Question

Bonjour, tout d'abord j'aimerais vous souhaitez une joyeuse et bonne année.

Je suis étudiant en école d'ingénieur et je débute dans la programmation en C. Avec mes camarades, nous avons pour projet d'informatique de réaliser le jeu du Labyrinthe en C. Malheureusement, nous bloquons depuis 2 semaines sur la génération du labyrinthe. En effet, le labyrinthe est composé de 49 tuiles, donc un plateau 7x7, dont 16 sont fixes et 33 sont généré aléatoirement (une tuile correspond à un couloir de labyrinthe). Ainsi, nous avons tout essayé que ce soit juste un tableau, un tableau de structure, etc... mais nous arrivons à rien. Nous demandons donc de l'aide pour réaliser ce projet.

Nous n'attendons surtout pas qu'on nous donne le code tout fait mais juste la manière pour réaliser ce projet car nous n'avons réellement aucune idée.

Voici le sujet pour mieux comprendre:

Ebumiii · Accepted Answer

Ok c'est bon j'ai enfin réussi

void afficher_une_tuile_coord_ecran(struct point debut_tuile,
                                    int dessin[3][3], char contenance) {
    int temp = debut_tuile.y;
    for(int li = 0; li < 3; li++){
        for(int co = 0; co < 3; co++){
            gotoligcol(debut_tuile.x,debut_tuile.y);
            if (li == 1 && co == 1){
                Color(0,11);
                printf("%c", contenance);
            }
            else if(dessin[li][co] == 1){
                Color(12,12);
                printf("%d", dessin[li][co]);
            }
            else if(dessin[li][co] != 1) {
                Color(11,11);
                printf("%d", dessin[li][co]);
            }
            debut_tuile.y = debut_tuile.y + 1;
        }
        debut_tuile.x = debut_tuile.x + 1;
        debut_tuile.y = temp;
    }
}

J'ai testé ma fonction avec ton exemple pour l'affichage de la tuile restante et cela à bien marcher.

Dalfab · Answer

Bonjour,

Je ne vois pas ce qui vous bloque. Un exemple avec un tableau de structure et des enum pour une lecture/écriture du code plus simple.

enum OrientedTile {
   OT_TT = 1+2+4,   // 1 peut aller à gauche
   OT_T1 = 2+4+8,   // 2 peut aller en bas
   OT_T2 = 1+4+8,   // 4 peut aller à droite
   OT_T3 = 1+2+8,   // 8 peut aller en haut
   OT_LL = 4+8,
   OT_L1 = 1+8,
   OT_L2 = 1+2,
   OT_L3 = 2+4,
   OT_II = 2+8,
   OT_I1 = 1+4,
};
enum Contains {
   Nothing,
   Token1,
   Token2,
   Token3,
   Token4,
   Gift,
};
struct Cell {
   enum OrientedTile  tile;
   enum Contains      contains;
};

int  main() {
   struct Cell  board[7][7];
   board[0][0] = (struct Cell){OT_L3,Token1};
   board[0][2] = (struct Cell){OT_TT,Gift};
   board[0][4] = (struct Cell){OT_TT,Gift};
   board[0][6] = (struct Cell){OT_L2,Token2};
   board[2][0] = (struct Cell){OT_T1,Gift};
   ... ...

// remplir avec 6  parmi {x, Gift} avec x=OT_TT OT_T1 OT_T2 ou OT_T3
   // remplir avec 6  parmi {x, Gift} avec x=OT_LL OT_L1 OT_L2 ou OT_L3
   // remplir avec 10 parmi {x, Nothing} avec x=OT_LL OT_L1 OT_L2 ou OT_L3
   // remplir avec 12 parmi {x, Nothing} avec x=OT_II ou OT_I1
};

J'ai donné des valeurs choisies aux tuiles, ce nombre devrait permettre de:
- les dessiner
- gérer le moment où les pions devront se déplacer parmi les tuiles.

[Dal] · Answer

Salut Dalfab, Salut Ebumiii,

J'ai l'impression que l'on ne dispose pas de l'énoncé en entier, car le but et principe du jeu ne sont pas vraiment décrits.

Il semble clair que les tuiles en L ou en T peuvent être orientées n'importe comment avant que le "Labyrinthe" ne soit créé en disposant les tuiles selon les règles prévues.

Au sujet de la 50ème tuile, qui peut être insérée par un joueur à un bout et qui résulte en l'expulsion de la tuile opposée, il est probable que, selon le but et principe du jeu (que l'on ne connaît pas) le joueur ait la possibilité de décider de l'orientation de la pièce avant de l'insérer (un peu comme une pièce de Tetris).

Dans ce cas, un moyen plus commode de déterminer l'orientation pourrait être pratique. Le fait que des déplacements soient possibles vers le haut, le bas, la gauche ou la droite n'est pas utilisé dans l'état de l'énoncé communiqué (c'est peut être dans une partie de l'énoncé qu'on n'a pas), mais en tout état de cause, cela peut se déduire de la forme et de l'orientation.

Alors, je proposerais un type struct tuile :

qui indique la forme de la tuile (fixe) : L ou T
	qui indique l'orientation (variable, sauf pour les 16 tuiles inamovibles) : Nord, Ouest, Sud, Est
	qui indique si elle est vide, ou si elle contient quelque chose (fixe)

On peut effectivement utiliser des types enum pour ces 3 attributs.

Avec cela, on peut créer un tableau qui recense exhaustivement les 50 tuiles, avec leurs attributs, en mettant, par exemple, les 16 tuiles dont la position et orientation est fixe en début. Les 34 tuiles qui suivent pourraient être mélangées après avoir été exhaustivement insérées (mélange de Fisher-Yates) et leur orientation initiale choisie au hasard.

Un deuxième tableau à 2 dimensions de 7 x 7 peut alors servir à stocker les tuiles dans le tableau de jeu.

Au lieu de stocker les tuiles dans le tableau de jeu, on peut d'ailleurs stocker les indices des éléments du tableau de 50 tuiles. Cela sera plus efficace de décaler des entiers (indices) stockés dans le tableau de jeu de 7 x 7 lorsqu'il s'agira d'insérer une tuile à "une extrémité", plutôt que des struct (quoique le C assure bien l'affectation de types struct).

Il y a une autre difficulté dans (la dernière partie de) l'énoncé (qui nous est montré), qui est l'affichage en mode console.

Selon l'exemple d'affichage de l'énoncé, une tuile nécessitant pour un affichage 4 lignes (3 lignes pour la dessiner et une ligne séparatrice) sur 4 colonnes (3 colonnes pour la dessiner et une colonne séparatrice), un affichage ligne par ligne permis par le C standard suppose de "composer" le dessin d'une des 7 lignes en 4 lignes de 28 caractères correspondant visuellement aux éléments composant chacune les 7 tuiles de cette ligne du tableau de jeu. C'est un peu coton à faire, mais une fonction à laquelle on passe le tableau de jeu, le tableau de pièces, le numéro de la ligne à afficher et la ligne de terminal la composant à afficher, devrait pouvoir faire cela.

On peut même écrire des tests unitaires si la fonction renvoie la chaîne à afficher pour chaque ligne de terminal.

:-)

Ebumiii · Answer

Salut Dal,

Merci pour ton aide. Voici ce que nous avons réussie pour l'instant.

#include <stdio.h>

enum OrientationTuile {
    Nord,
    Ouest,
    Sud,
    Est,
};

enum Forme {
    L,
    T,
    I,
};

enum Contenance{
    Tresor,
    Vide,
    Pion1,
    Pion2,
    Pion3,
    Pion4,
};

struct Tuile {
    enum OrientationTuile tuile;
    enum Forme forme;
    enum Contenance contenance;
};

int main() {

struct Tuile tab[50];
    tab[0] = (struct Tuile) {Ouest,L,Pion1};
    tab[1] = (struct Tuile) {Nord,T,Tresor};
    tab[2] = (struct Tuile) {Nord,T,Tresor};
    tab[3] = (struct Tuile) {Sud,L,Pion2};
    tab[4] = (struct Tuile) {Est,T,Tresor};
    tab[5] = (struct Tuile) {Est,T,Tresor};
    tab[6] = (struct Tuile) {Nord,T,Tresor};
    tab[7] = (struct Tuile) {Ouest,T,Tresor};
    tab[8] = (struct Tuile) {Est,T,Tresor};
    tab[9] = (struct Tuile) {Sud,T,Tresor};
    tab[10] = (struct Tuile) {Ouest,T,Tresor};
    tab[11] = (struct Tuile) {Ouest,T,Tresor};
    tab[12] = (struct Tuile) {Nord,L,Pion3};
    tab[13] = (struct Tuile) {Sud,T,Tresor};
    tab[14] = (struct Tuile) {Sud,T,Tresor};
    tab[15] = (struct Tuile) {Est,L,Pion4};

for(int i = 16; i<50; i++){
        tab[i] = (struct Tuile)
    }

return 0;
}

Comme tu peux l'apercevoir, nous bloquons sur le premier tableau de 50 tuiles où l'on dois placer dans les 16 premières les tuiles fixes et pour le reste les tuiles aléatoires. Peux-tu nous expliquer comment réaliser cela plus précisément (avec un code par exmple) car malgré tes explications concises, comme nous débutons dans la programmation, nous avons du mal à tout comprendre.

Voici le reste du sujet qui te permettra peut-être à mieux comprendre.

Merci beaucoup de votre aide.

Dalfab · Answer

Le problème ici est de voir comment des données mélangées peuvent être placées dans la table 7x7, tout en cohabitant avec des tuiles qui ont une position déterminée.

Il y a plein de manières, certaines compliquées d'autres plus simples.

J'étais plutôt parti sur un remplissage de la grille 7x7 avec :
- on la remplit entièrement avec l'indication pour chaque tuile comme étant ni T ni L ni I (c'était la valeur 0 de mon enum OrientedTile)
- on met les bonnes tuiles aux bonnes positions
- donc toutes les autres sont pour le moment dans l'état : ni T, ni L, ni I.
Puis dans un autre tableau linéaire rempli avec les 50-16 tuiles choisies en fonction des critères autorisées dans l'ordre des critères.
Puis cet autre tableau est mélangé.
Il reste à recopier en parcourant toutes les cases de la grille 7x7 et identifiant celles qui sont dans l'état ni L ni T ni I, pour les remplacer successivement par celle du tableau mélangé.
Il va alors rester la dernière du tableau mélangé qui sera la tuile de plus pour débuter le jeu.

Pour utiliser la méthode indiquée par Dal, on peut trouver une "bijection" (désolé pour le gros mot) entre les indices du tableau linéaire à 50 éléments et la grille 7x7. C'est faisable. On voit que les tuiles fixes sont celles qui ont à la fois i et j qui sont pairs (et donc pour k l'indice dans le tableau tab, k <= 15), les mélangeables ont soit i soit j qui est impair et un k >= 16. La tuile k=49 ne correspondant à aucun (i,j), c'est la tuile pour débuter le jeu.

Un autre moyen partant du code de Dal. On peut directement considérer que le tableau tab est aussi la grille 7x7 + 1 élément. C'est selon moi la solution la plus simple, mais me parait difficile à trouver quand on débute.
L'indice dans tab est directement 7*j+i. On utilise la "formule" 7*j+i pour accéder à une case de la grille 7x7
Après avoir fait le mélange des éléments 16 à 49, on a les éléments de 1 à 15 qui ne sont pas à leur place.
Il suffit de faire un échange avec l'élément qui a leur place attendue par exemple:

tmp = tab[1];  tab[1] = tab[0*7+2];  tab[0*7+2] = tmp; // seconde tuile à sa place
tmp = tab[2];  tab[2] = tab[0*7+4];  tab[0*7+4] = tmp; // troisième tuile à sa place
...

Il y a certainement d'autres manières de faire.

Ebumiii · Answer

Bonjour, voici ce que nous avons réalisé en suivant vos instructions: #include #include #include enum OrientationTuile { NORD, OUEST, SUD, EST, MAX_ORIENTATION_TUILE }; enum Forme { FORME_L, FORME_T, FORME_I, }; #define CASE_VIDE ' ' #define CASE_PION1 '1' #define CASE_PION2 '2' #define CASE_PION3 '3' #define CASE_PION4 '4' #define CASE_TRESOR1 'A' struct Tuile { enum OrientationTuile orientation; enum Forme forme; char contenance; }; void swap(struct Tuile tab[], int i, int j) { struct Tuile temp[1]; temp[0] = tab[i]; tab[i] = tab[j]; tab[j] = temp[0]; } void melanger(struct Tuile tab[], int n) { for (int i = 16; i <= n - 2; i++) { int j = i + rand() % (n - i); swap(tab, i, j); } } int main(void) { srand(time(NULL)); struct Tuile tab[50]; char tresor = CASE_TRESOR1; tab[0] = (struct Tuile) {OUEST, FORME_L, CASE_PION1}; tab[1] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[2] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[3] = (struct Tuile) {SUD, FORME_L, CASE_PION2}; tab[4] = (struct Tuile) {EST, FORME_T, tresor++}; tab[5] = (struct Tuile) {EST, FORME_T, tresor++}; tab[6] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[7] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[8] = (struct Tuile) {EST, FORME_T, tresor++}; tab[9] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[10] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[11] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[12] = (struct Tuile) {NORD, FORME_L, CASE_PION3}; tab[13] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[14] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[15] = (struct Tuile) {EST, FORME_L, CASE_PION4}; /* * Selon l'énoncé, il faut ensuite : * - 6 tuiles T avec trésor que l'on met en positions 16 à 21 * - 6 tuiles L avec trésor que l'on met en positions 22 à 27 * - 10 tuiles L sans trésor que l'on met en positions 28 à 37 * - 12 tuiles I sans trésor que l'on met en positions 38 à 49 */ /* 6 tuiles T avec trésor que l'on met en positions 16 à 21 */ for (int i = 16; i < 22; i++) { tab[i].forme = FORME_T; tab[i].contenance= tresor++; tab[i].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int j = 22; j < 28; j++) { tab[j].forme = FORME_L; tab[j].contenance = tresor++; tab[j].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int k = 28; k < 38; k++){ tab[k].forme = FORME_L; tab[k].contenance = CASE_VIDE; tab[k].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int l = 38; l < 50; l++){ tab[l].forme = FORME_I; tab[l].contenance = CASE_VIDE; tab[l].orientation = rand() % MAX_ORIENTATION_TUILE; } int n = 50; melanger(tab, n); struct Tuile plateau[7][7]; /* Tuile fixe */ plateau[0][0] = tab[0]; plateau[0][2] = tab[1]; plateau[0][4] = tab[2]; plateau[0][6] = tab[3]; plateau[2][0] = tab[4]; plateau[2][2] = tab[5]; plateau[2][4] = tab[6]; plateau[2][6] = tab[7]; plateau[4][0] = tab[8]; plateau[4][2] = tab[9]; plateau[4][4] = tab[10]; plateau[4][6] = tab[11]; plateau[6][0] = tab[12]; plateau[6][2] = tab[13]; plateau[6][4] = tab[14]; plateau[6][6] = tab[15]; /* Tuile aleatoire */ plateau[0][1] = tab[16]; plateau[0][3] = tab[17]; plateau[0][5] = tab[18]; plateau[1][0] = tab[19]; plateau[1][1] = tab[20]; plateau[1][2] = tab[21]; plateau[1][3] = tab[22]; plateau[1][4] = tab[23]; plateau[1][5] = tab[24]; plateau[1][6] = tab[25]; plateau[2][1] = tab[26]; plateau[2][3] = tab[27]; plateau[2][5] = tab[28]; plateau[3][0] = tab[29]; plateau[3][1] = tab[30]; plateau[3][2] = tab[31]; plateau[3][3] = tab[32]; plateau[3][4] = tab[33]; plateau[3][5] = tab[34]; plateau[3][6] = tab[35]; plateau[4][1] = tab[36]; plateau[4][3] = tab[37]; plateau[4][5] = tab[38]; plateau[5][0] = tab[39]; plateau[5][1] = tab[40]; plateau[5][2] = tab[41]; plateau[5][3] = tab[42]; plateau[5][4] = tab[43]; plateau[5][5] = tab[44]; plateau[5][6] = tab[45]; plateau[6][1] = tab[46]; plateau[6][3] = tab[47]; plateau[6][5] = tab[48]; struct Tuile restant; restant = tab[49]; return 0; } Grace à l'aide de Dal, nous avons crée un tableau de 50 structures avec les 16 premières valeurs représentant les tuiles fixes et les 34 restantes qu'on a mélangé grâce à une fonction permettant de reproduire le mélange de Fisher-Yates (on la fonction de ce site: https://www.techiedelight.com/fr/shuffle-given-array-elements-fisher-yates-shuffle/ ). Désormais, on possède le tableau avec les 50 structures dans les bonnes conditions, on a tout simplement affecter chaque case du tableau à deux dimension 7x7 par celle qui lui correspond (ce n'est pas jolie mais c'est ce qui nous a paru le plus simple à faire). Ainsi, on suppose qu'on a le plateau grâce au tableau à deux dimensions mais à partir de ce moment on ne sait pas trop comment afficher plateau. Nous n'avons pas aussi trop compris l'utilisation à multiple reprise de trésor++, en effet est ce que nous devons pas plutôt crée plusieurs #define CASE_TRESORN (N allant de 1 à 24) représentant chacun une lettre de A à X où le fait de mettre trésor++ permet directement de faire cela. Pour l'affichage du plateau, il n'est pas obligé de faire les lignes séparatrices (c'est facultatif), on pense aussi que cela peut compliqué les choses de rajouter les lignes séparatrices. Pour les couleurs, on nous demande d'utiliser la fonction COLOR, on nous donne directement le programme permettant d'utiliser cette fonction. #include #include #include /////////// PROTOTYPES DES SOUS-PROGRAMMES void Color(int couleurDuTexte,int couleurDeFond); /////////////////////////////////////// // Nom du sous-programme : COLOR // Rôle : change la couleur du texte dans la console, ainsi que la couleur du fond pour la ligne // Compatibilité : windows XP /////////////////////////////////////// void Color(int couleurDuTexte,int couleurDeFond) // fonction d'affichage de couleurs { HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(H,couleurDeFond*16+couleurDuTexte); } int main() { printf("Hello world! "); /* 0 : Noir 1 : Bleu foncé 2 : Vert foncé 3 : Turquoise 4 : Rouge foncé 5 : Violet 6 : Vert caca d'oie 7 : Gris clair 8 : Gris foncé 9 : Bleu fluo 10 : Vert fluo 11 : Turquoise 12 : Rouge fluo 13 : Violet 2 14 : Jaune 15 : Blanc */ // essai numero 1 Color(12,3); printf("Le texte va avoir la couleur 12 et le Fond la couleur 3 "); // essai numero 2 : on repasse au noir et blanc Color(15, 0); printf("Hello world! "); // essai 3 : un peu de turquoise Color(11, 0); printf("Hello world! "); // et la derniere couleur reste jusqu'à ce qu'on change de nouveau printf("Hello world! "); //... return 0; } Il nous ait aussi donné une fonction de manipulation de curseur à l'écran. Mais cela nous parait pas important pour l'instant . #include void gotoligcol( int lig, int col ) { // ressources COORD mycoord; mycoord.X = col; mycoord.Y = lig; SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), mycoord ); } int main () { // exemple d'appel au niveau du main // .... gotoligcol(5,15); // place le curseur ligne 5 colonne 15 à l'écran printf("bonjour"); // et écrit bonjour à cet endroit return 0; } On vous remercie pour le temps que vous prenez pour nous aider, on vous est réellement reconnaissant. :)

Ebumiii · Answer

Bonjour Dal,

On a compris ce que tu nous as envoyé et effectivement l'utilisation des pointeurs nous parait plus simple pour la suite programme (on a eu que quelque cours sur les pointeurs). Cependant, on a toujours du mal à savoir comment afficher une tuile selon les informations d'une structure.

On pense, qu'il faut crée plusieurs tableaux d'entier soit à deux dimensions 3x3 ou un simple tableau de 9 cases où on sautera une ligne toute les 3 valeurs. En effet , on suppose qu'à partir de cela on fait plusieurs if avec pour condition les valeurs de la structure lu en paramètre (on réalise tout ca dans une fonction qu'on nommera afficher_tuile() pour ne pas le réécrire). Ainsi, on réalisera cette fonction 49 fois pour obtenir le plateau en entier.

Exemple:

int une_tuile[3][3];

if (tab[] = (struct Tuile) {OUEST, FORMe_L, CASE_PION1}){ 
    une_tuile[0][0] = 254;
    une_tuile[0][1] = 254;
    une_tuile[0][2] = 254;
    une_tuile[1][0] = 254;
    une_tuile[1][1] = 254;
    une_tuile[1][2] = 254;
    une_tuile[2][0] = 254;
    une_tuile[2][1] = 254;
    une_tuile[2][2] = 254;
}

else if(tab[]= (struct Tuile) {Nord, FORME_L,CASE_PION1}) {

...etc

254 représentant un carré noir en ASCII et 255 le vide. Mais on ne sait pas comment placé les trésors.

Voilà, c'est ce que nous pensons faire pour générer le labyrinthe mais il y a des fortes chances que cela ne sois pas ça.

Sachant que nous faisons de la programmation que depuis 2 mois, nous avons du mal à avoir la théorie pour réaliser les programmes. On bloque énormément sur des choses qui puissent vous paraître simple mais qui ne sont pas évidentes pour nous. Donc merci pour l'aide que tu nous apportes.

Ebumiii · Answer

Salut Dal, voici notre progression: #include #include #include #include #define CASE_VIDE ' ' #define CASE_PION1 '1' #define CASE_PION2 '2' #define CASE_PION3 '3' #define CASE_PION4 '4' #define CASE_TRESOR1 'A' void Color(int couleurDuTexte,int couleurDeFond) // fonction d'affichage de couleurs { HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(H,couleurDeFond*16+couleurDuTexte); } void gotoligcol( int lig, int col ) { COORD mycoord; mycoord.X = col; mycoord.Y = lig; SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), mycoord ); } enum OrientationTuile { NORD, OUEST, SUD, EST, MAX_ORIENTATION_TUILE }; enum Forme { FORME_L, FORME_T, FORME_I, }; struct Tuile { enum OrientationTuile orientation; enum Forme forme; char contenance; }; void swap(struct Tuile tab[], int i, int j) { struct Tuile temp[1]; temp[0] = tab[i]; tab[i] = tab[j]; tab[j] = temp[0]; } void melanger_a_partir_de_16(struct Tuile tab[], int n) { for (int i = 16; i <= n - 2; i++) { int j = i + rand() % (n - i); swap(tab, i, j); } } void tourner_L_NORD(int tuile_en_L[3][3]){ tuile_en_L[0][0] = 1; tuile_en_L[0][1] = 0; tuile_en_L[0][2] = 0; tuile_en_L[1][0] = 1; tuile_en_L[1][2] = 0; tuile_en_L[2][0] = 1; tuile_en_L[2][1] = 1; tuile_en_L[2][2] = 1; } void tourner_L_OUEST(int tuile_en_L[3][3]){ tuile_en_L[0][0] = 1; tuile_en_L[0][1] = 1; tuile_en_L[0][2] = 1; tuile_en_L[1][0] = 1; tuile_en_L[1][2] = 0; tuile_en_L[2][0] = 1; tuile_en_L[2][1] = 0; tuile_en_L[2][2] = 0; } void tourner_L_SUD(int tuile_en_L[3][3]){ tuile_en_L[0][0] = 1; tuile_en_L[0][1] = 1; tuile_en_L[0][2] = 1; tuile_en_L[1][0] = 0; tuile_en_L[1][2] = 1; tuile_en_L[2][0] = 0; tuile_en_L[2][1] = 0; tuile_en_L[2][2] = 1; } void tourner_L_EST(int tuile_en_L[3][3]){ tuile_en_L[0][0] = 0; tuile_en_L[0][1] = 0; tuile_en_L[0][2] = 1; tuile_en_L[1][0] = 0; tuile_en_L[1][2] = 1; tuile_en_L[2][0] = 1; tuile_en_L[2][1] = 1; tuile_en_L[2][2] = 1; } void tourner_T_NORD(int tuile_en_T[3][3]){ tuile_en_T[0][0] = 1; tuile_en_T[0][1] = 1; tuile_en_T[0][2] = 1; tuile_en_T[1][0] = 0; tuile_en_T[1][2] = 0; tuile_en_T[2][0] = 1; tuile_en_T[2][1] = 0; tuile_en_T[2][2] = 1; } void tourner_T_OUEST(int tuile_en_T[3][3]){ tuile_en_T[0][0] = 1; tuile_en_T[0][1] = 0; tuile_en_T[0][2] = 1; tuile_en_T[1][0] = 0; tuile_en_T[1][2] = 1; tuile_en_T[2][0] = 1; tuile_en_T[2][1] = 0; tuile_en_T[2][2] = 1; } void tourner_T_SUD(int tuile_en_T[3][3]){ tuile_en_T[0][0] = 1; tuile_en_T[0][1] = 0; tuile_en_T[0][2] = 1; tuile_en_T[1][0] = 0; tuile_en_T[1][2] = 0; tuile_en_T[2][0] = 1; tuile_en_T[2][1] = 1; tuile_en_T[2][2] = 1; } void tourner_T_EST(int tuile_en_T[3][3]){ tuile_en_T[0][0] = 1; tuile_en_T[0][1] = 0; tuile_en_T[0][2] = 1; tuile_en_T[1][0] = 1; tuile_en_T[1][2] = 0; tuile_en_T[2][0] = 1; tuile_en_T[2][1] = 0; tuile_en_T[2][2] = 1; } void tourner_I_NORD(int tuile_en_I[3][3]){ tuile_en_I[0][0] = 1; tuile_en_I[0][1] = 0; tuile_en_I[0][2] = 1; tuile_en_I[1][0] = 1; tuile_en_I[1][2] = 1; tuile_en_I[2][0] = 1; tuile_en_I[2][1] = 0; tuile_en_I[2][2] = 1; } void tourner_I_OUEST(int tuile_en_I[3][3]){ tuile_en_I[0][0] = 1; tuile_en_I[0][1] = 1; tuile_en_I[0][2] = 1; tuile_en_I[1][0] = 0; tuile_en_I[1][2] = 0; tuile_en_I[2][0] = 1; tuile_en_I[2][1] = 1; tuile_en_I[2][2] = 1; } int main(void) { srand(time(NULL)); struct Tuile tab[50]; char tresor = CASE_TRESOR1; tab[0] = (struct Tuile) {OUEST, FORME_L, CASE_PION1}; tab[1] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[2] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[3] = (struct Tuile) {SUD, FORME_L, CASE_PION2}; tab[4] = (struct Tuile) {EST, FORME_T, tresor++}; tab[5] = (struct Tuile) {EST, FORME_T, tresor++}; tab[6] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[7] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[8] = (struct Tuile) {EST, FORME_T, tresor++}; tab[9] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[10] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[11] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[12] = (struct Tuile) {NORD, FORME_L, CASE_PION3}; tab[13] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[14] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[15] = (struct Tuile) {EST, FORME_L, CASE_PION4}; for (int i = 16; i < 22; i++) { tab[i].forme = FORME_T; tab[i].contenance= tresor++; tab[i].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int j = 22; j < 28; j++) { tab[j].forme = FORME_L; tab[j].contenance = tresor++; tab[j].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int k = 28; k < 38; k++){ tab[k].forme = FORME_L; tab[k].contenance = CASE_VIDE; tab[k].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int l = 38; l < 50; l++){ tab[l].forme = FORME_I; tab[l].contenance = CASE_VIDE; tab[l].orientation = rand() % MAX_ORIENTATION_TUILE; } int n = 50; melanger_a_partir_de_16(tab, n); /* Initialisation à 0 du tableau de jeu */ int plateau[7][7]; for (int i = 0; i < 7; i++) { for (int j = 0; j < 7; j++) { plateau[i][j] = 0; } } /* Tuiles fixes sur le tableau de jeu */ plateau[0][0] = 0; plateau[0][2] = 1; plateau[0][4] = 2; plateau[0][6] = 3; plateau[2][0] = 4; plateau[2][2] = 5; plateau[2][4] = 6; plateau[2][6] = 7; plateau[4][0] = 8; plateau[4][2] = 9; plateau[4][4] = 10; plateau[4][6] = 11; plateau[6][0] = 12; plateau[6][2] = 13; plateau[6][4] = 14; plateau[6][6] = 15; /* Tuiles aleatoires : les emplacements vides sont ceux contenant * zéro, à l'exception de celui aux coordonnées 0,0 qui représente * l'index 0 du tableau de tuiles */ int itab = 16; for (int i = 0; i < 7; i++) for (int j = 0; j < 7; j++) { if (i == 0 && j == 0) continue; if (plateau[i][j] == 0) plateau[i][j] = itab++; } int restant = 49; int tuile_en_L[3][3] = { {1,0,0}, {1,0,0}, {1,1,1}, }; int tuile_en_T[3][3] = { {1,1,1}, {0,0,0}, {1,0,1}, }; int tuile_en_I[3][3] = { {1,0,1}, {1,0,1}, {1,0,1}, }; struct Tuile temp; temp = tab[1]; tab[1] = tab[plateau[0][1]]; tab[plateau[0][1]] = temp; temp = tab[1]; tab[1] = tab[plateau[0][1]]; tab[plateau[0][1]] = temp; //etc ... } Mais nous constatons que c'est beaucoup trop long, et nous n'avons pas réussi à réaliser ton repère dans le tableau 3x3 permettant d'afficher les bonnes tuiles. Nous sommes vraiment perdu sur la suite sachant que devons rendre le code de l'affichage dimanche nous sommes vraiment inquiet. Pourrais tu, s'il te plaît, nous réaliser le code juste pour l'affichage du plateau. Nous savons qu'on est à rien de le réaliser mais malheureusement, on n'a pas la théorie pour réaliser cela. Donc, nous te supplions de nous aider malgré toute l'aide que tu nous as déjà fournis. Bonne soirée.

[Dal] · Answer

Salut Ebumiii,

Le forum ne sert pas, en principe à faire faire le travail par d'autres.

Voilà cependant quelques indications.

En faisant des tests sur ton jeu de données, je pense qu'il y a des erreurs, à mon sens, dans ton initialisation de l'orientation de certaines des 16 tuiles fixes.

Si on suit l'ordre de l'enum orientation, les rotations sont antihoraires : Nord, Ouest, Sud, Est. Ce sont des rotations successives de la tuile orientée Nord de -90 degrés (un quart de tour vers la gauche, autour de l'origine qui est au centre du carré de 3x3).

Je ferais donc plutôt cela :

tab[0] =  (struct Tuile) {EST,   FORME_L, CASE_PION1};
        tab[1] =  (struct Tuile) {NORD,  FORME_T, tresor++};
        tab[2] =  (struct Tuile) {NORD,  FORME_T, tresor++};
        tab[3] =  (struct Tuile) {SUD,   FORME_L, CASE_PION2};
        tab[4] =  (struct Tuile) {OUEST,   FORME_T, tresor++};
        tab[5] =  (struct Tuile) {OUEST,   FORME_T, tresor++};
        tab[6] =  (struct Tuile) {NORD,  FORME_T, tresor++};
        tab[7] =  (struct Tuile) {EST, FORME_T, tresor++};
        tab[8] =  (struct Tuile) {OUEST,   FORME_T, tresor++};
        tab[9] =  (struct Tuile) {SUD,   FORME_T, tresor++};
        tab[10] = (struct Tuile) {EST, FORME_T, tresor++};
        tab[11] = (struct Tuile) {EST, FORME_T, tresor++};
        tab[12] = (struct Tuile) {NORD,  FORME_L, CASE_PION3};
        tab[13] = (struct Tuile) {SUD,   FORME_T, tresor++};
        tab[14] = (struct Tuile) {SUD,   FORME_T, tresor++};
        tab[15] = (struct Tuile) {OUEST,   FORME_L, CASE_PION4};

Ensuite, dans ton code, tu pars donc sur une représentation de tes formes de base de tuiles sous la forme d'un tableau de 3x3 entiers avec des 0 et des 1.

Je mettrais ces tableaux en variables globales et les nommerais de façon plus explicite pour que l'on comprenne que c'est une représentation du dessin des formes de base des tuiles, comme ceci :

int dessin_tuile_en_L[3][3] = {
        {1,0,0},
        {1,0,0},
        {1,1,1},
};

int dessin_tuile_en_T[3][3] = {
        {1,1,1},
        {0,0,0},
        {1,0,1},
};

int dessin_tuile_en_I[3][3] = {
        {1,0,1},
        {1,0,1},
        {1,0,1},
};

Une fois que tu as fait cela, tu peux écrire une fonction qui prend en paramètre une struct Tuile et renvoie le tableau représentant le dessin de base approprié pour cette tuile.

void get_dessin_de_base(int dessin[3][3], struct Tuile t) {
        int * p;
        switch (t.forme) {
                case FORME_L: p = (int *) dessin_tuile_en_L; break;
                case FORME_T: p = (int *) dessin_tuile_en_T; break;
                case FORME_I: p = (int *) dessin_tuile_en_I; break;
        }
        memcpy(dessin, p, sizeof(int) * 3 * 3);
}

C'est sur ce dessin de base ainsi récupéré que tu vas appliquer les rotations.

OK, maintenant, pour afficher ton plateau de tuiles, je ferais les fonctions suivantes, utilisant un type struct point permettant de stocker des coordonnées :

void rotation_90(int dessin[3][3]) {
        /* TODO */
}

struct point {
        int x;
        int y;
};

void afficher_une_tuile_coord_ecran(struct point debut_tuile,
                int dessin[3][3], char contenance) {
        /* TODO */
}

void afficher_une_tuile_coord_plateau(struct point debut_plateau,
                struct Tuile t, int li, int co) {
        /* TODO */
}

Pour les rotations, tu dois recenser les points qui composent chaque forme et leurs coordonnées dans un repère cartésien dont l'origine est au centre de la forme. Vois ceci pour comprendre comment calculer la transformation des coordonnées des points :

https://www.alloprof.qc.ca/fr/eleves/bv/mathematiques/les-rotations-dans-un-plan-cartesien-m1322

Dans mon cas, j'ai utilisé (x,y)↦(y,-x) pour la rotation antihoraire de 90 degrés, pour correspondre au système de coordonnées de l'écran (axe vertical inversé).

La fonction afficher_une_tuile_coord_plateau() permet d'afficher le plateau simplement en faisant ceci :

/* affichage du tableau */
        clearscrn();

struct point debut_plateau = { .x = 10, .y = 2 };
        for (int li = 0; li < 7; li++)
                for (int co = 0; co < 7; co++) {
                        afficher_une_tuile_coord_plateau(debut_plateau,
                                        tab[plateau[li][co]], li, co);
                }

/* affichage de la pièce restante */
        gotoligcol(2, 45);
        printf("tuile restante :
");
        int dessin[3][3];
        get_dessin_de_base(dessin, tab[restant]);
        afficher_une_tuile_coord_ecran(
                        (struct point) { 45, 4 },
                        dessin,
                        tab[restant].contenance);

Je me suis fait une petite fonction clearsrcn() pour effacer l'écran, une fonction faisant la même chose que gotoligcol() et une fonction gérant le mode inverse vidéo pour afficher les murs (en utilisant les séquences d'échappement des terminaux ANSI, car je suis sous Linux), et cela donne ceci à l'exécution :

Si, comme je le pense, la tuile restante peut être orientée au choix par l'utilisateur avant d'être insérée, son orientation pourrait être remise au Nord en attendant que l'utilisateur décide où l'insérer et selon quelle orientation.

Ebumiii · Answer

Salut dal,

je n'ai pas trop saisie comment on pouvais transformer le tableau en repère cartésien parce que sinon je ne vois pas comment appliqué la formule (x,y) > (y,-x) car du coup le centre du repère serait donc de coordonné (1,1).

Donc j'ai décidé d'affecter chaque valeur du tableau à celle qui lui correspond lorsqu'on effectue une rotation:

void rotation_90(int dessin[3][3]){
    int temp1, temp2;

// aucune modification pour dessin[1][1] car c'est le centre du repere

dessin[0][2] = temp1;          // rotation pour les corner des la tuile
    dessin[0][2] = dessin[2][2];
    dessin[2][2] = dessin[2][0];
    dessin[2][0] = dessin[0][0];
    dessin[0][0] = temp1;

dessin[0][1] = temp2;          // rotation pour le reste de la tuile
    dessin[0][1] = dessin[1][2];
    dessin[1][2] = dessin[2][1];
    dessin[2][1] = dessin[1][0];
    dessin[1][0] = temp2;
}

En ce qui concerne la fonction afficher_une_tuile_coord_ecran, je n'ai pas trop compris ce qu'il fallait faire, pourrais tu m'en dire un peu plus s'il te plaît.

(oui il est incroyable ton tableau :] )

Ebumiii · Answer

Mais du coup les rotations de ma fonction se font dans le sens horaire du coup faudra t-il remettre l'affectation des 16 structures du tableau comme avant ?

Ebumiii · Answer

Concernant l'affichage, voici ce que j'ai fait je ne sais pas trop si cela correspond à ce que tu as expliquer.

void afficher_une_tuile_coord_ecran(struct point debut_tuile,
                                    int dessin[3][3], char contenance) {
    gotoligcol(debut_tuile.x,debut_tuile.y);
    for(int i = 0; i < 3; i++){
        for(int j = 0; j < 3; j++){
            if (i == 1 && i == 1)
                printf("%c", contenance);
            printf("%d", dessin[i][j]);
        }
    }
}

Il y a vraiment une chose que je n'ai toujours pas comprise c'est comment on procède pour relier un les tableau dessin_tuile_en_T, dessin_tuile_en_L etc... à une structure selon ces caractérisque.

Cela concerne aussi les rotations. Je ne vois pas comment je peux les appliquer. Faut-il les faire dans le main auparavant ? Ou ici aussi il faut faire une fonction ?

Ebumiii · Answer

La tu penses que c'est bien ?

void afficher_une_tuile_coord_ecran(struct point debut_tuile,
                                    int dessin[3][3], char contenance) {
    for(int li = 0; li < 3; li++){
        for(int co = 0; co < 3; co++){
            gotoligcol(li,co);
            if (li == 1 && co == 1)
                printf("%c", contenance);
            printf("%d", dessin[li][co]);
            debut_tuile.y = co;
        }
        debut_tuile.x = li;
    }
}

je ne suis pas sur pour les affectations de debut_tuile.x et debut_tuile.y

Ebumiii · Answer

En ce qui concerne la fonction  afficher_tuile_cord_plateau je ne comprend pas pourquoi les rotations elle ne s'effectue pas et pourquoi j'ai des caractères qui s'affiche en plus de la tuile.

void afficher_une_tuile_coord_plateau(struct point debut_plateau,
                                      struct Tuile t, int li, int co) {

int dessin[3][3];

get_dessin_de_base(dessin, t);

switch (t.orientation) {
        case EST :
            rotation_90(dessin);
            break;
        case SUD :
            rotation_90(dessin);
            rotation_90(dessin);
            break;
        case OUEST:
            rotation_90(dessin);
            rotation_90(dessin);
            rotation_90(dessin);
            break;
    }

debut_plateau.x = li * 3;
    debut_plateau.y = co * 3;
    afficher_une_tuile_coord_ecran(debut_plateau,dessin,t.contenance);
}

Une deuxième version pour les rotations qui ne marche pas non plus.

void afficher_une_tuile_coord_plateau(struct point debut_plateau,
                                      struct Tuile t, int li, int co) {

int dessin[3][3];

get_dessin_de_base(dessin, t);

if (t.orientation == EST)
        rotation_90(dessin);
    if (t.orientation == SUD){
        for(int i = 0; i < 2; i++)
            rotation_90(dessin);
    }
    if (t.orientation == OUEST){
        for(int i = 0; i < 3; i++)
            rotation_90(dessin);
    }
    
    debut_plateau.x = li * 3;
    debut_plateau.y = co * 3;
    afficher_une_tuile_coord_ecran(debut_plateau,dessin,t.contenance);
}

Ebumiii · Answer

Salut Dal, tout d'abord désolé pour les questions répétitives qui ont pu t'agacer mais à force j'ai presque réaliser l'affichage du labyrinthe. J'ai passé toute la nuit à comprendre comment l'afficher désormais le plus compliqué fait j'ai un tout dernier problème, je ne comprend pourquoi j'ai des tuiles qui n'apparaisse pas sous la bonne forme. Exemple: Je ne comprend pas pourquoi il y a des cases qui ne s'affichent pas ou s'affiche pas de la bonne couleur. Voici notre code: #include #include #include #include #define CASE_VIDE ' ' #define CASE_PION1 '1' #define CASE_PION2 '2' #define CASE_PION3 '3' #define CASE_PION4 '4' #define CASE_TRESOR1 'A' void Color(int couleurDuTexte,int couleurDeFond) // fonction d'affichage de couleurs { HANDLE H=GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(H,couleurDeFond*16+couleurDuTexte); } void gotoligcol( int lig, int col ) { COORD mycoord; mycoord.X = col; mycoord.Y = lig; SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), mycoord ); } enum OrientationTuile { NORD, OUEST, SUD, EST, MAX_ORIENTATION_TUILE }; enum Forme { FORME_L, FORME_T, FORME_I, }; struct Tuile { enum OrientationTuile orientation; enum Forme forme; char contenance; }; void swap(struct Tuile tab[], int i, int j) { struct Tuile temp[1]; temp[0] = tab[i]; tab[i] = tab[j]; tab[j] = temp[0]; } void melanger_a_partir_de_16(struct Tuile tab[], int n) { for (int i = 16; i <= n - 2; i++) { int j = i + rand() % (n - i); swap(tab, i, j); } } void rien(int dessin[3][3]){ int temp1, temp2; dessin[0][0] = dessin[0][0]; dessin[0][1] = dessin[0][1]; dessin[0][2] = dessin[0][2]; dessin[1][0] = dessin[1][0]; dessin[1][2] = dessin[1][2]; dessin[2][0] = dessin[2][0]; dessin[2][1] = dessin[2][1]; dessin[2][2] = dessin[2][2]; } void rotation_90(int dessin[3][3]){ int temp1, temp2; // aucune modification pour dessin[1][1] car c'est le centre du repere dessin[0][2] = temp1; // rotation pour les corner des la tuile dessin[0][2] = dessin[2][2]; dessin[2][2] = dessin[2][0]; dessin[2][0] = dessin[0][0]; dessin[0][0] = temp1; dessin[0][1] = temp2; // rotation pour le reste de la tuile dessin[0][1] = dessin[1][2]; dessin[1][2] = dessin[2][1]; dessin[2][1] = dessin[1][0]; dessin[1][0] = temp2; } void rotation_180(int dessin[3][3]){ int temp1, temp2; // aucune modification pour dessin[1][1] car c'est le centre du repere dessin[0][2] = temp1; // rotation pour les corner des la tuile dessin[0][2] = dessin[2][0]; dessin[2][0] = temp1; dessin[0][0] = temp1; dessin[0][0] = dessin[2][2]; dessin[2][2] = temp1; dessin[0][1] = temp2; // rotation pour le reste de la tuile dessin[0][1] = dessin[2][1]; dessin[2][1] = temp2; dessin[1][0] = temp2; dessin[1][0] = dessin[1][2]; dessin[1][2] = temp2; } void rotation_270(int dessin[3][3]){ int temp1, temp2; // aucune modification pour dessin[1][1] car c'est le centre du repere dessin[0][2] = temp1; // rotation pour les corner des la tuile dessin[0][2] = dessin[0][0]; dessin[0][0] = dessin[2][0]; dessin[2][0] = dessin[2][2]; dessin[2][2] = temp1; dessin[0][1] = temp2; // rotation pour le reste de la tuile dessin[0][1] = dessin[1][0]; dessin[1][0] = dessin[2][1]; dessin[2][1] = dessin[1][2]; dessin[1][2] = temp2; } struct point { int x; int y; }; void afficher_une_tuile_coord_ecran(struct point debut_tuile, int dessin[3][3], char contenance) { int temp = debut_tuile.y; for(int li = 0; li < 3; li++){ for(int co = 0; co < 3; co++){ gotoligcol(debut_tuile.x,debut_tuile.y); if (li == 1 && co == 1){ Color(0,11); printf("%c", contenance); } if(dessin[li][co] == 1){ Color(12,12); printf("%d", dessin[li][co]); } if(dessin[li][co] == 0) { Color(11,11); printf("%d", dessin[li][co]); } debut_tuile.y = debut_tuile.y + 1; } debut_tuile.x = debut_tuile.x + 1; debut_tuile.y = temp; } } int dessin_tuile_en_L[3][3] = { {1,0,0}, {1,0,0}, {1,1,1}, }; int dessin_tuile_en_T[3][3] = { {1,1,1}, {0,0,0}, {1,0,1}, }; int dessin_tuile_en_I[3][3] = { {1,0,1}, {1,0,1}, {1,0,1}, }; void get_dessin_de_base(int dessin[3][3], struct Tuile t) { int * p; switch (t.forme) { case FORME_L: p = (int *) dessin_tuile_en_L; break; case FORME_T: p = (int *) dessin_tuile_en_T; break; case FORME_I: p = (int *) dessin_tuile_en_I; break; } memcpy(dessin, p, sizeof(int) * 3 * 3); } void afficher_une_tuile_coord_plateau(struct point debut_plateau, struct Tuile t, int li, int co) { int dessin[3][3]; get_dessin_de_base(dessin, t); if (t.orientation == 3) rotation_270(dessin); else if (t.orientation == 2) rotation_180(dessin); else if (t.orientation == 1) rotation_90(dessin); else if (t.orientation == 0) rien(dessin); debut_plateau.x = li * 4; debut_plateau.y = co * 4; afficher_une_tuile_coord_ecran(debut_plateau,dessin,t.contenance); } int main(void) { srand(time(NULL)); struct Tuile tab[50]; char tresor = CASE_TRESOR1; tab[0] = (struct Tuile) {EST, FORME_L, CASE_PION1}; tab[1] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[2] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[3] = (struct Tuile) {SUD, FORME_L, CASE_PION2}; tab[4] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[5] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[6] = (struct Tuile) {NORD, FORME_T, tresor++}; tab[7] = (struct Tuile) {EST, FORME_T, tresor++}; tab[8] = (struct Tuile) {OUEST, FORME_T, tresor++}; tab[9] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[10] = (struct Tuile) {EST, FORME_T, tresor++}; tab[11] = (struct Tuile) {EST, FORME_T, tresor++}; tab[12] = (struct Tuile) {NORD, FORME_L, CASE_PION3}; tab[13] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[14] = (struct Tuile) {SUD, FORME_T, tresor++}; tab[15] = (struct Tuile) {OUEST, FORME_L, CASE_PION4}; for (int i = 16; i < 22; i++) { tab[i].forme = FORME_T; tab[i].contenance= tresor++; tab[i].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int i = 22; i < 28; i++) { tab[i].forme = FORME_L; tab[i].contenance = tresor++; tab[i].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int i = 28; i < 38; i++){ tab[i].forme = FORME_L; tab[i].contenance = CASE_VIDE; tab[i].orientation = rand() % MAX_ORIENTATION_TUILE; } for(int i = 38; i < 50; i++){ tab[i].forme = FORME_I; tab[i].contenance = CASE_VIDE; tab[i].orientation = rand() % MAX_ORIENTATION_TUILE; } int n = 50; melanger_a_partir_de_16(tab, n); int plateau[7][7] = { 0 }; plateau[0][0] = 0; plateau[0][2] = 1; plateau[0][4] = 2; plateau[0][6] = 3; plateau[2][0] = 4; plateau[2][2] = 5; plateau[2][4] = 6; plateau[2][6] = 7; plateau[4][0] = 8; plateau[4][2] = 9; plateau[4][4] = 10; plateau[4][6] = 11; plateau[6][0] = 12; plateau[6][2] = 13; plateau[6][4] = 14; plateau[6][6] = 15; int itab = 16; for (int i = 0; i < 7; i++) for (int j = 0; j < 7; j++) { if (i == 0 && j == 0) continue; if (plateau[i][j] == 0) plateau[i][j] = itab++; } int restant = 49; int dessin[3][3]; struct point debut_plateau; debut_plateau.x = 0; debut_plateau.y = 0; for (int li = 0; li < 7; li++) for (int co = 0; co < 7; co++) { afficher_une_tuile_coord_plateau(debut_plateau, tab[plateau[li][co]], li, co); } gotoligcol(29, 0); Color(15,0); printf("tuile restante : "); get_dessin_de_base(dessin, tab[restant]); afficher_une_tuile_coord_ecran( (struct point) { 30, 3 }, dessin, tab[restant].contenance); return 0; } Pourtant il me semble bien que les fonctions d'affichage parcours bien le tableau et applique bien les modifications selon la valeur du tableau.

Génération d'un labyrinthe amovible en C

15 réponses

Discussions similaires