[C++ obiektowo][SFML 1.6][SFML 2.5] Przetłumaczenie kodu na najnowszy język sfmla.

#include "Plansza.h"
#include "Runda.h"

// ready to sfml :)
#include <iostream>
#include <string>

#include<SFML\Graphics.hpp>
#include<SFML\Window.hpp>
#include<SFML\System.hpp>

using namespace std;

int main()
{
   
   
    unsigned int antialias = 8;
    sf::RenderWindow Gra( sf::VideoMode::GetMode( 0 ), "4 w Rzędzie", sf::Style::Resize | sf::Style::Close,
    sf::WindowSettings::WindowSettings( 24, 8, antialias ) );
   
   
   
    //FPS - by dzialalo na zlomie
    Gra.SetFramerateLimit( 30 );
   
    // powstawanie planszy
    PLANSZA plansza( Gra );
   
    //stworzenie rundki gierki
    RUNDA runda( plansza );
   
    // odpalenie okienka
    while( Gra.IsOpened() )
    {
        // czas na wydarzenia
        sf::Event wydarzenie;
        while( Gra.GetEvent( wydarzenie ) )
        {
            // jak zamkniesz okienko
            if( wydarzenie.Type == sf::Event::Closed )
                 Gra.Close();
            else if( wydarzenie.Type == wydarzenie.MouseButtonReleased && wydarzenie.MouseButton.Button == sf::Mouse::Left )
                 runda.wloz_do_kolumny( Gra.GetInput() );
           
        }
       
       
       
        // czyszczenie planszy
        Gra.Clear( plansza.Kolor_planszy );
       
        //narysuj plansze ze zmianami
        plansza.rysowanie();
       
        // pokaz zmiany
        Gra.Display();
    }
   
    return EXIT_SUCCESS;
}

#ifndef PLANSZA_H_
#define PLANSZA_H_

#include<SFML\Graphics.hpp>
#include<SFML\Audio.hpp>

#include <iostream>

#define Wiersze 6
#define Kolumny 7

enum Zeton
{
    Pusty,
    Czerwony,
    Niebieski,
};

enum Kontur
{
    Normalny,
    Podkreslony
};

enum Ruch
{
    Polozenie,
    Pelny,
    KoniecGry
};

class PLANSZA {
   
public:
    PLANSZA( sf::RenderWindow & App );
    PLANSZA();
   
    ~PLANSZA();
   
    void restart(); //ponowna gra
    void rysowanie(); //powstawanie zetonow na planszy
   
    Ruch dodaj_do_kolumny( unsigned int k, Zeton kolorGracza );
   
    int rozdz_okna(); // domyslne ust wielkosci okna
   
    sf::Color Kolor_planszy;
   
private:
    bool jestKoniecGry( const unsigned int y, const unsigned int x );
    bool SprawdzPoziom( const unsigned int y, const unsigned int x );
    bool SprawdzPion( const unsigned int y, const unsigned int x );
    bool SprawdzUkos( const unsigned int y, const unsigned int x );
   
    //plansza
    Zeton plansza[ Wiersze + 2 ][ Kolumny + 2 ];
   
    Kontur kontur_Planszy[ Wiersze + 2 ][ Kolumny + 2 ];
   
    // okienko gdzie bedzie plansza
    sf::RenderWindow & okno;
   
    // kolory na planszy
    sf::Color CzerwonyKolor;
    sf::Color NiebieskiKolor;
    sf::Color PustyKolor;
    sf::Color LiniaKolor;
    sf::Color PodkreslonyKolor;
   
    // ustawnienia dla zetonu
    float wys_okna;
    float szer_okna;
    // wielkosc konturu
    float kontur;
    // promien zetonu
    float zasieg;
    // odstepy
    float przestrzen_w, przestrzen_k;
};
#endif

#include "Plansza.h"
#include "Runda.h"

#include <string>
#include<iostream>
using namespace std;


