## formiga de Langton

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`.

[!java]

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.