Replace CR/LF by LF

Input.cpp

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

Input.h

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

intToStr.cpp

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

intToStr.h

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

main.cpp

@@ -1,259 +1,259 @@
-#include "spawn.h"
-#include "intToStr.h"
-
-#define NB_GAMERS 2
-
-#define NB_GROW 6
-#define NB_BASE 10
-#define NEXT_ROUND spawn( &obs, NB_BASE+lvl*NB_GROW, w, h )
-#define GAMERS_POS (1+t)*(h/(1+NB_GAMERS))
-
-int main ( int argc, char** argv )
-{
-    /// initialize SDL video
-    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
-    {
-        printf( "Unable to init SDL: %s\n", SDL_GetError() );
-        return 1;
-    }
-    SDL_ShowCursor( SDL_DISABLE );
-
-    /// make sure SDL cleans up before exit
-    atexit(SDL_Quit);
-
-    /// init random list
-    srand( time(0) );
-
-    /// create a new window
-    Uint16 w, h;
-    SDL_Surface *buffer(0x0), *screen(0x0);
-
-    { // spare useless variables
-        const SDL_VideoInfo* fenetreInfo = SDL_GetVideoInfo();
-        w = fenetreInfo->current_w;
-        h = fenetreInfo->current_h;
-    }
-    screen = SDL_SetVideoMode(w, h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
-    std::cout << "Set " << w << 'x' << h << " video." << std::endl;
-    if ( !screen )
-    {
-        std::cout << "Unable to set video " << SDL_GetError() << std::endl;
-        return 1;
-    }
-    else
-    {
-        buffer = SDL_CreateRGBSurface( SDL_HWSURFACE, w, h, 32, 0, 0, 0, 0 );
-    }
-
-    /// variables
-    const Uint32 delay(18);
-    Uint32 tps( SDL_GetTicks() ), tps_old(0);
-    Uint32 fdis_time(0), fdis_count(0), fdis_rslt(0);
-    bool alive[NB_GAMERS];
-    bool running;
-    int lvl( 1 );
-
-    /// graph
-    int i(0), x[NB_GAMERS], y[NB_GAMERS];
-    Uint8 r(0), g(255), b(255);
-    bool up[NB_GAMERS], down[NB_GAMERS];
-
-    /// init
-    for ( int t(0); t < NB_GAMERS; t++ )
-    {
-        alive[t] = true;
-        x[t] = -1;
-        y[t] = GAMERS_POS;
-        up[t] = down[t] = false;
-    }
-
-    /// obstacles
-    std::vector<SDL_Rect> obs(0);
-    NEXT_ROUND;
-
-    /// program main loop
-    bool done = false;
-    while (!done)
-    {
-        // message processing loop
-        SDL_Event event;
-        while (SDL_PollEvent(&event))
-        {
-            // check for messages
-            switch (event.type)
-            {
-                // exit if the window is closed
-            case SDL_QUIT:
-                done = true;
-                break;
-
-                // check for keypresses
-            case SDL_KEYDOWN:
-                // exit if ESCAPE is pressed
-                switch ( event.key.keysym.sym )
-                {
-                case SDLK_ESCAPE:
-                    done = true;
-                    break;
-                case SDLK_UP:
-                case SDLK_LEFT:
-                    up[0] = true;
-                    break;
-                case SDLK_DOWN:
-                case SDLK_RIGHT:
-                    down[0] = true;
-                    break;
-                case SDLK_BACKSPACE:
-                    alive[0] = true;
-                    x[0] = w+1;
-                    lvl = 0;
-                #if NB_GAMERS > 1
-                    alive[1] = true;
-                    x[1] = w+1;
-                    break;
-                case SDLK_w:
-                case SDLK_a:
-                    up[1] = true;
-                    break;
-                case SDLK_s:
-                case SDLK_d:
-                    down[1] = true;
-                    break;
-                #endif
-                default:
-                    break;
-                }
-                break;
-
-            case SDL_KEYUP:
-                switch ( event.key.keysym.sym )
-                {
-                case SDLK_UP:
-                case SDLK_LEFT:
-                    up[0] = false;
-                    break;
-                case SDLK_DOWN:
-                case SDLK_RIGHT:
-                    down[0] = false;
-                    break;
-                #if NB_GAMERS > 1
-                case SDLK_w:
-                case SDLK_a:
-                    up[1] = false;
-                    break;
-                case SDLK_s:
-                case SDLK_d:
-                    down[1] = false;
-                    break;
-                #endif
-                default:
-                    break;
-                }
-                break;
-
-            } // end switch event tye
-        } // end of message processing
-
-        // color computing
-        if ( i < 256 )
-        {
-            r = i;
-            g = 255 - i%256;
-            // b = 255
-        }
-        else if ( i < 512 )
-        {
-            //r = 255
-            g = i%256;
-            b = 255 - i%256;
-        }
-        else if ( i < 768 )
-        {
-            r = 255 - i%256;
-            //g = 255
-            b = i%256;
-        }
-
-        // still run ?
-        running = alive[0];
-        #if NB_GAMERS > 1
-        running &= alive[1];
-        #endif // NB_GAMERS
-
-        // direction
-        for ( int t(0); t<NB_GAMERS; t++ )
-            for ( int j(0); j < 5 && running; j++ )
-            {
-                x[t]++;
-                if ( up[t] ) y[t]--;
-                else if ( down[t] ) y[t]++;
-                if ( y[t] < 0 ) y[t] = h-1;
-                if ( y[t] >= h ) y[t] = 0;
-                if ( t == 0) pixelRGBA(buffer, x[0], y[0], r, g, b, 255);
-                else pixelRGBA(buffer, x[1], y[1], g, b, r, 255);
-            }
-
-        // next round
-        if ( x[0] > w )
-        {
-            lvl++;
-            obs.clear();
-            NEXT_ROUND;
-            SDL_FillRect( buffer, 0, 0x000000 );
-            for ( int t(0); t<NB_GAMERS; t++ )
-            {
-                x[t] = 0;
-                y[t] = GAMERS_POS;
-            }
-        }
-
-        /// -- Buffer
-            /// calculs
-            i++;
-            for ( int t(0); t<NB_GAMERS; t++ )
-                if ( !alive[t] )
-                    stringRGBA(buffer, x[t]+8, y[t]+8, "GAME OVER", r/3, g/3, b/3, 255);
-            if ( i > 767 ) i = 0;
-
-            /// draw obstacles
-            for ( Uint16 j(0); j < obs.size(); j++ )
-            {
-                SDL_FillRect( buffer, &obs[j], b + (g << 8) + (r << 16) );
-                for ( int t(0); t<NB_GAMERS; t++ )
-                    if (x[t] > obs[j].x &&
-                        x[t] < obs[j].x + obs[j].w &&
-                        y[t] > obs[j].y &&
-                        y[t] < obs[j].y + obs[j].h) alive[t] = false;
-            }
-            stringRGBA(buffer, 12, 12, ("Level "+intToStr( lvl )).c_str(), r, g, b, 255);
-            for ( int t(0); t<NB_GAMERS; t++ )
-                if ( !alive[t] )
-                    stringRGBA(buffer, x[t]+6, y[t]+6, "GAME OVER", 255, 4, 23, 255);
-
-        /// past buffer
-        SDL_BlitSurface( buffer, 0, screen, 0 );
-
-        /// fps count
-        fdis_count++;
-        if ( SDL_GetTicks() - fdis_time > 1000) {
-            fdis_rslt = fdis_count;
-            fdis_count = 0;
-            fdis_time = SDL_GetTicks();
-        }
-        stringRGBA(screen, 12, 24, ("Fps: "+intToStr( fdis_rslt )).c_str(), r, g, b, 255);
-
-        /// finally, update the screen :)
-        SDL_Flip(screen);
-
-        /// time management
-        do
-        {
-            tps = SDL_GetTicks();
-        } while ( tps-tps_old < delay );
-        tps_old = tps;
-    } // end main loop
-
-    /// all is well ;)
-    std::cout << "Exited cleanly." << std::endl;
-    return 0;
-}
+#include "spawn.h"
+#include "intToStr.h"
+
+#define NB_GAMERS 2
+
+#define NB_GROW 6
+#define NB_BASE 10
+#define NEXT_ROUND spawn( &obs, NB_BASE+lvl*NB_GROW, w, h )
+#define GAMERS_POS (1+t)*(h/(1+NB_GAMERS))
+
+int main ( int argc, char** argv )
+{
+    /// initialize SDL video
+    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
+    {
+        printf( "Unable to init SDL: %s\n", SDL_GetError() );
+        return 1;
+    }
+    SDL_ShowCursor( SDL_DISABLE );
+
+    /// make sure SDL cleans up before exit
+    atexit(SDL_Quit);
+
+    /// init random list
+    srand( time(0) );
+
+    /// create a new window
+    Uint16 w, h;
+    SDL_Surface *buffer(0x0), *screen(0x0);
+
+    { // spare useless variables
+        const SDL_VideoInfo* fenetreInfo = SDL_GetVideoInfo();
+        w = fenetreInfo->current_w;
+        h = fenetreInfo->current_h;
+    }
+    screen = SDL_SetVideoMode(w, h, 32, SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
+    std::cout << "Set " << w << 'x' << h << " video." << std::endl;
+    if ( !screen )
+    {
+        std::cout << "Unable to set video " << SDL_GetError() << std::endl;
+        return 1;
+    }
+    else
+    {
+        buffer = SDL_CreateRGBSurface( SDL_HWSURFACE, w, h, 32, 0, 0, 0, 0 );
+    }
+
+    /// variables
+    const Uint32 delay(18);
+    Uint32 tps( SDL_GetTicks() ), tps_old(0);
+    Uint32 fdis_time(0), fdis_count(0), fdis_rslt(0);
+    bool alive[NB_GAMERS];
+    bool running;
+    int lvl( 1 );
+
+    /// graph
+    int i(0), x[NB_GAMERS], y[NB_GAMERS];
+    Uint8 r(0), g(255), b(255);
+    bool up[NB_GAMERS], down[NB_GAMERS];
+
+    /// init
+    for ( int t(0); t < NB_GAMERS; t++ )
+    {
+        alive[t] = true;
+        x[t] = -1;
+        y[t] = GAMERS_POS;
+        up[t] = down[t] = false;
+    }
+
+    /// obstacles
+    std::vector<SDL_Rect> obs(0);
+    NEXT_ROUND;
+
+    /// program main loop
+    bool done = false;
+    while (!done)
+    {
+        // message processing loop
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            // check for messages
+            switch (event.type)
+            {
+                // exit if the window is closed
+            case SDL_QUIT:
+                done = true;
+                break;
+
+                // check for keypresses
+            case SDL_KEYDOWN:
+                // exit if ESCAPE is pressed
+                switch ( event.key.keysym.sym )
+                {
+                case SDLK_ESCAPE:
+                    done = true;
+                    break;
+                case SDLK_UP:
+                case SDLK_LEFT:
+                    up[0] = true;
+                    break;
+                case SDLK_DOWN:
+                case SDLK_RIGHT:
+                    down[0] = true;
+                    break;
+                case SDLK_BACKSPACE:
+                    alive[0] = true;
+                    x[0] = w+1;
+                    lvl = 0;
+                #if NB_GAMERS > 1
+                    alive[1] = true;
+                    x[1] = w+1;
+                    break;
+                case SDLK_w:
+                case SDLK_a:
+                    up[1] = true;
+                    break;
+                case SDLK_s:
+                case SDLK_d:
+                    down[1] = true;
+                    break;
+                #endif
+                default:
+                    break;
+                }
+                break;
+
+            case SDL_KEYUP:
+                switch ( event.key.keysym.sym )
+                {
+                case SDLK_UP:
+                case SDLK_LEFT:
+                    up[0] = false;
+                    break;
+                case SDLK_DOWN:
+                case SDLK_RIGHT:
+                    down[0] = false;
+                    break;
+                #if NB_GAMERS > 1
+                case SDLK_w:
+                case SDLK_a:
+                    up[1] = false;
+                    break;
+                case SDLK_s:
+                case SDLK_d:
+                    down[1] = false;
+                    break;
+                #endif
+                default:
+                    break;
+                }
+                break;
+
+            } // end switch event tye
+        } // end of message processing
+
+        // color computing
+        if ( i < 256 )
+        {
+            r = i;
+            g = 255 - i%256;
+            // b = 255
+        }
+        else if ( i < 512 )
+        {
+            //r = 255
+            g = i%256;
+            b = 255 - i%256;
+        }
+        else if ( i < 768 )
+        {
+            r = 255 - i%256;
+            //g = 255
+            b = i%256;
+        }
+
+        // still run ?
+        running = alive[0];
+        #if NB_GAMERS > 1
+        running &= alive[1];
+        #endif // NB_GAMERS
+
+        // direction
+        for ( int t(0); t<NB_GAMERS; t++ )
+            for ( int j(0); j < 5 && running; j++ )
+            {
+                x[t]++;
+                if ( up[t] ) y[t]--;
+                else if ( down[t] ) y[t]++;
+                if ( y[t] < 0 ) y[t] = h-1;
+                if ( y[t] >= h ) y[t] = 0;
+                if ( t == 0) pixelRGBA(buffer, x[0], y[0], r, g, b, 255);
+                else pixelRGBA(buffer, x[1], y[1], g, b, r, 255);
+            }
+
+        // next round
+        if ( x[0] > w )
+        {
+            lvl++;
+            obs.clear();
+            NEXT_ROUND;
+            SDL_FillRect( buffer, 0, 0x000000 );
+            for ( int t(0); t<NB_GAMERS; t++ )
+            {
+                x[t] = 0;
+                y[t] = GAMERS_POS;
+            }
+        }
+
+        /// -- Buffer
+            /// calculs
+            i++;
+            for ( int t(0); t<NB_GAMERS; t++ )
+                if ( !alive[t] )
+                    stringRGBA(buffer, x[t]+8, y[t]+8, "GAME OVER", r/3, g/3, b/3, 255);
+            if ( i > 767 ) i = 0;
+
+            /// draw obstacles
+            for ( Uint16 j(0); j < obs.size(); j++ )
+            {
+                SDL_FillRect( buffer, &obs[j], b + (g << 8) + (r << 16) );
+                for ( int t(0); t<NB_GAMERS; t++ )
+                    if (x[t] > obs[j].x &&
+                        x[t] < obs[j].x + obs[j].w &&
+                        y[t] > obs[j].y &&
+                        y[t] < obs[j].y + obs[j].h) alive[t] = false;
+            }
+            stringRGBA(buffer, 12, 12, ("Level "+intToStr( lvl )).c_str(), r, g, b, 255);
+            for ( int t(0); t<NB_GAMERS; t++ )
+                if ( !alive[t] )
+                    stringRGBA(buffer, x[t]+6, y[t]+6, "GAME OVER", 255, 4, 23, 255);
+
+        /// past buffer
+        SDL_BlitSurface( buffer, 0, screen, 0 );
+
+        /// fps count
+        fdis_count++;
+        if ( SDL_GetTicks() - fdis_time > 1000) {
+            fdis_rslt = fdis_count;
+            fdis_count = 0;
+            fdis_time = SDL_GetTicks();
+        }
+        stringRGBA(screen, 12, 24, ("Fps: "+intToStr( fdis_rslt )).c_str(), r, g, b, 255);
+
+        /// finally, update the screen :)
+        SDL_Flip(screen);
+
+        /// time management
+        do
+        {
+            tps = SDL_GetTicks();
+        } while ( tps-tps_old < delay );
+        tps_old = tps;
+    } // end main loop
+
+    /// all is well ;)
+    std::cout << "Exited cleanly." << std::endl;
+    return 0;
+}

spawn.cpp

@@ -1,19 +1,19 @@
-#include "spawn.h"
-
-#define SAMPLER_X 19
-#define SAMPLER_Y 10
-#define WIDE_X w/SAMPLER_X
-#define WIDE_Y h/SAMPLER_Y
-#define WIDE_SUM WIDE_MAX+WIDE_MIN
-#define SAFE_ZONE 200
-
-void spawn( std::vector<SDL_Rect>* obs, Uint16 nb, Uint16 w, Uint16 h )
-{
-    for ( Uint16 i(0); i < nb; i++)
-    {
-        obs->push_back( {   SAFE_ZONE + rand()%(w-SAFE_ZONE-WIDE_X),  // x
-                            rand()%(h-WIDE_Y),                        // y
-                            WIDE_X,                   // w
-                            WIDE_Y} );                // h
-    }
-}
+#include "spawn.h"
+
+#define SAMPLER_X 19
+#define SAMPLER_Y 10
+#define WIDE_X w/SAMPLER_X
+#define WIDE_Y h/SAMPLER_Y
+#define WIDE_SUM WIDE_MAX+WIDE_MIN
+#define SAFE_ZONE 200
+
+void spawn( std::vector<SDL_Rect>* obs, Uint16 nb, Uint16 w, Uint16 h )
+{
+    for ( Uint16 i(0); i < nb; i++)
+    {
+        obs->push_back( {   SAFE_ZONE + rand()%(w-SAFE_ZONE-WIDE_X),  // x
+                            rand()%(h-WIDE_Y),                        // y
+                            WIDE_X,                   // w
+                            WIDE_Y} );                // h
+    }
+}

spawn.h

@@ -1,13 +1,13 @@
-#ifndef SPAWN_H_INCLUDED
-#define SPAWN_H_INCLUDED
-
-#include <SDL.h>
-#include "Input.h"
-#include "SDL_gfxPrimitives.h"
-#include <vector>
-#include <cstdlib>
-#include <ctime>
-
-void spawn( std::vector<SDL_Rect>* obs, Uint16 nb, Uint16 w, Uint16 h );
-
-#endif // SPAWN_H_INCLUDED
+#ifndef SPAWN_H_INCLUDED
+#define SPAWN_H_INCLUDED
+
+#include <SDL/SDL.h>
+#include "Input.h"
+#include "SDL_gfxPrimitives.h"
+#include <vector>
+#include <cstdlib>
+#include <ctime>
+
+void spawn( std::vector<SDL_Rect>* obs, Uint16 nb, Uint16 w, Uint16 h );
+
+#endif // SPAWN_H_INCLUDED