Tu as déjà entendu parler des tables mais tu ne sais pas ce que c'est ou même comment t'en servir

Les tables en Lua

Le but de ce tutoriel est de voir ensemble comment créer ces propres function Lua et gLua.

### Comment ça marche

Les fonctions en Lua

### Avant de commencer, c'est quoi un objet ?

Si on prend le monde réel (si si, vous allez voir, vous

La programmation orientée objet en Lua

gLua

Le but de ce tutoriel est de voir ensemble comment créer ces propres function Lua et gLua.

### Comment ça marche ?

Une function en Lua a une structure très basique, premièrement on va déclarer l'entête d'une function comme ceci : 
`function maFunction()` 
Et on termine notre function par un `end`.
En dessous de l'entête de ma function je peux y mettre mon code en identant le tout.
Ce qui donne : 
```lua
function maFunction()
    // mon code
end
```
> Le Lua n'est pas sensible à l'indentation, ce n'est pas obligé, sa rend le code plus lisible, tandis qu'en Python nous somme contraint à l'indentation.
> 

Voici un exemple d'une fonction très simple en Lua : 
```lua
function helloWord()
    return "Hello World !"
end
helloWord() // renvoie: Hello World !
```

### Les fonctions argumentées.

Une fonction argumentée est une fonctions ou l'on pourra y définir des valeurs de notre choix lors de l'appelation de cette dernière ! Ces arguments sont placés entre les parenthèses lors de la déclaration de la fonction, voici un exemple très simple d'une fonction argumentée en gLua :
```lua
function nomAleatoire(names) -- Notre arguments dans cette fonction est 'names', c'est une table
    return names[math.random(1, #names)] -- ici on va dire de retourner un nom aléatoire de la table names en générant un nombre aléatoires entre 1 et la dernière key de la table 'names'
end
nomAleatoire({"Jean","Pierre","Paul","Jacques"})
```
Output:
`Jean` ou `Pierre` ou `Paul` ou `Jacques`
### Les fonctions de calculs

Dans cette partie nous allons voir comment faire une fonction qui nous permettra de calculer un nombre après soustraction d'un pourcentage à ce dernier.
```lua
function pourcentage(nbr,percent) -- On déclare notre fonction
    if not isnumber(nbr) then return end -- On vérifie que "nbr" est un nombre pour éviter les erreurs
    if not isnumber(percent) then return end -- Idem pour "percent"

    soustract = ( nbr / 100 ) * percent -- On calcule le nombre que l'on devra soustraire de notre nombre original "nbr"
    result = nbr - soustract -- On soustrait le pourcentage au nombre original "nbr

    return result -- On retourne le résultat de calcul
end
print(pourcentage(500, 20)) -- On va afficher le nombre après soustraction de 20% de 500
```

### Les métafonctions en gLua

Les métafonctions servent par exemple à définir des valeurs sur une métatables ou bien y exécuter du code, lui ordonner une action, au niveau de la structure, c'est la même que pour les fonctions seul petit changement, le nom de la fonction commencera par la variable de la métatable, voici un exemple !
```lua
local gcaUsers = FindMetaTable("Player") -- Ici on définit gcaUsers comme étant la métatable sur la classe "Player"

function gcaUsers:estVivant() -- On déclare notre métafonction
    if self:IsAlive() then -- On fait une condition booléenne
        print(self:Nick()..' est en vie !') -- Si true alors on affiche dans la console : X est en vie !
    else
        print(self:Nick().." n'est plus parmis nous :( ")  -- Si false alors on affiche dans la console : X n'est plus parmis nous :(
    end
end
```

Une fois que l'on a crée notre métafonction, on peut l'utiliser n'importe où ! Exemple :

```lua
for _, v in pairs(player.GetAll()) do
    v:estVivant()
end
```
Output : 
`Zeta est en vie !`

<data>NE PAS SUPPRIMER CETTE LIGNE!</data>

Apprendre la programmation en Lua, notamment en lien avec Garry's Mod