Partage
  • Partager sur Facebook
  • Partager sur Twitter

Besoin d'un petit coup de main

mémoire et SDL avec des "class"

Sujet résolu
7 juin 2007 à 18:30:18

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

Alors, je me suis lancé pour entrainement dans un petit jeu SDL (j'ai fini tout le cours :p )
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 ;)
  • Partager sur Facebook
  • Partager sur Twitter
7 juin 2007 à 19:39:21

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

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

Mais pour pouvoir t'aider, il va nous falloir un bout de code.
  • Partager sur Facebook
  • Partager sur Twitter
Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.
8 juin 2007 à 7:13:37

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" !

Image utilisateur


Image utilisateur



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.
  • Partager sur Facebook
  • Partager sur Twitter
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)
  • Partager sur Facebook
  • Partager sur Twitter
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.
  • Partager sur Facebook
  • Partager sur Twitter
8 juin 2007 à 17:28:45

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

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 :p:-°

Encore merci, collègue ou plutôt maître programmeur ^^
  • Partager sur Facebook
  • Partager sur Twitter
Anonyme
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.
  • Partager sur Facebook
  • Partager sur Twitter