Principalement destiné aux jeunes, ce second jeu H.urna est dédié à l'apprentissage de la programmation sans avoir à écrire une ligne de code. Dans ces défis, nous utiliserons des instructions en bloc pour guider un robot laser afin de produire des lignes, des motifs et des formes avec le même genre d'instructions utilisées par les ordinateurs pour dessiner des images vectorielles à l'écran.

Au programme:

Rappel des concepts fondamentaux du jeu précédent (Globo dans les Labyrinthes):
- Utiliser des blocs pour avancer et / ou reculer.
- S'orienter et se tourner.
- Utiliser des boucles pour éviter la répétition inutile de code.
- Utiliser des instructions conditionnelles pour effectuer des actions en fonction de l'environnement.

Nouveaux concepts introduits:
- Utiliser des variables pour stocker et réutiliser des informations.
- Utiliser des angles libres pour tourner.
- Effectuer des calculs mathématiques dans le code.
- Utiliser un nouveau type de boucle (For).
- Utiliser des boucles imbriquées.

Concepts optionnels libre d'utilisation:
- Compositions conditionnelles.
- Opérations mathématiques avancées.
- Disjoncteurs de boucle.
- Nombres aléatoires.
- ...

Note : les derniers niveaux sont suffisamment difficiles pour que les développeurs professionnels puissent en profiter ; )

Nous venons d'acquérir un nouveau robot laser!
Maîtrisons-le pour produire de superbes images.

Faisons glisser les instructions sur le panneau de droite pour guider notre robot laser afin de produire le motif proposé à chaque niveau. La position et la direction du laser sont représentés par une tortue (il s’agit là d’un hommage traditionnel à Turtle Graphics et au langage Logo). N'oublions pas: un programme est simplement une série d'instructions indiquant à l'ordinateur quoi faire.

Ci-dessous se trouve la description, les concepts de programmation abordés ainsi qu'une solution pour chaque niveau du jeu.

Niveaux 1 - 3 : Échauffements

Niveau 1 - Simple instructions

Échauffement: faire glisser des blocs sur le panneau de droite pour dire au robot comment réaliser un carré et cliquer sur 'Run'.

H.urna Blocks - Robot Laser - Niveau 01

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

Niveau 2 - Utiliser une boucle 'For' afin déviter des répétitions inutiles!

La boucle 'For' exécute certaines actions un nombre spécifié de fois.

H.urna Blocks - Robot Laser - Niveau 02

Solution niveau 02 et code généré :
for (let i = 0; i < 4; ++i) {
 moveForward();
 turnRight();
}

Niveau 3 - The moonwalk !

Même carré qu'avant, mais la tortue (le robot laser) refuse d'avancer.

H.urna Blocks - Robot Laser - Niveau 03

Solution niveau 03 et code généré :
for (let i = 0; i < 4; ++i) {
 turnLeft();
 moveBackward();
}

Niveaus 4 - 7 : Gérer les distances et les angles

Niveau 4 - Gérer la distance - 4 carrés

Gérer les étapes de distance du robot pour créer ces 4 carrés imbriqués (100, 75, ...).
Remarque: nous pouvons dupliquer des blocs et des groupes de blocs en utilisant un clic droit.

H.urna Blocks - Robot Laser - Niveau 04

Solution niveau 04 et code généré :
for (let i = 0; i < 4; ++i) {
 moveForward(100);
 turnRight();
}
for (let i = 0; i < 4; ++i) {
 moveForward(75);
 turnRight();
}
for (let i = 0; i < 4; ++i) {
 moveForward(50);
 turnRight();
}
for (let i = 0; i < 4; ++i) {
 moveForward(25);
 turnRight();
}

Niveau 5 - Gérer l'angle - Octogone

Arrêtons d'être coincé avec des formes à angle droit : faisons un octogone

H.urna Blocks - Robot Laser - Niveau 05

Solution niveau 05 et code généré :
for (let i = 0; i < 8; ++i) {
 moveForward();
 turnRight(45);
}

Niveau 6 - Polygones everywhere !

