1 /*****************************************************************************
2 *
3 * Copyright (C) 2003 C�dric Br�gardis <cedric.bregardis@free.fr>
4 *
5 * This file is part of BRIQUOLO
6 *
7 * BRIQUOLO is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * BRIQUOLO is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with BRIQUOLO; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 *****************************************************************************/
22 #include "TableauJeu.h"
23 #include "BonusFast.h"
24 #include "BonusSlow.h"
25 #include "BonusPetit.h"
26 #include "BonusGros.h"
27 #include "BonusPetitPlateau.h"
28 #include "BonusGrosPlateau.h"
29 #include "BonusDoubleBalle.h"
30 #include "BonusSuperPuissance.h"
31 #include "BonusVueSubjective.h"
32 #include "ExplosionBrique.h"
33 #include "BibliothequeSon.h"
34 #include "Option.h"
35 #include <MOGL_Temps.h>
36
TableauJeu(MOGL_Fenetre * p_Fenetre)37 TableauJeu::TableauJeu(MOGL_Fenetre * p_Fenetre)
38 : TableauBase(p_Fenetre), _ProbaBonus(0.2f), _FinTableau(false), _NombreVie(5),
39 _VibrationX(0), _VibrationY(0), _CummulDep(0)
40 {
41 Plateau * _Plateau=new Plateau;
42 _Plateau->SetPosition(20, 1);
43 AjouterPlateau(_Plateau);
44 _Camera=new Camera(_Plateau);
45
46
47 _Univers->SetCamera(_Camera->GetMOGLCamera());
48
49 _TemporisationFinTableau=new MOGL_Temporisation(3, false, false);
50 _TemporisationFinTableau->FinTemporisation.Connecter(this, &TableauJeu::_OnFinTemporisation);
51 _Univers->AjouterElement(_TemporisationFinTableau);
52
53 _TemporisationDepartBalle=new MOGL_Temporisation(3, false, false);
54 _TemporisationDepartBalle->FinTemporisation.Connecter(this, &TableauJeu::_OnDepartBalle);
55 _Univers->AjouterElement(_TemporisationDepartBalle);
56 _NombreVie--;
57 DepartTableau();
58 }
59
~TableauJeu()60 TableauJeu::~TableauJeu()
61 {
62 for(Set_Balle::iterator itBa=_SetBalle.begin(); itBa!=_SetBalle.end(); itBa++)
63 {
64 delete (*itBa);
65 }
66
67 for(Set_Plateau::iterator itPla=_SetPlateau.begin(); itPla!=_SetPlateau.end(); itPla++)
68 {
69 delete (*itPla);
70 }
71
72 for(Set_Bonus::iterator itBo=_SetBonus.begin(); itBo!=_SetBonus.end(); itBo++)
73 {
74 delete (*itBo);
75 }
76
77 Set_Generateur::iterator itGe;
78 for(itGe=_SetGenerateur.begin(); itGe!=_SetGenerateur.end(); itGe++)
79 {
80 _Univers->RetirerElement(*itGe);
81 delete (*itGe);
82 }
83
84 for(itGe=_SetGenerateurADetruire.begin(); itGe!=_SetGenerateurADetruire.end(); itGe++)
85 {
86 _Univers->RetirerElement(*itGe);
87 delete (*itGe);
88 }
89
90 delete _Camera;
91 delete _TemporisationDepartBalle;
92 delete _TemporisationFinTableau;
93 }
94
DepartTableau()95 void TableauJeu::DepartTableau()
96 {
97 _Camera->SetVueSubjective(false);
98 for(Set_Balle::iterator itBa=_SetBalle.begin(); itBa!=_SetBalle.end(); itBa++)
99 {
100 _Univers->RetirerElement((*itBa)->GetElementArbreMOGL());
101 delete (*itBa);
102 }
103 _SetBalle.clear();
104
105 for(Set_Plateau::iterator itPla=_SetPlateau.begin(); itPla!=_SetPlateau.end(); itPla++)
106 {
107 (*itPla)->SetPosition(20, 1);
108
109 (*itPla)->SetTaille(5);
110 }
111
112 if (_NombreVie>=0)
113 {
114 ElementTableau::SetDerniereCollision(NULL, NULL);
115 Balle * balle=new Balle;
116 balle->SetTaille(1.5);
117 AjouterBalle(balle);
118 _BallePartie=false;
119 _TemporisationDepartBalle->Demarrer();
120
121 balle->SetPosition((*_SetPlateau.begin())->GetPositionX(),
122 (*_SetPlateau.begin())->GetPositionY() + (*_SetPlateau.begin())->GetTailleY()/2 + balle->GetRayon());
123 }
124 else
125 {
126 FinBalle.Emettre();
127 }
128 // RAZ du cumul de d�placement
129 _CummulDep = 0;
130 }
131
AjouterBalle(Balle * p_Balle)132 void TableauJeu::AjouterBalle(Balle * p_Balle)
133 {
134 _SetBalle.insert(p_Balle);
135 _Univers->AjouterElement(p_Balle->GetElementArbreMOGL());
136 }
137
RetirerBalle(Balle * p_Balle)138 bool TableauJeu::RetirerBalle(Balle * p_Balle)
139 {
140 Set_Balle::iterator it=_SetBalle.find(p_Balle);
141 if (it!=_SetBalle.end())
142 {
143 _Univers->RetirerElement(p_Balle->GetElementArbreMOGL());
144 delete (*it);
145
146 _SetBalle.erase(it);
147 return true;
148 }
149 else
150 {
151 return false;
152 }
153 }
154
AjouterPlateau(Plateau * p_Plateau)155 void TableauJeu::AjouterPlateau(Plateau * p_Plateau)
156 {
157 p_Plateau->SetMinX(_XMin);
158 p_Plateau->SetMaxX(_XMax);
159
160 _SetPlateau.insert(p_Plateau);
161 _Univers->AjouterElement(p_Plateau->GetElementArbreMOGL());
162 }
163
RetirerPlateau(Plateau * p_Plateau)164 bool TableauJeu::RetirerPlateau(Plateau * p_Plateau)
165 {
166 Set_Plateau::iterator it=_SetPlateau.find(p_Plateau);
167 if (it!=_SetPlateau.end())
168 {
169 _Univers->RetirerElement(p_Plateau->GetElementArbreMOGL());
170 _SetPlateau.erase(it);
171 return true;
172 }
173 else
174 {
175 return false;
176 }
177 }
178
Maj()179 void TableauJeu::Maj()
180 {
181 Set_Balle setBalleADetruire;
182
183 if (!_FinTableau)
184 {
185 // On d�truit les g�n�rateur de particules
186 for(Set_Generateur::iterator itGenerateur=_SetGenerateurADetruire.begin();
187 itGenerateur!=_SetGenerateurADetruire.end();
188 itGenerateur++)
189 {
190 _Univers->RetirerElement(*itGenerateur);
191 delete (*itGenerateur);
192 }
193 _SetGenerateurADetruire.clear();
194
195 // On regarde les bonus pour voir si on en attrape
196 Set_Bonus setBonusADetruire;
197 Set_Bonus::iterator itBonus;
198 for(itBonus=_SetBonus.begin(); itBonus!=_SetBonus.end(); itBonus++)
199 {
200 for(Set_Plateau::iterator itPlat=_SetPlateau.begin(); itPlat!=_SetPlateau.end(); itPlat++)
201 {
202 if ((*itBonus)->Mouvement(*itPlat, this) ||
203 (*itBonus)->GetPositionY()+(*itBonus)->GetTailleY()/2<_YMin)
204 {
205 setBonusADetruire.insert(*itBonus);
206 break;
207 }
208 }
209 }
210 for(itBonus=setBonusADetruire.begin(); itBonus!=setBonusADetruire.end(); itBonus++)
211 {
212 _Univers->RetirerElement((*itBonus)->GetElementArbreMOGL());
213 //delete (*itBonus);
214
215 Set_Bonus::iterator it=_SetBonus.find(*itBonus);
216 if (it!=_SetBonus.end())
217 {
218 delete (*it);
219 _SetBonus.erase(it);
220 }
221 }
222
223 // On fait une mise � jour des �l�ment du tableau
224 for(Set_ElementTableau::iterator itElem=_SetElementTableau.begin(); itElem!=_SetElementTableau.end(); itElem++)
225 {
226 (*itElem)->Maj();
227 }
228
229 // Mise � jour de la vibration
230 _VibrationX -= MOGL_Temps::GetVariationTemps();
231 if (_VibrationX < 0)
232 {
233 _VibrationX = 0;
234 }
235 _VibrationY -= MOGL_Temps::GetVariationTemps();
236 if (_VibrationY < 0)
237 {
238 _VibrationY = 0;
239 }
240 float offx = cosf(_VibrationX * 20000) * 0.2 * _VibrationX;
241 float offy = sinf(_VibrationY * 20000) * 0.2 * _VibrationY;
242 _Camera->SetOffset(offx, offy);
243
244 // On s'occupe de la collision de la balle
245 Set_Balle::iterator itBalle;
246 for(itBalle=_SetBalle.begin(); itBalle!=_SetBalle.end(); itBalle++)
247 {
248 (*itBalle)->MajVitesse();
249 float remainingTime = MOGL_Temps::GetVariationTemps();
250 while (remainingTime>0)
251 {
252 (*itBalle)->SetTempsMax(remainingTime);
253 // #######################
254 // ## On regarde tous les trucs sur lesquels il peut y avoir collision
255 // #######################
256 Struct_Collision collision, collisionTemps;
257
258 collision.TempsCollision=(*itBalle)->GetTempsMax();
259 //ElementTableau * element=NULL;
260 bool collisionElementTableau=false;
261
262 //(*itBalle)->PreparerDeplacement(facteur);
263
264 // On regarde tous les plateaux
265 if (_BallePartie)
266 {
267 for(Set_Plateau::iterator itPlat=_SetPlateau.begin(); itPlat!=_SetPlateau.end(); itPlat++)
268 {
269 if ((*itPlat)->IsDerniereCollisionOk(*itBalle))
270 {
271 collisionTemps=(*itPlat)->TesterCollision(*itBalle);
272 if (collisionTemps.TempsCollision < collision.TempsCollision)
273 {
274 collision=collisionTemps;
275 collisionElementTableau=true;
276 collision.ResponsableCollision = *itPlat;
277 }
278 }
279 }
280 }
281
282 // On regarde les bords
283 collisionTemps=_CollisionBord(*itBalle);
284 if (collisionTemps.TempsCollision < collision.TempsCollision)
285 {
286 collision=collisionTemps;
287 }
288
289 // On regarde tous les �l�ments du tableau
290 for(Set_ElementTableau::iterator itElem=_SetElementTableau.begin(); itElem!=_SetElementTableau.end(); itElem++)
291 {
292 if ((*itElem)->IsDerniereCollisionOk(*itBalle))
293 {
294 collisionTemps=(*itElem)->TesterCollision(*itBalle);
295 if (collisionTemps.TempsCollision < collision.TempsCollision)
296 {
297 collision=collisionTemps;
298 collisionElementTableau=true;
299 collision.ResponsableCollision = *itElem;
300 }
301 }
302 }
303
304 // #######################
305 // Parmis les diff�rentes collisions on regarde cel
306 // #######################
307
308 // MAJ vitesse d�placement des plateaux selon le d�placement
309 // cumul�
310 DeplacerPlateaux(_CummulDep);
311 // RAZ du cumul de d�placement
312 _CummulDep = 0;
313
314 // On d�place les plateaux
315
316 for(Set_Plateau::iterator itPlat=_SetPlateau.begin(); itPlat!=_SetPlateau.end(); itPlat++)
317 {
318 (*itPlat)->Deplacer(collision.TempsCollision);
319 }
320
321 // On d�place la balle
322 (*itBalle)->Deplacer(collision.TempsCollision);
323
324 // La structure de collision indique un temps inf�rieur au temps max de placement.
325 // Cela signifie qu'une collision a eu lieu
326 if (collision.TempsCollision<remainingTime)
327 {
328 // Il y a eu collision
329 // On modifie donc la balle avec les nouveaux param�tres provemenants de la collision
330 //(*itBalle)->SetVitesse(collision.VitesseX, collision.VitesseY);
331
332 // Si c'est un �l�ment on lui dit qu'il a �t� touch�
333 bool detruire=false;
334 if (collisionElementTableau)
335 {
336 detruire=collision.ResponsableCollision->Toucher(*itBalle, collision.TempsCollision);
337 }
338 else
339 {
340 // C'est pas une brique donc on joue le son du rebond standard
341 BibliothequeSon::SonRebond->Jouer(false);
342 }
343
344 // On fait apparaitre un syst�me de particules ?
345 if (collisionElementTableau)
346 {
347 Generateur * generateur=collision.ResponsableCollision->CreerGenerateurParticules();
348 if (generateur!=NULL)
349 {
350 AjouterGenerateur(generateur);
351 }
352 }
353
354 // On stocke ce qui a caus� la collision
355 if (collisionElementTableau)
356 {
357 ElementCollision::SetDerniereCollision(collision.ResponsableCollision, *itBalle);
358 }
359 else
360 {
361 ElementCollision::SetDerniereCollision(NULL, NULL);
362 }
363
364 if (detruire)
365 {
366 // Il faut d�truire l'�l�ment de la collision
367 // On fait apparaitre un bonus ?
368 Point pt = collision.ResponsableCollision->GetVisualCenter();
369 CreerBonus(pt.x, pt.y);
370
371 // On efface l'�l�ment
372 ElementTableau * elem = dynamic_cast<ElementTableau *>(collision.ResponsableCollision);
373 if (elem != NULL)
374 {
375 RetirerElementTableau(elem);
376 }
377 delete collision.ResponsableCollision;
378 }
379
380 if (!detruire || !(*itBalle)->GetSuperPuissance())
381 {
382 (*itBalle)->SetPosition(collision.PositionX, collision.PositionY);
383 (*itBalle)->SetVitesseTotale(collision.VitesseX, collision.VitesseY);
384 (*itBalle)->AddAcceleration(collision.AddFacteurCollision);
385 }
386
387 }
388 else
389 {
390 // Il n'y a pas eu collision
391 //(*itBalle)->SetPosition((*itBalle)->GetArriveeX(), (*itBalle)->GetArriveeY());
392 //(*itBalle)->Deplacer(remainingTime);
393 }
394
395 // On regarde si la balle disparait
396 if ((*itBalle)->GetPositionY()<_YMin)
397 {
398 setBalleADetruire.insert(*itBalle);
399 }
400 remainingTime -= collision.TempsCollision;
401 }
402 }
403
404 for(itBalle=setBalleADetruire.begin(); itBalle!=setBalleADetruire.end(); itBalle++)
405 {
406 RetirerBalle(*itBalle);
407 }
408
409 // On regarde si il reste des �l�ments � d�truire
410 unsigned int nbElemReste=0;
411 for(Set_ElementTableau::iterator itElem2=_SetElementTableau.begin(); itElem2!=_SetElementTableau.end(); itElem2++)
412 {
413 if (!(*itElem2)->EstDecors())
414 {
415 nbElemReste++;
416 }
417 }
418 if (nbElemReste==0)
419 {
420 _FinTableau=true;
421 _TemporisationFinTableau->Demarrer();
422 }
423 if (_SetBalle.size()==0)
424 {
425 _NombreVie--;
426 DepartTableau();
427
428 for(Set_Bonus::iterator itBo=_SetBonus.begin(); itBo!=_SetBonus.end(); itBo++)
429 {
430 _Univers->RetirerElement((*itBo)->GetElementArbreMOGL());
431 delete (*itBo);
432 }
433 _SetBonus.clear();
434
435 }
436 }
437
438 _Camera->Maj();
439 }
440
441
_CollisionBord(Balle * p_Balle)442 Struct_Collision TableauJeu::_CollisionBord(Balle * p_Balle)
443 {
444 Struct_Collision collision;
445 collision.TempsCollision=p_Balle->GetTempsMax();
446 collision.VitesseX=p_Balle->GetVitesseTotaleX();
447 collision.VitesseY=p_Balle->GetVitesseTotaleY();
448 /* collision.VitesseX=p_Balle->GetVitesseX();
449 collision.VitesseY=p_Balle->GetVitesseY();
450 */
451
452 float rayon=p_Balle->GetRayon();
453
454 if (p_Balle->GetPositionX()<_XMin+rayon)// && t<collision.PositionCollision)
455 {
456 collision.TempsCollision=0.5*p_Balle->GetTempsMax();
457 collision.PositionX=_XMin+rayon+0.001;
458 collision.PositionY= p_Balle->GetPositionY();//t*(p_Balle->GetArriveeY()-p_Balle->GetPositionY())+p_Balle->GetPositionY();
459 collision.VitesseX=-p_Balle->GetVitesseTotaleX();
460 collision.VitesseY=p_Balle->GetVitesseTotaleY();
461 }
462
463 // t=(_XMax-rayon-p_Balle->GetPositionX())/(p_Balle->GetArriveeX()-p_Balle->GetPositionX());
464 if (p_Balle->GetPositionX()>_XMax-rayon)// && t<collision.PositionCollision)
465 {
466 collision.TempsCollision=0.5*p_Balle->GetTempsMax();
467 collision.PositionX=_XMax-rayon-0.001;
468 collision.PositionY= p_Balle->GetPositionY(); // t*(p_Balle->GetArriveeY()-p_Balle->GetPositionY())+p_Balle->GetPositionY();
469 collision.VitesseX=-p_Balle->GetVitesseTotaleX();
470 collision.VitesseY=p_Balle->GetVitesseTotaleY();
471 }
472
473 // t=(_YMax-rayon-p_Balle->GetPositionY())/(p_Balle->GetArriveeY()-p_Balle->GetPositionY());
474 if (p_Balle->GetPositionY()>_YMax-rayon)// && t<collision.PositionCollision)
475 {
476 collision.TempsCollision=0.5*p_Balle->GetTempsMax();
477 collision.PositionY=_YMax-rayon;
478 collision.PositionX=p_Balle->GetPositionX(); //t*(p_Balle->GetArriveeX()-p_Balle->GetPositionX())+p_Balle->GetPositionX();
479 collision.VitesseY=-p_Balle->GetVitesseTotaleY();
480 collision.VitesseX=p_Balle->GetVitesseTotaleX();
481 }
482
483 return collision;
484 }
485
DeplacerPlateaux(float p_Distance)486 void TableauJeu::DeplacerPlateaux(float p_Distance)
487 {
488 // On regarde tous les plateaux
489 for(Set_Plateau::iterator itPlat=_SetPlateau.begin(); itPlat!=_SetPlateau.end(); itPlat++)
490 {
491 if (MOGL_Temps::GetVariationTemps() != 0)
492 {
493 (*itPlat)->SetVitesse(p_Distance/MOGL_Temps::GetVariationTemps());
494 }
495 }
496 /*
497 // On d�place les plateaux
498 for(Set_Plateau::iterator itPlat=_SetPlateau.begin(); itPlat!=_SetPlateau.end(); itPlat++)
499 {
500 (*itPlat)->Deplacer(p_Distance);
501 }
502 */
503 }
504
GetSetElementTableau()505 TableauJeu::Set_ElementTableau * TableauJeu::GetSetElementTableau()
506 {
507 return &_SetElementTableau;
508 }
509
GetSetBalle()510 TableauJeu::Set_Balle * TableauJeu::GetSetBalle()
511 {
512 return &_SetBalle;
513 }
514
GetSetPlateau()515 TableauJeu::Set_Plateau * TableauJeu::GetSetPlateau()
516 {
517 return &_SetPlateau;
518 }
519
GetSetBonus()520 TableauJeu::Set_Bonus * TableauJeu::GetSetBonus()
521 {
522 return &_SetBonus;
523 }
524
GetSetGenerateur()525 TableauJeu::Set_Generateur * TableauJeu::GetSetGenerateur()
526 {
527 return &_SetGenerateur;
528 }
529
CreerBonus(float p_X,float p_Y)530 void TableauJeu::CreerBonus(float p_X, float p_Y)
531 {
532 // Il faut d�truire l'�l�ment de la collision
533 // On fait apparaitre un bonus ?
534 if (rand()/static_cast<float>(RAND_MAX)<_ProbaBonus)
535 {
536 Bonus * bonus=_CreerBonus();
537 bonus->SetPosition(p_X, p_Y);
538
539 _SetBonus.insert(bonus);
540 _Univers->AjouterElement(bonus->GetElementArbreMOGL());
541 }
542 }
543
AjouterGenerateur(Generateur * p_Generateur)544 void TableauJeu::AjouterGenerateur(Generateur * p_Generateur)
545 {
546 _SetGenerateur.insert(p_Generateur);
547 p_Generateur->FinGenerateur.Connecter(this, &TableauJeu::OnFinGenerateur);
548 _Univers->AjouterElement(p_Generateur);
549 }
550
OnFinGenerateur(Generateur * p_Generateur)551 void TableauJeu::OnFinGenerateur(Generateur * p_Generateur)
552 {
553 Set_Generateur::iterator it=_SetGenerateur.find(p_Generateur);
554 if (it!=_SetGenerateur.end())
555 {
556 _SetGenerateur.erase(it);
557 }
558 _SetGenerateurADetruire.insert(p_Generateur);
559 }
560
_CreerBonus()561 Bonus * TableauJeu::_CreerBonus()
562 {
563 unsigned int nbBonus=9;
564 float valInd=1.0/nbBonus;
565
566 float al=rand()/static_cast<float>(RAND_MAX);
567 if (al<valInd * 1)
568 {
569 return new BonusDoubleBalle;
570 }
571 if (al<valInd * 2)
572 {
573 return new BonusFast;
574 }
575 if (al<valInd * 3)
576 {
577 return new BonusSlow;
578 }
579 if (al<valInd * 4)
580 {
581 return new BonusPetit;
582 }
583 if (al<valInd * 5)
584 {
585 return new BonusGros;
586 }
587 if (al<valInd * 6)
588 {
589 return new BonusPetitPlateau;
590 }
591 if (al<valInd * 7)
592 {
593 return new BonusGrosPlateau;
594 }
595 if (al<valInd * 8)
596 {
597 return new BonusSuperPuissance;
598 }
599 if (al<valInd * 9)
600 {
601 return new BonusVueSubjective;
602 }
603
604 return new BonusDoubleBalle;
605 }
606
GetCamera()607 Camera * TableauJeu::GetCamera()
608 {
609 return _Camera;
610 }
611
ClavierUp(SDL_keysym * key)612 void TableauJeu::ClavierUp(SDL_keysym * key)
613 {
614 switch (key->sym)
615 {
616 case SDLK_c :
617 {
618 _Camera->ChangerVue();
619 break;
620 }
621 case SDLK_SPACE :
622 {
623 _OnDepartBalle();
624 break;
625 }
626 default:
627 break;
628 }
629 }
630
ClavierDown(SDL_keysym * key)631 void TableauJeu::ClavierDown(SDL_keysym * key)
632 {
633 switch (key->sym)
634 {
635
636 case SDLK_LEFT :
637 {
638 _CummulDep = MOGL_Temps::GetVariationDistance(Option::VitesseClavier.GetValeur() * -10);
639 if (!_BallePartie)
640 {
641 for(Set_Balle::iterator it=_SetBalle.begin(); it!=_SetBalle.end(); it++)
642 {
643 (*it)->SetPosition((*_SetPlateau.begin())->GetPositionX(),
644 (*_SetPlateau.begin())->GetPositionY() + (*_SetPlateau.begin())->GetTailleY()/2 + (*it)->GetRayon());
645 }
646 }
647 break;
648 }
649 case SDLK_RIGHT :
650 {
651 _CummulDep = MOGL_Temps::GetVariationDistance(Option::VitesseClavier.GetValeur() * 10);
652 if (!_BallePartie)
653 {
654 for(Set_Balle::iterator it=_SetBalle.begin(); it!=_SetBalle.end(); it++)
655 {
656 (*it)->SetPosition((*_SetPlateau.begin())->GetPositionX(),
657 (*_SetPlateau.begin())->GetPositionY() + (*_SetPlateau.begin())->GetTailleY()/2 + (*it)->GetRayon());
658 }
659 }
660 break;
661 }
662 default:
663 break;
664 }
665 }
666
DeplacementSouris(SDL_MouseMotionEvent * p_Event)667 void TableauJeu::DeplacementSouris(SDL_MouseMotionEvent * p_Event)
668 {
669 static bool bNotFirstDep = false;
670 if (bNotFirstDep)
671 {
672 int val=p_Event->xrel;
673 _CummulDep += val * Option::VitesseSouris.GetValeur()/50.0;
674 }
675 else
676 {
677 bNotFirstDep = true;
678 _CummulDep = 0;
679 }
680 if (!_BallePartie)
681 {
682 for(Set_Balle::iterator it=_SetBalle.begin(); it!=_SetBalle.end(); it++)
683 {
684 (*it)->SetPosition((*_SetPlateau.begin())->GetPositionX(),
685 (*_SetPlateau.begin())->GetPositionY() +
686 (*_SetPlateau.begin())->GetTailleY()/2 + (*it)->GetRayon());
687 }
688 }
689 }
690
_OnFinTemporisation()691 void TableauJeu::_OnFinTemporisation()
692 {
693 FinTableau.Emettre();
694 _FinTableau=false;
695 }
696
_OnDepartBalle()697 void TableauJeu::_OnDepartBalle()
698 {
699 if (!_BallePartie)
700 {
701 _TemporisationDepartBalle->Arreter();
702 for(Set_Balle::iterator it=_SetBalle.begin(); it!=_SetBalle.end(); it++)
703 {
704 (*it)->SetVitesseTotale(5,35);
705 }
706 _BallePartie=true;
707 }
708 }
709
BoutonSourisDown(SDL_MouseButtonEvent * p_Event)710 void TableauJeu::BoutonSourisDown(SDL_MouseButtonEvent * p_Event)
711 {
712 _OnDepartBalle();
713 }
714
GetNombreVie() const715 int TableauJeu::GetNombreVie() const
716 {
717 return _NombreVie;
718 }
719
SetNombreVie(int p_NombreVie)720 void TableauJeu::SetNombreVie(int p_NombreVie)
721 {
722 _NombreVie=p_NombreVie;
723 }
724
SetVibration(float pVibrationX,float pVibrationY)725 void TableauJeu::SetVibration(float pVibrationX, float pVibrationY)
726 {
727 _VibrationX = pVibrationX;
728 _VibrationY = pVibrationY;
729 }
730