Remove Microsoft Windows end of line

Replace CRLF by LF

Collisions.cpp

@@ -1,82 +1,82 @@
 #include "Collisions.h"
 
-Collisions::Collisions(SDL_Surface *screen, int const xBlocSize, int const yBlocSize)
+Collisions::Collisions(SDL_Surface *screen, int const xBlocSize, int const yBlocSize)
 : m_screen(screen), m_xSize(xBlocSize), m_ySize(yBlocSize)
-{
-    // Tableau dynamique
-    m_tableau = new int*[yBlocSize];
-    for (int i(0); i<yBlocSize; i++)
-        m_tableau[i] = new int[xBlocSize];
-
-    // Différents murs
-    m_carreStd = SDL_LoadBMP("Textures/Mur.bmp");
-    for (int i(0); i<12; i++)
-        m_carre[i] = colorMightyObjet(m_carreStd, i);
-
-    // Autres images
-    m_sol = SDL_LoadBMP("Textures/Sol.bmp");
-    m_terrain = SDL_CreateRGBSurface(SDL_HWSURFACE, m_screen->w, m_screen->h, 32, 0, 0, 0, 0);
-    m_position.x = m_position.y = 0;
-
-    // Initialisation standard
+{
+    // Tableau dynamique
+    m_tableau = new int*[yBlocSize];
+    for (int i(0); i<yBlocSize; i++)
+        m_tableau[i] = new int[xBlocSize];
+
+    // Différents murs
+    m_carreStd = SDL_LoadBMP("Textures/Mur.bmp");
+    for (int i(0); i<12; i++)
+        m_carre[i] = colorMightyObjet(m_carreStd, i);
+
+    // Autres images
+    m_sol = SDL_LoadBMP("Textures/Sol.bmp");
+    m_terrain = SDL_CreateRGBSurface(SDL_HWSURFACE, m_screen->w, m_screen->h, 32, 0, 0, 0, 0);
+    m_position.x = m_position.y = 0;
+
+    // Initialisation standard
     reinitialiser();
 }///Constructeur
 
 Collisions::~Collisions()
-{
-    // Destruction du tableau dynamique
-    for (int i(0); i < m_ySize; i++)
-        delete[] m_tableau[i];
-    delete[] m_tableau;
-    m_tableau = 0;
-
-    // Libération des surfaces
+{
+    // Destruction du tableau dynamique
+    for (int i(0); i < m_ySize; i++)
+        delete[] m_tableau[i];
+    delete[] m_tableau;
+    m_tableau = 0;
+
+    // Libération des surfaces
     for (int i(0); i<4; i++)
         SDL_FreeSurface(m_carre[i]);
-    SDL_FreeSurface(m_sol);
-    SDL_FreeSurface(m_terrain);
+    SDL_FreeSurface(m_sol);
+    SDL_FreeSurface(m_terrain);
     SDL_FreeSurface(m_carreStd);
 }///Destructeur
 
 void Collisions::ajouter(int x, int y, int ID)
-{
-    // Correction position
-    coorectPos(x, y);
-
-    // Blitage de surface
+{
+    // Correction position
+    coorectPos(x, y);
+
+    // Blitage de surface
     m_position.y=y*20;
-    m_position.x=x*20;
-    if (0<=ID && ID<=4 && (m_tableau[y][x]==VIDE || m_tableau[y][x] == ID))
-    {
-        m_tableau[y][x] = ID;
-        SDL_BlitSurface(m_carre[ID], 0, m_terrain, &m_position);
-    }
-    else
-    {
-        m_tableau[y][x] = NEUTRE;
-        SDL_BlitSurface(m_carreStd, 0, m_terrain, &m_position);
-    }
-
-    // Signalement
+    m_position.x=x*20;
+    if (0<=ID && ID<=4 && (m_tableau[y][x]==VIDE || m_tableau[y][x] == ID))
+    {
+        m_tableau[y][x] = ID;
+        SDL_BlitSurface(m_carre[ID], 0, m_terrain, &m_position);
+    }
+    else
+    {
+        m_tableau[y][x] = NEUTRE;
+        SDL_BlitSurface(m_carreStd, 0, m_terrain, &m_position);
+    }
+
+    // Signalement
 
 }///ajouter
 
 void Collisions::enlever(int x, int y)
-{
-    // Correction position
-    coorectPos(x, y);
-
-    // Blitage de surface
+{
+    // Correction position
+    coorectPos(x, y);
+
+    // Blitage de surface
     m_position.y=y*20;
     m_position.x=x*20;
-    SDL_BlitSurface(m_sol, 0, m_terrain, &m_position);
-
-    // Signalement
+    SDL_BlitSurface(m_sol, 0, m_terrain, &m_position);
+
+    // Signalement
     m_tableau[y][x] = VIDE;
 }///enlever
 
 int Collisions::tester(int x,int y) const
-{
+{
     coorectPos(x,y);
     return m_tableau[y][x];
 }///tester
@@ -92,30 +92,30 @@ void Collisions::reinitialiser()
     {
         for (int j(0); j < m_xSize; j++)
         {
-            m_tableau[i][j] = VIDE;
+            m_tableau[i][j] = VIDE;
             m_position.y = i*20;
             m_position.x = j*20;
             SDL_BlitSurface(m_sol, 0, m_terrain, &m_position);
         }
     }
-}///reinitialiser
-
-void Collisions::coorectPos(int &x, int &y) const
-{
-    while ( x >= m_xSize )
-        x -= m_xSize;
-    while ( x < 0 )
-        x += m_xSize;
-    while ( y >= m_ySize )
-        y -= m_ySize;
-    while ( y < 0 )
-        y += m_ySize;
+}///reinitialiser
+
+void Collisions::coorectPos(int &x, int &y) const
+{
+    while ( x >= m_xSize )
+        x -= m_xSize;
+    while ( x < 0 )
+        x += m_xSize;
+    while ( y >= m_ySize )
+        y -= m_ySize;
+    while ( y < 0 )
+        y += m_ySize;
 }///coorectPos
-
-int Collisions::getSize(int idCoord)
-{
-    if (idCoord) // y -> 1
-        return m_ySize;
-    else // x -> 0
-        return m_xSize;
-}
+
+int Collisions::getSize(int idCoord)
+{
+    if (idCoord) // y -> 1
+        return m_ySize;
+    else // x -> 0
+        return m_xSize;
+}

Collisions.h

@@ -1,57 +1,57 @@
-#ifndef COLLISIONS_H_INCLUDED
+#ifndef COLLISIONS_H_INCLUDED
 #define COLLISIONS_H_INCLUDED
-
+
 //Includes
-#include <iostream>
-#include <SDL/SDL.h>
-#include "traitement.h"
-
+#include <iostream>
+#include <SDL/SDL.h>
+#include "traitement.h"
+
 //Orientation
 #define HAUT 0
 #define DROITE 1
 #define BAS 2
-#define GAUCHE 3
-
-//Define du mur
-#define VIDE -1 //Pas de mur
-#define NEUTRE -2 // Mur sans identification
-
-/** \brief Gestionnaire de collisions
- * \last Remplacement bool par int, -1 = MUR
- * \next
- *
- *
- */
-
+#define GAUCHE 3
+
+//Define du mur
+#define VIDE -1 //Pas de mur
+#define NEUTRE -2 // Mur sans identification
+
+/** \brief Gestionnaire de collisions
+ * \last Remplacement bool par int, -1 = MUR
+ * \next
+ *
+ *
+ */
+
 class Collisions
 {
-    public:
+    public:
 
         Collisions(SDL_Surface* screen, int const xBlocSize, int const yBlocSize);
-        ~Collisions();
+        ~Collisions();
 
         void ajouter(int x, int y, int ID);
         void enlever(int x, int y);
         int tester(int x, int y) const;
         void afficher();
-        void reinitialiser();
-        void coorectPos(int &x, int &y) const;
-
+        void reinitialiser();
+        void coorectPos(int &x, int &y) const;
+
         int getSize(int idCoord);// x -> 0 et y -> 1
 
-    private:
+    private:
 
-        SDL_Surface* m_screen;
+        SDL_Surface* m_screen;
         SDL_Surface* m_carreStd;
         SDL_Surface* m_carre[12];
-        SDL_Surface* m_sol;
-        SDL_Surface* m_terrain;
-
-        int const m_xSize;
-        int const m_ySize;
+        SDL_Surface* m_sol;
+        SDL_Surface* m_terrain;
+
+        int const m_xSize;
+        int const m_ySize;
 
         SDL_Rect m_position;
         int **m_tableau;
-};
-
-#endif // COLLISIONS_H_INCLUDED
+};
+
+#endif // COLLISIONS_H_INCLUDED

Liner.cpp

@@ -5,32 +5,32 @@ static SDL_Surface* s_trainee[15];
 static SDL_Surface* s_mort(0);
 
 Liner::Liner(int x, int y, int orientation, int id, SDL_Surface *screen, SDL_Surface *pseudo, Collisions *collisioneur, TableauPower *powerGetter)
-: m_x(x), m_y(y), m_orientation(orientation), m_id(id), m_estVivant(false), m_fin(false), m_meurtrier(-1),
+: m_x(x), m_y(y), m_orientation(orientation), m_id(id), m_estVivant(false), m_fin(false), m_meurtrier(-1),
 m_collisioneur(collisioneur), m_screen(screen), m_liner(0), m_cercle(0), m_pseudo(pseudo),
 m_powerGetter(powerGetter), m_power(0)
-{
+{
     if (HAUT <= orientation && orientation <= GAUCHE)
-        m_liner = s_linerSurface[orientation];
+        m_liner = s_linerSurface[orientation];
 
-    SDL_Surface* cercle = SDL_LoadBMP("Textures/Cercle.bmp");
+    SDL_Surface* cercle = SDL_LoadBMP("Textures/Cercle.bmp");
 
     if (!m_liner)
-        std::cout << "Image du liner inexistante. Attention à initPict(). " << SDL_GetError() << std::endl;
+        std::cout << "Image du liner inexistante. Attention à initPict(). " << SDL_GetError() << std::endl;
 
     if (!cercle)
-        std::cout << "Impossible de charger une surface dans l'objet Liner : " << SDL_GetError() << std::endl;
-    else
-    {
-        m_cercle = colorMightyObjet(cercle, id);
-        SDL_FreeSurface(cercle);
-        SDL_SetColorKey( m_cercle, SDL_SRCCOLORKEY, SDL_MapRGB(m_cercle->format, 0, 0, 0) );
+        std::cout << "Impossible de charger une surface dans l'objet Liner : " << SDL_GetError() << std::endl;
+    else
+    {
+        m_cercle = colorMightyObjet(cercle, id);
+        SDL_FreeSurface(cercle);
+        SDL_SetColorKey( m_cercle, SDL_SRCCOLORKEY, SDL_MapRGB(m_cercle->format, 0, 0, 0) );
     }
 
 }///Constructeur
 
 Liner::~Liner()
 {
-    SDL_FreeSurface(m_cercle);
+    SDL_FreeSurface(m_cercle);
     m_trainee.clear();
 }///Destructeur
 
@@ -39,7 +39,7 @@ void Liner::actualiser(int direction)
     //[1] Calcule le changement de direction
     m_orientation += direction;
     if (m_orientation==4)
-        m_orientation=HAUT;
+        m_orientation=HAUT;
 
     else if (m_orientation==-1)
         m_orientation=GAUCHE;
@@ -68,15 +68,15 @@ void Liner::collisioner()
 {
     if (m_collisioneur->tester(m_x, m_y) != VIDE)
     {
-        if (m_power!=0)
-        {
-            m_power->postMortemPower(m_x, m_y, m_id);
-            m_power = 0;
-        }
-        if (m_collisioneur->tester(m_x, m_y) != VIDE){
-            m_estVivant = false;
-            m_meurtrier = m_collisioneur->tester(m_x, m_y);
-            if ( m_meurtrier == NEUTRE || m_meurtrier == m_id ) m_meurtrier = 5;
+        if (m_power!=0)
+        {
+            m_power->postMortemPower(m_x, m_y, m_id);
+            m_power = 0;
+        }
+        if (m_collisioneur->tester(m_x, m_y) != VIDE){
+            m_estVivant = false;
+            m_meurtrier = m_collisioneur->tester(m_x, m_y);
+            if ( m_meurtrier == NEUTRE || m_meurtrier == m_id ) m_meurtrier = 5;
         }
     }
 }///collisioner
@@ -85,35 +85,35 @@ void Liner::afficher()
 {
     //[1] Calculs
     m_position.x = m_x * 20;
-    m_position.y = m_y * 20;
+    m_position.y = m_y * 20;
 
     if (m_estVivant)
         m_liner = s_linerSurface[m_orientation];
     else
-        m_liner=s_mort;
-
-    //[2] Affiche trainée
-    for ( Uint16 i(1); i<m_trainee.size(); i++ )
-    {
-        SDL_BlitSurface( s_trainee[i-1], 0, m_screen, &m_trainee[i] );
-    }
-
+        m_liner=s_mort;
+
+    //[2] Affiche trainée
+    for ( Uint16 i(1); i<m_trainee.size(); i++ )
+    {
+        SDL_BlitSurface( s_trainee[i-1], 0, m_screen, &m_trainee[i] );
+    }
+
     //[3] Affiche liner
     SDL_BlitSurface(m_cercle, 0, m_screen, &m_position);
-    SDL_BlitSurface(m_liner, 0, m_screen, &m_position);
-
-    //[4] Affiche pseudo
-    if ( m_fin )
-    {
-        m_position.y += 20;
-        SDL_BlitSurface(m_pseudo, 0, m_screen, &m_position);
-    }
-
-    //[5] Affiche pouvoir
-    if (m_power!=0)
+    SDL_BlitSurface(m_liner, 0, m_screen, &m_position);
+
+    //[4] Affiche pseudo
+    if ( m_fin )
+    {
+        m_position.y += 20;
+        SDL_BlitSurface(m_pseudo, 0, m_screen, &m_position);
+    }
+
+    //[5] Affiche pouvoir
+    if (m_power!=0)
         m_power->afficher(m_x, m_y);
-}///afficher
-
+}///afficher
+
 void Liner::direEstFini(bool fin)
 {
     m_fin = fin;
@@ -125,7 +125,7 @@ bool Liner::estVivant() const
 }///estVivant
 
 void Liner::avancer(int nbFois)
-{
+{
     // Avancée
     for (int i(0); i<nbFois; i++)
     {
@@ -144,14 +144,14 @@ void Liner::avancer(int nbFois)
                 m_x-=1;
                 break;
         }//Switch
-    }//For
-
-    // Remise sur le terrain
-    m_collisioneur->coorectPos(m_x, m_y);
-
-    // Mise à jour de la trainée
-    m_trainee.push_front( { m_x * 20, m_y * 20, 0, 0 } );
-    if ( m_trainee.size() > 16 ) m_trainee.pop_back();
+    }//For
+
+    // Remise sur le terrain
+    m_collisioneur->coorectPos(m_x, m_y);
+
+    // Mise à jour de la trainée
+    m_trainee.push_front( { m_x * 20, m_y * 20, 0, 0 } );
+    if ( m_trainee.size() > 16 ) m_trainee.pop_back();
 
 }///avancer
 
@@ -163,25 +163,25 @@ void Liner::utiliserPouvoir()
         m_power=0;
         m_collisioneur->coorectPos(m_x, m_y);
     }
-}///utiliserPouvoir
-
-void Liner::reset( int x, int y, int orientation )
-{
-    // Attributs
-    m_x = x ;
-    m_y = y ;
-    m_orientation = orientation ;
-    m_estVivant = true ;
-    m_fin = false ;
-    m_meurtrier = -1 ;
-    m_power = 0x0 ;
-    m_trainee.clear();
-
-    // Surface
+}///utiliserPouvoir
+
+void Liner::reset( int x, int y, int orientation )
+{
+    // Attributs
+    m_x = x ;
+    m_y = y ;
+    m_orientation = orientation ;
+    m_estVivant = true ;
+    m_fin = false ;
+    m_meurtrier = -1 ;
+    m_power = 0x0 ;
+    m_trainee.clear();
+
+    // Surface
     if (HAUT <= orientation && orientation <= GAUCHE)
-        m_liner = s_linerSurface[orientation];
-    else
-        m_orientation = BAS ;
+        m_liner = s_linerSurface[orientation];
+    else
+        m_orientation = BAS ;
 }///reset
 
 int Liner::getMeurtrier()
@@ -189,29 +189,29 @@ int Liner::getMeurtrier()
     return m_meurtrier;
 }///getMeutrier
 
-/************************************Fonctions indépendantes************************************/
+/************************************Fonctions indépendantes************************************/
 
 bool initialisationPict()
-{
+{
     /// Chargement
     s_linerSurface[HAUT] = SDL_LoadBMP("Textures/Haut.bmp");
     s_linerSurface[DROITE] = retournement(s_linerSurface[HAUT],1);
     s_linerSurface[BAS] = retournement(s_linerSurface[HAUT],2);
     s_linerSurface[GAUCHE] = retournement(s_linerSurface[HAUT],3);
-    s_mort = SDL_LoadBMP("Textures/Mort.bmp");
-
-    for ( int i(0); i<15; i++ )
-    {
-        s_trainee[i] = SDL_CreateRGBSurface( SDL_HWSURFACE, 20, 20, 32, 0, 0, 0, 0 );
-        if ( !s_trainee[i] )
-            return false;
-        else
-        {
-            SDL_FillRect( s_trainee[i], 0, SDL_MapRGB( s_trainee[i]->format, 255, 255, 255 ) );
-            SDL_SetAlpha( s_trainee[i], SDL_SRCALPHA, 255-12*i );
-        }
-    }
-
+    s_mort = SDL_LoadBMP("Textures/Mort.bmp");
+
+    for ( int i(0); i<15; i++ )
+    {
+        s_trainee[i] = SDL_CreateRGBSurface( SDL_HWSURFACE, 20, 20, 32, 0, 0, 0, 0 );
+        if ( !s_trainee[i] )
+            return false;
+        else
+        {
+            SDL_FillRect( s_trainee[i], 0, SDL_MapRGB( s_trainee[i]->format, 255, 255, 255 ) );
+            SDL_SetAlpha( s_trainee[i], SDL_SRCALPHA, 255-12*i );
+        }
+    }
+
     /// Tests
     for (int i(0); i<4; i++)
     {
@@ -219,12 +219,12 @@ bool initialisationPict()
             return false;
         else
             SDL_SetColorKey(s_linerSurface[i],SDL_SRCCOLORKEY,SDL_MapRGB(s_linerSurface[i]->format,255,0,0));
-    }
+    }
 
     if (!s_mort)
-        return false;
+        return false;
 
-    return true;
+    return true;
 
 }///initialisationPict
 
@@ -234,16 +234,16 @@ void fermeturePict()
     {
         SDL_FreeSurface(s_linerSurface[i]);
         s_linerSurface[i]=0;
-    }
+    }
 
     SDL_FreeSurface(s_mort);
