Mémory en C++

Signaler
-
Je dois faire un memory son et image pour un projet sauf que :
A l'aide mon programme est à présenté lundi et il y a des beug à partir du niveau 1 et le son beug aussi, est ce que quelqu'un pourrait m'ader à le rendre parfait ?

Voici mon code en C++ :

#include "main.h"

SDL_Surface *brouge, *bbleu, *bvert, *bjaune, *particler, *particleb, *particlev, *particlej,*background, *niveau;
SDL_Rect cbackground, clevel, crouge, cbleu, cvert, cjaune; //cbouttons[3]; // PROBLEME ETRANGE: s'il n'y a rien entre 'clevel' et 'cbouttons3', ça bug. Lié a la mémoire
FMOD_SOUND *notes[4], *erreur, *reussie;
FMOD_SYSTEM *system1;

int loop;

void blit_scene(SDL_Surface *screen){
SDL_BlitSurface(background, NULL, screen, &cbackground);
SDL_BlitSurface(brouge, NULL, screen, &crouge);
SDL_BlitSurface(bbleu, NULL, screen, &cbleu);
SDL_BlitSurface(bvert, NULL, screen, &cvert);
SDL_BlitSurface(bjaune, NULL, screen, &cjaune);
SDL_BlitSurface(niveau, NULL, screen, &clevel);
return;
}

void playsound(int son){
if(son>5)return;
switch(son)
{
case 0:
FMOD_System_PlaySound(system1, FMOD_CHANNEL_FREE, notes[son], 0, NULL);
break;

case 1:
FMOD_System_PlaySound(system1, FMOD_CHANNEL_FREE, notes[son], 0, NULL);
break;

case 2:
FMOD_System_PlaySound(system1, FMOD_CHANNEL_FREE, notes[son], 0, NULL);
break;

case 3:
FMOD_System_PlaySound(system1, FMOD_CHANNEL_FREE, notes[son], 0, NULL);
break;

case 4:
FMOD_System_PlaySound(system1, FMOD_CHANNEL_FREE, erreur, 0, NULL);
break;

case 5:
FMOD_System_PlaySound(system1, FMOD_CHANNEL_FREE, reussie, 0, NULL);
break;

}
return;
}

