manipulation de fichiers

Version imprimable

Voir 40 message(s) de cette discussion en une page

26/02/2013, 18h55
devdeb91

Mon but est par exemple lier une position exemple 11 et 15 a une chaine exemple foret qui sera le nom dans et le tout sera eu lier a une chaine exemple fermer ou ouvert.

ceci est pour une gestion de coffre la position serai le position du coffre lier a le nom de sa carte le tout lier a l’état du coffre je ne sais pas si je m'exprime bien

donc du coup je voudrai avec un find pouvoir trouver si la positon y et x existe

ou sinon avec un insert j'aimerai insérer les valeurs dans chaque champ précis

Bonsoir, tu pourrais peut-être rendre ça plus clair en créent des classes pour séparer tes éléments,

Code:

1
2
3
4
5
6
7
8
9
        class Carte {
        public:
                Carte( const int nbrDeCoffres ) { for( int num( 0 ); num < nbrDeCoffres; num++ ) coffresOuvert.push_back( 0 ); }
                void Ouvrir( const int num ) { coffresOuvert[ num ] = 1; }
                void Fermer( const int num ) { coffresOuvert[ num ] = 0; }
                const bool Tester( const int num ) const { return coffresOuvert[ num ]; }
        private:
                std::vector <bool> coffresOuvert;
        };

que tu place avant ta boucle principale pour sauvegarder ces données. (Tu peux faire de même pour tes cartes)
Ensuite ça s'utilise facilement :

Code:

1
2
3
4
5
6
7
8
 
        Carte carte1( 20 );
        carte1.Ouvrir( numeroCoffre );
        if( carte1.Tester( numeroCoffre ))
                std::cout << "Coffre Ouvert : " << std::endl;
        else
                std::cout << "Coffre Ferme : " << std::endl;
        carte1.Fermer( numeroCoffre );

26/02/2013, 19h15
PilloBuenaGente

Citation:

donc du coup je voudrai avec un find pouvoir trouver si la postion y et x existe

Tes coffres vont ce déplacer ?? Sinon tu peux les appeler en tant que numéro. (1,2,3...) Même mettre des "enum"s par soucis de clarté. (édit->fautes)

Citation:

Envoyé par PilloBuenaGente

Bonsoir, tu pourrais peut-être rendre ça plus clair en créent des classes pour séparer tes éléments,

Code:

1
2
3
4
5
6
7
8
9
        class Carte {
        public:
                Carte( const int nbrDeCoffres ) { for( int num( 0 ); num < nbrDeCoffres; num++ ) coffresOuvert.push_back( 0 ); }
                void Ouvrir( const int num ) { coffresOuvert[ num ] = 1; }
                void Fermer( const int num ) { coffresOuvert[ num ] = 0; }
                const bool Tester( const int num ) const { return coffresOuvert[ num ]; }
        private:
                std::vector <bool> coffresOuvert;
        };

que tu place avant ta boucle principale pour sauvegarder ces données. (Tu peux faire de même pour tes cartes)
Ensuite ça s'utilise facilement :

Code:

1
2
3
4
5
6
7
8
 
        Carte carte1( 20 );
        carte1.Ouvrir( numeroCoffre );
        if( carte1.Tester( numeroCoffre ))
                std::cout << "Coffre Ouvert : " << std::endl;
        else
                std::cout << "Coffre Ferme : " << std::endl;
        carte1.Fermer( numeroCoffre );

cela me parait trés bien mais j'ai deja tout un systeme mis en place et sa me perturbe de le changer car avec ta façon faudrait peu etre tout repenser ou une grande partie.

voici le code peu etre aura tu une vision plus précise

Code:

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
65
66
67
68
void loadMap(SMap & Map, std::string const & filename)
{
    cout << "chargement de map " << filename << endl;
 
    Map.tiles.clear(); //supprime les informations de la map précédante
    Map.wraps.clear();
    Map.coffres.clear();
    Map.title.clear();
    ifstream ifs(filename);
    size_t rows;
    size_t cols;
    //cout << rows << " " << cols <<endl;
    ifs>>rows>>cols;
    Map.rows = rows;
    Map.cols = cols;
    //cout << rows << " " << cols <<endl;
    for(size_t y = 0; y < rows; ++y)
    {
        for(size_t x = 0; x < cols; ++x)
        {
           char c;
           ifs>>c;
           /*if(c == '@')
           {
               Map.position_x = x;
               Map.position_y = y;
           }*/
           Map.tiles.push_back(c);
           //cout << c << endl;
           //cout << c << " " << y << " " << x <<endl;
        }
        //ifs.seekg(1, ios::cur);
        //getline(ifs, contenue);
        //cout << contenue << endl;
    }
    int wrapCount;
    ifs>>wrapCount;
    //cout << wrapCount << endl;
    for(int i = 0; i< wrapCount;++i)
    {
         size_t xOrig;
         size_t yOrig;
         size_t xMapCorner;
         size_t yMapCorner;
         size_t xCoord;
         size_t yCoord;
         ifs>>xOrig>>yOrig
            >>xMapCorner>>yMapCorner>>
            xCoord>>yCoord;
       Map.wraps.insert(std::make_pair(Position(xOrig, yOrig),
                            SWrap(xOrig, yOrig, xMapCorner, yMapCorner, xCoord, yCoord)));
    }
    int coffrecount;
    ifs>>coffrecount;
    for(int i = 0; i< coffrecount;++i)
    {
        size_t xOrig;
        size_t yOrig;
        string contenue;
        string etat;
        ifs>>xOrig>>yOrig>>contenue>>etat;
        Map.tilecoffre(xOrig, yOrig, etat);
        Map.coffres.insert(std::make_pair(Position(xOrig, yOrig),
                           SCoffre(contenue)));
    }
    ifs>>Map.title;
    //cout << Map.title << endl;
}

Code:

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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
struct SCoffre {
        SCoffre(std::string containt):
        contenue(containt){}
 
    std::string contenue;
};
 
struct SMap {
        size_t rows;
        size_t cols;/* supprimé car pris en charge par Joueur
        int position_x; // cols
        int position_y; // rows*/
	std::vector<unsigned char> tiles;
	std::map<Position, SWrap> wraps;
	std::map<Position, SCoffre> coffres;
	std::string title;
        /* et, comme on peut travailler en orienté objets, on peut rajouter
         * une fonction membre qui renvoie le caractère qui se trouve en X,Y ;)
         */
       const unsigned char tileAt(size_t x, size_t y) const
       {return tiles[y*cols + x];}
       /* et la même chose avec une Position (sait on jamais ;)) */
       const unsigned char tileAt(Position const & pos)
       {return tileAt(pos.x(), pos.y());}
 
       void tilegamer(Joueur & joueur)
       {
           tiles[joueur.y()*cols + joueur.x()] = '@';
       }
 
