Principalement destiné aux jeunes, ce module est le premier des jeux H.urna dédiés à l'apprentissage de la programmation sans avoir à écrire une ligne de code. Les joueurs arrangent des blocs pour diriger notre mascotte Globo et l'aider à s'échapper des labyrinthes.

Alors que les programmeurs professionnels créent des logiciels en écrivant des lignes de code pour qu’un ordinateur puisse les interpréter, vous commencez ici avec un outil de programmation visuel avec lequel vous pouvez librement jouer. Et ne vous inquiétez pas, ce jeu est progressif pour vous permettre de découvrir les concepts de programmation étape par étape.

Reste que la difficulté peut être intéressante aussi pour ceux habitués à programmer ; )

Ci-dessous, un petit passage sur les labyrinthes et leurs origines, mais vous pouvez aussi aller directement à la section Jeu.

Oh mon Glob !
Globo voyageait à travers certaines dimensions quand il s'est retrouvé coincé dans ses propres méandres !
Nous lui avions pourtant dit d’éviter les boucles, mais cela ne pouvait aider.
Maintenant… Nous devons le reconnecter et le guider vers sa capsule.

Faites glisser les blocs d'instructions et emboîtez les sur le panneau de droite pour dire à Globo quoi faire pour rejoindre sa capsule bleue sans heurter un mur. Rappelez-vous: un programme est juste une série d'instructions qui indique à un ordinateur quoi faire.

Il y a 3 situations possibles que Globo peut rencontrer avec vos instructions : Globo arrive à la capsule, Globo n’a pas atteint le but ou Globo a heurté un mur.
Pour les deux derniers cas : réessayez en changeant vos blocs et cliquez sur play.

Vous êtes maintenant prêt à relever les défis et sauver Globo.

Vous trouverez ci-dessous les descriptions et les concepts de programmation couverts par chaque niveau. Vous trouverez également la solution optimale pour chaque défi. Note le code et les blocs reste en anglais et reste basique; c'est la langue universelle pour la programmation et nous préconisons son utilisation sans traduction dans ce contexte.

Niveaux 1 - 2 : Instructions simples

Ce sont les niveaux d’échauffement. Ici, vous pouvez découvrir et jouer avec l’interface H.urna Blocks. Néanmoins, le deuxième niveau commence à nécessiter une représentation spatiale et comprendre la relativité d'une instruction (par exemple, tourner à gauche dépendra de la direction actuelle de Globo).

Niveau 1 - Aidez Globo à aller à la capsule !

Utilisez seulement 2 blocs pour indiquer à Globo d’aller directement au but.

H.urna Blocks - Globo dans les labyrinthes - Niveau 01

Solution niveau 01 et le code généré :
moveForward();
moveForward();

Niveau 2 - La vie n'est pas toujours un droit chemin

Utilisez le bloc 'Turn' pour dire à Globo de tourner à gauche ou à droite.

H.urna Blocks - Globo dans les labyrinthes - Niveau 02

Solution niveau 02 et le code généré :
turnLeft();
moveForward();
turnRight();
moveForward();

Niveaux 3 - 5 : Boucles

Ces niveaux introduisent le concept de «boucle» : ce qui rend la programmation si pratique lorsque l'on veut répéter la même opération autant de fois que necessaire. Utilisez ici le bloc "repeat-until" (répéter jusqu'à) pour créer une boucle. Placez des blocs d'instruction dans la boucle, ils seront exécutés à chaque exécution (ou itération) de la boucle. La condition de boucle est ici réglée pour ne s’arrêter que lorsque l’objectif est atteint.

Niveau 3 - Minimisez votre effort

Atteignez ici la capsule en utilisant seulement deux blocs. Utilisez le bloc 'repeat-until' pour exécuter un bloc d'instruction plus d'une fois.

H.urna Blocks - Globo dans les labyrinthes - Niveau 03

Solution niveau 03 et le code généré :
while (!isSolved()) {
 moveForward();
}

Niveau 4 - Minimisez votre effort - Partie II

Vous pouvez insérer plus d'un bloc dans un bloc "repeat-until".
5 blocs sont ici nécessaires pour résoudre ce niveau.

H.urna Blocks - Globo dans les labyrinthes - Niveau 04

Solution niveau 04 et le code généré :
while (!isSolved()) {
 turnLeft();
 moveForward();
 turnRight();
 moveForward();
}

Niveau 5 - Minimisez votre effort - Partie Finale

Attention : à l'intérieur d'un bloc "repeat-until", la condition est testée uniquement au début de chaque itération (de la boucle). Vous n'avez pas besoin de mettre tout votre code dans la boucle.
6 blocs nécessaires pour celui-ci.

H.urna Blocks - Globo dans les labyrinthes - Niveau 05

Solution niveau 05 et le code généré :
moveForward();
while (!isSolved()) {
 turnLeft();
 moveForward();
 turnRight();
 moveForward();
}

Niveaux 6 - 9 : Conditions

