Bonjour à tous
Je me heurte actuellement à un problème. Je suis en train de coder un jeu avec la SFML dont les grandes lignes n'apporteront rien à la résolution de mon problème. En fait, je dispose d'une classe Image_pack qui contient une list d'images sfml et une liste d'une autre classe qui permet de lier un pointeur sur image avec un index et un nom. Le code des 2 classes sera sans doute plus clair : (pour des raisons de simplicité, les 2 classes sont dans le même fichier)
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
//image_pack.hpp
//image_pack + Image_id_index
#ifndef IMAGE_PACK_HPP
#define IMAGE_PACK_HPP
 
#include <SFML\Graphics.hpp>
#include <list>
#include <iostream>
 
using namespace sf;
using namespace std;
 
class Image_id_index
{
    public:
        Image_id_index(Image *img, int index, string id);
 
        int get_index() const;
        string get_name() const;
        Image *get_img_adress();
 
    private:
        Image *m_img;
        int m_index;
        string m_name;
};
 
class Image_pack
{
    public:
        Image_pack();
 
        bool push_back(string img_path, int index, string id);
 
        Image *getImage(int index);
        Image *getImage(string id);
 
    private:
        list<Image_id_index> m_t_image_id_index;
        list<Image> m_t_image;
};
 
#endif
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
//image_pack.cpp
 
#include "image_pack.hpp"
 
Image_id_index::Image_id_index(Image* img, int index, string id) :
                                m_index(index),
                                m_name(id),
                                m_img(img)
{
    cout<<index<<" "<<id<<" "<<m_img<<endl;
}
 
int Image_id_index::get_index() const
{
    return m_index;
}
 
string Image_id_index::get_name() const
{
    return m_name;
}
 
Image *Image_id_index::get_img_adress()
{
    return m_img;
}
 
Image_pack::Image_pack()
{}
 
bool Image_pack::push_back(string img_path, int index, string id)
{
    Image img;
    if(!img.LoadFromFile(img_path.c_str()))
    {
        cout<<"Le fichier ressource est corrompu ou l'image n'existe pas"<<endl;
        return false;
    }
 
    m_t_image.push_back(img);
    list<Image>::iterator i = m_t_image.end();
    i--;
    m_t_image_id_index.push_back(Image_id_index(&(*i),index,id));
    return true;
}
 
Image * Image_pack::getImage(int index)
{
    cout<<index<<" ";
    cout<<m_t_image_id_index.size()<<endl;
    for(list<Image_id_index>::iterator it = m_t_image_id_index.begin();it!=m_t_image_id_index.end();it++)
        if(it->get_index() == index)
            return it->get_img_adress();
    return NULL;
}
 
Image * Image_pack::getImage(string id)
{
    for(list<Image_id_index>::iterator it = m_t_image_id_index.begin();it!=m_t_image_id_index.end();it++)
        if(it->get_name() == id)
            return it->get_img_adress();
    return NULL;
}
L'utilisation de la classe Image_pack est la suivante :
au début du jeu, une classe déclare une instance de Image_pack puis charge à partir d'un fichier toutes les données nécessaires pour ajouter des images à l'instance créée, comme ceci :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
void MainWindow::load_resources(string file_name)
{
    ifstream stream(file_name.c_str(),ios::in);
 
    if(stream == NULL)
    {
        cout<<endl<<"Fichier introuvable, gestion des ressources impossible"<<endl;
        m_quit = true;
    }
    else
    {
        string filepath;
        string name;
        int index;
 
        while(stream>>filepath>>name>>index && m_quit == false)
        {
            cout<<"chargement de l'image : "<<endl<<"- chemin d'acces : "<<filepath<<endl<<"- nom : "<<name<<endl<<"- index : "<<index<<endl<<endl;
            if(!m_img_pack->push_back(filepath,index,name))
                m_quit = true;
        }
 
        if(!stream.eof())
        {
            cout<<"Le fichier ressources est corrompu, les ressources n'ont pas pu etre chargees"<<endl;
            m_quit = true;
        }
    }
}
Ensuite, le pack est donné en paramètre à de nombreuses autres classes qui utiliseront par l'index ou le nom les images contenues dans ce pack. Sauf que tout ne se passe pas comme prévu : une erreur vraiment bizarre s'est glissée dans mon programme. En effet, lorsque j'essaie d'utiliser la fonction getImage(int index) du pack, le programme s'arrête de fonctionner. Divers tests avec le deboggeur m'ont permis d'en déduire que cela provenait vraisemblablement de l'appel aux méthodes de la list<Image_id_index> que sont size(), begin() et end() (size pour confirmer ce bug). Je ne sais vraiment pas du tout à quoi cela peut-il être du car l'appel à ces méthodes dans la fonction push_back du pack fonctionne parfaitement . Je précise que cela ne peut pas venir d'un index faux puisque l'appel à ces méthodes survient avant les possibles erreurs liées à un index trop élevé.
Pouvez-vous m'aider ? Merci par avance