Import source code from old project

Project was initially edited with Code::Blocks under Windows.

Collisions.cpp

@@ -0,0 +1,121 @@
+#include "Collisions.h"
+
+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
+    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
+    for (int i(0); i<4; i++)
+        SDL_FreeSurface(m_carre[i]);
+    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
+    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
+
+}///ajouter
+
+void Collisions::enlever(int x, int y)
+{
+    // 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
+    m_tableau[y][x] = VIDE;
+}///enlever
+
+int Collisions::tester(int x,int y) const
+{
+    coorectPos(x,y);
+    return m_tableau[y][x];
+}///tester
+
+void Collisions::afficher()
+{
+    SDL_BlitSurface(m_terrain, 0, m_screen, 0);
+}///dessiner
+
+void Collisions::reinitialiser()
+{
+    for (int i(0); i < m_ySize; i++)
+    {
+        for (int j(0); j < m_xSize; j++)
+        {
+            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;
+}///coorectPos
+
+int Collisions::getSize(int idCoord)
+{
+    if (idCoord) // y -> 1
+        return m_ySize;
+    else // x -> 0
+        return m_xSize;
+}

Collisions.h

@@ -0,0 +1,57 @@
+#ifndef COLLISIONS_H_INCLUDED
+#define COLLISIONS_H_INCLUDED
+
+//Includes
+#include <iostream>
+#include <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
+ *
+ *
+ */
+
+class Collisions
+{
+    public:
+
+        Collisions(SDL_Surface* screen, int const xBlocSize, int const yBlocSize);
+        ~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;
+
+        int getSize(int idCoord);// x -> 0 et y -> 1
+
+    private:
+
+        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_Rect m_position;
+        int **m_tableau;
+};
+
+#endif // COLLISIONS_H_INCLUDED

Liner.cpp

@@ -0,0 +1,249 @@
+#include "Liner.h"
+
+static SDL_Surface* s_linerSurface[4];
+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_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];
+
+    SDL_Surface* cercle = SDL_LoadBMP("Textures/Cercle.bmp");
+
+    if (!m_liner)
+        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) );
+    }
+
+}///Constructeur
+
+Liner::~Liner()
+{
+    SDL_FreeSurface(m_cercle);
+    m_trainee.clear();
+}///Destructeur
+
+void Liner::actualiser(int direction)
+{
+    //[1] Calcule le changement de direction
+    m_orientation += direction;
+    if (m_orientation==4)
+        m_orientation=HAUT;
+
+    else if (m_orientation==-1)
+        m_orientation=GAUCHE;
+
+    if (m_estVivant)//Début d'éxécution vivant
+    {
+            //[2] Rajoute un mur
+            m_collisioneur->ajouter(m_x, m_y, m_id);
+
+            //[3] Avance
+            avancer(1);
+    }//Fin d'exécution vivant
+
+    //[4] Misa à jour du pointeur de pouvoir
+    if (m_power!=0)
+    {
+        if(m_power->estUtilise())
+            m_power=0;
+    }
+    else
+        m_power=m_powerGetter->chercherPouvoir(m_x, m_y);
+
+}///actualiser
+
+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;
+        }
+    }
+}///collisioner
+
+void Liner::afficher()
+{
+    //[1] Calculs
+    m_position.x = m_x * 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] );
+    }
+
+    //[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)
+        m_power->afficher(m_x, m_y);
+}///afficher
+
+void Liner::direEstFini(bool fin)
+{
+    m_fin = fin;
+}///direEstFini
+
+bool Liner::estVivant() const
+{
+    return m_estVivant;
+}///estVivant
+
+void Liner::avancer(int nbFois)
+{
+    // Avancée
+    for (int i(0); i<nbFois; i++)
+    {
+        switch (m_orientation)
+        {
+            case HAUT:
+                m_y-=1;
+                break;
+            case BAS:
+                m_y+=1;
+                break;
+            case DROITE:
+                m_x+=1;
+                break;
+            case GAUCHE:
+                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();
+
+}///avancer
+
+void Liner::utiliserPouvoir()
+{
+    if (m_power!=0)
+    {
+        m_power->usePower(m_orientation, m_x, m_y, m_id);
+        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
+    if (HAUT <= orientation && orientation <= GAUCHE)
+        m_liner = s_linerSurface[orientation];
+    else
+        m_orientation = BAS ;
+}///reset
+
+int Liner::getMeurtrier()
+{
+    return m_meurtrier;
+}///getMeutrier
+
+/************************************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 );
+        }
+    }
+
+    /// Tests
+    for (int i(0); i<4; i++)
+    {
+        if (!s_linerSurface[i])
+            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 true;
+
+}///initialisationPict
+
+void fermeturePict()
+{
+    for(int i(0); i<4; i++)
+    {
+        SDL_FreeSurface(s_linerSurface[i]);
+        s_linerSurface[i]=0;
+    }
+
+    SDL_FreeSurface(s_mort);
+    s_mort=0;
+
+    for ( int i(0); i<15; i++ )
+    {
+        SDL_FreeSurface(s_trainee[i]);
+        s_trainee[i]=0;
+    }
+
+}///fermeturePict
+

Liner.h

@@ -0,0 +1,69 @@
+#ifndef LINER_H_INCLUDED
+#define LINER_H_INCLUDED
+
+#include <iostream>
+#include <deque>
+#include <SDL.h>
+#include "Collisions.h"
+#include "traitement.h"
+#include "Power.h"
+
+//Mouvement
+#define TOURNE_DROITE 1//Quand ne tourne pas, 0
+#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
+ *
+ *
+ */
+
+class Liner
+{
+    public:
+
+        Liner(int x, int y, int orientation, int id, SDL_Surface *screen, SDL_Surface *pseudo, Collisions *collisioneur, TableauPower *powerGetter);
+        ~Liner();
+
+        void actualiser(int direction);
+        void collisioner();
+        void afficher();
+        void direEstFini(bool fin);
+        bool estVivant() const;
+        void avancer(int nbFois);
+        void utiliserPouvoir();
+        void reset( int x, int y, int orientation );
+
+        int getMeurtrier();
+
+    private:
+
+        int m_x; //Coordonnées en nb blocs
+        int m_y;
+        int m_orientation; //0 à 3
+        const int m_id;
+        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;
+
+        TableauPower *m_powerGetter;
+        Power *m_power;
+
+        std::deque<SDL_Rect> m_trainee;
+};
+
+bool initialisationPict();
+void fermeturePict();
+
+#endif // Liner_H_INCLUDED

Power.cpp

@@ -0,0 +1,219 @@
+#include "Power.h"
+
+Power::Power(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: m_screen(screen), m_image(apparence), m_gestionnaireCollisions(gestionnaireCollisons), m_mediaPlayer(mediaPlayer),
+m_used(false), m_estPose(true)
+{
+
+}///Constructeur
+
+Power::~Power()
+{
+
+}///Destructeur
+
+//Fonctions pour le tableauPower
+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);
+}///afficher
+
+bool Power::estUtilise()
+{
+    return m_used;
+}
+
+bool Power::estPose()
+{
+    return m_estPose;
+}///estAttribue
+
+void Power::convertDir(int orientation, int &ajoutX, int &ajoutY) const
+{
+    ajoutX = 0;
+    ajoutY = 0;
+    switch (orientation)
+    {
+        case HAUT:
+            ajoutY=-1;
+            break;
+        case DROITE:
+            ajoutX=1;
+            break;
+        case BAS:
+            ajoutY=1;
+            break;
+        case GAUCHE:
+            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];
+
+    // 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;
+
+    //Powers
+    for (int i(0); i<m_nbPow; i++)
+    {
+        if (m_tableau[i] == 0)
+        {}//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];
+    delete[] m_tableau;
+}///Destructeur
+
+Power* TableauPower::chercherPouvoir(int x, int y) const
+{
+    Power *pouvoirPotentiel(0);
+
+    for (int i(0); i<m_nbPow; i++)
+        if (m_tableau[i]!=0)
+            if (x == m_positions[0][i] && y == m_positions[1][i] && m_tableau[i]->estPose())
+            {
+                pouvoirPotentiel = m_tableau[i];
+                m_tableau[i]->attribuer();
+            }
+
+    return pouvoirPotentiel;
+}///chercherPouvoir
+
+Power* TableauPower::randomPower()
+{
+    //[1] Démarrage
+    Power *pouvoirAlea(0);
+
+    //[2] Calculs alétoires
+    switch (rand() % 8)
+    {
+    case 0:
+        pouvoirAlea = new Missile(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Missile"));
+        break;
+    case 1:
+        pouvoirAlea = new Expansion(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Expansion"));
+        break;
+    case 2:
+        pouvoirAlea = new Boost(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Boost"));
+        break;
+    case 3:
+        pouvoirAlea = new Teleport(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Teleport"));
+        break;
+    case 4:
+        pouvoirAlea = new Bouclier(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Bouclier"));
+        break;
+    case 5:
+        pouvoirAlea = new Trender(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Trender"));
+        break;
+    case 6:
+        pouvoirAlea = new Tunnel(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Tunnel"));
+        break;
+    case 7:
+        pouvoirAlea = new Bomb(m_screen, m_gestionnaireCollisions, m_mediaPlayer, m_spriteGet->takeSprite("Bomb"));
+        break;
+    }
+
+    //[3] Return
+    return pouvoirAlea;
+}///randomPower
+
+void TableauPower::initialiser()
+{
+    for (int i(0); i<m_nbPow; i++)
+    {
+        if (m_tableau[i] != 0)
+        {
+            delete m_tableau[i];
+            m_tableau[i] = 0;
+        }
+        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
+
+void TableauPower::actualiser()
+{
+    for (int i(0); i<m_nbPow; i++)
+        if (m_tableau[i]!=0)
+            if (m_tableau[i]->estUtilise())
+            {
+                 delete m_tableau[i];
+                 m_tableau[i]=0;
+            }
+}///actualiser
+
+void TableauPower::afficher()
+{
+    for (int i(0); i<m_nbPow; i++)
+        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");
+}///bruiterMort
+

Power.h

@@ -0,0 +1,90 @@
+#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
+ */
+
+class Power
+{
+    public:
+
+        //Fonctions pour le tableau
+        Power(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        virtual ~Power();
+
+        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
+        void afficher(int x, int y);
+        bool estUtilise();
+        bool estPose();
+
+    protected:
+
+        void convertDir(int orientation, int &ajoutX, int &ajoutY) const;
+
+    protected:
+
+        SDL_Surface *m_screen;
+        SDL_Surface *m_image;
+        SDL_Rect m_position;
+
+        Collisions *m_gestionnaireCollisions;
+        Sounderer *m_mediaPlayer;
+
+        bool m_used;
+        bool m_estPose;
+};
+
+class TableauPower
+{
+    public:
+
+        TableauPower(SDL_Surface *screen, Collisions *gestionnaireCollisons, int nbPow );
+        ~TableauPower();
+
+        Power* chercherPouvoir(int x, int y) const;
+        Power* randomPower();
+        void initialiser();
+        void actualiser(); // Nettoie les pouvoirs plus utilisés
+        void afficher();
+
+        void bruiterMort();
+
+    private:
+
+        SDL_Surface *m_screen;
+        Collisions *m_gestionnaireCollisions;
+        SpriteLoader *m_spriteGet;
+        Sounderer *m_mediaPlayer;
+        const int m_nbPow;
+        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/Bomb.h"
+
+#endif // POWER_H_INCLUDED

Sons/.gitignore

@@ -0,0 +1,2 @@
+# WAV are too large for git
+*.wav

Sounderer.cpp

@@ -0,0 +1,180 @@
+#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()
+{
+    ///SDL extend init
+    SDL_InitSubSystem(SDL_INIT_AUDIO);
+
+    ///Implémentation des paramètres
+    m_rate = 22050;
+	m_format = AUDIO_S16SYS;
+	m_nbChannels = 2;
+	m_bufferSize = 4096;
+
+	///Démarrage du mixer avec les paramètres désirés
+	if ( Mix_OpenAudio(m_rate, m_format, m_nbChannels, m_bufferSize) != 0 ) {
+		std::cout <<"Impossible d'initialiser le système audio SDL_mixer avec les paramètres définis : "<<Mix_GetError()<< std::endl;
+		return false;
+	}
+
+	///Initialisation terminée
+    return true;
+}
+
+bool Sounderer::preLoad(std::string nom, short extension)
+{
+	/// Cherche le son dans le tableau
+    m_it = m_paquet.find(nom);
+
+    /// Si le son est déjà chargé, pas beson de le refaire
+    if (m_it != m_paquet.end())
+    {
+        if (m_paquet[nom] == 0x0) return false;
+        else return true;
+    }
+
+    /// Sinon on le charge
+    else
+    {
+        //Définit l'extension
+        std::string ext;
+        if (extension == EXT_OGG) ext = ".ogg";
+        else ext = ".wav";
+
+        //Compose le source puis le charge
+        std::string source(m_folder + nom + ext);
+        m_paquet[nom] = Mix_LoadWAV(source.c_str());
+
+        //Teste une erreur
+        if (m_paquet[nom] == 0x0)
+        {
+            std::cout << "Le son " <<nom<< ".wav n'a pas pu être chargé : " << Mix_GetError() << std::endl << std::endl;
+            return false;
+        }
+
+        //Attribut canal libre et réservé
+        m_lastCanal++;
+        m_channel[nom] = m_lastCanal;
+    }
+
+    // Fonction terminée
+    return true;
+}
+
+bool Sounderer::play(std::string nom, int repetition)
+{
+    //Capture le canal et joue le son
+    if (preLoad(nom))
+        m_channel[nom] = Mix_PlayChannel(m_channel[nom], m_paquet[nom], repetition);
+    else return false;
+
+	if(m_channel[nom] == -1) {
+		std::cout <<"Impossible de jouer le son ''"<<nom<<"'' : "<<Mix_GetError()<< std::endl;
+		return false;
+	}
+
+	//Fin
+	return true;
+}
+
+bool Sounderer::fadePlay(std::string nom, int crescendoLenght, int repetition)
+{
+    //Capture le canal et joue le son
+    if (preLoad(nom))
+        m_channel[nom] = Mix_FadeInChannel(m_channel[nom], m_paquet[nom], repetition, crescendoLenght);
+    else return false;
+
+	if(m_channel[nom] == -1) {
+		std::cout <<"Impossible de jouer le son ''"<<nom<<"'' : "<<Mix_GetError()<< std::endl;
+		return false;
+	}
+
+	//Fin
+	return true;
+}
+
+bool Sounderer::stop(std::string nom)
+{
+    if ( m_paquet.find(nom) != m_paquet.end() )
+        if ( Mix_Playing(m_channel[nom]) )
+        {
+            Mix_HaltChannel(m_channel[nom]);
+            return true;
+        }
+    return false;
+}
+
+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;
+}
+

Sounderer.h

@@ -0,0 +1,56 @@
+#ifndef SOUNDERER_H_INCLUDED
+#define SOUNDERER_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <map>
+#include <SDL.h>
+#include <SDL_mixer.h>
+
+#define EXT_WAV 0
+#define EXT_OGG 1
+#define INFINITY_LOOP -1
+
+class Sounderer
+{
+public:
+
+    Sounderer();
+    Sounderer(std::string folder);
+    ~Sounderer();
+
+    bool init();// à appeler avant utilisation
+
+    // 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;
+    Mix_Music* m_music;
+
+	std::map<std::string, int> m_channel;//Channel on which our sound is played
+    std::map<std::string, Mix_Chunk*>::iterator m_it;
+    std::map<std::string, Mix_Chunk*> m_paquet;
+
+	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

Spawns/spawn1.txt

@@ -0,0 +1,12 @@
+6 5 1
+5 6 2
+-6 5 3
+-5 6 2
+6 -5 1
+-6 -5 3
+-5 -6 0
+5 -6 1
+10 5 2
+-10 5 3
+-10 -5 1
+10 -5 0

SpriteLoader.cpp

@@ -0,0 +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;
+}
+

SpriteLoader.h

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

@@ -0,0 +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] );
+    }
+}

Starter.h

@@ -0,0 +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

TextRender.cpp

@@ -0,0 +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;
+    }
+
+    /// 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;
+}

TextRender.h

@@ -0,0 +1,62 @@
+#ifndef TEXTRENDER_H
+#define TEXTRENDER_H
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include <SDL.h>
+#include <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

config.txt

@@ -0,0 +1,36 @@
+40
+30
+4
+0
+25
+James_Watt 276 274 275
+Einstein 97 115 100
+Tesla 106 107 108
+Newton 260 261 262
+Kelvin 122 120 99
+Laplace 118 98 110
+Schrodinger 102 103 104
+Gauss 114 114 114
+Ampère 114 114 114
+Fourier 114 114 114
+Euler 114 114 114
+Delannoy 114 114 114
+
+1- Nombre de bloc x (1 bloc = 20px de côté)
+2- Nombre de bloc en y
+3- Nombre de joueurs (12 max)
+4- Plein écran ( 0 = désactivé, 1 = activé, 2 = ajustement du nombre de blocs automatique )
+5- Nombre de pouvoirs ( 5 est une valeur par défaut )
+
+5-Pseudo joueur 1 (<; v; >)
+6-Pseudo joueur 2 (q; s; d)
+7-Pseudo joueur 3 (j; k; l)
+8-Pseudo joueur 4 (4; 5; 6)
+9-Pseudo joueur 5 (w; x; c)
+10-Pseudo joueur 6 (v; b; n)
+11-Pseudo joueur 7 (f; g; h)
+12-Pseudo joueur 8 (_; _; _)
+13-Pseudo joueur 9 (_; _; _)
+14-Pseudo joueur 10 (_; _; _)
+15-Pseudo joueur 11 (_; _; _)
+16-Pseudo joueur 12 (_; _; _)

gestionFichiers.cpp

@@ -0,0 +1,59 @@
+#include "gestionFichiers.h"
+
+using namespace std;
+
+int haveNbJoueurs()
+{
+    string const nomFichierParametre("config.txt");
+    ifstream fluxIn(nomFichierParametre.c_str());
+
+    if (fluxIn)
+    {
+        //Ouverture fichier succés
+        int nbJoueurs;
+        fluxIn >> nbJoueurs;
+        return nbJoueurs;
+    }
+    else
+    {
+        //Echec ouverture fichier
+        cout << "ERREUR: impossible de lire le fichier " << nomFichierParametre << " ." << endl;
+        return -1;
+    }
+}///haveNbJoueurs
+
+/*int haveNbBlocs(char axe)
+{
+    //[1] Ouverture du flux
+    string const nomFichierParametre("config.txt");
+    ifstream fluxIn(nomFichierParametre.c_str());
+    if (!fluxIn)
+    {
+        //Echec ouverture fichier
+        cout << "ERREUR: impossible de lire le fichier " << nomFichierParametre << " ." << endl;
+        return -1;
+    }
+
+    //[2] Création de divers variables
+    string lineJumper("Permet de sauter des lignes");
+    int nbBlocs(0);
+
+    //[3] Lectures et return
+    switch (axe)
+    {
+        case 'x':
+            getline(fluxIn,lineJumper);
+            fluxIn >> nbBlocs;
+            return nbBlocs;
+            break;
+        case 'y':
+            getline(fluxIn,lineJumper);
+            getline(fluxIn,lineJumper);
+            fluxIn >> nbBlocs;
+            return nbBlocs;
+            break;
+    }
+
+    return -1;
+}///haveNbBlocs
+*/

gestionFichiers.h

@@ -0,0 +1,24 @@
+#ifndef GESTIONFICHIERS_H_INCLUDED
+#define GESTIONFICHIERS_H_INCLUDED
+
+#include <iostream>
+#include <fstream>
+
+/*Programmeur: Jovian Hersemeule
+**Dernière modification le: 18/05/2013
+
+**Rôle de la fonction haveNbJoueurs:
+Cette fonction permet d'obtenir le nombre de joueurs préconfiguré dans le fichier config.txt.
+    Renvoi: un entier. Le nombre de joueurs écrit (si 23 945, renvoie 23 945) -1 si echec de lecture.
+
+**Rôle de la fonction haveNbBlocs:
+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.
+*/
+
+int haveNbJoueurs();
+//int haveNbBlocs(char axe);
+
+#endif // GESTIONFICHIERS_H_INCLUDED

intToStr.cpp

@@ -0,0 +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;
+}

intToStr.h

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

jeu.cpp

@@ -0,0 +1,347 @@
+#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.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)
+        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 );
+    myStarter.loadAreas();
+
+    /// [2] Boucle principale
+    while (!done)
+    {
+        // [2.1] Gestion évènements
+        while (SDL_PollEvent(&event))
+        {
+            switch (event.type)
+            {
+            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();
+                }
+
+                // 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;
+                }
+            } // 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
+            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 );
+            }
+            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
+    }
+}

jeu.h

@@ -0,0 +1,69 @@
+#ifndef JEU_H_INCLUDED
+#define JEU_H_INCLUDED
+
+#include <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

main.cpp

@@ -0,0 +1,60 @@
+#include <iostream>
+#include <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
+ *
+ */
+
+
+int main ( int argc, char** argv )
+{
+    /// [1] Démarrage
+    // [1.1] Démarrages SDL
+    if ( SDL_Init( SDL_INIT_VIDEO ) < 0)
+    {
+        std::cout << "Impossible d'initialiser la SDL: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    // [1.2] Préparation de fermeture
+    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
+    srand(time(0));
+
+    /// [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);
+    if (settings.pleinEcran) flags |= SDL_FULLSCREEN;
+    SDL_Surface* screen = SDL_SetVideoMode(settings.xSize*20, settings.ySize*20, 32, flags);
+    if ( !screen )
+    {
+        std::cout << "Impossible de créer la fenêtre : " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    /// [3] Boucle principale
+    int retour;
+    retour = jeuMulti(screen, settings);
+
+    /// [4] Destruction des composants
+    SDL_FreeSurface(screen);
+
+    std::cout << "Aucune erreur detectee." << std::endl;
+    return retour;
+}

powers/Bomb.cpp

@@ -0,0 +1,62 @@
+#include "Bomb.h"
+
+Bomb::Bomb(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Bomb::~Bomb()
+{
+
+}///Destructeur
+
+void Bomb::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Bomb");
+
+    //[1] Orientation de la trajectoire du Bomb
+    int posX(x);
+    int posY(y);
+
+    int ajoutX(0);
+    int ajoutY(0);
+    convertDir(orientation, ajoutX, ajoutY);
+
+    //[2] Parcours du Bomb dans le vide
+    while (m_gestionnaireCollisions->tester(posX, posY) == VIDE)
+    {
+        posX += ajoutX;
+        posY += ajoutY;
+    }
+
+    posX -= ajoutX;
+    posY -= ajoutY;
+
+    //[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);
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Bomb::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Bomb");
+
+    //[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);
+
+    //[end]
+    m_used = true;
+}///postMortemPower
+
+
+
+

powers/Bomb.h

@@ -0,0 +1,24 @@
+#ifndef BOMB_H
+#define BOMB_H
+
+#include "../Power.h"
+
+/** \brief Bomb : hérite de Power
+ * \last Création
+ * \next Mise en fonctionnement
+ *
+ *
+ */
+
+class Bomb : public Power
+{
+    public:
+
+        Bomb(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Boost.cpp

@@ -0,0 +1,67 @@
+#include "Boost.h"
+
+Boost::Boost(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Boost::~Boost()
+{
+
+}///Destructeur
+
+void Boost::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Boost");
+
+    //[1]Préparation de l'orientation du bond
+    int ajoutX(0);
+    int ajoutY(0);
+    convertDir(orientation, ajoutX, ajoutY);
+    bool sboum(false);
+
+    //[2]Bond
+    for (int i(0); i<6; i++)
+    {
+        if (m_gestionnaireCollisions->tester(x, y) != VIDE || sboum)
+        {
+            if (!sboum)
+            {
+                x -= ajoutX;
+                y -= ajoutY;
+            }
+            sboum = true;
+        }
+        else
+        {//Si pas de mur rencontré
+            m_gestionnaireCollisions->ajouter(x, y, ID);
+            x += ajoutX;
+            y += ajoutY;
+        }
+    }
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Boost::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[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);
+
+    for (int i(-portee); i <= portee; i++)
+        if ( i != 0 )
+            m_gestionnaireCollisions->ajouter(x+i, y, ID);
+
+    m_used = true;
+}///postMortemPower
+

powers/Boost.h

@@ -0,0 +1,24 @@
+#ifndef BOOST_H_INCLUDED
+#define BOOST_H_INCLUDED
+
+#include "../Power.h"
+
+/** \brief Boost : hérite de Power
+ * \last Post mortem implémenté
+ * \next
+ *
+ *
+ */
+
+class Boost : public Power
+{
+    public:
+
+        Boost(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Bouclier.cpp

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

powers/Bouclier.h

@@ -0,0 +1,25 @@
+#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
+ *
+ *
+ */
+
+class Bouclier : public Power
+{
+    public:
+
+        Bouclier(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Expansion.cpp

@@ -0,0 +1,52 @@
+#include "Expansion.h"
+
+Expansion::Expansion(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Expansion::~Expansion()
+{
+
+}///Destructeur
+
+void Expansion::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Expansion");
+
+    //[1] Paramètres
+    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++)
+            m_gestionnaireCollisions->ajouter(posX+i, posY, ID);
+    }
+    else
+    {//Epandage vertical
+        for (int i(-portee); i <= portee; i++)
+            m_gestionnaireCollisions->ajouter(posX, posY+i, ID);
+    }
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Expansion::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[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);
+
+    //[END]
+    m_used = true;
+}///postMortemPower

powers/Expansion.h

@@ -0,0 +1,24 @@
+#ifndef EXPANSION_H_INCLUDED
+#define EXPANSION_H_INCLUDED
+
+#include "../Power.h"
+
+/** \brief Expansion : hérite de Power
+ * \last Relecture et premières corrections
+ * \next
+ *
+ *
+ */
+
+class Expansion : public Power
+{
+    public:
+
+        Expansion(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Missile.cpp

@@ -0,0 +1,63 @@
+#include "Missile.h"
+
+Missile::Missile(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Missile::~Missile()
+{
+
+}///Destructeur
+
+void Missile::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Missile");
+
+    //[1] Orientation de la trajectoire du missile
+    int posX(x);
+    int posY(y);
+
+    int ajoutX(0);
+    int ajoutY(0);
+    convertDir(orientation, ajoutX, ajoutY);
+
+    //[2] Parcours du missile dans le vide
+    while (m_gestionnaireCollisions->tester(posX,posY) == VIDE)
+    {
+        posX += ajoutX;
+        posY += ajoutY;
+    }
+
+    //[3] Perforation de toute l'épaisseur
+    while (m_gestionnaireCollisions->tester(posX,posY) != VIDE)
+    {
+        m_gestionnaireCollisions->enlever(posX,posY);
+
+        posX += ajoutX;
+        posY += ajoutY;
+    }
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Missile::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Missile");
+
+    //[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);
+
+    //[end]
+    m_used = true;
+}///postMortemPower
+
+
+
+

powers/Missile.h

@@ -0,0 +1,24 @@
+#ifndef MISSILE_H_INCLUDED
+#define MISSILE_H_INCLUDED
+
+#include "../Power.h"
+
+/** \brief Missile : hérite de Power
+ * \last Relecture et premières corrections
+ * \next
+ *
+ *
+ */
+
+class Missile : public Power
+{
+    public:
+
+        Missile(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Teleport.cpp

@@ -0,0 +1,47 @@
+#include "Teleport.h"
+
+Teleport::Teleport(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Teleport::~Teleport()
+{
+
+}///Destructeur
+
+void Teleport::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Teleport");
+
+    //[1]Préparation de l'orientation du bond
+    int ajoutX(0);
+    int ajoutY(0);
+    convertDir(orientation, ajoutX, ajoutY);
+
+    //[2]Bond
+    for (int i(0); i<6; i++)
+    {
+        x += ajoutX;
+        y += ajoutY;
+    }
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Teleport::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Teleport");
+
+    //[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);
+
+    m_used = true;
+}///postMortemPower

powers/Teleport.h

@@ -0,0 +1,24 @@
+#ifndef TELEPORT_H_INCLUDED
+#define TELEPORT_H_INCLUDED
+
+#include "../Power.h"
+
+/** \brief Teleport : hérite de Power
+ * \last Post mortem implémenté
+ * \next
+ *
+ *
+ */
+
+class Teleport : public Power
+{
+    public:
+
+        Teleport(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Trender.cpp

@@ -0,0 +1,70 @@
+#include "Trender.h"
+
+Trender::Trender(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Trender::~Trender()
+{
+
+}///Destructeur
+
+void Trender::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Trender");
+
+    //[1] Orientation de la trajectoire du Trender
+    int posX(x);
+    int posY(y);
+
+    int ajoutX(0);
+    int ajoutY(0);
+    convertDir(orientation, ajoutX, ajoutY);
+
+    //[2] Parcours du Trender dans le vide
+    while (m_gestionnaireCollisions->tester(posX,posY) == VIDE)
+    {
+        posX += ajoutX;
+        posY += ajoutY;
+    }
+
+    //[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++ )
+    {
+        m_gestionnaireCollisions->ajouter(posX, posY, ID);
+
+        posX += ajoutX;
+        posY += ajoutY;
+    }
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Trender::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Trender");
+
+    //[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);
+
+    //[end]
+    m_used = true;
+}///postMortemPower
+
+
+
+

powers/Trender.h

@@ -0,0 +1,25 @@
+#ifndef TRENDER_H
+#define TRENDER_H
+
+#include "../Power.h"
+
+/** \brief Trender : hérite de Power
+ * \last Création
+ * \next Mise en fonctionnement
+ *
+ *
+ */
+
+class Trender : public Power
+{
+    public:
+
+        Trender(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

powers/Tunnel.cpp

@@ -0,0 +1,58 @@
+#include "Tunnel.h"
+
+Tunnel::Tunnel(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence)
+: Power(screen, gestionnaireCollisons, mediaPlayer, apparence)
+{
+
+}///Constructeur
+
+Tunnel::~Tunnel()
+{
+
+}///Destructeur
+
+void Tunnel::usePower(int orientation, int &x, int &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Tunnel");
+
+    //[1] Orientation de la trajectoire du Tunnel
+    int posX(x);
+    int posY(y);
+
+    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);
+        //m_gestionnaireCollisions->enlever(posX, posY)
+
+        posX += ajoutX;
+        posY += ajoutY;
+    }
+
+    //[END]
+    m_used = true;
+}///usePower
+
+void Tunnel::postMortemPower(int const &x, int const &y, int const &ID)
+{
+    //[0] Bruitage
+    m_mediaPlayer->play("Tunnel");
+
+    //[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);
+
+    //[end]
+    m_used = true;
+}///postMortemPower
+
+
+
+

powers/Tunnel.h

@@ -0,0 +1,24 @@
+#ifndef TUNNEL_H
+#define TUNNEL_H
+
+#include "../Power.h"
+
+/** \brief Tunnel : hérite de Power
+ * \last Création
+ * \next Mise en fonctionnement
+ *
+ *
+ */
+
+class Tunnel : public Power
+{
+    public:
+
+        Tunnel(SDL_Surface *screen, Collisions *gestionnaireCollisons, Sounderer *mediaPlayer, SDL_Surface* apparence);
+        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

traitement.cpp

@@ -0,0 +1,114 @@
+#include "traitement.h"
+
+SDL_Surface* retournement(SDL_Surface* originale, int nbQuarts)
+{
+    //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,
+                                   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;
+        Uint8 bytes(originale->format->BytesPerPixel);
+
+        // Balayage
+        Sint32 xFromPos(0), yFromPos(0);
+        Sint32 xToPos(0), yToPos(0);
+        for (xFromPos = 0; xFromPos < originale->w; xFromPos++)
+            for (yFromPos = 0; yFromPos < originale->h; yFromPos++)
+            {
+                if (nbQuarts == 1){
+                    xToPos = originale->h - yFromPos - 1;
+                    yToPos = xFromPos;
+                }
+                if (nbQuarts == 2){
+                    xToPos = originale->w - xFromPos - 1;
+                    yToPos = originale->h - yFromPos - 1;
+                }
+                if (nbQuarts == 3){
+                    xToPos = yFromPos;
+                    yToPos = originale->w - xFromPos - 1;
+                }
+
+                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
+        SDL_BlitSurface(originale, 0, pivot, 0);
+
+    return pivot;
+}
+
+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;
+        Uint8 bytes(originale->format->BytesPerPixel);
+
+        // Balayage
+        Sint32 xPos(0), yPos(0);
+        for (xPos = 0; xPos < originale->w; xPos++)
+            for (yPos = 0; yPos < originale->h; yPos++)
+            {
+                if (!blue)
+                    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];
+
+                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;
+    }
+}

traitement.h

@@ -0,0 +1,36 @@
+#ifndef RETOURNER_H_INCLUDED
+#define RETOURNER_H_INCLUDED
+
+#include <iostream>
+#include <SDL.h>
+
+SDL_Surface* retournement(SDL_Surface* originale, int nbQuarts);
+/** retournement() \brief Permet de créer une nouvelle image pivotée.
+ *
+ * SDL_Surface* originale \param Surface originale pour pivoter.
+ * 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.
+ *
+ * SDL_Surface* originale \param Surface originale pour modifier.
+ * bool blue \param Indique si cette couleur est à retirer.
+ * bool green \param Indique si cette couleur est à retirer.
+ * 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.
+ *
+ * SDL_Surface* originale \param Surface originale pour modifier.
+ * int id \param Contient l'identifiant du mightyLiner associé.
+ * SDL_Surface* \return La surface modifiée. Attention ! Ne pas oublier freeSurface().
+ *
+ */
+
+#endif // RETOURNER_H_INCLUDED