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.


Messages - Arnibou

Pages: [1] 2 Suivante »
1
Projets SFML / Re : Un Miniminijeu à 0€! ;)
« le: Mai 16, 2013, 09:21:39 am »
moi je veux bien le tester si j'ai le code source que je compilerais moi même  :)

2
Le site est beaucoup mieux qu'avant, il est plus clair, plus lisible.
Bravo pour le boulot que tu as fourni.
Juste une question : j'avais pris la nightly build du 15/03/13 y'as t'il des changements avec celle que tu proposes en téléchargement? et la version gcc 4.7 mingw fonctionne sur la 4.7.1?
Merci.

Edit: Dans la doc les classes sont pas dans l'ordre Alphabétique c'est chiant :p

3
Général / Re : Problème itérator sur map et sf::Text
« le: Mars 18, 2013, 12:55:32 pm »
Bon j'ai rajouté un
objectif_quete[0] = "";
pour contourner le problème (vu qu'il ne sera jamais utilisé) par contre j'aurais vraiment aimer comprendre pourquoi ça ne fonctionnait pas ...

J'ai mis Résolu quand même.

4
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

5
Général / Re : [SFML 2.0/Code::blocks] problème installation
« le: Février 28, 2013, 04:33:49 pm »
J'ai exactement le meme probleme et en supprimant libstdc++_6.dll, le prog se lance mais sfml.exe a cessé de fonctionner.
Edit: j'ai tenté de recompiler sfml et il y a exactement le meme probleme qu'avec la nightly.
Et idem en essayant sur l'ancienne version de code block

6
merci pour ton explication c'était vraiment tout bête  :)

7
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

8
Général / Re : Allocation dynamique d'un objet c++
« le: Janvier 27, 2013, 02:50:22 pm »
Merci pour ta reponse.
Je n'avais jamais lu qu'on pouvait tester um pointeur comme ca, pas mal de cous n'en parle pas.
Je vais suivre ton conseil et continuer de potasser pour approndir tout ca.

9
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  :)

10
Général / Re : sfml a cessé de fonctionner
« le: Décembre 18, 2012, 10:32:24 pm »
Avant de poster le fameux char * justement d'aprés le debugger je pense que ça peut venir de la en commentant la partie qui l'utilise ça fonctionne.

Le but de celui ci était que j'incrementais un char boucle à chaque frame pour la récuperer dans la class joueur et la remettre à 0 dés qu'elle dépassait une certaine valeur directement dans la class joueur donc en passant par un pointeur (dans les paramètres de la fonction je renvoyais une référence de celle ci).

Cela servait à que l'animation soit moins rapide, j'avais trouver cette méthode mais je pense que je vais passer par un facteur temps.

Citer
Ok et c'est laquelle cette fameuse variable

Justement n'importe quelle variable que ce soit un int, un sf::sprite etc... dés que je la déclare ça plante (même sans m'en servir) dans n'importe quel fichier .h

Citer
et si tu veux tester l'intersection de 2 Rect y'a une fonction déjà toute faite ( http://www.sfml-dev.org/documentation/2.0/classsf_1_1Rect.php#a566740c8f58e01bb052266f47e7e1011 ).

Ah oui jamais fait attention lol , avec tous ces tutos que l'on trouve pour tester 2 box qui se touchent ... on peut avoir plus simple avec intersect :) merci pour cette info

PS: j'avais poster un bon gros morceau du code car justement impossible de cibler l'endroit précis :x

EDIT : Aprés avoir retiré ce fameux char*, le problème persiste toujours donc ça ne venait pas de là :(

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

12
Général / Re : Utilité de sprite.setOrigin(x, y) ?
« le: Décembre 16, 2012, 11:33:17 am »
merci pour cette explication claire.
Je vais faire des tests plus concrêts pour me faire une idée.

Edit : Après quelques tests voilà pourquoi je ne comprenais pas ce qui se passait dans mon programme car ça joue aussi sur les coordonnées de la "box", du coup les positions des box n'allaient plus nulle part :)

13
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

14
Graphique / Re : Position d'un sprite
« le: Mai 14, 2012, 10:01:19 pm »

15
bon j'ai planché sur le constructeur par copie avec des petits exemples pour comprendre le fonctionnement mais pour mon cas sur plusieurs sprites et texture je galère trop ..

Un petit indice pour l'operateur d'affectation par rapport à mon code ne serait pas de refus car là ça fait 2 jours que je dors plus lol

Pages: [1] 2 Suivante »