       void tileremplace(Joueur & joueur)
       {
           tiles[joueur.y()*cols + joueur.x()] = '.';
       }
       void tilecoffre(Joueur & joueur)
       {
           tiles[joueur.y()*cols + joueur.x()] = 'O';
       }
       void tilecoffre(size_t x, size_t y, std::string etat)
       {
           std::string state = "fermer";
           char c;
           if(etat.compare(state) == 0)
           {
               c = 'C';
               //tilecoffre(x, y, c);
               tiles[y*cols + x] = c;
           }
           else
           {
               c = 'O';
               //tilecoffre(x, y, c);
               tiles[y*cols + x] = c;
           }
       }
       /*void tilecoffre(size_t x, size_t y, char c)
       {
           if(c == 'O')
           {
               tiles[y*cols + x] = c;
           }
           else
            tiles[y*cols + x] = c;
       }*/
        bool hasTeleportAt(size_t x, size_t y) const
        {
            return wraps.find(Position(x,y)) != wraps.end();
        }
        Position nextMap(size_t x, size_t y)
        {
            //auto it = wraps.begin();
            auto it = wraps.find(Position(x,y));
            if(it == wraps.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationMap;
        }
        Position gamerNextPosition(size_t x, size_t y)
        {
            //auto it = wraps.begin();
            std::cout << x << " " << y << std::endl;
            auto it = wraps.find(Position(x,y));
            if(it == wraps.end()) // ne devrait pas arriver, mais qui sait
            {
                std::cout << "non trouver" << std::endl;
                return Position(0,0);
            }
            return it->second.destinationCoordinates;
        }
        std::string coffreContaint(size_t x, size_t y)
        {
            auto it = coffres.find(Position(x,y));
            if(it == coffres.end())
            {
                std::cout << "non trouver" << std::endl;
                std::string erreur="vide";
                return erreur;
            }
            return it->second.contenue;
        }
};

en gros il charge une carte avec a l'aide d'info contenue dans un fichier dont les info coffre entre autre.

du coup deux choix se pose a moi soit réecrire le fichier a chaque fois que un coffre est ouvert

soit stocker cela dans une std::map

de ce fait j'essaye de faire un map de la position avec le nom de la carte puis un map de cela avec l'etat ceci permettrai de consulter l'etat en cherchant si les positions et la carte correspond puis si cela correspond on regarde l'etat et le place en ouvert ou fermer sur la carte

c'est pourquoi je veut faire un map<map<position, string>, string>

Citation:

j'essaye de faire un map de la position avec le nom de la carte puis un map de cela avec l'etat ceci permettrai de consulter l'etat en cherchant si les positions et la carte correspond

Et tout d'un coup ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
        class Carte {
        public:
                Carte() {}
                void NouveauCoffre( const int carte, const int position, const std::string objet ) {
                        coffre[ carte ][ position ] = objet;
                }
                const std::string Tester( const int carte, const int position ) {
                        if( coffre[ carte ][ position ] != "0" ) {
                                if( coffre[ carte ][ position ] == "Vide")
                                        return std::string("CoffreVide");
                                else
                                        return std::string("CoffreContient") coffre[ carte ][ position ];
                        }
                        else
                                return std::string("PasDeCoffre");
                }
                const std::string Ouvrir( const int carte, const int position ) {
                        std::string newCoffre( coffre[ carte ][ position ] );
                        coffre[ carte ][ position ] = "Vide";
                        return newCoffre;
                }
        private:
                std::map < const int , std::map <const int, std::string > > coffre;
        };

26/02/2013, 23h22
devdeb91

Je suis parti sur la modification du fichier directement et cela fonctionne mais n'est pas très top donc je vais voir ta façon.

Par contre si on part sur un système de sauvegarde les données ici seront perdu si je ne me trompe pas donc ne vaudrai t-il pas mieux modifier le fichier directement ou il sera possible de récupérer le tout ?

Et aussi peut on a travers du code c++ vérifier l'existence d'un fichier sans pour autant le créer ?
26/02/2013, 23h42
PilloBuenaGente

A moins que tu désires une sauvegarde à chaque mouvement, si les coffres sont disponible dans tout le programme, tu les charges au lancement puis les sauvegarde à la fermeture.
26/02/2013, 23h54
devdeb91

Moi j'ai fait en sorte de sauvegarder dans un nomfichier.save.txt a chaque fois que un coffre est ouvert comme sa je peut changer l’état mais bon je pense que ceci est du bricolage enfin bon je fini 2-3 truc et renvoie le rendu au cas ou si des personnes arriverai à optimiser cela

Comme le dit PilloBuenaGente, l'ouverture d'un coffre n'est à sauvegarder que quand le joueur décide de sauvegarder sa progression.

Niveau données, les informations de Coffre dans une Map n'ont pas à indiquer son état d'ouverture, seulement le contenu du coffre (et on suppose qu'il ne change pas).

Au chargement de la map, on aurait un truc comme ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 mapCourante = ChargerCarteFichier(mapX, mapY); for x { for y { if(mapCourante[x, y].Type==TypeCase.Coffre) { if(queteCourantes.coffresOuverts.Contient(mapX, mapY, x, y) mapCourante[x, y].Type = TypeCase.CoffreOuvert. } } }
PS: N'utilise pas de strings pour la gestion de la carte en mémoire quand des enums suffisent. Il peut arriver que des enums ne suffisent pas, mais elles suffiront la plupart du temps.

Voir 40 message(s) de cette discussion en une page