Discussion :

[felix104116]

Bonjour à vous!

Je viens ce matin afin de vous faire part d'un petit problème dans ce "Jeu".
Petites précision: Le jeu marche, (il exécute un fichier .h et un fichier de prototypes .cpp)
mais lorsque le jeu se termine et qu'il affiche l'image "win.bmp", il affiche le message d'erreur suivant:
"Run-Time Check Failure #2 - Stack around the variable 'Arret' was corrupted. a eu lieu*"

Même chose quand j'utilise Escape (SDLK_ESCAPE) qui set la variable Arret à true.

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
 
#ifndef _SDLCLG_H
#define _SDLCLG_H
///////////////////////////////////////////////////////////////////////////////
// sdlclg.h
// Interface de programmation graphique pour le cours de KA0 utilisation la
// la libraire SDL 1.2.14-VC8
// Joan-Sébastien Morales, Stéphane Chassé et Etienne Forest
// Version 1.0 Création 25 octobre 2009
// Version 1.1 Modification 27 octobre 2009
//   -- Ajout de messages d'erreurs
//   -- Ajout de la fonction RafraichirFenetre
// Version 1.2 Modification 17 novembre 2009
//   -- Ajout du type ImageId
//   -- Ajout de l'énumération Evenement
//   -- Ajout de la fonction AttendreEvenement
// Version 1.21 Modification 24 novembre 2009
//   -- Correction d'un bug avec la fonction AttendreEvenement
// Version 1.3 Modification 23 septembre 2016
//   -- Conversion à SDL 2.0.4 pour Visual Studio 2015
// Version 1.31 Modification 31 octobre 2016
//   -- Correction d'un problème de création de textures à l'affichage
//      qui remplissait la RAM inutilement
///////////////////////////////////////////////////////////////////////////////
#include <SDL.h>
#include <string>
using namespace std;
 
///////////////////////////////////////////////////////////////////////////////
// Type de données utilisé pour conserver les numéros d'images
///////////////////////////////////////////////////////////////////////////////
typedef int ImageId;
 
///////////////////////////////////////////////////////////////////////////////
// Liste des événements associés au clavier
///////////////////////////////////////////////////////////////////////////////
enum Evenement
{
	EVAucun, EVQuitter, EVBas, EVHaut, EVGauche, EVDroite
};
///////////////////////////////////////////////////////////////////////////////
// Attendre
// Permet de placer le programme en attente pendant un certain temps
// Intrant: Temps: Nombre de millisecondes
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void Attendre(int Temps);
///////////////////////////////////////////////////////////////////////////////
// InitialiserAffichage
// Fait apparaître une fenêtre graphique
// IMPORTANT: InitialiserAffichage doit être appelé avant même de charger des images
//   sinon tout l'affichage sera noir.
// Intrant: Titre: Titre de la fenêtre
//			Largeur: Largeur de la fenêtre en pixels
//		    Hauteur: Hauteur de la fenêtre en pixels
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void InitialiserAffichage(string Titre, int Largeur, int Hauteur);
///////////////////////////////////////////////////////////////////////////////
// RemplirFenetre
// Colore toute la fenêtre d'une certaine couleur
// Intrant: Rouge: Composante rouge de la couleur (0-255)
//          Vert : Composante verte de la couleur (0-255)
//          Bleu : Composante bleue de la couleur (0-255)
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void RemplirFenetre(int Rouge, int Vert, int Bleu);
///////////////////////////////////////////////////////////////////////////////
// DessinerRectangle
// Permet de dessiner un rectangle d'une certaine couleur dans la fenêtre
// Intrant: PosX: Position horizontale du rectangle. 
//          PosY: Position verticale du rectangle. 
//          Le point (0,0) est en haut à gauche
//			Largeur: Largeur du rectangle en pixels
//			Hauteur: Hauteur du rectangle en pixels
//          Rouge: Composante rouge de la couleur (0-255)
//          Vert : Composante verte de la couleur (0-255)
//          Bleu : Composante bleue de la couleur (0-255)
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void DessinerRectangle(int PosX, int PosY, int Largeur, int Hauteur, int Rouge, int Vert, int Bleu);
///////////////////////////////////////////////////////////////////////////////
// ChargerImage
// Permet de charger une image du disque dur vers la mémoire
// Le seul type d'image supporté est le bitmap (BMP)
// Intrant: NomFichier: Nom du fichier image. Le fichier doit être dans le 
//                      même répertoire que le projet
// Extrant: un numéro identifiant uniquement l'image
///////////////////////////////////////////////////////////////////////////////
ImageId ChargerImage(string NomFichier);
///////////////////////////////////////////////////////////////////////////////
// AfficherImage
// Permet d'afficher une image à un certain endroit dans le fenêtre graphique
// Intrant: Image: Numéro de l'image
//			PosX: Position horizontale de l'image
//          PosY: Position verticale de l'image
//          Le point (0,0) est en haut à gauche
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void AfficherImage(ImageId Image, int PosX, int PosY);
///////////////////////////////////////////////////////////////////////////////
// RafraichirFenetre
// Mettre à jour la fenêtre d'affichage pour que les dernières modifications
// soient visibles
// Intrant: Aucun
// Extrant: Aucun
///////////////////////////////////////////////////////////////////////////////
void RafraichirFenetre();
///////////////////////////////////////////////////////////////////////////////
// QuitterAffichage
// Ferme la fenêtre graphique
///////////////////////////////////////////////////////////////////////////////
void QuitterAffichage();
///////////////////////////////////////////////////////////////////////////////
// AttendreEvenement
// Attend que l'usager appuie sur une touche du clavier
// Intrant: Aucun
// Extrant: L'événement correspondant à la touche du clavier:
//   EVHaut: Flèche vers le haut
//   EVBas:  Flèche vers le bas
//   EVDroite: Flèche vers la droite
//   EVGauche: Flèche vers la gauche
//   EVQuitter: Esc
///////////////////////////////////////////////////////////////////////////////
Evenement AttendreEvenement(int& PosX, int& PosY, int MaxX, int MaxY);
 
void DeplacerHaut(int& PosX, int& PosY, int MaxX, int MaxY);
void DeplacerBas(int& PosX, int& PosY, int MaxX, int MaxY);
 
void DeplacerGauche(int& PosX, int& PosY, int MaxX, int MaxY);
void DeplacerDroite(int& PosX, int& PosY, int MaxX, int MaxY);
void Deux();
void Un();
void trois();
 
#endif //_SDLCLG_H

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
 
///////////////////////////////////////////////////////////////////////////////
// sdlclg.cpp
// Interface de programmation graphique pour le cours de KA0 utilisation la
// la libraire SDL 2.0.4-VC
// Joan-Sébastien Morales, Stéphane Chassé et Etienne Forest
// Version 1.0 Création 25 octobre 2009
// Version 1.1 Modification 27 octobre 2009
//   -- Ajout de messages d'erreurs
//   -- Ajout de la fonction RafraichirFenetre
// Version 1.2 Modification 17 novembre 2009
//   -- Ajout du type ImageId
//   -- Ajout de l'énumération Evenement
//   -- Ajout de la fonction AttendreEvenement
// Version 1.21 Modification 24 novembre 2009
//   -- Correction d'un bug avec la fonction AttendreEvenement
// Version 1.3 Modification 23 septembre 2016
//   -- Conversion à SDL 2.0.4 pour Visual Studio 2015
// Version 1.31 Modification 31 octobre 2016
//   -- Correction d'un problème de création de textures à l'affichage
//      qui remplissait la RAM inutilement
///////////////////////////////////////////////////////////////////////////////
 
// Finalement débarrassés de windows.h!
#include <vector> // Pour stocker les images
#include <iostream>
#include "sdlclg.h"
 
SDL_Window *fenetre = 0;  // On peut maintenant créer plusieurs fenêtres
						  // On doit donc en créer une avant de faire quoi que ce soit.
SDL_Renderer *renderer = 0; // On doit créer un renderer pour afficher des textures dans la fenêtre
vector<SDL_Surface*> Images;  // Vecteur d'images, inchangé en SDL2
vector<SDL_Texture*> Textures; // Vecteur de textures, nouveauté.  On affiche des textures construites à partir des images
	// Mais on doit conserver les images aussi pour accéder à leurs propriétés.
 
inline void VerifierErreur(bool Test, string Msg)
{
	if (Test)
	{
		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Erreur!", Msg.c_str(), NULL); // NULL : No parent window
		// MessageBox de SDL, plus besoin de windows.h
		exit(1);
	}
}
 
void Attendre(int Temps)
{
	VerifierErreur(Temps <= 0, "Attendre: Temps invalide");
	SDL_Delay(Temps); // Maintenant inclus dans SDL, plus besoin de windows.h!
}
 
void InitialiserAffichage(string Titre, int Largeur, int Hauteur)
{
	VerifierErreur(Largeur <= 0, "InitialiserAffichage: Largeur invalide");
	VerifierErreur(Hauteur <= 0, "InitialiserAffichage: Hauteur invalide");
 
	SDL_Init(SDL_INIT_VIDEO);
	SDL_CreateWindowAndRenderer(Largeur, // La fonction a changé un peu en SDL2 à cause de la fenêtre et du renderer
			Hauteur,
			SDL_WINDOW_RESIZABLE,
			&fenetre,
			&renderer);
	VerifierErreur(!fenetre, "InitialiserAffichage: Impossible de charger le mode vidéo");
	VerifierErreur(!renderer, "InitialiserAffichage: Impossible de créer le rendu");
	SDL_SetWindowTitle(fenetre, Titre.c_str()); // Changé en SDL2
}
 
void RemplirFenetre(int Rouge, int Vert, int Bleu)
{
	VerifierErreur(Rouge<0 || Rouge>255, "RemplirFenetre: Couleur rouge invalide");
	VerifierErreur(Vert<0 || Vert>255, "RemplirFenetre: Couleur verte invalide");
	VerifierErreur(Bleu<0 || Bleu>255, "RemplirFenetre: Couleur bleue invalide");
 
	SDL_SetRenderDrawColor(renderer, Rouge, Vert, Bleu, 255); // Alpha 255: opaque	
	SDL_RenderClear(renderer); // RenderClear "vide" le renderer avec la couleur choisie
}
 
void DessinerRectangle(int PosX, int PosY, int Largeur, int Hauteur,
	int Rouge, int Vert, int Bleu)
{
	VerifierErreur(PosX<0, "DessinerRectangle: PosX invalide");
	VerifierErreur(PosY<0, "DessinerRectangle: PosY invalide");
	VerifierErreur(Largeur<0, "DessinerRectangle: Largeur invalide");
	VerifierErreur(Hauteur<0, "DessinerRectangle: Hauteur invalide");
	VerifierErreur(Rouge<0 || Rouge>255, "DessinerRectangle: Couleur rouge invalide");
	VerifierErreur(Vert<0 || Vert>255, "DessinerRectangle: Couleur verte invalide");
	VerifierErreur(Bleu<0 || Bleu>255, "DessinerRectangle: Couleur bleue invalide");
 
	SDL_Surface *rectangle = 0;
	SDL_Texture* rectTexture = 0; 
	SDL_Rect destR;
 
	// Créer la surface
	rectangle = SDL_CreateRGBSurface(0, Largeur, Hauteur, 32, 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff); // masques RGBA
	// Remplir avec la couleur
	SDL_FillRect(rectangle, NULL, SDL_MapRGB(rectangle->format, Rouge, Vert, Bleu));
	// Créer la texture à partir de la surface (nouveau de SDL2)
	rectTexture = SDL_CreateTextureFromSurface(renderer, rectangle);
	SDL_FreeSurface(rectangle); // Libération de la surface
 
	// Destination dans la fenêtre
	destR.x = PosX;
	destR.y = PosY;
	destR.h = Hauteur;
	destR.w = Largeur;
 
	// Copier la texture rectangle dans le renderer
	SDL_RenderCopy(renderer, rectTexture, NULL, &destR); // NULL: Copier la texture au complet 
}
 
