Remove every windows CR special characters

src/Balle.cpp

@@ -1,96 +1,96 @@
-#include "Balle.h"
-
-Balle::Balle(int nbRqt)
-:m_nbRqt(nbRqt),
-m_point(RAYON_BALLE,BLEU), m_position(RAYON_FENETRE, RAYON_FENETRE),
- m_trajectoire(rand()-RAND_MAX/2, rand()-RAND_MAX/2), m_vitesse((float)VITESSE_MAX/4), m_centre(RAYON_FENETRE, RAYON_FENETRE)
-
-{
-    //[1] Renplit le tableau de pointeurs
-    for (int i(0); i<NB_JOUEURS_MAX; i++)
-        m_tableauRqt[i]=0;
-
-    //[2] Met la valeur de la trajectoire à 1
-    m_trajectoire.normaliser();
-}///Constructeur
-
-
-void Balle::ajouterRaquette(unsigned int slot, Raquette *ajoutRqt)
-{
-    if (slot >= 0 && slot<NB_JOUEURS_MAX)
-        m_tableauRqt[slot] = ajoutRqt;
-}///ajouterRaquette
-
-bool Balle::bouger(SDL_Surface* screen)
-{
-    //[1] On bouge
-    m_position += m_trajectoire*m_vitesse;
-    if((m_position-m_centre).norme()<=RAYON_TERRAIN)//(m_position-m_centre).norme() est égal à la distance par rapport au centre
-        return true;
-    else
-    //[2] ça sort ou pas ?
-    {
-        //[2.1] Position sur limite
-        m_position = m_centre+(m_position-m_centre).normalise()*(RAYON_TERRAIN-RAYON_BALLE);
-        float angleEcart;
-        bool droite;
-
-        //[2.2] Hum... y a t'il une raquette ?
-        for (int i(0); i<NB_JOUEURS_MAX; i++)
-            if (m_tableauRqt[i]!=0)
-            {
-                angleEcart = (m_position-m_centre).scalair(m_tableauRqt[i]->getAngleActuel());
-                Vecteur tmp(m_position-m_centre);
-                tmp.rotate(5);
-                droite = (tmp.scalair(m_tableauRqt[i]->getAngleActuel())<angleEcart);
-                if (angleEcart<=ANGLE_ECART_RQT)
-                {
-                    m_trajectoire = (m_centre-m_position).normalise();
-                    if (m_vitesse<VITESSE_MAX)
-                        m_vitesse *= ACCELERATEUR;
-                    if(droite)
-                        m_trajectoire.rotate(angleEcart/ANGLE_ECART_RQT*30);
-                    else
-                        m_trajectoire.rotate(-angleEcart/ANGLE_ECART_RQT*30);
-
-                    return true;
-                }
-            }
-
-        //[2.3] Pas raquette... hors zone !
-        camenbertPerdant(screen);
-        m_position = m_centre;
-        m_trajectoire = Vecteur(rand()-RAND_MAX/2, rand()-RAND_MAX/2).normalise();
-        m_vitesse = (float)VITESSE_MAX/4;
-        return false;
-    }
-}///bouger
-
-void Balle::afficher(SDL_Surface* screen)
-{
-    m_point.afficherPoint(screen,m_position.getX(),m_position.getY());
-}///afficher
-
-void Balle::camenbertPerdant(SDL_Surface* screen)
-{
-    SDL_Surface *pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
-    SDL_FillRect(pixel,0,SDL_MapRGB(pixel->format, 255, 0, 0));
-    SDL_Rect pos;
-    for(int y = -RAYON_TERRAIN;y < RAYON_TERRAIN; y++)
-        for(int x = -RAYON_TERRAIN;x < RAYON_TERRAIN; x++)
-        {
-            if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN &&
-               ((m_nbRqt == 2 && y*((m_position.getY()-RAYON_TERRAIN<0)*2-1)<0) ||
-                (m_nbRqt == 3 && ((x-(y*1.75)<0 && ((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN)*1.75<0) && x+(y*1.75)>0 && ((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN)*1.75>0)) ||
-                                  (x*(m_position.getX()-RAYON_FENETRE)>0 && ((x-(y*1.75)>0 && ((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN)*1.75>0) && m_position.getX()-RAYON_FENETRE>0) || (x+(y*1.75)<0 && ((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN)*1.75<0) && m_position.getX()-RAYON_FENETRE<0))))) || // <- n'est pas fini
-                (m_nbRqt == 4 && (x-y)*((((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN))<0)*2-1)<0 && (x+y)*-((((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN))<0)*2-1)>0)))
-            {
-                pos.x = x+RAYON_FENETRE;
-                pos.y = y+RAYON_FENETRE;
-                SDL_BlitSurface(pixel, 0, screen, &pos);
-            }
-        }
-    SDL_Flip(screen);
-    SDL_Delay(200);
-}
-
+#include "Balle.h"
+
+Balle::Balle(int nbRqt)
+:m_nbRqt(nbRqt),
+m_point(RAYON_BALLE,BLEU), m_position(RAYON_FENETRE, RAYON_FENETRE),
+ m_trajectoire(rand()-RAND_MAX/2, rand()-RAND_MAX/2), m_vitesse((float)VITESSE_MAX/4), m_centre(RAYON_FENETRE, RAYON_FENETRE)
+
+{
+    //[1] Renplit le tableau de pointeurs
+    for (int i(0); i<NB_JOUEURS_MAX; i++)
+        m_tableauRqt[i]=0;
+
+    //[2] Met la valeur de la trajectoire à 1
+    m_trajectoire.normaliser();
+}///Constructeur
+
+
+void Balle::ajouterRaquette(unsigned int slot, Raquette *ajoutRqt)
+{
+    if (slot >= 0 && slot<NB_JOUEURS_MAX)
+        m_tableauRqt[slot] = ajoutRqt;
+}///ajouterRaquette
+
+bool Balle::bouger(SDL_Surface* screen)
+{
+    //[1] On bouge
+    m_position += m_trajectoire*m_vitesse;
+    if((m_position-m_centre).norme()<=RAYON_TERRAIN)//(m_position-m_centre).norme() est égal à la distance par rapport au centre
+        return true;
+    else
+    //[2] ça sort ou pas ?
+    {
+        //[2.1] Position sur limite
+        m_position = m_centre+(m_position-m_centre).normalise()*(RAYON_TERRAIN-RAYON_BALLE);
+        float angleEcart;
+        bool droite;
+
+        //[2.2] Hum... y a t'il une raquette ?
+        for (int i(0); i<NB_JOUEURS_MAX; i++)
+            if (m_tableauRqt[i]!=0)
+            {
+                angleEcart = (m_position-m_centre).scalair(m_tableauRqt[i]->getAngleActuel());
+                Vecteur tmp(m_position-m_centre);
+                tmp.rotate(5);
+                droite = (tmp.scalair(m_tableauRqt[i]->getAngleActuel())<angleEcart);
+                if (angleEcart<=ANGLE_ECART_RQT)
+                {
+                    m_trajectoire = (m_centre-m_position).normalise();
+                    if (m_vitesse<VITESSE_MAX)
+                        m_vitesse *= ACCELERATEUR;
+                    if(droite)
+                        m_trajectoire.rotate(angleEcart/ANGLE_ECART_RQT*30);
+                    else
+                        m_trajectoire.rotate(-angleEcart/ANGLE_ECART_RQT*30);
+
+                    return true;
+                }
+            }
+
+        //[2.3] Pas raquette... hors zone !
+        camenbertPerdant(screen);
+        m_position = m_centre;
+        m_trajectoire = Vecteur(rand()-RAND_MAX/2, rand()-RAND_MAX/2).normalise();
+        m_vitesse = (float)VITESSE_MAX/4;
+        return false;
+    }
+}///bouger
+
+void Balle::afficher(SDL_Surface* screen)
+{
+    m_point.afficherPoint(screen,m_position.getX(),m_position.getY());
+}///afficher
+
+void Balle::camenbertPerdant(SDL_Surface* screen)
+{
+    SDL_Surface *pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(pixel,0,SDL_MapRGB(pixel->format, 255, 0, 0));
+    SDL_Rect pos;
+    for(int y = -RAYON_TERRAIN;y < RAYON_TERRAIN; y++)
+        for(int x = -RAYON_TERRAIN;x < RAYON_TERRAIN; x++)
+        {
+            if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN &&
+               ((m_nbRqt == 2 && y*((m_position.getY()-RAYON_TERRAIN<0)*2-1)<0) ||
+                (m_nbRqt == 3 && ((x-(y*1.75)<0 && ((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN)*1.75<0) && x+(y*1.75)>0 && ((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN)*1.75>0)) ||
+                                  (x*(m_position.getX()-RAYON_FENETRE)>0 && ((x-(y*1.75)>0 && ((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN)*1.75>0) && m_position.getX()-RAYON_FENETRE>0) || (x+(y*1.75)<0 && ((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN)*1.75<0) && m_position.getX()-RAYON_FENETRE<0))))) || // <- n'est pas fini
+                (m_nbRqt == 4 && (x-y)*((((m_position.getX()-RAYON_TERRAIN)-(m_position.getY()-RAYON_TERRAIN))<0)*2-1)<0 && (x+y)*-((((m_position.getX()-RAYON_TERRAIN)+(m_position.getY()-RAYON_TERRAIN))<0)*2-1)>0)))
+            {
+                pos.x = x+RAYON_FENETRE;
+                pos.y = y+RAYON_FENETRE;
+                SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+        }
+    SDL_Flip(screen);
+    SDL_Delay(200);
+}
+

