cours n°10 · Découverte

L'aventure en texte

Un joueur tape deux mots, un jeu répond. Split, case/when et un peu d'état — l'IA avant l'IA.

~11 min7 stations
▶ vidéo🧩 exercices📄 cheat sheet

42 secondes · sous-titres Français inclus · 8.5 Mo

Les 7 trucs que tu vas savoir faire

Leçon 10 : L'aventure en texte

Regarde la leçon (42 s) : avant ChatGPT, une IA s'appelait `split`. Un joueur tape des mots, un jeu répond — et tout tient dans trois idées.

La phrase du joueur

Écris `mots(commande)` : découpe la phrase du joueur en mots — `"prendre epee"` → `["prendre", "epee"]`. Un espace, deux mots : l'IA d'avant, c'était `split`.

Le verbe commande

Écris `verbe(commande)` : le PREMIER mot — c'est lui qui décide. `"prendre epee"` → `"prendre"` · `" ouvrir porte"` → `"ouvrir"` (les espaces en trop ne comptent pas).

Le nom, ou rien

Écris `nom(commande)` : le DEUXIÈME mot, ou `nil` s'il n'y en a pas. `"prendre epee"` → `"epee"` · `"ouvrir grande porte"` → `"grande"` · `"marcher"` → `nil`. Une commande sans objet n'a pas de nom.

Reconnaître : deux mots exacts

Écris `reconnait?(commande, verbe, nom_attendu)` : true seulement si la commande fait EXACTEMENT ces deux mots, dans l'ordre. `"epee prendre"` n'est pas `"prendre epee"` — le parser d'avant ChatGPT : deux mots, point final.

Le vocabulaire du gardien

Écris `reponds(sujet)` : le garde parle par répliques prêtes — `"cle"` → `"Il désigne la serrure, sans un mot."` · `"bonjour"` → `"— Tu parles ? Ici, on répond par des gestes."` · tout autre sujet → `"— …"` (le silence : je ne comprends pas).

Leçon 10 : OK

Sans aide : `reponse(etat, commande)` — l'ÉTAT + la commande exacte choisissent la réplique. `"prendre epee"` en `:debut` → `"L'épée est à toi."` · la même commande en `:fin` → `"Déjà prise."` · toute autre commande → `"— …"`.

Partage la leçon

← tous les cours

📄 La feuille de chute

imprime-la, colle-la à ton écran, fais semblant que c'est ton idée

📄 Cheat sheet — L'aventure en texte (le parser avant ChatGPT)

Avant ChatGPT, une IA s'appelait split. Le joueur tape deux mots, le jeu répond — et ça n'a jamais rien compris. C'est pour ça que ça marchait.

L'histoire, en trois lignes

Année Œuvre Apport
1976 Colossal Cave Adventure (Crowther) le premier monde écrit en mots
1977 Zork (4 étudiants du MIT) le parser VERB + NOM
1979-80 Scott Adams · Infocom répliques rangées + états (la « mort » sauvegardée)

Aucun modèle, aucun entraînement : des phrases rangées dans un tableau. Le joueur tape, le jeu compare. Le « langage », c'est un case/when.

Le parser : la chaîne complète

def mots(commande)
  commande.split          # "prendre epee" → ["prendre", "epee"]
end
def verbe(commande)
  commande.split.first    # → "prendre"
end
def nom(commande)
  commande.split[1]       # → "epee"  (ou nil : pas d'objet)
end
def reconnait?(commande, verbe, nom)
  commande.split == [verbe, nom]   # deux mots, dans l'ordre, exactement
end
reconnait?("prendre epee", "prendre", "epee")   # => true
reconnait?("epee prendre",   "prendre", "epee") # => false — l'ordre compte

Le standard d'or du genre : « I don't understand the word ___ » — le jeu répond non vingt fois de suite. Un parser honnête sait dire non.

Le dialogue : des répliques rangées

def reponds(sujet)
  case sujet
  when "cle"     then "Il désigne la serrure, sans un mot."
  when "bonjour" then "— Tu parles ? Ici, on répond par des gestes."
  else "— …"                 # le silence = "je ne comprends pas"
  end
end

Chaque sujet connu a sa ligne ; le else est obligatoire — sans lui, l'inconnu répond nil et le personnage « plante » en plein milieu de la phrase.

L'état : la même commande, deux répliques

def reponse(etat, commande)
  case [etat, commande]                    # compare la PAIRE
  when [:debut, "prendre epee"] then "L'épée est à toi."
  when [:fin,   "prendre epee"] then "Déjà prise."
  else "— …"
  end
end

La mémoire du jeu n'est rien d'autre que une variable (:debut, :fin) qui change quelles lignes sont vraies. ChatGPT improvise ici ; ton case/when se souvient.

La boucle (ce que le joueur appelle « jouer »)

# 1. lire  2. mots → verbe + nom  3. reconnait?  4. reponse(etat, commande)  5. afficher
# …puis 1. encore, jusqu'à : Tu es mort. Partie terminée.

À ne plus jamais dire

  • "il faut un LLM pour dialoguer avec le joueur" → un case/when et un else
  • "le parser doit tout comprendre" → deux mots exacts ; le reste, c'est de l'écriture d'auteur
  • "une IA, c'est un modèle" → en 1977, c'était split.

SlopCourse Microduck — du slop au code propre.