STL :Probleme du fou echecs , aide sur l'utilisation d'un Map ou autre

**razily** · 30/03/2010, 11h09

Bonjour à tous ,

voilà je suis confronté à un autre problème et notamment sur les pièces à logue portée comme le fou et la reine auxquelles il faut vérifier s'il y a une pièce dans une case avant d'arriver à la case où on veut se déplacer .
je pensais qu'avec un simple vector çà pourrait marcher (c'est ce que j'ai fait pour les pions et et le roi ) mais apparemment notamment pour le fou comme exemple , l'utilisation d'un map semble la solution :
avec un simple vector , j'arrive à trouver les cases valides d'un fou sans tenir compte la présence ou non d'une pièce dans une case :

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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
/************************************************
* deplacement fou 
*************************************************/
 
class Fou:public Piece {
 
		public :
 
 
 
			Fou(int x , int y,int coul , char etiq):Piece(x,y,coul,etiq){};
 
			bool ValiderDeplacement(int x,int y,Piece* Ptr);
 
			int getCouleur();
 
 
 
			};
 
			int Fou::getCouleur(){
				return couleur;
 
				}
 
 
 
 ostream& operator<<(ostream& out,Fou &P1){
		out << "ligne: "<< P1.avoirLigne() << "colonne:"<< P1.avoirColonne() << endl ;
		 return out ;
		}
 
 
   bool Fou::ValiderDeplacement(int x,int y,Piece* Ptr){
				Coordonne temp;
				Coordonne* temp2,*temp3,*temp5;
				int val ;
				bool valide = false ;
				bool trouve = false ;
				int ligne , colonne ;
				Emplacement casesValidesFou;
				Emplacement deplacement;
				vector<Coordonne*>::iterator i;
				vector<Coordonne*>::iterator ii;
				// les vecteurs de directions 
				Coordonne* VecteurFou1 = new Coordonne(-1,1);
				Coordonne* VecteurFou2 = new Coordonne(1,-1);
				Coordonne* VecteurFou3 = new Coordonne(1,1);
				Coordonne* VecteurFou4 = new Coordonne(-1,-1);
 
 
				// on insere dans un vector
 
				casesValidesFou.push_back(VecteurFou1);
				casesValidesFou.push_back(VecteurFou2);
				casesValidesFou.push_back(VecteurFou3);
				casesValidesFou.push_back(VecteurFou4);
 
 
				for(i = casesValidesFou.begin();i!=casesValidesFou.end();i++){
						cout << *i << " " ;
 
					}
 
 
				   i = casesValidesFou.begin();
 
				   while(i!=casesValidesFou.end()){
 
					   if(*i==NULL){
						    cout <<"erreur de creation de vectore roi\n" ;
 
						   }
					   else {
 
 
						   temp = this->Place ;
 
		while(((temp <=8)==0)&&((temp>=1)==0)){
 
				 temp =temp + *i ;
			 temp2 = new Coordonne(temp);
 
		if (((temp <=8)==0)&&((temp>=1)==0)) {
							          deplacement.push_back(temp2);
 
										}
 
							   }
 
 
 
						   }
 
							i++;
					   }
 
 
				  for(i=deplacement.begin(); i!= deplacement.end();i++)
					 {
 
                          cout <<"vector dans deplacement" <<*i <<" " ;
 
						 }
 
				  i=deplacement.begin();
 
				  temp3 = new Coordonne(x,y);
				  val = 0;
				  ii = deplacement.begin();
 
		  while((ii!=deplacement.end())&&(trouve==false)){
 
			  // il faut s'assurer aussi que la case est vide 
 
				   temp5 = *ii;
				   if((*temp3==*temp5)==0){
					   trouve = true;
 
					   }
				   else {
					   ii++;
 
					   }
 
				   }
 
			   val = distance(i,ii);
 
			   cout << "la valeur se trouve a la"<<" " << val <<" " <<  "eme position" << endl;
 
			   if(trouve==true){
				   cout << "deplacement Fou " << endl ;
 
				   cout << "il faut verifier la presence d'une piece de la case "  << endl ;
 
				   cout << "s'il y a il faut s'assurer que ila une couleur differente " << endl ;
 
                       cout << "deplacement vers la ccase " << *temp3 << endl ;
 
				   }
			   else{
                     cout <<"impossible de se deplacer pour le fou "<< endl ;
				   }	
 
 
 
 
 
 
 
				return valide ;
				}