-    s_mort=0;
-
-    for ( int i(0); i<15; i++ )
-    {
+    s_mort=0;
+
+    for ( int i(0); i<15; i++ )
+    {
         SDL_FreeSurface(s_trainee[i]);
-        s_trainee[i]=0;
-    }
+        s_trainee[i]=0;
+    }
 
 }///fermeturePict
 

Liner.h

@@ -1,69 +1,69 @@
-#ifndef LINER_H_INCLUDED
+#ifndef LINER_H_INCLUDED
 #define LINER_H_INCLUDED
-
-#include <iostream>
-#include <deque>
+
+#include <iostream>
+#include <deque>
 #include <SDL/SDL.h>
-#include "Collisions.h"
-#include "traitement.h"
-#include "Power.h"
-
+#include "Collisions.h"
+#include "traitement.h"
+#include "Power.h"
+
 //Mouvement
 #define TOURNE_DROITE 1//Quand ne tourne pas, 0
-#define TOURNE_GAUCHE -1
+#define TOURNE_GAUCHE -1
 
 
-/** \brief Voici la classe du Mighty Liner
- * \last Créer un attribut ID pour permettre au collisioneur d'afficher des murs différents
- * \next Réintégrer les pouvoirs
- *
- *
- */
-
+/** \brief Voici la classe du Mighty Liner
+ * \last Créer un attribut ID pour permettre au collisioneur d'afficher des murs différents
+ * \next Réintégrer les pouvoirs
+ *
+ *
+ */
+
 class Liner
 {
-    public:
+    public:
 
         Liner(int x, int y, int orientation, int id, SDL_Surface *screen, SDL_Surface *pseudo, Collisions *collisioneur, TableauPower *powerGetter);
-        ~Liner();
+        ~Liner();
 
         void actualiser(int direction);
         void collisioner();
-        void afficher();
+        void afficher();
         void direEstFini(bool fin);
         bool estVivant() const;
         void avancer(int nbFois);
-        void utiliserPouvoir();
-        void reset( int x, int y, int orientation );
-
+        void utiliserPouvoir();
+        void reset( int x, int y, int orientation );
+
         int getMeurtrier();
 
-    private:
+    private:
 
         int m_x; //Coordonnées en nb blocs
         int m_y;
-        int m_orientation; //0 à 3
+        int m_orientation; //0 à 3
         const int m_id;
-        bool m_estVivant;
-        bool m_fin; // Pour afficher les pseudos
-
-        int m_meurtrier;
-
+        bool m_estVivant;
+        bool m_fin; // Pour afficher les pseudos
+
+        int m_meurtrier;
+
         Collisions *m_collisioneur;
 
         SDL_Surface *m_screen;
         SDL_Surface *m_liner;
         SDL_Surface *m_cercle;
         SDL_Surface *m_pseudo;
-        SDL_Rect m_position;
+        SDL_Rect m_position;
 
         TableauPower *m_powerGetter;
-        Power *m_power;
-
+        Power *m_power;
+
         std::deque<SDL_Rect> m_trainee;
 };
 
 bool initialisationPict();
-void fermeturePict();
-
-#endif // Liner_H_INCLUDED
+void fermeturePict();
+
+#endif // Liner_H_INCLUDED

Power.cpp

@@ -17,23 +17,23 @@ void Power::attribuer()
 {
     m_estPose = false;
     //SDL_SetAlpha(m_image, SDL_SRCALPHA, 128);
-}///attribuer
-
-void Power::afficher(int x, int y)
-{
-    m_position.x = x * 20;
-    m_position.y = y * 20;
-    SDL_BlitSurface(m_image, 0, m_screen, &m_position);
+}///attribuer
+
+void Power::afficher(int x, int y)
+{
+    m_position.x = x * 20;
+    m_position.y = y * 20;
+    SDL_BlitSurface(m_image, 0, m_screen, &m_position);
 }///afficher
 
 bool Power::estUtilise()
 {
     return m_used;
-}
-
-bool Power::estPose()
-{
-    return m_estPose;
+}
+
+bool Power::estPose()
+{
+    return m_estPose;
 }///estAttribue
 
 void Power::convertDir(int orientation, int &ajoutX, int &ajoutY) const
@@ -55,61 +55,61 @@ void Power::convertDir(int orientation, int &ajoutX, int &ajoutY) const
             ajoutX=-1;
             break;
     }
-}
-
+}
+
 
 /********************************************* class TableauPower *********************************************/
 
 TableauPower::TableauPower(SDL_Surface *screen, Collisions *gestionnaireCollisons, int nbPow)
 : m_screen(screen), m_gestionnaireCollisions(gestionnaireCollisons), m_spriteGet(0), m_mediaPlayer(0), m_nbPow(nbPow)
-{
-    //Sprites loader
-    m_spriteGet = new SpriteLoader("Textures/");
-    SDL_SetColorKey(m_spriteGet->takeSprite("Missile"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Expansion"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Boost"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Teleport"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Bouclier"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Trender"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Tunnel"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-    SDL_SetColorKey(m_spriteGet->takeSprite("Bomb"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
-
-    //Sounderer
-    m_mediaPlayer = new Sounderer("Sons/");
-    if (m_mediaPlayer->init())
-    {
-        m_mediaPlayer->preLoad("Mort", EXT_OGG);
-
-        m_mediaPlayer->preLoad("Missile", EXT_OGG);
-        m_mediaPlayer->preLoad("Expansion", EXT_OGG);
-        m_mediaPlayer->preLoad("Boost", EXT_OGG);
-        m_mediaPlayer->preLoad("Teleport", EXT_OGG);
-        m_mediaPlayer->preLoad("Bouclier", EXT_OGG);
-        m_mediaPlayer->preLoad("Trender", EXT_OGG);
-        m_mediaPlayer->preLoad("Tunnel", EXT_OGG);
-        m_mediaPlayer->preLoad("Bomb", EXT_OGG);
-
-        //m_mediaPlayer->startMusic("musicMadagascar");
-    }
-
-    //Tableaux statiques
-    m_tableau = new Power*[m_nbPow];
-    for ( int i(0); i<2; i++ )
-        m_positions[i] = new int[m_nbPow];
-
+{
+    //Sprites loader
+    m_spriteGet = new SpriteLoader("Textures/");
+    SDL_SetColorKey(m_spriteGet->takeSprite("Missile"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Expansion"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Boost"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Teleport"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Bouclier"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Trender"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Tunnel"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+    SDL_SetColorKey(m_spriteGet->takeSprite("Bomb"), SDL_SRCCOLORKEY ,SDL_MapRGB(screen->format,255,255,255));
+
+    //Sounderer
+    m_mediaPlayer = new Sounderer("Sons/");
+    if (m_mediaPlayer->init())
+    {
+        m_mediaPlayer->preLoad("Mort", EXT_OGG);
+
+        m_mediaPlayer->preLoad("Missile", EXT_OGG);
+        m_mediaPlayer->preLoad("Expansion", EXT_OGG);
+        m_mediaPlayer->preLoad("Boost", EXT_OGG);
+        m_mediaPlayer->preLoad("Teleport", EXT_OGG);
+        m_mediaPlayer->preLoad("Bouclier", EXT_OGG);
+        m_mediaPlayer->preLoad("Trender", EXT_OGG);
+        m_mediaPlayer->preLoad("Tunnel", EXT_OGG);
+        m_mediaPlayer->preLoad("Bomb", EXT_OGG);
+
+        //m_mediaPlayer->startMusic("musicMadagascar");
+    }
+
+    //Tableaux statiques
+    m_tableau = new Power*[m_nbPow];
+    for ( int i(0); i<2; i++ )
+        m_positions[i] = new int[m_nbPow];
+
     // Powers
     for (int i(0); i<m_nbPow; i++)
         m_tableau[i] = 0;
 }///Constructeur
 
 TableauPower::~TableauPower()
-{
-    //Sprites loader
-    delete m_spriteGet;
-
-    //Sounderer
-    delete m_mediaPlayer;
-
+{
+    //Sprites loader
+    delete m_spriteGet;
+
+    //Sounderer
+    delete m_mediaPlayer;
+
     //Powers
     for (int i(0); i<m_nbPow; i++)
     {
@@ -117,17 +117,17 @@ TableauPower::~TableauPower()
         {}//Ne fait rien si le pointeur est déjà vide.
         else
             delete m_tableau[i];
-    }
-
-    // Tableaux
-    for ( int i(0); i<2; i++ )
-        delete[] m_positions[i];
+    }
+
+    // Tableaux
+    for ( int i(0); i<2; i++ )
+        delete[] m_positions[i];
     delete[] m_tableau;
 }///Destructeur
 
 Power* TableauPower::chercherPouvoir(int x, int y) const
 {
-    Power *pouvoirPotentiel(0);
+    Power *pouvoirPotentiel(0);
 
     for (int i(0); i<m_nbPow; i++)
         if (m_tableau[i]!=0)
@@ -135,11 +135,11 @@ Power* TableauPower::chercherPouvoir(int x, int y) const
             {
                 pouvoirPotentiel = m_tableau[i];
                 m_tableau[i]->attribuer();
-            }
+            }
 
     return pouvoirPotentiel;
-}///chercherPouvoir
-
+}///chercherPouvoir
+
 Power* TableauPower::randomPower()
 {
     //[1] Démarrage
@@ -187,8 +187,8 @@ void TableauPower::initialiser()
             delete m_tableau[i];
             m_tableau[i] = 0;
         }
-        m_tableau[i] = randomPower();
-        m_positions[0][i] = rand() % m_gestionnaireCollisions->getSize(0);// x
+        m_tableau[i] = randomPower();
+        m_positions[0][i] = rand() % m_gestionnaireCollisions->getSize(0);// x
         m_positions[1][i] = rand() % m_gestionnaireCollisions->getSize(1);// y
     }//for
 }///initialiser
@@ -207,13 +207,13 @@ void TableauPower::actualiser()
 void TableauPower::afficher()
 {
     for (int i(0); i<m_nbPow; i++)
-        if (m_tableau[i]!=0)
+        if (m_tableau[i]!=0)
             if (m_tableau[i]->estPose())
                 m_tableau[i]->afficher(m_positions[0][i], m_positions[1][i]);
 }///afficher
 
-void TableauPower::bruiterMort()
-{
-    m_mediaPlayer->play("Mort");
+void TableauPower::bruiterMort()
+{
+    m_mediaPlayer->play("Mort");
 }///bruiterMort
 

Power.h

@@ -1,51 +1,51 @@
-#ifndef POWER_H_INCLUDED
+#ifndef POWER_H_INCLUDED
 #define POWER_H_INCLUDED
-
+
 #include <cstdlib>
-#include "Collisions.h"
-#include "SpriteLoader.h"
-#include "Sounderer.h"
-
-/** \brief Power
- * \last Surface donnée
- * \next
- */
-
-/** \brief TableauPower
- * \last Ajuster le nombre de pouvoirs à volonté
- * \next Ajouter le Trender
+#include "Collisions.h"
+#include "SpriteLoader.h"
+#include "Sounderer.h"
+
+/** \brief Power
+ * \last Surface donnée
+ * \next
+ */
+
+/** \brief TableauPower
+ * \last Ajuster le nombre de pouvoirs à volonté
+ * \next Ajouter le Trender
  */
 
-class Power
+class Power
 {
-    public:
+    public:
 
         //Fonctions pour le tableau
-        Power(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Power();
+        Power(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        virtual ~Power();
 
-        void attribuer();
+        void attribuer();
 
         //Fonctions pour le joueur
         virtual void usePower(int orientation, int &x, int &y, int const &ID) = 0;
         virtual void postMortemPower(int const &x, int const &y, int const &ID) = 0;
 
-        //Pour les deux
+        //Pour les deux
         void afficher(int x, int y);
-        bool estUtilise();
+        bool estUtilise();
         bool estPose();
 
-    protected:
+    protected:
 
         void convertDir(int orientation, int &ajoutX, int &ajoutY) const;
 
-    protected:
+    protected:
 
         SDL_Surface *m_screen;
         SDL_Surface *m_image;
         SDL_Rect m_position;
 
-        Collisions *m_gestionnaireCollisions;
+        Collisions *m_gestionnaireCollisions;
         Sounderer *m_mediaPlayer;
 
         bool m_used;
@@ -54,37 +54,37 @@ class Power
 
 class TableauPower
 {
-    public:
+    public:
 
         TableauPower(SDL_Surface *screen, Collisions *gestionnaireCollisons, int nbPow );
-        ~TableauPower();
+        ~TableauPower();
 
-        Power* chercherPouvoir(int x, int y) const;
+        Power* chercherPouvoir(int x, int y) const;
         Power* randomPower();
         void initialiser();
         void actualiser(); // Nettoie les pouvoirs plus utilisés
-        void afficher();
-
+        void afficher();
+
         void bruiterMort();
 
-    private:
+    private:
 
         SDL_Surface *m_screen;
-        Collisions *m_gestionnaireCollisions;
-        SpriteLoader *m_spriteGet;
-        Sounderer *m_mediaPlayer;
+        Collisions *m_gestionnaireCollisions;
+        SpriteLoader *m_spriteGet;
+        Sounderer *m_mediaPlayer;
         const int m_nbPow;
-        Power** m_tableau;
+        Power** m_tableau;
         int* m_positions[2];//[coordonnee][id power]
 };
 
 #include "powers/Boost.h"
 #include "powers/Expansion.h"
 #include "powers/Missile.h"
-#include "powers/Teleport.h"
-#include "powers/Bouclier.h"
-#include "powers/Trender.h"
-#include "powers/Tunnel.h"
+#include "powers/Teleport.h"
+#include "powers/Bouclier.h"
+#include "powers/Trender.h"
+#include "powers/Tunnel.h"
 #include "powers/Bomb.h"
-
-#endif // POWER_H_INCLUDED
+
+#endif // POWER_H_INCLUDED

Sounderer.cpp

@@ -1,24 +1,24 @@
-#include "Sounderer.h"
-
-Sounderer::Sounderer() : m_lastCanal(-1), m_folder(""), m_musicName(""), m_music(0x0)
-{}
-
-Sounderer::Sounderer(std::string folder) : m_lastCanal(-1), m_folder(folder), m_musicName(""), m_music(0x0)
-{}
-
-Sounderer::~Sounderer()
-{
-    // Musique
-    if (m_music != 0x0) Mix_FreeMusic(m_music);
-
-    // Canaux
+#include "Sounderer.h"
+
+Sounderer::Sounderer() : m_lastCanal(-1), m_folder(""), m_musicName(""), m_music(0x0)
+{}
+
+Sounderer::Sounderer(std::string folder) : m_lastCanal(-1), m_folder(folder), m_musicName(""), m_music(0x0)
+{}
+
+Sounderer::~Sounderer()
+{
+    // Musique
+    if (m_music != 0x0) Mix_FreeMusic(m_music);
+
+    // Canaux
     for( m_it = m_paquet.begin(); m_it != m_paquet.end(); m_it++ )
         if (m_it->second != 0x0)
         {
             //Libération mémoire
             Mix_FreeChunk(m_it->second);
             m_it->second = 0x0;
-        }
+        }
 }
 
 bool Sounderer::init()
@@ -40,8 +40,8 @@ bool Sounderer::init()
 
 	///Initialisation terminée
     return true;
-}
-
+}
+
 bool Sounderer::preLoad(std::string nom, short extension)
 {
 	/// Cherche le son dans le tableau
@@ -128,53 +128,53 @@ bool Sounderer::stop(std::string nom)
 void Sounderer::stopAll()
 {
     Mix_HaltChannel(-1);
-}
-
-bool Sounderer::startMusic(std::string musicName)
-{
-    /// 1 Sécurité de présence d'une musique
-    if (m_music == 0x0)
-    {
-        if (musicName != "")
-        {
-            m_music = Mix_LoadMUS( (m_folder + musicName + ".wav").c_str());
-        }
-
-        if (m_music == 0x0){
-            std::cout << "Sounderer::startMusic > 1 :" << Mix_GetError() << std::endl;
-            return false;
-        }
-    }
-
-    /// 2 Charge si la musique est différente
-    else if (musicName != m_musicName)
-    {
-        // Charge la nouvelle musique
-        Mix_Music* otherMusic(0x0);
-        otherMusic = Mix_LoadMUS( (m_folder + musicName + ".wav").c_str());
-
-        // Si la nouvelle musique est bien chargée, on l'attribue
-        if (otherMusic == 0x0)
-            std::cout << "Sounderer::startMusic > 2 :" << Mix_GetError() << std::endl;
-        else {
-            Mix_FreeMusic(m_music);
-            m_music = otherMusic;
-            otherMusic = 0x0;
-            m_musicName = musicName;
-        }
-    }
-
-    /// 3 Lancement de l'extrait et sécurité
-    if (Mix_FadeInMusic(m_music, INFINITY_LOOP, 3692) == 0)
-        return true;
-    else {
-        std::cout << "Sounderer::startMusic > 3 :" << Mix_GetError() << std::endl;
-        return false;
-    }
 }
-
-void Sounderer::assignFolder(std::string folder)
-{
-    m_folder = folder;
-}
-
+
+bool Sounderer::startMusic(std::string musicName)
+{
+    /// 1 Sécurité de présence d'une musique
+    if (m_music == 0x0)
+    {
+        if (musicName != "")
+        {
+            m_music = Mix_LoadMUS( (m_folder + musicName + ".wav").c_str());
+        }
+
+        if (m_music == 0x0){
+            std::cout << "Sounderer::startMusic > 1 :" << Mix_GetError() << std::endl;
+            return false;
+        }
+    }
+
+    /// 2 Charge si la musique est différente
+    else if (musicName != m_musicName)
+    {
+        // Charge la nouvelle musique
+        Mix_Music* otherMusic(0x0);
+        otherMusic = Mix_LoadMUS( (m_folder + musicName + ".wav").c_str());
+
+        // Si la nouvelle musique est bien chargée, on l'attribue
+        if (otherMusic == 0x0)
+            std::cout << "Sounderer::startMusic > 2 :" << Mix_GetError() << std::endl;
+        else {
+            Mix_FreeMusic(m_music);
+            m_music = otherMusic;
+            otherMusic = 0x0;
+            m_musicName = musicName;
+        }
+    }
+
+    /// 3 Lancement de l'extrait et sécurité
+    if (Mix_FadeInMusic(m_music, INFINITY_LOOP, 3692) == 0)
+        return true;
+    else {
+        std::cout << "Sounderer::startMusic > 3 :" << Mix_GetError() << std::endl;
+        return false;
+    }
+}
+
+void Sounderer::assignFolder(std::string folder)
+{
+    m_folder = folder;
+}
+

Sounderer.h

@@ -1,45 +1,45 @@
-#ifndef SOUNDERER_H_INCLUDED
-#define SOUNDERER_H_INCLUDED
-
-#include <iostream>
-#include <string>
-#include <map>
+#ifndef SOUNDERER_H_INCLUDED
+#define SOUNDERER_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <map>
 #include <SDL/SDL.h>
 #include <SDL/SDL_mixer.h>
 
 #define EXT_WAV 0
 #define EXT_OGG 1
-#define INFINITY_LOOP -1
-
-class Sounderer
-{
-public:
-
-    Sounderer();
-    Sounderer(std::string folder);
-    ~Sounderer();
+#define INFINITY_LOOP -1
+
+class Sounderer
+{
+public:
+
+    Sounderer();
+    Sounderer(std::string folder);
+    ~Sounderer();
 
     bool init();// à appeler avant utilisation
-
-    // Fonctions de bruitage
+
+    // Fonctions de bruitage
     bool preLoad(std::string nom, short extension = EXT_WAV);// Précharge le son pour accélerer sa premièrer lecture [!] Dossier et extension auto
     bool play(std::string nom, int repetition = 0);// Joue le son choisi, le charge automatiquement si pas encore chargé
     bool fadePlay(std::string nom, int crescendoLenght, int repetition = 0);// Démarre le son par un crescendo d'une longueur voulue
     bool stop(std::string nom);// Stoppe le son choisi
-    void stopAll();
-
-    // Fonctions de musique
-    bool startMusic(std::string musicName = "");
-
-    // Fonction param
-    void assignFolder(std::string folder);// Situe le dossier où sont contenus les sons
-
-private:
-
-    int m_lastCanal;
-    std::string m_folder;
-
-    std::string m_musicName;
+    void stopAll();
+
+    // Fonctions de musique
+    bool startMusic(std::string musicName = "");
+
+    // Fonction param
+    void assignFolder(std::string folder);// Situe le dossier où sont contenus les sons
+
+private:
+
+    int m_lastCanal;
+    std::string m_folder;
+
+    std::string m_musicName;
     Mix_Music* m_music;
 
 	std::map<std::string, int> m_channel;//Channel on which our sound is played
@@ -49,8 +49,8 @@ private:
 	int m_rate;// = 22050 : Frequency of audio playback
 	Uint16 m_format;// = AUDIO_S16SYS : Format of the audio we're playing
 	int m_nbChannels;// = 2 : 2 channels = stereo
-	int m_bufferSize;// = 4096 : Size of the audio buffers in memory
-
-};
-
-#endif // SOUNDERER_H_INCLUDED
+	int m_bufferSize;// = 4096 : Size of the audio buffers in memory
+
+};
+
+#endif // SOUNDERER_H_INCLUDED

SpriteLoader.cpp

@@ -1,65 +1,65 @@
-#include "SpriteLoader.h"
-
-SpriteLoader::SpriteLoader() : m_folder("")
-{
-
-}
-
-SpriteLoader::SpriteLoader(std::string folder) : m_folder(folder)
-{
-
-}
-
-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;
-        }
-
-        return m_paquet[nom];
-    }
-}
-
-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;
-}
-
+#include "SpriteLoader.h"
+
+SpriteLoader::SpriteLoader() : m_folder("")
+{
+
+}
+
+SpriteLoader::SpriteLoader(std::string folder) : m_folder(folder)
+{
+
+}
+
+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;
+        }
+
+        return m_paquet[nom];
+    }
+}
+
+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;
+}
+

SpriteLoader.h