ImageId ChargerImage(string NomFichier)
{
	SDL_Surface* Image = SDL_LoadBMP(NomFichier.c_str());
 
	VerifierErreur(!Image, string("ChargerImage: Impossible de charger l'image ") + NomFichier);
 
	Images.push_back(Image);
 
	// Le color key doit être set ici, dans l'image.  Problème si on le fait plusieurs fois (à l'affichage)
	SDL_SetColorKey(Images[Images.size()-1], SDL_TRUE, // enable color key (transparency)
		SDL_MapRGB(Images[Images.size()-1]->format, 0, 0, 0));
 
	// Créer une texture à partir de la surface (image)
	SDL_Texture* Texture = SDL_CreateTextureFromSurface(renderer, Images[Images.size()-1]);
	Textures.push_back(Texture);
 
	return Images.size() - 1;
}
 
void AfficherImage(ImageId Image, int PosX, int PosY)
{
	VerifierErreur(Image<0 || unsigned int(Image)>Images.size() - 1, "Numéro d'image invalide");
	VerifierErreur(PosX<0, "AfficherImage: PosX invalide");
	VerifierErreur(PosY<0, "AfficherImage: PosY invalide");
 
	// Rectangle représentant la position et la dimension de l'image dans la fenêtre
	SDL_Rect position;
	position.x = PosX;
	position.y = PosY;
	position.h = Images[Image]->h; // SDL2
	position.w = Images[Image]->w; // SDL2
 
	// Copier la texture dans le renderer
	SDL_RenderCopy(renderer, Textures[Image], NULL, &position); // NULL: Copier la texture au complet 
}
 
void RafraichirFenetre()
{
	SDL_RenderPresent(renderer);  // SDL2
}
 
void QuitterAffichage()
{
	// Libérer les surfaces (images)
	for (unsigned int i = 0; i<Images.size(); i++)
	{
		SDL_FreeSurface(Images[i]);
	}
	// Détruire le renderer
	SDL_DestroyRenderer(renderer);
	// Détruire la fenêtre
	SDL_DestroyWindow(fenetre);
	// Quitter
	SDL_Quit();
}
 
