Bienvenue, Invité. Merci de vous connecter ou de vous inscrire. Avez-vous oublié d'activer ?

Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Sujets - Lolilolight

Pages: [1] 2 3 ... 5 Suivante »
1
Réseau / Le client ne reçoit pas ma std::string
« le: Novembre 06, 2016, 02:49:14 pm »
Salut, j'essaye d'extraire un certificat d'openssl :

int Rsa::ossl_getCertificate (unsigned char** out) {
        return i2d_X509(x, out);
}
 

Pour l'envoyer à mon client.

void Network::sendPbKeyRsa(User &user) {
            unsigned char* out = nullptr;
            int length = EncryptedPacket::getCertificate(&out);
            std::string response (reinterpret_cast<char*>(out), length);
            Packet packet;
            packet<<response;
            user.getTcpSocket().send(packet);
            user.setHasPbKeyRsa(true);
        }
 

Mais à la réception ma chaîne de caractère est vide, le paquet est invalide car la taille de la chaîne est trop longue par rapport à la taille initiale du paquet.

if (clientTCP.receive(packet) == Socket::Done) {
                        packet>>message;
                        Network::setPbKey(message);
                        pbKeyRsaReceived = true;
 

De ce fait je n'ai pas de message et mon programme plante.
Pourtant cela marchait bien auparavant, y a t'il eu des changements ?
Faut il rajouter un \0 manuellement à la fin du tableau d'unsigned char ?
Bref je ne comprends plus rien car au départ ça fonctionnait bien et ici tout à coup ça ne fonctionne plus.


2
Salut, j'ai ça depuis pas longtemps; ça n'affiche pas le message du serveur.

Code source du serveur :

#include <SFML/Network.hpp>
#include <iostream>
int main (int argv, char* argc[]) {
    sf::TcpListener listener;
    if (listener.listen(10000) != sf::Socket::Done)
        std::cerr<<"Error while listening to the port"<<std::endl;
    sf::SocketSelector selector;
    selector.add(listener);
    std::vector<sf::TcpSocket*> clients;
    while (true) {
        if (selector.wait(sf::milliseconds(10))) {
            if (selector.isReady(listener)) {
                sf::TcpSocket *client = new sf::TcpSocket();
                if (listener.accept(*client) == sf::Socket::Done) {
                    std::cout<<"client connected"<<std::endl;
                    selector.add(*client);
                    clients.push_back(client);
                }
            }
            for (unsigned int i = 0; i < clients.size(); i++) {
                if (selector.isReady(*clients[i])) {
                    sf::Packet packet;
                    if (clients[i]->receive(packet) == sf::Socket::Done) {
                        std::string message;
                        packet>>message;
                        std::cout<<"message : "<<message<<std::endl;
                        message = "I'm fine thanks";
                        packet.clear();
                        packet<<message;
                        clients[i]->send(packet);
                    } else {
                        std::cout<<"client disconnected"<<std::endl;
                        selector.remove(*clients[i]);
                        delete clients[i];
                    }
                }
            }
        }
    }
    return 0;
}

Code source du client :

#include <SFML/Network.hpp>
#include <iostream>
int main (int argv, char* argc[]) {
    sf::TcpSocket socket;
    if (socket.connect(sf::IpAddress::LocalHost, 10000) != sf::Socket::Done)
        std::cerr<<"Server not running"<<std::endl;
    std::string message = "Hello server";
    std::string message2 = "how are you";
    sf::Packet packet;
    packet<<message;
    socket.send(packet);
    packet.clear();
    packet<<message2;
    socket.send(packet);
    packet.clear();
    sf::SocketSelector selector;
    selector.add(socket);
    while (true) {
        if (socket.receive(packet) == sf::Socket::Done) {
            packet>>message;
            std::cout<<"message : "<<message<<std::endl;
        }
    }
    return 0;
}

Pourtant avant ça marchait.

Rien à voir mais j'ai aussi ce soucis :

static bool startCli (int portTCP, int portUDP, sf::IpAddress, bool useSecuredConnexion = true);

Lorsue j'appelle la méthode sans passer le troisième paramètre, la variable booléenne vaut false hors u'elle devrait valoi true.

Bref, je ne parviens plus à travailler, tout cela est vraiment instable, ce ui marchait hier ne marche plus aujourd'hui.

3
Général / Undefined reference.
« le: Octobre 03, 2016, 11:07:41 am »
Salut, j'ai installé SFML 2.4, je voudrais remettre la 2.2 mais j'ai des erreurs de référence indéfinie, en fait le lien symbolique (libsfml-network.so) pointe toujours vers libsfml-network.so.2.4 et non vers libsfml-network.so.2.2

Comment puis je changer la destionation du lien symbolique ?

Merci.

4
Fenêtrage / Traiter un type d'évènement en 1er.
« le: Avril 21, 2014, 08:42:42 pm »
Salut.

J'ai fait un thread afin de traité les évènements SFML de manière assynchrone c'est à dire :

1)traité un évènement.
2)rendre la scène et traité un autre évènement simultanément.
Et ainsi de suite et donc je ne fait pas de boucle while qui traite tout les évènements puis qui effectue le rendu.

