PlaneTakingOff.cpp

#include <GLFW/glfw3.h>
#include <cmath>
#include <cstdlib>
#include <random>
#include <vector>

// ETAT GLOBAL
static float avionX = -1.25f;
static float avionY = -0.46f;
static float avionVX = 0.0f;
static float avionVY = 0.0f;
static float avionAngle = 0.0f;
static int   phase = 0;
static float phaseTimer = 0.0f;
static float gearFold = 0.0f;

// Commandes manuelles
static bool commandeAvancer = false;
static bool commandeDecoller = false;

// Camera offset pour suivre l'avion
static float camX = -0.90f;
static float camY = 0.0f;

// Parametres avion
const float RUNWAY_Y = -0.46f;
const float TAXI_SPEED = 0.45f;   // Vitesse quand tu appuies sur A
const float ACCEL_RATE = 0.75f;   // Acceleration plus rapide au decollage
const float MAX_SPEED = 1.25f;    // Vitesse max plus grande
const float CLIMB_VY = 0.42f;     // Montee un peu plus rapide
const float CLIMB_ANGLE = 15.0f;
const float LEVEL_OFF_Y = 0.58f;   // A partir de cette hauteur, l'avion commence a redevenir droit
const float CLOUD_SPEED = 0.045f;

// Tant que camY est plus petit que cette valeur,
// les montagnes peuvent encore apparaitre dans l'ecran.
// Donc l'avion doit rester penche et continuer de monter.
const float MOUNTAINS_GONE_CAMERA_Y = 1.38f;

// Monde tres large pour eviter le bug noir
static const float WORLD_LEFT = -30.0f;
static const float WORLD_RIGHT = 30.0f;

static const float PI = 3.14159265f;

// Nuages
struct Nuage { float x, y; };
static Nuage nuages[8];
static float nuageOffset = 0.0f;

// Herbe
struct BrinHerbe {
    float x;
    float yBase;
    float hauteur;
    float largeur;
    float orientation;
    float rigidite;
};

static std::vector<BrinHerbe> brinsHerbe;

float ventMagnitude = 0.030f;
float ventLongueurOnde = 7.0f;
float ventPeriode = 1.4f;
float souffleMagnitude = 0.22f;
float souffleLargeur = 0.18f;
float souffleY = -0.66f;
float souffleVitesse = 0.35f;


void cercle(float cx, float cy, float r) {
    glBegin(GL_TRIANGLE_FAN);
    glVertex2f(cx, cy);

    for (int i = 0; i <= 36; i++) {
        float a = i * 2.0f * PI / 36;
        glVertex2f(cx + cosf(a) * r, cy + sinf(a) * r);
    }

    glEnd();
}

void dessinerPomme(float x, float y, float r) {
    // Pomme rouge
    glColor3f(0.75f, 0.02f, 0.02f);
    cercle(x, y, r);

    // Petit reflet rouge clair
    glColor3f(1.0f, 0.18f, 0.14f);
    cercle(x - r * 0.30f, y + r * 0.25f, r * 0.35f);

    // Tige marron
    glColor3f(0.28f, 0.13f, 0.04f);
    glLineWidth(2.0f);
    glBegin(GL_LINES);
    glVertex2f(x, y + r * 0.75f);
    glVertex2f(x + r * 0.15f, y + r * 1.45f);
    glEnd();
    glLineWidth(1.0f);
}

void segmentEnd(float ox, float oy, float angleDeg, float len, float& ex, float& ey) {
    float rad = angleDeg * PI / 180.0f;
    ex = ox + sinf(rad) * len;
    ey = oy - cosf(rad) * len;
}

// ARBRES
void dessinerArbreRealiste(float cx, float baseY, float scale, bool isDark) {
    glPushMatrix();
    glTranslatef(cx, baseY, 0.0f);
    glScalef(scale, scale, 1.0f);

    glColor3f(0.35f, 0.20f, 0.12f);
    glBegin(GL_POLYGON);
    glVertex2f(-0.015f, 0.0f);
    glVertex2f(0.015f, 0.0f);
    glVertex2f(0.012f, 0.25f);
    glVertex2f(-0.012f, 0.25f);
    glEnd();

    glEnd();

    if (isDark) {
        glColor3f(0.06f, 0.28f, 0.10f);
        glPushMatrix(); glTranslatef(0, 0.18f, 0); glScalef(1.15f, 1, 1); cercle(0, 0, 0.120f); glPopMatrix();

        glColor3f(0.08f, 0.32f, 0.12f);
        glPushMatrix(); glTranslatef(0, 0.28f, 0); glScalef(1.1f, 0.95f, 1); cercle(0, 0, 0.115f); glPopMatrix();

        glColor3f(0.10f, 0.35f, 0.14f);
        glPushMatrix(); glTranslatef(0, 0.36f, 0); glScalef(1, 0.85f, 1); cercle(0, 0, 0.100f); glPopMatrix();

        glColor3f(0.12f, 0.38f, 0.16f);
        glPushMatrix(); glTranslatef(-0.025f, 0.42f, 0); glScalef(0.8f, 0.9f, 1); cercle(0, 0, 0.045f); glPopMatrix();

        glColor3f(0.13f, 0.40f, 0.17f);
        glPushMatrix(); glTranslatef(0.03f, 0.40f, 0); glScalef(0.75f, 0.85f, 1); cercle(0, 0, 0.042f); glPopMatrix();
    }
    else {
        glColor3f(0.12f, 0.45f, 0.18f);
        glPushMatrix(); glTranslatef(0, 0.18f, 0); glScalef(1.15f, 1, 1); cercle(0, 0, 0.120f); glPopMatrix();

        glColor3f(0.15f, 0.50f, 0.22f);
        glPushMatrix(); glTranslatef(0, 0.28f, 0); glScalef(1.1f, 0.95f, 1); cercle(0, 0, 0.115f); glPopMatrix();

        glColor3f(0.18f, 0.54f, 0.26f);
        glPushMatrix(); glTranslatef(0, 0.36f, 0); glScalef(1, 0.85f, 1); cercle(0, 0, 0.100f); glPopMatrix();

        glColor3f(0.20f, 0.58f, 0.30f);
        glPushMatrix(); glTranslatef(-0.025f, 0.42f, 0); glScalef(0.8f, 0.9f, 1); cercle(0, 0, 0.045f); glPopMatrix();

        glColor3f(0.22f, 0.60f, 0.32f);
        glPushMatrix(); glTranslatef(0.03f, 0.40f, 0); glScalef(0.75f, 0.85f, 1); cercle(0, 0, 0.042f); glPopMatrix();

        glColor3f(0.25f, 0.65f, 0.38f);
        glBegin(GL_TRIANGLES);
        glVertex2f(-0.085f, 0.28f);
        glVertex2f(-0.070f, 0.35f);
        glVertex2f(-0.065f, 0.25f);
        glEnd();

        glColor3f(0.23f, 0.62f, 0.35f);
        glBegin(GL_TRIANGLES);
        glVertex2f(0.085f, 0.26f);
        glVertex2f(0.070f, 0.33f);
        glVertex2f(0.065f, 0.22f);
        glEnd();
    }
    // POMMES ROUGES SUR L'ARBRE
    dessinerPomme(-0.055f, 0.300f, 0.014f);
    dessinerPomme(0.045f, 0.310f, 0.014f);
    dessinerPomme(-0.020f, 0.395f, 0.013f);
    dessinerPomme(0.070f, 0.220f, 0.012f);
    dessinerPomme(-0.075f, 0.220f, 0.012f);
    dessinerPomme(0.000f, 0.285f, 0.014f);
    dessinerPomme(0.000f, 0.18f, 0.013f);
    glPopMatrix();
}