Jusqu'à présent, vous avez programmé une série d'instructions à exécuter quoi qu'il en soit. Mais parfois, vous ne voudrez faire quelque chose que lorsqu'une certaine condition est vraie . Par exemple vous arrivez chez vous, si votre porte est fermée, vous devrez l'ouvrir pour pouvoir entrer dans votre bercail.

C’est la même chose avec la programmation, vous devez dire à l’ordinateur quoi faire en fonction des conditions (appellées variables). Vous guiderez Globo en utilisant le bloc if pour lui dire de vérifier certaines conditions avant d'effectuer certaines actions.

Niveau 6 - Blocs conditionnels - Partie I

Le bloc "if" de ce jeu vous permet de vérifier s'il existe un chemin dans une certaine direction. Utilisez ce bloc pour tourner en cas de besoin !

H.urna Blocks - Globo dans les labyrinthes - Niveau 06

Solution niveau 06 et le code généré :
while (!isSolved()) {
 moveForward();
 if (hasRightPath()) {
  turnRight();
 }
}

Niveau 7 - Blocs conditionnels - Partie II

Si près et si loin... Parfois un labyrinthe semble plus compliqué alors que la logique reste la même.

H.urna Blocks - Globo dans les labyrinthes - Niveau 07

Solution niveau 07 et le code généré :
while (!isSolved()) {
 moveForward();
 if (hasLeftPath()) {
  turnLeft();
 }
}

Niveau 8 - Blocs conditionnels - Partie III

Pouvez-vous résoudre ce défi avec seulement 6 blocs à repartir ? Vous pouvez utiliser plusieurs blocs "if" dans une boucle. Restez cependant prudent avec l'ordre de vos instructions : il a son importance.

H.urna Blocks - Globo dans les labyrinthes - Niveau 08

Solution niveau 08 et le code généré :
while (!isSolved()) {
 if (hasLeftPath()) {
  turnLeft();
 }
 moveForward();
 if (hasRightPath()) {
  turnRight();
 }
}

Niveau 9 - Blocs conditionnels - Partie finale (Joueur avancé)

If-Else, un nouveau bloc conditionnel : parfois, vous souhaitez prendre une descision lorsqu'une condition est vraie ou sinon en prendre une autre dans le cas contraire. Par exemple, cette fois, vous êtes devant votre appartement verrouillée à clé. Si (If) vous avez les clés, vous pouvez déverrouiller la porte pour entrer, sinon (Else), vous pouvez sonner en espérant que quelqu'un soit à l'intérieur pour venir vous ouvrir.

Remarque: il est important de définir l'ordre des conditions avec soin. Le programme vérifie toujours la condition "si" en premier. Si c'est vrai, il ignorera toujours la déclaration "sinon".

Même si ce niveau semble beaucoup plus compliqué, seul 6 blocs restent nécessaires pour le résoudre.

H.urna Blocks - Globo dans les labyrinthes - Niveau 09

Solution niveau 09 et le code généré :
while (!isSolved()) {
 moveForward();
 if (hasRightPath()) {
  turnRight();
 }
 else if (hasLeftPath()) {
  turnLeft();
 }
}

Niveau 10 - Niveau Bonus (Joueur avancé)

Ce niveau bonus est pour un joueur intermédiaire. Il reste très sympa à résoudre et pas tant difficile une fois comprit le principe. N'hésitez pas à changer la vitesse de l'animation pour la rendre plus rapide ; )

Depuis mon enfance, j'ai toujours entendu dire que pour sortir d'un labyrinthe, il suffisait de marcher avec l'une de mes mains toujours collée au mur. Ce niveau est idéal pour tester cette hypothèse, et croyez-moi, c’est très amusant à visualiser. Cette stratégie est mieux connue sous le nom de «suiveur de mur», «règle de la main gauche» ou «règle de la main droite».

H.urna Blocks - Globo dans les labyrinthes - Niveau 10

Solution niveau 10 et le code généré :
while (!isSolved()) {
 if (hasRightPath()) {
  turnRight();
  moveForward();
 }
 else if (hasForwardPath()) {
  moveForward();
 }
 else if (hasLeftPath()) {
  turnLeft();
  moveForward();
 }
}

Solution bis niveau 10 et le code généré :
while (!isSolved()) {
 if (hasForwardPath()) {
  moveForward();
 }
 else {
  turnLeft();
 }
 if (hasRightPath()) {
  turnRight();
 }
}

Attention !
Cette stratégie ne fonctionne que pour des labyrinthes simplement connectés : quand toutes ses parois sont connectées ensemble. Vous pouvez facilement représenter l'échec possible sur un labyrinthe plus complexe (ci-dessous).

Vous êtes maintenant sur un labyrinthe où un mur est seul au milieu (non connecté à un autre) et vous commencez avec votre main dessus. En quoi cette stratégie aboutira-t-elle ?
Vous tournerez infiniment autour de ce mur et serez perdu pour toujours...

Sautons à bord de l' H.urna Explorer pour jouer et tenter de résoudre les labyrinthes dans lesquels Globo est coincé.