mini rpg c++ le retour

Version imprimable

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

bonjour

alors voila pour ceux qu'il ne le savent pas encore je développe un rpg en c++.
pour ceux qui on suivi deja mon cas bah je pense un peu avoir avancer.
tout d'abord voici les codes sources.

main.cpp :

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
#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.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);
 
    /*while(bool exit == false)
    {
        system("cls");
        afficheMap(Map);
        for(size_t y = 0; y < Map.rows; y++)
        {
            for(size_t x = 0; x < Map.cols; x++)
            {
 
            }
        }
    }*/
    //cout << dep.x() << endl;
    //cout << Map.title << endl;
    //cout << Map.rows << endl;
    return 0;
}
 
 
/* 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() );
}
 
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;
    int x;
    int 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)
    {
         SWrap wrap;
         ifs>>wrap.sourceX>>wrap.sourceY
            >>wrap.destMapX>>wrap.destMapY
            >>wrap.destX>>wrap.destY;
        Map.wraps.push_back(wrap);
    }
    ifs>>Map.title;
    //cout << Map.title << endl;
}
 
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;
}

main.h :

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
#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED
#include "position.h"
#include "deplace.h"
#include <iostream>
#include <windows.h>
#include <vector>
#include <fstream>
#include <map>
#include <string>
 
struct SWrap {
	/*ici les coord de départ sur la map courante*/
	int sourceX;
	int sourceY;
	/*ici, l'identification de la map de sortie: nom, coordonnées, etc.*/
	int destMapX;
	int destMapY;
	/*ici les coordonnees d'arrive sur la map de sortie*/
	int destX;
	int destY;
};
 
struct SMap {
        size_t rows;
        size_t cols;
        int position_x; // cols
        int position_y; // rows
	std::vector<unsigned char> tiles;
	std::vector<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());}
};
 
 
bool operator <(Position const & first, Position const & second);
bool operator ==(Position const & first, Position const & second);
void loadMapList(std::map<Position, std::string> & toFill);
void loadMap(SMap & Map, std::string const & filename);
void afficheMap(SMap & Map);
 
 
#endif // MAIN_H_INCLUDED

position.h :

Code:

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 "main.h"
 
class Position
{
    public:
        Position(int x, int y):x_(x), y_(y){} // y = rows , x = cols
        int x() const{return x_;}
        int y() const{return y_;}
    private:
        int x_;
        int y_;
};
 
 
#endif // POSITION_H_INCLUDED

deplace.h :

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
#ifndef DEPLACE_H_INCLUDED
#define DEPLACE_H_INCLUDED
#include "position.h"
 
 
enum Direction
{
   nord,
   nordouest,
   ouest,
   sudouest,
   sud,
   sudest,
   est,
   nordest
};
 
class deplace
{
    public:
        deplace(int x, int y): position_(x, y){}
        int x() const{return position_.x();}
        int y() const{return position_.y();}
        void bouger(Direction d)
        {
           switch(d)
           {
               case nord:
                   position_=Position(x(),y()+1);
                   break;
               case nordouest:
                   position_=Position(x()-1,y()+1);
                   break;
               case ouest:
                   position_=Position(x()-1,y());
                   break;
               case sudouest:
                   position_=Position(x()-1,y()-1);
                   break;
               case sud:
                   position_=Position(x(),y()-1);
                   break;
               case sudest:
                   position_=Position(x()+1,y()-1);
                   break;
               case est:
                   position_=Position(x()+1,y());
                   break;
               case nordest:
                   position_=Position(x()+1,y()+1);
                   break;
           }
        }
         /* tout le reste */
    private:
        Position position_;
};
 
#endif // DEPLACE_H_INCLUDED

bon voila les présentation faite commençon. alors la structure SMap est rempli d'un tas d'information utile, mon objet deplace et position sont initialiser, maintenant je n'est plus qu'a deplacer j'ai deja idée de comment
voici le procéder :

si c'est vers le haut (nord) :

il va placer le '@' 30 case plus avant
il va remplacer l'ancienne case par un '.'
il va incrémenter la position
si il tombe sur une porte bah il changera de map via le fichier

si c'est vers le bas (sud) :

pareil que en haut sauf les 30 case seront vers l'arriere

si c'est vers la gauche(ouest) :

il va reculer d'une case dans le tableau tiles
il v remplacer l'ancienne case par un '.'
il va changer la position dans position
si il tombe sur une porte il va changer de map

si c'est vers la droite(est) :

pareil que pour la gauche sauf que se sera une case de plus.

mais malgré tout sa en tete il me reste un souci voila pourquoi

Code:

