## Fonctions

Souvent, on souhaite écrire une méthode calculant une valeur donnée, et qui la retourne. On appelle fonctions ces méthodes qui renvoient un résultat.Écrire une fonction n'est pas tellement plus dur que pour les méthodes sans résultat. [!java|c]Il suffit d'écrire le type de données renvoyées par votre fonction avant son nom (là où nous écrivions `void` avant).[/!] [!scala]Il suffit d'ajouter deux points (:), le type de données renvoyées par votre fonction et le signe égal (=) entre les parenthèses de la déclaration et l'accolade du bloc. Cette syntaxe est assez proche de la définition d'une variable (avec son type) dont la valeur serait une fonction.[/!] Vous pouvez utiliser l'instruction `return` n'importe ou dans le corps de votre fonction pour spécifier que le calcul est fini (la suite de la fonction n'est pas exécutée) et donner la valeur à donner à l'appelant après le mot-clé `return`.

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

En fait, vous pouvez également utiliser le mot-clé `return` dans les méthodes ne renvoyant pas de résultat, pour interrompre leur exécution. Dans ce cas, il ne faut bien entendu pas donner de valeur à droite du `return`.

Il est possible d'avoir plusieurs instructions `return` dans différentes branches de `if`. Ce qui est interdit, c'est d'avoir une branche du code qui n'est pas terminée par un `return`, ou d'écrire du code après le `return`. En effet, si la machine arrive à la fin de la fonction sans avoir rencontré de `return`, elle ne peut pas savoir quelle valeur communiquer à celui qui a appelé la fonction. De plus, le `return` interrompt immédiatement l'exécution de la fonction (pourquoi continuer à chercher quand on a déjà trouvé le résultat de la fonction?). Donc, s'il y a du code après un `return`, c'est sans doute une erreur, et le compilateur vous l'indique.

    [!java|scala|c][!java]boolean [/!][!c]int [/!] [!scala]def [/!]estDevantLibre()[!scala]:Boolean =[/!] {
        if (estFaceMur() == [!java|scala]true[/!][!c]1[/!]) {
            return [!java|scala]false[/!][!c]0[/!];
            /* interdit d'écrire du code ici */
        } else {
            return [!java|scala]true[/!][!c]1[/!];
            /* pareil ici */
        }
        /* même ici, oubliez */
    }[/!][!python]def estDevantLibre():
        if estFaceMur() == True:
            return False
            # interdit d'écrire du code ici
        else
            return True
            # pareil ici
    # même ici, oubliez[/!]

### Objectif de cet exercice

Vous allez encore une fois écrire une fonction qui sera utilisée par la buggle. Son nom doit être `haveBaggle`, et elle doit renvoyer un booléen indiquant si la colonne face à la buggle contient un biscuit ou non. Votre buggle va s'en servir pour chercher la première colonne contenant un biscuit et s'y arrêter.

Le plus simple pour écrire cette fonction est peut être d'utiliser une variable booléenne `vuBiscuit` indiquant si on a vu un biscuit jusque là. Initialement, elle contient faux («[!python]False[/!][!scala|java]false[/!][!c]0[/!]»).

Ensuite, on avance de 6 cases (le monde contient 7 cases, et on est déjà sur l'une d'entre elles). Pour chaque case, si elle contient un biscuit, on range la valeur vrai dans `vuBiscuit` (et on ne fait rien d'autre qu'avancer si non).

Quand on est arrivé à la fin, on recule de 6 cases, et on retourne le contenu de `vuBiscuit` à l'appelant.

Cet exercice est un peu particulier, puisqu'il a deux mondes initiaux, chacun ayant un objectif particulier. Votre code doit fonctionner pour chacun d'entre eux. Remarquez que le menu déroulant de sélection du monde (juste sous la barre de réglage de la vitesse) permet de spécifier le monde que vous souhaitez observer.

Quand votre fonction `haveBaggle` fonctionne, passez à l'exercice suivant.