Ajout d'une méthode == dans la classe sf::Event.

[Lolilolight]

Salut, je voudrais faire ceci : un event qui déclenche un slot (ou des events qui déclenchent plusieurs fois le même slot) et un autre event correspondant pour terminer un déclenchement.

Alors j'ai décidé de stocker les event déclancheurs, les event terminateurs et le slot avec ses paramètres dans une classe Action et de comparer les events déclencheurs avec les events terminateurs afin de supprimer les events de la pile.
Cependant, l'opérateur == dans la classe sf::Event n'existe pas, alors, je dois le réimplémenter moi même, se serait bien de le rajouter :

 bool equalEvent (Event event, Event other) {
        if (event.type != other.type) {
            return false;
        }
        if (event.type == Event::Resized) {
            ...
        }
        //Même chose pour les autres type d'events.
    }
 

PS : j'ai aussi rajouté un booléen à ma fonction de comparaison, pour savoir si on compare aussi les paramètre des évènements, ou qu'on compare juste les types des évènements.

Ainsi je n'ai qu'à créer un sf::Event et lui passer un type (si je veux que par exemple si je relâche une touche du clavier l'event se termine) et si je veux que l'event se termine si une touche précise du clavier est enfoncée bah je créer un sf::Event en lui donnant un code de touche)

PS 2 : non j'ai rien dis, j'ai mis une valeur spéciale (par exemple la valeur Unknow pour sf::Keyboard::Key) lorsque je veux juste que l'action se termine si n'importe quel touche du clavier est pressée.

Bref se serait bien un code du genre :

 bool equalEvent (sf::Event event, sf::Event other) {
        if (event.type != other.type) {
            return false;
        }
        if (event.type == sf::Event::Resized) {
            return event.size.width == other.size.width && event.size.height == other.size.height;
        }
        if (event.type == sf::Event::TextEntered) {
            return event.text.unicode == other.text.unicode;
        }
        if (event.type == sf::Event::KeyPressed || event.type == sf::Event::KeyReleased) {
            if (event.key.code == sf::Keyboard::Key::Unknown)
                return true;
            return event.key.code == other.key.code;
        }
        if (event.type == sf::Event::MouseWheelMoved) {
            return event.mouseWheel.delta == other.mouseWheel.delta;
        }
        if (event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseButtonReleased) {
            return event.mouseButton.button == other.mouseButton.button;
        }
        if (event.type == sf::Event::MouseMoved) {
            return event.mouseMove.x == other.mouseMove.x && event.mouseMove.y == other.mouseMove.y;
        }
        if (event.type == sf::Event::JoystickButtonPressed || event.type == sf::Event::JoystickButtonReleased) {
            return event.joystickButton.joystickId == other.joystickButton.joystickId
                && event.joystickButton.button == other.joystickButton.button;
        }
        if (event.type == sf::Event::JoystickMoved) {
            return event.joystickMove.joystickId == other.joystickMove.joystickId
                && event.joystickMove.position == other.joystickMove.position;
        }
    }
 

Et voici ce à quoi ça pourrait servir :

keyHeldDownAction = new Action<sf::Keyboard::Key> (*slot2, false);
        sf::Event endEvent;
        sf::Event event;
        event.type == sf::Event::KeyPressed;
        event.key.code == sf::Keyboard::Key::Unknown;
        endEvent.type == sf::Event::KeyReleased;
        endEvent.key.code == sf::Keyboard::Key::Unknown;
        keyHeldDownAction->pushEndEvent(event, endEvent);
 

keyHeldDown est une action qui se déclenche si une touche du clavier est enfoncée et se termine si une touche du clavier est relevée.

keyHeldDown peut bien sûr contenir plusieurs sf::Event si plusieurs toutches sont enfoncées en même temps.

[kimci86]

Il me semble que cette façon de gérer les évènements déclencheurs est un peu limitée en particulier lorsqu'il s'agit de détecter si la souris est dans une zone de la fenêtre. Il faudrait autant d'évènements déclencheurs que de pixels dans la zone. Il faut probablement que tu fasses ta propre classe pour les évènements déclencheurs.

Par exemple:

class Trigger
{
        public:
                virtual bool match(const sf::Event&) = 0;
};

class MouseMove : public Trigger
{
        public:
                MouseMove(const sf::IntRect& r) : m_rect(r) {}

                virtual bool match(const sf::Event& e)
                {
                        return e.type == sf::Event::MouseMoved && m_rect.contains(e.mouseMove.x, e.mouseMove.y);
                }

        private:
                sf::IntRect m_rect;
};

// etc

[Laurent]

Ce serait bien pour ton utilisation particulière, mais je ne vois pas l'intérêt pour SFML. En plus ce que tu veux est assez spécifique, donc garde le dans ton code à toi, ce sera mieux pour tout le monde.

[Lolilolight]

En effet ce que je veux faire est assez spécifique, et les librairies de bases (SFML et std) ne me permettent pas de le faire car, ça se rapproche plutôt de ça :

]http://jlecomte.atspace.eu/c++/c++-faq-lite/pointers-to-members.html]



Et un event qui appelle le pointeur de fonction, un autre qui met fin à l'appel sur le pointeur de fonction.

Ok donc je vais garder mon code et ne pas modifier SFML, j'ai fais un tutoriel sur ce que j'ai fais à cette adresse : (dernière sous partie)

http://www.jeux-libres.com/tutoriaux/tuto-680-chapitre-entity-systeme-de-sfgl.php

Au cas ou ça te donnerais des pistes. 

Ce que je voudrais savoir c'est si SFML définis des valeurs spéciales si par exemple lors de la définition d'un event lorsque je clic sur un bouton de la souris, je n'ai pas spécifier quel bouton à été pressé. (Car je n'ai pas besoin de le savoir)

Si pas, je pense que je vais créer moi même des valeurs spéciales car ça serait embêter de se retrouver avec des valeurs indéterminées. :/ (Pour les structures SFML)

Il me semble que cette façon de gérer les évènements déclencheurs est un peu limitée en particulier lorsqu'il s'agit de détecter si la souris est dans une zone de la fenêtre. Il faudrait autant d'évènements déclencheurs que de pixels dans la zone. Il faut probablement que tu fasses ta propre classe pour les évènements déclencheurs.

Ou bien utiliser la classe System de SFGL.
(Si la souris est dans la zone, on émet le signal.)

Bref je vais faire les 2-3 dernières petites choses que je n'ai pas encore faîtes, c'est à dire : créer une classe qui lie des actions à un id, et créer un wrapper pour les fonctions membres.

Je trouve ça plus simple que de devoir faire de la méta-compilation.

Mais sinon oui pour vérifier si la souris est dans une zone de texte il y a moyen de le faire en faisant sa propre classe, ce sera le rôle des classes gui de SFGL. (Que j'implémenterai surement dans une version futur pour faire un système genre à Qt avec des boutons...)
Mais ce serait en effet bien de pouvoir faire une classe qui permet de créer ses propres événements déclencheurs et finaux.

Je vais surement implémenter ça dans une version futur de SFGL.

[Lolilolight]

Re salut, je voudrais faire des flags pour faire par exemple un event déclencheur si on appuie surl'une des touches suivante. (Z, Q, S D)
J'ai essayé ça mais ça ne marche pas :

 sf::Event endEvent;
        sf::Event event;
        event.type = sf::Event::KeyPressed;
        event.key.code = sf::Keyboard::Key::Z | sf::Keyboard::Key::Q | sf::Keyboard::Key::S | sf::Keyboard::Key::D;
        endEvent.type = sf::Event::KeyReleased;
        endEvent.key.code = sf::Keyboard::Key::Z | sf::Keyboard::Key::Q | sf::Keyboard::Key::S | sf::Keyboard::Key::D;
        moveAction->linkEvents(event, endEvent);
 

N'y a t'il pas possibilité de faire des flags avec les événements SFML ?

Se serait bien de pouvoir rajouter ça.

Sinon, me faudrait une piste..., voir même coder ma propre classe Event mais je sais pas du tout comment on gère des flags en interne. :/

[Hiura]

http://www.bromeon.ch/libraries/thor/v2.0/tutorial-actions.html

[Lolilolight]

Ok, je pense que je vais faire un système comme celui là alors.

[Nexus]

Ok, je pense que je vais faire un système comme celui là alors.

Pourquoi tu n'utilises pas Thor directement au lieu de le copier? Il n'y a pas beaucoup de sens de perdre plein de temps pour re-implementer toutes les choses qui existent déjà.

L'idée derrière Thor est offrir de la fonctionnalité fréquemment utilisée, pour que les gens puissent se concentrer sur l'implementation des jeux. Considère que j'ai investé assez de temps pour reflechir d'un design et implementer, tester, debugger et optimizer tout le code -- espérant que des autres utilisateurs d'SFML peuvent en profiter.

[Lolilolight]

J'y ai pensé mais thor ne répond pas à mes besoins (Si tu as vu ma manière de stocker mes fonctions de callback. )

J'ai besoin de stocker des fonctions avec un nombre variable d'arguments et leur passer des arguments plus tard. (Pour les interfaces graphiques (clic sur un bouton, etc...).
Thor si j'ai bien lu la documentation permet de faire ça  uniquement pour une renderwindow. (Sinon il faut utiliser connect et lui passer un std::function ou un std::bind pour l'appeler directement sous peine de devoir faire un foncteur)
Moi je n'ai qu'à faire une fonction, lui passer l'adresse de la renderwindow (ou bien autre chose) et stocker l'adresse de la fonction pour l'appeler plus tard. (Seul inconvénient : on ne peut pas stocker l'adresse d'un pointeur de fonction sur une fonction membre en c++ alors il faut faire une méthode statique qui appelle la fonction membre sur l'objet)

