Import project

Armes/Arme.cpp

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

Armes/Arme.h

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

Armes/Armes_Gest.cpp

@@ -0,0 +1,185 @@
+#include "Armes_Gest.h"
+
+/// ~~~ ARMES_GEST IMPLEMENTATION ~~~ ----------------------------------------------------------------- VVVVV
+
+Armes_Gest::Armes_Gest( SpriteLoader* sprites )
+{
+    /// Chargement des images
+    // Chargement des images
+    m_armeImg[ GUN ] = sprites->takeSprite("Gun");
+    m_armeImg[ FUSIL ] = sprites->takeSprite("Fusil");
+    m_armeImg[ SHOTGUN ] = sprites->takeSprite("Shotgun");
+
+    m_armeImg[ USIANE ] = sprites->takeSprite("Usiane");
+    m_armeImg[ SCATTER ] = sprites->takeSprite("Scatter");
+    m_armeImg[ BAROUDEUR ] = sprites->takeSprite("Baroudeur");
+
+    m_armeImg[ SULFATEUSE ] = sprites->takeSprite("Sulfateuse");
+    m_armeImg[ TRIPHASEUR ] = sprites->takeSprite("Triphaseur");
+    m_armeImg[ BOMBER ] = sprites->takeSprite("Bomber");
+
+    // On enlève le transparent
+    Uint32 noir( SDL_MapRGBA( m_armeImg[0]->format, 0, 0, 0, 255 ) );
+    for (Uint8 i(0); i < NB_MODELS; i++) {
+        SDL_SetColorKey(m_armeImg[i], SDL_SRCCOLORKEY, noir);
+    }
+
+    /// Création des Crafts
+    m_crafts[ Craft( SHOTGUN, BAROUDEUR ) ] = BOMBER;
+
+    m_crafts[ Craft( FUSIL, SCATTER ) ] = TRIPHASEUR;
+    m_crafts[ Craft( FUSIL, SHOTGUN ) ] = BAROUDEUR;
+
+    m_crafts[ Craft( GUN, USIANE ) ] = SULFATEUSE;
+    m_crafts[ Craft( GUN, SHOTGUN ) ] = USIANE;
+    m_crafts[ Craft( GUN, FUSIL ) ] = SCATTER;
+}
+
+Armes_Gest::~Armes_Gest()
+{
+    for (m_itList = m_posees.begin(); m_itList != m_posees.end(); m_itList++){
+        delete (*m_itList);
+    }
+}
+
+SDL_Surface* Armes_Gest::getImg( WeaponType model ) const
+{
+    return m_armeImg[ model ];
+}
+
+void Armes_Gest::allDisplay( const Vec &lookAt, SDL_Surface* screen )
+{
+    for (m_itList = m_posees.begin(); m_itList != m_posees.end(); m_itList++){
+        (*m_itList)->afficher( lookAt, screen );
+    }
+}
+
+void Armes_Gest::drop( Vec pos, Arme* weapon )
+{
+    m_posees.insert( m_posees.begin(), new CaisseArme( m_armeImg[ weapon->getModel() ], weapon, pos) );
+}
+
+Arme* Armes_Gest::saisir( Vec pos )
+{
+    Arme* weapon( 0x0 );
+
+    if (m_posees.empty()) std::cout << "Mais il n'y a pas d'arme sur le sol !" << std::endl;
+
+    for (m_itList = m_posees.begin(); m_itList != m_posees.end() && weapon == 0x0; m_itList++){
+        if ( (*m_itList)->proxi( pos ) ) {
+            weapon = (*m_itList)->takeWeapon();
+            m_posees.erase( m_itList );
+        }
+    }
+
+    return weapon;
+}
+
+Arme* Armes_Gest::crafting( Arme* paire[2], Tirs_Gest* tirsGest )
+{
+    std::cout << "Crafting : " << std::endl;
+
+    Craft* prod(0x0);
+    prod = new Craft( paire[0]->getModel(), paire[1]->getModel() );
+    WeaponType resultat;
+    Arme* renvoi(0x0);
+
+    m_itMap = m_crafts.find( *prod );
+
+    if ( m_itMap == m_crafts.end() ) std::cout << "Combinaison inexistante.";
+    else {
+        resultat = m_crafts[ *prod ];
+        renvoi = takeWeapon( resultat, tirsGest );
+
+        std::cout << "Arme obtenue : " << resultat;
+    }
+    std::cout << std::endl << std::endl << std::endl;
+
+    delete prod;
+
+    return renvoi;
+}
+
+Arme* Armes_Gest::takeWeapon( WeaponType model, Tirs_Gest* tirsGest ) const
+{
+    switch ( model)
+    {
+        case GUN :
+            return new Gun( tirsGest );
+            break;
+        case FUSIL :
+            return new Fusil( tirsGest );
+            break;
+        case SHOTGUN :
+            return new Shotgun( tirsGest );
+            break;
+        case USIANE :
+            return new Usiane( tirsGest );
+            break;
+        case SCATTER :
+            return new Scatter( tirsGest );
+            break;
+        case BAROUDEUR :
+            return new Baroudeur( tirsGest );
+            break;
+        case SULFATEUSE :
+            return new Sulfateuse( tirsGest );
+            break;
+        case TRIPHASEUR :
+            return new Triphaseur( tirsGest );
+            break;
+        case BOMBER :
+            return new Bomber( tirsGest );
+            break;
+        default:
+            return 0x0;
+            break;
+    }
+}
+
+Arme* Armes_Gest::startWeapon( Tirs_Gest* tirsGest ) const
+{
+    int choice( rand() % 3 );
+    return takeWeapon( (WeaponType)choice, tirsGest );
+}
+
+
+
+/// ~~~ CRAFT IMPLEMENTATION ~~~ ----------------------------------------------------------------- VVVVV
+
+Craft::Craft()
+:m_a(GUN), m_b(SHOTGUN)
+{
+
+}
+
+Craft::Craft( WeaponType a, WeaponType b )
+{
+    if ( a < b ) {
+        m_a = a;
+        m_b = b;
+    }
+    else {
+        m_a = b;
+        m_b = a;
+    }
+}
+
+Craft::~Craft()
+{
+
+}
+
+void Craft::debugCout() const
+{
+    std::cout <<"Arme A : "<< m_a << std::endl;
+    std::cout <<"Arme B : "<< m_b << std::endl << std::endl;
+}
+
+bool Craft::operator<( const Craft& a ) const
+{
+    if ( m_a < a.m_a )
+        return true;
+    else
+        return m_b < a.m_b;
+}

Armes/Armes_Gest.h

@@ -0,0 +1,75 @@
+#ifndef ARMES_GEST_H
+#define ARMES_GEST_H
+
+#include "CaisseArme.h"
+#include "../Structures/SpriteLoader.h"
+#include <list>
+#include <cstdlib> // Random
+
+// Armes de rang 1
+#include "Modeles/Shotgun.h"
+#include "Modeles/Gun.h"
+#include "Modeles/Fusil.h"
+
+// Armes de rang 2
+#include "Modeles/Usiane.h"
+#include "Modeles/Scatter.h"
+#include "Modeles/Baroudeur.h"
+
+// Armes de rang 3
+#include "Modeles/Sulfateuse.h"
+#include "Modeles/Triphaseur.h"
+#include "Modeles/Bomber.h"
+
+class Craft; // Permet de stocker une combinaison
+
+class Armes_Gest
+{
+    public:
+
+        Armes_Gest( SpriteLoader* sprites );
+        virtual ~Armes_Gest();
+
+        SDL_Surface* getImg( WeaponType model ) const; // Permet au perso d'obtenir la surface associée à l'arme
+
+        void allDisplay(const Vec &lookAt, SDL_Surface* screen);
+
+        void drop( Vec pos, Arme* weapon );
+        Arme* saisir( Vec pos ); // Si une arme posée est à portée, return ptr. Sin return 0.
+        Arme* crafting( Arme* paire[2], Tirs_Gest* tirsGest ); // Si la combinaison existe, delete les deux armes et créé une nouvelle. Sinon return 0x0.
+
+        Arme* takeWeapon( WeaponType model, Tirs_Gest* tirsGest ) const; // Créé une nouvelle arme à partir de son nom de modele
+        Arme* startWeapon( Tirs_Gest* tirsGest ) const; // Octroie une arme de rang 1
+
+
+    protected:
+
+        std::list< CaisseArme* > m_posees; // Stock des armes posées
+        std::list< CaisseArme* >::iterator m_itList; // Itérateur list
+
+        std::map< Craft, WeaponType > m_crafts; // Stock des crafts possibles
+        std::map< Craft, WeaponType >::iterator m_itMap; // Itérateur map
+
+        SDL_Surface* m_armeImg[ NB_MODELS ]; // Image de chaque arme
+};
+
+class Craft
+{
+    public:
+
+        Craft();
+        Craft( WeaponType a, WeaponType b );
+        ~Craft();
+
+        void debugCout() const;
+
+        bool operator<( const Craft& a) const;
+
+
+    private:
+
+        WeaponType m_a;
+        WeaponType m_b;
+};
+
+#endif // ARMES_GEST_H