src/Balle.h

@@ -1,43 +1,43 @@
-#ifndef BALLE_H_INCLUDED
-#define BALLE_H_INCLUDED
-
-#define ACCELERATEUR 1.1
-#define VITESSE_MAX (COTE/80)
-#define BLEU 2016
-#define NB_JOUEURS_MAX 4
-#define RAYON_BALLE (COTE/80)
-
-///Dernière modif: 25/06/2013 debug angle de frappe
-///Objet: amélioration de la trajectoire aléatoire
-///A faire: Variation d'angle lors de la frappe
-
-#include "main.h"
-
-#include "Raquette.h"
-
-class Balle
-{
-public:
-    Balle(int nbRqt);
-
-    void ajouterRaquette(unsigned int slot, Raquette *ajoutRqt);
-    bool bouger(SDL_Surface* screen);//rebon potentiel, renvoie true quand Ok, false quand hors zone
-    void afficher(SDL_Surface* screen);
-    void camenbertPerdant(SDL_Surface* screen);
-
-protected:
-    //Attributs vectoriels
-    Vecteur m_position;
-    Vecteur m_trajectoire;
-    Vecteur m_centre;
-    float m_vitesse;
-
-    //Attributs images
-    Point m_point;
-
-    //Attributs spécifiques
-    Raquette* m_tableauRqt[NB_JOUEURS_MAX];
-    int const m_nbRqt;
-};
-
-#endif // BALLE_H_INCLUDED
+#ifndef BALLE_H_INCLUDED
+#define BALLE_H_INCLUDED
+
+#define ACCELERATEUR 1.1
+#define VITESSE_MAX (COTE/80)
+#define BLEU 2016
+#define NB_JOUEURS_MAX 4
+#define RAYON_BALLE (COTE/80)
+
+///Dernière modif: 25/06/2013 debug angle de frappe
+///Objet: amélioration de la trajectoire aléatoire
+///A faire: Variation d'angle lors de la frappe
+
+#include "main.h"
+
+#include "Raquette.h"
+
+class Balle
+{
+public:
+    Balle(int nbRqt);
+
+    void ajouterRaquette(unsigned int slot, Raquette *ajoutRqt);
+    bool bouger(SDL_Surface* screen);//rebon potentiel, renvoie true quand Ok, false quand hors zone
+    void afficher(SDL_Surface* screen);
+    void camenbertPerdant(SDL_Surface* screen);
+
+protected:
+    //Attributs vectoriels
+    Vecteur m_position;
+    Vecteur m_trajectoire;
+    Vecteur m_centre;
+    float m_vitesse;
+
+    //Attributs images
+    Point m_point;
+
+    //Attributs spécifiques
+    Raquette* m_tableauRqt[NB_JOUEURS_MAX];
+    int const m_nbRqt;
+};
+
+#endif // BALLE_H_INCLUDED

src/Input.h

