Bonjour !!

Je suis en train développer un jeu où on se déplace salle par salle.

Et il m'arrive cette erreur au moment je passe d'un salle à une autre où se situe dans la nouvelle salle des assassins. Après plusieurs test, j'ai remarqué que c'était eu le problème, je souvent lu que le problème venait des pointeurs.

Voici une parti de Main.cpp

    std::unique_ptr<LS::MesEnnemis> Ennemis(new LS::MesEnnemis);
    std::unique_ptr<LS::MesEnnemis> Ennemis2(new LS::MesEnnemis);
    std::unique_ptr<LS::MesEnnemis> Ennemis3(new LS::MesEnnemis);
    std::unique_ptr<LS::MesEnnemis> Ennemis4(new LS::MesEnnemis);
    std::unique_ptr<LS::MesEnnemis> Ennemis5(new LS::MesEnnemis);

    std::unique_ptr<LS::MesEnnemis> Ennemis6(new LS::MesEnnemis);
    std::unique_ptr<LS::MesEnnemis> Ennemis7(new LS::MesEnnemis);
    std::unique_ptr<LS::MesEnnemis> Ennemis8(new LS::MesEnnemis);

    sf::Event event;
    sf::Clock time;

    while (window.isOpen())
    {

        CN::Tableau tab;

        tab = niveau.NbrEnnemisNiveau();

        Ennemis.reset(new LS::MesEnnemis);
        Ennemis2.reset(new LS::MesEnnemis);
        Ennemis3.reset(new LS::MesEnnemis);
        Ennemis4.reset(new LS::MesEnnemis);
        Ennemis5.reset(new LS::MesEnnemis);

        Ennemis6.reset(new LS::MesEnnemis);
        Ennemis7.reset(new LS::MesEnnemis);
        Ennemis8.reset(new LS::MesEnnemis);

        switch (tab.get(0,0))
        {
            case 1:
                {
                    Ennemis.reset(new LS::Sorcier);
                    Ennemis6.reset(new LS::Sorcier);

                    break;
                }
            case 2:
                {
                    Ennemis.reset(new LS::Archer);
                    Ennemis6.reset(new LS::Archer);

                    break;
                }
            case 3:
                {
                    Ennemis.reset(new LS::Soldat);
                    Ennemis6.reset(new LS::Soldat);

                    break;
                }
             case 4:
                {
                    Ennemis.reset(new LS::Guerrier);
                    Ennemis6.reset(new LS::Guerrier);

                    break;
                }
             case 5:
                {
                    Ennemis.reset(new LS::Assassin);
                    Ennemis6.reset(new LS::Assassin);

                    break;
                }
             case 6:
                {
                    Ennemis.reset(new LS::Mage);
                    Ennemis6.reset(new LS::Soldat);

                    break;
                }
         }

        Ennemis->ReplaDebut(perso);
        Ennemis6->ReplaDebut(perso);

        switch (tab.get(1,0))
        {
            case 1:
                {
                    Ennemis2.reset(new LS::Sorcier);
                    Ennemis7.reset(new LS::Sorcier);

                    break;
                }
            case 2:
                {
                    Ennemis2.reset(new LS::Archer);
                    Ennemis7.reset(new LS::Archer);

                    break;
                }
            case 3:
                {
                    Ennemis2.reset(new LS::Soldat);
                    Ennemis7.reset(new LS::Soldat);

                    break;
                }
             case 4:
                {
                    Ennemis2.reset(new LS::Guerrier);
                    Ennemis7.reset(new LS::Guerrier);

                    break;
                }
             case 5:
                {
                    Ennemis2.reset(new LS::Assassin);
                    Ennemis7.reset(new LS::Assassin);

                    break;
                }
            case 6:
                {
                    Ennemis2.reset(new LS::Mage);
                    Ennemis7.reset(new LS::Soldat);

                    break;
                }
         }

        Ennemis2->ReplaDebut(perso);
        Ennemis7->ReplaDebut(perso);


        switch (tab.get(2,0))
        {
            case 1:
                {
                    Ennemis3.reset(new LS::Sorcier);
                    Ennemis8.reset(new LS::Sorcier);

                    break;
                }
            case 2:
                {
                    Ennemis3.reset(new LS::Archer);
                    Ennemis8.reset(new LS::Archer);

                    break;
                }
            case 3:
                {
                    Ennemis3.reset(new LS::Soldat);
                    Ennemis8.reset(new LS::Soldat);

                    break;
                }
             case 4:
                {
                    Ennemis3.reset(new LS::Guerrier);
                    Ennemis8.reset(new LS::Guerrier);

                    break;
                }
             case 5:
                {
                    Ennemis3.reset(new LS::Assassin);
                    Ennemis8.reset(new LS::Assassin);

                    break;
                }
            case 6:
                {
                    Ennemis3.reset(new LS::Mage);
                    Ennemis8.reset(new LS::Mage);

                    break;
                }
         }

        Ennemis3->ReplaDebut(perso);
        Ennemis8->ReplaDebut(perso);

        switch (tab.get(3,0))
        {
            case 1:
                {
                    Ennemis4.reset(new LS::Sorcier);

                    break;
                }
            case 2:
                {
                    Ennemis4.reset(new LS::Archer);

                    break;
                }
            case 3:
                {
                    Ennemis4.reset(new LS::Soldat);

                    break;
                }
             case 4:
                {
                    Ennemis4.reset(new LS::Guerrier);

                    break;
                }
             case 5:
                {
                    Ennemis4.reset(new LS::Assassin);

                    break;
                }
            case 6:
                {
                    Ennemis4.reset(new LS::Mage);

                    break;
                }
         }

        Ennemis4->ReplaDebut(perso);

        switch (tab.get(4,0))
        {
            case 1:
                {
                    Ennemis5.reset(new LS::Sorcier);

                    break;
                }
            case 2:
                {
                    Ennemis5.reset(new LS::Archer);

                    break;
                }
            case 3:
                {
                    Ennemis5.reset(new LS::Soldat);

                    break;
                }
             case 4:
                {
                    Ennemis5.reset(new LS::Guerrier);

                    break;
                }
             case 5:
                {
                    Ennemis5.reset(new LS::Assassin);

                    break;
                }
            case 6:
                {
                    Ennemis5.reset(new LS::Mage);

                    break;
                }
         }

        Ennemis5->ReplaDebut(perso);

        LS::MesEnnemis::division(joueur);

        time.restart();

        while (window.isOpen())
        {

            while (window.pollEvent(event))
            {
                if (event.type == sf::Event::Closed || sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
                    window.close();
            }


            if (Ennemis->Depla(perso,perso2) ||
                Ennemis2->Depla(perso,perso2) ||
                Ennemis3->Depla(perso,perso2) ||
                Ennemis4->Depla(perso,perso2) ||
                Ennemis5->Depla(perso,perso2))
            {
                niveau.Mort();

                perso.repla(window,1);

                if (joueur)
                perso2.repla(window,1);

                LS::MesEnnemis::RemettreAZero();


                Ennemis.reset(new LS::MesEnnemis);
                Ennemis2.reset(new LS::MesEnnemis);
                Ennemis3.reset(new LS::MesEnnemis);
                Ennemis4.reset(new LS::MesEnnemis);
                Ennemis5.reset(new LS::MesEnnemis);
                Ennemis6.reset(new LS::MesEnnemis);
                Ennemis7.reset(new LS::MesEnnemis);
                Ennemis8.reset(new LS::MesEnnemis);
            }

            if (joueur)
            {
                 if (Ennemis6->Depla(perso,perso2) ||
                     Ennemis7->Depla(perso,perso2) ||
                     Ennemis8->Depla(perso,perso2))
                 {
                    niveau.Mort();

                    perso.repla(window,1);

                    if (joueur)
                    perso2.repla(window,1);

                    LS::MesEnnemis::RemettreAZero();


                    Ennemis.reset(new LS::MesEnnemis);
                    Ennemis2.reset(new LS::MesEnnemis);
                    Ennemis3.reset(new LS::MesEnnemis);
                    Ennemis4.reset(new LS::MesEnnemis);
                    Ennemis5.reset(new LS::MesEnnemis);
                    Ennemis6.reset(new LS::MesEnnemis);
                    Ennemis7.reset(new LS::MesEnnemis);
                    Ennemis8.reset(new LS::MesEnnemis);
                 }

                if (perso2.deplacer(window) && LS::MesEnnemis::EnnemisMort())
                {
                    perso2.repla(window,0);

                    perso.positionPerso(perso2);

                    niveau.ChangementDeNiveau();

                    break;
                }
            }

            if (perso.deplacer(window) && LS::MesEnnemis::EnnemisMort())
            {
                perso.repla(window,0);

                if (joueur)
                perso2.positionPerso(perso);

                niveau.ChangementDeNiveau();

                break;
            }


            if (sf::Keyboard::isKeyPressed(sf::Keyboard::A))
            {
                LS::MesEnnemis::RemettreAZero();
                break;
            }

            window.clear(sf::Color(204,204,204));
                niveau.afficherNiveau(window);

                Ennemis->afficher(window);
                Ennemis2->afficher(window);
                Ennemis3->afficher(window);
                Ennemis4->afficher(window);
                Ennemis5->afficher(window);

                if (joueur)
                {
                    Ennemis6->afficher(window);
                    Ennemis7->afficher(window);
                    Ennemis8->afficher(window);

                    perso2.afficher(window);
                }

                perso.afficher(window);

            window.display();
        }


    }

La classe Assassin des Classe.hpp

    class Assassin : public MesEnnemis
    {
        public:
            Assassin();

            virtual bool Depla(LesSprites &lesSprites,LesSprites &lesSprites2);

            virtual bool CollisionsPerso(LesSprites &lesSprites,LesSprites &lesSprites2);

            virtual void afficher(sf::RenderWindow& window);

            ~Assassin() {}
        private:

            PV::Couteau cut;
            short deplaX;
            short deplaY;

    };

 La classe couteau

    class Couteau
    {
        public:
            Couteau();
            float PositionX();
            float PositionY();
            bool repla(float PosX,float PosY,float angle);
            void depla();
            void afficher(sf::RenderWindow &window);
            ~Couteau();

        private:

            float x,y;

            sf::Texture text;
            sf::Sprite spr;
    };

Et Leurs méthodes dans Méthode.hpp

Assassin:

    Assassin::Assassin() : MesEnnemis(), deplaX(-5), deplaY(5)
    {
        text.loadFromFile("MesImages/ASS.PNG");
        text.setSmooth(true);

        spr.setTexture(text);
        spr.setOrigin(sf::Vector2f(30,18.5));

        EnemisMort++;
    }
    bool Assassin::Depla(LesSprites &lesSprites,LesSprites &lesSprites2)
    {
        float a = lesSprites.PositionX();
        float b = lesSprites.PositionY();
        float x = spr.getPosition().x;
        float y = spr.getPosition().y;
        float angle;

        if (MT::carre(a-x) + MT::carre(b-y) >=
            MT::carre(lesSprites2.PositionX() - x) + MT::carre(lesSprites2.PositionY() - y))
        {
            a = lesSprites2.PositionX();
            b = lesSprites2.PositionY();
        }

        if (y - b == 0)
        {
            if (x - a > 0)
                    angle = -90;
            else angle = 90;
        }
        else if (y - b > 0)
            angle = atan(-(x - a) / (y - b));
        else  if (y - b < 0)
            angle = M_PI - atan((x - a) / (y - b));
        else
        {
            if (x - a >= 0)
                angle = -90;
            else angle = 90;
        }

        spr.setRotation(angle * 180 / M_PI);


        SprDeTir += 1;

        if (SprDeTir > 30)
        {


            short a = time.getElapsedTime().asMilliseconds() % 3;

            switch (a)
            {
            case 0:
                {
                    deplaX = -5;
                    deplaY = -5;

                    break;
                }
            case 1:
                {
                    deplaX = 5;
                    deplaY = 5;

                    break;
                }
            case 2:
                {
                    deplaX = 5;
                    deplaY = -5;

                    break;

                }
            default:
                {
                    deplaX = 5;
                    deplaY = -5;
                }
            }


            SprDeTir = 0;
        }

        if (CN::CollisionsTilmap(spr.getPosition().x + sin(angle) * deplaX,
                                 spr.getPosition().y + cos(angle) * deplaY) &&
            spr.getPosition().y + cos(angle) * deplaY > 40 && spr.getPosition().y + cos(angle) * deplaY < 600 &&
            spr.getPosition().x + sin(angle) * deplaX > 40 && spr.getPosition().x + sin(angle) * deplaX < 760)
        {
            spr.move(sin(angle) * deplaX,cos(angle) * deplaY);
        }
        else SprDeTir = 31;


        if (MT::carre(lesSprites.PositionX()-spr.getPosition().x) +
            MT::carre(lesSprites.PositionY()-spr.getPosition().y) <= MT::carre(160))
        {
            if (cut.repla(spr.getPosition().x,spr.getPosition().y,angle))
            {
                deplaX = -5;
                deplaY = 5;
            }

            SprDeTir = 0;
        }

            cut.depla();

        if (CollisionsPerso(lesSprites,lesSprites2))
            return true;

        return false;
    }
    bool Assassin::CollisionsPerso(LesSprites &lesSprites,LesSprites &lesSprites2)
    {
        float u(lesSprites.PositionX()),v(lesSprites.PositionY()),x(cut.PositionX()),y(cut.PositionY()),
        u2(lesSprites2.PositionX()),v2(lesSprites2.PositionY());

        if (MT::carre(u-x) + MT::carre(v-y) <= 23 * 60 || MT::carre(u2-x) + MT::carre(v2-y) <= 23 * 60)
            return true;


        MesEnnemis::CollisionsEnnemis(lesSprites,50);
        MesEnnemis::CollisionsEnnemis(lesSprites2,50);

         return false;
    }
    void Assassin::afficher(sf::RenderWindow& window)
    {
        MesEnnemis::afficher(window);
        cut.afficher(window);
    }

Couteau:

    Couteau::Couteau()
    {
        text.loadFromFile("MesImages/COU.PNG");
        text.setSmooth(true);

        spr.setTexture(text);
        spr.setOrigin(text.getSize().x/2,text.getSize().y/2);
        spr.setPosition(sf::Vector2f(-100,-100));
    }
    bool Couteau::repla(float PosX,float PosY,float angle)
    {
        if (spr.getPosition().x < 0 || spr.getPosition().x > 800 ||
            spr.getPosition().y < 0 || spr.getPosition().y > 640)
        {
            spr.setPosition(sf::Vector2f(PosX + sin(angle) * 24.299 + cos(angle) * 9.775,
                                         PosY + sin(angle) *  9.775 + -cos(angle) * 24.299));

            x = sin(angle) * 8;
            y = -cos(angle) * 8;

            return true;
        }

        return false;
    }
    void Couteau::depla()
    {
        spr.move(sf::Vector2f(x,y));
        spr.rotate(40);

        if (CN::CollisionsTilmapMur(spr.getPosition().x,spr.getPosition().y))
        {
            x = 0;
            y = 0;

            spr.setPosition(sf::Vector2f(-100,-100));
        }
    }
    void Couteau::afficher(sf::RenderWindow &window)
    {
        if (dessiner)
        window.draw(spr);
    }
    float Couteau::PositionX()
    {
        return spr.getPosition().x;
    }
    float Couteau::PositionY()
    {
       return spr.getPosition().y;
    }

    Couteau::~Couteau() {}

Si vous trouvez la cause de cet erreur, merci de répondre !!

Il dit quoi le débogueur ?

Le débogueur, il me dit ça:

ERROR: You need to specify a debugger program in the debuggers's settings.
(For MinGW compilers, it's 'gdb.exe' (without the quotes))
(For MSVC compilers, it's 'cdb.exe' (without the quotes))

Je ne sais pas m'en servir, j'ai essayer mais cela n'a pas marché.

-
Edité par Titicplusplus 31 janvier 2019 à 13:49:12

> il m'arrive cette erreur

mais laquelle ?

C'est gentil, mais, du point de vue du lecteur du forum, tu débarques avec 500 lignes de code, avec "trouvez moi l'erreur, démerdez-vous pour trouver laquelle".

-
Edité par michelbillaud 31 janvier 2019 à 14:00:32

http://lmgtfy.com/?q=Code%3A%3ABlocks+debugger

Salut ! Déjà tu devrais simplifier ton code en faisant un tableau pour tes ennemis. Couplé à des for, tu divises la taille de ton code par 10 et il sera plus facile à maintenir.