Neste exercício, vai transformar o seu buggle numa formiga de Langton. Estes pequenos animais artificiais são bastante interessantes por que eles recebem regras simples que dependem apenas do seu ambiente local e depois de um período de aparente comportamento caótico, um modelo geral surge.
As regras são absolutamente triviais: para calcular qual o próximo passo,
verifique a cor atual do chão (a usar getGroundColor()
). Se for
branco, mude para preto, vire à direita e mova uma célula. Se for preto mude
para branco, vire a esquerda e ande uma célula.
Difícil encontrar regras mais simples, não é? Bem, vamos em frente codificar
isto agora. Precisa completar o método step()
, que codifica o
comportamento da formiga em cada passo. Vai provavelmente usar o método
getGroundColor()
para recuperar a cor da célula na qual a
formiga está no momento. Cores úteis são nomeadas simplesmente de
Cor.preto
e Cor.branco
.
Para comparar cores, não pode usar o símbolo de igualdade (==), pois estas coisas não são valores escalares, mas objetos. Ao invés disto, precisa escrever algo como o seguinte:
Cor c /* = alguma inicialização */; if (c.equals(Cor.preto)) { /* é igual */ } else { /* não é igual */ }[/!]
Mudar a cor do chão não é difícil, mas meio demorado: tem que mudar a cor do
pincel do seu buggle, baixar o pincel (para marcar a célula atual -- com
brushDown()
) e levantar o pincel de novo (com
brushUp()
) para evitar problemas quando o buggle se mexer. É,
naturalmente, livre para organizar o seu código da forma que quiser, mas
deve querer escrever um método setGroundColor(color)
para
separar um pouco as coisas.
Como pode ver da execução deste exercício, o interessante neste algoritmo é que depois de uns 10000 passos de comportamento relativamente caótico, a formiga começa a construir um modelo regular. O surgimento deste modelo regular em meio ao caos é bastante fascinante, não acha? Mova para o próximo exercício para ver mais disto.