Lua

Pour les articles homonymes, voir Lua (homonymie)   

---

Modèle:Infobox Langage de programmation

Lua est un langage de script libre, réflexif et impératif.

Créé en 1993, il est conçu de manière à pouvoir être embarqué au sein d'autres applications afin d'étendre celles-ci. Lua (du Modèle:Lang-pt Modèle:API, au Brésil : Modèle:API, signifiant « Lune ») a été développé par Luiz Henrique de Figueiredo, Roberto Ierusalimschy (en)Modèle:Lien/catégorisation et Waldemar Celes, membres du groupe de recherche TeCGraf, de l'université pontificale catholique de Rio de Janeiro au Brésil.

L'interpréteur Lua est écrit en langage C ANSI strict, et de ce fait est compilable sur une grande variété de systèmes. Il est également très compact, la version 5.0.2 n'occupant que Modèle:Unité à Modèle:Unité selon le compilateur utilisé et le système cible. Il est souvent utilisé dans des systèmes embarqués tels qu'OpenWrt où cette compacité est très appréciée. Il profite de la compatibilité que possède le langage C avec un grand nombre de langages pour s'intégrer facilement dans la plupart des projets.

Il est particulièrement apprécié pour l'embarqué, le développement réseau et les jeux vidéo.

Le Lua est utilisé dans des jeux vidéo comme : Transformice, World of Warcraft, Roblox, Garry's Mod, Onset, computercraft mod (mod de Minecraft), Multi Theft Auto (mod multijoueur de Grand Theft Auto: San Andreas), FiveM (mod multijoueur de Grand Theft Auto V), ainsi que les moteurs de jeu vidéo tels que le SourceEngine, CryENGINE, LÖVE, ou encore les Fantasy consoles, tel que Pico-8.

Il est également utilisé au niveau réseau comme hook sur Apache, Lighttpd (par défaut), Nginx (via OpenResty), dans les routeurs Cisco, dans l'analyseur de paquets Wireshark, l'antispam Rspamd, l'autocommutateur téléphonique privé Asterisk (optionnel), pour les scripts de MediaWiki.

Généralités

Commentaires

En Lua, les commentaires débutent par -- et finissent à la fin de la ligne, comme en Ada. Si la première ligne commence par #! (shebang) elle est aussi traitée comme un commentaire. Les commentaires multilignes sont également disponibles avec la syntaxe <syntaxhighlight lang="lua">--... </syntaxhighlight>

Variables

Les variables peuvent contenir nil (la valeur nulle, vide), un booléen, une chaîne de caractères, un nombre (pas de différence entre entier et flottants), une table ou une fonction. Il existe aussi d'autres types comme userdata ou thread moins souvent rencontrés. Le type userdata est très pratique, il correspond à un objet C/C++ défini par l'utilisateur : il est donc possible de créer une structure C ou une classe C++, et d'utiliser des objets de ce type dans un script Lua, après avoir attaché à cet objet une métatable qui se charge d'appeler les fonctions de la classe C++. On peut donc imaginer de créer les classes métier de base d'un programme en C, et coder l'application elle-même en Lua, ce qui accélère considérablement son développement grâce aux outils de haut niveau fournis par le langage.

En interne on peut aussi rencontrer les proto, une sorte de prototype de fonction, le bytecode de cette fonction étant chargé mais ce dernier n'a pas été exécuté; On rencontrera les protos quand un fichier est chargé (compilé) mais pas exécuté ou bien avec les closures.

Par défaut, lorsqu'on déclare une variable, elle est globale à tout l'environnement d'exécution, sauf si elle est précédée du mot-clef local.