@@ -1,127 +1,127 @@
-#ifndef INPUT_H_INCLUDED
-#define INPUT_H_INCLUDED
-
-#include <SDL/SDL.h>
-#undef main
-
-class Input
-{
-public:
-    Input(): m_x(0), m_y(0), m_xRel(0), m_yRel(0), m_continuer(true)
-    {
-        for(int i = 0;i<323;i++)
-            m_touches[i] = false;
-
-        for(int i = 0;i<8;i++)
-            m_boutonsSouris[i] = false;
-    }
-    ~Input()
-    {
-
-    }
-
-    void updateEvenement()
-    {
-        m_xRel = 0;
-        m_yRel = 0;
-
-        while(SDL_PollEvent(&m_evenement))
-        {
-            switch(m_evenement.type)
-            {
-            case SDL_QUIT:
-                m_continuer = false;
-                break;
-
-            case SDL_KEYDOWN:
-                m_touches[m_evenement.key.keysym.sym] = true;
-                break;
-
-            case SDL_KEYUP:
-                m_touches[m_evenement.key.keysym.sym] = false;
-                break;
-
-            case SDL_MOUSEBUTTONDOWN:
-                m_boutonsSouris[m_evenement.button.button] = true;
-                break;
-
-            case SDL_MOUSEBUTTONUP:
-                m_boutonsSouris[m_evenement.button.button] = false;
-                break;
-
-            case SDL_MOUSEMOTION:
-                m_x = m_evenement.motion.x;
-                m_y = m_evenement.motion.y;
-
-                m_xRel = m_evenement.motion.xrel;
-                m_yRel = m_evenement.motion.yrel;
-                break;
-
-            default:
-                break;
-            }
-        }
-    }
-    bool continuer() const
-    {
-        return m_continuer;
-    }
-    bool getTouches(const SDLKey touche) const
-    {
-        return m_touches[touche];
-    }
-    bool getBoutonSouris(const Uint8 bouton) const
-    {
-        return m_boutonsSouris[bouton];
-    }
-    bool mouvementSouris() const
-    {
-        if(m_xRel == 0 && m_yRel == 0)
-            return false;
-
-        else
-            return true;
-    }
-    int getX() const
-    {
-        return m_x;
-    }
-    int getY() const
-    {
-        return m_y;
-    }
-    int getXRel() const
-    {
-        return m_xRel;
-    }
-    int getYRel() const
-    {
-       return m_yRel;
-    }
-    void afficherPointeur(bool reponse) const
-    {
-        if(reponse)
-            SDL_ShowCursor(SDL_ENABLE);
-        else
-            SDL_ShowCursor(SDL_DISABLE);
-    }
-    /*void capturerPointeur(bool reponse) const
-    {
-        if(reponse)
-            SDL_SetRelativeMouseMode(SDL_TRUE);
-        else
-            SDL_SetRelativeMouseMode(SDL_FALSE);
-    }*/
-
-private:
-    SDL_Event m_evenement;
-    bool m_touches[323];
-    bool m_boutonsSouris[8];
-
-    int m_x, m_y;
-    int m_xRel, m_yRel;
-
-    bool m_continuer;
-};
-
-#endif // INPUT_H_INCLUDED
+#ifndef INPUT_H_INCLUDED
+#define INPUT_H_INCLUDED
+
+#include <SDL/SDL.h>
+#undef main
+
+class Input
+{
+public:
+    Input(): m_x(0), m_y(0), m_xRel(0), m_yRel(0), m_continuer(true)
+    {
+        for(int i = 0;i<323;i++)
+            m_touches[i] = false;
+
+        for(int i = 0;i<8;i++)
+            m_boutonsSouris[i] = false;
+    }
+    ~Input()
+    {
+
+    }
+
+    void updateEvenement()
+    {
+        m_xRel = 0;
+        m_yRel = 0;
+
+        while(SDL_PollEvent(&m_evenement))
+        {
+            switch(m_evenement.type)
+            {
+            case SDL_QUIT:
+                m_continuer = false;
+                break;
+
+            case SDL_KEYDOWN:
+                m_touches[m_evenement.key.keysym.sym] = true;
+                break;
+
+            case SDL_KEYUP:
+                m_touches[m_evenement.key.keysym.sym] = false;
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenement.button.button] = true;
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenement.button.button] = false;
+                break;
+
+            case SDL_MOUSEMOTION:
+                m_x = m_evenement.motion.x;
+                m_y = m_evenement.motion.y;
+
+                m_xRel = m_evenement.motion.xrel;
+                m_yRel = m_evenement.motion.yrel;
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+    bool continuer() const
+    {
+        return m_continuer;
+    }
+    bool getTouches(const SDLKey touche) const
+    {
+        return m_touches[touche];
+    }
+    bool getBoutonSouris(const Uint8 bouton) const
+    {
+        return m_boutonsSouris[bouton];
+    }
+    bool mouvementSouris() const
+    {
+        if(m_xRel == 0 && m_yRel == 0)
+            return false;
+
+        else
+            return true;
+    }
+    int getX() const
+    {
+        return m_x;
+    }
+    int getY() const
+    {
+        return m_y;
+    }
+    int getXRel() const
+    {
+        return m_xRel;
+    }
+    int getYRel() const
+    {
+       return m_yRel;
+    }
+    void afficherPointeur(bool reponse) const
+    {
+        if(reponse)
+            SDL_ShowCursor(SDL_ENABLE);
+        else
+            SDL_ShowCursor(SDL_DISABLE);
+    }
+    /*void capturerPointeur(bool reponse) const
+    {
+        if(reponse)
+            SDL_SetRelativeMouseMode(SDL_TRUE);
+        else
+            SDL_SetRelativeMouseMode(SDL_FALSE);
+    }*/
+
+private:
+    SDL_Event m_evenement;
+    bool m_touches[323];
+    bool m_boutonsSouris[8];
+
+    int m_x, m_y;
+    int m_xRel, m_yRel;
+
+    bool m_continuer;
+};
+
+#endif // INPUT_H_INCLUDED

src/Point.h

@@ -1,6 +1,6 @@
-#ifndef POINT_H_INCLUDED
-#define POINT_H_INCLUDED
-
+#ifndef POINT_H_INCLUDED
+#define POINT_H_INCLUDED
+
 ///Modifié le: 10/06/2013
 ///Objet: débuggage, mise en fonction
 
@@ -22,7 +22,7 @@
             Permet d'obtenir le rayon.
 
 */
-
+
 class Point
 {
     public:
@@ -38,5 +38,5 @@ class Point
 
     //Attributs SDL:
     SDL_Surface *m_pixel;
-};
-#endif // POINT_H_INCLUDED
+};
+#endif // POINT_H_INCLUDED

src/Raquette.cpp

@@ -1,84 +1,84 @@
-#include "Raquette.h"
-
-Raquette::Raquette(int identifiant, int nbJoueursTotal, Uint32 couleur):
-    m_identifiant(identifiant),m_centre(COTE/2,COTE/2),
-    m_angleOrigine(0,COTE/2-COTE/36),m_angleEcartMax(180/nbJoueursTotal-(asin((float)RAYON_RQT/RAYON_TERRAIN)*180/M_PI))
-{
-    m_angleOrigine.rotate(360.0/nbJoueursTotal*identifiant);
-    m_angleActuel = m_angleOrigine;
-
-    m_pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
-    SDL_FillRect(m_pixel,0,couleur);
-    m_position = m_centre+m_angleActuel;
-
-}///Constructeur
-
-Raquette::~Raquette()
-{
-    SDL_FreeSurface(m_pixel);
-}///Destructeur
-
-void Raquette::afficher(SDL_Surface* screen)
-{
-    // [1] Balayage des positions
-    SDL_Rect pos;
-    float distanceCentre;
-    for(int y(-RAYON_RQT);y<RAYON_RQT;y++)
-        for(int x(-RAYON_RQT);x<RAYON_RQT;x++)
-        {
-            // [2] Position du point en balayage
-            pos.x = m_position.getX()+x;
-            pos.y = m_position.getY()+y;
-            distanceCentre = (Vecteur(pos.x, pos.y)-m_centre).norme();
-            // [3] Arrondi
-            if(distanceCentre < RAYON_FENETRE && distanceCentre > RAYON_TERRAIN &&
-               x*x+y*y < (RAYON_RQT)*(RAYON_RQT))
-                SDL_BlitSurface(m_pixel, 0, screen, &pos);
-        }
-}///afficher
-
-void Raquette::deplacer(bool droite)
-{
-    // [1] Teste si la raquette a le droit de bouger
-    bool ecart = m_angleActuel.scalair(m_angleOrigine)<=m_angleEcartMax;
-    // [2] On bouge
-    //[2.1] Vers la droite
-    if(droite && ecart)
-    {
-        //[2.1.1]Mouvement
-        m_angleActuel.rotate(VITESSE);
-        //[2.1.2]Pas trop loin !
-        if (m_angleActuel.scalair(m_angleOrigine)>m_angleEcartMax)
-        {
-            Vecteur tmp(m_angleOrigine);
-            tmp.rotate(m_angleEcartMax-0.05);
-            m_angleActuel = tmp;
-        }
-
-    }
-    //[2.2] Ou vers la gauche
-    else if (ecart)
-    {
-        m_angleActuel.rotate(-VITESSE);
-        if (m_angleActuel.scalair(m_angleOrigine)>m_angleEcartMax)
-        {
-            Vecteur tmp(m_angleOrigine);
-            tmp.rotate(-m_angleEcartMax+0.05);
-            m_angleActuel = tmp;
-        }
-    }
-    else
-    {
-        Vecteur tmp(m_angleOrigine);
-        tmp.rotate(-m_angleEcartMax);
-        m_angleActuel = tmp;
-    }
-    // [END]
-    m_position = m_centre+m_angleActuel;
-}///deplacer
-
-Vecteur Raquette::getAngleActuel()
-{
-    return m_angleActuel;
-}///getAngleActuel
-
+#include "Raquette.h"
+
+Raquette::Raquette(int identifiant, int nbJoueursTotal, Uint32 couleur):
+    m_identifiant(identifiant),m_centre(COTE/2,COTE/2),
+    m_angleOrigine(0,COTE/2-COTE/36),m_angleEcartMax(180/nbJoueursTotal-(asin((float)RAYON_RQT/RAYON_TERRAIN)*180/M_PI))
+{
+    m_angleOrigine.rotate(360.0/nbJoueursTotal*identifiant);
+    m_angleActuel = m_angleOrigine;
+
+    m_pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(m_pixel,0,couleur);
+    m_position = m_centre+m_angleActuel;
+
+}///Constructeur
+
+Raquette::~Raquette()
+{
+    SDL_FreeSurface(m_pixel);
+}///Destructeur
+
+void Raquette::afficher(SDL_Surface* screen)
+{
+    // [1] Balayage des positions
+    SDL_Rect pos;
+    float distanceCentre;
+    for(int y(-RAYON_RQT);y<RAYON_RQT;y++)
+        for(int x(-RAYON_RQT);x<RAYON_RQT;x++)
+        {
+            // [2] Position du point en balayage
+            pos.x = m_position.getX()+x;
+            pos.y = m_position.getY()+y;
+            distanceCentre = (Vecteur(pos.x, pos.y)-m_centre).norme();
+            // [3] Arrondi
+            if(distanceCentre < RAYON_FENETRE && distanceCentre > RAYON_TERRAIN &&
+               x*x+y*y < (RAYON_RQT)*(RAYON_RQT))
+                SDL_BlitSurface(m_pixel, 0, screen, &pos);
+        }
+}///afficher
+
+void Raquette::deplacer(bool droite)
+{
+    // [1] Teste si la raquette a le droit de bouger
+    bool ecart = m_angleActuel.scalair(m_angleOrigine)<=m_angleEcartMax;
+    // [2] On bouge
+    //[2.1] Vers la droite
+    if(droite && ecart)
+    {
+        //[2.1.1]Mouvement
+        m_angleActuel.rotate(VITESSE);
+        //[2.1.2]Pas trop loin !
+        if (m_angleActuel.scalair(m_angleOrigine)>m_angleEcartMax)
+        {
+            Vecteur tmp(m_angleOrigine);
+            tmp.rotate(m_angleEcartMax-0.05);
+            m_angleActuel = tmp;
+        }
+
+    }
+    //[2.2] Ou vers la gauche
+    else if (ecart)
+    {
+        m_angleActuel.rotate(-VITESSE);
+        if (m_angleActuel.scalair(m_angleOrigine)>m_angleEcartMax)
+        {
+            Vecteur tmp(m_angleOrigine);
+            tmp.rotate(-m_angleEcartMax+0.05);
+            m_angleActuel = tmp;
+        }
+    }
+    else
+    {
+        Vecteur tmp(m_angleOrigine);
+        tmp.rotate(-m_angleEcartMax);
+        m_angleActuel = tmp;
+    }
+    // [END]
+    m_position = m_centre+m_angleActuel;
+}///deplacer
+
+Vecteur Raquette::getAngleActuel()
+{
+    return m_angleActuel;
+}///getAngleActuel
+

src/Raquette.h

@@ -1,37 +1,37 @@
-#ifndef RAQUETTE_H_INCLUDED
-#define RAQUETTE_H_INCLUDED
-
-#include "main.h"
-
-#define VITESSE 1.5
-#define RAYON_FENETRE (COTE/2)
-#define RAYON_TERRAIN (RAYON_FENETRE-COTE/36)
-#define RAYON_RQT (COTE/12)
-#define ANGLE_ECART_RQT (asin((float)RAYON_RQT/RAYON_TERRAIN)*180/M_PI+1)
-
-class Raquette
-{
-public:
-    Raquette(int identifiant, int nbJoueursTotal, Uint32 couleur);
-    ~Raquette();
-
-    void afficher(SDL_Surface* screen);
-    void deplacer(bool droite);
-    Vecteur getAngleActuel();
-
-private:
-    //Attributs vectoriels
-    Vecteur m_angleActuel;
-    Vecteur m_angleOrigine;
-    Vecteur m_centre;
-    Vecteur m_position;
-
-    //Autres
-    float const m_angleEcartMax;
-    unsigned short m_identifiant;
-
-    //Attributs SDL
-    SDL_Surface *m_pixel;
-};
-
-#endif // RAQUETTE_H_INCLUDED
+#ifndef RAQUETTE_H_INCLUDED
+#define RAQUETTE_H_INCLUDED
+
+#include "main.h"
+
+#define VITESSE 1.5
+#define RAYON_FENETRE (COTE/2)
+#define RAYON_TERRAIN (RAYON_FENETRE-COTE/36)
+#define RAYON_RQT (COTE/12)
+#define ANGLE_ECART_RQT (asin((float)RAYON_RQT/RAYON_TERRAIN)*180/M_PI+1)
+
+class Raquette
+{
+public:
+    Raquette(int identifiant, int nbJoueursTotal, Uint32 couleur);
+    ~Raquette();
+
+    void afficher(SDL_Surface* screen);
+    void deplacer(bool droite);
+    Vecteur getAngleActuel();
+
+private:
+    //Attributs vectoriels
+    Vecteur m_angleActuel;
+    Vecteur m_angleOrigine;
+    Vecteur m_centre;
+    Vecteur m_position;
+
+    //Autres
+    float const m_angleEcartMax;
+    unsigned short m_identifiant;
+
+    //Attributs SDL
+    SDL_Surface *m_pixel;
+};
+
+#endif // RAQUETTE_H_INCLUDED

src/Vecteur.h