Le soucis c'est que, lorsque j'appuie sur une touche, il ne stope pas la commande au moment ou je relâche la touche, car pollevent me renvoie tout les évènements keypressed qui sont en attente de traitement par mon autre thread et seulement après il traite l'évènement keyreleased, il y a donc un décalage entre mes actions et le moment ou je relâche la touche, et la classe sf::Keyboard ne résoud pas le problème. :/ (Il me semble qu'elle ne renvoie faux que lorsque l'évènement keyreleased a été traité par pollEvent)

Alors j'aimerais récupérer en priorité les évènements de type keyreleased pour ignorer les événements keypressed en attente lorsque je relâche la touche pour arrêté l'action au moment ou je relâche la touche et pas 5 secondes après, est ce possible de faire ça avec SFML ?

Sinon j'aimerais implémenter ça moi même dans la classe sf::Window.

5
Présentation du projet

ODFAE est un framework pour SFML que je développe depuis plusieurs années déjà dans le but de créer un jeux vidéos complet. (De n'importe quel type)

Le but est de fournir un framework le plus complet possible afin de créer n'importe quel type de jeux.  (Et devenir ainsi le framework de création de jeux par excellence.)

Le code source du framework est régulièrement remis à jour et implémente déjà des nouvelles fonctionnalités du standart c++11 (les threads et primitives de synchronisation, les tuples, les lvalue, les std::functions, etc...) ainsi que certains design pattern. (le pattern facory, type erasure, entity system, singleton, etc...)

SFGL est un projet opensource vous pouvez donc faire part de vos idées afin d'améliorer la structure du code source.

La version 1 devrait sortir vers le mois de févrirer-mars mais en attendant vous pouvez toujours aller rechercher les sources sur github : https://github.com/Lolilolight/ODFAEG/tree/master/src/odfaeg

Vous pouvez aussi si vous le souhaiter consulter mon devblog :
http://lolilolightdevblog.wordpress.com/



Les fonctionnalités.

Voici une liste des fonctionnalités implémentées (ou en cours d'amélioration) :

-Un entity system.
-Un système de signal et de slots.
-Un système d'actions.
-Un système de gestion de ressources.
-Un système de states.

Les fonctionnalités à venir dans les versions futures.

-Un système de réseau avec cryptage SSL et prédiction de mouvement.
-Un moteur de particule.
-Gestion de la 3D. (Chargement de fichier.obj, génération de terrain, éclairage, physique, etc...)

Certains tutoriels sont déjà en cours de rédaction sur ce site :

Chapitre I :

http://www.jeux-libres.com/tutoriaux/tuto-679-chapitre-introduction-et-installation-de-sfgl.php

Chapitre II :

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

Chapitre III :

http://www.jeux-libres.com/tutoriaux/tuto-684-odfaeg-ombre-lumieres-et-animation.php

Versions futures

Version II

Ajout de la partie réseau du framework, et ajout de la physique afin de préparer la version III.

Version III

Ajout de la 3D.

6
Général / Juste une petite question sur le c++ d'ordre général.
« le: Janvier 05, 2014, 10:49:26 am »
Salut, j'aimerais savoir si il y a moyen de passer des références à un tuple et de les extraires : (Car ce code-ci marche bien mais, lorsque je veux utiliser des références le type de l'objet renvoyé par bind change, ce n'est plus un std::function mais un std::_BindHelper marchin quelque chose :

std::function<void(Ex&, std::string)> f1 = std::bind(&Ex::of, obj, "1");
    Slot<void, std::function<void(Ex&, std::string)>> s1(f1);
    s1(obj, "1");
//Ne marche pas!
std::function<void(Ex&, std::string&)> f2 = std::bind(&Ex::of, obj, "1");
    Slot<void, std::function<void(Ex&, std::string&)>> s2(f2);
    s2(obj, "1");
 

Alors j'ai essayer de créer mon propre binder et de faire ça :

#ifndef BIND_H
#define BIND_H

#include "function.h"

#include <tuple>
namespace sfgl {
    namespace helper {
        template<int ...> struct seq {};

        template<int N, int ...S> struct gens : gens<N-1, N-1, S...> {};

        template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };
    }
    template <typename R> class Bind {
    };
    template <typename R, typename... A> class Bind <R(A...)> {
        public :
        Bind (R(*f)(A...) , A... args) : function(f)  {
            params = std::make_tuple(args...);
        }

        template<int ...S>
        R operator ()(A... args) {
            params = std::make_tuple(args...);
            return callFunc(typename helper::gens<sizeof...(A)>::type());
        }
        template<int ...S>
        R operator ()() {
            //R(*func)(A...) = *reinterpret_cast<R**>(function);
            return callFunc(typename helper::gens<sizeof...(A)>::type());
        }
        template<int ...S>
        R callFunc(helper::seq<S...>)
        {
            return function(std::get<S>(params)...);
        }
        //private :
        std::tuple <A...> params;
        R(*function)(A...);
    };
    template <typename R, typename O, typename... A> class Bind <R(O&, A...)> {
        public:
        Bind (R(O::*f)(A...), O object, A... args) : object(object), function(f) {
            params = std::make_tuple(args...);
        }
        void changeParams (A... args) {
            params = std::make_tuple(args...);
        }
        R operator ()(A... args) {
            params = std::make_tuple(args...);
            return callFunc(typename helper::gens<sizeof...(A)>::type());
        }
        template<int ...S>
        R operator ()() {
            return callFunc(typename helper::gens<sizeof...(A)>::type());
        }
        template<int ...S>
        R callFunc(helper::seq<S...>)
        {
            return (object.*function)(std::get<S>(params)...);
        }
        //private :
        O object;
        std::tuple <A...> params;
        R(O::*function)(A...);
    };
}
#endif // BIND
 

Malheureusement, ça ne fonctionne pas lorsque je veux passer des références à mon slot.

Je sais que il faut utiliser un std::reference_wrapper mais je ne vois pas comment l'utiliser avec les templates variadique..., afin de faire un tuple qui puisse stocker aussi bien des références que des pointeurs.

Bref le but final est d'essayer de faire un binder dont le type ne change pas (que ce soit lorsque j'utilise des références, ou bien des placeholders...)

