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.

mini rpg c++ le retour

C++

Vue hybride

Discussions similaires

Partager

Partager