Tutoriel
lua9dx

Programmer en Lua (1) : Les fondamentaux

par

Mon ami Jean-marc de PSPnGo vient de terminer la première partie de son tutorial pour apprendre à programmer en LUA. Tout au long de ces prochaines semaines, nous allons essayer de vous aider à remplir les colonnes de nos futures news en devenant vous mêmes acteurs de la scène PSP. Cliquez sur suite

- Laisser ce bandeau de pub s'afficher nous permet de continuer l'aventure PSP-GENERATION -
Click here to visit our sponsor

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.

 

LuaIDE, sa coloration syntaxique et son débugger

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".

 

Exécutez vos programmes avec Lua Player pour Windows !

 

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

Dans les pages qui suivent, nous allons aborder certains thèmes essentiels de la programmation. Vous n'avez pas besoin de connaissances particulières pour suivre nos exemples et les exécuter sur votre console. Dans la mesure du possible, nous détaillerons les actions exécutées et nous tâcherons de rester clair ! Ceci dit, vous aurez probablement besoin d'un glossaire informatique pour comprendre tous les rouages de la programmation.

 

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 :

vert = Color.new(0, 255, 0)

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 :

screen:print(90, 15, "Mon premier programme Lua", vert)

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).

 

Représentez-vous l'écran de la PSP.

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 :

screen.flip()

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 whiledoend : tant qu'une condition sera remplie, on effectuera une tâche bien précise.

-- ma boucle conditionnelle
while true do
   screen.waitVblankStart()
end

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.

Lua permet aussi d'inclure des blocs de commentaires, avec la syntaxe :

--[[ 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 :

rouge = Color.new(255, 0, 0)
chiffre1 = "4"
chiffre2 = "2"
introduction = "Un petit peu de calcul"

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 :

-- Addition des deux chiffres
total = chiffre1 + chiffre2

-- 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.

monTableau = { }
monTableau = {1, 2, 3, 5, 7 }

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.

A l'inverse, sachez qu'il est possible de définir directement le membre d'un tableau. Ainsi :

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 :

ville = { }
ville[1] = { nom = "Nantes", habitants = "280000" }
ville[2] = { nom = "Strasbourg", habitants = "273000" }
ville[3] = { nom = "Dijon", habitants = "150000" }

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 :

decalage = 15
positionY = 30

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 fordoend 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.

Résumons-nous à propos des boucles conditionnelles. Jusqu'à présent, nous avons vu : La boucle while ... do ... end, qui répète une action tant qu'une condition est remplie. La boucle for ... do ... end, qui va exécuter une action pour une série de valeurs, en les incrémentant au fur et à mesure.

 

 SP-GENERATION

 

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

 

 SP-GENERATION

Avez-vous pensé à cliquer sur la pub ?

- Laisser ce bandeau de pub s'afficher nous permet de continuer l'aventure PSP-GENERATION -
Click here to visit our sponsor
Visiter notre partenaire nous permet de continuer l'aventure.

PSP-GENERATION
Donnez vos impressions en cliquant ici
PSP-GENERATION

Commenter 27 commentaires

Anonymous
Depuis le temps que je demandais sur le forum si il existait un tuto pour le lua : me voila servi.
Vivement la suite...

tout vient a point a qui sait attendre.
Signaler Citer
Anonymous
moi je capte kedal a ce truc, je sais meme pas a quoi sa sert.
apparemment sa a l'air interessant mais je sais pas ce que c'est 8O
en cas si quelqu'un a la motive de m'espliquer sa serai sympa
merci @= :wink:
(dsl pour le "kedal" plus haut chez pas comment sa s'ecrie)
Signaler Citer
Anonymous
moi j'essairai de faire un MMORPG avec la librairie netlib quand je saurais programmer le lua.

Se serait bien de faire un forum programmation psp, car il y a l'air d'avoir plusieurs interessé par ce tuto (moi le 1er) et dans se forum on pourrait se conseiller, mettre nos source a dispo , enfin faire plein de trucs.
Signaler Citer
castor123
Bonjour à tous !

Tout d'abord, je vous remercie sincèrement pour tous vos encouragements concernant le tutoriel. Votre passion et votre élan sont très motivants ! Merci également à PSP-Generation d'avoir publié un lien vers PSP'n Go et de soutenir le projet d'un tutoriel exhaustif en français.

En ce qui concerne les épisodes à venir, ils devraient répondre en grande partie à vos questions et à vos envies :
- on verra l'adaptation d'un jeu de rôle mythique en "Point and Click", Shadowgate, en Lua. Il s'agit d'apprendre à afficher des images, à maîtriser les techniques de base de l'animation, et à réagir aux interactions de l'utilisateur.
- il y aura également un jeu dans la veine de PacMan. Dans ce premier volet du tutoriel, vous apprenez les bases : il m'a semblé nécessaire qu'on se mette tous d'accord, et qu'on parte sur les mêmes fondations (qu'est-ce qu'une variable ? une fonction ? un tableau en Lua ? comment "écoute-t-on" les pressions sur les boutons de la PSP ?). On apprendra alors à se servir d'une "grille" et à en révéler certaines portions pour composer un niveau.
- enfin, le dernier jeu vidéo du prochain tutoriel sera un jeu de tennis. Il interviendra sous deux formats. La première version consiste à "partager" la PSP entre deux joueurs : le joueur de gauche utilise la gâchette L pour frapper la balle et la croix directionnelle pour se déplacer sur le court, le joueur de droite utilise la gâchette R pour donner un coup droit et les quatre boutons de droite pour se déplacer. Une seconde version prévoit un affichage dans le sens "vertical" : le filet agit comme un axe de symétrie vertical, et les deux joueurs se font face. Ils utilisent une fois de plus la croix directionnelle et les boutons pour se déplacer (mais la flèche de gauche permet alors de se déplacer "vers le haut"). Les deux joueurs auront ainsi l'impression d'être tous les deux "en bas de l'écran", pour améliorer le confort d'utilisation.

Bref, voici quelques premiers aperçus de ce qui vous attend ! :)

Bonne lecture à tous, et merci encore de vos encouragements.

Jean-Marc
http://www.pspngo.fr
Signaler Citer