mini rpg c++ le retour

**Médinoc** · 12/02/2013, 23h05

Utilise c = ifs.get() (ou ifs.get(c), selon le type de c) à la place.

**devdeb91** · 12/02/2013, 23h15

voici deux fonction que j'ai implementer a la structure SMap pouvait me dire se que vous en pensez car j'ai l'impression qu'elle est peu etre un peu barbare

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 unsigned char tilegamer(Joueur & joueur)
       {
           tiles[joueur.y()*cols + joueur.x()] = '@';
       }
 
       unsigned char tileremplace(Joueur & joueur)
       {
           tiles[joueur.y()*cols + joueur.x()] = '.';
       }

**Iradrille** · 12/02/2013, 23h22

Pourquoi refaire les calculs au lieu d'utiliser la fonction tileAt ?
Sinon, tu déclares tes deux fonctions comme renvoyant un unsigned char, hors elles ne renvoient rien, faut corriger ça.

edit: tu peux aussi (et tu devrais) passer une référence constante sur le joueur, vu que tu ne les modifies pas.

**devdeb91** · 12/02/2013, 23h25

Le problème est que j'ai pas réussi a utiliser tileAt donc je l'ai fait directe a la main. et de plus tileAt renvoie un caractère donc on aura le caractère mais pas la tile ou placer le perso ou placer le '.'

**Iradrille** · 12/02/2013, 23h31

Ah vi, bien vu pour tileAt, du coup tu peux rajouter une fonction qui fera le calcul, et qui te retourne l'indice correspondant (size_t), ça t'évitera de refaire le calcul à chaque fois.
(Fonction privée car tu n'en n'aura besoin qu'a l'intérieur de ta classe normalement)

**devdeb91** · 13/02/2013, 06h31

alors voila travailler un peu dessus mais blocage au niveau de sa

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
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();
            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;
        }

quand on appelle la premiere fonction il fait bien se qu'il faut mais aprés la deuxieme fonction il trouve pas je sais ou pense savoir d'ou sa vien je soupçonne que quand il fait la recherche il utilise un indice ou pointer qui place quand il a trouver du coup aprés lors de la prochaine recherche le pointer etant placer il commence du ce pointer mais je n'est réussi a replacer ce pointer au debut j'ai essayer un begin() mais rien n'i fait si vous pouvez plus me renseigner sur sa.

attention : je ne veut pas la solution non plus je veut juste plus de renseignement sur cela ( deja regarder la plupart des fonction de map) et aussi savoir si je me trompe sur le coup du pointer

**Iradrille** · 13/02/2013, 07h07

Un .find() recherche bien dans tous le container.

Si tu appelles les 2 fonctions avec les mêmes coordonnées, soit les 2 trouvent, soit aucune ne trouve.

Les deux fonctions sont identiques, ya pas de raisons qu'une marche mais pas l'autre.

**devdeb91** · 13/02/2013, 07h11

bah pourtant je peut t'assurer que la c'est le cas j'ai vérifié tout il envoie les même coordonnée mais pourtant une return le bon résultat l'autre return qu'elle a pas trouvé le pire c'est que j'avais pondu un truc pas mal pour avoir les deux bon return mais rien n'y fait

**devdeb91** · 14/02/2013, 11h18

bon bah voici le retour de l'avancement si vous avez des remarques a faire je suis preneur car je pense que cela n'est pas encore parfait

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
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
#include "main.h"
 
using namespace std;
 
int main()
{
    map<Position, string> maplist;    //<------ ici c'est le map que je comprend pas
    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);
 
    Joueur joueur(15,7);
    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 pos = Map.nextMap(joueur.x(), joueur.y());
               cout << pos.x() << " " << pos.y() << endl;
               auto it = maplist.find(Position(pos.x(),pos.y()));
               loadMap(Map, (*it).second );
               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
            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 pos = Map.nextMap(joueur.x(), joueur.y());
               cout << pos.x() << " " << pos.y() << endl;
               auto it = maplist.find(Position(pos.x(),pos.y()));
               loadMap(Map, (*it).second );
               //cout << Map.wraps << endl;
               Joueur joueur(posgamer.x(), posgamer.y());
               Map.tilegamer(joueur);
               //afficheMap(Map);
               //cout << pos.x() << endl;
               //loadMap(Map.nextMap(joueur.x(), joueur.y()));
               //tele(Map.gamerNextPosition(joueur.x(), joueur.y()));
           }
           else
            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);
           Map.tilegamer(joueur);
           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 pos = Map.nextMap(joueur.x(), joueur.y());
               cout << pos.x() << " " << pos.y() << endl;
               auto it = maplist.find(Position(pos.x(),pos.y()));
               loadMap(Map, (*it).second );
               Joueur joueur(posgamer.x(), posgamer.y());
               Map.tilegamer(joueur);
           }
           else
            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);
           Map.tilegamer(joueur);
           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 pos = Map.nextMap(joueur.x(), joueur.y());
               cout << pos.x() << " " << pos.y() << endl;
               auto it = maplist.find(Position(pos.x(),pos.y()));
               loadMap(Map, (*it).second );
               Joueur joueur(posgamer.x(), posgamer.y());
               Map.tilegamer(joueur);
           }
           else
            Map.tilegamer(joueur);
           afficheMap(Map);
       }
       //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();
    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)));
    }
    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);
         }
         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);
         }
         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);
         }
         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);
         }
         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 :

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
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
#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 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::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()] = '.';
       }
        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;
        }
};
 
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 :

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
#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 :

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
#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)){}
         size_t x() const{return position_.x();}
         size_t y() const{return position_.y();}
         void move(Deplacement const & dep)
         {
             position_=Position(x()+dep.distanceX(), y()+dep.distanceY());
         }
    private:
        Position position_;
};
 
#endif // JOUEUR_H_INCLUDED

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
#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 // TELEPORT_H_INCLUDED

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
#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
        int x() const{return x_;}
        int y() const{return y_;}
    private:
        size_t x_;
        size_t y_;
};
 
 
#endif // POSITION_H_INCLUDED

**koala01** · 14/02/2013, 20h15

Envoyé par devdeb91

bon bah voici le retour de l'avancement si vous avez des remarques a faire je suis preneur car je pense que cela n'est pas encore parfait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#include "main.h"
 
using namespace std;
 
int main()
{
    map<Position, string> maplist;    //<------ ici c'est le map que je comprend pas

En fait, ce qui fout le bordel, c'est la directive using namespace std; qui se trouve juste au dessus.

Cette directive a pour effet de dire au compilateur quelque chose qui ressemble à :

Il y a plein de trucs dans l'espace de noms std, mais, si tu trouves ces trucs sans qu'ils ne soient préfixés par std::, c'est pas grave, c'est la même chose et on parle bel et bien de ce qui se trouve dans cet espace de noms

Du coup,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
using namespace std;
map<Position, string> maplist;

est strictement identique à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

parce que map est le nom d'une collection "clé / valeur" qui existe dans l'espace de noms std et string est, toujours dans l'espace de noms std, le nom de ce qui permet de représenter des chaines de caractères.

**devdeb91** · 14/02/2013, 20h31

par contre je pense que tu aura remarquer que quand on change de map il place bien mais dés que tu bouge il place mal enfete il veut pas réinitialiser la position du coup il garde une mauvaise position mais j'i travail

mini rpg c++ le retour

C++

Discussions similaires

Partager

Partager