Bind<void(Ex&, std::string)> b1 (&Ex::of,obj, _1);
    Slot<void, Bind<void(Ex&, std::string)>> s1 (b1);
    s1("1");
Bind<void(Ex&, std::string&)> b2 (&Ex::of,obj, _1);
    Slot<void, Bind<void(Ex&, std::string)>> s2 (b2);
    s2(std::ref("1"));
 

Mais je ne sais pas si c'est possible de faire quelque chose comme ça.

Au pire je mettrai des arguments bidons lors de la création de mon binder si j'en ai pas besoin lors de l'appel du slot que je remplacerai à l'appel du slot, et je n'auriserai pas le passage par référence qui me pose problème mais que par pointeur.

7
Système / Crash avec sf::Clock dans une std::map.
« le: Janvier 03, 2014, 12:02:56 pm »
Salut, ce code-ci sur windows 7 crash chez moi (celui mis entre commentaire) :

void addClock(sf::Clock clock, std::string name)  {
        //std::map<std::string, sf::Clock>::iterator it = clocks.find(name);
        /*if (it != clocks.end())
            throw Erreur (13, "This clock already exist!", 0);*/

        clocks.insert(std::pair<std::string, sf::Clock>(name, clock));
        //clocks.insert(std::make_pair(name, clock));
    }
 

J'ai le même problème avec les sf::Event.

Je n'ai pas testé sur linux mais, si ça fonctionne sous linux je pense que je vais passer sous linux.

8
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.


9
Fenêtrage / Les évènements.
« le: Décembre 30, 2013, 12:46:38 pm »
Salut,

