Gra w życie. Warunek cyklu.

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

//klasa słóżąca do przechowywania współrzędnych punktu w macierzy 2D
struct punkt {
    int baseW;
    int baseK;
    punkt( int w, int k ) {
        baseW = w;
        baseK = k;
       
    }
    vector < punkt > generateNebers( int size ) {
        //metoda dostarczająca listę wszystkich sąsiednich punktów do punktu bazowego
        //size określa rozmiar macierzy w tym wypadku kwadratowej
        vector < punkt > punkty;
        if((( baseW - 1 ) >= 0 ) &&(( baseK - 1 ) >= 0 ) ) { //if sprawdza czy ewnentualny sąsiad nie wychodzi poza zakres <0,size>
            punkty.push_back( punkt( baseW - 1, baseK - 1 ) ); //jeśli taki sąsiad mieści się w zakresie to dodaj do listy
        }
        if(( baseW - 1 ) >= 0 ) {
            punkty.push_back( punkt( baseW - 1, baseK ) );
        }
        if((( baseW - 1 ) >= 0 ) &&(( baseK + 1 ) < size ) ) {
            punkty.push_back( punkt( baseW - 1, baseK + 1 ) );
        }
        if(( baseK - 1 ) >= 0 ) {
            punkty.push_back( punkt( baseW, baseK - 1 ) );
        }
        if((( baseK + 1 ) < size ) ) {
            punkty.push_back( punkt( baseW, baseK + 1 ) );
        }
        if((( baseW + 1 ) < size ) &&(( baseK - 1 ) >= 0 ) ) {
            punkty.push_back( punkt( baseW + 1, baseK - 1 ) );
        }
        if(( baseW + 1 ) < size ) {
            punkty.push_back( punkt( baseW + 1, baseK ) );
        }
        if((( baseW + 1 ) < size ) &&(( baseK + 1 ) < size ) ) {
            punkty.push_back( punkt( baseW + 1, baseK + 1 ) );
        }
        return punkty;
       
    }
   
};
class matrix {
    int * tab = NULL;
    int rozmiar;
    int wiersze = 0, kolumny = 0;
public:
    friend ostream & operator <<( ostream & s, matrix & m );
    friend istream & operator >>( istream & s, matrix & m );
    matrix( int w, int k )
        : wiersze( w )
         , kolumny( k )
    {
        rozmiar = w * k;
        tab = new int[ rozmiar ];
        for( int i = 0; i < rozmiar; i++ ) tab[ i ] = 0;
       
    }
    matrix() { } //konstruktor domyślny nic nie robi
    ~matrix() {
        if( tab ) {
            delete[] tab;
            tab = NULL;
        }
    }
   
   
    int & operator ()( int w, int k ) {
        return tab[ w * kolumny + k ];
    }
   
    int row() { return wiersze; }
    int column() { return kolumny; }
    matrix liveNextCycle();
    matrix & operator =( matrix && wzor ); //operator przenoszenia
    matrix( const matrix & wzor ); //konstruktor kopiujący
    matrix( matrix && wzor ); //konstruktor przenoszący
    matrix & operator =( const matrix & wzor ); //operator przypisania. Ten nie powinien się odpalić w c++11
    bool operator ==( const matrix & m );
   
};



matrix & matrix::operator =( matrix && wzor )
{
    //operator przenoszenia (prawie jak operator przypisania) ale niszczy obiekt źródłowy "wzór". Jest to optymalizacja. Nie kopiuje danych tylko wskaźniki
    //nie jest niezbędny, ale optymalizuje niektóre operacje przypisania.
    cout << "jestem operator przenoszenia" << endl;
   
    std::swap( tab, wzor.tab ); //przepisanie tylko wskaźnika na macierz bez kopiowania danych
    std::swap( wiersze, wzor.wiersze ); //przepisanie zmiennych "wiersz" oraz "kolumna"
    std::swap( kolumny, wzor.kolumny );
    std::swap( rozmiar, wzor.rozmiar );
   
    //niszczenie obiektu wzór
    return * this;
}

