Gra w życie – implementacja Java

Mateusz M. 13/02/2013

🕑 2 minuty czytania

Cześć! Cieszę się, że mnie odwiedziłeś/aś. Zanim przejdziesz do artykułu chciałbym zwrocić Ci uwagę na to, że ten artykuł był pisany kilka lat temu (2013-02-13) miej więc proszę na uwadzę że rozwiązania i przemyślenia które tu znajdziesz nie muszą być aktualne. Niemniej jednak zachęcam do przeczytania.

Gra w Życie to gra, w której, hmm.. Obserwujemy życie komórek. Nie maja one zbyt dużo do zaoferowania, gdyż mogą być tylko martwe lub żywe. Cała akcja toczy się na dwuwymiarowej.. Tablicy :P
Ta gra to jeden z pierwszych i najbardziej znanych przykładów automatu komórkowego, wymyślony w roku 1970 przez brytyjskiego matematyka Johna Conwaya.
Reguły gry są proste:

Martwa komórka, która ma dokładnie 3 żywych sąsiadów, staje się żywa w następnej jednostce czasu (rodzi się)
Żywa komórka z 2 albo 3 żywymi sąsiadami pozostaje nadal żywa; przy innej liczbie sąsiadów umiera (z „samotności” albo „zatłoczenia”).

Może przed kodem, pokaż jak to wygląda. Jako stan poczatkowy zaimplementowałem prostokąt, który w następnych populacjach tworzy ładne wzory:)

No i jak wygląda kilka kolejnych populacji:

I jeszcze kilka kolejnych:

Samo wywołanie klasy którą za chwile przedstawię jest dość proste:

1
2
3
4
5
6
7
8
9
10
11

Gra n = new Gra(15,15);
n.init();

while(true){

n.Draw();
Scanner sc = new Scanner(System.in);
if(!sc.nextLine().equals("n"))
break;

}

Jak widac po kodzie, kolejna populacja będzie generowana po wpisaniu litery „n”. Od „nowa”… A może od „następna”? :P mało istotne.

Klasa Gra wygląda tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

import java.util.Arrays;
import java.util.Random;

/**
*
* @author Matt
*/
public class Gra {
int n=10;
int m=10;
//stanrdowe wymiary
private boolean plansza[][];//plansza glowna
private boolean plansza_t[][];
//plansza przechowuje poprzednie pokolenie
Gra()
{
plansza = new boolean[n][m];
//konstruktor
}

Gra(int n, int m){
this.n=n;
this.m=m;
plansza = new boolean[n][m];
//konstruktor nr.2
}

public void init(){
/*
Random r = new Random();
for(int i=0;i<(2*n);i++)
plansza[r.nextInt(n)][r.nextInt(m)]=true;
*/

//kod zakomentowany wyżej wypełnia losowo część macierzy

plansza_t=new boolean[n][m];
plansza[5][5] = true; plansza[5][7] = true; plansza[5][9] = true;
plansza[6][5] = true; plansza[6][9] = true;
plansza[7][5] = true; plansza[7][9] = true;
plansza[8][5] = true; plansza[8][9] = true;
plansza[9][5] = true; plansza[9][7] = true; plansza[9][9] = true;
//a tutaj prosty wzor ktory pokazuje jak dziala ten program
//figura startowa to prostokat
}

private void checkCell(int w, int k){

if(plansza[w][k] == false)//jesli niezywa
{

boolean temp[] = new boolean[8];//tymczasowa tablica
Arrays.fill(temp, false);//wypelniam ją false

temp[0]=(((w-1)>=0 && (k-1)>=0) && plansza_t[w-1][k-1]==true)?true:false;
temp[1]=(w-1)>=0 && plansza_t[w-1][k]==true?true:false;
temp[2]=(w-1)>=0 && (k+1)<m && plansza_t[w-1][k+1]==true?true:false;
temp[3]=(k+1)<m && plansza_t[w][k+1]==true?true:false;
temp[4]=(k+1)<m && (w+1)<m && plansza_t[w+1][k+1]==true?true:false;
temp[5]=(w+1)<m && plansza_t[w+1][k]==true?true:false;
temp[6]=(k-1)>=0 && (w+1)<m && plansza_t[w+1][k-1]==true?true:false;
temp[7]=(k-1)>=0 && plansza_t[w][k-1]==true?true:false;
// sprawdzam kazdy z 8 sasiadów.
//mozna to petla zrobic ale takie rozwiazanie pokazuje istote Gry w Życie

int suma_zywych_sasiadow=0;
for(int i=0;i<8;i++){

if(temp[i]==true)
suma_zywych_sasiadow=suma_zywych_sasiadow+1;
//licze ilość sąsiadów

}
if(suma_zywych_sasiadow==3){
plansza[w][k]=true;
//jesli jest 3 to ozywiam
}
}

if(plansza[w][k]== true) //jesli zyje
{
boolean temp[] = new boolean[8];
Arrays.fill(temp, false);

temp[0]=(((w-1)>=0 && (k-1)>=0) && plansza_t[w-1][k-1]==true)?true:false;
temp[1]=(w-1)>=0 && plansza_t[w-1][k]==true?true:false;
temp[2]=(w-1)>=0 && (k+1)<m && plansza_t[w-1][k+1]==true?true:false;
temp[3]=(k+1)<m && plansza_t[w][k+1]==true?true:false;
temp[4]=(k+1)<m && (w+1)<m && plansza_t[w+1][k+1]==true?true:false;
temp[5]=(w+1)<m && plansza_t[w+1][k]==true?true:false;
temp[6]=(k-1)>=0 && (w+1)<m && plansza_t[w+1][k-1]==true?true:false;
temp[7]=(k-1)>=0 && plansza_t[w][k-1]==true?true:false;
//licze sasiadów

int suma_zywych_sasiadow=0;
for(int i=0;i<8;i++){

if(temp[i]==true)
suma_zywych_sasiadow=suma_zywych_sasiadow+1;

//dodaje wartosci true
}

if(suma_zywych_sasiadow==3 || suma_zywych_sasiadow ==2)
{
//jesli ma 3 lub 2 sasiadow to zyje dalej
plansza[w][k]=true;

}
else{//jesli nie to umiera
plansza[w][k]=false;
}
}

}

public void Draw(){

for(int i=0;i<n;i++){

for(int j=0;j<m;j++){

plansza_t[i][j]=plansza[i][j];

//kopiuje pokolenie aktualne do tymczasowej macierzy
}

}

for(int i=0;i<n;i++){

for(int j=0;j<m;j++){

//wyswietlam plansze
if(plansza[i][j]==true)
System.out.print("#");
else
System.out.print(".");

}

System.out.println();
}
for(int i=0;i<n;i++){

for(int j=0;j<m;j++){

//obliczam kolejne pokolenie
this.checkCell(i, j);

}
}

}
}

Jak uruchomić plik *.jar? Bardzo prosto. Urochomić cmd, przejść do folderu z plikiem *.jar i wydać polecenie

java -jar plik.jar

gdzie plik to nazwa pliku.

Jeśli się bardzo chce można napisać program w c++ który odpadać będzie taki program.
Kod jest opatrzony komentarzami – myślę że nie wiele musze wyjaśniać.

Dzięki za wizytę,
Mateusz Mazurek