Je voudrais faire une fonction qui se charge d'appeler un slot (avec des paramètres) lorsqu'un évènements SFML précis est délclanché, lors d'une action.

Cependant, il y a un petit problème, sf::Keyboard(...) et event.type.key ne sont pas du même type on dirait car cela ne compile pas :

if (eventType == TYPE::OCCURED_ONCE_ENTERED
                    && sf::Keyboard::isKeyPressed(event.type.key))                
                    b();
 

Bref dommage ça aurait été bien..., je pense que de ce fait je vais devoir recoder une classe pour stocker les states de chaque touche du clavier et boutons de souris et joystick.

Bref, je trouve le système de gestion d'évènements de SFML pas très pratique. (Surtout si on veut faire une classe qui appelle un pointeur de fonction lorsque un ou plusieurs évènements sont déclenchés)

10
Général / Petit problème avec std::remove.
« le: Décembre 25, 2013, 10:54:20 am »
Salut, j'ai essayer de faire la même chose que sur ce tutoriel :
http://fr.sfml-dev.org/forums/index.php?action=post;board=25.0
Mais en utilisant std::remove.

Malheureusement, ça ne marche pas :

#ifndef BINDER_H
#define BINDER_H
#include "sequence.h"
#include "function.h"
struct SLOT {
    template <typename T>
    static Function <typename std::remove_pointer<T>::type> makeSlot (T t) {
        return Function<typename std::remove_pointer<T>::type>(t);
    }
};
#endif // BINDER_H
 

void f (std::string s1, std::string s2) {
    std::cout<<"I'm a function "<<endl;
}
int main () {
     Function<void()> f = SLOT::makeSlot(&f);  
    return 0;
}
 

Il m'indique cette erreur :
main.cpp|30|error: conversion from 'sfgl::Function<sfgl::Function<void()> >' to non-scalar type 'sfgl::Function<void()>' requested|

Est un bu du compilateur ? :o

Pourquoi j'ai un sfgl::Function<sfgl::Function<void()> > d'un côté ???

PS : sinon je voudrais juste essayer de simplifier cette écriture de barbare :

