Clavier

Le clavier d'un ordinateur, c'est la fenêtre de son terminal. Faites un clic droit sur l'ordinateur (ou sur un moniteur qui l'affiche) pour l'ouvrir : tant qu'elle est ouverte, ce que tape le joueur va à l'ordinateur, jusqu'à 16 blocs de distance. Les moniteurs n'ont pas de clavier à eux.

Un programme reçoit le clavier sous forme d'évènements : un évènement key pour les touches spéciales (Entrée, les flèches...), un évènement char pour chaque caractère tapé. Le terminal garde quelques raccourcis pour lui, et read() transforme les touches en une ligne de texte.

#Touches et caractères

Ces dix touches envoient un évènement key, avec le nom de la touche dans e.key :

Tout ce qui tape un caractère envoie à la place un évènement char, avec le caractère dans e.char : les lettres, les chiffres, la ponctuation, et la barre d'espace (e.char == " "). Les lettres gardent leur casse ("a" ou "A", avec Maj ou le verrouillage des majuscules), et la disposition du clavier est celle du joueur : un clavier AZERTY tape "z" là où un clavier QWERTY tape "w".

Les autres touches n'envoient rien au programme : Maj, Ctrl et Alt seules, F1 à F12, Page préc., Page suiv., Inser... et Échap, qui ferme la fenêtre du terminal. Il n'y a pas d'évènement quand une touche est relâchée.

Un petit programme pour voir ce qu'envoie chaque touche :

print("Tapez quelque chose (Ctrl+T pour arrêter)")
while true do
  local e = os.pull_event()
  if e.name == "key" then print("touche : " .. e.key) end
  if e.name == "char" then print("caractère : '" .. e.char .. "'") end
  if e.name == "paste" then print("collage : " .. #e.text .. " caractères") end
end

> testclavier
Tapez quelque chose (Ctrl+T pour arrêter)
caractère : 'S'
caractère : 'a'
caractère : ' '
touche : left
touche : enter
collage : 18 caractères

#Raccourcis du terminal

Le terminal garde ces touches pour lui : un programme ne les voit jamais.

Ctrl+T arrête le programme sur-le-champ : pcall ne peut pas l'attraper. L'écran est effacé (texte, couleurs et dessins), Terminated s'affiche en rouge et l'invite revient. Les sorties redstone et les émissions sur les Liaisons de redstone gardent les valeurs que le programme leur a données : redémarrez (ou éteignez) pour les relâcher. À l'invite, Ctrl+T affiche ^T, abandonne la ligne en cours de frappe et quitte l'interpréteur brass.

Ctrl+R fait comme une coupure de courant : le programme s'arrête, les sorties redstone, les émissions sur les Liaisons de redstone et les lignes de la Liaison d'affichage sont relâchées, la file d'évènements est vidée, puis l'ordinateur démarre et relance startup. Un ordinateur démarre au plus une fois tous les 10 ticks (une demi-seconde) : une demande plus rapprochée attend son tour.

Ctrl+V envoie le texte du presse-papiers, 4096 caractères au plus, sous forme d'évènement paste (rien quand le presse-papiers est vide). À l'invite et dans read(), le texte est tapé dans la ligne à la place, jusqu'à son premier retour à la ligne, les tabulations devenant des espaces.

Éteindre arrête tout comme Ctrl+R et laisse l'écran noir ; l'ordinateur reste éteint, même s'il tourne, jusqu'à Allumer.

#Taper une ligne : read() et l'invite

L'invite du shell et read() partagent le même éditeur de ligne :

• Une ligne contient 1024 caractères au plus. Quand elle est plus large que l'écran, elle défile sur le côté.
• read(masque) affiche le premier caractère de masque à la place de chaque caractère tapé : read("*") pour un mot de passe.
• Pendant que read() attend, les autres évènements restent dans la file pour plus tard : un changement de redstone ou un message n'est pas perdu.
• Les touches tapées avant l'appel de read() ne sont pas perdues non plus : elles attendent dans la file et vont dans la ligne. Un joueur qui tape pendant un sleep voit son texte apparaître au read() suivant.
• L'invite retient les 50 dernières lignes de commande (pas les vides, et pas deux fois la même à la suite).
• Tab à l'invite complète la commande (premier mot), le nom d'un exemple après examples, et les noms de fichiers et de dossiers (je/sn devient jeux/snake/). Dans l'interpréteur brass, il complète les globales et les membres des bibliothèques (term.set_c devient term.set_cursor). Avec plusieurs possibilités, il complète leur début commun.

Un code d'accès masqué, pour une salle forte gardée par une porte en fer sur la face du dessus :

write("Code : ")
local code = read("*")
if code == "creeper" then
  rs.set("top", true)
  sleep(3)
  rs.set("top", false)
else
  print("Mauvais code")
end

#Dans l'éditeur

L'éditeur (edit <fichier>) a ses propres touches, dans l'esprit d'un éditeur de code. Le guide Le shell et l'éditeur les montre à l'œuvre.

Maj avec un déplacement (flèches, Début, Fin, Page préc., Page suiv.) sélectionne. Les raccourcis à lettre suivent la disposition du clavier.

#Exemple : déplacer un curseur

Un programme qui lit les deux sortes d'évènements : les flèches arrivent en évènements key, les lettres en évènements char. Une seule table associe les deux à un déplacement, si bien que les flèches, ZQSD et WASD marchent toutes. Espace laisse une marque, Entrée quitte.

local taille = term.get_size()
local x, y = math.floor(taille.w / 2), math.floor(taille.h / 2)
local marques = {}
local DEPLACEMENTS = {
  up = {0, -1}, down = {0, 1}, left = {-1, 0}, right = {1, 0},
  w = {0, -1}, a = {-1, 0}, s = {0, 1}, d = {1, 0},
  z = {0, -1}, q = {-1, 0},
}

local function poser(texte, couleur)
  term.set_cursor(x, y)
  term.set_fg(couleur)
  term.write(texte)
end

term.clear()
term.set_cursor(1, 1)
term.set_fg(term.colors.yellow)
term.write("Flèches, ZQSD ou WASD : bouger")
term.set_cursor(1, 2)
term.write("Espace : marquer   Entrée : quitter")
poser("@", term.colors.lime)

local actif = true
while actif do
  local e = os.pull_event()
  local deplacement = nil
  if e.name == "key" then
    deplacement = DEPLACEMENTS[e.key]
    if e.key == "enter" then actif = false end
  elseif e.name == "char" then
    deplacement = DEPLACEMENTS[string.lower(e.char)]
    if e.char == " " then marques[x .. "," .. y] = true end
  end
  if deplacement then
    if marques[x .. "," .. y] then poser("#", term.colors.orange) else poser(" ", term.colors.white) end
    x = math.max(1, math.min(taille.w, x + deplacement[1]))
    y = math.max(3, math.min(taille.h, y + deplacement[2]))
    poser("@", term.colors.lime)
  end
end
term.set_fg(term.colors.white)
term.clear()
term.set_cursor(1, 1)

Écran

Le curseur reste sous les deux lignes d'aide (ligne 3 au moins), et math.max / math.min le gardent sur l'écran quelle que soit sa taille : le même programme tourne sur un Microcontrôleur (40 × 12) et sur un Ordinateur moderne (64 × 24).