Les tableaux multidimensionnels

[Swice 14]

Bonjour à toutes et à tous !

 

Après avoir commencé les tutoriaux il y a quelques semaines, je vous en présente aujourd'hui un nouveau.

Je vais vous parler des tableaux, de leur utilités et leurs avantages, en tenant compte d'une chose : je travaille dans le langage Lua.

 

Beaucoup d'entre-vous savent certainement leur principe, et leur fonctionnement. C'est pour cela que ce tutoriel s'adresse en premier lieu aux débutants qui pourront continuer de se perfectionner dans ce domaine.

 

Je vais donc vous présenter les tableaux. Il en existe de plusieurs sortes, enfin, je devrais dire, de plusieurs dimensions.

 

1. Les tableaux à une dimension (ou classiques, simples)

 

a. Déclaration, création. 

 

Révélation

 

Commençons par voir comment déclarer ou créer un tableau.

Tout d'abord, il faut savoir qu'un tableau joue le même rôle qu'une variable. Cependant, celui-ci en peut en contenir plusieurs.

 

Pour créer un tableau, on utilisera donc un local suivi du nom du tableau, d'un = et d'un {, puis à la fin d'un }, comme ceci :

local NonTableau = {}

 

Votre tableau est créé. Il faut maintenant le remplir. Je vous rappelle que nous parlons pour le moment des tableaux à une dimension.

 

 

 

b. Remplissage.

 

Révélation

 

Alors, une fois le tableau créé, il faut le remplir.

Il n'y a pas 36 solutions pour remplir un tableau, mais quelques règles à respecter.

 

Pour entrer des chiffres ou des nombres, rien de plus simple, on les entre séparés d'une virgule.

local NomTableau = {1, 2, 3, 4, 5, 6}

 

Par contre, si vous voulez entre d'autres caractères, comme des lettres ou des phrases, il faut les mettre entre guillemets.

local NomTableau = {"A", "B", "C", "D"}
local NomTableau = {"Le chat est noir", "La souris est blanche", "Le cochon est rose"}

 

Voilà deux choses en terme de remplissage à ne pas oublier.

Maintenant, je vais vous montrer l'utilisation possible des tableaux à une dimension.

 

 

 

c. Utilisation.

 

Révélation

 

Les tableaux à une dimension sont très pratiques lorsque vous souhaitez stocker un seul type d'informations. 

Par exemple, une série de vnum ou d'index de map, qui pourraient vous servir à spawn un monstre aléatoire ou à téléporter un joueur sur une map.

 

Exemple pour spawn un monstre aléatoire (on pourrait dire que ce sont des boss de fin d'instance) :

(nous sommes déjà dans un code, je vous montre juste la partie concernée)

 

when login with pc.get_map_index() == 300 and d.getf("instance_feu") == 8 begin
      local boss_spawn_table = {1203, 1425, 12365, 251}
      d.spawn_mob(boss_spawn_table[number(1, table.getn(boss_spawn_table)]), 300, 400, 0, true, 1)
end

 

Là, vous allez vous demander : "qu'est-ce que c'est que ça ?" - Je vais tout vous expliquer.

 

 

 

d. Récupération des données.

 

Révélation

 

Alors voilà, maintenant notre tableau est créé, et nous avons une situation.

Je vais vous montrer comment récupérer les données d'un tableau simple.

 

Les valeurs du tableau correspondent à des valeurs numériques. Par exemple ici, 1203 correspond à 1, 12365 à 2, etc..

Pour retrouver une donnée dans un tableau, il faut entrer le nombre lui correspondant entre [] à la suite du nom du tableau.

 

Par exemple, dans le tableau :

local boss_spawn_table = {1203, 1425, 12365, 251}

 

boss_spawn_table[1] correspondra à 1203.

boss_spawn_table[4] correspondra à 251.

 

Dans un tableau à lettres ou phrases, ce qui vous sera renvoyé conservera les guillemets.

 

Logiquement, une autre question se pose dans votre esprit : à quoi sert le table.getn(NomTableau) ?

 

C'est en réalité très simple, cette fonction vous renvoie la taille du tableau.

Prenons par exemple un tableau de phrases pour changer un peu :

 local string_table = {"Le chat est noir", "La souris est blanche", "Le cochon est rose"}

 

Ici, le tableau se compose de 3 données différentes, séparées par des virgules.

Vous aurez donc, entre [], des chiffres allant de 1 à 3.

 

Prenons pour hypothèse que vous voulez choisir une de ces phrases aléatoirement.

(nous sommes déjà dans un code, je vous montre juste la partie concernée)

when 20000.chat."Annoncer une phrase" begin
     local string_table = {"Le chat est noir", "La souris est blanche", "Le cochon est rose"}
     notice_all(string_table[number(1, table.getn(string_table))])
end

 

Pour être plus clair, nous allons annoncer une phrase contenue dans le tableau.

Cette phrase sera choisir aléatoirement par un procédé simple : l'utilisation de deux fonctions : number() et table.getn().

 

La première, vous la connaissez, choisit un nombre entre deux extrémités.

On commence par 1 et on termine par : table.getn(string_table).

Comme vu précédemment, cette fonction renvoie la taille du tableau. Ici, le tableau se compose de 3 données, sa taille sera donc 3.

 

Vous allez me demander : pourquoi ne pas mettre number(1,3) ?

 

Vous pouvez le faire, cependant, la fonction comporte un avantage : lorsque vous ajoutez quelques choses dans le tableau, elle l'intègre automatiquement.

Par exemple, en ajoutant une phrase dans le tableau :

 local string_table = {"Le chat est noir", "La souris est blanche", "Le cochon est rose"}

Pour obtenir :

local string_table = {"Le chat est noir", "La souris est blanche", "Le cochon est rose", "Le poussin est jaune"}

La taille du tableau passera à 4, et la fonction la comprendra d'elle-même.

 

Remarque :

La fonction getn() parcourt les index du tableau dans l'ordre croissant jusqu'à ce qu'il tombe sur un index dit nil, qui est une valeur nulle en lua.

local tab = {
	[1] = "Premier index",
	[2] = "Deuxième index",
	[12] = "Douzième index"
}

Ici table.getn(tab) renverra la valeur 2 et non 3 car l'index 3 n'existe pas.

Le fait de ne pas indiquer d'index lors de l'écriture d'un tableau laisse lua gérer les index de manière croissante. De la même façon, table.insert() insérera la valeur au premier index dont la valeur est nil.

 

 

 

II. Les tableaux multidimensionnels.

 

Ne soyez pas effrayés par la taille de ce mot, les tableaux multidimensionnels ne sont pas beaucoup plus compliqués à comprendre.

Il faut juste retenir une chose : ce sont des tableaux dans des tableaux.

 

 

a. Déclaration, Création.

 

Révélation

 

 

Comme pour les tableaux simples, ces tableaux se déclarent comme des variables :

local NomTableau = {}

Sauf qu'ils ne seront pas remplis de données, mais bien d'autres tableaux.

 

 

 

 

b. Remplissage.

 

Révélation

 

 

Voilà comment remplir un tableau multidimensionnels.

Le but est d'insérer plusieurs tableaux dans un tableau.

local NomTableau = {
     [1] = {125, 1465, 1484, 4578},
     [2] = {154, 4758, 4824, 1456},
     [3] = {124, 1568, 1478, 4576}
}

Le tableau peut aussi s'écrire en ligne :

local NomTableau = {{125, 1465, 1484, 4578}, {154, 4758, 4824, 1456}, {124, 1568, 1478, 4576}}

Cependant, pour des raisons de lisibilité je préfère la première façon et je l'utiliserai pour le tutoriel.

 

Ce tableau est très simple, il est constitué de deux dimensions.

Je précise une chose avant d'aller plus loin : les [n] = ne sont pas obligatoires, ils sont utiles pour commencer.

 

Pour le contenu, c'est la même chose que pour les tableaux simples, il ne faut pas oublier les " et virgules.

Ce qui change ici, c'est la forme. Il y a plusieurs tableaux dans le tableau principal.

 

Remarque :

Vous remarquerez les virgules après chaque tableau pour passer au suivant, il ne faut surtout pas les oublier.

Notez également qu'il n'y en a pas après le dernier tableau.

 

Le tableau secondaire est ouvert et fermé sur la même ligne par des accolades {}, on peut dire que le tableau est écrit en ligne.

Le tableau principal quant à lui, est ouvert sur la première ligne puis fermé tout à la fin avec les accolades {}, on peut dire que le tableau est écrit de manière développé.

Ceci n'est pas obligatoire mais il s'agit d'un style d'écriture facilitant la lecture des tableaux.

 

Nous pouvons avoir un tableau dans un tableau qui se situe dans un tableau qui se trouve lui même dans un autre tableau. Vous comprendrez qu'il est possible d'imbriquer une infinité de tableau.

 

Je vous montre autre chose :

Par exemple, nous voulons stocker des valeurs dans des catégories, et connaître le nom de cette catégorie.

local NomTableau = {
	[1] = {
		["nom"] = "Epées",
		["contenu"] = {
			-- vnum -- nom
			{1520, "Epée de puissance"},
			{1530, "Epée de sorcier"},
			{1540, "Epée maudite"}
		}
	},
	[2] = {
		["nom"] = "Dagues",
		["contenu"] = {
			-- vnum -- nom
			{1420, "Dagues de puissance"},
			{1430, "Dagues de sorcier"},
			{1440, "Dagues maudites"}
		}
	}
}

Ici, commençons par observer les balises (entre crochets []).

Les balises numériques ne sont pas obligatoires, comme précisé précédemment. Cependant, des balises de textes pourront être ajoutées.

Ces balises vous permettrons de retrouver l'endroit où elles se trouvent, comme les nombres.

 

Par exemple ici, pour retrouver le vnum des Dagues maudites, je dois faire :

NomTableau[2]["contenu"][3][1]

À chaque fois je dois aller chercher l'emplacement du tableau dans le tableau précédent.

 

Si besoin, je suis disponible par message privé pour vous donner d'autres exemples et vous aider dans la compréhension de ce système.

 

Maintenant, regardons la structure du tableau.

Vous voyez que tout n'est pas sur la même ligne. Des tabulations sont nécessaires pour différencier les tableaux. Je vous conseille vivement de constituer vos tableaux avec des tabulations : +1, +3, +1, +3, etc..

 

Remarque :

N'oubliez pas les virgules à la fin de chaque tableau, sauf pour le dernier de chaque tableau.

Ce qui se trouve entre guillemets " " doit être restitué à la lettre prêt. Cela remplace les chiffres ou nombres habituels entre crochets [].

 

 

 

 

c. Utilisation.

 

Révélation

 

 

Un tableau multidimensionnel sera très utile lorsque vous souhaitez stocker plusieurs types d'informations.

Il sera aussi plus pratique lorsque vous avez, par exemple, des catégories, comme ci-dessus.

 

Prenons un exemple tout simple pour illustrer tout ça.

J'aimerais stocker des bonus, répartis en 2 catégories.

(Nous sommes déjà dans un code, je vous montre juste la partie concernée)

when kill with npc.get_race() == 304 and pc.get_map_index() == 121 begin
	local bonus_table = {
		[1] = {
			["nom"] = "Attaque",
			["bonus"] = {
				{"Force", 5},
				{"Intelligence", 4},
				{"Dextérite", 6},
				{"Demi-humains", 17}
			}
		},
		[2] = {
			["nom"] = "Défense",
			["bonus"] = {
				{"Régénération de vie", 10},
				{"Résistance au poison", 41},
				{"Résistance au dégâts moyens", 74},
				{"Résistance au dégâts de compétence", 73}
			}
		}
	}
	local i = number(1,table.getn(bonus_table))
	local j = number(1,table.getn(bonus_table[i][2]))
	affect.add_hair(bonus_table[i][2][j][2], 10, 10*60)
	notice("Vous avez obtenu un bonus de "..bonus_table[i][2][j][1]..".")
end

Ici je ne m'occupe pas des noms des catégories, mais voilà un exemple de l'application de ces tableaux. Après, c'est à vous de leur trouver une utilité.

 

Petite explication :

affect.add_hair(bonus, puissance, durée)

La durée est en secondes.

 

 

 

 

d. Récupération des données.
 

Révélation

 

Contrairement aux tableaux simples, les tableaux multidimensionnels se composent de plusieurs tableaux, ce qui rend l'accès aux données stockées plus compliqué.

 

Prenons pour exemple un tableau très simple :

local NomTableau = {
	[1] = {
		["nom"] = "Epées",
		["contenu"] = {
			-- vnum -- nom
			{1520, "Epée de puissance"},
			{1530, "Epée de sorcier"},
			{1540, "Epée maudite"}
		}
	},
	[2] = {
		["nom"] = "Dagues"
		["contenu"] = {
			-- vnum -- nom
			{1420, "Dagues de puissance"},
			{1430, "Dagues de sorcier"},
			{1440, "Dagues maudites"}
		}
	}
}

Alors, la formule pour trouver un vnum ou un nom sera :

NomTableau[A][B][C][D]

A correspond au premier tableau sélectionné dans le tableau NomTableau. Il sera de valeur numérique comme les autres.

B, lui, correspondra au tableau sélectionné dans le tableau A.

C, dans le cas où B = 2, correspond aux tableaux sélectionné dans le tableau B, il renverra donc à un tableau sous la forme : {vnum, "nom"}

Pour choisir une des données du tableau C, on donne une valeur à D, qui sélectionnera la valeur demandée.

 

Attention :

La majeure partie des erreurs liées aux tableaux sont dues à un mauvaise indice (nombres A, B, C, D, etc..). Pensez à toujours vous relire !

 

 

 

III. Quelques fonction à savoir

 

 

Après table.getn(NomTableau), voici plusieurs autres fonctions qui pourront vous servir.

 

Dans les exemples qui suivent, je vais utiliser ce tableau :

formule_table = {"Bonjour", 1, "Bonsoir", 2, 4, "Salut"}

 

a. Insertion dans un tableau.

 

Révélation

 

 

table.insert(NomTableau, valeur)

Cette fonction vous permet d'ajouter une valeur dans un tableau. A vous de lui trouver une utilité.

 

Exemple :

table.insert(formule_table, 5)

Renvoie la valeur 5 dans le tableau formule_table :

formule_table = {"Bonjour", 1, "Bonsoir", 2, 4, "Salut", 5}

 

 

 

 

 

b. Sélection aléatoire dans un tableau.

 

Révélation

 

 

table_get_random_item(NomTableau)

Cette fonction va choisir une valeur aléatoire dans le tableau.

 

Exemple :

local choix = table_get_random_item(formule_table)

Peut renvoyer n'importe quelle valeur du tableau formule_table.

 

 

 

 

 

c. Présence d'une valeur dans un tableau.

 

Révélation

 

 

table_is_in(NomTableau, valeur)

Cette fonction permet de savoir si une valeur est dans un tableau. C'est donc très utile pour les boucles.

Si vous ne possédez pas cette fonction, elle est disponible ici.

 

Exemple :

if table_is_in(formule_table, 4) then -- comme 4 est dans la table, les instructions seront effectuées.
	--instructions
end

if !table_is_in(formule_table, 6) then -- là, je cherche à savoir si 6 n'est pas dans la table (le ! joue le même rôle que le not)
	table.insert(formule_table, 6) -- comme il n'est pas dans la table, je l'ajoute avec table.insert()
end

 

 

 

 

 

d. Suppression d'une valeur dans un tableau.

 

Révélation

 

 

table.remove(NomTableau, position)

Cette fonction va supprimer la valeur dont on renseigne la position dans le tableau NomTableau. Elle renseigne aussi la valeur de l'élément supprimé.

 

Exemple :

table.remove(formule_table, 5) -- va supprimer la 5ème valeur du tableau formule_table

Le tableau ressemblera alors à :

formule_table = {"Bonjour", 1, "Bonsoir", 2, "Salut"} -- la valeur 4 a été supprimée car elle était en 5ème position

Si vous ne renseignez pas le champ position, c'est la dernière valeur du tableau qui sera supprimée.

 

 

 

 

 

e. Concaténation de valeurs présentes dans un tableau.

 

Révélation

 

 

table.concat(NomTableau, séparateur, début, fin)

Cette fonction renvoie les données du tableau concaténées avec le séparateur, à partir de l'index début, jusque l'index fin.

Début et fin ne sont pas obligatoires, début peut être seul, mais pas fin.

 

Prenons un autre tableau cette fois :

table_exemple = {"Le", "ciel", "est", "bleu"}

 

Exemple :

notice(table.concat(table_exemple, " - ")) 

Attention aux espaces entre les ", si vous ne les mettez pas, il n'y en aura pas entre vos caractères.

Cette fonction va afficher : Le - ciel - est - bleu sur le chat local.

 

 

 

 

 

f. Tri des valeurs dans un tableau.

 

Révélation

 

 

table.sort(NomTable, fonction de tri)

La fonction de tri n'est pas obligatoire et dans le cas où elle est absente, les valeurs seront dans l'ordre croissant.

Cette fonction va trier les données du tableau NomTable selon une fonction de tri.

 

Prenons ce tableau :

table_a_trier = {2, 5, 7, 4, 8, 1, 3, 6, 9}

Nous sommes dans la quête misterMob.

 

function fonction_tri(a, b)
	return a > b
end

 

Exemple :

table.sort(table_a_trier, misterMob.fonction_tri(a, b)) 

Résultat : 9, 8, 7, 6, 5, 4, 3, 2, 1

 

 

 

 

 

IV. Les tableaux dans le questlib.lua

 

Dernier point sur lequel je vais m'attarder dans ce tutoriel. Merci à Ant0k pour sa participation.

Vous pouvez créer des tableaux dans le questlib.lua. De cette manière, les tableaux seront accessibles dans tous les fichiers .quest.

 

Dans ce fichier (questlib.lua), vous pouvez créer un type particulier de tableau :

NomTableau = {["keys"] = "super"}

function NomTableau.NomFonction()
	return "Tout fonctionne : "..NomTableau["keys"].." !"
end

 

Dans votre code (fichier .quest), vous introduirez cette fonction (en lien avec celles mises au dessus) :

chat(NomTableau.NomFonction())

Qui affichera : Tout fonctionne : super ! dans le chat.

 

 

Je pense que pour débuter, tout cela est suffisant.

Après, vous avez toujours la possibilité de trouver des fonctions relatives aux tableaux dans le questlib de votre serveur.

 

Je pense en avoir fini avec ce tutoriel, j'espère qu'il en aidera plus d'un !

Si vous avez des questions, n'hésitez pas à les poser. Si vous avez des remarques, des améliorations à me transmettre, n'hésitez pas non plus, je suis ouvert à toutes critiques !

 

Bonne journée/soirée et à bientôt !

Modifié le 14 septembre 2018 par _Sufhal

[Calypso 6797]

Très bon tutoriel, merci à toi

[Valithis² 95]

Tu m'as devancé, c'était la seconde partie de mon second tutoriel avec les timers & co :'(

Néanmoins, tu as poussé l'explication plus loin que je l'aurais fais.

Bon tutoriel.

[Kijaru 1362]

Merci pour ce très beau tutoriel

[Swice 14]

Tu m'as devancé, c'était la seconde partie de mon second tutoriel avec les timers & co :'(

Néanmoins, tu as poussé l'explication plus loin que je l'aurais fais.

Bon tutoriel.

 

Salut,

 

Si tu souhaites ajouter une chose ou me corriger sur un point, n'hésites surtout pas 

 

 

 

Edit : Mise à jour du tutoriel (partie III) avec l'ajout de plusieurs fonctions et d'exemples relatifs à ces fonctions.

 

 

Bonne journée !

[antok 62]

Yop, tu peux aussi rajouter qu'en mettant ton tableau dans locale.lua il sera accessible par toute les quêtes.

Vous pouvez aussi créer des fonctions de ce type (dans le questlib.lua) :

tableau = {["key"] = "value" }

function tableau.maFonction()
return "CA MARCHE!!!!! : "..tableau["key"].."."
end

 

chat(tableau.maFonction()) -- code placé dans votre quête

 

Ce code affichera "CA MARCHE!!!!! : value." dans le chat.

[Swice 14]

Merci pour ce petit ajout Ant0k, j'édite le tutoriel.

[Calypso 6797]

Tutoriel acceptée.

Merci pour ton investissement Swice

[iThorgrim 5]

Je me permet de faire un ajout si jamais
Il est possible d'utiliser les tableaux pour faire des Switch "maison", bah oui foutre des if tout partout c'est très très vite dégeu'!

On va prendre comme exemple un jeu, dans notre jeu notre niveau est 1.

Une fonction qui n'existe pas "GetLevel()" récupére le niveau.

Le but de notre code c'est de dire que si notre joueur est tel ou tel niveau alors il se passeras une action.

Le code avec les if pourrais ressembler à ceci :

...
if (player:GetLevel() == 1) then
	player:SuperbeAction();
elseif (player:GetLevel() == 2) then
	player:SuperbeAction();
elseif (player:GetLevel() == 3) then
	player:SuperbeAction();
elseif (player:GetLevel() == 4) then
	player:SuperbeAction();
elseif (player:GetLevel() == 5) then
	player:SuperbeAction();
else
...

Bon si vous avez du coup 200 possibilités ça deviens vite dégeu, mais vous avez la technique du Tableau Switch!

...
local Switch = {
	[1] = function (player)
		player:SuperbeAction()
	end,

	[2] = function (player)
		player:SuperbeAction()
	end,
};
Switch[player:GetLevel()](player);
...

 

Modifié le 28 juin 2020 par iThorgrim