manipulation de fichiers [Résolu]

[devdeb91]

bonjour

alors voila je cherche a manipuler un fichier dynamiquement .

se que j'entend par la c'est que j'ai une gestion d'une carte avec des coffre sur cette carte les emplacement et les information a la carte sont dans un fichier lu au demarrage pour charger la carte.

je voudrais que quand j'ouvre un coffre il le mette ouvert definitivement car quand je change de carte et revient dessus les coffres sont a nouveau dispo hors je ne veut pouvoir les ouvrirs qu'une fois.

j'ai penser a renseigner avec des tellg les positions des infos a changer puis une fois que je tomber sur une des infos je changer mais cela ne me parait pas forcement top.

du coup auriez vous des solutions plus beau car je cherche a faire un code relativement bien ecris qui pourrai etre compris par tout le monde

[Ehonn]

Il faut que tu lises le fichier une seule fois (au début du programme) pour charger ses informations dans l'une de tes classes. Une fois le chargement fait, tu fermes le fichier. Les cartes utiliseront une seule instance de cette classe (et ne travaillent pas avec le fichier).

[devdeb91]

C'est déjà le cas mais quand je sort d'une carte à une autre je recharge un autre fichier du coup quand je repasse a l'autre carte plus tard il recharge encore le fichier du coup les coffres ouvert seront à nouveau fermer.

voici le code pour voir un peu le système

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
#include "main.h"
 
using namespace std;
 