PLANSZA::PLANSZA( sf::RenderWindow & App )
    : okno( App ) // konstruktor, tworzace plansze
{
    // kolory planszy
    Kolor_planszy = sf::Color::Color( 255, 255, 157 );
    CzerwonyKolor = sf::Color::Color( 214, 71, 0 );
    NiebieskiKolor = sf::Color::Color( 23, 125, 208 );
    PustyKolor = sf::Color::Color( 224, 224, 224 );
    LiniaKolor = sf::Color::Color( 232, 232, 0 );
    PodkreslonyKolor = sf::Color::Color( 19, 240, 57 );
   
    //by miec zetony dobrze wyskalowane z plansza
   
    wys_okna = okno.GetHeight();
    szer_okna = okno.GetWidth();
    //zachowanie proporcji dla skalowania oknem
    if( wys_okna < szer_okna )
    {
        zasieg = wys_okna /( Wiersze * 2.0 );
       
        // odstepy miedzy wierszami
       
        przestrzen_w = 1.0 / 2.0 * zasieg;
       
        // ustalenie polozenia konturow
        kontur = 1.0 / 15.0 * zasieg;
       
        zasieg = zasieg - przestrzen_w / 2.0 - kontur;
       
        //kolumny
        przestrzen_k =( szer_okna -( Kolumny * 2.0 ) * zasieg ) /( Kolumny + 1.0 );
       
    }
    else
    {
        zasieg = szer_okna /( Kolumny * 2.0 );
       
        przestrzen_k = 1.0 / 2.0 * zasieg;
       
        kontur = 1.0 / 15.0 * zasieg;
       
        zasieg = zasieg - przestrzen_k / 2.0 - kontur;
       
        przestrzen_k =( szer_okna -( Wiersze * 2.0 ) * zasieg ) /( Wiersze + 1.0 );
    }
   
    //czyszczenie planszy
    restart();
}


PLANSZA::~PLANSZA() // destruktor
{
}

void PLANSZA::restart()
{
    // z zetonow na pola puste :)
   
    for( int y = 0; y < Wiersze + 1; y++ )
    {
        for( int x = 0; x < Kolumny + 1; x++ )
        {
            plansza[ y ][ x ] = Pusty; // wypelnienie pustym kolorem
            kontur_Planszy[ y ][ x ] = Normalny; // bez podkreslenia
        }
    }
   
}

void PLANSZA::rysowanie()
{
    for( int y = 1; y <= Wiersze; y++ )
    {
        // centrowanie wierszy
        float srodek_wierszy =( przestrzen_w + zasieg ) * y + zasieg *( y - 1 );
        for( int x = 1; x <= Kolumny; x++ )
        {
            // centrowanie kolumn
            float srodek_kolumn =( przestrzen_k + zasieg ) * x + zasieg *( x - 1 );
            // Kolory kolka
            sf::Color wypelniacz;
            if( plansza[ y ][ x ] == Pusty )
                 wypelniacz = PustyKolor;
            else if( plansza[ y ][ x ] == Czerwony )
                 wypelniacz = CzerwonyKolor;
            else
                 wypelniacz = NiebieskiKolor;
            // Kontury kolka
            sf::Color Kolor_krawedzie;
            if( kontur_Planszy[ y ][ x ] == Podkreslony )
                 Kolor_krawedzie = PodkreslonyKolor;
            else
                 Kolor_krawedzie = LiniaKolor;
            // rysowanie w oknie kolka
           
            okno.Draw( sf::Shape::Circle( przestrzen_w, przestrzen_k, zasieg,
            wypelniacz, kontur, Kolor_krawedzie ) );
        }
    }
}

Ruch PLANSZA::dodaj_do_kolumny( unsigned int kolumna, Zeton kolorGracza )
{
    // szukanie pustych
    for( int i = Wiersze; i > 0; i-- )
    {
        //dodaj zeton gracza jesli w kolumnie jest pusto
        if( plansza[ i ][ kolumna ] == Pusty )
        {
            plansza[ i ][ kolumna ] = kolorGracza;
            //Czy ktos juz wygral??
            if( jestKoniecGry( i, kolumna ) )
                 return KoniecGry;
            else
                 return Polozenie;
           
        }
    }
    //jak nic z powyzszych to kolumna jest pelna
    return Pelny;
}

bool PLANSZA::jestKoniecGry( const unsigned int y, const unsigned int x )
{
    // zakreslanie 4 w rzedzie i ich poprawne warunki do szczescia
   
   
    bool t = false;
    t |= SprawdzPoziom( y, x );
    t |= SprawdzPion( y, x );
    t |= SprawdzUkos( y, x );
    return t;
}

