Il est possible et conseillé d’organiser son code dans différents fichiers .lua afin d’aérer. Puis il suffit d’appeler ce fichier grâce à un « require » :
Exemple après la création d’un fichier game.lua, saisissez dans le fichier main.lua :
require (« game »)
Quant à la portée (« scope« ) d’une variable, elle peut être globale c’est à dire utilisée dans tout le code ou alors « local » ce qui signifie qu’elle n’est utilisable que dans le fichier ou la fonction dans laquelle elle a été crée.
L’exemple ci-dessus montre bien l’ordre d’exécution des différents « print » et ainsi la portée de chaque test qui prend différentes valeurs selon le lieu où cette variable a été crée et sa portée, local ou global.
Pour qu’une fonction prenne une valeur, on la lui retourne « return«
Comme vu ci-dessus, une fois qu’une fonction s’est vu retourner une valeur, elle peut être elle-même réutilisée dans une autre fonction.
Pour stocker des valeurs, nous avons vu l’utilisation des tables mais nous pouvons également le faire avec les « strings », guillemets. On appellera ces tables, des Objets ce qui va nous permettre d’emmagasiner davantage encore de variables.
function love.load()
rect = {}
-- ces deux formes veulent dire la même chose
rect["width"] = 100
rect.width = 100
end
On pourra donc aussi utiliser le point pour donner des propriétés à cette table . Cette typographie sera d’ailleurs privilégiée parce que plus rapide et claire.
function love.load()
-- faire attention à la casse employée
listOfRectangles = {}
end
function createRect()
rect = {}
rect.x = 100
rect.y = 100
rect.width = 70
rect.height = 90
rect.speed = 100
-- on insère le nouveau rectangle dans la table
table.insert(listOfRectangles, rect)
end
function love.keypressed(key)
-- les deux signes égal signifient une comparaison
if key == "space" then
createRect()
end
end
function love.update(dt)
for i,v in ipairs(listOfRectangles) do
v.x = v.x + v.speed * dt
end
end
function love.draw(dt)
for i,v in ipairs(listOfRectangles) do
love.graphics.rectangle("line", v.x, v.y, v.width, v.height)
end
end
Donc en traduction :
Dans la fonction love.load ( ), nous avons crée une table qui s’appelle listOfRectangles puis une fonction createRect . On y a également inséré une nouvelle table rect et à cette table de nouvelles propriétés comme l’abscisse, l’ordonnée, la largeur, la hauteur et la vitesse à affecter à ce nouveau rectangle. Puis dans la fonction love.keypressed nous donnons pour instruction de créer un nouveau rectangle à chaque fois que la touche « espace » sera pressée. Dans la fonction love.update(dt) qui va mettre à jour votre programme à chaque itération on insère une boucle for ipairs (vu juste précédemment dans le #7) qui indique la vitesse à calculer pour chaque appel de la fonction listOfRectangle. Dans la fonction love.draw(dt), on insère de la même manière une boucle for ipairs afin que chaque appel de la fonction listOfRectangle, un nouveau rectangle soit crée à l’écran. Ce qui donne ceci :
Afin de parcourir une table, il existe aussi la boucle ipairs . Reprenons notre exemple précédent :
function love.load()
auteurs = {"Tolkien", "Castelot"}
table.insert(auteurs, "Zola")
table.insert(auteurs, "Freud")
table.remove(auteurs, 2)
auteurs[1] = "Sanderson"
for i,v in ipairs(auteurs) do
print(i, v)
end
--Output:
--1, "Sanderson"
--2, "Zola"
--3, "Freud"
end
La table est ainsi parcourue avec la position de chaque valeur indiquée. Voici à quoi cela ressemble avec le logiciel ZeroBrane Studio :
En décidant de l’afficher via Löve, nous passons par la fonction draw :
function love.draw()
-- i and v étant des variables, on peut leur donner n'importe
-- quel nom
for i,aut in ipairs(auteurs) do
love.graphics.print(aut, 100, 100 + 50 * i)
end
end
Cette boucle for sert à répéter un morceau de code un certain nombre de fois.
On la crée de cette manière pour parcourir une table comme dans l’exemple précédent :
function love.load()
auteurs = {"Tolkien", "Castelot"}
table.insert(auteurs, "Zola")
for i=1,3 do
print(auteurs[i])
end
end
On donne la variable au sein de la table communément i mais on peut lui donner le nom que l’on veut. Dans l’exemple ci-dessus on commence donc à parcourir la table à partir de la valeur 1 jusqu’à la valeur 3 et on demande au programme d’indiquer chaque valeur prise par cette table dans cet intervalle.
On peut ajouter une valeur après le for i = 1, 10 , 2 qui indique de quelle manière la variable va augmenter… dans cet exemple elle augmentera de 2 en 2 !
De base, une table sert à stocker des valeurs. On crée une table en lui donnant un nom suivi du signe égal ainsi que des « brackets« , les parenthèses spéciales du clavier :{ }.
function love.load()
auteurs = {}
end
Pour ajouter des valeurs à ces tables, dans un premier temps il suffit d’insérer des valeurs entre les « curly brackets » ou encore d’utiliser la fonction table.insert :
function love.load()
--chaque valeur est séparée par une virgule comme les paramètre
--et arguments
auteurs = {"Tolkien", "Castelot"}
table.insert(auteurs, "Zola")
end
La position de chaque valeur dans la table dépend de son ordre d’insertion dans celle-ci. Dans notre précédent exemple « Tolkien » est en première position alors que « Zola » n’a été inséré qu’en troisième place juste derrière « Castelot ».
Pour accéder au contenu de cette table par un simple print , on appelle la table suivi de crochets contenant la valeur que l’on souhaite voir apparaître (toujours suivi de l’emplacement avec x et y )
function love.draw()
love.graphics.print(auteurs[1], 150, 75)
end
--output : Tolkien
Editer une table :
On peut ajouter des valeurs à une table avec la fonction table.insert comme nous l’avons déjà vu mais on peut également en ôter avec table.remove.
function love.load()
auteurs = {"Tolkien", "Castelot"}
table.insert(auteurs, "Zola")
table.insert(auteurs, "Freud")
table.remove(auteur, 2)
--La valeur de la position 1 devient "Sanderson"
auteurs[1] = "Sanderson"
end
Pour ajouter une variable à une position précise il faut saisir le nom de la variable avec la position voulue entre crochet, le signe égal puis la valeur entre guillemets si c’est une chaîne de caractères.
le signe # (alt gr + 3 ) permet d’obtenir la taille de la table :
function love.load()
auteurs = {"Tolkien", "Castelot"}
print(#auteurs)
--Output: 2
table.insert(auteurs, "Zola")
print(#auteurs)
--Output: 3
for i=1,#auteurs do
print(auteurs[i])
end
end
function love.draw()
for i=1,#auteurs do
love.graphics.print(auteurs[i], 100, 100 + 50 * i)
end
end
Dans la fonction love.draw ci-dessus on demande à afficher la liste complète des valeurs de la table « auteurs » en indiquant en quel x et quel y procéder. On ajoute 50 à l’ordonnée y à chaque valeur de la table … sinon elles apparaitraient superposées !!! 😀
La fonction if permet de conditionner l’exécution, l’arrêt d’une fonction, en vérifiant si une valeur est inférieure … supérieure … ou si une variable est vraie ou fausse (boolean). On peut y ajouter else ou encore elseif pour déterminer ce que le programme doit faire si les conditions d’exécution de la fonction ne sont pas remplies.
Par exemple si nous reprenons l’exemple de notre rectangle mobile précédent, nous pourrions conditionner son mouvement au fait d’appuyer sur une touche . Cela pourrait se coder de cette manière :
if love.keyboard.isDown("right") then
x = x + 100 * dt
else
x = x - 100 * dt --We decrease the value of x
end
Ce qui se traduit par : si la touche « droit » est appuyée alors l’abscisse augmente de 100*dt sinon elle décroit de 100*dt.
On peut encore conditionner le mouvement ainsi :
if love.keyboard.isDown("right") then
x = x + 100 * dt
elseif love.keyboard.isDown("left") then
x = x - 100 * dt
end
Ce qui se traduit par : si la touche « droit » est appuyée alors l’abscisse augmente de 100*dt alors que si c’est la touche « gauche » qui est appuyée alors l’abscisse décroit de 100*dt.
Alors comment faire apparaitre un rectangle qui se déplace tout seul en LUA.
Avec le Framework Löve2d on commence par les fonctions d’appel de base : function love.load( ) end
function love.update( ) end
function love.draw( ) end
Dans la fonction love.draw, nous allons dessiner un rectange :
function love.draw( )
love.graphics.rectangle("line", x, 50, 200, 150)
end
sachant qu’un rectangle peut être « line » ou « fill » c’est à dire, juste une ligne qui en dresse le contour ou alors un rectangle plein. Les deuxième et troisième arguments sont respectivement les coordonnées en x et en y. Puis en quatrième et cinquième, la largeur (width) et la hauteur (height).
Nous incluons dans le love.load une valeur à x afin d’indiquer à quel endroit de l’écran nous souhaitons le faire apparaitre et dans le love.update une fonction afin de modifier son abscisse régulièrement.
function love.load( ) x = 100 end
function love.update (dt) x = x + 5 * dt end
function love.draw ( ) love.graphics.rectangle (« line », x, 50, 200, 150) end
Sans oublier de tenir compte du Delta Time qui permettra d’adapter le rafraichissement de l’image selon les capacités de chaque ordinateur.
Les fonctions emmagasinent du code qu’elles peuvent executer à n’importe quel moment voulu par le(a) programmeur(se). Plutôt que de répéter des morceaux de code à chaque fois que l’action est voulu, on appelle la fonction dédiée. De plus si l’on veut changer un aspect de la fonction, il suffit d’en faire le changement une seule fois pour qu’il s’opère à chaque fois que cette fonction est appelée.
On appelle une fonction en donnant son nom suivi de parenthèses dans lesquelles on peut stocker des valeurs que l’on appelle dès lors, paramètres. Ces valeurs n’existent que dans cette fonction et peuvent changer. La fonction peut également renvoyer à une valeur stockée dans une variable.
Exemples :
function som (a , b) return a + b end print (som (200, 75)) –Output –275
La formation de Gamecodeur me permet d’aborder la programmation pour la réalisation de jeux vidéos en commençant par le langage Lua. Je vais donc au fil d’articles synthétiser et traduire les documents de tutoriel trouvables sur le site de Löve2d.
Pour celle de Grafikart, je suis plutôt son parcours sur la programmation orientée web avec le langage HTML , le CSS qui ne sont que le commencement.
Pour compléter tout ça, je suis également le Free Code Camp qui est une formation en ligne gratuite sous forme de mini tuto pour différents langages qui complètent parfaitement l’enseignement de Grafikart.