@@ -1,29 +1,29 @@
-#ifndef SPRITELOADER_H_INCLUDED
-#define SPRITELOADER_H_INCLUDED
-
-#include <iostream>
-#include <string>
-#include <map>
-#include <SDL/SDL.h>
-
-class SpriteLoader
-{
-public:
-
-    SpriteLoader();
-    SpriteLoader(std::string folder);
-    ~SpriteLoader();
-
-    SDL_Surface* takeSprite(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;
-
-};
-
-#endif // SPRITELOADER_H_INCLUDED
+#ifndef SPRITELOADER_H_INCLUDED
+#define SPRITELOADER_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <map>
+#include <SDL/SDL.h>
+
+class SpriteLoader
+{
+public:
+
+    SpriteLoader();
+    SpriteLoader(std::string folder);
+    ~SpriteLoader();
+
+    SDL_Surface* takeSprite(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;
+
+};
+
+#endif // SPRITELOADER_H_INCLUDED

Starter.cpp

@@ -1,81 +1,81 @@
-#include "Starter.h"
-
-Starter::Starter( int xSize, int ySize ): m_xSize( xSize ), m_ySize( ySize ) //TODO m_xl(0x0),
-{
-
-}
-
-Starter::~Starter()
-{
-    //dtor
-}
-
-void Starter::loadAreas()
-{
-    /// Config
-    std::string const source("Spawns/spawn1.txt");
-    std::ifstream fluxIn(source.c_str());
-
-    int x, y, d;
-
-    /// Attributions
-    if (fluxIn)
-    {
-        //Ouverture fichier succés
-        for (int i(0); i<12; i++)
-        {
-            fluxIn >> x ;
-            fluxIn >> y ;
-            fluxIn >> d ;
-
-            if ( x < 0 )
-                x += m_xSize;
-
-            if ( y < 0 )
-                y += m_ySize;
-
-            m_xl.push_back(x);
-            m_yl.push_back(y);
-            m_dl.push_back(d);
-        }
-    }
-    else
-    {
-        //Echec ouverture fichier
-        std::cout << "ERREUR: impossible de lire le fichier " << source << " ." << std::endl;
-
-        /// Spawn à la main
-        // 1
-        m_xl.push_back(5);
-        m_yl.push_back(5);
-        m_dl.push_back(BAS);
-        // 1
-        m_xl.push_back(10);
-        m_yl.push_back(5);
-        m_dl.push_back(DROITE);
-        // 1
-        m_xl.push_back(5);
-        m_yl.push_back(4);
-        m_dl.push_back(HAUT);
-        // 1
-        m_xl.push_back(5);
-        m_yl.push_back(10);
-        m_dl.push_back(DROITE);
-        // 1
-        m_xl.push_back(5);
-        m_yl.push_back(15);
-        m_dl.push_back(DROITE);
-    }
-
-    std::cout << "m_xl.size() " << m_xl.size() << std::endl ;
-    std::cout << "m_yl.size() " << m_yl.size() << std::endl ;
-    std::cout << "m_dl.size() " << m_dl.size() << std::endl ;
-}
-
-void Starter::spawnLiners( Liner** linerTab, int nbJoueurs )
-{
-    for ( unsigned int i(0); i < nbJoueurs; i ++ )
-    {
-        linerTab[i]->reset( m_xl[i], m_yl[i], m_dl[i] );
-    }
-}
+#include "Starter.h"
+
+Starter::Starter( int xSize, int ySize ): m_xSize( xSize ), m_ySize( ySize ) //TODO m_xl(0x0),
+{
+
+}
+
+Starter::~Starter()
+{
+    //dtor
+}
+
+void Starter::loadAreas()
+{
+    /// Config
+    std::string const source("Spawns/spawn1.txt");
+    std::ifstream fluxIn(source.c_str());
+
+    int x, y, d;
+
+    /// Attributions
+    if (fluxIn)
+    {
+        //Ouverture fichier succés
+        for (int i(0); i<12; i++)
+        {
+            fluxIn >> x ;
+            fluxIn >> y ;
+            fluxIn >> d ;
+
+            if ( x < 0 )
+                x += m_xSize;
+
+            if ( y < 0 )
+                y += m_ySize;
+
+            m_xl.push_back(x);
+            m_yl.push_back(y);
+            m_dl.push_back(d);
+        }
+    }
+    else
+    {
+        //Echec ouverture fichier
+        std::cout << "ERREUR: impossible de lire le fichier " << source << " ." << std::endl;
+
+        /// Spawn à la main
+        // 1
+        m_xl.push_back(5);
+        m_yl.push_back(5);
+        m_dl.push_back(BAS);
+        // 1
+        m_xl.push_back(10);
+        m_yl.push_back(5);
+        m_dl.push_back(DROITE);
+        // 1
+        m_xl.push_back(5);
+        m_yl.push_back(4);
+        m_dl.push_back(HAUT);
+        // 1
+        m_xl.push_back(5);
+        m_yl.push_back(10);
+        m_dl.push_back(DROITE);
+        // 1
+        m_xl.push_back(5);
+        m_yl.push_back(15);
+        m_dl.push_back(DROITE);
+    }
+
+    std::cout << "m_xl.size() " << m_xl.size() << std::endl ;
+    std::cout << "m_yl.size() " << m_yl.size() << std::endl ;
+    std::cout << "m_dl.size() " << m_dl.size() << std::endl ;
+}
+
+void Starter::spawnLiners( Liner** linerTab, int nbJoueurs )
+{
+    for ( unsigned int i(0); i < nbJoueurs; i ++ )
+    {
+        linerTab[i]->reset( m_xl[i], m_yl[i], m_dl[i] );
+    }
+}

Starter.h

@@ -1,36 +1,36 @@
-#ifndef STARTER_H
-#define STARTER_H
-
-#include <vector>
-#include <fstream>
-#include "Liner.h"
-#include "intToStr.h"
-
-/** \brief Voici la classe du Starter : elle place les liners en débuts de partie.
- * \last Créé
- * \next
- *
- *
- */
-
-class Starter
-{
-/// > Fonctions
-    public:
-        Starter( int xSize, int ySize );
-        ~Starter();
-
-        void loadAreas();
-        void spawnLiners( Liner** linerTab, int nbJoueurs );
-
-/// > Attributs
-    private:
-        int m_xSize ;
-        int m_ySize ;
-
-        std::vector< int > m_xl ; // Tableaux à dimensionner
-        std::vector< int > m_yl ;
-        std::vector< int > m_dl ;
-};
-
-#endif // STARTER_H
+#ifndef STARTER_H
+#define STARTER_H
+
+#include <vector>
+#include <fstream>
+#include "Liner.h"
+#include "intToStr.h"
+
+/** \brief Voici la classe du Starter : elle place les liners en débuts de partie.
+ * \last Créé
+ * \next
+ *
+ *
+ */
+
+class Starter
+{
+/// > Fonctions
+    public:
+        Starter( int xSize, int ySize );
+        ~Starter();
+
+        void loadAreas();
+        void spawnLiners( Liner** linerTab, int nbJoueurs );
+
+/// > Attributs
+    private:
+        int m_xSize ;
+        int m_ySize ;
+
+        std::vector< int > m_xl ; // Tableaux à dimensionner
+        std::vector< int > m_yl ;
+        std::vector< int > m_dl ;
+};
+
+#endif // STARTER_H

TextRender.cpp

@@ -1,150 +1,150 @@
-#include "TextRender.h"
-
-
-/// Class TextRender > > >
-#define TXT_ERROR "Un problème est survenu dans la classe TextRender développée par Jovian. Type : "
-
-TextRender::TextRender( std::string folder, Uint16 nbLiteTxts, Uint16 fontSize )
-:m_police( 0x0 ), m_liteTabSize( nbLiteTxts )
-{
-    /// Initialisation de la TTF
-    if ( TTF_Init() < 0 ) std::cout << TXT_ERROR << "initialisation TTF." << std::endl;
-
-    /// Chargement de la police
-    m_police = TTF_OpenFont( (folder+"droid.ttf").c_str(), fontSize );
-    if ( !m_police ) std::cout << TXT_ERROR << "chargement police." << std::endl;
-
-    /// Déclaration des LiteTextes
-    if ( nbLiteTxts != 0 ) {
-        m_liteTab = new LiteText*[ nbLiteTxts ];
-        for ( Uint16 i(0); i<nbLiteTxts; i++ ) {
-            m_liteTab[i] = new LiteText( m_police, "LiteTxt" );
-        }
-    }
-}
-
-TextRender::~TextRender()
-{
-    /// Destruction des surfaces LiteTxt
-    if ( m_liteTabSize != 0 ) {
-        for ( Uint16 i(0); i<m_liteTabSize; i++ ) {
-            delete m_liteTab[i];
-        }
-        delete[] m_liteTab;
-    }
-
-    /// Destruction des surfaces Name
-    for( m_it = m_name.begin(); m_it != m_name.end(); m_it++ )
-    {
-        SDL_FreeSurface(m_it->second);
-        m_it->second = 0x0;
-    }
-
+#include "TextRender.h"
+
+
+/// Class TextRender > > >
+#define TXT_ERROR "Un problème est survenu dans la classe TextRender développée par Jovian. Type : "
+
+TextRender::TextRender( std::string folder, Uint16 nbLiteTxts, Uint16 fontSize )
+:m_police( 0x0 ), m_liteTabSize( nbLiteTxts )
+{
+    /// Initialisation de la TTF
+    if ( TTF_Init() < 0 ) std::cout << TXT_ERROR << "initialisation TTF." << std::endl;
+
+    /// Chargement de la police
+    m_police = TTF_OpenFont( (folder+"droid.ttf").c_str(), fontSize );
+    if ( !m_police ) std::cout << TXT_ERROR << "chargement police." << std::endl;
+
+    /// Déclaration des LiteTextes
+    if ( nbLiteTxts != 0 ) {
+        m_liteTab = new LiteText*[ nbLiteTxts ];
+        for ( Uint16 i(0); i<nbLiteTxts; i++ ) {
+            m_liteTab[i] = new LiteText( m_police, "LiteTxt" );
+        }
+    }
+}
+
+TextRender::~TextRender()
+{
+    /// Destruction des surfaces LiteTxt
+    if ( m_liteTabSize != 0 ) {
+        for ( Uint16 i(0); i<m_liteTabSize; i++ ) {
+            delete m_liteTab[i];
+        }
+        delete[] m_liteTab;
+    }
+
+    /// Destruction des surfaces Name
+    for( m_it = m_name.begin(); m_it != m_name.end(); m_it++ )
+    {
+        SDL_FreeSurface(m_it->second);
+        m_it->second = 0x0;
+    }
+
     /// Fermeture TTF
-    TTF_CloseFont( m_police );
-    TTF_Quit();
-}
-
-SDL_Surface* TextRender::takeName( std::string nom )
-{
-    // Cherche la surface dans le tableau
-    m_it = m_name.find(nom);
-
-    // Si la surface est déjà chargée, on la donne
-    if (m_it != m_name.end())
-        return m_it->second;
-
-    // Sinon on la charge
-    else
-        return brutLoadName( nom );
-}
-
-SDL_Surface* TextRender::preLoadName( std::string nom, Uint8 r, Uint8 g, Uint8 b )
-{
-   // Cherche la surface dans le tableau
-    m_it = m_name.find(nom);
-
-    // Si la surface est déjà chargée, on la détruit
-    if (m_it != m_name.end())
-        SDL_FreeSurface( m_it->second );
-
-    // On la charge et on la donne
-    return brutLoadName( nom , r, g, b );
-}
-
-SDL_Surface* TextRender::brutLoadName( std::string nom, Uint8 r, Uint8 g, Uint8 b )
-{
-    SDL_Color color = {r, g, b};
-    SDL_Color background = {255, 255, 255};
-    m_name[nom] = TTF_RenderText_Shaded( m_police, nom.c_str(), color, background );
-    if (m_name[nom] == 0)
-    {
-        m_name[nom] = SDL_CreateRGBSurface(SDL_HWSURFACE, 40, 40, 32, 0, 0, 0, 0);
-        std::cout << TXT_ERROR << "génération de texte." << std::endl;
-    }
-
-    return m_name[nom];
-}
-
-SDL_Surface* TextRender::takeLite( Uint16 ID )
-{
-    /// Sécurité
-    if ( ID >= m_liteTabSize ) return 0x0;
-
-    /// Renvoi
-    return m_liteTab[ID]->get();
-}
-
-SDL_Surface* TextRender::tRendLite( Uint16 ID, std::string texte, Uint8 r, Uint8 g, Uint8 b )
-{
-    /// Sécurité
-    if ( ID >= m_liteTabSize ) return 0x0;
-
-    /// Rendering
-    m_liteTab[ID]->render( texte, r, g, b);
-
-    /// Renvoi
-    return m_liteTab[ID]->get();
-}
-
-LiteText* TextRender::takeLiteObject( Uint16 ID )
-{
-    /// Sécurité
-    if ( ID >= m_liteTabSize ) return 0x0;
-
-    /// Renvoi
-    return m_liteTab[ID];
-}
-
-
-/// Class LiteText > > >
-
-LiteText::LiteText( TTF_Font* police, std::string text )
-:m_text( 0x0 ), m_policeCopy( police )
-{
-    render( text );
-}
-
-LiteText::~LiteText()
-{
-    if ( m_text != 0x0 )
-            SDL_FreeSurface( m_text );
-}
-
-void LiteText::render( std::string text, Uint8 r, Uint8 g, Uint8 b )
-{
-    if ( !text.empty() )
-    {
-        if ( m_text != 0x0 )
-            SDL_FreeSurface( m_text );
-
-        /// Rendering
-        SDL_Color color = { r, g, b };
-        m_text = TTF_RenderText_Solid( m_policeCopy, text.c_str(), color );
-    }
-}
-
-SDL_Surface* LiteText::get()
-{
-    return m_text;
-}
+    TTF_CloseFont( m_police );
+    TTF_Quit();
+}
+
+SDL_Surface* TextRender::takeName( std::string nom )
+{
+    // Cherche la surface dans le tableau
+    m_it = m_name.find(nom);
+
+    // Si la surface est déjà chargée, on la donne
+    if (m_it != m_name.end())
+        return m_it->second;
+
+    // Sinon on la charge
+    else
+        return brutLoadName( nom );
+}
+
+SDL_Surface* TextRender::preLoadName( std::string nom, Uint8 r, Uint8 g, Uint8 b )
+{
+   // Cherche la surface dans le tableau
+    m_it = m_name.find(nom);
+
+    // Si la surface est déjà chargée, on la détruit
+    if (m_it != m_name.end())
+        SDL_FreeSurface( m_it->second );
+
+    // On la charge et on la donne
+    return brutLoadName( nom , r, g, b );
+}
+
+SDL_Surface* TextRender::brutLoadName( std::string nom, Uint8 r, Uint8 g, Uint8 b )
+{
+    SDL_Color color = {r, g, b};
+    SDL_Color background = {255, 255, 255};
+    m_name[nom] = TTF_RenderText_Shaded( m_police, nom.c_str(), color, background );
+    if (m_name[nom] == 0)
+    {
+        m_name[nom] = SDL_CreateRGBSurface(SDL_HWSURFACE, 40, 40, 32, 0, 0, 0, 0);
+        std::cout << TXT_ERROR << "génération de texte." << std::endl;
+    }
+
+    return m_name[nom];
+}
+
+SDL_Surface* TextRender::takeLite( Uint16 ID )
+{
+    /// Sécurité
+    if ( ID >= m_liteTabSize ) return 0x0;
+
+    /// Renvoi
+    return m_liteTab[ID]->get();
+}
+
+SDL_Surface* TextRender::tRendLite( Uint16 ID, std::string texte, Uint8 r, Uint8 g, Uint8 b )
+{
+    /// Sécurité
+    if ( ID >= m_liteTabSize ) return 0x0;
+
+    /// Rendering
+    m_liteTab[ID]->render( texte, r, g, b);
+
+    /// Renvoi
+    return m_liteTab[ID]->get();
+}
+
+LiteText* TextRender::takeLiteObject( Uint16 ID )
+{
+    /// Sécurité
+    if ( ID >= m_liteTabSize ) return 0x0;
+
+    /// Renvoi
+    return m_liteTab[ID];
+}
+
+
+/// Class LiteText > > >
+
+LiteText::LiteText( TTF_Font* police, std::string text )
+:m_text( 0x0 ), m_policeCopy( police )
+{
+    render( text );
+}
+
+LiteText::~LiteText()
+{
+    if ( m_text != 0x0 )
+            SDL_FreeSurface( m_text );
+}
+
+void LiteText::render( std::string text, Uint8 r, Uint8 g, Uint8 b )
+{
+    if ( !text.empty() )
+    {
+        if ( m_text != 0x0 )
+            SDL_FreeSurface( m_text );
+
+        /// Rendering
+        SDL_Color color = { r, g, b };
+        m_text = TTF_RenderText_Solid( m_policeCopy, text.c_str(), color );
+    }
+}
+
+SDL_Surface* LiteText::get()
+{
+    return m_text;
+}

TextRender.h

@@ -1,62 +1,62 @@
-#ifndef TEXTRENDER_H
-#define TEXTRENDER_H
-
-#include <iostream>
+#ifndef TEXTRENDER_H
+#define TEXTRENDER_H
+
+#include <iostream>
 #include <map>
-#include <string>
+#include <string>
 
 #include <SDL/SDL.h>
-#include <SDL/SDL_ttf.h>
-
-class LiteText;
-
-class TextRender
-{
-/// > Fonctions
-    public:
-
-        TextRender( std::string folder = "", Uint16 nbLiteTxts = 0, Uint16 fontSize = 65 );
-        virtual ~TextRender();
-
-        SDL_Surface* takeName( std::string nom );
-        SDL_Surface* preLoadName( std::string nom, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
-
-        SDL_Surface* takeLite( Uint16 ID );
-        SDL_Surface* tRendLite( Uint16 ID, std::string texte, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
-        LiteText* takeLiteObject( Uint16 ID );
-
-    protected:
-
-        SDL_Surface* brutLoadName( std::string nom, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
-
-/// > Attributs
-    protected:
-
-        TTF_Font* m_police;
-
-        const Uint16 m_liteTabSize;
-        LiteText** m_liteTab;
-
-        std::map<std::string, SDL_Surface*>::iterator m_it;
-        std::map<std::string, SDL_Surface*> m_name;
-};
-
-class LiteText
-{
-/// > Fonctions
-    public:
-
-        LiteText( TTF_Font* police, std::string text = " " );
-        ~LiteText();
-
-        void render( std::string text, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
-        SDL_Surface* get();
-
-/// > Attributs
-    private:
-
-        SDL_Surface* m_text;
-        TTF_Font* m_policeCopy;
-};
-
-#endif // TEXTRENDER_H
+#include <SDL/SDL_ttf.h>
+
+class LiteText;
+
+class TextRender
+{
+/// > Fonctions
+    public:
+
+        TextRender( std::string folder = "", Uint16 nbLiteTxts = 0, Uint16 fontSize = 65 );
+        virtual ~TextRender();
+
+        SDL_Surface* takeName( std::string nom );
+        SDL_Surface* preLoadName( std::string nom, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
+
+        SDL_Surface* takeLite( Uint16 ID );
+        SDL_Surface* tRendLite( Uint16 ID, std::string texte, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
+        LiteText* takeLiteObject( Uint16 ID );
+
+    protected:
+
+        SDL_Surface* brutLoadName( std::string nom, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
+
+/// > Attributs
+    protected:
+
+        TTF_Font* m_police;
+
+        const Uint16 m_liteTabSize;
+        LiteText** m_liteTab;
+
+        std::map<std::string, SDL_Surface*>::iterator m_it;
+        std::map<std::string, SDL_Surface*> m_name;
+};
+
+class LiteText
+{
+/// > Fonctions
+    public:
+
+        LiteText( TTF_Font* police, std::string text = " " );
+        ~LiteText();
+
+        void render( std::string text, Uint8 r=0, Uint8 g=0, Uint8 b=0 );
+        SDL_Surface* get();
+
+/// > Attributs
+    private:
+
+        SDL_Surface* m_text;
+        TTF_Font* m_policeCopy;
+};
+
+#endif // TEXTRENDER_H

gestionFichiers.cpp

@@ -56,4 +56,4 @@ int haveNbJoueurs()
 
     return -1;
 }///haveNbBlocs
-*/
+*/

gestionFichiers.h

@@ -1,7 +1,7 @@
-#ifndef GESTIONFICHIERS_H_INCLUDED
-#define GESTIONFICHIERS_H_INCLUDED
+#ifndef GESTIONFICHIERS_H_INCLUDED
+#define GESTIONFICHIERS_H_INCLUDED
 
-#include <iostream>
+#include <iostream>
 #include <fstream>
 
 /*Programmeur: Jovian Hersemeule
@@ -15,10 +15,10 @@ Cette fonction permet d'obtenir le nombre de joueurs préconfiguré dans le fich
 Cette fonction permet de connaître la largeur ou la hauteur en nombre de blocs,
 préconfiguré dans le fichier config.txt.
     Argument:   un caractère. 'x' pour la largeur et 'y' pour la hauteur.
-    Renvoi:     un entier. Le nombre de blocs dans l'axe voulu. -1 si echec de lecture.
+    Renvoi:     un entier. Le nombre de blocs dans l'axe voulu. -1 si echec de lecture.
 */
 
 int haveNbJoueurs();
-//int haveNbBlocs(char axe);
-
-#endif // GESTIONFICHIERS_H_INCLUDED
+//int haveNbBlocs(char axe);
+
+#endif // GESTIONFICHIERS_H_INCLUDED

intToStr.cpp

@@ -1,22 +1,22 @@
-# include "intToStr.h"
-
-std::string intToStr( int numero )
-{
-    //[1] Préparer
-    std::string resultat;
-    char caractere(0);
-
-    //[2] S'auto appeler
-    caractere = numero%10;
-    caractere += 48;
-    numero /= 10;
-
-    if ( numero != 0 )
-        resultat = intToStr( numero );
-
-    resultat += caractere;
-
-
-    //[3] Renvoi
-    return resultat;
-}
+# include "intToStr.h"
+
+std::string intToStr( int numero )
+{
+    //[1] Préparer
+    std::string resultat;
+    char caractere(0);
+
+    //[2] S'auto appeler
+    caractere = numero%10;
+    caractere += 48;
+    numero /= 10;
+
+    if ( numero != 0 )
+        resultat = intToStr( numero );
+
+    resultat += caractere;
+
+
+    //[3] Renvoi
+    return resultat;
+}

intToStr.h

@@ -1,8 +1,8 @@
-#ifndef INTTOSTR_H_INCLUDED
-#define INTTOSTR_H_INCLUDED
-
-#include <string>
-
-std::string intToStr( int numero );
-
-#endif // INTTOSTR_H_INCLUDED
+#ifndef INTTOSTR_H_INCLUDED
+#define INTTOSTR_H_INCLUDED
+
+#include <string>
+
+std::string intToStr( int numero );
+
+#endif // INTTOSTR_H_INCLUDED

jeu.cpp

@@ -1,56 +1,56 @@
-#include "jeu.h"
-
-int jeuMulti( SDL_Surface* screen, Config settings )
-{
+#include "jeu.h"
+
+int jeuMulti( SDL_Surface* screen, Config settings )
+{
     /// [1] Préparation des composants
-    // [1.1] Composants de base SDL
-    SDL_Event event;
-    bool done = false;
-    Uint32 tempsPrecedent(0), ecart(0), frameRate(1000/12), dernierStart(0);//12fps
+    // [1.1] Composants de base SDL
+    SDL_Event event;
+    bool done = false;
+    Uint32 tempsPrecedent(0), ecart(0), frameRate(1000/12), dernierStart(0);//12fps
 
     // [1.2] Gestionnaires
-    Collisions collisionneur(screen, settings.xSize, settings.ySize);
-    TableauPower powerCreater(screen, &collisionneur, settings.nbPouvoirs );
-    Score tabScore;
-    clearScore( &tabScore );
-
-    // [1.3] Gestion paramètres
-    int nbJoueurs = settings.nbJoueurs;
-    if (nbJoueurs < 1)
-        return 1;
-    else if (nbJoueurs > 12)
+    Collisions collisionneur(screen, settings.xSize, settings.ySize);
+    TableauPower powerCreater(screen, &collisionneur, settings.nbPouvoirs );
+    Score tabScore;
+    clearScore( &tabScore );
+
+    // [1.3] Gestion paramètres
+    int nbJoueurs = settings.nbJoueurs;
+    if (nbJoueurs < 1)
+        return 1;
+    else if (nbJoueurs > 12)
         return 1;
 
     // [1.4] Création des images des liners
-    if (!initialisationPict())
-        return false;
-
-    // [1.5] Création du texm_xl.tRender
-    TextRender texter( "Polices/", nbJoueurs, settings.ySize );
-    texter.preLoadName( settings.pseudo[0], ROUGE );
-    texter.preLoadName( settings.pseudo[1], BLEU );
-    texter.preLoadName( settings.pseudo[2], VERT );
-    texter.preLoadName( settings.pseudo[3], JAUNE );
-    texter.preLoadName( settings.pseudo[4], ROSE );
-    texter.preLoadName( settings.pseudo[5], CYAN );
-    texter.preLoadName( settings.pseudo[6], ORANGE );
-    texter.preLoadName( settings.pseudo[7], VIOLET );
-    texter.preLoadName( settings.pseudo[8], GRIS );
-    texter.preLoadName( settings.pseudo[9], MARINE );
-    texter.preLoadName( settings.pseudo[10], PLUME );
-    texter.preLoadName( settings.pseudo[11], MARRON );
-
-    // [1.6] Création des liners
-    int nbVivants(0), nbVivantsPrec(4);
-    int guidon[12], nbPoints[nbJoueurs];
-    Liner* hyperliner[nbJoueurs];
-    for (int i(0); i<nbJoueurs; i++){
-        hyperliner[i] = new Liner(5, 5, DROITE, i, screen, texter.takeName(settings.pseudo[i]), &collisionneur, &powerCreater) ;
-        guidon[i] = nbPoints[i] = 0;
-    }
-
-    // [1.7] Création du démarreur
-    Starter myStarter( settings.xSize, settings.ySize );
+    if (!initialisationPict())
+        return false;
+
+    // [1.5] Création du texm_xl.tRender
+    TextRender texter( "Polices/", nbJoueurs, settings.ySize );
+    texter.preLoadName( settings.pseudo[0], ROUGE );
+    texter.preLoadName( settings.pseudo[1], BLEU );
+    texter.preLoadName( settings.pseudo[2], VERT );
+    texter.preLoadName( settings.pseudo[3], JAUNE );
+    texter.preLoadName( settings.pseudo[4], ROSE );
+    texter.preLoadName( settings.pseudo[5], CYAN );
+    texter.preLoadName( settings.pseudo[6], ORANGE );
+    texter.preLoadName( settings.pseudo[7], VIOLET );
+    texter.preLoadName( settings.pseudo[8], GRIS );
+    texter.preLoadName( settings.pseudo[9], MARINE );
+    texter.preLoadName( settings.pseudo[10], PLUME );
+    texter.preLoadName( settings.pseudo[11], MARRON );
+
+    // [1.6] Création des liners
+    int nbVivants(0), nbVivantsPrec(4);
+    int guidon[12], nbPoints[nbJoueurs];
+    Liner* hyperliner[nbJoueurs];
+    for (int i(0); i<nbJoueurs; i++){
+        hyperliner[i] = new Liner(5, 5, DROITE, i, screen, texter.takeName(settings.pseudo[i]), &collisionneur, &powerCreater) ;
+        guidon[i] = nbPoints[i] = 0;
+    }
+
+    // [1.7] Création du démarreur
+    Starter myStarter( settings.xSize, settings.ySize );
     myStarter.loadAreas();
 
     /// [2] Boucle principale
@@ -64,284 +64,284 @@ int jeuMulti( SDL_Surface* screen, Config settings )
             case SDL_QUIT:
                 done = true;
                 break;
-            case SDL_KEYDOWN:
-                // Controles de joueurs
-                for ( int i(0); i < nbJoueurs; i ++ )
-                {
-                    if ( event.key.keysym.sym == settings.cmd[i][0] )
-                        guidon[i] = TOURNE_GAUCHE ;
-                    else if ( event.key.keysym.sym == settings.cmd[i][2] )
-                        guidon[i] = TOURNE_DROITE ;
-
-                    if ( event.key.keysym.sym == settings.cmd[i][1] && nbVivants > 1 )
-                        hyperliner[i]->utiliserPouvoir();
-                }
-
+            case SDL_KEYDOWN:
+                // Controles de joueurs
+                for ( int i(0); i < nbJoueurs; i ++ )
+                {
+                    if ( event.key.keysym.sym == settings.cmd[i][0] )
+                        guidon[i] = TOURNE_GAUCHE ;
+                    else if ( event.key.keysym.sym == settings.cmd[i][2] )
+                        guidon[i] = TOURNE_DROITE ;
+
+                    if ( event.key.keysym.sym == settings.cmd[i][1] && nbVivants > 1 )
+                        hyperliner[i]->utiliserPouvoir();
+                }
+
                 // Commandes classiques
-                switch (event.key.keysym.sym)
-                {
-                case SDLK_ESCAPE:
-                    done = true;
-                    break;
-                case SDLK_p:
-                case SDLK_KP_ENTER:
-                case SDLK_RETURN:
-                    // Pause
-                    dernierStart = SDL_GetTicks();
-
-                    // Réinitialisation
-                    nbVivants = nbJoueurs;
-                    collisionneur.reinitialiser();
-                    powerCreater.initialiser();
-
-                    // Placement
-                    myStarter.spawnLiners( hyperliner, nbJoueurs );
-
-                    break;
-                /*case SDLK_RIGHT:
-                    guidon[0] = TOURNE_DROITE;
-                    break;
-                case SDLK_LEFT:
-                    guidon[0] = TOURNE_GAUCHE;
-                    break;
-                case SDLK_UP:
-                case SDLK_DOWN:
-                    if ( hyperliner[0] != 0 && nbVivants > 1 )
-                        hyperliner[0]->utiliserPouvoir();
-                    break;
-                case SDLK_d:
-                    guidon[1] = TOURNE_DROITE;
-                    break;
-                case SDLK_q:
-                case SDLK_a:
-                    guidon[1] = TOURNE_GAUCHE;
-                    break;
-                case SDLK_s:
-                case SDLK_z:
-                case SDLK_w:
-                    if ( nbJoueurs > 1 && hyperliner[1] != 0 && nbVivants > 1 )
-                        hyperliner[1]->utiliserPouvoir();
-                    break;
-                case SDLK_l:
-                    guidon[2] = TOURNE_DROITE;
-                    break;
-                case SDLK_j:
-                    guidon[2] = TOURNE_GAUCHE;
-                    break;
-                case SDLK_k:
-                case SDLK_i:
-                    if ( nbJoueurs > 2 && hyperliner[2] != 0 && nbVivants > 1 )
-                        hyperliner[2]->utiliserPouvoir();
-                    break;
-                case SDLK_KP6:
-                    guidon[3] = TOURNE_DROITE;
-                    break;
-                case SDLK_KP4:
-                    guidon[3] = TOURNE_GAUCHE;
-                    break;
-                case SDLK_KP5:
-                case SDLK_KP8:
-                    if ( nbJoueurs > 3 && hyperliner[3] != 0 && nbVivants > 1 )
-                        hyperliner[3]->utiliserPouvoir();
-                    break;*/
-                default:
-                    break;
+                switch (event.key.keysym.sym)
+                {
+                case SDLK_ESCAPE:
+                    done = true;
+                    break;
+                case SDLK_p:
+                case SDLK_KP_ENTER:
+                case SDLK_RETURN:
+                    // Pause
+                    dernierStart = SDL_GetTicks();
+
+                    // Réinitialisation
+                    nbVivants = nbJoueurs;
+                    collisionneur.reinitialiser();
+                    powerCreater.initialiser();
+
+                    // Placement
+                    myStarter.spawnLiners( hyperliner, nbJoueurs );
+
+                    break;
+                /*case SDLK_RIGHT:
+                    guidon[0] = TOURNE_DROITE;
+                    break;
+                case SDLK_LEFT:
+                    guidon[0] = TOURNE_GAUCHE;
+                    break;
+                case SDLK_UP:
+                case SDLK_DOWN:
+                    if ( hyperliner[0] != 0 && nbVivants > 1 )
+                        hyperliner[0]->utiliserPouvoir();
+                    break;
+                case SDLK_d:
+                    guidon[1] = TOURNE_DROITE;
+                    break;
+                case SDLK_q:
+                case SDLK_a:
+                    guidon[1] = TOURNE_GAUCHE;
+                    break;
+                case SDLK_s:
+                case SDLK_z:
+                case SDLK_w:
+                    if ( nbJoueurs > 1 && hyperliner[1] != 0 && nbVivants > 1 )
+                        hyperliner[1]->utiliserPouvoir();
+                    break;
+                case SDLK_l:
+                    guidon[2] = TOURNE_DROITE;
+                    break;
+                case SDLK_j:
+                    guidon[2] = TOURNE_GAUCHE;
+                    break;
+                case SDLK_k:
+                case SDLK_i:
+                    if ( nbJoueurs > 2 && hyperliner[2] != 0 && nbVivants > 1 )
+                        hyperliner[2]->utiliserPouvoir();
+                    break;
+                case SDLK_KP6:
+                    guidon[3] = TOURNE_DROITE;
+                    break;
+                case SDLK_KP4:
+                    guidon[3] = TOURNE_GAUCHE;
+                    break;
+                case SDLK_KP5:
+                case SDLK_KP8:
+                    if ( nbJoueurs > 3 && hyperliner[3] != 0 && nbVivants > 1 )
+                        hyperliner[3]->utiliserPouvoir();
+                    break;*/
+                default:
+                    break;
                 }
             } // end switch event type
         } // end of message processing
 
-        // [2.2] Calculs
-            // On compte les survivants
-            nbVivantsPrec = nbVivants;
-            nbVivants = 0;
-
-            for (int i(0); i<nbJoueurs; i++)
-                if (hyperliner[i] != 0)
-                    if (hyperliner[i]->estVivant())
-                        nbVivants++;
-
-            if ( nbVivants != nbVivantsPrec && nbVivants < 2 )
-                updateScore( &tabScore, hyperliner, nbJoueurs );
-
-            if ( nbVivants != nbVivantsPrec && nbJoueurs > 1 )
-                powerCreater.bruiterMort();
-
-            nbVivants = (nbJoueurs == 1)? 2 : nbVivants;/**< DEBUG : à enlever */
-
-            // Si il y en a assez, la partie continue
-            if (nbVivants > 1)
-                for (int i(0); i<nbJoueurs; i++){
-                    if (hyperliner[i] != 0 && SDL_GetTicks() - dernierStart > 3000)
-                    {
-                        hyperliner[i]->actualiser(guidon[i]);
-                        hyperliner[i]->direEstFini( false );
-                    }
-                    else if (hyperliner[i] != 0)
-                        hyperliner[i]->direEstFini( true );
-                    guidon[i] = 0;
-                }
-            else
-            {
-                for (int i(0); i<nbJoueurs; i++)
-                    if (hyperliner[i] != 0)
-                        hyperliner[i]->direEstFini( true );
-            }
-
-            // On gère les collisions en même temps pour plus d'équité
-            for (int i(0); i<nbJoueurs; i++){
-                if (hyperliner[i] != 0)
-                {
-                    hyperliner[i]->collisioner();
-                }
-            }
-
-            // On nettoie les pouvoirs utilisés
+        // [2.2] Calculs
+            // On compte les survivants
+            nbVivantsPrec = nbVivants;
+            nbVivants = 0;
+
+            for (int i(0); i<nbJoueurs; i++)
+                if (hyperliner[i] != 0)
+                    if (hyperliner[i]->estVivant())
+                        nbVivants++;
+
+            if ( nbVivants != nbVivantsPrec && nbVivants < 2 )
+                updateScore( &tabScore, hyperliner, nbJoueurs );
+
+            if ( nbVivants != nbVivantsPrec && nbJoueurs > 1 )
+                powerCreater.bruiterMort();
+
+            nbVivants = (nbJoueurs == 1)? 2 : nbVivants;/**< DEBUG : à enlever */
+
+            // Si il y en a assez, la partie continue
+            if (nbVivants > 1)
+                for (int i(0); i<nbJoueurs; i++){
+                    if (hyperliner[i] != 0 && SDL_GetTicks() - dernierStart > 3000)
+                    {
+                        hyperliner[i]->actualiser(guidon[i]);
+                        hyperliner[i]->direEstFini( false );
+                    }
+                    else if (hyperliner[i] != 0)
+                        hyperliner[i]->direEstFini( true );
+                    guidon[i] = 0;
+                }
+            else
+            {
+                for (int i(0); i<nbJoueurs; i++)
+                    if (hyperliner[i] != 0)
+                        hyperliner[i]->direEstFini( true );
+            }
+
+            // On gère les collisions en même temps pour plus d'équité
+            for (int i(0); i<nbJoueurs; i++){
+                if (hyperliner[i] != 0)
+                {
+                    hyperliner[i]->collisioner();
+                }
+            }
+
+            // On nettoie les pouvoirs utilisés
             powerCreater.actualiser();
 
         // [2.3] Dessin des composants
             SDL_FillRect(screen, 0, 0);
 
-            collisionneur.afficher();
-            powerCreater.afficher();
-            for (int i(0); i<nbJoueurs; i++)
-            {
-                if (hyperliner[i] != 0)
-                    hyperliner[i]->afficher();
-            }
-
-            if ( nbVivants < 2 ) { // Jeu en fini
-                    displayScore( &tabScore, &texter, nbJoueurs, screen, settings.pseudo );
-                    SDL_ShowCursor( SDL_ENABLE );
-            }
+            collisionneur.afficher();
+            powerCreater.afficher();
+            for (int i(0); i<nbJoueurs; i++)
+            {
+                if (hyperliner[i] != 0)
+                    hyperliner[i]->afficher();
+            }
+
+            if ( nbVivants < 2 ) { // Jeu en fini
+                    displayScore( &tabScore, &texter, nbJoueurs, screen, settings.pseudo );
+                    SDL_ShowCursor( SDL_ENABLE );
+            }
             else SDL_ShowCursor( SDL_DISABLE ); // Jeu en cours
 
-            SDL_Flip(screen);
-
-        // [2.4] Gestion du temps
-            /*ecart = SDL_GetTicks() - tempsPrecedent;
-            if (ecart < frameRate)
-                SDL_Delay(frameRate - ecart);
-            tempsPrecedent = SDL_GetTicks();*/
-            ecart = SDL_GetTicks() - tempsPrecedent;
-            while (ecart < frameRate)
-            {
-                if ( frameRate - ecart > 4 )
-                    SDL_Delay( frameRate - ecart - 4 );
-                ecart = SDL_GetTicks() - tempsPrecedent;
-            }
-            tempsPrecedent = SDL_GetTicks();
-
-    } //fin bcl principale
-
-    /// [3] Etape de fin
-    // Destruction des composants dynamiques
-    for (int i(0); i<nbJoueurs; i++)
-        if (hyperliner[i] != 0)
-                delete hyperliner[i];
-    fermeturePict();
-
-    return 0;
-}
-
-Config readConfig()
-{
-    /// Config
-    Config settings;
-    std::string const source("config.txt");
-    std::ifstream fluxIn(source.c_str());
-    short optEcran;
-
-    /// Attributions
-    if (fluxIn)
-    {
-        //Ouverture fichier succés
-        fluxIn >> settings.xSize;
-        fluxIn >> settings.ySize;
-        fluxIn >> settings.nbJoueurs;
-        fluxIn >> optEcran;
-        fluxIn >> settings.nbPouvoirs;
-
-        for (int i(0); i<12; i++)
-        {
-            fluxIn >> settings.pseudo[i];
-            fluxIn >> settings.cmd[i][0];
-            fluxIn >> settings.cmd[i][1];
-            fluxIn >> settings.cmd[i][2];
-        }
-    }
-    else
-    {
-        //Echec ouverture fichier
-        std::cout << "ERREUR: impossible de lire le fichier " << source << " ." << std::endl;
-
-        //Paramètres par défaut
-        settings.xSize = 45;
-        settings.ySize = 30;
-        settings.nbJoueurs = 2;
-        optEcran = 0;
-        settings.nbPouvoirs = 5;
-
-        for (int i(0); i<4; i++)
-            settings.pseudo[i] = "Joueur " + intToStr(i);
-    }
-
-    /// Optimisation
-    if ( optEcran != 2 ) {
-        settings.pleinEcran = optEcran;
-    }
-    else {
-        settings.pleinEcran = true;
-        const SDL_VideoInfo* fenetreInfo = SDL_GetVideoInfo();
-        settings.xSize = fenetreInfo->current_w / 20;
-        settings.ySize = fenetreInfo->current_h / 20;
-    }
-
-    /// Fin
-    return settings;
-}
-
-void updateScore( Score* tabScore, Liner** hyperliner, int nbJoueurs )
-{
-    if ( hyperliner[0] == 0x0 ) return; // Sécurité
-
-    /// Compter les scores
-    int murder;
-    for ( Uint16 i(0); i < nbJoueurs; i++) {
-        murder = hyperliner[i]->getMeurtrier();
-        if ( murder != -1 ) tabScore->mort[i]++; // Morts
-        if ( murder != -1 && murder != 5 ) tabScore->frag[murder]++; // Frags
-    }
-}
-
-void displayScore( Score* tabScore, TextRender* texter, int nbJoueurs, SDL_Surface* screen, std::string pseudo[12] )
-{
-    SDL_Rect pos = { 50, 50, 0, 0 }, blanc;
-    const int espace( (screen->h - 100 ) / nbJoueurs );
-    std::string chaine;
-    SDL_Surface* bande;
-    for ( Uint16 i(0); i < nbJoueurs; i++ ) {
-        /// Texte
-        chaine = pseudo[i] + " [" + intToStr(i+1) + "] : " + intToStr(tabScore->frag[i]) + " frags; " + intToStr(tabScore->mort[i]) + " morts.";
-
-        /// Text rendering
-        bande = texter->tRendLite( i, chaine );
-
-        /// Blanco
-        blanc.x = pos.x - 4;
-        blanc.y = pos.y - 2;
-        blanc.h = bande->h + 4;
-        blanc.w = bande->w + 8;
-        SDL_FillRect( screen, &blanc, 0xffffff );
-
-        /// Application bande
-        SDL_BlitSurface( texter->takeLite(i), 0, screen, &pos );
-        pos.y += espace;
-    }
-}
-
-void clearScore ( Score* tabScore )
-{
-    for ( Uint16 i(0); i < 12; i++) {
-        tabScore->mort[i] = tabScore->frag[i] = 0; // Initialisaton
-    }
-}
+            SDL_Flip(screen);
+
+        // [2.4] Gestion du temps
+            /*ecart = SDL_GetTicks() - tempsPrecedent;
+            if (ecart < frameRate)
+                SDL_Delay(frameRate - ecart);
+            tempsPrecedent = SDL_GetTicks();*/
+            ecart = SDL_GetTicks() - tempsPrecedent;
+            while (ecart < frameRate)
+            {
+                if ( frameRate - ecart > 4 )
+                    SDL_Delay( frameRate - ecart - 4 );
+                ecart = SDL_GetTicks() - tempsPrecedent;
+            }
+            tempsPrecedent = SDL_GetTicks();
+
+    } //fin bcl principale
+
+    /// [3] Etape de fin
+    // Destruction des composants dynamiques
+    for (int i(0); i<nbJoueurs; i++)
+        if (hyperliner[i] != 0)
+                delete hyperliner[i];
+    fermeturePict();
+
+    return 0;
+}
+
+Config readConfig()
+{
+    /// Config
+    Config settings;
+    std::string const source("config.txt");
+    std::ifstream fluxIn(source.c_str());
+    short optEcran;
+
+    /// Attributions
+    if (fluxIn)
+    {
+        //Ouverture fichier succés
+        fluxIn >> settings.xSize;
+        fluxIn >> settings.ySize;
+        fluxIn >> settings.nbJoueurs;
+        fluxIn >> optEcran;
+        fluxIn >> settings.nbPouvoirs;
+
+        for (int i(0); i<12; i++)
+        {
+            fluxIn >> settings.pseudo[i];
+            fluxIn >> settings.cmd[i][0];
+            fluxIn >> settings.cmd[i][1];
+            fluxIn >> settings.cmd[i][2];
+        }
+    }
+    else
+    {
+        //Echec ouverture fichier
+        std::cout << "ERREUR: impossible de lire le fichier " << source << " ." << std::endl;
+
+        //Paramètres par défaut
+        settings.xSize = 45;
+        settings.ySize = 30;
+        settings.nbJoueurs = 2;
+        optEcran = 0;
+        settings.nbPouvoirs = 5;
+
+        for (int i(0); i<4; i++)
+            settings.pseudo[i] = "Joueur " + intToStr(i);
+    }
+
+    /// Optimisation
+    if ( optEcran != 2 ) {
+        settings.pleinEcran = optEcran;
+    }
+    else {
+        settings.pleinEcran = true;
+        const SDL_VideoInfo* fenetreInfo = SDL_GetVideoInfo();
+        settings.xSize = fenetreInfo->current_w / 20;
+        settings.ySize = fenetreInfo->current_h / 20;
+    }
+
+    /// Fin
+    return settings;
+}
+
+void updateScore( Score* tabScore, Liner** hyperliner, int nbJoueurs )
+{
+    if ( hyperliner[0] == 0x0 ) return; // Sécurité
+
+    /// Compter les scores
+    int murder;
+    for ( Uint16 i(0); i < nbJoueurs; i++) {
+        murder = hyperliner[i]->getMeurtrier();
+        if ( murder != -1 ) tabScore->mort[i]++; // Morts
+        if ( murder != -1 && murder != 5 ) tabScore->frag[murder]++; // Frags
+    }
+}
+
+void displayScore( Score* tabScore, TextRender* texter, int nbJoueurs, SDL_Surface* screen, std::string pseudo[12] )
+{
+    SDL_Rect pos = { 50, 50, 0, 0 }, blanc;
+    const int espace( (screen->h - 100 ) / nbJoueurs );
+    std::string chaine;
+    SDL_Surface* bande;
+    for ( Uint16 i(0); i < nbJoueurs; i++ ) {
+        /// Texte
+        chaine = pseudo[i] + " [" + intToStr(i+1) + "] : " + intToStr(tabScore->frag[i]) + " frags; " + intToStr(tabScore->mort[i]) + " morts.";
+
+        /// Text rendering
+        bande = texter->tRendLite( i, chaine );
+
+        /// Blanco
+        blanc.x = pos.x - 4;
+        blanc.y = pos.y - 2;
+        blanc.h = bande->h + 4;
+        blanc.w = bande->w + 8;
+        SDL_FillRect( screen, &blanc, 0xffffff );
+
+        /// Application bande
+        SDL_BlitSurface( texter->takeLite(i), 0, screen, &pos );
+        pos.y += espace;
+    }
+}
+
+void clearScore ( Score* tabScore )
+{
+    for ( Uint16 i(0); i < 12; i++) {
+        tabScore->mort[i] = tabScore->frag[i] = 0; // Initialisaton
+    }
+}

jeu.h

@@ -1,69 +1,69 @@
-#ifndef JEU_H_INCLUDED
-#define JEU_H_INCLUDED
-
+#ifndef JEU_H_INCLUDED
+#define JEU_H_INCLUDED
+
 #include <SDL/SDL.h>
 #include "Liner.h"
-#include "Collisions.h"
-#include "Power.h"
-#include "TextRender.h"
-#include "Starter.h"
-#include "intToStr.h"
-
-#include <fstream>// Pour readConfig()
-
-// Couleurs
-#define ROUGE 128, 0, 0
-#define BLEU 0, 0, 128
-#define VERT 0, 128, 0
-#define JAUNE 128, 128, 0
-#define ROSE 128, 0, 128
-#define CYAN 0, 128, 128
-#define ORANGE 128, 64, 0
-#define VIOLET 64, 0, 60
-#define GRIS 64, 64, 64
-#define MARINE 0, 0, 64
-#define PLUME 32, 64, 128
-#define MARRON 64, 32, 0
-
- struct Config
- {
-     int xSize;
-     int ySize;
-     int nbJoueurs;
-     bool pleinEcran;
-     int nbPouvoirs;
-
-     std::string pseudo[12];
-     int cmd[12][3];
- };
-
- struct Score
- {
-     Uint32 frag[12]; // Stocke le nombre de frags de chaque joueur
-     Uint32 mort[12]; // Nb de morts
- };
-
-int jeuMulti( SDL_Surface* screen, Config settings );
-/** \brief Permet de lancer le mode de jeu en multi-joueur
- *
- * \param SDL_Surface* contenant la surface dynamique de la fenêtre
- * \param int contenant le nombre de joueurs.
- * \return entier : 0 si pas d'erreur, autre si problème
- *
- */
-
-//int jeuSolo( SDL_Surface* screen );
-/** \brief Mode survie un joueur
- *
- * \param SDL_Surface* contenant la surface dynamique de la fenêtre
- * \param
- * \return entier : 0 si pas d'erreur, autre si problème
- *
- */
-
-Config readConfig();
-void updateScore( Score* tabScore, Liner** hyperliner, int nbJoueurs );
-void displayScore( Score* tabScore, TextRender* texter, int nbJoueurs, SDL_Surface* screen, std::string pseudo[4] );
-void clearScore ( Score* tabScore );
-
-#endif // JEU_H_INCLUDED
+#include "Collisions.h"
+#include "Power.h"
+#include "TextRender.h"
+#include "Starter.h"
+#include "intToStr.h"
+
+#include <fstream>// Pour readConfig()
+
+// Couleurs
+#define ROUGE 128, 0, 0
+#define BLEU 0, 0, 128
+#define VERT 0, 128, 0
+#define JAUNE 128, 128, 0
+#define ROSE 128, 0, 128
+#define CYAN 0, 128, 128
+#define ORANGE 128, 64, 0
+#define VIOLET 64, 0, 60
+#define GRIS 64, 64, 64
+#define MARINE 0, 0, 64
+#define PLUME 32, 64, 128
+#define MARRON 64, 32, 0
+
+ struct Config
+ {
+     int xSize;
+     int ySize;
+     int nbJoueurs;
+     bool pleinEcran;
+     int nbPouvoirs;
+
+     std::string pseudo[12];
+     int cmd[12][3];
+ };
+
+ struct Score
+ {
+     Uint32 frag[12]; // Stocke le nombre de frags de chaque joueur
+     Uint32 mort[12]; // Nb de morts
+ };
+
+int jeuMulti( SDL_Surface* screen, Config settings );
+/** \brief Permet de lancer le mode de jeu en multi-joueur
+ *
+ * \param SDL_Surface* contenant la surface dynamique de la fenêtre
+ * \param int contenant le nombre de joueurs.
+ * \return entier : 0 si pas d'erreur, autre si problème
+ *
+ */
+
+//int jeuSolo( SDL_Surface* screen );
+/** \brief Mode survie un joueur
+ *
+ * \param SDL_Surface* contenant la surface dynamique de la fenêtre
+ * \param
+ * \return entier : 0 si pas d'erreur, autre si problème
+ *
+ */
+
+Config readConfig();
+void updateScore( Score* tabScore, Liner** hyperliner, int nbJoueurs );
+void displayScore( Score* tabScore, TextRender* texter, int nbJoueurs, SDL_Surface* screen, std::string pseudo[4] );
+void clearScore ( Score* tabScore );
+
+#endif // JEU_H_INCLUDED

main.cpp

@@ -1,18 +1,18 @@
 #include <iostream>
-#include <SDL/SDL.h>
-
+#include <SDL/SDL.h>
+
 #include <cstdlib>
-#include <ctime>
-
-#include "jeu.h"
-
-/** \brief Main de Mighty Liners
- * \last Init random
- * \next Importer pouvoirs
- *
- * \return entier : 0 si pas d'erreur, autre si problème
- *
- */
+#include <ctime>
+
+#include "jeu.h"
+
+/** \brief Main de Mighty Liners
+ * \last Init random
+ * \next Importer pouvoirs
+ *
+ * \return entier : 0 si pas d'erreur, autre si problème
+ *
+ */
 
 
 int main ( int argc, char** argv )
@@ -29,17 +29,17 @@ int main ( int argc, char** argv )
     atexit(SDL_Quit);
 
     // [1.3] Para-fenêtre
-    SDL_WM_SetCaption("Mighty Liners V2 - By Jovian", 0);
-
-    // [1.4] Démarrage de l'aléatoire
+    SDL_WM_SetCaption("Mighty Liners V2 - By Jovian", 0);
+
+    // [1.4] Démarrage de l'aléatoire
     srand(time(0));
 
-    /// [2] Préparation des composants
-    // [2.0] Lecture des paramètres
-    Config settings(readConfig());
+    /// [2] Préparation des composants
+    // [2.0] Lecture des paramètres
+    Config settings(readConfig());
 
-    // [2.1] Préparation de la fenêtre
-    Uint32 flags(SDL_HWSURFACE | SDL_DOUBLEBUF);
+    // [2.1] Préparation de la fenêtre
+    Uint32 flags(SDL_HWSURFACE | SDL_DOUBLEBUF);
     if (settings.pleinEcran) flags |= SDL_FULLSCREEN;
     SDL_Surface* screen = SDL_SetVideoMode(settings.xSize*20, settings.ySize*20, 32, flags);
     if ( !screen )
@@ -48,12 +48,12 @@ int main ( int argc, char** argv )
         return 1;
     }
 
-    /// [3] Boucle principale
-    int retour;
+    /// [3] Boucle principale
+    int retour;
     retour = jeuMulti(screen, settings);
 
     /// [4] Destruction des composants
-    SDL_FreeSurface(screen);
+    SDL_FreeSurface(screen);
 
     std::cout << "Aucune erreur detectee." << std::endl;
     return retour;

powers/Bomb.cpp

@@ -2,7 +2,7 @@
 
 Bomb::Bomb(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -12,9 +12,9 @@ Bomb::~Bomb()
 }///Destructeur
 
 void Bomb::usePower(int orientation, int &x, int &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Bomb");
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Bomb");
 
     //[1] Orientation de la trajectoire du Bomb
     int posX(x);
@@ -24,17 +24,17 @@ void Bomb::usePower(int orientation, int &x, int &y, int const &ID)
     int ajoutY(0);
     convertDir(orientation, ajoutX, ajoutY);
 
-    //[2] Parcours du Bomb dans le vide
+    //[2] Parcours du Bomb dans le vide
     while (m_gestionnaireCollisions->tester(posX, posY) == VIDE)
     {
         posX += ajoutX;
         posY += ajoutY;
-    }
+    }
 
     posX -= ajoutX;
     posY -= ajoutY;
 
-    //[3] Boum
+    //[3] Boum
     for (int i(-2); i<=2; i++)
         for (int j(-2); j<=2; j++)
             if (i != 0 || j != 0) m_gestionnaireCollisions->ajouter(posX+i, posY+j, ID);
@@ -45,13 +45,13 @@ void Bomb::usePower(int orientation, int &x, int &y, int const &ID)
 
 void Bomb::postMortemPower(int const &x, int const &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Bomb");
+    //[0] Bruitage
+    m_mediaPlayer->play("Bomb");
 
-    //[1] Explosion de blocs
+    //[1] Explosion de blocs
     for (int i(-1); i<=1; i++)
         for (int j(-1); j<=1; j++)
-            if (i != 0 || j != 0) m_gestionnaireCollisions->enlever(x+i, y+j);
+            if (i != 0 || j != 0) m_gestionnaireCollisions->enlever(x+i, y+j);
 
     //[end]
     m_used = true;

powers/Bomb.h

@@ -1,24 +1,24 @@
-#ifndef BOMB_H
-#define BOMB_H
-
+#ifndef BOMB_H
+#define BOMB_H
+
 #include "../Power.h"
 
-/** \brief Bomb : hérite de Power
- * \last Création
- * \next Mise en fonctionnement
- *
- *
+/** \brief Bomb : hérite de Power
+ * \last Création
+ * \next Mise en fonctionnement
+ *
+ *
  */
 
 class Bomb : public Power
 {
-    public:
+    public:
 
         Bomb(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Bomb();
+        virtual ~Bomb();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // BOMB_H
+};
+
+#endif // BOMB_H

powers/Boost.cpp

@@ -2,7 +2,7 @@
 
 Boost::Boost(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -13,8 +13,8 @@ Boost::~Boost()
 
 void Boost::usePower(int orientation, int &x, int &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Boost");
+    //[0] Bruitage
+    m_mediaPlayer->play("Boost");
 
     //[1]Préparation de l'orientation du bond
     int ajoutX(0);
@@ -47,20 +47,20 @@ void Boost::usePower(int orientation, int &x, int &y, int const &ID)
 }///usePower
 
 void Boost::postMortemPower(int const &x, int const &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Boost");
-
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Boost");
+
     //[1] Etalage
-    int portee(2);
-
-    for (int i(-portee); i <= portee; i++)
-        if ( i != 0 )
-            m_gestionnaireCollisions->ajouter(x, y+i, ID);
+    int portee(2);
+
+    for (int i(-portee); i <= portee; i++)
+        if ( i != 0 )
+            m_gestionnaireCollisions->ajouter(x, y+i, ID);
 
-    for (int i(-portee); i <= portee; i++)
-        if ( i != 0 )
-            m_gestionnaireCollisions->ajouter(x+i, y, ID);
+    for (int i(-portee); i <= portee; i++)
+        if ( i != 0 )
+            m_gestionnaireCollisions->ajouter(x+i, y, ID);
 
     m_used = true;
 }///postMortemPower

powers/Boost.h

@@ -1,24 +1,24 @@
-#ifndef BOOST_H_INCLUDED
+#ifndef BOOST_H_INCLUDED
 #define BOOST_H_INCLUDED
 
 #include "../Power.h"
-
-/** \brief Boost : hérite de Power
- * \last Post mortem implémenté
- * \next
- *
- *
+
+/** \brief Boost : hérite de Power
+ * \last Post mortem implémenté
+ * \next
+ *
+ *
  */
 
 class Boost : public Power
 {
-    public:
+    public:
 
         Boost(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Boost();
+        virtual ~Boost();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // BOOST_H_INCLUDED
+};
+
+#endif // BOOST_H_INCLUDED

powers/Bouclier.cpp

@@ -2,7 +2,7 @@
 
 Bouclier::Bouclier(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -13,8 +13,8 @@ Bouclier::~Bouclier()
 
 void Bouclier::usePower(int orientation, int &x, int &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Bouclier");
+    //[0] Bruitage
+    m_mediaPlayer->play("Bouclier");
 
     //[1] Orientation de la trajectoire du Bouclier
     int ajoutX(0);
@@ -22,7 +22,7 @@ void Bouclier::usePower(int orientation, int &x, int &y, int const &ID)
     convertDir(orientation, ajoutY, ajoutX);//Perpendicularité
 
     //[2] Protect instant
-    for (int i(-1); i <= 1; i++)
+    for (int i(-1); i <= 1; i++)
         m_gestionnaireCollisions->ajouter(x+ajoutX*i, y+ajoutY*i, ID);
 
     //[END]
@@ -30,12 +30,12 @@ void Bouclier::usePower(int orientation, int &x, int &y, int const &ID)
 }///usePower
 
 void Bouclier::postMortemPower(int const &x, int const &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Bouclier");
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Bouclier");
 
     //Désintégration du mur
-    m_gestionnaireCollisions->enlever(x, y);
+    m_gestionnaireCollisions->enlever(x, y);
 
     //[end]
     m_used = true;

powers/Bouclier.h

@@ -1,25 +1,25 @@
-#ifndef BOUCLIER_H_INCLUDED
-#define BOUCLIER_H_INCLUDED
-
+#ifndef BOUCLIER_H_INCLUDED
+#define BOUCLIER_H_INCLUDED
+
 #include "../Power.h"
-
+
 /// Last modification : 14 04 2014
-/** \brief Bouclier : hérite de Power
- * \last Post mortem implémenté
- * \next
- *
- *
+/** \brief Bouclier : hérite de Power
+ * \last Post mortem implémenté
+ * \next
+ *
+ *
  */
 
 class Bouclier : public Power
 {
-    public:
+    public:
 
         Bouclier(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Bouclier();
+        virtual ~Bouclier();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // BOUCLIER_H_INCLUDED
+};
+
+#endif // BOUCLIER_H_INCLUDED

powers/Expansion.cpp

@@ -2,7 +2,7 @@
 
 Expansion::Expansion(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -12,26 +12,26 @@ Expansion::~Expansion()
 }///Destructeur
 
 void Expansion::usePower(int orientation, int &x, int &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Expansion");
-
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Expansion");
+
     //[1] Paramètres
-    int portee(5);
-    int const posX(x);
-    int const posY(y);
-
+    int portee(5);
+    int const posX(x);
+    int const posY(y);
+
     //[2] Epandage
     if (orientation==HAUT || orientation==BAS)
-    {//Epandage horizontal
-        for (int i(-portee); i <= portee; i++)
+    {//Epandage horizontal
+        for (int i(-portee); i <= portee; i++)
             m_gestionnaireCollisions->ajouter(posX+i, posY, ID);
     }
     else
     {//Epandage vertical
-        for (int i(-portee); i <= portee; i++)
+        for (int i(-portee); i <= portee; i++)
             m_gestionnaireCollisions->ajouter(posX, posY+i, ID);
-    }
+    }
 
     //[END]
     m_used = true;
@@ -39,13 +39,13 @@ void Expansion::usePower(int orientation, int &x, int &y, int const &ID)
 
 void Expansion::postMortemPower(int const &x, int const &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Expansion");
-
-    //[1] Etalage
+    //[0] Bruitage
+    m_mediaPlayer->play("Expansion");
+
+    //[1] Etalage
     for (int i(0); i<3; i++)
         for (int j(0); j<3;j++)
-            m_gestionnaireCollisions->ajouter(x-1+i, y-1+j, ID);
+            m_gestionnaireCollisions->ajouter(x-1+i, y-1+j, ID);
 
     //[END]
     m_used = true;

powers/Expansion.h

@@ -1,24 +1,24 @@
-#ifndef EXPANSION_H_INCLUDED
-#define EXPANSION_H_INCLUDED
+#ifndef EXPANSION_H_INCLUDED
+#define EXPANSION_H_INCLUDED
 
 #include "../Power.h"
-
-/** \brief Expansion : hérite de Power
- * \last Relecture et premières corrections
- * \next
- *
- *
- */
+
+/** \brief Expansion : hérite de Power
+ * \last Relecture et premières corrections
+ * \next
+ *
+ *
+ */
 
 class Expansion : public Power
 {
-    public:
+    public:
 
         Expansion(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Expansion();
+        virtual ~Expansion();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // EXPANSION_H_INCLUDED
+};
+
+#endif // EXPANSION_H_INCLUDED

powers/Missile.cpp

@@ -2,7 +2,7 @@
 
 Missile::Missile(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -12,9 +12,9 @@ Missile::~Missile()
 }///Destructeur
 
 void Missile::usePower(int orientation, int &x, int &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Missile");
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Missile");
 
     //[1] Orientation de la trajectoire du missile
     int posX(x);
@@ -46,13 +46,13 @@ void Missile::usePower(int orientation, int &x, int &y, int const &ID)
 
 void Missile::postMortemPower(int const &x, int const &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Missile");
+    //[0] Bruitage
+    m_mediaPlayer->play("Missile");
 
-    //[1] Explosion
+    //[1] Explosion
     for (int i(-1); i<=1; i++)
         for (int j(-1); j<=1; j++)
-            if (i != 0 || j != 0) m_gestionnaireCollisions->enlever(x+i, y+j);
+            if (i != 0 || j != 0) m_gestionnaireCollisions->enlever(x+i, y+j);
 
     //[end]
     m_used = true;

powers/Missile.h

@@ -1,24 +1,24 @@
-#ifndef MISSILE_H_INCLUDED
-#define MISSILE_H_INCLUDED
+#ifndef MISSILE_H_INCLUDED
+#define MISSILE_H_INCLUDED
 
 #include "../Power.h"
 
-/** \brief Missile : hérite de Power
- * \last Relecture et premières corrections
- * \next
- *
- *
+/** \brief Missile : hérite de Power
+ * \last Relecture et premières corrections
+ * \next
+ *
+ *
  */
 
 class Missile : public Power
 {
-    public:
+    public:
 
         Missile(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Missile();
+        virtual ~Missile();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // MISSILE_H_INCLUDED
+};
+
+#endif // MISSILE_H_INCLUDED

powers/Teleport.cpp

@@ -13,8 +13,8 @@ Teleport::~Teleport()
 
 void Teleport::usePower(int orientation, int &x, int &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Teleport");
+    //[0] Bruitage
+    m_mediaPlayer->play("Teleport");
 
     //[1]Préparation de l'orientation du bond
     int ajoutX(0);
@@ -33,15 +33,15 @@ void Teleport::usePower(int orientation, int &x, int &y, int const &ID)
 }///usePower
 
 void Teleport::postMortemPower(int const &x, int const &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Teleport");
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Teleport");
 
-    //[1] Inversion
+    //[1] Inversion
     for (int i(-1); i<=1; i++)
         for (int j(-1); j<=1; j++)
-            if ((i != 0 || j != 0) && m_gestionnaireCollisions->tester(x+i, y+j) != VIDE) m_gestionnaireCollisions->enlever(x+i, y+j);
-            else m_gestionnaireCollisions->ajouter(x+i, y+j, ID);
+            if ((i != 0 || j != 0) && m_gestionnaireCollisions->tester(x+i, y+j) != VIDE) m_gestionnaireCollisions->enlever(x+i, y+j);
+            else m_gestionnaireCollisions->ajouter(x+i, y+j, ID);
 
     m_used = true;
 }///postMortemPower

powers/Teleport.h

@@ -1,24 +1,24 @@
-#ifndef TELEPORT_H_INCLUDED
-#define TELEPORT_H_INCLUDED
+#ifndef TELEPORT_H_INCLUDED
+#define TELEPORT_H_INCLUDED
 
 #include "../Power.h"
-
-/** \brief Teleport : hérite de Power
- * \last Post mortem implémenté
- * \next
- *
- *
- */
+
+/** \brief Teleport : hérite de Power
+ * \last Post mortem implémenté
+ * \next
+ *
+ *
+ */
 
 class Teleport : public Power
 {
-    public:
+    public:
 
         Teleport(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Teleport();
+        virtual ~Teleport();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // TELEPORT_H_INCLUDED
+};
+
+#endif // TELEPORT_H_INCLUDED

powers/Trender.cpp

@@ -2,7 +2,7 @@
 
 Trender::Trender(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -12,9 +12,9 @@ Trender::~Trender()
 }///Destructeur
 
 void Trender::usePower(int orientation, int &x, int &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Trender");
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Trender");
 
     //[1] Orientation de la trajectoire du Trender
     int posX(x);
@@ -33,18 +33,18 @@ void Trender::usePower(int orientation, int &x, int &y, int const &ID)
 
     //[3] Traverse de toute l'épaisseur
     while (m_gestionnaireCollisions->tester(posX, posY) != VIDE)
-    {
+    {
         posX += ajoutX;
         posY += ajoutY;
-    }
-
-    //[4] Ajoute une ligne
-    for ( int i(0); i < 6; i++ )
-    {
+    }
+
+    //[4] Ajoute une ligne
+    for ( int i(0); i < 6; i++ )
+    {
         m_gestionnaireCollisions->ajouter(posX, posY, ID);
 
         posX += ajoutX;
-        posY += ajoutY;
+        posY += ajoutY;
     }
 
     //[END]
@@ -53,13 +53,13 @@ void Trender::usePower(int orientation, int &x, int &y, int const &ID)
 
 void Trender::postMortemPower(int const &x, int const &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Trender");
+    //[0] Bruitage
+    m_mediaPlayer->play("Trender");
 
-    //[1] Explosion de blocs
+    //[1] Explosion de blocs
     for (int i(-1); i<=1; i++)
         for (int j(-1); j<=1; j++)
-            if (i != 0 || j != 0) m_gestionnaireCollisions->ajouter(x+i, y+j, ID);
+            if (i != 0 || j != 0) m_gestionnaireCollisions->ajouter(x+i, y+j, ID);
 
     //[end]
     m_used = true;

powers/Trender.h

@@ -1,25 +1,25 @@
-#ifndef TRENDER_H
-#define TRENDER_H
-
+#ifndef TRENDER_H
+#define TRENDER_H
+
 #include "../Power.h"
 
-/** \brief Trender : hérite de Power
- * \last Création
- * \next Mise en fonctionnement
- *
- *
+/** \brief Trender : hérite de Power
+ * \last Création
+ * \next Mise en fonctionnement
+ *
+ *
  */
 
 class Trender : public Power
 {
-    public:
+    public:
 
         Trender(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Trender();
+        virtual ~Trender();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-
-#endif // TRENDER_H
+};
+
+
+#endif // TRENDER_H

powers/Tunnel.cpp

@@ -2,7 +2,7 @@
 
 Tunnel::Tunnel(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
 : Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
-{
+{
 
 }///Constructeur
 
@@ -12,9 +12,9 @@ Tunnel::~Tunnel()
 }///Destructeur
 
 void Tunnel::usePower(int orientation, int &x, int &y, int const &ID)
-{
-    //[0] Bruitage
-    m_mediaPlayer->play("Tunnel");
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Tunnel");
 
     //[1] Orientation de la trajectoire du Tunnel
     int posX(x);
@@ -22,17 +22,17 @@ void Tunnel::usePower(int orientation, int &x, int &y, int const &ID)
 
     int ajoutX(0);
     int ajoutY(0);
-    convertDir(orientation, ajoutX, ajoutY);
-
-    //[2] Ajoute une ligne
-    for ( int i(0); i < 10; i++ )
-    {
-        m_gestionnaireCollisions->ajouter(posX + ajoutY, posY + ajoutX, ID);
-        m_gestionnaireCollisions->ajouter(posX - ajoutY, posY - ajoutX, ID);
+    convertDir(orientation, ajoutX, ajoutY);
+
+    //[2] Ajoute une ligne
+    for ( int i(0); i < 10; i++ )
+    {
+        m_gestionnaireCollisions->ajouter(posX + ajoutY, posY + ajoutX, ID);
+        m_gestionnaireCollisions->ajouter(posX - ajoutY, posY - ajoutX, ID);
         //m_gestionnaireCollisions->enlever(posX, posY)
 
         posX += ajoutX;
-        posY += ajoutY;
+        posY += ajoutY;
     }
 
     //[END]
@@ -41,13 +41,13 @@ void Tunnel::usePower(int orientation, int &x, int &y, int const &ID)
 
 void Tunnel::postMortemPower(int const &x, int const &y, int const &ID)
 {
-    //[0] Bruitage
-    m_mediaPlayer->play("Tunnel");
+    //[0] Bruitage
+    m_mediaPlayer->play("Tunnel");
 
-    //[1] Explosion de blocs
+    //[1] Explosion de blocs
     for (int i(-1); i<=1; i++)
         for (int j(-1); j<=1; j++)
-            if (i != 0 || j != 0) m_gestionnaireCollisions->ajouter(x+i, y+j, ID);
+            if (i != 0 || j != 0) m_gestionnaireCollisions->ajouter(x+i, y+j, ID);
 
     //[end]
     m_used = true;

powers/Tunnel.h

@@ -1,24 +1,24 @@
-#ifndef TUNNEL_H
-#define TUNNEL_H
-
+#ifndef TUNNEL_H
+#define TUNNEL_H
+
 #include "../Power.h"
 
-/** \brief Tunnel : hérite de Power
- * \last Création
- * \next Mise en fonctionnement
- *
- *
+/** \brief Tunnel : hérite de Power
+ * \last Création
+ * \next Mise en fonctionnement
+ *
+ *
  */
 
 class Tunnel : public Power
 {
-    public:
+    public:
 
         Tunnel(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
-        virtual ~Tunnel();
+        virtual ~Tunnel();
 
         virtual void usePower(int orientation, int &x, int &y, int const &ID);
         virtual void postMortemPower(int const &x, int const &y, int const &ID);
-};
-
-#endif // TUNNEL_H
+};
+
+#endif // TUNNEL_H

traitement.cpp

@@ -2,20 +2,20 @@
 
 SDL_Surface* retournement(SDL_Surface* originale, int nbQuarts)
 {
-    //Création de la seconde surface
+    //Création de la seconde surface
     nbQuarts%=4;
     SDL_Surface* pivot(0);
     if (nbQuarts%2)
-        pivot=SDL_CreateRGBSurface(SDL_HWSURFACE, originale->h, originale->w, originale->format->BitsPerPixel,
+        pivot=SDL_CreateRGBSurface(SDL_HWSURFACE, originale->h, originale->w, originale->format->BitsPerPixel,
                                    originale->format->Rmask, originale->format->Gmask, originale->format->Bmask, originale->format->Amask);
     else
-        pivot=SDL_CreateRGBSurface(SDL_HWSURFACE, originale->w, originale->h, originale->format->BitsPerPixel,
-                                   originale->format->Rmask, originale->format->Gmask, originale->format->Bmask, originale->format->Amask);
-    if (nbQuarts != 0)
-    {
-        // Démarrage du retournement
-        unsigned char* pixelsSources = (unsigned char*) originale->pixels;
-        unsigned char* pixelsPivot = (unsigned char*) pivot->pixels;
+        pivot=SDL_CreateRGBSurface(SDL_HWSURFACE, originale->w, originale->h, originale->format->BitsPerPixel,
+                                   originale->format->Rmask, originale->format->Gmask, originale->format->Bmask, originale->format->Amask);
+    if (nbQuarts != 0)
+    {
+        // Démarrage du retournement
+        unsigned char* pixelsSources = (unsigned char*) originale->pixels;
+        unsigned char* pixelsPivot = (unsigned char*) pivot->pixels;
         Uint8 bytes(originale->format->BytesPerPixel);
 
         // Balayage
@@ -35,29 +35,29 @@ SDL_Surface* retournement(SDL_Surface* originale, int nbQuarts)
                 if (nbQuarts == 3){
                     xToPos = yFromPos;
                     yToPos = originale->w - xFromPos - 1;
-                }
-
-                for (int i(0); i < bytes; i++)
+                }
+
+                for (int i(0); i < bytes; i++)
                     pixelsPivot[yToPos * pivot->w * bytes + xToPos * bytes + i] = pixelsSources[yFromPos * originale->w * bytes + xFromPos * bytes + i];
-            }
-    }
-    else
-        // Copie sans modif
+            }
+    }
+    else
+        // Copie sans modif
         SDL_BlitSurface(originale, 0, pivot, 0);
 
     return pivot;
 }
 
-SDL_Surface* destroyColor(SDL_Surface* originale, bool blue, bool green, bool red)
-{
+SDL_Surface* destroyColor(SDL_Surface* originale, bool blue, bool green, bool red)
+{
     //Création de la seconde surface
-    SDL_Surface* produit = SDL_CreateRGBSurface(SDL_HWSURFACE, originale->h, originale->w, originale->format->BitsPerPixel,
-                                                originale->format->Rmask, originale->format->Gmask, originale->format->Bmask, originale->format->Amask);
-    if (blue || green || red)
-    {
-        // Démarrage du retournement
-        unsigned char* pixelsSources = (unsigned char*) originale->pixels;
-        unsigned char* pixelsProduit = (unsigned char*) produit->pixels;
+    SDL_Surface* produit = SDL_CreateRGBSurface(SDL_HWSURFACE, originale->h, originale->w, originale->format->BitsPerPixel,
+                                                originale->format->Rmask, originale->format->Gmask, originale->format->Bmask, originale->format->Amask);
+    if (blue || green || red)
+    {
+        // Démarrage du retournement
+        unsigned char* pixelsSources = (unsigned char*) originale->pixels;
+        unsigned char* pixelsProduit = (unsigned char*) produit->pixels;
         Uint8 bytes(originale->format->BytesPerPixel);
 
         // Balayage
@@ -66,49 +66,49 @@ SDL_Surface* destroyColor(SDL_Surface* originale, bool blue, bool green, bool re
             for (yPos = 0; yPos < originale->h; yPos++)
             {
                 if (!blue)
-                    pixelsProduit[yPos * produit->w * bytes + xPos * bytes] = pixelsSources[yPos * originale->w * bytes + xPos * bytes];
+                    pixelsProduit[yPos * produit->w * bytes + xPos * bytes] = pixelsSources[yPos * originale->w * bytes + xPos * bytes];
 
                 if (!green)
-                    pixelsProduit[yPos * produit->w * bytes + xPos * bytes + 1] = pixelsSources[yPos * originale->w * bytes + xPos * bytes + 1];
+                    pixelsProduit[yPos * produit->w * bytes + xPos * bytes + 1] = pixelsSources[yPos * originale->w * bytes + xPos * bytes + 1];
 
                 if (!red)
                     pixelsProduit[yPos * produit->w * bytes + xPos * bytes + 2] = pixelsSources[yPos * originale->w * bytes + xPos * bytes + 2];
-            }
-    }
-    else
-        // Copie sans modif
-        SDL_BlitSurface(originale, 0, produit, 0);
-
-    return produit;
-}
-
-SDL_Surface* colorMightyObjet(SDL_Surface* source, int id)
-{
-    switch (id)
-    {
-    case 0:
-        return destroyColor(source, true, true, false);// Rouge
-        break;
-    case 1:
-        return destroyColor(source, false, true, true);// Bleu
-        break;
-    case 2:
-        return destroyColor(source, true, false, true);// Vert
-        break;
-    case 3:
-        return destroyColor(source, true, false, false);// Jaune
-        break;
-    case 4:
-        return destroyColor(source, false, true, false);// Rose
-        break;
-    case 5:
-        return destroyColor(source, false, false, true);// Cyan
-        break;
-    case 6:
-        return destroyColor(source, true, true, false);// Orange
-        break;
-    default:
-        return destroyColor(source, false, false, false);// Pas de modif : retourne une copie
-        break;
-    }
-}
+            }
+    }
+    else
+        // Copie sans modif
+        SDL_BlitSurface(originale, 0, produit, 0);
+
+    return produit;
+}
+
+SDL_Surface* colorMightyObjet(SDL_Surface* source, int id)
+{
+    switch (id)
+    {
+    case 0:
+        return destroyColor(source, true, true, false);// Rouge
+        break;
+    case 1:
+        return destroyColor(source, false, true, true);// Bleu
+        break;
+    case 2:
+        return destroyColor(source, true, false, true);// Vert
+        break;
+    case 3:
+        return destroyColor(source, true, false, false);// Jaune
+        break;
+    case 4:
+        return destroyColor(source, false, true, false);// Rose
+        break;
+    case 5:
+        return destroyColor(source, false, false, true);// Cyan
+        break;
+    case 6:
+        return destroyColor(source, true, true, false);// Orange
+        break;
+    default:
+        return destroyColor(source, false, false, false);// Pas de modif : retourne une copie
+        break;
+    }
+}

traitement.h

@@ -11,7 +11,7 @@ SDL_Surface* retournement(SDL_Surface* originale, int nbQuarts);
  * int nbQuarts \param Indique le nombre de quarts de tour à réaliser, sens indirect.
  * SDL_Surface* \return La surface pivotée. Attention ! Ne pas oublier freeSurface().
  *
- */
+ */
 
 SDL_Surface* destroyColor(SDL_Surface* originale, bool blue, bool green, bool red);
 /** destroyColor() \brief Permet de créer une nouvelle image en retirant des couleurs.
@@ -22,8 +22,8 @@ SDL_Surface* destroyColor(SDL_Surface* originale, bool blue, bool green, bool re
  * bool red \param Indique si cette couleur est à retirer.
  * SDL_Surface* \return La surface modifiée. Attention ! Ne pas oublier freeSurface().
  *
- */
-
+ */
+
  SDL_Surface* colorMightyObjet(SDL_Surface* source, int id);
 /** colorMightyObjet() \brief Utilise destroyColor() en fonction de l'identifiant.
  *