Jogo Da Vida em Unity 3D

Introdução

De acordo com a Wikipedia:

O jogo da vida é um autómato celular desenvolvido pelo matemático britânico John Horton Conway em 1970. É o exemplo mais bem conhecido de autômato celular.

O jogo foi criado de modo a reproduzir, através de regras simples, as alterações e mudanças em grupos de seres vivos, tendo aplicações em diversas áreas da ciência.

As regras definidas são aplicadas a cada nova "geração"; assim, a partir de uma imagem em um tabuleiro bi-dimensional definida pelo jogador, percebem-se mudanças muitas vezes inesperadas e belas a cada nova geração, variando de padrões fixos a caóticos.

Ou seja, o jogo é uma simulação de autômatos, onde "células" podem se reproduzir ou morrer de acordo com algumas regras básicas simples. Um projeto fácil de ser implementado com resultados visíveis muito interessantes.


As regras

O jogo da vida padrão segue algumas regras simples:

qualquer célula viva com menos do que dois vizinhos vivos morre, como se fosse causado por sub-população;
qualquer célula viva com dois ou três vizinhos vivos sobrevive para a próxima geração;
qualquer célula viva com mais do que três vizinhos vivos morre, como se fosse causado por superpopulação;
qualquer célula morta com exatamente três vizinhos vivos se torna uma célula viva, como se fosse causado por reprodução.



O jogo

Uma versão funcional do projeto está disponível abaixo:




[Tens de ter uma conta e sessão iniciada para poderes visualizar este link]



Para utilizar:

Start: inicia uma simulação;
Random: preenche de forma aleatória o mundo com células vivas e mortas;
Clear: limpa o mundo deixando apenas células mortas;
Clique no mundo (parte branca) para ativar uma célula.

[Tens de ter uma conta e sessão iniciada para poderes visualizar este link]

Para aprender, baixe o arquivo do projeto com o fonte:

Jogo da vida (arquivo de projeto Unity)


Detalhes da implementação


Para este projeto, resolvi utilizar a Unity, por contar com diversos recursos facilitadores, permitindo-me concentrar apenas no algoritmo do jogo ao invés de código de infra-estrutura para coisas como entrada, renderização etc.

O jogo da vida possui alguns "conceitos" simples que foram implementados:

Mundo: representa o espaço onde as células se reproduzem, nascem e morrem;
Célula: representa uma entidade do jogo; segue algumas regras básicas a cada geração;
Geração: representa uma execução da lógica de reprodução e morte em todas as células do mundo.

Para representar o mundo, foi necessário um espaço onde as células estariam alinhadas e que permitisse ao usuário escolher quais células iniciariam vivas (para configurar a simulação): isto foi resolvido facilmente na Unity através de um prefab representando a célula (basicamente um "quadrado" com um colisor para detectar se o mouse está em cima).

A representação visual das células vivas e mortas é apenas uma troca da cor do material do prefab.

O mundo é montado em tempo de inicialização, dada uma dimensão no editor (uma simples matriz 2d).
A aplicação das regras da geração são executadas a cada frame e no final do frame a representação visual do mundo é atualizada com as regras aplicadas.

A implementação das regras foi bem fácil e intuitiva (após as funções auxiliares estarem prontas); a parte mais trabalhosa foi a função de contagem de vizinhos vivos de uma célula (que foi bem "força-bruta").

Segue o código e algumas explicações relevantes:

Cell.cs
+ expandir fonte

O código todo da célula é descomplicado e basicamente apenas lida com a entrada do usuário e atualiza a cor da célula de acordo com o estado de vida da mesma.


LifeGame.cs
+ expandir fonte

Linha 44: a função InitWorld é um algoritmo simples que monta o mundo inserindo o prefab da célula no espaço de jogo em uma formação de grid (algoritmo comum de tile).
Linha 82: na função Update, realizamos a chamada da função ApplyRules que irá processar a lógica de uma geração.
Linha 93: a função ApplyRules aplica a lógica simples na geração atual (ponto principal do jogo da vida).
Linha 141: a função CountAliveNeighbors é a maior função do jogo, mas também uma das mais simples: serve apenas para contar a quantidade de vizinhos vivos de uma célula; sua complexidade está no caso de uma célula estar na borda do mundo..



Conclusões

Foi um projeto fácil, com resultados interessantes. O código foi implementado em poucas horas e serve como base para diversos outros projetos como um campo minado, por exemplo.

Com poucas construções (apenas matrizes e funções), uma lógica simples e criatividade é possível fazer projetos muito atrativos com a Unity.

Ainda há espaço para melhorias: efeitos visuais mais chocantes quando uma célula nasce e morre, outra posição para a câmera, regras novas etc.

Código:

[code]