Triceraprog
La programmation depuis le Crétacé

Human Resource Machine est un jeu de Tomorrow Corporation de type résolution de défi. Ces défis se présentent tous sous la même formes : une série de chiffres et/ou lettres à transformer en une autre série de chiffres et/ou lettres, en fonction de directives.

Et pour cela, le joueur a à sa disposition une série de commandes. Au début, très peu, leur nombre s'étoffe au fur et à mesure des 42 niveaux de la ligne principale. Ces commandes sont exécutées par l'avatar du joueur, qui va courir d'un bout à l'autre d'une pièce pour prendre des données, les transformer, les ajoutes, les comparer, les stocker...

C'est ici que cela m'intéresse dans le cadre de Triceraprog. Le personnage que contrôle le joueur simule le fonctionnement d'un ordinateur (en parti). Le joueur au fur et à mesure de la résolution des puzzle apprend « tout simplement » un langage d'assemblage.

Un langage d'assemblage, ou langage assembleur, est un langage très proche des opérations effectuées par un processeur d'ordinateur. Résoudre des problèmes avec ce seul langage est assez fastidieux et c'est sur ce ressort que joue Human Resource Machine.

Le joueur a la possibilité de copier/coller les programmes du jeu, et ce qui est intéressant est que ce qui est sauvé dans le presse-papier ressemble à un vrai langage d'assemblage pour une machine inventée pour l'occasion. Voici un exemple de résolution d'un des premiers niveaux du jeu, copié dans un éditeur de texte :

-- HUMAN RESOURCE MACHINE PROGRAM --

a:
    INBOX   
    COPYTO   0
b:
c:
    INBOX   
    JUMPZ    e
    SUB      0
    JUMPN    d
    JUMP     c
d:
    ADD      0
    COPYTO   0
    JUMP     b
e:
    COPYFROM 0
    OUTBOX  
    JUMP     a

En termes plus clairs (attention soyez attentif !) :

1. le programme indique qu'il faut prendre une donnée dans celle qui se présentent en entrée (INBOX)
2. la copier dans une case mémoire nommée 0 (COPYTO 0)
3. puis prendre une autre donnée
4. aller à la ligne indiquer e: si cette donnée est égale à zéro (JUMPZ).
5. Dans le cas contraire, retrancher le contenu de la case 0 à la donnée courante (SUB 0)
6. Si le résultat est négatif, allez en d:

7. Sinon revenir en c:

8. Dans le cas où le résultat était négatif et que l'on est maintenant en d:, cela signifie que la nouvelle donnée était plus petite que celle dans la case 0.

9. La nouvelle donnée est rétablie (ADD 0... on ajoute ce qu'on avait retranché) et est mise dans la case 0.

10. On revient en b: pour lire une nouvelle donnée

11. Dans le cas où la donnée était égale à 0, on arrive en e:

12. La donnée présente dans la case 0 est copiée dans la sortie (COPYFROM 0 puis OUTBOX)
13. On reprend tout le depuis le début.

Plus clair ? Mouais... Et en français ? Voici : en entrée se trouvent des suites de nombres qui sont séparées par des 0 (zéro). Pour chaque série, le plus petit des nombres est recopié en sortie. Ce qui est exactement l'énoncé du défi.

Apprentissage ?

Je ne suis pas entièrement persuadé que le jeu soit didactique au point d'enseigner la programmation en assembleur. Cependant, il présente une manière de décrire des problèmes et fait ressentir ce qu'est la programmation de ce type.

Pour un programmeur déjà habitué à l'exercice, le jeu n'est pas très long. Je l'ai terminé en moins de 3 heures, à l'exception du dernier des puzzles optionnels, qui aurait été vraiment long à mettre au point, je n'en avais pas vraiment envie.

Je me demande cependant, pour quelqu'un qui n'est pas programmeur, si le jeu est intéressant et à quel point il est complexe.

Au final, un jeu sympathique avec une petite histoire amusante en fil rouge. Si vous voulez jouer à programmer en assembleur, ce jeu est fait pour vous.