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 - Arnibou

Pages: [1]
1
Général / (Résolu) Problème itérator sur map et sf::Text
« le: Mars 17, 2013, 01:54:41 pm »
Bonjour,

Dans le cadre de mon jeu, j'ai 1 classe quete qui contient 2 map (1 pour le titre de la quete et 1 pour l'objectif avec un id correspondant)
Dans la gui, j'ai une fonction Gui::boite de dialogue qui recupére des données et les affiche.

Quand j'affectionne une quete à une entite, cela affiche le titre de la quete (avec un iterateur sur la 1ere map) et quand je clic sur la quete j'ai le descriptif de cette derniére avec l'objectif qui s'affichent (iterateur sur la 2eme map pour l'objectif)

Et là c'est le drame si j'affectionne l'objectif 1 (1ere case de la map j'ai un joli segmenlt fault) par contre le 2, 3 etc... fonctionnent.
Par contre si j'affectionne une autre quete à une entite qui a pour objectif la case n°2 et que je lui parle en 1er, si je vais voir celui qui a l'objectif 1 ensuite et que je lui parle, cela fonctionne.

En isolant un peu de code je me suis rendu compte que c'est au moment du setString que cela coince car avec un std::cout cela fonctionne ...

Je ne parle pas de la 1ere map (titre de la quete) ou cela fonctionne bien.

