arduino, eletrônica, robotica...

Jogo da Vida de Conway - em Processing

Este pequeno programa em Processing é uma implementação do popular "Game of Life" de Conway (Jogo da Vida). Serve para mostrar o poder dos autómatos celulares, que são usados como modelos que representam muitos processos naturais - e são incrívelmente simples. Para saber mais:clique

O intuito do código visa ser mais educativo que eficiente; com certeza há melhores maneiras de implementar isto, mas o foco é na simplicidade e usar os recursos gerais do Processing.

Este programa é sem fins lucrativos.



Conway conway;

int genCount;





void setup() {

size(640, 320, P2D);

frameRate(24);

conway = new Conway(2); //tamanho da "célula" = 2 x 2 pixels na tela. Escolha o seu!

genCount = 0; // qtde. de iterações

}



//loop de desenho. Há uma atraso de 100ms apenas por razões estéticas

void draw() {

conway.render();

conway.generate();

delay(100);

}



//clicar com o mouse acaba a simulação

void mousePressed() {

showDone();

}



//mostramos uma mensagem ao finalizar

void showDone() {

PFont metaBold;

metaBold = loadFont("Amble-Bold-48.vlw");

textFont(metaBold);

textMode(SCREEN);

fill(255);

text("Jogo da Vida\nConway", width / 2, height / 2 - 50);

noLoop();

}





//A clase Conway permite criar/gerar/desenhar matrizes de células com tamanho escolhido

class Conway {

int[][] cells;

int csz;



Conway(int cellSz) {

csz = cellSz;

//esta matriz do tamanho da tela, armazena as células

cells = new int[width / csz][height / csz];

randomize();

}



// Criamos um conjunto inicial aleatório de células

void randomize() {

for (int j = 0; j < height / csz; j++) {

for (int i = 0; i < width / csz; i++) {

cells[i][j] = int(random(2)); //as célualas possuem dois "estados" -> Viva = 1, ou Morta = 0

}

}

}



//desenhamos as células, baseadas no tamanho escolhido. Viva = verde, Morta = preto

void render() {

for (int j = 0; j < height / csz; j++) {

for (int i = 0; i < width / csz; i++) {

if (cells[i][j] == 1) fill(0, 255, 0);

else fill(0);

noStroke();

rect(i * csz, j * csz, csz, csz);

}

}

}



//rotina para gerar os novos estados das células, baseados nas regras de Conway

void generate() {



//cria-se uma nova matriz para armazenar os próximos "estados" das células

int[][] nextGen = new int[width / csz][height / csz];



//percorremos todas as células correntes

for (int j = 0; j < height / csz; j++) {

for (int i = 0; i < width / csz; i++) {

//o próximo "estado" da célula à partir das regras

nextGen[i][j] = regras(cells[i][j], vizinhos(i, j));

}

}



//os "próximos estados" das células aqui viram-se os atuais

cells = (int[][]) nextGen.clone();

}



//obter a quantidade de vizinhos vivos para uma célula qualquer

int vizinhos(int i, int j) {



//a lógica das próximas linhas existe para evitar erros com as células de "fronteira" - nos limites da tela

int lx = i == 0 ? i : i - 1; //se estiver na fronteira esquerda - o mínimo x é "0"

int ly = j == 0 ? j : j - 1; //se estiver na fronteira superior - o mínimo y é "0"

int hx = i == (width / csz) - 1 ? (width / csz) : i + 2; //se estiver na fronteira direita - o máximo x é "(width / csz) - 1"

int hy = j == (height / csz) - 1 ? (height / csz) : j + 2; //se estiver na fronteira inferior - o máximo y é "(height / csz) - 1"



int vz = 0;

for (int y = ly; y < hy ; y++) {

for (int x = lx; x < hx ; x++) {

if (x == i && y == j) continue;

vz += cells[x][y];

}

}



return vz;

}





//éste é o "miolo" do nosso programa. As regras de Conway são muito simples - e poderosas.

int regras(int eu, int vizinhos) {

//"eu" é a célula em análise

if (eu == 1 && (vizinhos == 2 || vizinhos == 3)) return 1; //continua viva!

if (eu == 1 && vizinhos < 2) return 0; //morreu de solidão...

if (eu == 1 && vizinhos > 3) return 0; //morreu por sobrepopulação

if (eu == 0 && vizinhos == 3) return 1; //uma nova célula nasce!

return eu; //as células mortas que não tem condições para renascer, continuam mortas

}

}