Mon programme marche en debug, mais pas en release, je suis perdu

Version imprimable

15/07/2021, 20h21
ArnaudNRoses

Mon programme marche en debug, mais pas en release, je suis perdu

Bonjour, je suis perdu, mon programme avec la SDL 2 ne marche PARFAITEMENT qu'en debug.

En release, comme en debug ( avec visual studio ), je n ai pas d'erreurs et de warnings ( c++ niveau 4 pour les erreurs ) et aucune exceptions levées aussi ( je coche toutes exceptions de partout si j'ose dire, et normalement mon programme est bien fait pour éviter les exceptions),

j ai juste un warning :

Avertissement C6262 La fonction utilise '452240' octets de pile*: dépasse /analyze:stacksize '16384'. Si possible, déplacez certaines données vers le tas. GOF1 C:\VISUAL STUDIO\Projets Visual Studio\Solution GOF1\GOF1\src\main.cpp 107

Mais mon programme marche qu'en debug, en release, dans la visualisation des variables locales au main dans le debugger de visual studio, il m'en manque les 3 quarts, dans la version debug elles sont toutes la !!!

Je comprends pas mon problème...
15/07/2021, 20h53
Bousk

Tu as juste un warning qui te dit que tu exploses la pile, mais sinon tout va bien ? :ptdr:
15/07/2021, 21h44
ArnaudNRoses

1 pièce(s) jointe(s)

j ai bien mis cette option pour élargir la pile, mais j ai pas l impression que ca change grand chose

Pièce jointe 601702
15/07/2021, 22h16
ArnaudNRoses

1 pièce(s) jointe(s)

Et j ai mis ca aussi mais aucun effet,

Pièce jointe 601706

auriez-vous une idée ?

en fait, même elle ne marche bien que sur la debug 64 et aucune des trois autres configs....

merci de vos de vos réponses...
15/07/2021, 22h56
Bousk

On change pas la taille de la pile pour corriger son code.
On corrige son code.
Tu as des trucs en pile qui n'ont certainement rien à y faire. 450Mo de pile... y'a absolument aucune chance que ce soit légitime. :weird:
15/07/2021, 23h11
ArnaudNRoses

euh... c est juste 450 ko pas 450 Mo.

dans la pile, J ai beaucoup de tableaux à 2 ou 3 dimensions qui sont que des pointeurs ( 8 octets ) et ces pointeurs pointent sur des objets alloués eux dynamiquement dans dans le tas .

il faut que même mes tableaux de pointeurs qui sont dans la pile soit eux aussi dans le tas c ça mon problème ?????
16/07/2021, 09h00
Astraya

Tu dois avoir dans ton code un tableau sur la pile qui est énorme. A savoir que la stacksize est de 16ko pourr le mode utilisateur et 1ko pour le mode kernel.
Cf : https://docs.microsoft.com/fr-fr/cpp...?view=msvc-160
16/07/2021, 12h06
dalfab
Citation:

Envoyé par ArnaudNRoses

euh... c est juste 450 ko pas 450 Mo.

dans la pile, J ai beaucoup de tableaux à 2 ou 3 dimensions qui sont que des pointeurs ( 8 octets ) et ces pointeurs pointent sur des objets alloués eux dynamiquement dans dans le tas .

il faut que même mes tableaux de pointeurs qui sont dans la pile soit eux aussi dans le tas c ça mon problème ?????

Comme tu l'écris toi même, un pointeur ne fait que 8 octets, donc prend peu de place sur ta pile.
Le compilateur doit t'indiquer la fonction qui pose un problème, et donc trouver la ou les variables trop grandes ne devrait pas être si difficile.

Le fait que des variables ou des fonctions ne soient plus visibles en release est possible, car l'optimisation a réorganisé les choses et les choses devenues inutiles ont disparu. Dans cet exemple doubler() et y disparaissent, le programme retourne immédiatement 42.
Code:

1 2 3 4 5 6 void doubler( int &x ) { x *= 2; } int main() { int y = 21; doubler( y ); return y; }
Attention, il peut aussi y avoir d'autres causes qui font que le programme n'ait pas le même comportement en release et en debug. En gros tous les cas correspondant à un "undefined behaviour".
16/07/2021, 15h23
ArnaudNRoses

Merci pour vos réponses !!!!

sur la doc de microsoft, ils disent que la pile est par défaut de 1 Mo ...

ca devrait donc loger ... si ont a pas le droit de mettre des "trucs trop" grand dans la pile , pourquoi les ordi ont 8 Go de RAM ?????

ont pas le droit d'avoir de données trop grande ?????? la spécification de c++ à ma connaissance n'impose de vals max pour les tableaux tant que ca loge en mémoire,

J ai effectivement mis l'optimisation pour un code plus rapide, car c est un jeu "en temps réel" ( un shoot them up ), je sais pas il optimise comme tu dis, vu qu 'il manque vraiment beaucoup de variables locales dans le visualiseur des variables du débuggeur , même mes littérateurs dans les boucle for , alors que le programme fonctionne quand même sans planter. pour visual studio et mon pc mon programme plante pas et fais pas d'exceptions ( lol d'ailleurs !!!), il manque juste beaucoup de décors, les threads se lance pas ect....

la fonction qui pose problème, c est le main ... et que elle d'après IntelliSense de chez bilou...
16/07/2021, 15h36
ArnaudNRoses

1 pièce(s) jointe(s)

Pièce jointe 601755

sinon, pour mes variables locales automatiques dans le main, je vais voir quels sont les plus grandes et voir ce que je peux y faire pour y remedier...
16/07/2021, 16h38
ArnaudNRoses

1 pièce(s) jointe(s)

Si je mets main au lieu de SDL_main, je passe de 452 ko a 46 ko de pile pour mon main, je comprends pas tout :

sinon j 'ai pas grosse variables en fait en locales dans mon main

Pièce jointe 601766
16/07/2021, 17h25
Astraya

Citation:

Envoyé par ArnaudNRoses

Merci pour vos réponses !!!!

sur la doc de microsoft, ils disent que la pile est par défaut de 1 Mo ...

Faut apprendre a lire. Premier paragraphe :

