10. Rien à gauche?

Comme vous le savez, Reeborg peut voir s’il y a un obstacle qui bloque son chemin avec rien_devant(); il peut également déterminer s’il y a un obstacle à sa droite avec rien_a_droite(). Malheureusement, il ne peut pas détecter des obstacles à sa gauche. Vous allez corriger ceci.

10.1. Exploration du code

Important

Assurez-vous de sélectionner Javascript comme langue de programmation.

Explorons le code en exécutant ce qui suit:

voir_source(rien_devant)

Le résultat que je vois est le suivant:

function () {
  return RUR.control.front_is_clear(RUR.current_world.robots[0]);
}

Note

On peut traduire front_is_clear par rien_devant, et right_is_clear par rien_a_droite.

avec un résultat semblable pour voir_source(rien_a_droite). Poursuivons notre exploration en exécutant ce qui suit:

voir_source(RUR.control.front_is_clear)

Le résultat que j’obtiens, et qui est très différent de celui que j’avais obtenu lorsque je préparais la première version de ce tutoriel, est le suivant:

function (robot){
    var tile, tiles, tilename;
    if( RUR.control.wall_in_front(robot)) {
        return false;
    }
    tile = RUR.control.tile_in_front(robot);
    if (tile) {
        if (tile.detectable && tile.fatal){
                if (tile == RUR.tiles.water) {
                    if (!RUR.control._bridge_present(robot)){
                        return false;
                    }
                } else {
                    return false;
                }
        }
    }

    tiles = RUR.control.top_tiles_in_front(robot);
    if (tiles) {
        for (tilename in tiles) {
            if (RUR.top_tiles[tilename] !== undefined &&
                RUR.top_tiles[tilename].detectable &&
                RUR.top_tiles[tilename].fatal) {
                return false
            }
        }
    }

    return true;
}

Bon, tout cela est très compliqué ... essayons plutôt ce qui suit:

voir_source(RUR.control.right_is_clear)

Ah, ceci semble beaucoup plus simple! Voici le résultat que je vois:

function (robot){
    var result;
    RUR._recording_(false);
    RUR.control.__turn_right(robot);
    result = RUR.control.front_is_clear(robot);
    RUR.control.turn_left(robot);
    RUR._recording_(true);
    return result;
}

Tenant compte du fait qu’en Javascript on a besoin de déclarer les variables locales, ce qui n’est pas requis en Python, voici comment on pourrait écrire une fonction équivalente en Python:

def function(robot):
    RUR._recording_(False)
    RUR.control.__turn_right(robot)
    result = RUR.control.front_is_clear(robot)
    RUR.control.turn_left(robot)
    RUR._recording_(True)
    return result

et voici la traduction française correspondante:

def fonction(robot):
    RUR._enregistrement_(False)
    RUR.control.__tourne_a_droite(robot)
    résultat = RUR.control.rien_devant(robot)
    RUR.control.tourne_a_gauche(robot)
    RUR._enregistrement_(True)
    return résultat;

Comme on peut le voir, le créateur de Reeborg a inclus le prototype d’une fonction permettant à Reeborg de tourner directement à droite: RUR.control.__turn_right. Il a utilisé la convention Python d’utiliser un nom qui débute avec deux caractères de soulignement pour dénoter un objet “privé”, qui n’est pas à l’intention des programmeurs externes comme nous.

Voici un résumé de l’effet de la fonction:

1. On arrête un enregistrement
2. Reeborg tourne à sa droite.
3. Reeborg utilise RUR.control.front_is_clear(), l’équivalent de rien_devant, pour déterminer s’il y a un obstacle devant lui. En réutilisant une fonction bien testée (sans bogues!), on respecte la règle numéro 3: Ne vous répétez pas.
4. Reeborg retourne à son orientation de départ.
5. On reprend l’enregistrement
6. La valeur du résultat est retournée.

L’arrêt temporaire de l’enregistrement fait en sorte qu’on ne voit jamais à l’écran les mouvements de Reeborg lorsqu’il tourne tout d’abord à sa droite avant de retourner à son orientation de départ. Il est très malin ce programmeur...

Important

Assurez-vous de sélectionner Python comme langue de programmation pour ce qui suit.

À votre tour!

Ensuite, en vous inspirant de la logique de la méthode Javascript rien_a_droite ci-dessus, ajouter une méthode rien_a_gauche à votre classe RobotRéparé. Au lieu d’utiliser la méthode Javascript RUR._recording_() pour arrêter ou reprendre l’enregistrement, vous devriez utiliser la fonction Python enregistrement() dont je vous ai caché l’existence jusqu’ici.

Je suggère que vous placiez votre classe ``RobotRéparé`` dans votre bibliothèque.

Finalement vous pouvez tester votre méthode avec le monde Vide et le code ci-dessous:

from biblio import RobotRéparé

reeborg = RobotRéparé()

while reeborg.rien_a_gauche():
    reeborg.tourne_a_gauche()

Si vous avez bien fait le tout correctement, Reeborg devrait faire un seul virage à gauche avant que le programme ne termine.