vous avez remarqué que deplacement est un vector
ce code m'affiche çà :

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
 
 
              affichage pion :ligne: 2colonne:2
 
un deplacement vers la case 4 6
ligne: -1       colonne:1
 ligne: 1       colonne:-1
 ligne: 1       colonne:1
 ligne: -1      colonne:-1
 vector dans deplacementligne: 1        colonne:3
 vector dans deplacementligne: 3        colonne:1
 vector dans deplacementligne: 3        colonne:3
 vector dans deplacementligne: 4        colonne:4
 vector dans deplacementligne: 5        colonne:5
 vector dans deplacementligne: 6        colonne:6
 vector dans deplacementligne: 7        colonne:7
 vector dans deplacementligne: 8        colonne:8
 vector dans deplacementligne: 1        colonne:1
 la valeur se trouve a la 9 eme position
impossible de se deplacer pour le fou
la validation de deplacement est0
impossible de se dÚplacer
Appuyez sur une touche pour continuer...

en fait si je resume y a des vecteurs de direction

-1,1) ,(1,-1),(1,1),(-1,-1)
et à chaque vecteur de direction on associe les cases valides

exemple pour un fou (2,2)

Code :

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

1
2
3
4
5
 
(-1,1) -> (1,3)
(1,-1)-> (3,1)
(1,1) -> (3,3) - (4,4) -(5,5) -(6,6) -(7,7) - (8,8)
(-1,-1) -> (1,1)

mais le problème c'est que ce cas peut changer seln la situation
exemple pour un fou (3,4)

Code :

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

1
2
3
4
5
 
(-1,1) -> (2,5) - (1,6)
(1,-1)-> (4,3) -(5,2) -(6,1)
(1,1) -> (4,5) -(5,6) -(6,7)- (7,8)
(-1,-1) -> (2,3) - (1,2)

l'intérêt et l'objectif c'est que si je voulais me déplacer à la case (6,6) cas du fou (2,2) je dois vérifier selon la logique des chose et les rêgles si y a des pièces dans ces cases : (3,3) - (4,4) -(5,5)
le problème avec un vector c'est qu'il rassemble tout donc il se peut qu'il vérifie la case (3,1) ou (1,3) qui n'ont rien avoir :

l'idée qui vient à l'esprit c'est de déclarer un map comme suit au lieu de vector :
map<Coordonne*, Coordonne*> deplacement ;

mais après je ne sais pas trop comment relier comme dans cet exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
map<int, string> Employees;
 
	   // 1) Assignment using array index notation
	   Employees[5234] = "Mike C.";
	   Employees[3374] = "Charlie M.";
	   Employees[1923] = "David D.";
	   Employees[7582] = "John A.";
	   Employees[5328] = "Peter Q.";

et aussi , je pense qu'avec map::find(key). on peut trouver la clé associer et si c'était le cas , comment faire pour parcourir les valeurs associées à cette clé ??

est -ce que le fait de mettre deplacement.begin() ne met pas l'itérator au début même dans une mauvaise clé ??
j'ai vraiment besoin de vos avis et vos aides

toutes suggestions seront toujours les bienvenues

merci d'avance

**bruno_pages** · 30/03/2010, 12h52

Bonjour,

j'ai du mal à comprendre l'intérêt de stoker toutes les possibilités de déplacements de toutes les pièces, car tout devra être recalculé le coup suivant suite au déplacement/disparition/transformation d'une pièce

les positions possibles d'une pièce dépendent de la pièce elle même, il est donc normal que ce vecteur des positions possibles soient liée à une pièce et une seule. Par contre je ne comprends pas non plus pourquoi vous voulez globaliser cela dans une map, vous pouvez soit attacher le vecteur des positions possibles au niveau de chaque pièce, ou au niveau de chaque case (les cases vides ayant un vecteur associé vide)

si malgré tout vous utilisez une map n'est ne sera pas map<Coordonne*, Coordonne*> mais plutôt map<Coordonne*, vector<Coordonne*> >

**koala01** · 30/03/2010, 14h37

Salut,

A vrai dire, pour une pièce comme un fou, il y a quatre sens déplacement possibles:

déplacement en diagonale "avant gauche"
déplacement en diagonale "avant droite"
déplacement en diagonale "arrière gauche"
déplacement en diagonale "arrière droite".

(pour une tour, il y a quatre sens de déplacement adaptée "en ligne droite", et pour la reine, nous arrivons à un total de huit sens de déplacement

).

Il est donc tout à fait possible de déterminer les positions limites qu'une pièce peut atteindre, la raison pour laquelle on ne peut pas aller plus loin (pièce "ennemie", pièce "amie" ou... limite de l'échiquier atteinte) et de se contenter de calculer celles-ci, étant entendu que tu ne pourra provoquer le déplacement que, au mieux, jusqu'à la case ainsi déterminée.

Lorsque tu souhaite vérifier si ta pièce peut accéder à une position donnée, il te "suffit" de vérifier si:

la position à atteindre respecte les règles de déplacement (si elle se trouve, par exemple, effectivement en diagonale par rapport au fou)
la position à atteindre est dans l'espace compris entre la position actuelle et les différentes positions limites (en fait, on pourrait dire "et la position limite adaptée au sens de déplacement qu'occasionne la tentative d'accéder à cette nouvelle position ")
Si l'on peut effectivement aller jusqu'à la position limite, ou si on doit s'arrêtre "juste avant".

De plus, ainsi que Bruno l'a fait remarquer, ce calcul n'est réellement nécessaire que... quand on souhaite déplacer la pièce en question car cela peut occasionner des calculs assez long (on peut devoir tester jusqu'à 21 positions potentielles pour la reine et jusqu'à 14 positions potentielles pour les tours ou les fous) qui seront de toutes façons susceptibles d'être invalidés par n'importe quel déplacement d'une autre pièce.

Tu pourrais donc envisager une énumération proche de

Code :

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

1
2
3
4
5
6
enum eBlocageType
{
    btEnnemi, // la case est occupée par un ennemi
    btAmi, // la case est occupée par un ami
    btLastCase // la case est... la limite du terrain de jeu
};

qui serait utilisée dans une structure représentant les cases extrêmes:

Code :

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

1
2
3
4
5
6
7
struct Extreme
{
    int posX; // position sur l'axe des X
    int posY; // position sur l'axe des Y
    eBlocageType bt; // l'état de la case (AKA la raison pour laquelle c'est
                     // cette case qui est considérée comme extrême)
};

Ta classe Fou pourrait donc 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
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
class Fou()
{
    /* je ne présente ici que ce qui nous intéresse dans notre discussion */
    public:
        void move(int px, int py)
        {
            if(positionAccessible(px,py)
            {
                posx_=px;
                posy_=py;
            }
        }
    private:
        int posx_; // la position actuelle sur l'axe des X
        int posy_; // la position actuelle sur l'axe des Y
        Extreme avg_; // la position extrême de déplacement en avant gauche
        Extreme avd_; // la position extrême de déplacement en avant droite
        Extreme arg_; // la position extrême de déplacement en arrière gauche
        Extreme ard_; // la position extrême de déplacement en arrière droite
        void calculePosExtreme()
        {
            /* détermine les positions extrêmes et la raison du blocage */
        }
        bool positionAccessible(int x, int y) const
        {
            /* le déplacement doit se faire en diagonale */
            int depX=posx_-x;
            int depY=posy_-y;
            bool correct;
           /* le déplacement est envisageable si la valeur absolue de 
            * déplacement sur l'axe des X correspond à 
            * la valeur absolue de déplacement sur l'axe des Y
            */ 
            if(depX==depY)
                correct=true; 
            else if(depX<0)
                correct= (-depX==depY);
            else if(depY<0)
                correct= (-depX==depY);
            /* si ce n'est pas le cas, autant ne pas aller plus loin :P 
             */                
            if(! correct)
                return false;
            /* si on arrive ici, nous pouvons calculer les positions extrêmes
             */
            calculePosExtreme();
            /* une possibilité par sens de déplacement */
            if(depX<0 && depY<0)
            {
                if(arg_.bt==ami)
                    return posx_+depX<arg_.posX;
                else
                    return posx+depX<=arg_.posY;
            }
            if(depX<0 && depY> 0)
            {
                if(avg_.bt==ami)
                    return posx_+depX<avg_.posX;
                else
                    return posx+depX<=avg_.posY;
            }
            if(depX>0 && depY<0)
            {
                if(arg_.bt==ami)
                    return posx_+depX<ard_.posX;
                else
                    return posx+depX<=ard_.posY;
            }
            /* si on arrive ici, depX et depY sont tous les deux égaux 
             *ou supérieursà 0
             */
 
                if(arg_.bt==ami)
                    return posx_+depX<avd_.posX;
                return posx+depX<=arg_.posY;
        }
};

STL :Probleme du fou echecs , aide sur l'utilisation d'un Map ou autre

C++

Discussions similaires

Partager

Partager