@@ -1,263 +1,263 @@
-#ifndef VECTEUR_H_INCLUDED
-#define VECTEUR_H_INCLUDED
-
-#include <cmath>
-
-class Vecteur
-{
-    public:
-
-    Vecteur() : m_x(0.0), m_y(0.0), m_z(0.0)
-    {
-
-    }
-    Vecteur(float x, float y, float z = 0) : m_x(x), m_y(y), m_z(z)
-    {
-
-    }
-    Vecteur(const Vecteur &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
-    {
-
-    }
-    ~Vecteur()
-    {
-
-    }
-    float getX() const
-    {
-        return m_x;
-    }
-
-    float getY() const
-    {
-        return m_y;
-    }
-
-    float getZ() const
-    {
-        return m_z;
-    }
-
-
-    // Setters
-
-    void setVecteur(float x, float y, float z)
-    {
-        m_x = x;
-        m_y = y;
-        m_z = z;
-    }
-
-    void setX(float x)
-    {
-        m_x = x;
-    }
-
-    void setY(float y)
-    {
-        m_y = y;
-    }
-
-    void setZ(float z)
-    {
-        m_z = z;
-    }
-    void normaliser()
-    {
-        // La fonction sqrt() permet de trouver la racine carré d'un nombre
-
-        float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
-
-
-        // Normalisation du vecteur
-
-        if(longueur != 0.0)
-        {
-            m_x /= longueur;
-            m_y /= longueur;
-            m_z /= longueur;
-        }
-    }
-    Vecteur normalise()
-    {
-        // La fonction sqrt() permet de trouver la racine carré d'un nombre
-        Vecteur resultat;
-        float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
-
-
-        // Normalisation du vecteur
-
-        if(longueur != 0.0)
-        {
-            resultat.setX(m_x/longueur);
-            resultat.setY(m_y/longueur);
-            resultat.setZ(m_z/longueur);
-        }
-        return resultat;
-    }
-    Vecteur& operator=(const Vecteur &vecteur)
-    {
-        // Copie des valeurs
-
-        m_x = vecteur.m_x;
-        m_y = vecteur.m_y;
-        m_z = vecteur.m_z;
-
-
-        // Retour de l'objet
-
-        return *this;
-    }
-    Vecteur operator+(const Vecteur &vecteur)
-    {
-        // Création d'un objet résultat
-
-        Vecteur resultat;
-
-
-        // Addition des coordonnées
-
-        resultat.m_x = m_x + vecteur.m_x;
-        resultat.m_y = m_y + vecteur.m_y;
-        resultat.m_z = m_z + vecteur.m_z;
-
-
-        // Retour de résultat
-
-        return resultat;
-    }
-    Vecteur operator-(const Vecteur &vecteur)
-    {
-        // Création d'un objet résultat
-
-        Vecteur resultat;
-
-
-        // Soustraction des coordonnées
-
-        resultat.m_x = m_x - vecteur.m_x;
-        resultat.m_y = m_y - vecteur.m_y;
-        resultat.m_z = m_z - vecteur.m_z;
-
-
-        // Retour de résultat
-
-        return resultat;
-    }
-    Vecteur operator*(float multiplicateur)
-    {
-        // Création d'un objet résultat
-
-        Vecteur resultat;
-
-
-        // Multiplication des coordonnées
-
-        resultat.m_x = m_x * multiplicateur;
-        resultat.m_y = m_y * multiplicateur;
-        resultat.m_z = m_z * multiplicateur;
-
-
-        // Retour du résultat
-
-        return resultat;
-    }
-    Vecteur operator/(float diviseur)
-    {
-        // Création d'un objet résultat
-
-        Vecteur resultat;
-
-
-        // Multiplication des coordonnées
-
-        resultat.m_x = m_x / diviseur;
-        resultat.m_y = m_y / diviseur;
-        resultat.m_z = m_z / diviseur;
-
-
-        // Retour du résultat
-
-        return resultat;
-    }
-    Vecteur operator*(const Vecteur &vecteur)
-    {
-        // Création d'un objet résultat
-
-        Vecteur resultat;
-
-
-        // Produit Vectoriel
-
-        resultat.m_x = (m_y * vecteur.m_z) - (m_z * vecteur.m_y);
-        resultat.m_y = (m_z * vecteur.m_x) - (m_x * vecteur.m_z);
-        resultat.m_z = (m_x * vecteur.m_y) - (m_y * vecteur.m_x);
-
-
-        // Retour de l'objet
-
-        return resultat;
-    }
-    void operator*=(const Vecteur &vecteur)
-    {
-        *this = *this * vecteur;
-    }
-    void operator-=(const Vecteur &vecteur)
-    {
-        *this = *this - vecteur;
-    }
-    void operator+=(const Vecteur &vecteur)
-    {
-        *this = *this + vecteur;
-    }
-    void operator*=(float multiplicateur)
-    {
-        *this = *this * multiplicateur;
-    }
-    void operator/=(float multiplicateur)
-    {
-        *this = *this * multiplicateur;
-    }
-    float scalair(const Vecteur &vecteur)
-    {
-        Vecteur v1(*this), v2(vecteur);
-        v1.normaliser();
-        v2.normaliser();
-        float produitScalair = v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
-        if(produitScalair>1)
-            produitScalair = 1;
-        return acos(produitScalair)*180/M_PI;
-    }
-    bool operator==(const Vecteur &vecteur)
-    {
-        if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
-            return true;
-        else
-            return false;
-    }
-    bool operator!=(const Vecteur &vecteur)
-    {
-        if(*this == vecteur)
-            return false;
-        else
-            return true;
-    }
-    double norme()
-    {
-        return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
-    }
-    void rotate(float angle)
-    {
-        float _angle = angle*M_PI/180;
-        float tmp = m_x;
-        m_x = cos(_angle)*m_x-sin(_angle)*m_y;
-        m_y = sin(_angle)*tmp+cos(_angle)*m_y;
-    }
-
-private:
-    float m_x;
-    float m_y;
-    float m_z;
-};
-
-#endif // VECTEUR_H_INCLUDED
+#ifndef VECTEUR_H_INCLUDED
+#define VECTEUR_H_INCLUDED
+
+#include <cmath>
+
+class Vecteur
+{
+    public:
+
+    Vecteur() : m_x(0.0), m_y(0.0), m_z(0.0)
+    {
+
+    }
+    Vecteur(float x, float y, float z = 0) : m_x(x), m_y(y), m_z(z)
+    {
+
+    }
+    Vecteur(const Vecteur &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
+    {
+
+    }
+    ~Vecteur()
+    {
+
+    }
+    float getX() const
+    {
+        return m_x;
+    }
+
+    float getY() const
+    {
+        return m_y;
+    }
+
+    float getZ() const
+    {
+        return m_z;
+    }
+
+
+    // Setters
+
+    void setVecteur(float x, float y, float z)
+    {
+        m_x = x;
+        m_y = y;
+        m_z = z;
+    }
+
+    void setX(float x)
+    {
+        m_x = x;
+    }
+
+    void setY(float y)
+    {
+        m_y = y;
+    }
+
+    void setZ(float z)
+    {
+        m_z = z;
+    }
+    void normaliser()
+    {
+        // La fonction sqrt() permet de trouver la racine carré d'un nombre
+
+        float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
+
+
+        // Normalisation du vecteur
+
+        if(longueur != 0.0)
+        {
+            m_x /= longueur;
+            m_y /= longueur;
+            m_z /= longueur;
+        }
+    }
+    Vecteur normalise()
+    {
+        // La fonction sqrt() permet de trouver la racine carré d'un nombre
+        Vecteur resultat;
+        float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
+
+
+        // Normalisation du vecteur
+
+        if(longueur != 0.0)
+        {
+            resultat.setX(m_x/longueur);
+            resultat.setY(m_y/longueur);
+            resultat.setZ(m_z/longueur);
+        }
+        return resultat;
+    }
+    Vecteur& operator=(const Vecteur &vecteur)
+    {
+        // Copie des valeurs
+
+        m_x = vecteur.m_x;
+        m_y = vecteur.m_y;
+        m_z = vecteur.m_z;
+
+
+        // Retour de l'objet
+
+        return *this;
+    }
+    Vecteur operator+(const Vecteur &vecteur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Addition des coordonnées
+
+        resultat.m_x = m_x + vecteur.m_x;
+        resultat.m_y = m_y + vecteur.m_y;
+        resultat.m_z = m_z + vecteur.m_z;
+
+
+        // Retour de résultat
+
+        return resultat;
+    }
+    Vecteur operator-(const Vecteur &vecteur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Soustraction des coordonnées
+
+        resultat.m_x = m_x - vecteur.m_x;
+        resultat.m_y = m_y - vecteur.m_y;
+        resultat.m_z = m_z - vecteur.m_z;
+
+
+        // Retour de résultat
+
+        return resultat;
+    }
+    Vecteur operator*(float multiplicateur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Multiplication des coordonnées
+
+        resultat.m_x = m_x * multiplicateur;
+        resultat.m_y = m_y * multiplicateur;
+        resultat.m_z = m_z * multiplicateur;
+
+
+        // Retour du résultat
+
+        return resultat;
+    }
+    Vecteur operator/(float diviseur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Multiplication des coordonnées
+
+        resultat.m_x = m_x / diviseur;
+        resultat.m_y = m_y / diviseur;
+        resultat.m_z = m_z / diviseur;
+
+
+        // Retour du résultat
+
+        return resultat;
+    }
+    Vecteur operator*(const Vecteur &vecteur)
+    {
+        // Création d'un objet résultat
+
+        Vecteur resultat;
+
+
+        // Produit Vectoriel
+
+        resultat.m_x = (m_y * vecteur.m_z) - (m_z * vecteur.m_y);
+        resultat.m_y = (m_z * vecteur.m_x) - (m_x * vecteur.m_z);
+        resultat.m_z = (m_x * vecteur.m_y) - (m_y * vecteur.m_x);
+
+
+        // Retour de l'objet
+
+        return resultat;
+    }
+    void operator*=(const Vecteur &vecteur)
+    {
+        *this = *this * vecteur;
+    }
+    void operator-=(const Vecteur &vecteur)
+    {
+        *this = *this - vecteur;
+    }
+    void operator+=(const Vecteur &vecteur)
+    {
+        *this = *this + vecteur;
+    }
+    void operator*=(float multiplicateur)
+    {
+        *this = *this * multiplicateur;
+    }
+    void operator/=(float multiplicateur)
+    {
+        *this = *this * multiplicateur;
+    }
+    float scalair(const Vecteur &vecteur)
+    {
+        Vecteur v1(*this), v2(vecteur);
+        v1.normaliser();
+        v2.normaliser();
+        float produitScalair = v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
+        if(produitScalair>1)
+            produitScalair = 1;
+        return acos(produitScalair)*180/M_PI;
+    }
+    bool operator==(const Vecteur &vecteur)
+    {
+        if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
+            return true;
+        else
+            return false;
+    }
+    bool operator!=(const Vecteur &vecteur)
+    {
+        if(*this == vecteur)
+            return false;
+        else
+            return true;
+    }
+    double norme()
+    {
+        return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
+    }
+    void rotate(float angle)
+    {
+        float _angle = angle*M_PI/180;
+        float tmp = m_x;
+        m_x = cos(_angle)*m_x-sin(_angle)*m_y;
+        m_y = sin(_angle)*tmp+cos(_angle)*m_y;
+    }
+
+private:
+    float m_x;
+    float m_y;
+    float m_z;
+};
+
+#endif // VECTEUR_H_INCLUDED

src/jeu.cpp

@@ -1,138 +1,138 @@
-#include "jeu.h"
-void tracerLigne(SDL_Surface *screen, int nbJoueurs)
-{
-    SDL_Rect pos;
-    SDL_Surface* pixel;
-    pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
-    SDL_FillRect(pixel, 0, SDL_MapRGB(pixel->format, 255, 255, 255));
-    for(int y = -RAYON_FENETRE; y<RAYON_FENETRE; y++)
-    {
-        for(int x = -RAYON_FENETRE; x<RAYON_FENETRE; x++)
-        {
-            pos.x = x+RAYON_FENETRE;
-            pos.y = y+RAYON_FENETRE;
-            if(nbJoueurs == 2)
-            {
-                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && y>-LARGEUR_LIGNE && y<LARGEUR_LIGNE)
-                    SDL_BlitSurface(pixel, 0, screen, &pos);
-            }
-            else if(nbJoueurs == 3)
-            {
-                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && ((y<0 && x>-LARGEUR_LIGNE && x<LARGEUR_LIGNE) || (y>-COTE/400 && abs(1.75*y)-abs(x)>-LARGEUR_LIGNE*2 && abs(1.75*y)-abs(x)<LARGEUR_LIGNE*2)))
-                    SDL_BlitSurface(pixel, 0, screen, &pos);
-            }
-            else if(nbJoueurs == 4)
-            {
-                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && abs(y)-abs(x)>-LARGEUR_LIGNE && abs(y)-abs(x)<LARGEUR_LIGNE)
-                    SDL_BlitSurface(pixel, 0, screen, &pos);
-            }
-        }
-    }
-}
-int jeu(SDL_Surface *screen,int const nbJoueurs)
-{
-    // [1] Préparation des composants
+#include "jeu.h"
+void tracerLigne(SDL_Surface *screen, int nbJoueurs)
+{
+    SDL_Rect pos;
+    SDL_Surface* pixel;
+    pixel = SDL_CreateRGBSurface(SDL_HWSURFACE, 1, 1, 32, 0, 0, 0, 0);
+    SDL_FillRect(pixel, 0, SDL_MapRGB(pixel->format, 255, 255, 255));
+    for(int y = -RAYON_FENETRE; y<RAYON_FENETRE; y++)
+    {
+        for(int x = -RAYON_FENETRE; x<RAYON_FENETRE; x++)
+        {
+            pos.x = x+RAYON_FENETRE;
+            pos.y = y+RAYON_FENETRE;
+            if(nbJoueurs == 2)
+            {
+                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && y>-LARGEUR_LIGNE && y<LARGEUR_LIGNE)
+                    SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+            else if(nbJoueurs == 3)
+            {
+                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && ((y<0 && x>-LARGEUR_LIGNE && x<LARGEUR_LIGNE) || (y>-COTE/400 && abs(1.75*y)-abs(x)>-LARGEUR_LIGNE*2 && abs(1.75*y)-abs(x)<LARGEUR_LIGNE*2)))
+                    SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+            else if(nbJoueurs == 4)
+            {
+                if(x*x+y*y<RAYON_TERRAIN*RAYON_TERRAIN && abs(y)-abs(x)>-LARGEUR_LIGNE && abs(y)-abs(x)<LARGEUR_LIGNE)
+                    SDL_BlitSurface(pixel, 0, screen, &pos);
+            }
+        }
+    }
+}
+int jeu(SDL_Surface *screen,int const nbJoueurs)
+{
+    // [1] Préparation des composants
     //[1.1] Objets pratiques
-    Uint32 tempsPrecedent(0);
-    bool continuer(true);
-
-    //[1.2] La surface point
-    SDL_Surface* arene(0);
-    arene = SDL_CreateRGBSurface(SDL_HWSURFACE, COTE, COTE, 32, 0, 0, 0, 0);
-    Point point(COTE/2,SDL_MapRGB(screen->format,0,0,255));
-    Point point2(COTE/2-COTE/36,SDL_MapRGB(screen->format,30,200,10));
-    point.afficherPoint(arene, COTE/2, COTE/2);
-    point2.afficherPoint(arene, COTE/2, COTE/2);
-    tracerLigne(arene, nbJoueurs);
-
-    //[1.2] Raquettes
-    Raquette *tabRaquette[nbJoueurs];
-    for(int i(0); i<nbJoueurs; i++)
-        tabRaquette[i] = new Raquette(i, nbJoueurs, SDL_MapRGB(screen->format, 255, 0, 0));
-
-    //[1.3] La balle
-    Balle baballe(nbJoueurs);
-    Balle baballe2(nbJoueurs);
-    for (int i(0); i<nbJoueurs; i++)
-        baballe.ajouterRaquette(i,tabRaquette[i]);
-    if(nbJoueurs == 4)
-        for (int i(0); i<nbJoueurs; i++)
+    Uint32 tempsPrecedent(0);
+    bool continuer(true);
+
+    //[1.2] La surface point
+    SDL_Surface* arene(0);
+    arene = SDL_CreateRGBSurface(SDL_HWSURFACE, COTE, COTE, 32, 0, 0, 0, 0);
+    Point point(COTE/2,SDL_MapRGB(screen->format,0,0,255));
+    Point point2(COTE/2-COTE/36,SDL_MapRGB(screen->format,30,200,10));
+    point.afficherPoint(arene, COTE/2, COTE/2);
+    point2.afficherPoint(arene, COTE/2, COTE/2);
+    tracerLigne(arene, nbJoueurs);
+
+    //[1.2] Raquettes
+    Raquette *tabRaquette[nbJoueurs];
+    for(int i(0); i<nbJoueurs; i++)
+        tabRaquette[i] = new Raquette(i, nbJoueurs, SDL_MapRGB(screen->format, 255, 0, 0));
+
+    //[1.3] La balle
+    Balle baballe(nbJoueurs);
+    Balle baballe2(nbJoueurs);
+    for (int i(0); i<nbJoueurs; i++)
+        baballe.ajouterRaquette(i,tabRaquette[i]);
+    if(nbJoueurs == 4)
+        for (int i(0); i<nbJoueurs; i++)
             baballe2.ajouterRaquette(i,tabRaquette[i]);
 
-    // [2] Program main loop
-    Input input;
+    // [2] Program main loop
+    Input input;
     bool pause = true, p = true;
     while (continuer && !input.getTouches(SDLK_ESCAPE))
-    {
-        //baballe.camenbertPerdant(screen);
-        // [2.1] Gestion des evenement
-        input.updateEvenement();
-        continuer = input.continuer();
-        if(nbJoueurs == 2)
-        {
-            if (input.getTouches(SDLK_v))
-                tabRaquette[0]->deplacer(false);
-            if (input.getTouches(SDLK_x))
-                tabRaquette[0]->deplacer(true);
-            if (input.getTouches(SDLK_RIGHT))
-                tabRaquette[1]->deplacer(true);
-            if (input.getTouches(SDLK_LEFT))
-                tabRaquette[1]->deplacer(false);
-        }
-        if(nbJoueurs == 3)
-        {
-            if (input.getTouches(SDLK_v))
-                tabRaquette[0]->deplacer(false);
-            if (input.getTouches(SDLK_x))
-                tabRaquette[0]->deplacer(true);
-            if (input.getTouches(SDLK_q))
-                tabRaquette[1]->deplacer(true);
-            if (input.getTouches(SDLK_a))
-                tabRaquette[1]->deplacer(false);
-            if (input.getTouches(SDLK_KP3))
-                tabRaquette[2]->deplacer(true);
-            if (input.getTouches(SDLK_KP6))
-                tabRaquette[2]->deplacer(false);
-        }
-        if(nbJoueurs == 4)
-        {
-            if (input.getTouches(SDLK_v))
-                tabRaquette[0]->deplacer(false);
-            if (input.getTouches(SDLK_x))
-                tabRaquette[0]->deplacer(true);
-            if (input.getTouches(SDLK_q))
-                tabRaquette[1]->deplacer(true);
-            if (input.getTouches(SDLK_a))
-                tabRaquette[1]->deplacer(false);
-            if (input.getTouches(SDLK_RIGHT))
-                tabRaquette[2]->deplacer(true);
-            if (input.getTouches(SDLK_LEFT))
-                tabRaquette[2]->deplacer(false);
-            if (input.getTouches(SDLK_KP3))
-                tabRaquette[3]->deplacer(true);
-            if (input.getTouches(SDLK_KP6))
-                tabRaquette[3]->deplacer(false);
-        }
-
-        if(input.getTouches(SDLK_SPACE) && p)
-        {
-            pause = true;
-            p = false;
-        }
-        else if(!input.getTouches(SDLK_SPACE))
+    {
+        //baballe.camenbertPerdant(screen);
+        // [2.1] Gestion des evenement
+        input.updateEvenement();
+        continuer = input.continuer();
+        if(nbJoueurs == 2)
+        {
+            if (input.getTouches(SDLK_v))
+                tabRaquette[0]->deplacer(false);
+            if (input.getTouches(SDLK_x))
+                tabRaquette[0]->deplacer(true);
+            if (input.getTouches(SDLK_RIGHT))
+                tabRaquette[1]->deplacer(true);
+            if (input.getTouches(SDLK_LEFT))
+                tabRaquette[1]->deplacer(false);
+        }
+        if(nbJoueurs == 3)
+        {
+            if (input.getTouches(SDLK_v))
+                tabRaquette[0]->deplacer(false);
+            if (input.getTouches(SDLK_x))
+                tabRaquette[0]->deplacer(true);
+            if (input.getTouches(SDLK_q))
+                tabRaquette[1]->deplacer(true);
+            if (input.getTouches(SDLK_a))
+                tabRaquette[1]->deplacer(false);
+            if (input.getTouches(SDLK_KP3))
+                tabRaquette[2]->deplacer(true);
+            if (input.getTouches(SDLK_KP6))
+                tabRaquette[2]->deplacer(false);
+        }
+        if(nbJoueurs == 4)
+        {
+            if (input.getTouches(SDLK_v))
+                tabRaquette[0]->deplacer(false);
+            if (input.getTouches(SDLK_x))
+                tabRaquette[0]->deplacer(true);
+            if (input.getTouches(SDLK_q))
+                tabRaquette[1]->deplacer(true);
+            if (input.getTouches(SDLK_a))
+                tabRaquette[1]->deplacer(false);
+            if (input.getTouches(SDLK_RIGHT))
+                tabRaquette[2]->deplacer(true);
+            if (input.getTouches(SDLK_LEFT))
+                tabRaquette[2]->deplacer(false);
+            if (input.getTouches(SDLK_KP3))
+                tabRaquette[3]->deplacer(true);
+            if (input.getTouches(SDLK_KP6))
+                tabRaquette[3]->deplacer(false);
+        }
+
+        if(input.getTouches(SDLK_SPACE) && p)
+        {
+            pause = true;
+            p = false;
+        }
+        else if(!input.getTouches(SDLK_SPACE))
             p = true;
 
-        // [3] Calcul
-        baballe.bouger(screen);
-        //if(nbJoueurs == 4)
+        // [3] Calcul
+        baballe.bouger(screen);
+        //if(nbJoueurs == 4)
             //baballe2.bouger(screen);
 
-        // [4] Dessin
-        SDL_BlitSurface(arene, 0, screen, 0);
-        for(int i(0); i<nbJoueurs; i++)
-            tabRaquette[i]->afficher(screen);
-        baballe.afficher(screen);
-        if(nbJoueurs == 4)
+        // [4] Dessin
+        SDL_BlitSurface(arene, 0, screen, 0);
+        for(int i(0); i<nbJoueurs; i++)
+            tabRaquette[i]->afficher(screen);
+        baballe.afficher(screen);
+        if(nbJoueurs == 4)
             baballe2.afficher(screen);
 
         SDL_Flip(screen);
@@ -140,32 +140,32 @@ int jeu(SDL_Surface *screen,int const nbJoueurs)
         //[5] Gestion du temps
         while (15>SDL_GetTicks()-tempsPrecedent || pause)
         {
-            //ça bloque pendant 30 ms moins le temps de calcul
-            if(pause)
-            {
-                input.updateEvenement();
-                if(input.getTouches(SDLK_SPACE) && p)
-                {
-                    pause = false;
-                    p = false;
-                }
-                else if(!input.getTouches(SDLK_SPACE))
-                    p = true;
-                if(!input.continuer() || input.getTouches(SDLK_ESCAPE))
-                {
-                    continuer = false;
-                    break;
-                }
+            //ça bloque pendant 30 ms moins le temps de calcul
+            if(pause)
+            {
+                input.updateEvenement();
+                if(input.getTouches(SDLK_SPACE) && p)
+                {
+                    pause = false;
+                    p = false;
+                }
+                else if(!input.getTouches(SDLK_SPACE))
+                    p = true;
+                if(!input.continuer() || input.getTouches(SDLK_ESCAPE))
+                {
+                    continuer = false;
+                    break;
+                }
             }
         }
         tempsPrecedent=SDL_GetTicks();
 
     } ///Boucle évenementielle
 
-    // [6] Nettoyage
-    for(int i(0); i<nbJoueurs; i++)
+    // [6] Nettoyage
+    for(int i(0); i<nbJoueurs; i++)
         delete tabRaquette[i];
-
-    // [END] Renvoi
-    return 0;
-}
+
+    // [END] Renvoi
+    return 0;
+}

src/jeu.h

@@ -1,16 +1,16 @@
-#ifndef JEU_H_INCLUDED
-#define JEU_H_INCLUDED
-
-///Dernière modif:
-///Objet:
-
-#include "main.h"
-
-#include "Raquette.h"
-#include "Balle.h"
-
-#define LARGEUR_LIGNE COTE/160
-
-int jeu(SDL_Surface *screen,int const nbJoueurs);
-
-#endif // JEU_H_INCLUDED
+#ifndef JEU_H_INCLUDED
+#define JEU_H_INCLUDED
+
+///Dernière modif:
+///Objet:
+
+#include "main.h"
+
+#include "Raquette.h"
+#include "Balle.h"
+
+#define LARGEUR_LIGNE COTE/160
+
+int jeu(SDL_Surface *screen,int const nbJoueurs);
+
+#endif // JEU_H_INCLUDED

src/main.cpp

@@ -1,30 +1,30 @@
-#include "main.h"
-
+#include "main.h"
+
 #include "jeu.h"
 
 
 int main ( int argc, char** argv )
-{
-    std::cout << "-+°, PONG CIRCLE ,°+-" << std::endl;
-    std::cout << "plain ecran? ( 1 oui / 0 non ) : ";
-    bool fullScreen;
-    std::cin >> fullScreen;
-    int nbJoueurs;
-    std::cout << "Entrez le nombre de joueurs (2/3/4) : ";
-    std::cin >> nbJoueurs;
-    if(nbJoueurs < 2)
-        nbJoueurs = 2;
-    if(nbJoueurs > 4)
-        nbJoueurs = 4;
-    std::cout << "pause : espace ( le jeu demarre en pause )" << std::endl;
-    if(nbJoueurs == 2)
-        std::cout << "joueur1 (BAS) : x/v\njoueur2 (HAUT): " << char(27) << "/" << char(26) << std::endl;
-    if(nbJoueurs == 3)
-        std::cout << "joueur1 (BAS)   : x/v\njoueur2 (GAUCHE): a/q\njoueur3 (DROITE): 6/3" << std::endl;
-    if(nbJoueurs == 4)
-        std::cout << "joueur1 (BAS)   : x/v\njoueur2 (GAUCHE): a/q\njoueur3 (HAUT)  : " << char(27) << "/" << char(26) << "\njoueur4 (DROITE): 6/3" << std::endl;
-
-    system("PAUSE");
+{
+    std::cout << "-+°, PONG CIRCLE ,°+-" << std::endl;
+    std::cout << "plain ecran? ( 1 oui / 0 non ) : ";
+    bool fullScreen;
+    std::cin >> fullScreen;
+    int nbJoueurs;
+    std::cout << "Entrez le nombre de joueurs (2/3/4) : ";
+    std::cin >> nbJoueurs;
+    if(nbJoueurs < 2)
+        nbJoueurs = 2;
+    if(nbJoueurs > 4)
+        nbJoueurs = 4;
+    std::cout << "pause : espace ( le jeu demarre en pause )" << std::endl;
+    if(nbJoueurs == 2)
+        std::cout << "joueur1 (BAS) : x/v\njoueur2 (HAUT): " << char(27) << "/" << char(26) << std::endl;
+    if(nbJoueurs == 3)
+        std::cout << "joueur1 (BAS)   : x/v\njoueur2 (GAUCHE): a/q\njoueur3 (DROITE): 6/3" << std::endl;
+    if(nbJoueurs == 4)
+        std::cout << "joueur1 (BAS)   : x/v\njoueur2 (GAUCHE): a/q\njoueur3 (HAUT)  : " << char(27) << "/" << char(26) << "\njoueur4 (DROITE): 6/3" << std::endl;
+
+    system("PAUSE");
 
     // [1] Initialisation de la SDL
     if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
@@ -33,25 +33,25 @@ int main ( int argc, char** argv )
         return 1;
     }
     atexit(SDL_Quit);
-    SDL_Surface *screen;
+    SDL_Surface *screen;
     if(fullScreen)
-        screen = SDL_SetVideoMode(COTE, COTE, 32,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
+        screen = SDL_SetVideoMode(COTE, COTE, 32,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
     else
-        screen = SDL_SetVideoMode(COTE, COTE, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
+        screen = SDL_SetVideoMode(COTE, COTE, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
 
     if ( !screen )
     {
         std::cout << "Unable to set LGxHT video: "<< SDL_GetError() << std::endl;
         return 1;
     }
-    SDL_WM_SetCaption("Pong Circle !!!",NULL);
-    SDL_ShowCursor(SDL_DISABLE);
-
+    SDL_WM_SetCaption("Pong Circle !!!",NULL);
+    SDL_ShowCursor(SDL_DISABLE);
+
     srand(time(0));
-
-    // [2] Appel de la fonction jeu
-    int erreur;
-    erreur = jeu(screen,nbJoueurs);
+
+    // [2] Appel de la fonction jeu
+    int erreur;
+    erreur = jeu(screen,nbJoueurs);
 
     // all is well ;)
     std::cout << "Pas d'erreur detectee." << std::endl;

src/main.h

@@ -1,25 +1,25 @@
-#ifndef MAIN_H_INCLUDED
-#define MAIN_H_INCLUDED
-
-#include <iostream>
-#include <SDL/SDL.h>
-#include <cstdlib>
-#include <ctime>
-
-#include "Input.h"
-#include "Point.h"
-#include "Vecteur.h"
-
-
-
+#ifndef MAIN_H_INCLUDED
+#define MAIN_H_INCLUDED
+
+#include <iostream>
+#include <SDL/SDL.h>
+#include <cstdlib>
+#include <ctime>
+
+#include "Input.h"
+#include "Point.h"
+#include "Vecteur.h"
+
+
+
 ///Dernière modification: 25/06/2013
-///Objet: déplacement des includes spécifiques
-
-#define COTE 640
-
-/*
-Programmeurs:
-Jovian et Nathan
-*/
-
-#endif // MAIN_H_INCLUDED
+///Objet: déplacement des includes spécifiques
+
+#define COTE 640
+
+/*
+Programmeurs:
+Jovian et Nathan
+*/
+
+#endif // MAIN_H_INCLUDED