Les chaînes de caractères sont délimitées par des guillemets simples (') ou doubles ("), voire la marque de chaîne littérale <syntaxhighlight lang="lua"> ... </syntaxhighlight> (multiligne, pas de caractère spécial). L'opérateur de concaténation de chaînes se représente par deux points (..).

Les fonctions

Les fonctions sont considérées comme des variables. Cela apporte une grande flexibilité : il est par exemple possible de créer des fonctions locales à une autre fonction, de passer une fonction comme paramètre d'une autre fonction (ou comme valeur de retour) ou de mettre des fonctions dans des tables. Si on affecte nil à une fonction (eg. print = nil), la fonction n'existe plus, n'est plus appelable.

Un avantage des fonctions en Lua est qu'elles peuvent prendre un nombre indéfini de paramètres mais aussi qu'elles peuvent retourner plusieurs valeurs.

Les tables, métatables

Les tables sont une structure Lua qui permet de stocker des variables indexées par une clef (comme en PHP par exemple). Les tables servent à beaucoup de choses en Lua.

Ces dernières sont utilisées de deux manières différentes :

• Une liste (avec un index commençant à 1 et non à 0)
• Une hashtable (faisant office de struct), pouvant prendre en clé et en valeur tout type de variable non nil.

Il est tout à fait possible (mais fortement déconseillé pour des questions de qualité de code) d'avoir une table qui mêle liste et hashtable.

La convention veut qu'on parcoure une liste avec l'itérateur ipairs et la hashtable avec l'itérateur pairs .

Dans une table, il est impossible d'assigner une variable à nil ou l’indexer à la clé nil.

Les métatables sont des tables pour lesquelles on a associé une fonction à chaque opérateur de base (+, -, (), []...). Ce mécanisme est très proche de la surcharge des opérateurs en C++. Par exemple, si la variable x contient une table associée à une métatable appropriée, l'appel de fonction x(arguments) sera valide car Lua cherchera alors dans la métatable comment traiter cet appel.

C'est ainsi qu'on peut implémenter l'héritage entre tables. Si un champ n'est pas trouvé lorsqu'il est demandé, Lua cherchera dans la métatable quelle table est parente et demandera à la table parente de fournir l'élément approprié.

Exemples

Condition

<syntaxhighlight lang="lua"> if condition1 and condition2 then

-- instructions exécutées si les conditions 1 et 2 sont vraies

elseif condition1 then

-- instructions exécutées si la condition 1 est vraie et la condition 2 est fausse

elseif condition2 then

-- instructions exécutées si la condition 2 est vraie et la condition 1 est fausse

else

-- instructions exécutées si les deux conditions sont fausses

end </syntaxhighlight>

Boucles

<syntaxhighlight lang="lua"> repeat

-- code

until condition </syntaxhighlight> et <syntaxhighlight lang="lua"> while condition do

-- code

end </syntaxhighlight> ainsi que <syntaxhighlight lang="lua"> for var = start, valend, step do

-- code

end </syntaxhighlight> ou <syntaxhighlight lang="lua"> for var_1, ..., var_n in explist do

-- code

end </syntaxhighlight>

Déclaration de fonctions

<syntaxhighlight lang="lua"> function mafonction(arg1, arg2, ...)

-- code
return résultat1, résultat2

end </syntaxhighlight> ou <syntaxhighlight lang="lua"> mafonction = function (arg1, arg2, ...)

-- code
return résultat1, résultat2

end </syntaxhighlight>

Appels de fonction

<syntaxhighlight lang="lua"> res1, res2 = mafonction(var) </syntaxhighlight>

Blocs inconditionnels

Les blocs inconditionnels servent par exemple à déclarer des variables locales à ce bloc : <syntaxhighlight lang="lua"> do

local mavariable = "chaîne" -- déclaration de variable, optionnel
-- code utilisant mavariable

end </syntaxhighlight>

Déclaration de table

Table à indices numériques consécutifs (En Lua, le premier indice d'une table est 1) <syntaxhighlight lang="lua">a = { 5, "foo", C:\Lua\Lua.exe, 'bar', 42 } </syntaxhighlight> Table à indices explicites, indiqués entre crochets (les indices qui sont des chaines ayant la syntaxe d'une variable n'ont pas besoin de guillemets ni de crochets) <syntaxhighlight lang="lua">a = { d = 5, [12] = "foo", ['chaîne avec espace'] = true } </syntaxhighlight> Quand on assigne une variable a une autre, si la valeur de celle-ci n'est pas un nombre, une chaine de caractères ou un booléen alors la référence de celle-ci est copiée. Donc, dans le cas des tables, si une variable a possède une table et qu'on assigne à la variable b la variable a alors toutes modifications subies par a seront directement visibles sur b <syntaxhighlight lang="lua"> local a = {1,"b",3} local b = a a.foo = "bar" print(b.foo) -- bar -- b et a on les mêmes références </syntaxhighlight> Table stockant des variables complexes : autres tables, fonctions, références croisées... Lorsque les valeurs en tant qu'indice ne sont pas des nombres, des chaines de caractères ou des booléens, alors l'indice sera la référence de la variable en question. <syntaxhighlight lang="lua"> fonction = function (a, b) return (a + b) / a * b end t = { b = { -- Fonction comme clé -- La référence de la fonction agira comme clé [fonction] = 'Fonction !', -- Index numérique [5] = 42, -- Index chaîne simple (ie. syntaxe d'une variable) ls = [[Valeur Multiligne]] , -- Index chaîne quelconque ['Expression rationnelle'] = [[(?:\d{1,3}\.){3}\d{1,3}]], [ C:\Lua\Lua.exe ] = true, }, -- Stockage d'une fonction f = function () return math.random(100) end, ff = fonction, -- Table comme clé -- La table étant anonyme, aucune référence a cette table est stockée et donc la valeur stockée inaccessible [ { 'a', 'b' } ] = { "aa", "bb" }, } -- Référence dans la table t.reference = t.a t.self = t -- Référence a soi même t.self.réference = t.a print(t[ { t.a, t.b } ]) -- nil car aucune valeur n'a pour clé la référence de cette nouvelle table, l'ancienne table a une référence différente </syntaxhighlight>

