dessin de la couleur du joueur qui joue
[quoridor:quoridor.git] / View.cpp
1 // View.cpp\r
2 #include <iostream>\r
3 #\r
4 #include "View.h"\r
5 \r
6 using namespace std;\r
7 \r
8 //mettre un model dans la vue et le controller.\r
9 //transformer le model en singleton.\r
10 //le controller fait un getInstance et la vue le recupere.\r
11 \r
12 // Static non const members must be initialized in the .cpp\r
13 View *View::instance = 0;\r
14 \r
15 void View::redraw()\r
16 {\r
17         glutPostRedisplay(); // rafraichissement de l'affichage\r
18 }\r
19 \r
20 \r
21 View *View::getInstance()\r
22 {\r
23         if (View::instance == 0 )\r
24                 instance = new View();\r
25 \r
26         return instance;\r
27 }\r
28 \r
29 View::View()\r
30 {\r
31         this->model = Model::getInstance();\r
32         this->hauteurP = hauteurPlateau();\r
33         this->largeurP = largeurPlateau();\r
34         this->nbLignes = model->getNbLignes();\r
35         glClearColor(0.5, 0.5, 0.5, 0);\r
36 }\r
37 \r
38 void View::displayPlateau()\r
39 {\r
40 \r
41         int x = TAILLE_CONTOUR;\r
42         int y = TAILLE_CONTOUR + TAILLE_RANGEMENT;\r
43 \r
44         glColor3f(.6, .6, .6);\r
45 \r
46         for (int j=0; j < this->nbLignes; j++){\r
47                 y += TAILLE_GAP;\r
48                 for (int i=0; i < this->nbLignes; i++){\r
49                         x += TAILLE_GAP;\r
50                         glPushMatrix();\r
51                         glTranslatef(x,y,0);\r
52                         dessinerCase();\r
53                         glPopMatrix();\r
54                         x += TAILLE_CARRE;\r
55                 }\r
56                 x = TAILLE_CONTOUR;\r
57                 y += TAILLE_CARRE;\r
58         }\r
59 \r
60         /* Dessine les carrés du rangement. */\r
61         x = TAILLE_CONTOUR;\r
62         y += TAILLE_GAP;\r
63 \r
64         displayRangements(x,y);\r
65 \r
66         y = TAILLE_CONTOUR;\r
67         displayRangements(x,y);\r
68 \r
69 }\r
70 \r
71 void View::dessinerCase(){\r
72         glRectf( 0 , 0 , TAILLE_CARRE, TAILLE_CARRE);\r
73 }\r
74 \r
75 void View::displayPions()\r
76 {\r
77         //Joueur un\r
78         Plateau::Coordonee joueurUn = this->model->getPositionJoueur(JOUEUR_UN);\r
79 \r
80         joueurUn.x = TAILLE_CONTOUR + ((TAILLE_GAP + TAILLE_CARRE) * (joueurUn.x-1)) + (TAILLE_CARRE/2) + TAILLE_GAP;\r
81         joueurUn.y = TAILLE_CONTOUR + TAILLE_RANGEMENT + ((TAILLE_CARRE + TAILLE_GAP) * (joueurUn.y-1)) + (TAILLE_CARRE/2) + TAILLE_GAP;\r
82 \r
83 \r
84         getCouleurJoueurUn();\r
85         GLUquadricObj *pionUn;\r
86         pionUn = gluNewQuadric();\r
87         gluQuadricDrawStyle(pionUn,GLU_FILL);\r
88 \r
89         glPushMatrix();\r
90 \r
91         glTranslatef(joueurUn.x,joueurUn.y, 0);\r
92         gluDisk(pionUn,.0,4.0,30,1);\r
93 \r
94         glPopMatrix();\r
95 \r
96         //Joueur deux\r
97         Plateau::Coordonee joueurDeux = this->model->getPositionJoueur(JOUEUR_DEUX);\r
98 \r
99         joueurDeux.x = TAILLE_CONTOUR + ((TAILLE_GAP + TAILLE_CARRE) * (joueurDeux.x-1)) + (TAILLE_CARRE/2) + TAILLE_GAP;\r
100         joueurDeux.y = TAILLE_CONTOUR + TAILLE_RANGEMENT + ((TAILLE_CARRE + TAILLE_GAP) * (joueurDeux.y-1)) + (TAILLE_CARRE/2) + TAILLE_GAP;\r
101 \r
102         getCouleurJoueurDeux();\r
103         GLUquadricObj *pionDeux;\r
104         pionDeux = gluNewQuadric();\r
105         gluQuadricDrawStyle(pionDeux,GLU_FILL);\r
106 \r
107         glPushMatrix();\r
108 \r
109         glTranslatef(joueurDeux.x,joueurDeux.y, 0);\r
110         gluDisk(pionDeux,.0,4.0,30,1);\r
111 \r
112         glPopMatrix();\r
113 \r
114 \r
115         // ?? gluDeleteQuadric(...) ???\r
116 \r
117 }\r
118 \r
119 void View::displayRangements(int x, int y)\r
120 {\r
121         y += TAILLE_GAP;\r
122         for (int i=0; i < this->nbLignes; i++){\r
123                 x += TAILLE_GAP;\r
124                 glPushMatrix();\r
125                 glTranslatef(x,y,0);\r
126                 glScalef(1.0,2.2,0.0);\r
127                 dessinerCase();\r
128                 glPopMatrix();\r
129                 x += TAILLE_CARRE;\r
130         }\r
131 \r
132 }\r
133 \r
134 void View::displayMursDansRangements()\r
135 {\r
136         int x = TAILLE_CONTOUR ;\r
137         int y = this->hauteurP - TAILLE_CONTOUR - TAILLE_CARRE - TAILLE_CARRE - TAILLE_GAP;\r
138         int nbreBarrieres = model->getNombreBarrieresRestantes(JOUEUR_UN);\r
139         glColor3b(25, 28, 25);\r
140 \r
141         //haut\r
142         for(int i=0; i < nbreBarrieres; i++) {\r
143                 dessinerMur(x,y);\r
144                 x += TAILLE_GAP + TAILLE_CARRE;\r
145         }\r
146 \r
147         //bas\r
148         x = TAILLE_CONTOUR;\r
149         y = TAILLE_CONTOUR + TAILLE_GAP;\r
150 \r
151         nbreBarrieres = model->getNombreBarrieresRestantes(JOUEUR_DEUX);\r
152 \r
153         for (int i=0; i < nbreBarrieres; i++) {\r
154                 dessinerMur(x,y);\r
155                 x+=TAILLE_GAP;\r
156                 x+=TAILLE_CARRE;\r
157         }\r
158 \r
159 \r
160 }\r
161 \r
162 void View::dessinerTriangle() {\r
163 \r
164         glColor3ub(0,0,0);\r
165         glBegin(GL_TRIANGLES);\r
166         glVertex2d(0,0);\r
167         glVertex2d(0,TAILLE_CARRE*2);\r
168         glVertex2d(TAILLE_CARRE*2, 0);\r
169         glEnd();\r
170 \r
171 }\r
172 \r
173 /* Dessine 4 triangles au 4 coins du plateau. */\r
174 void View::displayFancy() {\r
175 \r
176         //supérieur gauche\r
177         glPushMatrix();\r
178 \r
179         glTranslatef(TAILLE_CONTOUR, this->hauteurP-TAILLE_CONTOUR-TAILLE_GAP , 0.0);\r
180         glRotated(180.0,0.0,0.0,1.0);\r
181         dessinerTriangle();\r
182 \r
183         glPopMatrix();\r
184 \r
185         //supérieur droite\r
186         glPushMatrix();\r
187 \r
188         glTranslatef(this->largeurP-TAILLE_CONTOUR, this->hauteurP-TAILLE_CONTOUR-TAILLE_GAP , 0.0);\r
189         glRotated(270,0.0,0.0,1.0);\r
190         dessinerTriangle();\r
191 \r
192         glPopMatrix();\r
193 \r
194         //inférieur gauche\r
195         glPushMatrix();\r
196 \r
197         glTranslatef(TAILLE_CONTOUR, TAILLE_CONTOUR + TAILLE_GAP , 0.0);\r
198         glRotated(90.0,0.0,0.0,1.0);\r
199         dessinerTriangle();\r
200 \r
201         glPopMatrix();\r
202 \r
203         //inférieur droite.\r
204         glPushMatrix();\r
205 \r
206         glTranslatef(this->largeurP-TAILLE_CONTOUR, TAILLE_CONTOUR + TAILLE_GAP, 0.0);\r
207         dessinerTriangle();\r
208 \r
209         glPopMatrix();\r
210 \r
211 }\r
212 \r
213 \r
214 \r
215 /* Définit la viewport contenant le jeu et ses caractéristiques de projection */\r
216 void View::viewportJeu()\r
217 {\r
218 \r
219         glViewport (0, 0, w_global, h_global);\r
220         glMatrixMode(GL_PROJECTION);\r
221         glLoadIdentity();\r
222 \r
223         ratioJeu = ((float) w_global / h_global);\r
224         ratioDessin = ((float) this->largeurP / this->hauteurP);\r
225 \r
226 \r
227         /* Gère la distorsion.\r
228         On vérifie si c'est la hauteur qu'on a augmenté ou la largeur.\r
229         si c'est la hauteur rajouter de l'espace en haut et en bas.\r
230         si c'est la longueur rajouter de l'espace a gauche et a droite.\r
231          */\r
232 \r
233         if(ratioJeu > ratioDessin )\r
234         {\r
235                 gluOrtho2D(0 - ( 0.5 * ((w_global * (float) this->hauteurP/h_global) - this->largeurP) ),\r
236                                 0 + this->largeurP + ( 0.5 * ((w_global * (float) this->hauteurP/h_global) - this->largeurP) ),\r
237                                 0 , 0 + this->hauteurP);\r
238         }\r
239         else\r
240         {\r
241                 gluOrtho2D(0, 0 + this->largeurP, 0 - (0.5 * ((h_global * (float) this->largeurP/w_global) - this->hauteurP)),\r
242                                 0 + this->hauteurP + (0.5 * ((h_global * (float) this->largeurP/w_global) - this->hauteurP)));\r
243         }\r
244 \r
245         glMatrixMode(GL_MODELVIEW);\r
246         glLoadIdentity();\r
247 \r
248 }\r
249 \r
250 /* Calcul la hauteur total de la zone du dessin. */\r
251 int View::hauteurPlateau(){\r
252         int hauteurTotal;\r
253         hauteurTotal = model->getNbLignes()*TAILLE_CARRE + (model->getNbLignes()+1)* TAILLE_GAP; //plateau\r
254         hauteurTotal += TAILLE_RANGEMENT*2; //Rangement des murs\r
255         hauteurTotal += TAILLE_CONTOUR*2; //Contour du plateau\r
256         return hauteurTotal;\r
257 }\r
258 \r
259 /* Calcul la largeur total de la zone du dessin. */\r
260 int View::largeurPlateau(){\r
261         int largeurTotal;\r
262         largeurTotal = model->getNbLignes()*(TAILLE_CARRE+TAILLE_GAP)+TAILLE_GAP; //plateau\r
263         largeurTotal += TAILLE_CONTOUR*2; //Contour du plateau\r
264         return largeurTotal;\r
265 }\r
266 \r
267 void View::viewportBouttons()\r
268 {\r
269         //viewport à partir du coin inférieur gauche\r
270         glViewport (12, 0, w_global-24, 64);\r
271         glMatrixMode(GL_PROJECTION);\r
272         glLoadIdentity();\r
273         gluOrtho2D(-10.0, 10.0, -10.0, 10.0); //zone de dessin.\r
274         glMatrixMode(GL_MODELVIEW);\r
275         glLoadIdentity();\r
276 \r
277 }\r
278 \r
279 \r
280 \r
281 /* Définit le modèle pour affichage à l'écran */\r
282 void View::display(void)\r
283 {\r
284 \r
285         glColor3f(0.5, 0.5, 0.5);\r
286         glClear(GL_COLOR_BUFFER_BIT); \r
287         viewportJeu(); // définit la viewport et la matrice de projection\r
288         glColor3f(1.0, 1.0, 1.0);\r
289         glPushMatrix();\r
290         glRectf(0, 0, this->largeurP, this->hauteurP);\r
291         glPopMatrix();\r
292 \r
293         displayPlateau();\r
294         displayMursDansRangements();\r
295         displayPions();\r
296         displayMurs();\r
297         displayFancy();\r
298         displayMurEnMvmt();\r
299         dessinerJoueurCourrant();\r
300         glutSwapBuffers();\r
301 \r
302 }\r
303 \r
304 void View::displayMurs(){\r
305         int x ;\r
306         int y ;\r
307         int nbLignes = model->getNbLignes();\r
308         glColor3b(25, 28, 25);\r
309 \r
310         for(int i=1; i < nbLignes; i++) {\r
311 \r
312                 for (int j=1; j < nbLignes; j++) {\r
313 \r
314                         if (model->getPlateau()->getTypeMur(j,nbLignes-i) != PAS_MUR){\r
315 \r
316                                 x = xPositionMur(j);\r
317                                 y = yPositionMur(nbLignes-i);\r
318 \r
319                                 if (model->getPlateau()->getTypeMur(j,nbLignes-i) == MUR_HORIZONTAL){\r
320                                         dessinerMurHorizontal(x,y);\r
321                                 }else{\r
322                                         dessinerMur(x,y);\r
323                                 }\r
324                         }\r
325                 }\r
326         }\r
327 }\r
328 \r
329 int View::xPositionMur(int x){\r
330         int xDis = TAILLE_CONTOUR ;\r
331         xDis += x * (TAILLE_CARRE + TAILLE_GAP);\r
332         return xDis;\r
333 }\r
334 \r
335 int View::yPositionMur(int y){\r
336         int yDis = TAILLE_CONTOUR + TAILLE_CARRE + TAILLE_GAP + TAILLE_GAP;\r
337         yDis += y * (TAILLE_CARRE + TAILLE_GAP);\r
338         return yDis;\r
339 }\r
340 \r
341 void View::displayMurEnMvmt(){\r
342         if (model->getMode() == MUR ){\r
343                 Plateau::Coordonee pos = model->getPlateau()->getMur();\r
344                 int x = xPositionMur(pos.x);\r
345                 int y = yPositionMur(pos.y);\r
346                 if (model->getPlateau()->getTypeMur() == MUR_HORIZONTAL){\r
347                         dessinerMurHorizontal(x,y);\r
348                 } else {\r
349                         dessinerMur(x,y);\r
350                 }\r
351         }\r
352 }\r
353 \r
354 void View::dessinerMur(int x, int y){\r
355         glPushMatrix();\r
356         glTranslatef(x,y,0);\r
357         glScalef(.2,2.2,0.0);\r
358         dessinerCase();\r
359         glPopMatrix();\r
360 }\r
361 \r
362 //void View::dessinerMurHorizontal(int x, int y){\r
363 //      glPushMatrix();\r
364 //      glTranslatef(x,y,0);\r
365 //      glRotated(90.0, x+(TAILLE_GAP/2) , y + TAILLE_CARRE + (TAILLE_GAP/2),1.0);\r
366 //      glTranslatef(-(TAILLE_GAP/2),-TAILLE_CARRE-(TAILLE_GAP/2),0);\r
367 //      glScalef(.2,2.2,0.0);\r
368 //      dessinerCase();\r
369 //      glPopMatrix();\r
370 //}\r
371 \r
372 void View::dessinerMurHorizontal(int x, int y){\r
373         glPushMatrix();\r
374 \r
375         glTranslatef(x-TAILLE_CARRE,y+TAILLE_CARRE,0);\r
376         //glRotated(90.0, TAILLE_L_MUR / 2 ,TAILLE_H_MUR / 2 ,1.0);\r
377         glScalef(2.2,.2,0.0);\r
378         dessinerCase();\r
379         glPopMatrix();\r
380 }\r
381 \r
382 \r
383 /* Récupère les dimensions de la fenêtre d'écran */\r
384 void View::reshape(int w, int h)\r
385 {       \r
386         w_global=w;\r
387         h_global=h;\r
388 \r
389 }\r
390 \r
391 /* Définit le contour du jeu pour affichage */\r
392 void dessineContourJeu(){\r
393 \r
394 }\r
395 \r
396 void View::getCouleurJoueurUn(){\r
397         glColor3b(10, 10, 10);\r
398 }\r
399 \r
400 void View::getCouleurJoueurDeux(){\r
401         glColor3ub(255, 0, 0);\r
402 }\r
403 \r
404 void View::dessinerJoueurCourrant(){\r
405         glPushMatrix();\r
406         glColor3ub(255, 0, 0);\r
407         //glTranslatef(this->largeurP-TAILLE_RANGEMENT,this->hauteurP/2,0);\r
408 \r
409         //glScalef(.2,.2,0.0);\r
410         glRasterPos3f(50,50,0);\r
411         glutBitmapCharacter(glutBitmapTimesRoman24, 'r');\r
412 \r
413         //glutStrokeCharacter(glutStrokeMonoRoman,'r');\r
414         //glutStrokeMonoRoman();\r
415         glPopMatrix();\r
416 }\r