Construisons ces polygones en utilisant seulement 16 blocs (Rappel: n'hésitons pas à utiliser la copie avec le clic droit).

H.urna Blocks - Robot Laser - Niveau 06

Solution niveau 06 et code généré :
for (let i = 0; i < 3; ++i) {
 moveForward();
 turnRight(120);
}
for (let i = 0; i < 4; ++i) {
 moveForward();
 turnRight(90);
}
for (let i = 0; i < 6; ++i) {
 moveForward();
 turnRight(60);
}
for (let i = 0; i < 8; ++i) {
 moveForward();
 turnRight(45);
}

Niveau 7 - Polygone déguisé en cercle

Tracer 360 micro-lignes ressemblera à un cercle parfait.
N'hésitons pas à changer le curseur de vitesse pour obtenir une animation plus rapide.

H.urna Blocks - Robot Laser - Niveau 07

Solution niveau 07 et code généré :
for (let i = 0; i < 360; ++i) {
 moveForward(1);
 turnRight(1);
}

Niveaus 8 - 11 : Utilisation de variables pour stocker et réutiliser des informations

Jusqu'à présent, nous avons programmé une série d'instructions à exécuter dans tous les cas, nous avons appris à utiliser des conditions, à utiliser des boucles prédéfinies, à gérer les distances et les angles... C'est beaucoup. Mais maintenant, nous allons commencer à utiliser la mémoire de l'ordinateur! C'est un grand pas en avant, mais ne nous inquiétons pas, ça va être tranquille (ou presque).

Niveau 8 - La spirale

Pour créer une spirale, nous allons augmenter la distance parcourue par la tortue à chaque étape. Afin de le faire efficacement, nous utiliserons une variable (une mémoire).

H.urna Blocks - Robot Laser - Niveau 08

Solution niveau 08 et code généré :
let lenght = 10;
for (let i = 0; i < 8; ++i) {
 moveForward(lenght);
 turnRight(90);
 lenght += 10;
}

Niveau 9 - Rappelez-vous le niveau 04? L'utilisation d'une variable nous évitera la répétition.

Deux boucles imbriquées seront nécessaires pour cette figure (longueur de 25 à 100). N'ayons pas peur, c'est toujours (presque) aussi simple qu'avant. Nous faisions 4 fois la même chose pour construire un carré et nous ferons ces choses 4 fois pour obtenir 4 carrés :).

H.urna Blocks - Robot Laser - Niveau 09

Solution niveau 09 et code généré :
let lenght = 25;
for (let i = 0; i < 4; ++i) {
 for (let j = 0; j < 4; ++j) {
  moveForward(lenght);
  turnRight(90);
 }
 lenght += 25;
}

Niveau 10 - Crise ! Nous manquons de blocs !

Attention, nous avons un nombre limité de blocs à utiliser! Il faut absolument utiliser une variable : plus de triche possible (longueur de 10 à 80). La solution est presque la même que pour le niveau précédent.

H.urna Blocks - Robot Laser - Niveau 10

Solution niveau 10 et code généré :
let lenght = 10;
turnRight(45);
for (let i = 0; i < 8; ++i) {
 for (let j = 0; j < 4; ++j) {
  moveForward(lenght);
  turnRight(90);
 }
 lenght += 10;
}

Niveau 11 - Du triangle au cercle non parfait

Dessinons ces 13 polygones en utilisant une variable pour contrôler les boucles (deux boucles imbriquées seront nécessaires).

H.urna Blocks - Robot Laser - Niveau 11

Solution niveau 11 et code généré :
turnLeft(90);
for (let i = 3; i < 16; ++i) {
 for (let j = 0; j < i; ++j) {
  moveForward();
  turnRight(360 / i);
 }
}

Niveau 12 - Laser on (Turtle down) / off (Turtle up) !

Nous voudrons peut-être arrêter d'utiliser le laser en nous déplaçant d'un point à un autre.

H.urna Blocks - Robot Laser - Niveau 12

Solution niveau 12 et code généré :
moveForward();
turnRight();
laser('off');
moveForward();
turnRight();
laser('on');
moveForward();

Niveau 13 - Boss Final!

Tout les concepts ensemble! (très avancé).

H.urna Blocks - Robot Laser - Niveau 13

Pas de solution offerte pour le niveau 13, mais quelques indices
- Tout est fait de pentagones!
- Sauf les deux pentagones au milieu, le reste peut être aisemment réaliser avec 3 petites boucles imbriquées.
- Ce motif peut être décrit comme une fractale.

Niveau 14 - Freestyle !

Des tonnes de nouvelles fonctions pour jouer dans cet espace libre de 2000 x 2000. N'hésitez pas à prendre une capture d'écran et à la partager.

Sautons à bord de l' Hurna Explorer pour jouer et tenter de réaliser ces 13 figures avec notre robot laser.