// CIEL
void dessinerCiel() {
    glBegin(GL_QUADS);
// Degrade du ciel, du bleu profond en haut a un bleu plus clair vers l'horizon
    glColor3f(0.05f, 0.23f, 0.43f);
    glVertex2f(-1.0f, 1.0f);
    glColor3f(0.05f, 0.23f, 0.43f);
    glVertex2f(1.0f, 1.0f);
    glColor3f(0.10f, 0.43f, 0.66f);
    glVertex2f(1.0f, 0.35f);
    glColor3f(0.10f, 0.43f, 0.66f);
    glVertex2f(-1.0f, 0.35f);
// Degrade de l'horizon vers le sol, du bleu clair vers un bleu tres pale
    glColor3f(0.10f, 0.43f, 0.66f);
    glVertex2f(-1.0f, 0.35f);
    glColor3f(0.10f, 0.43f, 0.66f);
    glVertex2f(1.0f, 0.35f);
    glColor3f(0.36f, 0.72f, 0.83f);
    glVertex2f(1.0f, -0.25f);
    glColor3f(0.36f, 0.72f, 0.83f);
    glVertex2f(-1.0f, -0.25f);
// Degrade du sol, du bleu pale vers un bleu encore plus pale
    glColor3f(0.36f, 0.72f, 0.83f);
    glVertex2f(-1.0f, -0.25f);
    glColor3f(0.36f, 0.72f, 0.83f);
    glVertex2f(1.0f, -0.25f);
    glColor3f(0.72f, 0.91f, 0.94f);
    glVertex2f(1.0f, -1.0f);
    glColor3f(0.72f, 0.91f, 0.94f);
    glVertex2f(-1.0f, -1.0f);
    glEnd();
}

// NUAGE
void dessinerNuageShape(float x, float y) {
// Un nuage est compose de plusieurs cercles qui se chevauchent pour donner une forme de nuage moelleux
    glColor3f(0.85f, 0.87f, 0.90f);
    cercle(x - 0.090f, y - 0.015f, 0.035f);
    cercle(x - 0.045f, y - 0.020f, 0.045f);
    cercle(x + 0.010f, y - 0.022f, 0.055f);
    cercle(x + 0.065f, y - 0.018f, 0.045f);
    cercle(x + 0.105f, y - 0.012f, 0.032f);
// Des cercles plus clairs par dessus pour donner du volume
    glColor3f(0.96f, 0.96f, 0.98f);
    cercle(x - 0.080f, y, 0.038f);
    cercle(x - 0.030f, y - 0.003f, 0.045f);
    cercle(x + 0.030f, y - 0.002f, 0.048f);
    cercle(x + 0.085f, y, 0.035f);
// Des cercles encore plus clairs pour les reflets de lumiere
    glColor3f(1.0f, 1.0f, 1.0f);
    cercle(x - 0.060f, y + 0.020f, 0.045f);
    cercle(x - 0.010f, y + 0.032f, 0.058f);
    cercle(x + 0.050f, y + 0.022f, 0.048f);
    cercle(x - 0.030f, y + 0.030f, 0.020f);
}
// Dessine les nuages en continu qui deplacent lentement vers la gauche pour donner une impression de mouvement dans le ciel
void dessinerNuagesEnContinu() {
    const float LOOP_W = 3.2f;
    for (int i = 0; i < 8; i++) {
        float nx = nuages[i].x - fmodf(nuageOffset, LOOP_W);

        while (nx < -1.6f)
            nx += LOOP_W;

        while (nx > 1.6f)
            nx -= LOOP_W;

        dessinerNuageShape(nx, nuages[i].y);
    }
}
// TRAIN D'ATTERRISSAGE
void dessinerTrain(float t) {
    float alpha = 1.0f - t;
    if (alpha < 0.01f) return;

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Le train d'atterrissage est compose de deux jambes, chacune avec une cuisse et un genou qui se replient pour rentrer dans l'avion
    { 
        float px = -0.090f, py = -0.040f;
        float len1 = 0.062f;
        float len2 = 0.048f;

        float angleCuisse = -90.0f * t;
        float angleGenou = 160.0f * t;

        float genouX, genouY;
        segmentEnd(px, py, angleCuisse, len1, genouX, genouY);

        float piedX, piedY;
        segmentEnd(genouX, genouY, angleCuisse + angleGenou, len2, piedX, piedY);

        glColor4f(0.65f, 0.65f, 0.67f, alpha);
        glLineWidth(4.5f);
        glBegin(GL_LINES);
        glVertex2f(px, py);
        glVertex2f(genouX, genouY);
        glEnd();

        glColor4f(0.58f, 0.58f, 0.60f, alpha);
        glLineWidth(3.5f);
        glBegin(GL_LINES);
        glVertex2f(genouX, genouY);
        glVertex2f(piedX, piedY);
        glEnd();

        glLineWidth(1.0f);

        glColor4f(0.08f, 0.08f, 0.08f, alpha);
        glPushMatrix();
        glTranslatef(piedX, piedY, 0);
        cercle(0, 0, 0.017f);
        glPopMatrix();

        glColor4f(0.55f, 0.55f, 0.58f, alpha);
        glPushMatrix();
        glTranslatef(piedX, piedY, 0);
        cercle(0, 0, 0.008f);
        glPopMatrix();

        glColor4f(0.70f, 0.70f, 0.72f, alpha);
        glPushMatrix();
        glTranslatef(genouX, genouY, 0);
        cercle(0, 0, 0.008f);
        glPopMatrix();
    }
// Meme chose pour l'autre jambe du train d'atterrissage
    {
        float px = 0.235f, py = -0.038f;
        float len1 = 0.052f;
        float len2 = 0.040f;

        float angleCuisse = 95.0f * t;
        float angleGenou = -150.0f * t;

        float genouX, genouY;
        segmentEnd(px, py, angleCuisse, len1, genouX, genouY);

        float piedX, piedY;
        segmentEnd(genouX, genouY, angleCuisse + angleGenou, len2, piedX, piedY);

        glColor4f(0.65f, 0.65f, 0.67f, alpha);
        glLineWidth(4.0f);
        glBegin(GL_LINES);
        glVertex2f(px, py);
        glVertex2f(genouX, genouY);
        glEnd();

        glColor4f(0.58f, 0.58f, 0.60f, alpha);
        glLineWidth(3.0f);
        glBegin(GL_LINES);
        glVertex2f(genouX, genouY);
        glVertex2f(piedX, piedY);
        glEnd();

        glLineWidth(1.0f);

        glColor4f(0.08f, 0.08f, 0.08f, alpha);
        glPushMatrix();
        glTranslatef(piedX, piedY, 0);
        cercle(0, 0, 0.015f);
        glPopMatrix();

        glColor4f(0.55f, 0.55f, 0.58f, alpha);
        glPushMatrix();
        glTranslatef(piedX, piedY, 0);
        cercle(0, 0, 0.007f);
        glPopMatrix();

        glColor4f(0.70f, 0.70f, 0.72f, alpha);
        glPushMatrix();
        glTranslatef(genouX, genouY, 0);
        cercle(0, 0, 0.007f);
        glPopMatrix();
    }
    glDisable(GL_BLEND);
    glLineWidth(1.0f);
}