Les fonctions

Les fonctions mathématiques

La fonction math.pi permet de retourner la valeur de pi.<syntaxhighlight lang="lua"> print(math.pi) --> Affiche dans la console la valeur de pi (3.1415926535898) </syntaxhighlight>La fonction math.min(liste) retourne le plus petit nombre contenu dans une liste<syntaxhighlight lang="lua"> print(math.min(6,4,2,9,1)) --> Affiche 1 dans la console étant donné que 1 est le plus petit nombre de la liste. </syntaxhighlight>La fonction math.max(liste) retourne le plus grand nombre contenu dans une liste<syntaxhighlight lang="lua"> print(math.max(4,6,7,9,1)) --> Affiche 9 dans la console étant donné que ce nombre est le plus grand de sa liste. </syntaxhighlight>La fonction math.floor(x) permet de retourner le plus grand entier inférieur ou égal à x.<syntaxhighlight lang="lua"> print(math.floor(1.5)) --> Retourne dans la console le nombre 1 print(math.floor(1.5 + 0.5)) --> Retourne dans la console le nombre 2 </syntaxhighlight>La fonction math.abs(x) permet de retourner la valeur absolue de x.<syntaxhighlight lang="lua"> print(math.abs(-100)) --> Retourne dans la console le nombre 100. </syntaxhighlight>La fonction math.pow(x, y) permet de retourner x à la puissance de y. On peut aussi utiliser l'expression x^y<syntaxhighlight lang="lua"> print(math.pow(6,8)) --> Retourne dans la console le nombre 1679616. -- On peut également utiliser: print(6^8) </syntaxhighlight>La fonction math.random(x, y) retourne un nombre aléatoire entre la valeur x et la valeur y.<syntaxhighlight lang="lua"> local x = 1 local y = 10

print(math.random(x, y)) --> Retourne dans la console un nombre entier aléatoire entre 1 et 10. </syntaxhighlight>La fonction math.sqrt(x) retourne la racine carrée de x.<syntaxhighlight lang="lua"> local x = 6 print(math.sqrt(x)) --> Retourne la racine carrée de x(6) donc 2.4494897427832. </syntaxhighlight>

Les fonctions os

