Remove CR characters

Microsoft Windows legacy.

Armes/Arme.cpp

@@ -1,25 +1,25 @@
-#include "Arme.h"
-
+#include "Arme.h"
+
 Arme::Arme( int degats, WeaponType model, Tirs_Gest* tirsGest, Uint32 freqShot )
-:m_degats( degats ), m_model( model ), m_tirsGest( tirsGest ), m_lastShot( 0 ), m_freqShot( freqShot )
-{
-    //ctor
-}
-
-Arme::~Arme()
-{
-    //dtor
+:m_degats( degats ), m_model( model ), m_tirsGest( tirsGest ), m_lastShot( 0 ), m_freqShot( freqShot )
+{
+    //ctor
+}
+
+Arme::~Arme()
+{
+    //dtor
 }
 
-WeaponType Arme::getModel()
-{
-    return m_model;
+WeaponType Arme::getModel()
+{
+    return m_model;
 }
 
-void Arme::gachette( Vec pos, Vec visee, bool allie )
-{
+void Arme::gachette( Vec pos, Vec visee, bool allie )
+{
     if ( SDL_GetTicks() - m_lastShot > m_freqShot ) {
         m_lastShot = SDL_GetTicks();
         tirer( pos, visee, allie);
-    }
-}
+    }
+}

Armes/Arme.h

@@ -1,18 +1,18 @@
-#ifndef ARME_H
+#ifndef ARME_H
 #define ARME_H
 
 #include "../Structures/Affichable.h"
-#include "../Tirs/Tirs_Gest.h"
+#include "../Tirs/Tirs_Gest.h"
 
 #define NB_MODELS 9
-enum WeaponType { GUN, FUSIL, SHOTGUN, USIANE, SCATTER, BAROUDEUR, SULFATEUSE, TRIPHASEUR, BOMBER };
-
-class Arme
+enum WeaponType { GUN, FUSIL, SHOTGUN, USIANE, SCATTER, BAROUDEUR, SULFATEUSE, TRIPHASEUR, BOMBER };
+
+class Arme
 {
-/// Fonctions
+/// Fonctions
     public:
-
-        Arme( int degats, WeaponType model, Tirs_Gest* tirsGest, Uint32 freqShot );
+
+        Arme( int degats, WeaponType model, Tirs_Gest* tirsGest, Uint32 freqShot );
         virtual ~Arme();
 
         WeaponType getModel();// Permet de prendre la bonne surface dans le sprite loader
@@ -23,7 +23,7 @@ class Arme
 
         virtual void tirer(Vec pos, Vec visee, bool allie) = 0;// Tire selon le modèle de l'arme
 
-/// Attributs
+/// Attributs
     protected:
 
         int m_degats;
@@ -32,7 +32,7 @@ class Arme
         Tirs_Gest* m_tirsGest;
 
         Uint32 m_lastShot;
-        const Uint32 m_freqShot;
-};
-
-#endif // ARME_H
+        const Uint32 m_freqShot;
+};
+
+#endif // ARME_H

Armes/Armes_Gest.cpp

@@ -1,21 +1,21 @@
-#include "Armes_Gest.h"
+#include "Armes_Gest.h"
 
 /// ~~~ ARMES_GEST IMPLEMENTATION ~~~ ----------------------------------------------------------------- VVVVV
-
-Armes_Gest::Armes_Gest( SpriteLoader* sprites )
+
+Armes_Gest::Armes_Gest( SpriteLoader* sprites )
 {
     /// Chargement des images
-    // Chargement des images
-    m_armeImg[ GUN ] = sprites->takeSprite("Gun");
-    m_armeImg[ FUSIL ] = sprites->takeSprite("Fusil");
+    // Chargement des images
+    m_armeImg[ GUN ] = sprites->takeSprite("Gun");
+    m_armeImg[ FUSIL ] = sprites->takeSprite("Fusil");
     m_armeImg[ SHOTGUN ] = sprites->takeSprite("Shotgun");
-
-    m_armeImg[ USIANE ] = sprites->takeSprite("Usiane");
-    m_armeImg[ SCATTER ] = sprites->takeSprite("Scatter");
+
+    m_armeImg[ USIANE ] = sprites->takeSprite("Usiane");
+    m_armeImg[ SCATTER ] = sprites->takeSprite("Scatter");
     m_armeImg[ BAROUDEUR ] = sprites->takeSprite("Baroudeur");
-
-    m_armeImg[ SULFATEUSE ] = sprites->takeSprite("Sulfateuse");
-    m_armeImg[ TRIPHASEUR ] = sprites->takeSprite("Triphaseur");
+
+    m_armeImg[ SULFATEUSE ] = sprites->takeSprite("Sulfateuse");
+    m_armeImg[ TRIPHASEUR ] = sprites->takeSprite("Triphaseur");
     m_armeImg[ BOMBER ] = sprites->takeSprite("Bomber");
 
     // On enlève le transparent
@@ -32,34 +32,34 @@ Armes_Gest::Armes_Gest( SpriteLoader* sprites )
 
     m_crafts[ Craft( GUN, USIANE ) ] = SULFATEUSE;
     m_crafts[ Craft( GUN, SHOTGUN ) ] = USIANE;
-    m_crafts[ Craft( GUN, FUSIL ) ] = SCATTER;
-}
-
-Armes_Gest::~Armes_Gest()
-{
+    m_crafts[ Craft( GUN, FUSIL ) ] = SCATTER;
+}
+
+Armes_Gest::~Armes_Gest()
+{
     for (m_itList = m_posees.begin(); m_itList != m_posees.end(); m_itList++){
         delete (*m_itList);
-    }
-}
+    }
+}
 
-SDL_Surface* Armes_Gest::getImg( WeaponType model ) const
-{
-    return m_armeImg[ model ];
-}
+SDL_Surface* Armes_Gest::getImg( WeaponType model ) const
+{
+    return m_armeImg[ model ];
+}
 
-void Armes_Gest::allDisplay( const Vec &lookAt, SDL_Surface* screen )
-{
+void Armes_Gest::allDisplay( const Vec &lookAt, SDL_Surface* screen )
+{
     for (m_itList = m_posees.begin(); m_itList != m_posees.end(); m_itList++){
         (*m_itList)->afficher( lookAt, screen );
-    }
-}
+    }
+}
 
-void Armes_Gest::drop( Vec pos, Arme* weapon )
-{
-    m_posees.insert( m_posees.begin(), new CaisseArme( m_armeImg[ weapon->getModel() ], weapon, pos) );
-}
+void Armes_Gest::drop( Vec pos, Arme* weapon )
+{
+    m_posees.insert( m_posees.begin(), new CaisseArme( m_armeImg[ weapon->getModel() ], weapon, pos) );
+}
 
-Arme* Armes_Gest::saisir( Vec pos )
+Arme* Armes_Gest::saisir( Vec pos )
 {
     Arme* weapon( 0x0 );
 
@@ -71,8 +71,8 @@ Arme* Armes_Gest::saisir( Vec pos )
             m_posees.erase( m_itList );
         }
     }
-
-    return weapon;
+
+    return weapon;
 }
 
 Arme* Armes_Gest::crafting( Arme* paire[2], Tirs_Gest* tirsGest )
@@ -151,7 +151,7 @@ Craft::Craft()
 :m_a(GUN), m_b(SHOTGUN)
 {
 
-}
+}
 
 Craft::Craft( WeaponType a, WeaponType b )
 {

Armes/Armes_Gest.h

@@ -1,5 +1,5 @@
-#ifndef ARMES_GEST_H
-#define ARMES_GEST_H
+#ifndef ARMES_GEST_H
+#define ARMES_GEST_H
 
 #include "CaisseArme.h"
 #include "../Structures/SpriteLoader.h"
@@ -21,13 +21,13 @@
 #include "Modeles/Triphaseur.h"
 #include "Modeles/Bomber.h"
 
-class Craft; // Permet de stocker une combinaison
-
-class Armes_Gest
-{
+class Craft; // Permet de stocker une combinaison
+
+class Armes_Gest
+{
     public:
-
-        Armes_Gest( SpriteLoader* sprites );
+
+        Armes_Gest( SpriteLoader* sprites );
         virtual ~Armes_Gest();
 
         SDL_Surface* getImg( WeaponType model ) const; // Permet au perso d'obtenir la surface associée à l'arme
@@ -41,7 +41,7 @@ class Armes_Gest
         Arme* takeWeapon( WeaponType model, Tirs_Gest* tirsGest ) const; // Créé une nouvelle arme à partir de son nom de modele
         Arme* startWeapon( Tirs_Gest* tirsGest ) const; // Octroie une arme de rang 1
 
-
+
     protected:
 
         std::list< CaisseArme* > m_posees; // Stock des armes posées
@@ -50,7 +50,7 @@ class Armes_Gest
         std::map< Craft, WeaponType > m_crafts; // Stock des crafts possibles
         std::map< Craft, WeaponType >::iterator m_itMap; // Itérateur map
 
-        SDL_Surface* m_armeImg[ NB_MODELS ]; // Image de chaque arme
+        SDL_Surface* m_armeImg[ NB_MODELS ]; // Image de chaque arme
 };
 
 class Craft
@@ -70,6 +70,6 @@ class Craft
 
         WeaponType m_a;
         WeaponType m_b;
-};
-
-#endif // ARMES_GEST_H
+};
+
+#endif // ARMES_GEST_H

Armes/CaisseArme.cpp

@@ -1,15 +1,15 @@
-#include "CaisseArme.h"
-
+#include "CaisseArme.h"
+
 CaisseArme::CaisseArme( SDL_Surface* img, Arme* lachee, Vec pos )