Armes/CaisseArme.cpp

@@ -0,0 +1,31 @@
+#include "CaisseArme.h"
+
+CaisseArme::CaisseArme( SDL_Surface* img, Arme* lachee, Vec pos )
+:Affichable( img ), m_contenu( lachee )
+{
+    m_pos = pos;
+}
+
+CaisseArme::~CaisseArme()
+{
+    if (m_contenu != 0x0) delete m_contenu;
+}
+
+bool CaisseArme::proxi(Vec pos) const
+{
+    pos -= m_pos;
+    return pos.norme() < 40.0f;
+}
+
+bool CaisseArme::empty() const
+{
+    if ( m_contenu == 0x0 ) return true;
+    else return false;
+}
+
+Arme* CaisseArme::takeWeapon()
+{
+    Arme* contenu( m_contenu );
+    m_contenu = 0x0;
+    return contenu;
+}

Armes/CaisseArme.h

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

Armes/Modeles/Baroudeur.cpp

@@ -0,0 +1,21 @@
+#include "Baroudeur.h"
+
+Baroudeur::Baroudeur( Tirs_Gest* tirsGest )
+:Arme( 19, BAROUDEUR, tirsGest, 620 )
+{
+    //ctor
+}
+
+Baroudeur::~Baroudeur()
+{
+    //dtor
+}
+
+void Baroudeur::tirer(Vec pos, Vec visee, bool allie)
+{
+    m_tirsGest->addTir( pos, visee, m_degats, allie);
+    visee.rotateR( 0.05f );
+    m_tirsGest->addTir( pos, visee, m_degats, allie);
+    visee.rotateR( -0.10f );
+    m_tirsGest->addTir( pos, visee, m_degats, allie);
+}

Armes/Modeles/Baroudeur.h

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

Armes/Modeles/Bomber.cpp

@@ -0,0 +1,23 @@
+#include "Bomber.h"
+
+Bomber::Bomber( Tirs_Gest* tirsGest )
+:Arme( 19, BOMBER, tirsGest, 620 )
+{
+    //ctor
+}
+
+Bomber::~Bomber()
+{
+    //dtor
+}
+
+void Bomber::tirer(Vec pos, Vec visee, bool allie)
+{
+    float pas( 0.05f );
+    visee.rotateR( -2 * pas );
+
+    for ( int i(0); i<5; i++ ) {
+        m_tirsGest->addTir( pos, visee, m_degats, allie);
+        visee.rotateR( pas );
+    }
+}

Armes/Modeles/Bomber.h

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

Armes/Modeles/Fusil.cpp

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

Armes/Modeles/Fusil.h

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

Armes/Modeles/Gun.cpp

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

Armes/Modeles/Gun.h

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

Armes/Modeles/Scatter.cpp

@@ -0,0 +1,22 @@
+#include "Scatter.h"
+
+Scatter::Scatter( Tirs_Gest* tirsGest )
+:Arme( 40, SCATTER, tirsGest, 729 )
+{
+    //ctor
+}
+
+Scatter::~Scatter()
+{
+    //dtor
+}
+
+void Scatter::tirer(Vec pos, Vec visee, bool allie)
+{
+    Vec ortho( visee.getY(), -visee.getX() );
+    ortho.normaliser();
+    ortho *= 12.0f;
+
+    m_tirsGest->addTir( pos-ortho, visee, m_degats, allie);
+    m_tirsGest->addTir( pos+ortho, visee, m_degats, allie);
+}

Armes/Modeles/Scatter.h

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

Armes/Modeles/Shotgun.cpp

@@ -0,0 +1,20 @@
+#include "Shotgun.h"
+
+Shotgun::Shotgun( Tirs_Gest* tirsGest )
+:Arme( 19, SHOTGUN, tirsGest, 620 )
+{
+    //ctor
+}
+
+Shotgun::~Shotgun()
+{
+    //dtor
+}
+
+void Shotgun::tirer(Vec pos, Vec visee, bool allie)
+{
+    visee.rotateR( 0.05f );
+    m_tirsGest->addTir( pos, visee, m_degats, allie);
+    visee.rotateR( -0.10f );
+    m_tirsGest->addTir( pos, visee, m_degats, allie);
+}

Armes/Modeles/Shotgun.h

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

Armes/Modeles/Sulfateuse.cpp

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

Armes/Modeles/Sulfateuse.h

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

Armes/Modeles/Triphaseur.cpp

@@ -0,0 +1,23 @@
+#include "Triphaseur.h"
+
+Triphaseur::Triphaseur( Tirs_Gest* tirsGest )
+:Arme( 34, TRIPHASEUR, tirsGest, 729 )
+{
+    //ctor
+}
+
+Triphaseur::~Triphaseur()
+{
+    //dtor
+}
+
+void Triphaseur::tirer(Vec pos, Vec visee, bool allie)
+{
+    Vec ortho( visee.getY(), -visee.getX() );
+    ortho.normaliser();
+    ortho *= 20.0f;
+
+    m_tirsGest->addTir( pos-ortho, visee, m_degats, allie);
+    m_tirsGest->addTir( pos, visee, m_degats, allie);
+    m_tirsGest->addTir( pos+ortho, visee, m_degats, allie);
+}

Armes/Modeles/Triphaseur.h

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

Armes/Modeles/Usiane.cpp

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

Armes/Modeles/Usiane.h

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

Control/ClavierCtrl.cpp

@@ -0,0 +1,48 @@
+#include "ClavierCtrl.h"
+
+ClavierCtrl::ClavierCtrl(InputAndJoy* input)
+:HardCtrl(input)
+{
+    //ctor
+}
+
+ClavierCtrl::~ClavierCtrl()
+{
+    //dtor
+}
+
+void ClavierCtrl::update()
+{
+    /// Gestion des changements de clavier Linux/Windows
+    #ifdef WIN32
+        #define PKEY_A SDLK_q
+        #define PKEY_Q SDLK_a
+        #define PKEY_Z SDLK_w
+    #else
+        #define PKEY_A SDLK_a
+        #define PKEY_Q SDLK_q
+        #define PKEY_Z SDLK_z
+    #endif
+
+    /// Deplacement
+    m_mvt.setVecteur(0.0f, 0.0f);
+    if ( m_input->getTouche(PKEY_Z) ) m_mvt.setY(1.0f);
+    if ( m_input->getTouche(PKEY_Q) ) m_mvt.setX(-1.0f);
+    if ( m_input->getTouche(SDLK_s) ) m_mvt.setY(-1.0f);
+    if ( m_input->getTouche(SDLK_d) ) m_mvt.setX(1.0f);
+    m_mvt.normaliser();
+
+    /// Visee
+    m_visee.setVecteur( m_input->getX() - m_input->getWinHalfW(), m_input->getWinHalfH() - m_input->getY() );
+
+    /// Tir
+    m_tir[ L_HAND ] = m_input->getBoutonSouris(1); // 1 = clic gauche
+    m_tir[ R_HAND ] = m_input->getBoutonSouris(3); // 0 = clic droit
+
+    /// Recherche
+    m_search[ L_HAND ] = m_input->getTouche(PKEY_A);
+    m_search[ R_HAND ] = m_input->getTouche(SDLK_e);
+
+    /// Craft
+    m_craft = m_input->getTouche(SDLK_c);
+}

Control/ClavierCtrl.h

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

Control/Controler.cpp

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

Control/Controler.h

@@ -0,0 +1,39 @@
+#ifndef CONTROLER_H
+#define CONTROLER_H
+
+// Inclusions
+#include <iostream>
+#include "../Structures/Vecteur.h"
+
+// Noms des mains
+#define L_HAND 0
+#define R_HAND 1
+
+
+class Controler
+{
+    public:
+        Controler();
+        virtual ~Controler();
+
+        virtual void update() = 0;
+
+        Vec getMvt() const;
+        Vec getVisee() const;
+        bool getCraft();
+        bool getTir( unsigned short main ) const;
+        bool getSearch( unsigned short main );
+
+    protected:
+        Vec m_mvt; // Norme € [0 ; 1]
+        Vec m_visee;
+        bool m_craft;
+        bool m_tir[2]; // Deux armes
+        bool m_search[2];
+
+    private:
+        bool m_prevCraft;
+        bool m_prevSearch[2]; // Pour éviter de chercher en continu
+};
+
+#endif // CONTROLER_H