1
2
3
4
5
6
7
 for(y = 0; y < 10; y++)
        {
            for(x = 0; x < 20; x++)
            {
                switch(allMaps[inmap].tiles[y][x])
                {
                case '@':

je compter faire un truc similaire a sa mais avec mon tableau tiles a une dimension au niveau du switch je bloque

voici mon debut de code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
while(bool exit == false)
    {
        system("cls");
        afficheMap(Map);
        for(size_t y = 0; y < Map.rows; y++)
        {
            for(size_t x = 0; x < Map.cols; x++)
            {
 
            }
        }
    }

donc ma question est auriez vous une idée pour que je me débloque ? biensur toute remarque est accepter et toute autre methode differente de la mienne aussi du moment qu'on m'explique un peu le déroulement.

merci

11/02/2013, 15h02
Médinoc
Tu as cette méthode:
Code:

1 2 const unsigned char tileAt(size_t x, size_t y) const {return tiles[y*cols + x];}
Sers-t'en.

Le fait qu'une map soit un vecteur 1D ou un tableau 2D, c'est un détail d'implémentation, on n'a pas à s'en soucier à l'extérieur.

PS: Es-tu sûr que les objets comme le joueur ('@') doivent faire partie de la map elle-même? Cela risque de te compliquer la vie plus que la faciliter...
11/02/2013, 15h17
devdeb91

euh la méthode en faite j'en est pas compris l'utilité j'ai essayer de l'utiliser mais finalement j'ai pas compris donc je l'ai laisser de coté.

et pour le joueur c'est juste pour dans un premier temps histoire de voir si le deplacement se fait bien une fois bien en place je verrais

tileAt sert justement à accéder à la map sans te soucier de faire toi-même la multiplication par la largeur.

Par contre, il va falloir en faire une version capable d'écriture, vu qu'on veut pouvoir modifier:
Code:

1 2 3 4 5 6 //Accesseur de tile, const et non-const (version avec coordonnées) unsigned char & tileAt(size_t x, size_t y) {return tiles[y*cols + x];} unsigned char const tileAt(size_t x, size_t y) const {return tiles[y*cols + x];} // et la même chose avec une Position (sait on jamais ;)) unsigned char & tileAt(Position const & pos) {return tileAt(pos.x(), pos.y());} unsigned char const tileAt(Position const & pos) const {return tileAt(pos.x(), pos.y());}
Avec ça, tu peux faire Map.tileAt(x, y) = '@'; si tu veux...

11/02/2013, 15h32
devdeb91

Étant donné qu'il ont les mêmes paramètres comment le programme va t-il les différencier lors de l'appel ?
11/02/2013, 15h35
Médinoc
Le compilo les différencie grâce au type de Map. Là où Map est const, il utilisera la version const; sinon, la version non-const.

Ne te soucie pas de l'effet sur les performances, pour deux raisons:
- Il est trop tôt pour ça ("premature optimization is the root of all evil")
- Ces méthodes sont est définies dans le corps de la classe, elles sont donc inline de toute façon.

Donc si je résume bien si je fais

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
while(bool exit == false)
    {
        system("cls");
        afficheMap(Map);
        for(size_t y = 0; y < Map.rows; y++)
        {
            for(size_t x = 0; x < Map.cols; x++)
            {
                 switch(Map.tileAt(y, x))
                 {
                    case '@' :
                                 etc...
 
            }
        }
    }

cela devrai passer et ne dépassera pas la taille du tableau

11/02/2013, 16h27
Médinoc

Oui, c'est ça.
11/02/2013, 16h30
devdeb91

Merci je teste ça ce soir et balance les retours

Salut,

Déjà, ta map ne devrait pas avoir la responsabilité de gérer la position du joueur, car le joueur a sa "vie propre" et s'occupe de gérer sa position lui-même.

Tu devrais donc avoir une classe "gamer" proche de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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(), dep.distanceY();
         }
    private:
        Position position_;
};

Bon, tu l'auras remarqué, j'ai introduit une classe Deplacement, qui représente simplement une distance en abscisse et en ordonnée.

Cette classe a pour invariant que les distances doivent se trouver dans la fourchette comprise entre -1 et +1 (car on ne se déplace jamais que d'une case à la fois ;)) et ressemble à quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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_;
};

Il nous faut aussi un moyen de calculer le déplacement sur base d'une position sur la carte et de la (ou des) touches enfoncées, car il serait dommage que notre joueur en vienne à jouer au passe-muraille ;)

Cela peut se faire grâce à une fonction libre qui pourrait ressembler à quelque chose comme

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
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 up:
         /* 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 down:
         /* 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 left:
         /* si on rencontre un "#" à gauche, on est bloqué :aie */
         if (map.tileAt(xOrigin-1, yOrigin)
         {
             return Deplacement(0,0);
         }
         return Deplacement(-1,0);
         case right:
         /* 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);
}

Et, pour être complet, il ne nous manque plus que la classe Teleport, qui pourrait ressembler à quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
class Teleport
{
    public:
        Teleport(Joueur & j, ):
        j(j){}
        void operator()(Position const & to) const
        {
            j.position_ = to;
        }
    private:
        Joueur & j;
}

Enfin, l'ordre de travail va avoir son importance.

L'idée est de travailler dans l'ordre suivant:

calculer le déplacement du joueur
déplacer le joueur
retirer le symbole de sa position actuelle sur la carte
placer le joueur à sa nouvelle position sur la carte
afficher la carte
si le joueur se trouve sur une porte ou sur un télé-porteur alors
- changer de carte et le placer au bon endroit

Au final, la boucle générale pourrait ressembler à quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
while(bool 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 */
       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;
        }
    }

Comme tu peux le remarqué, j'ai marqué un certain nombre de fonction comme étant "à créer" (je me suis basé sur le principe que ce seraient des fonctions membres ;)) voyons donc les modifications à apporter à SMap :D

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
 
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::vector<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());}
        bool hasTeleportAt(size_t x, size_t y) const
        {
            /* code C++11 inside, mais facile à convertir :D */
            for(auto it : wraps)
            {
                if(it.sourceX== x && it.sourceY==y)
                {
                    return true;
                }
            }
            return false;
        }
        Postition nextMap(size_t x, size_t y)
        {
            for(auto it : wraps)
            {
                if(it.sourceX== x && it.sourceY==y)
                {
                    return Position(it.destMapX, it.destMapY);
                }
            }
            /* on ne devrait pas arriver ici, mais, dans le doute, on renvoie
             * par défaut à la première map ;))
             */
            return Position(0,0);
        }
        Postition gamerNextPosition(size_t x, size_t y)
        {
            for(auto it : wraps)
            {
                if(it.sourceX== x && it.sourceY==y)
                {
                    return Position(it.destX, it.destY);
                }
            }
            /* on ne devrait pas arriver ici, mais, dans le doute, on renvoie
             * par défaut à la première map ;))
             */
            return Position(0,0);
        }
};