La fonction os.time() retourne le nombre de secondes entre le Modèle:Date- à 00:00 et la seconde à laquelle vous appelez la fonction.<syntaxhighlight lang="lua"> print(os.time()) </syntaxhighlight>La fonction os.date() retourne le jour, le mois, le numéro du mois, l'heure, les minutes, les secondes et l'année à laquelle vous êtes quand vous appelez cette "fonction"<syntaxhighlight lang="lua"> print(os.date()) --> Retourne Thu Jul 1 14:52:59 2021 </syntaxhighlight>La fonction os.clock() retourne le temps écoulé en seconde depuis que Lua a été lancé.<syntaxhighlight lang="lua"> print(os.clock()) --> Retourne dans la console 853312.913685 </syntaxhighlight>

La fonction type

La fonction type(x) permet de donner le type de x.<syntaxhighlight lang="lua"> local a = "Bonjour" local b = 5 local c = true local d

print(type(a)) --> Retourne dans la console "string" car la variable est de type string. print(type(b)) --> Retourne dans la console "number" car la variable est de type number. print(type(c)) --> Retourne dans la console "boolean" car la variable est une valeur booléene print(type(print())) --> Retourne dans la console "function" car string est une fonction. print(type(d)) --> Retourne nil dans la console "nil" car la variable d ne contient pas de valeur. </syntaxhighlight>

Les fonctions table

En lua, il existe 9 fonctions table.

La fonction table.insert(x, y, z) permet d'insérer une valeur y dans un tableau x. On peut aussi lui donner une position à laquelle s'ajouter en rajoutant un argument z. Si aucun argument z n'est donné, la valeur s'affichera en dernière position de la table.<syntaxhighlight lang="lua"> local tableau = {"je", "suis", "un", "utilisateur", "du"} table.insert(tableau, "wiki") --> Insert dans la variable tableau enla valeur wiki. Le troisième argument pour donner la position n'est pas donné donc la valeur se positionnera en dernière place du tableau. </syntaxhighlight>La fonction table.remove(x, y) permet de retirer du tableau x une valeur en indiquant la position de la valeur y.<syntaxhighlight lang="lua"> local tableau = {"je", "suis", "un", "faux", "utilisateur"}

table.remove(tableau, 4) --> Retire la valeur "faux" du tableau qui était en 4ème position. Malheureusement, on ne peut pas retirer de valeur en indiquant le nom de la valeur, si vous voulez retirer une valeur sans connaître le numéro de position, merci de suivre le paragraphe si dessous avec les boucles pairs(). </syntaxhighlight>La fonction table.sort(x) permet de trier et modifier la position des éléments du tableau x.<syntaxhighlight lang="lua"> local tableau = {6, 4, 5, 3, 2, 1} table.sort(tableau) --> Va venir trier les valeurs du tableau et le modifier en {1, 2, 3, 4, 5, 6} </syntaxhighlight>La fonction table.concat(x, y) permet de regrouper l'ensemble des valeurs d'un tableau et les transforme en chaines de caractères. Le y est un argument facultatif qui peuvent servir de séparateur entre chaque groupement de valeurs.<syntaxhighlight lang="lua"> local tableau = {"un", "renard", "caché", "dans", 1, "arbre"} local concatTableau = table.concat(tableau)

print(concatTableau) --> Retourne dans la console la valeur unrenardcachédans1arbre </syntaxhighlight>On peut aussi ajouter un séparateur lors du trie (y).<syntaxhighlight lang="lua"> local tableau = {"un", "renard", "caché", "dans", 1, "arbre"} local concatTableau = table.concat(tableau, " | ")

print(concatTableau) --> Retourne dans la console: un | renard | caché | dans | 1 | arbre. L'argument y était " | " donc y a été ajouté entre chaque valeurs transformées. </syntaxhighlight>La fonction table.foreach(x, z) ne fonctionne plus depuis la version 5.1 de lua et doit être remplacée par les boucles pairs(), voir ci-dessous.<syntaxhighlight lang="lua"> -- Maintenant obsolète. </syntaxhighlight>La fonction table.foreachi(x, y) ne fonctionne plus depuis la version 5.1 de lua et doit être remplacée par les boucles ipairs().<syntaxhighlight lang="lua"> -- Maintenant obsolète. </syntaxhighlight>La fonction table.getn(x) permet d'afficher la taille d'un tableau x.<syntaxhighlight lang="lua"> local tableau = {"un", "renard", "gentil"} local longueur = table.getn(tableau)