Control/HardCtrl.cpp

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

Control/HardCtrl.h

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

Control/IA/Brute.cpp

@@ -0,0 +1,41 @@
+#include "Brute.h"
+
+Brute::Brute(Persos_Gest* persosGest, bool allie)
+: IACtrl(persosGest, allie), m_aglStrafe(0.0f), m_focusID(65535), m_cote()
+{
+    if ( rand()%2 ) m_cote = 1;
+    else m_cote = -1;
+}
+
+Brute::~Brute()
+{}//Ne rien détruire
+
+void Brute::update()
+{
+    ///Rafraichit focus
+        if ( !m_persosGest->getVivant(m_focusID, !m_allie) ) m_focusID = focusProche( !m_allie );
+
+    ///Visee
+        m_visee =  m_persosGest->getPos( m_focusID, !m_allie ) - m_moi->getPos();
+
+    ///Mouvement
+        if ( m_focusID == NO_FOCUS )
+        {
+            m_mvt.setVecteur(0.0f,0.0f,0.0f);
+        }
+        else
+        {
+            m_mvt = m_visee;
+            if ( m_mvt.norme() < 350.0 && ( m_aglStrafe <= 90.f || m_aglStrafe >= 90.f )) m_aglStrafe += 4.5f*m_cote;
+            else if ( m_aglStrafe != 0.0f ) m_aglStrafe -= 4.5f*m_cote;
+            m_mvt.rotateD( m_aglStrafe );
+        }
+
+    ///Tir
+        if ( m_mvt.norme() < 380.0 && m_focusID != NO_FOCUS ) m_tir[ L_HAND ] = m_tir[ R_HAND ] = true;
+        else m_tir[ L_HAND ] = m_tir[ R_HAND ] = false;
+
+        m_mvt.normaliser();
+}
+
+///END FICHIER

Control/IA/Brute.h

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

Control/IA/Follower.cpp

@@ -0,0 +1,32 @@
+#include "Follower.h"
+
+Follower::Follower(Persos_Gest* persosGest, bool allie)
+: IACtrl(persosGest, allie), m_focIDAllie(65535), m_focIDFoe(65535), m_vitesse(0.0f)
+{}
+
+Follower::~Follower()
+{}
+
+void Follower::update()
+{
+    ///Rafraichit focus
+        if ( !m_persosGest->getVivant(m_focIDAllie, m_allie) ) m_focIDAllie = focusProche( m_allie );
+        if ( !m_persosGest->getVivant(m_focIDFoe, !m_allie) ) m_focIDFoe = focusProche( !m_allie );
+
+    ///Visee
+        m_visee =  m_persosGest->getPos( m_focIDFoe, !m_allie ) - m_moi->getPos();
+
+    ///Mouvement
+        m_mvt =  m_persosGest->getPos( m_focIDAllie, m_allie ) - m_moi->getPos();
+        if ( m_mvt.norme() < 274.0 && m_vitesse > 0.0f) m_vitesse -= 0.1f; /// Près de l'allié : stop
+        else if ( m_vitesse < 1.0f ) m_vitesse += 0.1f; /// Loin, on le rejoint
+
+    ///Tir
+        if ( m_visee.norme() < 380.0 && m_persosGest->getVivant( m_focIDFoe, !m_allie ) ) m_tir[ L_HAND ] = m_tir[ R_HAND ] = true;
+        else m_tir[ L_HAND ] = m_tir[ R_HAND ] = false;
+
+        m_mvt.normaliser();
+        m_mvt *= m_vitesse;
+}
+
+///END FICHIER

Control/IA/Follower.h

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

Control/IA/Sniper.cpp

@@ -0,0 +1,26 @@
+#include "Sniper.h"
+
+Sniper::Sniper(Persos_Gest* persosGest, bool allie)
+: IACtrl( persosGest, allie ), m_focusID( 65535 ), m_lastShot( 0 )
+{}
+
+Sniper::~Sniper()
+{}//Ne rien détruire
+
+void Sniper::update()
+{
+    ///Rafraichit focus
+        if ( !m_persosGest->getVivant( m_focusID, !m_allie) ) m_focusID = focusProche( !m_allie );
+
+    ///Visee
+        m_visee =  m_persosGest->getPos( m_focusID, !m_allie ) - m_moi->getPos();
+
+    ///Tir
+        if ( SDL_GetTicks() - m_lastShot > 2500 ) { // Faut 2.5 secondes à un sniper pour viser
+            m_lastShot = SDL_GetTicks();
+            m_tir[ L_HAND ] = m_tir[ R_HAND ] = true;
+        }
+        else m_tir[ L_HAND ] = m_tir[ R_HAND ] = false;
+}
+
+///END FICHIER

Control/IA/Sniper.h

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

Control/IACtrl.cpp

@@ -0,0 +1,54 @@
+#include "IACtrl.h"
+
+IACtrl::IACtrl(Persos_Gest* persosGest, bool allie)
+: m_moi(0x0), m_persosGest(persosGest), m_allie(allie)
+{
+    //ctor
+}
+
+IACtrl::~IACtrl()
+{
+    //Ne rien détruire
+}
+
+void IACtrl::setPersoMoi(Perso* moi)
+{
+    m_moi = moi;
+}
+
+Uint16 IACtrl::focusProche(bool allie)
+{
+    /// Initialisation
+    unsigned int i;
+    Uint16 focusID( NO_FOCUS );
+    Vec diff;
+    float lg, lgMin; // Prend le premier vivant comme référence
+
+    /// Balayage
+    // Sélectionne le premier vivant
+    for ( i = 0; i < m_persosGest->getNb( allie ); i++ )
+    {
+        if ( m_persosGest->getVivant(i, allie) ) {
+            diff = m_persosGest->getPos(i, allie) - m_moi->getPos();
+            lgMin = diff.norme();
+            focusID = i;
+            break;
+        }
+    }
+    if ( focusID == NO_FOCUS ) return NO_FOCUS;
+
+    // Sélectionne le plus près
+    for ( i = i + 1; i < m_persosGest->getNb( allie ); i++ )
+    {
+        diff = m_persosGest->getPos(i, allie) - m_moi->getPos();
+        lg = diff.norme();
+        if ( m_persosGest->getVivant(i, allie) && lg != 0.0f && lg < lgMin ) {
+            lgMin = lg;
+            focusID = i;
+        }
+    }
+
+    return focusID;
+}
+
+/// END FICHIER

Control/IACtrl.h

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

Control/Input.cpp

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

Control/Input.h

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

Control/InputAndJoy.cpp

