sfml a cessé de fonctionner

[Arnibou]

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.

[G.]

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.

Ok et c'est laquelle cette fameuse variable ? C'est où que ça plante ?
Sinon c'est un sacré morceau de code que tu nous files là... perso pas le courage de chercher quoi que ce soit là-dedans. ^^ Essaie de filer un code minimal (le plus petit possible) et complet (qui compile direct) pour avoir plus de chance que quelqu'un t'aide. (en plus en transformant le code comme ça y'a des chances pour que tu trouves tout seul le probleme)

A part ça je trouve l'utilisation d'un char* pour boucle douteuse, 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 ).

[Arnibou]

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.

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

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à

[Laurent]

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

Tu retires du code jusqu'à ce que ça ne plante plus. Ensuite tu fais la même chose mais à d'autres endroits. Jusqu'à ce que plus une seule ligne de code ne puisse être retirée sans masquer le problème. C'est vraiment pas compliqué, et c'est la seule façon de trouver rapidement un bug (on fait pareil, faut pas croire qu'on a des pouvoirs spéciaux)