Kategorie: AlgorytmikaProgramowanie

Gra w życie – implementacja Java

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
Tagi: algorytmyaparatgraimplementacjajavakomórkowywżycie
11 lat ago
Mateusz M.

Zostaw komentarz

Podobne wpisy

Ostatnie wpisy

Podsumowanie: luty i marzec 2024

Ostatnio tygodnie były tak bardzo wypełnione, że nie udało mi się napisać nawet krótkiego podsumowanie. Więc dziś zbiorczo podsumuję luty… Read More

2 tygodnie ago

Podsumowanie: styczeń 2024

Zapraszam na krótkie podsumowanie miesiąca. Książki W styczniu przeczytałem "Homo Deus: Historia jutra". Książka łudząco podoba do wcześniejszej książki tego… Read More

3 miesiące ago

Podsumowanie roku 2023

Cześć! Zapraszam na podsumowanie roku 2023. Książki Zacznijmy od książek. W tym roku cel 35 książek nie został osiągnięty. Niemniej… Read More

4 miesiące ago

Podsumowanie: grudzień 2023

Zapraszam na krótkie podsumowanie miesiąca. Książki W grudniu skończyłem czytać Mein Kampf. Nudna książka. Ciekawsze fragmenty można by było streścić… Read More

4 miesiące ago

Praca zdalna – co z nią dalej?

Cześć, ostatnio w Internecie pojawiło się dużo artykułów, które nie były przychylne pracy zdalnej. Z drugiej strony większość komentarzy pod… Read More

4 miesiące ago

Podsumowanie: listopad 2023

Zapraszam na krótkie podsumowanie miesiąca. Książki W listopadzie dokończyłem cykl "Z mgły zrodzony" Sandersona. Tylko "Stop prawa" mi nie do… Read More

5 miesięcy ago