Function<void(std::string, std::string> func = &f
 

Si quelqu'un à une solution je suis preneur. :P

11
Général / Des problèmes avec mingw, encore et toujours. :/
« le: Décembre 15, 2013, 11:33:18 am »
J'ai pensé à installer le compilateur tdm 32 bits, ça compilait bien il y a 2 jours, et puis, je me retrouve avec cette fichue erreur qui ne sort de je ne sais pas d'ou :

Citer
obj\Debug\main.o:c:\tdm-gcc-32\lib\gcc\mingw32\4.8.1\include\c++\iostream|74|first defined here|

Hors que je n'ai pas touché à mon code.

PS : je devrais peut être changer de compilateur, et en prendre un qui marche une bonne fois pour toutes.

12
Graphique / L'utilisation de la vue après un getView provoque un crash
« le: Décembre 03, 2013, 04:21:11 pm »
Salut, la fonction getView() de renderWindow me provoque un crash, voici le code source :
GameStates, contient juste la fenêtre de rendu et le contexte de rendu du jeux.

#define GAME_STATES
#include <SFML/Graphics.hpp>

namespace sfgl {


class GameStates
{
        public:


                struct Context
                {

                        explicit Context(sf::RenderWindow& window, int lightQuality, bool renderLights, bool renderShadow, bool displayMiniMap/*, FontManager& fonts, Cursor& cursor, Player& player*/)
                        : window(window), renderLights (renderLights), renderShadows(renderShadows), lightQuality(lightQuality), displayMiniMap(displayMiniMap)/*, fonts(&fonts), cursor(&cursor), player(&player)*/{}

                        sf::RenderWindow&       window;
                        bool renderShadows;
                        bool renderLights;
                        int lightQuality;
                        bool displayMiniMap;
                       
                };


        public:
                                                        GameStates(Context context);
                virtual                         ~GameStates();

                virtual void            render() = 0;  


        protected:
                void                            requestStackPush(unsigned int id);
                void                            requestStackPop();
                void                            requestStateClear();

                Context&                                getContext() const;

        protected:             
                Context&                                mContext;
};

}

#endif // GAME_STATES
 

Game : rend la frame courante de la game dans la renderwindow :
#include "../../include/SFGL/game.h"
namespace sfgl {
using namespace sf;
using namespace std;
Game::Game (Context context) : GameStates (context) {
    View view = getContext().window.getView();
    renderTextShadows.create(view.getSize().x, view.getSize().y);
    renderTextLights.create(view.getSize().x, view.getSize().y);
}

void Game::render () {
    Map *currentMap = World::getCurrentMap();
    View view = getContext().window.getView();
    Vector2f v2 (view.getCenter().x - view.getSize().x * 0.5f, view.getCenter().y - view.getSize().y * 0.5f);
    if (getContext().renderShadows) {
        renderTextShadows.setView(view);
        renderTextShadows.clear(Color::White);
        RectangleShape rect;
        rect.setPosition(Vector2f(v2.x, v2.y));
        rect.setFillColor((Color(100, 100, 100, 128)));
        rect.setSize(Vector2f (view.getSize().x, view.getSize().y));

        vector<Shadow*> visibleShadows = currentMap->getVisibleShadows();

        for (unsigned int i = 0; i < visibleShadows.size(); i++) {
                renderTextShadows.draw(*visibleShadows[i]);
        }

        renderTextShadows.draw(rect, RenderStates(BlendAdd));
        renderTextShadows.display();
    }
    if (getContext().renderLights) {
        vector<DrawableEntity*> visibleLights = currentMap->getVisibleEntities("E_LIGHT");

        for (unsigned int i = 0; i < visibleLights.size(); i++) {

            renderTextLights.draw(*visibleLights[i], RenderStates(BlendAdd));
        }
        renderTextLights.display();
    }
    vector<DrawableEntity*> visibleTilesGround = currentMap->getVisibleEntities("E_GROUND");
    for (unsigned int i = 0; i < visibleTilesGround.size(); i++) {
         getContext().window.draw(*visibleTilesGround[i]);
    }
    if (getContext().renderShadows) {
         Sprite shadows (renderTextShadows.getTexture());
         shadows.setPosition(v2.x, v2.y);
         getContext().window.draw (shadows, RenderStates(BlendMultiply));

    }
    vector<DrawableEntity*> visibleTilesDecor = currentMap->getVisibleEntities("E_DECOR");
    for (unsigned int i = 0; i < visibleTilesGround.size(); i++) {
         getContext().window.draw(*visibleTilesGround[i]);
    }
    if (getContext().renderLights) {
        Sprite lights (renderTextLights.getTexture());
        lights.setPosition(v2.x, v2.y);
        getContext().window.draw (lights, RenderStates(BlendMultiply));
    }
}
void Game::update() {
    Map *currentMap = World::getCurrentMap();
    View currentView = getContext().window.getView();    
    Vector2f viewPos (currentView.getCenter().x - currentView.getSize().x * 0.5f, currentView.getCenter().y - currentView.getSize().y * 0.5f);
    Vector2f viewSize (currentView.getSize().x, currentView.getSize().y);
    BoundingRectangle viewRect (viewPos.x, viewPos.y, viewSize.x, viewSize.y);
    currentMap->checkVisibleEntities(viewRect);
    if (getContext().renderLights)
        World::getLightManager().computeIntersectionsWithWall();
}
}

 

J'ai un crash à cette ligne lorsque j'essaye d'accéder à une fonction de la classe view :

Vector2f viewPos (currentView.getCenter().x - currentView.getSize().x * 0.5f, currentView.getCenter().y - currentView.getSize().y * 0.5f);
 

Voici le main :

#include <SFGL/utilities.h>
#include <vector>
#include <iostream>
#include <SFGL/World/2D/world.h>
#include <SFGL/World/2D/tGround.h>
#include <SFGL/Graphics/2D/tile.h>
#include <SFGL/BoundingAreas/boundingRectangle.h>
#include <SFGL/Game.h>

using namespace sfgl;
using namespace std;
int main () {
    // création de la fenêtre
    sf::RenderWindow window(sf::VideoMode(800, 600), "My window");
    //On récupère le gestionnaire de texture et on charge les textures du jeux.
    TextureManager &tm = World::getTextureManager();
    if (!tm.loadTexture("tilesets/herbe.png"))
        cerr<<"Error : file not found"<<endl;
    //Crée une nouvelle carte et l'affecte au monde. (Le monde peut être composé de plusieurs cartes.
    Map *currentMap = new Map(100, 50, 30);
    World::addMap(currentMap);
    currentMap->setName("Map test");
    World::setCurrentMap("Map test");
    //On ajoute créer une tile et on l'ajoute au sol.
    Tile *t = new Tile(*tm.getTexture("tilesets/herbe.png"), Vec2f(0, 0), Vec2f(100, 50), sf::IntRect(0, 0, 100, 50), "E_GROUND");
    TileGround *tg = new TileGround(t);
    //On ajoute le sol à la carte.
    currentMap->addEntity(tg);
    /*On définit le contexte de rendu du jeux en passant les paramètre suivants :
    *(Fenêtre de rendu, qualité des lumières (ici 0 vu qu'on en a pas), si on veut afficher les lumière,
    si on veut afficher les ombres et si on veut afficher la mini carte, on met tout à false ici vu que
    on a pas de lumières ni de bâtiments*/

    Game game (GameStates::Context(window, 0, false, false, false));
    game.update();
    // on fait tourner le programme tant que la fenêtre n'a pas été fermée
    while (window.isOpen())
    {
        // on traite tous les évènements de la fenêtre qui ont été générés depuis la dernière itération de la boucle
        sf::Event event;
        while (window.pollEvent(event))
        {
            // fermeture de la fenêtre lorsque l'utilisateur le souhaite
            if (event.type == sf::Event::Closed)
                window.close();

        }
        //On affiche la frame courante du jeux
        //game.render();
        // fin de la frame courante, affichage de tout ce qu'on a dessiné
        window.display();
    }
    //On libère notre texture de la mémoire car on en a plus besoin.
    tm.deleteTexture("tilesets/herbe.png");
    return 0;

}
 


13
Général / Recherche de compilateur mingw qui supporte les regex du c++11.
« le: Décembre 03, 2013, 09:15:03 am »
Salut, j'ai télécharger la version 4.8.0 de mingw que j'ai trouvé sur le site de Qt, le fichier exécutable de mon compilateur s'appelle  i686-w64-mingw32.g++.

Mais cette version est apparemment encore expérimentale, car, sur le site officiel de mingw, quand j'installe la dernière version de mingw qui est la version 4.8.1 apparemment, et que je veux compiler un code qui utilise les std::thread du c++11, il m'indique une erreur comme quoi std::thread n'existe pas. (Et je ne trouve aucun exécutable qui se nomme i686-w64-mingw32.g++ dans le dossier de mingw)

J'ai décidé donc de garder ma version actuelle de mingw, mais, le soucis c'est que, je suis obligé d'utiliser boost car ce code que j'ai trouvé sur internet ne compile pas avec ma version actuelle de mingw :

std::vector<std::string> split(const string& input, const string& regex) {
    // passing -1 as the submatch index parameter performs splitting
    std::sregex_token_iterator
        first{input.begin(), input.end(), regex, -1},
        last;
    return {first, last};
}
 

Donc voilà je recherche une version de mingw qui implémente cette fonction du c++11 afin de pouvoir me passer de boost. (A moins que cette version de mingw n'existe pas encore et que ce n'est possible de faire cela qu'avec un compilateur non open source ? :o )

Car ma version de mingw ne me trouve pas la classe sregex_token_iterator. :/




14
Général / Compiler une librairie.
« le: Novembre 25, 2013, 12:35:03 pm »
Salut, j'ai créer un projet sous code::block pour compiler une librairie statique et j'ai un fichier libSFGL.a
Je voudrais savoir comment tu as compiler SFML toi, avec code::blocks ou en mode console ?
Car je vois que toi tu as plusieurs fichier .a (un pour chaque module en fait), bref, je voudrais un peu savoir comment tu as fait.


15
Projets SFML / Projet d'extension de SFML. (SFML 3D)
« le: Novembre 06, 2013, 12:02:54 pm »
Salut,

j'ai trouvé que ça pourrait être de sympa de pouvoir dessiner des objets en 3D mais avec la simplicité qu'offre SFML.

C'est donc ce pourquoi j'ai décidé de commencer à coder une nouvelle bibliothèque se basant sur SFML, et j'en ai profiter pour mixer tout cela avec du code source de mon autre projet.

Je compte rajouter aussi de la génération de terrain, le chargements de différents formats d'objets 3D (.obj, .md2, .3ds, etc...), de la gestion de collision, etc... (Mais ça se sera pour bien plus tard car je dois terminé mon autre projet)

Etant donné que se projet se base sur la SFML, et utilise SFML, la syntaxe sera la même que celle présentée dans les tutoriels de la SFML.

Il y a juste que les objets transformables et dessinables devront hérité de DynamicDrawableEntity et les objets dessinable non transformable de DrawableEntity.

Un autre changement aussi, pour combiner les transformations si vous voulez faire des graphes de scene, il faudra mettre states.combinedTransform à true, au lieu de combiner directement les transformations dans la méthode draw. (Ceci à été fait pour des raisons d'optimisation, en laissant le soin à opengl (et non au framework) de combiner lui même les transformations)

Bref, voici un exemple de code source qui dessine un cube avec le framework avec une caméra "freefly".

#include "myRenderWindow.h"
#include <SFML/Window/Event.hpp>

using namespace sf3;
MyRenderWindow::MyRenderWindow (Vec2f size, std::string title) :
    RenderWindow(sf::VideoMode(size.x, size.y), title, Style::Default, ContextSettings(32)),
    cube(Vec3f(-1, 1, 1), 2, 2, 2, Color(255, 0, 0)) {
    cube.rotate(45,Vec3f(0, 1, 0));
    view = getDefaultView();
    view->move(0, 0, 10);
    speed = 10.f;
    sensivity = 0.2f;
    oldX = Mouse::getPosition(*this).x;
    oldY = Mouse::getPosition(*this).y;
    verticalMotionActive = false;
    verticalMotionDirection = 0;
}
void MyRenderWindow::show () {
    while(isOpen()) {

        sf::Event event;
        while (pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
            {
                close();
            }
            else if (event.type == sf::Event::Resized)
            {
                // on ajuste le viewport lorsque la fenêtre est redimensionnée
                view->reset(FloatRect(0, 0, event.size.width, event.size.height));
            } else if (event.type == sf::Event::MouseMoved && sf::Mouse::isButtonPressed(Mouse::Right)) {
                int relX = event.mouseMove.x - oldX;
                int relY = event.mouseMove.y - oldY;
                int teta = view->getTeta() - relX;
                int phi = view->getPhi() - relY;
                view->rotate(teta, phi);
                oldX = event.mouseMove.x;
                oldY = event.mouseMove.y;
            } else if (event.type == sf::Event::MouseWheelMoved) {
                if (event.mouseWheel.delta > 0) {
                    verticalMotionActive = true;
                    verticalMotionDirection = 1;
                    timeBeforeStoppingVerticalMotion = milliseconds(250);
                    clock2.restart();
                } else if (event.mouseWheel.delta < 0) {
                    verticalMotionActive = true;
                    verticalMotionDirection = -1;
                    timeBeforeStoppingVerticalMotion = milliseconds(250);
                    clock2.restart();
                }

            }
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) {
            view->move(view->getForward(), speed * clock.getElapsedTime().asSeconds());
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) {
            view->move(view->getForward(), -speed * clock.getElapsedTime().asSeconds());
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
            view->move(view->getLeft(), -speed * clock.getElapsedTime().asSeconds());
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
            view->move(view->getLeft(), speed * clock.getElapsedTime().asSeconds());
        }
        oldX = Mouse::getPosition(*this).x;
        oldY = Mouse::getPosition(*this).y;
        if (clock2.getElapsedTime() > timeBeforeStoppingVerticalMotion) {
            verticalMotionActive = false;
            verticalMotionDirection = 0;
        } else {
            timeBeforeStoppingVerticalMotion -= clock2.getElapsedTime();
        }
        view->move(0, verticalMotionDirection * speed * clock2.getElapsedTime().asSeconds(), 0);
        clear(Color::Black);
        draw(cube);
        display();
        clock.restart();
    }
}
 
#include "Graphics/myRenderWindow.h"
int main() {
    MyRenderWindow renderWindow(Vec2f(800, 600),"SFML3D");
    renderWindow.show();
    return 0;
}
 

Pour le moment le framework ne fait pas grand chose mais des nouvelles fonctionnalités seront rajoutée au fur et à mesure.

PS : je compte aussi améliorer la partie réseau de la SFML pour pouvoir faire des paquets crypté avec openssl.

Pages: [1] 2 3 ... 5 Suivante »