print(longueur) --> Retourne dans la console la longueur du tableau "tableau" donc 3. </syntaxhighlight>

Les fonctions strings

Les fonctions strings permettent de traiter les strings, il en existe 15.

Le string.find(x, y) permet de rechercher des caractères y dans le string x. Si ça retourne nil, rien a été trouvé, en revanche, si quelque chose est trouvé, ça va indiquer à partir de quel emplacement les caractères recherchaient sont trouvés.<syntaxhighlight lang="lua"> local variable = "Bonjour, je m'appel Lua." local find = string.find(variable, "our")

if find then -- Si find n'est pas égal à nil est donc il a trouvé quelque chose alors

   print(find) -- Retourne le numéro de commencement des caractères recherchaient. En l'occurence, 5.

end </syntaxhighlight>On peut aussi rajouter un argument z qui permet de commencer à chercher les caractères y à partir d'un certain caractère.<syntaxhighlight lang="lua"> local MA_VARIABLE = "Je suis quelqu'un qui suis une autre personne." local resultat = string.find(MA_VARIABLE, "is", 17)

if resultat then -- S'il a trouvé dans le string à partir du caractère 17 un mot contenant is alors:

   print(resultat) -- Retourne dans la console l'endroit où se situe le début des caractères souhaitaient. En l'occurence, 25. 

end </syntaxhighlight>Le string.byte(x, y, z) permet de retourner le code numérique des caractères (Code ASCII) de la string x.<syntaxhighlight lang="lua"> local MA_VARIABLE = "Je suis une gentille personne" local RESULTAT_ASCII = string.byte(MA_VARIABLE)

print(RESULTAT_ASCII) --> Retourne dans la console le résultat de la conversion de la string en code numérique ASCII </syntaxhighlight>Il est aussi possible d'utiliser l'argument y pour définir un début de conversion ainsi que l'argument z pour définir la fin de conversion (numéro de caractère).<syntaxhighlight lang="lua"> local MA_VARIABLE = "Je suis une gentille personne" local RESULTAT_ASCII = string.byte(MA_VARIABLE, 1, 10) --> Retourne la conversion du caractère 1 à 10 de la string

print(RESULTAT_ASCII) --> Retourne dans la console le résultat de la conversion en ASCII du caractère 1 à 10 de la string. </syntaxhighlight>Le string.char(x) permet de convertir le code numérique x qui est en code ASCII en caractères normaux.<syntaxhighlight lang="lua"> local ASCII_CODE = 74 local RESULTAT = string.char(ASCII_CODE)

print(RESULTAT) --> Retourne dans la console la conversion du code numérique ASCII en caractères numériques (de la variable ASCII_CODE) </syntaxhighlight>Le string.dump(x) permet de convertir la fonction x en représentation binaire pour pouvoir ensuite être appelé par la fonction loadString(y).<syntaxhighlight lang="lua"> function demonstration()

   print("Lancement de la fonction")

end

local dumped = string.dump(demonstration) assert(loadstring(dumped)) ()

--> Retourne dans la console "Lancement de la fonction." </syntaxhighlight>Le string.format() permet de retourner une chaine de caractères formatée.<syntaxhighlight lang="lua"> print(string.format("Je suis %s, j'adore les %s, et j'aime le chiffre %i", "gentil", "bananes", 15)) --> Je suis gentil, j'adore les bananes, et j'aime le chiffre 15

--> %s permet de rajouter des strings --> %i permet de rajouter des nombres </syntaxhighlight>Le string.gmatch(x, y) permet de retourner une sous-chaîne de la chaîne principale x.<syntaxhighlight lang="lua"> for i in string.gmatch("Je suis quelqu'un de gentil", "%a+") do print(i) end

Je suis quelqu un de gentil </syntaxhighlight>Le string.gsub(x, y, z) permet de remplacer les mots y d'une string x par un autre mot z.<syntaxhighlight lang="lua"> print(string.gsub("Je suis une personne", "une personne", "un zombie")) -- string.gsub(x(la string), y(mot à remplacer), z(mot qui remplace)) --> Je suis un zombie </syntaxhighlight>Le string.upper(x) permet de retourner le texte d'une string x en modifiant les minuscules en MAJUSCULES (sauf caractères spéciaux).<syntaxhighlight lang="lua"> local MA_STRING = "Je suis un éléphant Rose" print(string.upper(MA_STRING))

--> JE SUIS UN éLéPHANT ROSE </syntaxhighlight>Le string.lower(x) permet de retourner le texte d'une string x en modifiant les MAJUSCULES par des minuscules.<syntaxhighlight lang="lua"> local MA_STRING = "JE SUIS QUELQU'UN" print(string.lower(MA_STRING))

--> je suis quelqu'un </syntaxhighlight>Le string.reverse(x) permet de retourner le texte d'une string x en inversant la chaîne de caractères.<syntaxhighlight lang="lua"> local MA_STRING = "je suis un scripter" print(string.reverse(MA_STRING))

--> retpircs nu sius ej </syntaxhighlight>Le string.sub(x, y, z) permet de retourner une sous-chaîne de la string x en gardant uniquement le caractère souhaitait y. S'il y'a un argument z, ça va récupérer la sous-chaîne du caractère y au caractère z. Si l'argument y est négatif, ça va commencer à l'envers et prendre la fin de phrase.<syntaxhighlight lang="lua"> local MA_STRING = "je suis un scripter" print(string.sub(MA_STRING, 1, 7))

--> je suis

print(string.sub(MA_STRING, -2))

--> e </syntaxhighlight>Le string.rep(x, y) permet de multiplier le contenu de la string x avec le nombre de y.<syntaxhighlight lang="lua"> local MA_STRING = "je suis " print(string.rep(MA_STRING, 5))

--> je suis je suis je suis je suis je suis </syntaxhighlight>Le string.match(x, y, z) permet de retourner une sous-chaîne de caractères de la string x en prenant ce qui est souhaitait en y commençant avec le caractère z. Z étant facultatif.<syntaxhighlight lang="lua"> local MA_STRING = "Je suis un scripter" print(string.match(MA_STRING, "s..."))

--> suis

local DEUXIEME_STRING = "Je suis un scripter" print(string.match(MA_STRING, "s...", 12))

--> scri </syntaxhighlight>

La fonction pairs()

La fonction pairs(x) permet de chercher différents éléments d'un tableau. Elle sert actuellement à remplacer la fonction table.foreach qui est éronnée depuis la version de lua 5.1. Son utilisation est simple, elle vient prendre le premier argument après le mot for pour faire en sorte que ce soit l'index donc qu'il porte le numéro de position dans le tableau. Et après, le deuxième argument qu'on appel souvent v pour value qui indique la valeur. Ce qui donne for i, v in pairs(x) do. Le i est le numéro de position de la valeur dans le tableau et le v est la valeur.

Pour trouver une valeur dans le tableau, on vas donc insérer un argument qui sera le nom du tableau x. <syntaxhighlight lang="lua"> local tableau = {"premier", "second", "troisième", "quatrième", "cinquième"}

for i, v in pairs(tableau) do

   print(i, v)

end

--> Résultat dans la console: 1 premier 2 second 3 troisième 4 quatrième 5 cinquième </syntaxhighlight>Pour pouvoir retirer une valeur d'un tableau, on utilise aussi cette fonction, en les traitant jusqu'à récupérer le bon numéro:<syntaxhighlight lang="lua"> local tableau = {"un", "deux", "trois", "quatre", "cinq"}

local compteur = 0 -- Mettre la valeur à 0 pour pouvoir ensuite ajouter une valeur à chaque traitement. for index, value in pairs(tableau) do

   compteur += 1 -- Ajoute un au compteur
   if value == "trois" then
       table.remove(tableau, compteur) -- Retire du tableau la valeur trois.
       break -- Arrêt de la boucle.
   end