bool PLANSZA::SprawdzPoziom( const unsigned int y, const unsigned int x )
{
    // szukanie 4 w poziomie dla danego koloru
   
    Zeton kolor_Zetonu = plansza[ y ][ x ];
    int l = 1, i;
    // szukanie na prawo
    for( i = x + 1; plansza[ y ][ i ] == kolor_Zetonu; i++ )
         l++;
    // szukanie na lewo
    for( i = x - 1; plansza[ y ][ i ] == kolor_Zetonu; i-- )
         l++;
    // Podkreslenie jak znajdzie
    if( l >= 4 )
    {
        while( plansza[ y ][ ++i ] == kolor_Zetonu )
             kontur_Planszy[ y ][ i ] = Podkreslony;
       
        return true;
    }
    else
         return false;
   
}

bool PLANSZA::SprawdzPion( const unsigned int y, const unsigned int x )
{
    // szukanie 4 w pionie
   
    Zeton kolor_Zetonu = plansza[ y ][ x ];
    int l = 1, i;
    // szuka dol
    for( i = y + 1; plansza[ i ][ x ] == kolor_Zetonu; i++ )
         l++;
    // od gory szuka
    for( i = y - 1; plansza[ i ][ x ] == kolor_Zetonu; i-- )
         l++;
    // podkreslenie znalezionego
    if( l >= 4 )
    {
        while( plansza[ ++i ][ x ] == kolor_Zetonu )
             kontur_Planszy[ i ][ x ] = Podkreslony;
       
        return true;
    }
    else
         return false;
   
}
bool PLANSZA::SprawdzUkos( const unsigned int y, const unsigned int x )
{
    // szuka po skosach
    Zeton kolor_Zetonu = plansza[ y ][ x ];
    bool t = false;
    int cnt = 1, i, j;
    // lewy dol
    for( i = y + 1, j = x - 1; plansza[ i ][ j ] == kolor_Zetonu; i++, j-- )
         cnt++;
    // prawa gora
    for( i = y - 1, j = x + 1; plansza[ i ][ j ] == kolor_Zetonu; i--, j++ )
         cnt++;
    // podkreslenie wygranej kombi
    if( cnt >= 4 )
    {
        while( plansza[ ++i ][ --j ] == kolor_Zetonu )
             kontur_Planszy[ i ][ j ] = Podkreslony;
       
        t = true;
    }
    cnt = 1;
    // prawy dol
    for( i = y + 1, j = x + 1; plansza[ i ][ j ] == kolor_Zetonu; i++, j++ )
         cnt++;
    // lewa gora
    for( i = y - 1, j = x - 1; plansza[ i ][ j ] == kolor_Zetonu; i--, j-- )
         cnt++;
    // podkreslenie
    if( cnt >= 4 )
    {
        while( plansza[ ++i ][ ++j ] == kolor_Zetonu )
             kontur_Planszy[ i ][ j ] = Podkreslony;
       
        return true;
    }
    else
         return t;
   
}

int PLANSZA::rozdz_okna()
{
    return okno.GetWidth();
}

#include "Runda.h"
#include "Plansza.h"


RUNDA::RUNDA( PLANSZA & Refer )
    : plansza( Refer )
{
    // zerowa tura
    Tury = 0;
    // Startuje gracz czerwony
    nast_Gracz = Czerwony;
}

RUNDA::~RUNDA() { }

void RUNDA::ustalenieTury()
{
    Tury = Tury + 1;
}

int RUNDA::nrTury()
{
    return Tury;
}
RUNDA RUNDA::operator +( const RUNDA & other ) {
    this->Tury = Tury + other.Tury;
    //return Tury;
}
RUNDA RUNDA::operator =( const RUNDA & other ) {
    this->Tury = other.Tury;
    //return Tury;
}


void RUNDA::wloz_do_kolumny( const sf::Input & klik )
{
   
   
    // Kolumny wybierane na klik
    kolumna = float( klik.GetMouseX() ) / plansza.rozdz_okna() * Kolumny + 1;
    //Koniec gry -> nowa gra
    if( stanGry == KoniecGry )
    {
        plansza.restart();
        Tury = 0;
        stanGry = Pelny;
    }
    else
    {
        // polozenie do wybranej kolumny
        stanGry = plansza.dodaj_do_kolumny( kolumna, nast_Gracz );
        // jak kolumna niepelna to dalej
        if( stanGry != Pelny )
        {
            Tury++;
            // nastepna tura
            if( nast_Gracz == Czerwony )
                 nast_Gracz = Niebieski;
            else
                 nast_Gracz = Czerwony;
            // jak plansza pelna jest kolorkow - koniec giereczki
            if( Tury == Kolumny * Wiersze )
                 stanGry = KoniecGry;
           
        }
    }
}