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.

Source : https://sheepolution.com/learn/book/9

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 :

Source : https://sheepolution.com/learn/book/8

Un rectangle mobile à chaque fois qu’espace est pressée !

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

Ce qui donnera en affichage :

Sources : https://sheepolution.com/learn/book/7

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 !

source : https://sheepolution.com/learn/book/7

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 !!! 😀

Suite avec les Boucles For

Traduction de la source https://sheepolution.com/learn/book/7

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.

traduction de la source : https://sheepolution.com/learn/book/6

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.

Source : https://sheepolution.com/learn/book/5

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 :

Les variables sont des mots dans lesquels vous pouvez stocker des valeurs comme des nombres ou du texte.

Ces variables peuvent faire l’objet d’opérations arithmétiques :

b = 10

c = a * b

Pour afficher les résultats des opérations effectuées en Lua dans l’interpréteur Löve2d il suffit d’utiliser la commande :

print()

Lorsque les variables stockent du texte, il est nécessaire d’utiliser les guillemets  » — » autrement appelées string.

Nous pouvons concatener des variables en utilisant deux points .. —— .. ou en anglais two dots.

name = « Lisa »

age = « 24 . »

text = « Coucou, je m’appelle ».. name ..  » et j’ai  » .. age.. « ans. »

Un print(text) donnera :

« Coucou, je m’appelle Lisa et j’ai 24 ans. »

Elles peuvent donc être utilisées pour effectuer le tracking de certaines informations, comme un score, des caractéristiques de personnage …

source : https://sheepolution.com/learn/book/2