Gra w Życie

Witam, mam problem z warunkami brzegowymi w grze w życie. Chciałbym, aby komórki brzegowe były połączone z przeciwległymi, coś jak w grze snake. Ma ktoś jakiś pomysł?

public void step(){
        System.out.println("Jeden krok");
        boolean[][] nowaSiatka = new boolean[WIDTH][HEIGHT];
        for (int x = 0; x < siatka.length; x++){
            for (int y = 0; y < siatka.length; y++){
                int licznikSasiadow = 0;              //sprawdzanie sasiadów
                if (y > 0 && siatka[x][y-1] == true){ //dol
                    licznikSasiadow++;
                }
                if (y < WIDTH - 1 && siatka[x][y+1] == true){ //gora
                    licznikSasiadow++;
                }
                if (x > 0 && siatka[x-1][y] == true) { //lewo
                    licznikSasiadow++;
                }
                if (x < HEIGHT - 1 && siatka[x+1][y] == true){ //prawo
                    licznikSasiadow++;
                }
                if (x < HEIGHT - 1 && y > 0 && siatka[x+1][y-1] == true){ //prawo dol
                    licznikSasiadow++;
                }
                if (x < HEIGHT - 1 && y < WIDTH - 1 && siatka[x+1][y+1] == true){ //prawo gora               
                    licznikSasiadow++;
                }
                if (x > 0 && y > 0 && siatka[x-1][y-1] == true){ //lewo dol
                    licznikSasiadow++;
                }
                if (x > 0 && y < WIDTH - 1 && siatka[x-1][y+1] == true){ //lewo gora
                    licznikSasiadow++;
                }     

                //Zasady Gra w Zycie
                if (siatka[x][y] == true) { //jezeli sa zywi
                    if (licznikSasiadow == 2 || licznikSasiadow == 3) { //jezeli dwoch lub trzech sasiadow
                        nowaSiatka[x][y] = true; //przezyja w kolejnym kroku  
                    }
                    else { 
                        nowaSiatka[x][y] = false; //umra w kolejnym kroku
                    }
                }
                //wiecej zasad smierci
                else { 
                    if (licznikSasiadow == 3){                
                        nowaSiatka[x][y] = true;
                        } 
                }
}

Eh, po prostu daj to(dla tablicy 8x8):

 if (x < HEIGHT - 1 && siatka[x-7][y] == true){// dla prawo
                    licznikSasiadow++;
}

 if (x < HEIGHT - 1 && siatka[x+7][y] == true){// dla lewo
                    licznikSasiadow++;
}

itd.

Ja swojego czasu, pisząc w C#, dla każdej komórki wywoływałem taką funkcję:

public int CountNeighbours(int col, int row)
{
	int x, y;
    int alives = 0;
	for (int r = -1; r <= 1; r++)
	{
		for (int c = -1; c <= 1; c++)
		{
			if (!(r == 0 && c == 0))
			{
				x = col + c;
				y = row + r;
				
				if (x < 0)
					x = maxCols;
				else if (x > maxCols)
					x = 0;
				
				if (y < 0)
					y = maxRows;
				else if (y > maxRows)
					y = 0;

				if (Board[x,y] == 1)
					alives++;
			}
		}
	}
	return alives;
}

Działało bez pudła.

Co do Twojego kodu - nie wstawiaj na sztywno if (licznikSasiadow == 2 || licznikSasiadow == 3), bo fajnie można się pobawić automatami komórkowymi właśnie zmieniając te reguły. Ja miałem dwie tablice - jedną przechowującą te liczby z zakresu 0-8, które dają przeżycie komórce żywej, a drugą zawierającą zasady dotyczące wskrzeszania martwych komórek.

@D3vVv, zrobiłem to Twoim sposobem, ale coś nie hasa :( Zrobiłem to statycznie. Zmieniłem znak w:

x < HEIGHT - 1

, ponieważ wydaje mi się, że te zmiany powinny zachodzić na 0 (bo pętla od tej wartości się zaczyna) i na 19, bo tablica ma wielkość 20x20.

                ////////////////////////////////////////////////////////////////////////
 if (y == 19 && siatka[x][y-19] == true){ //dol
                    licznikSasiadow++;
                }
                if (y == 0 && siatka[x][y+19] == true){ //gora
                    licznikSasiadow++;
                }
                if (x == 0 && siatka[x+19][y] == true) { //lewo
                    licznikSasiadow++;
                }
                if (x == 19 && siatka[x-19][y] == true){ //prawo
                    licznikSasiadow++;
                }
                if (x == 19 && y == 19 && siatka[x-19][y] == true){ //prawo dol
                    licznikSasiadow++;
                }
                if (x == 19 && y == 0 && siatka[x-19][y] == true){ //prawo gora               
                    licznikSasiadow++;
                }
                if (x == 0 && y == 19  && siatka[x+19][y] == true){ //lewo dol
                    licznikSasiadow++;
                }
                if (x == 0 && y == 0 && siatka[x+19][y] == true){ //lewo gora
                    licznikSasiadow++;
                }     

Nie mogłeś od razu powiedzieć, że tablica jest 20x20 standardowo jest 8x8

Pierwszy kod był dobry teraz to już kombinujesz.

 if (x == 0 && siatka[x+19][y] == true) //lewo max
         licznikSasiadow++;
 if (x > 0 && siatka[x-1][y] == true) //lewo zwykłe
         licznikSasiadow++;

Zresztą spróbuj zrobić to z kodu @Bateria