int main()
{
    map<Position, string> maplist;
    loadMapList(maplist) ;
    auto it = maplist.find(Position(0,0)); // find methode de map
    SMap Map;
    loadMap(Map, (*it).second);
 
    //cout << Map.tiles[14*30 + 14] << endl;
    //cout << Map.tileAt(14,14) << endl;
    //cout << endl;
    //cout << Map.position_x << endl;
    //cout << Map.position_y << endl;
    afficheMap(Map);
    //Position pos(Map.position_x, Map.position_y);
    //deplace dep(Map.position_x, Map.position_y);
    Position pos(15,7);
    Joueur joueur(pos.x(), pos.y());
    Map.tilegamer(joueur);
    //afficheMap(Map);
    //Map.tileremplace(joueur);
    //afficheMap(Map);
    bool exit = false;
    //int gamespeed = 200;
    while(exit == false)
    {
       //system("cls");
        /*Récupération de la touche enfoncée  que je passe ici */
       /* (1) supprime le symbole du joueur à sa position actuelle */
       if(GetAsyncKeyState(VK_UP) != 0)
       {
           Map.tileremplace(joueur);
           TOUCHE touche = haut;
           Deplacement deplacement = computeDeplacement(joueur.x(), joueur.y(), Map, touche);
           joueur.move(deplacement);
           if(Map.tileAt(joueur.x(), joueur.y()) == '_')
           {
               cout << "teleporteur" << endl;
               cout << joueur.x() << " " << joueur.y() << endl;
               Position posgamer = Map.gamerNextPosition(joueur.x(), joueur.y());
               cout << posgamer.x() << " " << posgamer.y() << endl;
               Teleport tele(joueur);
               Position posmap = Map.nextMap(joueur.x(), joueur.y());
               cout << posmap.x() << " " << posmap.y() << endl;
               auto it = maplist.find(Position(posmap.x(),posmap.y()));
               loadMap(Map, (*it).second );
               joueur.changepos(posgamer.x(), posgamer.y());
                cout << joueur.x() << " " << joueur.y() <<endl;
               //Joueur joueur(posgamer.x(), posgamer.y());
               //Map.tilegamer(joueur);
               //auto it = maplist.find(Position())
               //loadMap(Map.nextMap(joueur.x(), joueur.y()));
               //tele(Map.gamerNextPosition(joueur.x(), joueur.y()));
           }
           else if(Map.tileAt(joueur.x(), joueur.y()) == 'C')
           {
               cout << "coffre" << endl;
               string contenue = Map.coffreContaint(joueur.x(), joueur.y());
               cout << contenue << endl;
               Map.tilecoffre(joueur);
               Deplacement dep = computeDeplacement(joueur.x(), joueur.y(), Map, bas);
               joueur.move(dep);
 
           }
           Map.tilegamer(joueur);
           afficheMap(Map);
       }
 
       if(GetAsyncKeyState(VK_DOWN) != 0)
       {
           Map.tileremplace(joueur);
           TOUCHE touche = bas;
           Deplacement deplacement = computeDeplacement(joueur.x(), joueur.y(), Map, touche);
           joueur.move(deplacement);
           if(Map.tileAt(joueur.x(), joueur.y()) == '_')
           {
               cout << "teleporteur" << endl;
               cout << joueur.x() << " " << joueur.y() << endl;
               Position posgamer = Map.gamerNextPosition(joueur.x(), joueur.y());
               cout << posgamer.x() << " " << posgamer.y() << endl;
               //Joueur joueur(posgamer.x(), posgamer.y());
               //cout << joueur.x() << " " << joueur.y() << endl;
               Teleport tele(joueur);
               Position posmap = Map.nextMap(joueur.x(), joueur.y());
               cout << posmap.x() << " " << posmap.y() << endl;
               auto it = maplist.find(Position(posmap.x(),posmap.y()));
               loadMap(Map, (*it).second );
               //cout << Map.wraps << endl;
               //delete joueur;
               //Joueur joueur(posgamer.x(), posgamer.y());
               joueur.changepos(posgamer.x(), posgamer.y());
               cout << joueur.x() << " " << joueur.y() <<endl;
               //Map.tilegamer(joueur);
               //afficheMap(Map);
               //cout << pos.x() << endl;
               //loadMap(Map.nextMap(joueur.x(), joueur.y()));
               //tele(Map.gamerNextPosition(joueur.x(), joueur.y()));
           }
           else if(Map.tileAt(joueur.x(), joueur.y()) == 'C')
           {
               cout << "coffre" << endl;
               string contenue = Map.coffreContaint(joueur.x(), joueur.y());
               cout << contenue << endl;
               Map.tilecoffre(joueur);
               Deplacement dep = computeDeplacement(joueur.x(), joueur.y(), Map, haut);
               joueur.move(dep);
           }
           Map.tilegamer(joueur);
           afficheMap(Map);
       }
 
       if(GetAsyncKeyState(VK_RIGHT) != 0)
       {
           Map.tileremplace(joueur);
           TOUCHE touche = droite;
           Deplacement deplacement = computeDeplacement(joueur.x(), joueur.y(), Map, touche);
           joueur.move(deplacement);
           //afficheMap(Map);
           if(Map.tileAt(joueur.x(), joueur.y()) == ':')
           {
               cout << "teleporteur" << endl;
               cout << joueur.x() << " " << joueur.y() << endl;
               Position posgamer = Map.gamerNextPosition(joueur.x(), joueur.y());
               cout << posgamer.x() << " " << posgamer.y() << endl;
                Teleport tele(joueur);
               Position posmap = Map.nextMap(joueur.x(), joueur.y());
               cout << posmap.x() << " " << posmap.y() << endl;
               auto it = maplist.find(Position(posmap.x(),posmap.y()));
               loadMap(Map, (*it).second );
               joueur.changepos(posgamer.x(), posgamer.y());
               //Joueur joueur(posgamer.x(), posgamer.y());
               //Map.tilegamer(joueur);
           }
           else if(Map.tileAt(joueur.x(), joueur.y()) == 'C')
           {
               cout << "coffre" << endl;
               string contenue = Map.coffreContaint(joueur.x(), joueur.y());
               cout << contenue << endl;
               Map.tilecoffre(joueur);
               Deplacement dep = computeDeplacement(joueur.x(), joueur.y(), Map, gauche);
               joueur.move(dep);
           }
           Map.tilegamer(joueur);
           afficheMap(Map);
 
       }
 
       if(GetAsyncKeyState(VK_LEFT) != 0)
       {
           Map.tileremplace(joueur);
           TOUCHE touche = gauche;
           Deplacement deplacement = computeDeplacement(joueur.x(), joueur.y(), Map, touche);
           joueur.move(deplacement);
 
           //afficheMap(Map);
           if(Map.tileAt(joueur.x(), joueur.y()) == ':')
           {
               cout << "teleporteur" << endl;
               cout << joueur.x() << " " << joueur.y() << endl;
               Position posgamer = Map.gamerNextPosition(joueur.x(), joueur.y());
               cout << posgamer.x() << " " << posgamer.y() << endl;
                Teleport tele(joueur);
               Position posmap = Map.nextMap(joueur.x(), joueur.y());
               cout << posmap.x() << " " << posmap.y() << endl;
               auto it = maplist.find(Position(posmap.x(),posmap.y()));
               loadMap(Map, (*it).second );
               joueur.changepos(posgamer.x(), posgamer.y());
               //Joueur joueur(posgamer.x(), posgamer.y());
               //Map.tilegamer(joueur);
           }
           else if(Map.tileAt(joueur.x(), joueur.y()) == 'C')
           {
               cout << "coffre" << endl;
               string contenue = Map.coffreContaint(joueur.x(), joueur.y());
               cout << contenue << endl;
               Map.tilecoffre(joueur);
               Deplacement dep = computeDeplacement(joueur.x(), joueur.y(), Map, droite);
               joueur.move(dep);
           }
           Map.tilegamer(joueur);
           afficheMap(Map);
       }
 
       //afficheMap(Map);
       //cout << joueur.x() << " " << joueur.y() << endl;
       //Map.tileAt(joueur.x(),joueur.y())=' ';
       /* (2) calcule le déplacement */
       //Deplacement deplacement = computeDeplacement(joueur.x(), joueur.y(), Map, touche);
        /* (3) déplace le joueur selon ce qui est demandé */
        //joueur.move(deplacement);
        /* (4) place le joueur sur la carte */
        //Map.tileAt(joueur.x(), joueur.y()) = '@';
        /* (5) affiche la map */
        //afficheMap(Map);
        /* (6) si le joueur est sur une porte ou sur un téléporteur, alors*/
        /*if(Map.hasTeleportAt(joueur.x(), joueur.y())) // fonction à créer
        {
            Teleport tele(joueur);
            loadMap(map.nextMap(joueur.x(), joueur.y())); //fonction à créer
            tele(map.gamerNextPosition(joueur.x(), joueur.y())); //fonction à créer qui renvoie la position de destination;
        }*/
    }
 
}
 
 
/* Pour pouvoir utiliser la std::map, on a besoin de l'opérateur de
 *comparaison <
 *
 */