@@ -0,0 +1,147 @@
+#include "InputAndJoy.h"
+
+InputAndJoy::InputAndJoy()
+: m_manette(0), m_nbAxes(0), m_nbBoutons(0), m_controleurType(0), m_seuil(3600)
+{
+    // Démarrage du joystick
+    if (SDL_InitSubSystem(SDL_INIT_JOYSTICK)<0)
+    {
+        std::cout << "Problème lors de l'initialisation du matériel pour les manettes : "<<SDL_GetError()<< std::endl;
+    }
+    else
+    {
+        // Ouverture du joystick
+        SDL_JoystickEventState(SDL_ENABLE);
+        m_manette = SDL_JoystickOpen(0);
+        if (m_manette == NULL)
+        {
+            std::cout << "Manette non démarrée : " << SDL_GetError() << std::endl;
+            setMainControleur(CLAVIER_SOURIS);
+        }
+        else
+        {
+            setMainControleur(MANETTE);
+            // Détermination de la valeur des attributs
+            m_nbAxes = SDL_JoystickNumAxes(m_manette);
+            m_nbBoutons = SDL_JoystickNumButtons(m_manette);
+            for (int i(0); i<m_nbAxes; i++)
+                m_axeValue.push_back(0);
+            for (int i(0); i<m_nbBoutons; i++)
+                m_boutonValue.push_back(false);
+        }
+    }
+}
+
+InputAndJoy::~InputAndJoy()
+{
+    if (m_manette != 0x0) SDL_JoystickClose(m_manette);
+}
+
+void InputAndJoy::updateEvenements()
+{
+    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while(SDL_PollEvent(&m_evenements))
+    {
+        // Switch sur le type d'évènement
+        switch(m_evenements.type)
+        {
+        /// Evenements clavier et souris
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_touches[m_evenements.key.keysym.sym] = true;
+            break;
+
+            // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_touches[m_evenements.key.keysym.sym] = false;
+            break;
+
+            // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenements.button.button] = true;
+            break;
+
+            // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenements.button.button] = false;
+            break;
+
+            // Cas d'un mouvement de souris
+            case SDL_MOUSEMOTION:
+                if (m_relativeMouse)
+                {
+                    m_xRel = m_evenements.motion.x-m_windowHalfWidth;
+                    m_yRel = m_evenements.motion.y-m_windowHalfHeight;
+                }
+                else
+                {
+                    m_x = m_evenements.motion.x;
+                    m_y = m_evenements.motion.y;
+                    m_xRel = m_evenements.motion.xrel;
+                    m_yRel = m_evenements.motion.yrel;
+                }
+
+            break;
+
+            // Cas de la fermeture de la fenêtre
+            case SDL_QUIT:
+                m_terminer = true;
+            break;
+
+        /// Evenements joystick
+            case SDL_JOYAXISMOTION:
+                if (m_evenements.jaxis.value>m_seuil || m_evenements.jaxis.value<-m_seuil)
+                    m_axeValue[m_evenements.jaxis.axis] = m_evenements.jaxis.value;
+                else
+                    m_axeValue[m_evenements.jaxis.axis] = 0;
+                break;
+            case SDL_JOYBUTTONDOWN:
+                    m_boutonValue[m_evenements.jbutton.button] = true;
+                break;
+            case SDL_JOYBUTTONUP:
+                    m_boutonValue[m_evenements.jbutton.button] = false;
+                break;
+
+            default:
+            break;
+        }
+    }
+
+    // Pour éviter que la souris se barre en mode relative, on la "warp"
+    if (m_relativeMouse)
+         SDL_WarpMouse(m_windowHalfWidth, m_windowHalfHeight);
+}
+
+int InputAndJoy::getAxeValue(const Uint8 axeID) const
+{
+    if (axeID < m_nbAxes)
+        return m_axeValue[axeID];
+    else
+        std::cout << "Axe numéro "<<axeID<<" non-éxistant." << std::endl;
+    return -1;
+}
+
+bool InputAndJoy::getBoutonPad(const Uint8 bouton) const
+{
+    if (bouton<m_nbBoutons)
+        return m_boutonValue[bouton];
+    else
+        std::cout << "Bouton numéro "<<bouton<<" non-éxistant." << std::endl;
+    return false;
+}
+
+void InputAndJoy::setMainControleur(int type)
+{
+    if (type == CLAVIER_SOURIS || type == MANETTE)
+        if (m_manette!=0 || type!=MANETTE)
+            m_controleurType = type;
+}
+
+int InputAndJoy::getMainCtrl() const
+{
+    return m_controleurType;
+}

Control/InputAndJoy.h

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

Control/JoyCtrl.cpp

@@ -0,0 +1,46 @@
+#include "JoyCtrl.h"
+
+JoyCtrl::JoyCtrl(InputAndJoy* input)
+:HardCtrl(input)
+{
+    //ctor
+}
+
+JoyCtrl::~JoyCtrl()
+{
+    //dtor
+}
+
+void JoyCtrl::update()
+{
+    ///Deplacement
+    m_mvt.setVecteur( (float)m_input->getAxeValue(0) / 32768, (float)m_input->getAxeValue(1) / -32768);
+
+    ///Visee
+    Vec move( (float)m_input->getAxeValue(3) / 14000, (float)m_input->getAxeValue(4) / -14000 );
+    float norme( move.norme() );
+    move.setX( move.getX() * norme * norme * norme );
+    move.setY( move.getY() * norme * norme * norme );
+    m_visee += move;
+
+    if ( m_visee.getX() > m_input->getWinHalfW() )
+        m_visee.setX( m_input->getWinHalfW() );
+    else if ( m_visee.getX() < -m_input->getWinHalfW() )
+        m_visee.setX( -m_input->getWinHalfW() );
+
+    if ( m_visee.getY() > m_input->getWinHalfH() )
+        m_visee.setY( m_input->getWinHalfH() );
+    else if ( m_visee.getY() < -m_input->getWinHalfH() )
+        m_visee.setY( -m_input->getWinHalfH() );
+
+    ///Tir
+    m_tir[ L_HAND ] = m_input->getBoutonPad(4); // Xbox pad = LB
+    m_tir[ R_HAND ] = m_input->getBoutonPad(5); // Xbox pad = RB
+
+    ///Recherche
+    m_search[ L_HAND ] = m_input->getBoutonPad(2); // Xbox pad = A
+    m_search[ R_HAND ] = m_input->getBoutonPad(1); // Xbox pad = B
+
+    ///Craft
+    m_craft = m_input->getBoutonPad(3); // Xbox pad = Y
+}

Control/JoyCtrl.h

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

Jeu.cpp

