Bonjour,

Il y a une semaine, j'ai décidé de me lancer dans la SDL, mais je n'ai visiblement pas compris le fonctionnement de SDL_Event.

Pour m'entrainer, j'ai commencer un petit projet pour faciliter la création d'un jeu (gestion des Sprites par exemple).

J'ai donc commencer par coder une classe mettant en place le contexte graphique. Jusqu'au moment ou j'ai dû me plonger dans les évènements. J'ai coder une classe "SDL_Controller" qui doit à terme lier l'interface de commande utilisateur au programme (gestion du clavier etc...). Malheureusement, j'ai un problème avec la base de cette classe : acquérir les évènements. En effet, la fonction SDL_PollEvent(m_event) envoie l'erreur Segmentation Fault. Pourtant, de ce que j'ai vu, il n'y a pas besoin d'initialiser le SDL_Event*pour utiliser cette fonction.

Pour les curieux, voici mon code :

/// SDl_Controller.hpp

#define MESSAGE     Uint32

#define CMD         int

#define CMD_NULL        0x0000
#define CMD_MAX         0x0400

#define CMD_RESET       !(CMD_JUMP | CMD_INVENTORY | CMD_PAUSE | CMD_WEAPON)

#define CMD_UP          0x0001
#define CMD_DOWN        0x0002
#define CMD_RIGHT       0x0004
#define CMD_LEFT        0x0008
#define CMD_JUMP        0x0010
// ..d'autres commandes

class SDL_Controller
{
    public:
        SDL_Controller(SDL_Event *event) ;
        virtual ~SDL_Controller() ;

        CMD getCmd() ;
        MESSAGE getEvent() ;

        void refresh() ;

    protected:
    private:
        SDL_Event *m_event ;

        char m_keys[CMD_MAX] ;

        CMD m_cmd ;
        MESSAGE m_lastEvent ;
};

/// SDL_Controller.cpp

SDL_Controller::SDL_Controller(SDL_Event *event) : m_event(event)
{
    m_keys[CMD_UP] = 'z' ;
    m_keys[CMD_DOWN] = 's' ;
    m_keys[CMD_RIGHT] = 'd' ;
    m_keys[CMD_LEFT] = 'q' ;
    m_keys[CMD_JUMP] = ' ' ;		// NB : cette touche doit n'envoyer qu'une seul commande à l'appuis de cette touche

    // .. d'autres touches
}

// fct qui renvoie une commande a executer dans le jeu
 CMD SDL_Controller::getCmd(){
    CMD cmd = m_cmd ;

    m_cmd &= CMD_RESET ;

    return cmd ;
}

// fct qui renvoie la dernière action enregistrée
MESSAGE SDL_Controller::getEvent(){
    return  m_lastEvent ;
}

void SDL_Controller::refresh(){

    if(SDL_PollEvent(m_event) == NULL)
        return ;

    m_lastEvent = m_event->type ;

    switch(m_event->type){
    case(SDL_KEYDOWN):
        if(m_keys[CMD_UP] == m_event->key.keysym.sym){
            m_cmd |= CMD_UP ;
        }else if(m_keys[CMD_DOWN] == m_event->key.keysym.sym){
            m_cmd |= CMD_DOWN ;
        }
        break ;
    case(SDL_KEYUP):
        if(m_keys[CMD_UP] == m_event->key.keysym.sym)
            m_cmd &= !CMD_UP ;
        else if(m_keys[CMD_DOWN] == m_event->key.keysym.sym)
            m_cmd &= !CMD_DOWN ;
        // ...plein d'autres tests
        break ;
    }
}

-
Edité par >KryptOs_ 2 septembre 2018 à 11:36:43

Salut,

Si, l'argument donné à SDL_PollEvent doit etre un pointeur sur un SDL_event valide.

Dans les exemples que tu as certainement vu, c'était :

SDL_event e;
int retour = SDL_PollEvent(&e);

Ici, l'adresse passée pointe sur un SDL_event valide.

Si tu fais :

SDL_event* pe = NULL;
int retour = SDL_PollEvent(pe);

Alors le pointeur est sur NULL, (et pire sur une zone aléatoire et invalide si tu ne l'initialises pas à NULL).

Donc dans le 2e exemple, pour que ça marche, si faudrait faire un new ou un malloc. 

Mais bon, quit a changer, dans ta classe, met directement un SDL_event, pas un SDL_event*