Sujets

1

Suggestions de nouvelles fonctionnalités / Coloration syntaxique de sf::Text

« le: Juillet 04, 2015, 11:44:53 pm »

Bonsoir.
Je n'ai pas vu de fonction dans l'API permettant de le faire, où alors j'ai raté quelque chose ?

Pour l'instant la SFML permet d'afficher un texte, de changer sa couleur, la taille des caractères, etc...
Néanmoins les changement s'appliquent sur tout le texte, et rien de permet par exemple de n'afficher qu'un seul mot en gras.
Si il n'y pas de plus grosses priorités, est-ce envisageable ?

2

Graphique / Redimensionnement Qt + SFML

« le: Novembre 19, 2014, 04:43:42 pm »

Bonjour,

je n'arrive pas a redimensionner correctement mon rendu SFML, qui hérite de QSFMLCanvas, et qui est inclut dans un autre widget (ma fenêtre). J'ai essayé plusieurs choses (dont ce qui est proposé sur le tuto, à la différence que je redimensionne dans une de mes fonction et non lorsque la fenêtre est redimmensionné manuellement) mais j'arrive a chaque fois sur cela:



J'utilise ce code:

    resize(parent->size().width(), parent->size().height()); //parent est le widget parent

    setView(View(FloatRect(0, 0, size().width(), size().height())));

 

Une idée ?

3

Graphique / Problème view + sélection d'un sprite

« le: Octobre 11, 2014, 10:37:27 pm »

Bonsoir,

j'ai un problème lorsque je déplace ma view et que j'essaye de déplacer un personnage.
Indépendamment, les deux fonctionnent très bien, mais quand je déplace ma view et que je clique sur un sprite avec la texture de sélection, le résultat est assez aléatoire : si je déplace une ou deux fois la view, le personnage ne va pas aller au bon endroit, et si je la déplace plus il ne bouge plus du tout. 
En revanche, pas de problèmes si je ne bouge pas ma vue.

Je n'ai mis que les parties concernées afin que la page ne fasse pas 3 km.

main.cpp

int main()
{
    RenderWindow app(VideoMode(1250, 750), "SFML window");
    Carte carte("lvl5");
    Personnage perso("hero1", 5, 3);
    View view1 = app.getDefaultView();


    while (app.isOpen())
    {

        Event event;
        while (app.pollEvent(event))
        {

            if (event.type == Event::MouseButtonReleased)
                {
                   if (event.mouseButton.button == Mouse::Right)

                    perso.bouge(event.mouseButton.x, event.mouseButton.y, &carte);
        }
            if (event.type == Event::Resized){
            FloatRect visibleArea(0, 0, event.size.width, event.size.height);
            app.setView(View(visibleArea));

        }

            if (Keyboard::isKeyPressed(Keyboard::Up)) { view1.move(0, -50);}
            if (Keyboard::isKeyPressed(Keyboard::Right)){view1.move(50, 0);}
            if (Keyboard::isKeyPressed(Keyboard::Down)){view1.move(0, 50);}
            if (Keyboard::isKeyPressed(Keyboard::Left)) {view1.move(-50, 0);}

            if (event.type == Event::Closed)
                app.close();
        }

        app.setView(view1);
        app.clear(Color::Blue);
        perso.canMove(&carte); // Vérifie où le personnage peut se déplacer et décide des sprites à afficher en conséquences
        carte.draw(&app);
        perso.draw(&app);
        app.display();
    }
    return EXIT_SUCCESS;
}
 

carte.cpp

void Carte::getMove(int pixX, int pixY, int deplacement) { // Fonction décrite juste au dessus (qui passe d'abord par le personnage)

    for (int i (0-deplacement); i <= deplacement; i++) {
        for (int j (0-deplacement); j <= deplacement; j++) {

            if (m_tabSquare[pixX+i][pixY+j+1].getPassage() == 0) {
                    if (abs(i) + abs(j) > deplacement) {}
                    else if (i == 0 && j == 0) {}
                    else { m_tabSquare[pixX+i][pixY+j].moveSquare(); }
                }

            else {}
        }

    }
}
 

personnage.cpp

Personnage::Personnage(){}
Personnage::Personnage(std::string persoName, int pixX, int pixY): m_pixX(pixX), m_pixY(pixY) {

    if (!m_textPerso.loadFromFile("textures\\" + persoName + ".png")) { cout << "Erreur chargement : texture personnage" << endl; }
    m_spritePerso.setTexture(m_textPerso);
    m_spritePerso.setPosition(m_pixX*50, m_pixY*50);
    m_deplacement = 3;

}
Personnage::~Personnage() {}

