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

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

Si on prend le monde réel (si si, vous allez voir, vous connaissez…), nous sommes entourés d’objets : une chaise, une table, une voiture, etc. Ces objets forment un tout.

* Ils possèdent des propriétés (la chaise possède 4 pieds, elle est de couleur bleue, etc.).

* Ces objets peuvent faire des actions (la voiture peut rouler, klaxonner, etc.).

* Ils peuvent également interagir entre eux (l’objet conducteur démarre la voiture, l’objet volant fait tourner l’objet voiture, etc.).

Il faut bien faire attention à distinguer ce qu’est l’objet et ce qu'est la définition d’un objet

### La définition de l'objet
La définition de l’objet (ou structure de l’objet) permet d’indiquer ce qui compose un objet, c'est-à-dire quelles sont ses propriétés, ses actions etc. Comme par exemple le fait qu’une chaise ait des pieds ou qu’on puisse s’asseoir dessus.
Par contre, l’objet chaise est bien concret. On peut donc avoir plusieurs objets chaises : on parle également d’instances. Les objets chaises, ce sont bien celles concrètes que l’on voit devant nous autour de l’objet table pour démarrer une partie de belote.

On peut faire l’analogie avec notre dictionnaire qui nous décrit ce qu’est une chaise. Le dictionnaire décrit en quoi consiste l’objet, et l’instance de l’objet représente le concret associé à cette définition. Chaque objet a sa propre vie et est différent d’un autre. Nous pouvons avoir une chaise bleue, une autre rouge, une autre avec des roulettes, une cassée …

Bon, finalement la notion d’objet est plutôt simple quand on la ramène à ce qu’on connait déjà :D .

Sachant qu’un objet en programmation c’est comme un objet du monde réel mais ce n’est pas forcément restreint au matériel. Un chien est un objet. Des concepts comme l’amour ou une idée sont également des objets, tandis qu’on ne dirait pas cela dans le monde réel.

#### En résumé
* La définition (ou structure) d’un objet est un concept abstrait, comme une définition dans le dictionnaire. Cette définition décrit les caractéristiques d’un objet (la chaise a des pieds, l’homme a des jambes, etc.). Cette définition est unique comme une définition dans le dictionnaire.
* Un objet ou une instance est la réalisation concrète de la structure de l’objet. On peut avoir de multiples instances, comme les 100 voitures sur le parking devant chez moi. Elles peuvent avoir des caractéristiques différentes (une voiture bleue, une voiture électrique, une voiture à 5 portes, etc.)

### Mais à quoi ça sert les objets ?

Nous avons décrit plusieurs concepts de la programmation orientée objet mais nous n’avons pas encore dit à quoi elle allait nous servir.

En fait, on peut dire que la [POO](https://fr.wikipedia.org/wiki/Programmation_orientée_objet) (Programmation Orientée Objet) est une façon de développer une application qui consiste à représenter (on dit également « modéliser ») une application informatique sous la forme d’objets, ayant des propriétés et pouvant interagir entre eux. La modélisation orientée objet est proche de la réalité ce qui fait qu’il sera relativement facile de modéliser une application de cette façon. De plus, les personnes non-techniques pourront comprendre et éventuellement participer à cette modélisation.

Cette façon de modéliser les choses permet également de découper une grosse application, généralement floue, en une multitude d’objets interagissant entre eux. Cela permet de découper un gros problème en plus petits afin de le résoudre plus facilement.

Utiliser une approche orientée objet améliore également la maintenabilité. Plus le temps passe et plus une application est difficile à maintenir. Il devient difficile de corriger des choses sans tout casser ou d’ajouter des fonctionnalités sans provoquer une régression par ailleurs. L’orienté objet nous aide ici à limiter la casse en proposant une approche où les modifications internes à un objet n’affectent pas tout le reste du code, grâce notamment à l’encapsulation.

Un autre avantage de la [POO](https://fr.wikipedia.org/wiki/Programmation_orientée_objet) est la réutilisabilité. Des objets peuvent être réutilisés ou même étendus grâce à l’héritage.

Il faut savoir que la [POO](https://fr.wikipedia.org/wiki/Programmation_orientée_objet), c’est beaucoup plus que ça et nous en verrons des subtilités plus loin, mais comprendre ce qu’est un objet est globalement suffisant pour une grande partie du tutoriel.

#### En résumé
* L’approche orientée objet permet de modéliser son application sous la forme d’interactions entre objets.
* Les objets ont des propriétés et peuvent faire des actions.
* Ils masquent la complexité d'une implémentation grâce à l'encapsulation.
* Les objets peuvent hériter de fonctionnalités d'autres objets s'il y a une relation d'héritage entre eux.

### Créez votre premier objet
**Dans ce tutoriel nous utiliserons les métatables.**

Les métatables sont un outil pour simuler la programmation orientée objet en raison de leur comportement.
 
Commençons par créer notre métatable :
```lua
local Voiture = {} -- C'est notre metatable. Il représentera notre "Classe".
Voiture.__index = Voiture
```

Maintenant, nous avons besoin d'une fonction qui sera appelée à la création de notre objet, le plus souvent appelé "new".
 
```lua
local Voiture = {} -- C'est notre metatable. Il représentera notre "Classe".
Voiture.__index = Voiture

function Voiture:new(vitesse, couleur)
    -- Voici la table que nous allons retourner
    local instance = {}
    instance.vitesse = vitesse or 120
    instance.couleur = couleur or Color(255, 0, 0)
    -- vitesse et couleur sont ici des propriétées de notre object Voiture

    setmetatable(instance, Voiture)
    return instance
end
```

Maintenant que notre base est prête, ajoutons quelques fonctions :
 
```lua
-- 1: Table de l'objet (en l'occurence "Voiture")
-- 2: Variable à manipuler
-- 3: Nom formatté pour les fonctions (Get/Set) (Exemple: Vitesse donc: GetVitesse/SetVitesse)
-- 4: Type de variable (Énumérations disponibles: FORCE_STRING/FORCE_NUMBER/FORCE_BOOL)
AccessorFunc(Voiture, "vitesse", "Vitesse", FORCE_NUMBER)
AccessorFunc(Voiture, "couleur", "Couleur") -- Même manipulation sans le dernier argument car il n'y a pas d'énumération pour les couleurs (Color())
--> https://github.com/Facepunch/garrysmod/blob/master/garrysmod/lua/includes/util.lua#L178-L198

-- Désormais affichons la voiture !
function Voiture:Display()
    -- Ici on récupère la couleur de notre voiture
    local couleur = self:GetCouleur() -- Cette fonction est générée grace aux "AccessorFunc"

    MsgC(couleur, [[
         ___________
        //   |||   \\         
     __//____|||____\\____   
    | _|      |       _  ||
    |/ \______|______/ \_||
     \_/             \_/
    ]] .. "\n")
    -- Et pif, paf, pouf, de l'ASCII !
end
```

Enfin, nous allons créer une fonction `Voiture()` qui est identique à `Voiture:new()`.

```lua
setmetatable(Voiture, {__call = Voiture.new})
```

Nous avons maintenant créé avec succès notre nouvelle classe !

```lua
local Voiture = {} -- C'est notre metatable. Il représentera notre "Classe".
Voiture.__index = Voiture

function Voiture:new(vitesse, couleur)
    -- Voici la table que nous allons retourner
    local instance = {}
    instance.vitesse = vitesse or 120
    instance.couleur = couleur or Color(255, 0, 0)

    setmetatable(instance, Voiture)
    return instance
end

-- 1: Table de l'objet (en l'occurence "Voiture")
-- 2: Variable à manipuler
-- 3: Nom formatté pour les fonctions (Get/Set) (Exemple: Vitesse donc: GetVitesse/SetVitesse)
-- 4: Type de variable (Énumérations disponibles: FORCE_STRING/FORCE_NUMBER/FORCE_BOOL)
AccessorFunc(Voiture, "vitesse", "Vitesse", FORCE_NUMBER)
AccessorFunc(Voiture, "couleur", "Couleur") -- Même manipulation sans le dernier argument car il n'y a pas d'énumération pour les couleurs (Color())
--> https://github.com/Facepunch/garrysmod/blob/master/garrysmod/lua/includes/util.lua#L178-L198

-- Désormais affichons la voiture !
function Voiture:Display()
   -- Ici on récupère la couleur de notre voiture
   local couleur = self:GetCouleur() -- Cette fonction est générée grace aux "AccessorFunc"

   MsgC(couleur, [[
        ___________
       //   |||   \\         
    __//____|||____\\____   
   | _|      |       _  ||
   |/ \______|______/ \_||
    \_/             \_/
   ]] .. "\n")
   -- Et pif, paf, pouf, de l'ASCII !
end

setmetatable(Voiture, {__call = Voiture.new})
```

### Et si on testait ?

```lua
print("==== Voiture n°1 ====")

local MaVoiture = Voiture() -- Création de l'objet sans passer les arguments dans le constructeur
MaVoiture:SetVitesse(90) -- On définit une vitesse
MaVoiture:SetCouleur(Color(255, 0, 255)) -- Puis une couleur
MaVoiture:Display() -- On l'affiche
print(MaVoiture:GetVitesse()) -- Elle roule à combien déjà?

print("==== Voiture n°2 ====")

local MaVoiture2 = Voiture(360, Color(255, 107, 129)) -- Création de l'objet en passant les arguments dans le constructeur
MaVoiture2:Display() -- On l'affiche
print(MaVoiture2:GetVitesse()) -- Elle roule à combien déjà?
```

![Résultat](https://i.imgur.com/UHZxiKt.png)
### Simplification
Il est également possible de **simplifier ce processus de création d'objets** avec cette petite fonction :
```lua
function Class(constructor)
    local class = {}
    class.__index = class

    function class:new(...)
        local instance = {}
        if constructor and isfunction(constructor) then
            instance = constructor(...)
        end

        setmetatable(instance, class)
        return instance
    end

    setmetatable(class, {__call = class.new})
    return class
end
```
  
  Pour son **utilisation**, c'est très facile !
  
  ```lua
local Object = Class(function(value)
    local t = {}
    t.value = value or "Hello World"

    return t
end)

function Object:GetValue()
    return self.value
end

function Object:SetValue(value)
    self.value = value
end
```
   
### Aller plus loin
Un **tutoriel détaillé en anglais** est également disponible sur le [Wiki de Garry's Mod](https://wiki.facepunch.com/gmod/Object_Oriented_Lua) !
#### Vous en voulez encore plus, cette partie est pour vous !

Je vais alors vous présenter un compileur Lua, faites du bruit pour... [MoonScript](https://moonscript.org/) !

MoonScript est un langage de script dynamique qui se compile en Lua. Il vous offre la puissance de l'un des langages de script les plus rapides, combinée à un riche ensemble de fonctionnalités.

Sa particularité physique, **le gain de temps** !
Et forcément, [sa documentation](https://moonscript.org/reference/) !

Il possède également la possibilité [d'écrire et de compiler son code en ligne](https://moonscript.org/compiler/) sans avoir besoin de [l'installer](https://moonscript.org/#installation) !

#### Exemple
 Voici un exemple que vous retrouverez en MoonScript :
```lua
class Thing
  name: "unknown"

class Person extends Thing
  say_name: => print "Hello, I am #{@name}!"

with Person!
  .name = "MoonScript"
  \say_name!
```
**Waaah! Mais quelle simplicité !**

Ce qui nous retournera en Lua :
```lua
local Thing
do
  local _class_0
  local _base_0 = {
    name = "unknown"
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function() end,
    __base = _base_0,
    __name = "Thing"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Thing = _class_0
end
local Person
do
  local _class_0
  local _parent_0 = Thing
  local _base_0 = {
    say_name = function(self)
      return print("Hello, I am " .. tostring(self.name) .. "!")
    end
  }
  _base_0.__index = _base_0
  setmetatable(_base_0, _parent_0.__base)
  _class_0 = setmetatable({
    __init = function(self, ...)
      return _class_0.__parent.__init(self, ...)
    end,
    __base = _base_0,
    __name = "Person",
    __parent = _parent_0
  }, {
    __index = function(cls, name)
      local val = rawget(_base_0, name)
      if val == nil then
        local parent = rawget(cls, "__parent")
        if parent then
          return parent[name]
        end
      else
        return val
      end
    end,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  if _parent_0.__inherited then
    _parent_0.__inherited(_parent_0, _class_0)
  end
  Person = _class_0
end
do
  local _with_0 = Person()
  _with_0.name = "MoonScript"
  _with_0:say_name()
end
```
**Waaah! Mais quel charabia dites moi donc !**

La sortie de ce code est la suivante (après exécution) : `Hello, I am MoonScript!`.

Bon j'suis d'accord que la structure peut être complexe au début, mais après c'est succulent !

### Héritage

Un autre élément important dans la programmation orientée objet que nous allons aborder est l’héritage.

> Ah bon ? Les objets aussi peuvent mourir et transmettre leur patrimoine ?
> 
Eh bien c’est presque comme en droit, à part que l’objet ne meurt pas et qu’il n’y pas de taxe sur l’héritage.
C’est-à-dire qu’un objet dit « père » peut transmettre certaines de ses caractéristiques à un autre objet dit « fils ».

Pour cela, on pourra définir une relation d’héritage entre eux. S’il y a une relation d’héritage entre un objet père et un objet fils, alors l’objet fils hérite de l’objet père. On dit également que l’objet fils est une spécialisation de l’objet père ou qu’il dérive de l’objet père.

En langage plus courant on peut également dire que l’objet fils est « une sorte » d’objet père.

On dit souvent qu’un petit exemple vaut bien un long discours, alors prenons par exemple l’objet « chien » et imaginons ses caractéristiques tirées du monde réel en utilisant l’héritage :

* L’objet « chien » est une sorte d’objet « mammifère »

* L’objet « mammifère » est une sorte d’objet « animal »

* L’objet « animal » est une sorte d’objet « être vivant »

Chaque père est un peu plus général que son fils. Et inversement, chaque fils est un peu plus spécialisé que son père. Avec l’exemple du dessus, un mammifère est un peu plus général qu’un chien, l’être vivant étant encore plus général qu’un mammifère.

Il est possible pour un père d’avoir plusieurs fils, par contre, l’inverse est impossible, un fils ne peut pas avoir plusieurs pères. Et oui, c’est triste mais c’est comme ça, c’est le règne du père célibataire avec plusieurs enfants à charge !

Ainsi, un objet « chat » peut également être un fils de l’objet « mammifère ». Un objet « végétal » peut également être fils de l’objet « être vivant ».

Ce qu’on peut reproduire sur le schéma suivant. Chaque bulle représentant un objet et chaque flèche représente l’héritage entre les objets.

![Schéma](https://i.imgur.com/YgVtxqn.png)

On peut définir une sorte de hiérarchie entre les objets, un peu comme on le ferait avec un arbre généalogique. La différence est qu’un objet héritant d’un autre peut obtenir certains ou tous les comportements de l’objet qu’il spécialise, alors qu’un petit enfant n’hérite pas forcément des yeux bleus de sa mère ou du côté bougon de son grand-père, le hasard de la nature faisant le reste.

Pour bien comprendre cet héritage de comportement, empruntons à nouveau les exemples du monde réel.

* L’être vivant peut par exemple faire l’action « vivre ».

* Le mammifère possède des yeux.

* Le chien, qui est une sorte d’être vivant et une sorte de mammifère, peut également faire l’action « vivre » et aura des yeux.

* Le chat qui est une autre sorte d’être vivant peut lui aussi faire l’action « vivre » et aura également des yeux.

On voit bien ici que le chat et le chien héritent des comportements de leurs parents et grands-parents en étant capables de vivre et d’avoir des yeux.
Par contre, l’action « aboyer » est spécifique au chien. Ce qui veut dire que ni le chat, ni le dauphin ne seront capables d’aboyer. Il n’y a que dans les dessins animés de Tex Avery que ceci est possible !
Évidemment, il n’y a pas de notion d’héritage entre le chien et le chat et l’action aboyer est définie au niveau du comportement du chien. Ceci implique également que seul un objet qui est une sorte de chien, par exemple l’objet Labrador ou l’objet Chihuahua, pourra hériter du comportement « aboyer », car il y a une relation d’héritage entre eux.
Finalement, c'est plutôt logique. :D
Rappelons juste avant de terminer ce paragraphe qu’un objet ne peut pas hériter de plusieurs objets. Il ne peut hériter que d’un seul objet.

### Conclusion

Sur ce point je ne vais pas rentrer dans les détails car il y a déjà une documentation toute faite :KappaRetard: !

Bref, retenez que  [MoonScript](https://moonscript.org/) vous offre la possibilité de :
- Gagner du temps sur l'écriture de son code
- Permet l'héritage

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

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