@@ -0,0 +1,199 @@
+#include "Jeu.h"
+
+Jeu::Jeu()
+:m_screen(0x0), m_sprites("Textures/"), m_cursor(0x0), m_terrain(0x0),
+m_input(0x0), m_tirsGest(0x0), m_armGest(0x0), m_persosGest(0x0),
+m_support(0x0), m_persoFocus(0x0), m_nbJoueurs(1)
+{}
+
+Jeu::~Jeu()
+{
+    SDL_FreeSurface(m_screen);
+
+    if ( m_terrain != 0x0 ) delete m_terrain;
+    if ( m_input != 0x0 ) delete m_input;
+    if ( m_tirsGest != 0x0 ) delete m_tirsGest;
+    if ( m_persosGest != 0x0 ) delete m_persosGest;
+    if ( m_armGest != 0x0 ) delete m_armGest;
+
+    if ( m_support != 0x0 ) {
+        if ( m_nbJoueurs > 1 )
+            for ( Uint16 i(0); i<m_nbJoueurs; i++ )
+                SDL_FreeSurface( m_support[i] );
+        delete[] m_support;
+    }
+    if ( m_persoFocus != 0x0 ) delete[] m_persoFocus;
+
+    SDL_Quit();
+}
+
+bool Jeu::init()
+{
+    /// [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 false;
+    }
+
+    // [1.2] Para-fenêtre
+    SDL_WM_SetCaption("Hyper Gunner Bêta", 0);
+
+    // [1.3] Nombres aléatoires
+    srand( time(0) );
+
+
+    /// [2] Préparation des composants
+    // [2.1] Préparation des surfaces
+    const SDL_VideoInfo* ecran = SDL_GetVideoInfo(); // Acquisition des dimensions de l'écran
+    m_screen = SDL_SetVideoMode(/*ecran->current_w*/1366, /*ecran->current_h*/768, 32, SDL_HWSURFACE|SDL_DOUBLEBUF/*|SDL_FULLSCREEN*/);
+    if ( !m_screen )
+    {
+        std::cout << "Impossible de créer une fenêtre " <<ecran->current_w<<'*'<<ecran->current_h<< " : " << SDL_GetError() << std::endl;
+        return false;
+    }
+    else std::cout << "Création d'une fenêtre " <<ecran->current_w<<'*'<<ecran->current_h<< std::endl;
+
+    m_cursor = m_sprites.takeSprite("ViseurUsiane");
+    SDL_SetColorKey(m_cursor, SDL_SRCCOLORKEY, SDL_MapRGB(m_cursor->format, 255, 255, 255));
+
+    // [2.2] Préparation terrain
+    m_terrain = new Terrain(m_sprites.takeSprite("SiteCrash"));
+    m_sprites.destroySprite("SiteCrash"); // Le terrain s'en servait pour remplir ses chunks, il faut la libérer
+
+    // [2.3] Préparation input
+    m_input = new InputAndJoy;
+    m_input->placerPtr(m_screen);
+    m_input->afficherPointeur(false);
+    if ( m_input->getMainCtrl() == MANETTE ) m_nbJoueurs++;
+
+    // [2.3.1] Préparation écran scindé
+    m_persoFocus = new Perso*[m_nbJoueurs];
+    m_support = new SDL_Surface*[m_nbJoueurs];
+
+    if ( m_nbJoueurs > 1 ) { // Multijoueur
+        for ( Uint16 i(0); i < m_nbJoueurs; i++ ) {
+            m_support[i] = SDL_CreateRGBSurface( SDL_HWSURFACE, ecran->current_w/m_nbJoueurs, ecran->current_h, 32, 0, 0, 0, 0);
+            SDL_FillRect( m_support[i], 0, 0xff0000 );
+        }
+        m_scinde.x = ecran->current_w/m_nbJoueurs;
+        m_scinde.y = 0;
+    }
+    else { // Solo
+        m_support[0] = m_screen;
+    }
+
+    // [2.4.1] Préaparation du gestionnaire de tirs
+    m_tirsGest = new Tirs_Gest(m_sprites.takeSprite("BlueTir"), m_sprites.takeSprite("RedTir"));
+
+    // [2.4.2] Préparation du gestionnaire des armes
+    m_armGest = new Armes_Gest( &m_sprites );
+    /* TEST ARMES
+    m_armGest->drop( Vec( 250.0f, -10.0f ), new Shotgun( m_tirsGest ) );
+    m_armGest->drop( Vec( -250.0f, 10.0f ), new Bomber( m_tirsGest ) );*/
+
+    // [2.5] Préparation perso(s) focus
+    HardCtrl* ctrl(0x0);
+    if ( m_input->getMainCtrl() != CLAVIER_SOURIS && m_input->getMainCtrl() != MANETTE ) return false;
+
+    ctrl = new ClavierCtrl(m_input);
+    m_persoFocus[0] = new Perso(m_sprites.takeSprite("Allie"), m_sprites.takeSprite("Mort"), ctrl, m_tirsGest, true, m_armGest);
+
+    if ( m_nbJoueurs == 2 ) {
+        ctrl = new JoyCtrl(m_input);
+        m_persoFocus[1] = new Perso(m_sprites.takeSprite("Allie"), m_sprites.takeSprite("Mort"), ctrl, m_tirsGest, true, m_armGest);
+    }
+
+    // [2.6] Préparation du gestionnaire de persos
+    m_persosGest = new Persos_Gest();
+    for ( Uint16 i(0); i < m_nbJoueurs; i++ )
+        m_persosGest->addAllie(m_persoFocus[i]);
+    /* TEST IA*/
+    IACtrl* IAFriend( 0x0 );
+    Perso* ami ( 0x0 );
+    for (int i(0); i < 3; i++)
+    {
+        IAFriend = new Brute( m_persosGest, true );
+        ami = new Perso(m_sprites.takeSprite("Allie"), m_sprites.takeSprite("Mort"), IAFriend, m_tirsGest, true, m_armGest, rand() % 1000, rand() % 1000);
+        IAFriend->setPersoMoi( ami );
+        m_persosGest->addAllie( ami );
+    }
+
+    /// [3] Renvoi succès
+    return true;
+}
+
+int Jeu::mainLoop()
+{
+    /// [1] Boucle principale
+    Uint32 tDepart(SDL_GetTicks()), tDif, tFps(1000/50); // 50fps
+    bool done = false;
+    Uint32 nbFrame(0), usedTime(0);///DEBUG
+    while (!done)
+    {
+        // [3.1] Gestion évènements
+        m_input->updateEvenements();
+        if (m_input->terminer()) done = true;
+        if (m_input->getTouche(SDLK_ESCAPE)) done = true;
+
+        // [3.2] Calculs
+        m_persosGest->allMove();
+        m_tirsGest->allMove();
+        m_persosGest->nextWave(m_sprites, m_tirsGest, m_armGest);
+
+        // [3.3] Dessin des composants
+        for ( unsigned int i(0); i<m_nbJoueurs; i++ )
+            afficher(m_persoFocus[i], m_support[i]);
+
+        if ( m_nbJoueurs == 2 ) {
+            SDL_BlitSurface( m_support[0], 0, m_screen, 0);
+            SDL_BlitSurface( m_support[1], 0, m_screen, &m_scinde);
+        }
+
+        SDL_Flip(m_screen);
+
+        // [3.4] Gestion du temps
+        tDif = SDL_GetTicks() - tDepart;
+        nbFrame++;///DEBUG
+        usedTime += tDif;///DEBUG
+        if (tDif < tFps) SDL_Delay(tFps - tDif);
+        tDepart = SDL_GetTicks();
+    }
+
+    std::cout << "Environ " << (float)usedTime/nbFrame <<" ms sont utilisées par frame sur " << tFps << std::endl;
+    return 0;
+}
+
+void Jeu::afficher( const Perso* focus, SDL_Surface* support )
+{
+    // Focus OU Caméra libre
+    if ( focus->estVivant() ) {
+        m_look = focus->getPos();
+    }
+    else {
+        #define CAM_FREE_SPEED 12.0f
+        if (m_input->getTouche(SDLK_RIGHT)) m_look.setX(m_look.getX() + CAM_FREE_SPEED);
+        if (m_input->getTouche(SDLK_LEFT)) m_look.setX(m_look.getX() - CAM_FREE_SPEED);
+        if (m_input->getTouche(SDLK_UP)) m_look.setY(m_look.getY() + CAM_FREE_SPEED);
+        if (m_input->getTouche(SDLK_DOWN)) m_look.setY(m_look.getY() - CAM_FREE_SPEED);
+    }
+
+    // Nettoyage
+    SDL_FillRect( support, 0, 0x141213 );
+
+    // Elements
+    m_terrain->afficher(m_look, support);
+    m_armGest->allDisplay(m_look, support);
+    m_tirsGest->allDisplay(m_look, support);
+    m_persosGest->allDisplay(m_look, support);
+
+    // Curseur
+    Vec viseur = focus->getVisee();
+    SDL_Rect posCurseur;
+    posCurseur.x = viseur.getX() + support->w/2 - 32;
+    posCurseur.y = support->h/2 - viseur.getY() - 32;
+    SDL_BlitSurface(m_cursor, 0, support, &posCurseur);
+}
+
+///FICHIER END

Jeu.h

@@ -0,0 +1,55 @@
+#ifndef JEU_H
+#define JEU_H
+
+#include <iostream>
+#include <ctime>
+
+#include "Control/ClavierCtrl.h"
+#include "Control/JoyCtrl.h"
+
+#include "Control/IA/Brute.h"
+
+#include "Persos/Persos_Gest.h"
+#include "Tirs/Tirs_Gest.h"
+#include "Armes/Armes_Gest.h"
+#include "Structures/SpriteLoader.h"
+#include "Terrain/Terrain.h"
+
+
+class Jeu
+{
+/// Fonctions - - -
+    public:
+        Jeu();
+        ~Jeu();
+
+        bool init();
+
+        int mainLoop();
+
+    protected:
+        void afficher( const Perso* focus, SDL_Surface* support );
+
+/// Attributs - - -
+    protected:
+        SDL_Surface* m_screen;
+        SpriteLoader m_sprites;
+        SDL_Surface* m_cursor;
+
+        Terrain* m_terrain;
+
+        InputAndJoy* m_input;
+
+        Tirs_Gest* m_tirsGest;
+        Armes_Gest* m_armGest;
+        Persos_Gest* m_persosGest;
+
+        SDL_Surface** m_support;
+        Perso** m_persoFocus;
+        Uint16 m_nbJoueurs;
+        SDL_Rect m_scinde;
+
+        Vec m_look;
+};
+
+#endif // JEU_H

Persos/DisplayHP.cpp

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

Persos/DisplayHP.h

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

Persos/Perso.cpp

