## Funções

Frequentemente, vai escrever um método que calcula algum valor e o retorna. Métodos a retornar resultados são chamados funções. Escrever uma função não é realmente mais difícil do que escrever um simples método. [!java|c]Simplesmente tem que especificar o tipo de dados do resultado esperado entes do nome da função (onde previamente tínhamos `void`).[/!] [!scala]Simplesmente tem que adicionar um dois-pontos (:) depois do parêntesis e escrever o tipo de dados que a função dele vai retornar e adicionar um símbolo de igualdade (=). Esta sintaxe é na verdade mais próxima de definir uma variável, com o tipo dela, do que na verdade escrever uma função.[/!] Pode usar a instrução `return` em qualquer lugar do corpo da sua função para especificar que o cálculo foi feito (a função não continuará a ser executada) e que o resultado é o valor que acompanha a palavra-chave `return`.

    [!java|c]double pi() {[/!][!scala]def pi(): Double = {[/!][!python]def pi():[/!]
        return 3.14159[!java|c];[/!]
    [!java|scala|c]}[/!]

Na verdade, também pode usar a palavra-chave `return` em métodos que não retornam qualquer resultado, para interromper o cálculo. Obviamente que nestes casos não passa nenhum valor para retornar.

É possível ter várias instruções `return` em várias ramificações de um condicional. De fato, é proibido ter um caminho de execução no corpo da função sem nenhum `return`, ou escrever algum código depois da instrução `return`. Na verdade, se a máquina alcança o fim da função sem encontrar qualquer `return`, ela não sabe o real valor que deve retornar a quem chamou a função. Além disto, o `return` interrompe imediatamente a execução da função (por que se preocupar a olhar além quando sabe o resultado da função?). Então, se existe algum código depois de um `return`, deve ser um erro e o compilador irá te alertar disto.

    [!java|scala|c][!java]boolean [/!][!c]int [/!][!scala]def [/!]isFrontFree()[!scala]:Boolean =[/!] {
        if (isFacingWall() == [!java|scala]true[/!][!c]1[/!]) {
            return [!java|scala]false[/!][!c]0[/!];
            /* proibido pôr código aqui */
        } else {
            return [!java|scala]true[/!][!c]1[/!];
            /* nem aqui */
        }
        /* e nem mesmo aqui. desista */
    }[/!][!python]def livreEmFrente():
        if isFacingWall() == True:
            return False
            # proibido pôr código aqui
        else
            return True
            # nem aqui
    # e nem mesmo aqui, desista[/!]

### Objetivo do exercício

Vai mais uma vez escrever uma função que o buggle vai usar. O nome dela deve ser `temBaggle` e retorna um valor booleano a indicar se a linha na frente do buggle contém um baggle ou não. O buggle vai usar isto para buscar a primeira linha a conter um baggle e parar nela.

A forma fácil de fazer esta função é usar uma variável booleana chamada `baggleAvistado` a indicar se vimos ou não um baggle até o momento. O valor inicial é '[!python]False[/!][!scala|java]false[/!][!c]0[/!]'.

Então mova 6 passos para frente (o mundo contém 7 células e já estamos numa delas). Para cada célula, se ela contiver um baggle, vamos guardar true em `baggleVisto` (e se não, vamos simplesmente andar para frente).

No final, vamos nos mover 6 passos para trás e retornar o valor de `baggleVisto` para quem chamou o método.

Observe que o buggle usado fornece código oculto que irá chamar a sua função `haveBaggle` em cada coluna, movendo automaticamente entre colunas. Portanto, é muito importante que a sua função `haveBaggle` não tenha nenhum efeito colateral: a posição (e orientação) no final do seu código deve ser a observada no início deste código. Ela moverá entre elas para buscar a baggle, mas volta para o início da coluna.

Além disso, este exercício é um pouco diferente, pois existem dois mundos iniciais, cada um com um objetivo específico. O seu código deve funcionar para cada um deles. Observe que o menu de rolagem de seleção de mundos (logo abaixo do controle deslizante de velocidade) permite mudar o mundo observado.

Quando a sua função `temBaggle` funcionar, siga ao próximo exercício.