flèches du clavier et séquence d'echappement

**kaitlyn** · 15/06/2024, 19h31

Il fallait commencer par ça. Oublie ncurses et prends SDL2 ou équivalent.

Edit:

https://www.studyplan.dev/sdl-dev/sdl2-window

**emmesse** · 15/06/2024, 19h41

Merci pour l'URL, je vais voir ça.

**emmesse** · 20/06/2024, 07h24

J'ai fini la première étape, la génération de labyrinthe:
Nom : Capture d’écran du 2024-06-20 06-59-06.png
Affichages : 62
Taille : 5,7 Ko

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
//classesEtConstantes.hpp
#ifndef CLASSESETCONSTANTES_HPP
#define CLASSESETCONSTANTES_HPP
 
#include <SDL2/SDL.h>
#include <random>
 
constexpr int largeur=24;
constexpr int hauteur=16;
 
struct lieu{
  lieu();
  bool mur_nord,mur_sud,mur_est,mur_ouest,chemin,non_marque;
};
 
class laby{
public:
  laby();
  void afficher(SDL_Renderer*);
  void boucle_de_jeu();
  void solution();
private:
  lieu tableau[largeur][hauteur];
  void creuser(int x,int y);
};
 
#endif

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
#include <iostream>
#include <random>
#include <SDL2/SDL.h>
#include "classesEtConstantes.hpp"
 
laby::laby(){
  creuser(0,0);//(0,0)=lieu de départ pour la construction
}
 
 
void laby::afficher(SDL_Renderer *pRenderer){
  char disque[3]={(char)226,(char)143,(char)186};
  SDL_Rect bords;
  bords.x=0;
  bords.y=0;
  bords.w=800;
  bords.h=600;
  SDL_SetRenderDrawColor(pRenderer,255,255,255,255);
  SDL_RenderFillRect(pRenderer,&bords);
  SDL_SetRenderDrawColor(pRenderer,0,0,0,255);
  bords.x=400-largeur*30/2;
  bords.y=300-hauteur*30/2;
  bords.w=largeur*30;
  bords.h=hauteur*30;
  SDL_RenderDrawRect(pRenderer,&bords);
  int width=largeur*30;
  int height=hauteur*30;
  for(int x=0;x<largeur;x++)
    for(int y=0;y<hauteur;y++){
      int X0=400-width/2+x*30;//X0 est l'abcisse du bord gauche du lieu courant
      int X1=400-width/2+(x+1)*30;//X1 est l'abcisse du bord droit du lieu courant
      int Y0=y*30+300-height/2;//Y0 est l'ordonnée du bord haut du lieu courant
      int Y1=(y+1)*30+300-height/2;//Y1 est l'ordonnée du bord bas du lieu courant
      if(tableau[x][y].mur_sud)
	SDL_RenderDrawLine(pRenderer,X0,Y1,X1,Y1);
      if(tableau[x][y].mur_est)
	SDL_RenderDrawLine(pRenderer,X1,Y0,X1,Y1);
    }
}
 
void laby::creuser(int x,int y){
  std::random_device rd;
  std::mt19937 eng(rd());
  std::uniform_int_distribution<int> distr2(0,1);
  std::uniform_int_distribution<int> distr3(0,2);
  std::uniform_int_distribution<int> distr4(0,3);
 
  tableau[x][y].non_marque=false;//pour marquer le lieu de coordonnées (x,y)
 
  if(x==0){//colonne ouest du tableau
    if(y==0){//coin nord-ouest du tableau
      while(tableau[x+1][y].non_marque||tableau[x][y+1].non_marque){
	switch(distr2(eng)){//abattre mur à l'est ou sud
	case 0://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	  break;
	case 1://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false; //abattre mur est (point cardinal est) 
	    creuser(x+1,y);//creuser à l'est
	  }
	}
      }
    }
    else if(y==hauteur-1){//coin sud-ouest du tableau
      while(tableau[x][y-1].non_marque||tableau[x+1][y].non_marque){
	switch(distr2(eng)){//abattre mur est (point cardinal est)  ou nord
	case 0://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false; //abattre mur à l'est
	    creuser(x+1,y);//creuser à l'est
	  }
	  break;
	case 1://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	}
      }
    }
    else{ //bord ouest du tableau
      while(tableau[x+1][y].non_marque||tableau[x][y-1].non_marque||tableau[x][y+1].non_marque){
	switch(distr3(eng)){
	case 0://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	  break;
	case 1://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 2://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	}
      }
    }
  }
  else if(x==largeur-1){//colonne est (point cardinal est) du tableau
    if(y==0){//coin nord-est du tableau
      while(tableau[x-1][y].non_marque||tableau[x][y+1].non_marque){
	switch(distr2(eng)){
	case 0://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 1://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	}
      }
    }
    else if(y==hauteur-1){//coin sud-est du tableau
      while(tableau[x][y-1].non_marque||tableau[x-1][y].non_marque){
	switch(distr2(eng)){
	case 0://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 1://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	}
      }
    }
    else{ //bord est du tableau
      while(tableau[x][y-1].non_marque||tableau[x-1][y].non_marque||tableau[x][y+1].non_marque){
	switch(distr3(eng)){
	case 0://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 1://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 2://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	}
      }
    }
  }
  else{//les autres abcisses
    if(y==0){//bord nord
      while(tableau[x-1][y].non_marque||tableau[x][y+1].non_marque||tableau[x+1][y].non_marque){
	switch(distr3(eng)){
	case 0://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 1://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	  break;
	case 2://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	}
      }
    }
    else if(y==hauteur-1){//bord sud
      while(tableau[x-1][y].non_marque||tableau[x][y-1].non_marque||tableau[x+1][y].non_marque){
	switch(distr3(eng)){
	case 0://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	  break;
	case 1://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 2://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	}
      }
    }
    else{ //autres ordonnées
      while(tableau[x][y-1].non_marque||tableau[x+1][y].non_marque||tableau[x][y+1].non_marque||tableau[x-1][y].non_marque){
	switch(distr4(eng)){
	case 0://nord
	  if(tableau[x][y-1].non_marque){ //lieu nord non marqué. il y a alors forcément mur_nord==true
	    tableau[x][y].mur_nord = tableau[x][y-1].mur_sud=false; //abattre mur au nord
	    creuser(x,y-1);//creuser au nord
	  }
	  break;
	case 1://est
	  if(tableau[x+1][y].non_marque){//lieu est (point cardinal est) non marqué. il y a alors forcément mur_est==true
	    tableau[x][y].mur_est = tableau[x+1][y].mur_ouest = false;
	    creuser(x+1,y);//creuser à l'est
	  }
	  break;
	case 2://sud
	  if(tableau[x][y+1].non_marque){//lieu sud non marqué. il y a alors forcément mur_sud==true
	    tableau[x][y].mur_sud=tableau[x][y+1].mur_nord=false;//abattre mur sud
	    creuser(x,y+1);//creuser au sud
	  }
	  break;
	case 3://ouest
	  if(tableau[x-1][y].non_marque){//lieu ouest non marque. il y a alors forcément mur_ouest==true
	    tableau[x][y].mur_ouest=tableau[x-1][y].mur_est=false;//abattre mur_ouest
	    creuser(x-1,y);//creuser à l'ouest
	  }
	}
      }
    }
  }
}

Code :

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

1
2
3
4
5
6
#include "classesEtConstantes.hpp"
 
lieu::lieu(){
  mur_nord = mur_sud = mur_est = mur_ouest = non_marque = true;
  chemin=false;
}

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
//main.cpp
#include <SDL2/SDL.h>
#include "classesEtConstantes.hpp"
 
int main(){
  laby labyrinthe;
  if (SDL_Init(SDL_INIT_EVERYTHING) < 0){
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "[DEBUG] > %s", SDL_GetError());
    return -1;
  }
  SDL_Window* pWindow{ nullptr };     
  SDL_Renderer* pRenderer{ nullptr };
  if (SDL_CreateWindowAndRenderer(800, 600, SDL_WINDOW_SHOWN, &pWindow, &pRenderer) < 0){
    SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "[DEBUG] > %s", SDL_GetError());        
    SDL_Quit(); 
    return -1;
  }
  SDL_Event events;
  bool isOpen{ true };
  while (isOpen){
    while (SDL_PollEvent(&events)){
      switch (events.type){
      case SDL_QUIT:
	isOpen = false;
	break;
      }
    }
    labyrinthe.afficher(pRenderer);
    SDL_RenderPresent(pRenderer);
  }
 
  SDL_DestroyRenderer(pRenderer);SDL_DestroyWindow(pWindow);
  SDL_Quit();
  return 0;
}

**deedolith** · 20/06/2024, 09h24

Maintenant si tu veux faire du vrai C++ (sans tous ces pointeurs nu problématiques),
réécrit la même chose avec une bibliothèque C++.

**emmesse** · 20/06/2024, 11h04

avec sfml peut-être?
que penses-tu de Qt?

**kaitlyn** · 20/06/2024, 17h34

Salut,

Envoyé par deedolith

Maintenant si tu veux faire du vrai C++ (sans tous ces pointeurs nu problématiques),
réécrit la même chose avec une bibliothèque C++.

Je ne partage pas du tout ton avis. Ce n'est pas en utilisant une Lib C++ qu'une personne se mettra soudainement à écrire du bon C++, et encore moins du vrai C++, parce que ça, je ne sais pas ce que c'est.
Je prends en exemple, freetype, ou sqlite ou autre Lib C utilisée pratiquement partout, alors non seulement c'est du C, très souvent du C89, mais en plus il y est fait énormément usage de PIMPL, de fonction-macros, du coup le style d'utilisation t'est pratiquement imposé. Dans ces cas là, tout ce que tu peux faire c'est de la ségrégation de code, mais ça n'empêchera pas d'écrire du bon C++ si tu en as la capacité.

**deedolith** · 20/06/2024, 19h40

Je ne vais pas te contredire.

Cependant, quand on part de zéro, et qu'on a le choix, mieux vaut se tourner vers les bibliothèques C++.

Il y a aussi la possibilité d'écrire des wrappers, mais ce n'est pas à la portée de tous.

**kaitlyn** · 21/06/2024, 19h42

Salut,

Le monde du jeu vidéo est beaucoup trop particulier et va bien au-delà de ces considérations. Tout ce que tu peux estimer comme vrai en applicatif ne l'est plus. Bien sûr, ce n'est pas avec un "snake game" que tu verras la différence.

flèches du clavier et séquence d'echappement

C++

Discussions similaires

Partager

Partager