@@ -0,0 +1,222 @@
+#include "Perso.h"
+
+Perso::Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest)
+:Affichable(rotozoomSurface(srcImg, 90.0, 1.0, 0)),
+/** Vie*/ m_vieMax(100), m_vie(m_vieMax), m_disHP( m_vieMax ),
+/** Etat*/ m_vitesse(4.0f), m_vivant(true), m_allie(allie),
+/** Interactions*/ m_srcImg(srcImg), m_deathImg(deathImg), m_fullImg(0x0), m_visee(1.0f, 0.0f), m_ortho(0.0f, 17.0f), m_ctrl(ctrl), m_tirsGest(tirsGest),
+/** Arme*/ m_armGest( armGest ), m_arme()
+{
+    // Création de l'image stockant l'apparence
+    m_fullImg = SDL_CreateRGBSurface( SDL_HWSURFACE, m_srcImg->w, m_srcImg->h, 32, 0, 0, 0, 0);
+
+    // On récupère une arme de départ
+    m_arme[ L_HAND ] = m_armGest->startWeapon( tirsGest );
+    m_arme[ R_HAND ] = 0x0;
+    majFullImg();
+}
+
+Perso::Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest, float x, float y)
+:Affichable(rotozoomSurface(srcImg, 90.0, 1.0, 0)),
+/** Vie*/ m_vieMax(100), m_vie(m_vieMax), m_disHP( m_vieMax ),
+/** Etat*/ m_vitesse(4.0f), m_vivant(true), m_allie(allie),
+/** Interactions*/ m_srcImg(srcImg), m_deathImg(deathImg), m_visee(0.0f, 0.0f), m_ctrl(ctrl), m_tirsGest(tirsGest),
+/** Arme*/ m_armGest( armGest ), m_arme()
+{
+    // Création de l'image stockant l'apparence
+    m_fullImg = SDL_CreateRGBSurface( SDL_HWSURFACE, m_srcImg->w, m_srcImg->h, 32, 0, 0, 0, 0);
+
+    // Attribution des coordonnées du spawn
+    m_pos.setVecteur(x, y);
+
+    // On récupère une arme de départ
+    m_arme[ L_HAND ] = m_armGest->startWeapon( tirsGest );
+    m_arme[ R_HAND ] = 0x0;
+    majFullImg();
+}
+
+Perso::~Perso()
+{
+    SDL_FreeSurface(m_img);
+    SDL_FreeSurface(m_fullImg);
+
+    delete m_ctrl;
+    if ( m_arme[ L_HAND ] != 0x0 ) delete m_arme[ L_HAND ];
+    if ( m_arme[ R_HAND ] != 0x0 ) delete m_arme[ R_HAND ];
+}
+
+void Perso::bouger()
+{
+    if ( !m_vivant ) return;
+
+    m_ctrl->update();
+    bool change( false );
+
+    ///Deplacement
+    // Mouvement
+    Vec dir = m_ctrl->getMvt();
+    m_pos += dir * m_vitesse;
+
+    // Collision
+    if ( m_pos.getX() > 4500.0f ) m_pos.setX( 4500.0f );
+    else if ( m_pos.getX() < -1500.0f ) m_pos.setX( -1500.0f );
+    if ( m_pos.getY() > 1500.0f ) m_pos.setY( 1500.0f );
+    else if ( m_pos.getY() < -1500.0f ) m_pos.setY( -1500.0f );
+
+    // Placement
+    m_disHP.IAmHere( m_pos );
+
+    ///Craft
+    if ( m_ctrl->getCraft() && m_arme[0] && m_arme[1] ) {
+        Arme* prod = m_armGest->crafting( m_arme, m_tirsGest );
+        if ( prod != 0x0 ) {
+            m_arme[0] = prod;
+            m_arme[1] = 0x0;
+            change = true;
+        }
+    }
+
+    ///Recherche
+    for ( short i(0); i<2; i++ )
+    {
+        if ( m_ctrl->getSearch(i) )
+        {
+            if ( m_arme[ i ] == 0x0 )
+            {
+                // On saisit une arme
+                m_arme[ i ] = m_armGest->saisir( m_pos );
+            }
+            else
+            {
+                // On lache l'arme
+                m_armGest->drop( m_pos, m_arme[ i ] );
+                m_arme[ i ] = 0x0;
+            }
+
+            // On modifie l'apparence
+            change = true;
+        }
+    }
+    // Et on réinitialise l'apparence
+    if ( change && m_vivant ) majFullImg();
+
+    ///Collision avec les tirs
+    int aie( m_tirsGest->encaisser(m_pos, m_allie) );
+    if ( aie > 0 ) {
+        m_vie -= aie;
+
+        if (m_vie < 0) {
+            // Le perso est mort
+            m_vie = 0;
+            m_vivant = false;
+            SDL_BlitSurface( m_deathImg, 0, m_fullImg, 0 );
+            m_visee.normaliser(); // Pour orienter l'image de mort : force le test
+
+            // Et lache ses armes
+            for ( short i(0); i<2; i++ ) {
+                if ( m_arme[ i ] != 0x0 ) {
+                    m_armGest->drop( (i==0)? m_pos + m_ortho*2.0f : m_pos - m_ortho*2.0f, m_arme[ i ] );
+                    m_arme[ i ] = 0x0;
+                }
+            }
+        }
+
+        m_disHP.updateImg( m_vie );
+    }
+
+    ///Orientation
+    // On récupère
+    Vec visee( m_ctrl->getVisee() );
+
+    // Si entre deux on a tourné ...
+    if ( m_visee != visee )
+    {
+        // ... on tourne
+        m_visee = visee;
+        m_ortho.setVecteur( visee.getY(), -visee.getX() ); // Vecteur normal
+        m_ortho.normaliser();
+        m_ortho *= 17.0f;
+
+        // Calcul de l'angle en radians
+        float angle;
+        if (m_visee.getX() != 0.0f) angle = atan((double)( m_visee.getY()) / m_visee.getX() ); // Angle en radians
+        else if (m_visee.getY() < 0.0f) angle = -M_PI_2;
+        else angle = M_PI_2;
+
+        // Conversion
+        angle = angle * 180.0f / M_PI; // Angle en °
+        if ( m_visee.getX() < 0 ) angle += 180.0f;
+
+        // Rotation de l'image
+        SDL_FreeSurface(m_img);
+        m_img = rotozoomSurface(m_fullImg, angle, 1.0f, SMOOTHING_OFF );
+    }
+
+    ///Fine gachette
+    for ( short i(0); i<2; i++ ) {
+        if ( m_ctrl->getTir( i ) && m_arme[ i ] != 0x0 ) {
+            m_arme[ i ]->gachette( (i==0)? m_pos - m_ortho : m_pos + m_ortho, m_visee, m_allie );
+        }
+    }
+}
+
+bool Perso::estVivant() const
+{
+    return m_vivant;
+}
+
+Vec Perso::getPos() const
+{
+    return m_pos;
+}
+
+Vec Perso::getVisee() const
+{
+    return m_visee;
+}
+
+void Perso::regen()
+{
+    if ( !m_vivant ) {
+        m_vivant = true;
+        majFullImg();
+    }
+
+    m_vieMax += 6;
+    m_vie = m_vieMax;
+
+    m_disHP.setMax( m_vieMax );
+    m_disHP.updateImg( m_vie );
+}
+
+void Perso::afficher( const Vec &lookAt, SDL_Surface* screen )
+{
+    /// Afficher perso
+    Affichable::afficher( lookAt, screen );
+
+    /// Afficher barre de vie
+    m_disHP.afficher( lookAt, screen );
+}
+
+void Perso::majFullImg()
+{
+    // Réinitialise l'apparance
+    SDL_BlitSurface( m_srcImg, 0, m_fullImg, 0);
+
+    // Rajoute l'arme
+    SDL_Rect cadrage = { 24, 0, 0, 0 };
+    for ( short i(0); i<2; i++ )
+    {
+        if ( m_arme[ i ] != 0x0 )
+        {
+            SDL_Surface* weapon( m_armGest->getImg( m_arme[i]->getModel() ) );
+            SDL_BlitSurface( weapon, 0, m_fullImg, &cadrage );
+        }
+        cadrage.y += 30;
+    }
+
+    // Force le rafraichissement de l'image
+    m_visee.normaliser();
+}
+
+///FICHIER END

Persos/Perso.h

@@ -0,0 +1,73 @@
+#ifndef PERSO_H
+#define PERSO_H
+
+// Base
+#include <iostream>
+#include <cmath>
+
+// Affichage
+#include "../Structures/SDL_rotozoom.h"
+#include "../Structures/Affichable.h"
+#include "DisplayHP.h"
+
+// Mouvement
+#include "../Structures/Vecteur.h"
+#include "../Control/Controler.h"
+
+// Tirs
+#include "../Tirs/Tirs_Gest.h"
+#include "../Armes/Armes_Gest.h"
+
+
+class Perso : public Affichable
+{
+/// Fonctions - - -
+    public:
+        Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest);
+        Perso(SDL_Surface* srcImg, SDL_Surface* deathImg, Controler* ctrl, Tirs_Gest* tirsGest, bool allie, Armes_Gest* armGest, float x, float y);
+        virtual ~Perso();
+
+        void bouger();
+        bool estVivant() const;
+
+        Vec getPos() const;
+        Vec getVisee() const;
+
+        void regen();
+
+        void virtual afficher(const Vec &lookAt, SDL_Surface* screen);
+
+    protected:
+        void majFullImg();
+
+/// Attributs - - -
+    protected:
+        // Vie
+        int m_vieMax;
+        int m_vie;
+        DisplayHP m_disHP;
+
+        // Physique
+        float m_vitesse;
+        bool m_vivant;
+        const bool m_allie;
+
+        // Surfaces
+        SDL_Surface* m_srcImg;
+        SDL_Surface* m_deathImg;
+        SDL_Surface* m_fullImg;
+
+        // Visée
+        Vec m_visee;
+        Vec m_ortho;
+        Controler* m_ctrl;
+
+        // Pour encaisser
+        Tirs_Gest* m_tirsGest;
+
+        // Pour tirer
+        Armes_Gest* m_armGest;
+        Arme* m_arme[2];
+};
+
+#endif // PERSO_H

Persos/Persos_Gest.cpp