bool operator <(Position const & first, Position const & second)
{
    return first.x() < second.x() ||
              (first.x() == second.x() && first.y() < second.y() );
}
/* et, tant qu'à faire, te l'opérateur de comparaison == (pour d'autres
 * usages ultérieurs, très certainement ;)
 */
bool operator ==(Position const & first, Position const & second)
{
    return ( first.x() == second.x() && first.y() == second.y() );
}
 
bool operator !=(Position const & first, Position const & second)
{
    return  !(first == second);
}
 
void loadMapList(std::map<Position, std::string> & toFill)
{
    cout << "fonction de chargement liste " << endl;
    std::ifstream ifs("ephernia.txt");
    if(ifs)  // si l'ouverture a réussi
        {
            // instructions
                //ifs.close();  // on referme le fichier
        }
        else  // sinon
                cerr << "Erreur à l'ouverture !" << endl;
    size_t x;
    size_t y;
    std::string filename;
    while(ifs>>x>>y>>filename)
    {
        toFill.insert(std::make_pair(Position(x,y),filename)); // insert methode de map
    }
}
 
 
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;
        ifs>>xOrig>>yOrig>>contenue;
        Map.coffres.insert(std::make_pair(Position(xOrig, yOrig),
                           SCoffre(contenue)));
    }
    ifs>>Map.title;
    //cout << Map.title << endl;
}
 