-:Affichable( img ), m_contenu( lachee )
-{
-    m_pos = pos;
-}
-
-CaisseArme::~CaisseArme()
-{
-    if (m_contenu != 0x0) delete m_contenu;
-}
+:Affichable( img ), m_contenu( lachee )
+{
+    m_pos = pos;
+}
+
+CaisseArme::~CaisseArme()
+{
+    if (m_contenu != 0x0) delete m_contenu;
+}
 
 bool CaisseArme::proxi(Vec pos) const
 {

Armes/CaisseArme.h

@@ -1,15 +1,15 @@
-#ifndef CAISSEARME_H
-#define CAISSEARME_H
-
+#ifndef CAISSEARME_H
+#define CAISSEARME_H
+
 #include "../Structures/Affichable.h"
-#include "Arme.h"
-
-
-class CaisseArme : public Affichable
-{
+#include "Arme.h"
+
+
+class CaisseArme : public Affichable
+{
     public:
-
-        CaisseArme( SDL_Surface* img, Arme* lachee, Vec pos );
+
+        CaisseArme( SDL_Surface* img, Arme* lachee, Vec pos );
         virtual ~CaisseArme();// Détruit l'arme si elle est encore là
 
         bool proxi(Vec pos) const;// Indique si l'arme est à portée
@@ -17,10 +17,10 @@ class CaisseArme : public Affichable
         bool empty() const;// Arme encore là ?
 
         Arme* takeWeapon();// Met le ptr à 0
-
+
     protected:
 
-        Arme* m_contenu;
-};
-
-#endif // CAISSEARME_H
+        Arme* m_contenu;
+};
+
+#endif // CAISSEARME_H

Armes/Modeles/Baroudeur.cpp

@@ -1,15 +1,15 @@
-#include "Baroudeur.h"
-
+#include "Baroudeur.h"
+
 Baroudeur::Baroudeur( Tirs_Gest* tirsGest )
-:Arme( 19, BAROUDEUR, tirsGest, 620 )
-{
-    //ctor
-}
-
-Baroudeur::~Baroudeur()
-{
-    //dtor
-}
+:Arme( 19, BAROUDEUR, tirsGest, 620 )
+{
+    //ctor
+}
+
+Baroudeur::~Baroudeur()
+{
+    //dtor
+}
 
 void Baroudeur::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Baroudeur.h

@@ -1,18 +1,18 @@
-#ifndef BAROUDEUR_H
-#define BAROUDEUR_H
-
-#include "../Arme.h"
-
-
-class Baroudeur : public Arme
-{
-    public:
-        Baroudeur( Tirs_Gest* tirsGest );
+#ifndef BAROUDEUR_H
+#define BAROUDEUR_H
+
+#include "../Arme.h"
+
+
+class Baroudeur : public Arme
+{
+    public:
+        Baroudeur( Tirs_Gest* tirsGest );
         virtual ~Baroudeur();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // BAROUDEUR_H
+
+    protected:
+};
+
+#endif // BAROUDEUR_H

Armes/Modeles/Bomber.cpp

@@ -1,15 +1,15 @@
-#include "Bomber.h"
-
+#include "Bomber.h"
+
 Bomber::Bomber( Tirs_Gest* tirsGest )
-:Arme( 19, BOMBER, tirsGest, 620 )
-{
-    //ctor
-}
-
-Bomber::~Bomber()
-{
-    //dtor
-}
+:Arme( 19, BOMBER, tirsGest, 620 )
+{
+    //ctor
+}
+
+Bomber::~Bomber()
+{
+    //dtor
+}
 
 void Bomber::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Bomber.h

@@ -1,18 +1,18 @@
-#ifndef BOMBER_H
-#define BOMBER_H
-
-#include "../Arme.h"
-
-
-class Bomber : public Arme
-{
-    public:
-        Bomber( Tirs_Gest* tirsGest );
+#ifndef BOMBER_H
+#define BOMBER_H
+
+#include "../Arme.h"
+
+
+class Bomber : public Arme
+{
+    public:
+        Bomber( Tirs_Gest* tirsGest );
         virtual ~Bomber();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // BOMBER_H
+
+    protected:
+};
+
+#endif // BOMBER_H

Armes/Modeles/Fusil.cpp

@@ -1,17 +1,17 @@
-#include "Fusil.h"
-
+#include "Fusil.h"
+
 Fusil::Fusil( Tirs_Gest* tirsGest )
-:Arme( 51, FUSIL, tirsGest, 1000 )
-{
-    //ctor
-}
-
-Fusil::~Fusil()
-{
-    //dtor
-}
+:Arme( 51, FUSIL, tirsGest, 1000 )
+{
+    //ctor
+}
+
+Fusil::~Fusil()
+{
+    //dtor
+}
 
 void Fusil::tirer(Vec pos, Vec visee, bool allie)
 {
     m_tirsGest->addTir( pos, visee, m_degats, allie);
-}
+}

Armes/Modeles/Fusil.h

@@ -1,18 +1,18 @@
-#ifndef FUSIL_H
-#define FUSIL_H
-
-#include "../Arme.h"
-
-
-class Fusil : public Arme
-{
-    public:
-        Fusil( Tirs_Gest* tirsGest );
+#ifndef FUSIL_H
+#define FUSIL_H
+
+#include "../Arme.h"
+
+
+class Fusil : public Arme
+{
+    public:
+        Fusil( Tirs_Gest* tirsGest );
         virtual ~Fusil();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // FUSIL_H
+
+    protected:
+};
+
+#endif // FUSIL_H

Armes/Modeles/Gun.cpp

@@ -1,15 +1,15 @@
-#include "Gun.h"
-
+#include "Gun.h"
+
 Gun::Gun( Tirs_Gest* tirsGest )
-:Arme( 26, GUN, tirsGest, 400 )
-{
-    //ctor
-}
-
-Gun::~Gun()
-{
-    //dtor
-}
+:Arme( 26, GUN, tirsGest, 400 )
+{
+    //ctor
+}
+
+Gun::~Gun()
+{
+    //dtor
+}
 
 void Gun::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Gun.h

@@ -1,18 +1,18 @@
-#ifndef GUN_H
-#define GUN_H
-
-#include "../Arme.h"
-
-
-class Gun : public Arme
-{
-    public:
-        Gun( Tirs_Gest* tirsGest );
+#ifndef GUN_H
+#define GUN_H
+
+#include "../Arme.h"
+
+
+class Gun : public Arme
+{
+    public:
+        Gun( Tirs_Gest* tirsGest );
         virtual ~Gun();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // GUN_H
+
+    protected:
+};
+
+#endif // GUN_H

Armes/Modeles/Scatter.cpp

@@ -1,15 +1,15 @@
-#include "Scatter.h"
-
+#include "Scatter.h"
+
 Scatter::Scatter( Tirs_Gest* tirsGest )
-:Arme( 40, SCATTER, tirsGest, 729 )
-{
-    //ctor
-}
-
-Scatter::~Scatter()
-{
-    //dtor
-}
+:Arme( 40, SCATTER, tirsGest, 729 )
+{
+    //ctor
+}
+
+Scatter::~Scatter()
+{
+    //dtor
+}
 
 void Scatter::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Scatter.h

@@ -1,18 +1,18 @@
-#ifndef SCATTER_H
-#define SCATTER_H
-
-#include "../Arme.h"
-
-
-class Scatter : public Arme
-{
-    public:
-        Scatter( Tirs_Gest* tirsGest );
+#ifndef SCATTER_H
+#define SCATTER_H
+
+#include "../Arme.h"
+
+
+class Scatter : public Arme
+{
+    public:
+        Scatter( Tirs_Gest* tirsGest );
         virtual ~Scatter();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // SCATTER_H
+
+    protected:
+};
+
+#endif // SCATTER_H

Armes/Modeles/Shotgun.cpp

@@ -1,15 +1,15 @@
-#include "Shotgun.h"
-
+#include "Shotgun.h"
+
 Shotgun::Shotgun( Tirs_Gest* tirsGest )
-:Arme( 19, SHOTGUN, tirsGest, 620 )
-{
-    //ctor
-}
-
-Shotgun::~Shotgun()
-{
-    //dtor
-}
+:Arme( 19, SHOTGUN, tirsGest, 620 )
+{
+    //ctor
+}
+
+Shotgun::~Shotgun()
+{
+    //dtor
+}
 
 void Shotgun::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Shotgun.h

@@ -1,19 +1,19 @@
-#ifndef BASICSHOTGUN_H
-#define BASICSHOTGUN_H
-
-#include "../Arme.h"
-
-
-class Shotgun : public Arme
-{
-    public:
-        Shotgun( Tirs_Gest* tirsGest );
+#ifndef BASICSHOTGUN_H
+#define BASICSHOTGUN_H
+
+#include "../Arme.h"
+
+
+class Shotgun : public Arme
+{
+    public:
+        Shotgun( Tirs_Gest* tirsGest );
         virtual ~Shotgun();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
+
     protected:
-
-};
-
-#endif // BASICSHOTGUN_H
+
+};
+
+#endif // BASICSHOTGUN_H

Armes/Modeles/Sulfateuse.cpp

@@ -1,15 +1,15 @@
-#include "Sulfateuse.h"
-
+#include "Sulfateuse.h"
+
 Sulfateuse::Sulfateuse( Tirs_Gest* tirsGest )
-:Arme( 16, SULFATEUSE, tirsGest, 100 )
-{
-    //ctor
-}
-
-Sulfateuse::~Sulfateuse()
-{
-    //dtor
-}
+:Arme( 16, SULFATEUSE, tirsGest, 100 )
+{
+    //ctor
+}
+
+Sulfateuse::~Sulfateuse()
+{
+    //dtor
+}
 
 void Sulfateuse::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Sulfateuse.h

@@ -1,18 +1,18 @@
-#ifndef SULFATEUSE_H
-#define SULFATEUSE_H
-
-#include "../Arme.h"
-
-
-class Sulfateuse : public Arme
-{
-    public:
-        Sulfateuse( Tirs_Gest* tirsGest );
+#ifndef SULFATEUSE_H
+#define SULFATEUSE_H
+
+#include "../Arme.h"
+
+
+class Sulfateuse : public Arme
+{
+    public:
+        Sulfateuse( Tirs_Gest* tirsGest );
         virtual ~Sulfateuse();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // SULFATEUSE_H
+
+    protected:
+};
+
+#endif // SULFATEUSE_H

Armes/Modeles/Triphaseur.cpp

@@ -1,15 +1,15 @@
-#include "Triphaseur.h"
-
+#include "Triphaseur.h"
+
 Triphaseur::Triphaseur( Tirs_Gest* tirsGest )
-:Arme( 34, TRIPHASEUR, tirsGest, 729 )
-{
-    //ctor
-}
-
-Triphaseur::~Triphaseur()
-{
-    //dtor
-}
+:Arme( 34, TRIPHASEUR, tirsGest, 729 )
+{
+    //ctor
+}
+
+Triphaseur::~Triphaseur()
+{
+    //dtor
+}
 
 void Triphaseur::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Triphaseur.h

@@ -1,18 +1,18 @@
-#ifndef TRIPHASEUR_H
-#define TRIPHASEUR_H
-
-#include "../Arme.h"
-
-
-class Triphaseur : public Arme
-{
-    public:
-        Triphaseur( Tirs_Gest* tirsGest );
+#ifndef TRIPHASEUR_H
+#define TRIPHASEUR_H
+
+#include "../Arme.h"
+
+
+class Triphaseur : public Arme
+{
+    public:
+        Triphaseur( Tirs_Gest* tirsGest );
         virtual ~Triphaseur();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // TRIPHASEUR_H
+
+    protected:
+};
+
+#endif // TRIPHASEUR_H

Armes/Modeles/Usiane.cpp

@@ -1,15 +1,15 @@
-#include "Usiane.h"
-
+#include "Usiane.h"
+
 Usiane::Usiane( Tirs_Gest* tirsGest )
-:Arme( 19, USIANE, tirsGest, 250 )
-{
-    //ctor
-}
-
-Usiane::~Usiane()
-{
-    //dtor
-}
+:Arme( 19, USIANE, tirsGest, 250 )
+{
+    //ctor
+}
+
+Usiane::~Usiane()
+{
+    //dtor
+}
 
 void Usiane::tirer(Vec pos, Vec visee, bool allie)
 {

Armes/Modeles/Usiane.h

@@ -1,18 +1,18 @@
-#ifndef USIANE_H
-#define USIANE_H
-
-#include "../Arme.h"
-
-
-class Usiane : public Arme
-{
-    public:
-        Usiane( Tirs_Gest* tirsGest );
+#ifndef USIANE_H
+#define USIANE_H
+
+#include "../Arme.h"
+
+
+class Usiane : public Arme
+{
+    public:
+        Usiane( Tirs_Gest* tirsGest );
         virtual ~Usiane();
 
         virtual void tirer(Vec pos, Vec visee, bool allie);
-
-    protected:
-};
-
-#endif // USIANE_H
+
+    protected:
+};
+
+#endif // USIANE_H

Control/ClavierCtrl.cpp

@@ -1,32 +1,32 @@
-#include "ClavierCtrl.h"
-
+#include "ClavierCtrl.h"
+
 ClavierCtrl::ClavierCtrl(InputAndJoy* input)
-:HardCtrl(input)
-{
-    //ctor
-}
-
-ClavierCtrl::~ClavierCtrl()
-{
-    //dtor
+:HardCtrl(input)
+{
+    //ctor
+}
+
+ClavierCtrl::~ClavierCtrl()
+{
+    //dtor
 }
 
 void ClavierCtrl::update()
-{
-    /// Gestion des changements de clavier Linux/Windows
-    #ifdef WIN32
-        #define PKEY_A SDLK_q
-        #define PKEY_Q SDLK_a
-        #define PKEY_Z SDLK_w
-    #else
-        #define PKEY_A SDLK_a
-        #define PKEY_Q SDLK_q
-        #define PKEY_Z SDLK_z
-    #endif
+{
+    /// Gestion des changements de clavier Linux/Windows
+    #ifdef WIN32
+        #define PKEY_A SDLK_q
+        #define PKEY_Q SDLK_a
+        #define PKEY_Z SDLK_w
+    #else
+        #define PKEY_A SDLK_a
+        #define PKEY_Q SDLK_q
+        #define PKEY_Z SDLK_z
+    #endif
 
     /// Deplacement
-    m_mvt.setVecteur(0.0f, 0.0f);
-    if ( m_input->getTouche(PKEY_Z) ) m_mvt.setY(1.0f);
+    m_mvt.setVecteur(0.0f, 0.0f);
+    if ( m_input->getTouche(PKEY_Z) ) m_mvt.setY(1.0f);
     if ( m_input->getTouche(PKEY_Q) ) m_mvt.setX(-1.0f);
     if ( m_input->getTouche(SDLK_s) ) m_mvt.setY(-1.0f);
     if ( m_input->getTouche(SDLK_d) ) m_mvt.setX(1.0f);
@@ -45,4 +45,4 @@ void ClavierCtrl::update()
 
     /// Craft
     m_craft = m_input->getTouche(SDLK_c);
-}
+}

Control/ClavierCtrl.h

@@ -1,16 +1,16 @@
-#ifndef CLAVIERCTRL_H
-#define CLAVIERCTRL_H
-
-#include "HardCtrl.h"
-
-
-class ClavierCtrl : public HardCtrl
-{
-    public:
-        ClavierCtrl(InputAndJoy* input);
+#ifndef CLAVIERCTRL_H
+#define CLAVIERCTRL_H
+
+#include "HardCtrl.h"
+
+
+class ClavierCtrl : public HardCtrl
+{
+    public:
+        ClavierCtrl(InputAndJoy* input);
         virtual ~ClavierCtrl();
 
-        void update();
-};
-
-#endif // CLAVIERCTRL_H
+        void update();
+};
+
+#endif // CLAVIERCTRL_H

Control/Controler.cpp

@@ -1,26 +1,26 @@
-#include "Controler.h"
-
+#include "Controler.h"
+
 Controler::Controler()
-:m_mvt(0.0f, 0.0f), m_visee(0.0f, 0.0f), m_craft(false), m_tir(), m_search(), m_prevSearch()
-{
-    m_tir[ L_HAND ] = m_tir[ R_HAND ] = false;
-    m_search[ L_HAND ] = m_search[ R_HAND ] = false;
-    m_prevSearch[ L_HAND ] = m_prevSearch[ R_HAND ] = false;
-}
-
-Controler::~Controler()
-{
-    //dtor
-}
+:m_mvt(0.0f, 0.0f), m_visee(0.0f, 0.0f), m_craft(false), m_tir(), m_search(), m_prevSearch()
+{
+    m_tir[ L_HAND ] = m_tir[ R_HAND ] = false;
+    m_search[ L_HAND ] = m_search[ R_HAND ] = false;
+    m_prevSearch[ L_HAND ] = m_prevSearch[ R_HAND ] = false;
+}
 
-Vec Controler::getMvt() const
-{
-    return m_mvt;
+Controler::~Controler()
+{
+    //dtor
 }
 
-Vec Controler::getVisee() const
-{
-    return m_visee;
+Vec Controler::getMvt() const
+{
+    return m_mvt;
+}
+
+Vec Controler::getVisee() const
+{
+    return m_visee;
 }
 
 bool Controler::getCraft()
@@ -32,16 +32,16 @@ bool Controler::getCraft()
     else return false;
 }
 
-bool Controler::getTir( unsigned short main ) const
-{
-    return m_tir[ main ];
+bool Controler::getTir( unsigned short main ) const
+{
+    return m_tir[ main ];
 }
 
-bool Controler::getSearch( unsigned short main )
-{
+bool Controler::getSearch( unsigned short main )
+{
     if ( m_search[main] != m_prevSearch[main] ) {
         m_prevSearch[main] = m_search[main];
         return m_search[main];
     }
-    else return false;
+    else return false;
 }

Control/Controler.h

@@ -1,4 +1,4 @@
-#ifndef CONTROLER_H
+#ifndef CONTROLER_H
 #define CONTROLER_H
 
 // Inclusions
@@ -7,13 +7,13 @@
 
 // Noms des mains
 #define L_HAND 0
-#define R_HAND 1
-
-
-class Controler
-{
-    public:
-        Controler();
+#define R_HAND 1
+
+
+class Controler
+{
+    public:
+        Controler();
         virtual ~Controler();
 
         virtual void update() = 0;
@@ -23,7 +23,7 @@ class Controler
         bool getCraft();
         bool getTir( unsigned short main ) const;
         bool getSearch( unsigned short main );
-
+
     protected:
         Vec m_mvt; // Norme € [0 ; 1]
         Vec m_visee;
@@ -33,7 +33,7 @@ class Controler
 
     private:
         bool m_prevCraft;
-        bool m_prevSearch[2]; // Pour éviter de chercher en continu
-};
-
-#endif // CONTROLER_H
+        bool m_prevSearch[2]; // Pour éviter de chercher en continu
+};
+
+#endif // CONTROLER_H

Control/HardCtrl.cpp

@@ -1,12 +1,12 @@
-#include "HardCtrl.h"
-
+#include "HardCtrl.h"
+
 HardCtrl::HardCtrl(InputAndJoy* input)
-:m_input(input)
-{
-    //ctor
-}
-
-HardCtrl::~HardCtrl()
-{
-    //dtor
-}
+:m_input(input)
+{
+    //ctor
+}
+
+HardCtrl::~HardCtrl()
+{
+    //dtor
+}

Control/HardCtrl.h

@@ -1,21 +1,21 @@
-#ifndef HARDCTRL_H
+#ifndef HARDCTRL_H
 #define HARDCTRL_H
 
 #include <iostream>
 #include "Controler.h"
-#include "../Control/InputAndJoy.h"
-
-
-class HardCtrl : public Controler
-{
-    public:
-        HardCtrl(InputAndJoy* input);
+#include "../Control/InputAndJoy.h"
+
+
+class HardCtrl : public Controler
+{
+    public:
+        HardCtrl(InputAndJoy* input);
         virtual ~HardCtrl();
 
         virtual void update() = 0;
-
+
     protected:
-        InputAndJoy* m_input;
-};
-
-#endif // HARDCTRL_H
+        InputAndJoy* m_input;
+};
+
+#endif // HARDCTRL_H

Control/IA/Brute.cpp

@@ -1,14 +1,14 @@
-#include "Brute.h"
-
+#include "Brute.h"
+
 Brute::Brute(Persos_Gest* persosGest, bool allie)
-: IACtrl(persosGest, allie), m_aglStrafe(0.0f), m_focusID(65535), m_cote()
+: IACtrl(persosGest, allie), m_aglStrafe(0.0f), m_focusID(65535), m_cote()
 {
     if ( rand()%2 ) m_cote = 1;
     else m_cote = -1;
-}
-
-Brute::~Brute()
-{}//Ne rien détruire
+}
+
+Brute::~Brute()
+{}//Ne rien détruire
 
 void Brute::update()
 {

Control/IA/Brute.h

@@ -1,13 +1,13 @@
-#ifndef BRUTE_H
-#define BRUTE_H
+#ifndef BRUTE_H
+#define BRUTE_H
 
-#include "../IACtrl.h"
-
-class Brute : public IACtrl
+#include "../IACtrl.h"
+
+class Brute : public IACtrl
 {
-///Méthodes
-    public:
-        Brute(Persos_Gest* persosGest, bool allie = false);
+///Méthodes
+    public:
+        Brute(Persos_Gest* persosGest, bool allie = false);
         virtual ~Brute();
 
         virtual void update();
@@ -16,7 +16,7 @@ class Brute : public IACtrl
     private:
         float m_aglStrafe;
         Uint16 m_focusID;
-        short m_cote;
-};
-
-#endif // BRUTE_H
+        short m_cote;
+};
+
+#endif // BRUTE_H

Control/IA/Follower.cpp

@@ -1,11 +1,11 @@
-#include "Follower.h"
-
+#include "Follower.h"
+
 Follower::Follower(Persos_Gest* persosGest, bool allie)
-: IACtrl(persosGest, allie), m_focIDAllie(65535), m_focIDFoe(65535), m_vitesse(0.0f)
-{}
-
-Follower::~Follower()
-{}
+: IACtrl(persosGest, allie), m_focIDAllie(65535), m_focIDFoe(65535), m_vitesse(0.0f)
+{}
+
+Follower::~Follower()
+{}
 
 void Follower::update()
 {

Control/IA/Follower.h

@@ -1,13 +1,13 @@
-#ifndef FOLLOWER_H
-#define FOLLOWER_H
+#ifndef FOLLOWER_H
+#define FOLLOWER_H
 
-#include "../IACtrl.h"
-
-class Follower : public IACtrl
+#include "../IACtrl.h"
+
+class Follower : public IACtrl
 {
-///Méthodes
-    public:
-        Follower(Persos_Gest* persosGest, bool allie = false);
+///Méthodes
+    public:
+        Follower(Persos_Gest* persosGest, bool allie = false);
         virtual ~Follower();
 
         virtual void update();
@@ -16,7 +16,7 @@ class Follower : public IACtrl
     private:
         Uint16 m_focIDAllie;
         Uint16 m_focIDFoe;
-        float m_vitesse; // €[0; 1]
-};
-
-#endif // FOLLOWER_H
+        float m_vitesse; // €[0; 1]
+};
+
+#endif // FOLLOWER_H

Control/IA/Sniper.cpp

@@ -1,11 +1,11 @@
-#include "Sniper.h"
-
+#include "Sniper.h"
+
 Sniper::Sniper(Persos_Gest* persosGest, bool allie)
-: IACtrl( persosGest, allie ), m_focusID( 65535 ), m_lastShot( 0 )
-{}
-
-Sniper::~Sniper()
-{}//Ne rien détruire
+: IACtrl( persosGest, allie ), m_focusID( 65535 ), m_lastShot( 0 )
+{}
+
+Sniper::~Sniper()
+{}//Ne rien détruire
 
 void Sniper::update()
 {

Control/IA/Sniper.h

@@ -1,13 +1,13 @@
-#ifndef SNIPER_H
+#ifndef SNIPER_H
 #define SNIPER_H
-
-#include "../IACtrl.h"
-
-class Sniper : public IACtrl
+
+#include "../IACtrl.h"
+
+class Sniper : public IACtrl
 {
-///Méthodes
-    public:
-        Sniper(Persos_Gest* persosGest, bool allie = false);
+///Méthodes
+    public:
+        Sniper(Persos_Gest* persosGest, bool allie = false);
         virtual ~Sniper();
 
         virtual void update();
@@ -15,6 +15,6 @@ class Sniper : public IACtrl
 ///Attributs
     private:
         Uint16 m_focusID;
-        Uint32 m_lastShot;
-};
-#endif // SNIPER_H
+        Uint32 m_lastShot;
+};
+#endif // SNIPER_H

Control/IACtrl.cpp

@@ -1,14 +1,14 @@
-#include "IACtrl.h"
-
+#include "IACtrl.h"
+
 IACtrl::IACtrl(Persos_Gest* persosGest, bool allie)
-: m_moi(0x0), m_persosGest(persosGest), m_allie(allie)
-{
-    //ctor
-}
-
-IACtrl::~IACtrl()
-{
-    //Ne rien détruire
+: m_moi(0x0), m_persosGest(persosGest), m_allie(allie)
+{
+    //ctor
+}
+
+IACtrl::~IACtrl()
+{
+    //Ne rien détruire
 }
 
 void IACtrl::setPersoMoi(Perso* moi)

Control/IACtrl.h

@@ -1,4 +1,4 @@
-#ifndef IACTRL_H
+#ifndef IACTRL_H
 #define IACTRL_H
 
 #include <iostream>
@@ -6,14 +6,14 @@
 #include "Controler.h"
 #include "../Persos/Persos_Gest.h"
 
-#define NO_FOCUS 65535
-
-
-class IACtrl : public Controler
+#define NO_FOCUS 65535
+
+
+class IACtrl : public Controler
 {
-/// Fonctions
-    public:
-        IACtrl(Persos_Gest* persosGest, bool allie = false);
+/// Fonctions
+    public:
+        IACtrl(Persos_Gest* persosGest, bool allie = false);
         virtual ~IACtrl();
 
         virtual void update() = 0;
@@ -23,11 +23,11 @@ class IACtrl : public Controler
     protected:
         Uint16 focusProche(bool allie); // Retourne l'ID du perso focalisé
 
-/// Attributs
+/// Attributs
     protected:
         Perso* m_moi;
         Persos_Gest* m_persosGest;
-        bool m_allie;
-};
-
-#endif // IACTRL_H
+        bool m_allie;
+};
+
+#endif // IACTRL_H

Control/Input.cpp

@@ -1,60 +1,60 @@
-#include "Input.h"
-
-
-// Constructeur et Destructeur
+#include "Input.h"
+
+
+// Constructeur et Destructeur
 Input::Input()
 : m_x(0), m_y(0), m_xRel(0), m_yRel(0),
 m_terminer(false), m_relativeMouse(false), m_windowHalfHeight(0), m_windowHalfWidth(0)
-{
-    // Initialisation du tableau m_touches[]
-    for(int i(0); i < SDLK_LAST; i++)
+{
+    // Initialisation du tableau m_touches[]
+    for(int i(0); i < SDLK_LAST; i++)
         m_touches[i] = false;
-    std::cout << "Il y a "<<SDLK_LAST<<" touches sur le clavier."<<std::endl;
-
-    // Initialisation du tableau m_boutonsSouris[]
-    for(int i(0); i < 8; i++)
-        m_boutonsSouris[i] = false;
-}
-
-
-Input::~Input()
-{}
-
-
-// Méthodes
-void Input::updateEvenements()
-{
-    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
-    m_xRel = 0;
-    m_yRel = 0;
-
-    // Boucle d'évènements
-    while(SDL_PollEvent(&m_evenements))
-    {
-        // Switch sur le type d'évènement
-        switch(m_evenements.type)
-        {
-            // Cas d'une touche enfoncée
-            case SDL_KEYDOWN:
-                m_touches[m_evenements.key.keysym.sym] = true;
-            break;
-
-            // Cas d'une touche relâchée
-            case SDL_KEYUP:
-                m_touches[m_evenements.key.keysym.sym] = false;
-            break;
-
-            // Cas de pression sur un bouton de la souris
-            case SDL_MOUSEBUTTONDOWN:
-                m_boutonsSouris[m_evenements.button.button] = true;
-            break;
-
-            // Cas du relâchement d'un bouton de la souris
-            case SDL_MOUSEBUTTONUP:
-                m_boutonsSouris[m_evenements.button.button] = false;
-            break;
-
-            // Cas d'un mouvement de souris
+    std::cout << "Il y a "<<SDLK_LAST<<" touches sur le clavier."<<std::endl;
+
+    // Initialisation du tableau m_boutonsSouris[]
+    for(int i(0); i < 8; i++)
+        m_boutonsSouris[i] = false;
+}
+
+
+Input::~Input()
+{}
+
+
+// Méthodes
+void Input::updateEvenements()
+{
+    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while(SDL_PollEvent(&m_evenements))
+    {
+        // Switch sur le type d'évènement
+        switch(m_evenements.type)
+        {
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_touches[m_evenements.key.keysym.sym] = true;
+            break;
+
+            // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_touches[m_evenements.key.keysym.sym] = false;
+            break;
+
+            // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenements.button.button] = true;
+            break;
+
+            // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenements.button.button] = false;
+            break;
+
+            // Cas d'un mouvement de souris
             case SDL_MOUSEMOTION:
                 if (m_relativeMouse)
                 {
@@ -67,94 +67,94 @@ void Input::updateEvenements()
                     m_y = m_evenements.motion.y;
                     m_xRel = m_evenements.motion.xrel;
                     m_yRel = m_evenements.motion.yrel;
-                }
-
-            break;
-
+                }
+
+            break;
+
             // Cas de la fermeture de la fenêtre
             case SDL_QUIT:
                 m_terminer = true;
-            break;
-
-            // Les autres ne nous interessent pas : on évite de faire râler g++
-            default:
-            break;
-        }
+            break;
+
+            // Les autres ne nous interessent pas : on évite de faire râler g++
+            default:
+            break;
+        }
     }
 
     // Pour éviter que la souris se barre en mode relative, on la "warp"
     if (m_relativeMouse)
-         SDL_WarpMouse(m_windowHalfWidth, m_windowHalfHeight);
-}
-
-
-bool Input::terminer() const
-{
-    return m_terminer;
-}
-
-
-void Input::afficherPointeur(bool reponse) const
-{
-    if(reponse)
-        SDL_ShowCursor(SDL_ENABLE);
-
-    else
-        SDL_ShowCursor(SDL_DISABLE);
-}
-
-
-void Input::capturerPointeur(bool reponse)
-{
-    m_relativeMouse = reponse;
-}
-
-
-
-// Getters
-
-bool Input::getTouche(const int touche) const
-{
-    return m_touches[touche];
-}
-
-
-bool Input::getBoutonSouris(const Uint8 bouton) const
-{
-    return m_boutonsSouris[bouton];
-}
-
-
-bool Input::mouvementSouris() const
-{
-    if(m_xRel == 0 && m_yRel == 0)
-        return false;
-
-    else
-        return true;
-}
-
-
-// Getters concernant la position du curseur
-
-int Input::getX() const
-{
-    return m_x;
-}
-
-int Input::getY() const
-{
-    return m_y;
-}
-
-int Input::getXRel() const
-{
-    return m_xRel;
-}
-
-int Input::getYRel() const
-{
-    return m_yRel;
+         SDL_WarpMouse(m_windowHalfWidth, m_windowHalfHeight);
+}
+
+
+bool Input::terminer() const
+{
+    return m_terminer;
+}
+
+
+void Input::afficherPointeur(bool reponse) const
+{
+    if(reponse)
+        SDL_ShowCursor(SDL_ENABLE);
+
+    else
+        SDL_ShowCursor(SDL_DISABLE);
+}
+
+
+void Input::capturerPointeur(bool reponse)
+{
+    m_relativeMouse = reponse;
+}
+
+
+
+// Getters
+
+bool Input::getTouche(const int touche) const
+{
+    return m_touches[touche];
+}
+
+
+bool Input::getBoutonSouris(const Uint8 bouton) const
+{
+    return m_boutonsSouris[bouton];
+}
+
+
+bool Input::mouvementSouris() const
+{
+    if(m_xRel == 0 && m_yRel == 0)
+        return false;
+
+    else
+        return true;
+}
+
+
+// Getters concernant la position du curseur
+
+int Input::getX() const
+{
+    return m_x;
+}
+
+int Input::getY() const
+{
+    return m_y;
+}
+
+int Input::getXRel() const
+{
+    return m_xRel;
+}
+
+int Input::getYRel() const
+{
+    return m_yRel;
 }
 
 void Input::placerPtr(SDL_Surface* activWindow)

Control/Input.h

@@ -1,61 +1,61 @@
-#ifndef DEF_INPUT
+#ifndef DEF_INPUT
 #define DEF_INPUT
 
 ///Jovian
-///Adaptation pour InputAndJoy
-
+///Adaptation pour InputAndJoy
+
 // Include
-#include <iostream>
-#include <SDL.h>
-
-
-// Classe
-class Input
-{
-    public:
-
-    Input();
-    virtual ~Input();
-
+#include <iostream>
+#include <SDL.h>
+
+
+// Classe
+class Input
+{
+    public:
+
+    Input();
+    virtual ~Input();
+
     virtual void updateEvenements();
-
-    bool terminer() const;
-    void afficherPointeur(bool reponse) const;
-    void capturerPointeur(bool reponse);
-
-    bool getTouche(const int touche) const;
-    bool getBoutonSouris(const Uint8 bouton) const;
-    bool mouvementSouris() const;
-
-    int getX() const;
-    int getY() const;
-
-    int getXRel() const;
+
+    bool terminer() const;
+    void afficherPointeur(bool reponse) const;
+    void capturerPointeur(bool reponse);
+
+    bool getTouche(const int touche) const;
+    bool getBoutonSouris(const Uint8 bouton) const;
+    bool mouvementSouris() const;
+
+    int getX() const;
+    int getY() const;
+
+    int getXRel() const;
     int getYRel() const;
 
     void placerPtr(SDL_Surface* activWindow);
 
     int getWinHalfH();
-    int getWinHalfW();
-
-
-    protected:
-
-    SDL_Event m_evenements;
-    bool m_touches[SDLK_LAST];
-    bool m_boutonsSouris[8];
-
-    int m_x;
-    int m_y;
-    int m_xRel;
-    int m_yRel;
-
+    int getWinHalfW();
+
+
+    protected:
+
+    SDL_Event m_evenements;
+    bool m_touches[SDLK_LAST];
+    bool m_boutonsSouris[8];
+
+    int m_x;
+    int m_y;
+    int m_xRel;
+    int m_yRel;
+
     bool m_terminer;
     bool m_relativeMouse;
 
     int m_windowHalfHeight;
-    int m_windowHalfWidth;
-};
-
-#endif
-
+    int m_windowHalfWidth;
+};
+
+#endif
+

Control/InputAndJoy.cpp

@@ -31,7 +31,7 @@ InputAndJoy::InputAndJoy()
         }
     }
 }
-
+
 InputAndJoy::~InputAndJoy()
 {
     if (m_manette != 0x0) SDL_JoystickClose(m_manette);
@@ -39,38 +39,38 @@ InputAndJoy::~InputAndJoy()
 
 void InputAndJoy::updateEvenements()
 {
-    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
-    m_xRel = 0;
-    m_yRel = 0;
-
-    // Boucle d'évènements
-    while(SDL_PollEvent(&m_evenements))
-    {
-        // Switch sur le type d'évènement
-        switch(m_evenements.type)
+    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while(SDL_PollEvent(&m_evenements))
+    {
+        // Switch sur le type d'évènement
+        switch(m_evenements.type)
         {
-        /// Evenements clavier et souris
-            // Cas d'une touche enfoncée
-            case SDL_KEYDOWN:
-                m_touches[m_evenements.key.keysym.sym] = true;
-            break;
-
-            // Cas d'une touche relâchée
-            case SDL_KEYUP:
-                m_touches[m_evenements.key.keysym.sym] = false;
-            break;
-
-            // Cas de pression sur un bouton de la souris
-            case SDL_MOUSEBUTTONDOWN:
-                m_boutonsSouris[m_evenements.button.button] = true;
-            break;
-
-            // Cas du relâchement d'un bouton de la souris
-            case SDL_MOUSEBUTTONUP:
-                m_boutonsSouris[m_evenements.button.button] = false;
-            break;
-
-            // Cas d'un mouvement de souris
+        /// Evenements clavier et souris
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_touches[m_evenements.key.keysym.sym] = true;
+            break;
+
+            // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_touches[m_evenements.key.keysym.sym] = false;
+            break;
+
+            // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenements.button.button] = true;
+            break;
+
+            // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenements.button.button] = false;
+            break;
+
+            // Cas d'un mouvement de souris
             case SDL_MOUSEMOTION:
                 if (m_relativeMouse)
                 {
@@ -83,11 +83,11 @@ void InputAndJoy::updateEvenements()
                     m_y = m_evenements.motion.y;
                     m_xRel = m_evenements.motion.xrel;
                     m_yRel = m_evenements.motion.yrel;
-                }
-
-            break;
-
-            // Cas de la fermeture de la fenêtre
+                }
+
+            break;
+
+            // Cas de la fermeture de la fenêtre
             case SDL_QUIT:
                 m_terminer = true;
             break;
@@ -104,18 +104,18 @@ void InputAndJoy::updateEvenements()
                 break;
             case SDL_JOYBUTTONUP:
                     m_boutonValue[m_evenements.jbutton.button] = false;
-                break;
-
-            default:
-            break;
+                break;
+
+            default:
+            break;
         }
     }
 
     // Pour éviter que la souris se barre en mode relative, on la "warp"
     if (m_relativeMouse)
          SDL_WarpMouse(m_windowHalfWidth, m_windowHalfHeight);
-}
-
+}
+
 int InputAndJoy::getAxeValue(const Uint8 axeID) const
 {
     if (axeID < m_nbAxes)
@@ -124,7 +124,7 @@ int InputAndJoy::getAxeValue(const Uint8 axeID) const
         std::cout << "Axe numéro "<<axeID<<" non-éxistant." << std::endl;
     return -1;
 }
-
+
 bool InputAndJoy::getBoutonPad(const Uint8 bouton) const
 {
     if (bouton<m_nbBoutons)

Control/InputAndJoy.h

@@ -1,37 +1,37 @@
-#ifndef INPUTANDJOY_H_INCLUDED
+#ifndef INPUTANDJOY_H_INCLUDED
 #define INPUTANDJOY_H_INCLUDED
 
 
 ///Jovian
-///Adaptation pour InputAndJoy
-
+///Adaptation pour InputAndJoy
+
 // Include
 #include <vector>
 #include "Input.h"
 
 //Enum
 #define CLAVIER_SOURIS 1
-#define MANETTE 2
-
-// Classe
-class InputAndJoy : public Input
-{
-    public:
-
-    InputAndJoy();
+#define MANETTE 2
+
+// Classe
+class InputAndJoy : public Input
+{
+    public:
+
+    InputAndJoy();
     virtual ~InputAndJoy();
 
-    virtual void updateEvenements();
-
-    int getAxeValue(const Uint8 axeID) const;
+    virtual void updateEvenements();
+
+    int getAxeValue(const Uint8 axeID) const;
     bool getBoutonPad(const Uint8 bouton) const;
 
     void setMainControleur(int type);
-    int getMainCtrl() const;
-
-
-    private:
-
+    int getMainCtrl() const;
+
+
+    private:
+
     SDL_Joystick* m_manette;
     int m_nbAxes;
     int m_nbBoutons;
@@ -39,7 +39,7 @@ class InputAndJoy : public Input
     int const m_seuil;
 
     std::vector<int> m_axeValue;
-    std::vector<bool> m_boutonValue;
-};
-
-#endif // INPUTANDJOY_H_INCLUDED
+    std::vector<bool> m_boutonValue;
+};
+
+#endif // INPUTANDJOY_H_INCLUDED

Control/JoyCtrl.cpp

@@ -1,15 +1,15 @@
-#include "JoyCtrl.h"
-
+#include "JoyCtrl.h"
+
 JoyCtrl::JoyCtrl(InputAndJoy* input)
-:HardCtrl(input)
-{
-    //ctor
-}
-
-JoyCtrl::~JoyCtrl()
-{
-    //dtor
-}
+:HardCtrl(input)
+{
+    //ctor
+}
+
+JoyCtrl::~JoyCtrl()
+{
+    //dtor
+}
 
 void JoyCtrl::update()
 {

Control/JoyCtrl.h

@@ -1,16 +1,16 @@
-#ifndef JOYCTRL_H
-#define JOYCTRL_H
-
-#include "HardCtrl.h"
-
-
-class JoyCtrl : public HardCtrl
-{
-    public:
-        JoyCtrl(InputAndJoy* input);
+#ifndef JOYCTRL_H
+#define JOYCTRL_H
+
+#include "HardCtrl.h"
+
+
+class JoyCtrl : public HardCtrl
+{
+    public:
+        JoyCtrl(InputAndJoy* input);
         virtual ~JoyCtrl();
 
-        void update();
-};
-
-#endif // JOYCTRL_H
+        void update();
+};
+
+#endif // JOYCTRL_H

Jeu.cpp

@@ -1,12 +1,12 @@
-#include "Jeu.h"
-
+#include "Jeu.h"
+
 Jeu::Jeu()
 :m_screen(0x0), m_sprites("Textures/"), m_cursor(0x0), m_terrain(0x0),
 m_input(0x0), m_tirsGest(0x0), m_armGest(0x0), m_persosGest(0x0),
-m_support(0x0), m_persoFocus(0x0), m_nbJoueurs(1)
-{}
-
-Jeu::~Jeu()
+m_support(0x0), m_persoFocus(0x0), m_nbJoueurs(1)
+{}
+
+Jeu::~Jeu()
 {
     SDL_FreeSurface(m_screen);
 
@@ -22,10 +22,10 @@ Jeu::~Jeu()
                 SDL_FreeSurface( m_support[i] );
         delete[] m_support;
     }
-    if ( m_persoFocus != 0x0 ) delete[] m_persoFocus;
+    if ( m_persoFocus != 0x0 ) delete[] m_persoFocus;
 
-    SDL_Quit();
-}
+    SDL_Quit();
+}
 
 bool Jeu::init()
 {
@@ -52,7 +52,7 @@ bool Jeu::init()
     {
         std::cout << "Impossible de créer une fenêtre " <<ecran->current_w<<'*'<<ecran->current_h<< " : " << SDL_GetError() << std::endl;
         return false;
-    }
+    }
     else std::cout << "Création d'une fenêtre " <<ecran->current_w<<'*'<<ecran->current_h<< std::endl;
 
     m_cursor = m_sprites.takeSprite("ViseurUsiane");
@@ -142,8 +142,8 @@ int Jeu::mainLoop()
         m_tirsGest->allMove();
         m_persosGest->nextWave(m_sprites, m_tirsGest, m_armGest);
 
-        // [3.3] Dessin des composants
-        for ( unsigned int i(0); i<m_nbJoueurs; i++ )
+        // [3.3] Dessin des composants
+        for ( unsigned int i(0); i<m_nbJoueurs; i++ )
             afficher(m_persoFocus[i], m_support[i]);
 
         if ( m_nbJoueurs == 2 ) {
@@ -163,10 +163,10 @@ int Jeu::mainLoop()
 
     std::cout << "Environ " << (float)usedTime/nbFrame <<" ms sont utilisées par frame sur " << tFps << std::endl;
     return 0;
-}
-
-void Jeu::afficher( const Perso* focus, SDL_Surface* support )
-{
+}
+
+void Jeu::afficher( const Perso* focus, SDL_Surface* support )
+{
     // Focus OU Caméra libre
     if ( focus->estVivant() ) {
         m_look = focus->getPos();
@@ -177,8 +177,8 @@ void Jeu::afficher( const Perso* focus, SDL_Surface* support )
         if (m_input->getTouche(SDLK_LEFT)) m_look.setX(m_look.getX() - CAM_FREE_SPEED);
         if (m_input->getTouche(SDLK_UP)) m_look.setY(m_look.getY() + CAM_FREE_SPEED);
         if (m_input->getTouche(SDLK_DOWN)) m_look.setY(m_look.getY() - CAM_FREE_SPEED);
-    }
-
+    }
+
     // Nettoyage
     SDL_FillRect( support, 0, 0x141213 );
 
@@ -193,7 +193,7 @@ void Jeu::afficher( const Perso* focus, SDL_Surface* support )
     SDL_Rect posCurseur;
     posCurseur.x = viseur.getX() + support->w/2 - 32;
     posCurseur.y = support->h/2 - viseur.getY() - 32;
-    SDL_BlitSurface(m_cursor, 0, support, &posCurseur);
+    SDL_BlitSurface(m_cursor, 0, support, &posCurseur);
 }
 
 ///FICHIER END

Jeu.h

@@ -1,4 +1,4 @@
-#ifndef JEU_H
+#ifndef JEU_H
 #define JEU_H
 
 #include <iostream>
@@ -13,24 +13,24 @@
 #include "Tirs/Tirs_Gest.h"
 #include "Armes/Armes_Gest.h"
 #include "Structures/SpriteLoader.h"
-#include "Terrain/Terrain.h"
-
-
-class Jeu
-{
-/// Fonctions - - -
-    public:
-        Jeu();
+#include "Terrain/Terrain.h"
+
+
+class Jeu
+{
+/// Fonctions - - -
+    public:
+        Jeu();
         ~Jeu();
 
         bool init();
 
-        int mainLoop();
-
-    protected:
-        void afficher( const Perso* focus, SDL_Surface* support );
+        int mainLoop();
 
-/// Attributs - - -
+    protected:
+        void afficher( const Perso* focus, SDL_Surface* support );
+
+/// Attributs - - -
     protected:
         SDL_Surface* m_screen;
         SpriteLoader m_sprites;
@@ -42,14 +42,14 @@ class Jeu
 
         Tirs_Gest* m_tirsGest;
         Armes_Gest* m_armGest;
-        Persos_Gest* m_persosGest;
+        Persos_Gest* m_persosGest;
 
         SDL_Surface** m_support;
         Perso** m_persoFocus;
         Uint16 m_nbJoueurs;
         SDL_Rect m_scinde;
 
-        Vec m_look;
-};
-
-#endif // JEU_H
+        Vec m_look;
+};
+
+#endif // JEU_H

Persos/DisplayHP.cpp

@@ -1,21 +1,21 @@
-#include "DisplayHP.h"
-
+#include "DisplayHP.h"
+
 DisplayHP::DisplayHP( int vieMax, Uint32 front, Uint32 back, Vec up )
-:Affichable( 0x0 ), m_vieMax( vieMax ), m_front( front ), m_back( back ), m_up( up ), m_vie()
+:Affichable( 0x0 ), m_vieMax( vieMax ), m_front( front ), m_back( back ), m_up( up ), m_vie()
 {
-    /// Création de la surface de barre de vie
+    /// Création de la surface de barre de vie
     cadrer();
 
     /// Remplissage
     m_vie.h = BARRE_EPAIS;
     m_vie.w = vieMax;
-    SDL_FillRect(m_img, 0x0, m_front);
-}
-
-DisplayHP::~DisplayHP()
-{
-    SDL_FreeSurface( m_img );
-}
+    SDL_FillRect(m_img, 0x0, m_front);
+}
+
+DisplayHP::~DisplayHP()
+{
+    SDL_FreeSurface( m_img );
+}
 
 void DisplayHP::updateImg( const int &vie )
 {

Persos/DisplayHP.h

@@ -1,15 +1,15 @@
-#ifndef DISPLAYHP_H
-#define DISPLAYHP_H
+#ifndef DISPLAYHP_H
+#define DISPLAYHP_H
 
 #include "../Structures/Affichable.h"
 
-#define BARRE_EPAIS 5
-
-class DisplayHP : public Affichable
+#define BARRE_EPAIS 5
+
+class DisplayHP : public Affichable
 {
-/// Méthodes
-    public:
-        DisplayHP( int vieMax, Uint32 front = 0x00940C, Uint32 back = 0x2E0000, Vec up = Vec(0.0f, 48.0f) );
+/// Méthodes
+    public:
+        DisplayHP( int vieMax, Uint32 front = 0x00940C, Uint32 back = 0x2E0000, Vec up = Vec(0.0f, 48.0f) );
         virtual ~DisplayHP();
 
         void updateImg( const int &vie );
@@ -20,13 +20,13 @@ class DisplayHP : public Affichable
     protected:
         void cadrer();
 
-/// Attributs
+/// Attributs
     protected:
         int m_vieMax;
         Uint32 m_front;
         Uint32 m_back;
         Vec m_up;
-        SDL_Rect m_vie;
-};
-
-#endif // DISPLAYHP_H
+        SDL_Rect m_vie;
+};
+
+#endif // DISPLAYHP_H

Persos/Perso.cpp

@@ -1,11 +1,11 @@
-#include "Perso.h"
-
+#include "Perso.h"
+
 Perso::Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest)
 :Affichable(rotozoomSurface(srcImg, 90.0, 1.0, 0)),
 /** Vie*/ m_vieMax(100), m_vie(m_vieMax), m_disHP( m_vieMax ),
 /** Etat*/ m_vitesse(4.0f), m_vivant(true), m_allie(allie),
 /** Interactions*/ m_srcImg(srcImg), m_deathImg(deathImg), m_fullImg(0x0), m_visee(1.0f, 0.0f), m_ortho(0.0f, 17.0f), m_ctrl(ctrl), m_tirsGest(tirsGest),
-/** Arme*/ m_armGest( armGest ), m_arme()
+/** Arme*/ m_armGest( armGest ), m_arme()
 {
     // Création de l'image stockant l'apparence
     m_fullImg = SDL_CreateRGBSurface( SDL_HWSURFACE, m_srcImg->w, m_srcImg->h, 32, 0, 0, 0, 0);
@@ -13,7 +13,7 @@ Perso::Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_G
     // On récupère une arme de départ
     m_arme[ L_HAND ] = m_armGest->startWeapon( tirsGest );
     m_arme[ R_HAND ] = 0x0;
-    majFullImg();
+    majFullImg();
 }
 
 Perso::Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest, float x, float y)
@@ -33,17 +33,17 @@ Perso::Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_G
     m_arme[ L_HAND ] = m_armGest->startWeapon( tirsGest );
     m_arme[ R_HAND ] = 0x0;
     majFullImg();
-}
-
-Perso::~Perso()
-{
-    SDL_FreeSurface(m_img);
+}
+
+Perso::~Perso()
+{
+    SDL_FreeSurface(m_img);
     SDL_FreeSurface(m_fullImg);
 
     delete m_ctrl;
     if ( m_arme[ L_HAND ] != 0x0 ) delete m_arme[ L_HAND ];
-    if ( m_arme[ R_HAND ] != 0x0 ) delete m_arme[ R_HAND ];
-}
+    if ( m_arme[ R_HAND ] != 0x0 ) delete m_arme[ R_HAND ];
+}
 
 void Perso::bouger()
 {

Persos/Perso.h

@@ -1,4 +1,4 @@
-#ifndef PERSO_H
+#ifndef PERSO_H
 #define PERSO_H
 
 // Base
@@ -16,15 +16,15 @@
 
 // Tirs
 #include "../Tirs/Tirs_Gest.h"
-#include "../Armes/Armes_Gest.h"
-
-
-class Perso : public Affichable
+#include "../Armes/Armes_Gest.h"
+
+
+class Perso : public Affichable
 {
-/// Fonctions - - -
-    public:
-        Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest);
-        Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest, float x, float y);
+/// Fonctions - - -
+    public:
+        Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest);
+        Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest, float x, float y);
         virtual ~Perso();
 
         void bouger();
@@ -40,7 +40,7 @@ class Perso : public Affichable
     protected:
         void majFullImg();
 
-/// Attributs - - -
+/// Attributs - - -
     protected:
         // Vie
         int m_vieMax;
@@ -67,7 +67,7 @@ class Perso : public Affichable
 
         // Pour tirer
         Armes_Gest* m_armGest;
-        Arme* m_arme[2];
-};
-
-#endif // PERSO_H
+        Arme* m_arme[2];
+};
+
+#endif // PERSO_H

