Structure de programmation

Commentaires

# texte libre

Tous les textes qui apparaissent après le dièse "#" ne sont pas considérés comme des instructions. Le robot passe directement à la ligne suivante. Utiliser cette possibilité pour annoter les différentes parties du script, juste pour vous-même, afin de conserver des informations sur la manière dont les différentes parties du script fonctionnent.

Boucles

repeter(n){...instructions...}
Répète les instructions entre les accolades {} le nombre n de fois.

exemple:

# un carré  de  2X2
repeter(4)
{
    avance(2)
    droite()
}
                  

repeter(){...instructions...}
répète l'instruction entre les accolades indéfiniment.

exemple:

# avancer simplement
# (mais va éventuellement continuer à heurter un mur)
repeter()
{
    avance()
}

repeterTantQue(condition){...instructions...}
répète les instructions entre les accolades aussi longtemps que les conditions sont vraies

exemple:

# continue à avancer, 
# mais  s’arrête quand il ne peut aller plus loin
repeterTantQue(rienDevant)
{
    avance(1)
}

sortie
Permet de sortir d'une boucle ( c'est à dire une section qui se répète), donc cela interrompt les instructions entre les accolades. Le robot reprend la suite des instructions après l'accolade fermante } de la boucle.

exemple:

# continue d'avancer jusqu'à ne plus pouvoir aller plus loin
repeter

repeter()
{
    si(obstacleDevant())    {    
        sortie
    }
    sinon
    {    
        avance(1)
    }
}
                  

top

Si

si(condition){...instructions...}
Exécute les instructions entre les accolades tant que la condition est vraie. Sinon, le robot passe aux instructions écrites après l'accolade fermante }. La condition doit être une instruction de perception (voir), par exemple : rienDevant.

exemple:

# s'il y a de la peinture  blanche à gauche, 
# alors la transformer en noir
si(blancAGauche())
{
    gauche()
    avance(1)
    peindreEnNoir()
    arreterDePeindre()
    recule(1)
    droite()
}
                  

si(condition){...instructions...}sinon{...instructions...}
Réalise les instructions entre la première paire d'accolades tant que la condition est vraie, sinon, réalise les instructions de la seconde paire d'accolades. La condition doit être une instruction de perception (voir)

exemple:

# s'il y a de la peinture blanche à gauche, 
# alors la transformer en noire
# sinon avancer de quelques cases
si(blancAGauche())
{
    gauche()
    avance(1)
    peindreEnNoir()
    arreterDePeindre()
    recule(1)
    droite()
}
sinon
{
    avance(3)
}
                  

top

Expressions logiques

Les conditions en "si" et en "répéter tant que" sont appelées des expressions logiques. De telles expressions sont le résultat d'une valeur vraie ou fausse qui est évaluée afin de décider quelle partie de l'instruction exécuter.

Une expression logique peut être le résultat d'une instruction de perception (voir) : oui/non. Les instructions basiques peuvent aussi être composées avec des opérateurs booléens |, &, ~.

exemple:

si(blancAGauche())
{
    gauche()
    avance(1)
}

La condition peut également être affinée par une combinaison des opérateurs suivants afin de préciser dans quels cas les instructions doivent être exécutées.

Les valeurs Vrai et Faux peuvent aussi s'appliquer directement avec une instruction de perception.

L'ordre des opérateurs est important (comme avec l'addition et la multiplication). L'opération "non" à la force la plus contraignante, suivie par "et" suivie par "ou". Les parenthèses peuvent être utilisées pour modifier l'ordre d'évaluation.

exemples:

				
repeterTantQue(non rienDevant() et (blancAGauche() ou blancADroite())){
    avance(1)
}

si(pileOuFace() et non blancADroite())
{
    droite()
    recule(1)
}

si(vrai et faux){
    # cette instruction n'est jamais exécutée
    avance(1)
}
              

top

Procédures

procedure name(par1, par2, ... , parN){...instructions...}
Définir une nouvelle procédure avec n'importe quel nom. La procédure peut avoir de 0 à plusieurs paramètres que vous pouvez nommer avec des noms mémorisables. Ici il sont appelés par1, par2...parN. Ce sont les variables qui peuvent être utilisée dans les instructions entre les accolades. Les instructions d'une procédure ne seront pas exécutées automatiquement, vous devez écrire un "appel de procédure" chaque fois que vous voulez réaliser les instructions dans la définition (voir les instructions suivantes).
Pensez à créer une nouvelle procédure quand vous utilisez une séquence d'instruction plusieurs fois.

exemple:

# définit comment dessiner un rectangle
procedure rectangle(width, height)
{
    peindreEnBlanc()
    repeter(2)
    {
        avance(height)
        droite()
        avance(width)
        droite()
    }
    arreterDePeindre()
}
                  

name(arg1, arg2, . . . , argN)
Est l'appel de la procédure avec le nom et le même nombre de paramètres que d'arguments. Les arguments, appelés ici arg1, arg2...argN sont les valeurs particulières qui doivent être utilisées dans la procédure.

exemple:

# ces instructions seront réalisées
avance(1)
rectangle(3,2) # appelle la procédure "rectangle"
avance(3)
rectangle(1,4) # un autre appel avec d'autres arguments


# Ceci est la définition de la procédure "rectangle"
procedure rectangle(width, height)
{
    peindreEnBlanc()
    repeter(2)
    {
        avance(height)
        droite()
        avance(width)
        droite()
    }
    arreterDePeindre()
}