mini rpg c++ le retour

**devdeb91** · 10/02/2013, 21h14

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 :

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

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

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

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

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

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 :

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

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

**Médinoc** · 11/02/2013, 15h02

Tu as cette méthode:

Code C++ :

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

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...

**devdeb91** · 11/02/2013, 15h17

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

**Médinoc** · 11/02/2013, 15h27

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 :

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

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...

**devdeb91** · 11/02/2013, 15h32

Étant donné qu'il ont les mêmes paramètres comment le programme va t-il les différencier lors de l'appel ?

**Médinoc** · 11/02/2013, 15h35

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.

**devdeb91** · 11/02/2013, 15h40

Donc si je résume bien si je fais

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

**Médinoc** · 11/02/2013, 16h27

Oui, c'est ça.

**devdeb91** · 11/02/2013, 16h30

Merci je teste ça ce soir et balance les retours

**koala01** · 11/02/2013, 17h47

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 :

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

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

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 :

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

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

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 :

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

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

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

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 :

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

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

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

**devdeb91** · 11/02/2013, 19h28

Bon si vous me cherchez je serai en train de me pendre

non mais sérieusement koala la tu ma

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

. je vais à nouveau regarder tout ça lol

koala pour moi tu est un dieu

**koala01** · 11/02/2013, 21h12

Envoyé par devdeb91

bon si vous me chercher je serai entrain de me pendre

non mais sérieusement koala la tu ma

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 !!!

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"

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

. 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

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

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

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

**devdeb91** · 11/02/2013, 21h32

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

ça me renforce sur l'idée que je veux continuer ce projet et ouais je suis un peu

. 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

**Iradrille** · 11/02/2013, 21h52

Envoyé par koala01

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

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).

**devdeb91** · 11/02/2013, 22h02

euh par contre au bout d'un moment tu dis

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 :

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

**koala01** · 12/02/2013, 08h33

Envoyé par devdeb91

euh par contre au bout d'un moment tu dis

puis aprés tu met le code suivant

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

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

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

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...

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

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"

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

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

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

**devdeb91** · 12/02/2013, 09h08

parcontre est grave si j'ai remplacer

Code :

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

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

par

Code :

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

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

car position sont constructeur c'est

Code :

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

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

donc au compilo il refuser

**Médinoc** · 12/02/2013, 09h24

Ces méthodes devraient être const, au passage.

**koala01** · 12/02/2013, 14h30

Envoyé par devdeb91

parcontre est grave si j'ai remplacer

Code :

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

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

par

Code :

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

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

car position sont constructeur c'est

Code :

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

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:

Il n'y aura aucune valeur inférieure à 0 car size_t est une valeur non signée
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 )
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é

)