Cours Lua 5.4

-- Lancer le REPL en tapant 'lua' dans le terminal
-- puis tapez du code Lua directement :

> 2 + 2
4
> "Bonjour" .. " " .. "Lua"
Bonjour Lua
> print("Hello World!")
Hello World!
> os.date("%Y-%m-%d")
"2026-07-22"

-- hello.lua : Mon premier script Lua
print("Bonjour le monde !")
print("Bienvenue dans Lua 5.4")

-- Commentaire sur une seule ligne avec --

--[[ Commentaire multi-lignes
   Ceci est un commentaire
   sur plusieurs lignes
--]]

-- La fin d'une instruction est marquée par un retour à la ligne
-- ou un point-virgule (optionnel)
print("A") ; print("B")  -- point-virgule pour séparer sur une ligne

-- Variable globale (à éviter)
nom = "Alice"

-- Variable locale (recommandé)
local age = 25
local ville = "Paris"

-- Les variables non déclarées valent nil par défaut
print(inexistant)  --> nil

-- nil : absence de valeur
local x = nil

-- boolean : true ou false
local estVrai = true
local estFaux = false

-- number : entiers et flottants (Lua 5.4 distingue les deux)
local entier = 42       -- type : integer
local flottant = 3.14   -- type : float
local grand = 1e6      -- notation scientifique = float

-- string : chaînes de caractères
local prenom = "Marie"
local message = 'Aussi entre guillemets simples'

print(type(nil))         --> "nil"
print(type(true))        --> "boolean"
print(type(42))          --> "integer"  (Lua 5.4)
print(type(3.14))        --> "float"    (Lua 5.4)
print(type("salut"))     --> "string"
print(type(print))       --> "function"
print(type({}))          --> "table"

-- Assignation multiple
local a, b, c = 1, 2, 3
print(a, b, c)  --> 1  2  3

-- Échange de valeurs sans variable temporaire
a, b = b, a
print(a, b)  --> 2  1

-- Trop de valeurs = ignorées, pas assez = nil
local x, y = 10          -- x=10, y=nil
local p, q, r = 1, 2     -- p=1, q=2, r=nil

-- tostring : convertir en chaîne
local nb = 42
local txt = tostring(nb)
print(txt .. " est un texte")  --> "42 est un texte"
print(tostring(true))          --> "true"
print(tostring(nil))           --> "nil"

-- tonumber : convertir en nombre
print(tonumber("123"))        --> 123
print(tonumber("3.14"))       --> 3.14
print(tonumber("abc"))        --> nil (conversion échoue)
print(tonumber(true))         --> nil

local i = 5       -- integer
local f = 5.0     -- float
print(type(i))    --> "integer"
print(type(f))    --> "float"
print(i == f)     --> true (comparaison de valeur)

