[SFML] Kolizja i co potem?

#include <SFML/Graphics.hpp>
#include <list>
// Klasa, która reprezentuje kwadrat, zdolny do
// zmiany koloru w zależności od stanu kolzji.
class CRect
{
    sf::Color Color;
    sf::RectangleShape Rect;
public:
    CRect( sf::Vector2f size, sf::Color col, sf::Vector2f Pos )
        : Rect( size )
        , Color( col )
    {
        Rect.setFillColor( Color );
        Rect.setPosition( Pos );
    }
    sf::FloatRect GetRectToColide()
    {
        return Rect.getGlobalBounds();
    }
    void SetPosition( float x, float y )
    {
        Rect.setPosition( x, y );
    }
    // Zmiana koloru na kolor kolizyjny
    void SetColide()
    {
        Rect.setFillColor( sf::Color::Red );
    }
    // Zmiana koloru na wlasny
    void SetFree()
    {
        Rect.setFillColor( Color );
    }
    void Draw( sf::RenderWindow & app )
    {
        app.draw( Rect );
    }
};

// Klasa, która obsłuugje rysowanie wszystkich dodanych do niej kwadratów
class CRectList
{
public:
    // Aby nie komplikować przykładu z pobieraniem listy itd,
    // tutaj zmienna będzie wyjątkowo publiczna
    std::list < CRect * > Items;
   
    void Add( CRect * rect )
    {
        Items.push_back( rect );
    }
    ~CRectList()
    {
        // jakieś tam zwolnieine zasoboów
    }
    void Draw( sf::RenderWindow & app )
    {
        std::list < CRect * >::iterator it = Items.begin();
        while( it != Items.end() )
        {
            ( * it )->Draw( app );
            it++;
        }
    }
};
// Klasa obsługująca gracza
class CPlayer
{
    sf::RectangleShape Rect;
public:
    CPlayer( const sf::Vector2f & vec )
        : Rect( vec )
    {
        Rect.setFillColor( sf::Color::Yellow );
        Rect.setPosition( 400, 300 );
    }
    sf::FloatRect GetRectToColide()
    {
        return Rect.getGlobalBounds();
    }
    void Move( sf::Vector2f Vec )
    {
        Rect.move( Vec );
    }
    // Funckja zwracająca teoretyczny ruch
    sf::Vector2f Move( float time )
    {
        sf::Vector2f vec;
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::W ) )
        {
            vec.y -= 1;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::S ) )
        {
            vec.y += 1;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::A ) )
        {
            vec.x -= 1;
        }
        if( sf::Keyboard::isKeyPressed( sf::Keyboard::D ) )
        {
            vec.x += 1;
        }
        // mnożenie przez 200 jest dlatego, żeby obiekt sie nie ślimaczył
        return sf::Vector2f( vec.x * 200 * time, vec.y * 200 * time );
    }
    void Draw( sf::RenderWindow & app )
    {
        app.draw( Rect );
    }
};
class CColider
{
public:
    static bool IsCol( sf::FloatRect c1, sf::FloatRect c2 )
    {
        if( c1.left + c1.width >= c2.left )
        if( c1.left <= c2.left + c2.width )
        if( c1.top + c1.height >= c2.top )
        if( c1.top <= c2.top + c2.height )
             return true;
       
        return false;
    }
    static void Colide( CPlayer & pl, sf::Vector2f Move, CRectList & List )
    {
        sf::FloatRect tmp = pl.GetRectToColide();
        tmp.left += Move.x;
        sf::FloatRect tmp2 = pl.GetRectToColide();
        tmp2.top += Move.y;
       
        std::list < CRect * >::iterator it = List.Items.begin();
        bool Colided1 = false;
        bool Colided2 = false;
        while( it != List.Items.end() )
        {
            if( IsCol( tmp,( * it )->GetRectToColide() ) )
            {
                ( * it )->SetColide();
                // 1
                Colided1 = true;
            }
            else if( IsCol( tmp2,( * it )->GetRectToColide() ) )
            {
                ( * it )->SetColide();
                // 2
                Colided2 = true;
            }
            else
            {
                ( * it )->SetFree();
            }
           
            it++;
        }
       
        // W zależności od ilości FPS może zacząć się pojawiać przerwa
        // mniejsza bądź większa, między klockami. Jeżeli nie będą to
        // kwadraty a jakieś sprity to problem będzie niewidoczny.
        // Jeżeli zależy komuś na dokładności, to wtedy trzeba by
        // w punktach 1 i 2 obliczać odległość obiektu od miejsca kolizji
        // i pamiętać najmniejszą z tych odległości, a potem o tą najmniejszą
        // (zamiast pełnego ruchu) przesunąć obiekt. Mamy wtedy pewność,
        // że taki obiekt nie będzie kolidował.
       
        // Niewielkim kosztem można również zrobić aby gracz napierając na
        // ścianę, zamiast stać w miejscu to aby przesuwał się w którąś stronę
        if( !Colided1 )
             pl.Move( sf::Vector2f( Move.x, 0 ) );
       
        if( !Colided2 )
             pl.Move( sf::Vector2f( 0, Move.y ) );
       
    }
};

int main()
{
    sf::RenderWindow App( sf::VideoMode( 800, 600 ), "SFML works!" );
    sf::Clock Clock;
    float time = 0;
    CPlayer Player( sf::Vector2f( 50.f, 50.f ) );
    CRectList RList;
    RList.Add( new CRect( sf::Vector2f( 50, 50 ), sf::Color::Blue, sf::Vector2f( 150, 70 ) ) );
    RList.Add( new CRect( sf::Vector2f( 50, 50 ), sf::Color::Green, sf::Vector2f( 150, 120 ) ) );
    RList.Add( new CRect( sf::Vector2f( 50, 50 ), sf::Color::White, sf::Vector2f( 150, 170 ) ) );
    RList.Add( new CRect( sf::Vector2f( 50, 50 ), sf::Color::Cyan, sf::Vector2f( 130, 220 ) ) );
    RList.Add( new CRect( sf::Vector2f( 50, 50 ), sf::Color::Magenta, sf::Vector2f( 230, 150 ) ) );
    RList.Add( new CRect( sf::Vector2f( 50, 50 ), sf::Color::Magenta, sf::Vector2f( 340, 150 ) ) );
    while( App.isOpen() )
    {
        sf::Event event;
        while( App.pollEvent( event ) )
        {
            if( event.type == sf::Event::Closed )
                 App.close();
           
        }
       
        App.clear();
       
        // Logic
        CColider::Colide( Player, Player.Move( time ), RList );
       
        // Drawing
        RList.Draw( App );
        Player.Draw( App );
        App.display();
        // Frametime
        time = Clock.restart().asSeconds();
    }
   
    return 0;
}