void dessinerAvion(float px, float py, float angleDeg, float gearFoldT) {
    glPushMatrix();
    glTranslatef(px, py, 0.0f);
    glRotatef(angleDeg, 0.0f, 0.0f, 1.0f);
    glScalef(1.55f, 1.55f, 1.0f);

// OMBRE SOUS L'AVION
    if (gearFoldT < 0.85f) {
        float a = (1.0f - gearFoldT / 0.85f) * 0.25f;

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glColor4f(0.12f, 0.12f, 0.12f, a);
        glPushMatrix();
        glTranslatef(0, -0.135f, 0);
        glScalef(2.4f, 0.42f, 1);
        cercle(0, 0, 0.11f);
        glPopMatrix();

        glDisable(GL_BLEND);
    }

    dessinerTrain(gearFoldT);

// AILE ARRIERE / AUTRE COTE DE L'AVION
    glColor3f(0.82f, 0.83f, 0.86f);
    glBegin(GL_POLYGON);
    glVertex2f(0.120f, -0.035f);
    glVertex2f(0.000f, -0.037f);
    glVertex2f(-0.170f, 0.050f);
    glVertex2f(-0.150f, 0.067f);
    glVertex2f(0.105f, -0.003f);
    glEnd();

    glColor3f(0.66f, 0.67f, 0.71f);
    glBegin(GL_POLYGON);
    glVertex2f(0.090f, -0.023f);
    glVertex2f(0.020f, -0.025f);
    glVertex2f(-0.120f, 0.040f);
    glVertex2f(-0.100f, 0.047f);
    glVertex2f(0.085f, -0.010f);
    glEnd();

    glColor3f(0.96f, 0.96f, 0.98f);
    glBegin(GL_POLYGON);
    glVertex2f(0.110f, -0.031f);
    glVertex2f(0.010f, -0.033f);
    glVertex2f(-0.135f, 0.040f);
    glVertex2f(-0.110f, 0.037f);
    glVertex2f(0.080f, -0.019f);
    glEnd();

    glColor3f(0.54f, 0.55f, 0.59f);
    glLineWidth(1.0f);
    glBegin(GL_LINES);
    glVertex2f(0.065f, -0.019f);
    glVertex2f(-0.105f, 0.041f);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2f(-0.020f, 0.000f);
    glVertex2f(-0.060f, 0.013f);
    glVertex2f(-0.095f, 0.030f);
    glVertex2f(-0.053f, 0.021f);
    glEnd();

    glColor3f(0.50f, 0.51f, 0.55f);
    glLineWidth(1.0f);
    glBegin(GL_LINE_STRIP);
    glVertex2f(0.120f, -0.035f);
    glVertex2f(0.000f, -0.037f);
    glVertex2f(-0.170f, 0.050f);
    glVertex2f(-0.150f, 0.067f);
    glVertex2f(0.105f, -0.003f);
    glEnd();

// CORPS PRINCIPAL DE L'AVION
    glColor3f(0.91f, 0.91f, 0.93f);
    glBegin(GL_POLYGON);

    glVertex2f(-0.365f, 0.000f);
    glVertex2f(-0.330f, 0.016f);
    glVertex2f(-0.275f, 0.030f);
    glVertex2f(-0.185f, 0.038f);
    glVertex2f(-0.070f, 0.043f);
    glVertex2f(0.060f, 0.043f);
    glVertex2f(0.170f, 0.039f);
    glVertex2f(0.260f, 0.032f);
    glVertex2f(0.315f, 0.023f);

    glVertex2f(0.340f, 0.012f);
    glVertex2f(0.365f, 0.002f);
    glVertex2f(0.385f, -0.012f);
    glVertex2f(0.397f, -0.027f);
    glVertex2f(0.400f, -0.039f);
    glVertex2f(0.393f, -0.050f);
    glVertex2f(0.375f, -0.058f);
    glVertex2f(0.345f, -0.061f);
    glVertex2f(0.305f, -0.058f);

    glVertex2f(0.215f, -0.052f);
    glVertex2f(0.095f, -0.047f);
    glVertex2f(-0.045f, -0.043f);
    glVertex2f(-0.180f, -0.039f);
    glVertex2f(-0.295f, -0.030f);
    glVertex2f(-0.360f, -0.014f);

    glEnd();

// PARTIE CLAIRE EN HAUT DU FUSELAGE
    glColor3f(0.98f, 0.98f, 0.99f);
    glBegin(GL_POLYGON);
    glVertex2f(-0.260f, 0.018f);
    glVertex2f(-0.100f, 0.031f);
    glVertex2f(0.120f, 0.033f);
    glVertex2f(0.270f, 0.025f);
    glVertex2f(0.315f, 0.015f);
    glVertex2f(0.210f, 0.012f);
    glVertex2f(0.030f, 0.015f);
    glVertex2f(-0.160f, 0.014f);
    glEnd();

// OMBRE SOUS LE FUSELAGE
    glColor3f(0.76f, 0.76f, 0.78f);
    glBegin(GL_POLYGON);
    glVertex2f(-0.280f, -0.026f);
    glVertex2f(-0.080f, -0.038f);
    glVertex2f(0.130f, -0.044f);
    glVertex2f(0.270f, -0.052f);
    glVertex2f(0.382f, -0.058f);
    glVertex2f(0.345f, -0.061f);
    glVertex2f(0.100f, -0.049f);
    glVertex2f(-0.120f, -0.043f);
    glVertex2f(-0.300f, -0.031f);
    glEnd();

// NEZ CLAIR
    glColor3f(0.97f, 0.97f, 0.98f);
    glBegin(GL_POLYGON);
    glVertex2f(0.305f, 0.018f);
    glVertex2f(0.340f, 0.010f);
    glVertex2f(0.365f, -0.002f);
    glVertex2f(0.386f, -0.017f);
    glVertex2f(0.395f, -0.030f);
    glVertex2f(0.388f, -0.038f);
    glVertex2f(0.360f, -0.025f);
    glVertex2f(0.325f, 0.000f);
    glEnd();

    glColor3f(1.0f, 1.0f, 1.0f);
    glPushMatrix();
    glTranslatef(0.377f, -0.023f, 0.0f);
    glScalef(1.00f, 0.50f, 1.0f);
    cercle(0, 0, 0.006f);
    glPopMatrix();

    glColor3f(1.0f, 0.74f, 0.78f);
    glPushMatrix();
    glTranslatef(0.360f, -0.044f, 0.0f);
    glScalef(0.90f, 0.45f, 1.0f);
    cercle(0, 0, 0.005f);
    glPopMatrix();

    glColor3f(0.70f, 0.71f, 0.74f);
    glBegin(GL_POLYGON);
    glVertex2f(0.310f, -0.049f);
    glVertex2f(0.350f, -0.056f);
    glVertex2f(0.382f, -0.058f);
    glVertex2f(0.345f, -0.061f);
    glVertex2f(0.305f, -0.058f);
    glEnd();

// COCKPIT
    glColor3f(0.07f, 0.25f, 0.42f);
    glBegin(GL_POLYGON);
    glVertex2f(0.190f, 0.020f);
    glVertex2f(0.255f, 0.026f);
    glVertex2f(0.315f, 0.020f);
    glVertex2f(0.355f, -0.001f);
    glVertex2f(0.338f, -0.023f);
    glVertex2f(0.278f, -0.024f);
    glVertex2f(0.228f, 0.006f);
    glEnd();

    glColor3f(0.45f, 0.75f, 0.96f);
    glBegin(GL_POLYGON);
    glVertex2f(0.220f, 0.017f);
    glVertex2f(0.275f, 0.020f);
    glVertex2f(0.312f, 0.011f);
    glVertex2f(0.285f, 0.000f);
    glVertex2f(0.238f, 0.005f);
    glEnd();

    glColor3f(0.72f, 0.90f, 1.0f);
    glBegin(GL_TRIANGLES);
    glVertex2f(0.303f, 0.013f);
    glVertex2f(0.345f, -0.002f);
    glVertex2f(0.318f, -0.010f);
    glEnd();

    glColor3f(0.03f, 0.12f, 0.20f);
    glLineWidth(1.4f);
    glBegin(GL_LINES);
    glVertex2f(0.255f, 0.025f);
    glVertex2f(0.278f, -0.024f);
    glVertex2f(0.315f, 0.020f);
    glVertex2f(0.313f, -0.024f);
    glEnd();

// CONTOUR DU NEZ
    glColor3f(0.62f, 0.63f, 0.66f);
    glLineWidth(1.1f);
    glBegin(GL_LINE_STRIP);
    glVertex2f(0.340f, 0.012f);
    glVertex2f(0.365f, 0.002f);
    glVertex2f(0.385f, -0.012f);
    glVertex2f(0.397f, -0.027f);
    glVertex2f(0.400f, -0.039f);
    glVertex2f(0.393f, -0.050f);
    glVertex2f(0.375f, -0.058f);
    glEnd();

// AILE AVANT / COTE VISIBLE DE L'AVION
    // Avancée un peu et abaissée
    glColor3f(0.84f, 0.85f, 0.87f);
    glBegin(GL_POLYGON);
    glVertex2f(0.135f, -0.024f);
    glVertex2f(0.000f, -0.026f);
    glVertex2f(-0.145f, -0.085f);
    glVertex2f(-0.120f, -0.100f);
    glVertex2f(0.120f, -0.060f);
    glEnd();

    glColor3f(0.68f, 0.69f, 0.72f);
    glBegin(GL_POLYGON);
    glVertex2f(0.100f, -0.040f);
    glVertex2f(0.025f, -0.040f);
    glVertex2f(-0.100f, -0.078f);
    glVertex2f(-0.080f, -0.086f);
    glVertex2f(0.095f, -0.056f);
    glEnd();

    glColor3f(0.96f, 0.96f, 0.97f);
    glBegin(GL_POLYGON);
    glVertex2f(0.125f, -0.026f);
    glVertex2f(0.010f, -0.028f);
    glVertex2f(-0.115f, -0.076f);
    glVertex2f(-0.090f, -0.074f);
    glVertex2f(0.085f, -0.040f);
    glEnd();

    glColor3f(0.55f, 0.56f, 0.60f);
    glLineWidth(1.0f);
    glBegin(GL_LINES);
    glVertex2f(0.065f, -0.046f);
    glVertex2f(-0.090f, -0.080f);
    glEnd();

    glBegin(GL_LINE_LOOP);
    glVertex2f(-0.015f, -0.055f);
    glVertex2f(-0.050f, -0.064f);
    glVertex2f(-0.080f, -0.076f);
    glVertex2f(-0.045f, -0.070f);
    glEnd();

    glColor3f(0.50f, 0.51f, 0.55f);
    glLineWidth(1.0f);
    glBegin(GL_LINE_STRIP);
    glVertex2f(0.135f, -0.024f);
    glVertex2f(0.000f, -0.026f);
    glVertex2f(-0.145f, -0.085f);
    glVertex2f(-0.120f, -0.100f);
    glVertex2f(0.120f, -0.060f);
    glEnd();

// FENETRES PASSAGERS
    for (int i = 0; i < 11; i++) {
        float wx = -0.120f + i * 0.026f;

        glColor3f(0.08f, 0.28f, 0.45f);
        glPushMatrix();
        glTranslatef(wx, 0.006f, 0);
        glScalef(1.35f, 0.78f, 1);
        cercle(0, 0, 0.0054f);
        glPopMatrix();

        glColor3f(0.70f, 0.88f, 0.98f);
        glPushMatrix();
        glTranslatef(wx - 0.0015f, 0.008f, 0);
        glScalef(0.65f, 0.34f, 1);
        cercle(0, 0, 0.0030f);
        glPopMatrix();
    }

// PORTE AVANT
    glColor3f(0.66f, 0.67f, 0.70f);
    glLineWidth(1.2f);
    glBegin(GL_LINE_LOOP);
    glVertex2f(0.160f, 0.020f);
    glVertex2f(0.185f, 0.018f);
    glVertex2f(0.188f, -0.028f);
    glVertex2f(0.160f, -0.031f);
    glEnd();

// QUEUE VERTICALE
    glColor3f(0.93f, 0.93f, 0.95f);
    glBegin(GL_POLYGON);
    glVertex2f(-0.330f, 0.006f);
    glVertex2f(-0.250f, 0.020f);
    glVertex2f(-0.225f, 0.120f);
    glVertex2f(-0.285f, 0.102f);
    glVertex2f(-0.335f, 0.052f);
    glEnd();

    glColor3f(0.74f, 0.75f, 0.78f);
    glBegin(GL_TRIANGLES);
    glVertex2f(-0.300f, 0.020f);
    glVertex2f(-0.245f, 0.098f);
    glVertex2f(-0.270f, 0.020f);
    glEnd();

    glColor3f(0.99f, 0.99f, 1.0f);
    glBegin(GL_POLYGON);
    glVertex2f(-0.315f, 0.040f);
    glVertex2f(-0.285f, 0.096f);
    glVertex2f(-0.245f, 0.105f);
    glVertex2f(-0.270f, 0.090f);
    glVertex2f(-0.305f, 0.042f);
    glEnd();

    glPopMatrix();
}
// HERBE
float bruit01(float n) {
    return 0.5f + 0.5f * sinf(n * 12.9898f + 78.233f);
}