Deplacement computeDeplacement(size_t xOrigin, size_t yOrigin, SMap const & Map, TOUCHE touche)
{
     /* on va considérer que touche peut valoir "up","down","left" et "right"
      * sous la forme de valeurs énumérées ;)
       */
     switch(touche)
     {
         case haut:
         /* si on rencontre un "#" en haut, on est bloqué :aie */
         if (Map.tileAt(xOrigin, yOrigin-1) == '#')
         {
             return Deplacement(0,0);
         }
         else if(Map.tileAt(xOrigin, yOrigin-1) == 'O')
         {
             return Deplacement(0,0);
         }
         return Deplacement(0,-1);
 
		 case bas:
         /* si on rencontre un "#" en bas, on est bloqué :aie */
         if (Map.tileAt(xOrigin, yOrigin+1) == '#')
         {
             return Deplacement(0,0);
         }
         else if(Map.tileAt(xOrigin, yOrigin+1) == 'O')
         {
             return Deplacement(0,0);
         }
         return Deplacement(0,1);
 
         case gauche:
         /* si on rencontre un "#" à gauche, on est bloqué :aie */
         if (Map.tileAt(xOrigin-1, yOrigin) == '#')
         {
             return Deplacement(0,0);
         }
         else if(Map.tileAt(xOrigin-1, yOrigin) == 'O')
         {
             return Deplacement(0,0);
         }
         return Deplacement(-1,0);
 
		 case droite:
         /* si on rencontre un "#" à droite, on est bloqué :aie */
         if (Map.tileAt(xOrigin+1, yOrigin) == '#' )
         {
             return Deplacement(0,0);
         }
         else if(Map.tileAt(xOrigin+1, yOrigin) == 'O')
         {
             return Deplacement(0,0);
         }
         return Deplacement(1,0);
     }
     /* on ne devrait jamais arriver ici, mais ca évite un avertissement du
       * compilo, et puis, sait on jamais ;)
       * Pour toutes les autres touches, on ne bouge pas :D
       */
    return Deplacement(0,0);
}
 
void afficheMap(SMap & Map)
{
    size_t x = 0;
    for(size_t y = 0; y < Map.rows * Map.cols; y++)
    {
        if(x == Map.cols)
        {
            x = 0;
            cout << endl;
        }
        cout << Map.tiles[y];
        x++;
    }
    cout << 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED
#include "position.h"
#include "deplacement.h"
#include "joueur.h"
#include "teleport.h"
#include <iostream>
#include <windows.h>
#include <vector>
#include <fstream>
#include <map>
#include <string>
#include <assert.h>
 
 
struct SWrap {
        SWrap(size_t xSrc, size_t ySrc,
                   size_t xCorner, size_t yCorner,
                   size_t xCoord, size_t yCoord):
                   source(Position(xSrc,ySrc)),
                   destinationMap(Position(xCorner,yCorner)),
                  destinationCoordinates(Position(xCoord, yCoord)){}
	/*ici les coord de départ sur la map courante*/
	Position source;
	/*ici, l'identification de la map de sortie: nom, coordonnées, etc.*/
	Position destinationMap;
	/*ici les coordonnees d'arrive sur la map de sortie*/
	Position destinationCoordinates;
};
 
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';
       }
        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;
        }
};
 
enum TOUCHE
{
    haut,
    bas,
    gauche,
    droite
};
 
bool operator <(Position const & first, Position const & second);
bool operator ==(Position const & first, Position const & second);
bool operator !=(Position const & first, Position const & second);
Deplacement computeDeplacement(size_t xOrigin, size_t yOrigin, SMap const & Map, TOUCHE touche);
void loadMapList(std::map<Position, std::string> & toFill);
void loadMap(SMap & Map, std::string const & filename);
void afficheMap(SMap & Map);
 
 
#endif // MAIN_H_INCLUDED

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef DEPLACEMENT_H_INCLUDED
#define DEPLACEMENT_H_INCLUDED
#include <assert.h>
 
class Deplacement
{
    public:
        Deplacement(int x, int y):distanceX_(x),distanceY_(y)
        {
             assert(x>=-1 && x<=1);
             assert(y>=-1 && y<=1);
        }
        int distanceX() const{return distanceX_;}
        int distanceY() const{return distanceY_;}
    private:
        int distanceX_;
        int distanceY_;
};
 
#endif // DEPLACEMENT_H_INCLUDED

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
#ifndef JOUEUR_H_INCLUDED
#define JOUEUR_H_INCLUDED
 
