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, 16h02
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, 16h17
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, 16h32
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, 16h35
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, 17h27
Médinoc

Oui, c'est ça.
11/02/2013, 17h30
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, 20h28
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, 22h12
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, 22h32
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, 22h52
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, 10h08
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, 10h24
Médinoc

Ces méthodes devraient être const, au passage.
12/02/2013, 15h30
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, 15h40
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

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