Sujets

1

Projets SFML / Shoot'hem uuuuuuuuuuuuup

« le: Août 08, 2012, 01:58:16 pm »

Salutations messieurs (et les deux filles, au fond)

Voilà, après avoir un peu galéré pour installer SFML, je me suis lancé dans un moteur de jeu. Ce moteur a pour but de créer un shoot'hem up, mais devrait être réutilisable pour à peu près n'importe quel type de jeu 2D (plateforme, RPG ...).

Le jeu en lui même avance pas mal, je devrais avoir une version jouable sous peu (le temps de debugger et d'ajouter deux-trois fonctionnalités). C'est le moteur qui pose problème. Il est assez imposant en lignes de codes (normal), mais ce qui m'embête, c'est que j'ai l'impression de l'avoir mal structuré : j'ai beaucoup de mal à apporter des modifications sans modifier tout plein de trucs, il est assez peu flexible.

Donc, j'aimerais vous le soumettre (seulement les headers, en fait, sinon ça fera trop de lecture :p) pour que vous me disiez, éventuellement, si j'ai merdé quelque part. Je suis encore débutant, après tout, donc ...

Entrees/TableauEntrees.h

enum Touche
{Desactivee, Pressee, Activee, Lachee};

class MajTouche //foncteur
{
    public :
    void operator()(std::pair<const sf::Mouse::Button, Touche>& x);
    void operator()(std::pair<const sf::Keyboard::Key, Touche>& x);
};


class Entrees
{
    public :

    Entrees(sf::Window* fenetre = 0);
    bool fini();
    sf::Vector2f curseur();
    void MAJ();

    std::map<sf::Mouse::Button, Touche>& boutonsSouris();
    std::map<sf::Keyboard::Key , Touche> boutonsClavier();

    protected :
// des variables
};

Graphique/AfficheurObjets.h

class AfficheurObjets
{
    public :

    AfficheurObjets(sf::RenderTarget* cible);

    void afficher(const ObjetAffichable& objet, const ParametresAffichage& para);
    void afficher(const ObjetAffichable& objet);

    void effacer();
};

Graphique/ObjetAffichable.h

class ObjetAffichable // Interface d'objet affichable
{
    virtual const sf::Drawable& afficher() const = 0;
    virtual void MAJ() {}
};

Graphique/Sprite.h

class Sprite : public ObjetAffichable
{
    public :

    Sprite();
    Sprite(const sf::Texture& paraObjet);

    void attribuer(const sf::Texture& paraObjet);

    sf::Sprite& afficher();
    const sf::Sprite& afficher() const;

    void deplacer(const sf::Vector2f& distance);

    protected :

    private :

    sf::Sprite m_sprite;

};

Jeu/Physique/Mouvement.h

class Mouvement
{
    public :

    Mouvement( sf::Vector2f position = sf::Vector2f(0,0), sf::Vector2f vitesse = sf::Vector2f(0,0) );

    void MAJ();
    virtual void changerVitesse(sf::Vector2f nvitesse, bool relatif = false);

    sf::Vector2f position() const;
    sf::Vector2f vitesse() const;

    protected :
    void deplacer(sf::Vector2f nposition, bool relatif = false);
};

Jeu/Physique/ObjetPhysique

class ObjetPhysique : public Mouvement
{
    public :

    ObjetPhysique(sf::IntRect parametres = RECT_NUL,
                  sf::Vector2f position = POINT_NUL, sf::Vector2f vitesse = POINT_NUL);

    sf::IntRect boiteAbsolue() const;
    sf::IntRect boiteRelative() const;
    sf::Vector2f decalage() const;
    void aligner(bool reset);
};
bool testerCollision(const ObjetPhysique& objet1, const ObjetPhysique& objet2);

bool testerCollision(const sf::IntRect& rectangle1, const sf::IntRect& rectangle2);
bool testerCollision(const sf::Vector2f& rectangle1, const sf::IntRect& rectangle2);
inline bool testerCollision(const sf::IntRect& rectangle1, const sf::Vector2f& Point2);

Jeu/Emetteur.h

template <typename T>
class Emetteur
{
    public :
    virtual void attribuer(TableauVart<T>& ncible);
    virtual void creer(sf::Vector2f position) = 0;

    protected :
    TableauVart<T>& cible();
};

Jeu/Majable.h

class Majable //interface
{
    virtual void MAJ() = 0;
    virtual bool detruire() const = 0;
};

Jeu/VartAbs.h

class VartAbs : public Majable // encore une interface
{
    virtual void afficherDans(AfficheurObjets&) = 0;
};
/* Petite explication : sous ce nom qui ne veut rien dire se cache l'interface
de tous les objets de jeu. Pour être précis, de tous les objets qui sont mis
à jour à chaque frame et que l'on affiche juste après
*/

Jeu/Vart.h

class Vart : public VartAbs, public ObjetPhysique
{
    public :

    Vart(const ParaVart& para);
    Vart(const ParaVart& para, sf::Vector2f position);

    virtual void MAJ();
    virtual bool detruire() const;
    virtual void afficherDans(AfficheurObjets&);

    protected :
    virtual void detruireObjet();
};

Jeu/ParametresVart.h

class ParaVart
{
    public :

    ParaVart();
    ParaVart(const sf::Texture& nSprite, const sf::IntRect& nHitbox, const sf::Vector2f& nVitesse);

    void attribuer(const sf::Texture& nSprite, const sf::IntRect& nHitbox, const sf::Vector2f& nVitesse);
    void attribuer(std::istream& flux, std::map<std::string, Sprite>& tableauSprites);

    Sprite sprite() const;
    sf::IntRect hitbox() const;
    sf::Vector2f vitesse() const;
};

Jeu/TableauVarts.h

template <typename T = VartAbs>
class TableauVart : public VartAbs
{
    public :

    TableauVart();

    void ajouter(T* nvart);
    inline const std::vector< boost::shared_ptr<T> >& tableau() const;
    inline std::vector< boost::shared_ptr<T> >& tableau();

    inline boost::shared_ptr<T> objetN(unsigned short lequel);
    inline const boost::shared_ptr<T> objetN(unsigned short lequel) const;
    inline unsigned short taille() const;

    virtual void MAJ();
    virtual bool detruire() const;
    virtual void afficherDans(AfficheurObjets& cible);

    protected :
    void enlever(int lequel);
};
/* La classe dont je suis le plus fier. Elle stocke un vector de Varts et leur applique
les méthodes qu'on lui applique (ce qui permet notamment la récursivité)*/

Alea.h

class Alea
{
    public :
    Alea();
    int operator()(int maximum);
    int operator()(int minimum, int maximum);
};

Gestionnaire.h

class Gestionnaire
{
    public :

    Gestionnaire(Niveau* niveauJoue = 0, Entrees* tableauEntrees = 0, sf::RenderWindow* cible = 0);
    void attribuer(Niveau* niveauJoue, Entrees* tableauEntrees, sf::RenderWindow* cible);

    virtual void MAJ();
    virtual bool continuer();
};

Niveau.h

class Niveau : public VartAbs
{
    public :
    Niveau();
    virtual void attribuer(std::istream& chaineNiveau, Entrees* entrees) = 0;

    virtual void MAJ();
    virtual bool detruire() const;
    virtual void afficherDans(AfficheurObjets& fenetre);

    protected :
    void ajouter(VartAbs* ajout);
    virtual void finirJeu();
    Entrees* m_entrees; // use-a
};

Timer.h

class Chronometre
{
    public :

    Chronometre(int tempsDepart = 0, int tempsMax = 0, bool razAuto = true);

    void modifierTempsMax(int nTemps);
    void modifierTemps(int nTemps, bool limiter = false);
    virtual void razTemps();

    bool decrementer();

    inline int tempsMax() const;
    inline int temps() const;
};

Voilà, c'étaient tous les headers du moteur. Si vous avez des questions ou des conseils, hésitez pas

2

Général / IDE à utiliser

« le: Avril 10, 2012, 06:47:40 pm »

Bonjours à vous, humains, humaines, geeks et autres suppôts de Chtulhu !

Je voulais poser une petite question qui me trottait dans la tête depuis un bout de temps : quel IDE utilisez-vous pour compiler vos projets SFML ? Parce que, dans mon cas :
- SFML ne marche pas avec Code::Blocks sous Windows 7
- Je ne parle même pas de Visual 2010 ...
- Le debugger de CodeBlocks ne marche pas sur XP
- Et Visual 2008 me renvoie plusieurs erreurs incompréhensible (C2275, c'est pas censé être une erreur typique du C ?)

Donc, j'aimerais bien savoir comment vous faites, vous autres codeurs qui arrivez à créer des projets SFML ? Pour ma part, je bloque un peu partout ... :/