class Joueur
{
     /* donnons l'acces à une classe "teleport".
      * cela évite d'avoir à exposer une fonction de type moveTo, et améliore
      * l'encapsulation ;)
      */
     friend class Teleport;
     public:
         Joueur(size_t x, size_t y):position_(Position(x,y)){}
         //~Joueur(){}
         size_t x() const{return position_.x();}
         size_t y() const{return position_.y();}
         //void setx(size_t x){position_.setx(x);}
         //void sety(size_t y){position_.sety(y);}
         void move(Deplacement const & dep)
         {
             position_=Position(x()+dep.distanceX(), y()+dep.distanceY());
         }
         void changepos(size_t x, size_t y)
         {
             position_.changepos(x,y);
         }
    private:
        Position position_;
};
 
#endif // JOUEUR_H_INCLUDED

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
#ifndef POSITION_H_INCLUDED
#define POSITION_H_INCLUDED
#include <cstring>
 
class Position
{
    public:
        Position(size_t x, size_t y):x_(x), y_(y){} // y = rows , x = cols
        //~Position(){}
        int x() const{return x_;}
        int y() const{return y_;}
        void changepos(size_t x, size_t y)
        {
            this->x_ = x;
            this->y_ = y;
        }
        //void setx(size_t x){this.x_ = x;}
        //void sety(size_t y){this.y_ = y;}
    private:
        size_t x_;
        size_t y_;
};
 
 
#endif // POSITION_H_INCLUDED

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#ifndef TELEPORT_H_INCLUDED
#define TELEPORT_H_INCLUDED
 
class Teleport
{
    public:
        Teleport(Joueur & j):
        j(j){}
        void operator()(Position const & to) const
        {
            j.position_ = to;
        }
    private:
        Joueur & j;
};
 
#endif /

pour les carte voir les pieces jointes

[Ehonn]

Je n'ai pas lu le code mais il te suffit de stocker tes cartes dans une std::map et faire le chargement de la carte demandée si celle-ci n'est pas trouvée dans la std::map.

[devdeb91]

C'est ce que fait déjà le code est cela fonctionne très bien mais pas assez pour modifier tout ce qu'il faut quand il faut.

[Ehonn]

Il faut donc que tu ajoutes un "état" à ton coffre.
Soit avec un booléen, soit en mettant son contenu à vide.

[devdeb91]

Le problème en soit n'est pas d'ouvrir le coffre cela l'ouvre bien et passe à l’état ouvert.

Le problème c'est que le coffre est directement lié à la map donc quand on change de map puis revient dessus la coffre ouvert précédemment revient en mode fermé car le fichier n'as pas été modifié donc dans le fichier il est toujours fermer bien qu'il ait été ouvert c'est pour cela que je voulais modifier le fichier directement.

[Ehonn]

Tu parles de deux exécutions différentes (du même programme) ?

Si non, il ne faut pas créer plusieurs fois la même carte, on la stocke quelque part en attendant qu'elle soit réutiliser (la conversion précédente).

Si oui, tu peux réécrire le fichiers des coffres (mis à jour) dans le destructeur de la carte.

[devdeb91]

Je t'explique il va charger un fichier contenant un bout de carte ( exemple : une ville) puis lorsque il va sortir de la ville il va charger un autre fichier carte ( exemple : foret) dans cette foret il y a imaginons 3 coffre il va les ouvrir.

il va rechanger de carte par exemple retour dans la ville donc rechargement de la carte ville et imaginons pour x ou y raison il décide de retourner dans la carte foret bah il rechargera encore la carte foret mais vue que les coffres sont intégrer dans la map donc dans le fichier il ne seront pu ouvert mais fermer ( un peu comme zelda quand tu casse les pot puis revient dans la pièce il sont à nouveau là )

[Bousk]

Envoyé par devdeb91

car le fichier n'as pas été modifier donc dans le fichier il est toujours fermer bien qu'il est etait ouvert c'est pour cela que je voulais modifier le fichier directement

La solution consiste alors à le modifier, ce fichier..
A chaque action, tu le réécris, vu qu'il est réouvert à chaque entrée sur la map.

[devdeb91]

Je me doute mais y a t-il pas un moyen plus beau que cela car je trouve cela pas très top

[Médinoc]

Dans tous les cas, l'état d'ouverture des coffres doit rester en mémoire, qu'on recharge la map elle-même à chaque fois qu'on y entre ou qu'on la garde en mémoire.

[devdeb91]

re

alors je voudrais savoir car je ne suis pas sur est il possible de supprimer un mot dans un fichier ou sans forcement le supprimer le remplacer par un autre ?

[Médinoc]

Modifier un fichier texte, c'est long, car il faut copier tout le fichier jusqu'à la partie qu'on veut modifier, la modifier puis copier le reste, puis supprimer l'ancien et renommer le nouveau.

Un fichier binaire, avec des enregistrements de longueur fixe, peut être modifié sur-place plus facilement.

Mais ce qu'on te dit, c'est de ne pas toucher à tes maps originales. L'état des coffres, ce doit être une variable de la partie en cours, pas un composant des maps qu'on modifierait. Tu peux par exemple tenir une liste/map des coffres déjà ouverts, et la sauvegarder dans un fichier séparé, avec la position courante et les points de vie du héros.

Prenons un exemple concret: Dans les Zelda 2D depuis ALTTP, différentes variables d'un donj' ont différentes durées de vie:

• Les pots brisés respawnent dès qu'on retourne dans une pièce qu'on a quittée.
• Leur contenu (hors clés) lui, ne respawne pas tant qu'on n'est pas sorti du donjon, donc le fait qu'ils ont été consommés reste en mémoire tant qu'on s'y trouve. Pareil pour les ennemis (hors boss et sous-boss)
• Les clés collectées, portes déverrouillées et coffres ouverts restent en mémoire pendant toute la partie, du début à la fin, et sont sauvegardées avec le reste de la progression du joueur.

[devdeb91]

Non mais la je suis d'accord j'ai tout modifié pour pouvoir mettre dans des variables mais voila le problème c'est que l’état du coffre est un string (ouvert ou fermer) qui se trouve dans le fichier de la carte donc quand je lis il place le et tout grasse aux infos mais je voudrais modifier l’état donc quand il est ouvert a la fin je veux changer dans le fichier le mot fermer en ouvert donc que un mot. Est-ce possible ?

[Médinoc]

L'état du coffre, c'est une string uniquement dans le fichier. En mémoire, ce doit être un bool.

Et cet état, tu n'as pas à la sauvegarder dans la carte. Tu ne modifies jamais la carte dans le fichier. Tous les événements appartiennent à la partie courante. En gros, si le joueur retourne dans cette pièce, tu dois vérifier cette mémoire juste après avoir chargé la carte (et là si tu veux, tu peux la modifier en mémoire).

[devdeb91]

dans se cas la comment la garder tout le temps en mémoire sans que elle soit effacer au bout d'un moment par une autre donnée

[Médinoc]

Avec une std::map, par exemple.

[devdeb91]

peut on faire une std::map d'une std::map exemple

Code :

std::map<std::map<Position, string>, string>

et dans l'eventualité ou cela est possible pour un insert ou find cela donnerais par exemple cela ou pas

Code :

flux.find.find(Position(x,y)

ou encore

Code :

flux.insert(make_pair(insert(make_pair(Position,string)), string)

[JolyLoic]

Envoyé par devdeb91

peut on faire une std::map d'une std::map exemple

Code :

std::map<std::map<Position, string>, string>

Oui, bien entendu. Maintenant, est-ce que ça a du sens, peut-être.

Envoyé par devdeb91

et dans l'eventualité ou cela est possible pour un insert ou find cela donnerais par exemple cela ou pas

Code :

flux.find.find(Position(x,y)

Tu veux trouver quoi au fait ? tu as associé une chaîne à une map. Donc, si tu veux retrouver ta chaîne, tu dois en clef fournir une map. Pas une position.

Envoyé par devdeb91

ou encore

Code :

flux.insert(make_pair(insert(make_pair(Position,string)), string)

Là encore, tu as un soucis : Tu essaye d'ajouter un élément, qui doit être une pair<map<...>, string>, mais tu lui passe juste une pair<pair<...>,string>.

Je me demande si en fait, tu ne voudrais pas plutôt une map<Position, map<string, string>>, ou toute autre combinaison où la seconde map est liée à la valeur plus qu'à la clef.