Les tables et les boucles for avec LÖVE2D

Les tables sont essentiellement des listes dans lesquelles nous pouvons stocker des valeurs.

Vous créez des tables avec des accolades ({ }) :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

function love.load()
  fruits = {}
end

function love.update()

end

function love.draw()

end

Nous venons de créer une table nommée fruits. Maintenant, nous devons y stocker des valeurs. Il y a plusieurs façons de le faire.

La première possibilité est de mettre des valeurs entre les accolades :

1
2
3
4

function love.load()
  -- Chaque valeur est séparée par une virgule, comme avec les paramètres et les arguments
  fruits = {"apple", "banana"}
end

Nous pouvons aussi utiliser la fonction table.insert. Le premier argument de la fonction est la table et le second argument est la valeur que nous souhaitons ajouter à celle-ci :

1
2
3
4
5

function love.load()
  -- Chaque valeur est séparée par une virgule, comme pour les paramètres et les arguments
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")
end

Maintenant, après avoir exécuté love.load, notre table contient :

• “apple”
• “banana”
• “pear”

Pour le prouver, affichons les données à l’écran. Pour cela, nous allons utiliser love.graphics.print :

1
2
3
4

function love.draw()
  -- Arguments: (string, x-position, y-position)
  love.graphics.print("Test", 100, 100)
end

Quand vous lancez le jeu, vous devriez voir le texte “Test” affiché. Nous pouvons accéder aux valeurs de notre table en écrivant le nom de la table suivi de crochets ([ ]) (pas des accolades ni des parenthèses, mais bien des crochets). Dans ces crochets, nous écrivons l’index que nous voulons. Il indique la position dans le tableau et la valeur correspondante.

Comme mentionné, les tables sont une liste de valeurs. Nous avons mis “apple” puis “banana”, donc ils sont en première et seconde position dans la liste. Ensuite, nous avons ajouté “pear”. Il est donc placé à la 3ème position dans la liste. En position 4, il n’y a pas de valeur (pas encore) puisque nous n’avons que 3 valeurs. Donc si nous voulons afficher “pear”, nous devons accéder à la 3ème position de la liste :

1
2
3

function love.draw()
  love.graphics.print(fruits[3], 100, 100)
end

Maintenant, nous voulons afficher les 3 fruits. Nous pouvons utiliser love.graphics.print 3 fois avec un index différent pour chaque appel :

1
2
3
4
5

function love.draw()
  love.graphics.print(fruits[1], 100, 100)
  love.graphics.print(fruits[2], 100, 200)
  love.graphics.print(fruits[3], 100, 300)
end

… mais imaginons que nous ayons 100 valeurs dans la table à afficher. Heureusement, nous avons une solution pour cela : la boucle for !

La boucle for

La boucle for est une solution pour répéter une partie de code un certain nombre de fois. On crée une boucle for comme ceci :

1
2
3
4
5
6
7
8

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")

  for i=1, 10 do
    print("hello", i)
  end
end

Si vous exécutez le jeu, vous devriez voir s’afficher hello 1, hello 2, hello 3 … jusqu’à 10.

Pour créer une boucle for, il faut écrire for en premier. Ensuite, vous devez définir une variable et lui donner une valeur numérique initiale. C’est là que la boucle for commence. La variable peut avoir n’importe quel nom, mais il est courant de l’appeler i. Cette variable n’est utilisable qu’à l’intérieur de la boucle for (comme les paramètres des fonctions). Ensuite, vous écrivez la valeur finale de la boucle.
Par exemple, for i=6, 18 do commencera à 6 et bouclera jusqu’à ce que i ait la valeur 18.

Il y a aussi un troisième paramètre facultatif qui est le pas d’incrémentation entre chaque itération. Par exemple, for i=6, 18, 4 do donnera comme valeurs successives à i : 6, 10, 14, 18. Avec cette approche, vous pouvez aussi faire une boucle qui décrémente en utilisant un pas négatif comme -1.

Notre table commence à l’index 1 et contient 3 valeurs, donc nous pouvons écrire :

1
2
3
4
5
6
7
8

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")

  for i=1, 3 do
    print(fruits[i])
  end
end

Quand vous exécutez le jeu, vous allez voir s’afficher les 3 fruits. Dans la première itération, le programme affiche fruits[1], puis dans la seconde fruits[2] et pour finir fruits[3].

Modification des tables