int main ( int argc, char** argv )
{

int screenx =GetSystemMetrics(SM_CXSCREEN); // RECUPERER DIMENSIONS ECRAN
int screeny =GetSystemMetrics(SM_CYSCREEN);

srand (time(NULL));

// initialisation de la SDL
if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
{
fprintf(stderr, "Erreur lors de l'initialisation de la SDL: %s\n", SDL_GetError() );
return 1;
}

// initialisation de SDL TTF
if(TTF_Init() == -1)
{
fprintf(stderr, "Erreur lors de l'initialisation de TTF : %s\n", TTF_GetError());
exit(EXIT_FAILURE);
}

// make sure SDL cleans up before exit
atexit(SDL_Quit);

// créer la fenêtre
SDL_Surface* screen = SDL_SetVideoMode(screenx, screeny, 32, SDL_FULLSCREEN|SDL_DOUBLEBUF);
if ( !screen )
{
fprintf(stderr, "Erreur lors du parametrage de l'ecran: %s\n", SDL_GetError());
return 1;
}


// INITIALISATION DU SON /////////////////////////
FMOD_SYSTEM *system;
FMOD_SOUND *musique;

FMOD_RESULT resultat, resultat1, resultat2, resultat3, resultat4, resultat5, resultat6;

FMOD_System_Create(&system1);
FMOD_System_Init(system1, 128, FMOD_INIT_NORMAL, NULL);

resultat = FMOD_System_CreateSound(system1, "Sons/music1.mp3", FMOD_SOFTWARE | FMOD_2D | FMOD_LOOP_NORMAL, 0, &musique);
//resultat = FMOD_System_CreateSound(system, "music1.mp3", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM, 0, &musique);
FMOD_Sound_SetLoopCount(musique, -1);

resultat1 = FMOD_System_CreateSound(system1, "Sons/0.mp3", FMOD_CREATESAMPLE, 0, ¬es[0]);
resultat2 = FMOD_System_CreateSound(system1, "Sons/1.mp3", FMOD_CREATESAMPLE, 0, ¬es[1]);
resultat3 = FMOD_System_CreateSound(system1, "Sons/2.mp3", FMOD_CREATESAMPLE, 0, ¬es[2]);
resultat4 = FMOD_System_CreateSound(system1, "Sons/3.mp3", FMOD_CREATESAMPLE, 0, ¬es[3]);
resultat5 = FMOD_System_CreateSound(system1, "Sons/erreur.mp3", FMOD_CREATESAMPLE, 0, &erreur);
resultat6 = FMOD_System_CreateSound(system1, "Sons/win.mp3", FMOD_CREATESAMPLE, 0, &reussie);


//FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, musique, 0, NULL);

////////////////////////////////////////////////////////////
/* DIVERSES VARIABLES NECESSAIRES */
SDL_Event event;

bool quitter false, win true, entre= false;

int difficulte = 2;
int suite_memory[99];
int suite_entre[99];
int etape = 0;
int level 0, ei 0;
char tNiveau[9];

Uint32 t_start 0, t_lastup 0, t_framerate = 0;
int frame 0, framerate 0, i=0; // image par seconde
int ypos = screeny-(screeny*0.25);
int xpos xpos screenx/4;

///////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////
/* CHARGEMENT POLICE */
TTF_Font *police = TTF_OpenFont(".//graphics//police1.ttf", 50);
TTF_Font *police2 = TTF_OpenFont(".//graphics//robotaura.ttf", 50);
SDL_Color cDefault = {200, 50, 0};
SDL_Color cSelected = {0, 0, 250};
////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////
/* CHARGEMENT IMAGES */
background = IMG_Load (".//graphics//background2.png");
brouge = IMG_Load (".//graphics//bred.png");
bbleu = IMG_Load (".//graphics//bblue.png");
bvert = IMG_Load (".//graphics//bgreen.png");
bjaune = IMG_Load (".//graphics//byellow.png");
particler = IMG_Load (".//graphics//particler.png");
particleb = IMG_Load (".//graphics//particleb.png");
particlev = IMG_Load (".//graphics//particlev.png");
particlej = IMG_Load (".//graphics//particlej.png");

if ( !background || !brouge || !bbleu || !bvert || !bjaune || !particler || !particleb || !particlev || !particlej)
{
fprintf (stderr, "IMG_Load: %s\n", IMG_GetError () );
return 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////

SDL_Surface *tOption1, *tOption2;
SDL_Rect posOption[2];

tOption1 = TTF_RenderText_Blended(police, "Jouer", cDefault);
posOption[0].x = (screenx / 2) - (tOption1->w/2);
posOption[0].y = ((screeny / 2) - (tOption1->h/2)) - 100;

tOption2 = TTF_RenderText_Blended(police, "Quitter", cDefault);
posOption[1].x = (screenx / 2) - (tOption2->w/2);
posOption[1].y = (screeny / 2) - (tOption2->h/2);

menu:

SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_BlitSurface(background, NULL, screen, &cbackground);
SDL_BlitSurface(tOption1, NULL, screen, &posOption[0]);
SDL_BlitSurface(tOption2, NULL, screen, &posOption[1]);
SDL_Flip(screen);

SDL_Delay(3000);

/////////////////////////////////////////////////////////////
/* Positionnement des images */

clevel.x = 20;
clevel.y = 20;
cbackground.x = 0;
cbackground.y = 0;
//background->w = screenx;
//background->h = screeny;
//SDL_ResizeXY(background, screenx,screeny, 7);

crouge.x = xpos;
crouge.y = ypos;
cbleu.x = xpos+200;
cbleu.y = ypos;
cvert.x = xpos+400;
cvert.y = ypos;
cjaune.x = xpos+600;
cjaune.y = ypos;
/////////////////////////////////////////////////////////////////////////////

SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);

sprintf(tNiveau, "Niveau %d", level);
niveau = TTF_RenderText_Blended(police2, tNiveau, cDefault);


int loop = 0;
particules particule1[MAX_PARTICLES];

for (loop=0; loop<MAX_PARTICLES; loop++) // Boucle pour dessiner toute les particules
{
particule1[loop].position.x = screenx/2;
particule1[loop].position.y = (screeny/2)-50;
}


for(i=0; i <= difficulte; i++) // Génération aléatoire de la suite de couleurs
{
suite_memory[i] = rand()%4; // Generer un nombre compris entre 0 et 4 (exclu)
if(i>=1){
while(suite_memory[i] == suite_memory[i-1])suite_memory[i] = rand()%4; // Pour éviter d'avoir 2 fois la même couleur de suite
}

}

t_start = SDL_GetTicks(); // enregistre le temps T0, on commence le jeu
t_lastup = t_start;

//playsound(suite_memory[0]);
while(!quitter)
{


SDL_PollEvent(&event);

switch(event.type)
{
case SDL_QUIT:
quitter = true;
break;

case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_ESCAPE: /* Appui sur la touche Echap, on arrête le programme */
quitter = true;
break;

default:
break;
}
break;
}


if(SDL_GetTicks()-t_lastup >= 2000)
{
if(etape == difficulte)
{

SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
blit_scene(screen);
SDL_Flip(screen);


/* Test la mémoire du joueur*/
ei=0;
entre = false;
while(!entre)
{
SDL_Delay(4);
//SDL_PollEvent(&event);
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
entre = true;
quitter = true;
goto quitter;
break;

case SDL_MOUSEBUTTONUP:
if(ei <= difficulte){
if(event.motion.x >= crouge.x && event.motion.x <= crouge.x + 150 && event.motion.y >= crouge.y && event.motion.y <= crouge.y + 150)
{
playsound(0);
suite_entre[ei]=0;
ei++;
}

else if(event.motion.x >= cbleu.x && event.motion.x <= cbleu.x + 150 && event.motion.y >= cbleu.y && event.motion.y <= cbleu.y + 150)
{
playsound(1);
suite_entre[ei]=1;
ei++;
}

else if(event.motion.x >= cvert.x && event.motion.x <= cvert.x + 150 && event.motion.y >= cvert.y && event.motion.y <= cvert.y + 150)
{
playsound(2);
suite_entre[ei]=2;
ei++;
}

else if(event.motion.x >= cjaune.x && event.motion.x <= cjaune.x + 150 && event.motion.y >= cjaune.y && event.motion.y <= cjaune.y + 150)
{
playsound(3);
suite_entre[ei]=3;
ei++;
}

entre = false;

}
else entre = true;
break;

case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_ESCAPE: /* Appui sur la touche Echap, on arrête le programme */
entre = true;
goto quitter;
break;

default:
break;
}
break;
}
}
/* Fin de test, on procède a la vérification */

for(i=0; i < difficulte; i++)
{
if(suite_memory[i] != suite_entre[i])
{
win=false;
break;
}
else win = true;

}




/* Si tout est juste, on continue*/
if(win)
{
playsound(5);
level++;
difficulte++;
sprintf(tNiveau, "Niveau %d", level);
niveau = TTF_RenderText_Blended(police2, tNiveau, cDefault);
etape = 0;
entre = false;
ei = 0;

for(i=0; i <= difficulte; i++) // Génération aléatoire de la suite de couleurs
{
suite_memory[i] = rand()%4; // Generer un nombre compris entre 0 et 4 (exclu)
if(i>=1){
while(suite_memory[i] == suite_memory[i-1])suite_memory[i] = rand()%4; // Pour éviter d'avoir 2 fois la même couleur de suite
}
}
}
else
{
playsound(4);
level = 0;
difficulte = 2;
etape = 0;
entre = false;
ei = 0;
//goto menu; /* Sinon on repart au menu */

}

}
else etape++;
frame = 0;
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