void initialiserHerbe() {
    if (!brinsHerbe.empty()) return;

    const int N = 440000;

    std::mt19937 gen(1337);
    std::uniform_real_distribution<float> distX(WORLD_LEFT, WORLD_RIGHT);
    std::uniform_real_distribution<float> distOri(0.0f, PI);
    std::uniform_real_distribution<float> distJitter(-0.003f, 0.003f);
    std::uniform_real_distribution<float> distRigidite(0.55f, 0.98f);
    std::uniform_real_distribution<float> distSelect(0.0f, 1.0f);

    brinsHerbe.reserve(N);

    for (int i = 0; i < N; ++i) {
        const float x = distX(gen);
        const bool avant = distSelect(gen) > 0.65f;

        const float yMin = avant ? -1.0f : -0.50f;
        const float yMax = avant ? -0.80f : -0.26f;

        const float y = yMin + (yMax - yMin) * distSelect(gen) + distJitter(gen);
        const float base = 0.006f + 0.016f * bruit01(x * 31.0f + y * 57.0f + i * 0.13f);
        const float h = avant ? (base * 1.4f + 0.005f) : base;

        BrinHerbe b;
        b.x = x + distJitter(gen);
        b.yBase = y;
        b.hauteur = h;
        b.largeur = 0.002f + 0.002f * bruit01(i * 0.87f);
        b.orientation = distOri(gen);
        b.rigidite = distRigidite(gen);

        brinsHerbe.push_back(b);
    }
}

void dessinerHerbeRealiste() {
    glBegin(GL_QUADS);

    glColor3f(0.30f, 0.66f, 0.43f);
    glVertex2f(WORLD_LEFT, -0.40f);
    glVertex2f(WORLD_RIGHT, -0.40f);
    glColor3f(0.18f, 0.48f, 0.30f);
    glVertex2f(WORLD_RIGHT, -0.50f);
    glVertex2f(WORLD_LEFT, -0.50f);

    glColor3f(0.24f, 0.58f, 0.35f);
    glVertex2f(WORLD_LEFT, -0.80f);
    glVertex2f(WORLD_RIGHT, -0.80f);
    glColor3f(0.10f, 0.34f, 0.18f);
    glVertex2f(WORLD_RIGHT, -1.00f);
    glVertex2f(WORLD_LEFT, -1.00f);

    glColor3f(0.24f, 0.58f, 0.35f);
    glVertex2f(WORLD_LEFT, -0.25f);
    glVertex2f(WORLD_RIGHT, -0.25f);
    glColor3f(0.10f, 0.34f, 0.18f);
    glVertex2f(WORLD_RIGHT, -0.40f);
    glVertex2f(WORLD_LEFT, -0.40f);

    glEnd();

    initialiserHerbe();

    const float t = (float)glfwGetTime();
    const float cycle = fmodf(t * souffleVitesse, 2.8f);
    const float sourceX = -1.4f + cycle;

    glLineWidth(1.0f);
    glBegin(GL_LINES);

    for (auto& b : brinsHerbe) {
        const float onde = t * ventPeriode + b.x * ventLongueurOnde + b.yBase * 4.0f;
        const float vent = sinf(onde) * ventMagnitude * (1.15f - b.rigidite);
        const float turb = sinf(onde * 0.7f + b.orientation) * 0.006f;

        const float dx = b.x - sourceX;
        const float dy = b.yBase - souffleY;
        const float atten = expf(-(dx * dx + dy * dy) / (souffleLargeur * souffleLargeur));
        const float pulse = 0.7f + 0.3f * sinf(onde * 1.8f + 2.0f);
        const float souffle = souffleMagnitude * atten * pulse * (1.12f - b.rigidite);

        const float tipX = b.x + cosf(b.orientation) * b.largeur + vent + turb + souffle;
        const float tipY = b.yBase + b.hauteur;

        if (b.yBase > -0.52f)
            glColor3f(0.35f, 0.70f, 0.42f);
        else
            glColor3f(0.32f, 0.64f, 0.37f);

        glVertex2f(b.x, b.yBase);

        glColor3f(0.49f, 0.79f, 0.46f);
        glVertex2f(tipX, tipY);
    }

    glEnd();
}