matrix::matrix( const matrix & wzor ) {
    //konstruktor kopiujący bywa potrzebny
    cout << "jestem konstruktor kopiujący" << endl;
    wiersze = wzor.wiersze;
    kolumny = wzor.kolumny;
    rozmiar = wzor.rozmiar;
    tab = new int[ rozmiar ];
    for( int i = 0; i < rozmiar; i++ ) { //kopiowanie bufora, oraz rezerwacja pamięci na dane. To jest to co różni konstruktor kopiujący od przenoszącego. 
        tab[ i ] = wzor.tab[ i ];
    }
}

matrix::matrix( matrix && wzor ) {
    //konstruktor przenoszący w programie nie używany
   
    cout << "jestem konstruktor przenoszący" << endl;
    std::swap( tab, wzor.tab ); //przepisanie tylko wskaźnika na macierz bez kopiowania danych
    std::swap( wiersze, wzor.wiersze ); //przepisanie zmiennych "wiersz" oraz "kolumna"
    std::swap( kolumny, wzor.kolumny );
    std::swap( rozmiar, wzor.rozmiar );
}
matrix & matrix::operator =( const matrix & wzor ) {
    //dzięki tej funkcji (operator przeciążony) możemy urzywać znaku "=" tak jak w normalnych operacjach
    cout << "jestem operator przypisania" << endl;
    wiersze = wzor.wiersze;
    kolumny = wzor.kolumny;
    rozmiar = wzor.rozmiar;
    if( tab ) delete[] tab; // zwalnianie pamięci ze starej tablicy
   
    tab = new int[ rozmiar ]; // alokacja nowej
    for( int i = 0; i < rozmiar; i++ ) { //kopiowanie bufora
        tab[ i ] = wzor.tab[ i ];
    }
    return * this;
}
bool matrix::operator ==( const matrix & m ) {
    //operator funkcja która porównuje macierze To jest klasa imitująca tablicę 2D ale dane trzyma w 1D łatwiej porównać tablice 1D
    for( int i = 0; i < rozmiar; i++ ) {
        if( m.tab[ i ] != tab[ i ] ) return false;
       
    }
    return true;
}
matrix matrix::liveNextCycle() { //wygenerowanie kolejnego cyklu życia komórek
    matrix tabPom( wiersze, kolumny ); //macierz pomocnicza do przechowywania nowego stanu
    for( int w = 0; w < wiersze; w++ ) { //przeglądanie macierzy w dwóch pętlach "w" jak wiersze "k" jak kolumny
        for( int k = 0; k < kolumny; k++ ) {
            punkt p( w, k ); //punkt który analizujemy aktualnie
            vector < punkt > listaSasiadow = p.generateNebers( wiersze ); //uzyskaj listę wszystkich sąsiadów punktu p
            int licznikZywych = 0; //licznik żywych ustawiamy na zero
            for( const punkt & pTemp: listaSasiadow ) { //pętla sprawdzająca sąsiadów. Sprawdzi każdy punkt z listy
                if(( * this )( pTemp.baseW, pTemp.baseK ) == 1 ) licznikZywych++; //jeśli sąsiad ma stan 1 to zwiększ licznik żywych
               
            }
            // jeśli aktualna komórka jest żywa
            if(( * this )( w, k ) == 1 ) {
                if(( licznikZywych == 2 ) ||( licznikZywych == 3 ) ) {
                    tabPom( w, k ) = 1;
                   
                } else {
                    tabPom( w, k ) = 0;
                }
            } else { //jeśli aktóralna komórka jest martwa
                if( licznikZywych == 3 ) tabPom( w, k ) = 1;
               
            }
           
        }
    }
    return tabPom;
   
}


//dzięki tej funkcji możemy wypisać macierz na ekran lub do pliku korzystając z zapisu
//cout<<ObjMatrix;
ostream & operator <<( ostream & s, matrix & m ) {
    for( int w = 0; w < m.wiersze; w++ ) {
        for( int k = 0; k < m.kolumny; k++ ) {
            s << m( w, k ) << " ";
            // s (strumień). Może to być np "cout"(na ekran); lub plik
            // m(1,3)   //elemetn macierzy zapis działa jak zapis  "tablica[1][3]"
        }
        s << endl;
    }
    return s;
}