Persos/Persos_Gest.cpp

@@ -2,18 +2,18 @@
 
 #include "../Control/IA/Brute.h"
 #include "../Control/IA/Follower.h"
-#include "../Control/IA/Sniper.h"
-
+#include "../Control/IA/Sniper.h"
+
 Persos_Gest::Persos_Gest()
-:m_nextWave( 1 ), m_loading( true ), m_lastWon( SDL_GetTicks() )
-{
-    //ctor
-}
-
-Persos_Gest::~Persos_Gest()
+:m_nextWave( 1 ), m_loading( true ), m_lastWon( SDL_GetTicks() )
+{
+    //ctor
+}
+
+Persos_Gest::~Persos_Gest()
 {
     std::cout << "Vous êtes allés juqu'à la vague : " << m_nextWave-1 << std::endl;
-    // Destruction des alliés
+    // Destruction des alliés
     while ( !m_allies.empty() ) {
         delete m_allies.back();
         m_allies.pop_back();
@@ -23,8 +23,8 @@ Persos_Gest::~Persos_Gest()
     while ( !m_foes.empty() ) {
         delete m_foes.back();
         m_foes.pop_back();
-    }
-}
+    }
+}
 
 void Persos_Gest::allDisplay(const Vec &lookAt, SDL_Surface* screen) const
 {

Persos/Persos_Gest.h

@@ -1,5 +1,5 @@
-#ifndef PERSOS_GEST_H
-#define PERSOS_GEST_H
+#ifndef PERSOS_GEST_H
+#define PERSOS_GEST_H
 
 #include <iostream>
 #include <vector>
@@ -7,12 +7,12 @@
 #include "Perso.h"
 #include "../Structures/SpriteLoader.h"
 /*#include "../Control/IACtrl.h" */ class IACtrl;
-
-
-class Persos_Gest
-{
-    public:
-        Persos_Gest();
+
+
+class Persos_Gest
+{
+    public:
+        Persos_Gest();
         virtual ~Persos_Gest();
 
         void allDisplay(const Vec &lookAt, SDL_Surface* screen) const;
@@ -27,15 +27,15 @@ class Persos_Gest
 
         void nextWave( SpriteLoader &skinGiver, Tirs_Gest* tirsGest, Armes_Gest* armGest);
         IACtrl* createRandIA();
-
+
     protected:
         std::vector<Perso*> m_allies;
         std::vector<Perso*> m_foes;
 
         unsigned int m_nextWave;
         bool m_loading;
-        Uint32 m_lastWon;
+        Uint32 m_lastWon;
 };
-
-
-#endif // PERSOS_GEST_H
+
+
+#endif // PERSOS_GEST_H

Structures/Affichable.cpp

@@ -1,15 +1,15 @@
-#include "Affichable.h"
-
+#include "Affichable.h"
+
 Affichable::Affichable(SDL_Surface* img)
-:m_img(img), m_pos(0.0f, 0.0f)
-{
-    //ctor
-}
-
-Affichable::~Affichable()
-{
-    //dtor
-}
+:m_img(img), m_pos(0.0f, 0.0f)
+{
+    //ctor
+}
+
+Affichable::~Affichable()
+{
+    //dtor
+}
 
 void Affichable::afficher(const Vec &lookAt, SDL_Surface* screen)
 {

Structures/Affichable.h

@@ -1,22 +1,22 @@
-#ifndef AFFICHABLE_H
-#define AFFICHABLE_H
+#ifndef AFFICHABLE_H
+#define AFFICHABLE_H
 
 #include <iostream>
 #include <SDL.h>
-#include "../Structures/Vecteur.h"
-
-class Affichable
-{
-    public:
-        Affichable(SDL_Surface* img);
+#include "../Structures/Vecteur.h"
+
+class Affichable
+{
+    public:
+        Affichable(SDL_Surface* img);
         virtual ~Affichable();
 
         void virtual afficher(const Vec &lookAt, SDL_Surface* screen);
-
+
     protected:
         SDL_Surface* m_img;
         SDL_Rect m_rect;
-        Vec m_pos;
-};
-
-#endif // AFFICHABLE_H
+        Vec m_pos;
+};
+
+#endif // AFFICHABLE_H

Structures/SpriteLoader.cpp

@@ -1,46 +1,46 @@
-#include "SpriteLoader.h"
-
+#include "SpriteLoader.h"
+
 SpriteLoader::SpriteLoader()
-: m_folder(""), m_optiFormat(true)
-{}
-
+: m_folder(""), m_optiFormat(true)
+{}
+
 SpriteLoader::SpriteLoader(std::string folder)
-: m_folder(folder), m_optiFormat(true)
-{}
-
+: m_folder(folder), m_optiFormat(true)
+{}
+
 SpriteLoader::SpriteLoader(std::string folder, bool optiFormat)
-: m_folder(folder), m_optiFormat(optiFormat)
-{}
-
-SpriteLoader::~SpriteLoader()
-{
-    for( m_it = m_paquet.begin(); m_it != m_paquet.end(); m_it++ )
-    {
-        SDL_FreeSurface(m_it->second);
-        m_it->second = 0x0;
-    }
-}
-
-SDL_Surface* SpriteLoader::takeSprite(std::string nom)
-{
-    // Cherche la surface dans le tableau
-    m_it = m_paquet.find(nom);
-
-    // Si la surface est déjà chargée, on la donne
-    if (m_it != m_paquet.end())
-    {
-        return m_it->second;
-    }
-
-    // Sinon on la charge
-    else
-    {
-        std::string source(m_folder + nom + ".bmp");
-        m_paquet[nom] = SDL_LoadBMP(source.c_str());
-        if (m_paquet[nom] == 0)
-        {
-            m_paquet[nom] = SDL_CreateRGBSurface(SDL_HWSURFACE, 40, 40, 32, 0, 0, 0, 0);
-            std::cout << "La texture " <<nom<< " n'a pas pu être chargée." << std::endl << std::endl;
+: m_folder(folder), m_optiFormat(optiFormat)
+{}
+
+SpriteLoader::~SpriteLoader()
+{
+    for( m_it = m_paquet.begin(); m_it != m_paquet.end(); m_it++ )
+    {
+        SDL_FreeSurface(m_it->second);
+        m_it->second = 0x0;
+    }
+}
+
+SDL_Surface* SpriteLoader::takeSprite(std::string nom)
+{
+    // Cherche la surface dans le tableau
+    m_it = m_paquet.find(nom);
+
+    // Si la surface est déjà chargée, on la donne
+    if (m_it != m_paquet.end())
+    {
+        return m_it->second;
+    }
+
+    // Sinon on la charge
+    else
+    {
+        std::string source(m_folder + nom + ".bmp");
+        m_paquet[nom] = SDL_LoadBMP(source.c_str());
+        if (m_paquet[nom] == 0)
+        {
+            m_paquet[nom] = SDL_CreateRGBSurface(SDL_HWSURFACE, 40, 40, 32, 0, 0, 0, 0);
+            std::cout << "La texture " <<nom<< " n'a pas pu être chargée." << std::endl << std::endl;
         }
 
         // Si on doit optimiser
@@ -49,42 +49,42 @@ SDL_Surface* SpriteLoader::takeSprite(std::string nom)
             SDL_Surface* src = m_paquet[nom];
             m_paquet[nom] = SDL_DisplayFormat(src);
             SDL_FreeSurface(src);
-        }
-
-        return m_paquet[nom];
-    }
+        }
+
+        return m_paquet[nom];
+    }
 }
 
 void SpriteLoader::destroySprite(std::string nom)
 {
-    // Cherche la surface dans le tableau
-    m_it = m_paquet.find(nom);
-
-    // Si la surface est déjà chargée, on la donne
-    if (m_it != m_paquet.end())
-    {
+    // Cherche la surface dans le tableau
+    m_it = m_paquet.find(nom);
+
+    // Si la surface est déjà chargée, on la donne
+    if (m_it != m_paquet.end())
+    {
         SDL_FreeSurface(m_it->second);
-        m_paquet.erase(m_it);
+        m_paquet.erase(m_it);
+    }
+}
+
+void SpriteLoader::addSprite(std::string nom, SDL_Surface* sprite)
+{
+    m_it = m_paquet.find(nom);
+    if (m_it == m_paquet.end())
+    {
+        m_paquet[nom] = sprite;
+        return;
+    }
+    else
+    {
+        std::cout << "Attention ! La texture " <<nom<< " a déjà une surface associée. Destruction de la nouvelle surface." << std::endl;
+        SDL_FreeSurface(sprite);
     }
-}
-
-void SpriteLoader::addSprite(std::string nom, SDL_Surface* sprite)
-{
-    m_it = m_paquet.find(nom);
-    if (m_it == m_paquet.end())
-    {
-        m_paquet[nom] = sprite;
-        return;
-    }
-    else
-    {
-        std::cout << "Attention ! La texture " <<nom<< " a déjà une surface associée. Destruction de la nouvelle surface." << std::endl;
-        SDL_FreeSurface(sprite);
-    }
-}
-
-void SpriteLoader::assignFolder(std::string folder)
-{
-    m_folder = folder;
-}
-
+}
+
+void SpriteLoader::assignFolder(std::string folder)
+{
+    m_folder = folder;
+}
+

Structures/SpriteLoader.h

@@ -1,32 +1,32 @@
-#ifndef SPRITELOADER_H_INCLUDED
-#define SPRITELOADER_H_INCLUDED
-
-#include <iostream>
-#include <string>
-#include <map>
-#include <SDL.h>
-
-class SpriteLoader
-{
-public:
-
-    SpriteLoader();
-    SpriteLoader(std::string folder);
-    SpriteLoader(std::string folder, bool optiFormat);
-    ~SpriteLoader();
-
+#ifndef SPRITELOADER_H_INCLUDED
+#define SPRITELOADER_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <map>
+#include <SDL.h>
+
+class SpriteLoader
+{
+public:
+
+    SpriteLoader();
+    SpriteLoader(std::string folder);
+    SpriteLoader(std::string folder, bool optiFormat);
+    ~SpriteLoader();
+
     SDL_Surface* takeSprite(std::string nom);
-    void destroySprite(std::string nom);
-    void addSprite(std::string nom, SDL_Surface* sprite);
-    void assignFolder(std::string folder);
-
-private:
-
-    std::string m_folder;
-    std::map<std::string, SDL_Surface*>::iterator m_it;
+    void destroySprite(std::string nom);
+    void addSprite(std::string nom, SDL_Surface* sprite);
+    void assignFolder(std::string folder);
+
+private:
+
+    std::string m_folder;
+    std::map<std::string, SDL_Surface*>::iterator m_it;
     std::map<std::string, SDL_Surface*> m_paquet;
-    bool m_optiFormat; // True par défaut
-
-};
-
-#endif // SPRITELOADER_H_INCLUDED
+    bool m_optiFormat; // True par défaut
+
+};
+
+#endif // SPRITELOADER_H_INCLUDED

Structures/Vecteur.cpp

@@ -1,219 +1,219 @@
-#include "Vecteur.h"
+#include "Vecteur.h"
 
-///Constructeurs
-Vec::Vec() : m_x(0.0), m_y(0.0), m_z(0.0)
+///Constructeurs
+Vec::Vec() : m_x(0.0), m_y(0.0), m_z(0.0)
 {}
-
-Vec::Vec(float x, float y, float z) : m_x(x), m_y(y), m_z(z)
+
+Vec::Vec(float x, float y, float z) : m_x(x), m_y(y), m_z(z)
 {}
-
-Vec::Vec(const Vec &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
+
+Vec::Vec(const Vec &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
 {}
-
-Vec::~Vec()
+
+Vec::~Vec()
 {}
 
-///Fonctions
-void Vec::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.0f)
-    {
-        m_x /= longueur;
-        m_y /= longueur;
-        m_z /= longueur;
-    }
-}
-
-float Vec::scalair(const Vec &vecteur) const
-{
-    Vec v1(*this), v2(vecteur);
-    v1.normaliser();
-    v2.normaliser();
-    return v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
-}
-
-double Vec::norme() const
-{
-    return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
-}
-
-void Vec::rotateR(float angle)
-{
-    float tmp = m_x;
-    m_x = cos(angle)*m_x-sin(angle)*m_y;
-    m_y = sin(angle)*tmp+cos(angle)*m_y;
-}
-
-void Vec::rotateD(float angle)
-{
-    float _angle = angle * M_PI / 180.0;
-    float tmp = m_x;
-    m_x = cos(_angle)*m_x-sin(_angle)*m_y;
-    m_y = sin(_angle)*tmp+cos(_angle)*m_y;
-}
-
-///Getters
-float Vec::getX() const
-{
-    return m_x;
-}
-
-float Vec::getY() const
-{
-    return m_y;
-}
-
-float Vec::getZ() const
-{
-    return m_z;
-}
-
-/// Setters
-void Vec::setVecteur(float x, float y, float z)
-{
-    m_x = x;
-    m_y = y;
-    m_z = z;
-}
-
-void Vec::setX(float x)
-{
-    m_x = x;
-}
-
-void Vec::setY(float y)
-{
-    m_y = y;
-}
-
-void Vec::setZ(float z)
-{
-    m_z = z;
-}
-
-///Opérateurs
-Vec& Vec::operator=(const Vec &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;
-}
-
-Vec Vec::operator+(const Vec &vecteur)
-{
-    // Création d'un objet résultat
-    Vec 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;
-}
-
-Vec Vec::operator-(const Vec &vecteur)
-{
-    // Création d'un objet résultat
-    Vec 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;
-}
-
-Vec Vec::operator*(float multiplicateur)
-{
-    // Création d'un objet résultat
-    Vec 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;
-}
-
-Vec Vec::operator/(float diviseur)
-{
-    // Création d'un objet résultat
-    Vec 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;
-}
-
-Vec Vec::operator*(const Vec &vecteur)
-{
-    // Création d'un objet résultat
-    Vec 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 Vec::operator*=(const Vec &vecteur)
-{
-    *this = *this * vecteur;
-}
-
-void Vec::operator-=(const Vec &vecteur)
-{
-    *this = *this - vecteur;
-}
-
-void Vec::operator+=(const Vec &vecteur)
-{
-    *this = *this + vecteur;
-}
-
-void Vec::operator*=(float multiplicateur)
-{
-    *this = *this * multiplicateur;
-}
-
-void Vec::operator/=(float multiplicateur)
-{
-    *this = *this * multiplicateur;
-}
-
-bool Vec::operator==(const Vec &vecteur)
-{
-    if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
-        return true;
-    else
-        return false;
-}
-
-bool Vec::operator!=(const Vec &vecteur)
-{
-    if(*this == vecteur)
-        return false;
-    else
-        return true;
-}
+///Fonctions
+void Vec::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.0f)
+    {
+        m_x /= longueur;
+        m_y /= longueur;
+        m_z /= longueur;
+    }
+}
+
+float Vec::scalair(const Vec &vecteur) const
+{
+    Vec v1(*this), v2(vecteur);
+    v1.normaliser();
+    v2.normaliser();
+    return v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
+}
+
+double Vec::norme() const
+{
+    return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
+}
+
+void Vec::rotateR(float angle)
+{
+    float tmp = m_x;
+    m_x = cos(angle)*m_x-sin(angle)*m_y;
+    m_y = sin(angle)*tmp+cos(angle)*m_y;
+}
+
+void Vec::rotateD(float angle)
+{
+    float _angle = angle * M_PI / 180.0;
+    float tmp = m_x;
+    m_x = cos(_angle)*m_x-sin(_angle)*m_y;
+    m_y = sin(_angle)*tmp+cos(_angle)*m_y;
+}
+
+///Getters
+float Vec::getX() const
+{
+    return m_x;
+}
+
+float Vec::getY() const
+{
+    return m_y;
+}
+
+float Vec::getZ() const
+{
+    return m_z;
+}
+
+/// Setters
+void Vec::setVecteur(float x, float y, float z)
+{
+    m_x = x;
+    m_y = y;
+    m_z = z;
+}
+
+void Vec::setX(float x)
+{
+    m_x = x;
+}
+
+void Vec::setY(float y)
+{
+    m_y = y;
+}
+
+void Vec::setZ(float z)
+{
+    m_z = z;
+}
+
+///Opérateurs
+Vec& Vec::operator=(const Vec &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;
+}
+
+Vec Vec::operator+(const Vec &vecteur)
+{
+    // Création d'un objet résultat
+    Vec 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;
+}
+
+Vec Vec::operator-(const Vec &vecteur)
+{
+    // Création d'un objet résultat
+    Vec 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;
+}
+
+Vec Vec::operator*(float multiplicateur)
+{
+    // Création d'un objet résultat
+    Vec 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;
+}
+
+Vec Vec::operator/(float diviseur)
+{
+    // Création d'un objet résultat
+    Vec 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;
+}
+
+Vec Vec::operator*(const Vec &vecteur)
+{
+    // Création d'un objet résultat
+    Vec 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 Vec::operator*=(const Vec &vecteur)
+{
+    *this = *this * vecteur;
+}
+
+void Vec::operator-=(const Vec &vecteur)
+{
+    *this = *this - vecteur;
+}
+
+void Vec::operator+=(const Vec &vecteur)
+{
+    *this = *this + vecteur;
+}
+
+void Vec::operator*=(float multiplicateur)
+{
+    *this = *this * multiplicateur;
+}
+
+void Vec::operator/=(float multiplicateur)
+{
+    *this = *this * multiplicateur;
+}
+
+bool Vec::operator==(const Vec &vecteur)
+{
+    if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
+        return true;
+    else
+        return false;
+}
+
+bool Vec::operator!=(const Vec &vecteur)
+{
+    if(*this == vecteur)
+        return false;
+    else
+        return true;
+}

Structures/Vecteur.h

@@ -1,15 +1,15 @@
-#ifndef VECTEUR_H_INCLUDED
-#define VECTEUR_H_INCLUDED
-
-#include <cmath>
-
-class Vec
-{
-public:
-
-    Vec();
-    Vec(float x, float y, float z = 0);
-    Vec(const Vec &vecteur);
+#ifndef VECTEUR_H_INCLUDED
+#define VECTEUR_H_INCLUDED
+
+#include <cmath>
+
+class Vec
+{
+public:
+
+    Vec();
+    Vec(float x, float y, float z = 0);
+    Vec(const Vec &vecteur);
     ~Vec();
 
     void normaliser();
@@ -17,38 +17,38 @@ public:
     double norme() const;
     void rotateR(float angle); // angle en radians
     void rotateD(float angle); // angle en degrés
-
-    float getX() const;
-    float getY() const;
+
+    float getX() const;
+    float getY() const;
     float getZ() const;
-
-    void setVecteur(float x, float y, float z = 0);
-    void setX(float x);
-    void setY(float y);
+
+    void setVecteur(float x, float y, float z = 0);
+    void setX(float x);
+    void setY(float y);
     void setZ(float z);
-
-    Vec& operator=(const Vec &vecteur);
-    Vec operator+(const Vec &vecteur);
-    Vec operator-(const Vec &vecteur);
-    Vec operator*(float multiplicateur);
-    Vec operator/(float diviseur);
+
+    Vec& operator=(const Vec &vecteur);
+    Vec operator+(const Vec &vecteur);
+    Vec operator-(const Vec &vecteur);
+    Vec operator*(float multiplicateur);
+    Vec operator/(float diviseur);
     Vec operator*(const Vec &vecteur);
-
-    void operator*=(const Vec &vecteur);
-    void operator-=(const Vec &vecteur);
-    void operator+=(const Vec &vecteur);
-    void operator*=(float multiplicateur);
+
+    void operator*=(const Vec &vecteur);
+    void operator-=(const Vec &vecteur);
+    void operator+=(const Vec &vecteur);
+    void operator*=(float multiplicateur);
     void operator/=(float multiplicateur);
 
-
-    bool operator==(const Vec &vecteur);
+
+    bool operator==(const Vec &vecteur);
     bool operator!=(const Vec &vecteur);
-
-
-private:
-    float m_x;
-    float m_y;
-    float m_z;
-};
-
-#endif // VECTEUR_H_INCLUDED
+
+
+private:
+    float m_x;
+    float m_y;
+    float m_z;
+};
+
+#endif // VECTEUR_H_INCLUDED

Terrain/Chunk.cpp

@@ -1,12 +1,12 @@
-#include "Chunk.h"
-
+#include "Chunk.h"
+
 Chunk::Chunk(SDL_Surface* imgDyn, int x, int y)
-:Affichable(imgDyn)
-{
-    m_pos.setVecteur(x * LG_CHUNK, y * LG_CHUNK);
-}
-
-Chunk::~Chunk()
-{
-    SDL_FreeSurface(m_img);
-}
+:Affichable(imgDyn)
+{
+    m_pos.setVecteur(x * LG_CHUNK, y * LG_CHUNK);
+}
+
+Chunk::~Chunk()
+{
+    SDL_FreeSurface(m_img);
+}

Terrain/Chunk.h

@@ -1,18 +1,18 @@
-#ifndef CHUNK_H
-#define CHUNK_H
+#ifndef CHUNK_H
+#define CHUNK_H
 
 #include "../Structures/Affichable.h"
 
-#define LG_CHUNK 3000
-
-class Chunk : public Affichable
-{
-    public:
-        Chunk(SDL_Surface* imgDyn, int x, int y);
+#define LG_CHUNK 3000
+
+class Chunk : public Affichable
+{
+    public:
+        Chunk(SDL_Surface* imgDyn, int x, int y);
         virtual ~Chunk(); // Détruit l'image
-
+
     protected:
-
-};
-
-#endif // CHUNK_H
+
+};
+
+#endif // CHUNK_H

Terrain/Terrain.cpp

@@ -1,10 +1,10 @@
-#include "Terrain.h"
-
+#include "Terrain.h"
+
 Terrain::Terrain(SDL_Surface* img)
-:Affichable(img)
+:Affichable(img)
 {
     SDL_Surface *tmpImg, *model;
-    m_rect.w = m_rect.h = LG_CHUNK;
+    m_rect.w = m_rect.h = LG_CHUNK;
     for (int x(0); x<NB_X_CHUNK; x++)
         for (int y(0); y<NB_Y_CHUNK; y++)
         {
@@ -21,15 +21,15 @@ Terrain::Terrain(SDL_Surface* img)
 
             // Création du chunk
             m_chunk[NB_Y_CHUNK-y-1][x] = new Chunk(tmpImg, x, NB_Y_CHUNK-y-1);
-        }
-}
-
-Terrain::~Terrain()
-{
+        }
+}
+
+Terrain::~Terrain()
+{
     for (int x(0); x<NB_X_CHUNK; x++)
         for (int y(0); y<NB_Y_CHUNK; y++)
-            delete m_chunk[y][x];
-}
+            delete m_chunk[y][x];
+}
 
 void Terrain::afficher(const Vec &lookAt, SDL_Surface* screen) const
 {

Terrain/Terrain.h

@@ -1,4 +1,4 @@
-#ifndef TERRAIN_H
+#ifndef TERRAIN_H
 #define TERRAIN_H
 
 #include <iostream>
@@ -6,21 +6,21 @@
 #include "Chunk.h"
 
 #define NB_Y_CHUNK 3000/LG_CHUNK
-#define NB_X_CHUNK 6000/LG_CHUNK
-
-
-class Terrain : public Affichable
-{
-    public:
-        Terrain(SDL_Surface* img);
+#define NB_X_CHUNK 6000/LG_CHUNK
+
+
+class Terrain : public Affichable
+{
+    public:
+        Terrain(SDL_Surface* img);
         virtual ~Terrain();
 
         void virtual afficher(const Vec &lookAt, SDL_Surface* screen) const;
-
+
     protected:
         Chunk* m_chunk[NB_Y_CHUNK][NB_X_CHUNK];//[y][x]
 
-        //Un jour il y aura des choses permettant la gestion des collisions
-};
-
-#endif // TERRAIN_H
+        //Un jour il y aura des choses permettant la gestion des collisions
+};
+
+#endif // TERRAIN_H

Tirs/Tir.cpp

@@ -1,36 +1,36 @@
-#include "Tir.h"
-
+#include "Tir.h"
+
 Tir::Tir(SDL_Surface* img, Vec pos, Vec visee, int degats, bool allie)
-:Affichable(img), m_degats(degats), m_exist(true), m_vitesse(20.0f), m_allie(allie)
-{
+:Affichable(img), m_degats(degats), m_exist(true), m_vitesse(20.0f), m_allie(allie)
+{
     m_dir = visee;
     m_dir.normaliser();
 
-    m_pos = pos + m_dir * 30.0f;
-}
-
-Tir::~Tir()
+    m_pos = pos + m_dir * 30.0f;
+}
+
+Tir::~Tir()
 {}
 
 void Tir::afficher(const Vec &lookAt, SDL_Surface* screen)
 {
     if ( m_exist ) Affichable::afficher(lookAt, screen);
-}
+}
 
-void Tir::move()
-{
+void Tir::move()
+{
     m_pos += m_dir * m_vitesse;
     if (m_pos.getX() > 4500 || m_pos.getX() < -1500 || m_pos.getY() > 1500 || m_pos.getY() < -1500)
         m_exist = false;
-}
+}
 
-int Tir::encaisser(const Vec &pos, bool allie)
+int Tir::encaisser(const Vec &pos, bool allie)
 {
     // Si le tir ne collisionne pas
     if ( !m_exist ) return 0;// Déjà encaissé
     if ( m_allie==allie ) return 0;// On ne touche pas les amis
 
-    // Mesure distance
+    // Mesure distance
     Vec distance = m_pos - pos;
     if (distance.norme() < 32.0f)
     {
@@ -39,10 +39,10 @@ int Tir::encaisser(const Vec &pos, bool allie)
         return m_degats;
     }
     // Pas touché
-    else return 0;
-}
+    else return 0;
+}
 
-bool Tir::exist() const
-{
-    return m_exist;
-}
+bool Tir::exist() const
+{
+    return m_exist;
+}

Tirs/Tir.h

@@ -1,15 +1,15 @@
-#ifndef TIR_H
-#define TIR_H
+#ifndef TIR_H
+#define TIR_H
 
 #include <iostream>
 #include "../Structures/Affichable.h"
 #include "../Structures/Vecteur.h"
-
-
-class Tir : public Affichable
-{
-    public:
-        Tir(SDL_Surface* img, Vec pos, Vec visee, int degats, bool allie);
+
+
+class Tir : public Affichable
+{
+    public:
+        Tir(SDL_Surface* img, Vec pos, Vec visee, int degats, bool allie);
         virtual ~Tir();
 
         void virtual afficher(const Vec &lookAt, SDL_Surface* screen); // Empêche l'affichage si déjà encaissé
@@ -17,14 +17,14 @@ class Tir : public Affichable
         void move();
         int encaisser(const Vec &pos, bool allie);
         bool exist() const;
-
+
     protected:
         int m_degats;
         bool m_exist;
         float m_vitesse;
         bool m_allie;
 
-        Vec m_dir;
-};
-
-#endif // TIR_H
+        Vec m_dir;
+};
+
+#endif // TIR_H

Tirs/Tirs_Gest.cpp

@@ -1,22 +1,22 @@
-#include "Tirs_Gest.h"
-
+#include "Tirs_Gest.h"
+
 Tirs_Gest::Tirs_Gest(SDL_Surface* blueTir, SDL_Surface* redTir)
-:m_tirs(0), m_blueImg(blueTir), m_redImg(redTir)
-{
-    SDL_SetColorKey(m_blueImg, SDL_SRCCOLORKEY, SDL_MapRGBA(m_blueImg->format, 0, 0, 0, 255));
-    SDL_SetColorKey(m_redImg, SDL_SRCCOLORKEY, SDL_MapRGBA(m_redImg->format, 0, 0, 0, 255));
-}
-
-Tirs_Gest::~Tirs_Gest()
+:m_tirs(0), m_blueImg(blueTir), m_redImg(redTir)
+{
+    SDL_SetColorKey(m_blueImg, SDL_SRCCOLORKEY, SDL_MapRGBA(m_blueImg->format, 0, 0, 0, 255));
+    SDL_SetColorKey(m_redImg, SDL_SRCCOLORKEY, SDL_MapRGBA(m_redImg->format, 0, 0, 0, 255));
+}
+
+Tirs_Gest::~Tirs_Gest()
 {
     // Nettoyage
     while ( !m_tirs.empty() ) {
         delete m_tirs.front();
         m_tirs.pop_front();
     }
-}
+}
 
-void Tirs_Gest::allDisplay(const Vec &lookAt, SDL_Surface* screen)
+void Tirs_Gest::allDisplay(const Vec &lookAt, SDL_Surface* screen)
 {
     // Nettoyage
     while ( !m_tirs.empty() && !m_tirs.front()->exist() ) {
@@ -24,31 +24,31 @@ void Tirs_Gest::allDisplay(const Vec &lookAt, SDL_Surface* screen)
         m_tirs.pop_front();
     }
 
-    // Affichage
+    // Affichage
     for (unsigned int i(0); i < m_tirs.size(); i++)
-        m_tirs[i]->afficher(lookAt, screen);
+        m_tirs[i]->afficher(lookAt, screen);
 }
 
 void Tirs_Gest::allMove() const
 {
     for (unsigned int i(0); i < m_tirs.size(); i++)
         m_tirs[i]->move();
-}
+}
 
-void Tirs_Gest::addTir(Vec pos, Vec visee, int degats, bool allie)
+void Tirs_Gest::addTir(Vec pos, Vec visee, int degats, bool allie)
 {
-    SDL_Surface* tirImg(0x0);
+    SDL_Surface* tirImg(0x0);
     m_tirs.push_back(0x0);
     if ( allie ) tirImg = m_blueImg;
     else tirImg = m_redImg;
-    m_tirs.back() = new Tir(tirImg, pos, visee, degats, allie);
-}
+    m_tirs.back() = new Tir(tirImg, pos, visee, degats, allie);
+}
 
-int Tirs_Gest::encaisser(Vec pos, bool allie) const
-{
+int Tirs_Gest::encaisser(Vec pos, bool allie) const
+{
     int somme(0);
     for (unsigned int i(0); i < m_tirs.size(); i++)
         somme += m_tirs[i]->encaisser(pos, allie);
 
-    return somme;
-}
+    return somme;
+}

Tirs/Tirs_Gest.h

@@ -1,13 +1,13 @@
-#ifndef TIRS_GEST_H
-#define TIRS_GEST_H
+#ifndef TIRS_GEST_H
+#define TIRS_GEST_H
 
 #include "Tir.h"
-#include <deque>
-
-class Tirs_Gest
-{
-    public:
-        Tirs_Gest(SDL_Surface* blueTir, SDL_Surface* redTir);
+#include <deque>
+
+class Tirs_Gest
+{
+    public:
+        Tirs_Gest(SDL_Surface* blueTir, SDL_Surface* redTir);
         virtual ~Tirs_Gest();
 
         void allDisplay(const Vec &lookAt, SDL_Surface* screen); // Nettoie également les tirs périmés
@@ -15,11 +15,11 @@ class Tirs_Gest
 
         void addTir(Vec pos, Vec visee, int degats, bool allie);
         int encaisser(Vec pos, bool allie) const;
-
+
     protected:
         std::deque<Tir*> m_tirs;
         SDL_Surface* m_blueImg;
-        SDL_Surface* m_redImg;
-};
-
-#endif // TIRS_GEST_H
+        SDL_Surface* m_redImg;
+};
+
+#endif // TIRS_GEST_H