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