J'ai besoin aussi de pouvoir charger des ressources via des streams, donc, j'ai besoin d'avoir un ressource holder qui possède un pointeur de fonction avec un nombre variable d'arguments vu que je ne charge pas les ressources que via un fichier ou bien via la mémoire. (mais aussi via le réseau)
Et puis c'est bien mieux pour pouvoir faire des streams perso. ^^

Thor est adapté pour des petits jeux comme celui présenté dans le bouquin mais pas vraiment pour des gros jeux je trouve. ^^

J'ai besoin de quelque chose qui permet non seulement de gérer des signaux sur la RenderWindow mais aussi pour des guis.

La seule chose que j'aurai pu reprendre de ta librairie c'est ton système d'actionmap qui je dois l'avoué est bien. (Et aussi peut être ton système de particule, je ne sais pas, je ne l'ai pas encore testé)
Bref je vais faire comme je fait à chaque fois fouiller le code source de plusieurs librairies et prendre seulement ce que j'ai besoin pour l'adapter à la mienne. (C'est la méthode que a toujours le mieux marché chez moi)
Si je dois modifier du code source d'une librairie existante je m'en sors pas (car trop de code d'un coup), et si je dois recréer la mienne entièrement ça ne marche pas non plus car ça prend trop de temps et je n'ai pas toujours suffisamment de connaissances pour pouvoir la réussir aussi bien que certaines librairie déjà existantes..

[Nexus]

on ne peut pas stocker l'adresse d'un pointeur de fonction sur une fonction membre en c++ alors il faut faire une méthode statique qui appelle la fonction membre sur l'objet

Ton problème est que tu ne veux pas comprendre les choses existantes, tu préfères de les refaire, malgré que cela durera beaucoup plus longtemps et le resultat sera pire. std::function est un bon exemple, elle offre tout ce qu'il faut, mais apparemment tu n'as toujours pas compris ce concepte. Nous avons essayé de te dire cela plusieures foix, c'est dommage que tu préfères de ne pas nous écouter.

Thor est adapté pour des petits jeux comme celui présenté dans le bouquin mais pas vraiment pour des gros jeux je trouve. ^^

Ca serait une thème interessante à discuter, mais il faudrait regarder Thor d'une perspective qui ne couvre pas seulement toi, mais une grande partie des utilisateurs d'SFML. Toi, tu argumentes toujours de tes demandes spécifiques (qui sont souvent très bizarres) est tu n'essaye même pas de comprendre les autres.

Je peux juste répéter ce qui a été dit une douzaine des foix: Comprends les conceptes (en ce cas ceux de Thor) et écoute les gens. Il y en a beaucoup qui ont plus d'éxperience que toi, et ils veulent t'aider, mais pour cela il faut être plus ouvert aux conseils.

[Lolilolight]

Ton problème est que tu ne veux pas comprendre les choses existantes, tu préfères de les refaire, malgré que cela durera beaucoup plus longtemps et le resultat sera pire. std::function est un bon exemple, elle offre tout ce qu'il faut, mais apparemment tu n'as toujours pas compris ce concepte. Nous avons essayé de te dire cela plusieures foix, c'est dommage que tu préfères de ne pas nous écouter.

Ce n'est pas une question que je ne veux pas écouter les conseils des autres et j'ai très bien compris le concept de std::function et de std::bind, mais le gros défaut de ces 2 objects, c'est qu'ils ne permettent pas de faire des tableaux sur des pointeurs de fonction quelconque.

Bref je te défie de faire un wrapper sur un std::function ou bien sur un std::bind. (avec un nombre variable d'arguments)

Avec ton tutoriel si j'ai bien lu on est obligé de faire soit un foncteur (SpriteMover dans ton cas) qui appelle la fonction ou bien de passer un std::bind (ou un std::function) à ta méthode connect pour l'appelé directement.

Ici, pas besoin, une fonction membre statique suffit :

#ifndef MY_APPLI
#define MY_APPLI
#include "SFGL/Core/application.h"
#include "SFGL/Graphics/2D/tile.h"
#include "SFGL/Graphics/2D/map.h"
#include "SFGL/Graphics/2D/ambientLight.h"
#include "SFGL/Core/action.h"
#include "SFGL/Core/object.h"
#define SPEED 0.1
using namespace sfgl;
using namespace sf;

class MyAppli : public Application {
    public :
    Map* theMap;

    MyAppli(sf::RenderWindow &window) : Application (window) {
        running = false;

    }
    static void close (sf::RenderWindow *window) {
        window->close();

    }
    static void keyHeldDown (sf::View *view, sf::Keyboard::Key key) {
        if (key == sf::Keyboard::Key::Z) {
            view->move (0, -10);
        } else if (key == sf::Keyboard::Key::Q) {
            view->move (-10, 0);
        } else if (key == sf::Keyboard::Key::S) {
            view->move (0, 10);
        } else if (key == sf::Keyboard::Key::D) {
            view->move (10, 0);
        }
    }
    static void mouseInside (Vector2f mousePos) {
        BoundingRectangle br (0, 0, 100, 100);
        if (br.isPointInside(Vec2f(mousePos.x, mousePos.y))) {
            std::cout<<"Mouse inside!"<<std::endl;
        }
    }
    void load() {
        TextureManager &tm =  getCache().resourceManager<Texture>("TextureManager");
        tm.load("tilesets/herbe.png", "GRASS");
        tm.load("tilesets/murs.png", "WALLS");
        View view = getWindow().getDefaultView();
        Vec2f pos (view.getCenter().x - view.getSize().x * 0.5f, view.getCenter().y - view.getSize().y * 0.5f);
        BoundingRectangle br (pos.x, pos.y, view.getSize().x, view.getSize().y);
        theMap = new Map (100, 50, 30, "Map test");
        std::vector<Tile*> tiles;
        std::vector<Tile*> walls;
        tiles.push_back(new Tile(tm.getResourceByAlias("GRASS"), Vec2f(0, 0), Vec2f(120, 60),IntRect(0, 0, 100, 50), 0));
        walls.push_back(new Tile(tm.getResourceByAlias("WALLS"), Vec2f(0, 0), Vec2f(100, 100), IntRect(100, 0, 100, 100), 0));
        walls.push_back(new Tile(tm.getResourceByAlias("WALLS"), Vec2f(0, 0), Vec2f(100, 100), IntRect(100, 100, 100, 100), 1));
        walls.push_back(new Tile(tm.getResourceByAlias("WALLS"), Vec2f(0, 0), Vec2f(100, 100), IntRect(100, 200, 100, 100), 1));
        walls.push_back(new Tile(tm.getResourceByAlias("WALLS"), Vec2f(0, 0), Vec2f(100, 100), IntRect(100, 300, 100, 100), 1));
        walls.push_back(new Tile(tm.getResourceByAlias("WALLS"), Vec2f(0, 0), Vec2f(100, 100), IntRect(100, 400, 100, 100), 1));
        walls.push_back(new Tile(tm.getResourceByAlias("WALLS"), Vec2f(0, 0), Vec2f(100, 100), IntRect(100, 500, 100, 100), 1));
        BoundingRectangle rect(0, 0, 1000, 1000);
        theMap->generate_map(tiles, walls, rect);
        theMap->checkVisibleEntities(br);

    }
    void init () {
        View view = getWindow().getDefaultView();
        Bind<void(sf::RenderWindow*)> slot (&MyAppli::close, &getWindow());
        closedAction = new Action<sf::RenderWindow*>(slot);

        Bind<void(sf::View*, sf::Keyboard::Key)> slot2 (&MyAppli::keyHeldDown, &view, sf::Keyboard::Key::Unknown);
        moveAction = new Action<sf::View*, sf::Keyboard::Key> (slot2, false);
        sf::Event endEvent1, endEvent2, endEvent3, endEvent4;
        sf::Event event1, event2, event3, event4;
        event1.type = sf::Event::KeyPressed;
        event1.key.code = sf::Keyboard::Key::Z;
        event2.type = sf::Event::KeyPressed;
        event2.key.code = sf::Keyboard::Key::Q;
        event3.type = sf::Event::KeyPressed;
        event3.key.code = sf::Keyboard::Key::S;
        event4.type = sf::Event::KeyPressed;
        event4.key.code = sf::Keyboard::Key::D;

        endEvent1.type = sf::Event::KeyReleased;
        endEvent1.key.code = sf::Keyboard::Key::Z;
        endEvent2.type = sf::Event::KeyReleased;
        endEvent2.key.code = sf::Keyboard::Key::Q;
        endEvent3.type = sf::Event::KeyReleased;
        endEvent3.key.code = sf::Keyboard::Key::S;
        endEvent4.type = sf::Event::KeyReleased;
        endEvent4.key.code = sf::Keyboard::Key::D;
        moveAction->linkEvents(event1, endEvent1);
        moveAction->linkEvents(event2, endEvent2);
        moveAction->linkEvents(event3, endEvent3);
        moveAction->linkEvents(event4, endEvent4);
        System::connect("MouseInside", Function<void> (&MyAppli::mouseInside));
    }
    void render() {

        if (getWindow().isOpen())
        {


        // clear the window with black color
        getWindow().clear(sf::Color::Black);

        std::vector<Entity*> entities = theMap->getVisibleEntities("E_GROUND+E_WALL");// draw everything here...

        for (unsigned int i = 0; i < entities.size(); i++) {
            getWindow().draw(*entities[i]);
        }
        /*entities = theMap->getVisibleEntities("E_WALL");// draw everything here...

        for (unsigned int i = 0; i < entities.size(); i++) {
            getWindow().draw(*entities[i]);shadow = new ShadowWall(*light, this);
        }*/

        // end the current frame
        getWindow().display();
        }

    }
    void update () {
        // check all the window's events that were triggered since the last iteration of the loop

        sf::Event event;
        while (getWindow().pollEvent(event))
        {
            if (event.type == sf::Event::Closed) {
                closedAction->pushEvent(event, event.type);
                closedAction->process();
                running =false;
            }
            if (event.type == sf::Event::KeyPressed || event.type == sf::Event::KeyReleased) {
                moveAction->pushEvent(event, event.type);
                View view = getWindow().getView();
                moveAction->changeParams(&view, event.key.code);
                moveAction->process();
                getWindow().setView(view);
            }
            if (event.type == sf::Event::MouseMoved) {
                Vector2f mousePos = Vector2f(event.mouseMove.x, event.mouseMove.y);
                System::emit ("MouseInside", Vec2f(mousePos.x, mousePos.y));
            }
        }
    }
    void stop() {
        running = false;
    }
    int exec () {
        load();
        init();
        running = true;
        while (running) {
            render();
            update();
        }
        return EXIT_SUCCESS;
    }

    ~MyAppli () {

    }
    private:
        bool running;
        Action<sf::RenderWindow*> *closedAction;
        Action<sf::View*, sf::Keyboard::Key> *moveAction;
};

#endif // MY_APPLI
 

De plus mon système offre la possibilité de gérer ses propres signaux, (Et pas seulement des signaux lié à une action, par exemple, lorsque la souris rentre dans une zone, avec thor, je devrai définir une action pour chaque pixel de la zone)

Ca serait une thème interessante à discuter, mais il faudrait regarder Thor d'une perspective qui ne couvre pas seulement toi, mais une grande partie des utilisateurs d'SFML. Toi, tu argumentes toujours de tes demandes spécifiques (qui sont souvent très bizarres) est tu n'essaye même pas de comprendre les autres.

Je peux juste répéter ce qui a été dit une douzaine des foix: Comprends les conceptes (en ce cas ceux de Thor) et écoute les gens. Il y en a beaucoup qui ont plus d'éxperience que toi, et ils veulent t'aider, mais pour cela il faut être plus ouvert aux conseils.

Tu me fais pensé lorsque je vais me présenté à un entretient d'embauche pour un poste de programmeur ou me répond à chaque fois ceci : (tu n'as pas assez d'expériences donc ont a pris quelqu'un qui a plus d'expérience que toi)

Ou bien lorsqu'on compare mon expérience avec ma personnalité.

De belles conneries...

Bref je n'ai pas envie de discuter plus longtemps ici, car je perds mon temps, j'ai fais un truc qui marche en y ayant passé beaucoup de temps, c'est l'essentiel, je m'en fou complètement d'avoir +/- d'expérience que les autres ou d'être plus renfermé sur moi même. (Heureusement que y'a des gens plus malin qui ne m'ignorent pas juste à cause de ça)

Au pire je pourrai toujours mettre ça vraiment au point par la suite, bref, tu verras quand mon 1er jeux sera sorti et après tu jugeras mais merci de ne pas me juger n'importe comment.

PS : De plus j'ai dû faire de la prédiction de mouvements, une intelligence artificielle, un entity-system, du chargement de ressource via le réseau, bref, beaucoup de chose que thor n'offre pas. (Et j'ai même commencé à dessiner des objets en 3D et à me déplacer dans la scene.)

Mais bon on peut toujours me reproché d'être fort renfermé sur moi même et de réfléchir beaucoup, tu sais..., si je devais stopper tout mes projets à cause de ça, autant tout abandonné tout de suite.

PS 2 : avoir plus d'expérience que moi c'est : maîtriser html, php, css, JEE, javascript et JQuery, .NET, etc..., maîtriser le c/c++, le java, opengl, openssl, les matrices (transformations et projections en 2d et en 3d), la prédiction de mouvements, l'intelligence artificielle, la maintenance informatique, etc...
Il faut donc aussi bien avoir de bonne bases en math qu'en programmation et aussi en Anglais

Et je pourrai encore en rajouter sur la liste car je n'ai pas cité toutes les choses que j'ai faîtes là.

Dès que la version 1 de SFGL est finie je compte même attaquer la physique et les effets avec les shaders pour vraiment être au top niveau programmation. (Et plus tard je devrais surement m'attaquer à l'infographie et au son)

Bref pour te dire que j'ai du gérer mon projet ambitieux tout seul depuis des année maintenant, alors, je suis peux être fot renfermé sur moi même mais pour avoir plus d'expérience que moi il faut déjà en avoir fait de choses et pas se limiter à l'utilisation d'une librairie.

[Lo-X]

Puisque ce dont tu discutes n'a presque plus aucun rapport avec le topic initial (demande de nouvelle fonctionnalité) et que tu n'as manifestement plus besoin de nos lumières (ton soucis est résolu ou en passe de l'être), je te conseille fortement de fermer ce post si tu le peux, avant qu'il ne devienne un autre de tes "blogs" ou que les discussions s'enveniment.

[Lolilolight]

En effet le problème est résolu donc on peut fermé ce post. (Moi même je ne peux pas le faire mais je suppose que quelqu'un s'en chargera de toute façon)