jeu du labyrinthe minotaure probleme de tableau

**guimc85** · 02/04/2020, 12h48

Bonjour je aurais besoin de votre aide si possible car je suis très débutant en C

1er point.
je suis en train de créer un petit jeu pour le cadre de mon projet de ma formation en C, il consiste dans un labyrinthe avec des personnages "H" et "M" sur le quelle je doit éviter de me croiser, mon problème c'est que j'ai un tableau que je fait initialiser a début de mon programme sur le quelle il va afficher les chemins, murs et les "." que sont des points que vont s’ajouter a mon score bien le problème une fois que mon "H" passe dessous il si ajouter 10 points jusque a la tout va bien mais a chaque fois que je passe dessous il donne toujours mes 10 points je doit faire un sort de récupérer la coordonne de positionneCurseur(xH,yH); pour que je puisse dans le tableau la ou se trouve le "2" et le mettre a "0" dans le tableau Lab [HauteurLab][LargeurLab]

2ème point.
si quelqu'un peut aussi m aider pour faire en sort que mon "M" se déplace tout seule car j n arrive pas non plus.

merci de votre aide

si je ne suis pas sur le bonne forum je suis désolé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <windows.h>
#include <time.h>
#define LargeurLab 31
#define HauteurLab 21
 
void Attend();
void PositionneCurseur();
void Couleur();
int main()
{
    int score = 0;
 
    system("mode con LINES=50 COLS=50");
 
    int Lab [HauteurLab][LargeurLab]=
                   {{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                    {3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1},
                    {1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1},
                    {1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,1},
                    {1,1,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0,1},
                    {1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,2,0,0,0,0,0,0,1},
                    {1,0,0,1,1,1,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0,1,1,1,1,0,0,1,0,0,1},
                    {1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1},
                    {1,0,0,1,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                    {1,0,0,1,0,0,0,0,0,0,2,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1},
                    {1,1,1,1,1,1,1,0,0,1,0,0,1,0,0,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,1},
                    {1,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1},
                    {1,0,0,1,0,0,1,0,0,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1,1,0,0,1,0,0,1},
                    {1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0,1,0,0,1},
                    {1,0,0,1,0,0,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1,1,0,0,1,0,0,1,0,0,1},
                    {1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,2,0,1,0,0,1},
                    {1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1},
                    {1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
                    {1,0,0,1,1,1,1,0,0,1,0,0,1,0,0,1,1,1,1,1,1,1,0,0,1,0,0,1,0,0,1},
                    {1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1},
                    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1}};
 
 
    int ligne,colonne;
 
 
///---------------------initialisation du tableau labyrenthe------------------------------///
    for (ligne=0; ligne<HauteurLab; ligne++)
    {
 
        for(colonne=0; colonne<LargeurLab; colonne++)
        {
            //afichache des chemins
            if (Lab [ligne][colonne]==0)
            {
                printf(" ");
            }
            //affichache des murs
            if (Lab [ligne][colonne]==1)
            {
                Couleur(15,0);
                printf("%c",219);
            }
            //afichache des points pour le score
            if (Lab [ligne][colonne]==2)
            {
                printf(".");
            }
            //afichache du mur de entree
            if (Lab [ligne][colonne]==3)
            {
                Couleur(14,0);
                printf("%c",219);
            }
            //affichage du mur que donne acces au labyranthe suivant
            if (Lab [ligne][colonne]==4)
            {
                Couleur(12,0);
                printf("%c",219);
            }
        }
        printf("\n");
    }
 
 
 
 
 
 
    int xH,yH = 0;
    int xM,yM = 0;
    int xh,yh = 1;
 
    //fontion pour donner une position pour h alectoire sans tomber sur un mur
    do{
        srand(time(NULL));
        xH=1+rand()%31;
        yH=1+rand()%21;
        xM=1+rand()%31;
        yM=1+rand()%21;
 
    }while(Lab[yH][xH]!=0||Lab[yM][xM]!=0);
 
 
    char touche;
 
    PositionneCurseur(1,22);
    printf("Score: %d",score);
 
    PositionneCurseur(xH,yH);
    printf("H");
 
    PositionneCurseur(xM,yM);
    printf("M");
 
 
    while(1)
    {
        if(kbhit())
        {
            touche=getch();
 
            if(touche == 72)// code ASCII de la fleche haut
            {
                PositionneCurseur(xH,yH);//determiner la position x et y de H
 
                if(Lab [yH-1][xH]==0||Lab [yH-1][xH]==2)//determine la position x et y de H est vide ou que il y a la case 2 pour avoir des points pour pouvoir monter
                {
                    if(Lab [yH-1][xH]==2)//si position --y de H est =2 alors additionner 10 points
                    {
                        score+=10;
                        Lab [yH][xH]==Lab [0][0];
                    }
                    printf(" ");
                    yH --;
 
                }
 
 
           }
 
            if(touche == 80)// code ASCII de la fleche bas
            {
                PositionneCurseur(xH,yH);
 
                if(Lab [yH+1][xH]==0||Lab [yH+1][xH]==2)
                {
                    if(Lab [yH+1][xH]==2)
                    {
                        score+=10;
                        Lab [HauteurLab][LargeurLab]==Lab [yH][xH];
                    }
                    printf(" ");
                    yH ++;
                }
 
 
 
            }
 
            if(touche == 75)// code ASCII de la fleche gauche
            {
                PositionneCurseur(xH,yH);
 
                if(Lab [yH][xH-1]==0||Lab [yH][xH-1]==2)
                {
                     if(Lab [yH][xH-1]==2)
                    {
                        score+=10;
                        Lab [HauteurLab][LargeurLab]==Lab [yH][xH];
                    }
                    printf(" ");
                    xH --;
                }
 
            }
 
            if(touche == 77)// code ASCII de la fleche droite
            {
                PositionneCurseur(xH,yH);
 
                if(Lab [yH][xH+1]==0||Lab [yH][xH+1]==2)
                {
                    if(Lab [yH][xH+1]==2)
                    {
                        score+=10;
                        Lab [HauteurLab][LargeurLab]==Lab [yH][xH];
                    }
                    printf(" ");
                    xH ++;
                }
            }
 
 
 
	/// ensuite on répéte le processus pour toutes les touches à gérer
        PositionneCurseur(xH,yH);
        printf("H");
        PositionneCurseur(1,22);
        printf("Score: %d",score);
        PositionneCurseur(1,24);
        printf("position x= %d \n position y= %d",xH,yH);
 
        }
///-----------------------deplacement minotaure---------------------------///
        //Attend(500);
        if(Lab [yM][xM+1]==0)
                {
                    printf(" ");
                    xM ++;
                }else if(Lab [yM][xM-1]==0){
                    printf(" ");
                    xM --;
                }else if (Lab [yM-1][xM]==0){
                    printf(" ");
                    yM --;
                }else if (Lab [yM+1][xM]==0){
                    printf(" ");
                    yM ++;
                }
 
 
 
        PositionneCurseur(xM,yM);
        printf("M");
            if(touche == 13)// code ASCII de la touche enter
            {
                break;
            }
 
    }
 
    return 0;
}
 
void PositionneCurseur(int x, int y)
{
    HANDLE Console=0;  // Stocke le numéro de la console affichée à l'écran
    COORD  Point;      // Gére la position du curseur sur la console
 
    Point.Y = y;       // Fixe les coordonnées du point
    Point.X = x;
 
    Console = GetStdHandle(STD_OUTPUT_HANDLE);         // Récupère le numéro de console pour obtenir les infos de la console
    SetConsoleCursorPosition (Console, Point);         // Fixe la position du curseur sur la console
}
 
void Couleur(int CouleurCaractere, int CouleurFond)
{
    HANDLE Console=0;  // Stocke le numéro de la console affichée à l'écran
 
    Console = GetStdHandle(STD_OUTPUT_HANDLE);           // Récupère le numéro de console pour obtenir les infos de la console
 
    SetConsoleTextAttribute (Console , CouleurCaractere+(CouleurFond*16)); // Fixe la couleur du fond et la couleur du caractère
 
}
 
void Attend(clock_t milliseconde)
 
{
    clock_t temps;    // Stocke le temps (en milliseconde)
    temps=clock();    // Stocke le temps actuel
 
    // Tant que le temps demandé n'est pas passé on boucle
    while(temps+milliseconde*(CLOCKS_PER_SEC/1000) >clock());
}

**hurukan** · 08/04/2020, 20h36

Je travaille essentiellement sous Linux du coup je ne saurais pas tester ton programme (c'est le soucis du non respect de Windows concernant les standards et la difficulté d'écrire des programmes en C qui soient portables, de mon point de vue).

Bon, taper le code source même succintement commenté c'est assez difficile d'apporter, à la lecture, une éventuelle aide.

Au niveau de la conception, j'aurais essayé d'abord sur un tableau de bien plus petite taille pour faire des essais ( pour "modéliser" )
Ensuite j'aurais validé:

+ le fonctionnement du contrôle clavier (est-ce que le personnage reste bien dans les limites du tableau, quand j'appuie sur une touche est-ce que le personnage se déplace dans la bonne direction, etc...)
+ que mon programme est capable de différencier des "zones" libres et des "murs", et d'opérer ce qui est prévu quand on rencontre un mur par exemple, ...

En général si le "code" du tableau doit être modifié, les techniques liées aux tableaux et les indices des éléments devraient apporter très facilement une solution par rapport à ce que j'ai pu comprendre comme étant ton soucis.
Le tout est d'ordonnancer clairement ce qui est le plus important de faire: ici ton programme n'est pas "threadé" cela veut dire que tu n'as pas de processus dédicacé au déplacement du minotaure.

Si le minotaure doit se "déplacer tout seul" il faut un "thread" pour qu'il puisse se déplacer sans empêcher le joueur de se déplacer à son tour.
Sinon, en mode "un peu plus simple" (pas sûr que ce soit si simple que cela), il faudrait déplacer le minotaure après un événement, par exemple, dès que le joueur a appuyé sur une touche.

Tu appellerais une fonction qui gère le déplacement du minotaure dans une direction aléatoire (en vérifiant préalablement que cette direction proposée ne va pas l'envoyer dans un mur) une fois que le joueur a appuyé sur une touche, par exemple.
En y pensant je me demande comment les "jeux rétros" étaient écrits parce que je suis pas certain que le mécanisme des threads existait en 1980 sur les processeurs comme le Z80 ^^
Rien que le jeu Galaga par exemple.

**Médinoc** · 14/04/2020, 14h45

Envoyé par hurukan

Si le minotaure doit se "déplacer tout seul" il faut un "thread" pour qu'il puisse se déplacer sans empêcher le joueur de se déplacer à son tour.
Sinon, en mode "un peu plus simple" (pas sûr que ce soit si simple que cela), il faudrait déplacer le minotaure après un événement, par exemple, dès que le joueur a appuyé sur une touche.

Normalement le kbhit() doit contourner ce problème.

**hurukan** · 21/04/2020, 16h12

oui sous linux kbhit n'existe pas, il est censé être "non bloquant".
sous linux on utilise un "getch" un peu spécial avec des paramètres que nous transférons au terminal pour ne plus "attendre" que le buffer d'entrée contienne un caractère... la fonction ainsi paramétrée retourne -1 si il n'y a rien dans le buffer.
Cependant, j'ai déjà essayé sans thread (semblant de RPG en mode console bien marrant à faire pour mettre en oeuvre tout cela), et franchement c'est tout de même pas évident à mettre en oeuvre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#ifdef LINUX
int nbgetchEx(void)
{
	char							Buffer;
	struct termios		oldtcfg;
	struct termios		newtcfg;
	struct sigaction	Detournement;
 
	Detournement.sa_handler=SIG_IGN;
	// On ne peut pas interrompre le getch...
	sigaction(SIGINT,&Detournement,NULL);
 
	tcgetattr(STDIN_FILENO, &oldtcfg);
  newtcfg = oldtcfg;
 
	// mode non bloquant...
 
	newtcfg.c_cc[VMIN] = 0;
	newtcfg.c_cc[VTIME] = 2;																											// 0 ça pousse le processeur à 100% (faire gaffe à ce que l'on fait)
	newtcfg.c_lflag &= ~(ICANON|ECHOCTL|ECHO);																		// n'a pas besoin d'appuyer sur "entrée" (caractère non bloquant de la procédure) sans écho
	tcsetattr(STDIN_FILENO, TCSANOW, &newtcfg);
 
	Buffer=getchar();	// retourne EOF (-1) si il y a rien dans le buffer
 
	// on restitue "l'ancienne configuration"
	tcsetattr(STDIN_FILENO, TCSANOW, &oldtcfg); 
 
	Detournement.sa_handler=SIG_DFL;
	Detournement.sa_flags=0;
	sigaction(SIGINT,&Detournement,NULL);
 
	return Buffer;
}
#endif

...extrait de ma librairie...

**Médinoc** · 21/04/2020, 16h23

~~Pour autant que je sache getch() n'existe pas plus nativement que kbhit() sous linux, mais la bibliothèque curses (ncurses, pdcurses) supporte les deux.~~
Edit: Sauf que non, on dirait.

Néanmoins...

**hurukan** · 21/04/2020, 16h52

oui ^^

je n'utilise pas ncurse je trouve cette librairie simplement "imbuvable" mais c'est une question de goût ^^

**guimc85** · 01/06/2020, 10h07

Merci les gars pour vous commentaires

mais depuis je suis parvenu a finir mon projet, et je crois bien avoir faire quelque chose de bien pour mon niveau en c

affichage de labyrinthes, gestion de vie du joueur et score et déplacement des ennemis via une deuxième boucle avec le thread, pour le déplacement du minotaure je créer aussi un logarithme de solution de la main gauche que permet que l ennemie puisse se déplacer sans se coincer en quelque part, je essaye de trouver une mailleur solution pour que le ennemies trouver le chemin vers notre joueur plus rapidement ça aurais donne plus de difficulté pour notre joueur.
mais pour le ensemble tout a était bien réussi.

je laisse ici en annexe le code source de mon projet,

si vous pouvez me donner votre feedback car a cause du covid le prof na pas donne le sien
niveaux structure et mise en code c'est un peu bordélique a mes yeux

**Sve@r** · 01/06/2020, 12h46

Bonjour

Envoyé par guimc85

je essaye de trouver une mailleur solution pour que le ennemies trouver le chemin vers notre joueur plus rapidement ça aurais donne plus de difficulté pour notre joueur.

Fais en sorte que le joueur laisse une trace de son passage (un équivalent informatique d'une odeur). Imaginons par exemple qu'il passe sur la case (5, 5). Il laisse alors une trace de valeur (on va dire) 20. Puis il se déplace sur la case (6, 5) il y met l'odeur de valeur 20 et celle de la case (5, 5) passe à 19. Et etc. Comme ça, dès que le minotaure tombe sur la trace, il peut la remonter directement vers le joueur.
Et la valeur de l'odeur permet d'associer le jeu à un certain niveau (plus forte c'est plus difficile pour le joueur, plus faible c'est plus facile).

Envoyé par guimc85

si vous pouvez me donner votre feedback car a cause du covid le prof na pas donne le sien

Oui, je vais regarder ça.

jeu du labyrinthe minotaure probleme de tableau

C

Discussions similaires

Partager

Partager