-- Division entière avec //
print(7 // 2)    --> 3 (integer)
print(7 / 2)     --> 3.5 (float)

local a, b = 10, 3

print(a + b)    -- Addition       : 13
print(a - b)    -- Soustraction   : 7
print(a * b)    -- Multiplication : 30
print(a / b)    -- Division       : 3.3333333333333
print(a // b)   -- Division entière : 3
print(a % b)    -- Modulo (reste)  : 1
print(a ^ 2)   -- Puissance       : 100
print(-a)       -- Négation       : -10

print(5 == 5)    -- Égal           : true
print(5 ~= 3)    -- Différent      : true (pas de != en Lua)
print(5 < 3)     -- Inférieur      : false
print(5 > 3)     -- Supérieur      : true
print(5 <= 5)   -- Inférieur ou =  : true
print(5 >= 6)   -- Supérieur ou =  : false

-- not : inverse la valeur logique
print(not true)     --> false
print(not nil)      --> true

-- and : retourne le premier opérande faux, ou le dernier si tout est vrai
print(true and "oui")     --> "oui"
print(nil and "non")      --> nil
print(false and "non")    --> false

-- or : retourne le premier opérande vrai, ou le dernier si tout est faux
print(nil or "défaut")     --> "défaut"
print("oui" or "non")     --> "oui"

local prenom = "Jean"
local nom = "Dupont"
local nomComplet = prenom .. " " .. nom
print(nomComplet)  --> "Jean Dupont"

-- Concaténation avec des nombres (conversion automatique)
print("J'ai " .. 5 .. " pommes")  --> "J'ai 5 pommes"

-- Longueur d'une chaîne
print(#"Bonjour")    --> 7
print(#"")          --> 0

-- Longueur d'un tableau
local fruits = {"pomme", "banane", "cerise"}
print(#fruits)       --> 3

local age = 18

if age >= 18 then
    print("Vous êtes majeur.")
end

local note = 14

if note >= 16 then
    print("Très bien")
elseif note >= 14 then
    print("Bien")
elseif note >= 12 then
    print("Assez bien")
elseif note >= 10 then
    print("Passable")
else
    print("Insuffisant")
end
-- Affiche : "Bien"

local connecte = true
local admin = false

if connecte then
    if admin then
        print("Panneau d'administration")
    else
        print("Espace membre")
    end
else
    print("Veuillez vous connecter.")
end

if 0 then print("0 est truthy en Lua !") end
if "" then print("La chaîne vide est truthy !") end
if {} then print("Une table vide est truthy !") end
if nil then print("Jamais affiché") else print("nil est falsy") end

local age = 20
local statut = (age >= 18) and "majeur" or "mineur"
print(statut)  --> "majeur"

-- Fonctionne comme : condition ? valeurSiVrai : valeurSiFaux
local x = 5
local resultat = x > 0 and "positif" or "négatif"
print(resultat)  --> "positif"

-- Boucle de 1 à 5 (pas de 1 par défaut)
for i = 1, 5 do
    print(i)
end
-- Affiche : 1, 2, 3, 4, 5

-- Boucle avec un pas personnalisé
for i = 0, 10, 2 do
    print(i)
end
-- Affiche : 0, 2, 4, 6, 8, 10

-- Boucle descendante
for i = 5, 1, -1 do
    print(i)
end
-- Affiche : 5, 4, 3, 2, 1

-- ipairs : itère sur un tableau ordonné (de l'index 1)
local fruits = {"pomme", "banane", "cerise"}
for index, valeur in ipairs(fruits) do
    print(index, valeur)
end
-- 1 pomme, 2 banane, 3 cerise

-- pairs : itère sur toutes les clés d'une table (hash + array)
local personne = {nom = "Lucie", age = 22, ville = "Lyon"}
for cle, valeur in pairs(personne) do
    print(cle .. " = " .. tostring(valeur))
end

local compteur = 1

while compteur <= 5 do
    print("Tour n°" .. compteur)
    compteur = compteur + 1
end

local n = 1
repeat
    print(n)
    n = n * 2
until n > 100
-- Affiche : 1, 2, 4, 8, 16, 32, 64

-- break : sortir de la boucle
for i = 1, 100 do
    if i == 5 then
        print("On arrête à 5 !")
        break
    end
    print(i)
end

-- goto et labels (Lua 5.2+)
for i = 1, 10 do
    if i == 3 then
        goto fin
    end
    print(i)
end
::fin::
print("Terminé")

-- Déclaration d'une fonction
local function direBonjour(nom)
    print("Bonjour, " .. nom .. " !")
end

direBonjour("Alice")   --> "Bonjour, Alice !"

-- Équivalent avec assignation de variable
local direBonjour2 = function(nom)
    print("Bonjour, " .. nom .. " !")
end

local function diviser(a, b)
    return a // b, a % b  -- quotient et reste
end

local quotient, reste = diviser(17, 5)
print(quotient, reste)  --> 3  2

-- Si on ne récupère qu'une valeur, les autres sont ignorées
local q = diviser(17, 5)
print(q)  --> 3

local function somme(...)
    local args = {...}
    local total = 0
    for _, v in ipairs(args) do
        total = total + v
    end
    return total
end

print(somme(1, 2, 3, 4, 5))  --> 15

local function créerCompteur()
    local n = 0
    return function()
        n = n + 1
        return n
    end
end

local compteur = créerCompteur()
print(compteur())  --> 1
print(compteur())  --> 2
print(compteur())  --> 3

-- Les fonctions peuvent être stockées dans des tableaux
local operations = {
    addition = function(a, b) return a + b end,
    multiplication = function(a, b) return a * b end,
}

print(operations.addition(3, 4))        --> 7
print(operations.multiplication(3, 4)) --> 12

-- Fonction passée en argument (callback)
local function appliquer(fn, x)
    return fn(x)
end

local doubler = function(x) return x * 2 end
print(appliquer(doubler, 5))  --> 10

local fruits = {"pomme", "banane", "cerise"}

print(fruits[1])   --> "pomme" (pas fruits[0] !)
print(fruits[2])   --> "banane"
print(#fruits)     --> 3 (longueur du tableau)

local liste = {10, 20, 30}

-- table.insert : ajouter un élément
table.insert(liste, 40)           -- ajoute à la fin
table.insert(liste, 2, 15)      -- insère à l'index 2
print(table.concat(liste, ", "))  --> "10, 15, 20, 30, 40"

-- table.remove : supprimer un élément
table.remove(liste, 1)           -- supprime l'élément à l'index 1
print(table.concat(liste, ", "))  --> "15, 20, 30, 40"

local personne = {
    nom = "Alice",
    age = 30,
    ville = "Marseille",
    ["clé avec espaces"] = "valeur spéciale",
}

print(personne.nom)   --> "Alice"
print(personne["age"])  --> 30 (syntaxe alternative)
print(personne.ville)  --> "Marseille"

local joueur = {
    "Épée",          -- [1] = "Épée"
    "Bouclier",      -- [2] = "Bouclier"
    nom = "Héros",   -- clé nommée
    pv = 100,        -- clé nommée
}

print(#joueur)        --> 2 (compte seulement les clés numériques)
print(joueur.nom)     --> "Héros"

-- table.sort : trier un tableau
local nombres = {5, 2, 8, 1, 9, 3}
table.sort(nombres)
print(table.concat(nombres, ", "))  --> "1, 2, 3, 5, 8, 9"

-- Tri personnalisé avec une fonction de comparaison
local mots = {"banane", "cerise", "abricot"}
table.sort(mots, function(a, b) return a > b end)
print(table.concat(mots, ", "))  --> "cerise, banane, abricot"

-- table.pack / table.unpack
local t = table.pack(1, 2, 3, 4, 5)
print(t.n)  --> 5
local a, b, c = table.unpack(t, 2, 4)
print(a, b, c)  --> 2  3  4

local t = {10, 20, nom = "test", 30}

-- ipairs s'arrête au trou (manque l'index 4 puis le champ "nom")
for i, v in ipairs(t) do
    print(i, v)
end
-- 1 10, 2 20 (s'arrête car index 3 est "nom" pas un number)

-- pairs parcourt tout
for k, v in pairs(t) do
    print(k, v)
end
-- 1 10, 2 20, nom test, 4 30

-- Différentes façons de créer une chaîne
local s1 = "Bonjour"
local s2 = 'Aussi avec des guillemets simples'
local s3 = [[Chaîne multi-ligne
qui peut contenir
plusieurs lignes
sans échapper les retours à la ligne]]

-- Concaténation avec ..
local nom = "Lua"
local version = 5.4
print(nom .. " " .. tostring(version))  --> "Lua 5.4"

print(#"Hello")     --> 5
print(#"")          --> 0
print(#"café")      --> 4 (octets, pas caractères UTF-8)

local s = "Bonjour le monde"

-- string.sub : extraire une sous-chaîne
print(string.sub(s, 1, 7))    --> "Bonjour"
print(string.sub(s, -6))      --> "monde" (depuis la fin)

-- string.find : chercher un motif
local debut, fin = string.find(s, "monde")
print(debut, fin)  --> 11  16

-- string.gsub : remplacement global
local nouveau = string.gsub(s, "monde", "Lua")
print(nouveau)  --> "Bonjour le Lua"

-- string.upper / string.lower
print(string.upper("hello"))  --> "HELLO"
print(string.lower("HELLO"))  --> "hello"

-- string.rep : répéter une chaîne
print(string.rep("ha", 3))  --> "hahaha"

-- string.reverse : inverser
print(string.reverse("abc"))  --> "cba"

local nom = "Alice"
local age = 25
local pi = 3.14159

print(string.format("Bonjour %s, vous avez %d ans.", nom, age))
--> "Bonjour Alice, vous avez 25 ans."

print(string.format("Pi = %.2f", pi))
--> "Pi = 3.14"

-- Codes de format courants :
-- %s : chaîne, %d : entier, %f : flottant
-- %x : hexadécimal, %o : octal, %% : pourcentage littéral
print(string.format("Hex : %x, Oct : %o", 255, 255))
--> "Hex : ff, Oct : 377"

local sql = [[
SELECT nom, age
FROM utilisateurs
WHERE ville = 'Paris'
ORDER BY nom
]]
print(sql)

-- Pour ignorer l'indentation, utilisez [= n [ ... ]= n ]
local texte = [=[
   Ceci est indenté
   mais le résultat ne le sera pas
]=]

local monTable = {a = 1, b = 2}
local mt = {}  -- la métatable

setmetatable(monTable, mt)
print(getmetatable(monTable))  --> table: 0x... (la table mt)

local personne = {nom = "Alice"}
local mt = {
    __index = function(table, cle)
        return "Clé '" .. cle .. "' non trouvée"
    end
}
setmetatable(personne, mt)

print(personne.nom)      --> "Alice" (clé existante)
print(personne.age)      --> "Clé 'age' non trouvée"
print(personne.ville)    --> "Clé 'ville' non trouvée"

-- __index peut aussi être une table (plus courant)
local defauts = {couleur = "bleu", taille = 10}
local obj = {nom = "Widget"}
setmetatable(obj, {__index = defauts})
print(obj.couleur)  --> "bleu" (trouvé via __index)

local donnees = {}
local mt = {
    __newindex = function(table, cle, valeur)
        print("Interdit de modifier '" .. cle .. "'")
    end
}
setmetatable(donnees, mt)

donnees.nom = "test"  --> "Interdit de modifier 'nom'"

local Vecteur = {}
Vecteur.__index = Vecteur

function Vecteur.new(x, y)
    return setmetatable({x = x, y = y}, Vecteur)
end

function Vecteur:__add(autre)
    return Vecteur.new(self.x + autre.x, self.y + autre.y)
end

function Vecteur:__sub(autre)
    return Vecteur.new(self.x - autre.x, self.y - autre.y)
end

function Vecteur:__mul(scalaire)
    return Vecteur.new(self.x * scalaire, self.y * scalaire)
end

function Vecteur:__tostring()
    return string.format("(%d, %d)", self.x, self.y)
end

function Vecteur:__len()
    return math.sqrt(self.x^2 + self.y^2)
end

local v1 = Vecteur.new(3, 4)
local v2 = Vecteur.new(1, 2)

print(v1 + v2)    --> (4, 6)
print(v1 - v2)    --> (2, 2)
print(v1 * 2)    --> (6, 8)
print(#v1)        --> 5 (norme)

local Timer = {}
Timer.__index = Timer

function Timer.new(secondes)
    return setmetatable({duree = secondes, restant = secondes}, Timer)
end

function Timer:__call()
    if self.restant > 0 then
        self.restant = self.restant - 1
        return true
    else
        return false
    end
end

local t = Timer.new(3)
print(t())  --> true (2 restant)
print(t())  --> true (1 restant)
print(t())  --> true (0 restant)
print(t())  --> false (terminé)

local Animal = {}
Animal.__index = Animal

function Animal.new(nom, espece)
    return setmetatable({nom = nom, espece = espece}, Animal)
end

function Animal:parler()
    print(self.nom .. " fait un bruit.")
end

-- Héritage : Chien hérite d'Animal
local Chien = setmetatable({}, {__index = Animal})
Chien.__index = Chien

function Chien.new(nom)
    local self = Animal.new(nom, "Chien")
    return setmetatable(self, Chien)
end

function Chien:parler()
    print(self.nom .. " fait Wouf !")
end

local rex = Chien.new("Rex")
rex:parler()   --> "Rex fait Wouf !"
print(rex.espece)  --> "Chien" (hérité d'Animal)

-- Créer une coroutine
local co = coroutine.create(function()
    print("Début")
    coroutine.yield()  -- suspendre
    print("Reprise !")
end)

print(coroutine.status(co))  --> "suspended"
coroutine.resume(co)          --> Affiche "Début"
print(coroutine.status(co))  --> "suspended"
coroutine.resume(co)          --> Affiche "Reprise !"
print(coroutine.status(co))  --> "dead"

local co = coroutine.create(function(prenom)
    print("Bonjour, " .. prenom)
    local age = coroutine.yield("Quel âge as-tu ?")  -- renvoie la question
    print("Tu as " .. age .. " ans.")
end)

local ok, msg = coroutine.resume(co, "Alice")
print(msg)  --> "Quel âge as-tu ?"

ok, msg = coroutine.resume(co, 25)
-- Affiche "Tu as 25 ans."

-- Producteur : génère des nombres
local function producteur(max)
    for i = 1, max do
        coroutine.yield(i * 10)
    end
end

-- Consommateur : traite les données
local co = coroutine.create(function()
    producteur(5)
end)

while coroutine.status(co) ~= "dead" do
    local ok, valeur = coroutine.resume(co)
    if ok and valeur then
        print("Reçu :", valeur)
    end
end
-- Affiche : 10, 20, 30, 40, 50

local function compter(n)
    for i = 1, n do
        coroutine.yield(i)
    end
end

local gen = coroutine.wrap(compter)

print(gen(5))  --> 1
print(gen())    --> 2
print(gen())    --> 3
print(gen())    --> 4
print(gen())    --> 5

-- Exemple : dialogue asynchrone pour un jeu
local function dialogueNPC()
    print("NPC : Salut aventurier !")
    coroutine.yield()  -- attend la réponse du joueur
    print("NPC : Tu veux une quête ?")
    coroutine.yield()  -- attend la réponse
    print("NPC : Va tuer 10 slimes !")
end

local npc = coroutine.create(dialogueNPC)
coroutine.resume(npc)  -- NPC parle
io.read()             -- joueur appuie sur Entrée
coroutine.resume(npc)  -- NPC continue
io.read()             -- joueur appuie sur Entrée
coroutine.resume(npc)  -- NPC donne la quête

-- Charger le module "math" (déjà fourni par Lua)
local math = require("math")
print(math.sqrt(16))  --> 4

-- Charger un module personnalisé
local utils = require("utils")

-- fichier : utils.lua
local Utils = {}

function Utils.majuscule(texte)
    return string.upper(texte)
end

function Utils.chevaucher(t1, t2)
    for _, v in ipairs(t1) do
        for _, v2 in ipairs(t2) do
            if v == v2 then return true end
        end
    end
    return false
end

return Utils

-- fichier : main.lua
local Utils = require("utils")

print(Utils.majuscule("bonjour"))  --> "BONJOUR"

local a = {1, 2, 3}
local b = {3, 4, 5}
print(Utils.chevaucher(a, b))  --> true

-- package.loaded contient tous les modules déjà chargés
for nom, mod in pairs(package.loaded) do
    print(nom)
end

-- package.path définit où require() cherche les modules
print(package.path)
-- Contient quelque chose comme :
-- ./?.lua;/usr/local/share/lua/5.4/?.lua;...
-- Le ? est remplacé par le nom du module

-- fichier : config.lua
local CONFIG = {}

-- Variable privée (pas accessible de l'extérieur)
local secret = "ma_clé_123"

-- Variable publique (accessible via le module)
CONFIG.version = "1.0.0"
CONFIG.debug = true

function CONFIG.getSecret()
    return secret
end

return CONFIG

-- fichier : main.lua
local Config = require("config")

print(Config.version)    --> "1.0.0"
print(Config.debug)      --> true
print(Config.secret)     --> nil (variable privée)
print(Config.getSecret()) --> "ma_clé_123" (via fonction publique)

-- Structure de fichiers :
-- projet/
--   main.lua
--   mod/
--     init.lua
--     utils.lua

-- mod/init.lua
local M = {}
M.utils = require("mod.utils")
return M

-- main.lua
local mod = require("mod")
print(mod.utils)  -- accès au sous-module

-- entities.lua : Module des entités de jeu
local Entite = {}
Entite.__index = Entite

function Entite.new(nom, pv, attaque)
    return setmetatable({
        nom = nom,
        pv = pv,
        pvMax = pv,
        attaque = attaque,
    }, Entite)
end

function Entite:estVivant()
    return self.pv > 0
end

function Entite:subirDegats(degats)
    self.pv = self.pv - degats
    if self.pv < 0 then self.pv = 0 end
    print(self.nom .. " subit " .. degats .. " dégâts. PV : " .. self.pv)
end

function Entite:__tostring()
    return string.format("%s [PV: %d/%d, ATK: %d]",
        self.nom, self.pv, self.pvMax, self.attaque)
end

-- Héritage : Joueur hérite d'Entite
local Joueur = setmetatable({}, {__index = Entite})
Joueur.__index = Joueur

function Joueur.new(nom)
    local self = Entite.new(nom, 100, 15)
    self.inventaire = {}
    self.xp = 0
    self.niveau = 1
    return setmetatable(self, Joueur)
end

function Joueur:ajouterObjet(objet)
    table.insert(self.inventaire, objet)
end

function Joueur:gagnerXP(montant)
    self.xp = self.xp + montant
    if self.xp >= self.niveau * 50 then
        self.niveau = self.niveau + 1
        self.pvMax = self.pvMax + 20
        self.pv = self.pvMax
        self.attaque = self.attaque + 3
        print("*** Niveau supérieur ! Niveau " .. self.niveau .. " ***")
    end
end

-- Héritage : Monstre hérite d'Entite
local Monstre = setmetatable({}, {__index = Entite})
Monstre.__index = Monstre

function Monstre.new(nom, pv, attaque, xp)
    local self = Entite.new(nom, pv, attaque)
    self.xp = xp
    return setmetatable(self, Monstre)
end

Entite.Joueur = Joueur
Entite.Monstre = Monstre
return Entite

-- items.lua : Module des objets
local Objets = {
    potion = {
        nom = "Potion de soin",
        type = "consommable",
        effet = function(cible)
            cible.pv = math.min(cible.pv + 30, cible.pvMax)
            print(cible.nom .. " récupère 30 PV !")
        end,
    },
    epee = {
        nom = "Épée de fer",
        type = "arme",
        bonus = 5,
    },
    bouclier = {
        nom = "Bouclier en bois",
        type = "armure",
        bonus = 3,
    },
}

function Objets.obtenir(cle)
    return Objets[cle]
end

return Objets

-- dialogues.lua : Module de dialogues avec coroutines
local Dialogues = {}

function Dialogues.marchand()
    return coroutine.create(function()
        print("--- Le Marchand ---")
        print("Marchand : Bienvenue ! J'ai des objets à vendre.")
        coroutine.yield({action = "menu"})

        print("Marchand : La potion te soigne de 30 PV.")
        coroutine.yield({action = "vendre", objet = "potion", prix = 20})

        print("Marchand : Reviens quand tu veux !")
        coroutine.yield({action = "fin"})
    end)
end

function Dialogues.boss()
    return coroutine.create(function()
        print("--- Le Dragon ---")
        print("Dragon : Tu oses défier le Dragon de Feu ?!")
        coroutine.yield()

        print("Dragon : GOUTTE MON FEU !")
        coroutine.yield()

        print("Dragon : Impréssionnant... Tu es digne de ce combat !")
    end)
end

return Dialogues

-- main.lua : Programme principal du RPG
local math = require("math")
local Entite = require("entities")
local Objets = require("items")
local Dialogues = require("dialogues")

-- Créer le joueur
local joueur = Entite.Joueur.new("Héros")
joueur:ajouterObjet(Objets.obtenir("potion"))

-- Créer les ennemis
local ennemis = {
    Entite.Monstre.new("Gobelin", 30, 8, 15),
    Entite.Monstre.new("Squelette", 50, 12, 25),
    Entite.Monstre.new("Dragon de Feu", 120, 20, 100),
}

-- Fonction de combat
local function combat(j, e)
    print("\n=== COMBAT : " .. j.nom .. " vs " .. e.nom .. " ===")
    print(e)

    while j:estVivant() and e:estVivant() do
        -- Tour du joueur
        local degats = math.random(1, j.attaque)
        e:subirDegats(degats)

        if not e:estVivant() then
            print(e.nom .. " est vaincu !")
            j:gagnerXP(e.xp)
            return true
        end

        -- Tour de l'ennemi
        degats = math.random(1, e.attaque)
        j:subirDegats(degats)

        if not j:estVivant() then
            print(j.nom .. " a été vaincu...")
            return false
        end

        print("  " .. j .. " | " .. e)
    end
end

-- Boucle principale du jeu
print("========================================")
print("   RPG LUA 5.4 - LE DÉFI DU DRAGON")
print("========================================")
print()

-- Dialoguer avec le marchand (coroutine)
local dialog = Dialogues.marchand()
coroutine.resume(dialog)
coroutine.resume(dialog)
coroutine.resume(dialog)

-- Combattre les monstres
for i, ennemi in ipairs(ennemis) do
    print("\n--- Étape " .. i .. " ---")

    -- Dialogue du boss avant le dernier combat
    if i == 3 then
        local bossDialog = Dialogues.boss()
        coroutine.resume(bossDialog)
        coroutine.resume(bossDialog)
        coroutine.resume(bossDialog)
    end

    local victoire = combat(joueur, ennemi)
    if not victoire then
        print("\nGame Over... Vous avez péri.")
        return
    end
end

print("\n========================================")
print("  FÉLICITATIONS ! Vous avez vaincu le Dragon !")
print("  Niveau final : " .. joueur.niveau)
print("========================================")