@@ -0,0 +1,153 @@
+#include "Persos_Gest.h"
+
+#include "../Control/IA/Brute.h"
+#include "../Control/IA/Follower.h"
+#include "../Control/IA/Sniper.h"
+
+Persos_Gest::Persos_Gest()
+:m_nextWave( 1 ), m_loading( true ), m_lastWon( SDL_GetTicks() )
+{
+    //ctor
+}
+
+Persos_Gest::~Persos_Gest()
+{
+    std::cout << "Vous êtes allés juqu'à la vague : " << m_nextWave-1 << std::endl;
+    // Destruction des alliés
+    while ( !m_allies.empty() ) {
+        delete m_allies.back();
+        m_allies.pop_back();
+    }
+
+    // Destruction des ennemis
+    while ( !m_foes.empty() ) {
+        delete m_foes.back();
+        m_foes.pop_back();
+    }
+}
+
+void Persos_Gest::allDisplay(const Vec &lookAt, SDL_Surface* screen) const
+{
+    for (unsigned int i(0); i < m_allies.size(); i++) m_allies[i]->afficher(lookAt, screen);
+    for (unsigned int i(0); i < m_foes.size(); i++) m_foes[i]->afficher(lookAt, screen);
+}
+
+void Persos_Gest::allMove() const
+{
+    for (unsigned int i(0); i < m_allies.size(); i++) m_allies[i]->bouger();
+    for (unsigned int i(0); i < m_foes.size(); i++) m_foes[i]->bouger();
+}
+
+void Persos_Gest::addAllie(Perso* newPerso)
+{
+    m_allies.push_back(newPerso);
+}
+
+void Persos_Gest::addFoe(Perso* newFoe)
+{
+    m_foes.push_back(newFoe);
+}
+
+Uint16 Persos_Gest::getNb( bool allie ) const
+{
+    if ( allie )
+        return m_allies.size();
+    else
+        return m_foes.size();
+}
+
+Vec Persos_Gest::getPos( const Uint16 &ID, bool allie ) const
+{
+    if ( allie && ID < m_allies.size() )
+        return m_allies[ID]->getPos();
+
+    else if ( !allie && ID < m_foes.size() )
+        return m_foes[ID]->getPos();
+
+    return Vec(0.0f, 0.0f);
+}
+
+bool Persos_Gest::getVivant( const Uint16 &ID, bool allie ) const
+{
+    if ( allie && ID < m_allies.size() )
+        return m_allies[ID]->estVivant();
+
+    else if ( !allie && ID < m_foes.size() )
+        return m_foes[ID]->estVivant();
+
+    return false;
+}
+
+void Persos_Gest::nextWave( SpriteLoader &skinGiver, Tirs_Gest* tirsGest, Armes_Gest* armGest )
+{
+    /// Attente
+    if ( m_loading ) {
+        if ( SDL_GetTicks() - m_lastWon < (Uint32)5000 )
+            return;
+    }
+    else
+    {
+        for (unsigned int i(0); i < m_foes.size(); i++) // Teste si tous les ennemis sont morts
+        {
+            if ( m_foes[i]->estVivant() )
+                return;
+        }
+
+        /// Régénerer les alliés vivants
+            for (unsigned int i(0); i < m_allies.size(); i++)
+                m_allies[i]->regen();
+
+        m_loading = true;
+        m_lastWon = SDL_GetTicks();
+        return;
+    }
+    m_loading = false;
+
+    /// Remettre les ennemis sur pieds
+    // Destruction des ennemis
+    while ( !m_foes.empty() ) {
+        delete m_foes.back();
+        m_foes.pop_back();
+    }
+
+    // Apparition des nouveaux ennemis
+    IACtrl* IAEnemy( 0x0 );
+    Perso* ennemi( 0x0 );
+    unsigned int nbNewFoes( m_nextWave );
+    float x, y;
+    float dx(6000.0f / nbNewFoes);
+    for (unsigned int i(0); i < nbNewFoes; i++)
+    {
+        x = dx*i; // Balayage des abscisses
+        y = ( (i%2) == 0 )? -1460.0f : 1460.0f; // Haut ou bas
+        IAEnemy = createRandIA();
+        ennemi = new Perso( skinGiver.takeSprite("Ennemi"), skinGiver.takeSprite("Mort"), IAEnemy, tirsGest, false, armGest, x, y );
+        IAEnemy->setPersoMoi( ennemi );
+        addFoe( ennemi );
+    }
+
+    /// Préparer la prochaine vague
+    m_nextWave++;
+}
+
+IACtrl* Persos_Gest::createRandIA()
+{
+    int nbAlea( rand() % 10 );
+    switch ( nbAlea )
+    {
+        case 0 :
+            return new Follower( this );
+            break;
+
+        case 1 :
+            return new Sniper( this );
+            break;
+
+        default :
+            return new Brute( this );
+            break;
+
+    }
+}
+
+///END FICHIER

Persos/Persos_Gest.h

@@ -0,0 +1,41 @@
+#ifndef PERSOS_GEST_H
+#define PERSOS_GEST_H
+
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include "Perso.h"
+#include "../Structures/SpriteLoader.h"
+/*#include "../Control/IACtrl.h" */ class IACtrl;
+
+
+class Persos_Gest
+{
+    public:
+        Persos_Gest();
+        virtual ~Persos_Gest();
+
+        void allDisplay(const Vec &lookAt, SDL_Surface* screen) const;
+        void allMove() const;
+
+        void addAllie( Perso* newPerso );
+        void addFoe( Perso* newFoe );
+
+        Uint16 getNb( bool allie ) const;
+        Vec getPos( const Uint16 &ID, bool allie ) const;
+        bool getVivant( const Uint16 &ID, bool allie ) const;
+
+        void nextWave( SpriteLoader &skinGiver, Tirs_Gest* tirsGest, Armes_Gest* armGest);
+        IACtrl* createRandIA();
+
+    protected:
+        std::vector<Perso*> m_allies;
+        std::vector<Perso*> m_foes;
+
+        unsigned int m_nextWave;
+        bool m_loading;
+        Uint32 m_lastWon;
+};
+
+
+#endif // PERSOS_GEST_H

Structures/Affichable.cpp

@@ -0,0 +1,20 @@
+#include "Affichable.h"
+
+Affichable::Affichable(SDL_Surface* img)
+:m_img(img), m_pos(0.0f, 0.0f)
+{
+    //ctor
+}
+
+Affichable::~Affichable()
+{
+    //dtor
+}
+
+void Affichable::afficher(const Vec &lookAt, SDL_Surface* screen)
+{
+    m_rect.x = m_pos.getX() - lookAt.getX() + screen->w/2 - m_img->w/2;
+    m_rect.y = lookAt.getY() - m_pos.getY() + screen->h/2 - m_img->h/2;
+
+    SDL_BlitSurface(m_img, 0, screen, &m_rect);
+}

Structures/Affichable.h

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

Structures/SDL_rotozoom.h

@@ -0,0 +1,123 @@
+/*
+
+SDL_rotozoom.c: rotozoomer, zoomer and shrinker for 32bit or 8bit surfaces
+
+Copyright (C) 2001-2012  Andreas Schiffler
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+claim that you wrote the original software. If you use this software
+in a product, an acknowledgment in the product documentation would be
+appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+
+Andreas Schiffler -- aschiffler at ferzkopp dot net
+
+*/
+
+#ifndef _SDL_rotozoom_h
+#define _SDL_rotozoom_h
+
+#include <math.h>
+
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef M_PI
+#define M_PI	3.141592654
+#endif
+
+#include "SDL.h"
+
+	/* ---- Defines */
+
+	/*!
+	\brief Disable anti-aliasing (no smoothing).
+	*/
+#define SMOOTHING_OFF		0
+
+	/*!
+	\brief Enable anti-aliasing (smoothing).
+	*/
+#define SMOOTHING_ON		1
+
+	/* ---- Function Prototypes */
+
+#ifdef _MSC_VER
+#  if defined(DLL_EXPORT) && !defined(LIBSDL_GFX_DLL_IMPORT)
+#    define SDL_ROTOZOOM_SCOPE __declspec(dllexport)
+#  else
+#    ifdef LIBSDL_GFX_DLL_IMPORT
+#      define SDL_ROTOZOOM_SCOPE __declspec(dllimport)
+#    endif
+#  endif
+#endif
+#ifndef SDL_ROTOZOOM_SCOPE
+#  define SDL_ROTOZOOM_SCOPE extern
+#endif
+
+	/*
+
+	Rotozoom functions
+
+	*/
+
+	SDL_ROTOZOOM_SCOPE SDL_Surface *rotozoomSurface(SDL_Surface * src, double angle, double zoom, int smooth);
+
+	SDL_ROTOZOOM_SCOPE SDL_Surface *rotozoomSurfaceXY
+		(SDL_Surface * src, double angle, double zoomx, double zoomy, int smooth);
+
+
+	SDL_ROTOZOOM_SCOPE void rotozoomSurfaceSize(int width, int height, double angle, double zoom, int *dstwidth,
+		int *dstheight);
+
+	SDL_ROTOZOOM_SCOPE void rotozoomSurfaceSizeXY
+		(int width, int height, double angle, double zoomx, double zoomy,
+		int *dstwidth, int *dstheight);
+
+	/*
+
+	Zooming functions
+
+	*/
+
+	SDL_ROTOZOOM_SCOPE SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy, int smooth);
+
+	SDL_ROTOZOOM_SCOPE void zoomSurfaceSize(int width, int height, double zoomx, double zoomy, int *dstwidth, int *dstheight);
+
+	/*
+
+	Shrinking functions
+
+	*/
+
+	SDL_ROTOZOOM_SCOPE SDL_Surface *shrinkSurface(SDL_Surface * src, int factorx, int factory);
+
+	/*
+
+	Specialized rotation functions
+
+	*/
+
+	SDL_ROTOZOOM_SCOPE SDL_Surface* rotateSurface90Degrees(SDL_Surface* src, int numClockwiseTurns);
+
+	/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif				/* _SDL_rotozoom_h */

