Programmer en Lua (1) : Les fondamentaux

- Laisser ce bandeau de pub s'afficher nous permet de continuer l'aventure PSP-GENERATION -

PSP-GENERATION

Nous l'avons souvent vu dans nos colonnes : les homebrews peuvent être programmés en C/C++ mais aussi en Lua, un langage de scripting plutôt élaboré, permettant d'étendre considérablement les fonctions d'une application. Ce langage a été développé par Roberto Ierusalimschy, Waldemar Celes et Luiz Henrique de Figueiredo de l'Université de Rio de Janeiro, au Brésil. Signifiant "Lune" en Portugais, Lua est interprété : on ne compile pas le code source, on le fait lire par un interpréteur, qui va alors exécuter les opérations et les algorithmes. Pensez à la programmation HTML, par exemple ; on décrit l'allure d'une page web, on modifie les couleurs et les polices… pour laisser un interpréteur (le navigateur de l'utilisateur !) afficher le résultat. Dès son origine, le format a tout de suite été adopté par l'industrie du jeu vidéo. Baldur's Gate, entre autres, en a fait une utilisation massive pour développer des scripts un peu particuliers, concernant le comportement de PNJ (Personnages non-joueurs) notamment. Mais Grand Theft Auto : Liberty City Stories en exploite également quelques-uns à partir de son UMD.

Sur PlayStation Portable, une version du Lua Player est maintenue par Frank Buss (Shine) et Joachim Benqtsson (Nevyn). Les possesseurs du firmware 2.60 doivent s'en tenir pour l'instant à la version 0.16 de l'interpréteur. Pour tester vos propres applications, sachez qu'il existe également une version Windows, à travers laquelle vous pourrez facilement débugger votre code source. Toujours au niveau des outils, sachez que Tristan Rybak a développé LuaIDE, une interface de développement adaptée au Lua. La coloration syntaxique est au rendez-vous, ainsi qu'un débuggeur. Ceci dit, vous pouvez tout à fait rédiger vos codes sources dans le bloc-notes, et les tester dans la version Windows de Lua avant de les transférer vers votre PSP.

Pour bien débuter, nous allons parcourir les fonctions essentielles de Lua et mettre en place plusieurs exemples. L'objectif final de ce premier chapitre consacré à la programmation en Lua consiste à développer un petit logiciel de création graphique. Nous verrons par la suite comment créer un véritable jeu vidéo, en ajoutant des images, du son et de l'animation. Lua est un excellent moyen de se familiariser avec l'algorithmie et de comprendre les rouages essentiels d'un langage de programmation. Mais ne sous-estimez pas la complexité de la programmation, au sens général : nous bifurquerons par la suite vers le C/C++, pour réaliser des homebrews plus élaborés, compilés.

Avant de débuter, assurez-vous de savoir lancer des scripts Lua sur votre PSP. Téléchargez pour cela la version du Lua Player correspondant à votre firmware.
• Décompressez l'archive et transférez-la sur votre PSP, via un câble USB ou en utilisant PSP-FTPD par exemple.
• Lancez l'eLoader comme vous en avez l'habitude, et exécutez Lua Player.
• La liste des scripts et des applications s'affiche alors. Choisissez un des projets d'exemple et appuyez sur le Cercle : le programme devrait alors se lancer.

Nous allons travailler directement avec le bloc-notes. Nous allons créer un répertoire /PSPNGO dans lequel nous allons ranger notre fichier source, script.lua. Il est intéressant d'isoler d'emblée votre script dans son propre répertoire : lorsque vous ajouterez des images, de la musique, et que votre application reposera sur plusieurs bibliothèques, vous aurez réuni tous les fichiers nécessaires à son exécution.

Pour exécuter un programme Lua sous Windows, décompressez le Lua Player adapté au système d'exploitation de Microsoft, et lancez l'invite de commandes (Démarrer / Exécuter, puis saisissez "cmd" ou déroulez le menu Démarrer / Accessoires / Invite de commandes). Rendez-vous dans le répertoire où vous avez décompressé Lua Player et saisissez "luaplayer.exe script.lua".

Vous êtes fin prêt ? Alors, on commence !

Songez à tout ce qui peut apparaître à l'écran : des images, du texte, des valeurs numériques… Toutes ces données sont contenues dans des variables. On en fait une utilisation permanente : si vous désirez afficher un texte en vert, vous devrez tout d'abord définir cette couleur dans une première variable, avant d'appeler la fonction qui affiche du texte. Commençons d'ailleurs par ce premier exemple :

Avec cette instruction, vous créez une nouvelle couleur, que vous stockez sous la variable "vert". Color est un type d'objet : avec le mot-clé "new", on en crée une nouvelle instance. Pensez à un fabricant de figurines ; pour réaliser des modèles, il commence par concevoir un moule. Chaque figurine usinée sera alors une nouvelle instance de ce moule d'origine. Entre parenthèses, on précise trois valeurs : elles correspondent respectivement à la quantité de rouge, de vert et de bleu. A partir de ces trois couleurs fondamentales, on peut définir tout le spectre colorimétrique. Ouvrez Paint et double-cliquez sur une couleur : sur le volet droit de la fenêtre qui s'ouvre, chaque teinte est exprimée selon sa "quantité" de rouge, de vert et de bleu, exprimée de 0 à 255. Dans notre exemple précédent, nous avons donc défini une couleur dépourvue de rouge et de bleu, mais avec du vert à 100%.

Le nom de la variable vous incombe. Par commodité, nous l'avons appelée "vert", mais vous auriez très bien pu saisir "gazon" ou "couleur". Nous y reviendrons.

Affichons maintenant du texte à l'écran. Pour cela, ajoutez la ligne suivante :

La fonction "screen:print" va afficher le texte passé en paramètre à l'écran. Les deux premiers nombres correspondent à l'emplacement du texte en lui-même. La PSP dispose d'un écran à la résolution de 480x272 pixels. Le premier chiffre indique la position sur l'axe des abscisses par rapport au bord gauche de l'écran. Le second chiffre correspond au décalage sur l'axe des ordonnées par rapport au haut de l'écran (reportez-vous à la figure ci-dessous). Ainsi, notre instruction va afficher le texte "Mon premier programme Lua" à 90 pixels du bord gauche et à 15 pixels du haut de l'écran. En dernier lieu, nous précisons la couleur utilisée pour afficher le texte : on reprend pour cela le nom de la variable définie précédemment (vert).

Mais si vous exécutez le programme, rien ne s'affiche à l'écran pour l'instant. C'est tout à fait normal : Lua dispose de deux tampons ("buffers") pour afficher des éléments à l'écran. On commence d'abord par définir un tampon hors de l'écran ("offscreen buffer"), avant de l'afficher sur le tampon présenté à l'écran ("onscreen buffer"). Cette technique est appelée le double-buffering : en préchargeant une image dans la mémoire de la console pendant qu'on en affiche une autre à l'écran, on peut intervertir l'état des deux tampons. On parvient ainsi à recréer une animation, sans avoir le moindre effet de scintillement. Nous allons donc intervertir les deux tampons :

Si vous exécutez maintenant le programme, celui-ci va se clore immédiatement. Le texte sera bien affiché à l'écran, mais son apparition sera si brève que vous n'aurez pas le temps de le lire. Pour y remédier, nous devons introduire une boucle conditionnelle. Il s'agit d'une boucle while … do … end : tant qu'une condition sera remplie, on effectuera une tâche bien précise.

Nous souhaitons afficher le texte en permanence à l'écran : l'instruction while true est toujours vraie (le "littéral true" est toujours vérifié, nous n'avons pas réellement défini une condition mais plutôt un état). Ensuite, il faut considérer l'affichage sur l'écran comme un ancien tube cathodique : un rayon balaie l'écran, de haut en bas, pour afficher tous les pixels de l'image. Lorsqu'il touche le bas de l'écran, le rayon doit se repositionner en haut : il est alors désactivé le temps de l'opération et on parle de Vblank (pour Vertical Blank). Grâce à cette boucle conditionnelle, on affiche donc en permanence notre texte. Nous verrons par la suite qu'il faut profiter de ce temps d'attente pour "alterner" les deux tampons d'affichage : on crée ainsi une animation, sans le moindre scintillement. Par ailleurs, notez la première ligne des instructions suivantes : il s'agit d'un commentaire, précédé de deux traits d'union ("--"). Vous pouvez les multiplier au sein de votre code source pour clarifier votre traitement, et pour remettre les mains dans le cambouis ultérieurement.

--[[ mon commentaire --]]

Dans ce cas, vous pouvez enchaîner des commentaires sur plusieurs lignes : le programme ne reprend la main qu'après la fermeture du "--]]".

Exécutez le programme : la phrase "Mon premier programme Lua" s'affiche en vert, en haut de l'écran.

Nous allons maintenant définir quelques variables. Lua bénéficie d'un typage dynamique : il n'est pas nécessaire de préciser le type de données que contient chaque variable. Nous allons définir les variables suivantes :

Qu'il s'agisse de texte ou de valeurs numériques, il n'y a pas de différences au niveau de la définition des variables en Lua. Le langage va reconnaître automatiquement le type de données concernées, pour effectuer éventuellement des opérations. Après avoir défini ces quelques variables, nous allons réaliser un calcul :

-- Affichage des opérations à l'écran
screen:print(90, 15, "Mon premier programme Lua", vert)
screen:print(90, 30, introduction, rouge)
screen:print(120, 40, "Le resultat du calcul est :", vert)
screen:print(240, 50, total, rouge)

screen.flip()

while true do
   screen.waitVblankStart()
end

On peut réaliser directement des opérations arithmétiques sur des valeurs numériques, à l'aide des opérateurs +, -, * ou /. Ainsi, on va additionner le contenu des deux variables chiffre1 et chiffre2. Notez qu'on a défini du texte dans la variable introduction : on l'affiche alors directement, en appelant cette variable dans la fonction screen:print.

A présent, intéressons-nous aux tableaux. Essentiels dans tous les langages de programmation, ils permettent de stocker une quantité considérable de données au sein d'un même élément, que vous pourrez parcourir librement.

Grâce à ces deux instructions, nous avons tout d'abord créé un tableau vide, puis nous lui avons assigné cinq valeurs. On parle aussi de cinq membres : on peut appeler n'importe quel membre en précisant sa position. Ainsi, monTableau[2] va renvoyer le deuxième membre du tableau, soit le chiffre 2. Vous pouvez d'ores et déjà imaginer le parcours de toutes les valeurs d'un tableau grâce à une boucle conditionnelle. Nous y reviendrons.

monTableau = { }
monTableau[2] = "3"

On crée un nouveau tableau vierge et on place le chiffre 3 dans le second membre. Par ailleurs, contrairement à d'autres langages de programmation, les tableaux en Lua commencent à 1 : monTableau[1] révèle le premier membre (pour les autres langages, il s'agit généralement de monTableau[0]).

Mais il est également possible de définir un tableau dans un tableau :

Nous avons créé un tableau vide, puis nous avons rempli ses trois premiers membres avec d'autres tableaux. Nous pouvons ainsi accéder à plusieurs propriétés : ville[1].nom va renvoyer "Nantes", tandis que ville[2].habitants va renvoyer "273000".

Affichons le contenu de notre tableau à l'aide d'une boucle conditionnelle :

for a=1, 3 do
   ordonnee = positionY+decalage
   screen:print(90, ordonnee, ville[a].nom .. " " .. ville[a].habitants .. " habitants", rouge)
   positionY = ordonnee
end

Ces quelques lignes méritent une explication. La boucle for … do … end permet de parcourir le tableau dans son ensemble. for a=1, 3 va faire prendre alternativement la valeur 1, 2 et 3 à la variable a. On parcourt ainsi trois fois d'affilée la boucle avant d'en sortir. A chaque fois, nous allons afficher la valeur de ville[a].nom et de ville[a].habitants : nous allons donc bien parcourir les trois valeurs définies précédemment dans le tableau. Le signe ".." sert à concaténer des chaînes en Lua, c'est-à-dire à les afficher à la suite les unes des autres. Comme nous l'avons déjà vu, nous devons préciser la position de chaque ligne de texte. Pour éviter qu'elles ne superposent, nous allons les afficher les unes en-dessous des autres. Si la position horizontale reste la même (à 90 pixels du bord gauche de l'écran), l'ordonnée doit varier. Nous avons alors défini une variable decalage en-dehors de la boucle for, ainsi que la position de départ (positionY). Chaque donnée du tableau va donc s'afficher à 15 pixels en-dessous de la précédente. Dans la fonction screen:print, les expressions entre guillemets sont à afficher telles quelles – on les utilise ici pour afficher un espace entre les variables (et pour inscrire le terme "habitants" en bout de ligne).

En guise d'exercice, essayez de calculer le nombre total d'habitants de ces trois villes réunies, pour l'afficher en bas à droite de la fenêtre.

 SP-GENERATION

Lire la suite de l'article sur
PSPnGo en cliquant ICI

 SP-GENERATION