Uniwersytet Śląski w Katowicach 
Wydział Informatyki i Nauki o Materiałach 
 
 
 
 

 

Sztuczna Inteligencja 

 

Automat komórkowy 

Matrix 

 
 
 

Opracowali: 

Paulina Giereś 

Ewelina Kania 

Inżynieria biomedyczna rok III, OM1

 

 
 
 

Automat komórkowy Matrix działa na podanych zasadach: 
 

● Każda komórka może przyjąć wartości od 0 do 255, co oznacza od koloru czarnego 

do największego nasycenia danego koloru (w naszym przypadku zieleń #00ff00) 

● Populacja zaczyna się od 10 komórek w losowo wybranym miejscu w oknie. 

● Dla każdej komórki bierze się pod uwagę komórki z jej ortogonalnego sąsiedztwa, 

oznacza to, że pod uwagę bierzemy czterech sąsiadów, na rysunku zaznaczonych 
zielonym kolorem.

 

  

rys. 1 

 

 

● Jeśli suma wartości komórek na dole i na górze nie jest równa zero, wtedy stan 

branej pod uwagę komórki zmienia się zgodnie z modulo (resztą z dzielenia) sumy 
wartości komórek po prawej i lewej stronie przez wartości komórek na dole i na 
górze. 

 

rys. 2

   rys. 3 

 

132

78) mod (81

78)

1

(

+ 1

+ 1

= 5

  

 

(dla ułatwienia nie zmieniono wartości sąsiadów na rys. 3) 

 

● Jeśli suma komórek na dole oraz na górze wynosi zero, wtedy należy brać pod uwagę 

jedynie sumę wartości komórek po lewej i prawej stronie i dodać ją do obecnego 
stanu komórki.  
Uwaga: najwyższa wartość 255! W przypadku, gdy suma wyniesie więcej, stan 
zmienia się na 255. 

 

rys. 4

rys.5 

 

175

75)

6

86

(

+ 1

+ 3 = 3

 

Przypadek, w którym bierzemy najwyższą możliwą wartość, 255 

 
 

● Automat posiada trzy tryby, które zmienia się za pomocą klawiszy 1,2 i 3. Różnią się 

od siebie sposobem rozwoju. 

 

● Kliknięcie LPM prowadzi do ponownej populacji w oknie 

 

 
 
 
 
 
 
 
 
 
 
 
 

Tryb 1 
 

 

 

 

 
 
 
 
 

Tryb 2 
 

 

 

 

 
 
 
 
 

Tryb 3 
 

 

 

 

 
 
 

 
 

KOD PROGRAMU 

 
int W = 600; // szerokość okna (powinno być dzielne przez S) 
int H = 400; // wysokość okna (powinno być dzielne przez S) 
int S = 2; // rozmiar komórek w pikselach 
int C = W / S; // ilość column w automacie 
int R = H / S; // ilość wierszy w automacie 
int mode=1; // która wersja jest wyświetlana na początku 
int [][] curr; // obecne pokolenie 
int [][] prev; // poprzednie pokolenie 
color [] palette; // 256 kolorów 
 
void setup() { 
  size(W,H); 
  frameRate(15); // 

im więcej tym szybciej 

  background(0); 
  noStroke(); 
  curr = new int[R][C]; 
  prev = new int[R][C]; 
  populate(); 
  palette = new int[256]; 
  for (int i=0; i<256; i++) { 

int k = (int)(pow(i/256.0,2)*255.0); //

 intensywność wybranego koloru,(pow(x,y)=x^y) 

palette[i] = color(0,k,0); // kolor (R,G,B) 

  } 
} 
 
void populate() { 
  for (int r=0; r<R; r++) { 

for (int c=0; c<C; c++) { 

 

prev[r][c] = curr[r][c] = (int)random(10); // można zmieniać!  

// (10) - mała populacja początkowa, w miarę szybko się rozwija  

} 

  } 
} 
 
 
void update() { 
  for (int r=0; r<R; r++) { 

for (int c=0; c<C; c++) { 

 

int state = curr[r][c]; 

 

int lr = prev[r][(c-1+C)%C] + prev[r][(c+1)%C]; // modulo % 

 

int tb = prev[(r-1+R)%R][c] + prev[(r+1)%R][c]; 

 

 

  

 

 

 

int breed = 0; 

 

switch(mode) { // tryby 

 

 

case 1 : breed = (state+lr)&0xff; break;  

// aktywny 

 

 

case 2 : breed = ((state+lr))&0xf; break;  

// najbardziej “matrixowy” efekt, usuwa najwyższe wartości bitów, wolniejszy rozwój 

 

case 3 : breed = (state+100)&0xff; break;  

// bardzo zaszumiony efekt 

 

// itd 

 

} 

 

curr[r][c] = (tb==0) ? breed : (lr%tb)&0xff; 
} 

  } 
} 
 
void render() { 
  for (int r=0,y=0; r<R; y+=S,r++) { 

for (int c=0,x=0; c<C; x+=S,c++) { 

 

fill(palette[curr[r][c]]); 

 

rect(x,y,S,S); // kształt 
} 

  } 
} 
 
void swap() { 
  int [][] temp = curr; 
  curr = prev; 
  prev = temp; 
} 
 
void ui() { 
  fill(255,42,0,120); 
  text("mode: " + mode, 5, H-5); 

} 
 
void draw() { 
  update(); 
  render(); 
  ui(); 
  swap(); 
} 
 
void keyPressed() { 
  if ((key>='1') && (key<='3')) 

mode = key - '0'; 

} 
 
void mousePressed() { 
  populate(); 
}