[Résolu] Besoin d'un petit coup de main - mémoire et SDL avec des "class" par GimralasQS - page 1

Bonjour, tout d'abord j'aimerais remercier M@teo21. Ses cours sont vraiment facile à comprendre et très agréable à lire.

Alors, je me suis lancé pour entrainement dans un petit jeu SDL (j'ai fini tout le cours

)
Je suis un maniaque de la mémoire :-°

et je me suis rendu compte de qqch et j'aimerais savoir si c'est normal.

Faire bouger la souris crée des centaines d'évenements mais est-ce normal que la mémoire utilisée par l'ordi s'accumule à cause de cela ? En effet, après quelques mouvement de souris la memoire grimpe déjà à 100 mb d'utilisé alors que mon jeu n'en prend que pour l'instant que 8mb ! o_O

Aussi, j'ai une class "Heros" (et une "Fenetre" mais ca on s'en fout un peu :-°

). Cette class "Heros" utilise entre autre une méthode "deplacer" et une autre "sauter". A l'interieur de ces méthodes, je déclare et utilise quelques variables notamment pour la fonction sauter qui utilise SDL_GetTicks(). Et alors là aussi, le fait de faire déplacer mon personnage ou de le faire sauter accumule quelques dizaine d'Mb de mémoire au fur et à mesure du déplacement ! o_O

Je vous le redemande : "est-ce normal ?" :euh:

Merci d'avance

Re-salut,
voilà je vous fournit un partie de mon code à savoir le main et la class "Heros". Je vous re-signale aussi que je fais du c++ depuis 2 ou 3 semaine et donc je ne code peut-etre pas très "proprement"...

------------------------------------------------------------------------------------------------------- main.cpp
#include <iostream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include "constantes.hpp"
#include "createur.hpp"
#include "Heros.hpp"
#include "Fenetre.hpp"
#include <string>
using namespace std;

int main(int argc, char *argv[])
{
preparation();

SDL_Event event;
bool power = true;

SDL_Init(SDL_INIT_VIDEO);
TTF_Init();

Fenetre fenetre;

Heros gimralas;

bool vie = true;

SDL_EnableKeyRepeat(10, 70);

while(power)
{
SDL_WaitEvent(&event);

switch(event.type)
{
case SDL_QUIT: power = false;
break;
case SDL_KEYDOWN: switch(event.key.keysym.sym)
{
case SDLK_RIGHT: gimralas.deplacer(AVANT);
break;
case SDLK_LEFT: gimralas.deplacer(ARRIERE);
break;
case SDLK_v: if(vie)
{
vie = false;
}
else
{
vie = true;
}
break;
}
break;
case SDL_KEYUP: switch(event.key.keysym.sym)
{
case SDLK_RIGHT: gimralas.setMove();
break;
case SDLK_LEFT: gimralas.setMove();
break;
case SDLK_SPACE: gimralas.sauter(fenetre);
break;
}
break;
}

fenetre.afficherFond();
gimralas.afficherImage(fenetre);
if(vie)
{
gimralas.afficherVie(fenetre);
}

fenetre.miseAJour();
}

TTF_Quit();
SDL_Quit();

return EXIT_SUCCESS;
}

------------------------------------------------------------------------------------------------------ Heros.hpp
#ifndef DEF_C_HEROS
#define DEF_C_HEROS

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include "constantes.hpp"
#include "createur.hpp"
#include "Fenetre.hpp"

class Heros
{
private:

long m_vie;
long m_etat;
SDL_Rect m_positionHeros;
SDL_Surface *m_image[6];
bool m_deplacement[2];

public:

Heros();
~Heros();
void deplacer(bool);
void sauter(class Fenetre& fenetre);
void afficherImage(class Fenetre& fenetre);
void setMove(bool move = false, bool direction = false);
void afficherVie(class Fenetre& fenetre);
};

#endif
----------------------------------------------------------------------------------------------------Heros.cpp