// PISTES
void dessinerPiste1() {
    glBegin(GL_QUADS);
    glColor3f(0.28f, 0.28f, 0.28f);
    glVertex2f(WORLD_LEFT, -0.50f);
    glVertex2f(WORLD_RIGHT, -0.50f);
    glVertex2f(WORLD_RIGHT, -0.80f);
    glVertex2f(WORLD_LEFT, -0.80f);
    glEnd();
}

void dessinerPiste2() {
    glBegin(GL_QUADS);
    glColor3f(0.28f, 0.28f, 0.28f);
    glVertex2f(WORLD_LEFT, -0.30f);
    glVertex2f(WORLD_RIGHT, -0.30f);
    glVertex2f(WORLD_RIGHT, -0.40f);
    glVertex2f(WORLD_LEFT, -0.40f);
    glEnd();
}

// MONTAGNES REALISTES AVEC NEIGE - VERSION PLUS PETITE
void dessinerMontagnes() {
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glShadeModel(GL_SMOOTH);

    for (float offset = WORLD_LEFT - 4.0f; offset < WORLD_RIGHT + 4.0f; offset += 3.2f) {
        glPushMatrix();
        glTranslatef(offset, 0.0f, 0.0f);
        glTranslatef(0.0f, -0.55f, 0.0f);
        glScalef(1.0f, 0.78f, 1.0f);
        glTranslatef(0.0f, 0.55f, 0.0f);

// MONTAGNES LOINTAINES - BLEU/GRIS AVEC BRUME
        glBegin(GL_TRIANGLES);

        glColor4f(0.50f, 0.58f, 0.64f, 0.35f);
        glVertex2f(-1.60f, -0.55f);
        glColor4f(0.82f, 0.87f, 0.90f, 0.45f);
        glVertex2f(-0.65f, 0.12f);
        glColor4f(0.42f, 0.50f, 0.57f, 0.35f);
        glVertex2f(0.30f, -0.55f);

        glColor4f(0.45f, 0.53f, 0.60f, 0.38f);
        glVertex2f(-0.20f, -0.55f);
        glColor4f(0.76f, 0.82f, 0.86f, 0.45f);
        glVertex2f(0.70f, 0.18f);
        glColor4f(0.36f, 0.45f, 0.52f, 0.38f);
        glVertex2f(1.65f, -0.55f);

        glColor4f(0.44f, 0.52f, 0.59f, 0.35f);
        glVertex2f(1.10f, -0.55f);
        glColor4f(0.72f, 0.79f, 0.84f, 0.43f);
        glVertex2f(2.05f, 0.08f);
        glColor4f(0.35f, 0.43f, 0.50f, 0.35f);
        glVertex2f(3.10f, -0.55f);

        glEnd();

// MONTAGNES PRINCIPALES - FACES GAUCHE/DROITE
        glBegin(GL_TRIANGLES);
    // Grande montagne gauche - face éclairée
        glColor4f(0.34f, 0.38f, 0.40f, 1.0f);
        glVertex2f(-1.35f, -0.55f);
        glColor4f(0.62f, 0.66f, 0.65f, 1.0f);
        glVertex2f(-0.55f, 0.52f);
        glColor4f(0.27f, 0.31f, 0.33f, 1.0f);
        glVertex2f(-0.30f, -0.55f);

    // Grande montagne gauche - face sombre
        glColor4f(0.24f, 0.28f, 0.30f, 1.0f);
        glVertex2f(-0.30f, -0.55f);
        glColor4f(0.50f, 0.54f, 0.54f, 1.0f);
        glVertex2f(-0.55f, 0.52f);
        glColor4f(0.14f, 0.18f, 0.21f, 1.0f);
        glVertex2f(0.60f, -0.55f);

    // Montagne centrale - face éclairée
        glColor4f(0.36f, 0.40f, 0.41f, 1.0f);
        glVertex2f(-0.20f, -0.55f);
        glColor4f(0.68f, 0.70f, 0.67f, 1.0f);
        glVertex2f(0.75f, 0.62f);
        glColor4f(0.30f, 0.34f, 0.35f, 1.0f);
        glVertex2f(0.95f, -0.55f);

    // Montagne centrale - face sombre
        glColor4f(0.25f, 0.29f, 0.31f, 1.0f);
        glVertex2f(0.95f, -0.55f);
        glColor4f(0.52f, 0.55f, 0.55f, 1.0f);
        glVertex2f(0.75f, 0.62f);
        glColor4f(0.13f, 0.17f, 0.20f, 1.0f);
        glVertex2f(1.80f, -0.55f);

    // Montagne droite - face éclairée
        glColor4f(0.32f, 0.36f, 0.38f, 1.0f);
        glVertex2f(1.15f, -0.55f);
        glColor4f(0.58f, 0.61f, 0.60f, 1.0f);
        glVertex2f(1.95f, 0.38f);
        glColor4f(0.26f, 0.30f, 0.32f, 1.0f);
        glVertex2f(2.15f, -0.55f);

    // Montagne droite - face sombre
        glColor4f(0.22f, 0.26f, 0.28f, 1.0f);
        glVertex2f(2.15f, -0.55f);
        glColor4f(0.45f, 0.49f, 0.50f, 1.0f);
        glVertex2f(1.95f, 0.38f);
        glColor4f(0.12f, 0.16f, 0.19f, 1.0f);
        glVertex2f(2.95f, -0.55f);

        glEnd();

// NEIGE IRREGULIERE SUR LES SOMMETS
    // Neige grande montagne gauche
        glBegin(GL_TRIANGLE_FAN);
        glColor4f(1.00f, 1.00f, 0.96f, 1.0f);
        glVertex2f(-0.55f, 0.52f);

        glColor4f(0.92f, 0.96f, 1.00f, 1.0f);
        glVertex2f(-0.78f, 0.23f);
        glVertex2f(-0.66f, 0.18f);
        glVertex2f(-0.57f, 0.27f);
        glVertex2f(-0.48f, 0.16f);
        glVertex2f(-0.36f, 0.25f);
        glVertex2f(-0.25f, 0.20f);
        glEnd();

    // Ombre bleutée dans la neige gauche
        glBegin(GL_TRIANGLES);
        glColor4f(0.70f, 0.80f, 0.88f, 0.85f);
        glVertex2f(-0.55f, 0.52f);
        glVertex2f(-0.48f, 0.16f);
        glVertex2f(-0.25f, 0.20f);
        glEnd();

    // Neige montagne centrale
        glBegin(GL_TRIANGLE_FAN);
        glColor4f(1.00f, 1.00f, 0.97f, 1.0f);
        glVertex2f(0.75f, 0.62f);

        glColor4f(0.94f, 0.97f, 1.00f, 1.0f);
        glVertex2f(0.48f, 0.30f);
        glVertex2f(0.58f, 0.22f);
        glVertex2f(0.70f, 0.34f);
        glVertex2f(0.82f, 0.23f);
        glVertex2f(0.95f, 0.35f);
        glVertex2f(1.08f, 0.28f);
        glEnd();

    // Ombre neige centrale
        glBegin(GL_TRIANGLES);
        glColor4f(0.68f, 0.79f, 0.88f, 0.85f);
        glVertex2f(0.75f, 0.62f);
        glVertex2f(0.82f, 0.23f);
        glVertex2f(1.08f, 0.28f);
        glEnd();

    // Neige montagne droite
        glBegin(GL_TRIANGLE_FAN);
        glColor4f(1.00f, 1.00f, 0.97f, 1.0f);
        glVertex2f(1.95f, 0.38f);

        glColor4f(0.93f, 0.96f, 1.00f, 1.0f);
        glVertex2f(1.72f, 0.13f);
        glVertex2f(1.82f, 0.08f);
        glVertex2f(1.92f, 0.17f);
        glVertex2f(2.03f, 0.09f);
        glVertex2f(2.17f, 0.15f);
        glEnd();

    // Ombre neige droite
        glBegin(GL_TRIANGLES);
        glColor4f(0.68f, 0.78f, 0.86f, 0.80f);
        glVertex2f(1.95f, 0.38f);
        glVertex2f(2.03f, 0.09f);
        glVertex2f(2.17f, 0.15f);
        glEnd();


// CRETES / OMBRES DE ROCHES
        glBegin(GL_TRIANGLES);
    // Crête sombre grande montagne gauche
        glColor4f(0.08f, 0.11f, 0.13f, 0.28f);
        glVertex2f(-0.55f, 0.47f);
        glVertex2f(-0.37f, -0.55f);
        glVertex2f(-0.22f, -0.55f);

    // Crête claire gauche
        glColor4f(0.78f, 0.80f, 0.76f, 0.22f);
        glVertex2f(-0.58f, 0.44f);
        glVertex2f(-0.95f, -0.20f);
        glVertex2f(-0.85f, -0.55f);

    // Crête sombre centrale
        glColor4f(0.07f, 0.10f, 0.12f, 0.30f);
        glVertex2f(0.75f, 0.57f);
        glVertex2f(0.98f, -0.55f);
        glVertex2f(1.15f, -0.55f);

    // Crête claire centrale
        glColor4f(0.80f, 0.82f, 0.78f, 0.23f);
        glVertex2f(0.72f, 0.56f);
        glVertex2f(0.20f, -0.20f);
        glVertex2f(0.30f, -0.55f);

    // Crête sombre droite
        glColor4f(0.07f, 0.10f, 0.12f, 0.25f);
        glVertex2f(1.95f, 0.34f);
        glVertex2f(2.18f, -0.55f);
        glVertex2f(2.35f, -0.55f);
        glEnd();
        glEnd();
        glPopMatrix();
    }
}

// RESET PROPRE
void resetScene() {
    avionX = -3.25f;
    avionY = RUNWAY_Y;
    avionVX = 0.0f;
    avionVY = 0.0f;
    avionAngle = 0.0f;
    gearFold = 0.0f;

    camX = avionX + 0.35f;
    camY = 0.0f;

    phase = 0;
    phaseTimer = 0.0f;

    commandeAvancer = false;
    commandeDecoller = false;
}

// UPDATE AVION MANUEL
void updateAvion(float dt) {
    phaseTimer += dt;
    switch (phase) {
// Avion immobile au debut
    case 0:
        avionY = RUNWAY_Y;
        avionVX = 0.0f;
        avionVY = 0.0f;
        avionAngle = 0.0f;
        gearFold = 0.0f;
        // Si tu appuies sur A, l'avion commence a avancer plus vite
        if (commandeAvancer) {
            phase = 1;
            phaseTimer = 0.0f;
        }
        // Si tu appuies directement sur decoller
        if (commandeDecoller) {
            phase = 2;
            phaseTimer = 0.0f;
            commandeDecoller = false;
        }
        break;
// Avion au sol : il avance seulement tant que tu appuies sur A
    case 1:
        avionY = RUNWAY_Y;
        avionVY = 0.0f;
        avionAngle = 0.0f;
        gearFold = 0.0f;
        if (commandeDecoller) {
            phase = 2;
            phaseTimer = 0.0f;
            commandeDecoller = false;
            break;
        }
        if (commandeAvancer) {
            avionVX = TAXI_SPEED;       // Plus rapide qu'avant
            avionX += avionVX * dt;
        }
        else {
            avionVX = 0.0f;
        }
        break;
// Decollage : apres avoir appuye sur D ou ESPACE,l'avion accelere automatiquement sur la piste.
    case 2:
        avionVX += ACCEL_RATE * dt;

        if (avionVX > MAX_SPEED)
            avionVX = MAX_SPEED;

        avionX += avionVX * dt;
        avionY = RUNWAY_Y;
        avionAngle = 0.0f;
        gearFold = 0.0f;

        if (avionVX >= MAX_SPEED * 0.80f) {
            phase = 3;
            phaseTimer = 0.0f;
        }

        break;
// L'avion quitte le sol et prend un angle de montee
    case 3:
        avionVX += 0.11f * dt;
        avionVY += 0.75f * dt;

        if (avionVX > MAX_SPEED * 1.05f)
            avionVX = MAX_SPEED * 1.05f;

        if (avionVY > CLIMB_VY)
            avionVY = CLIMB_VY;

        avionX += avionVX * dt;
        avionY += avionVY * dt;

        avionAngle += 30.0f * dt;

        if (avionAngle > CLIMB_ANGLE)
            avionAngle = CLIMB_ANGLE;

        gearFold += 0.95f * dt;

        if (gearFold > 1.0f)
            gearFold = 1.0f;

        // Quand il arrive a une certaine hauteur,
        // il passe en phase de stabilisation.
        if (avionY > LEVEL_OFF_Y) {
            phase = 4;
            phaseTimer = 0.0f;
        }

        break;
// Tant que les montagnes sont encore visibles,l'avion reste penche et continue de monter.
    case 4:
        avionVX += 0.02f * dt;

        if (avionVX > MAX_SPEED * 1.10f)
            avionVX = MAX_SPEED * 1.10f;

        avionX += avionVX * dt;

        // Montee claire pendant que le decor descend.
        avionY += 0.24f * dt;

        // L'avion reste penche tant que les montagnes ne sont pas sorties.
        // On garde un angle naturel, pas completement horizontal.
        avionAngle = CLIMB_ANGLE;

        gearFold = 1.0f;

        // Quand la camera est montee assez haut,
        // les montagnes sont sorties de l'ecran.
        // Seulement maintenant l'avion peut devenir droit.
        if (camY > MOUNTAINS_GONE_CAMERA_Y) {
            phase = 5;
            phaseTimer = 0.0f;
        }
        break;
// Maintenant les montagnes ne sont plus visibles, l'avion peut devenir droit progressivement.
    case 5:
        avionVX += 0.005f * dt;

        if (avionVX > MAX_SPEED * 1.12f)
            avionVX = MAX_SPEED * 1.12f;

        avionX += avionVX * dt;

        // Il monte encore un peu, mais moins fort.
        avionY += 0.06f * dt;

        // Retour progressif vers 0 degre.
        avionAngle -= 18.0f * dt;

        if (avionAngle < 0.0f)
            avionAngle = 0.0f;

        gearFold = 1.0f;

        if (avionX > 11.0f || avionY > 2.40f) {
            resetScene();
        }

        break;
    }
}

