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
}
}

Exibições: 5962

Comentar

Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!

Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)

Destaques

Registre-se no
Lab de Garagem
Clicando aqui

Convide um
amigo para fazer
parte

curso gratis de arduino

© 2020   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço