Reorganise + add French

1. Basic Syntax and Data Types.md → English/1. Basic Syntax and Data Types.md

@@ -59,7 +59,7 @@ isValid = true
 -- This is also a boolean
 isCompleted = false
 ```
-### Tables
+### Tables (see 6. Tables and Metatables)
 Tables are used to store collections of values and can be used as arrays or dictionaries.
 ```lua
 -- This is a table

3. Flow Control.md → English/3. Flow Control.md

@@ -42,7 +42,7 @@ local x = 5
 while x > 0 do
     print(x)
     x = x - 1
-end`
+end
 ```
 
 ## Repeat Until

4. Fivem Basic Functions.md → English/4. Fivem Basic Functions.md

@@ -12,7 +12,7 @@ RegisterCommand("hello", function()
     print("Hello!")
 end, false)
 ```
-The first argument is the command name, the second argument is the callback function that will be executed when the command is called, and the third argument is the "restricted" boolean : If this is a server command and you set this to true, then players will need the command.yourCommandName ace permission to execute this command
+The first argument is the command name, the second argument is the callback function that will be executed when the command is called, and the third argument is the "restricted" boolean : If this is a server command and you set this to true, then players will need the `command.yourCommandName` ace permission to execute this command
 ## Triggering an Event
 To trigger an event that can be handled by other scripts, you can use the TriggerEvent function.
 
@@ -37,11 +37,13 @@ The first argument is the event name, and the second argument is the callback fu
 You can use the GetEntityCoords function to get the player's current position in the world.
 
 ```lua