Evenement AttendreEvenement(int& PosX, int& PosY, int MaxX, int MaxY)
{
	// Rien n'a changé ici avec SDL2
	Evenement e = EVAucun;
	SDL_Event event;
	bool Valide = false;
	while (!Valide)
	{
		SDL_WaitEvent(&event);
		switch (event.type)
		{
		case SDL_QUIT:
			e = EVQuitter;
			Valide = true;
			break;
		case SDL_KEYDOWN:
			switch (event.key.keysym.sym)
			{
			case SDLK_UP: // Flèche haut
				e = EVHaut;
				Valide = true;
				DeplacerHaut(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_DOWN: // Flèche bas
				e = EVBas;
				Valide = true;
				DeplacerBas(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_RIGHT: // Flèche droite
				e = EVDroite;
				Valide = true;
				DeplacerGauche(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_LEFT: // Flèche gauche
				e = EVGauche;
				Valide = true;
				DeplacerDroite(PosX, PosY, MaxX, MaxY);
				break;
			case SDLK_ESCAPE: /* Appui sur la touche Echap, on arrête le programme */
				e = EVQuitter;
				Valide = true;
				break;
			}
			break;
		}
	}
	return e;
}

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
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
#include "sdlclg.h"
#include <iostream>
#include <Windows.h>
#include <mmsystem.h>
using namespace std;
int main(int argc, char *argv[])
{
	PlaySound(TEXT("musique.wav"), NULL, SND_FILENAME | SND_NODEFAULT | SND_ASYNC);
	bool win = false;
	bool Arret = false;
	InitialiserAffichage("Jeu", 800, 600);
	ChargerImage("fond.bmp");
	ChargerImage("sapin.bmp");
	ChargerImage("bonhomme.bmp");
	ChargerImage("cadeau.bmp");
	ChargerImage("traineau.bmp");
	ChargerImage("win.bmp");
	ChargerImage("petitflocon.bmp");
	ChargerImage("loading.bmp");
	AfficherImage(7, 0, 0);
	RafraichirFenetre();
	srand(static_cast<unsigned int>(time(0)));
	Objet Tableau[NbCases][NbCases];
	Position Bonhomme;
	Bonhomme.x = rand() % NbCasesX;
	Bonhomme.y = rand() % NbCases;
	const int NombreFlocon = 50;
	Position Flocons[NombreFlocon];
	for (int i = 0; i <= NombreFlocon-1; i++) {
		Flocons[i] = {
		rand() % NbCasesX,
		rand() % NbCases
		};
		Tableau[Flocons[i].x][Flocons[i].y] = Flocon;
	}
	AfficherImage(0, 0, 0);
	AfficherImage(1, 670, 220);
	AfficherImage(3, 550, 450);
	AfficherImage(4, 430, 40);
	sleep_for(seconds(2));
	RafraichirFenetre();
	while (!win) {
		AfficherImage(0, 0, 0);
		AfficherImage(1, 670, 220);
		AfficherImage(3, 550, 450);
		AfficherImage(4, 430, 40);
		system("cls");
		for (int i = 0; i <= NombreFlocon - 1; i++) {
				if (Tableau[Flocons[i].x][Flocons[i].y] == Vide) {
				}
				else if (Tableau[Flocons[i].x][Flocons[i].y] == Flocon) {
					AfficherImage(6, Flocons[i].x*NbPixelsParCase, Flocons[i].y*NbPixelsParCase);
					//cout << "Flocon #" << i << " " << Flocons[i].x << " " << Flocons[i].y << endl; //Deboguage
				}
		}
		AfficherImage(2, Bonhomme.x*NbPixelsParCase, Bonhomme.y*NbPixelsParCase);
		//cout << "Position actuelle: " << Bonhomme.x << " " << Bonhomme.y << endl; //Deboguage
		RafraichirFenetre();
 
		AttendreEvenement(Bonhomme.x, Bonhomme.y, Arret);
		if (Arret) {
			QuitterAffichage();
			return 0;
		}
		if (Bonhomme.x >= 23) {
			Bonhomme.x = 23;
		}
		if (Bonhomme.x <= 0) {
			Bonhomme.x = 0;
		}
		if (Bonhomme.y >= 16) {
			Bonhomme.y = 16;
		}
		if (Bonhomme.y <= 0) {
			Bonhomme.y = 0;
		}
		for (int i = 0; i <= NombreFlocon - 1; i++) {
			if ((Bonhomme.x <= Flocons[i].x && Bonhomme.x +1 >= Flocons[i].x) && (Bonhomme.y <= Flocons[i].y && Bonhomme.y+2 >= Flocons[i].y)) {
					Tableau[Flocons[i].x][Flocons[i].y] = Vide;
				}
				else {
				}
		}
		win = true;
		for (int i = 0; i <= NombreFlocon - 1; i++) {
			if (Tableau[Flocons[i].x][Flocons[i].y] == Flocon) {
				win = false;
			}
			else {
 
			}
		}
	}
	if (win) {
		ChargerImage("win.bmp");
		AfficherImage(8, 0, 0);
		RafraichirFenetre();
		sleep_for(seconds(5));
		QuitterAffichage();
	}
		return 0;
}
 
void Chargement() {	
	InitialiserAffichage("Hunt", 800,600);
}
 
 
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Merci énormément