Bonjour tout le monde actuellement j'ai coder plusieurs "outils" pour prochainement la création d'un simple jeu. Là j'en suis à l'étape des input ( Boutons, Champs, Champs multiligne, case, etc... ). Pour éviter d'avoir trop de ressources à charger, j'ai créer un manager qui s'occupe :
- De charger les textures dans la cg
- De l'ajouts de différents input tel que les boutons
- De l’affichage de ceux ci (je leur donne les pointeurs des textures à utiliser)
- Du test pour savoir si l'on à cliqué dessus
- Et cetera...
Pour créer les boutons et autres, je n'ai pas eu de problèmes. Mais depuis que j'utilise le Manager que j'ai créé, j'ai pus me rendre compte que cela ne fonctionne pas très bien.
En faite je crée trois bouton.
Les trois s'affiche sans problème mais seul le premier bouton fonctionne, si je clique dessus il change d'état et de textures. Les autres ne réagisse pas du tout !

Voici le code actuel :

La classe Button
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
class Button : public sf::Drawable, public sf::Transformable
    {
    public:
 
    Button( std::string name, bs::Vector4f def, sf::Texture *texture ) : b_name{name}, b_array(sf::Quads, 4), b_state{State::DEFAULT}
    {
        b_texture = texture;
 
        b_array[0].position = sf::Vector2f(0,0);
        b_array[1].position = sf::Vector2f(def.a.x,0);
        b_array[2].position = sf::Vector2f(def.a.x,def.a.y);
        b_array[3].position = sf::Vector2f(0,def.a.y);
 
        b_array[0].texCoords = sf::Vector2f(0,0);
        b_array[1].texCoords = sf::Vector2f(def.a.x,0);
        b_array[2].texCoords = sf::Vector2f(def.a.x,def.a.y);
        b_array[3].texCoords = sf::Vector2f(0,def.a.y);
 
        this->setPosition(def.b);
        b_size = def.a;
    }
 
    void setTextureOnPress( sf::Texture *texture )
    {
        b_texturePress = texture;
    }
 
    void setTextureOnHover( sf::Texture *texture )
    {
        b_textureHover = texture;
    }
 
    sf::Vector2f size() const
    {
        return b_size;
    }
 
    bool isTouch( sf::Vector2f pos )
    {
        if( pos.x < this->getPosition().x + size().x && pos.x > this->getPosition().x )
            if( pos.y < this->getPosition().x + size().y && pos.y > this->getPosition().y )
                return true;
 
        return false;
    }
 
    void press()
    {
        b_state = State::PRESSED;
    }
 
    void release()
    {
        b_state = State::DEFAULT;
    }
 
    bool tried()
    {
        if( b_state == State::PRESSED )
            return true;
        return false;
    }
 
    std::string name() const
    {
        return b_name;
    }
 
    private:
 
    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
    {
        states.transform *= getTransform();
        if( b_state == State::HOVER )
            states.texture = b_textureHover;
        else if ( b_state == State::PRESSED )
            states.texture = b_texturePress;
        else
            states.texture = b_texture;
        target.draw(b_array, states);
    }
 
    std::string const b_name;
    sf::Texture *b_texture;
    sf::Texture *b_textureHover;
    sf::Texture *b_texturePress;
    sf::VertexArray b_array;
    State b_state;
    sf::Vector2f b_size;
 
    };
La classe Manager

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
 
class Manager : public sf::Drawable, public sf::Transformable
    {
    public:
 
        Manager(){this->load();}
 
        void add( std::string name, ButtonType type, bs::Vector4f shape )
        {
            switch(type)
            {
            case ButtonType::NORMAL:
                {
                    std::map<ButtonType,sf::Texture>::iterator it;
                    it = m_textures.find(ButtonType::NORMAL);
                    m_buttons.push_back(new Button(name,shape,&it->second));
                }
 
                break;
            default:
                break;
            }
 
        }
 
        std::string trigger( sf::Vector2f pos )
        {
            std::string rsl;
 
            for( size_t i{0}; i < m_buttons.size(); i++ )
            {
                if( m_buttons[i]->isTouch(pos) )
                {
                    if( m_buttons[i]->tried() )
                    {
                        m_buttons[i]->release();
                        rsl = m_buttons[i]->name();
                    }
                    else
                    {
                        m_buttons[i]->press();
                    }
                }
            }
 
            return rsl;
        }
 
    private:
 
    void load()
    {
        sf::Texture t;
        m_textures[ButtonType::NORMAL] = t;
 
        if(!m_textures[ButtonType::NORMAL].loadFromFile("C:/Test/f.png"))
            std::cout << "Erreur";
    }
 
    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
    {
        for( size_t i{0}; i < m_buttons.size(); i++ )
        {
            target.draw(*m_buttons[i]);
        }
    }
 
    std::map<ButtonType,sf::Texture> m_textures;
    std::vector<Button*> m_buttons;
 
    };
Le code qui crée les boutons

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
void load( Loadable l, Input::Manager &manager )
    {
        manager.add("Play", Input::ButtonType::NORMAL, bs::Vector4f(120,30,100,100));
        manager.add("Quit", Input::ButtonType::NORMAL, bs::Vector4f(120,30,100,150));
        manager.add("Options", Input::ButtonType::NORMAL, bs::Vector4f(120,30,100,200));
    }
bs::Vector4f, ButtonType, State, Loadable

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
 
enum Loadable{ MENU, HUD };
 
enum ButtonType{NORMAL, PLAY, VALID, CANCEL, QUIT, BUY, SELL};
 
enum State{DEFAULT,PRESSED,HOVER};
 
struct Vector4f
    {
        Vector4f(){}
        Vector4f( float x, float y, float z, float w)
        {
            sf::Vector2f v(x,y);
            a = v;
            v.x = z; v.y = w;
            b = v;
        }
 
        sf::Vector2f a;
        sf::Vector2f b;
    };
Un code pour tester l'ensemble

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
 
sf::RenderWindow window;
    window.create(sf::VideoMode(640,480), "Test", sf::Style::Default);
 
    Input::Manager *m = new Input::Manager();
    bs::load(Loadable::MENU, *m);
 
    while(window.isOpen())
    {
        sf::Event e;
        while( window.pollEvent(e))
        {
            if( e.type == sf::Event::MouseButtonPressed )
                if( m->trigger(sf::Vector2f( sf::Mouse::getPosition(window).x, sf::Mouse::getPosition(window).y )  ) != "" )
                {
                   //st
                }
            if( e.type == sf::Event::MouseButtonReleased )
                if( m->trigger(sf::Vector2f( sf::Mouse::getPosition(window).x, sf::Mouse::getPosition(window).y )  ) != "" )
                {
                   //st
                }
        }
 
        window.clear(sf::Color(230,230,230));
        window.draw(*m);
        window.display();
    }
Merci de votre aide, je suis un peu perplexe pour le coup x)

Ps: Pour le moment le code n'est pas du tout "sécurisé" mais j'aimerais déjà qu'il fonctionne avant de plus m'avancer