Mais comment faire si nous voulons adapter notre boucle quand nous ajoutons ou supprimons une valeur de la table ?
Nous devrions changer le 3 par un autre nombre. Pour cela, nous allons utiliser #fruits. Avec le symbole #, nous obtenons la taille de la table :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")

  print(#fruits)
  -- Sortie: 3

  for i=1, #fruits do
    print(fruits[i])
  end
end

Utilisons cette connaissance pour afficher les 3 fruits non plus dans la console mais dans la fenêtre de jeu :

1
2
3
4
5

function love.draw()
  for i=1, #fruits do
    love.graphics.print(fruits[i], 100, 100)
  end
end

Si vous lancez le jeu, vous devriez voir les 3 noms affichés, sauf qu’ils sont tous à la même position ! Nous pouvons résoudre ce problème en les affichant à différentes hauteurs :

1
2
3
4
5

function love.draw()
  for i=1, #fruits do
    love.graphics.print(fruits[i], 100, 100 + 50 * i)
  end
end

Maintenant, “apple” sera affiché à la position y $100 + 50 \times 1 = 150$. Ensuite, “banana” sera à 200 et “pear” à 250.

Si nous ajoutons un autre fruit, nous n’aurons rien besoin de changer. Le décalage vers le bas se fera automatiquement. Ajoutons “pineapple” pour tester :

1
2
3
4
5

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")
  table.insert(fruits, "pineapple")
end

Maintenant que nous savons ajouter des éléments dans une table, il serait bon de pouvoir en supprimer. Pour cela, nous utilisons table.remove. Le premier argument est la table de laquelle nous voulons enlever quelque chose, et le second argument est l’index de l’élément à supprimer. Donc, si nous voulons supprimer “banana”, nous ferons comme suit :

1
2
3
4
5
6

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")
  table.insert(fruits, "pineapple")
  table.remove(fruits, 2)
end

Lorsque nous lancerons le jeu, nous verrons que “banana” n’est plus affiché et que “pear” et “pineapple” ont été déplacés vers le haut.

Quand vous supprimez une valeur dans une table avec table.remove, tous les éléments suivants remontent d’une position. Ainsi, ce qui était en position 3 sera en position 2, ce qui était en position 4 sera en position 3, et ainsi de suite.

Vous pouvez aussi ajouter ou modifier des valeurs directement dans la table. Par exemple, nous pouvons changer “apple” en “tomato” :

1
2
3
4
5
6
7
8

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")
  table.insert(fruits, "pineapple")
  table.remove(fruits, 2)
  -- La valeur en position 1 de la table devient "tomato"
  fruits[1] = "tomato"
end

ipairs

Revenons à la boucle for. Il existe une autre façon, plus simple, de parcourir la table en utilisant ipairs :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

function love.load()
  fruits = {"apple", "banana"}
  table.insert(fruits, "pear")
  table.insert(fruits, "pineapple")
  table.remove(fruits, 2)
  fruits[1] = "tomato"

  for i, v in ipairs(fruits) do
    print(i, v)
  end

  -- Sortie:
  -- 1, "tomato"
  -- 2, "pear"
  -- 3, "pineapple"
end

Cette boucle for est ce que nous appelons une itération, et elle parcourt toute la table. La variable i nous donne l’index (la position) et v la valeur à cette position. C’est essentiellement un raccourci à la place de fruits[i]. Par exemple, dans la première itération, la valeur de i serait 1 et v serait “tomato”. Dans la deuxième itération, i et v seraient respectivement 2 et “pear”.

Mais comment cela fonctionne-t-il ?
Pourquoi la fonction ipairs permet-elle cela ?
C’est un sujet pour une autre fois. Pour l’instant, sachez simplement que ipairs est essentiellement un raccourci pour le code suivant :

1
2
3
4

for i=1, #fruits do
    v = fruits[i]
    -- Code à exécuter avec i et v
end

Utilisons ipairs pour afficher notre table :

1
2
3
4
5
6

function love.draw()
  -- i et v sont des variables que nous pouvons nommer comme nous le souhaitons
  for i, frt in ipairs(fruits) do
    love.graphics.print(frt, 100, 100 + 50 * i)
  end
end

Résumé

Les tables sont des listes dans lesquelles nous pouvons stocker des valeurs. Nous pouvons ajouter des valeurs lors de la création, avec table.insert ou avec table_name[index] = “une valeur”. Nous pouvons obtenir la taille d’une table avec le symbole # comme ceci : #table_name.
Avec les boucles for, nous pouvons répéter des morceaux de code un certain nombre de fois. Nous pouvons aussi utiliser une boucle for pour itérer (parcourir) une table, soit avec une boucle numérique classique, soit avec la fonction ipairs qui simplifie l’accès aux éléments.