Tu l'auras sans doute remarqué, c'est toujours la même logique: on boucle sur tous les télé-porteurs connus, et on renvoie la réponse adéquate lorsqu'on le trouve ;)

Ceci dit, au prix de quelques petites évolutions supplémentaires, on pourrait sans doute obtenir quelque chose de plus efficace.

La première concernerait la structure SWrap et la ferait modifier sous la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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;
};

La deuxième se ferait au niveau de SMap, en modifiant std::vector<SWrap> wraps; en std::map<Position, SWrap> wraps;Ces deux modifications impliqueraient, fatalement, une légère modification de loadMap pour lui donner la forme de

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

et, du coup, les fonctions de SMap pourraient ressembler à

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
 
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::vector<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());}
        bool hasTeleportAt(size_t x, size_t y) const
        {
            return wraps.find(Position(x,y) != wraps.end();
        }
        Postition nextMap(size_t x, size_t y)
        {
            auto it = wraps.find(Position(x,y);
            if(it == position.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationMap;
        }
        Postition gamerNextPosition(size_t x, size_t y)
        {
 
            auto it = wraps.find(Position(x,y);
            if(it == position.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationCoordinates;
        }
};

Et voilà le travail :D

Bon, n'hésites pas à demander des informations supplémentaires en cas de besoin, car c'est de nouveau du concentré de génie ;)

11/02/2013, 19h28
devdeb91

Bon si vous me cherchez je serai en train de me pendre :P non mais sérieusement koala la tu ma :pan::zekill: tu me donnes des bouts de code je galère à les comprendre j'arrive à assimiler le tout et même me l'approprier en rajoutant des trucs plus ou moins utiles et la tu me balances un autre code qui vient presque tout remettre en question:aie:. je vais à nouveau regarder tout ça lol

koala pour moi tu est un dieu :hola::hola::hola:
11/02/2013, 21h12
koala01
Citation:

Envoyé par devdeb91

bon si vous me chercher je serai entrain de me pendre :P non mais sérieusement koala la tu ma :pan::zekill:

Ben, je ne fais que travailler en suivant ta logique...

Quand on te dit qu' un projet doit être correctement analysé avant d'écrire les premières lignes de code !!! :D

Si tu avais fait ne serait-ce qu'un semblant d'analyse fonctionnelle (comprends: si tu avais essayé de voir tous les besoins qui découle de la simple phrase "ce serait pas mal de faire un RPG"), tu aurais déjà pu te rendre compte que le fait de disposer d'une carte ne représentait qu'une partie du travail ;)

Lors de ta question précédente, je n'ai travaillé que sur la manière de concevoir "correctement" la carte, et ce que cela impliquait.

Maintenant, tu es confronté à un problème que tu aurais très bien pu anticiper si tu avais travaillé correctement: le fait que tu as un joueur d'un coté et une carte de l'autre, et qu'il faut les faire travailler "de concert" :D

Citation:

tu me donne des bout de code je galere a les comprendre j'arrive a assimiler le tout a meme me l'approprier en rajoutant des truc plus ou moin utile et la tu me balance un autre code qui vient presque tout remettre en question:aie:. je vair a nouveau regarder tout sa lol

D'abord, je ne remet pas TOUT en question: je ne remet que certains aspects spécifiques en question :D

Ensuite, tu as effectivement galéré pour comprendre ce que j'expliquais dans la discussion précédente, mais ce n'est absolument pas perdu:
- Une bonne partie de ce que j'explique ici n'est jamais qu'une adaptation de ce que tu as du assimiler
- Il y a quand même une bonne partie de ce dont on a parlé précédemment qui reste tout à fait valide
- Maintenant que tu t'es approprié ce dont on parlait dans la discussion précédente, tu pourras sans doute le réutiliser "à ton gré" dans d'autres circonstances :D
Finalement, je te rends un énorme service sans même que tu ne t'en aperçoive ;): je te permet d'évoluer à un rythme, peut etre soutenu, mais très facilement acceptable :D

Ne crois pas pas que je me sois agressé d'aucune manière avec ta réponse, j'ai dépassé ce stade depuis longtemps.

Ta réponse était surtout l'occasion d'aborder certains de mes sujets de prédilection :D
11/02/2013, 21h32
devdeb91

Je crois avoir un mal entendu tout ce qui est dit dans le précédent post n'est pas méchamment j’apprécie ton aide et le fait que tu me donnes des codes encore plus dur :lol: ça me renforce sur l'idée que je veux continuer ce projet et ouais je suis un peu :sm: . aussi sache que je m'aperçois des services rendue car au fond c'est exactement ce que je veux faire mais c'est exactement ce que je n'arrive a faire.

Pour finir il est totalement vrai que je suis parti sur le sujet sans trop d'études avant j’avais seulement fait quelque idée du genre une class personnage qui lui est lier une class magie un class objet etc...

Voila donc même si tu le dis dans le précédent post que tu ne t'es pas offensé je tiens à te dire désolé si jamais j'ai mal fait passé le message qui était à la base un grand remerciement pour tout ces explications et codes
11/02/2013, 21h52
Iradrille

Citation:

Envoyé par koala01

Quand on te dit qu' un projet doit être correctement analysé avant d'écrire les premières lignes de code !!! :D

C'est vrai, mais quand on part sur un sujet qu'on ne maîtrise pas vraiment, il peut être assez difficile de prévoir à l'avance comment les choses vont s'organiser.
Alors qu'en codant, on se rend compte assez facilement qu'il faudrait ajouter telle ou telle classe quand on en a besoin.

Et bien que se soit agréable de coder en ayant un diagramme de classe sous les yeux, pour les petits / moyen projets c'est toujours "marrant" de commencer à coder directement.
Ça implique par contre de travailler par itération : implémenter quelque chose puis phase de refactoring, mais ça marche plutôt bien comme technique. :)

C'est comme ne pas faire de différence entre Joueur et Map, pour moi ce n'est pas un problème au début. Si on veut commencer par mettre en place la map, on à pas forcément besoin d'une classe Joueur.
Bien sur il arrivera forcément un moment ou on sera obligé de les séparer, mais ça peut être fait plus tard (par exemple quand on commence à prendre en compte le clavier pour les déplacements).

euh par contre au bout d'un moment tu dis

Citation:

La deuxième se ferait au niveau de SMap, en modifiant std::vector<SWrap> wraps; en std::map<Position, SWrap> wraps;

puis aprés tu met le code suivant

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
 
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::vector<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());}
        bool hasTeleportAt(size_t x, size_t y) const
        {
            return wraps.find(Position(x,y) != wraps.end();
        }
        Postition nextMap(size_t x, size_t y)
        {
            auto it = wraps.find(Position(x,y);
            if(it == position.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationMap;
        }
        Postition gamerNextPosition(size_t x, size_t y)
        {
 
            auto it = wraps.find(Position(x,y);
            if(it == position.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationCoordinates;
        }
};

donc faut il le changer ou pas car dans ton code tu le change pas

Citation:
Envoyé par devdeb91
euh par contre au bout d'un moment tu dis

puis aprés tu met le code suivant
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 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::vector<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());} bool hasTeleportAt(size_t x, size_t y) const { return wraps.find(Position(x,y) != wraps.end(); } Postition nextMap(size_t x, size_t y) { auto it = wraps.find(Position(x,y); if(it == position.end()) // ne devrait pas arriver, mais qui sait { return Position(0,0); } return it->second.destinationMap; } Postition gamerNextPosition(size_t x, size_t y) { auto it = wraps.find(Position(x,y); if(it == position.end()) // ne devrait pas arriver, mais qui sait { return Position(0,0); } return it->second.destinationCoordinates; } };
donc faut il le changer ou pas car dans ton code tu le change pas
Ooops, voila un bel exemple de copier/coller foieux :?

Il faut bel et bien modifier le vector en map sous la forme de
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 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());} bool hasTeleportAt(size_t x, size_t y) const { return wraps.find(Position(x,y) != wraps.end(); } Postition nextMap(size_t x, size_t y) { auto it = wraps.find(Position(x,y); if(it == position.end()) // ne devrait pas arriver, mais qui sait { return Position(0,0); } return it->second.destinationMap; } Postition gamerNextPosition(size_t x, size_t y) { auto it = wraps.find(Position(x,y); if(it == position.end()) // ne devrait pas arriver, mais qui sait { return Position(0,0); } return it->second.destinationCoordinates; } };
Et non, je ne m'étais absolument pas senti agressé par ta réponse, malgré le fait que la mienne ai eu un furieux air de plaidoyer :D

Citation:

Envoyé par Iradrille

C'est vrai, mais quand on part sur un sujet qu'on ne maîtrise pas vraiment, il peut être assez difficile de prévoir à l'avance comment les choses vont s'organiser.

Attention, j'ai parlé d'une analyse fonctionnelle :D

C'est à dire le fait de décrire, de préférence par écrit, les besoins auxquels il faudra répondre.

Le tout en prenant soin de détailler les besoins "complexes" que le texte mets en évidence ;)

Cela peut se faire mentalement, bien sur, mais "les écrits restent" quant aux pensées...

Citation:

Alors qu'en codant, on se rend compte assez facilement qu'il faudrait ajouter telle ou telle classe quand on en a besoin.

A condition d'avoir une certaine tournure d'esprit qu'il n'est franchement pas évident d'acquérir et que l'on n'a pas forcément sur un premier (ou sur un deuxième projet).

Or, cette tournure d'esprit est, justement, stimulée par l'analyse fonctionnelle ;)

Citation:

Et bien que se soit agréable de coder en ayant un diagramme de classe sous les yeux, pour les petits / moyen projets c'est toujours "marrant" de commencer à coder directement.
Ça implique par contre de travailler par itération : implémenter quelque chose puis phase de refactoring, mais ça marche plutôt bien comme technique. :)

... les deux premiers jours, peut etre...

Après, cela devient vite "lassant" et risque de provoquer l'abandon du projet parce que l'on n'arrive décidément pas à "faire ce qu'on veut" et que le projet devient impossible à faire évoluer "comme on veut" :aie:

Citation:

C'est comme ne pas faire de différence entre Joueur et Map, pour moi ce n'est pas un problème au début. Si on veut commencer par mettre en place la map, on à pas forcément besoin d'une classe Joueur.
Bien sur il arrivera forcément un moment ou on sera obligé de les séparer, mais ça peut être fait plus tard (par exemple quand on commence à prendre en compte le clavier pour les déplacements).

Et bien, n'est ce pas ce moment là que j'ai choisi pour parler de la classe joueur :question:

Cependant, le simple fait d'avoir écrit "quelque part" qu'un RPG a pour but de manipuler un joueur à l'intérieur de une (ou plusieurs) carte(s) l'aurait mis en évidence, non :question:

On peut attendre d'avoir besoin du joueur pour l'implémenter, et c'est d'ailleurs ce que "YAGNI" (You Ain't Gonna Need It) nous suggère, mais cela ne veut absolument pas dire que cela ne doit pas être prévu dés le départ ;)

12/02/2013, 09h08
devdeb91
parcontre est grave si j'ai remplacer
Code:

1 2 Postition nextMap(size_t x, size_t y) Postition gamerNextPosition(size_t x, size_t y)
par
Code:

1 2 Postition gamerNextPosition(int x, int y) Postition nextMap(int x, int y)
car position sont constructeur c'est

Code:

Position(int x, int y):x_(x), y_(y){}

donc au compilo il refuser
12/02/2013, 09h24
Médinoc

Ces méthodes devraient être const, au passage.
12/02/2013, 14h30
koala01
Citation:
Envoyé par devdeb91

parcontre est grave si j'ai remplacer

Code:

1 2 Postition nextMap(size_t x, size_t y) Postition gamerNextPosition(size_t x, size_t y)

par

Code:

1 2 Postition gamerNextPosition(int x, int y) Postition nextMap(int x, int y)

car position sont constructeur c'est

Code:

Position(int x, int y):x_(x), y_(y){}

donc au compilo il refuser
En fait, le constructeur de position aurait largement intérêt à utiliser des size_t dans le sens où ce type apporte trois certitudes:
1. Il n'y aura aucune valeur inférieure à 0 car size_t est une valeur non signée
2. Il permet de représenter l'ensemble des adresses mémoires accessibles depuis le système (tu pourrait, par exemple, prévoir une carte de 10 000 000 d'éléments de coté sur un système 32 bits, alors que tu ne pourrais surement pas en faire autant avec un int ;))
3. size_t est le type renvoyé par toutes les fonctions membres des différentes collections de la STL (comme vector, map etc) qui ont trait à la taille de ces collections
@Médinoc >> en effet, ces fonctions devraient être constantes, ca serait beaucoup mieux (je devais être fatigué ;))
12/02/2013, 14h40
devdeb91

Donc en conclusion je vais changer tout les size_t changer en int en size_t ainsi que les int de position en size_t
12/02/2013, 15h08
koala01
En fait, la logique est en réalité toute simple:
1. Si une valeur peut etre négative, tu peux (doit!) utiliser un type signé (int, long, long long, ...) dont la taille permet de représenter au minimum l'ensemble des valeurs qui t'intéressent.
2. Si les valeurs numériques sont susceptibles de ne jamais être négatives, comme ce qui permet de représenter des tailles ou des indexes, l'idéal est d'utiliser size_t afin d'éviter de placer une limite "artificielle" parce que les valeurs sont répartie de part et d'autre de 0
3. Si les valeurs sont destinées à être utilisées avec les résultat de fonctions membres des différentes collections de la STL (size, capacity, etc), size_t est le type renvoyé par ces fonctions, et donc le type à utiliser comme valeurs de références
En gros, il n'y a que pour le déplacement qu'il est utile d'avoir des valeurs négatives (on peut "revenir en arrière" ;))

Tout ce qui se rapporte à Position, à tileAt ou aux tailles des lignes et des colonnes doit utiliser des size_t ;)
12/02/2013, 15h54
devdeb91