// CAMERA
void updateCamera(float dt) {
    float targetX = avionX + 0.35f;
    float targetY = 0.0f;
    // Position voulue de l'avion dans l'ecran.
    // 0.00 = milieu exact
    // 0.30 = un peu plus haut que le milieu
    const float PLANE_SCREEN_Y = 0.30f;
    if (phase <= 2) {
        // Au sol, on garde la camera basse pour voir la piste normalement.
        targetY = 0.0f;
    }
    else if (phase == 3) {
        // Pendant le debut du decollage, la camera commence a suivre l'avion,
        // mais doucement pour ne pas faire disparaitre la piste trop vite.
        float cameraToKeepPlane = avionY - PLANE_SCREEN_Y;
        float cameraNatural = (avionY - RUNWAY_Y) * 0.35f;

        targetY = cameraNatural;

        if (targetY > cameraToKeepPlane)
            targetY = cameraToKeepPlane;

        if (targetY < 0.0f)
            targetY = 0.0f;
    }
    else {
        // Phase 4 et 5 : l'avion doit rester au milieu / un peu haut.
        // Donc la camera suit l'avion avec cette formule :
        // position ecran de l'avion = avionY - camY
        // camY = avionY - PLANE_SCREEN_Y
        // Resultat : l'avion reste a PLANE_SCREEN_Y dans l'ecran.
        targetY = avionY - PLANE_SCREEN_Y;

        if (targetY < 0.0f)
            targetY = 0.0f;

        // Limite haute pour eviter une camera infinie.
        if (targetY > 1.80f)
            targetY = 1.80f;
    }

    // Lissage de la camera.
    // X suit l'avion.
    // Y suit assez doucement pour que route/montagnes descendent de facon fluide.
    float smoothSpeedX = 3.2f;
    float smoothSpeedY = 1.65f;

    camX += (targetX - camX) * smoothSpeedX * dt;
    camY += (targetY - camY) * smoothSpeedY * dt;
}

// DISPLAY
static float lastTime = 0.0f;

void display() {
    float now = (float)glfwGetTime();
    float dt = now - lastTime;
    lastTime = now;

    if (dt > 0.08f)
        dt = 0.08f;

    nuageOffset += CLOUD_SPEED * dt;

    updateAvion(dt);
    updateCamera(dt);

    glClear(GL_COLOR_BUFFER_BIT);

    // Le ciel et les nuages ne suivent pas la camera.
    // Donc meme quand la camera monte, les nuages restent visibles.
    dessinerCiel();
    dessinerNuagesEnContinu();

    glPushMatrix();

    // Le decor suit la camera.
    // Important : on ne cache plus le decor avec un if brutal.
    // La route, les arbres et les montagnes sortent naturellement de l'ecran
    // grace au deplacement progressif de la camera.
    glTranslatef(-camX, -camY, 0.0f);

    dessinerMontagnes();

    for (float x = WORLD_LEFT; x <= WORLD_RIGHT; x += 0.22f) {
        int index = (int)((x - WORLD_LEFT) / 0.22f);
        dessinerArbreRealiste(x, -0.25f, 0.5f, index % 2 == 0);
    }

    dessinerHerbeRealiste();
    dessinerPiste1();
    dessinerPiste2();

    // L'avion reste toujours dessine.
    dessinerAvion(avionX, avionY, avionAngle, gearFold);

    glPopMatrix();
}

// CONTROLES CLAVIER
void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods) {

    if (action == GLFW_PRESS) {

        // A ou fleche droite : avancer au sol
        if (key == GLFW_KEY_A || key == GLFW_KEY_RIGHT) {
            commandeAvancer = true;
        }

        // Espace ou D : decoller
        if (key == GLFW_KEY_SPACE || key == GLFW_KEY_D) {
            commandeDecoller = true;
        }

        // R : recommencer
        if (key == GLFW_KEY_R) {
            resetScene();
        }

        // ESC : quitter
        if (key == GLFW_KEY_ESCAPE) {
            glfwSetWindowShouldClose(window, 1);
        }
    }

    if (action == GLFW_RELEASE) {

        // Quand tu laches A ou la fleche droite, l'avion arrete d'avancer au sol
        if (key == GLFW_KEY_A || key == GLFW_KEY_RIGHT) {
            commandeAvancer = false;
        }
    }
}

// MAIN
int main() {
    if (!glfwInit())
        return -1;

    glfwWindowHint(GLFW_SAMPLES, 4);

    GLFWwindow* win = glfwCreateWindow(1400, 900, "Avion OpenGL - Decollage", NULL, NULL);

    if (!win) {
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(win);
    glfwSwapInterval(1);

    glfwSetKeyCallback(win, keyCallback);
    glfwSetWindowTitle(win, "Avion OpenGL - A: Avancer vite | Espace/D: Decoller | R: Reset");

    glClearColor(0.72f, 0.91f, 0.94f, 1.0f);

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_LINE_SMOOTH);

    srand(42);

    float yLevels[4] = { 0.30f, 0.44f, 0.56f, 0.66f };

    for (int i = 0; i < 8; i++) {
        nuages[i].x = -1.5f + i * 0.42f;
        nuages[i].y = yLevels[i % 4];
    }

    resetScene();

    lastTime = (float)glfwGetTime();

    while (!glfwWindowShouldClose(win)) {
        display();
        glfwSwapBuffers(win);
        glfwPollEvents();
    }

    glfwTerminate();

    return 0;
}