IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

POO jeu 2D avec SDL2


Sujet :

C++

  1. #1
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut POO jeu 2D avec SDL2
    Bonjour,

    Je suis sur un premier projet assez simple de collisions entre balles, qui entrent en collisions comme sur un billard.

    L'utilisateur pourra :

    - Avant le début du jeu : définir le nombre initial de balles, et définir leur vitesses initiales et leur diamètre
    - faire un clic droit sur une balle, le jeu se met en pause (PauseState class) et la distance entre la souris et le centre de la balle définit le noveau diamètre de celle-ci et change sa masse.
    - faire un clic gauche sur une balle permet de la déplacer pour lui donner un nouveau vecteur vitesse, ou de la supprimer en la déplaçant sur le bord
    - cliquer sur le bouton RESET avec en sous menu un slider permettant de définir le nombre de balles (entre 2 et 150 par exemple, ça dépend du diamètre évidemment) et leur diamètre unique ou aléatoire (pour GUI vous me conseillez d'utiliser la librairier QT ?
    - Afficher en temps réels le nombre de collisions
    - Un Bouton "Gravity" permet d'activer la gravité ou la désactiver

    Pourriez vous me conseiller svp pour l'architecture ?

    Quelles classes pour le GUI ?

    J'ai déjà ces classes-là :
    - Game
    - GameState
    - PauseState , PlayState et MenuState (qui héritent de GameState).
    - Ltexture qui permet de dessiner dans SDL_Renderer et SDL_Rect
    - Button pour les boutons mais je préfèrerai faire une classe entière pour tout le GUI, qu'en pensez vous ?
    - BallManager, qui stocke entre autre un vector de Ball instances
    - Ball

    Voici mon main.cpp (ce n'est pas la version fonctionnelle, c'est juste pour vous donner une idée et je sais que toutes ces déclarations de variables n'ont pas forcément grand chose à faire là) :

    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
    #include "CONSTANTS.h"
    #include "Game.h"
    #include "MenuState.h"
    #include <iostream>
     
     
    char texte[15]; //utile pour convertir Balls::num_collisions en char, pour le rendu de texte dans le menu
     
    int rand_velocity_init_x, rand_velocity_init_y; //utilisé lors de la création d'instance de balles (vecteurs vitesse initiaux)
    int max_num_balls_per_row = (SCREEN_WIDTH/BALL_INIT_WIDTH)/2;
    int compteur_collisions = 0;
    int ball_image_init_width = BALL_INIT_IMAGE_WIDTH/2; //la largeur de balle propre à l'image initiale, avant changement de diamètre initial
     
    std::vector<Ball*> array_balls;
    std::vector<SDL_Rect> array_spriteBallsClips;
    Ball_manager* ball_manager1 = new Ball_manager(array_balls, array_spriteBallsClips, BALL_INIT_NUM, BALL_INIT_MIN_VELOCITY, BALL_INIT_MAX_VELOCITY);
    //Ball* balls[ball_manager1->m_num_balls] = {NULL};
    Button* buttons[Button::s_num] = {NULL};
     
    SDL_Event e;
    //Globally used font
    TTF_Font *gFont = NULL;
     
    LTexture gNumCollisionsTexteTexture, gButtonSpriteSheetTexture, gSubMenu0, gSpriteSheetBallsTexture, gBackground;
     
    SDL_Rect gSpriteButtonsClips[Button::s_num];
    //Starts up SDL and creates window
     
     
    int main(int argc, char* argv[])
    {
    	Game game;
     
    	game.Init("State Manager",SCREEN_WIDTH, SCREEN_HEIGHT, 32,false);
     
    	//game.ChangeState(MenuState::Instance());
     
    	while(game.Running())
    	{
    		game.HandleEvents();
    		game.Update();
    		game.Draw();
    	}
     
    	// cleanup the engine
    	game.Clean();
     
    	return 0;
    }
    Dans game.Init() vous me conseillez de dessiner le SDL_window, le SDL_Render, les SDL_Rect des balles et le GUI ? Enfin tout quoi ?

    Et dans game.Draw() je dessinerai les balles frame par frame

    Merci

  2. #2
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Bonjour à tous,

    Finalement j'ai remanié les classes de mon projet en suivant un tuto (toujours en cours), mais j'ai un crash que je n'arrive pas à expliquer.

    J'ai créé une classe CMain:

    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
    class CMain
    {
        public:
            CMain(void);
            ~CMain(void);
     
            void GameLoop();
            bool LoadMedia(void);
     
        private:
     
            bool quit;
            SDL_Window* window;
            SDL_Renderer* renderer;
            SDL_Event* mainEvent;
            LTexture spriteSheetBallsTexture, backgroundTexture; /*buttonSpriteSheetTexture, subMenu0Texture,*/
            int rand_velocity_init_x, rand_velocity_init_y; //utilisé lors de la création d'instance de balles (vecteurs vitesse initiaux)
            int max_num_balls_per_row, compteur_collisions;
            int ball_image_init_width;//la largeur de balle propre à l'image initiale, avant changement de diamètre initial
            std::vector<Ball*> array_balls;
            std::vector<SDL_Rect> array_spriteBallsClips;
            BallManager* ball_manager1;
     
    };

    Voici main.cpp :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include "MainClass.h"
     
    CMain cmain;
     
    int main(int argc, char *argv[])
    {
     
        cmain.LoadMedia();
        //cmain.GameLoop();
        return 0;
     
    }
    Le constructeur ne fait pas crasher le programme, pas de soucis
    Ce qui n'est pas le cas pour cmain.LoadMedia() :


    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
    bool CMain::LoadMedia(void)
    {
     
    	quit = false;
     
    	if( !spriteSheetBallsTexture.loadFromFile( "ressources/textures/balls.png", renderer) || !backgroundTexture.loadFromFile( "ressources/textures/background.jpg", renderer))
    	{
    		printf( "Failed to load sprite balls texture or background \n" );
    		quit = true;
    	}
    	else
    	{
     
                SDL_Rect rect;
     
                printf( "num : %d\n", ball_manager1->getNumBalls() );
     
            }
     
            return quit;
     
    	}
    Je sais que c'est ball_manager1->getNumBalls() qui fait crasher le programme.

    ball_manager1 a été créé dans le constructeur de CMain :


    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
    CMain::CMain(void)
    {
     
    ...
     
     
        mainEvent = new SDL_Event();
        int rand_velocity_init_x, rand_velocity_init_y; //utilisé lors de la création d'instance de balles (vecteurs vitesse initiaux)
        int max_num_balls_per_row = (SCREEN_WIDTH/BALL_INIT_WIDTH)/2;
        int ball_image_init_width = BALL_INIT_IMAGE_WIDTH/2; //la largeur de balle propre à l'image initiale, avant changement de diamètre initial
        int compteur_collisions = 0;
        std::vector<Ball*> array_balls;
        std::vector<SDL_Rect> array_spriteBallsClips;
        BallManager* ball_manager1 = new BallManager(array_balls, array_spriteBallsClips, BALL_INIT_NUM, BALL_INIT_MIN_VELOCITY, BALL_INIT_MAX_VELOCITY);
     
     
    }

    Enfin voici la classe BallManager et sa fonction getNumBalls :

    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
    class BallManager{
    public:
     
        BallManager(std::vector<Ball*> array_balls, std::vector<SDL_Rect> spriteBallsClips, int num_balls, int min_velocity, int max_velocity);
     
        ~BallManager();
     
        void addBall(std::vector<Ball*> array_balls);
        void addMultiBalls(std::vector<Ball*> array_balls);
        bool collision(Ball* ball1, std::vector<Ball*> array_balls);
     
        int getNumBalls(void);
        void setNumBalls(int nb_b);
        int getNumCollisions(void);
        void setNumCollisions(int nc);
     
      //Ball* array_balls;
        std::vector<Ball*> m_array_balls;
        std::vector<SDL_Rect> m_spriteBallsClips;
     
        int m_min_velocity;
        int m_max_velocity;
     
    private:
     
        int m_num_collisions;
        int m_num_balls;
     
    };
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int BallManager::getNumBalls(void){
        return m_num_balls;
    }
    A votre avis pourquoi ball_manager1->getNumBalls() fait crasher le programme ?

  3. #3
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2006
    Messages
    780
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : Mai 2006
    Messages : 780
    Points : 1 176
    Points
    1 176
    Par défaut
    dans le constructor de CMAIN:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    this->ball_manager1 = new BallManager(array_balls, array_spriteBallsClips, BALL_INIT_NUM, BALL_INIT_MIN_VELOCITY, BALL_INIT_MAX_VELOCITY);

    , plutôt non?

    Bon par contre ton code ressemble à un mélange de C et de C++ (pourquoi printf ?) et pourquoi tous ces pointeurs (nus en plus) ?

    En C++ on essaye de savoir qui a la responsabilité de quoi. Un objet a la responsabilité de la création et de la suppression d'un autre objet. C'est le comportement par défaut qui évite les bugs.

    Si on a besoin de pointeurs (création différée de l'objet, polymorphisme ), on utilisera des pointeurs intelligents qui évitent de faire des new/delete.

    Mais le comportement par défaut devrait être: pas de pointeur.

  4. #4
    Expert éminent sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2005
    Messages
    27 369
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2005
    Messages : 27 369
    Points : 41 518
    Points
    41 518
    Par défaut
    Tu redéclares ball_manager1 dans le constructeur de CMain, en tant que variable locale, au lieu d'initialiser ta variable membre.
    Supprime le type BallManager* au début de ta ligne, et ça devrait marcher.

    PS: Si tu as accès à C++11, tu devrais utiliser des pointeurs intelligents plutôt que des pointeurs nus.
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

  5. #5
    Membre éprouvé
    Profil pro
    Inscrit en
    Mai 2006
    Messages
    780
    Détails du profil
    Informations personnelles :
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : Mai 2006
    Messages : 780
    Points : 1 176
    Points
    1 176
    Par défaut
    Citation Envoyé par Médinoc Voir le message
    PS: Si tu as accès à C++11, tu devrais utiliser des pointeurs intelligents plutôt que des pointeurs nus.
    ou pas de pointeur si possible... et des références, ou référence+const.

  6. #6
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    Et tant qu'à faire, utiliser la SFML plutôt que la SDL, non ?
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  7. #7
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Bonjour,

    Merci pour vos réponses.

    Pourquoi faut il utiliser le "this->" quand on donne une valeur à chaque variable membre dans le constructeur, vu que s'en passer fonctionne aussi ?

    Citation Envoyé par JolyLoic Voir le message
    Et tant qu'à faire, utiliser la SFML plutôt que la SDL, non ?
    Salut JolyLoic,

    J'ai lu que SFML etait mal fichue pour les entrées clavier et souris. Tu es d'accord avec ça ?

    Pourquoi me conseilles-tu SFML plutôt que SDL2 ?


    EDIT :

    J'ai fait les modifs que vous m'avez conseillées (ormis pour les pointeurs que je compte faire plus tard). Et ça crashe cette fois-ci, à cause de

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    BallManager::BallManager(std::vector<Ball*> array_balls, std::vector<SDL_Rect> spriteBallsClips , int num_balls, int min_velocity, int max_velocity){
     
        ...
        this->m_num_balls = num_balls;
        ...
     
    }
    _____________
    _____________


    Je vous remontre le code de tout mon projet, pour que rien ne vous échappe :

    main.cpp :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
     
    #include "MainClass.h"
     
    CMain cmain;
     
    int main(int argc, char *argv[])
    {
     
        return 0;
     
    }
    MainClass.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
    #ifndef MAIN_CLASS_H
    #define MAIN_CLASS_H
     
    #include <SDL_image.h>
    #include <SDL_ttf.h>
    #include <cstdlib>
    #include <ctime>
    #include <stdio.h>
    #include <cstdlib>
    #include <vector>
    #include <math.h>
     
    #include "MainClass.h"
    #include "CONSTANTS.h"
    #include "LTexture.h"
    #include "BallManager.h"
    #include "Ball.h"
     
    class CMain
    {
        public:
            CMain(void);
            ~CMain(void);
     
            void GameLoop();
            bool LoadMedia(void);
     
        private:
     
            bool m_quit;
            SDL_Window* m_window;
            SDL_Renderer* m_renderer;
            SDL_Event* m_mainEvent;
            LTexture m_spriteSheetBallsTexture, m_backgroundTexture; /*buttonSpriteSheetTexture, subMenu0Texture,*/
            int m_rand_velocity_init_x, m_rand_velocity_init_y; //utilisé lors de la création d'instance de balles (vecteurs vitesse initiaux)
            int m_max_num_balls_per_row, m_compteur_collisions;
            int m_ball_image_init_width;//la largeur de balle propre à l'image initiale, avant changement de diamètre initial
            std::vector<Ball*> m_array_balls;
            std::vector<SDL_Rect> m_array_spriteBallsClips;
            BallManager* m_ball_manager1;
     
    };
    #endif
    MainClass.cpp : (Que le constructeur)

    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
    #include "MainClass.h"
     
    CMain::CMain(void)
    {
        this->m_quit = false;
        this->m_window = NULL;
     
    	//Initialize SDL
    	if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    	{
    		printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
    		this->m_quit = true;
    	}
    	else
    	{
    		//Set texture filtering to linear
    		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
    		{
    			printf( "Warning: Linear texture filtering not enabled!" );
    		}
     
    		//Create window
    		this->m_window = SDL_CreateWindow( "Colliding Balls", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
    		if( this->m_window == NULL )
    		{
    			printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
    			this->m_quit = true;
    		}
    		else
    		{
    			//Create renderer for window
    			this->m_renderer = SDL_CreateRenderer( this->m_window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC );
     
    			if( m_renderer == NULL )
    			{
    				printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
    				this->m_quit = true;
    			}
    			else
    			{
    				//Initialize renderer color
    				SDL_SetRenderDrawColor( this->m_renderer, 0xFF, 0xFF, 0xFF, 0xFF );
     
    				//Initialize PNG loading
    				int imgFlags = IMG_INIT_PNG;
    				if( !( IMG_Init( imgFlags ) & imgFlags ) )
    				{
    					printf( "SDL_image could not initialize! SDL_mage Error: %s\n", IMG_GetError() );
    					this->m_quit = true;
    				}
     
    				 //Initialize SDL_ttf
    				if( TTF_Init() == -1 )
    				{
    					printf( "SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError() );
    					this->m_quit = true;
    				}
     
    			}
    		}
    	}
     
     
        this->m_mainEvent = new SDL_Event();
        this->m_max_num_balls_per_row = (SCREEN_WIDTH/BALL_INIT_WIDTH)/2;
        this->m_ball_image_init_width = BALL_INIT_IMAGE_WIDTH/2; //la largeur de balle propre à l'image initiale, avant changement de diamètre initial
        this->m_compteur_collisions = 0;
     
        this->m_ball_manager1 = new BallManager(this->m_array_balls, this->m_array_spriteBallsClips, BALL_INIT_NUM, BALL_INIT_MIN_VELOCITY, BALL_INIT_MAX_VELOCITY);
     
     
     
    }
    BallManager.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
    #ifndef BALL_MANAGER_H
    #define BALL_MANAGER_H
     
    #include <SDL.h>
    #include <stdio.h>
    #include <cstdlib>
    #include <vector>
    #include <ctime>
    #include <math.h>
     
    #include "Ball.h"
     
    class BallManager{
    public:
     
        BallManager(std::vector<Ball*> array_balls, std::vector<SDL_Rect> spriteBallsClips, int num_balls, int min_velocity, int max_velocity);
     
        ~BallManager();
     
        void addBall(std::vector<Ball*> array_balls);
        void addMultiBalls(std::vector<Ball*> array_balls);
        bool collision(Ball* ball1, std::vector<Ball*> array_balls);
     
        int getNumBalls(void);
        void setNumBalls(int nb_b);
        int getNumCollisions(void);
        void setNumCollisions(int nc);
     
      //Ball* array_balls;
        std::vector<Ball*> m_array_balls;
        std::vector<SDL_Rect> m_spriteBallsClips;
     
        int m_min_velocity;
        int m_max_velocity;
     
    private:
     
        int m_num_collisions;
        int m_num_balls;
     
    };
     
    #endif
    BallManager.cpp

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
     
    #include "BallManager.h"
     
    BallManager::BallManager(std::vector<Ball*> array_balls, std::vector<SDL_Rect> spriteBallsClips , int num_balls, int min_velocity, int max_velocity){
     
        this->m_array_balls = array_balls;
        this->m_spriteBallsClips = spriteBallsClips;
        this->m_num_balls = num_balls;
        this->m_num_collisions= 0;
        this->m_min_velocity = min_velocity;
        this->m_max_velocity = max_velocity;
     
    }

  8. #8
    Expert éminent sénior
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2005
    Messages
    5 059
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Conseil

    Informations forums :
    Inscription : Février 2005
    Messages : 5 059
    Points : 12 095
    Points
    12 095
    Par défaut
    Pourquoi faut il utiliser le "this->" quand on donne une valeur à chaque variable membre dans le constructeur, vu que s'en passer fonctionne aussi ?
    Ici "this->" ou pas ça ne change rien.
    @nikko34 a dû être induit en erreur par le caractère très étrange de votre code.

    On met "this->toto" à la place de "toto" dans un constructeur quand la classe a un champ de nom "toto" et le constructeur de cette classe a un paramètre de nom "toto" (oui, c'est assez particulier comme cas).

    Dans le constructeur, "toto" est égale au paramètre, pour accéder au champs "toto" de la classe, c'est avec "this->toto".
    La résolution de nom commence par les paramètres et "toto" est un paramètre.
    En utilisant "this->toto", cela ne peut plus être égale au paramètre mais égale au champ de la classe.

    Pourquoi me conseilles-tu SFML plutôt que SDL2 ?
    SDL est une librairie C, SFML est une librairie C++.
    Pour pouvoir utiliser CORRECTEMENT (exception safe, etc...) une librairie C en C++, cela demande pas mal de travail assez fastidieux.

  9. #9
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Ok merci bacelar, j'utiliserai cette librairie dans mon prochain projet

    Sais tu pourquoi mon programme crash ?

  10. #10
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Bon les amis j'ai réussi à débuguer :

    Je remplacé les tableaux dynamiques par des tableaux statiques et le programme ne crashe plus
    Je pense que pour un meilleur contrôle sur la mémoire il vaut mieux prévoir large sur la taille du tableau et éviter les vector.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    Ball* m_array_balls[BALL_MAX_SCENE];
    SDL_Rect m_spriteBallsClips[BALL_MAX_SCENE];
    Je vous tiens au courant pour la suite

  11. #11
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    Citation Envoyé par guitz Voir le message
    Salut JolyLoic,

    J'ai lu que SFML etait mal fichue pour les entrées clavier et souris. Tu es d'accord avec ça ?

    Pourquoi me conseilles-tu SFML plutôt que SDL2 ?
    Comme l'a dit Bacelar, parce que SFML est écrite en C++, et facilite grandement la gestion des ressources par rapport à une bibliothèque en C. Pour ce qui est du clavier et de la souris, je n'ai pas de remarques particulières. Quand je l'utilise pour mes cours, je n'ai pas vu de problèmes d'utilisation liés à ça.

    Citation Envoyé par guitz Voir le message
    Je remplacé les tableaux dynamiques par des tableaux statiques et le programme ne crashe plus
    Je pense que pour un meilleur contrôle sur la mémoire il vaut mieux prévoir large sur la taille du tableau et éviter les vector.
    Je pense que tu as grandement tort...

    Maintenant utiliser des vector avec des objets qui n'ont pas été prévus pour, comme des objets en C, n'est pas forcément ce qu'il y a de plus simple, car tu dois faire attention à gérer correctement tes désallocations (mais ce n'est pas plus compliqué non plus que de gérer correctement ça avec des tableaux de taille fixe dont certains indices contiennent une donnée et d'autre pas). Mais après, c'est un tout : Utiliser des vector par rapport à des tableaux dynamiques aura un apport moyen. Utiliser des objets pour gérer tes ressources aura un apport moyen. Utiliser des pointeurs intelligents pour gérer les ressources qui demandent une gestion plus fine de la durée de vie aura un apport moyen. Mais faire tout ça ensemble, ne plus rien gérer manuellement simplifiera grandement le code, le rendra plus robuste et fonctionnel dès la première version.
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

  12. #12
    Membre éclairé Avatar de guitz
    Homme Profil pro
    Webdesigner
    Inscrit en
    Juillet 2006
    Messages
    717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Webdesigner

    Informations forums :
    Inscription : Juillet 2006
    Messages : 717
    Points : 741
    Points
    741
    Par défaut
    Merci JolyLoic

Discussions similaires

  1. crèer un sprite pour un jeu 2D avec Netbean
    Par D.Bilel dans le forum 2D
    Réponses: 2
    Dernier message: 22/08/2007, 19h51
  2. [POO] Etendre DOMXML avec SNOOPY
    Par riccco dans le forum Langage
    Réponses: 4
    Dernier message: 01/08/2007, 16h34
  3. Créer un jeu C avec SDL (hexagones)
    Par gaby_1 dans le forum Développement 2D, 3D et Jeux
    Réponses: 5
    Dernier message: 21/03/2007, 17h39
  4. [POO] utiliser Word avec php
    Par ygaudin dans le forum Langage
    Réponses: 1
    Dernier message: 12/09/2006, 12h04
  5. [POO] PHP5 : Problème avec les classes
    Par fleur_de_rose dans le forum Langage
    Réponses: 9
    Dernier message: 06/05/2006, 20h09

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo