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.