Structures/SpriteLoader.cpp

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

Structures/SpriteLoader.h

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

Structures/Vecteur.cpp

@@ -0,0 +1,219 @@
+#include "Vecteur.h"
+
+///Constructeurs
+Vec::Vec() : m_x(0.0), m_y(0.0), m_z(0.0)
+{}
+
+Vec::Vec(float x, float y, float z) : m_x(x), m_y(y), m_z(z)
+{}
+
+Vec::Vec(const Vec &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
+{}
+
+Vec::~Vec()
+{}
+
+///Fonctions
+void Vec::normaliser()
+{
+    // La fonction sqrt() permet de trouver la racine carré d'un nombre
+    float longueur(sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
+
+    // Normalisation du vecteur
+    if(longueur != 0.0f)
+    {
+        m_x /= longueur;
+        m_y /= longueur;
+        m_z /= longueur;
+    }
+}
+
+float Vec::scalair(const Vec &vecteur) const
+{
+    Vec v1(*this), v2(vecteur);
+    v1.normaliser();
+    v2.normaliser();
+    return v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
+}
+
+double Vec::norme() const
+{
+    return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
+}
+
+void Vec::rotateR(float angle)
+{
+    float tmp = m_x;
+    m_x = cos(angle)*m_x-sin(angle)*m_y;
+    m_y = sin(angle)*tmp+cos(angle)*m_y;
+}
+
+void Vec::rotateD(float angle)
+{
+    float _angle = angle * M_PI / 180.0;
+    float tmp = m_x;
+    m_x = cos(_angle)*m_x-sin(_angle)*m_y;
+    m_y = sin(_angle)*tmp+cos(_angle)*m_y;
+}
+
+///Getters
+float Vec::getX() const
+{
+    return m_x;
+}
+
+float Vec::getY() const
+{
+    return m_y;
+}
+
+float Vec::getZ() const
+{
+    return m_z;
+}
+
+/// Setters
+void Vec::setVecteur(float x, float y, float z)
+{
+    m_x = x;
+    m_y = y;
+    m_z = z;
+}
+
+void Vec::setX(float x)
+{
+    m_x = x;
+}
+
+void Vec::setY(float y)
+{
+    m_y = y;
+}
+
+void Vec::setZ(float z)
+{
+    m_z = z;
+}
+
+///Opérateurs
+Vec& Vec::operator=(const Vec &vecteur)
+{
+    // Copie des valeurs
+    m_x = vecteur.m_x;
+    m_y = vecteur.m_y;
+    m_z = vecteur.m_z;
+
+    // Retour de l'objet
+    return *this;
+}
+
+Vec Vec::operator+(const Vec &vecteur)
+{
+    // Création d'un objet résultat
+    Vec resultat;
+
+    // Addition des coordonnées
+    resultat.m_x = m_x + vecteur.m_x;
+    resultat.m_y = m_y + vecteur.m_y;
+    resultat.m_z = m_z + vecteur.m_z;
+
+    // Retour de résultat
+    return resultat;
+}
+
+Vec Vec::operator-(const Vec &vecteur)
+{
+    // Création d'un objet résultat
+    Vec resultat;
+
+    // Soustraction des coordonnées
+    resultat.m_x = m_x - vecteur.m_x;
+    resultat.m_y = m_y - vecteur.m_y;
+    resultat.m_z = m_z - vecteur.m_z;
+
+    // Retour de résultat
+    return resultat;
+}
+
+Vec Vec::operator*(float multiplicateur)
+{
+    // Création d'un objet résultat
+    Vec resultat;
+
+    // Multiplication des coordonnées
+    resultat.m_x = m_x * multiplicateur;
+    resultat.m_y = m_y * multiplicateur;
+    resultat.m_z = m_z * multiplicateur;
+
+    // Retour du résultat
+    return resultat;
+}
+
+Vec Vec::operator/(float diviseur)
+{
+    // Création d'un objet résultat
+    Vec resultat;
+
+    // Multiplication des coordonnées
+    resultat.m_x = m_x / diviseur;
+    resultat.m_y = m_y / diviseur;
+    resultat.m_z = m_z / diviseur;
+
+    // Retour du résultat
+    return resultat;
+}
+
+Vec Vec::operator*(const Vec &vecteur)
+{
+    // Création d'un objet résultat
+    Vec resultat;
+
+    // Produit Vectoriel
+    resultat.m_x = (m_y * vecteur.m_z) - (m_z * vecteur.m_y);
+    resultat.m_y = (m_z * vecteur.m_x) - (m_x * vecteur.m_z);
+    resultat.m_z = (m_x * vecteur.m_y) - (m_y * vecteur.m_x);
+
+    // Retour de l'objet
+    return resultat;
+}
+
+void Vec::operator*=(const Vec &vecteur)
+{
+    *this = *this * vecteur;
+}
+
+void Vec::operator-=(const Vec &vecteur)
+{
+    *this = *this - vecteur;
+}
+
+void Vec::operator+=(const Vec &vecteur)
+{
+    *this = *this + vecteur;
+}
+
+void Vec::operator*=(float multiplicateur)
+{
+    *this = *this * multiplicateur;
+}
+
+void Vec::operator/=(float multiplicateur)
+{
+    *this = *this * multiplicateur;
+}
+
+bool Vec::operator==(const Vec &vecteur)
+{
+    if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
+        return true;
+    else
+        return false;
+}
+
+bool Vec::operator!=(const Vec &vecteur)
+{
+    if(*this == vecteur)
+        return false;
+    else
+        return true;
+}

Structures/Vecteur.h

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

Terrain/Chunk.cpp

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

Terrain/Chunk.h

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

Terrain/Terrain.cpp

@@ -0,0 +1,40 @@
+#include "Terrain.h"
+
+Terrain::Terrain(SDL_Surface* img)
+:Affichable(img)
+{
+    SDL_Surface *tmpImg, *model;
+    m_rect.w = m_rect.h = LG_CHUNK;
+    for (int x(0); x<NB_X_CHUNK; x++)
+        for (int y(0); y<NB_Y_CHUNK; y++)
+        {
+            // Création de la surface du chunk
+            tmpImg = SDL_CreateRGBSurface(SDL_HWSURFACE, LG_CHUNK, LG_CHUNK, 32, 0, 0, 0, 0);
+            m_rect.x = x * LG_CHUNK;
+            m_rect.y = y * LG_CHUNK;
+            SDL_BlitSurface(img, &m_rect, tmpImg, 0);
+
+            // Optimisation surface
+            model = tmpImg;
+            tmpImg = SDL_DisplayFormat(model);
+            SDL_FreeSurface(model);
+
+            // Création du chunk
+            m_chunk[NB_Y_CHUNK-y-1][x] = new Chunk(tmpImg, x, NB_Y_CHUNK-y-1);
+        }
+}
+
+Terrain::~Terrain()
+{
+    for (int x(0); x<NB_X_CHUNK; x++)
+        for (int y(0); y<NB_Y_CHUNK; y++)
+            delete m_chunk[y][x];
+}
+
+void Terrain::afficher(const Vec &lookAt, SDL_Surface* screen) const
+{
+    ///Affichage optimisé
+    for (int x(0); x<NB_X_CHUNK; x++)
+        for (int y(0); y<NB_Y_CHUNK; y++)
+            m_chunk[y][x]->afficher(lookAt, screen);
+}

Terrain/Terrain.h

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

Textures/.gitignore

@@ -0,0 +1,2 @@
+# Very large file (54MB)
+SiteCrash.bmp

Tirs/Tir.cpp

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

Tirs/Tir.h

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

Tirs/Tirs_Gest.cpp

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

Tirs/Tirs_Gest.h

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

main.cpp

@@ -0,0 +1,12 @@
+#include "Jeu.h"
+
+int main ( int argc, char** argv )
+{
+    Jeu hyperGunner;
+
+    if (hyperGunner.init()) return hyperGunner.mainLoop();
+
+    std::cout << "Erreur dans l'initialisation de Hyper Gunner." << std::endl;
+
+    return 1;
+}