#include <iostream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include <FMOD/fmod.h>
#include "constantes.hpp"
#include "createur.hpp"
#include "Heros.hpp"
#include "Fenetre.hpp"
#include <string>
using namespace std;

Heros::Heros() : m_vie(100), m_etat(DROITE_N)
{
m_positionHeros.x = LARGEUR_F/4;
m_positionHeros.y = HAUTEUR_F/2 + (HAUTEUR_F/3 - HAUTEUR_F/2)/2;

m_image[DROITE_N] = IMG_Load("images/herosavant_n.png");
SDL_SetColorKey(m_image[DROITE_N], SDL_SRCCOLORKEY, SDL_MapRGB(m_image[DROITE_N]->format, 0, 255, 255));
m_image[DROITE_G] = IMG_Load("images/herosavant_g.png");
SDL_SetColorKey(m_image[DROITE_G], SDL_SRCCOLORKEY, SDL_MapRGB(m_image[DROITE_G]->format, 0, 255, 255));
m_image[DROITE_D] = IMG_Load("images/herosavant_d.png");
SDL_SetColorKey(m_image[DROITE_D], SDL_SRCCOLORKEY, SDL_MapRGB(m_image[DROITE_D]->format, 0, 255, 255));
m_image[GAUCHE_N] = IMG_Load("images/herosarriere_n.png");
SDL_SetColorKey(m_image[GAUCHE_N], SDL_SRCCOLORKEY, SDL_MapRGB(m_image[GAUCHE_N]->format, 0, 255, 255));
m_image[GAUCHE_G] = IMG_Load("images/herosarriere_g.png");
SDL_SetColorKey(m_image[GAUCHE_G], SDL_SRCCOLORKEY, SDL_MapRGB(m_image[GAUCHE_G]->format, 0, 255, 255));
m_image[GAUCHE_D] = IMG_Load("images/herosarriere_d.png");
SDL_SetColorKey(m_image[GAUCHE_D], SDL_SRCCOLORKEY, SDL_MapRGB(m_image[GAUCHE_D]->format, 0, 255, 255));

m_deplacement[0] = false;
m_deplacement[DIRECTION] = false;
}

Heros::~Heros()
{
for(int i = 0 ; i < 6 ; i++)
{
SDL_FreeSurface(m_image[i]);
}
}

void Heros::deplacer(bool direction)
{
static bool i = false;

setMove(true, direction);

if(m_deplacement[DIRECTION])
{
switch(m_etat)
{
case DROITE_N: if(i)
{
m_etat = DROITE_G;
}
else
{
m_etat = DROITE_D;
}
break;
case DROITE_G: m_etat = DROITE_N; i = false;
break;
case DROITE_D: m_etat = DROITE_N; i = true;
break;
default: m_etat = DROITE_N; i = true;
break;
}
m_positionHeros.x+=12;
if(m_positionHeros.x > LARGEUR_F - 60)
{
m_positionHeros.x-=12;
}
}
else
{
switch(m_etat)
{
case GAUCHE_N: if(i)
{
m_etat = GAUCHE_G;
}
else
{
m_etat = GAUCHE_D;
}
break;
case GAUCHE_G: m_etat = GAUCHE_N; i = false;
break;
case GAUCHE_D: m_etat = GAUCHE_N; i = true;
break;
default: m_etat = GAUCHE_N; i = true;
break;
}
m_positionHeros.x-=12;
if(m_positionHeros.x < 10)
{
m_positionHeros.x+=12;
}
}
}