//dzięki tej funkcji możemy wczytać z pliku żywe komórki, Korzystając zapisu:
//plik>>objMatrix;
istream & operator >>( istream & s, matrix & m ) {
    //zerowanie macierzy
    for( int w = 0; w < m.wiersze; w++ ) {
        for( int k = 0; k < m.kolumny; k++ ) {
            m( w, k ) = 0; //wypełni tablice zerami
        }
    }
    int w, k;
    while( s >> w >> k ) {
        //wczytuj parę współrzędnych, w(wiersz),k(kolumna) ze strumienia (np z pliku)
        m( w, k ) = 1; //ustaw pole macierzy o wierszu=w i kolumnie=k na jeden;
    }
    return s;
}


// Program właściwy użycie klasy matrix;

#include<fstream>
#include<list>
bool czyByla( matrix & tab, list < matrix > & kolejka ) { //funkcja sprawdza czy tablica "tab" jest gdzieś zapamiętana w kolejce
    for( matrix & element: kolejka ) { //iterujemy całą kojkę po wszystkich jej elementach
        if( element == tab ) return true; // Porównuje element z kolejki z tablica"tab". Znalezienie tablicy "tab" w kolejce, kończy porównanie wynikiem true;
        //ponieważ klasę "matrix" wyposażyliśmy w operator "==" więc potrafi ona porównać dwa obiekty tej klasy.
        //dlatego możemy napisać (element==tab) tak samo jakby to były zwykłe zmienne typu wbudowanego(np typu int ).
    }
    return false;
}
int main() {
    fstream plik( "dane.txt" ); //plik z twoimi komórkami
    matrix tablica( 10, 10 ); //deklaracja macierzy 10X10
    plik >> tablica; //wczytanie komórek z pliku do tablicy
    cout << tablica << endl; //wypisanie tablicy na ekran
    list < matrix > kolejka; //kontener na tablice masz pamiętać 10 tablic
    kolejka.push_front( tablica ); //bazową tablicę zapisujemy do kolejki na początek
    for( int i = 0; i < 50; i++ ) { // 50 pokoleń
        tablica = tablica.liveNextCycle(); //kolejny cykl życia. Tutaj jako "=" działa operator przenoszenia
        //funkcja "liveNextCycle()" zwraca obiekt tymczasowy, który można zniszczyć. Kompilator jak może korzysta z szybszego operatora
        cout << tablica << endl; //wyświetlamy tablicę
        if( czyByla( tablica, kolejka ) ) break; //sprawdzamy czy tablica znajduje się w kolejce.  Koniec pętli tablica wystąpiła;
       
        kolejka.push_front( tablica ); //odkładam na kolejkę działa konstruktor kopiujący. Obiekt "tablica" jest w pełni użyteczny
        //kolejka.push_front(std::move(tablica)); //działał by konstruktor przenoszący. Szybszy ale obiekt tablica byłby zniszczony nie do użytku
        if( kolejka.size() > 10 ) kolejka.pop_back(); //jeśli rozmiar kolejki >10 usuwam ostatni element ; potrzebujesz pamiętać tylko 10
       
    }
}

#include <iostream>
#include <fstream>
#include <Windows.h>
#include <cstdlib>
#define TABSIZE1 10
#define TABSIZE2 10
#define CYKLE 10
using namespace std;

short czy_rozne( short tab[][ TABSIZE1 ][ TABSIZE2 ], short pokolenie, short cykl )
{
    short ile_razy_spr; //ile trzeba porownac
    //short sa_rozne=0; //zakladamy ze sa rowne
   
    short tab_pom2[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ] = { 0 };
   
    if( pokolenie < CYKLE )
         ile_razy_spr = pokolenie;
    else
         ile_razy_spr = CYKLE;
   
    for( short i = 0; i < ile_razy_spr; i++ )
    {
        if( i == cykl )
             continue;
       
        for( short j = 0; j < TABSIZE1; j++ )
        for( short k = 0; k < TABSIZE2; k++ )
        {
            if( tab[ cykl ][ j ][ k ] != tab[ i ][ j ][ k ] )
                 tab_pom2[ i ][ j ][ k ] = 1;
           
        }
    }
    if( tab_pom2 != 0 )
         return 0;
   
}

