Messages

1

Suggestions de nouvelles fonctionnalités / Appliquer des filtres à sf::String

« le: Août 30, 2016, 05:26:24 pm »

Bonjour,

En travaillant sur une petite bibliothèque basée sur la SFML, j'ai créé un éditeur de texte et me suis dit que ce serait bien de pouvoir y appliquer des filtres, pour que l'utilisateur ne puisse taper que des chiffres par exemple.
Je me suis du coup rendu compte que sf::String ne permettait pas ce genre de chose.
Du coup j'ai codé un petit truc moi-même (voir plus bas), mais je me suis dit que ce serait pas mal de l'intégrer à la SFML.
Le code ci-dessous n'est qu'une suggestion, je pense que M.Gomilla (ou n'importe qui de plus expérimenté que moi) saura faire mieux.

typedef std::vector<sf::Uint32> CharFilter;

/**
 * \brief Applies the given filter to the string.
 *
 * The filter will remove every character from str that is not in the filter, unless you set the 'exclusive' paramter to true, then it will do the opposite (and remove every character that is in the filter).
 * An empty filter is considered as being "no filter", and thus do not have any effect.
 *
 * \param filter The filter to apply.
 * \param Set to true* if you want the filter to be exclusive, set to false* otherwise.
 */
void String::applyFilter(CharFilter filter, bool exclusive = false)
{
    if(!filter.empty())
    {
        for(std::size_t i = 0 ; i < m_string.getSize() ; i++)
            if( ( std::find(filter.begin(), filter.end(), m_string[i]) != filter.end() ) == exclusive )
                m_string.erase(i);
    }
}

2

Général / Re : Warnings ennuyeux

« le: Août 30, 2015, 09:22:57 am »

Ah, d'accord !
Bon dans ce cas je vais chercher la commande pour gcc. Merci beaucoup !

EDIT : En fait c'est exactement la même, il faut juste remplacer "clang" par "GCC".

3

Général / Re : Warnings ennuyeux

« le: Août 28, 2015, 11:21:42 pm »

Bon, eh bien s'il n'y a pas d'autres options que de retirer le -Winline, tant pis...merci quand même !

4

Général / [Résolu]Warnings ennuyeux

« le: Août 24, 2015, 03:34:35 pm »

Bonjour,

Ce n'est pas vraiment un problème dans la mesure où cela n'empêche mon programme ni de compiler ni de fonctionner, mais quand je compile en mode Release et reçois des palettes d'avertissements de type "warning: inlining failed in call to 'virtual sf::Text::~Text() noexcept': call is unlikely and code size would grow [-Winline]". J'en ai au moins une bonne vingtaine des comme ça.

Ce qui est étrange est quand dans les fichiers concernés le mot-clé inline n'est nulle part...

C'est ennuyeux dans le mesure où cela me gêne pour voir les autres avertissements qui pourraient m'être utiles.

Y a-t-il un moyen de les retirer autrement qu'en retirant le flag -Winline de mon compilo ou dois-je faire avec ? Merci d'avance.

5

Graphique / Re : sf::Rect inverse left et top

« le: Août 24, 2015, 03:28:13 pm »

Wow. Je sais pas quand j'ai écrit ça mais je devais être crevé.

Mea culpa.

6

Graphique / Re : sf::Rect inverse left et top

« le: Août 24, 2015, 12:06:01 pm »

(click to show/hide)

#ifndef GAME_H
#define GAME_H



#include <ctime>
#include <cstdlib>
#include <cmath>

#include <SFML/System/Clock.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Graphics/Texture.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/CircleShape.hpp>
#include <SFML/Graphics/RectangleShape.hpp>
#include <SFML/Graphics/Text.hpp>

#include "Lang.h"
#include "Savegame.h"


class Game
{
    public:
        Game(sf::Font const& font, std::int8_t difficulty);

        ~Game();


        void launch();
        // Starts the game.

        void setNewPosition();
        // Sets a new position to 'target'.

        void calcTargetDistance();
        // Set the right color for 'tip' depending of the distance between the mouse and 'target'.

        bool checkTargetFound();
        // Checks if the played found 'target'.

    private:
        sf::RenderWindow window;
        sf::Event event;
        bool playing, newRecord;
        sf::Clock clock;

        Savegame saveHandler;
        Save score;

        std::int8_t difficultyMode, targetSide;
        // 0 = easy, 1 = normal, 2 = hard, 3 = impossible

        unsigned short errorsCount;

        sf::IntRect target;

        sf::Texture t_background, t_colors;
        sf::Sprite background;
        sf::CircleShape tip;

        sf::Text newScoreMessage, saveScoreMessage, pressSPACEtoContinue;
        sf::Text elapsedTimeText, elapsedTime, errorsText, errors;
        sf::Text recordDisplay, difficultyDisplay;

};

#endif // GAME_H
 

(click to show/hide)

#include "Game.h"


Game::Game(sf::Font const& font, std::int8_t difficulty) : window(), event(), playing(false), newRecord(false), clock(), saveHandler(), score(),
                                                            difficultyMode(difficulty), targetSide(50), errorsCount(0), target(0, 0, 50, 50),
                                                            t_background(), t_colors(), background(), tip(16),
                                                            newScoreMessage(Lang::L_newScore, font, 60), pressSPACEtoContinue(Lang::L_pressSPACE, font),
                                                            elapsedTimeText(Lang::L_time, font), elapsedTime("0", font), errorsText(Lang::L_errors, font), errors("0", font),
                                                            recordDisplay("Record : 0s 0e", font), difficultyDisplay(Lang::L_easy, font, 14)
{
    switch(difficultyMode)
    {
    case 0:
        break;
    case 1:
        target.height = 30;
        target.width = 30;
        targetSide = 30;
        difficultyDisplay.setString("Normal");
        break;
    case 2:
        target.height = 10;
        target.width = 10;
        targetSide = 10;
        difficultyDisplay.setString(Lang::L_hard);
        break;
    default:
        target.height = 1;
        target.width = 1;
        targetSide = 0;
        difficultyDisplay.setString("Impossible");
    }

    score = saveHandler.getSave(difficulty);

    t_background.loadFromFile("background.png");
    t_colors.loadFromFile("colors.png");
    background.setTexture(t_background, true);
    tip.setPosition(756, 3);
    tip.setTexture(&t_colors, true);
    difficultyDisplay.setPosition(772 - difficultyDisplay.getLocalBounds().width / 2, 32);

    elapsedTimeText.setPosition(10, 5);
    elapsedTime.setPosition(10 + elapsedTimeText.getLocalBounds().width, 7);
    errorsText.setPosition(250, 5);
    errors.setPosition(250 + errorsText.getLocalBounds().width, 7);

    recordDisplay.setPosition(500, 5);

    newScoreMessage.setPosition((800 - newScoreMessage.getLocalBounds().width) / 2, 250);
    pressSPACEtoContinue.setPosition((800 - pressSPACEtoContinue.getLocalBounds().width) / 2, 320);
}


//////////////////////////////////////////////////////////////////////////////

Game::~Game()
{

}


//////////////////////////////////////////////////////////////////////////////


void Game::launch()
{
    window.create(sf::VideoMode(800, 600), "So close ! v1.0", sf::Style::Titlebar | sf::Style::Close);

    window.setFramerateLimit(60);

    setNewPosition();

    while(window.isOpen())
    {
        if(playing)
        {
            calcTargetDistance();

            float time(clock.getElapsedTime().asSeconds());
            std::string timeStr(std::to_string(clock.getElapsedTime().asSeconds()));
            if(time < 10)
                timeStr.resize(3);
            else
                timeStr.resize(4);

            elapsedTime.setString(timeStr);
            errors.setString(std::to_string(errorsCount));
        }

        window.clear();
        window.draw(background);
        window.draw(tip);
        window.draw(elapsedTimeText);
        window.draw(elapsedTime);
        window.draw(errorsText);
        window.draw(errors);
        window.draw(recordDisplay);
        window.draw(difficultyDisplay);

        if(newRecord)
            window.draw(newScoreMessage);
        if(!playing)
            window.draw(pressSPACEtoContinue);

        window.display();

        while(window.pollEvent(event))
        {
            switch(event.type)
            {
            case sf::Event::Closed:
                window.close();
                break;

            case sf::Event::MouseMoved:
                if(playing)
                    calcTargetDistance();
                break;

            case sf::Event::MouseButtonReleased:
                if(playing && event.mouseButton.button == sf::Mouse::Left)
                {
                    if(checkTargetFound())
                    {
                        playing = false;
                        // the player found it ! you must do something.

                    }
                    else
                        errorsCount++;
                }
                break;

            case sf::Event::KeyPressed:
                if(event.key.code == sf::Keyboard::Space)
                {
                    if(!playing)
                    {
                        playing = true;
                        errorsCount = 0;
                        clock.restart();
                    }
                    else
                    {
                        playing = false;
                        tip.setTextureRect(sf::IntRect(0, 0, 255, 1));
                        setNewPosition();
                    }
                }
                break;

            default:
                break;
            }
        }

    }
}


//////////////////////////////////////////////////////////////////////////////

void Game::setNewPosition()
{
    int x(797), y(546);

    switch(difficultyMode)
    {
    case 0:
        x-=20;
        y-=20;
    case 1:
        x-=20;
        x-=20;
    case 2:
        x-=10;
        y-=10;
        break;
    default:
        break;
    }

    target.top = rand() % x;
    target.left = ( rand() % y ) + 53;
}


//////////////////////////////////////////////////////////////////////////////

void Game::calcTargetDistance()
{

    short distance(0);

    sf::Vector2i mouse(sf::Mouse::getPosition(window));
    sf::Vector2i targetPos(target.height/2 + target.top, target.width / 2 + target.left);
    sf::Vector2i diff(mouse - targetPos);
    diff.x *= diff.x;
    diff.y *= diff.y;

    distance = sqrt(diff.x + diff.y);

    if(distance < targetSide/2)
        distance = 0;
    else
        distance -= targetSide/2;

    if(distance > 255)
        distance = 255;

    tip.setTextureRect(sf::IntRect(distance, 0, 1, 1));
}


//////////////////////////////////////////////////////////////////////////////

bool Game::checkTargetFound()
{
    sf::Vector2i mousePos(sf::Mouse::getPosition(window).y, sf::Mouse::getPosition(window).x); // on inverse x et y pour cause de bug de sf::Rect...

    return target.contains(mousePos);
}


 

Le jeu tel qu'il est fonctionne.
Quand on lance le jeu, on a une fenêtre qui indique "Appuyez sur ESPACE pour commencer une nouvelle partie" (ce à quoi correspond Lang::L_pressSPACE situé dans Lang.h).
On appuie sur la barre espace, le rectangle est placé quelque part aléatoirement et le timer se lance. En haut à droite on a un disque qui tend vers le vert quand on s'approche du rectangle et vers le rouge quand on s'en éloigne (c'est un jeu de chaud ou froid en fait).
Quand on clique, soit le bout de la souris n'est pas dans le rectangle et le compte d'erreurs est incrémenté, soit elle y est et le timer s'arrête, le message "Appuyez sur ESPACE" est affiché et le disque reste vert pour indiquer qu'on l'a trouvé.
Sinon, si on appuie sur espace, le jeu s'arrête également, mais le disque devient un fondu de vert au rouge pour indiquer qu'on a abandonné.

Si vous voulez le projet complet il est téléchargeable ici :
https://www.mediafire.com/?umbkb9ndm1mi285
Pour l'instant il n'est pas fini, le jeu ne gère pas encore complètement le système de sauvegarde, mais c'est tout ce qui manque.

7

Graphique / [Résolul] sf::Rect inverse left et top

« le: Août 24, 2015, 11:33:25 am »

Bonjour,

Je crois avoir trouvé un bug : sf::Rect utilise left comme coordonnée y et top comme coordonnée x.
Pour preuve, si je fais le code suivant (où target est un IntRect) :

if(target.contains(sf::Mouse::getPosition(window)))
{
    std::cout<<"Found it, GG !\n";
    return true;
}
else
    return false;
 

Et que la souris est dans le rectangle, la fonction renvoie false. Par contre si je fais :

sf::Vector2i mousePos(sf::Mouse::getPosition(window).y, sf::Mouse::getPosition(window).x); // on inverse x et y...
if(target.contains(mousePos))
{
    std::cout<<"Found it, GG !\n";
    return true;
}
else
    return false;

Le fonction renvoie true. Alors évidemment c'est contournable comme je viens de le faire mais c'est assez gênant quand même.

Dites-moi si c'est un vrai bug, si je suis le seul à l'avoir ou si je m'y prend juste mal ?
Sachant que j'utilise SFML 2.3.1, soit la dernière version.

8

Général / Re : Point d'entrée introuvable

« le: Août 07, 2015, 11:16:27 am »

Bon, ben, j'ai téléchargé la version pour GCC 4.8, vu qu'il n'y a pas de version SJLJ pour GCC 4.9...et ça fonctionne.
Je comprend vraiment pas. Déjà parce que je suis certain que j'avais téléchargé la version pour 4.9.2 (DW2) de SFML 2.2, et ensuite parce que ça fontionne parce que j'ai téléchargé la version pour GCC 4.8.1 et que j'utilise la 4.9.2.

Enfin...si ça fonctionne j'imagine que c'est le principal...Je crois que je vais réessayer de le compiler moi-même quand même.

9

Général / Point d'entrée introuvable

« le: Août 06, 2015, 11:31:37 pm »

Bonjour à tous,

Il m'était venu à l'idée un petit jeu et je me suis donc dit qu'il était temps de dépoussiérer SFML. J'en profite pour aller vérifier s'il y a eu des mises à jour et, surprise ! il en en a eu. Je passe donc de la 2.2 à la 2.3.1.
Je configure mon projet pour donner le chemin vers le dossier include, le dossier lib, je met les bons fichiers dans le linker (avec les -d pour le mode debug et tout ça).
Comme d'hab quoi. Exactement comme je faisais avec chaque nouveau projet SFML et comme indiqué dans le tuto. Puis je met les .dll dans le dossier de l'exécutable (encore une fois en faisant gaffe aux -d).

Seulement voilà : en exécutant une première fois le programme pour un test, je tombe sur une fenêtre titrée "Sousse.exe - Point d'entrée introuvable" (no coment sur le nom de mon jeu ok ?) et qui dit exactement :

Le point d'entrée de procédure _gxx_personality_v0 est introuvable dans la bibliothèque de liens dynamiques C:\Users\Jules\Desktop\C++\Projets SFML\Sousse\bin\Debug\sfml-graphics-d-2.dll

Sachant que j'utilise Code::Blocks 13.12 et GCC 4.9.2 32 bits sur Windows 8.1 64 bits et que :
– Oui, j'ai bien fait gaffe à télécharger la version "GCC 4.9.2 MinGW (DW2) - 32-bit" de SFML, comme je l'avais fait il y a quelques mois avec SFML 2.2 qui fonctionnait très bien.
– J'ai bien fait attention à mettre les .dll de SFML 2.3.1 et pas ceux de la 2.2.
– Il n'y a aucune erreur dans mon linking, les bons chemins sont bien indiqués.
– J'ai mis les bibliothèques dans le bon ordre, à savoir system tout en bas, puis windows juste au dessus, puis graphics, audio, et network au dessus de tout ça.
– J'ai réinstallé Code::Blocks.
– J'ai réinstallé GCC.
– J'ai re-téléchargé SFML 2.3.1.
– J'ai ré-téléchargé SFML 2.2. Et ça me donne la même erreur alors qu'il y a quelques mois il n'y avait aucun problème
– J'ai compilé SFML moi-même avec CMake. Pas mieux. Et à savoir que la commande mingw32-make install ne fonctionne pas, il me dit qu'il n'y a aucune ordre avec le nom "install".
– J'ai collé les .dll un peu partout.
– Je n'ai rien trouvé de probant, ni sur ce forum, ni sur le forum anglais, ni sur gogol.
– Mon code est celui du tuto.
– Je connais un mec qui peut avaler douze kilomètres de boudin sans mâcher.

Donc...un peu d'aide ? S'il vous plaît ? Merci d'avance.

Même si je sens que je vais me faire houspiller parce que la solution était sous mes yeux depuis le début mais que je suis un sac :S

10

Graphique / Re : sf::PrimitiveTpe::Quads ?

« le: Avril 20, 2015, 04:39:00 pm »

D'accord, merci ! Pour l'instant je n'ai pas l'intention de compiler sur une autre plate-forme que Windows, donc ça devrait aller.
Merci encore pour votre réponse rapide et précise !

11

Graphique / [Résolu] sf::PrimitiveTpe::Quads ?

« le: Avril 20, 2015, 02:06:10 pm »

Bonjour,

J'ai une question à propos du PrimitiveType::Quads. J'ai lu qu'il était déconseiller de l'utiliser car ne fonctionnant pas sur toutes les versions d'OpenGL.
Première chose que je ne comprend pas : quand j'installe SFML, les fonctions OpenGL nécessaires ne sont pas incluses dans les fichiers binaires ou les .dll ? En clair, la fonction d'OpenGL utilisée dépend-elle de la machine et non de ce que j'ai téléchargé sur le site ?

Ensuite, ma question la plus importante : si j'utilise les Quads, que je compile, et que mon exécutable fonctionne sur ma machine, si je donne mon exécutable (et tous les dlls qui vont avec) à quelqu'un d'autre, suis-je assuré que cela fonctionne ou peut-il y avoir un couac à cause de ça ?

Merci d'avance pour vos réponses. S'il vous plaît tenez compte du fait que je ne connais pas du tout OpenGL.

12

Général / Re : [ Résolu ] SIGSEGV (inventaire)

« le: Avril 19, 2015, 03:17:30 pm »

Donc bah pour le reste débrouille-toi...vas-y à grands coups de mapCoordsToPixel() et mapPixelToCoords(). Pour le reste il y a la doc'.

13

Général / Re : SIGSEGV (inventaire)

« le: Avril 19, 2015, 11:34:35 am »

J'avais oublié que les attributs étaient par défaut privés dans une classe...je manque terriblement de pratique.

Sinon, tu donnes bien une texture valide quand tu appelles add() ? Une texture qui n'est pas détruite à un moment ou un autre ?
Il me semble que tu n'utilises pas de vue personnalisée, si ?

14

Général / Re : SIGSEGV (inventaire)

« le: Avril 18, 2015, 08:16:42 pm »

Ah oui, exact. Étant donné la structure des vectors ça me semblait impossible, mais apparemment non. Au temps pour moi.

15

Général / Re : SIGSEGV (inventaire)

« le: Avril 18, 2015, 04:48:11 pm »

bool del(/*std::string delName*/) {
        //je sais pas comment delete une case précise dans un vector.
        //et evidemment, je peux pas utiliser pop_back...
        return true;
    }

Alors si tu veux pouvoir supprimer des cases au milieu de ton tableau tu devrais utiliser des list. Avec un vector, c'est impossible. Par contre, tu ne pourras plus utiliser les crochets [] pou accéder à un élément. Tu sais te servir des itérateurs ?

En fait, idéalement, tu te servirais des priority_queue pour trier tes éléments en mettant celui le plus à gauche (avec le x le plus petit) en premier, pour facilement ajouter 32 au x d'un élément que tu ajouterais.

Ensuite, plutôt que d'avoir un vector<int>, un vector<std::string> et un vector<sf::Sprite>, tu devrais avoir un seul vector d'objets de ce genre :

class InvSpace
{
    InvSpace() : number(0), name(""), image() {}
    InvSpace(int qty, const std::string& nm, const sf::Texture& texture) : number(qty), name(nm), image(texture) {}

    int number;
    std::string name;
    sf::Sprite image;
}

Ce serait plus simple. Et surtout, le C++ te permet de mettre ensemble les données qui sont liées, alors ne te gêne pas.
Comme ton inventaire a une taille limite, je te conseillerais d'avoir un simple tableau d'InvSpace de taille 16, ou à la rigueur un std::array<InvSpace, 16>. Et pour indiquer qu'une case est vide, il suffirait de faire :
myObjects[index].number = 0;
Pour indiquer que cette case est vide.
La position du sprite devrait être indiquée dans ta fonction add, ce n'est pas le rôle d'une fonction de dessin, qui devrait seulement faire :

void drawInventory(sf::RenderWindow& w)
{
    w.draw(invTextName);

    for( std::size_t i(0) ; i < invImg.size() ; i++)
        if(myObjects[i].number > 0)
            w.draw(myObjects[i].image);
}

Ensuite, ta fonction add :

bool add (int nbr, std::string str, const sf::Texture& img) // note comme je demande une texture plutôt qu'un sprite
{
    bool found = false;

    for (std::size_t i(0) ; i < 16 ; i++)
    {
        if (myObjects[i].name == str) // on a trouvé une case qui contient déjà de ces objets !
        {
            myObjects[i].number += nbr; // donc on en ajoute le nombre qu'il faut.
            return true; // objets ajoutés à l'inventaire avec succès.
        }
    }

    for(std::size_t i(0) ; i < 16 ; i++) // aucune case contenant déjà de ces objets n'a été trouvée, on va donc en chercher une vide.
    {
        if(myObjects[i].number == 0) // si cette case est vide...
        {
            myObjects[i].number = nbr; // ...on la remplit avec notre nouvel objet.
            myObjects[i].name = str;
            myObjects[i].image.setTexture(texture);

            if(i == 0) // si c'est la première case de l'inventaire...
                myObjects[i].image.setPosition(/* x et y du premier objet*/); // ...on lui donne la position du premier objet à afficher.
            else
            {
                myObjects[i].image.setPosition( myObjects[i-1].image.getPosition() ); // ...sinon on lui donne la position de l'objet d'avant...
                myObjects[i].image.move(32f, 0); // ...avec x+32 !
            }
            return true; // objets ajoutés à l'inventaire avec succès.
        }
    }

    return false; // échec, l'inventaire est plein, les objets n'ont pas pu y être ajoutés.
}

Si ça ne fonctionne pas...je ne sais plus quoi faire.


Enfin, met des retours à la ligne entre tes fonctions, aère ton code, ça le rend plus facile à lire. Si tu regardes le code source de la SFML tu verras qu'il met même des grandes lignes de / entre ses fonctions pour bien les séparer.