Utiliser Lua en C# Fonctions et Réflexion

Cours Utiliser Lua en C# Fonctions et Réflexion, tutoriel & guide de travaux pratiques en pdf.

Premiers pas en Lua

Pour commencer, nous allons créer un interpréteur Lua. C’est assez simple…
Lua luaInterpret = new Lua();
C’est cet objet qui nous permettra d’utiliser Lua. Pour commencer doucement, nous allons créer deux variables Lua, que nous afficherons en C#. Notez bien que ces variables sont crées dans l’interpréteur Lua, et non dans le programme C#. Vous remarquerez qu’aucun type n’a été déclaré : Lua est un langage typé dynamiquement, au contraire du C#.
luaInterpret[« chaine »] = « Une chaine »;
luaInterpret[« entier »] = 10;
Maintenant que ces variables sont créées au niveau de l’interpréteur, nous allons les récupérer pour les afficher. Lua ne travaillant qu’avec des doubles, l’entier sera récupéré sous la forme d’un double.
string chaine = (string) luaInterpret[« chaine »]; double entier = (double) luaInterpret[« entier »];
Il ne reste plus maintenant qu’à modifier la sortie textuelle sur la Console en utilisant nos nouvelles variables.
Console.WriteLine(« chaine = {0}\nentier = {1} », chaine, entier);
Si tout va bien, vous devriez avoir en sortie le contenu des variables.
Et si nous faisions un peu travailler l’interpréteur ? Avant la sortie en Console, nous allons envoyer un ordre à l’interpréteur. Pour cela, nous allons utiliser la méthode DoString(string chunk). Cette méthode prend en paramètres une chaîne de caractères correspondant à du code Lua. Généralement, le code Lua sera plutôt enregistré dans des fichiers externes à l’exécutable. Nous verrons cela plus tard, pour l’instant, donnons un bout de code brut à l’interpréteur :
luaInterpret.DoString(« entier = entier*2; »);
Insérez cette ligne de commande après la déclaration des variables Lua, et avant celles en C#.
Ca marche ! Nous avons maintenant 20 en sortie ! Nous allons maintenant tenter d’obtenir le même résultat à l’aide d’un fichier externe. Dans le répertoire d’exécution de votre programme (où vous avez recopié les dll), créez un répertoire scripts, et ouvrez-y un fichier texte vide que vous appèlerez var.lua. Voici son contenu :
entier = 2;
chaine = « Ma Chaine »;
entier = entier*2;
Nous allons utiliser cette fois-ci la méthode DoFile(string fileName) pour charger le code
Lua. Le code de la fonction Main() devient le suivant :
public static void Main(string[] args)
{
}
Lua luaInterpret = new Lua(); luaInterpret.DoFile(@ »scripts/var.lua »);
string chaine = (string) luaInterpret[« chaine »]; double entier = (double) luaInterpret[« entier »];
Console.WriteLine(« chaine = {0}= {1} », chaine, entier);
Voilà pour commencer ! Dans la prochaine partie, nous allons utiliser un peu de Réflexion pour utiliser nos fonctions C# dans nos scripts Lua.

Fonctions et Réflexion

Avec ce que nous avons vu précédemment, il est donc possible de préparer quelques scripts basiques en Lua, qui agrèmenteront vos programmes. Néanmoins, on arrive vite à la limite de ce qui est possible.
La fonction RegisterFunction(…) va nous permettre d’étendre la possibilité de nos scripts. Cette fonction, en utilisant la réflexion de .NET, va enregistrer des fonctions écrites dans le programme en C# dans l’interpréteur Lua. Ceci aura pour conséquences que ces fonctions pourront être appelées dans nos scripts !
Pour commencer, nous allons créer une petite classe toute simple dans notre fichier de code :
class Prix
{ public float prixEuros;
public Prix(float p)
{
prixEuros = p;
}
public float PrixEnFrancs()
{
return prixEuros*6.6557f;
}
}
Nous allons maintenant configurer l’interpréteur pour qu’il reconnaisse la fonction PrixEnFrancs(). La fonction RegisterFunction() nécessite trois paramètres. Le premier est le plus simple : il s’agit de l’alias qu’utilisera la fonction dans vos scripts. Vous pouvez reprendre le nom de la fonction, ou la renommer comme bon vous semble !
Le second paramètre est l’objet auquel est rattaché la fonction. Dans notre exemple, il s’agira d’un objet Prix nommé prix. Enfin, le troisième paramètre est une référence vers la fonction. C’est ici qu’est utilisée la réflexion. Ce tutorial n’ayant pas ce but, je ne rentrerai pas dans les détails. Sachez simplement utiliser cette méthode…
Voici le code de notre fonction Main() après ces quelques modifications :
public static void Main(string[] args)
{
}
Prix prix = new Prix(2.15f);
Lua luaInterpret = new Lua();
luaInterpret.RegisterFunction(« Conversion », prix,
prix.GetType().GetMethod(« PrixEnFrancs »));
luaInterpret.DoFile(@ »scripts/convert.lua »);
double monPrix = (double) luaInterpret[« prix »];
Console.WriteLine(« Le Prix en Francs : {0} F », monPrix);
Le fichier de script convert.lua ne contient qu’une seule ligne de code, qui appelle la fonction Conversion(), et la stocke dans la variable prix.
prix = Conversion();
Les fonctions enregistrées étant associées à une instance d’objet, il est possible par ce biais de modifier un objet. Rajoutez la fonction suivante à la classe Prix :
public void ModifierTarif(float prix)
{
prixEuros = prix;
}
Cette fonction accepte un paramètre : et oui, on peut aussi enregistrer des fonctions avec des paramètres ! Attention cependant aux types utilisés. La documentation de Lua est à ce titre fort bien conçue. Vous pouvez la consultez à cette adresse : http://www.lua.org/pil
Il nous reste donc à enregistrer cette fonction de la même façon que la précédente. Seul le nom de la fonction est nécessaire pour l’enregistrer, même si elle possède des paramètres. Attention cependant si vous utilisez le polymorphisme : une exception du type Ambiguous Match Exception sera levée.