void Heros::sauter(Fenetre& fenetre)
{
long tempsActuel = 0, tempsPrecedent = 0;
bool saut = true;
long debutSaut = SDL_GetTicks();
while(saut != false)
{
tempsActuel = SDL_GetTicks();
if(tempsActuel <= debutSaut+500)
{
if(tempsActuel-tempsPrecedent >= 25)
{
m_positionHeros.y-=5;
if(m_deplacement[0] && m_deplacement[DIRECTION])
{
m_positionHeros.x+=5;
}
else if(m_deplacement[0] && m_deplacement[DIRECTION] == false)
{
m_positionHeros.x-=5;
}
fenetre.afficherFond();
afficherImage(fenetre);
afficherVie(fenetre);
tempsPrecedent = tempsActuel;
}
else
{
SDL_Delay(25-(tempsActuel-tempsPrecedent));
}
}
else if(tempsActuel > debutSaut+500 && tempsActuel <= debutSaut+1025)
{
if(tempsActuel-tempsPrecedent >= 25)
{
m_positionHeros.y+=5;
if(m_deplacement[0] && m_deplacement[DIRECTION])
{
m_positionHeros.x+=5;
}
else if(m_deplacement[0] && m_deplacement[DIRECTION] == false)
{
m_positionHeros.x-=5;
}
fenetre.afficherFond();
afficherImage(fenetre);
afficherVie(fenetre);
tempsPrecedent = tempsActuel;
}
else
{
SDL_Delay(25-(tempsActuel-tempsPrecedent));
}
}
else
{
saut = false;
}

fenetre.miseAJour();
}
}

void Heros::afficherImage(Fenetre& fenetre)
{
SDL_BlitSurface(m_image[m_etat], NULL, fenetre.getEcran(), &m_positionHeros);
}

void Heros::setMove(bool move, bool direction)
{
m_deplacement[0] = move;
m_deplacement[DIRECTION] = direction;
}

void Heros::afficherVie(Fenetre& fenetre)
{
TTF_Font *police = NULL;
police = TTF_OpenFont("polices/comicsansms.ttf", 25);
char vie[10] = "";
sprintf(vie, "Vie: %d", m_vie);
SDL_Color couleurVie = {255, 0, 0};
SDL_Surface *texteVie = NULL;
texteVie = TTF_RenderText_Blended(police, vie, couleurVie);
SDL_Rect positionVie;
positionVie.x = 25;
positionVie.y = 25;
TTF_CloseFont(police);
SDL_BlitSurface(texteVie, NULL, fenetre.getEcran(), &positionVie);
}
-----------------------------------------------------------------------------------------

Voilà, si jamais le problème persiste ... j'ai encore le "createur.hpp", "createur.cpp", "Fenetre.hpp", "Fenetre.cpp" et le "constantes.hpp" !

le probleme se trouve donc dans la dernière colonne (utilisation mémoire qui augmente sans cesse au mouvement de souris et d'utilisation de méthode de Heros.

GimralasQS

7 juin 2007 à 18:30:18

Nanoc

7 juin 2007 à 19:39:21

Et je t'y réponds : Non, évidemment

Mais pour pouvoir t'aider, il va nous falloir un bout de code.

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

8 juin 2007 à 7:13:37

neuneutrinos

8 juin 2007 à 13:28:18

voila le probleme quand on ne compile pas fonction par fonction

(car meme le meilleur des programmeurs comet des erreurs)

essai de tester tes fichiers un à un (crée un autre main.cpp si nessessaire)

Anonyme

8 juin 2007 à 13:44:29

Tu ne libère pas la surface crée par TTF_RenderText_Blended dans afficherVie.
Et comme tu l'apelle plusieurs fois ==> ...

Neutrinos : Comment tu veux tester des fonctions une a une si elles sont interconnectées comme c'est le cas ici.

8 juin 2007 à 17:28:45

Eh ben ! Tout ce que peut faire un bête oubli de libération de surface

!

Merci beaucoup

Ps: je n'ai pas écrit tout ce code d'un coup, je teste toujours une fonction après l'avoir terminée, enfin j'essaie

Encore merci, collègue ou plutôt maître programmeur

8 juin 2007 à 18:16:39

Ecrit tout d'un coup , teste si ca semble marché et si oui fait un test avec un framework de test comme cppunit.

9 juin 2007 à 13:47:48

Merci

Besoin d'un petit coup de main

mémoire et SDL avec des "class"

Supprimer

Modérer

Signaler le message aux modérateurs