Je suis d'accord avec toi et non d'accord a la fois explication :

prenons exemple des jeux d'aujourd'hui beaucoup on une coordonnées x et une y et beaucoup ont intégré un système qui fait que une ligne traverse la carte de gauche a droit et de haut en bas et quand celle ci ce rencontre il estime que c'est le centre de la carte donc y = 0 et x = 0. toujours dans le même cas si on pas la ligne de gauche a droite un coté sera a +x et l'autre -x pareil pour la ligne de haut en bas avec +y et -y donc on aurai pu voir des valeur négative apparaitre si jamais il y avait ces fameuses lignes qui définissent le centre.

mais dans notre cas n'existant pas je suis d'accord sur le fait des valeur strictement positive
12/02/2013, 16h05
Iradrille

Les coordonnées sont souvent des float ou des double aussi.
Mais ce qui compte c'est que dans ton cas tu n'a pas de coordonnées négatives, et tu a des coordonnées entières.
12/02/2013, 16h35
koala01

En fait, le système de coordonnées centrées sur 0,0 est intéressant lorsque tu travailles sur des nodes de type "octree" ou similaire (en gros, ta carte est un arbre de coordonnées dont tu peux prendre un "sous ensemble" qui correspond à la partie à afficher).

C'est utile lorsque tu travaille e vue subjective ou 3D et que la "caméra" représente ta position, car tu n'as jamais besoin d'afficher l'intégralité de la map.