short pozycjax( short wspolrzedna ) { //ustala wspolrzedne x sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE1 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE1 - 1;
   
    if( wspolrzedna >= TABSIZE1 ) return 0;
   
}

short pozycjay( short wspolrzedna ) { //ustala wspolrzedne y sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE2 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE2 - 1;
   
    if( wspolrzedna >= TABSIZE2 ) return 0;
   
}

short nowa_tablica( short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle, short x, short y ) // ustala kolejny stan
{
    int l_zywych_sasiadow = 0;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ x ][ y ] == 1 ) // jesli komorka byla zywa
    {
        if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
             return 1;
        else
             return 0;
       
    }
    else //(komorka==0)
    if( l_zywych_sasiadow == 3 )
         return 1;
   
}

void wyswietl( short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle ) //wyswietla tablice dla poszczegolnego cyklu
{
    for( short i = 0; i < TABSIZE1; i++ )
    {
        for( short j = 0; j < TABSIZE2; j++ )
             cout << tab[ cykle ][ i ][ j ] << " ";
       
        cout << endl;
    }
}

int main( int argc, char * argv[] )

{
    short pokolenie = 1;
    short ile_pokolen = 50; //ile chcemy wyswietlac max
    short l_zywych_sasiadow;
    short x;
    short y;
    short cykle = pokolenie % 10;
    short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ] = { 0 };
    short tab_pom[ TABSIZE1 ][ TABSIZE2 ]; //tablica pomocnicza (do spr sasiadow prawidlowo)
    ifstream plik;
   
    //plik.open("zywe.txt");
    if( argc > 1 ) {
        string parametr;
        parametr = argv[ 1 ];
        plik.open( argv[ 1 ] );
    }
    else
         cout << "Nie podano wlasciwego parametru!";
   
   
    if( !plik.good() )
    {
        cout << "Nie udalo sie otworzyc pliku!";
        return 0;
    }
   
    while( !plik.eof() ) //spawdzanie do konca pliku
    {
        plik >> x;
        plik >> y;
        tab[ cykle ][ x ][ y ] = 1; // tablica po wczytaniu zyjacych komorek z pliku
    }
   
    plik.close();
   
    ///////
   
    do
    {
        wyswietl( tab, cykle );
        cout << endl << "Pokolenie nr " << pokolenie << endl;
        cout << endl;
        pokolenie++;
        //Sleep(1500);
        //system("cls");
        cout << endl << "cykl nr " << cykle << endl;
       
        for( short x = 0; x < TABSIZE1; x++ ) //wyznaczanie kolejngo stanu
        {
            for( short y = 0; y < TABSIZE2; y++ )
            {
                if( nowa_tablica( tab, cykle, x, y ) == 1 )
                {
                    tab_pom[ x ][ y ] = 1;
                }
                else
                {
                    tab_pom[ x ][ y ] = 0;
                }
            }
        }
        if( pokolenie < 10 )
             cykle = pokolenie;
        else
             cykle = pokolenie % 10;
       
        for( short x = 0; x < TABSIZE1; x++ )
        for( short y = 0; y < TABSIZE2; y++ )
             tab[ cykle ][ x ][ y ] = tab_pom[ x ][ y ];
       
    } while((( czy_rozne( tab, pokolenie, cykle ) ) == 0 ) &&( pokolenie <= ile_pokolen ) );
   
    system( "pause" );
    return 0;
}

#include <iostream>
#include <fstream>
#include <cstdlib>
#define TABSIZE1 10
#define TABSIZE2 10
#define CYKLE 10
using namespace std;

short czyByla( short tab[ 10 ][ TABSIZE1 ][ TABSIZE2 ], short pokolenie )
{
    short ile_razy_spr; //ile trzeba porownac
    //short sa_rozne=0; //zakladamy ze sa rowne
   
    if( pokolenie < CYKLE )
         ile_razy_spr = pokolenie;
    else
         ile_razy_spr = CYKLE;
   
    for( short i = 0; i < ile_razy_spr; i++ )
    {
        if( i == pokolenie % 10 )
             continue;
       
        int counter = 0;
        for( short j = 0; j < TABSIZE1; j++ ) {
            for( short k = 0; k < TABSIZE2; k++ ) {
                if( tab[ pokolenie % 10 ][ j ][ k ] == tab[ i ][ j ][ k ] ) {
                    counter++;
                }
               
            }
           
        }
        if( counter == 100 ) return true; //znalazłem tablice w której wszystkie 100 elementów jest zgodne
       
    }
    return false;
}