blit_scene(screen);

SDL_Flip(screen);
SDL_Delay(1000);

for (loop=0; loop<MAX_PARTICLES; loop++) // Remettre les particules au point de départ
{
particule1[loop].position.x = screenx/2;
particule1[loop].position.y = (screeny/2)-50;
}


switch(suite_memory[etape])
{
case 0: // Si c'est rouge
playsound(0);
break;

case 1: // Si c'est bleu
playsound(1);
break;

case 2: // Si c'est vert
playsound(2);
break;

case 3: // Si c'est jaune
playsound(3);
break;

}
t_lastup = SDL_GetTicks(); // Enregistre le temps de la derniere mise a jour
}

SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
blit_scene(screen);

for (loop=0; loop<MAX_PARTICLES; loop++) // Boucle pour dessiner toute les particules
{

switch(suite_memory[etape])
{
case 0: // Si c'est rouge
SDL_BlitSurface(particler, NULL, screen, &particule1[loop].position);
break;

case 1: // Si c'est bleu
SDL_BlitSurface(particleb, NULL, screen, &particule1[loop].position);
break;

case 2: // Si c'est vert
SDL_BlitSurface(particlev, NULL, screen, &particule1[loop].position);
break;

case 3: // Si c'est jaune
SDL_BlitSurface(particlej, NULL, screen, &particule1[loop].position);
break;

}

/* Ici faut mettre les calculs mathématiques pour avoir les positions des particules */

float V = (float((rand()%9))+1);
float Angle = float(rand()%360);

particule1[loop].xi = sin(Angle) * V;
particule1[loop].yi = cos(Angle) * V;

particule1[loop].position.x+=particule1[loop].xi; // Vitesse
particule1[loop].position.y+=particule1[loop].yi; // Vitesse

//particule1[loop].xi*=0.2;
//particule1[loop].yi*=0.2;
}



frame++;


SDL_Flip(screen);
SDL_Delay(4);



}


quitter:

int k=0;
while(k<3)
{
//FMOD_Sound_Release(notes[k]); // Libère les sons un par un
k++;
}

FMOD_Sound_Release(reussie);
FMOD_Sound_Release(erreur);
FMOD_Sound_Release(musique);
FMOD_System_Close(system);
FMOD_System_Release(system);

TTF_CloseFont(police);
TTF_CloseFont(police2);
TTF_Quit();

SDL_FreeSurface(background);
SDL_FreeSurface(particler);
SDL_FreeSurface(particleb);
SDL_FreeSurface(particlev);
SDL_FreeSurface(particlej);
SDL_FreeSurface(brouge);
SDL_FreeSurface(bbleu);
SDL_FreeSurface(bvert);
SDL_FreeSurface(bjaune);


SDL_Quit();
return 0;
}