void Personnage::draw (RenderWindow* app) { app->draw(m_spritePerso); }
void Personnage::canMove (Carte* carte) { carte->getMove(m_pixX, m_pixY, m_deplacement); }
void Personnage::bouge (int sourisx, int sourisy, Carte* carte) {

    // Je convertit les coordonnées de la souris car ma carte est juste une image de plusieurs pixel
    int pixSourisX = round(sourisx/50);
    int pixSourisY = round(sourisy/50);

    if (carte->moveOk(pixSourisX, pixSourisY, m_deplacement) == 1)  {
            m_pixX = pixSourisX;
            m_pixY = pixSourisY;
            m_spritePerso.setPosition(m_pixX*50, m_pixY*50);

        }
    else {}
}
 

Merci d'avance pour vos réponses !

4

Graphique / Problème affichage sprite

« le: Septembre 25, 2014, 08:03:52 pm »

Bonjour,

j'essaye d'afficher une carte en Tilemap, mais le programme plante lors de l'affichage (pas de problèmes lors de la compilation). Je pense que le problème viens lorsque je fait ma boucle dans Carte::draw, mais je n'arrive pas a trouver pourquoi 

carte.cpp

#include <iostream>
#include <string>
#include <vector>
#include "Carte.h"

using namespace std;
using namespace sf;

Carte::Carte() {}
Carte::Carte(string lvlname) {

    if (!m_carte.loadFromFile(lvlname + ".png")) { cout << "Erreur chargement : carte" << endl; }
    if (!m_textures.loadFromFile(lvlname + "textures.bmp")) { cout << "Erreur chargement : textures" << endl; }

    int m_mapx (m_carte.getSize().x);
    int m_mapy (m_carte.getSize().y);
    cout << "m_mapx vaut :" << m_mapx << endl;
    cout << "m_mapy vaut :" << m_mapy << endl;

    vector <vector <Square> > m_tabText(m_mapx);

    for (int i (0); i < m_mapx; i++) {
        for (int j (0); j < m_mapy; j++) {
            m_tabText[i].push_back(Square(attributionText(i, j), m_textures, i, j));
        }
    }
}

Carte::~Carte() {}

int Carte::attributionText(int x, int y) {

    if (m_carte.getPixel(x, y) == Color::Black) {return 0;}
    else if (m_carte.getPixel(x, y) == Color::Red) {return 1;}
    else if (m_carte.getPixel(x, y) == Color::Green) {return 2;}
    else if (m_carte.getPixel(x, y) == Color::Blue) {return 3;}
    cout << "Mauvaise attribution de texture" << endl; return 3;
}

void Carte::draw(RenderWindow* app) {

    for (int i (0); i < m_mapx; i++) {
        for (int j (0); j < m_mapy; j++) {
                m_tabText[i][j].draw(app);
        }
    }
}
 

carte.h

#include <string>
#include <vector>
#include <SFML/Graphics.hpp>

#include "Square.h"

class Carte {

public:

    Carte();
    Carte(std::string lvlname);
    ~Carte();
    void draw(sf::RenderWindow* app);

private:

    int attributionText(int i, int j);

    std::string m_lvlname;
    std::vector <std::vector <Square> > m_tabText;

    sf::Image m_carte;
    sf::Texture m_textures;
    sf::Sprite m_sprite;

    int m_numTexture;
    int m_mapx;
    int m_mapy;
    int m_tabColor;
    int m_nbColor;

};

square.cpp

#include <iostream>
#include <SFML/Graphics.hpp>
#include "Square.h"

using namespace std;
using namespace sf;

Square::Square() {}
Square::Square(int numTexture, sf::Texture& textures, int x, int y) {
   
    m_sprite.setTexture(textures);
    m_sprite.setTextureRect(IntRect(50*numTexture, 1, 50, 50));
    m_sprite.setPosition(Vector2f(50*x, 50*y));
}
Square::~Square() {}

void Square::draw(RenderWindow* app) { app->draw(m_sprite); }
 

square.h

#include <string>
#include <vector>
#include <SFML/Graphics.hpp>

class Square {

public:

    Square();
    Square(int numTexture, sf::Texture& textures, int x, int y);
    ~Square();
    void draw(sf::RenderWindow* app);

private:

    sf::Texture m_textures;
    sf::Sprite m_sprite;
    int m_numTexture;
    int m_x;
    int m_y;


};
#endif
 

J'ai fait une classe square (google.trad de "case",  pas sur que se soit ce qu'il y ai de mieux) car j'aimerai faire un T-RPG, donc je vais avoir besoin de savoir si il y a déjà quelqu'un dessus, combien cela coûte en déplacement pour passer par cette case, etc...

Merci d'avance pour vos réponses.