short pozycjax( short wspolrzedna ) { //ustala wspolrzedne x sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE1 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE1 - 1;
   
    if( wspolrzedna >= TABSIZE1 ) return 0;
   
}

short pozycjay( short wspolrzedna ) { //ustala wspolrzedne y sasiadow z uwzglednieniem krancow tablicy
    if( wspolrzedna >= 0 || wspolrzedna < TABSIZE2 ) return wspolrzedna;
   
    if( wspolrzedna <= - 1 ) return TABSIZE2 - 1;
   
    if( wspolrzedna >= TABSIZE2 ) return 0;
   
}

short nowa_tablica( short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle, short x, short y ) // ustala kolejny stan
{
    int l_zywych_sasiadow = 0;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x - 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y - 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ pozycjax( x + 1 ) ][ pozycjay( y + 1 ) ] == 1 ) l_zywych_sasiadow++;
   
    if( tab[ cykle ][ x ][ y ] == 1 ) // jesli komorka byla zywa
    {
        if( l_zywych_sasiadow == 2 || l_zywych_sasiadow == 3 )
             return 1;
        else
             return 0;
       
    }
    else //(komorka==0)
    if( l_zywych_sasiadow == 3 )
         return 1;
   
}

void wyswietl( short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ], short cykle ) //wyswietla tablice dla poszczegolnego cyklu
{
    for( short i = 0; i < TABSIZE1; i++ )
    {
        for( short j = 0; j < TABSIZE2; j++ )
             cout << tab[ cykle ][ i ][ j ] << " ";
       
        cout << endl;
    }
}

int main( int argc, char * argv[] )

{
    short pokolenie = 0;
    short ile_pokolen = 50; //ile chcemy wyswietlac max
    short x;
    short y;
    short cykle = pokolenie % 10;
    short tab[ CYKLE ][ TABSIZE1 ][ TABSIZE2 ] = { 0 };
    short tab_pom[ TABSIZE1 ][ TABSIZE2 ]; //tablica pomocnicza (do spr sasiadow prawidlowo)
    ifstream plik;
   
    plik.open( "dane.txt" );
   
   
   
    if( !plik.good() )
    {
        cout << "Nie udalo sie otworzyc pliku!";
        return 0;
    }
   
    while( !plik.eof() ) //spawdzanie do konca pliku
    {
        plik >> x;
        plik >> y;
        tab[ cykle ][ x ][ y ] = 1; // tablica po wczytaniu zyjacych komorek z pliku
    }
    wyswietl( tab, cykle );
   
    plik.close();
   
    ///////
   
    do
    {
       
        cout << endl << "Pokolenie nr " << pokolenie << endl;
        cout << endl;
        //Sleep(1500);
        //system("cls");
        cout << endl << "cykl nr " << cykle << endl;
       
        for( short x = 0; x < TABSIZE1; x++ ) //wyznaczanie kolejngo stanu
        {
            for( short y = 0; y < TABSIZE2; y++ )
            {
                if( nowa_tablica( tab, pokolenie % 10, x, y ) == 1 )
                {
                    tab_pom[ x ][ y ] = 1;
                }
                else
                {
                    tab_pom[ x ][ y ] = 0;
                }
            }
        }
        pokolenie++;
        for( short x = 0; x < TABSIZE1; x++ )
        for( short y = 0; y < TABSIZE2; y++ )
             tab[ pokolenie % 10 ][ x ][ y ] = tab_pom[ x ][ y ];
       
        wyswietl( tab, pokolenie % 10 );
        if( czyByla( tab, pokolenie ) ) break;
       
    } while( pokolenie <= ile_pokolen );
   
    system( "pause" );
    return 0;
}