end </syntaxhighlight>

La fonction pcall()

La fonction pcall() est utilisée pour isoler les erreurs contenus dans une fonction. Cela permet d'empêcher l'arrêt du script et d'afficher s'il y'a une erreur ou non avec possibilité de voir de quelle erreur il s'agit.<syntaxhighlight lang="lua">

pcall(function()

print(table.find("s")) --> est une erreur. print("Salut") end)

print("Je suis quelqu'un de gentil")

--> Dans la console: Je suis quelqu'un de gentil </syntaxhighlight>La fonction pcall() peut aussi être mise en fonction avec deux variables précédentes<syntaxhighlight lang="lua"> local success, error = pcall(function() print(table.find("s")) --> est une erreur. print("Ca marche") end)

print("Je suis quelqu'un de gentil")

if not success then -- S'il y'a pas de succès et donc a une erreur, alors:

   print(error)

end

--> Dans la console:

Je suis quelqu'un de gentil Script:2: invalid argument #1 to 'find' (table expected, got string) </syntaxhighlight>

Hello World

<syntaxhighlight lang="lua"> print('Hello World!') </syntaxhighlight>

Usages

Consoles

Lua a été embarqué dans la PlayStation Portable de Sony, grâce au programme Lua Player, et plus récemment Lua Player HM et Lua Player Euphoria qui permettent de lire des applications écrites avec Lua afin d'étendre les capacités de la console. Viendra plus tard l'XtreamLua Player, destiné à la création de jeux vidéo. Une modification (non officielle) du micrologiciel de la PSP permettait de lancer des programmes non-signés par Sony d'où la création d'un interpréteur Lua adapté pour la PSP.

Lua Player Euphoria reprend la syntaxe du Lua Player original et exécute le script à une vitesse fulgurante comparé au Lua Player HM. Cependant, Lua Player Euphoria est moins complet que son homologue plus ancien.

Lua Player One, un des derniers Lua Player mis à jour pour PSP, est un Lua Player développé au sein d'une communauté de développeurs espagnols ; il permet, entre autres, de gérer la 3D sur PSP. Un jeu de mini-golf dans l'espace a été développé à l'aide de cet outil.

Lua Player Plus (LPP) est sorti sur PlayStation Vita le Modèle:Date-. Ce Lua Player permet de créer des jeux pour la console.

Lua est inclus dans la console de poche open-source Pocket Chip (projet Kickstater). En effet cette dernière embarque le programme de console virtuel Pico-8 qui permet de jouer et de créer des jeux en Lua.

Extensions de jeux vidéo

Parmi les jeux vidéo de bac à sable qui l'utilisent figurent Garry's Mod, Roblox, Core, Stormworks (en)Modèle:Lien/catégorisation et Minecraft. Pour ce dernier, Modèle:Langue, une extension du jeu Minecraft, utilise Lua pour concevoir des programmes graphiques ou consoles et des « robots » autonomes à l'intérieur du jeu, permettant d'automatiser de nombreuses tâches répétitives ; Minetest, un jeu sandbox sous licence LGPL similaire à ce dernier, utilise Lua comme langage pour l'écriture d'extensions et à l'intérieur même du jeu (via certains modes) via la programmation de microcontrôleur ou de FPGA.

Il existe également un moteur de jeu utilisant Lua comme langage de programmation (une sorte de Pygame pour Lua) : LÖVE.

Beaucoup d'autres jeux vidéo l'utilisent, comme World of Warcraft de Blizzard Entertainment, Far Cry (et le moteur CryEngine en général) de Crytek Studios, le logiciel multijoueurs de GTA:SA Multi Theft Auto, SimCity 4 et Natural Selection 2 de Unknown Worlds Entertainment (qui a entre autres développé Decoda, un IDE pour Lua). Enfin, certains scripts de Zoo Tycoon 2 (Blue Fang Games) sont également présents sous des formes non compilées dans les fichiers du jeu. The Binding of Isaac: Afterbirth+ est un DLC pour le jeu The Binding of Isaac: Rebirth qui permet le support de mods écrits en Lua.