Citation:

La taille de frame de pile par défaut pour cet avertissement est 16 Ko pour le mode utilisateur, 1 Ko pour le mode noyau.
17/07/2021, 13h10
dalfab

Bonjour,

Oui la taille de la pile est de 1MO. C'est donc le maximum pour toutes les fonctions actuellement en cours sur un thread donné.
Ce qui fait 16 KO, c'est un frame de pile, c'est donc le maximum pour une unique fonction. Et ça c'est facile à détecter par le compilateur qui t'indique la fonction fautive.

Merci pour vos réponses,

mais je dois avoir un problème autre que /analyse/Stacksize, car je peux vous assure que j ai pas pour 46 ko de variables locales dans mon main, et que le reste est bien dans le tas...

je comprends vraiment pas mon problème...

vraiment trop peu de variables locales dans mon main, jugez par vous meme...

Code:

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
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
 
 
	#ifdef _DEBUG
	const char* surfacePixelFormatName = NULL;	
	char*	SDL_Error = NULL;
	bool	Test = false;
	#endif
 
	SDL_Renderer	*pRenderer = NULL;
	SDL_Window		*pWindow = NULL;
	float_t			ScaleX = 1.0f;
	float_t			ScaleY = 1.0f;
 
	int8_t MethodeCollision = PIXEL_BY_PIXEL_HIGH;
 
	register int32_t		WinH = 0;
	register int32_t		WinW = 0;
 
	char		MotScore[NB_CHIFFRES_DU_SCORE + 1] = "";
	int8_t		CaractereScore = 0;
 
	char		MotNbLevel[NB_CHIFFRES_DU_LEVEL + 1] = "";
	int8_t		CaractereNbLevel1 = 0;
	int8_t		CaractereNbLevel2 = 0;
	int8_t		CaractereNbLevel3 = 0;
	int8_t		NbChiffresLevel = 0;
	int32_t		xProchainChiffre = 0;
 
	register int32_t		NBCasesH = 0;
	register int32_t		NBCasesW = 0;
 
	register int32_t		s = 0;
	register int32_t		h = 0;
 
	register int32_t		t = 0;
	register int32_t		l = 0;
	register int32_t		m = 0;
	register int32_t		p = 0;
	register int32_t		q = 0;
	register int32_t		r = 0;
	register int32_t		i = 0;
	register int32_t		j = 0;
	register int32_t		k = 0;
 
	int16_t		Level = 0;
 
	int8_t		VagueScroll_7 = 0;
	int8_t		VagueScroll_8 = 0;
	int8_t		VagueScroll_9 = 0;
	int8_t		VagueScroll_10 = 0;
	int8_t		VagueScroll_11 = 0;
	int8_t		VagueScroll_12 = 0;
	int8_t		VagueScroll_13 = 0;
	int8_t		VagueScroll_14 = 0;
 
	int32_t		sScroll_0 = 0;
	int32_t		hScroll_0 = 0;
	int32_t		sScroll_7 = 0;
	int32_t		hScroll_7 = 0;
	int32_t		hScroll_8 = 0;
	int32_t		sScroll_8 = 0;
	int32_t		sScroll_9 = 0;
	int32_t		hScroll_9 = 0;
	int32_t		hScroll_10 = 0;
	int32_t		sScroll_10 = 0;
	int32_t		sScroll_11 = 0;
	int32_t		hScroll_11 = 0;
	int32_t		hScroll_12 = 0;
	int32_t		sScroll_12 = 0;
 
	int32_t		xVaisseauPause = 0;
	int32_t		yVaisseauPause = 0;
	int32_t		xPause = 0;
	int32_t		yPause = 0;
	bool		GamePause = false;
 
	int8_t		AnimEnemi[NB_ENEMIS][MAX_ENEMIS];
	int8_t		NBImagesAnimEnemi[NB_ENEMIS][MAX_ENEMIS];
	int8_t		SetAnimationEnemi[NB_ENEMIS][MAX_ENEMIS];	
	int8_t		NBImagesAnimEnemiGrisee[NB_ENEMIS][MAX_ENEMIS];
 
	for (i = 0; i < NB_ENEMIS; i++)
		for (j = 0; j < MAX_ENEMIS; j++)
		{
			AnimEnemi[i][j] = 0;
			NBImagesAnimEnemi[i][j] = 0;
			SetAnimationEnemi[i][j] = 0;			
			NBImagesAnimEnemiGrisee[i][j] = 0;			
		}
 
	float_t		ChanceTir = 0.10f;
 
	int16_t		NBEnemisDecors = 0;
 
	int32_t		ReferentCibleEnMouvementExplosionScroll_0 = 0;
	int32_t		ReferentCibleEnMouvementExplosionScroll_7 = 0;
	int32_t		ReferentCibleEnMouvementExplosionScroll_8 = 0;
 
	register bool	TamponBool = false;
 
	register int32_t	xTampon1 = 0;
	register int32_t	yTampon1 = 0;
 
	//register int32_t	xTampon2 = 0;
	//register int32_t	yTampon2 = 0;
 
	int32_t		iMenu = 0;
	int32_t		xMenu = 0;
	int32_t		yMenu = 0;
	int8_t		LettresMenu = 0;
	bool		Menu = true;
 
	int32_t		iGameOver = 0;
	int32_t		xGameOver = 0;
	int32_t		yGameOver = 0;
	int8_t		LettresGameOver = 0;
	bool		GameOver = false;
 
	int32_t		iDebutNiveau = 0;
	int32_t		xDebutNiveau = 0;
	int32_t		yDebutNiveau = 0;
	int8_t		LettresDebutNiveau = 0;
	bool		DebutNiveau = false;
 
	int32_t		iFinNiveau = 0;
	int32_t		xFinNiveau = 0;
	int32_t		yFinNiveau = 0;
	int8_t		LettresFinNiveau = 0;
	bool		FinNiveau = false;
 
	int32_t		xScroll_3 = 0;
	int32_t		xScroll_4 = 0;
	int32_t		xScroll_5 = 0;
	int32_t		xScroll_6 = 0;
 
	register SDL_Rect	dest = { 0,0,0,0 };
	register SDL_Rect	src = { 0,0,0,0 };
	SDL_Rect	SurfaceDeJeu = { 0,0,0,0 };	
 
	float_t		AngleEnemi = 0.0f;	
	int8_t		CourbeEnemi = 0;
 
	Uint8		AlphaFondu = 0;
 
	Uint32		TempsTampon = 0;
 
	Uint32		TempsTirDepart = 0;
	Uint32		TempsTirEcoule = 0;
	Uint32		TempsTirPause = 0;
 
	Uint32		TempsClavierDepart = 0;
	Uint32		TempsClavierEcoule = 0;
 
	Uint32		TempsDebutLevelDepart = 0;
	Uint32		TempsDebutLevelEcoule = 0;
 
	Uint32		TempsFinLevelDepart = 0;
	Uint32		TempsFinLevelEcoule = 0;
 
	Uint32		TempsGameOverDepart = 0;
	Uint32		TempsGameOverEcoule = 0;
 
	Uint64		TempsFPSDepart = 0;
	Uint64		TempsFPSEcouleCreation = 0;
	Uint64		TempsFPSEcouleAffichage = 0;
	Uint64		TempsFPSCount = SDL_GetPerformanceFrequency();
	bool		AffichageTempsFPS = false;	
	Uint8		CompteurFrameFPS = 0;
 
	int16_t		NbIndexExplosion[NB_EXPLOSIONS];
	int16_t		NbIndexTirs[NB_TIRS];
	int16_t		NbIndexTirsEnemis[NB_TIRS_ENEMIS];
 
	for (i = 0; i < NB_TIRS; i++)
		NbIndexTirs[i] = 0;
	for (i = 0; i < NB_EXPLOSIONS; i++)
		NbIndexExplosion[i] = 0;
	for (i = 0; i < NB_TIRS_ENEMIS; i++)
		NbIndexTirsEnemis[i] = 0;
 
	bool	TamponBoolScroll_7 = false;
	bool	TamponBoolScroll_8 = false;
	bool	TamponBoolScroll_9 = false;
	bool	TamponBoolScroll_10 = false;
	bool	TamponBoolScroll_11 = false;
	bool	TamponBoolScroll_12 = false;	
 
	EnemiParametres		EnemisParametresObtenu[NB_ENEMIS][MAX_ENEMIS];
	TirParametres		TirsParametresObtenu[NB_TIRS][MAX_TIRS];
	TirParametres		TirsEnemisParametresObtenu[NB_TIRS_ENEMIS][MAX_TIRS_ENEMIS];
 
	for (m = 0; m < NB_ENEMIS; m++)
		for (t = 0; t < MAX_ENEMIS; t++)
			InitialiserEnemi(EnemisParametresObtenu[m] + t);	
	for (m = 0; m < NB_TIRS; m++)
		for (t = 0; t < MAX_TIRS; t++)
			InitialiserTir(TirsParametresObtenu[m] + t);	
	for (m = 0; m < NB_TIRS_ENEMIS; m++)
		for (t = 0; t < MAX_TIRS_ENEMIS; t++)
			InitialiserTir(TirsEnemisParametresObtenu[m] + t);
 
	bool	PremiereImage = true;
	bool	JeuFini = false;
	bool	TransitionFondu = true;
	bool	DemarrerJeu = false;
	bool	NiveauComplete = false;
	bool	FaireQueUneFoisReinitialiserScenario = true;
 
	bool	VagueScroll_3_4_Actif = true;
	bool	VagueScroll_5_6_Actif = true;
	bool	VagueScroll_7_Actif = false;
	bool	VagueScroll_8_Actif = false;
	bool	VagueScroll_9_Actif = false;
	bool	VagueScroll_10_Actif = false;
	bool	VagueScroll_11_Actif = false;
	bool	VagueScroll_12_Actif = false;
	bool	VagueScroll_13_Actif = false;
	bool	VagueScroll_14_Actif = false;
 
	SDL_Thread	*pThreadScenario = NULL;
 
	int16_t		NbTuilesLevelScroll_0_H[NB_LEVELS];
	int16_t		NbTuilesLevelScroll_1_H[NB_LEVELS];
	int16_t		NbTuilesLevelScroll_2_H[NB_LEVELS];
	int16_t		NbTuilesLevelScroll_7_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_8_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_9_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_10_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_11_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_12_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_13_H[NB_LEVELS][MAX_VAGUES];
	int16_t		NbTuilesLevelScroll_14_H[NB_LEVELS][MAX_VAGUES];
 
	for (p = 0; p < NB_LEVELS; p++)
	{
		NbTuilesLevelScroll_0_H[p] = 0;
		NbTuilesLevelScroll_1_H[p] = 0;
		NbTuilesLevelScroll_2_H[p] = 0;
 
		for (m = 0; m < MAX_VAGUES; m++)
		{
			NbTuilesLevelScroll_7_H[p][m] = 0;
			NbTuilesLevelScroll_8_H[p][m] = 0;
			NbTuilesLevelScroll_9_H[p][m] = 0;
			NbTuilesLevelScroll_10_H[p][m] = 0;
			NbTuilesLevelScroll_11_H[p][m] = 0;
			NbTuilesLevelScroll_12_H[p][m] = 0;
			NbTuilesLevelScroll_13_H[p][m] = 0;
			NbTuilesLevelScroll_14_H[p][m] = 0;
		}
	}
 
	Uint32 ParametresTir[2];
	ParametresTir[0] = 0;
	ParametresTir[1] = 0;
 
	Uint32 ParametresTirEnemi[5];
	ParametresTirEnemi[0] = 0;
	ParametresTirEnemi[1] = 0;
	ParametresTirEnemi[2] = 0;
	ParametresTirEnemi[3] = 0;
	ParametresTirEnemi[4] = 0;
 
	SDL_Event			Evenement;	
	VaisseauParametres	Vaisseau;
 
	int32_t xMarge = 0;
	int32_t yMarge = 0;
	int32_t xMargeMAX = 0;
	int32_t yMargeMAX = 0;
	int32_t xMargeMIN = 0;
	int32_t yMargeMIN = 0;
	int32_t xRel = 0;
	int32_t yRel = 0;
 
	SDL_Rect	RectTampon = { 0,0,0,0 };
	SDL_Rect	RectTamponScroll = { 0,0,0,0 };
 
	SDL_Rect	RectTamponAC = {0,0,0,0};
	SDL_Rect	RectTamponBC = { 0,0,0,0 };
 
 
 
	// FIN DE LA DECLARATION DES VARIABLES LOCALES DU PROGRAMME DU JEU
 
 
 
 
 
	// DEBUT DE LA DECLARATION DES VARIABLES DYNAMIQUES LOCALES DU PROGRAMME DU JEU
 
 
 
 
 
	// Allocations des vérificateurs booléens avec NEW pour une bonne initialisation du jeu
 
	bool *AllocationsDynamiquesReussies = new bool;
	if (AllocationsDynamiquesReussies == NULL)
	{
		#ifdef _DEBUG				
		fprintf(stdout, "\nERREUR... ERREUR... ERREUR... ERREUR...  Le programme a rencontré un problème à la 1ère allocaton dynamique : MEMORY BUSY ?????\n\n");
		#else
		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "ERREUR", "Le programme a rencontre un probleme a la 1ere allocaton dynamique : MEMORY BUSY ?????", pWindow);
		#endif
 
		return 1;
	}
	*AllocationsDynamiquesReussies = true;
 
	bool *ImagesChargeesEnSurFaces = new bool;
		*ImagesChargeesEnSurFaces = true;
 
	bool *TaillesImagesValidees = new bool;
		*TaillesImagesValidees = true;
 
	bool *ClesCouleursAttribuees = new bool;
		*ClesCouleursAttribuees = true;
 
	bool *SurFacesTransformeesEnTexture = new bool;
		*SurFacesTransformeesEnTexture = true;
 
	bool *ReglageOpenGLTexture = new bool;
		*ReglageOpenGLTexture = true;
 
 
 
	// Allocations avec CALLOC
 
	//int16_t		MapLevelScroll_0[NB_LEVELS][MAX_TUILES_H_SCROLL_0][WINDOWS_NB_TUILES_W];
	int16_t		***MapLevelScroll_0 = (int16_t***)calloc(NB_LEVELS, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_0[j] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_0, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (i = 0; i < MAX_TUILES_H_SCROLL_0; i++)
			MapLevelScroll_0[j][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_0_PointsVie[NB_LEVELS][MAX_TUILES_H_SCROLL_0][WINDOWS_NB_TUILES_W];
	int16_t*** MapLevelScroll_0_PointsVie = (int16_t***)calloc(NB_LEVELS, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_0_PointsVie[j] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_0, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (i = 0; i < MAX_TUILES_H_SCROLL_0; i++)
			MapLevelScroll_0_PointsVie[j][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_1[NB_LEVELS][MAX_TUILES_H_SCROLL_1][WINDOWS_NB_TUILES_W];
	int16_t*** MapLevelScroll_1 = (int16_t***)calloc(NB_LEVELS, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_1[j] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_1, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (i = 0; i < MAX_TUILES_H_SCROLL_1; i++)
			MapLevelScroll_1[j][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_2[NB_LEVELS][MAX_TUILES_H_SCROLL_2][WINDOWS_NB_TUILES_W];
	int16_t*** MapLevelScroll_2 = (int16_t***)calloc(NB_LEVELS, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_2[j] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_2, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (i = 0; i < MAX_TUILES_H_SCROLL_2; i++)
			MapLevelScroll_2[j][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_7[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_7 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_7[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_7[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_7[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_8[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_8 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_8[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_8[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_8[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_7_Bis[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_7_Bis = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_7_Bis[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_7_Bis[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_7_Bis[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_8_Bis[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_8_Bis = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_8_Bis[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_8_Bis[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_8_Bis[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
 
	//int16_t		MapLevelScroll_7_PointsVie[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_7_PointsVie = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_7_PointsVie[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_7_PointsVie[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_7_PointsVie[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_8_PointsVie[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_8_PointsVie = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_8_PointsVie[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_8_PointsVie[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_8_PointsVie[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_7_ImageGrisee[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_7_ImageGrisee = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_7_ImageGrisee[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_7_ImageGrisee[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_7_ImageGrisee[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_8_ImageGrisee[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_7_8][WINDOWS_NB_TUILES_SCROLL_7_8_W];
	int16_t**** MapLevelScroll_8_ImageGrisee = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_8_ImageGrisee[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_8_ImageGrisee[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_7_8, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_7_8; i++)
				MapLevelScroll_8_ImageGrisee[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_7_8_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_9[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_9_10][WINDOWS_NB_TUILES_SCROLL_9_10_W];
	int16_t**** MapLevelScroll_9 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_9[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_9[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_9_10, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_9_10; i++)
				MapLevelScroll_9[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_9_10_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_10[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_9_10][WINDOWS_NB_TUILES_SCROLL_9_10_W];
	int16_t**** MapLevelScroll_10 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_10[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_10[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_9_10, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_9_10; i++)
				MapLevelScroll_10[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_9_10_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_11[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_11_12][WINDOWS_NB_TUILES_SCROLL_11_12_W];
	int16_t**** MapLevelScroll_11 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_11[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_11[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_11_12, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_11_12; i++)
				MapLevelScroll_11[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_11_12_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_12[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_11_12][WINDOWS_NB_TUILES_SCROLL_11_12_W];
	int16_t**** MapLevelScroll_12 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_12[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_12[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_11_12, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_11_12; i++)
				MapLevelScroll_12[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_11_12_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_13[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_13_14][WINDOWS_NB_TUILES_SCROLL_13_14_W];
	int16_t**** MapLevelScroll_13 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_13[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_13[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_13_14, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_13_14; i++)
				MapLevelScroll_13[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_13_14_W, sizeof(int16_t));
 
	//int16_t		MapLevelScroll_14[NB_LEVELS][MAX_VAGUES][MAX_TUILES_H_SCROLL_13_14][WINDOWS_NB_TUILES_SCROLL_13_14_W];
	int16_t**** MapLevelScroll_14 = (int16_t****)calloc(NB_LEVELS, sizeof(int16_t***));
	for (j = 0; j < NB_LEVELS; j++)
		MapLevelScroll_14[j] = (int16_t***)calloc(MAX_VAGUES, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			MapLevelScroll_14[j][k] = (int16_t**)calloc(MAX_TUILES_H_SCROLL_13_14, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (k = 0; k < MAX_VAGUES; k++)
			for (i = 0; i < MAX_TUILES_H_SCROLL_13_14; i++)
				MapLevelScroll_14[j][k][i] = (int16_t*)calloc(WINDOWS_NB_TUILES_SCROLL_13_14_W, sizeof(int16_t));
 
	//int16_t		MapScenario[NB_LEVELS][MAX_ACTIONS_SCENARIO][NB_PARAMETRES_SCENARIO];
	int16_t*** MapScenario = (int16_t***)calloc(NB_LEVELS, sizeof(int16_t**));
	for (j = 0; j < NB_LEVELS; j++)
		MapScenario[j] = (int16_t**)calloc(MAX_ACTIONS_SCENARIO, sizeof(int16_t*));
	for (j = 0; j < NB_LEVELS; j++)
		for (i = 0; i < MAX_ACTIONS_SCENARIO; i++)
			MapScenario[j][i] = (int16_t*)calloc(NB_PARAMETRES_SCENARIO, sizeof(int16_t));
 
 
 
	// Allocations avec MALLOC
 
	//ExplosionParametres MapExplosions[NB_EXPLOSIONS][MAX_EXPLOSIONS];
	ExplosionParametres ***MapExplosions = (ExplosionParametres***)calloc(NB_EXPLOSIONS,sizeof(ExplosionParametres**));
	for (j = 0; j < NB_EXPLOSIONS; j++)
		MapExplosions[j] = (ExplosionParametres**)calloc(MAX_EXPLOSIONS,sizeof(ExplosionParametres*));
	for (p = 0; p < NB_EXPLOSIONS; p++)
		for (q = 0; q < MAX_EXPLOSIONS; q++)
			MapExplosions[p][q] = (ExplosionParametres*)malloc(sizeof(ExplosionParametres));
 
	for (p = 0; p < NB_EXPLOSIONS; p++)
		for (q = 0; q < MAX_EXPLOSIONS; q++)
			InitialiserExplosion(MapExplosions[p][q]);
 
	//Image SpriteScroll[NB_LEVELS][NB_SCROLLS][MAX_TUILES];
	Image ****SpriteScroll = (Image****)calloc(NB_LEVELS, sizeof(Image***));
	for (p = 0; p < NB_LEVELS; p++)
		SpriteScroll[p] = (Image***)calloc(NB_SCROLLS, sizeof(Image**));
	for (p = 0; p < NB_LEVELS; p++)
		for (q = 0; q < NB_SCROLLS; q++)
			SpriteScroll[p][q] = (Image**)calloc(MAX_TUILES, sizeof(Image*));
	for (p = 0; p < NB_LEVELS; p++)
		for (q = 0; q < NB_SCROLLS; q++)
			for (r = 0; r < MAX_TUILES; r++)
				SpriteScroll[p][q][r] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_LEVELS; p++)
		for (q = 0; q < NB_SCROLLS; q++)
			for (r = 0; r < MAX_TUILES; r++)
				InitialiserImage(SpriteScroll[p][q][r]);
 
	//Image SpriteScrollGrisee[NB_LEVELS][NB_SCROLLS][MAX_TUILES];
	Image**** SpriteScrollGrisee = (Image****)calloc(NB_LEVELS, sizeof(Image***));
	for (p = 0; p < NB_LEVELS; p++)
		SpriteScrollGrisee[p] = (Image***)calloc(NB_SCROLLS, sizeof(Image**));
	for (p = 0; p < NB_LEVELS; p++)
		for (q = 0; q < NB_SCROLLS; q++)
			SpriteScrollGrisee[p][q] = (Image**)calloc(MAX_TUILES, sizeof(Image*));
	for (p = 0; p < NB_LEVELS; p++)
		for (q = 0; q < NB_SCROLLS; q++)
			for (r = 0; r < MAX_TUILES; r++)
				SpriteScrollGrisee[p][q][r] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_LEVELS; p++)
		for (q = 0; q < NB_SCROLLS; q++)
			for (r = 0; r < MAX_TUILES; r++)
				InitialiserImage(SpriteScrollGrisee[p][q][r]);
 
	//Image SpriteEnemi[NB_ENEMIS][NB_SETS_ANIMATIONS_ENEMIS][NB_ANIMATIONS_ENEMIS];
	Image**** SpriteEnemi = (Image****)calloc(NB_ENEMIS, sizeof(Image***));
	for (p = 0; p < NB_ENEMIS; p++)
		SpriteEnemi[p] = (Image***)calloc(NB_SETS_ANIMATIONS_ENEMIS, sizeof(Image**));
	for (p = 0; p < NB_ENEMIS; p++)
		for (q = 0; q < NB_SETS_ANIMATIONS_ENEMIS; q++)
			SpriteEnemi[p][q] = (Image**)calloc(NB_ANIMATIONS_ENEMIS, sizeof(Image*));
	for (p = 0; p < NB_ENEMIS; p++)
		for (q = 0; q < NB_SETS_ANIMATIONS_ENEMIS; q++)
			for (r = 0; r < NB_ANIMATIONS_ENEMIS; r++)
				SpriteEnemi[p][q][r] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_ENEMIS; p++)
		for (q = 0; q < NB_SETS_ANIMATIONS_ENEMIS; q++)
			for (r = 0; r < NB_ANIMATIONS_ENEMIS; r++)
				InitialiserImage(SpriteEnemi[p][q][r]);
 
	//Image SpriteEnemiGrisee[NB_ENEMIS][NB_SETS_ANIMATIONS_ENEMIS][NB_ANIMATIONS_ENEMIS];
	Image**** SpriteEnemiGrisee = (Image****)calloc(NB_ENEMIS, sizeof(Image***));
	for (p = 0; p < NB_ENEMIS; p++)
		SpriteEnemiGrisee[p] = (Image***)calloc(NB_SETS_ANIMATIONS_ENEMIS, sizeof(Image**));
	for (p = 0; p < NB_ENEMIS; p++)
		for (q = 0; q < NB_SETS_ANIMATIONS_ENEMIS; q++)
			SpriteEnemiGrisee[p][q] = (Image**)calloc(NB_ANIMATIONS_ENEMIS, sizeof(Image*));
	for (p = 0; p < NB_ENEMIS; p++)
		for (q = 0; q < NB_SETS_ANIMATIONS_ENEMIS; q++)
			for (r = 0; r < NB_ANIMATIONS_ENEMIS; r++)
				SpriteEnemiGrisee[p][q][r] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_ENEMIS; p++)
		for (q = 0; q < NB_SETS_ANIMATIONS_ENEMIS; q++)
			for (r = 0; r < NB_ANIMATIONS_ENEMIS; r++)
				InitialiserImage(SpriteEnemiGrisee[p][q][r]);
 
	//ExplosionParametres SpriteExplosion[NB_EXPLOSIONS][NB_ANIMATIONS_EXPLOSIONS];
	Image*** SpriteExplosion = (Image***)calloc(NB_EXPLOSIONS, sizeof(Image**));
	for (j = 0; j < NB_EXPLOSIONS; j++)
		SpriteExplosion[j] = (Image**)calloc(NB_ANIMATIONS_EXPLOSIONS, sizeof(Image*));
	for (p = 0; p < NB_EXPLOSIONS; p++)
		for (q = 0; q < NB_ANIMATIONS_EXPLOSIONS; q++)
			SpriteExplosion[p][q] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_EXPLOSIONS; p++)
		for (q = 0; q < NB_ANIMATIONS_EXPLOSIONS; q++)
			InitialiserImage(SpriteExplosion[p][q]);
 
	//Image SpriteEnemiDecor[NB_ENEMIS_DECOR][NB_ANIMATIONS_ENEMIS_DECOR];
	Image*** SpriteEnemiDecor = (Image***)calloc(NB_ENEMIS_DECOR, sizeof(Image**));
	for (j = 0; j < NB_ENEMIS_DECOR; j++)
		SpriteEnemiDecor[j] = (Image**)calloc(NB_ANIMATIONS_ENEMIS_DECOR, sizeof(Image*));
	for (p = 0; p < NB_ENEMIS_DECOR; p++)
		for (q = 0; q < NB_ANIMATIONS_ENEMIS_DECOR; q++)
			SpriteEnemiDecor[p][q] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_ENEMIS_DECOR; p++)
		for (q = 0; q < NB_ANIMATIONS_ENEMIS_DECOR; q++)
			InitialiserImage(SpriteEnemiDecor[p][q]);
 
	//Image SpriteEnemiDecorGrisee[NB_ENEMIS_DECOR][NB_ANIMATIONS_ENEMIS_DECOR];
	Image*** SpriteEnemiDecorGrisee = (Image***)calloc(NB_ENEMIS_DECOR, sizeof(Image**));
	for (j = 0; j < NB_ENEMIS_DECOR; j++)
		SpriteEnemiDecorGrisee[j] = (Image**)calloc(NB_ANIMATIONS_ENEMIS_DECOR, sizeof(Image*));
	for (p = 0; p < NB_ENEMIS_DECOR; p++)
		for (q = 0; q < NB_ANIMATIONS_ENEMIS_DECOR; q++)
			SpriteEnemiDecorGrisee[p][q] = (Image*)malloc(sizeof(Image));
 
	for (p = 0; p < NB_ENEMIS_DECOR; p++)
		for (q = 0; q < NB_ANIMATIONS_ENEMIS_DECOR; q++)
			InitialiserImage(SpriteEnemiDecorGrisee[p][q]);
 
	Image* ImageComparaisonScroll = (Image*)malloc(sizeof(Image));
	InitialiserImage(ImageComparaisonScroll);
 
 
 
	// Allocations avec NEW
 
	Image *SpriteVaisseau = new Image[NB_ANIMATIONS_VAISSEAU];
 
	for (p = 0; p < NB_ANIMATIONS_VAISSEAU; p++)
		InitialiserImage(SpriteVaisseau+p);
 
	Image* SpriteVaisseauGrisee = new Image[NB_ANIMATIONS_VAISSEAU];
 
	for (p = 0; p < NB_ANIMATIONS_VAISSEAU; p++)
		InitialiserImage(SpriteVaisseauGrisee + p);
 
	Image *SpriteTir = new Image[NB_TIRS];
 
	for (p = 0; p < NB_TIRS; p++)
		InitialiserImage(SpriteTir+p);
 
	Image* SpriteTirEnemi = new Image[NB_TIRS_ENEMIS];
 
	for (p = 0; p < NB_ENEMIS; p++)
		InitialiserImage(SpriteTirEnemi + p);
 
	Image *SpriteChiffreScore = new Image[NB_CHIFFRES_SCORE];
 
	for (p = 0; p < NB_CHIFFRES_SCORE; p++)
		InitialiserImage(SpriteChiffreScore+p);
 
	Image *SpriteLettreJeu_1 = new Image[NB_LETTRES_JEU_1];
 
	for (p = 0; p < NB_LETTRES_JEU_1; p++)
		InitialiserImage(SpriteLettreJeu_1 +p);
 
	Image *SpriteFontMenu = new Image[NB_FONTS_MENU];
 
	for (p = 0; p < NB_FONTS_MENU; p++)
		InitialiserImage(SpriteFontMenu +p);	
 
	Image *SpriteDivers = new Image[NB_SPRITES_DIVERS];
 
	for (p = 0; p < NB_SPRITES_DIVERS; p++)
		InitialiserImage(SpriteDivers +p);
 
	Image* SpriteFontCaracteres = new Image;
 
	InitialiserImage(SpriteFontCaracteres);

17/07/2021, 19h54
Astraya

Attends... Tu as tout ça dans 1 main????
Et tu retrouves tes petits?
Coupe tout ca en fonction, et comme tu est en C++ créer des objets..
La c'est inacceptable même pour une étudiant débutant
17/07/2021, 19h55
Astraya

Tu exploses la stack frame car tu gardes TOUT! Même ce qui est temporaire.
17/07/2021, 20h00
ArnaudNRoses

ah bon ???

ok

ils faut que je découpe tout en classes et en fonctions ?????

J ai pas le droit de programmer ainsi, tout mettre au début de mon main toutes les variables, et d'en un "petit peu"?

ah ok....
17/07/2021, 20h02
ArnaudNRoses

j y suis vraiment oblige de faire comme tu dis ?????

Merci pour ton aide !!!!!!

je vais faire ça et je tiens au courant du résultat...

Bonjour,

Une fonction a rarement plus d'une dizaine de variables, et fait rarement plus de 30 lignes. Donc ton main() n'a pas "trop peu de variables", il est gigantesque. Je n'ai jamais vu une aussi grande fonction en 35 ans d'expérience!

Quant aux données qui seraient énormes et donc ne devraient jamais être allouées automatiquement, on peut citer:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 int8_t AnimEnemi[NB_ENEMIS][MAX_ENEMIS]; int8_t NBImagesAnimEnemi[NB_ENEMIS][MAX_ENEMIS]; int8_t SetAnimationEnemi[NB_ENEMIS][MAX_ENEMIS]; int8_t NBImagesAnimEnemiGrisee[NB_ENEMIS][MAX_ENEMIS]; int16_t NbIndexExplosion[NB_EXPLOSIONS]; int16_t NbIndexTirs[NB_TIRS]; int16_t NbIndexTirsEnemis[NB_TIRS_ENEMIS]; EnemiParametres EnemisParametresObtenu[NB_ENEMIS][MAX_ENEMIS]; TirParametres TirsParametresObtenu[NB_TIRS][MAX_TIRS]; TirParametres TirsEnemisParametresObtenu[NB_TIRS_ENEMIS][MAX_TIRS_ENEMIS]; int16_t NbTuilesLevelScroll_0_H[NB_LEVELS]; int16_t NbTuilesLevelScroll_1_H[NB_LEVELS]; int16_t NbTuilesLevelScroll_2_H[NB_LEVELS]; int16_t NbTuilesLevelScroll_7_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_8_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_9_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_10_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_11_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_12_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_13_H[NB_LEVELS][MAX_VAGUES]; int16_t NbTuilesLevelScroll_14_H[NB_LEVELS][MAX_VAGUES];
Déplacer le code de SDL_Main() vers main() diminue la taille allouée sur la pile, car l'optimiseur déplace les variables qui ont un destructeur trivial en global. Il voit bien que ces données resteront toute la durée de l'application en mémoire, et que main() ne sera jamais appelée en réentrance, donc tout ça est déplacé en global au lieu d'en automatique justement dans le but d'éviter de charger inutilement la pile.

EDIT: j'ajouterai qu'il est peu probable que ton problème à l'exécution de l'application en release vienne de là. Ta fonction est appelée une unique fois, le fait que le compilateur ne puisse pas utiliser une standard stack frame ne devrait pas poser de problème à part peut-être pour le debugger. Donc après correction de cela, il te faudra rechercher ailleurs la cause de ton problème!

17/07/2021, 22h29
ArnaudNRoses

Merci pour ta réponse !!!!!

Pour ce qui est de peu de lignes dans une fonction, j'avais entendu parler de ce que tu viens de m écrire , mais je pensais que c'était imposé " par méthode de travail", non pas que techniquement il FAUT faire comme ça ...

c est juste ça ...

merci sinon !!
17/07/2021, 23h53
Astraya

C'est pas "il FAUT", mais il y a des principes à appliquer qui sont positifs sur de nombreux aspects ( performance, maintenance, ... ). Il y a un principe de conception qui s'appelle SOLID.
C'est un acronyme, le premier S signifie "Single Responsablity Principle" (Principe de responsabilité unique), qui dit que chaque fonction, chaque classe, chaque structure à une responsabilité unique, par exemple, une fonction d'addition de 2 vecteur 3D ne fait que ca. Là, dans ton main, tu as toutes les responsabilités dans 1 seule fonction. Je te laisse regarder les autres lettres sur le net.

Tu dois découper, reflechir sur le cycle de vie de ton application ( Initialisation, traitement, libération), deja rien que la tu peux avoir 3 fonctions.

Il n'est pas rare de voir un main qui ne fait que créer un objet application et qui lance juste une seule fonction ( run() ).
18/07/2021, 19h09
ArnaudNRoses

pour répondre a ton EDIT : d'où pourrai-je savoir d'où vient mon pb , car il n est levé aucune exception d'aucune sorte, et je me trompe pas dans mes tableaux littérateurs ects car ca se voit tres bien a l essai et a l utilisation les erreurs de ce genre....

sachant aussi que dans le debuggeur visual studio, la plupart de mes variables sont absentes de la fenêtre de visualisation des locales, ceci que en release, en debug, j ai toutes mes variables présentes et tout marche du coup on dirai, car en release, même au moment ou il ne marche plus il plante pas , pas d'exceptions levées, il fait quand même sa boucle générale au jeu quand même.
18/07/2021, 22h45
Astraya

Ca pourrait fixer ton problème si tu règles ce problème.
Une lecture à faire pour ce qui concerne les stack frames. A ne pas confondre avec la stack.

http://www.qnx.com/developers/docs/q...ackFrames.html
20/07/2021, 22h01
ArnaudNRoses

bonjour, j ai fait une version de mon prog avec des allocations dynamiques pour les tableaux que tu m avais fait remarque et ca change pas /analysestack.... toujours le meme nombre, 46 ko, je vous dis en version classes ce que ce donnera...
22/07/2021, 19h36
ArnaudNRoses

1 pièce(s) jointe(s)

Bonjour !!!

A propos de la lecture que tu m'a indique, j ai essayé de mettre comme indiqué l'omission des stack de frames dans les options du compilateur comme ceci :

Pièce jointe 602093

cela ne change rien du tout ...
22/07/2021, 21h46
Astraya

Au lieu de jouer avec les options, fais marcher ton code avec les options par défaut
23/07/2021, 15h13
ArnaudNRoses

Je l ai fait, j'avais refait un projet/solution avec les options par défaut du compilateur et éditeur de lien, rien n' y a fait et ceci sur 3 ordis différents, un win 7, un win 8.1 et l'autre win 10 , c 'est toujours pareil !!!!!!

je crois je vais attendre de finir ma versions en classes pour voir si ça change...

c'est gentil de chercher à m aider en tout cas ...

P;S : Est ce que un petit excès de inline utilisé à la place des macros peut être à l'origine de mon pb ????
23/07/2021, 17h41
dalfab
Non, ça ne peut-être que mieux.

Je vais me répéter mais ce qui fait qu'un programme release n'a le même comportement qu'en debug, c'est que le code contient des "comportements indéfinis", autrement dit des actions qui ont un résultat imprévisible. Et ici l'aléatoire donne un résultat qui semble correct en debug, et qui ne l'est clairement pas en release. Un exemple:
Code:

1 2 3 4 5 6 7 int main() { int i; if ( i != 0 ) std::cout << "hello"; else std::cout << "ciao"; }
Ce code peut tout à fait afficher "hello" en debug et "ciao" en release, ou l'inverse ou autre. Si tu voulais "hello" tu diras ma version debug marche, celle release ne marche pas. Mais l'erreur est dans le code qui n'a jamais initialisé i.
24/07/2021, 15h28
ArnaudNRoses

bonjour, mon programme n'as pas l'air d'avoir de situation indéfinie, car un endroit précis, il agit toujours de la même manière, j initialise tout, et je laisse pas "conceptuellement" ce cas s'insérer dans mes programmes. et la seule différence, c est que sur la version win 7 j ai des messages d'erreurs de la sdl qui me dit que les threads n'ont pu être instancies par manque de "ressources" (terme employé par la sdl ).
tout me semble bon dans mon prog.

P.S : en mettant la version release sans aucune optimisation, toutes mes variables locales au main "apparaissent " dans le debugger et j ai pu suivre le cheminement de mon programme, et je comprends pas, il agit, à un moment, comme un gros écrasement de pile qui signale rien au debugger...

P.P.S = quand la seule chose que je change dans mon projet release x64 c 'est de remplacer la directive préprocesseur de NDEBUG à _DEBUG tout marche impeccable...
26/07/2021, 03h07
ArnaudNRoses

En Fait, j ai trouvé la solution, j avais une ligne entre #ifdef _DEBUG et #endif _DEBUG qui ne devait pas s'y trouver , c'est tout bête et très logique par rapport à mon prog ( je mets toutes sortent de messages et "vérif." uniquement en debug par ce ce biais et je me suis trompé, ça m'a permis de faire de la lecture, j'adore la doc lol ...

ça me rassure j ai horreur des situations indéfinis, je fais tout pour les éviter, ça m'a permis d'en savoir plus sur les compilateurs et ect ...

j ai une dernière question à propos des cas indénis :

si je manipule un unsigned int8 NB donc plage qui va de 0 à 255, et que je fais NB = 0 puis après NB = NB -1, que devient mon unsigned int8 , -1 donc cas indéfini, donc bug, erreur ect , ou il se met au minimum de sa plage ç a d 0 et dans ce cas pour mon prog c'est bon ?????

Là tu dois aller lire la doc sur la two-complement representation des entiers.
Le dépassement des limites non signé sont des UB en C et C++, ce qui permets dans certaines situations d'autoriser le compilateur à faire des optimisations qu'il ne peut pas faire avec les versions signée car il DOIT gérer dans ce cas les dépassements.
Pour les versions signées c'est défini, c'est défini.
La représentation complément à deux fera la taf correctement ( Si ton système est bien en complément à deux, mais perso je n'ai jamais croisé autre chose )

Un exemple sur godbolt https://godbolt.org/z/r3cKchrn4
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include<cstdio> int main() { // Signed char est de [-128, 127] signed char i = -128; volatile signed char overflow_i = i-1; // Overflow de i, ça boucle printf("signed char overflow %i\n", overflow_i); // Signed char est de [0, 255] unsigned char j = 0; volatile unsigned char overflow_j = j-1; // Overflow de j, ça boucle aussi printf("unsigned char overflow %i\n", overflow_j); return 0; }

29/07/2021, 20h54
Kannagi

Citation:

Envoyé par ArnaudNRoses

J ai effectivement mis l'optimisation pour un code plus rapide, car c est un jeu "en temps réel" ( un shoot them up ), je sais pas il optimise comme tu dis, vu qu 'il manque vraiment beaucoup de variables locales dans le visualiseur des variables du débuggeur , même mes littérateurs dans les boucle for , alors que le programme fonctionne quand même sans planter. pour visual studio et mon pc mon programme plante pas et fais pas d'exceptions ( lol d'ailleurs !!!), il manque juste beaucoup de décors, les threads se lance pas ect....

la fonction qui pose problème, c est le main ... et que elle d'après IntelliSense de chez bilou...

Je pourrais quote un autre message , mais c'est représentatif de tes messages , c'est écrit un peu comme "oui mais je fais un truc spécial et complexe" , alors déjà pas mal de monde d'ici on fait du jeux vidéo en pro :)
Et sinon non un shoot them up n'est pas incroyable à faire et ça ne demande rien de spécial qu'un autre jeu actuellement , vu que j'en ai fait un sur une pauvre SNES.

Même si sur PC tu es beaucoup plus à l'aise et normalement ça devrait jamais ramer , sauf si tu programme avec des pieds :D

Citation:

Envoyé par ArnaudNRoses

dans la pile, J ai beaucoup de tableaux à 2 ou 3 dimensions qui sont que des pointeurs ( 8 octets ) et ces pointeurs pointent sur des objets alloués eux dynamiquement dans dans le tas

Étonnant que personne ne l'est souligné , mais y'a de grande chose que c'est l'origine du bug , utilise un debuggeur , vu que ton soucis semble vraiment être un segfault :)