Du code maintenant:
Partie où je me sers des iterateurs
 if(entite_cible_actuelle.recup_pnj_a_quete())
            {
                //Affichage de l'icone quête si le pnj a une quête
                spr_icone_quete = new sf::Sprite;
                spr_icone_quete->setTexture(texture_icone_quete);
                spr_icone_quete->setScale(0.2, 0.2);
                spr_icone_quete->setPosition(pos_vue.x - 428, pos_vue.y - 127);
                target.draw(*spr_icone_quete);
                //iterator pour parcourir le conteneur map de quêtes
                std::map<int, std::string>::iterator id_quete = texte_quete.recup_titre_quete().find(entite_cible_actuelle.recup_id_quete());
                //Affichage du titre de la quête
                if(id_quete == texte_quete.recup_titre_quete().end())
                std::cout << "Titre de la quete introuvable." << std::endl;
                else
                {
                    titre_quete = new sf::Text;
                    titre_quete->setString(id_quete->second); ///// ICI cela fonctionne ////
                    titre_quete->setCharacterSize(15);
                    if(!color_titre_quete)
                    titre_quete->setColor(sf::Color::Black);
                    else
                    {
                        titre_quete->setColor(sf::Color::Blue);
                        titre_quete->setScale(1.1f, 1.1f);
                    }
                    titre_quete->setStyle(sf::Text::Italic);
                    titre_quete->setPosition(pos_vue.x - 400, pos_vue.y - 120);
                    box_titre_quete = titre_quete->getGlobalBounds();
                    target.draw(*titre_quete);
                }
            }
            spr_annuler = new sf::Sprite; //Bouton Annuler
            spr_annuler->setTexture(texture_annuler);
            spr_annuler->setPosition(pos_vue.x - 270, pos_vue.y + 170);
            box_bouton_annuler = spr_annuler->getGlobalBounds();
            target.draw(*spr_annuler);
        }
        //DESCRIPTIF QUETE
        else
        {
            //Changement position et taille icone quête
            delete spr_icone_quete;
            spr_icone_quete = NULL;
            //Changement position et taille titre quête
            titre_quete->setColor(sf::Color::Black);
            titre_quete->setStyle(sf::Text::Underlined);
            titre_quete->setCharacterSize(18);
            titre_quete->setPosition(pos_vue.x - 430, pos_vue.y - 175);
            target.draw(*titre_quete);
            //Affichage du descriptif de la quete
            sf::Text text_quete[texte_quete.descriptif_quete(entite_cible_actuelle.recup_id_quete(), joueur.recup_pseudo()).size()];
            //text_accueil->setFont(font_quete);
            for(unsigned int i = 0; i < texte_quete.descriptif_quete(entite_cible_actuelle.recup_id_quete(), joueur.recup_pseudo()).size(); i++)
            {
                text_quete[i].setString(texte_quete.descriptif_quete(entite_cible_actuelle.recup_id_quete(), joueur.recup_pseudo())[i]);
                text_quete[i].setCharacterSize(14);
                text_quete[i].setColor(sf::Color::Black);
                text_quete[i].setPosition(pos_vue.x - 430, pos_vue.y - 140 + (i *15));
                target.draw(text_quete[i]);
            }
            //iterator pour parcourir le conteneur map d'objectif de quete
            std::map<int, std::string>::iterator objectif_quete = texte_quete.recup_objectif_quete().find(entite_cible_actuelle.recup_id_quete());
            if(objectif_quete ==  texte_quete.recup_objectif_quete().end())
            std::cout << "Objectif de la quete introuvable" << std::endl;
            else
            {
                //Objectif(s)
                sf::Text text_objectif[2];
                text_objectif[0].setString("Objectif :");
                text_objectif[0].setColor(sf::Color::Black);
                text_objectif[0].setStyle(sf::Text::Underlined);
                text_objectif[0].setCharacterSize(18);
                text_objectif[0].setPosition(pos_vue.x - 430, pos_vue.y);
                text_objectif[1].setString(objectif_quete->second);  ///////// ICI si j'affectionne la 1ere case à une entite, J'ai le plantage //////////
                text_objectif[1].setColor(sf::Color::Black);
                text_objectif[1].setCharacterSize(14);
                text_objectif[1].setPosition(pos_vue.x - 430, pos_vue.y + 30);
                for(unsigned int i = 0; i < 2; i++)
                target.draw(text_objectif[i]);
           }
 

La partie où il ya mes maps et qui les renvoit

Quete::Quete()
{
    //Ajout des quêtes dans le conteneur
    list_quetes[1] = "Un réveil brutal";
    list_quetes[2] = "Un monde chaothique";
    list_quetes[3] = "La dette de Pascal";
    list_quetes[4] = "L'entrainement de base";
    list_quetes[5] = "En route pour l'aventure";

    //Ajout d'objectif de quete
    objectif_quetes[1] = "Parler à Mouloud.";
    objectif_quetes[2] = "Parler à Azerty pour en apprendre plus \nsur ce monde.";
}

std::map<int, std::string> Quete::recup_titre_quete() const
{
    return list_quetes;
}

std::map<int, std::string> Quete::recup_objectif_quete() const
{
    return objectif_quetes;
}
 

Voila ce que le compilo me mets quand ça plante :

#0 6609D508     std::string::length() const() (D:\Projet\World of Chaos\sfml-system-d-2.dll:??)
#1 660822ED     sf::String::String(this=0x27c824, ansiString=..., locale=...) (D:\developpement\sfml-master\src\SFML\System\String.cpp:85)
#2 0040556A     _fu6___ZSt4cout() (D:\Projet\World of Chaos\gui.cpp:282)
#3 0040729C     Jeu::Jeu(this=0x27d960) (D:\Projet\World of Chaos\jeu.cpp:74)
#4 00407A90     main() (D:\Projet\World of Chaos\main.cpp:6)
 

Je ne vois d'où peut venir le problème.
J'utilise code block 10.05
la version de sfml : SFML-2.0-rc-windows-32-gcc4-sjlj

2
Général / Probleme d'état d'un bool dans une boucle avec un contains
« le: Février 19, 2013, 09:43:59 pm »
Bonsoir,

Me voici avec un petit problème que je pige pas, pour résumer j'ai un vector de sf:FloatRect et la position de la souris en temps réel.
J'ai fais une boucle pour savoir si la souris est en collision avec chaque box.

Dans la boucle j'ai mis des sf::text etc ... et tout fonctionne bien.

Mais j'ai voulu rajouté un bool pour m'afficher si ça touche ou pas (je vais m'en servir plus loin dans le programme de ce bool)
Le problème il se met à true seulement au dernier élément du vector, quand je passe la souris sur les premiers sprites, le bool reste à 0 et quand je la passe sur le dernier ça passe bien à 1.

Je ne comprend pas ce qu'il se passe même si je pense que c'est tout bête ...
J'ai mis les 2 lignes de commentaires à propos de ce bool

void Gui::collision_souris_sprite_entite(sf::RenderTarget &target, std::vector<sf::FloatRect> &box_entite, sf::View &vue, std::vector<Entite> &total_entite, bool clic_gauche)
{
    for(unsigned int i = 0; i < total_entite.size(); i ++)
    {
        if(box_entite[i].contains(pos_souris_vue))
        {
            touche_entite = true; // <-----Ici je met bien à true si je touche
            infos[0].setString(total_entite[i].recup_pseudo());
            infos[0].setCharacterSize(20);
            infos[0].setPosition(vue.getCenter().x + 400, vue.getCenter().y);
            infos[1].setString(total_entite[i].recup_vie());
            infos[1].setCharacterSize(20);
            infos[1].setPosition(vue.getCenter().x + 400, vue.getCenter().y + 50);
            for(unsigned char j = 0; j < 2; j++)
            target.draw(infos[j]);

            //Si clic gauche sur la cible, on récupère les infos
            if(clic_gauche)
            {
                cible = new sf::Text();
                pseudo_cible = total_entite[i].recup_pseudo();
                cible->setString(pseudo_cible);
                entite_cible_actuel = total_entite[i];
            }
        }
        else
        touche_entite = false; // <---- Ici je remet à false si je touche pas
    }
}
 

merci d'avance

3
Général / Allocation dynamique d'un objet c++
« le: Janvier 27, 2013, 01:46:15 pm »
Bonjour,

Je me suis penché sur l'allocation dynamique d'un objet en c++ mais j'ai quelques problèmes de compréhention.

Pour déclarer un objet je fais par exemple:
objet *test = new objet;
ensuite pour le détruire, je fais un delete, jusque là tout va bien.

Maintenant je voudrais que quand j'appuie sur un touche, ça crée l'objet et sur une autre que ça le détruise,
j'ai testé pas mal de choses mais sans succès  :'(

if (sf::Keyboard::isKeyPressed(sf::Keyboard::C) && !test)
{
     test= true;
     objet *ptr = new objet;
}

if (sf::Keyboard::isKeyPressed(sf::Keyboard::E) && test)
{
     test = false;
     delete ptr;
}
 

Bien sur ça ne fonctionne pas, il me dit que ptr n'est pas déclaré au moment du delete.

Donc le new et delete doivent être toujours dans la même fonction? Je ne vois pas comment procédé...

merci d'éclairer un débutant dans la matière  :)

4
Général / sfml a cessé de fonctionner
« le: Décembre 18, 2012, 11:25:23 am »
Bonjour,

Je crée un petit jeu style mario.

J'ai implanté ma map en tile mapping, insérer mon joueur et implanter les collisions jusque là tout allait bien.

Ensuite j'ai voulu crée une nouvelle variable et là rien qu'en à la déclarant j'ai une segmentation fault quand le joueur touche une tile.

Je me demande si c'est pas une fuite mémoire ou autre, je ne trouve pas ... (à moins que ma méthode pour les collisions ne soit pas bonne)

Voici mon code avec joueur et map qui gérent la collision:

joueur.cpp

#include "Joueur.h"



Joueur::Joueur()
{

    //Initialisation variables
    pos_joueurX = 70;
    pos_joueurY = 400;
    frame_run = 0;
    frame_sprint = 0;
    frame_walk = 0;
    temps_frame = 0.0f;
    status = 0;
    droite = true;
    action = false;
    elapsed_time = 0.0f;
    vitesse_anim_stand = 10;
    vitesse_anim_run = 3;
    vitesse_anim_sprint = 2;
    vitesse_anim_walk = 6;
    speed = 270;
    pos_joueur.x = pos_joueurX;
    pos_joueur.y = pos_joueurY;


    right = false;
    left = false;
    one = false;
    two = false;
    repeat_two = 0;


    //Definition des 4 box pour la collision
    rect_joueur_haut.height = 15;
    rect_joueur_haut.width = 50;
    rect_joueur_bas.height = 15;
    rect_joueur_bas.width = 50;
    rect_joueur_droite.height = 50;
    rect_joueur_droite.width = 15;
    rect_joueur_gauche.height = 50;
    rect_joueur_gauche.width = 15;



    saut = false;
    sautY = -400;
    retombe = false;
    hauteur_saut_max = 0;



    //Chargement de l'image dans la texture
    texture_joueur.loadFromFile("sprites/test.png");


    for(int i = 0; i < NB_SPRITES; i++)
    {
        //STAND
        sprite_joueur_droite_stand[i].setTexture(texture_joueur);
        sprite_joueur_gauche_stand[i].setTexture(texture_joueur);
        //RUN
        sprite_joueur_droite_run[i].setTexture(texture_joueur);
        sprite_joueur_gauche_run[i].setTexture(texture_joueur);
        //SPRINT
        sprite_joueur_droite_sprint[i].setTexture(texture_joueur);
        sprite_joueur_gauche_sprint[i].setTexture(texture_joueur);
        //WALK
        sprite_joueur_droite_walk[i].setTexture(texture_joueur);
        sprite_joueur_gauche_walk[i].setTexture(texture_joueur);

        //Decoupe sprites
        //STAND
        sprite_joueur_droite_stand[i].setTextureRect(sf::IntRect(230 * i, 0, 230, 260));
        sprite_joueur_gauche_stand[i].setTextureRect(sf::IntRect(230 * i, 260, 230, 260));
        //RUN
        sprite_joueur_droite_run[i].setTextureRect(sf::IntRect(230 * i, 520, 230, 260));
        sprite_joueur_gauche_run[i].setTextureRect(sf::IntRect(230 * i, 780, 230, 260));
        //SPRINT
        sprite_joueur_droite_sprint[i].setTextureRect(sf::IntRect(230 * i, 1040, 230, 260));
        sprite_joueur_gauche_sprint[i].setTextureRect(sf::IntRect(230 * i, 1300, 230, 260));
        //WALK
        sprite_joueur_droite_walk[i].setTextureRect(sf::IntRect(230 * i, 1560, 230, 260));
        sprite_joueur_gauche_walk[i].setTextureRect(sf::IntRect(230 * i, 1820, 230, 260));

        //Position du sprite au départ
        //STAND
        sprite_joueur_droite_stand[i].setPosition(pos_joueurX, pos_joueurY);
        sprite_joueur_gauche_stand[i].setPosition(pos_joueurX, pos_joueurY);
        //RUN
        sprite_joueur_droite_run[i].setPosition(pos_joueurX, pos_joueurY);
        sprite_joueur_gauche_run[i].setPosition(pos_joueurX, pos_joueurY);
        //SPRINT
        sprite_joueur_droite_sprint[i].setPosition(pos_joueurX, pos_joueurY);
        sprite_joueur_gauche_sprint[i].setPosition(pos_joueurX, pos_joueurY);
        //WALK
        sprite_joueur_droite_walk[i].setPosition(pos_joueurX, pos_joueurY);
        sprite_joueur_gauche_walk[i].setPosition(pos_joueurX, pos_joueurY);


        //Ajustement taille du sprite
        //STAND
        sprite_joueur_droite_stand[i].setScale(0.5, 0.5);
        sprite_joueur_gauche_stand[i].setScale(0.5, 0.5);
        //RUN
        sprite_joueur_droite_run[i].setScale(0.5, 0.5);
        sprite_joueur_gauche_run[i].setScale(0.5, 0.5);
        //SPRINT
        sprite_joueur_droite_sprint[i].setScale(0.5, 0.5);
        sprite_joueur_gauche_sprint[i].setScale(0.5, 0.5);
        //WALK
        sprite_joueur_droite_walk[i].setScale(0.5, 0.5);
        sprite_joueur_gauche_walk[i].setScale(0.5, 0.5);
    }
}

Joueur::~Joueur()
{

}

void Joueur::event_clavier_joueur(sf::RenderWindow &ecran)
{
    while(ecran.pollEvent(event))
    {
        if(event.type == sf::Event::Closed)
        ecran.close();

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
        {
            ecran.close();
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
        {
            right = true;
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
        {
            left = true;
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Numpad1))
        {
            one = true;
        }

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Numpad2))
        {
            two = true;
            //Pour éviter de sauter en continue en laissant appuyer la touche du saut
            if(repeat_two == 0)
            repeat_two ++;
        }


        if(event.type == sf::Event::KeyReleased)
        {
            if(event.key.code == sf::Keyboard::Right)
            right = false;

            if(event.key.code == sf::Keyboard::Left)
            left = false;

            if(event.key.code == sf::Keyboard::Numpad1)
            one = false;

            if(event.key.code == sf::Keyboard::Numpad2)
            {
                two = false;
                saut = false;
                repeat_two = 2;
            }
        }
    }
}

void Joueur::update_events(sf::Time temps, sf::Time recup_chrono, char *boucle, Map &map)
{
    elapsed_time = temps.asSeconds();

    //Si aucune action en cours alors animation repos
    if(!right && !left && !saut && !retombe)
    action = 0;
    //Autrement si une des actions en cours alors pas d'animation au repos
    else if(right || left || saut || retombe)
    action = 1;

    //Animation au repos
    if(!action)
    {
        if(*boucle >= vitesse_anim_stand)
        {
            frame_stand++;
            *boucle = 0.0f;
        }
        if(droite)
        status = 0;
        else
        status = 1;
    }

    //Le joueur tombe s'il n'y as pas de collision au sol
    if((!blocage_p_mur(rect_joueur_bas, map) && (!blocage_p_modif(rect_joueur_bas, map))) && !saut)
    {
        action = true;
        retombe = true;
        //Mise à jour de la hauteur du saut
        hauteur_saut_max = pos_joueur.y - 130;

        frame_run = 0;

        if(droite)
        {
            status = 2;
            for(int i = 0; i < NB_SPRITES; i++)
            {
                //On tombe status à droite
                sprite_joueur_droite_run[i].move(0, -(sautY * elapsed_time));
                //On récupère la position actuelle
                pos_joueur = sprite_joueur_droite_run[i].getPosition();
                rect_sprite = sprite_joueur_droite_run[i].getGlobalBounds();
                recup_position_joueur(rect_sprite);

                //Mise à jour de la position des autres sprites directions
                //STAND
                sprite_joueur_droite_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                //RUN
                sprite_joueur_droite_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                //SPRINT
                sprite_joueur_gauche_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                //WALK
                sprite_joueur_droite_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
            }
        }
        else
        {
            status = 3;
            for(int i = 0; i < NB_SPRITES; i++)
            {
                //On tombe status gauche
                sprite_joueur_gauche_run[i].move(0, -(sautY * elapsed_time));
                //On récupère la position actuelle
                pos_joueur = sprite_joueur_gauche_run[i].getPosition();
                rect_sprite = sprite_joueur_gauche_run[i].getGlobalBounds();
                recup_position_joueur(rect_sprite);

                //Mise à jour de la position des autres sprites directions
                //STAND
                sprite_joueur_droite_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                //RUN
                sprite_joueur_droite_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                //SPRINT
                sprite_joueur_droite_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                //WALK
                sprite_joueur_droite_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
            }
        }
    }
    else
    {
        retombe = false;
        if(!two)
        repeat_two = 0;
    }

    //Si le joueur touche le bas d'une tile, il retombe
    if(blocage_p_mur(rect_joueur_haut, map) && saut && !retombe)
    {
        saut = false;
        retombe = true;
        //Inrementation pour éviter de sauter à nouveau en laissant appuyer sur la touche de saut
        repeat_two ++;
    }

    //Affinage du saut pour plus de réalisme
    if(pos_joueur.y <= hauteur_saut_max + 10 && saut && !retombe && (right || left))
    {
        sautY = GRAVITE + 300;
    }
    else if(pos_joueur.y <= hauteur_saut_max + 20 && saut && !retombe && !right && !left)
    {
        sautY = GRAVITE + 300;
    }
    else
    {
        sautY = GRAVITE;
    }

    //Hauteur du saut max = retombe
    if((pos_joueur.y <= hauteur_saut_max) && saut && !retombe)
    {
        frame_run = 0;
        retombe = true;
        saut = false;
        //Inrementation pour éviter de sauter à nouveau en laissant appuyer sur la touche de saut
        repeat_two ++;
    }

    //Gestion déplacement à droite
    if(right && !left)
    {
        status = 2;
        droite = true;

        if(!saut && !retombe)
        {
            if(*boucle >= vitesse_anim_run)
            {
                frame_run++;
                *boucle = 0.0f;
            }
        }
        //Le joueur n'avance plus à droite s'il y a collision avec une tile
        if(!blocage_p_mur(rect_joueur_droite, map) && !blocage_p_modif(rect_joueur_droite, map))
        {
            for(int i = 0; i < NB_SPRITES; i++)
            {
                //On bouge à droite
                sprite_joueur_droite_run[i].move((speed * elapsed_time), 0);
                //On récupère la position actuelle
                pos_joueur = sprite_joueur_droite_run[i].getPosition();
                rect_sprite = sprite_joueur_droite_run[i].getGlobalBounds();
                recup_position_joueur(rect_sprite);

                //Mise à jour de la position des autres sprites directions
                //STAND
                sprite_joueur_droite_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                //RUN
                sprite_joueur_gauche_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                //SPRINT
                sprite_joueur_droite_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                //WALK
                sprite_joueur_gauche_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_droite_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
            }
        }

    }

    //Gestion du déplacement à gauche
    if(left && !right)
    {
        status = 3;
        droite = false;
        if(!saut && !retombe)
        {
            if(*boucle >= vitesse_anim_run)
            {
                frame_run++;
                *boucle = 0.0f;
            }
        }
        //Le joueur n'avance plus à gauche s'il y a collision avec une tile
        if(!blocage_p_mur(rect_joueur_gauche, map) && !blocage_p_modif(rect_joueur_gauche, map))
        {
            for(int i = 0; i < NB_SPRITES; i++)
            {

                //On bouge à gauche
                sprite_joueur_gauche_run[i].move((-speed * elapsed_time), 0);
                //On récupère la position actuelle
                pos_joueur = sprite_joueur_gauche_run[i].getPosition();
                rect_sprite = sprite_joueur_gauche_run[i].getGlobalBounds();
                recup_position_joueur(rect_sprite);

                //Mise à jour de la position des autres sprites directions
                //STAND
                sprite_joueur_droite_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                //RUN
                sprite_joueur_droite_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                //SPRINT
                sprite_joueur_droite_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                //WALK
                sprite_joueur_droite_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
            }
        }
    }

    //Gestion du saut
    if(two && !retombe && (repeat_two <= 1))
    {
        saut = true;
        frame_run = 0;

        if(droite)
        {
            status = 2;
            for(int i = 0; i < NB_SPRITES; i++)
            {
                //On bouge en haut
                sprite_joueur_droite_run[i].move(0, sautY * elapsed_time);

                //On récupère la position actuelle
                pos_joueur = sprite_joueur_droite_run[i].getPosition();
                rect_sprite = sprite_joueur_droite_run[i].getGlobalBounds();
                recup_position_joueur(rect_sprite);

                //Mise à jour de la position des autres sprites directions
                //STAND
                sprite_joueur_droite_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                //RUN
                sprite_joueur_gauche_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                //SPRINT
                sprite_joueur_droite_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                //WALK
                sprite_joueur_gauche_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_droite_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
            }
        }
        else
        {
            status = 3;
            for(int i = 0; i < NB_SPRITES; i++)
            {
                //On bouge en haut
                sprite_joueur_gauche_run[i].move(0, sautY * elapsed_time);

                //On récupère la position actuelle
                pos_joueur = sprite_joueur_gauche_run[i].getPosition();
                rect_sprite = sprite_joueur_gauche_run[i].getGlobalBounds();
                recup_position_joueur(rect_sprite);

                //Mise à jour de la position des autres sprites directions
                //STAND
                sprite_joueur_droite_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_stand[i].setPosition(pos_joueur.x, pos_joueur.y);
                //RUN
                sprite_joueur_droite_run[i].setPosition(pos_joueur.x, pos_joueur.y);
                //SPRINT
                sprite_joueur_droite_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_sprint[i].setPosition(pos_joueur.x, pos_joueur.y);
                //WALK
                sprite_joueur_droite_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
                sprite_joueur_gauche_walk[i].setPosition(pos_joueur.x, pos_joueur.y);
            }
        }
    }

}


void Joueur::afficher(sf::RenderTarget &target)
{
    //std::cout << repeat_two << std::endl;
    //Boucle l'animation
    if(frame_stand >= NB_SPRITES)
    frame_stand = 0;
    if(frame_run >= NB_SPRITES)
    frame_run = 0;
    if(frame_sprint >= NB_SPRITES)
    frame_sprint = 0;
    if(frame_walk >= NB_SPRITES)
    frame_walk = 0;


    //Affichage du bon sprite
    if(status == 0)
    {
        target.draw(sprite_joueur_droite_stand[frame_stand]);
    }
    else if(status == 1)
    {
        target.draw(sprite_joueur_gauche_stand[frame_stand]);
    }
    else if(status == 2)
    {
        target.draw(sprite_joueur_droite_run[frame_run]);
    }
    else if(status == 3)
    {
        target.draw(sprite_joueur_gauche_run[frame_run]);
    }
    else if(status == 4)
    {
        target.draw(sprite_joueur_droite_sprint[frame_sprint]);
    }
    else if(status == 5)
    {
        target.draw(sprite_joueur_gauche_sprint[frame_sprint]);
    }
    else if(status == 6)
    {
        target.draw(sprite_joueur_droite_walk[frame_walk]);
    }
    else if(status == 7)
    {
        target.draw(sprite_joueur_gauche_walk[frame_walk]);
    }
}

/*
COLLISION avec TILES MUR
*/


bool Joueur::blocage_p_mur(sf::FloatRect rect, Map &carte)
{
    if(collision_p_mur(rect, carte, carte.get_tab_size_mur()))
    return true;
    else
    return false;
}

bool Joueur::collision_p_mur(sf::FloatRect joueur, Map &carte, unsigned short int taille_tableau_tile)
{
    for(int i = 0; i < taille_tableau_tile; i++)
    if(test_collision(joueur, carte.get_prop_mur()[i]))
    return true;
}

/*
COLLISION avec TILES MODIFIABLES
*/


bool Joueur::blocage_p_modif(sf::FloatRect rect, Map &carte)
{
    if(collision_p_modif(rect, carte, carte.get_tab_size_modif()))
    return true;
    else
    return false;
}

bool Joueur::collision_p_modif(sf::FloatRect joueur, Map &carte, unsigned short int taille_tableau_tile)
{
    for(int i = 0; i < taille_tableau_tile; i++)
    if(test_collision(joueur, carte.get_prop_modif()[i]))
    return true;

}

bool Joueur::test_collision(sf::FloatRect box1, sf::FloatRect box2)
{
   if((box2.left >= box1.left + box1.width)      // trop à droite
        || (box2.left + box2.width <= box1.left) // trop à gauche
        || (box2.top >= box1.top + box1.height) // trop en bas
        || (box2.top + box2.height <= box1.top))  // trop en haut
          return false;
   else
          return true;
}

//Ajustement des 4 box : haut, bas, gauche et droite pour collision
sf::FloatRect Joueur::recup_position_joueur(sf::FloatRect pos)
{
    rect_joueur_haut.left = pos.left + 17;
    rect_joueur_haut.top = pos.top + 40 - TAILLE_TILE;
    rect_joueur_bas.left = pos.left + 17;
    rect_joueur_bas.top = pos.top + 75 + rect_joueur_bas.height;
    rect_joueur_droite.left = pos.left + 70;
    rect_joueur_droite.top = pos.top + 44;
    rect_joueur_gauche.left = pos.left + 35 - TAILLE_TILE;
    rect_joueur_gauche.top = pos.top + 44;
}

sf::Vector2f Joueur::recup_pos_joueur()
{
    return pos_joueur;
}
 

et mon map.cpp

#include "Map.h"



Map::Map()
{
    text_map0.loadFromFile("sprites/0.png");
    spr_map0.setTexture(text_map0);
}


Map::~Map()
{

}

void Map::chargement_monde1_1()
{
    sf::FloatRect prop_mur;

    text_map1.loadFromFile("sprites/1.png");
    spr_map1.setTexture(text_map1);
    text_map2.loadFromFile("sprites/2.png");
    spr_map2.setTexture(text_map2);

    char monde1_1[NB_TILE_HAUTEUR][NB_TILE_LARGEUR] {
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1}};

    monde_actuel.resize(NB_TILE_HAUTEUR);
    for(int i = 0; i < NB_TILE_HAUTEUR; ++i)
    monde_actuel[i].assign(monde1_1[i], monde1_1[i] + NB_TILE_LARGEUR);

    for(int i = 0; i < NB_TILE_LARGEUR; i++)
    {
        for(int j = 0; j < NB_TILE_HAUTEUR; j++)
        {
            if(monde_actuel[j][i] == 1)
            {
                prop_mur.left = i * TAILLE_TILE;
                prop_mur.top = (j * TAILLE_TILE) + (TAILLE_TILE * 2);
                tile_mur.push_back(prop_mur);
            }
            if(monde_actuel[j][i] == 2)
            {
                prop_mur.left = i * TAILLE_TILE;
                prop_mur.top = (j * TAILLE_TILE) + (TAILLE_TILE * 2);
                tile_modif.push_back(prop_mur);
            }
        }
    }
}


void Map::affichage_monde(sf::RenderTarget &target)
{
    for(int i = 0; i < NB_TILE_LARGEUR; i++)
    {
        for(int j = 0; j < NB_TILE_HAUTEUR; j++)
        {
            if(monde_actuel[j][i] == 0)
            {
                spr_map0.setPosition(i * TAILLE_TILE, (j * TAILLE_TILE) + (TAILLE_TILE * 2));
                target.draw(spr_map0);
            }
            if(monde_actuel[j][i] == 1)
            {
                spr_map1.setPosition(i * TAILLE_TILE, (j * TAILLE_TILE) + (TAILLE_TILE * 2));
                target.draw(spr_map1);
            }
            if(monde_actuel[j][i] == 2)
            {
                spr_map2.setPosition(i * TAILLE_TILE, (j * TAILLE_TILE) + (TAILLE_TILE * 2));
                target.draw(spr_map2);
            }
        }
    }
}

std::vector<sf::FloatRect> Map::get_prop_mur()
{
    return tile_mur;
}


unsigned short int Map::get_tab_size_mur()
{

    return tile_mur.size();
}

std::vector<sf::FloatRect> Map::get_prop_modif()
{
    return tile_modif;
}

unsigned short int Map::get_tab_size_modif()
{
    return tile_modif.size();
}
 

le debugger me donne :

#0 68ED6253   sf::RenderTarget::draw(this=0x28aaa8, drawable=..., states=...) D:\developpement\sfml-master\src\SFML\Graphics\RenderTarget.cpp:126)
#1 00405964   Joueur::afficher(this=0x28ae48, target=...) (D:\Projet\Edgar contre les murlocs\Joueur.cpp:475)
#2 004025E3   _fu1___ZSt4cout() (D:\Projet\Edgar contre les murlocs\MoteurJeu.cpp:67)
#3 00402898   main() (D:\Projet\Edgar contre les murlocs\main.cpp:7)

Je suis sous windows 7 64bits
codeblock 10.05
SFML-2.0-rc-windows-32-gcc4-sjlj

merci d'avance.

5
Général / Utilité de sprite.setOrigin(x, y) ?
« le: Décembre 16, 2012, 10:42:16 am »
Bonjour,

Je n'arrive pas à comprendre à quoi peut servir setOrigin.

Dans mon cas, j'ai un sprite qui fait 230x260 je lui fait un scale par exemple de 0.5,0.5 donc ses dimensions deviennent 115x130, comme le setOrigin est par defaut 0,0 si moi je lui met 50,10 par exemple et ensuite je lui applique la scale:

Quelle sera la différence entre le setOrigin à 0,0 et celui 50,10 aprés le scale?

merci d'avance

6
Bonsoir,

Pour commencer une partie de mon code:

Entite_static.cpp

Entite_static::Entite_static()
{
    for(int i = 0; i < NB_DECOR; i++)
    {
        rect_decor[i].left = 0;
        rect_decor[i].top = 0;
        rect_decor[i].width = 0;
        rect_decor[i].height = 0;
    }

}

Entite_static::~Entite_static()
{

}

void Entite_static::ajout_entite(unsigned char id, int x, int y)
{
    if(id == 0)
    {
        tree_texture.loadFromFile("sprites/environnements/tree_barrens/tree_450_500.png");
        sprite_tree.setTexture(tree_texture);
    }
    if(id == 1)
    {
        tree2_texture.loadFromFile("sprites/environnements/tree_barrens/tree2_450_500.png");
        sprite_tree2.setTexture(tree2_texture);
    }

    //Positions des Entite_static
    sprite_tree.setPosition(x, y);
    sprite_tree2.setPosition(x, y);

    //Recuperation box tree
    rect_decor[0] = sprite_tree.getGlobalBounds();
    //Ajustement box tree
    rect_decor[0].left = rect_decor[0].left + 113;
    rect_decor[0].top = rect_decor[0].top + 380;
    rect_decor[0].width = 226;
    rect_decor[0].height = 72;
    //Recuperation box tree2
    rect_decor[1] = sprite_tree2.getGlobalBounds();
    //Ajustement box tree2
    rect_decor[1].left = rect_decor[1].left + 250;
    rect_decor[1].top = rect_decor[1].top + 400;
    rect_decor[1].width = 150;
    rect_decor[1].height = 72;
}


void Entite_static::afficher_decor(sf::RenderTarget &target)
{
    target.draw(sprite_tree);
    target.draw(sprite_tree2);
}
 

ensuite dans :
map.h

Entite_static decor_monde1[NB_TOTAL_DECOR];
 

map.cpp
void Map::monde1()
{
    //Chargement monde1
    map_monde1.loadFromFile("maps/map1.png");
    sprite_map_monde1.setTexture(map_monde1);
    sprite_map_monde1.setPosition(-1400, -700);

    /*
    Chargement du decor
    ajout_entite(id_du_decor, position_en_x, position_en_y)
    */

    //TREE
    decor_monde1[0].ajout_entite(0, 200, 200);
    decor_monde1[1].ajout_entite(0, 200, 0);
    //TREE2
    decor_monde1[2].ajout_entite(1, 400, 0);
    decor_monde1[3].ajout_entite(1, 1000, -110);
}

void Map::afficher_map(sf::RenderTarget &target, unsigned char monde)
{
    target.draw(sprite_map_monde1);
}

void Map::afficher_decor(sf::RenderTarget &target, unsigned char monde)
{
    for(int i = 0; i < NB_TOTAL_DECOR; i++)
    decor_monde1[i].afficher_decor(target);
}
 

Voila une partie de mon code pour afficher un decor par rapport à son id et sa position x, y

Est il possible de classer le tableau decor_monde1 en focntion de la position en y de l'entité car pour l'affichage je voudrais que ceux qui sont le plus en haut soit affiché en 1er?

7
Bonjour,

J'ai un petit probleme lors de l'animation qui continue et surtout la selection du sprite à l'ecran qui s'affiche !
Je pense que cela vient des events (mais je suis pas sur, j'ai essayé pas mal de choses)

Donc dés que j'appuie par exemple à droite, le perso va bien sur la droite (je n'ai pas geré aucune vitesse encore) mais l'animation continue ... quand je relache, il faut que j'appuie une fois à gauche pour la stopper et en reappuyant a gauche le perso va à gauche mais l'animation continue ...

Au démarrage du programme haut et bas fonctionne aussi en selectionnant bien la bonne animation mais si j'appuie sur droite ou gauche cela ne fonctionne plus ...

Comme un code vaut plus qu'un long discours le voici:

Sprite.h

#ifndef SPRITE_H_INCLUDED
#define SPRITE_H_INCLUDED

#include <SFML/Graphics.hpp>
#include <iostream>

class SpriteHero
{
    private :

    //Chargement de la feuille de sprites
    sf::Image hero_marche_nu_unarmed;

    //Application image dans une texture
    sf::Texture texture_hero_marche_nu_unarmed;

    //Decoupes sprites
    sf::Sprite sprite_hero_marche_droite_nu_unarmed[16];
    sf::Sprite sprite_hero_marche_gauche_nu_unarmed[16];
    sf::Sprite sprite_hero_marche_bas_nu_unarmed[16];
    sf::Sprite sprite_hero_marche_haut_nu_unarmed[16];

    //ANIMATION
    //Position de départ
    int positionX, positionY;
    //sa vitesse de deplacement
    //droite, gauche
    int velocityX;
    //haut, bas
    int velocityY;
    //sa frame courante
    int frame;
    //Son status d'animation
    int status;



    public :

    SpriteHero(); //Constructeur
    void decoupe_hero_marche_nu_unarmed(); // Decoupe des feuilles de sprites
    void events_clavier(); //Gestion clavier
    void afficher(sf::RenderTarget &target); //Affiche a l'ecran les direction du Hero à prendre

};


#endif // SPRITE_H_INCLUDED

 

Sprite.cpp

#include "Sprite.h"

SpriteHero::SpriteHero()
{
    //Initialisation des attributs
    positionX = 150;
    positionY = 450;
    velocityX = 0;
    velocityY = 0;
    frame = 0;
    status = 8;

}


void SpriteHero::decoupe_hero_marche_nu_unarmed()
{
    //Chargement Feuille de sprite
    hero_marche_nu_unarmed.LoadFromFile("test.png");
    //Maque de transparence
    hero_marche_nu_unarmed.CreateMaskFromColor(sf::Color(0 ,0, 255));
    //Chargement de l'image dans la texture
    texture_hero_marche_nu_unarmed.LoadFromImage(hero_marche_nu_unarmed);

    for(int i = 0; i < 16; i++)
    {
        sprite_hero_marche_droite_nu_unarmed[i].SetTexture(texture_hero_marche_nu_unarmed);
        sprite_hero_marche_gauche_nu_unarmed[i].SetTexture(texture_hero_marche_nu_unarmed);
        sprite_hero_marche_bas_nu_unarmed[i].SetTexture(texture_hero_marche_nu_unarmed);
        sprite_hero_marche_haut_nu_unarmed[i].SetTexture(texture_hero_marche_nu_unarmed);
    }
    //Découpe des sprites
    for(int i = 0; i < 16; i++)
    {
        sprite_hero_marche_droite_nu_unarmed[i].SetTextureRect(sf::IntRect(140 * i, 0, 140, 160));
        sprite_hero_marche_gauche_nu_unarmed[i].SetTextureRect(sf::IntRect(2100 - (140 * i), 160, 140, 160));
        sprite_hero_marche_bas_nu_unarmed[i].SetTextureRect(sf::IntRect(140 * i, 320, 140, 160));
        sprite_hero_marche_haut_nu_unarmed[i].SetTextureRect(sf::IntRect(140 * i, 480, 140, 160));
    }
    //Position du sprite au départ
    for(int i = 0; i < 16; i++)
    {
        sprite_hero_marche_droite_nu_unarmed[i].SetPosition(positionX, positionY);
        sprite_hero_marche_gauche_nu_unarmed[i].SetPosition(positionX, positionY);
        sprite_hero_marche_bas_nu_unarmed[i].SetPosition(positionX, positionY);
        sprite_hero_marche_haut_nu_unarmed[i].SetPosition(positionX, positionY);
    }
}

void SpriteHero::events_clavier()
{
    if (sf::Keyboard::IsKeyPressed(sf::Keyboard::Left))
    {
        velocityX -= 140;
    }
    else if (sf::Keyboard::IsKeyPressed(sf::Keyboard::Right))
    {
        velocityX += 140;
    }
    else if (sf::Keyboard::IsKeyPressed(sf::Keyboard::Up))
    {
        velocityY -= 160;
    }
    else if (sf::Keyboard::IsKeyPressed(sf::Keyboard::Down))
    {
        velocityY += 160;
    }


}

void SpriteHero::afficher(sf::RenderTarget &target)
{

    //Mouvement
    positionX += velocityX;
    positionY += velocityY;

    //On garde le personnage dans les limites de la fenêtre
    if(positionX < -40 || positionX + 100 > 800)
    {
        positionX -= velocityX;
    }

    if(positionY < -30 || positionY + 140 > 600)
    {
        positionY -= velocityY;
    }

    //Si Hero bouge à droite
    if(velocityX > 0)
    {
        //On prend le hero qui marche a droite
        status = 8;
        //Mise à jour de la position
        for(int i = 0; i < 16; i++)
        sprite_hero_marche_droite_nu_unarmed[i].SetPosition(positionX, positionY);
        //On bouge à la prochaine image de l'animation
        frame++;
    }
    //Si Hero bouge à gauche
    else if(velocityX < 0)
    {
        //On prend le hero qui marche a gauche
        status = 9;
        //Mise à jour de la position
        for(int i = 0; i < 16; i++)
        sprite_hero_marche_gauche_nu_unarmed[i].SetPosition(positionX, positionY);
        //On bouge à la prochaine image de l'animation
        frame++;
    }
    //Si Hero bouge en bas
    else if(velocityY > 0)
    {
        //On prend le hero qui marche en bas
        status = 10;
        //Mise à jour de la position
        for(int i = 0; i < 16; i++)
        sprite_hero_marche_bas_nu_unarmed[i].SetPosition(positionX, positionY);
        //On bouge à la prochaine image de l'animation
        frame++;
    }
     //Si Hero bouge en haut
    else if(velocityY < 0)
    {
        //On prend le hero qui marche en haut
        status = 11;
        //Mise à jour de la position
        for(int i = 0; i < 16; i++)
        sprite_hero_marche_haut_nu_unarmed[i].SetPosition(positionX, positionY);
        //On bouge à la prochaine image de l'animation
        frame++;
    }
    //Si l'animation ne bouge plus
    else
    {
        //Recommencer l'animation
        frame = 0;
    }

    //Boucle l'animation
    if(frame >= 16)
    {
        frame = 0;
    }

    //Affichage
    if(status == 8)
    {
        target.Draw(sprite_hero_marche_droite_nu_unarmed[frame]);
    }
    else if(status == 9)
    {
        target.Draw(sprite_hero_marche_gauche_nu_unarmed[frame]);
    }
    else if(status == 10)
    {
        target.Draw(sprite_hero_marche_bas_nu_unarmed[frame]);
    }
    else if(status == 11)
    {
        target.Draw(sprite_hero_marche_haut_nu_unarmed[frame]);
    }
}

 

main.cpp

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



int main()
{
    sf::RenderWindow App(sf::VideoMode(800, 600, 32), "Test Animation sprite");

    sf::Texture background;
    background.LoadFromFile("back.jpg");

    sf::Sprite back;
    back.SetTexture(background);

    SpriteHero hero;
    hero.decoupe_hero_marche_nu_unarmed();

    while (App.IsOpen())
    {
        sf::Event Event;
        while (App.PollEvent(Event))
        {
            switch (Event.Type) // Type de l'évènement en attente :
            {
                case sf::Event::Closed : // Croix en haut à droite
                App.Close();
                break;

                break;
            }
        }
        hero.events_clavier();

        App.Clear();

        App.Draw(back);
        hero.afficher(App);

        App.Display();

    }

    return EXIT_SUCCESS;
}

 

Voila j'espère avoir été clair et merci d'avance

Pages: [1]