gfx

La taille du dessin en pixels : la taille de la grille de texte multipliée par 6 et par 9.

local t = gfx.size()
print(t.w, t.h)
local grille = term.get_size()
print(grille.w * 6, grille.h * 9)

Écran

Utilisez-la plutôt que des nombres fixes, et le même programme s'adapte à tous les écrans. Ce cadre suit les bords de l'écran, quel que soit l'ordinateur :

local t = gfx.size()
gfx.clear("black")
gfx.line(1, 1, t.w, t.h, "gray")
gfx.line(t.w, 1, 1, t.h, "gray")
gfx.rect(1, 1, t.w, t.h, "yellow", 2)
gfx.text(5, 5, "1,1", "white")
local coin = t.w .. "," .. t.h
gfx.text(t.w - #coin * 4 - 3, t.h - 9, coin, "white")

Écran

Le même code sur un Microcontrôleur, dont l'écran fait 240 × 108 :

local t = gfx.size()
gfx.clear("black")
gfx.line(1, 1, t.w, t.h, "gray")
gfx.line(t.w, 1, 1, t.h, "gray")
gfx.rect(1, 1, t.w, t.h, "yellow", 2)
gfx.text(5, 5, "1,1", "white")
local coin = t.w .. "," .. t.h
gfx.text(t.w - #coin * 4 - 3, t.h - 9, coin, "white")

Écran

Voir aussi term.get_size()

Efface le dessin, ou le remplit entièrement d'une couleur.

Sans couleur, tous les pixels redeviennent vides et les fonds des cases du texte réapparaissent. Cela ne coûte rien. Avec une couleur, toute l'image est peinte, ce qui coûte une instruction pour 64 pixels (817 sur un Micro-ordinateur).

gfx.clear ne touche pas au texte, et term.clear ne touche pas au dessin. Ici, les cases sont mises en gris avec term.set_bg, le dessin les recouvre de bleu, et un rectangle de "none" ouvre une fenêtre où le gris réapparaît :

term.set_bg(term.colors.gray)
term.clear()                                -- la grille de texte : cases grises
gfx.clear("blue")                           -- le dessin les recouvre
gfx.rect(84, 50, 144, 72, "none", true)     -- pixels effacés : le gris revient
term.set_cursor(16, 9)
term.write("un trou dans le dessin")
term.set_cursor(2, 2)
term.write("Le texte est toujours au-dessus")

Écran

Un programme qui redessine son écran depuis zéro commence en général par les deux :

term.set_bg(term.colors.black)
term.clear()
gfx.clear()

Voir aussi term.clear()

La couleur d'un pixel du dessin, sous forme de nombre, même s'il a été dessiné avec un nom. Elle vaut nil là où rien n'est dessiné, hors de l'écran, et partout avant le premier dessin.

gfx.rect(10, 10, 20, 20, "red", true)
print(gfx.get_pixel(15, 15))
print(gfx.get_pixel(15, 15) == term.colors.red)
print(gfx.get_pixel(100, 100))

14
true
nil

Elle ne lit que le dessin, jamais le texte. Elle rend service dans les petits jeux, pour savoir ce qu'une pièce en mouvement va toucher : un mur dessiné en gris, une pièce d'or dessinée en jaune.

Colorie un pixel, ou un carré de size × size pixels centré dessus.

Avec une taille impaire, (x, y) est pile au milieu. Avec une taille paire, la ligne et la colonne en trop vont à droite et en bas. Au-delà de 64, la taille est ramenée à 64. Les points rouges marquent le point donné :

gfx.clear("black")
local tailles = {1, 2, 3, 5, 9, 15, 25}
local x = 16
for i = 1, #tailles do
  gfx.pixel(x, 60, "yellow", tailles[i])
  gfx.pixel(x, 60, "red")
  gfx.text(x - 2, 90, tostring(tailles[i]), "white")
  x = x + 22 + tailles[i]
end
gfx.text(8, 8, "GFX.PIXEL(X, Y, COLOR, SIZE)", "white", 2)
gfx.text(8, 130, "LE POINT ROUGE EST LE POINT (X, Y)", "red")

Écran

Les points sont l'outil idéal pour les relevés : une mesure, un point. Ici une journée d'une courbe d'ensoleillement, un point tous les 4 pixels :

local t = gfx.size()
gfx.clear("black")
gfx.line(1, 150, t.w, 150, "gray")
for x = 1, t.w, 4 do
  local y = 150 - math.max(0, math.sin((x - 20) / 270 * math.pi)) * 120
  gfx.pixel(x, y, "yellow", 3)
end
gfx.text(4, 158, "6:00", "white")
gfx.text(t.w - 22, 158, "18:00", "white")

Écran

Voir aussi gfx.rect() gfx.get_pixel()

Une ligne droite de (x1, y1) à (x2, y2), les deux bouts compris.

Une ligne fine fait un pixel de large et n'a pas de trous, même quand elle monte en pente raide. Une ligne épaisse tamponne un carré de thickness pixels à chaque point : ses bouts sont carrés, et elle coûte plus cher. Une ligne de 100 pixels épaisse de 8 touche 6 400 pixels.

gfx.clear("black")
for i = 1, 4 do
  local e = 2 ^ (i - 1)
  local y = 10 + i * 30
  gfx.line(16, y + 12, 136, y - 8, "orange", e)
  gfx.text(146, y, "EPAISSEUR " .. e, "white")
end
for degres = 0, 330, 30 do
  local a = degres * math.pi / 180
  gfx.line(254, 86, 254 + math.cos(a) * 44, 86 + math.sin(a) * 44, "yellow")
end
gfx.circle(254, 86, 10, "yellow", true)

Écran

Des lignes entre les mesures d'un capteur font un graphique. Chaque segment relie une valeur à la suivante :

local niveaux = {40, 52, 47, 70, 95, 88, 120, 112, 90, 64, 58, 75}
gfx.clear("black")
gfx.rect(10, 10, 286, 150, "gray")
for i = 1, #niveaux - 1 do
  local x1 = 12 + (i - 1) * 25
  local x2 = 12 + i * 25
  gfx.line(x1, 158 - niveaux[i], x2, 158 - niveaux[i + 1], "lime", 2)
end
gfx.text(16, 16, "NIVEAU DU RESERVOIR, 12 DERNIERES HEURES", "white")

Écran

Voir aussi gfx.pixel() gfx.triangle()

Un rectangle de w pixels de large et h pixels de haut, son coin en haut à gauche en (x, y).

Le bord est dessiné à l'intérieur du rectangle : gfx.rect(10, 10, 50, 20, "red", 3) reste dans les mêmes 50 × 20 pixels que le rectangle plein, avec un trou au milieu. Quand le bord fait au moins la moitié du plus petit côté, le rectangle est tout simplement plein. Une largeur ou une hauteur nulle ou négative ne dessine rien.

gfx.clear("black")
gfx.rect(10, 20, 86, 50, "white")
gfx.rect(110, 20, 86, 50, "lime", true)
gfx.rect(210, 20, 86, 50, "orange", 6)
gfx.text(10, 76, "CONTOUR", "white")
gfx.text(110, 76, "TRUE : PLEIN", "white")
gfx.text(210, 76, "6 : BORD", "white")
-- une barre de progression : un cadre, puis la partie remplie
local fait = 0.7
gfx.rect(10, 110, 200, 22, "white")
gfx.rect(12, 112, math.floor(196 * fait), 18, "green", true)
gfx.text(220, 116, math.round(fait * 100) .. "% BROYE", "white")

Écran

Les rectangles pleins sont aussi le moyen le plus rapide d'effacer une partie de l'image avant de la redessiner : peignez-la de la couleur du fond, ou avec "none".

Voir aussi gfx.pixel() gfx.clear()

Un cercle autour de (x, y), ou un disque, ou un anneau.

Le cercle fait 2 × radius + 1 pixels de diamètre. L'épaisseur du bord pousse vers l'intérieur, comme le bord d'un rectangle. Un rayon négatif ne dessine rien.

gfx.clear("black")
gfx.circle(40, 50, 28, "white")
gfx.circle(40, 120, 28, "light_blue", true)
gfx.circle(110, 85, 34, "orange", 6)
gfx.text(14, 160, "CONTOUR, DISQUE, ANNEAU", "white")
-- une Roue dentée de Create : d'abord les dents, puis la roue par-dessus
local cx, cy = 226, 85
for i = 0, 11 do
  local a = i * math.pi / 6
  gfx.pixel(cx + math.cos(a) * 52, cy + math.sin(a) * 52, "brown", 13)
end
gfx.circle(cx, cy, 50, "brown", true)
gfx.circle(cx, cy, 40, "orange", 3)
gfx.circle(cx, cy, 14, "light_gray", true)
gfx.circle(cx, cy, 5, "black", true)

Écran

Avec math.cos et math.sin, les cercles deviennent des voyants, des cadrans et des écrans radar. Une couronne de 8 voyants, allumés selon un motif :

local allumes = {true, true, false, true, false, false, true, true}
gfx.clear("black")
for i = 1, 8 do
  local a = (i - 1) * math.pi / 4 - math.pi / 2
  local x = 153 + math.cos(a) * 60
  local y = 86 + math.sin(a) * 60
  local couleur = "gray"
  if allumes[i] then couleur = "lime" end
  gfx.circle(x, y, 12, couleur, true)
  gfx.circle(x, y, 12, "white")
  gfx.text(x - 1, y - 2, tostring(i), "black")
end

Écran

Voir aussi gfx.rect() math.cos()

Un triangle passant par trois coins, donnés dans n'importe quel ordre.

Contrairement aux rectangles et aux cercles, le triangle n'a pas d'épaisseur de bord : le dernier argument vaut true pour un triangle plein, et tout le reste dessine le contour. Pour un contour épais, tracez trois lignes avec une épaisseur.

Les triangles font des toits, des montagnes, et surtout des flèches :

gfx.clear("black")
gfx.triangle(20, 80, 60, 16, 100, 80, "green", true)
gfx.triangle(120, 80, 160, 16, 200, 80, "white")
gfx.text(20, 88, "PLEIN", "white")
gfx.text(120, 88, "CONTOUR", "white")
-- des flèches de tendance à côté de deux stocks
gfx.triangle(20, 140, 30, 124, 40, 140, "lime", true)
gfx.text(48, 130, "FER  +120/H", "lime")
gfx.triangle(150, 124, 160, 140, 170, 124, "red", true)
gfx.text(178, 130, "CHARBON  -45/H", "red")

Écran

Voir aussi gfx.line()

Le pot de peinture : repeint toute la zone de la même couleur que le pixel en (x, y).

La zone s'étend depuis (x, y) aux voisins du dessus, du dessous, de gauche et de droite qui ont exactement la même couleur que le pixel de départ. Elle s'arrête sur toute autre couleur. Les contours tracés par gfx.line, gfx.circle et gfx.triangle sont fermés pour elle, même là où ils passent en diagonale : l'intérieur d'une forme se remplit sans fuir.

Les pixels vides comptent comme une couleur à part : sur une image effacée avec gfx.clear("black"), un trou fait avec "none" est un mur pour un remplissage qui part du noir.

Rien ne se passe quand le pixel a déjà la nouvelle couleur, ou quand (x, y) est hors de l'écran. Le remplissage s'arrête après 1 048 576 pixels, bien plus que le plus grand écran (82 944 pixels sur un Ordinateur moderne) : en pratique, il remplit toujours toute la zone, à une instruction pour 64 pixels.

Une forme fermée se remplit seulement à l'intérieur. Ouvrez une brèche d'un pixel, et la peinture s'échappe :

gfx.clear("black")
gfx.rect(4, 20, 146, 120, "gray")
gfx.rect(156, 20, 146, 120, "gray")
gfx.circle(77, 80, 40, "white")
gfx.circle(229, 80, 40, "white")
gfx.rect(266, 76, 6, 9, "black", true)     -- une brèche dans le cercle de droite
gfx.fill(77, 80, "orange")
gfx.fill(229, 80, "orange")
gfx.text(30, 148, "FERME", "white")
gfx.text(170, 148, "UNE BRECHE : CA FUIT", "white")

Écran

L'exemple shapes de l'ordinateur s'en sert pour les clics : chaque clic peint la zone sous la souris (voir shapes).

Voir aussi gfx.get_pixel()

Écrit du texte avec une minuscule police de 3 × 5 pixels, à n'importe quel pixel et à n'importe quelle taille. Renvoie la largeur occupée.

Chaque lettre fait 3 points de large et 5 de haut, suivie d'une colonne vide : 4 pixels par caractère, si bien qu'une ligne de 76 caractères tient sur un Micro-ordinateur à l'échelle 1. À l'échelle 2, chaque point devient un carré de 2 × 2 pixels, et ainsi de suite.

La police n'a que des majuscules (les minuscules sont dessinées en majuscules), des chiffres et ces signes : espace . , : ; ! ? ' " - + = / ( ) < > % * _ # [ ]. Les accents sont retirés (É est dessiné E), et tout autre caractère devient ?.

gfx.clear("black")
gfx.text(4, 4, "ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789", "white")
gfx.text(4, 12, ".,:;!?'\"-+=/()<>%*_#[]", "white")
gfx.text(4, 22, "les minuscules deviennent des capitales", "yellow")
gfx.text(4, 30, "Déjà vu : les accents sont retirés", "yellow")
gfx.text(4, 38, "Sans dessin : @ & $ { } ~", "red")
gfx.text(4, 54, "ECHELLE 2", "lime", 2)
gfx.text(4, 72, "ECHELLE 3", "lime", 3)
gfx.text(4, 98, "ECHELLE 6", "orange", 6)

Écran

La largeur renvoyée vaut (4 × caractères - 1) × échelle : la dernière colonne vide n'est pas comptée.

print(gfx.text(1, 1, "SALUT", "white"))
print(gfx.text(1, 10, "SALUT", "white", 2))
print(gfx.text(1, 30, "", "white"))

19
38
0

Comme la largeur est connue d'avance, centrer n'est qu'une soustraction. Gardez une petite fonction comme celle-ci en haut de vos programmes :

local t = gfx.size()
local function centrer(y, texte, couleur, echelle)
  local largeur = (#texte * 4 - 1) * echelle
  gfx.text((t.w - largeur) // 2 + 1, y, texte, couleur, echelle)
end
gfx.clear("blue")
gfx.rect(1, 1, t.w, 30, "black", true)
centrer(9, "GARE DU NORD", "yellow", 3)
centrer(60, "PROCHAIN TRAIN", "white", 2)
centrer(84, "2 MIN", "lime", 5)
centrer(140, "VOIE 3, DIRECTION LA MINE", "white", 1)

Écran

La largeur renvoyée sert aussi à placer le morceau de texte suivant, pour une étiquette suivie d'une valeur d'une autre couleur :

local etat = {
  {"PRESSION", "OK", "lime"},
  {"CHAUDIERE", "CHAUFFE", "yellow"},
  {"STRESS", "SURCHARGE", "red"},
}
gfx.clear("black")
for i, ligne in ipairs(etat) do
  local y = 12 + (i - 1) * 24
  local x = 10 + gfx.text(10, y, ligne[1], "white", 2)
  gfx.text(x + 8, y, ligne[2], ligne[3], 2)
end

Écran

Voir aussi gfx.image() term.write()

Dessine un sprite : une petite image écrite comme du texte, un caractère par pixel.

Chaque ligne est une chaîne. Chaque caractère est un chiffre hexadécimal, le numéro d'une couleur : 0 blanc, 1 orange... 9 cyan, a violet, b bleu, c marron, d vert, e rouge, f noir (les majuscules marchent aussi). Tout autre caractère, comme . ou une espace, est transparent : le pixel garde ce qu'il y avait avant. Le tableau complet est dans Couleurs.

gfx.clear("light_blue")
gfx.rect(1, 110, 306, 62, "green", true)
local creeper = {
  "5d5dd5d5",
  "d5ddd5dd",
  "dffd5ffd",
  "5ffddff5",
  "dd5ffd5d",
  "d5ffffdd",
  "5dffffd5",
  "ddfd5fdd",
}
gfx.image(10, 10, creeper)
gfx.image(30, 10, creeper, 4)
gfx.image(76, 10, creeper, 8)
gfx.text(10, 84, "ECHELLES 1, 4 ET 8", "black")
local fleche = {
  "....4....",
  "....44...",
  "44444444.",
  "444444444",
  "44444444.",
  "....44...",
  "....4....",
}
gfx.image(170, 20, fleche, 4)
gfx.text(214, 32, "NORMAL", "black")
gfx.image(170, 96, fleche, 4, true)      -- en miroir, à moitié sur l'herbe
gfx.text(214, 108, "MIROIR", "black")

Écran

scale fait de chaque pixel un carré, et flip retourne le sprite : un personnage qui marche à gauche et à droite n'a besoin que d'une image. Chaque ligne est retournée sur sa propre longueur : donnez la même longueur à toutes les lignes (complétez avec des .), sinon le sprite retourné se disloque.

Une ligne qui n'est pas une chaîne arrête le programme : bad argument #3 to 'image' (row 2 is not a string). Il n'y a pas de chiffre pour « effacer » : pour retirer un sprite, dessinez par-dessus un rectangle de la couleur du fond (ou de "none").

Voir aussi gfx.text() Couleurs

Fait glisser le dessin de (dx, dy). Ce qui sort de la zone est perdu, et ce qui entre de l'autre côté est vide.

Avec quatre nombres de plus, seul ce rectangle bouge et le reste de l'image ne change pas : une barre d'état peut rester en haut pendant que le paysage défile dessous. Donnez les quatre ou aucun. Le texte de l'écran ne bouge pas (c'est le rôle de term.scroll), et avant tout dessin, l'appel ne fait rien.

Un défilement coûte autant que de remplir sa zone une fois (une instruction pour 64 pixels), quel que soit ce qui y est dessiné : un paysage fait de centaines de formes se déplace pour le prix d'un rectangle, et seule la nouvelle bande au bord reste à dessiner. C'est ainsi que marchent les jeux à défilement horizontal et les graphiques en direct. Ici, les collines arrivent par la droite, 2 pixels par tick, sous une barre de titre qui ne bouge pas :

local t = gfx.size()
local HAUT = 20
gfx.clear("light_blue")
gfx.rect(1, 1, t.w, HAUT - 1, "gray", true)
gfx.text(4, 7, "COLLINES QUI DEFILENT", "white")
local pas = 0
while true do
  pas = pas + 1
  gfx.scroll(-2, 0, 1, HAUT, t.w, t.h - HAUT + 1)  -- tout ce qui est sous la barre, 2 pixels à gauche
  local sol = 120 + math.floor(18 * math.sin(pas / 9) + 7 * math.sin(pas / 3.7))
  gfx.rect(t.w - 1, HAUT, 2, sol - HAUT, "light_blue", true)
  gfx.rect(t.w - 1, sol, 2, 4, "lime", true)
  gfx.rect(t.w - 1, sol + 4, 2, t.h - sol - 3, "brown", true)
  sleep(0.05)
end

Écran

Voir aussi term.scroll()