--- Getting the player's position
-local player = GetPlayerPed(-1)
-local x, y, z = table.unpack(GetEntityCoords(player, true))
+local coords = GetEntityCoords(PlayerPedId())
+-- coords is a vector3 object, to access the specific value (x, y, or z), you have to see the vector3 as a table
+print(coords.x) -- X
+print(coords.y) -- Y
+print(coords.z) -- Z
 ```
-The first argument of the function is the player entity and the second argument is a boolean indicating whether to use the global or the entity's relative coordinates.
+The first argument of the function is the player entity
 
 ## Creating a Blip
 You can use the AddBlipForCoord function to create a blip on the map at a specific position.

Français/1. Syntaxe basique et Type de données.md

@@ -0,0 +1,85 @@
+# Syntaxe de base et types de données
+
+LUA est un langage de programmation léger et facile à apprendre. Dans cette section, nous aborderons la structure de base d'un script LUA, ainsi que les différents types de données disponibles et la manière de les manipuler.
+
+## Structure des scripts
+Un script LUA est un fichier texte brut portant l'extension `.lua`. Le script est exécuté de haut en bas et peut contenir une combinaison d'instructions, de commentaires et de fonctions.
+
+### Déclarations
+Les instructions sont des commandes qui effectuent une action spécifique, telle que l'attribution d'une valeur à une variable ou l'appel d'une fonction. 
+
+-- Voici une instruction qui attribue la valeur "hello" à la variable "greeting"
+greeting = "hello"
+
+### Commentaires
+Les commentaires sont utilisés pour ajouter des notes ou des explications au code et sont ignorés par l'interpréteur. En LUA, les commentaires sont créés en utilisant des doubles tirets (`--`).
+```lua
+-- Ceci est un commentaire et sera ignoré par l'interpréteur
+greeting = "bonjour"
+```
+### Fonctions
+Les fonctions sont des blocs de code qui effectuent une tâche spécifique et qui peuvent être réutilisés dans le script. Les fonctions sont définies en utilisant le mot-clé `function` et sont appelées en utilisant leur nom suivi de parenthèses (`()`).
+```lua
+-- Il s'agit d'une fonction qui imprime un message d'accueil.
+fonction sayHello()
+    print("Bonjour !")
+end
+
+-- Voici comment la fonction est appelée
+sayHello()
+```
+
+## Types de données
+Le LUA prend en charge plusieurs types de données, notamment
+
+### Nombres
+Les nombres sont utilisés pour représenter des valeurs numériques et peuvent être des nombres entiers ou des nombres à virgule flottante.
+```lua
+-- Ceci est un nombre
+age = 25
+
+-- Il s'agit également d'un nombre, mais avec une virgule décimale
+prix = 9.99
+```
+### Chaînes de caractères
+Les chaînes de caractères sont utilisées pour représenter du texte et sont placées entre guillemets doubles ou simples.
+```lua
+-- Il s'agit d'une chaîne de caractères
+name = "John"
+
+-- Il s'agit également d'une chaîne de caractères
+address = '123 Main St'
+```
+### Booléens
+Les booléens sont utilisés pour représenter des valeurs vraies ou fausses.
+```lua
+-- Il s'agit d'un booléen
+isValid = true
+
+-- Il s'agit également d'un booléen
+isCompleted = false
+```
+### Tables (voir 6. Tables et Metatables)
+Les tables sont utilisées pour stocker des collections de valeurs et peuvent être utilisées comme des tableaux ou des dictionnaires.
+```lua
+-- Ceci est une table
+myTable = {1, 2, 3}
+
+-- Il s'agit également d'un tableau, mais avec des clés nommées
+monDictionnaire = {nom = "Jean", âge = 25}
+```
+### Manipuler des données
+Le LUA fournit plusieurs fonctions et opérateurs intégrés pour manipuler des données, comme concaténer des chaînes de caractères, effectuer des opérations mathématiques, etc.
+```lua
+-- Concaténation de chaînes de caractères
+greeting = "Bonjour, " .. "monde !"
+
+-- Effectuer des opérations mathématiques
+somme = 2 + 2
+différence = 10 - 5
+produit = 2 * 3
+quotient = 10 / 2
+```
+Ceci n'est qu'une petite introduction à la syntaxe de base de LUA et aux types de données, il y a beaucoup plus à apprendre et à explorer, comme les structures de contrôle, les bibliothèques et les modules, la POO et plus encore.
+
+Gardez à l'esprit que les extraits de code ne s'exécuteront pas tels quels et qu'ils sont destinés à servir d'exemple et de référence.

Français/2. Variables et fonctions.md

@@ -0,0 +1,61 @@
+# Variables et fonctions
+
+En LUA, les variables sont utilisées pour stocker et manipuler des données, et les fonctions pour organiser et réutiliser le code.
+
+## Variables
+En LUA, les variables sont déclarées en utilisant le mot-clé `local` ou sans aucun mot-clé.
+```lua
+-- Déclarer une variable
+local x = 5
+
+-- Déclare une variable sans le mot-clé `local`
+y = 10
+```
+Il est recommandé d'utiliser le mot-clé local lors de la déclaration d'une variable, car il limite la portée de la variable à la fonction ou au fichier en cours, et empêche l'affectation accidentelle d'une variable globale.
+
+LUA supporte plusieurs types de données, dont les nombres, les chaînes de caractères, les booléens et les tableaux.
+```lua
+-- Déclaration d'une variable numérique
+local age = 25
+
+-- Déclaration d'une variable de type chaîne de caractères
+local name = "John"
+
+-- Déclare une variable booléenne
+local isValid = true
+
+-- Déclaration d'une variable de type tableau
+local myTable = {1, 2, 3}
+```
+## Fonctions
+En LUA, les fonctions sont déclarées à l'aide du mot-clé function et peuvent être appelées en utilisant le nom de la fonction suivi de parenthèses.
+```lua
+-- Déclaration d'une fonction
+fonction sayHello()
+    print("Bonjour !")
+fin
+
+-- Appel d'une fonction
+sayHello()
+```
+Les fonctions peuvent également prendre des paramètres et retourner des valeurs.
+```lua
+-- Déclarer une fonction avec des paramètres
+fonction add(x, y)
+    retourne x + y
+end
+
+-- Appel d'une fonction avec des arguments
+result = add(5, 10)
+```
+Les fonctions peuvent être stockées dans des variables et transmises comme arguments à d'autres fonctions.
+```lua
+-- Stockage d'une fonction dans une variable
+local myFunction = function()
+    print("Hello !")
+end
+
+-- Passer une fonction comme argument
+autreFonction(maFonction)
+```
+Ceci n'est qu'une petite introduction aux variables et aux fonctions en LUA, il y a beaucoup plus à apprendre et à explorer, comme les fermetures, la récursion, et bien d'autres choses encore.

Français/3. Structures de contrôle.md

@@ -0,0 +1,60 @@
+# Structures de contrôle
+
+En LUA, les instructions de contrôle de flux sont utilisées pour contrôler le flux d'exécution d'un script. Elles comprennent les instructions `if`, `else`, `elseif`, `for`, `while` et `repeat`.
+
+## Condition If-Else
+L'instruction `if` est utilisée pour vérifier si une certaine condition est vraie et exécuter un bloc de code si c'est le cas. L'instruction `else` est utilisée comme alternative si la condition n'est pas vraie.
+```lua
+-- Instruction If-else
+local x = 5
+if x > 10 then
+    print("x est supérieur à 10")
+else
+    print("x est inférieur ou égal à 10")
+end`
+```
+## Condition Elseif
+L'instruction `elseif` est utilisée pour vérifier plusieurs conditions. Si la première condition n'est pas vraie, le script vérifiera la suivante, et ainsi de suite, jusqu'à ce qu'une condition vraie soit trouvée ou que la fin du script soit atteinte.
+```lua
+-- Instruction Elseif
+local x = 5
+si x > 10 alors
+    print("x est supérieur à 10")
+elseif x < 0 then
+    print("x est inférieur à 0")
+else
+    print("x est compris entre 0 et 10")
+end`
+```
+## Boucle For
+La boucle `for` est utilisée pour itérer sur une plage de nombres ou sur les éléments d'un tableau. La variable de la boucle est déclarée et initialisée avant la boucle, et la boucle continue jusqu'à ce que la condition de fin soit remplie.
+```lua
+-- Boucle For
+for i = 1, 10 do
+    print(i)
+end
+```
+## Boucle While
+La boucle `while` est utilisée pour exécuter un bloc de code de manière répétée tant qu'une certaine condition est remplie.
+```lua
+-- Boucle While
+local x = 5
+while x > 0 do
+    print(x)
+    x = x - 1
+end`
+```
+
+## Repeat Until
+L'instruction `repeat` est utilisée pour exécuter un bloc de code de manière répétée jusqu'à ce qu'une certaine condition soit remplie. Le bloc de code est exécuté au moins une fois avant que la condition ne soit vérifiée.
+```lua
+-- Répéter jusqu'à ce que
+local x = 5
+repeat
+    x = x - 1
+    print(x)
+until x == 0
+```
+L'extrait de code ci-dessus exécutera la boucle jusqu'à ce que x soit égal à 0, et la valeur de x sera décrémentée à chaque itération.
+
+Gardez à l'esprit que l'extrait de code ne s'exécutera pas tel quel et qu'il est destiné à servir d'exemple et de référence.