Par contre, dans le cas présent, cela nécessiterait d'avoir des indexes de position (qui, en tant qu'index valent 0, vu que c'est la convention en C++) qui représentent des coordonnées négatives, et, pour obtenir l'index, tu devrais faire une manipulation supplémentaire qui consiste à corriger abscisses et ordonnées d'une valeur correspondantes :aie:

Dans le cas présent, cette solution n'est clairement pas applicable, et le principe Xp, KISS (Keep It simple, Stupid) nous incite largement à l'éviter ;)
12/02/2013, 16h52
devdeb91

bon bah ma théorie est morte :mouarf:
12/02/2013, 17h44
koala01

Citation:

Envoyé par devdeb91

bon bah ma théorie est morte :mouarf:

Non: adaptée :D

Citation:

Envoyé par koala01

Non: adaptée :D

bon j'ai changer ce qui avait a changer mais il est reste 3 errors que malgrés mes recherche je n'y arrive pas a les corriger donc voici les errors si vous pouviez m'aider :

la 1ere je sais que il veut un operator != mais je ne saurais le faire
les 2 autres je sais pas pourquoi

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
C:\Users\kevin\Desktop\jeu2\main.h||In member function 'bool SMap::hasTeleportAt(size_t, size_t) const':|
C:\Users\kevin\Desktop\jeu2\main.h|47|error: no match for 'operator!=' in 'Position(x, y) != ((const SMap*)this)->SMap::wraps.std::map<_Key, _Tp, _Compare, _Alloc>::end<Position, SWrap, std::less<Position>, std::allocator<std::pair<const Position, SWrap> > >()'|
C:\Users\kevin\Desktop\jeu2\main.h|47|note: candidates are:|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\..\..\..\..\include\objbase.h|80|note: BOOL operator!=(const GUID&, const GUID&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\..\..\..\..\include\objbase.h|80|note:   no known conversion for argument 1 from 'Position' to 'const GUID& {aka const _GUID&}'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_multimap.h|829|note: template<class _Key, class _Tp, class _Compare, class _Alloc> bool std::operator!=(const std::multimap<_Key, _Tp, _Compare, _Alloc>&, const std::multimap<_Key, _Tp, _Compare, _Alloc>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_multimap.h|829|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::multimap<_Key, _Tp, _Compare, _Alloc>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_map.h|913|note: template<class _Key, class _Tp, class _Compare, class _Alloc> bool std::operator!=(const std::map<_Key, _Tp, _Compare, _Alloc>&, const std::map<_Key, _Tp, _Compare, _Alloc>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_map.h|913|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::map<_Key, _Tp, _Compare, _Alloc>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_tree.h|883|note: template<class _Key, class _Val, class _KeyOfValue, class _Compare, class _Alloc> bool std::operator!=(const std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&, const std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_tree.h|883|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_tree.h|315|note: template<class _Val> bool std::operator!=(const std::_Rb_tree_iterator<_Tp>&, const std::_Rb_tree_const_iterator<_Val>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_tree.h|315|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::_Rb_tree_iterator<_Tp>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_vector.h|1394|note: template<class _Tp, class _Alloc> bool std::operator!=(const std::vector<_Tp, _Alloc>&, const std::vector<_Tp, _Alloc>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_vector.h|1394|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::vector<_Tp, _Alloc>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\streambuf_iterator.h|212|note: template<class _CharT, class _Traits> bool std::operator!=(const std::istreambuf_iterator<_CharT, _Traits>&, const std::istreambuf_iterator<_CharT, _Traits>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\streambuf_iterator.h|212|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::istreambuf_iterator<_CharT, _Traits>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\basic_string.h|2553|note: template<class _CharT, class _Traits, class _Alloc> bool std::operator!=(const std::basic_string<_CharT, _Traits, _Alloc>&, const _CharT*)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\basic_string.h|2553|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::basic_string<_CharT, _Traits, _Alloc>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\basic_string.h|2541|note: template<class _CharT, class _Traits, class _Alloc> bool std::operator!=(const _CharT*, const std::basic_string<_CharT, _Traits, _Alloc>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\basic_string.h|2541|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   mismatched types 'const _CharT*' and 'Position'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\basic_string.h|2529|note: template<class _CharT, class _Traits, class _Alloc> bool std::operator!=(const std::basic_string<_CharT, _Traits, _Alloc>&, const std::basic_string<_CharT, _Traits, _Alloc>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\basic_string.h|2529|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::basic_string<_CharT, _Traits, _Alloc>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\allocator.h|134|note: template<class _Tp> bool std::operator!=(const std::allocator<_Tp1>&, const std::allocator<_Tp1>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\allocator.h|134|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::allocator<_Tp1>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\allocator.h|129|note: template<class _T1, class _T2> bool std::operator!=(const std::allocator<_T1>&, const std::allocator<_T2>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\allocator.h|129|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::allocator<_T1>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|1051|note: template<class _Iterator> bool std::operator!=(const std::move_iterator<_Iterator>&, const std::move_iterator<_Iterator>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|1051|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::move_iterator<_Iterator>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|1045|note: template<class _IteratorL, class _IteratorR> bool std::operator!=(const std::move_iterator<_IteratorL>&, const std::move_iterator<_IteratorR>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|1045|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::move_iterator<_IteratorL>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|355|note: template<class _IteratorL, class _IteratorR> bool std::operator!=(const std::reverse_iterator<_IteratorL>&, const std::reverse_iterator<_IteratorR>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|355|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::reverse_iterator<_IteratorL>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|305|note: template<class _Iterator> bool std::operator!=(const std::reverse_iterator<_Iterator>&, const std::reverse_iterator<_Iterator>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_iterator.h|305|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::reverse_iterator<_Iterator>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_pair.h|225|note: template<class _T1, class _T2> constexpr bool std::operator!=(const std::pair<_T1, _T2>&, const std::pair<_T1, _T2>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_pair.h|225|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::pair<_T1, _T2>'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\postypes.h|223|note: template<class _StateT> bool std::operator!=(const std::fpos<_StateT>&, const std::fpos<_StateT>&)|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\postypes.h|223|note:   template argument deduction/substitution failed:|
C:\Users\kevin\Desktop\jeu2\main.h|47|note:   'Position' is not derived from 'const std::fpos<_StateT>'|
C:\Users\kevin\Desktop\jeu2\main.h||In member function 'Position SMap::nextMap(size_t, size_t)':|
C:\Users\kevin\Desktop\jeu2\main.h|52|error: expected primary-expression before '.' token|
C:\Users\kevin\Desktop\jeu2\main.h||In member function 'Position SMap::gamerNextPosition(size_t, size_t)':|
C:\Users\kevin\Desktop\jeu2\main.h|62|error: expected primary-expression before '.' token|
C:\Users\kevin\Desktop\jeu2\main.cpp||In function 'int main()':|
C:\Users\kevin\Desktop\jeu2\main.cpp|18|warning: unused variable 'exit' [-Wunused-variable]|
C:\Users\kevin\Desktop\jeu2\main.cpp|19|warning: unused variable 'gamespeed' [-Wunused-variable]|
||=== Build finished: 3 errors, 2 warnings (0 minutes, 3 seconds) ===|

12/02/2013, 20h35
koala01
En fait, si mes souvenirs sont bons, on avait défini l'opérateur == pour le type Position.

Il "suffit" donc de définir l'opérateur != sous la forme de
Code:

1 2 3 4 inline operator != (Position const & first, Position const & second) { return !(first == second); }
Les autres erreurs sont sans doute "simplement" dues à la première (car le compilateur arrête le parsing du fichier dés qu'il trouve une erreur).

Si ce n'est pas le cas, tu n'auras qu'à donner les erreurs qu'ils affiche ;)
12/02/2013, 20h42
devdeb91

Si mes souvenirs sont bons pour les autres on avait défini bool le type donc pourquoi le mettre inline ici ? Quelles seront les différences apportées entre ces deux la ? Faut il revenir sur les type des deux anciens operator ?
12/02/2013, 20h51
Médinoc

Juste une erreur, il faut la déclarer inline bool.
12/02/2013, 21h12
Iradrille

Citation:

Envoyé par devdeb91

si mes souvenir sont bon pour les autres on avait defini bool le type donc pourquoi le mettre inline ici ? quel seront les difference apporter entre ces deux la ? faut il revenir sur les type des deux ancien operator ?

Comme dit Médinoc, déclare la inline bool.

Une fonction inline se déclare et s'utilise comme une fonction, mais le compilo (s'il accepte de la passer inline ^^") va juste recopier le code de la fonction partout ou elle est utilisée.
C'est pratique pour les petites fonctions car un appel de fonction prend du temps, et pour ce genre de fonction, l'appel sera probablement plus long que le traitement effectué par la fonction elle même.
C'est donc un gain de performance gratuit (presque, ça génère un binaire plus gros) et facile à mettre en place.
(Sauf exception c'est un gain de performance, mais dans certains cas, si la fonction est appelé un très grand nombre de fois, on peut avoir une perte de performance)
12/02/2013, 21h13
devdeb91

bon alors j'ai tester avec l'operator mais toujours l'erreur

Code:

C:\Users\kevin\Desktop\jeu2\main.h|48|error: no match for 'operator!=' in 'Position(x, y) != ((const SMap*)this)->SMap::wraps.std::map<_Key, _Tp, _Compare, _Alloc>::end<Position, SWrap, std::less<Position>, std::allocator<std::pair<const Position, SWrap> > >()'|

qui apparait donc je seche la je vois pas ce qui veut
12/02/2013, 21h21
Iradrille

Je dirais que tu compares une Position et un iterator (std::map<Position, SWrap>::iterator).
On peut avoir le morceau de code en question ?

(Probablement un it à remplacer par un it->first)

Voici le bout de code où il trouve l'erreur

Code:

1
2
3
4
 bool hasTeleportAt(size_t x, size_t y) const
        {
            return wraps.find(Position(x,y) != wraps.end(); // c'est ici
        }

Il manque une parenthèse pour ton find :aie:
Code:

1 2 3 4 bool hasTeleportAt(size_t x, size_t y) const { return wraps.find(Position(x,y)) != wraps.end(); // c'est ici }

Bon vu sous cet angle-là je l'admets que ça marche mieux et que c'était une erreur bete :lol: . donc voila comme l'a demandé koala si les 2 autres erreurs persistaient je devais faire des retours donc voici les 2 autres erreurs avec leur code

Code:

C:\Users\kevin\Desktop\jeu2\main.h|53|error: expected primary-expression before '.' token|

Code:

1
2
3
4
5
6
7
8
9
Position nextMap(size_t x, size_t y)
        {
            auto it = wraps.find(Position(x,y));
            if(it == Position.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationMap;
        }

Code:

C:\Users\kevin\Desktop\jeu2\main.h|63|error: expected primary-expression before '.' token|

Code:

1
2
3
4
5
6
7
8
9
10
Position gamerNextPosition(size_t x, size_t y)
        {
 
            auto it = wraps.find(Position(x,y));
            if(it == Position.end()) // ne devrait pas arriver, mais qui sait
            {
                return Position(0,0);
            }
            return it->second.destinationCoordinates;
        }

12/02/2013, 21h45
Iradrille

Position.end() à remplacer par wraps.end()Des erreurs d’inattentions ça :o

(Tu cherches dans la map, et ensuite tu vérifies que le résultat soit valide).
12/02/2013, 21h50
devdeb91

Ah oui maintenant que tu le dis c'est vrai que ça me parait logique je devais être vachement fatigué pour pas remarquer. merci pour les réponses je donne des retours des que j'ai des résultat concluants
12/02/2013, 22h18
koala01

Et moi, vachement fatigué quand je l'ai écrit :aie: :?
12/02/2013, 22h38
devdeb91
D'ailleurs pendant que tu es là tu peux certainement me répondre comment faire pour que ifs>>c puisse lire un espace car quand on fait une map genre
Code:

1 2 3 4 5 ###### # # # # ######
les case blanche il veut pas les lire et les saute aurez tu une idée

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