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

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.

[Laurent]

Non, je pense que c'est toi qui t'y prend mal. Le code est correct et personne n'a jamais soulevé un tel problème avant toi.

Fournis un exemple avec un rectangle et un point ayant des coordonnées fixes, parce que là... on ne sait pas ce qu'est target, et ta souris pourrait être n'importe où. En clair ce n'est ni reproductible, ni vérifiable rapidement avec des calculs.

[Glân de Brylan]

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

[Laurent]

Pas sûr qu'on ait besoin de tout le code de ton jeu pour tester une simple fonction comme ça... Quelques coordonnées bien choisies et 3 lignes de code auraient suffi. Quand tu as un doute sur une fonction aussi simple, teste la hors contexte, avec un cas d'utilisation simple. Ca te permet de voir tout de suite si c'est la fonction ou bien ton utilisation de celle-ci qui contient un bug.

Bref. Comme l'erreur saute aux yeux, la voici :

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

... c'est là que tu as inversé les coordonnées.

[Glân de Brylan]

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

Mea culpa.