Français/4. Fonctions spécifiques à Fivem.md

@@ -0,0 +1,66 @@
+# Fonctions spécifiques à FiveM
+
+Dans FiveM, une modification pour le jeu populaire Grand Theft Auto V, il y a plusieurs fonctions spécifiques à la plateforme FiveM que vous pouvez utiliser dans vos scripts.
+
+Utilisez la référence des natives pour trouver la liste de toutes les fonctions disponibles : https://docs.fivem.net/natives/
+
+## Enregistrer une commande
+Pour enregistrer une commande qui peut être exécutée dans le chat, vous pouvez utiliser la fonction `RegisterCommand`.
+```lua
+-- Enregistrement d'une commande
+RegisterCommand("hello", function()
+    print("Bonjour !")
+end, false)
+```
+Le premier argument est le nom de la commande, le second est la fonction de rappel (callback) qui sera exécutée lorsque la commande sera appelée, et le troisième est le booléen "restricted" : s'il s'agit d'une commande serveur et que vous mettez cette valeur à true, alors les joueurs auront besoin de la permission ace `command.yourCommandName` pour exécuter cette commande.
+## Déclencher un événement
+Pour déclencher un événement qui peut être géré par d'autres scripts, vous pouvez utiliser la fonction TriggerEvent.
+
+```lua
+-- Déclenchement d'un événement
+TriggerEvent("myEvent", "Hello, World !")
+```
+Le premier argument est le nom de l'événement, et les arguments suivants sont transmis aux gestionnaires d'événements (Event Handlers)
+
+## Enregistrer un événement
+Pour enregistrer un gestionnaire d'événement (even handler), vous pouvez utiliser la fonction AddEventHandler.
+
+```lua
+-- Enregistrement d'un gestionnaire d'événement
+AddEventHandler("myEvent", function(message)
+    print(message)
+end)
+```
+Le premier argument est le nom de l'événement, et le second est la fonction de rappel (callback) qui sera exécutée lorsque l'événement sera déclenché.
+
+## Obtenir la position du joueur
+Vous pouvez utiliser la fonction GetEntityCoords pour obtenir la position actuelle du joueur dans le monde.
+
+```lua
+local coords = GetEntityCoords(PlayerPedId())
+-- coords est un vector3, pour accéder à une valeur spécifique (donc x, y, z) il faut voir le vector3 comme une table
+print(coords.x) -- X
+print(coords.y) -- Y
+print(coords.z) -- Z
+```
+Le premier argument de la fonction est l'entité du joueur
+
+## Création d'un blip
+Vous pouvez utiliser la fonction AddBlipForCoord pour créer un blip sur la carte à une position spécifique.
+
+```lua
+-- Création d'un blip
+local blip = AddBlipForCoord(x, y, z)
+```
+Les arguments passés à la fonction sont les coordonnées x, y et z de l'info-bulle.
+
+## Définir l'icône d'un blip
+Vous pouvez utiliser la fonction SetBlipSprite pour définir l'icône d'un blip.
+
+```lua
+-- Définition de l'icône d'un blip
+SetBlipSprite(blip, 1)
+```
+Le premier argument est le blip et le second est le numéro de l'icône.
+
+Ceci n'est qu'une petite introduction aux fonctions spécifiques de FiveM, il y a beaucoup d'autres fonctions, propriétés et événements que vous pouvez utiliser dans vos scripts. N'hésitez pas à consulter la documentation officielle pour plus d'informations et d'exemples.