Autres logiciels

Lua est également utilisé pour l'extension des capacités du lecteur multimédia VLC, dans les gestionnaires de fenêtres EFL Edje d'Enlightenment ainsi que Awesome (comme langage de configuration et de script).

Le PABX Asterisk propose Lua comme alternative pour étendre son plan de numérotation.

MediaWiki et les sites Wikimedia utilisent Lua comme langage de script pour les modèles (appelés modules).

Le logiciel CraftStudio utilise Lua pour programmer les éléments dynamiques des modèles.

Le logiciel libre d'interface neuronale directe OpenVibE (en)Modèle:Lien/catégorisation utilise Lua comme langage de script, en particulier pour la gestion de stimuli pour les expériences de neuroscience.

Le robot IRC irccd utilise Lua pour la création de plugins.

L'antispam Rspamd utilise également Lua pour son interface de programmation.

Lua est le langage de scripting principalement utilisé pour le système d'exploitation embarqué OpenWrt fonctionnant sur de nombreux routeurs. L'interface graphique d'administration LuCI est entièrement écrite en Lua.

Lua est le langage natif de Domoticz, logiciel de domotique Modèle:Langue. Il permet le Modèle:Langue avec des fonctionnalités avancées : Domoticz déclenche automatiquement ces scripts sur les changements d’états, en fonction du temps, etc.

Lua est également le langage natif de NSBase, logiciel de gestion de bases données. Le scripting permet de dynamiser les formulaires, rapports. Lua ainsi intégré permet de créer de véritables applications de gestion de bases de données.

Le logiciel de simulation de vol spatial Orbiter et ses add-ons (UCGO, UMmu) utilisent Lua pour permettre la création aisée d'écrans de contrôle (MFD - Multi Function Display), de missions ou de vaisseaux. La création de vaisseaux, en particulier, à la différence de modules DLL, ne nécessite pas la compilation d'un fichier C++.

BeamNG.drive utilise Lua pour compléter ses équations physiques.

Prosody : serveur XMPP léger écrit entièrement en lua.

L'environnement de bureau Awesome (linux) utilise aussi Lua dans ses fichiers de configuration depuis sa version 3.

FreeBSD intègre un interpréteur lua dans son chargeur depuis la version 11.3.

La solution qui associe le montage, l’étalonnage, les effets visuels, les animations graphiques et la post-production audio Davinci Resolve utilise Lua, Py2 et Py3

Notes et références

Annexes

Bibliographie

• Lua 5.2 Reference Manual sur http://www.lua.org, Lua.org et université pontificale catholique de Rio de Janeiro. Consulté le 14 mai 2014
• (eng) Roberto Ierusalimschy, Programming in Lua, Rio de Janeiro, Lua.org et université pontificale catholique de Rio de Janeiro, janvier 2013, 3^e éd. (1^re éd. 2003), 347 p. (ISBN 978-85-903798-5-0 et ISBN 85-903798-5-X) 
• (eng) Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo, Lua Programming Gems, Rio de Janeiro, Brésil, Lua.org et université pontificale catholique de Rio de Janeiro, 2008, 346 p. (ISBN 978-85-903798-4-3) 
• Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel d'apprentissage, Paris, D-BookeR édition, 2012, 188 p. (ISBN 978-2-8227-0005-4) [(payant) lire en ligne] 
• Cyril Doillon (dir.), Sylvain Fabre, Philippe Lhoste et Patrick Rapin, Le guide de Lua et ses applications : manuel de référence, Paris, D-BookeR édition, 2012, 336 p. (ISBN 978-2-8227-0015-3) [(payant) lire en ligne] 

Articles connexes

• Plua
• LuaTeX

Liens externes

• Modèle:Site officiel
• (eng) Lua Development Tools
• (eng) Lua embarqué
• (fra) Introduction à la programmation avec Lua

Modèle:Portail programmation informatique

Modèle:Portail jeu vidéo