#include <os.h>
#include <stdbool.h>

#include "ttr.h"

#define IASCORE_DANS_PATHFINDER	6
#define IASCORE_REALISABLE_NOW	3
#define IASCORE_WITHOUT_LOCO	2
#define IASCORE_ONE_WAGON_LESS	1

#define DEFAUSSER_CARTE		1
#define GARDER_CARTE        2

#define JOUEUR_TUTO			1

uint8 routeCourante = 0;
sint16 xCarte = 160;
sint16 yCarte = 96;
sint16 cursorX = 160;
sint16 cursorY = 105;
uint8 cptGoto = 0;

bool passAndPlayActif = false;
uint16 codePin[6];
uint16 lastAction[6];
uint16 lastPath[6];
uint8 lastPaiement[6][6];

uint16 villeX[]= {43,40, 26, 17,130,197,149,112, 69,236,231,148,228,335,280,355,349,335,437,440,513,568,614,580,524,407,585,396,547,469,503,565,376,440,587,349};
uint16 villeY[]= {39,76,110,241, 28,116,199,272,312,220,280,315,341,174, 35,112,208,266,154, 68, 82, 24, 63,114,143,208,173,268,219,234,257,262,352,346,367,324};

bool afficherSiRealise[] = {true,true,false,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true};

uint8 spotXno[] = {28,27,23,21,61,61,58,0,30,72, 75, 53, 73,0,98,114,110,104,132,143,158,171,185,177,158,0,0,119,0,140,149,0,109,128,167,105};
uint8 spotYno[] = {36,38,48,83,38,51,75,0,98,80,100,102,114,0,40, 56, 85, 98, 65, 45, 45, 38, 50, 62, 68,0,0, 98,0, 93,100,0,122,119,127,110};

uint8 spotX80[] = { 9, 9, 7, 7,20,20,19,0,10,23,24,17,23,0,31,36,35,33,42,46,51,55,59,57,51,0,0,38,0,45,48,0,35,41,53,34};
uint8 spotY80[] = {12,12,16,27,12,16,24,0,32,26,32,33,37,0,13,18,27,32,21,15,15,12,16,20,22,0,0,32,0,30,32,0,39,38,41,36};

uint8 spotX60[] = {7,6,6,5,15,15,14,0,7,17,18,13,18,0,24,27,26,25,32,34,38,41,44,42,38,0,0,29,0,34,36,0,26,31,40,25};
uint8 spotY60[] = {9,9,12,20,9,12,18,0,24,19,24,25,28,0,10,14,21,24,16,11,11,9,12,15,16,0,0,24,0,23,24,0,30,29,31,27};


#define MAX_SMOKE	60
sint8 fumeeX[MAX_SMOKE];
sint8 fumeeDx[MAX_SMOKE];
sint8 fumeeY[MAX_SMOKE];
uint8 fumeeL[MAX_SMOKE];
uint8 fumeeCpt[MAX_SMOKE];
uint16 fumeeCol[MAX_SMOKE];
uint8 nbFumee;

#define MAX_FLAG	500
uint8 flags[MAX_FLAG][6];

#ifdef DEBUG
#define		CPT_ANIMATION	60
#define 	DELTA_SCROLL	2
#else
#define		CPT_ANIMATION	30
#define 	DELTA_SCROLL	8
#endif

#define MAX_CARTE_X		640-284
#define MAX_CARTE_Y		412-222

#define MAX_CURSEUR_X		284
#define MAX_CURSEUR_Y		200


void ajouterPaveAAfficher(uint16 idxPave) {
    // insérer le idxPave dans la liste triée
    if (nbPaveAAfficher == 0) {
        pavesAAfficher[nbPaveAAfficher] = idxPave;
    } else {
        bool inserer = FALSE;
        for (uint16 i=0; i<nbPaveAAfficher; i++) {
            // si le pave est < on l'insere ici
            if (paves[idxPave].y < paves[i].y) {
                // tout décaler
                for (uint16 j=nbPaveAAfficher; j>i; j--) {
                    pavesAAfficher[j] = pavesAAfficher[j - 1];
                }
                // insérer
                pavesAAfficher[i] = idxPave;
                inserer = TRUE;
                break;
            } else {
                if ((paves[idxPave].y == paves[i].y) && (paves[idxPave].x == paves[i].x)) {
                    // tout décaler
                    for (uint16 j=nbPaveAAfficher; j>i; j--) {
                        pavesAAfficher[j] = pavesAAfficher[j - 1];
                    }
                    // insérer
                    pavesAAfficher[i] = idxPave;
                    inserer = TRUE;
                    break;
                }
            }
        }
        if (!inserer) {
            // insertion en fin
            pavesAAfficher[nbPaveAAfficher] = idxPave;
        }
    }

    nbPaveAAfficher++;

    // Afficher l'ombre
    uint16 ombre = FILE_WAGON_SHADOW_0_0 + paves[idxPave].rot;
    afficherGrafx_file(ombre, paves[idxPave].x, paves[idxPave].y, SCREEN_SHADOW, 0xFFFF);
}

char partie[23];

void empilerPartie(int nb) {
    if (nb > 9) {
        empilerPartie(trunc(nb / 10));
        empilerPartie(nb % 10);
        return;
    }

    switch(nb) {
    case 0:
        strcat(partie, "0");
        break;
    case 1:
        strcat(partie, "1");
        break;
    case 2:
        strcat(partie, "2");
        break;
    case 3:
        strcat(partie, "3");
        break;
    case 4:
        strcat(partie, "4");
        break;
    case 5:
        strcat(partie, "5");
        break;
    case 6:
        strcat(partie, "6");
        break;
    case 7:
        strcat(partie, "7");
        break;
    case 8:
        strcat(partie, "8");
        break;
    case 9:
        strcat(partie, "9");
        break;
    }
}

void sauverPartie(uint8 numJoueur, uint8 numPartie) {
    memset(partie, 0, 22);
    strcpy(partie, "grafx/sav_");
    empilerPartie(numPartie);
    strcat(partie, ".tns");
    FILE *ttrfic = fopen(getCheminFichier(partie), "w+b");
    if(!ttrfic) {
        return;
    }
    // version du fichier
    uint8 version = 1;
    fwrite(&version, sizeof(uint8), 1, ttrfic);
    // les joueurs
    fwrite(&nbTotalJoueur, sizeof(uint8), 1, ttrfic);
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        fwrite(&joueurs[i], sizeof(ttrJoueur), 1, ttrfic);
    }
    // à qui le tour
    fwrite(&numJoueur, sizeof(uint8), 1, ttrfic);
    // numéro du tour
    fwrite(&numeroTour, sizeof(uint8), 1, ttrfic);
    fwrite(&tourRestant, sizeof(uint8), 1, ttrfic);
    // les pioches
    fwrite(&nbCartesWagonPioche, sizeof(uint8), 1, ttrfic);
    fwrite(piocheCartesWagon, sizeof(uint8), 110, ttrfic);
    fwrite(&nbCartesWagonDefausse, sizeof(uint8), 1, ttrfic);
    fwrite(defausseCartesWagon, sizeof(uint8), 110, ttrfic);
    fwrite(&nbCartesMissionPioche, sizeof(uint8), 1, ttrfic);
    fwrite(piocheCartesMission, sizeof(uint8), 30, ttrfic);
    fwrite(choixCartesWagon, sizeof(uint8), 5, ttrfic);
    // Last paiement
    for (uint8 i=0; i<6; i++) {
        fwrite(lastPaiement[i], sizeof(uint8), 6, ttrfic);
    }

    // les paths
    uint8 owner[MAX_PATH];
    owner[0] = 0;
    for (uint8 i=1; i<MAX_PATH; i++) {
        owner[i] = paths[i].owner;
    }
    fwrite(&owner, sizeof(uint8), MAX_PATH, ttrfic);
    fclose(ttrfic);
}

uint8 chargerPartie(uint8 numPartie) {
    memset(partie, 0, 22);
    strcpy(partie, "grafx/sav_");
    empilerPartie(numPartie);
    strcat(partie, ".tns");
    FILE *ttrfic = fopen(getCheminFichier(partie), "rb");
    if(!ttrfic) {
        return 0;
    }

    // libérer les anciens joueurs
    free(joueurs);
    // la version
    uint8 version;
    fread(&version, sizeof(uint8), 1, ttrfic);
    // les joueurs
    fread(&nbTotalJoueur, sizeof(uint8), 1, ttrfic);
    joueurs = (ttrJoueur *)malloc((nbTotalJoueur + 1) * sizeof(ttrJoueur));
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        fread(&joueurs[i], sizeof(ttrJoueur), 1, ttrfic);
    }
    // à qui le tour
    uint8 numJoueur;
    fread(&numJoueur, sizeof(uint8), 1, ttrfic);

    // numéro du tour
    fread(&numeroTour, sizeof(uint8), 1, ttrfic);
    fread(&tourRestant, sizeof(uint8), 1, ttrfic);
    // les pioches
    fread(&nbCartesWagonPioche, sizeof(uint8), 1, ttrfic);
    fread(piocheCartesWagon, sizeof(uint8), 110, ttrfic);
    fread(&nbCartesWagonDefausse, sizeof(uint8), 1, ttrfic);
    fread(defausseCartesWagon, sizeof(uint8), 110, ttrfic);
    fread(&nbCartesMissionPioche, sizeof(uint8), 1, ttrfic);
    fread(piocheCartesMission, sizeof(uint8), 30, ttrfic);
    fread(choixCartesWagon, sizeof(uint8), 5, ttrfic);

    // Last paiement
    for (uint8 i=0; i<6; i++) {
        fread(lastPaiement[i], sizeof(uint8), 6, ttrfic);
    }

    // les paths
    uint8 owner[MAX_PATH];
    fread(&owner, sizeof(uint8), MAX_PATH, ttrfic);
    paths[0].owner = 0;
    for (uint8 i=1; i<MAX_PATH; i++) {
        paths[i].owner = owner[i];
    }

    fclose(ttrfic);
    // refaire la carte
    resetUsMap();
    nbPaveAAfficher = 0;
    for (uint8 i=1; i<MAX_PATH; i++) {
        for (uint8 j=0; j<paths[i].distance; j++) {
            paves[paths[i].idxPave[j]].owner = paths[i].owner;
            if (paths[i].owner != 0) {
                ajouterPaveAAfficher(paths[i].idxPave[j]);
            }
        }
    }
    preparerUsMap();
    return numJoueur;
}

uint16 ajouter_pave(sint16 x, sint16 y, uint8 rot) {
    numPave++;
    paves[numPave].x = x;
    paves[numPave].y = y;
    paves[numPave].rot = rot;
    paves[numPave].owner = 0;

    uint8 idx = 6;
    for (uint8 i=0; i<6; i++) {
        if (paths[routeCourante].idxPave[i] == 0) {
            idx = i;
            break;
        }
    }
    paths[routeCourante].idxPave[idx] = numPave;

    return numPave;
}

void creation_route(uint8 num, uint8 villeA, uint8 villeB, uint8 couleur, uint8 distance, uint8 lien) {
    paths[num].villeA = villeA;
    paths[num].villeB = villeB;
    paths[num].couleur = couleur;
    paths[num].distance = distance;
    paths[num].lien = lien;
    paths[num].owner = 0;
    for (uint8 i=0; i<6; i++) {
        paths[num].idxPave[i] = 0;
    }
    routeCourante = num;
}

void creations_routes() {
    paths = (ttrPath *)malloc(sizeof(ttrPath) * MAX_PATH);
    paves = (ttrPave *)malloc(sizeof(ttrPave) * MAX_PAVE); // revoir le nombre
    pavesAAfficher = (uint16 *)malloc(sizeof(uint16) * MAX_PAVE);

    numPave = 0;
    nbPaveAAfficher = 0;

    creation_route(1, TOWN_VANCOUVER,TOWN_CALGARY, COULEUR_LOCO, 3, 0);
    ajouter_pave(54,27,2);
    ajouter_pave(79,25,2);
    ajouter_pave(103,22,2);

    creation_route(2, TOWN_VANCOUVER, TOWN_SEATTLE, COULEUR_LOCO, 1, 3);
    ajouter_pave(30,52,19);

    creation_route(3, TOWN_VANCOUVER, TOWN_SEATTLE, COULEUR_LOCO, 1, 2);
    ajouter_pave(38,52,18);

    creation_route(4, TOWN_SEATTLE, TOWN_PORTLAND, COULEUR_LOCO, 1, 5);
    ajouter_pave(22,85,16);

    creation_route(5, TOWN_SEATTLE, TOWN_PORTLAND, COULEUR_LOCO, 1, 4);
    ajouter_pave(31,87,16);

    creation_route(6, TOWN_SEATTLE, TOWN_CALGARY, COULEUR_LOCO, 4, 0);
    ajouter_pave(54,68,1);
    ajouter_pave(78,66,2);
    ajouter_pave(101,58,10);
    ajouter_pave(116,37,14);

    creation_route(7, TOWN_CALGARY, TOWN_HELENA, COULEUR_LOCO, 4, 0);
    ajouter_pave(136,35,23);
    ajouter_pave(152,54,23);
    ajouter_pave(167,73,23);
    ajouter_pave(182,93,23);

    creation_route(8, TOWN_CALGARY, TOWN_WINNIPEG, COULEUR_BLANC, 6, 0);
    ajouter_pave(140,14,7);
    ajouter_pave(163,7,4);
    ajouter_pave(187,4,0);
    ajouter_pave(212,4,35);
    ajouter_pave(237,8,30);
    ajouter_pave(259,18,29);

    creation_route(9, TOWN_SEATTLE, TOWN_HELENA, COULEUR_JAUNE, 6, 0);
    ajouter_pave(50,80,32);
    ajouter_pave(74,85,32);
    ajouter_pave(98,90,32);
    ajouter_pave(121,95,32);
    ajouter_pave(145,101,32);
    ajouter_pave(169,106,32);

    creation_route(10, TOWN_PORTLAND, TOWN_SALT_LAKE_CITY, COULEUR_BLEU, 6, 0);
    ajouter_pave(38,104,31);
    ajouter_pave(62,112,30);
    ajouter_pave(84,123,27);
    ajouter_pave(103,138,25);
    ajouter_pave(121,154,24);
    ajouter_pave(133,174,22);

    creation_route(11, TOWN_PORTLAND, TOWN_SAN_FRANCISCO, COULEUR_ROSE, 5, 12);
    ajouter_pave(18,121,15);
    ajouter_pave(10,144,17);
    ajouter_pave(7,167,18);
    ajouter_pave(8,191,19);
    ajouter_pave(11,215,20);

    creation_route(12, TOWN_PORTLAND, TOWN_SAN_FRANCISCO, COULEUR_VERT, 5, 11);
    ajouter_pave(9,118,15);
    ajouter_pave(1,141,16);
    ajouter_pave(-2,166,17);
    ajouter_pave(-2,190,18);
    ajouter_pave(1,215,19);

    creation_route(13, TOWN_SAN_FRANCISCO, TOWN_SALT_LAKE_CITY, COULEUR_MARRON, 5, 14);
    ajouter_pave(30,220,6);
    ajouter_pave(54,214,6);
    ajouter_pave(76,207,6);
    ajouter_pave(99,200,6);
    ajouter_pave(122,192,6);

    creation_route(14, TOWN_SAN_FRANCISCO, TOWN_SALT_LAKE_CITY, COULEUR_BLANC, 5, 13);
    ajouter_pave(34,230,6);
    ajouter_pave(55,223,6);
    ajouter_pave(78,216,6);
    ajouter_pave(101,209,6);
    ajouter_pave(123,201,6);

    creation_route(15, TOWN_SAN_FRANCISCO, TOWN_LOS_ANGELES, COULEUR_ROSE, 3, 16);
    ajouter_pave(23,248,21);
    ajouter_pave(35,271,23);
    ajouter_pave(50,289,24);

    creation_route(16, TOWN_SAN_FRANCISCO, TOWN_LOS_ANGELES, COULEUR_JAUNE, 3, 15);
    ajouter_pave(15,252,21);
    ajouter_pave(26,275,22);
    ajouter_pave(43,294,24);

    creation_route(17, TOWN_LOS_ANGELES, TOWN_LAS_VEGAS, COULEUR_LOCO, 2,  0);
    ajouter_pave(68,281,15);
    ajouter_pave(87,267,3);

    creation_route(18, TOWN_LOS_ANGELES, TOWN_PHOENIX, COULEUR_LOCO, 3, 0);
    ajouter_pave(77,297,2);
    ajouter_pave(102,296,0);
    ajouter_pave(128,298,31);

    creation_route(19, TOWN_LOS_ANGELES, TOWN_EL_PASO, COULEUR_NOIR, 6, 0);
    ajouter_pave(80,316,26);
    ajouter_pave(100,328,28);
    ajouter_pave(124,335,30);
    ajouter_pave(147,340,33);
    ajouter_pave(171,342,1);
    ajouter_pave(193,337,4);

    creation_route(20, TOWN_LAS_VEGAS, TOWN_SALT_LAKE_CITY, COULEUR_MARRON, 3, 0);
    ajouter_pave(119,254,11);
    ajouter_pave(134,233,14);
    ajouter_pave(141,211,17);

    creation_route(21, TOWN_SALT_LAKE_CITY, TOWN_HELENA, COULEUR_ROSE, 3, 0);
    ajouter_pave(155,167,13);
    ajouter_pave(168,145,13);
    ajouter_pave(181,125,13);

    creation_route(22, TOWN_HELENA, TOWN_WINNIPEG, COULEUR_BLEU, 4, 0);
    ajouter_pave(204,93,11);
    ajouter_pave(222,76,11);
    ajouter_pave(239,58,11);
    ajouter_pave(257,41,11);

    creation_route(23, TOWN_SALT_LAKE_CITY, TOWN_DENVER, COULEUR_ROUGE, 3, 25);
    ajouter_pave(161,187,32);
    ajouter_pave(184,192,32);
    ajouter_pave(208,197,32);

    creation_route(24, TOWN_PHOENIX, TOWN_DENVER, COULEUR_BLANC, 5, 0);
    ajouter_pave(148,290,14);
    ajouter_pave(160,269,13);
    ajouter_pave(173,249,13);
    ajouter_pave(188,233,11);
    ajouter_pave(209,220,7);

    creation_route(25, TOWN_SALT_LAKE_CITY, TOWN_DENVER, COULEUR_JAUNE, 3, 23);
    ajouter_pave(158,198,32);
    ajouter_pave(182,203,32);
    ajouter_pave(206,207,32);

    creation_route(26, TOWN_EL_PASO, TOWN_SANTA_FE, COULEUR_LOCO, 2,  0);
    ajouter_pave(220,316,17);
    ajouter_pave(222,291,17);

    creation_route(27, TOWN_PHOENIX, TOWN_SANTA_FE, COULEUR_LOCO, 3, 0);
    ajouter_pave(162,299,8);
    ajouter_pave(185,289,8);
    ajouter_pave(207,278,8);

    creation_route(28, TOWN_PHOENIX, TOWN_EL_PASO, COULEUR_LOCO, 3, 0);
    ajouter_pave(159,313,30);
    ajouter_pave(182,320,30);
    ajouter_pave(204,327,30);

    creation_route(29, TOWN_SANTA_FE, TOWN_DENVER, COULEUR_LOCO, 2,  0);
    ajouter_pave(224,254,17);
    ajouter_pave(226,230,17);

    creation_route(30, TOWN_HELENA, TOWN_DENVER, COULEUR_VERT, 4, 0);
    ajouter_pave(197,124,21);
    ajouter_pave(206,147,21);
    ajouter_pave(215,169,21);
    ajouter_pave(224,192,21);

    creation_route(31, TOWN_HELENA, TOWN_OMAHA, COULEUR_ROUGE, 5, 0);
    ajouter_pave(215,122,29);
    ajouter_pave(238,131,29);
    ajouter_pave(260,140,29);
    ajouter_pave(282,149,29);
    ajouter_pave(305,159,29);

    creation_route(32, TOWN_HELENA, TOWN_DULUTH, COULEUR_MARRON, 6, 0);
    ajouter_pave(208,107,0);
    ajouter_pave(232,107,0);
    ajouter_pave(256,107,0);
    ajouter_pave(281,107,0);
    ajouter_pave(305,107,0);
    ajouter_pave(329,107,0);

    creation_route(33, TOWN_DENVER, TOWN_OMAHA, COULEUR_ROSE, 4, 0);
    ajouter_pave(242,198,10);
    ajouter_pave(263,185,8);
    ajouter_pave(285,177,6);
    ajouter_pave(310,171,2);

    creation_route(34, TOWN_DENVER, TOWN_OKLAHOMA_CITY, COULEUR_ROUGE, 4, 0);
    ajouter_pave(241,235,25);
    ajouter_pave(261,245,28);
    ajouter_pave(284,252,32);
    ajouter_pave(308,255,35);

    creation_route(35, TOWN_EL_PASO, TOWN_OKLAHOMA_CITY, COULEUR_JAUNE, 5, 0);
    ajouter_pave(238,325,6);
    ajouter_pave(261,316,8);
    ajouter_pave(284,306,9);
    ajouter_pave(300,290,11);
    ajouter_pave(317,271,13);

    creation_route(36, TOWN_DENVER, TOWN_KANSAS_CITY, COULEUR_NOIR, 4, 40);
    ajouter_pave(252,212,0);
    ajouter_pave(276,212,1);
    ajouter_pave(299,209,3);
    ajouter_pave(321,202,6);

    creation_route(37, TOWN_EL_PASO, TOWN_DALLAS, COULEUR_ROUGE, 4, 0);
    ajouter_pave(250,334,3);
    ajouter_pave(275,330,3);
    ajouter_pave(299,327,3);
    ajouter_pave(324,324,3);

    creation_route(38, TOWN_OKLAHOMA_CITY, TOWN_DALLAS, COULEUR_LOCO, 2,  49);
    ajouter_pave(331,279,19);
    ajouter_pave(334,300,19);

    creation_route(39, TOWN_SANTA_FE, TOWN_OKLAHOMA_CITY, COULEUR_BLEU, 3, 0);
    ajouter_pave(245,270,2);
    ajouter_pave(269,268,2);
    ajouter_pave(293,265,2);

    creation_route(40, TOWN_DENVER, TOWN_KANSAS_CITY, COULEUR_MARRON, 4, 36);
    ajouter_pave(250,221,0);
    ajouter_pave(276,221,1);
    ajouter_pave(299,218,4);
    ajouter_pave(324,212,6);

    creation_route(41, TOWN_KANSAS_CITY, TOWN_OKLAHOMA_CITY, COULEUR_LOCO, 2,  48);
    ajouter_pave(337,216,15);
    ajouter_pave(331,240,15);

    creation_route(42, TOWN_OMAHA, TOWN_KANSAS_CITY, COULEUR_LOCO, 1, 51);
    ajouter_pave(330,184,22);

    creation_route(43, TOWN_DULUTH, TOWN_OMAHA, COULEUR_LOCO, 2, 44);
    ajouter_pave(336,123,15);
    ajouter_pave(328,147,15);

    creation_route(44, TOWN_DULUTH, TOWN_OMAHA, COULEUR_LOCO, 2, 43);
    ajouter_pave(345,123,15);
    ajouter_pave(337,149,15);

    creation_route(45, TOWN_WINNIPEG, TOWN_DULUTH, COULEUR_NOIR, 4, 0);
    ajouter_pave(285,42,25);
    ajouter_pave(303,60,25);
    ajouter_pave(320,77,25);
    ajouter_pave(336,93,25);

    creation_route(46, TOWN_WINNIPEG, TOWN_SAULT_ST_MARIE, COULEUR_LOCO, 6, 0);
    ajouter_pave(293,30,32);
    ajouter_pave(318,36,32);
    ajouter_pave(342,41,32);
    ajouter_pave(367,46,32);
    ajouter_pave(391,51,32);
    ajouter_pave(416,57,32);

    creation_route(47, TOWN_OMAHA, TOWN_CHICAGO, COULEUR_BLEU, 4, 0);
    ajouter_pave(345,161,10);
    ajouter_pave(364,147,10);
    ajouter_pave(387,142,34);
    ajouter_pave(410,144,32);

    creation_route(48, TOWN_KANSAS_CITY, TOWN_OKLAHOMA_CITY, COULEUR_LOCO, 2,  41);
    ajouter_pave(346,217,16);
    ajouter_pave(340,241,16);

    creation_route(49, TOWN_OKLAHOMA_CITY, TOWN_DALLAS, COULEUR_LOCO, 2,  38);
    ajouter_pave(340,273,19);
    ajouter_pave(343,298,19);

    creation_route(50, TOWN_KANSAS_CITY, TOWN_SAINT_LOUIS, COULEUR_BLEU, 2, 59);
    ajouter_pave(359,194,35);
    ajouter_pave(384,194,35);

    creation_route(51, TOWN_OMAHA, TOWN_KANSAS_CITY, COULEUR_LOCO, 1, 42);
    ajouter_pave(339,180,22);

    creation_route(52, TOWN_OKLAHOMA_CITY, TOWN_LITTLE_ROCK, COULEUR_LOCO, 2, 0);
    ajouter_pave(346,257,0);
    ajouter_pave(370,257,0);

    creation_route(53, TOWN_DALLAS, TOWN_LITTLE_ROCK, COULEUR_LOCO, 2,  0);
    ajouter_pave(361,294,13);
    ajouter_pave(375,274,13);

    creation_route(54, TOWN_DALLAS, TOWN_HOUSTON, COULEUR_LOCO, 1, 72);
    ajouter_pave(359,325,24);

    creation_route(55, TOWN_LITTLE_ROCK, TOWN_NASHVILLE, COULEUR_BLANC, 3, 0);
    ajouter_pave(406,258,2);
    ajouter_pave(430,252,7);
    ajouter_pave(451,240,11);

    creation_route(56, TOWN_SAINT_LOUIS, TOWN_LITTLE_ROCK, COULEUR_LOCO, 2, 0);
    ajouter_pave(397,217,16);
    ajouter_pave(393,241,16);

    creation_route(57, TOWN_SAINT_LOUIS, TOWN_PITTSBURGH, COULEUR_VERT, 5, 0);
    ajouter_pave(417,197,8);
    ajouter_pave(437,186,8);
    ajouter_pave(457,175,8);
    ajouter_pave(479,162,8);
    ajouter_pave(500,151,8);

    creation_route(58, TOWN_SAINT_LOUIS, TOWN_CHICAGO, COULEUR_BLANC, 2, 60);
    ajouter_pave(411,185,13);
    ajouter_pave(424,165,13);

    creation_route(59, TOWN_KANSAS_CITY, TOWN_SAINT_LOUIS, COULEUR_ROSE, 2, 50);
    ajouter_pave(358,203,0);
    ajouter_pave(383,203,0);

    creation_route(60, TOWN_SAINT_LOUIS, TOWN_CHICAGO, COULEUR_VERT, 2, 58);
    ajouter_pave(402,182,13);
    ajouter_pave(415,159,12);

    creation_route(61, TOWN_DULUTH, TOWN_CHICAGO, COULEUR_ROUGE, 3, 0);
    ajouter_pave(362,116,26);
    ajouter_pave(385,127,29);
    ajouter_pave(408,133,32);

    creation_route(62, TOWN_DULUTH, TOWN_TORONTO, COULEUR_ROSE, 6, 0);
    ajouter_pave(367,103,3);
    ajouter_pave(390,99,3);
    ajouter_pave(415,95,3);
    ajouter_pave(439,92,3);
    ajouter_pave(463,87,3);
    ajouter_pave(487,83,3);

    creation_route(63, TOWN_DULUTH, TOWN_SAULT_ST_MARIE, COULEUR_LOCO, 3, 0);
    ajouter_pave(369,90,8);
    ajouter_pave(393,79,8);
    ajouter_pave(415,70,7);

    creation_route(64, TOWN_SAULT_ST_MARIE, TOWN_TORONTO, COULEUR_LOCO, 2,  0);
    ajouter_pave(455,66,33);
    ajouter_pave(479,71,33);

    creation_route(65, TOWN_SAULT_ST_MARIE, TOWN_MONTREAL, COULEUR_NOIR, 5, 0);
    ajouter_pave(448,48,10);
    ajouter_pave(467,35,8);
    ajouter_pave(488,26,6);
    ajouter_pave(510,18,4);
    ajouter_pave(535,16,0);

    creation_route(66, TOWN_TORONTO, TOWN_MONTREAL, COULEUR_LOCO, 3, 0);
    ajouter_pave(509,58,15);
    ajouter_pave(523,40,11);
    ajouter_pave(544,25,8);

    creation_route(67, TOWN_CHICAGO, TOWN_TORONTO, COULEUR_BLANC, 4, 0);
    ajouter_pave(433,123,11);
    ajouter_pave(454,112,9);
    ajouter_pave(474,102,5);
    ajouter_pave(495,90,10);

    creation_route(68, TOWN_CHICAGO, TOWN_PITTSBURGH, COULEUR_NOIR, 3, 80);
    ajouter_pave(449,143,5);
    ajouter_pave(471,137,2);
    ajouter_pave(495,136,0);

    creation_route(69, TOWN_TORONTO, TOWN_PITTSBURGH, COULEUR_LOCO, 2,  0);
    ajouter_pave(509,94,19);
    ajouter_pave(511,118,19);

    creation_route(70, TOWN_HOUSTON, TOWN_NEW_ORLEANS, COULEUR_LOCO, 2, 0);
    ajouter_pave(387,339,2);
    ajouter_pave(412,337,3);

    creation_route(71, TOWN_LITTLE_ROCK, TOWN_NEW_ORLEANS, COULEUR_VERT, 3, 0);
    ajouter_pave(397,277,22);
    ajouter_pave(408,298,22);
    ajouter_pave(419,319,22);

    creation_route(72, TOWN_DALLAS, TOWN_HOUSTON, COULEUR_LOCO, 1, 54);
    ajouter_pave(352,332,24);

    creation_route(73, TOWN_NEW_ORLEANS, TOWN_MIAMI, COULEUR_ROUGE, 6, 0);
    ajouter_pave(455,330,8);
    ajouter_pave(477,320,4);
    ajouter_pave(501,318,0);
    ajouter_pave(525,324,27);
    ajouter_pave(546,340,25);
    ajouter_pave(562,357,25);

    creation_route(74, TOWN_EL_PASO, TOWN_HOUSTON, COULEUR_VERT, 6, 0);
    ajouter_pave(235,345,27);
    ajouter_pave(257,354,30);
    ajouter_pave(281,359,32);
    ajouter_pave(304,361,0);
    ajouter_pave(329,359,2);
    ajouter_pave(353,354,6);

    creation_route(75, TOWN_NEW_ORLEANS, TOWN_ATLANTA, COULEUR_JAUNE, 4, 77);
    ajouter_pave(436,319,15);
    ajouter_pave(447,296,13);
    ajouter_pave(462,275,12);
    ajouter_pave(478,258,11);

    creation_route(76, TOWN_ATLANTA, TOWN_MIAMI, COULEUR_BLEU, 5, 0);
    ajouter_pave(506,271,23);
    ajouter_pave(522,290,23);
    ajouter_pave(537,308,23);
    ajouter_pave(553,328,23);
    ajouter_pave(569,347,23);

    creation_route(77, TOWN_NEW_ORLEANS, TOWN_ATLANTA, COULEUR_MARRON, 4, 75);
    ajouter_pave(444,323,14);
    ajouter_pave(456,302,13);
    ajouter_pave(470,283,12);
    ajouter_pave(485,265,11);

    creation_route(78, TOWN_SAINT_LOUIS, TOWN_NASHVILLE, COULEUR_LOCO, 2,  0);
    ajouter_pave(415,215,29);
    ajouter_pave(438,224,29);

    creation_route(79, TOWN_NASHVILLE, TOWN_PITTSBURGH, COULEUR_JAUNE, 4, 0);
    ajouter_pave(459,211,14);
    ajouter_pave(473,192,12);
    ajouter_pave(492,177,10);
    ajouter_pave(509,159,13);

    creation_route(80, TOWN_CHICAGO, TOWN_PITTSBURGH, COULEUR_MARRON, 3, 68);
    ajouter_pave(446,135,5);
    ajouter_pave(470,127,2);
    ajouter_pave(495,127,0);

    creation_route(81, TOWN_PITTSBURGH, TOWN_RALEIGH, COULEUR_LOCO, 2, 0);
    ajouter_pave(526,162,19);
    ajouter_pave(529,186,19);

    creation_route(82, TOWN_ATLANTA, TOWN_RALEIGH, COULEUR_LOCO, 2,  98);
    ajouter_pave(504,236,11);
    ajouter_pave(523,219,11);

    creation_route(83, TOWN_PITTSBURGH, TOWN_NEW_YORK, COULEUR_VERT, 2, 85);
    ajouter_pave(537,128,8);
    ajouter_pave(558,117,8);

    creation_route(84, TOWN_NEW_YORK, TOWN_BOSTON, COULEUR_JAUNE, 2, 89);
    ajouter_pave(583,92,13);
    ajouter_pave(595,71,13);

    creation_route(85, TOWN_PITTSBURGH, TOWN_NEW_YORK, COULEUR_BLANC, 2, 83);
    ajouter_pave(532,122,9);
    ajouter_pave(553,109,9);

    creation_route(86, TOWN_MONTREAL, TOWN_NEW_YORK, COULEUR_BLEU, 3, 0);
    ajouter_pave(566,88,19);
    ajouter_pave(563,64,20);
    ajouter_pave(559,39,19);

    creation_route(87, TOWN_MONTREAL, TOWN_BOSTON, COULEUR_LOCO, 2,  88);
    ajouter_pave(572,33,25);
    ajouter_pave(591,49,25);

    creation_route(88, TOWN_MONTREAL, TOWN_BOSTON, COULEUR_LOCO, 2,  87);
    ajouter_pave(578,25,25);
    ajouter_pave(597,41,25);

    creation_route(89, TOWN_NEW_YORK, TOWN_BOSTON, COULEUR_ROUGE, 2, 84);
    ajouter_pave(590,97,13);
    ajouter_pave(603,76,13);

    creation_route(90, TOWN_WASHINGTON, TOWN_NEW_YORK, COULEUR_MARRON, 2, 92);
    ajouter_pave(572,148,18);
    ajouter_pave(572,124,18);

    creation_route(91, TOWN_PITTSBURGH, TOWN_WASHINGTON, COULEUR_LOCO, 2,  0);
    ajouter_pave(536,147,28);
    ajouter_pave(558,159,28);

    creation_route(92, TOWN_WASHINGTON, TOWN_NEW_YORK, COULEUR_NOIR, 2, 90);
    ajouter_pave(582,148,18);
    ajouter_pave(581,124,18);

    creation_route(93, TOWN_RALEIGH, TOWN_WASHINGTON, COULEUR_LOCO, 2,  96);
    ajouter_pave(548,196,12);
    ajouter_pave(565,178,12);

    creation_route(94, TOWN_NASHVILLE, TOWN_RALEIGH, COULEUR_NOIR, 3, 0);
    ajouter_pave(478,217,9);
    ajouter_pave(498,207,4);
    ajouter_pave(522,205,0);

    creation_route(95, TOWN_NASHVILLE, TOWN_ATLANTA, COULEUR_LOCO, 1, 0);
    ajouter_pave(478,239,26);

    creation_route(96, TOWN_RALEIGH, TOWN_WASHINGTON, COULEUR_LOCO, 2,  93);
    ajouter_pave(555,202,12);
    ajouter_pave(572,184,12);

    creation_route(97, TOWN_ATLANTA, TOWN_CHARLESTON, COULEUR_LOCO, 2,  0);
    ajouter_pave(517,257,35);
    ajouter_pave(541,257,35);

    creation_route(98, TOWN_ATLANTA, TOWN_RALEIGH, COULEUR_LOCO, 2,  82);
    ajouter_pave(511,242,11);
    ajouter_pave(530,226,11);

    creation_route(99, TOWN_CHARLESTON, TOWN_RALEIGH, COULEUR_LOCO, 2,  0);
    ajouter_pave(554,223,26);
    ajouter_pave(565,239,15);

    creation_route(100, TOWN_CHARLESTON, TOWN_MIAMI, COULEUR_ROSE, 4, 0);
    ajouter_pave(559,271,19);
    ajouter_pave(562,295,19);
    ajouter_pave(567,320,21);
    ajouter_pave(576,343,22);
}

void done_routes() {
    free(paths);
    free(paves);
    free(pavesAAfficher);
}

void initJoueurs() {
    nbTotalJoueur = 0;
    joueurs = NULL;
}

void doneJoueurs() {
    free(joueurs);
    nbTotalJoueur = 0;
}

void pathfinder_reset() {
    for (uint8 i=0; i<36; i++) {
        pathfinder_ville[i].step = 0;
        pathfinder_ville[i].score = 0;
    }
}

void flagSet(uint16 flagActuel, uint8 numFlag) {
    uint8 col = trunc(numFlag / 8);
    uint8 bit = 1 << (numFlag % 8);
    flags[flagActuel][col] = flags[flagActuel][col] | bit;
}

bool isFlag(uint16 flagActuel, uint8 numFlag) {
    uint8 col = trunc(numFlag / 8);
    uint8 bit = 1 << (numFlag % 8);
    return (flags[flagActuel][col] & bit) == bit;
}

uint16 empilerFlags(uint16 flagActuel) {
    for (uint16 i=1; i<MAX_FLAG; i++) {
        if (flags[i][5] == 0) {
            for (uint8 j=0; j<5; j++) {
                flags[i][j] = flags[flagActuel][j];
            }
            flags[i][5] = 1;
            return i;
        }
    }

    return 0; // normalement pas possible
}

uint16 pathfinder_calculerCheminLePlusLong(uint8 numJoueur, uint8 numVille, uint16 score, uint16 flagActuel) {
    // bloquer le path
    flagSet(flagActuel, numVille);

    uint16 maxi = score;
    uint16 test = 0;
    for (uint8 i=1; i<MAX_PATH; i++) {
        if (paths[i].owner == numJoueur) {
            if ((paths[i].villeA == numVille) && !isFlag(flagActuel, paths[i].villeB)) {
                // empiler le flag
                uint16 nouveauFlag = empilerFlags(flagActuel);
                test = pathfinder_calculerCheminLePlusLong(numJoueur, paths[i].villeB, score + paths[i].distance, nouveauFlag);
                // dépiler le flag
                flags[nouveauFlag][5] = 0;
                if (test > maxi) {
                    maxi = test;
                }
            } else {
                if ((paths[i].villeB == numVille) && !isFlag(flagActuel, paths[i].villeA)) {
                    // empiler le flag
                    uint16 nouveauFlag = empilerFlags(flagActuel);
                    test = pathfinder_calculerCheminLePlusLong(numJoueur, paths[i].villeA, score + paths[i].distance, nouveauFlag);
                    // dépiler le flag
                    flags[nouveauFlag][5] = 0;
                    if (test > maxi) {
                        maxi = test;
                    }
                }
            }
        }
    }
    return maxi;
}

uint16 pathfinder_cheminLePlusLong(uint8 numJoueur) {
    // retourne la distance du plus long chemin pour le joueur courant
    uint16 maxi = 0;
    uint16 test = 0;

    for (uint8 i=0; i<36; i++) {
        if (joueurs[numJoueur].villesAccessibles[i]) {
            memset(flags, 0, sizeof(flags));
            // utiliser le flag[0]
            flags[0][5] = 1;
            test = pathfinder_calculerCheminLePlusLong(numJoueur, i, 0, 0);
            if (test > maxi) {
                maxi = test;
            }
        }
    }

    return maxi;
}

void pathfinder_propagerPourJoueur(uint8 numJoueur, uint8 start) {
    uint8 step = 1;
    pathfinder_ville[start].step = 1;
    pathfinder_ville[start].score = 0;
    bool continuer = true;
    while (continuer) {
        continuer = false;
        for (uint8 i=0; i<36; i++) {
            if (pathfinder_ville[i].step == step) {
                for (uint8 j=1; j<MAX_PATH; j++) {
                    if (paths[j].owner == numJoueur) {
                        uint8 score = pathfinder_ville[i].score + paths[j].distance;
                        if (paths[j].villeA == i) {
                            if ((pathfinder_ville[paths[j].villeB].step == 0) || (score < pathfinder_ville[paths[j].villeB].score)) {
                                pathfinder_ville[paths[j].villeB].score = score;
                                pathfinder_ville[paths[j].villeB].step = step + 1;
                                continuer = true;
                            }
                        } else {
                            if (paths[j].villeB == i) {
                                if ((pathfinder_ville[paths[j].villeA].step == 0) || (score < pathfinder_ville[paths[j].villeA].score)) {
                                    pathfinder_ville[paths[j].villeA].score = score;
                                    pathfinder_ville[paths[j].villeA].step = step + 1;
                                    continuer = true;
                                }
                            }
                        }
                    }
                }
            }
        }
        step++;

    }
    pathfinder_ville[start].step = 1;
    pathfinder_ville[start].score = 0;
}

bool estDisponible(uint8 numJoueur, uint8 numPath) {
    if (paths[numPath].owner > 0) {
        // déjà pris
        return false;
    }
    if ((paths[numPath].lien > 0) && (paths[paths[numPath].lien].owner > 0) && (nbTotalJoueur < 4)) {
        // seconde voie déjà prise
        return false;
    }
    if ((paths[numPath].lien > 0) && (paths[paths[numPath].lien].owner == numJoueur) && (nbTotalJoueur >= 4)) {
        // seconde voie déjà prise par ce joueur
        return false;
    }

    return true;
}

void pathfinder_propagerPourJoueurPlusCourt(uint8 numJoueur, uint8 start) {
    // si la route est libre on incremente le score
    // si le path est déjà revendiquée par le joueur on n'incrémente pas le score
    uint8 step = 1;
    uint8 score = 0;
    pathfinder_ville[start].step = 1;
    pathfinder_ville[start].score = 0;
    bool continuer = true;
    while (continuer) {
        continuer = false;
        for (uint8 i=0; i<36; i++) {
            if (pathfinder_ville[i].step == step) {
                for (uint8 j=1; j<MAX_PATH; j++) {
                    if (estDisponible(numJoueur, j) || (paths[j].owner == numJoueur)) {
                        // si le joueur a ce path alors le score = score de la ville A, sinon on ajoute la distance du path
                        score = pathfinder_ville[i].score;
                        if (paths[j].owner != numJoueur) {
                            score += paths[j].distance;
                        }

                        // on peut utiliser ce path
                        if (paths[j].villeA == i) {
                            // si la ville B n'a pas déjà été traitée, ou si elle a un score plus élevé
                            if ((pathfinder_ville[paths[j].villeB].step == 0) || (score < pathfinder_ville[paths[j].villeB].score)) {
                                pathfinder_ville[paths[j].villeB].score = score;
                                pathfinder_ville[paths[j].villeB].step = step + 1;
                                continuer = true;
                            }
                        } else {
                            if (paths[j].villeB == i) {
                                // si la ville A n'a pas déjà été traitée, ou si elle a un score plus élevé
                                if ((pathfinder_ville[paths[j].villeA].step == 0) || (score < pathfinder_ville[paths[j].villeA].score)) {
                                    pathfinder_ville[paths[j].villeA].score = score;
                                    pathfinder_ville[paths[j].villeA].step = step + 1;
                                    continuer = true;
                                }
                            }
                        }
                    }
                }
            }
        }
        step++;
    }
    pathfinder_ville[start].step = 1;
    pathfinder_ville[start].score = 0;
}

uint8 pathfinder_distanceRestante(uint8 numJoueur, uint8 numMission) {
    // retourne 200 si la ville est inaccessible, sinon la distance mini pour l'atteindre
    pathfinder_reset();
    pathfinder_propagerPourJoueurPlusCourt(numJoueur, missions[numMission].villeA);
    if (pathfinder_ville[missions[numMission].villeB].step == 0) {
        return 200;
    }
    return pathfinder_ville[missions[numMission].villeB].score;
}

bool testerMissionRealisse(uint8 numJoueur, uint8 numMission) {
    // si une des deux villes n'est pas accessible : pas réalisé !
    if (!joueurs[numJoueur].villesAccessibles[missions[numMission].villeA] || !joueurs[numJoueur].villesAccessibles[missions[numMission].villeB]) {
        return false;
    }

    pathfinder_reset();
    pathfinder_propagerPourJoueur(numJoueur, missions[numMission].villeA);
    bool resultat = pathfinder_ville[missions[numMission].villeB].score > 0;
    return resultat;
}

bool calculerPathFinderLePlusCourt(uint8 numJoueur, uint8 numMission) {
    pathfinder_reset();
    pathfinder_propagerPourJoueurPlusCourt(numJoueur, missions[numMission].villeA);
    bool resultat = pathfinder_ville[missions[numMission].villeB].score > 0;
    if (resultat) {
        // ajouter 2 points pour chaque route du path le plus court
        for (uint8 i=0; i<36; i++) {
            pathfinder_ville[i].step = 0;
        }
        uint8 step = 1;
        uint8 score = 0;
        pathfinder_ville[missions[numMission].villeB].step = 1;
        while (pathfinder_ville[missions[numMission].villeA].step == 0) {
            for (uint8 i=0; i<36; i++) {
                if (pathfinder_ville[i].step == step) {
                    for (uint8 j=1; j<MAX_PATH; j++) {
                        if (paths[j].villeA == i) {
                            // si la ville B a un score de score[A] - distance du path
                            score = pathfinder_ville[i].score;
                            if (paths[j].owner != numJoueur) {
                                score -= paths[j].distance;
                            }
                            if (pathfinder_ville[paths[j].villeB].score == score) {
                                pathfinder_ville[paths[j].villeB].step = step + 1;
                                paths[j].IAscore += IASCORE_DANS_PATHFINDER;
                            }
                        } else {
                            if (paths[j].villeB == i) {
                                // si la ville A a un score de score[B] - distance du path
                                score = pathfinder_ville[i].score;
                                if (paths[j].owner != numJoueur) {
                                    score -= paths[j].distance;
                                }
                                if (pathfinder_ville[paths[j].villeA].score == score) {
                                    pathfinder_ville[paths[j].villeA].step = step + 1;
                                    paths[j].IAscore += IASCORE_DANS_PATHFINDER;
                                }
                            }
                        }
                    }
                }
            }
            step++;
        }

        // retirer tous les paths déjà pris
        for (uint8 j=1; j<MAX_PATH; j++) {
            if (paths[j].owner > 0) {
                paths[j].IAscore = 0;
            }
        }
    }
    return resultat;
}

uint8 nbPathManquant(uint8 numJoueur, uint8 numMission) {
    pathfinder_reset();
    pathfinder_propagerPourJoueurPlusCourt(numJoueur, missions[numMission].villeA);
    uint8 resultat = 200;

    if (pathfinder_ville[missions[numMission].villeB].score > 0) {
        resultat = 0;

        // on dépile le path depuis B jusqu'à A
        // ajouter 2 points pour chaque route du path le plus court
        for (uint8 i=0; i<36; i++) {
            pathfinder_ville[i].step = 0;
        }
        uint8 step = 1;
        uint8 score = 0;
        pathfinder_ville[missions[numMission].villeB].step = 1;
        while (pathfinder_ville[missions[numMission].villeA].step == 0) {
            for (uint8 i=0; i<36; i++) {
                if (pathfinder_ville[i].step == step) {
                    for (uint8 j=1; j<MAX_PATH; j++) {
                        if (paths[j].villeA == i) {
                            // si la ville B a un score de score[A] - distance du path
                            score = pathfinder_ville[i].score;
                            if (paths[j].owner != numJoueur) {
                                score -= paths[j].distance;
                            }
                            if (pathfinder_ville[paths[j].villeB].score == score) {
                                pathfinder_ville[paths[j].villeB].step = step + 1;
                                if (paths[j].owner != numJoueur) {
                                    resultat++;
                                }
                            }
                        } else {
                            if (paths[j].villeB == i) {
                                // si la ville A a un score de score[B] - distance du path
                                score = pathfinder_ville[i].score;
                                if (paths[j].owner != numJoueur) {
                                    score -= paths[j].distance;
                                }
                                if (pathfinder_ville[paths[j].villeA].score == score) {
                                    pathfinder_ville[paths[j].villeA].step = step + 1;
                                    if (paths[j].owner != numJoueur) {
                                        resultat++;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            step++;
        }
    }
    return resultat;
}

void afficherTicketDestination(uint8 numJoueur, uint8 numMission, uint8 taille, uint16 ouX, uint16 ouY, bool ombre, bool faceCachee, bool realisee) {

    uint8 decalPts = 0;
    switch (missions[numMission].pts) {
    case 5:
        decalPts = 1;
        break;
    case 6:
        decalPts = 2;
        break;
    case 7:
        decalPts = 3;
        break;
    case 8:
        decalPts = 4;
        break;
    case 9:
        decalPts = 5;
        break;
    case 10:
        decalPts = 6;
        break;
    case 11:
        decalPts = 7;
        break;
    case 12:
        decalPts = 8;
        break;
    case 13:
        decalPts = 9;
        break;
    case 16:
        decalPts = 10;
        break;
    case 17:
        decalPts = 11;
        break;
    case 20:
        decalPts = 12;
        break;
    case 21:
        decalPts = 13;
        break;
    case 22:
        decalPts = 14;
        break;
    }

    switch (taille) {
    case 60:
        if (faceCachee) {
            if (ombre) {
                afficherGrafx_ram(RAM_CARD_SHADOW60, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }
            afficherGrafx_ram(RAM_MIS_BA_60, ouX, ouY, SCREEN_WORKING, 0xFFFF);
        } else {
            if (realisee) {
                if (ombre) {
                    afficherGrafx_ram(RAM_TICKET_DONE_SHADOW_60, ouX, ouY, SCREEN_WORKING, 0xFFFF); // à revoir le décalage de l'ombre
                }
                afficherGrafx_ramMask(RAM_MIS_FOND_60, RAM_MASK_TICKET_DONE_60, ouX, ouY, SCREEN_WORKING);
            } else {
                if (ombre) {
                    afficherGrafx_ram(RAM_CARD_SHADOW60, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
                afficherGrafx_ram(RAM_MIS_FOND_60, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }

            afficherGrafx_ram(RAM_MIS_01_60 + numMission, ouX+3, ouY+4, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_PTS_60_4 + decalPts, ouX+43, ouY+23, SCREEN_WORKING, 0xFFFF);
            // ne pas afficher san francisco et portland si réalisé.
            if (!realisee || afficherSiRealise[missions[numMission].villeA]) {
                if (joueurs[numJoueur].villesAccessibles[missions[numMission].villeA]) {
                    afficherGrafx_ram(RAM_VILLE_OK_60, ouX+spotX60[missions[numMission].villeA], ouY+spotY60[missions[numMission].villeA], SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_VILLE_KO_60, ouX+spotX60[missions[numMission].villeA], ouY+spotY60[missions[numMission].villeA], SCREEN_WORKING, 0xFFFF);
                }
            }
            if (!realisee || afficherSiRealise[missions[numMission].villeB]) {
                if (joueurs[numJoueur].villesAccessibles[missions[numMission].villeB]) {
                    afficherGrafx_ram(RAM_VILLE_OK_60, ouX+spotX60[missions[numMission].villeB], ouY+spotY60[missions[numMission].villeB], SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_VILLE_KO_60, ouX+spotX60[missions[numMission].villeB], ouY+spotY60[missions[numMission].villeB], SCREEN_WORKING, 0xFFFF);
                }
            }

            if (realisee) {
                afficherGrafx_ram(RAM_TICKET_DONE_60, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }
        }
        break;

    case 80:
        if (faceCachee) {
            if (ombre) {
                afficherGrafx_ram(RAM_CARD_SHADOW80, ouX-2, ouY-2, SCREEN_WORKING, 0xFFFF);
            }
            afficherGrafx_ram(RAM_MIS_BA_80, ouX, ouY, SCREEN_WORKING, 0xFFFF);
        } else {
            if (realisee) {
                if (ombre) {
                    afficherGrafx_ram(RAM_TICKET_DONE_SHADOW_80, ouX-2, ouY-2, SCREEN_WORKING, 0xFFFF); // à revoir le décalage de l'ombre
                }
                afficherGrafx_ramMask(RAM_MIS_FOND_80, RAM_MASK_TICKET_DONE_80, ouX, ouY, SCREEN_WORKING);
            } else {
                if (ombre) {
                    afficherGrafx_ram(RAM_CARD_SHADOW80, ouX-2, ouY-2, SCREEN_WORKING, 0xFFFF);
                }
                afficherGrafx_ram(RAM_MIS_FOND_80, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }

            afficherGrafx_ram(RAM_MIS_01_80 + numMission, ouX+4, ouY+5, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_PTS_80_4 + decalPts, ouX+58, ouY+31, SCREEN_WORKING, 0xFFFF);
            // ne pas afficher san francisco et portland si réalisé.
            if (!realisee || afficherSiRealise[missions[numMission].villeA]) {
                if (joueurs[numJoueur].villesAccessibles[missions[numMission].villeA]) {
                    afficherGrafx_ram(RAM_VILLE_OK_80, ouX+spotX80[missions[numMission].villeA], ouY+spotY80[missions[numMission].villeA], SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_VILLE_KO_80, ouX+spotX80[missions[numMission].villeA], ouY+spotY80[missions[numMission].villeA], SCREEN_WORKING, 0xFFFF);
                }
            }
            if (!realisee || afficherSiRealise[missions[numMission].villeB]) {
                if (joueurs[numJoueur].villesAccessibles[missions[numMission].villeB]) {
                    afficherGrafx_ram(RAM_VILLE_OK_80, ouX+spotX80[missions[numMission].villeB], ouY+spotY80[missions[numMission].villeB], SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_VILLE_KO_80, ouX+spotX80[missions[numMission].villeB], ouY+spotY80[missions[numMission].villeB], SCREEN_WORKING, 0xFFFF);
                }
            }

            if (realisee) {
                afficherGrafx_ram(RAM_TICKET_DONE_80, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }
        }
        break;

    case 100:
        if (faceCachee) {
            if (ombre) {
                afficherGrafx_ram(RAM_CARD_SHADOW, ouX-4, ouY-4, SCREEN_WORKING, 0xFFFF);
            }
            afficherGrafx_file(FILE_MIS_BA_NO, ouX, ouY, SCREEN_WORKING, 0xFFFF);
        } else {
            if (realisee) {
                if (ombre) {
                    afficherGrafx_ram(RAM_TICKET_DONE_SHADOW_NO, ouX-9, ouY-9, SCREEN_WORKING, 0xFFFF); // à revoir le décalage de l'ombre
                }
                afficherGrafx_ramMask(RAM_MIS_FOND_NO, RAM_MASK_TICKET_DONE_NO, ouX, ouY, SCREEN_WORKING);
            } else {
                if (ombre) {
                    afficherGrafx_ram(RAM_CARD_SHADOW, ouX-4, ouY-4, SCREEN_WORKING, 0xFFFF);
                }
                afficherGrafx_ram(RAM_MIS_FOND_NO, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }

            afficherGrafx_ram(RAM_MIS_01_NO + numMission, ouX+12, ouY+17, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_PTS_NO_4 + decalPts, ouX+189, ouY+104, SCREEN_WORKING, 0xFFFF);
            // ne pas afficher san francisco et portland si réalisé.
            if (!realisee || afficherSiRealise[missions[numMission].villeA]) {
                if (joueurs[numJoueur].villesAccessibles[missions[numMission].villeA]) {
                    afficherGrafx_ram(RAM_VILLE_OK_NO, ouX+spotXno[missions[numMission].villeA], ouY+spotYno[missions[numMission].villeA], SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_VILLE_KO_NO, ouX+spotXno[missions[numMission].villeA], ouY+spotYno[missions[numMission].villeA], SCREEN_WORKING, 0xFFFF);
                }
            }
            if (!realisee || afficherSiRealise[missions[numMission].villeB]) {
                if (joueurs[numJoueur].villesAccessibles[missions[numMission].villeB]) {
                    afficherGrafx_ram(RAM_VILLE_OK_NO, ouX+spotXno[missions[numMission].villeB], ouY+spotYno[missions[numMission].villeB], SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_VILLE_KO_NO, ouX+spotXno[missions[numMission].villeB], ouY+spotYno[missions[numMission].villeB], SCREEN_WORKING, 0xFFFF);
                }
            }

            if (realisee) {
                afficherGrafx_ram(RAM_TICKET_DONE_NO, ouX, ouY, SCREEN_WORKING, 0xFFFF);
            }
        }
        break;
    }
}

void afficherAnimationMissionOk(uint8 numJoueur, uint8 numMission) {
    empilerBackScr();
    afficherTicketDestination(numJoueur, numMission, 100, 35, 40, true, false, false);
    afficherBackScreen();
    // attendre un peu
    for (uint16 i=0; i<(2 * CPT_ANIMATION); i++) {
        afficherBackScreen();
    }
    depilerBackScr();

    // afficher la coche verte
    afficherTicketDestination(numJoueur, numMission, 100, 35, 40, true, false, true);

    // attendre un peu plus
    for (uint16 i=0; i<(4 * CPT_ANIMATION); i++) {
        afficherBackScreen();
    }
}

void revendiquerRoute(uint8 numPath, uint8 numJoueur) {
    joueurs[numJoueur].lastAction = 0xF000;
    lastPath[numJoueur] = numPath;
    paths[numPath].owner = numJoueur;
    joueurs[numJoueur].nbWagons -= paths[numPath].distance;
    joueurs[numJoueur].villesAccessibles[paths[numPath].villeA] = true;
    joueurs[numJoueur].villesAccessibles[paths[numPath].villeB] = true;
    switch (paths[numPath].distance) {
    case 1:
        joueurs[numJoueur].points += 1;
        break;
    case 2:
        joueurs[numJoueur].points += 2;
        break;
    case 3:
        joueurs[numJoueur].points += 4;
        break;
    case 4:
        joueurs[numJoueur].points += 7;
        break;
    case 5:
        joueurs[numJoueur].points += 10;
        break;
    case 6:
        joueurs[numJoueur].points += 15;
        break;
    }

    // faire une animation : les wagonnets du bas vers leurs positions sur la carte
    int destX[6];
    int destY[6];
    uint8 wag[6];
    uint8 sha[6];

    for (uint8 j=0; j<paths[numPath].distance; j++) {
        wag[j] = joueurs[numJoueur].couleur + paves[paths[numPath].idxPave[j]].rot;
        sha[j] = FILE_WAGON_SHADOW_0_0 + paves[paths[numPath].idxPave[j]].rot;
        destX[j] = paves[paths[numPath].idxPave[j]].x - xCarte;
        destY[j] = paves[paths[numPath].idxPave[j]].y - yCarte;
    }

    // effacer le curseur

    // le fond : la carte
    afficherCarte(xCarte,yCarte,284,222);
    // la carte foncée à droite
    afficherCarteSombre(284,0,319,222,xCarte,yCarte);
    // le bas ?
    afficherBas(numJoueur, 0);
    // conserver le fond
    empilerBackScr();
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        if (i != 0) {
            depilerBackScr();
        }

        // afficher les ombres
        for (uint8 j=0; j<paths[numPath].distance; j++) {
            uint16 ouX = 145 - trunc(((145 - destX[j]) * i) / CPT_ANIMATION);
            uint16 ouY = 240 - trunc(((240 - destY[j]) * i) / CPT_ANIMATION);
            afficherGrafx_file(sha[j], ouX, ouY, SCREEN_WORKING, 0xFFFF);
        }
        // afficher les wagons
        for (uint8 j=0; j<paths[numPath].distance; j++) {
            uint16 ouX = 145 - trunc(((145 - destX[j]) * i) / CPT_ANIMATION);
            uint16 ouY = 240 - trunc(((240 - destY[j]) * i) / CPT_ANIMATION);
            afficherGrafx_file(wag[j], ouX, ouY, SCREEN_WORKING, 0xFFFF);
        }

        afficherBackScreen();
    }

    for (uint8 i=0; i<paths[numPath].distance; i++) {
        paves[paths[numPath].idxPave[i]].owner = numJoueur;
        ajouterPaveAAfficher(paths[numPath].idxPave[i]);
    }
    preparerUsMap();

    // tester les routes possibles du joueur
    for (uint8 i=0; i < joueurs[numJoueur].nbCartesMission; i++) {
        if (!joueurs[numJoueur].missionsRealisee[i]) {
            joueurs[numJoueur].missionsRealisee[i] = testerMissionRealisse(numJoueur, joueurs[numJoueur].lstCartesMission[i]);
            if (joueurs[numJoueur].humain && joueurs[numJoueur].missionsRealisee[i]) {
                afficherAnimationMissionOk(numJoueur, joueurs[numJoueur].lstCartesMission[i]);
            }
        }
    }
}

void animationPaiementRoute(uint8 numJoueur, uint8 distance) {
    // se baser sur lastPaiement[numJoueur]

    // cartes wagons du bas vers le centre
    uint16 destX[7][6];
    for (uint8 i = 0; i < 6; i++) {
        for (uint8 j = 0; j < 6; j++) {
            destX[1][j] = 102;
            destX[2][j] = 72 + j * 60;
            destX[3][j] = 47 + j * 55;
            destX[4][j] = 27 + j * 50;
            destX[5][j] = 12 + j * 45;
            destX[6][j] = 2 + j * 40;
        }
    }
    empilerBackScr();
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        if (i != 0) {
            depilerBackScr();
        }
        uint8 ouY = 240 - trunc(((240 - 94) * i) / CPT_ANIMATION);
        for (uint8 j = 0; j < distance; j++) {
            uint16 ouX = 120 - trunc(((120 - destX[distance][j]) * i) / CPT_ANIMATION);
            afficherGrafx_ram(RAM_CARD_SHADOW80, ouX-2, ouY-2, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_WAG_LOCO_80 + lastPaiement[numJoueur][j], ouX, ouY, SCREEN_WORKING, 0xFFFF);
        }
        afficherBackScreen();
    }

    // attendre un peu
    for (uint16 i=0; i<(2 * CPT_ANIMATION); i++) {
        afficherBackScreen();
    }

    // puis du centre vers la défausse
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        depilerBackScr();

        // de destX,94 vers 320,137
        uint8 ouY = 94 - trunc(((94 - 137) * i) / CPT_ANIMATION);
        for (uint8 j = 0; j < distance; j++) {
            uint16 ouX = destX[distance][j] - trunc(((destX[distance][j] - 320) * i) / CPT_ANIMATION);
            afficherGrafx_ram(RAM_CARD_SHADOW60, ouX-2, ouY-2, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_WAG_BACK_60, ouX, ouY, SCREEN_WORKING, 0xFFFF);
        }
        afficherBackScreen();
    }
    depilerBackScr();
}

void payerRoute(uint8 numPath, uint8 selectionChoix, uint8 numJoueur) {
    for (uint8 i=0; i<paths[numPath].distance; i++) {
        joueurDefausseCarteWagon(numJoueur, paiementPossible[selectionChoix][i]);
        lastPaiement[numJoueur][i] = paiementPossible[selectionChoix][i];
    }

    // Animer le paiement des cartes wagons
    animationPaiementRoute(numJoueur, paths[numPath].distance);

    // tester ici la fin du jeu : s'il ne reste plus beaucoup de wagon au joueur.
    if (joueurs[numJoueur].nbWagons < 3) {
        if (tourRestant == 0) {
            tourRestant = nbTotalJoueur + 1;
        }
    }
}

void preparerUsMap() {
    // recopie shadows dans usmap
    effacerUsMap();

    // afficher les wagons
    for (uint16 i=0; i<nbPaveAAfficher; i++) {
        uint16 wagon = joueurs[paves[pavesAAfficher[i]].owner].couleur + paves[pavesAAfficher[i]].rot;
        afficherGrafx_file(wagon, paves[pavesAAfficher[i]].x, paves[pavesAAfficher[i]].y, SCREEN_WAGON, 0xFFFF);
    }

    // recopier usmap dans selection
    effacerMapSelection();
}

void selectionnerPath(uint8 numPath, uint16 couleur) {
    // la ville A
    uint16 x = villeX[paths[numPath].villeA];
    uint16 y = villeY[paths[numPath].villeA];
    afficherGrafx_ram(couleur, x,y, SCREEN_SELECT, 0xFFFF);

    // la ville B
    x = villeX[paths[numPath].villeB];
    y = villeY[paths[numPath].villeB];
    afficherGrafx_ram(couleur, x,y, SCREEN_SELECT, 0xFFFF);
}

void selectionnerMission(uint8 numMission, uint16 couleur) {
    // la ville A
    uint16 x = villeX[missions[numMission].villeA];
    uint16 y = villeY[missions[numMission].villeA];
    afficherGrafx_ram(couleur, x,y, SCREEN_SELECT, 0xFFFF);

    // la ville B
    x = villeX[missions[numMission].villeB];
    y = villeY[missions[numMission].villeB];
    afficherGrafx_ram(couleur, x,y, SCREEN_SELECT, 0xFFFF);
}

void melangerPiocheWagon() {
    for (uint8 i=0; i<nbCartesWagonPioche; i++) {
        uint8 j = rand() % nbCartesWagonPioche;
        // permuter i et j
        uint8 couleur = piocheCartesWagon[i];
        piocheCartesWagon[i] = piocheCartesWagon[j];
        piocheCartesWagon[j] = couleur;
    }
}

bool troisLocoRetournees() {
    // cas particulier : si la pioche est vide : on ne va pas boucler avec les 3 locos
    if (nbCartesWagonPioche == 0) {
        return false;
    }

    // ou s'il ne reste plus assez de cartes
    uint8 nb = 0;
    for (uint8 i=0; i<nbCartesWagonPioche; i++) {
        if (piocheCartesWagon[i] != COULEUR_LOCO) {
            nb++;
        }
    }
    for (uint8 i=0; i<nbCartesWagonPioche; i++) {
        if (piocheCartesWagon[i] != COULEUR_LOCO) {
            nb++;
        }
    }
    for(uint8 i=0; i<nbCartesWagonDefausse; i++) {
        if (piocheCartesWagon[i] != COULEUR_LOCO) {
            nb++;
        }
    }
    if (nb < 3) {
        return false;
    }

    nb = 0;
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] == COULEUR_LOCO) {
            nb++;
        }
    }
    return nb >= 3;
}

void melangerPiocheMission() {
    for (uint8 i=0; i<nbCartesMissionPioche; i++) {
        uint8 j = rand() % nbCartesMissionPioche;
        // permuter i et j
        uint8 mission = piocheCartesMission[i];
        piocheCartesMission[i] = piocheCartesMission[j];
        piocheCartesMission[j] = mission;
    }
}

void ajouterCarteMission(uint8 villeA, uint8 villeB, uint8 pts) {
    missions[nbCartesMissionPioche].villeA = villeA;
    missions[nbCartesMissionPioche].villeB = villeB;
    missions[nbCartesMissionPioche].pts = pts;
    piocheCartesMission[nbCartesMissionPioche] = nbCartesMissionPioche;
    nbCartesMissionPioche++;
}

void ajouterPaquet() {
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_BLANC;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_NOIR;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_ROSE;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_VERT;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_LOCO;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_MARRON;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_ROUGE;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_JAUNE;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_BLEU;
}

void initCartes() {
    nbCartesWagonDefausse = 0;
    nbCartesWagonPioche = 0;
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_LOCO;
    for (uint8 i=0; i<12; i++) {
        ajouterPaquet();
    }
    piocheCartesWagon[nbCartesWagonPioche++] = COULEUR_LOCO;
    melangerPiocheWagon();

    nbChoixCarteMission = 0;

    uint8 villeA;
    uint8 villeB;
    uint8 pts;
    nbCartesMissionPioche = 0;
    for (uint8 i=0; i<30; i++) {
        switch(i) {
        case 0:
            villeA = TOWN_BOSTON;
            villeB = TOWN_MIAMI;
            pts = PTS_MIS_01;
            break;
        case 1:
            villeA = TOWN_CALGARY;
            villeB = TOWN_PHOENIX;
            pts = PTS_MIS_02;
            break;
        case 2:
            villeA = TOWN_CALGARY;
            villeB = TOWN_SALT_LAKE_CITY;
            pts = PTS_MIS_03;
            break;
        case 3:
            villeA = TOWN_CHICAGO;
            villeB = TOWN_NEW_ORLEANS;
            pts = PTS_MIS_04;
            break;
        case 4:
            villeA = TOWN_CHICAGO;
            villeB = TOWN_SANTA_FE;
            pts = PTS_MIS_05;
            break;
        case 5:
            villeA = TOWN_DALLAS;
            villeB = TOWN_NEW_YORK;
            pts = PTS_MIS_06;
            break;
        case 6:
            villeA = TOWN_DENVER;
            villeB = TOWN_EL_PASO;
            pts = PTS_MIS_07;
            break;
        case 7:
            villeA = TOWN_DENVER;
            villeB = TOWN_PITTSBURGH;
            pts = PTS_MIS_08;
            break;
        case 8:
            villeA = TOWN_DULUTH;
            villeB = TOWN_EL_PASO;
            pts = PTS_MIS_09;
            break;
        case 9:
            villeA = TOWN_DULUTH;
            villeB = TOWN_HOUSTON;
            pts = PTS_MIS_10;
            break;
        case 10:
            villeA = TOWN_HELENA;
            villeB = TOWN_LOS_ANGELES;
            pts = PTS_MIS_11;
            break;
        case 11:
            villeA = TOWN_KANSAS_CITY;
            villeB = TOWN_HOUSTON;
            pts = PTS_MIS_12;
            break;
        case 12:
            villeA = TOWN_LOS_ANGELES;
            villeB = TOWN_CHICAGO;
            pts = PTS_MIS_13;
            break;
        case 13:
            villeA = TOWN_LOS_ANGELES;
            villeB = TOWN_MIAMI;
            pts = PTS_MIS_14;
            break;
        case 14:
            villeA = TOWN_LOS_ANGELES;
            villeB = TOWN_NEW_YORK;
            pts = PTS_MIS_15;
            break;
        case 15:
            villeA = TOWN_MONTREAL;
            villeB = TOWN_ATLANTA;
            pts = PTS_MIS_16;
            break;
        case 16:
            villeA = TOWN_MONTREAL;
            villeB = TOWN_NEW_ORLEANS;
            pts = PTS_MIS_17;
            break;
        case 17:
            villeA = TOWN_NEW_YORK;
            villeB = TOWN_ATLANTA;
            pts = PTS_MIS_18;
            break;
        case 18:
            villeA = TOWN_PORTLAND;
            villeB = TOWN_NASHVILLE;
            pts = PTS_MIS_19;
            break;
        case 19:
            villeA = TOWN_PORTLAND;
            villeB = TOWN_PHOENIX;
            pts = PTS_MIS_20;
            break;
        case 20:
            villeA = TOWN_SAN_FRANCISCO;
            villeB = TOWN_ATLANTA;
            pts = PTS_MIS_21;
            break;
        case 21:
            villeA = TOWN_SAULT_ST_MARIE;
            villeB = TOWN_NASHVILLE;
            pts = PTS_MIS_22;
            break;
        case 22:
            villeA = TOWN_SAULT_ST_MARIE;
            villeB = TOWN_OKLAHOMA_CITY;
            pts = PTS_MIS_23;
            break;
        case 23:
            villeA = TOWN_SEATTLE;
            villeB = TOWN_LOS_ANGELES;
            pts = PTS_MIS_24;
            break;
        case 24:
            villeA = TOWN_SEATTLE;
            villeB = TOWN_NEW_YORK;
            pts = PTS_MIS_25;
            break;
        case 25:
            villeA = TOWN_TORONTO;
            villeB = TOWN_MIAMI;
            pts = PTS_MIS_26;
            break;
        case 26:
            villeA = TOWN_VANCOUVER;
            villeB = TOWN_MONTREAL;
            pts = PTS_MIS_27;
            break;
        case 27:
            villeA = TOWN_VANCOUVER;
            villeB = TOWN_SANTA_FE;
            pts = PTS_MIS_28;
            break;
        case 28:
            villeA = TOWN_WINNIPEG;
            villeB = TOWN_HOUSTON;
            pts = PTS_MIS_29;
            break;
        case 29:
            villeA = TOWN_WINNIPEG;
            villeB = TOWN_LITTLE_ROCK;
            pts = PTS_MIS_30;
            break;
        }
        ajouterCarteMission(villeA, villeB, pts);
    }
    melangerPiocheMission();
}

bool isPiocheWagonVide() {
    return nbCartesWagonPioche == 0;
}

void refairePiocheWagon() {
    for(uint8 i=0; i<nbCartesWagonDefausse; i++) {
        piocheCartesWagon[nbCartesWagonPioche++] = defausseCartesWagon[i];
    }
    nbCartesWagonDefausse = 0;
    melangerPiocheWagon();
}

void joueurPiocheCarteWagon(uint8 numJoueur) {
    if (nbCartesWagonPioche > 0) {
        nbCartesWagonPioche--;
        uint8 carteWagon = piocheCartesWagon[nbCartesWagonPioche];

        joueurs[numJoueur].lstCartesWagon[joueurs[numJoueur].nbCartesWagon++] = carteWagon;
        joueurs[numJoueur].nbCartes[carteWagon]++;

    }
    if (nbCartesWagonPioche == 0) {
        refairePiocheWagon();
    }
}

void piochePiocheCarteWagon(uint8 num) {
    // si la pioche est vide : on la refait
    if (nbCartesWagonPioche == 0) {
        refairePiocheWagon();
    }

    // s'il reste au moins une carte on la prend
    if (nbCartesWagonPioche > 0) {
        nbCartesWagonPioche--;
        choixCartesWagon[num] = piocheCartesWagon[nbCartesWagonPioche];
    } else {
        // plus de cartes dans la pioche...
        choixCartesWagon[num] = 0xFF;
    }
}

void joueurDefausseCarteWagon(uint8 numJoueur, uint8 couleur) {
    for (uint8 i=0; i<joueurs[numJoueur].nbCartesWagon; i++) {
        if (joueurs[numJoueur].lstCartesWagon[i] == couleur) {
            defausseCartesWagon[nbCartesWagonDefausse++] = couleur;
            for (uint8 j=i; j<joueurs[numJoueur].nbCartesWagon; j++) {
                joueurs[numJoueur].lstCartesWagon[j] = joueurs[numJoueur].lstCartesWagon[j+1];
            }
            joueurs[numJoueur].nbCartesWagon--;
            joueurs[numJoueur].nbCartes[couleur]--;
            break;
        }
    }
}

void testerDerniereMissionPiochee(uint8 numJoueur) {
    uint8 derniereCarte = joueurs[numJoueur].nbCartesMission-1;
    uint8 numMission = joueurs[numJoueur].lstCartesMission[derniereCarte];
    joueurs[numJoueur].missionsRealisee[derniereCarte] = testerMissionRealisse(numJoueur, numMission);
}

void joueurPiocheCarteMission(uint8 numJoueur) {
    if (nbCartesMissionPioche > 0) {
        nbCartesMissionPioche--;
        joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].nbCartesMission++] = piocheCartesMission[nbCartesMissionPioche];
        testerDerniereMissionPiochee(numJoueur);
    }
}

void defausserPiocheWagon() {
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            defausseCartesWagon[nbCartesWagonDefausse++] = choixCartesWagon[i];
        }
    }
}

void initPioches() {
    for (uint8 i=0; i<5; i++) {
        piochePiocheCarteWagon(i);
    }
    while (troisLocoRetournees()) {
        defausserPiocheWagon();
        refairePiocheWagon();
        for (uint8 i=0; i<5; i++) {
            piochePiocheCarteWagon(i);
        }
    }

    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        for (uint8 j=0; j<4; j++) {
            joueurPiocheCarteWagon(i);
        }
    }
}


void piocherChoixCarteMission() {
    if (nbCartesMissionPioche > 0) {
        nbCartesMissionPioche--;
        choixCarteMission[nbChoixCarteMission++] = piocheCartesMission[nbCartesMissionPioche];
    }
}

void afficherZoomCarte(uint16 numCarte) {
    afficherGrafx_ram(RAM_CARD_SHADOW, 31, 36, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_file(numCarte, 35, 40, SCREEN_WORKING, 0xFFFF);
    afficherBackScreen();
    while (isKeyPressed(KEY_NSPIRE_TAB));
}

bool isMissionRealise(uint8 numJoueur, uint8 numMission) {
    for (uint8 i=0; i<joueurs[numJoueur].nbCartesMission; i++) {
        if (joueurs[numJoueur].lstCartesMission[i] == numMission) {
            return joueurs[numJoueur].missionsRealisee[i];
        }
    }
    return false;
}

void afficherZoomCarteMission(uint8 numJoueur, uint16 numCarte, bool realise) {
    afficherTicketDestination(numJoueur, numCarte, 100, 35, 40, true, !joueurs[numJoueur].humain, realise);
    afficherBackScreen();
    while (isKeyPressed(KEY_NSPIRE_TAB));
}

bool scrollerUp() {
    if (yCarte < 0) {
        yCarte = 0;
        return true;
    }
    if (yCarte >= DELTA_SCROLL) {
        yCarte -= DELTA_SCROLL;
        return true;
    }
    if (yCarte > 0) {
        yCarte = 0;
        return true;
    }
    return false;
}

bool scrollerRight() {
    if (xCarte > MAX_CARTE_X) {
        xCarte = MAX_CARTE_X;
        return true;
    }
    if (xCarte <= MAX_CARTE_X - DELTA_SCROLL) {
        xCarte += DELTA_SCROLL;
        return true;
    }
    if ((xCarte > MAX_CARTE_X - DELTA_SCROLL) && (xCarte < MAX_CARTE_X)) {
        xCarte = MAX_CARTE_X;
        return true;
    }
    return false;
}

bool scrollerDown() {
    if (yCarte > MAX_CARTE_Y) {
        yCarte = MAX_CARTE_Y;
        return true;
    }
    if (yCarte <= MAX_CARTE_Y - DELTA_SCROLL) {
        yCarte += DELTA_SCROLL;
        return true;
    }
    if ((yCarte > MAX_CARTE_Y - DELTA_SCROLL) && (yCarte < MAX_CARTE_Y)) {
        yCarte = MAX_CARTE_Y;
        return true;
    }
    return false;
}

bool scrollerLeft() {
    if (xCarte < 0) {
        xCarte = 0;
        return true;
    }
    if (xCarte >= DELTA_SCROLL) {
        xCarte -= DELTA_SCROLL;
        return true;
    }
    if (xCarte > 0) {
        xCarte = 0;
        return true;
    }
    return false;
}

void afficherBas(uint8 numJoueur, uint8 modeAffichage) {
    // gérer mode : mini wagon, missions, paiement
    switch (modeAffichage) {
    case 0:
        // les wagons
        if (joueurs[numJoueur].humain) {
            uint16 ouX = 16;

            afficherGrafx_ram(RAM_UI_HUMAN + joueurs[numJoueur].couleurW, 0, 215, SCREEN_WORKING, 0xFFFF);
            switch (joueurs[numJoueur].affichageBas) {
            case 0:
                for (uint8 i=0; i<9; i++) {
                    if (joueurs[numJoueur].nbCartes[i] > 0) {
                        afficherGrafx_ram(RAM_MINI_WAG_LOCO+i, ouX+7, 240-17, SCREEN_WORKING, 0xFFFF);
                        ecrireGrafx0(joueurs[numJoueur].nbCartes[i], ouX, 240-15, joueurs[numJoueur].couleurFonte);
                        ouX += 25+7;
                    }
                }
                break;
            case 1:
                for (uint8 i=1; i<=nbTotalJoueur; i++) {
                    uint16 x = ecrireGrafx0(joueurs[i].nbWagons, ouX, 240-15, joueurs[numJoueur].couleurFonte);
                    afficherGrafx_ram(RAM_MINI_WAG_BLUE + joueurs[i].couleurW, x+2, 240-17, SCREEN_WORKING, 0xFFFF);
                    ouX += 57;
                }
                break;
            }

            // s'il reste assez de place : afficher les missions ok et ko
            uint8 nbok = 0;
            uint8 nbko = 0;
            for (uint8 i=0; i<joueurs[numJoueur].nbCartesMission; i++) {
                if (joueurs[numJoueur].missionsRealisee[i]) {
                    nbok++;
                } else {
                    nbko++;
                }
            }

            if (ouX <= 250) {
                // place pour 2 cartes
                if ((nbok > 0) && (nbko > 0)) {
                    ouX = 250;
                    afficherGrafx_ram(RAM_MINI_MISSION_OK, ouX, 240-17, SCREEN_WORKING, 0xFFFF);
                    ecrireGrafx0(nbok, ouX+6, 240-15, 0x18E3);
                    ouX += 27;

                    afficherGrafx_ram(RAM_MINI_MISSION_KO, ouX, 240-17, SCREEN_WORKING, 0xFFFF);
                    ecrireGrafx0(nbko, ouX+6, 240-15, 0x18E3);
                    ouX += 27;
                } else {
                    // une seule carte
                    ouX = 250 + 27;
                    if (nbok > 0) {
                        afficherGrafx_ram(RAM_MINI_MISSION_OK, ouX, 240-17, SCREEN_WORKING, 0xFFFF);
                        ecrireGrafx0(nbok, ouX+6, 240-15, 0x18E3);
                    } else {
                        afficherGrafx_ram(RAM_MINI_MISSION_KO, ouX, 240-17, SCREEN_WORKING, 0xFFFF);
                        ecrireGrafx0(nbko, ouX+6, 240-15, 0x18E3);
                    }
                }
            } else {
                if (ouX <= 250+27) {
                    ouX = 250 + 27;
                    // place pour une seule carte
                    if ((nbok > 0) && (nbko == 0)) {
                        afficherGrafx_ram(RAM_MINI_MISSION_OK, ouX, 240-17, SCREEN_WORKING, 0xFFFF);
                        ecrireGrafx0(nbok, ouX+6, 240-15, 0x18E3);
                    } else {
                        if ((nbok == 0) && (nbko > 0)) {
                            afficherGrafx_ram(RAM_MINI_MISSION_KO, ouX, 240-17, SCREEN_WORKING, 0xFFFF);
                            ecrireGrafx0(nbko+6, ouX, 240-15, 0x18E3);
                        }
                    }
                }
            }
        } else {
            afficherGrafx_ram(RAM_UI_BOT + joueurs[numJoueur].couleurW, 0, 215, SCREEN_WORKING, 0xFFFF);
            // les cartes wagons
            uint16 ouX = ecrireGrafx0(joueurs[numJoueur].nbCartesWagon, 16, 240-15, joueurs[numJoueur].couleurFonte) + 2;
            afficherGrafx_ram(RAM_MINI_WAG_BACK, ouX, 240-16, SCREEN_WORKING, 0xFFFF);
            ouX += 32;

            // les cartes missions
            ouX = ecrireGrafx0(joueurs[numJoueur].nbCartesMission, ouX, 240-15, joueurs[numJoueur].couleurFonte) + 2;
            afficherGrafx_ram(RAM_MINI_MIS_BACK, ouX, 240-16, SCREEN_WORKING, 0xFFFF);
            ouX += 32;

            // les wagons
            ouX = ecrireGrafx0(joueurs[numJoueur].nbWagons, ouX, 240-15, joueurs[numJoueur].couleurFonte) + 2;
            afficherGrafx_ram(RAM_MINI_WAG_BLUE + joueurs[numJoueur].couleurW, ouX+2, 240-17, SCREEN_WORKING, 0xFFFF);
            ouX += 57;
        }

        break;
    case 1:
        // choix des missions
        if (joueurs[numJoueur].humain) {
            afficherGrafx_ram(RAM_UI_HUMAN + joueurs[numJoueur].couleurW, 0, 215-12, SCREEN_WORKING, 0xFFFF);
        } else {
            afficherGrafx_ram(RAM_UI_BOT + joueurs[numJoueur].couleurW, 0, 215-12, SCREEN_WORKING, 0xFFFF);
        }
        break;
    }
}

void afficherMiniChoix(uint8 numJoueur) {
    // le fond : la carte
    afficherCarte(xCarte,yCarte,284,222);
    // la carte foncée à droite
    afficherCarteSombre(284,0,319,222,xCarte,yCarte);
    // le bas ?
    afficherBas(numJoueur, 0);

    // Pioche carte mission
    if (nbCartesMissionPioche > 0) {
        afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
    }
    // Pioche cartes wagons retournés
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
        }
    }
    // Pioche carte wagon face retournée
    if (nbCartesWagonPioche > 0) {
        afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
    }
    // le wagon pour revendiquer une route
    if (joueurs[numJoueur].nbWagons > 0) {
        afficherGrafx_ram(RAM_WAGON_60 + joueurs[numJoueur].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
    }
    afficherBackScreen();
}

void animerGoto(uint8 numJoueur, uint16 x, uint8 y) {
    while ((xCarte != x) || (yCarte != y)) {
        if (xCarte < x - 8) {
            xCarte += 8;
        } else {
            if (xCarte < x - 4) {
                xCarte += 4;
            } else {
                if (xCarte > x + 8) {
                    xCarte -= 8;
                } else {
                    if (xCarte > x + 4) {
                        xCarte -= 4;
                    } else {
                        xCarte = x;
                    }
                }
            }
        }

        if (yCarte < y - 8) {
            yCarte += 8;
        } else {
            if (yCarte < y - 4) {
                yCarte += 4;
            } else {
                if (yCarte > y + 8) {
                    yCarte -= 8;
                } else {
                    if (yCarte > y + 4) {
                        yCarte -= 4;
                    } else {
                        yCarte = y;
                    }
                }
            }
        }

        afficherMiniChoix(numJoueur);
    }
}

void animerGotoVille(uint8 numJoueur, uint8 numVille) {
    uint16 x = villeX[numVille];
    uint16 y = villeY[numVille];

    if (x > 160) {
        x -= 160;
    } else {
        x = 0;
    }
    if (x > MAX_CARTE_X) {
        x = MAX_CARTE_X;
    }
    if (y > 120) {
        y -= 120;
    } else {
        y = 0;
    }
    if (y > MAX_CARTE_Y) {
        y = MAX_CARTE_Y;
    }
    animerGoto(numJoueur, x, y);
}

bool scrollerLettre(uint8 numJoueur) {
    if (isKeyPressed(KEY_NSPIRE_SPACE)) {
        if (cptGoto == 0) {
            animerGotoVille(numJoueur, missions[joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante]].villeA);
            cptGoto = 1;
        } else {
            animerGotoVille(numJoueur, missions[joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante]].villeB);
            cptGoto = 0;
        }
        while (isKeyPressed(KEY_NSPIRE_SPACE));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_A)) {
        animerGotoVille(numJoueur, TOWN_ATLANTA);
        while (isKeyPressed(KEY_NSPIRE_A));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_B)) {
        animerGotoVille(numJoueur, TOWN_BOSTON);
        while (isKeyPressed(KEY_NSPIRE_B));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_C)) {
        if (cptGoto > 2) {
            cptGoto = 0;
        }
        switch (cptGoto) {
        case 0:
            animerGotoVille(numJoueur, TOWN_CALGARY);
            cptGoto = 1;
            break;
        case 1:
            animerGotoVille(numJoueur, TOWN_CHARLESTON);
            cptGoto = 2;
            break;
        case 2:
            animerGotoVille(numJoueur, TOWN_CHICAGO);
            cptGoto = 0;
            break;
        }
        while (isKeyPressed(KEY_NSPIRE_C));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_D)) {
        if (cptGoto > 2) {
            cptGoto = 0;
        }
        switch (cptGoto) {
        case 0:
            animerGotoVille(numJoueur, TOWN_DALLAS);
            cptGoto = 1;
            break;
        case 1:
            animerGotoVille(numJoueur, TOWN_DENVER);
            cptGoto = 2;
            break;
        case 2:
            animerGotoVille(numJoueur, TOWN_DULUTH);
            cptGoto = 0;
            break;
        }
        while (isKeyPressed(KEY_NSPIRE_D));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_E)) {
        animerGotoVille(numJoueur, TOWN_EL_PASO);
        while (isKeyPressed(KEY_NSPIRE_E));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_H)) {
        if (cptGoto == 0) {
            animerGotoVille(numJoueur, TOWN_HELENA);
            cptGoto = 1;
        } else {
            animerGotoVille(numJoueur, TOWN_HOUSTON);
            cptGoto = 0;
        }
        while (isKeyPressed(KEY_NSPIRE_H));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_K)) {
        animerGotoVille(numJoueur, TOWN_KANSAS_CITY);
        while (isKeyPressed(KEY_NSPIRE_K));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_L)) {
        if (cptGoto > 2) {
            cptGoto = 0;
        }
        switch (cptGoto) {
        case 0:
            animerGotoVille(numJoueur, TOWN_LAS_VEGAS);
            cptGoto = 1;
            break;
        case 1:
            animerGotoVille(numJoueur, TOWN_LITTLE_ROCK);
            cptGoto = 2;
            break;
        case 2:
            animerGotoVille(numJoueur, TOWN_LOS_ANGELES);
            cptGoto = 0;
            break;
        }
        while (isKeyPressed(KEY_NSPIRE_L));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_M)) {
        if (cptGoto == 0) {
            animerGotoVille(numJoueur, TOWN_MIAMI);
            cptGoto = 1;
        } else {
            animerGotoVille(numJoueur, TOWN_MONTREAL);
            cptGoto = 0;
        }
        while (isKeyPressed(KEY_NSPIRE_M));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_N)) {
        if (cptGoto > 2) {
            cptGoto = 0;
        }
        switch (cptGoto) {
        case 0:
            animerGotoVille(numJoueur, TOWN_NASHVILLE);
            cptGoto = 1;
            break;
        case 1:
            animerGotoVille(numJoueur, TOWN_NEW_ORLEANS);
            cptGoto = 2;
            break;
        case 2:
            animerGotoVille(numJoueur, TOWN_NEW_YORK);
            cptGoto = 0;
            break;
        }
        while (isKeyPressed(KEY_NSPIRE_N));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_O)) {
        if (cptGoto == 0) {
            animerGotoVille(numJoueur, TOWN_OKLAHOMA_CITY);
            cptGoto = 1;
        } else {
            animerGotoVille(numJoueur, TOWN_OMAHA);
            cptGoto = 0;
        }
        while (isKeyPressed(KEY_NSPIRE_O));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_P)) {
        if (cptGoto > 2) {
            cptGoto = 0;
        }
        switch (cptGoto) {
        case 0:
            animerGotoVille(numJoueur, TOWN_PHOENIX);
            cptGoto = 1;
            break;
        case 1:
            animerGotoVille(numJoueur, TOWN_PITTSBURGH);
            cptGoto = 2;
            break;
        case 2:
            animerGotoVille(numJoueur, TOWN_PORTLAND);
            cptGoto = 0;
            break;
        }
        while (isKeyPressed(KEY_NSPIRE_P));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_R)) {
        animerGotoVille(numJoueur, TOWN_RALEIGH);
        while (isKeyPressed(KEY_NSPIRE_R));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_S)) {
        if (cptGoto > 5) {
            cptGoto = 0;
        }
        switch (cptGoto) {
        case 0:
            animerGotoVille(numJoueur, TOWN_SAINT_LOUIS);
            cptGoto = 1;
            break;
        case 1:
            animerGotoVille(numJoueur, TOWN_SALT_LAKE_CITY);
            cptGoto = 2;
            break;
        case 2:
            animerGotoVille(numJoueur, TOWN_SAN_FRANCISCO);
            cptGoto = 3;
            break;
        case 3:
            animerGotoVille(numJoueur, TOWN_SANTA_FE);
            cptGoto = 4;
            break;
        case 4:
            animerGotoVille(numJoueur, TOWN_SAULT_ST_MARIE);
            cptGoto = 5;
            break;
        case 5:
            animerGotoVille(numJoueur, TOWN_SEATTLE);
            cptGoto = 0;
            break;
        }
        while (isKeyPressed(KEY_NSPIRE_S));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_T)) {
        animerGotoVille(numJoueur, TOWN_TORONTO);
        while (isKeyPressed(KEY_NSPIRE_T));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_V)) {
        animerGotoVille(numJoueur, TOWN_VANCOUVER);
        while (isKeyPressed(KEY_NSPIRE_V));
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_W)) {
        if (cptGoto == 0) {
            animerGotoVille(numJoueur, TOWN_WASHINGTON);
            cptGoto = 1;
        } else {
            animerGotoVille(numJoueur, TOWN_WINNIPEG);
            cptGoto = 0;
        }
        while (isKeyPressed(KEY_NSPIRE_W));
        return true;
    }
    return false;
}

bool scrollerCarte(uint8 numJoueur) {
    // si déplacement rapide vers une ville
    if (scrollerLettre(numJoueur)) {
        return true;
    }

    bool c1;
    bool c2;
    if (isKeyPressed(KEY_NSPIRE_1)) {
        c1 = scrollerDown();
        c2 = scrollerLeft();
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_2)) {
        return scrollerDown();
    }
    if (isKeyPressed(KEY_NSPIRE_3)) {
        c1 = scrollerDown();
        c2 = scrollerRight();
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_4)) {
        return scrollerLeft();
    }
    if (isKeyPressed(KEY_NSPIRE_5)) {
        return true;
    }
    if (isKeyPressed(KEY_NSPIRE_6)) {
        return scrollerRight();
    }
    if (isKeyPressed(KEY_NSPIRE_7)) {
        c1 = scrollerUp();
        c2 = scrollerLeft();
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_8)) {
        return scrollerUp();
    }
    if (isKeyPressed(KEY_NSPIRE_9)) {
        c1 = scrollerUp();
        c2 = scrollerRight();
        return c1 || c2;
    }
    return false;
}

bool scrollerCurseurUp() {
    if (cursorY < 0) {
        cursorY = 0;
        return true;
    }
    if (cursorY >= 2) {
        cursorY -= 2;
        return true;
    }
    if (cursorY > 0) {
        cursorY = 0;
        return true;
    }
    return false;
}

bool scrollerCurseurDown() {
    if (cursorY > MAX_CURSEUR_Y) {
        cursorY = MAX_CURSEUR_Y;
        return true;
    }
    if (cursorY <= MAX_CURSEUR_Y-2) {
        cursorY += 2;
        return true;
    }
    if ((cursorY > MAX_CURSEUR_Y-2) && (cursorY < MAX_CURSEUR_Y)) {
        cursorY = MAX_CURSEUR_Y;
        return true;
    }
    return false;
}

bool scrollerCurseurLeft() {
    if (cursorX < 0) {
        cursorX = 0;
        return true;
    }
    if (cursorX >= 2) {
        cursorX -= 2;
        return true;
    }
    if (cursorX > 0) {
        cursorX = 0;
        return true;
    }
    return false;
}

bool scrollerCurseurRight() {
    if (cursorX > MAX_CURSEUR_X) {
        cursorX = MAX_CURSEUR_X;
        return true;
    }
    if (cursorX <= MAX_CURSEUR_X-2) {
        cursorX += 2;
        return true;
    }
    if ((cursorX > MAX_CURSEUR_X-2) && (cursorX < MAX_CURSEUR_X)) {
        cursorX = MAX_CURSEUR_X;
        return true;
    }
    return false;
}

bool scrollerCurseur() {
    bool c1;
    bool c2;

    if (isKeyPressed(KEY_NSPIRE_UP)) {
        return scrollerCurseurUp();
    }
    if (isKeyPressed(KEY_NSPIRE_UPRIGHT)) {
        c1 = scrollerCurseurUp();
        c2 = scrollerCurseurRight();
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_RIGHT)) {
        return scrollerCurseurRight();
    }
    if (isKeyPressed(KEY_NSPIRE_RIGHTDOWN)) {
        c1 = scrollerCurseurDown();
        c2 = scrollerCurseurRight();
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_DOWN)) {
        return scrollerCurseurDown();
    }
    if (isKeyPressed(KEY_NSPIRE_DOWNLEFT)) {
        c1 = scrollerCurseurDown();
        c2 = scrollerCurseurLeft();
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_LEFT)) {
        return scrollerCurseurLeft();
    }
    if (isKeyPressed(KEY_NSPIRE_LEFTUP)) {
        c1 = scrollerCurseurUp();
        c2 = scrollerCurseurLeft();
        return c1 || c2;
    }
    return false;
}

bool autoScroll() {
    bool c1;
    bool c2;

    if (isKeyPressed(KEY_NSPIRE_UP)) {
        // si le curseur est en haut : ne déplacer que la carte
        c1 = false;
        if (cursorY <= 10) {
            if (yCarte < 0) {
                yCarte = 0;
                c1 = true;
            } else {
                if (yCarte >= DELTA_SCROLL) {
                    yCarte -= DELTA_SCROLL;
                    c1 = true;
                } else {
                    if (yCarte > 0) {
                        yCarte = 0;
                        c1 = true;
                    }
                }
            }
        }
        return c1;
    }
    if (isKeyPressed(KEY_NSPIRE_UPRIGHT)) {
        c1 = false;
        if (cursorY <= 10) {
            if (yCarte < 0) {
                yCarte = 0;
                c1 = true;
            } else {
                if (yCarte >= DELTA_SCROLL) {
                    yCarte -= DELTA_SCROLL;
                    c1 = true;
                } else {
                    if (yCarte > 0) {
                        yCarte = 0;
                        c1 = true;
                    }
                }
            }
        }
        c2 = false;
        if (cursorX > MAX_CURSEUR_X - 10) {
            if (xCarte > MAX_CARTE_X) {
                xCarte = MAX_CARTE_X;
                c2 = true;
            } else {
                if (xCarte <= MAX_CARTE_X - DELTA_SCROLL) {
                    xCarte += DELTA_SCROLL;
                    c2 = true;
                } else {
                    if ((xCarte > MAX_CARTE_X - DELTA_SCROLL) && (xCarte < MAX_CARTE_X)) {
                        xCarte = MAX_CARTE_X;
                        c2 = true;
                    }
                }
            }
        }
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_RIGHT)) {
        c2 = false;
        if (cursorX > MAX_CURSEUR_X - 10) {
            if (xCarte > MAX_CARTE_X) {
                xCarte = MAX_CARTE_X;
                c2 = true;
            } else {
                if (xCarte <= MAX_CARTE_X - DELTA_SCROLL) {
                    xCarte += DELTA_SCROLL;
                    c2 = true;
                } else {
                    if ((xCarte > MAX_CARTE_X - DELTA_SCROLL) && (xCarte < MAX_CARTE_X)) {
                        xCarte = MAX_CARTE_X;
                        c2 = true;
                    }
                }
            }
        }
        return c2;
    }
    if (isKeyPressed(KEY_NSPIRE_RIGHTDOWN)) {
        c1 = false;
        if (cursorY > MAX_CURSEUR_Y - 10) {
            if (yCarte > MAX_CARTE_Y) {
                yCarte = MAX_CARTE_Y;
                c1 = true;
            } else {
                if (yCarte <= MAX_CARTE_Y - DELTA_SCROLL) {
                    yCarte += DELTA_SCROLL;
                    c1 = true;
                } else {
                    if ((yCarte > MAX_CARTE_Y - DELTA_SCROLL) && (yCarte < MAX_CARTE_Y)) {
                        yCarte = MAX_CARTE_Y;
                        c1 = true;
                    }
                }
            }
        }
        c2 = false;
        if (cursorX > MAX_CURSEUR_X - 10) {
            if (xCarte > MAX_CARTE_X) {
                xCarte = MAX_CARTE_X;
                c2 = true;
            } else {
                if (xCarte <= MAX_CARTE_X - DELTA_SCROLL) {
                    xCarte += DELTA_SCROLL;
                    c2 = true;
                } else {
                    if ((xCarte > MAX_CARTE_X - DELTA_SCROLL) && (xCarte < MAX_CARTE_X)) {
                        xCarte = MAX_CARTE_X;
                        c2 = true;
                    }
                }
            }
        }
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_DOWN)) {
        c1 = false;
        if (cursorY > MAX_CURSEUR_Y - 10) {
            if (yCarte > MAX_CARTE_Y) {
                yCarte = MAX_CARTE_Y;
                c1 = true;
            } else {
                if (yCarte <= MAX_CARTE_Y - DELTA_SCROLL) {
                    yCarte += DELTA_SCROLL;
                    c1 = true;
                } else {
                    if ((yCarte > MAX_CARTE_Y - DELTA_SCROLL) && (yCarte < MAX_CARTE_Y)) {
                        yCarte = MAX_CARTE_Y;
                        c1 = true;
                    }
                }
            }
        }
        return c1;
    }
    if (isKeyPressed(KEY_NSPIRE_DOWNLEFT)) {
        c1 = false;
        if (cursorY > MAX_CURSEUR_Y - 10) {
            if (yCarte > MAX_CARTE_Y) {
                yCarte = MAX_CARTE_Y;
                c1 = true;
            } else {
                if (yCarte <= MAX_CARTE_Y - DELTA_SCROLL) {
                    yCarte += DELTA_SCROLL;
                    c1 = true;
                } else {
                    if ((yCarte > MAX_CARTE_Y - DELTA_SCROLL) && (yCarte < MAX_CARTE_Y)) {
                        yCarte = MAX_CARTE_Y;
                        c1 = true;
                    }
                }
            }
        }
        c2 = false;
        if (cursorX <= 10) {
            if (xCarte < 0) {
                xCarte = 0;
                c2 = true;
            } else {
                if (xCarte >= DELTA_SCROLL) {
                    xCarte -= DELTA_SCROLL;
                    c2 = true;
                } else {
                    if (xCarte > 0) {
                        xCarte = 0;
                        c2 = true;
                    }
                }
            }
        }
        return c1 || c2;
    }
    if (isKeyPressed(KEY_NSPIRE_LEFT)) {
        c2 = false;
        if (cursorX <= 10) {
            if (xCarte < 0) {
                xCarte = 0;
                c2 = true;
            } else {
                if (xCarte >= DELTA_SCROLL) {
                    xCarte -= DELTA_SCROLL;
                    c2 = true;
                } else {
                    if (xCarte > 0) {
                        xCarte = 0;
                        c2 = true;
                    }
                }
            }
        }
        return c2;
    }
    if (isKeyPressed(KEY_NSPIRE_LEFTUP)) {
        c1 = false;
        if (cursorY <= 10) {
            if (yCarte < 0) {
                yCarte = 0;
                c1 = true;
            } else {
                if (yCarte >= DELTA_SCROLL) {
                    yCarte -= DELTA_SCROLL;
                    c1 = true;
                } else {
                    if (yCarte > 0) {
                        yCarte = 0;
                        c1 = true;
                    }
                }
            }
        }
        c2 = false;
        if (cursorX <= 10) {
            if (xCarte < 0) {
                xCarte = 0;
                c2 = true;
            } else {
                if (xCarte >= DELTA_SCROLL) {
                    xCarte -= DELTA_SCROLL;
                    c2 = true;
                } else {
                    if (xCarte > 0) {
                        xCarte = 0;
                        c2 = true;
                    }
                }
            }
        }
        return c1 || c2;
    }
    return false;
}

bool isPathPossible(uint8 numJoueur, uint8 numPath) {
    if (!estDisponible(numJoueur, numPath)) {
        return false;
    }
    if (joueurs[numJoueur].nbWagons >= paths[numPath].distance) {
        return true;
    }
    return false;
}

bool joueurPeutRevendiquerCePath(uint8 numJoueur, uint8 numPath) {
    // si le path n'est pas dispo : retourner false
    if (!isPathPossible(numJoueur, numPath)) {
        return false;
    }
    // tester si le joueur a de quoi payer ce path
    // compter les différentes cartes possibles du joueur
    if (paths[numPath].couleur == 0) {
        for (uint8 i=1; i<9; i++) {
            if (joueurs[numJoueur].nbCartes[i] + joueurs[numJoueur].nbCartes[COULEUR_LOCO] >= paths[numPath].distance) {
                return true;
            }
        }
        return joueurs[numJoueur].nbCartes[COULEUR_LOCO] >= paths[numPath].distance;
    } else {
        return joueurs[numJoueur].nbCartes[paths[numPath].couleur] + joueurs[numJoueur].nbCartes[COULEUR_LOCO] >= paths[numPath].distance;
    }
}

uint8 nbLocoPourPayer(uint8 numJoueur, uint8 numPath) {
    // si couleur fixe
    if (paths[numPath].couleur != COULEUR_LOCO) {
        if (joueurs[numJoueur].nbCartes[paths[numPath].couleur] >= paths[numPath].distance) {
            return 0;
        }
        return paths[numPath].distance - joueurs[numJoueur].nbCartes[paths[numPath].couleur];
    } else {
        uint8 mini = paths[numPath].distance;
        uint8 test;
        for (uint8 i=1; i<9; i++) {
            if (joueurs[numJoueur].nbCartes[i] >= paths[numPath].distance) {
                return 0;
            } else {
                test = paths[numPath].distance - joueurs[numJoueur].nbCartes[i];
                if (test < mini) {
                    mini = test;
                }
            }
        }
        return mini;
    }
}

bool pathSansLoco(uint8 numJoueur, uint8 numPath) {
    // retourne true si le joueur peut payer ce path sans utiliser de loco
    return nbLocoPourPayer(numJoueur, numPath) == 0;
}

bool manqueUnWagonPourCePath(uint8 numJoueur, uint8 numPath) {
    // retourne true s'il ne manque qu'un seul wagon au joueur pour payer ce path
    // si couleur fixe
    if (paths[numPath].couleur != COULEUR_LOCO) {
        return joueurs[numJoueur].nbCartes[paths[numPath].couleur] == paths[numPath].distance - 1;
    } else {
        for (uint8 i=1; i<9; i++) {
            if (joueurs[numJoueur].nbCartes[i] == paths[numPath].distance - 1) {
                return true;
            }
        }
        return false;
    }
}


bool isBestPath(uint8 numJoueur, uint8 numPath1, uint8 numPath2) {
    // retourne vrai si le path1 est meilleur que le path2
    if (paths[numPath1].IAscore > paths[numPath2].IAscore) {
        return true;
    }
    if (paths[numPath1].IAscore == paths[numPath2].IAscore) {
        // gérer les égalitées de iascore. trier en fonction de la faisabilité du path (par exemple s'il manque une seule carte c'est plus intéressant que s'il en manque 3)
        // idem pour les locos dépensées : moins de loco = plus intéressant
        uint8 nb1 = nbLocoPourPayer(numJoueur, numPath1);
        uint8 nb2 = nbLocoPourPayer(numJoueur, numPath2);
        if (nb1 < nb2) {
            return true;
        }
        if (nb2 > nb1) {
            return false;
        }

        // kiff kiff
        return true;
    }
    return false;
}

uint8 nbLocoPaiementPossible(uint8 numPaiement, uint8 nbWagons) {
    uint8 nb = 0;
    for (uint8 i=0; i<nbWagons; i++) {
        if (paiementPossible[numPaiement][i] == COULEUR_LOCO) {
            nb++;
        }
    }
    return nb;
}

void trierPaiementPossiblePourIA(uint8 nbWagons) {
    // mettre en premier le chemin le plus intéressant pour l'IA (sans loco et/ou si la couleur n'est pas utilisée pour une autre route)
    if (nbPaiementPossible > 1) {
        for (uint8 i=1; i<nbPaiementPossible; i++) {
            if (nbLocoPaiementPossible(i, nbWagons) < nbLocoPaiementPossible(0, nbWagons)) {
                // swapper 0 et i
                for (uint8 j=0; j<nbWagons; j++) {
                    uint8 c = paiementPossible[0][j];
                    paiementPossible[0][j] = paiementPossible[i][j];
                    paiementPossible[i][j] = c;
                }
            }
        }
    }
}

void renseignerCartesMissionAGarder(uint8 numJoueur, uint8 nbCartesAGarder) {
    bool missionImpossible[5];
    uint8 nbWagonNecessaires[5];
    memset(nbWagonNecessaires, 0, sizeof(nbWagonNecessaires));

    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        missionImpossible[i] = false;
    }

    uint8 nbCarteOk = 0;
    uint8 totalWagonConsomme = 0;
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (choixCarteMissionResultat[i] == GARDER_CARTE) {
            totalWagonConsomme = pathfinder_distanceRestante(numJoueur, choixCarteMission[i]);
        }
    }

    // la première fois : choisir les missions les plus longues en priorité
    if (nbCartesAGarder == 2) {
        uint8 min = missions[choixCarteMission[0]].pts;
        for (uint8 i=1; i<nbChoixCarteMission; i++) {
            if (missions[choixCarteMission[i]].pts < min) {
                min = missions[choixCarteMission[i]].pts;
            }
        }
        nbCarteOk = 0;
        for (uint8 i=0; i<nbChoixCarteMission; i++) {
            if (missions[choixCarteMission[i]].pts == min) {
                choixCarteMissionResultat[i] = DEFAUSSER_CARTE;
            } else {
                choixCarteMissionResultat[i] = GARDER_CARTE;
                nbCarteOk++;
            }
        }
        // s'il reste une carte à garder
        if (nbCarteOk < nbCartesAGarder) {
            // prendre la première carte qu'on trouve
            for (uint8 i=0; i<nbChoixCarteMission; i++) {
                if (choixCarteMissionResultat[i] == DEFAUSSER_CARTE) {
                    choixCarteMissionResultat[i] = GARDER_CARTE;
                    nbCarteOk++;
                    if (nbCarteOk >= nbCartesAGarder) {
                        return;
                    }
                }
            }


        }
        return;
    }


    // refuser les missions impossibles
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (choixCarteMissionResultat[i] == 0) {
            nbWagonNecessaires[i] = pathfinder_distanceRestante(numJoueur, choixCarteMission[i]);

            // si le chemin est impossible à réaliser
            if (nbWagonNecessaires[i] == 200) {
                missionImpossible[i] = true;
                choixCarteMissionResultat[i] = DEFAUSSER_CARTE;
            } else {
                // sinon s'il ne reste plus assez de wagon au joueur
                if (joueurs[numJoueur].nbWagons < totalWagonConsomme + nbWagonNecessaires[i]) {
                    missionImpossible[i] = true;
                    choixCarteMissionResultat[i] = DEFAUSSER_CARTE;
                }
            }
        }
    }

    // le nombre de cartes sélectionnées
    nbCarteOk = 0;
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (choixCarteMissionResultat[i] == GARDER_CARTE) {
            nbCarteOk++;
        }
    }

    // si on a gardé des missions déjà réalisées, on accepte les indéterminées qui n'ont qu'un path manquant
    if (nbCarteOk > 0) {
        for (uint8 i=0; i<nbChoixCarteMission; i++) {
            if ((choixCarteMissionResultat[i] == 0) && (joueurs[numJoueur].nbWagons < totalWagonConsomme + nbWagonNecessaires[i]) && (nbPathManquant(numJoueur, choixCarteMission[i]) == 1)) {
                choixCarteMissionResultat[i] = GARDER_CARTE;
                nbCarteOk++;
                totalWagonConsomme = pathfinder_distanceRestante(numJoueur, choixCarteMission[i]);
            }
        }
    }

    // ensuite on refuse les autres cartes pour l'instant
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (choixCarteMissionResultat[i] == 0) {
            choixCarteMissionResultat[i] = DEFAUSSER_CARTE;
        }
    }


    // s'il manque des cartes à garder : sélectionner une mission refusée mais pas impossible, celle qui sera la plus rapide à faire (= le moins de path manquants)
    if (nbCarteOk < nbCartesAGarder) {
        uint8 index = 200;
        uint8 nbManquant = 0;
        uint8 test = 0;
        for (uint8 i=0; i<nbChoixCarteMission; i++) {
            if ((choixCarteMissionResultat[i] == DEFAUSSER_CARTE) && !missionImpossible[i]) {
                if (index == 200) {
                    index = i;
                    nbManquant = nbPathManquant(numJoueur, choixCarteMission[i]);
                } else {
                    test = nbPathManquant(numJoueur, choixCarteMission[i]);
                    if (test < nbManquant) {
                        index = i;
                        nbManquant = test;
                    }
                }
            }
        }
        if (index != 200) {
            choixCarteMissionResultat[index] = GARDER_CARTE;
            nbCarteOk++;
//			totalWagonConsomme = pathfinder_distanceRestante(numJoueur, choixCarteMission[index]);
        }
    }

    // s'il manque des cartes à garder : sélectionner les missions impossibles
    if (nbCarteOk < nbCartesAGarder) {
        uint8 index = 200;
        for (uint8 i=0; i<nbChoixCarteMission; i++) {
            if ((choixCarteMissionResultat[i] == DEFAUSSER_CARTE) && missionImpossible[i]) {
                if (index == 200) {
                    index = i;
                } else {
                    if (missions[choixCarteMission[i]].pts < missions[choixCarteMission[index]].pts) {
                        index = i;
                    }
                }
            }
        }
        if (index != 200) {
            choixCarteMissionResultat[index] = GARDER_CARTE;
            nbCarteOk++;
//			totalWagonConsomme = pathfinder_distanceRestante(numJoueur, choixCarteMission[index]);
        }
    }


    // s'il manque encore des cartes : prendre la première qu'on trouve.
    if (nbCarteOk < nbCartesAGarder) {
        for (uint8 i=0; i<nbChoixCarteMission; i++) {
            if (choixCarteMissionResultat[i] == DEFAUSSER_CARTE) {
                choixCarteMissionResultat[i] = GARDER_CARTE;
                break;
            }
        }
    }
}


uint8 determinerCouleurAPiocher(uint8 numJoueur) {
    // retourne la couleur à piocher. on se base sur le nombre de cartes en main + celles qui sont déjà retournées
    // ajouter les cartes retournées
    uint8 nbCartesPioche[9];
    memset(nbCartesPioche, 0, sizeof(nbCartesPioche));
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            nbCartesPioche[choixCartesWagon[i]]++;
        }
    }

    uint8 resultat = 0;
    for (uint8 i=1; i<9; i++) {
        if ((joueurs[numJoueur].nbCartes[i] + nbCartesPioche[i]) > (joueurs[numJoueur].nbCartes[resultat] + nbCartesPioche[resultat])) {
            resultat = i;
        } else {
            if ((joueurs[numJoueur].nbCartes[i] + nbCartesPioche[i]) == (joueurs[numJoueur].nbCartes[resultat] + nbCartesPioche[resultat])) {
                if (nbCartesPioche[i] > nbCartesPioche[resultat]) {
                    resultat = i;
                }
            }
        }
    }
    return resultat;
}

void pondererPath(uint8 numJoueur) {
    // parcourir tous les paths ayant un score > 0
    for (uint8 i=1; i<MAX_PATH; i++) {
        if (paths[i].IAscore > 0) {
            // ajouter xx points s'il n'utilise pas de loco
            if (pathSansLoco(numJoueur, i)) {
                paths[i].IAscore += IASCORE_WITHOUT_LOCO;
            }
            // ajouter xx points s'il est réalisable tout de suite
            if (joueurPeutRevendiquerCePath(numJoueur, i)) {
                paths[i].IAscore += IASCORE_REALISABLE_NOW;
            } else {
                // ajouter xx points s'il ne manque qu'un wagon pour le réaliser
                if (manqueUnWagonPourCePath(numJoueur, i)) {
                    paths[i].IAscore += IASCORE_ONE_WAGON_LESS;
                }
            }
        }
    }
}

void determinerBestPaths(uint8 numJoueur) {
    // déterminer les best paths
    for (uint8 i=1; i<MAX_PATH; i++) {
        if (paths[i].IAscore > 0) {
            if (joueurs[numJoueur].bestPaths[0] == -1) {
                joueurs[numJoueur].bestPaths[0] = i;
            } else {
                if (isBestPath(numJoueur, i, joueurs[numJoueur].bestPaths[0])) {
                    joueurs[numJoueur].bestPaths[2] = joueurs[numJoueur].bestPaths[1];
                    joueurs[numJoueur].bestPaths[1] = joueurs[numJoueur].bestPaths[0];
                    joueurs[numJoueur].bestPaths[0] = i;
                } else {
                    if (joueurs[numJoueur].bestPaths[1] == -1) {
                        joueurs[numJoueur].bestPaths[1] = i;
                    } else {
                        if (isBestPath(numJoueur, i, joueurs[numJoueur].bestPaths[1])) {
                            joueurs[numJoueur].bestPaths[2] = joueurs[numJoueur].bestPaths[1];
                            joueurs[numJoueur].bestPaths[1] = i;
                        } else {
                            if (isBestPath(numJoueur, i, joueurs[numJoueur].bestPaths[2])) {
                                joueurs[numJoueur].bestPaths[2] = i;
                            }
                        }
                    }
                }
            }
        }
    }
}

// retourne true si on peut revendiquer une route tout de suite
bool remplirTableauBestPaths(uint8 numJoueur) {
    // pour chaque mission non réalisée : calculer le pathfinder le plus court
    bool pathTrouve = false;
    for (uint8 i=0; i < joueurs[numJoueur].nbCartesMission; i++) {
        if (!joueurs[numJoueur].missionsRealisee[i]) {
            if (calculerPathFinderLePlusCourt(numJoueur, joueurs[numJoueur].lstCartesMission[i])) {
                pathTrouve = true;
            }
        }
    }
    // si aucun path ne nous intéresse
    if (!pathTrouve) {
        // déterminer 2 couleurs préférées en fonction des routes à 6 encore disponibles
        joueurs[numJoueur].bestCouleur[0] = determinerCouleurAPiocher(numJoueur);
        joueurs[numJoueur].bestCouleur[1] = joueurs[numJoueur].bestCouleur[0];
        return false;
    }

    // ponderer les paths
    pondererPath(numJoueur);
    // choisir les best path
    determinerBestPaths(numJoueur);

    // si le joueur peut revendiquer tout de suite son best path
    if ((joueurs[numJoueur].bestPaths[0] >= 0) && joueurPeutRevendiquerCePath(numJoueur, joueurs[numJoueur].bestPaths[0])) {
        return true;
    }
    // ici, si le joueur n'a qu'un best path (et qu'il ne peut pas le revendiquer tout de suite) on va chercher un chemin alternatif pour le second best path
    if ((joueurs[numJoueur].bestPaths[0] >= 0) && (joueurs[numJoueur].bestPaths[1] == -1)) {
        // on bloque temporairement le bestpath[0]
        uint8 savNum = joueurs[numJoueur].bestPaths[0];
        uint8 sav = paths[savNum].owner;
        paths[savNum].owner = 10;

        pathTrouve = false;
        for (uint8 i=0; i < joueurs[numJoueur].nbCartesMission; i++) {
            if (!joueurs[numJoueur].missionsRealisee[i]) {
                if (calculerPathFinderLePlusCourt(numJoueur, joueurs[numJoueur].lstCartesMission[i])) {
                    pathTrouve = true;
                }
            }
        }

        if (pathTrouve) {
            // ponderer les paths
            pondererPath(numJoueur);
            // choisir les best path
            determinerBestPaths(numJoueur);
        }
        paths[savNum].owner = sav;
    }

    // si le joueur peut revendiquer son second best path
    if ((joueurs[numJoueur].bestPaths[1] >= 0) && joueurPeutRevendiquerCePath(numJoueur, joueurs[numJoueur].bestPaths[1])) {
        return true;
    }

    // sinon déterminer les 2 couleurs les plus intéressantes en fonction des best paths
    if (joueurs[numJoueur].bestPaths[0] >= 0) {
        // si ce path a une couleur bien définie
        if (paths[joueurs[numJoueur].bestPaths[0]].couleur != 0) {
            joueurs[numJoueur].bestCouleur[0] = paths[joueurs[numJoueur].bestPaths[0]].couleur;
            // la seconde carte pour le second path
            if (joueurs[numJoueur].bestPaths[1] >= 0) {
                if (paths[joueurs[numJoueur].bestPaths[1]].couleur != 0) {
                    joueurs[numJoueur].bestCouleur[1] = paths[joueurs[numJoueur].bestPaths[1]].couleur;
                } else {
                    joueurs[numJoueur].bestCouleur[1] = determinerCouleurAPiocher(numJoueur);
                }
            } else {
                joueurs[numJoueur].bestCouleur[1] = determinerCouleurAPiocher(numJoueur);
            }
        } else {
            // best path en gris : on se base sur le second best path
            if (joueurs[numJoueur].bestPaths[1] >= 0) {
                if (paths[joueurs[numJoueur].bestPaths[1]].couleur != 0) {
                    // la première couleur pour le second path
                    joueurs[numJoueur].bestCouleur[0] = paths[joueurs[numJoueur].bestPaths[1]].couleur;
                    // la seconde pour le premier : on se base sur le nombre de cartes en main + celles qui sont déjà retournées
                    joueurs[numJoueur].bestCouleur[1] = determinerCouleurAPiocher(numJoueur);
                } else {
                    // le second best path est aussi en gris : on se base sur le nombre de cartes en main + celles qui sont déjà retournées
                    joueurs[numJoueur].bestCouleur[0] = determinerCouleurAPiocher(numJoueur);
                    joueurs[numJoueur].bestCouleur[1] = joueurs[numJoueur].bestCouleur[0];
                }
            } else {
                // pas de second best path : on se base sur le nombre de cartes en main + celles qui sont déjà retournées
                joueurs[numJoueur].bestCouleur[0] = determinerCouleurAPiocher(numJoueur);
                joueurs[numJoueur].bestCouleur[1] = joueurs[numJoueur].bestCouleur[0];
            }
        }
        return false;
    }
    // ici on se base sur le nombre de cartes en main + celles qui sont déjà retournées
    joueurs[numJoueur].bestCouleur[0] = determinerCouleurAPiocher(numJoueur);
    joueurs[numJoueur].bestCouleur[1] = joueurs[numJoueur].bestCouleur[0];
    return false;
}

bool joueurToutesLesMissionsOk(uint8 numJoueur) {
    for (uint8 i=0; i < joueurs[numJoueur].nbCartesMission; i++) {
        if (!joueurs[numJoueur].missionsRealisee[i]) {
            return false;
        }
    }

    return true;
}

void afficherAideContextuelle(uint8 numAide) {
    for (uint8 i=1; i<21; i++) {
        afficherGrafx_file(FILE_INGAME_TEXT, 0, 240-i, SCREEN_WORKING, 0xFFFF);
        if (!isKeyPressed(KEY_NSPIRE_DOC)) {
            return;
        }

        switch (numAide) {
        case 1:
            // choix cartes mission
            ecrireGrafxA("Select 1 or more Destination Ticket", 30, 260-15-i, 0xFFFF);
            break;
        case 2:
            // choix cartes mission
            ecrireGrafxA("Select 2 or more Destination Ticket", 30, 260-15-i, 0xFFFF);
            break;
        case 3:
            // etat choix joueur
            ecrireGrafxA("Draw 1 Ticket, 2 Trains or Claim a Route", 30, 260-15-i, 0xFFFF);
            break;
        case 4:
            // après une carte piochée
            ecrireGrafxA("Draw another Train Car Card (not Loco.)", 30, 260-15-i, 0xFFFF);
            break;
        case 5:
            // dernier tour
            ecrireGrafxA("Last turn", 30, 260-15-i, 0xFFFF);
            break;
        case 6:
            // poser une route
            ecrireGrafxA("Use Ctrl/Del to change Train Cards", 30, 260-15-i, 0xFFFF);
            break;
        case 7:
            // déplacer le curseur
            ecrireGrafxA("Move the cursor over a route", 30, 260-15-i, 0xFFFF);
            break;
        case 8:
            // path indisponible
            ecrireGrafxA("This Route is already claimed", 30, 260-15-i, 0xFFFF);
            break;
        case 9:
            // pas assez de wagon
            ecrireGrafxA("You have not enough Wagon", 30, 260-15-i, 0xFFFF);
            break;
        case 10:
            // pas assez de cartes wagon
            ecrireGrafxA("You have not enough Train Car Card", 30, 260-15-i, 0xFFFF);
            break;

        case 11:
            // renseigner votre code pin
            ecrireGrafxA("Please, enter your numerical code.", 30, 260-15-i, 0xFFFF);
            break;
        }

        afficherBackScreen();
    }
    while (isKeyPressed(KEY_NSPIRE_DOC));
}

uint8 estimationDuNombreDeTourRestant() {
    if (tourRestant > 0) {
        return 0;
    }

    uint8 nbTour = 200;
    uint8 test;
    // si un des joueurs n'a plus beaucoup de wagon : retourner 0
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        if (joueurs[i].nbWagons < 3) {
            return 0;
        }
        // on se base sur des routes à 3
        test = round(joueurs[i].nbWagons / 3);
        if (joueurs[i].nbCartesWagon < test * 3) {
            test += round((((test * 3) - joueurs[i].nbCartesWagon) / 2) * 1.2); // nombre de cartes à piocher, en supposant qu'on ne pioche pas forcément les bonnes du premier coup
        }

        if (test < nbTour) {
            nbTour = test;
        }
    }
    return nbTour;
}

uint8 calculerMeilleurChoixIApourCarteWagon(uint8 numJoueur) {
    if (joueurs[numJoueur].bestCouleur[0] > 0) {
        for (uint8 i=0; i<5; i++) {
            if (choixCartesWagon[i] == joueurs[numJoueur].bestCouleur[0]) {
                return i;
            }
        }
    }
    if (joueurs[numJoueur].bestCouleur[1] > 0) {
        for (uint8 i=0; i<5; i++) {
            if (choixCartesWagon[i] == joueurs[numJoueur].bestCouleur[1]) {
                return i;
            }
        }
    }
    if (nbCartesWagonPioche > 0) {
        return 5;
    }
    // plus de cartes face cachée
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            return i;
        }
    }
    // là on est dans le .... : plus du tout de cartes
    return 8;
}

bool plusDeCartesRetournees() {
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            return false;
        }
    }
    return true;
}

bool joueurPeutAllerDeAaB(uint8 numJoueur, uint8 villeA, uint8 villeB) {
    pathfinder_reset();
    pathfinder_propagerPourJoueurPlusCourt(numJoueur, villeA);
    return pathfinder_ville[villeB].score > 0;
}

uint8 calculerMeilleurChoixIA(uint8 numJoueur) {
    for (uint8 i=0; i<3; i++) {
        joueurs[numJoueur].bestPaths[i] = -1;
        joueurs[numJoueur].bestCouleur[i] = -1;
    }
    for (uint8 i=1; i<MAX_PATH; i++) {
        paths[i].IAscore = 0;
    }

    // 0 à 4 : choix carte wagon déjà retournée
    //	5 : carte wagon de la pioche
    //	6 : carte mission
    //	7 : poser une route

    // calculer la meilleur route à prendre
    if (remplirTableauBestPaths(numJoueur)) {
        // on peut en revendiquer une maintenant
        return 7;
    }

    // si c'est le dernier tour : on essaye de revendiquer le plus long chemin possible
    if (tourRestant > 0) {
        joueurs[numJoueur].bestPaths[0] = -1;
        joueurs[numJoueur].bestPaths[1] = -1;

        for (uint8 i=1; i<MAX_PATH; i++) {
            if (joueurPeutRevendiquerCePath(numJoueur, i)) {
                if (joueurs[numJoueur].bestPaths[0] == -1) {
                    joueurs[numJoueur].bestPaths[0] = i;
                } else {
                    if (paths[i].distance > paths[joueurs[numJoueur].bestPaths[0]].distance) {
                        joueurs[numJoueur].bestPaths[0] = i;
                    }
                }
            }
        }
        if (joueurs[numJoueur].bestPaths[0] > 0) {
            return 7;
        }
    }


    // si toutes les missions sont réalisées : on pioche des cartes missions
    if (joueurToutesLesMissionsOk(numJoueur)) {
        // s'il reste des cartes dans la pioche et s'il reste encore quelques tours à jouer : piocher des missions
        if ((estimationDuNombreDeTourRestant() >= 2) && (nbCartesMissionPioche > 0)) {
            joueurs[numJoueur].bestPaths[0] = -1;
            joueurs[numJoueur].bestPaths[1] = -1;

            // si on peut géner un joueur humain, on le fait
            uint8 joueurHumain = 0;
            for (uint8 i=1; i<=nbTotalJoueur; i++) {
                if (joueurs[i].humain && (i != numJoueur)) {
                    joueurHumain = i;
                }
            }
            if (joueurHumain != 0) {
                for (uint8 i=1; i<MAX_PATH; i++) {
                    if (joueurPeutRevendiquerCePath(numJoueur, i)) {
                        // si les deux villes sont reliées par le joueur humain et si le joueur humain ne peut pas encore aller de la ville A à la ville B
                        if (joueurs[joueurHumain].villesAccessibles[paths[i].villeA] && joueurs[joueurHumain].villesAccessibles[paths[i].villeB]) {
                            if (!joueurPeutAllerDeAaB(joueurHumain, paths[i].villeA, paths[i].villeB)) {
                                if (joueurs[numJoueur].bestPaths[0] == 0) {
                                    joueurs[numJoueur].bestPaths[0] = i;
                                } else {
                                    if (paths[i].distance > paths[joueurs[numJoueur].bestPaths[0]].distance) {
                                        joueurs[numJoueur].bestPaths[0] = i;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (joueurs[numJoueur].bestPaths[0] > 0) {
                // hurk hurk hurk
                return 7;
            }

            return 6;
        } else {
            // on essaye de revendiquer le plus long chemin possible
            joueurs[numJoueur].bestPaths[0] = -1;
            joueurs[numJoueur].bestPaths[1] = -1;

            for (uint8 i=1; i<MAX_PATH; i++) {
                if (joueurPeutRevendiquerCePath(numJoueur, i)) {
                    if (joueurs[numJoueur].bestPaths[0] == -1) {
                        joueurs[numJoueur].bestPaths[0] = i;
                    } else {
                        if (paths[i].distance > paths[joueurs[numJoueur].bestPaths[0]].distance) {
                            joueurs[numJoueur].bestPaths[0] = i;
                        }
                    }
                }
            }
            if (joueurs[numJoueur].bestPaths[0] > 0) {
                return 7;
            }
        }
    }

    // en fonction des 2 couleurs de cartes à piocher
    // si aucune couleur retournée     : piocher 2 cartes face cachée
    // si une seule couleur retournée  : piocher une carte face cachée puis la couleur face visible
    // si les deux couleurs retournées : piocher les 2 cartes

    bool choix1Retournee = false;
    bool choix2Retournee = false;
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] == joueurs[numJoueur].bestCouleur[0]) {
            choix1Retournee = true;
        }
        if (choixCartesWagon[i] == joueurs[numJoueur].bestCouleur[1]) {
            choix2Retournee = true;
        }
    }
    if (nbCartesWagonPioche > 0) {
        if (!choix1Retournee && !choix2Retournee) {
            return 5;
        }
        if ((choix1Retournee && !choix2Retournee) || (choix2Retournee && !choix1Retournee)) {
            return 5;
        }
    }
    if (choix1Retournee) {
        for (uint8 i=0; i<5; i++) {
            if (choixCartesWagon[i] == joueurs[numJoueur].bestCouleur[0]) {
                return i;
            }
        }
    }
    if (choix2Retournee) {
        for (uint8 i=0; i<5; i++) {
            if (choixCartesWagon[i] == joueurs[numJoueur].bestCouleur[1]) {
                return i;
            }
        }
    }
    if (nbCartesWagonPioche > 0) {
        return 5;
    }
    // plus de cartes face cachée
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            return i;
        }
    }
    // plus de cartes face visible
    if (nbCartesMissionPioche > 0) {
        return 6;
    }
    return 8;
}


bool plusDeChoixSecondeCarte() {
    if (nbCartesWagonPioche > 0) {
        return false;
    }

    for (uint8 i=0; i<5; i++) {
        if ((choixCartesWagon[i] != 0xFF) && (choixCartesWagon[i] != COULEUR_LOCO)) {
            return false;
        }
    }
    return true;
}

uint8 getChiffre() {
    while (!isKeyPressed(KEY_NSPIRE_ESC)) {
        if (isKeyPressed(KEY_NSPIRE_0)) {
            while (isKeyPressed(KEY_NSPIRE_0));
            return 0;
        }
        if (isKeyPressed(KEY_NSPIRE_1)) {
            while (isKeyPressed(KEY_NSPIRE_1));
            return 1;
        }
        if (isKeyPressed(KEY_NSPIRE_2)) {
            while (isKeyPressed(KEY_NSPIRE_2));
            return 2;
        }
        if (isKeyPressed(KEY_NSPIRE_3)) {
            while (isKeyPressed(KEY_NSPIRE_3));
            return 3;
        }
        if (isKeyPressed(KEY_NSPIRE_4)) {
            while (isKeyPressed(KEY_NSPIRE_4));
            return 4;
        }
        if (isKeyPressed(KEY_NSPIRE_5)) {
            while (isKeyPressed(KEY_NSPIRE_5));
            return 5;
        }
        if (isKeyPressed(KEY_NSPIRE_6)) {
            while (isKeyPressed(KEY_NSPIRE_6));
            return 6;
        }
        if (isKeyPressed(KEY_NSPIRE_7)) {
            while (isKeyPressed(KEY_NSPIRE_7));
            return 7;
        }
        if (isKeyPressed(KEY_NSPIRE_8)) {
            while (isKeyPressed(KEY_NSPIRE_8));
            return 8;
        }
        if (isKeyPressed(KEY_NSPIRE_9)) {
            while (isKeyPressed(KEY_NSPIRE_9));
            return 9;
        }
    }
    return 99;
}

uint16 getPINCode(uint8 couleurW, uint16 couleurFonte, uint8 numJoueur) {
    // 126x48
    afficherGrafx_file(FILE_NEWGAME_FOND_HUMAN + couleurW, 87, 96, SCREEN_WORKING, 0xFFFF);

    afficherAideContextuelle(11);
    ecrireGrafxA("Enter code", 120, 106, couleurFonte);

    ecrireGrafxA(".", 145, 114, couleurFonte);
    ecrireGrafxA(".", 155, 114, couleurFonte);
    ecrireGrafxA(".", 165, 114, couleurFonte);
    ecrireGrafxA(".", 175, 114, couleurFonte);
    afficherBackScreen();
    uint8 c1 = getChiffre();
    if (c1 == 99) {
        return 19999;
    }

    ecrireGrafxA("*", 142, 120, couleurFonte);
    afficherBackScreen();
    uint8 c2 = getChiffre();
    if (c2 == 99) {
        return 19999;
    }

    ecrireGrafxA("*", 152, 120, couleurFonte);
    afficherBackScreen();
    uint8 c3 = getChiffre();
    if (c3 == 99) {
        return 19999;
    }

    ecrireGrafxA("*", 162, 120, couleurFonte);
    afficherBackScreen();
    uint8 c4 = getChiffre();
    if (c4 == 99) {
        return 19999;
    }

    ecrireGrafxA("*", 172, 120, couleurFonte);
    afficherBackScreen();

    uint16 pin = c1 * 1000 + c2 * 100 + c3 * 10 + c4;

    if (codePin[numJoueur] == 10000) {
        codePin[numJoueur] = pin;
    }
    return pin;
}

void rejouerAnimationRevendiquerRoute(uint8 numJoueur, uint8 numPath) {
    uint8 num = rand() % paths[numPath].distance;
    uint16 numPaveIA = paths[numPath].idxPave[num];

    sint16 iax = paves[numPaveIA].x - 160;
    sint16 iay = paves[numPaveIA].y - 105;
    if (iax < 0) {
        iax = 0;
    }
    if (iax > MAX_CARTE_X) {
        iax = MAX_CARTE_X;
    }
    if (iay < 0) {
        iay = 0;
    }
    if (iay > MAX_CARTE_Y) {
        iay = MAX_CARTE_Y;
    }

    // la carte doit être un multiple de 4
    uint16 IAcarteX = (iax >> 2) << 2;
    uint16 IAcarteY = (iay >> 2) << 2;

    num = rand() % paths[numPath].distance;
    numPaveIA = paths[numPath].idxPave[num];

    uint16 wagon = FILE_WAGON_BLUE_0_0 + paves[numPaveIA].rot;
    grafx_positionner_file(wagon);
    uint16 width = grafx_read2_file();
    uint16 height = grafx_read2_file();

    iax = paves[numPaveIA].x + round(width / 2) - IAcarteX;
    iay = paves[numPaveIA].y + round(height / 2) - IAcarteY;
    if (iax < 0) {
        iax = 0;
    }
    if (iax > 320) {
        iax = 320;
    }
    if (iay < 0) {
        iay = 0;
    }
    if (iay > 190) {
        iay = 190;
    }

    uint16 IAcurseurX = iax & 0xFFFE;
    cursorX = cursorX & 0xFFFE;
    uint16 IAcurseurY = iay & 0xFFFE;
    cursorY = cursorY & 0xFFFE;

    selectionnerPath(numPath, RAM_CARTE_VILLE_SELECT);

    // cartes payées = last paiement
    nbPaiementPossible = 1;
    for (uint8 i=0; i<6; i++) {
        paiementPossible[0][i] = lastPaiement[numJoueur][i];
    }

    // scroller
    bool continuer = TRUE;
    bool reconstruire = TRUE;
    bool afficher = TRUE;
    while (continuer) {
        if (reconstruire) {
            // le fond : la carte
            afficherCarte(xCarte,yCarte,284,222);
            // la carte foncée à droite
            afficherCarteSombre(284,0,319,222,xCarte,yCarte);
            // le bas ?
            afficherBas(numJoueur, 0);
            // conserver le fond
            empilerBackScr();

            afficher = true;
        }

        if (afficher) {
            afficher = false;

            // le fond
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // le curseur
            afficherGrafx_ram(RAM_CURSOR, cursorX-10, cursorY-1, SCREEN_WORKING, 0xFFFF);

            // les cartes à consommer
            uint16 ouX = 0;
            uint16 ouY = 0;
            if ((nbPaiementPossible > 0) && (numPath < 200)) {
                uint8 mod = 2;
                sint8 decalX = -18; // -26+8
                uint8 decalY = 24;

                if (paths[numPath].distance == 1) {
                    mod = 1;
                    decalX = -5; // -18+26/2
                }
                if (paths[numPath].distance > 4) {
                    mod = 3;
                    decalX = -31; // -26-26/2+8
                }
                // les ombres
                for (uint8 i=0; i<paths[numPath].distance; i++) {
                    ouX = cursorX+decalX + 26 * (i % mod);
                    ouY = cursorY+decalY + 18 * trunc(i / mod);
                    afficherGrafx_ram(RAM_MINI_CARD_SHADOW, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
                // les mini cartes
                for (uint8 i=0; i<paths[numPath].distance; i++) {
                    ouX = cursorX+decalX + 26 * (i % mod);
                    ouY = cursorY+decalY + 18 * trunc(i / mod);
                    afficherGrafx_ram(RAM_MINI_WAG_LOCO + paiementPossible[0][i], ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
            }
            afficherBackScreen();
        }

        if ((IAcarteX != xCarte) || (IAcarteY != yCarte)) {
            reconstruire = true;
            afficher = true;
            if (xCarte < IAcarteX - 8) {
                xCarte += 8;
            } else {
                if (xCarte < IAcarteX - 4) {
                    xCarte += 4;
                } else
                {
                    if (xCarte < IAcarteX) {
                        xCarte = IAcarteX;
                    }
                }
            }
            if (xCarte > IAcarteX + 8) {
                xCarte -= 8;
            } else {
                if (xCarte > IAcarteX + 4) {
                    xCarte -= 4;
                } else {
                    if (xCarte > IAcarteX) {
                        xCarte = IAcarteX;
                    }
                }
            }

            if (yCarte < IAcarteY - 8) {
                yCarte += 8;
            } else {
                if (yCarte < IAcarteY - 4) {
                    yCarte += 4;
                } else {
                    if (yCarte < IAcarteY) {
                        yCarte = IAcarteY;
                    }
                }
            }
            if (yCarte > IAcarteY + 8) {
                yCarte -= 8;
            } else {
                if (yCarte > IAcarteY + 4) {
                    yCarte -= 4;
                } else {
                    if (yCarte > IAcarteY) {
                        yCarte = IAcarteY;
                    }
                }
            }
        } else {
            afficher = true;
            if ((IAcurseurX != cursorX) || (IAcurseurY != cursorY)) {
                if (cursorX < IAcurseurX) {
                    cursorX += 2;
                }
                if (cursorX > IAcurseurX) {
                    cursorX -= 2;
                }
                if (cursorY < IAcurseurY) {
                    cursorY += 2;
                }
                if (cursorY > IAcurseurY) {
                    cursorY -= 2;
                }
            } else {
                continuer = FALSE;
            }
        }
    }

    //  placer les wagons (animation ?)
    revendiquerRoute(numPath, numJoueur);

    // payer les cartes
    payerRoute(numPath, 0, numJoueur);
}

void rejouerAnimationCarte(uint8 numJoueur, sint16 animationX, sint16 animationY, uint8 animationC, uint8 animationC2, uint8 selectionChoix) {
    uint16 ax = 0;
    uint16 ay = 0;

    empilerBackScr();
    // 1) de la droite vers le centre
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        if (i != 0) {
            depilerBackScr();
        }

        // de animationX, animationY vers (320-80)/2 , (240-52)/2
        ax = animationX - trunc(((animationX - 120) * i) / CPT_ANIMATION);
        ay = animationY - trunc(((animationY - 94) * i) / CPT_ANIMATION);
        afficherGrafx_ram(RAM_CARD_SHADOW80, ax-2, ay-2, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_ram(animationC, ax, ay, SCREEN_WORKING, 0xFFFF);

        afficherBackScreen();
    }

    // 2) du centre vers le bas
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        depilerBackScr();

        // de (320-80)/2 , (240-52)/2 vers (320-80)/2, 240
        ax = 35;
        ay = 40 - trunc(((40 - 240) * i) / CPT_ANIMATION);
        afficherGrafx_ram(RAM_CARD_SHADOW, ax-4, ay-4, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(animationC2, ax, ay, SCREEN_WORKING, 0xFFFF);

        afficherBackScreen();
    }

    uint8 carteWagon;
    // 3) consommer la carte et remettre la carte
    switch (selectionChoix) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
        // piocher une nouvelle carte et la remettre à sa place
        carteWagon = choixCartesWagon[selectionChoix];
        joueurs[numJoueur].lstCartesWagon[joueurs[numJoueur].nbCartesWagon++] = carteWagon;
        joueurs[numJoueur].nbCartes[carteWagon]++;
        // remettre une carte wagon
        piochePiocheCarteWagon(selectionChoix);
        if (choixCartesWagon[selectionChoix] != 0xFF) {
            for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
                depilerBackScr();

                // de 285 , 137 vers animationX, animationY
                ax = 290;
                ay = 137 - trunc(((137 - animationY) * i) / CPT_ANIMATION);
                afficherGrafx_ram(RAM_WAG_BACK_60, ax, ay, SCREEN_WORKING, 0xFFFF);

                afficherBackScreen();
            }
        }
        break;
    case 5:
        joueurPiocheCarteWagon(numJoueur);
        break;
    case 6:
        // piocher la carte mission
        if (nbCartesMissionPioche > 0) {
            nbCartesMissionPioche--;
        }
        break;
    }
}

void rejouerAnimationPiocherCartesMissions(uint8 numJoueur, uint8 nbCarte) {
    // pas de carte
    if (nbCarte == 0) {
        return;
    }

    uint8 nbCartePiochee = 0;
    for (uint8 i=0; i<3; i++) {
        if (nbCartesMissionPioche > 0) {
            nbCartePiochee++;
            rejouerAnimationCarte(numJoueur, 285-10, 3-10, RAM_MIS_BA_80, FILE_MIS_BA_NO, 6);
        }
    }

    // virer les cartes non conservées
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        if (i != 0) {
            depilerBackScr();
        }

        // de ouX, 240-17-40(240-52)/2 vers (320-80)/2, 240
        uint8 ouX = 18;
        uint16 ax = 0;
        uint16 ay = 0;
        for (uint8 j=0; j<nbCartePiochee - nbCarte; j++) {
            ax = ouX+10 - trunc(((ouX+10 - 285) * i) / CPT_ANIMATION);
            ay = 240-17-20 - trunc(((240-17-20 - 3) * i) / CPT_ANIMATION);
            afficherTicketDestination(numJoueur, 0, 60, ax, ay, true, true, false);
            ouX += 86;
        }

        afficherBackScreen();
    }
}

void rejouerAnimationPiocherCarteWagon(uint8 numJoueur, uint8 couleur) {
    // pas de carte
    if (couleur == 0) {
        return;
    }

    couleur--;
    // face cachée ?
    if (couleur == COULEUR_BACK) {
        rejouerAnimationCarte(numJoueur, 285-10, 137-10, RAM_WAG_BACK_80, FILE_WAG_BACK_NO, 5);
    } else {
        uint8 selectionChoix = 5;
        // trouver la couleur dans les cartes visibles
        for (uint8 i=0; i<5; i++) {
            if (choixCartesWagon[i] == couleur) {
                selectionChoix = i;
                break;
            }
        }
        rejouerAnimationCarte(numJoueur, 285-10, 3+39+5+selectionChoix*18-10, RAM_WAG_LOCO_80 + couleur, FILE_WAG_LOCO_NO + couleur, selectionChoix);
    }

    // A faire : 3 locos : vider les cartes retournées

}

void rejouerActionDuJoueur(uint8 numJoueur) {
    bool sav = joueurs[numJoueur].humain;
    joueurs[numJoueur].humain = false;
    afficherMiniChoix(numJoueur);

// 0000 : passer son tour
// 000F : nb de cartes mission piochées
// 00F0 : première carte piochée (attention couleur +1) de 1 à COULEUR_BACK+1
// 0F00 : seconde carte piochée : 0 pas de seconde carte piochée
// F000 : revendiquer une route, éventuellement stocker le n° du path dans un autre FF
    if (lastAction[numJoueur] > 0) {
        // en fonction du lastAction[numJoueur]
        if (lastAction[numJoueur] < 0x000F) {
            rejouerAnimationPiocherCartesMissions(numJoueur, lastAction[numJoueur]);
        } else {
            if (lastAction[numJoueur] == 0xF000) {
                rejouerAnimationRevendiquerRoute(numJoueur, lastPath[numJoueur]);
            } else {
                // 1ere carte
                rejouerAnimationPiocherCarteWagon(numJoueur, (lastAction[numJoueur] & 0x00F0) >> 4);
                // 2nde carte
                rejouerAnimationPiocherCarteWagon(numJoueur, (lastAction[numJoueur] & 0x0F00) >> 8);
            }
        }
    }

    joueurs[numJoueur].humain = sav;
}

void etatChoixJoueur(uint8 numJoueur, uint8 numSlot) {
    effacerMapSelection();

    // si la pioche de carte wagon est vide: la refaire
    if ((nbCartesWagonPioche == 0) && (nbCartesWagonDefausse > 0)) {
        refairePiocheWagon();
    }

    bool forcerPiocheCarteMission = false;
    if ((numeroTour == 0) && (joueurs[numJoueur].nbCartesMission == 0)) {
        // piocher les cartes missions du début
        forcerPiocheCarteMission = true;
    }

    // sauver la partie
    sauverPartie(numJoueur, numSlot);

    // Sauver le mode p&p avant le tour du joueur
    if (passAndPlayActif) {
        sauverPartie(numJoueur, numSlot + numJoueur * 10);
    }

    // Gérer le pass & play
    if (passAndPlayActif && joueurs[numJoueur].humain) {
        // Sauver les lastActions
        for (uint8 i=1; i<=nbTotalJoueur; i++) {
            lastAction[i] = joueurs[i].lastAction;
        }

        // afficher rapidement un écran pour éviter d'avoir une saute d'écran
        joueurs[numJoueur].humain = false;
        afficherMiniChoix(numJoueur);
        joueurs[numJoueur].humain = true;

        // demander le code pin
        uint16 tester = getPINCode(joueurs[numJoueur].couleurW, joueurs[numJoueur].couleurFonte, numJoueur);
        while (tester != codePin[numJoueur]) {
            if (tester == 19999) {
                etatGlobal = ETAT_LIBERATION_MEMOIRE;
                return;
            }
            joueurs[numJoueur].humain = false;
            afficherMiniChoix(numJoueur);
            joueurs[numJoueur].humain = true;
            tester = getPINCode(joueurs[numJoueur].couleurW, joueurs[numJoueur].couleurFonte, numJoueur);
        }


        // on recommence depuis le joueur humain juste après le joueur courant, jusqu'au joueur courant
        uint8 rejouerJoueur[12];
        for (uint8 i=0; i<12; i++) {
            rejouerJoueur[i] = 0;
        }
        uint8 maxi = 0;
        for (uint8 i=1; i<=nbTotalJoueur; i++) {
            rejouerJoueur[maxi++] = i;
        }
        for (uint8 i=1; i<=nbTotalJoueur; i++) {
            rejouerJoueur[maxi++] = i;
        }

        uint8 prochain = numJoueur;
        // cas particulier : premier tour, on remonte jusqu'au premier joueur humain trouvé ou jusqu'au bot "premier joueur"
        if (numeroTour == 0) {
            prochain = 0;
        } else {
            while (!joueurs[rejouerJoueur[prochain]].humain) {
                prochain++;
            }
        }
        // faire les actions des joueurs suivants jusqu'au joueur courant
        // en les mettant temporairement humain = false
        while (rejouerJoueur[prochain] != numJoueur) {
            if (!forcerPiocheCarteMission) {
                // charger la sauvegarde p&p de ce joueur (p&p = num joueur * 10 + slot
                chargerPartie(numSlot + rejouerJoueur[prochain] * 10);
            }
            rejouerActionDuJoueur(rejouerJoueur[prochain]);
            prochain++;
            if (rejouerJoueur[prochain] == 0) {
                prochain = 0;
            }
        }
        // recharger la partie pour être tranquille
        chargerPartie(numSlot);
    }

    // afficher rapidement un écran pour éviter d'avoir une saute d'écran
    afficherMiniChoix(numJoueur);

    // si la pioche de carte n'est pas vide, on regarde s'il manque des cartes retournées
    if (nbCartesWagonPioche > 0) {
        for (uint8 j=0; j<5; j++) {
            if ((choixCartesWagon[j] == 0xFF) && (nbCartesWagonPioche > 0)) {
                piochePiocheCarteWagon(j);
                if (choixCartesWagon[j] != 0xFF) {
                    empilerBackScr();
                    uint16 animationY = 3+39+5+j*18;
                    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
                        depilerBackScr();

                        // de 290,137 vers 285,animationY
                        uint16 ax = 290;
                        uint16 ay = 137 - trunc(((137 - animationY) * i) / CPT_ANIMATION);
                        afficherGrafx_ram(RAM_WAG_BACK_60, ax, ay, SCREEN_WORKING, 0xFFFF);

                        afficherBackScreen();
                    }
                    afficherMiniChoix(numJoueur);
                }
            }
        }
    }

    // remettre la carte
    if (joueurs[numJoueur].humain) {
        animerGoto(numJoueur, joueurs[numJoueur].xCarte, joueurs[numJoueur].yCarte);
    }

    // consommer la touche
    if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER)) {
        while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER));
    }

    bool afficher = true;
    bool reconstruire = true;
    bool animationEnCours = false;
    bool zoomEnCours = false;
    sint16 animationX = 0;
    sint16 animationY = 0;
    uint8 animationC = 0;
    uint8 animationC2 = 0;
    bool animationC2Mission = false;
    bool animationC2Realise = false;
    uint8 nbCartesPiochees = 0;
    nbChoixCarteMission = 0;
    bool IA = !joueurs[numJoueur].humain;
    uint8 carteWagon;
    uint8 selectionChoix = joueurs[numJoueur].selectionChoix;

    // recaler la carte
    if (xCarte > MAX_CARTE_X) {
        xCarte = MAX_CARTE_X;
    }
    if (yCarte > MAX_CARTE_Y) {
        yCarte = MAX_CARTE_Y;
    }

    if (IA) {
        animationEnCours = true;

        // gérer l'IA
        if (forcerPiocheCarteMission) {
            selectionChoix = 6;
        } else {
            selectionChoix = calculerMeilleurChoixIA(numJoueur);
        }

        switch (selectionChoix) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
            if (choixCartesWagon[selectionChoix] != 0xFF) {
                animationX = 285-10;
                animationY = 3+39+5+selectionChoix*18-10;
                animationC = RAM_WAG_LOCO_80 + choixCartesWagon[selectionChoix];
                animationC2 = FILE_WAG_LOCO_NO + choixCartesWagon[selectionChoix];
                animationC2Mission = false;
            }
            break;
        case 5:
            if (nbCartesWagonPioche > 0) {
                animationX = 285-10;
                animationY = 137-10;
                animationC = RAM_WAG_BACK_80;
                animationC2 = FILE_WAG_BACK_NO;
                animationC2Mission = false;
            }
            break;
        case 6:
            if (nbCartesMissionPioche > 0) {
                animationX = 285-10;
                animationY = 3-10;
                animationC = RAM_MIS_BA_80;
                animationC2 = FILE_MIS_BA_NO;
                animationC2Mission = false;
            }
            break;
        case 7:
            // poser un wagon
            if (joueurs[numJoueur].nbWagons > 0) {
                etatGlobal = ETAT_CHOIX_ROUTE;
            }
            break;
        case 8:
            // passer son tour
            joueurs[numJoueur].lastAction = 0;
            etatGlobal = ETAT_FIN_DU_TOUR;
            break;
        }


    } else {
        if (forcerPiocheCarteMission) {
            selectionChoix = 6;
            animationEnCours = true;
            animationX = 285-10;
            animationY = 3-10;
            animationC = RAM_MIS_BA_80;
            animationC2 = piocheCartesMission[nbCartesMissionPioche - 1]; // + FILE_MIS_01_NO
            animationC2Mission = true;
            animationC2Realise = false;
        } else {
            bool choixPossible[8];

            // 0..4 : face visible
            for (uint8 i=0; i<5; i++) {
                choixPossible[i] = choixCartesWagon[selectionChoix] != 0xFF;
            }
            choixPossible[5] = nbCartesWagonPioche > 0;
            choixPossible[6] = nbCartesMissionPioche > 0;
            choixPossible[7] = joueurs[numJoueur].nbWagons > 0;

            if (selectionChoix > 6) {
                selectionChoix = 7;
            }
            while (!choixPossible[selectionChoix]) {
                selectionChoix++;
                if (selectionChoix == 8) {
                    selectionChoix = 0;
                }
            }
        }

        if (joueurs[numJoueur].nbCartesMission > 0) {
            if (joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante]) {
                selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_OK);
            } else {
                selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_KO);
            }
        }
    }

    // Selection
    // 0..4 : carte wagon retournée
    // 5 	: carte wagon face cachée
    // 6	: carte mission
    // 7	: poser une route
    // 8	: passer son tour

    uint8 prochainEtat = etatGlobal;
    while (etatGlobal == ETAT_CHOIX_JOUEUR) {
        if (reconstruire) {
            // le fond : la carte
            afficherCarte(xCarte,yCarte,284,222);
            // la carte foncée à droite
            afficherCarteSombre(284,0,319,222,xCarte,yCarte);
            // le bas ?
            afficherBas(numJoueur, 0);
            // conserver le fond
            empilerBackScr();

            afficher = true;
        }

        if (afficher) {
            afficher = false;
            // le fond
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // afficher les cartes à droite
            // Mission
            if (selectionChoix != 6) {
                // carte mission
                if (nbCartesMissionPioche > 0) {
                    afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
                }
            }

            // Pioche cartes wagons retournés
            for (uint8 i=0; i<5; i++) {
                if ((i != selectionChoix) && (choixCartesWagon[i] != 0xFF)) {
                    // si c'est une loco et qu'on a déjà pioché une carte
                    if ((nbCartesPiochees > 0) && (choixCartesWagon[i] == COULEUR_LOCO)) {
                        afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285+10, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                    } else {
                        afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                    }
                }
            }
            // Pioche carte wagon face retournée
            if (nbCartesWagonPioche > 0) {
                if (selectionChoix != 5) {
                    afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                }
            }
            // le wagon pour revendiquer une route
            if (selectionChoix != 7) {
                if (joueurs[numJoueur].nbWagons > 0) {
                    afficherGrafx_ram(RAM_WAGON_60 + joueurs[numJoueur].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
                }
            }

            if (zoomEnCours) {
                afficher = true;
                zoomEnCours = false;
                switch (selectionChoix) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                    if (choixCartesWagon[selectionChoix] != 0xFF) {
                        afficherZoomCarte(FILE_WAG_LOCO_NO + choixCartesWagon[selectionChoix]);
                    }
                    break;
                case 5:
                    afficherZoomCarte(FILE_WAG_BACK_NO);
                    break;
                case 6:
                    afficherZoomCarte(FILE_MIS_BA_NO);
                    break;
                }
            } else {
                if (!animationEnCours) {
                    switch (selectionChoix) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                        if (choixCartesWagon[selectionChoix] != 0xFF) {
                            afficherGrafx_ram(RAM_CARD_SHADOW80, 285-10-2, 3+39+5+selectionChoix*18-10-2, SCREEN_WORKING, 0xFFFF);
                            afficherGrafx_ram(RAM_WAG_LOCO_80 + choixCartesWagon[selectionChoix], 285-10, 3+39+5+selectionChoix*18-10, SCREEN_WORKING, 0xFFFF);
                        }
                        afficherGrafx_ram(RAM_CURSOR, 285-10+14, 3+39+5+selectionChoix*18-10+36, SCREEN_WORKING, 0xFFFF);
                        break;
                    case 5:
                        if (nbCartesWagonPioche > 0) {
                            afficherGrafx_ram(RAM_CARD_SHADOW80, 285-10-2, 137-10-2, SCREEN_WORKING, 0xFFFF);
                            afficherGrafx_ram(RAM_WAG_BACK_80, 285-10, 137-10, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                            afficherGrafx_ram(RAM_CURSOR, 285-10+14, 137-10+36, SCREEN_WORKING, 0xFFFF);
                        }
                        break;
                    case 6:
                        afficherGrafx_ram(RAM_CARD_SHADOW80, 285-10-2, 3-10-2, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_ram(RAM_MIS_BA_80, 285-10, 3-10, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_ram(RAM_CURSOR, 285-10+14, 3-10+36, SCREEN_WORKING, 0xFFFF);
                        break;
                    case 7:
                        afficherGrafx_ram(RAM_WAGON_80 + joueurs[numJoueur].couleurW, 285-20, 137+39+5-10, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_ram(RAM_CURSOR, 285-10+14, 137+39+5-10+30, SCREEN_WORKING, 0xFFFF);
                        break;
                    }
                } else {
                    switch (selectionChoix) {
                    case 5:
                        if (nbCartesWagonPioche > 1) {
                            afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                        }
                        break;
                    case 6:
                        if (nbCartesMissionPioche > 1) {
                            afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
                        }
                        break;
                    }
                }
            }
            if (tourRestant > 0) {
                // afficher le marqueur Dernier tour
                afficherGrafx_ram(RAM_LAST_TURN, 0, 0, SCREEN_WORKING, 0xFFFF);
            }

            if (!animationEnCours || IA) {
                afficherBackScreen();
            }
        }

        if (prochainEtat != etatGlobal) {
            etatGlobal = prochainEtat;
        } else {
            // gérer les touches
            if (!animationEnCours) {
                // toujours pouvoir scroller la carte
                if (scrollerCarte(numJoueur)) {
                    joueurs[numJoueur].xCarte = xCarte;
                    joueurs[numJoueur].yCarte = yCarte;
                    reconstruire = true;
                }
                // mini carte
                if (isKeyPressed(KEY_NSPIRE_5)) {
                    afficherMiniCarte(true);
                    afficher = true;
                }
                // Zoom sur la carte
                if (isKeyPressed(KEY_NSPIRE_TAB) && (selectionChoix != 7)) {
                    zoomEnCours = true;
                    afficher = true;
                }
                // afficher la main du joueur
                if (isKeyPressed(KEY_NSPIRE_MENU)) {
                    afficherMainJoueur(numJoueur);
                    afficher = true;
                }

                // aide contextuelle
                if (isKeyPressed(KEY_NSPIRE_DOC)) {
                    if (nbCartesPiochees == 1) {
                        afficherAideContextuelle(4);
                    } else {
                        if (tourRestant > 0) {
                            afficherAideContextuelle(5);
                        } else {
                            afficherAideContextuelle(3);
                        }
                    }
                    afficher = true;
                }

                // changer le bas
                if (isKeyPressed(KEY_NSPIRE_SHIFT)) {
                    reconstruire = true;
                    joueurs[numJoueur].affichageBas++;
                    if (joueurs[numJoueur].affichageBas == 2) {
                        joueurs[numJoueur].affichageBas = 0;
                    }
                    while (isKeyPressed(KEY_NSPIRE_SHIFT));
                }
                // choisir la mission
                if (isKeyPressed(KEY_NSPIRE_SCRATCHPAD)) {
                    reconstruire = true;
                    if (afficherMissionCourante(numJoueur)) {
                        effacerMapSelection();
                        if (joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante]) {
                            selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_OK);
                        } else {
                            selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_KO);
                        }
                    }
                }

                // Choix suivant
                if (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN)) {
                    afficher = true;
                    if (nbCartesPiochees == 1) {
                        // rester sur le choix des cartes 0..5
                        switch (selectionChoix) {
                        case 0:
                        case 1:
                        case 2:
                        case 3:
                        case 4:
                            selectionChoix++;
                            while ((selectionChoix < 5) && ((choixCartesWagon[selectionChoix] == 0xFF) || (choixCartesWagon[selectionChoix] == COULEUR_LOCO))) {
                                selectionChoix++;
                            }
                            break;
                        }

                    } else {
                        switch (selectionChoix) {
                        case 0:
                        case 1:
                        case 2:
                        case 3:
                        case 4:
                            selectionChoix++;
                            while ((selectionChoix < 5) && ((choixCartesWagon[selectionChoix] == 0xFF) || ((nbCartesPiochees > 0) && (choixCartesWagon[selectionChoix] == COULEUR_LOCO)))) {
                                selectionChoix++;
                            }
                            if ((selectionChoix == 5) && (nbCartesWagonPioche == 0)) {
                                selectionChoix = 7;
                            }

                            break;
                        case 5:
                            selectionChoix = 7;
                            break;
                        case 6:
                            selectionChoix = 0;
                            bool ok = choixCartesWagon[selectionChoix] != 0xFF;
                            if (ok && (nbCartesPiochees > 0)) {
                                ok = choixCartesWagon[selectionChoix] != COULEUR_LOCO;
                            }
                            while (!ok) {
                                selectionChoix++;
                                if (selectionChoix > 5) {
                                    selectionChoix = 7;
                                    ok = true;
                                } else {
                                    if (selectionChoix == 5) {
                                        ok = nbCartesWagonPioche > 0;
                                    } else {
                                        ok = choixCartesWagon[selectionChoix] != 0xFF;
                                        if (ok && (nbCartesPiochees > 0)) {
                                            ok = choixCartesWagon[selectionChoix] != COULEUR_LOCO;
                                        }
                                    }
                                }
                            }
                            break;
                        }
                    }
                    while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN));
                }
                // Choix précédent
                if (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP)) {
                    afficher = true;

                    bool remonter = false;
                    if (nbCartesPiochees == 1) {
                        // rester sur choix des cartes 0..5
                        switch (selectionChoix) {
                        case 1:
                        case 2:
                        case 3:
                        case 4:
                        case 5:
                            selectionChoix--;
                            while ((selectionChoix != 0) && ((choixCartesWagon[selectionChoix] == 0xFF) || (choixCartesWagon[selectionChoix] == COULEUR_LOCO))) {
                                selectionChoix--;
                            }
                            break;
                        }

                    } else {
                        switch (selectionChoix) {
                        case 0:
                            selectionChoix = 6;
                            remonter = nbCartesMissionPioche == 0;
                            break;

                        case 1:
                        case 2:
                        case 3:
                        case 4:
                        case 5:
                            selectionChoix--;
                            while ((selectionChoix != 6) && ((choixCartesWagon[selectionChoix] == 0xFF) || ((nbCartesPiochees > 0) && (choixCartesWagon[selectionChoix] == COULEUR_LOCO)))) {
                                if (selectionChoix == 0) {
                                    selectionChoix = 6;
                                } else {
                                    selectionChoix--;
                                }
                            }
                            if (selectionChoix == 6) {
                                remonter = nbCartesMissionPioche == 0;
                            }

                            break;
                        case 7:
                            selectionChoix = 5;
                            if (nbCartesWagonPioche == 0) {
                                selectionChoix = 4;
                                while ((selectionChoix != 6) && ((choixCartesWagon[selectionChoix] == 0xFF) || ((nbCartesPiochees > 0) && (choixCartesWagon[selectionChoix] == COULEUR_LOCO)))) {
                                    if (selectionChoix == 0) {
                                        selectionChoix = 6;
                                    } else {
                                        selectionChoix--;
                                    }
                                }
                                if (selectionChoix == 6) {
                                    remonter = nbCartesMissionPioche == 0;
                                }
                            }
                            break;
                        }

                        while (remonter) {
                            if (selectionChoix == 6) {
                                selectionChoix = 0;
                            } else {
                                if (selectionChoix == 5) {
                                    selectionChoix = 7;
                                } else {
                                    selectionChoix++;
                                }
                            }
                            switch (selectionChoix) {
                            case 0:
                            case 1:
                            case 2:
                            case 3:
                            case 4:
                                remonter = choixCartesWagon[selectionChoix] == 0xFF;
                                if (!remonter && (nbCartesPiochees > 0)) {
                                    remonter = choixCartesWagon[selectionChoix] == COULEUR_LOCO;
                                }
                                break;

                            case 5:
                                remonter = nbCartesWagonPioche == 0;
                                break;

                            case 7:
                                remonter = false;
                                break;
                            }
                        }
                    }
                    while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP));
                }

                // Valider choix
                if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER)) {
                    joueurs[numJoueur].selectionChoix = selectionChoix;
                    switch (selectionChoix) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                        if ((choixCartesWagon[selectionChoix] != 0xFF) && ((nbCartesPiochees == 0) || (choixCartesWagon[selectionChoix] != COULEUR_LOCO))) {
                            animationEnCours = true;
                            afficher = true;
                            animationX = 285-10;
                            animationY = 3+39+5+selectionChoix*18-10;
                            animationC = RAM_WAG_LOCO_80 + choixCartesWagon[selectionChoix];
                            animationC2 = FILE_WAG_LOCO_NO + choixCartesWagon[selectionChoix];
                            animationC2Mission = false;
                        }
                        break;
                    case 5:
                        if (nbCartesWagonPioche > 0) {
                            animationEnCours = true;
                            afficher = true;
                            animationX = 285-10;
                            animationY = 137-10;
                            animationC = RAM_WAG_BACK_80;
                            if (IA) {
                                animationC2 = FILE_WAG_BACK_NO;
                            } else {
                                animationC2 = FILE_WAG_LOCO_NO + piocheCartesWagon[nbCartesWagonPioche - 1];
                            }
                            animationC2Mission = false;
                        }
                        break;
                    case 6:
                        if (nbCartesMissionPioche > 0) {
                            animationEnCours = true;
                            afficher = true;
                            animationX = 285-10;
                            animationY = 3-10;
                            animationC = RAM_MIS_BA_80;
                            if (IA) {
                                animationC2 = FILE_MIS_BA_NO;
                                animationC2Mission = false;
                            } else {
                                animationC2 = piocheCartesMission[nbCartesMissionPioche - 1]; // + FILE_MIS_01_NO
                                animationC2Mission = true;
                                animationC2Realise = testerMissionRealisse(numJoueur, animationC2);
                            }
                        }
                        break;
                    case 7:
                        // poser un wagon
                        if (joueurs[numJoueur].nbWagons > 0) {
                            etatGlobal = ETAT_CHOIX_ROUTE;
                        }
                        break;
                    }

                    while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER));
                }

                // sortir : à revoir. 1 sortie rapide et 1 sortie vers le menu
                if (isKeyPressed(KEY_NSPIRE_ESC)) {
                    etatGlobal = ETAT_LIBERATION_MEMOIRE;
                }
            } else {
                // animation en cours...
                empilerBackScr();

                // faire l'animation x fois
                uint8 nbAnimation = 1;
                if (selectionChoix == 6) {
                    nbAnimation = 3;
                    if (nbAnimation > nbCartesMissionPioche) {
                        nbAnimation = nbCartesMissionPioche;
                    }
                }

                uint16 ax = 0;
                uint16 ay = 0;

                for (uint8 nb=0; nb < nbAnimation; nb++) {
                    // 1) de la droite vers le centre
                    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
                        if (i != 0) {
                            depilerBackScr();
                        }

                        // de animationX, animationY vers (320-80)/2 , (240-52)/2
                        ax = animationX - trunc(((animationX - 120) * i) / CPT_ANIMATION);
                        ay = animationY - trunc(((animationY - 94) * i) / CPT_ANIMATION);
                        afficherGrafx_ram(RAM_CARD_SHADOW80, ax-2, ay-2, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_ram(animationC, ax, ay, SCREEN_WORKING, 0xFFFF);

                        afficherBackScreen();
                    }

                    // 2) du centre vers le bas
                    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
                        depilerBackScr();

                        // de (320-80)/2 , (240-52)/2 vers (320-80)/2, 240
                        ax = 35;
                        ay = 40 - trunc(((40 - 240) * i) / CPT_ANIMATION);
                        if (animationC2Mission) {
                            afficherTicketDestination(numJoueur, animationC2, 100, ax, ay, true, IA, animationC2Realise);
                        } else {
                            afficherGrafx_ram(RAM_CARD_SHADOW, ax-4, ay-4, SCREEN_WORKING, 0xFFFF);
                            afficherGrafx_file(animationC2, ax, ay, SCREEN_WORKING, 0xFFFF);
                        }

                        afficherBackScreen();
                    }

                    if (selectionChoix == 6) {
                        // afficher la mini carte misison
                        depilerBackScr();
                        afficherTicketDestination(numJoueur, animationC2, 80, 18+86*nb, 240-17-30, false, IA, animationC2Realise);
                        empilerBackScr();
                    }

                    // 3) consommer la carte et remettre la carte
                    switch (selectionChoix) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                        // piocher une nouvelle carte et la remettre à sa place
                        carteWagon = choixCartesWagon[selectionChoix];
                        if (nbCartesPiochees == 0) {
                            joueurs[numJoueur].lastAction = ((carteWagon + 1) << 4);
                        } else {
                            joueurs[numJoueur].lastAction = joueurs[numJoueur].lastAction + ((carteWagon + 1) << 8);
                        }
                        nbCartesPiochees++;
                        if (carteWagon == COULEUR_LOCO) {
                            nbCartesPiochees++;
                        }
                        joueurs[numJoueur].lstCartesWagon[joueurs[numJoueur].nbCartesWagon++] = carteWagon;
                        joueurs[numJoueur].nbCartes[carteWagon]++;

                        // remettre une carte wagon
                        piochePiocheCarteWagon(selectionChoix);
                        if (choixCartesWagon[selectionChoix] != 0xFF) {
                            for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
                                depilerBackScr();

                                // de 285 , 137 vers animationX, animationY
                                ax = 290;
                                ay = 137 - trunc(((137 - animationY) * i) / CPT_ANIMATION);
                                afficherGrafx_ram(RAM_WAG_BACK_60, ax, ay, SCREEN_WORKING, 0xFFFF);

                                afficherBackScreen();
                            }
                        }
                        if ((nbCartesPiochees == 2) || plusDeChoixSecondeCarte()) {
                            prochainEtat = ETAT_FIN_DU_TOUR;
                            animationEnCours = false;
                            selectionChoix = 8;
                        }
                        break;
                    case 5:
                        if (nbCartesPiochees == 0) {
                            joueurs[numJoueur].lastAction = (COULEUR_BACK + 1) << 4;
                        } else {
                            joueurs[numJoueur].lastAction = joueurs[numJoueur].lastAction + ((COULEUR_BACK + 1) << 8);
                        }
                        joueurPiocheCarteWagon(numJoueur);
                        nbCartesPiochees++;
                        if (nbCartesPiochees == 2) {
                            prochainEtat = ETAT_FIN_DU_TOUR;
                            animationEnCours = false;
                            selectionChoix = 8;
                        }
                        break;
                    case 6:
                        // piocher la carte mission
                        piocherChoixCarteMission();
                        if (!IA && (nbCartesMissionPioche > 0)) {
                            animationC2 = piocheCartesMission[nbCartesMissionPioche - 1]; // + FILE_MIS_01_NO
                            animationC2Mission = true;
                            animationC2Realise = testerMissionRealisse(numJoueur, animationC2);
                        }
                        break;
                    }
                }

                // 5) trois loco ?
                while (troisLocoRetournees()) {
                    // sauver le fond sans les cartes wagons
                    // le fond : la carte
                    afficherCarte(xCarte,yCarte,284,222);
                    // la carte foncée à droite
                    afficherCarteSombre(284,0,319,222,xCarte,yCarte);
                    // le bas ?
                    afficherBas(numJoueur, 0);
                    // carte mission
                    if (nbCartesMissionPioche > 0) {
                        afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
                    }
                    if (joueurs[numJoueur].nbWagons > 0) {
                        afficherGrafx_ram(RAM_WAGON_60 + joueurs[numJoueur].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
                    }
                    // conserver le fond
                    empilerBackScr();

                    // afficher les 3 locos un peu plus sur la gauche
                    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
                        if (i != 0) {
                            depilerBackScr();
                        }
                        for (uint8 j=0; j<5; j++) {
                            if (choixCartesWagon[j] != 0xFF) {
                                if (choixCartesWagon[j] == COULEUR_LOCO) {
                                    afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[j], 285-10, 3+39+5+j*18, SCREEN_WORKING, 0xFFFF);
                                } else {
                                    afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[j], 285, 3+39+5+j*18, SCREEN_WORKING, 0xFFFF);
                                }
                            }
                        }
                        if (nbCartesWagonPioche > 0) {
                            afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                        }
                        afficherBackScreen();
                    }

                    // 1) remettre les cartes dans la pioche
                    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
                        depilerBackScr();
                        for (uint8 j=0; j<5; j++) {
                            if (choixCartesWagon[j] != 0xFF) {
                                ay = 3+39+5+j*18 - trunc(((3+39+5+j*18 - 137) * i) / CPT_ANIMATION);
                                afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[j], 285, ay, SCREEN_WORKING, 0xFFFF);
                            }
                        }
                        if (nbCartesWagonPioche > 0) {
                            afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                        }
                        afficherBackScreen();
                    }
                    // 2) melanger la pioche
                    defausserPiocheWagon();
                    refairePiocheWagon();
                    // 3) re piocher 5 cartes
                    for (uint8 i=0; i<5; i++) {
                        piochePiocheCarteWagon(i);
                    }
                    // 4) afficher les cartes
                    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
                        depilerBackScr();
                        for (uint8 j=0; j<5; j++) {
                            if ((j != selectionChoix) && (choixCartesWagon[j] != 0xFF)) {
                                ay = 137 - trunc(((137 - (3+39+5+j*18)) * i) / CPT_ANIMATION);
                                afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[j], 285, ay, SCREEN_WORKING, 0xFFFF);
                            }
                        }
                        if (nbCartesWagonPioche > 0) {
                            afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                        }
                        afficherBackScreen();
                    }
                }
                if (selectionChoix == 6) {
                    etatGlobal = ETAT_CHOISIR_CARTES_MISSIONS;
                } else {
                    // si plus de cartes possibles : FIN DU TOUR
                    if ((selectionChoix < 6) && (etatGlobal != ETAT_FIN_DU_TOUR) && (nbCartesWagonPioche == 0) && plusDeCartesRetournees()) {
                        etatGlobal = ETAT_FIN_DU_TOUR;
                    }
                }

                reconstruire = true;
                animationEnCours = false;

                if (IA && (selectionChoix < 6) && (nbCartesPiochees < 2)) {
                    selectionChoix = calculerMeilleurChoixIApourCarteWagon(numJoueur);
                    switch (selectionChoix) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                        if (choixCartesWagon[selectionChoix] != 0xFF) {
                            animationX = 285-10;
                            animationY = 3+39+5+selectionChoix*18-10;
                            animationC = RAM_WAG_LOCO_80 + choixCartesWagon[selectionChoix];
                            animationC2 = FILE_WAG_LOCO_NO + choixCartesWagon[selectionChoix];
                            animationC2Mission = false;
                        }
                        break;
                    case 5:
                        if (nbCartesWagonPioche > 0) {
                            animationX = 285-10;
                            animationY = 137-10;
                            animationC = RAM_WAG_BACK_80;
                            animationC2 = FILE_WAG_BACK_NO;
                            animationC2Mission = false;
                        }
                        break;
                    }

                    animationEnCours = true;
                }
            }
        }
    }
}

uint8 remplirChoixPaiementWagon(uint8 numJoueur, uint8 numPath) {
    nbPaiementPossible = 0;
    memset(paiementPossible, 0, sizeof(paiementPossible));
    if (!estDisponible(numJoueur, numPath)) {
        return 8;
    }
    if (joueurs[numJoueur].nbWagons < paths[numPath].distance) {
        return 9;
    }

    // remplir les possibilités
    if (paths[numPath].couleur == 0) {
        // cas particulier : route en loco
        uint8 nbMax = paths[numPath].distance;
        uint8 nbLoco = 0;
        while (nbLoco < nbMax) {
            uint8 nbCouleur = nbMax - nbLoco;
            for (uint8 couleur = 8; couleur > 0; couleur--) {
                if ((joueurs[numJoueur].nbCartes[couleur] >= nbCouleur) && (joueurs[numJoueur].nbCartes[0] >= nbLoco)) {
                    // une possibilité : nbCouleur + nbLoco
                    uint8 idx = 0;
                    for (uint8 i = 0; i < nbCouleur; i++) {
                        paiementPossible[nbPaiementPossible][idx++] = couleur;
                    }
                    for (uint8 i = 0; i < nbLoco; i++) {
                        paiementPossible[nbPaiementPossible][idx++] = 0;
                    }
                    nbPaiementPossible++;
                }
            }
            nbLoco++;
        }
        // que des locos
        if (joueurs[numJoueur].nbCartes[0] == nbMax) {
            for (uint8 i = 0; i < nbMax; i++) {
                paiementPossible[nbPaiementPossible][i] = 0;
            }
            nbPaiementPossible++;
        }

        // mettre en premier le chemin le plus intéressant pour l'IA (sans loco et/ou si la couleur n'est pas utilisée pour une autre route)
        if (!joueurs[numJoueur].humain) {
            trierPaiementPossiblePourIA(paths[numPath].distance);
        }

    } else {
        // route d'une couleur
        uint8 nbMax = paths[numPath].distance;
        uint8 nbLoco = 0;
        while (nbLoco <= nbMax) {
            uint8 nbCouleur = nbMax - nbLoco;
            if ((joueurs[numJoueur].nbCartes[paths[numPath].couleur] >= nbCouleur) && (joueurs[numJoueur].nbCartes[0] >= nbLoco)) {
                // une possibilité : nbCouleur + nbLoco
                uint8 idx = 0;
                for (uint8 i = 0; i < nbCouleur; i++) {
                    paiementPossible[nbPaiementPossible][idx++] = paths[numPath].couleur;
                }
                for (uint8 i = 0; i < nbLoco; i++) {
                    paiementPossible[nbPaiementPossible][idx++] = 0;
                }
                nbPaiementPossible++;
            }
            nbLoco++;
        }
    }

    if (nbPaiementPossible == 0) {
        return 10;
    }
    return 6;
}

void etatChoixRouteJoueur(uint8 numJoueur, uint8 numSlot) {
    bool afficher = true;
    bool reconstruire = true;
    uint8 selectionChoix = 0;
    bool tester = true;
    uint8 numPath = 0xFF;
    uint8 savNumPath = numPath;
    bool IA = !joueurs[numJoueur].humain;
    uint16 IAcarteX = 0;
    uint16 IAcarteY = 0;
    uint16 IAcurseurX = 160;
    uint16 IAcurseurY = 105;
    uint8 numPathIA = 2;
    uint8 aideContextuelle = 7;

    effacerMapSelection();
    if (IA) {
        if ((joueurs[numJoueur].bestPaths[0] >= 0) && joueurPeutRevendiquerCePath(numJoueur, joueurs[numJoueur].bestPaths[0])) {
            numPathIA = 0;
        } else {
            if ((joueurs[numJoueur].bestPaths[1] >= 0) && joueurPeutRevendiquerCePath(numJoueur, joueurs[numJoueur].bestPaths[1])) {
                numPathIA = 1;
            }
        }
        numPath = joueurs[numJoueur].bestPaths[numPathIA];
        uint8 num = rand() % paths[numPath].distance;
        uint16 numPaveIA = paths[numPath].idxPave[num];

        sint16 iax = paves[numPaveIA].x - 160;
        sint16 iay = paves[numPaveIA].y - 105;
        if (iax < 0) {
            iax = 0;
        }
        if (iax > MAX_CARTE_X) {
            iax = MAX_CARTE_X;
        }
        if (iay < 0) {
            iay = 0;
        }
        if (iay > MAX_CARTE_Y) {
            iay = MAX_CARTE_Y;
        }

        // la carte doit être un multiple de 4
        IAcarteX = (iax >> 2) << 2;
        IAcarteY = (iay >> 2) << 2;

        num = rand() % paths[numPath].distance;
        numPaveIA = paths[numPath].idxPave[num];

        uint16 wagon = FILE_WAGON_BLUE_0_0 + paves[numPaveIA].rot;
        grafx_positionner_file(wagon);
        uint16 width = grafx_read2_file();
        uint16 height = grafx_read2_file();

        iax = paves[numPaveIA].x + round(width / 2) - IAcarteX;
        iay = paves[numPaveIA].y + round(height / 2) - IAcarteY;
        if (iax < 0) {
            iax = 0;
        }
        if (iax > 320) {
            iax = 320;
        }
        if (iay < 0) {
            iay = 0;
        }
        if (iay > 190) {
            iay = 190;
        }

        IAcurseurX = iax & 0xFFFE;
        cursorX = cursorX & 0xFFFE;
        IAcurseurY = iay & 0xFFFE;
        cursorY = cursorY & 0xFFFE;

        selectionnerPath(numPath, RAM_CARTE_VILLE_SELECT);
        // voir le meilleur paiement
        remplirChoixPaiementWagon(numJoueur, numPath);
    } else {
        if (joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante]) {
            selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_OK);
        } else {
            selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_KO);
        }
    }

    while (etatGlobal == ETAT_CHOIX_ROUTE) {
        if (reconstruire) {
            // le fond : la carte
            afficherCarte(xCarte,yCarte,284,222);
            // la carte foncée à droite
            afficherCarteSombre(284,0,319,222,xCarte,yCarte);
            // le bas ?
            afficherBas(numJoueur, 0);
            // conserver le fond
            empilerBackScr();

            afficher = true;
        }

        if (afficher) {
            afficher = false;

            // le fond
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // le curseur
            afficherGrafx_ram(RAM_CURSOR, cursorX-10, cursorY-1, SCREEN_WORKING, 0xFFFF);

            // les cartes à consommer
            uint16 ouX = 0;
            uint16 ouY = 0;
            if ((nbPaiementPossible > 0) && (numPath < 200)) {
                uint8 mod = 2;
                sint8 decalX = -18; // -26+8
                uint8 decalY = 24;

                if (paths[numPath].distance == 1) {
                    mod = 1;
                    decalX = -5; // -18+26/2
                }
                if (paths[numPath].distance > 4) {
                    mod = 3;
                    decalX = -31; // -26-26/2+8
                }
                // les ombres
                for (uint8 i=0; i<paths[numPath].distance; i++) {
                    ouX = cursorX+decalX + 26 * (i % mod);
                    ouY = cursorY+decalY + 18 * trunc(i / mod);
                    afficherGrafx_ram(RAM_MINI_CARD_SHADOW, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
                // les mini cartes
                for (uint8 i=0; i<paths[numPath].distance; i++) {
                    ouX = cursorX+decalX + 26 * (i % mod);
                    ouY = cursorY+decalY + 18 * trunc(i / mod);
                    afficherGrafx_ram(RAM_MINI_WAG_LOCO + paiementPossible[selectionChoix][i], ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
            }
            afficherBackScreen();
        }

        if (IA) {
            if ((IAcarteX != xCarte) || (IAcarteY != yCarte)) {
                reconstruire = true;
                afficher = true;
                if (xCarte < IAcarteX - 8) {
                    xCarte += 8;
                } else {
                    if (xCarte < IAcarteX - 4) {
                        xCarte += 4;
                    } else
                    {
                        if (xCarte < IAcarteX) {
                            xCarte = IAcarteX;
                        }
                    }
                }
                if (xCarte > IAcarteX + 8) {
                    xCarte -= 8;
                } else {
                    if (xCarte > IAcarteX + 4) {
                        xCarte -= 4;
                    } else {
                        if (xCarte > IAcarteX) {
                            xCarte = IAcarteX;
                        }
                    }
                }

                if (yCarte < IAcarteY - 8) {
                    yCarte += 8;
                } else {
                    if (yCarte < IAcarteY - 4) {
                        yCarte += 4;
                    } else {
                        if (yCarte < IAcarteY) {
                            yCarte = IAcarteY;
                        }
                    }
                }
                if (yCarte > IAcarteY + 8) {
                    yCarte -= 8;
                } else {
                    if (yCarte > IAcarteY + 4) {
                        yCarte -= 4;
                    } else {
                        if (yCarte > IAcarteY) {
                            yCarte = IAcarteY;
                        }
                    }
                }
            } else {
                afficher = true;
                if ((IAcurseurX != cursorX) || (IAcurseurY != cursorY)) {
                    if (cursorX < IAcurseurX) {
                        cursorX += 2;
                    }
                    if (cursorX > IAcurseurX) {
                        cursorX -= 2;
                    }
                    if (cursorY < IAcurseurY) {
                        cursorY += 2;
                    }
                    if (cursorY > IAcurseurY) {
                        cursorY -= 2;
                    }
                } else {
                    revendiquerRoute(numPath, numJoueur);
                    payerRoute(numPath, 0, numJoueur);
                    etatGlobal = ETAT_FIN_DU_TOUR;
                }
            }
        } else {
            // toujours pouvoir scroller la carte
            if (scrollerCarte(numJoueur)) {
                joueurs[numJoueur].xCarte = xCarte;
                joueurs[numJoueur].yCarte = yCarte;
                afficher = true;
                reconstruire = true;
                tester = true;
                nbPaiementPossible = 0;
            }
            if (autoScroll()) {
                joueurs[numJoueur].xCarte = xCarte;
                joueurs[numJoueur].yCarte = yCarte;
                afficher = true;
                reconstruire = true;
                tester = true;
                nbPaiementPossible = 0;
            } else {
                if (scrollerCurseur()) {
                    afficher = true;
                    tester = true;
                    nbPaiementPossible = 0;
                }
            }
            // mini carte
            if (isKeyPressed(KEY_NSPIRE_5)) {
                afficherMiniCarte(true);
                afficher = true;
            }
            // afficher la main du joueur
            if (isKeyPressed(KEY_NSPIRE_MENU)) {
                afficherMainJoueur(numJoueur);
                afficher = true;
            }
            // changer le bas
            if (isKeyPressed(KEY_NSPIRE_SHIFT)) {
                reconstruire = true;
                joueurs[numJoueur].affichageBas++;
                if (joueurs[numJoueur].affichageBas == 2) {
                    joueurs[numJoueur].affichageBas = 0;
                }
                while (isKeyPressed(KEY_NSPIRE_SHIFT));
            }

            // choisir la mission
            if (isKeyPressed(KEY_NSPIRE_SCRATCHPAD)) {
                afficher = true;
                reconstruire = true;
                if (afficherMissionCourante(numJoueur)) {
                    effacerMapSelection();
                    if (joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante]) {
                        selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_OK);
                    } else {
                        selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_KO);
                    }
                    if ((numPath < 200) && (nbPaiementPossible > 0)) {
                        selectionnerPath(numPath, RAM_CARTE_VILLE_SELECT);
                    }
                }
            }

            if (tester && !any_key_pressed()) {
                tester = false;
                numPath = routeSousCurseur((cursorX + xCarte) >> 1, (cursorY + yCarte) >> 1);
                if (numPath < 200) {
                    // peut-on réclamer cette route ?
                    aideContextuelle = remplirChoixPaiementWagon(numJoueur, numPath);
                    selectionChoix = 0;
                    afficher = true;
                } else {
                    aideContextuelle = 7;
                }

                if (savNumPath != numPath) {
                    savNumPath = numPath;
                    effacerMapSelection();
                    if (joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante]) {
                        selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_OK);
                    } else {
                        selectionnerMission(joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], RAM_CARTE_VILLE_KO);
                    }
                    if ((numPath < 200) && (nbPaiementPossible > 0)) {
                        selectionnerPath(numPath, RAM_CARTE_VILLE_SELECT);
                        aideContextuelle = 6;
                    }
                    reconstruire = true;
                }
            }

            // aide contextuelle
            if (isKeyPressed(KEY_NSPIRE_DOC) && (numPath < 200)) {
                afficherAideContextuelle(aideContextuelle);
                afficher = true;
            }

            // choix suivant
            if (isKeyPressed(KEY_NSPIRE_DEL) && (numPath < 200)) {
                if (selectionChoix < (nbPaiementPossible - 1)) {
                    selectionChoix++;
                } else {
                    selectionChoix = 0;
                }
                afficher = true;
                while (isKeyPressed(KEY_NSPIRE_DEL));
            }
            // choix précédent
            if (isKeyPressed(KEY_NSPIRE_CTRL) && (numPath < 200)) {
                if (selectionChoix > 0) {
                    selectionChoix--;
                } else {
                    selectionChoix = nbPaiementPossible - 1;
                }
                afficher = true;
                while (isKeyPressed(KEY_NSPIRE_CTRL));
            }
            // valider la route
            if ((isKeyPressed(KEY_NSPIRE_VAR)  || isKeyPressed(KEY_NSPIRE_ENTER)) && (numPath < 200)) {
                // tester si c'est possible !!!
                if (nbPaiementPossible > 0) {
                    revendiquerRoute(numPath, numJoueur);
                    payerRoute(numPath, selectionChoix, numJoueur);
                    etatGlobal = ETAT_FIN_DU_TOUR;
                }
                while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER));
            }
            if (isKeyPressed(KEY_NSPIRE_ESC)) {
                etatGlobal = ETAT_CHOIX_JOUEUR;
                while (isKeyPressed(KEY_NSPIRE_ESC));
            }
        }
    }

    if (passAndPlayActif && (etatGlobal == ETAT_FIN_DU_TOUR)) {
        sauverPartie(numJoueur, numSlot + numJoueur * 10);
    }
}

void animerRefusCarteMission(uint8 numJoueur) {
    // animation, reconstruire le fond
    // le fond : la carte
    afficherCarte(xCarte,yCarte,284,210);
    // la carte foncée à droite
    afficherCarteSombre(284,0,319,210,xCarte,yCarte);
    // partie droite

    // carte mission
    if (nbCartesMissionPioche > 0) {
        afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
    }
    // Pioche cartes wagons retournés
    for (uint8 i=0; i<5; i++) {
        if (choixCartesWagon[i] != 0xFF) {
            afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
        }
    }
    // Pioche carte wagon face retournée
    if (nbCartesWagonPioche > 0) {
        afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
    }
    // le wagon pour revendiquer une route
    if (joueurs[numJoueur].nbWagons > 0) {
        afficherGrafx_ram(RAM_WAGON_60 + joueurs[numJoueur].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
    }

    // le bas
    afficherBas(numJoueur, 1);
    // n'afficher que les cartes gardées
    uint16 ouX = 18;
    bool realise[4];
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (joueurs[numJoueur].humain) {
            realise[i] = testerMissionRealisse(numJoueur, choixCarteMission[i]);
        } else {
            realise[i] = false;
        }
    }

    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (choixCarteMissionResultat[i] == GARDER_CARTE) {
            afficherTicketDestination(numJoueur, choixCarteMission[i], 80, ouX, 240 - 17 - 40, true, !joueurs[numJoueur].humain, realise[i]);
        }
        ouX += 86;
    }

    // conserver le fond
    empilerBackScr();

    // virer les cartes non conservées
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        if (i != 0) {
            depilerBackScr();
        }

        // de ouX, 240-17-40(240-52)/2 vers (320-80)/2, 240
        ouX = 18;
        uint16 ax = 0;
        uint16 ay = 0;
        for (uint8 j=0; j<nbChoixCarteMission; j++) {
            if (choixCarteMissionResultat[j] == DEFAUSSER_CARTE) {
                ax = ouX+10 - trunc(((ouX+10 - 285) * i) / CPT_ANIMATION);
                ay = 240-17-20 - trunc(((240-17-20 - 3) * i) / CPT_ANIMATION);
                afficherTicketDestination(numJoueur, choixCarteMission[j], 60, ax, ay, false, !joueurs[numJoueur].humain, realise[j]);
            }
            ouX += 86;
        }

        afficherBackScreen();
    }

    // garder les cartes 2, défausser les 1 et changer le tour
    joueurs[numJoueur].lastAction = 0;
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        if (choixCarteMissionResultat[i] == DEFAUSSER_CARTE) {
            for (uint8 j = nbCartesMissionPioche; j>0; j--) {
                piocheCartesMission[j] = piocheCartesMission[j-1];
            }
            piocheCartesMission[0] = choixCarteMission[i];
            nbCartesMissionPioche++;
        } else {
            if (choixCarteMissionResultat[i] == GARDER_CARTE) {
                joueurs[numJoueur].lastAction++;
                joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].nbCartesMission++] = choixCarteMission[i];
                testerDerniereMissionPiochee(numJoueur);
                joueurs[numJoueur].missionCourante = joueurs[numJoueur].nbCartesMission - 1;
            }
        }
    }
}

void etatChoixCarteMission(uint8 numJoueur, uint8 numSlot, bool modeTuto) {
    memset(choixCarteMissionResultat, 0, sizeof(choixCarteMissionResultat));

    bool canAccept = false;
    bool afficher = true;
    bool reconstruire = true;
    uint8 selectionChoix = 0;
    bool IA = !joueurs[numJoueur].humain;
    bool realise[4];

    uint8 nbCartesAGarder = 1;
    if (joueurs[numJoueur].nbCartesMission == 0) {
        nbCartesAGarder = 2;
    }
    // 0: ??, DEFAUSSER_CARTE: NO, GARDER_CARTE: OK

    // garder par défaut les missions déjà réalisées
    for (uint8 i=0; i<nbChoixCarteMission; i++) {
        realise[i] = testerMissionRealisse(numJoueur, choixCarteMission[i]);
        if (realise[i]) {
            choixCarteMissionResultat[i] = GARDER_CARTE;
        }
    }

    effacerMapSelection();
    if (IA) {
        renseignerCartesMissionAGarder(numJoueur, nbCartesAGarder);
    } else {
        if (realise[selectionChoix]) {
            selectionnerMission(choixCarteMission[selectionChoix], RAM_CARTE_VILLE_OK);
        } else {
            selectionnerMission(choixCarteMission[selectionChoix], RAM_CARTE_VILLE_KO);
        }
    }

    // recaler la carte
    if (xCarte > MAX_CARTE_X) {
        xCarte = MAX_CARTE_X;
    }
    if (yCarte > MAX_CARTE_Y) {
        yCarte = MAX_CARTE_Y;
    }

    etatGlobal = ETAT_CHOISIR_CARTES_MISSIONS;
    while (etatGlobal == ETAT_CHOISIR_CARTES_MISSIONS) {
        if (reconstruire) {
            // le fond : la carte
            afficherCarte(xCarte,yCarte,284,210);
            // la carte foncée à droite
            afficherCarteSombre(284,0,319,210,xCarte,yCarte);
            // partie droite

            // carte mission
            if (nbCartesMissionPioche > 0) {
                afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
            }
            // Pioche cartes wagons retournés
            for (uint8 i=0; i<5; i++) {
                if (choixCartesWagon[i] != 0xFF) {
                    afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                }
            }
            // Pioche carte wagon face retournée
            if (nbCartesWagonPioche > 0) {
                afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
            }
            // le wagon pour revendiquer une route
            if (joueurs[numJoueur].nbWagons > 0) {
                afficherGrafx_ram(RAM_WAGON_60 + joueurs[numJoueur].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
            }

            // le bas
            afficherBas(numJoueur, 1);
            // conserver le fond
            empilerBackScr();

            afficher = true;
        }

        if (afficher) {
            afficher = false;

            // le fond
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // les cartes missions
            uint16 ouX = 18;
            canAccept = false;
            // si une carte n'a pas de choix : on refuse
            bool tousChoix = true;
            uint8 nbOk = 0;
            for (uint8 i=0; i<nbChoixCarteMission; i++) {
                switch (choixCarteMissionResultat[i]) {
                case 0: // ??
                    tousChoix = false;
                    afficherTicketDestination(numJoueur, choixCarteMission[i], 80, ouX, 240 - 17 - 30, false, !joueurs[numJoueur].humain, realise[i]);
                    break;
                case DEFAUSSER_CARTE: // 1 : NO
                    afficherTicketDestination(numJoueur, choixCarteMission[i], 60, ouX+10, 240 - 17 - 40, false, !joueurs[numJoueur].humain, realise[i]);
                    break;
                case GARDER_CARTE: // 2 : OK
                    nbOk++;
                    afficherTicketDestination(numJoueur, choixCarteMission[i], 80, ouX-2, 240 - 17 - 20 -2, true, !joueurs[numJoueur].humain, realise[i]);
                    break;
                }
                if (!IA && (i == selectionChoix)) {
                    // le curseur
                    afficherGrafx_ram(RAM_CURSOR, ouX + 30, 240 - 17, SCREEN_WORKING, 0xFFFF);
                }

                ouX += 86;
            }

            canAccept = tousChoix && (nbOk >= nbCartesAGarder);
            if (canAccept) {
                afficherGrafx_ram(RAM_ICO_OK, ouX, 240-24-2, SCREEN_WORKING, 0xFFFF);
            } else {
                afficherGrafx_ram(RAM_ICO_CANCEL, ouX, 240-24-2, SCREEN_WORKING, 0xFFFF);
            }
            afficherBackScreen();
        }

        if (IA) {
            animerRefusCarteMission(numJoueur);
            etatGlobal = ETAT_FIN_DU_TOUR;
        } else {
            if (scrollerCarte(numJoueur)) {
                joueurs[numJoueur].xCarte = xCarte;
                joueurs[numJoueur].yCarte = yCarte;
                reconstruire = true;
            }
            // sortir du tuto
            if (modeTuto && isKeyPressed(KEY_NSPIRE_ESC)) {
                etatGlobal = ETAT_LIBERATION_MEMOIRE;
                while (isKeyPressed(KEY_NSPIRE_ESC));
            }

            // mini carte
            if (isKeyPressed(KEY_NSPIRE_5)) {
                afficherMiniCarte(true);
                afficher = true;
            }
            // zoom sur carte
            if (isKeyPressed(KEY_NSPIRE_TAB)) {
                afficherZoomCarteMission(numJoueur, choixCarteMission[selectionChoix], realise[selectionChoix]);
                afficher = true;
            }
            // afficher la main du joueur
            if (isKeyPressed(KEY_NSPIRE_MENU) && !modeTuto) {
                afficherMainJoueur(numJoueur);
                afficher = true;
            }
            // aide contextuelle
            if (isKeyPressed(KEY_NSPIRE_DOC)) {
                afficherAideContextuelle(nbCartesAGarder);
                afficher = true;
            }

            // choix suivant
            if ((isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT)) && (selectionChoix < nbChoixCarteMission - 1)) {
                selectionChoix++;
                afficher = true;
                reconstruire = true;
                effacerMapSelection();
                if (realise[selectionChoix]) {
                    selectionnerMission(choixCarteMission[selectionChoix], RAM_CARTE_VILLE_OK);
                } else {
                    selectionnerMission(choixCarteMission[selectionChoix], RAM_CARTE_VILLE_KO);
                }
                while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT));
            }
            // choix précédent
            if ((isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT)) && (selectionChoix > 0)) {
                selectionChoix--;
                afficher = true;
                reconstruire = true;
                effacerMapSelection();
                if (realise[selectionChoix]) {
                    selectionnerMission(choixCarteMission[selectionChoix], RAM_CARTE_VILLE_OK);
                } else {
                    selectionnerMission(choixCarteMission[selectionChoix], RAM_CARTE_VILLE_KO);
                }
                while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT));
            }
            // accepter
            if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_DOWN)) {
                if (selectionChoix == nbChoixCarteMission) {
                    if (canAccept) {
                        animerRefusCarteMission(numJoueur);
                        etatGlobal = ETAT_FIN_DU_TOUR;
                    }
                } else {
                    choixCarteMissionResultat[selectionChoix] = GARDER_CARTE;
                    afficher = true;
                }
                while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_DOWN));
            }
            if (isKeyPressed(KEY_NSPIRE_ENTER)) {
                if (canAccept) {
                    animerRefusCarteMission(numJoueur);
                    etatGlobal = ETAT_FIN_DU_TOUR;
                }

                while (isKeyPressed(KEY_NSPIRE_ENTER));
            }

            // refuser
            if (isKeyPressed(KEY_NSPIRE_SHIFT) || isKeyPressed(KEY_NSPIRE_UP)) {
                if (selectionChoix == nbChoixCarteMission) {
                    if (canAccept) {
                        animerRefusCarteMission(numJoueur);
                        etatGlobal = ETAT_FIN_DU_TOUR;
                    }
                } else {
                    choixCarteMissionResultat[selectionChoix] = DEFAUSSER_CARTE;
                    afficher = true;
                }
                while (isKeyPressed(KEY_NSPIRE_SHIFT) || isKeyPressed(KEY_NSPIRE_UP));
            }
        }
    }
    if (passAndPlayActif && (etatGlobal == ETAT_FIN_DU_TOUR)) {
        sauverPartie(numJoueur, numSlot + numJoueur * 10);
    }
}

void afficherNombre(sint16 nb, uint16 ouX, uint16 ouY) {
    afficherGrafx_file(FILE_FOND_NOMBRE, ouX - 37, ouY - 27, SCREEN_WORKING, 0xFFFF);

    uint16 taille = taillerGrafx0(nb);
    ecrireGrafx0(nb, ouX - 10 - trunc(taille / 2), ouY - 22, 0xFFFF);
}

bool afficherMissionCourante(uint8 numJoueur) {
    while (isKeyPressed(KEY_NSPIRE_SCRATCHPAD));

    // conserver le fond
    assombrirBackScr();
    empilerBackScr();

    bool continuer = true;
    bool afficher = true;

    uint8 sav = joueurs[numJoueur].missionCourante;
    while (continuer) {
        if (afficher) {
            afficher = false;
            depilerBackScr();

            // petites cartes
            if (joueurs[numJoueur].missionCourante >= 2) {
                afficherTicketDestination(numJoueur, joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante - 2], 60, 130, 1, false, !joueurs[numJoueur].humain, joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante - 2]);
            }
            if (joueurs[numJoueur].missionCourante < joueurs[numJoueur].nbCartesMission - 2) {
                afficherTicketDestination(numJoueur, joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante + 2], 60, 130, 240-39, false, !joueurs[numJoueur].humain, joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante + 2]);
            }
            // moyennes cartes
            if (joueurs[numJoueur].missionCourante >= 1) {
                afficherTicketDestination(numJoueur, joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante - 1], 80, 120, 12, false, !joueurs[numJoueur].humain, joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante - 1]);
            }
            if (joueurs[numJoueur].missionCourante < joueurs[numJoueur].nbCartesMission - 1) {
                afficherTicketDestination(numJoueur, joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante + 1], 80, 120, 240-52-12, false, !joueurs[numJoueur].humain, joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante + 1]);
            }

            // grosse carte
            afficherTicketDestination(numJoueur, joueurs[numJoueur].lstCartesMission[joueurs[numJoueur].missionCourante], 100, 35, 40, true, !joueurs[numJoueur].humain, joueurs[numJoueur].missionsRealisee[joueurs[numJoueur].missionCourante]);

            afficherBackScreen();
        }

        if ((isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_8)) && (joueurs[numJoueur].missionCourante > 0)) {
            joueurs[numJoueur].missionCourante--;
            afficher = true;
            while (isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_8));
        }
        if ((isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_2)) && (joueurs[numJoueur].missionCourante < joueurs[numJoueur].nbCartesMission - 1)) {
            joueurs[numJoueur].missionCourante++;
            afficher = true;
            while (isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_2));
        }

        if (isKeyPressed(KEY_NSPIRE_ENTER) || isKeyPressed(KEY_NSPIRE_SCRATCHPAD)) {
            continuer = false;
        }
        if (isKeyPressed(KEY_NSPIRE_ESC) ) {
            continuer = false;
            joueurs[numJoueur].missionCourante = sav;
        }
    }
    while (isKeyPressed(KEY_NSPIRE_SCRATCHPAD) || isKeyPressed(KEY_NSPIRE_ESC) || isKeyPressed(KEY_NSPIRE_ENTER));

    return sav != joueurs[numJoueur].missionCourante;
}

void afficherMainJoueur(uint8 numJoueur) {
    while (isKeyPressed(KEY_NSPIRE_MENU));

    bool afficher = true;
    uint8 selectionChoix = 0;
    uint8 missionChoix = joueurs[numJoueur].missionCourante;
    uint8 nbCol = 0;
    uint16 plusLong[6];
    uint16 best = 0;
    uint16 ouX;
    uint16 ouXmini;
    uint8 ouY;
    uint8 deltaX;
    uint8 deltaY;
    uint8 centre[] = {11,16,0,15};

    // Route la plus longue
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        plusLong[i] = 0;
        if (joueurs[i].points > 0) {
            plusLong[i] = pathfinder_cheminLePlusLong(i);
            if (plusLong[i] > best) {
                best = plusLong[i];
            }
        }
    }

    // ordre des joueurs
    uint8 ordre[] = {0,0,0,0,0};
    uint8 nb=0;
    ordre[nb++] = numJoueur;
    for (uint8 n = numJoueur-1; n>0; n--) {
        ordre[nb++] = n;
    }
    for (uint8 n = nbTotalJoueur; n > numJoueur; n--) {
        ordre[nb++] = n;
    }

    uint8 x;
    uint8 y;
    uint8 dx;
    uint8 dy;
    uint8 taille;

    bool continuer = true;
    while (continuer) {
        if (afficher) {
            // le bandeau du haut
            afficher = false;
            afficherCarteSombre(0,0,319,239,xCarte,yCarte);
            // les onglets
            for (uint8 i=0; i<4; i++) {
                if (i != selectionChoix) {
                    afficherGrafx_file(FILE_MAIN_TAB_OFF, 4 + i * 76, - 10, SCREEN_WORKING, 0xFFFF);
                }
            }
            for (uint8 i=0; i<4; i++) {
                if (i != selectionChoix) {
                    switch (i) {
                    case 0:
                    case 1:
                        afficherGrafx_file(FILE_MAIN_CARDS_WAGON + i, 4 + i * 76 + centre[i], 10, SCREEN_WORKING, 0xFFFF);
                        break;
                    case 2:
                        x = 20 + 2 * 76;
                        y = 14;
                        dx = 0;
                        dy = 0;
                        if (nbTotalJoueur > 1) {
                            dx = round(30 / (nbTotalJoueur - 1));
                            dy = round(10 / (nbTotalJoueur - 1));
                        }
                        for (uint8 j=1; j <= nbTotalJoueur; j++) {
                            if (j != numJoueur) {
                                afficherGrafx_ram(RAM_MINI_WAG_BLUE + joueurs[j].couleurW, x, y, SCREEN_WORKING, 0xFFFF);
                                x += dx;
                                y += dy;
                            }
                        }

                        break;
                    case 3:
                        afficherGrafx_file(FILE_MAIN_POINTS, 4 + 3 * 76 + centre[i], 10, SCREEN_WORKING, 0xFFFF);
                        break;
                    }
                }
            }
            afficherGrafx_file(FILE_MAIN_TAB_ON, 4 + selectionChoix * 76, - 10, SCREEN_WORKING, 0xFFFF);
            switch (selectionChoix) {
            case 0:
            case 1:
                afficherGrafx_file(FILE_MAIN_CARDS_WAGON + selectionChoix, 4 + selectionChoix * 76 + centre[selectionChoix], 4, SCREEN_WORKING, 0xFFFF);
                break;
            case 2:
                x = 20 + 2 * 76;
                y = 8;
                dx = 0;
                dy = 0;
                if (nbTotalJoueur > 1) {
                    dx = round(30 / (nbTotalJoueur - 1));
                    dy = round(10 / (nbTotalJoueur - 1));
                }
                for (uint8 j=1; j <= nbTotalJoueur; j++) {
                    if (j != numJoueur) {
                        afficherGrafx_ram(RAM_MINI_WAG_BLUE + joueurs[j].couleurW, x, y, SCREEN_WORKING, 0xFFFF);
                        x += dx;
                        y += dy;
                    }
                }
                break;
            case 3:
                afficherGrafx_file(FILE_MAIN_POINTS, 4 + 3 * 76 + centre[selectionChoix], 4, SCREEN_WORKING, 0xFFFF);
                break;
            }

            // un pourtour
            unsigned char *dest = getBackScr();
            dest += 3*2 + 38 * 320 * 2;
            for (uint16 x=0; x<320-7; x++) {
                dest[0] = 0x69;
                dest[1] = 0x93;
                dest += 2;
            }
            dest += 7*2;
            for (uint8 y=0; y<196; y++) {
                dest[0] = 0x69;
                dest[1] = 0x93;
                dest += 2;

                for (uint16 x=0; x<320-9; x++) {
                    dest[0] = 0x13; // BD
                    dest[1] = 0xD6; // F7
                    dest += 2;
                }
                dest[0] = 0x69;
                dest[1] = 0x93;
                dest += 2;

                dest += 7*2;
            }
            for (uint16 x=0; x<320-7; x++) {
                dest[0] = 0x69;
                dest[1] = 0x93;
                dest += 2;
            }


            switch (selectionChoix) {
            case 0:
                // les cartes wagons
                ouX = 16;
                ouY = 40;
                for (uint8 i=0; i<=8; i++) {
                    if (joueurs[numJoueur].nbCartes[i] > 0) {
                        afficherGrafx_ram(RAM_WAG_LOCO_80 + i, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                        afficherNombre(joueurs[numJoueur].nbCartes[i], ouX + 78, ouY + 50);

                        ouX += 104;
                        if (ouX >= 320) {
                            ouX = 16;
                            ouY += 53;
                        }
                    }
                }
                // les wagons
                ouX = 6;
                ouY = 40 + 53*3;
                afficherGrafx_ram(RAM_WAGON_60 + joueurs[numJoueur].couleurW, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                afficherNombre(joueurs[numJoueur].nbWagons, ouX + 106, ouY + 36);

                ouX = 106 + 40;
                afficherGrafx_file(FILE_MAIN_POINTS, ouX, ouY-6, SCREEN_WORKING, 0xFFFF);
                afficherNombre(joueurs[numJoueur].points, ouX + 88, ouY + 36);
                if ((best == plusLong[numJoueur]) && (best > 0)) {
                    afficherGrafx_file(FILE_MINI_BEST_PATH2, ouX + 100, ouY, SCREEN_WORKING, 0xFFFF);
                }

                break;

            case 1:

                //80 : 3x3  80x52
                //60 : 5x5  60x39
                //60 : 6x6  51x39
                taille = 0;
                if (joueurs[numJoueur].nbCartesMission <= 9) {
                    ouXmini = 6+17;
                    ouY = 40+10;
                    deltaX = 80+17;
                    deltaY = 52+10;
                    taille = 80;
                    nbCol = 3;
                } else {
                    if (joueurs[numJoueur].nbCartesMission <= 25) {
                        ouXmini = 6+1;
                        ouY = 40;
                        deltaX = 60+1;
                        deltaY = 39;
                        taille = 60;
                        nbCol = 5;
                    } else {
                        ouXmini = 6;
                        ouY = 40;
                        deltaX = 49;
                        deltaY = 37;
                        taille = 60;
                        nbCol = 6;
                    }
                }

                uint16 sx=0;
                uint8 sy=0;

                ouX = ouXmini;
                for (uint8 i=0; i<joueurs[numJoueur].nbCartesMission; i++) {
                    afficherTicketDestination(numJoueur, joueurs[numJoueur].lstCartesMission[i], taille, ouX, ouY, false, !joueurs[numJoueur].humain, joueurs[numJoueur].missionsRealisee[i]);
                    if (i == missionChoix) {
                        // le curseur
                        sx = ouX + 20;
                        sy = ouY + 20;
                    }

                    ouX += deltaX;
                    if (ouX >= 270) {
                        ouX = ouXmini;
                        ouY += deltaY;
                    }
                }
                afficherGrafx_ram(RAM_CURSOR, sx, sy, SCREEN_WORKING, 0xFFFF);
                break;

            case 2:
                // les autres joueurs
                ouY = 40;
                for (uint8 j=1; j<nbTotalJoueur; j++) {
                    uint8 i = ordre[j];
                    // avatar
                    ouX = 6;

                    if (joueurs[i].humain) {
                        afficherGrafx_file(FILE_AVATAR_HUMAN_35PX + joueurs[i].couleurW, ouX+9, ouY+4, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_file(FILE_NEWGAME_RING_HUMAIN, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                    } else {
                        switch (joueurs[i].avatar) {
                        case 1:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT1 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        case 2:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT2 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        case 3:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT3 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        case 4:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT4 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        }
                        afficherGrafx_file(FILE_NEWGAME_RING_BOT, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                    }
                    ouX += 50;

                    // dernière action effectuée
                    if (joueurs[i].lastAction == 0xF000) {
                        // F000 : revendiquer une route, éventuellement stocker le n° du path dans un autre FF
                        afficherGrafx_file(FILE_LASTACTION_ROAD, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                    } else {
                        afficherGrafx_file(FILE_LASTACTION_BACK, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                        if (joueurs[i].lastAction == 0) {
                            // 0000 : passer son tour
                        } else {
                            uint8 nbCartes = 0;
                            uint8 cartes[] = {0,0,0};

                            if (joueurs[i].lastAction <= 3) {
                                // 000F : nb de cartes mission piochées
                                nbCartes = joueurs[i].lastAction;
                                switch (joueurs[i].lastAction) {
                                case 3:
                                    cartes[2] = RAM_MINI_MIS_BACK;
                                    cartes[1] = RAM_MINI_MIS_BACK;
                                    cartes[0] = RAM_MINI_MIS_BACK;
                                    break;
                                case 2:
                                    cartes[1] = RAM_MINI_MIS_BACK;
                                    cartes[0] = RAM_MINI_MIS_BACK;
                                    break;
                                case 1:
                                    cartes[0] = RAM_MINI_MIS_BACK;
                                    break;
                                }
                            } else {
                                uint16 test = (joueurs[i].lastAction & 0x00F0) >> 4;
                                // 00F0 : première carte piochée (attention couleur +1) de 1 à COULEUR_BACK+1
                                if (test != 0) {
                                    nbCartes++;
                                    cartes[0] = RAM_MINI_WAG_LOCO + test - 1;
                                }
                                // 0F00 : seconde carte piochée : 0 pas de seconde carte piochée
                                test = (joueurs[i].lastAction & 0x0F00) >> 8;
                                if (test != 0) {
                                    nbCartes++;
                                    cartes[1] = RAM_MINI_WAG_LOCO + test - 1;
                                }
                            }

                            switch (nbCartes) {
                            case 1:
                                afficherGrafx_ram(cartes[0], ouX+12, ouY+16, SCREEN_WORKING, 0xFFFF);
                                break;
                            case 2:
                                afficherGrafx_ram(cartes[0], ouX+12, ouY+8, SCREEN_WORKING, 0xFFFF);
                                afficherGrafx_ram(cartes[1], ouX+12, ouY+24, SCREEN_WORKING, 0xFFFF);
                                break;
                            case 3:
                                afficherGrafx_ram(cartes[0], ouX+6, ouY+10, SCREEN_WORKING, 0xFFFF);
                                afficherGrafx_ram(cartes[1], ouX+12, ouY+16, SCREEN_WORKING, 0xFFFF);
                                afficherGrafx_ram(cartes[2], ouX+18, ouY+22, SCREEN_WORKING, 0xFFFF);
                                break;
                            }
                        }
                    }
                    ouX += 46;

                    // wagons
                    afficherGrafx_ram(RAM_WAGON_60 + joueurs[i].couleurW, ouX-4, ouY+4, SCREEN_WORKING, 0xFFFF);
                    afficherNombre(joueurs[i].nbWagons, ouX + 60, ouY + 44);
                    // cartes wagons
                    ouX += 72;
                    afficherGrafx_ram(RAM_WAG_BACK_60, ouX, ouY + 4, SCREEN_WORKING, 0xFFFF);
                    afficherNombre(joueurs[i].nbCartesWagon, ouX + 56, ouY + 44);
                    // cartes missions
                    ouX += 72;
                    afficherGrafx_ram(RAM_MIS_BA_60, ouX, ouY + 4, SCREEN_WORKING, 0xFFFF);
                    afficherNombre(joueurs[i].nbCartesMission, ouX + 56, ouY + 44);

                    // ligne suivante
                    ouY += 48;

                }
                break;

            case 3:
                // les scores
                ouY = 40;
                for (uint8 j=1; j<nbTotalJoueur; j++) {
                    uint8 i = ordre[j];
                    ouX = 6;
                    if (joueurs[i].humain) {
                        afficherGrafx_file(FILE_AVATAR_HUMAN_35PX + joueurs[i].couleurW, ouX+9, ouY+4, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_file(FILE_NEWGAME_RING_HUMAIN, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                    } else {
                        switch (joueurs[i].avatar) {
                        case 1:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT1 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        case 2:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT2 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        case 3:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT3 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        case 4:
                            afficherGrafx_file(FILE_AVATAR_48PX_BOT4 + joueurs[i].couleurW, ouX+5, ouY+1, SCREEN_WORKING, 0xFFFF);
                            break;
                        }
                        afficherGrafx_file(FILE_NEWGAME_RING_BOT, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                    }
                    ouX += 50;
                    // Les points
                    afficherNombre(joueurs[i].points, ouX + 37, ouY + 38);
                    ouX += 50;

                    // route la plus longue
                    if ((best == plusLong[i]) && (best > 0)) {
                        afficherGrafx_file(FILE_MINI_BEST_PATH2, ouX, ouY + 3, SCREEN_WORKING, 0xFFFF);
                    }
                    // ligne suivante
                    ouY += 48;
                }
                break;
            }

            afficherBackScreen();
        }

        // mini carte
        if (isKeyPressed(KEY_NSPIRE_5)) {
            afficherMiniCarte(true);
            afficher = true;
        }
        // choix suivant
        if ((isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT)) && (selectionChoix < 3)) {
            selectionChoix++;
            afficher = true;
            while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT));
        }
        // choix précédent
        if ((isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT)) && (selectionChoix > 0)) {
            selectionChoix--;
            afficher = true;
            while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT));
        }

        if (selectionChoix == 1) {
            // zoom sur carte
            if (isKeyPressed(KEY_NSPIRE_TAB)) {
                afficherZoomCarteMission(numJoueur, joueurs[numJoueur].lstCartesMission[missionChoix], joueurs[numJoueur].missionsRealisee[missionChoix]);
                afficher = true;
            }

            // déplacer le curseur
            if (isKeyPressed(KEY_NSPIRE_8)) {
                if (missionChoix - nbCol >= 0) {
                    missionChoix -= nbCol;
                    afficher = true;
                }
                while (isKeyPressed(KEY_NSPIRE_8));
            }
            if (isKeyPressed(KEY_NSPIRE_2)) {
                if (missionChoix + nbCol < joueurs[numJoueur].nbCartesMission) {
                    missionChoix += nbCol;
                    afficher = true;
                }
                while (isKeyPressed(KEY_NSPIRE_2));
            }
            if (isKeyPressed(KEY_NSPIRE_4)) {
                if ((missionChoix % nbCol) > 0) {
                    missionChoix--;
                    afficher = true;
                }
                while (isKeyPressed(KEY_NSPIRE_4));
            }
            if (isKeyPressed(KEY_NSPIRE_6)) {
                if (((missionChoix % nbCol) < (nbCol - 1)) && (missionChoix + 1 < joueurs[numJoueur].nbCartesMission)) {
                    missionChoix++;
                    afficher = true;
                }
                while (isKeyPressed(KEY_NSPIRE_6));
            }
        }
        if (isKeyPressed(KEY_NSPIRE_MENU) || isKeyPressed(KEY_NSPIRE_ESC)) {
            continuer = false;
        }
    }
    while (isKeyPressed(KEY_NSPIRE_MENU) || isKeyPressed(KEY_NSPIRE_ESC));
}

void afficherAnimationMenu() {
    uint32 taille = chargerTaille_file(FILE_MAINMENU_LOCO);
    unsigned char *sprLoco = malloc(taille);
    chargerGrafx_file(sprLoco, FILE_MAINMENU_LOCO, taille);

    taille = chargerTaille_file(FILE_MAINMENU_PILAR);
    unsigned char *sprPilar = malloc(taille);
    chargerGrafx_file(sprPilar, FILE_MAINMENU_PILAR, taille);

    taille = chargerTaille_file(FILE_MAINMENU_GERRY_WAIT);
    unsigned char *sprGerry = malloc(taille);
    chargerGrafx_file(sprGerry, FILE_MAINMENU_GERRY_WAIT, taille);

    taille = chargerTaille_file(FILE_MAINMENU_SMOKE);
    unsigned char *sprSmoke = malloc(taille);
    chargerGrafx_file(sprSmoke, FILE_MAINMENU_SMOKE, taille);

    // la loco arrive
    dumperScreen(FILE_MAINMENU_FOND, 320 * 240 * 2, 0);
    empilerBackScr();
    nbFumee = 0;
    sint16 xLoco;
    sint16 yLoco;

    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
        // le fond
        if (i != 0) {
            depilerBackScr();
        }
        // la loco
        xLoco = round(i * 185 / CPT_ANIMATION)-185;
        yLoco = 77 + round(i * 12 / CPT_ANIMATION);
        afficherGrafx_buffer(sprLoco, xLoco, yLoco, SCREEN_WORKING, 0xFFFF);
        // update fumée
        if (nbFumee < MAX_SMOKE-1) {
            fumeeX[nbFumee] = xLoco + 125 + rand()%10;
            fumeeDx[nbFumee] = rand()%32 - 16;
            fumeeY[nbFumee] = yLoco - 16;
            fumeeL[nbFumee] = 60 + rand() % 50;
            fumeeCpt[nbFumee] = 0;
            switch (rand() % 4) {
            case 0:
                fumeeCol[nbFumee] = 0xFFFF; // 11111 111111 11111
                break;
            case 1:
                fumeeCol[nbFumee] = 0x7BEF; // 01111 011111 01111
                break;
            case 2:
                fumeeCol[nbFumee] = 0x39E7; // 00111 001111 00111
                break;
            case 3:
                fumeeCol[nbFumee] = 0x18E3; // 00011 000111 00011
                break;
            }
            nbFumee++;
        }
        for (uint8 j=0; j<nbFumee; j++) {
            fumeeY[j]--;
            fumeeCpt[j]++;
            if (fumeeCpt[j] == fumeeL[j]) {
                fumeeX[j] = xLoco + 125 + rand()%10;
                fumeeDx[j] = rand()%32 - 16;
                fumeeY[j] = yLoco - 16;
                fumeeL[j] = 60 + rand()%50;
                fumeeCpt[j] = 0;
            }
            afficherGrafx_buffer(sprSmoke, round(fumeeX[j] + (fumeeDx[j] * fumeeCpt[j]) / fumeeL[j]), fumeeY[j], SCREEN_WORKING, fumeeCol[j]);
        }
        // le pilier
        afficherGrafx_buffer(sprPilar, 0, 0, SCREEN_WORKING, 0xFFFF);
        afficherBackScreen();
    }

    // le fond
    depilerBackScr();
    // la loco
    xLoco = 0;
    yLoco = 89;
    afficherGrafx_buffer(sprLoco, 0, 89, SCREEN_WORKING, 0xFFFF);
    empilerBackScr();

    // gerry arrive
    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
        // le fond
        if (i != 0) {
            depilerBackScr();
        }
        // update fumée
        if (nbFumee < MAX_SMOKE-1) {
            fumeeX[nbFumee] = xLoco + 125 + rand()%10;
            fumeeDx[nbFumee] = rand()%32 - 16;
            fumeeY[nbFumee] = yLoco - 16;
            fumeeL[nbFumee] = 60 + rand() % 50;
            fumeeCpt[nbFumee] = 0;
            switch (rand() % 4) {
            case 0:
                fumeeCol[nbFumee] = 0xFFFF; // 11111 111111 11111
                break;
            case 1:
                fumeeCol[nbFumee] = 0x7BEF; // 01111 011111 01111
                break;
            case 2:
                fumeeCol[nbFumee] = 0x39E7; // 00111 001111 00111
                break;
            case 3:
                fumeeCol[nbFumee] = 0x18E3 ; // 00011 000111 00011
                break;
            }
            nbFumee++;
        }
        for (uint8 j=0; j<nbFumee; j++) {
            fumeeY[j]--;
            fumeeCpt[j]++;
            if (fumeeCpt[j] == fumeeL[j]) {
                fumeeX[j] = xLoco + 125 + rand()%10;
                fumeeDx[j] = rand()%32 - 16;
                fumeeY[j] = yLoco - 16;
                fumeeL[j] = 60 + rand()%50;
                fumeeCpt[j] = 0;
            }
            afficherGrafx_buffer(sprSmoke, round(fumeeX[j] + (fumeeDx[j] * fumeeCpt[j]) / fumeeL[j]), fumeeY[j], SCREEN_WORKING, fumeeCol[j]);
        }
        // le pilier
        afficherGrafx_buffer(sprPilar, 0, 0, SCREEN_WORKING, 0xFFFF);
        // Gerry
        afficherGrafx_buffer(sprGerry, round(i * 97 / CPT_ANIMATION)-97, 29, SCREEN_WORKING, 0xFFFF);
        afficherBackScreen();
    }

    // le bandeau en bas
    for (uint8 i=1; i<23; i++) {
        // le fond
        if (i != 0) {
            depilerBackScr();
        }
        // update fumée
        if (nbFumee < MAX_SMOKE-1) {
            fumeeX[nbFumee] = xLoco + 125 + rand()%10;
            fumeeDx[nbFumee] = rand()%32 - 16;
            fumeeY[nbFumee] = yLoco - 16;
            fumeeL[nbFumee] = 60 + rand() % 50;
            fumeeCpt[nbFumee] = 0;
            switch (rand() % 4) {
            case 0:
                fumeeCol[nbFumee] = 0xFFFF; // 11111 111111 11111
                break;
            case 1:
                fumeeCol[nbFumee] = 0x7BEF; // 01111 011111 01111
                break;
            case 2:
                fumeeCol[nbFumee] = 0x39E7; // 00111 001111 00111
                break;
            case 3:
                fumeeCol[nbFumee] = 0x18E3 ; // 00011 000111 00011
                break;
            }
            nbFumee++;
        }
        for (uint8 j=0; j<nbFumee; j++) {
            fumeeY[j]--;
            fumeeCpt[j]++;
            if (fumeeCpt[j] == fumeeL[j]) {
                fumeeX[j] = xLoco + 125 + rand()%10;
                fumeeDx[j] = rand()%32 - 16;
                fumeeY[j] = yLoco - 16;
                fumeeL[j] = 60 + rand()%50;
                fumeeCpt[j] = 0;
            }
            afficherGrafx_buffer(sprSmoke, round(fumeeX[j] + (fumeeDx[j] * fumeeCpt[j]) / fumeeL[j]), fumeeY[j], SCREEN_WORKING, fumeeCol[j]);
        }
        // le pilier
        afficherGrafx_buffer(sprPilar, 0, 0, SCREEN_WORKING, 0xFFFF);
        // Gerry
        afficherGrafx_buffer(sprGerry, 0, 29, SCREEN_WORKING, 0xFFFF);

        // le bandeau en bas
        afficherGrafx_file(FILE_MAINMENU_TEXT, 37, 240-i, SCREEN_WORKING, 0xFFFF);
        ecrireGrafxA("New Game", 160-32, 262-15-i, 0xFFFF);

        afficherBackScreen();
    }

    // that's all
    etatGlobal = ETAT_MENU;

    free(sprLoco);
    free(sprPilar);
    free(sprGerry);
    free(sprSmoke);
}

uint8 afficherMenuPrincipal() {
    uint8 selectionChoix = 0;

    // construire le fond
    dumperScreen(FILE_MAINMENU_FOND, 320 * 240 * 2, 0);
    afficherGrafx_file(FILE_MAINMENU_LOCO, 0, 89, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_file(FILE_MAINMENU_PILAR, 0, 0, SCREEN_WORKING, 0xFFFF);
    empilerBackScr();

    uint32 taille = chargerTaille_file(FILE_MAINMENU_GERRY_TICKET);
    unsigned char *sprGerry = malloc(taille);
    chargerGrafx_file(sprGerry, FILE_MAINMENU_GERRY_TICKET, taille);

    taille = chargerTaille_file(FILE_MAINMENU_SMOKE);
    unsigned char *sprSmoke = malloc(taille);
    chargerGrafx_file(sprSmoke, FILE_MAINMENU_SMOKE, taille);

    taille = chargerTaille_file(FILE_BUTTON_GREEN);
    unsigned char *sprG1 = malloc(taille);
    chargerGrafx_file(sprG1, FILE_BUTTON_GREEN, taille);

    taille = chargerTaille_file(FILE_BUTTON_GREEN_OVER);
    unsigned char *sprG2 = malloc(taille);
    chargerGrafx_file(sprG2, FILE_BUTTON_GREEN_OVER, taille);

    taille = chargerTaille_file(FILE_BUTTON_BLUE);
    unsigned char *sprB1 = malloc(taille);
    chargerGrafx_file(sprB1, FILE_BUTTON_BLUE, taille);

    taille = chargerTaille_file(FILE_BUTTON_BLUE_OVER);
    unsigned char *sprB2 = malloc(taille);
    chargerGrafx_file(sprB2, FILE_BUTTON_BLUE_OVER, taille);

    uint8 xLoco = 0;
    uint8 yLoco = 89;

    while (true) {
        depilerBackScr();

        // le fond
        if (selectionChoix == 0) {
            afficherGrafx_buffer(sprG2, 72, 24, SCREEN_WORKING, 0xFFFF);
        } else {
            afficherGrafx_buffer(sprG1, 72, 24, SCREEN_WORKING, 0xFFFF);
        }
        afficherGrafx_buffer(sprGerry, 0, 29, SCREEN_WORKING, 0xFFFF);

        if (selectionChoix == 0) {
            afficherGrafx_ram(RAM_CURSOR, 72+26-10, 24+26-1, SCREEN_WORKING, 0xFFFF);
        }

        if (selectionChoix == 1) {
            afficherGrafx_buffer(sprB2, 132, 133, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_CURSOR, 132+26-10, 133+26-1, SCREEN_WORKING, 0xFFFF);
        } else {
            afficherGrafx_buffer(sprB1, 132, 133, SCREEN_WORKING, 0xFFFF);
        }

        if (selectionChoix == 2) {
            afficherGrafx_buffer(sprB2, 272, 8, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_CURSOR, 272+26-10, 8+26-1, SCREEN_WORKING, 0xFFFF);
        } else {
            afficherGrafx_buffer(sprB1, 272, 8, SCREEN_WORKING, 0xFFFF);
        }

        if (selectionChoix == 3) {
            afficherGrafx_buffer(sprB2, 272, 108, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_CURSOR, 272+26-10, 108+26-1, SCREEN_WORKING, 0xFFFF);
        } else {
            afficherGrafx_buffer(sprB1, 272, 108, SCREEN_WORKING, 0xFFFF);
        }

        // update fumée
        for (uint8 i=0; i<nbFumee; i++) {
            fumeeY[i]--;
            fumeeCpt[i]++;
            if (fumeeCpt[i] == fumeeL[i]) {
                fumeeX[i] = xLoco + 125 + rand()%10;
                fumeeDx[i] = rand()%32 - 16;
                fumeeY[i] = yLoco - 16;
                fumeeL[i] = 60 + rand()%50;
                fumeeCpt[i] = 0;
            }
            afficherGrafx_buffer(sprSmoke, round(fumeeX[i] + (fumeeDx[i] * fumeeCpt[i]) / fumeeL[i]), fumeeY[i], SCREEN_WORKING, fumeeCol[i]);
        }

        // le bandeau en bas
        afficherGrafx_file(FILE_MAINMENU_TEXT, 37, 240-23, SCREEN_WORKING, 0xFFFF);
        switch (selectionChoix) {
        case 0:
            ecrireGrafxA("New Game", 160-32, 240-15, 0xFFFF);
            break;
        case 1:
            ecrireGrafxA("Load Game", 160-32, 240-15, 0xFFFF);
            break;
        case 2:
            ecrireGrafxA("Credits", 160-32, 240-15, 0xFFFF);
            break;
        case 3:
            ecrireGrafxA("How to play", 160-32, 240-15, 0xFFFF);
            break;
        }

        afficherBackScreen();

        if (isKeyPressed(KEY_NSPIRE_ESC)) {
            return ETAT_LIBERATION_MEMOIRE;
        }

        // choix suivant
        if (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_RIGHT)) {
            if (selectionChoix < 3) {
                selectionChoix++;
            }
            while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_RIGHT));
        }
        // choix précédent
        if (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_LEFT)) {
            if (selectionChoix > 0) {
                selectionChoix--;
            }
            while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_LEFT));
        }
        // sélectionner le choix
        if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER)) {
            if (selectionChoix == 0) {
                return ETAT_NOUVELLE_PARTIE;
            }
            if (selectionChoix == 1) {
                return ETAT_CHARGER_PARTIE;
            }
            if (selectionChoix == 2) {
                return ETAT_CREDITS;
            }
            if (selectionChoix == 3) {
                return ETAT_TUTORIAL;
            }
            while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER));
        }
    }

    free(sprGerry);
    free(sprSmoke);
    free(sprG1);
    free(sprG2);
    free(sprB1);
    free(sprB2);
}

void afficherPlaquette(uint16 x, uint8 y, uint8 humain, uint8 couleur, bool first) {
    // le fond
    switch (humain) {
    case 0: // disabled
        afficherGrafx_file(FILE_NEWGAME_FOND_OFF, x, y, SCREEN_WORKING, 0xFFFF);
        break;
    case 1: // humain
        afficherGrafx_file(FILE_NEWGAME_FOND_HUMAN + couleur, x, y, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_AVATAR_HUMAN_35PX + couleur, x+9, y+4, SCREEN_WORKING, 0xFFFF); // à revoir
        afficherGrafx_file(FILE_NEWGAME_RING_HUMAIN, x, y, SCREEN_WORKING, 0xFFFF);
        ecrireGrafxA("Human", x+53,y+13, 0xFFFF);
        break;
    case 2: // bot 1
        afficherGrafx_file(FILE_NEWGAME_FOND_BOT + couleur, x, y, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_AVATAR_48PX_BOT1 + couleur, x+5, y+1, SCREEN_WORKING, 0xFFFF);//(46-36)/2
        afficherGrafx_file(FILE_NEWGAME_RING_BOT, x, y, SCREEN_WORKING, 0xFFFF);
        ecrireGrafxA("Bot", x+53,y+13, 0xFFFF);
        break;
    case 3: // bot 2
        afficherGrafx_file(FILE_NEWGAME_FOND_BOT + couleur, x, y, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_AVATAR_48PX_BOT2 + couleur, x+5, y+1, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_NEWGAME_RING_BOT, x, y, SCREEN_WORKING, 0xFFFF);
        ecrireGrafxA("Bot", x+53,y+13, 0xFFFF);
        break;
    case 4: // bot 3
        afficherGrafx_file(FILE_NEWGAME_FOND_BOT + couleur, x, y, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_AVATAR_48PX_BOT3 + couleur, x+5, y+1, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_NEWGAME_RING_BOT, x, y, SCREEN_WORKING, 0xFFFF);
        ecrireGrafxA("Bot", x+53,y+13, 0xFFFF);
        break;
    case 5: // bot 4
        afficherGrafx_file(FILE_NEWGAME_FOND_BOT + couleur, x, y, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_AVATAR_48PX_BOT4 + couleur, x+5, y+1, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_NEWGAME_RING_BOT, x, y, SCREEN_WORKING, 0xFFFF);
        ecrireGrafxA("Bot", x+53,y+13, 0xFFFF);
        break;
    }
    if (humain == 0) {
        afficherGrafx_file(FILE_NEWGAME_FIRST_DIS, x + 130, y + 5, SCREEN_WORKING, 0xFFFF); // (48-38)/2
    } else {
        if (first) {
            afficherGrafx_file(FILE_NEWGAME_FIRST_ON, x + 130, y + 5, SCREEN_WORKING, 0xFFFF);
        } else {
            afficherGrafx_file(FILE_NEWGAME_FIRST_OFF, x + 130, y + 5, SCREEN_WORKING, 0xFFFF);
        }
    }
}

uint8 afficherNouvellePartie() {
    uint32 taille = chargerTaille_file(FILE_NEWGAME_FOND);
    unsigned char *sprFond = malloc(taille);
    chargerGrafx_file(sprFond, FILE_NEWGAME_FOND, taille);

    empilerBackScr();
    // faire apparaitre la planche en bois
    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
        afficherGrafx_buffer(sprFond, round(273 * i / CPT_ANIMATION)-226,0, SCREEN_WORKING, 0xFFFF);
        afficherBackScreen();

        if (i != 0) {
            depilerBackScr();
        }
    }

    uint8 first = 0;
    uint8 couleur[5];
    uint8 humain[5];
    uint16 couleurFonte[5];

    couleurFonte[0] = 0xFFFF; //(0x001F); // Blue
    couleurFonte[1] = 0xFFFF; //(0x07E0); // Green
    couleurFonte[2] = 0xFFFF; //(0xF81F); // Purple (Red + Blue)
    couleurFonte[3] = 0xFFFF; //(0xF800); // Red
    couleurFonte[4] = 0x18E3; //(0xFFE0); // Yellow (Red + Green)

    for (uint8 i=0; i<5; i++) {
        couleur[i] = 0;
        humain[i] = 0;
    }

    couleur[0] = rand() % 5;
    couleur[1] = rand() % 5;
    while (couleur[1] == couleur[0]) {
        couleur[1] = rand() % 5;
    }
    couleur[2] = rand() % 5;
    while ((couleur[2] == couleur[0]) || (couleur[2] == couleur[1])) {
        couleur[2] = rand() % 5;
    }
    couleur[3] = rand() % 5;
    while ((couleur[3] == couleur[0]) || (couleur[3] == couleur[1]) || (couleur[3] == couleur[2])) {
        couleur[3] = rand() % 5;
    }
    couleur[4] = rand() % 5;
    while ((couleur[4] == couleur[0]) || (couleur[4] == couleur[1]) || (couleur[4] == couleur[2]) || (couleur[4] == couleur[3])) {
        couleur[4] = rand() % 5;
    }

    switch (rand() % 5) {
    case 0:
        humain[0] = 1; // humain
        break;
    case 1:
        first = rand() % 2;
        switch (rand() % 2) {
        case 0:
            humain[0] = 1;
            humain[1] = 2 + rand() % 4;
            break;
        case 1:
            humain[0] = 2 + rand() % 4;
            humain[1] = 1;
            break;
        }
        break;
    case 2:
        first = rand() % 3;
        switch (rand() % 3) {
        case 0:
            humain[0] = 1;
            humain[1] = 2 + rand() % 4;
            humain[2] = 2 + rand() % 4;
            while (humain[2] == humain[1]) {
                humain[2] = 2 + rand() % 4;
            }
            break;
        case 1:
            humain[0] = 2 + rand() % 4;
            humain[1] = 1;
            humain[2] = 2 + rand() % 4;
            while (humain[2] == humain[0]) {
                humain[2] = 2 + rand() % 4;
            }
            break;
        case 2:
            humain[0] = 2 + rand() % 4;
            humain[1] = 2 + rand() % 4;
            humain[2] = 1;
            while (humain[1] == humain[0]) {
                humain[1] = 2 + rand() % 4;
            }
            break;
        }
        break;
    case 3:
        first = rand() % 4;
        switch (rand() % 4) {
        case 0:
            humain[0] = 1;
            humain[1] = 2 + rand() % 4;
            humain[2] = 2 + rand() % 4;
            while (humain[2] == humain[1]) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[1]) || (humain[3] == humain[2])) {
                humain[3] = 2 + rand() % 4;
            }
            break;
        case 1:
            humain[0] = 2 + rand() % 4;
            humain[1] = 1;
            humain[2] = 2 + rand() % 4;
            while (humain[2] == humain[0]) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[0]) || (humain[3] == humain[2])) {
                humain[3] = 2 + rand() % 4;
            }
            break;
        case 2:
            humain[0] = 2 + rand() % 4;
            humain[1] = 2 + rand() % 4;
            while (humain[1] == humain[0]) {
                humain[1] = 2 + rand() % 4;
            }
            humain[2] = 1;
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[0]) || (humain[3] == humain[1])) {
                humain[3] = 2 + rand() % 4;
            }
            break;
        case 3:
            humain[0] = 2 + rand() % 4;
            humain[1] = 2 + rand() % 4;
            while (humain[1] == humain[0]) {
                humain[1] = 2 + rand() % 4;
            }
            humain[2] = 2 + rand() % 4;
            while ((humain[2] == humain[0]) || (humain[2] == humain[1])) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 1;
            break;
        }
        break;
    case 4:
        first = rand() % 5;
        switch (rand() % 5) {
        case 0:
            humain[0] = 1;
            humain[1] = 2 + rand() % 4;
            humain[2] = 2 + rand() % 4;
            while (humain[2] == humain[1]) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[1]) || (humain[3] == humain[2])) {
                humain[3] = 2 + rand() % 4;
            }
            humain[4] = 2 + rand() % 4;
            while ((humain[4] == humain[1]) || (humain[4] == humain[2]) || (humain[4] == humain[3])) {
                humain[4] = 2 + rand() % 4;
            }
            break;
        case 1:
            humain[0] = 2 + rand() % 4;
            humain[1] = 1;
            humain[2] = 2 + rand() % 4;
            while (humain[2] == humain[0]) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[0]) || (humain[3] == humain[2])) {
                humain[3] = 2 + rand() % 4;
            }
            humain[4] = 2 + rand() % 4;
            while ((humain[4] == humain[0]) || (humain[4] == humain[2]) || (humain[4] == humain[3])) {
                humain[4] = 2 + rand() % 4;
            }
            break;
        case 2:
            humain[0] = 2 + rand() % 4;
            humain[1] = 2 + rand() % 4;
            while (humain[1] == humain[0]) {
                humain[1] = 2 + rand() % 4;
            }
            humain[2] = 1;
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[0]) || (humain[3] == humain[1])) {
                humain[3] = 2 + rand() % 4;
            }
            humain[4] = 2 + rand() % 4;
            while ((humain[4] == humain[0]) || (humain[4] == humain[1]) || (humain[4] == humain[3])) {
                humain[4] = 2 + rand() % 4;
            }
            break;
        case 3:
            humain[0] = 2 + rand() % 4;
            humain[1] = 2 + rand() % 4;
            while (humain[1] == humain[0]) {
                humain[1] = 2 + rand() % 4;
            }
            humain[2] = 2 + rand() % 4;
            while ((humain[2] == humain[0]) || (humain[2] == humain[1])) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 1;
            humain[4] = 2 + rand() % 4;
            while ((humain[4] == humain[0]) || (humain[4] == humain[1]) || (humain[4] == humain[2])) {
                humain[4] = 2 + rand() % 4;
            }
            break;
        case 4:
            humain[0] = 2 + rand() % 4;
            humain[1] = 2 + rand() % 4;
            while (humain[1] == humain[0]) {
                humain[1] = 2 + rand() % 4;
            }
            humain[2] = 2 + rand() % 4;
            while ((humain[2] == humain[0]) || (humain[2] == humain[1])) {
                humain[2] = 2 + rand() % 4;
            }
            humain[3] = 2 + rand() % 4;
            while ((humain[3] == humain[0]) || (humain[3] == humain[1]) || (humain[3] == humain[2])) {
                humain[3] = 2 + rand() % 4;
            }
            humain[4] = 1;
            break;
        }
        break;
    }

    uint8 selectionChoix = 5;
    // 5: ok, 6: back, 0..4

    uint8 selectionCol = 1;
    bool dejaUtilise = false;

    bool reconstruire = true;
    bool afficher = true;

    while (etatGlobal == ETAT_NOUVELLE_PARTIE) {
        if (reconstruire) {
            // effacer le fond comme pour le menu ?
            afficherGrafx_buffer(sprFond, 47,0, SCREEN_WORKING, 0xFFFF);
            for (uint8 i=0; i<5; i++) {
                afficherPlaquette(67, i*47+6, humain[i], couleur[i], first == i);
            }
            empilerBackScr();
            afficher = true;
        }
        if (afficher) {
            afficher = false;
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // afficher uniquement le curseur
            if (selectionChoix == 5) {
                afficherGrafx_file(FILE_BUTTON_BACK,0,0, SCREEN_WORKING, 0xFFFF);

                afficherGrafx_file(FILE_BUTTON_RIGHT_OVER,320-32,240-32, SCREEN_WORKING, 0xFFFF);
                afficherGrafx_ram(RAM_CURSOR, 320-16-10, 240-16-1, SCREEN_WORKING, 0xFFFF);
            } else {
                afficherGrafx_file(FILE_BUTTON_RIGHT,320-32,240-32, SCREEN_WORKING, 0xFFFF);

                if (selectionChoix == 6) {
                    afficherGrafx_file(FILE_BUTTON_BACK_OVER,0,0, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_ram(RAM_CURSOR, 16-10, 16-1, SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_file(FILE_BUTTON_BACK,0,0, SCREEN_WORKING, 0xFFFF);
                    switch (selectionCol) {
                    case 0:
                        afficherGrafx_ram(RAM_CURSOR, 57+33-10, selectionChoix * 48 + 30 - 1, SCREEN_WORKING, 0xFFFF);
                        break;
                    case 1:
                        afficherGrafx_ram(RAM_CURSOR, 57+64-10, selectionChoix * 48 + 30 - 1, SCREEN_WORKING, 0xFFFF);
                        break;
                    case 2:
                        afficherGrafx_ram(RAM_CURSOR, 57+140+17-10, selectionChoix * 48 + 30 - 1, SCREEN_WORKING, 0xFFFF);
                        break;
                    }
                }
            }

            afficherBackScreen();
        }

        // On monte
        if (isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_8)) {
            if ((selectionChoix < 5) && (selectionChoix > 0)) {
                afficher = true;
                // on passe au dessus
                selectionChoix--;
                if (humain[selectionChoix] == 0) {
                    selectionCol = 1;
                }
            } else {
                if (selectionChoix == 5) {
                    // on passe au dernier
                    afficher = true;
                    selectionChoix = 4;
                    selectionCol = 2;
                    if (humain[selectionChoix] == 0) {
                        selectionCol = 1;
                    }
                } else {
                    if (selectionChoix == 0) {
                        // sur le back
                        afficher = true;
                        selectionChoix = 6;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_8));
        }
        // On descend
        if (isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_2)) {
            if (selectionChoix == 6) {
                // on passe au premier
                afficher = true;
                selectionChoix = 0;
                selectionCol = 0;
                if ((selectionChoix < 5) && (humain[selectionChoix] == 0)) {
                    selectionCol = 1;
                }
            } else {
                if (selectionChoix < 5) {
                    afficher = true;
                    // on passe au dessus
                    selectionChoix++;
                    if (humain[selectionChoix] == 0) {
                        selectionCol = 1;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_2));
        }

        // choix suivant
        if (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT) || isKeyPressed(KEY_NSPIRE_6)) {
            if (selectionChoix == 6) {
                // on passe au premier
                afficher = true;
                selectionChoix = 0;
                selectionCol = 0;
                if ((selectionChoix < 5) && (humain[selectionChoix] == 0)) {
                    selectionCol = 1;
                }
            } else {
                if (selectionChoix != 5) {
                    afficher = true;
                    if ((humain[selectionChoix] == 0) || (selectionCol == 2)) {
                        // on passe en dessous
                        selectionChoix++;
                        selectionCol = 0;
                        if ((selectionChoix < 5) && (humain[selectionChoix] == 0)) {
                            selectionCol = 1;
                        }
                    } else {
                        // changement de colonne
                        selectionCol++;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT) || isKeyPressed(KEY_NSPIRE_6));
        }
        // choix précédent
        if (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT) || isKeyPressed(KEY_NSPIRE_4)) {
            if (selectionChoix == 5) {
                // on passe au dernier
                afficher = true;
                selectionChoix = 4;
                selectionCol = 2;
                if (humain[selectionChoix] == 0) {
                    selectionCol = 1;
                }
            } else {
                if (selectionChoix != 6) {
                    afficher = true;
                    if ((humain[selectionChoix] == 0) || (selectionCol == 0)) {
                        if (selectionChoix > 0) {
                            // on passe au dessus
                            selectionChoix--;
                            selectionCol = 2;
                            if (humain[selectionChoix] == 0) {
                                selectionCol = 1;
                            }
                        } else {
                            selectionChoix = 6;
                        }
                    } else {
                        // changement de colonne
                        selectionCol--;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT)  || isKeyPressed(KEY_NSPIRE_4));
        }
        // sélectionner le choix
        if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER) || isKeyPressed(KEY_NSPIRE_5)) {
            if (selectionChoix == 5) {
                // vérifier d'avoir au moins un joueur actif
                bool ok = false;
                for (uint8 i=0; i<5; i++) {
                    if (humain[i] != 0) {
                        ok = true;
                    }
                }
                if (ok) {
                    // libérer les anciens joueurs
                    if (nbTotalJoueur != 0) {
                        doneJoueurs();
                    }
                    free(joueurs);

                    // créer les nouveaux
                    for (uint8 i=0; i<5; i++) {
                        if (humain[i] != 0) {
                            nbTotalJoueur++;
                        }
                    }

                    // libérer les routes
                    for (uint8 i=1; i<MAX_PATH; i++) {
                        paths[i].owner = 0;
                    }
                    for (uint16 i=1; i<MAX_PAVE; i++) {
                        paves[i].owner = 0;
                    }
                    nbPaveAAfficher = 0;
                    resetUsMap();
                    preparerUsMap();

                    joueurs = (ttrJoueur *)malloc((nbTotalJoueur + 1) * sizeof(ttrJoueur));
                    for (uint8 i=1; i<=nbTotalJoueur; i++) {
                        joueurs[i].points = 0;
                        joueurs[i].nbCartesWagon = 0;
                        joueurs[i].nbCartesMission = 0;
                        joueurs[i].nbWagons = 45;
                        joueurs[i].missionCourante = 0;
                        joueurs[i].affichageBas = 0;
                        joueurs[i].lastAction = 0;
                        joueurs[i].xCarte = 160;
                        joueurs[i].yCarte = 96;

                        memset(joueurs[i].lstCartesWagon,0,sizeof(joueurs[i].lstCartesWagon));
                        memset(joueurs[i].lstCartesMission,0,sizeof(joueurs[i].lstCartesMission));
                        memset(joueurs[i].nbCartes, 0, sizeof(joueurs[i].nbCartes));
                        for (uint8 j=0; j<30; j++) {
                            joueurs[i].missionsRealisee[j] = false;
                        }
                        for (uint8 j=0; j<36; j++) {
                            joueurs[i].villesAccessibles[j] = false;
                        }
                    }

                    // renseigner le premier joueur
                    uint8 idxJoueur = 0;
                    for (uint8 i=first; i<5; i++) {
                        if (humain[i] != 0) {
                            idxJoueur++;
                            joueurs[idxJoueur].humain = humain[i] == 1;
                            joueurs[idxJoueur].couleurW = couleur[i];
                            joueurs[idxJoueur].couleurFonte = couleurFonte[couleur[i]];
                            if (joueurs[idxJoueur].humain) {
                                joueurs[idxJoueur].avatar = couleur[i];
                            } else {
                                joueurs[idxJoueur].avatar = humain[i] - 1; // 1 à 4
                            }
                            switch (couleur[i]) {
                            case 0:
                                joueurs[idxJoueur].couleur = FILE_WAGON_BLUE_0_0;
                                break;
                            case 1:
                                joueurs[idxJoueur].couleur = FILE_WAGON_GREEN_0_0;
                                break;
                            case 2:
                                joueurs[idxJoueur].couleur = FILE_WAGON_PURPLE_0_0;
                                break;
                            case 3:
                                joueurs[idxJoueur].couleur = FILE_WAGON_RED_0_0;
                                break;
                            case 4:
                                joueurs[idxJoueur].couleur = FILE_WAGON_YELLOW_0_0;
                                break;
                            }
                        }
                    }
                    for (uint8 i=0; i<first; i++) {
                        if (humain[i] != 0) {
                            idxJoueur++;
                            joueurs[idxJoueur].humain = humain[i] == 1;
                            joueurs[idxJoueur].couleurW = couleur[i];
                            joueurs[idxJoueur].couleurFonte = couleurFonte[couleur[i]];
                            if (joueurs[idxJoueur].humain) {
                                joueurs[idxJoueur].avatar = couleur[i]; // 0 à 4
                            } else {
                                joueurs[idxJoueur].avatar = humain[i] - 1; // 1 à 4
                            }
                            switch (couleur[i]) {
                            case 0:
                                joueurs[idxJoueur].couleur = FILE_WAGON_BLUE_0_0;
                                break;
                            case 1:
                                joueurs[idxJoueur].couleur = FILE_WAGON_GREEN_0_0;
                                break;
                            case 2:
                                joueurs[idxJoueur].couleur = FILE_WAGON_PURPLE_0_0;
                                break;
                            case 3:
                                joueurs[idxJoueur].couleur = FILE_WAGON_RED_0_0;
                                break;
                            case 4:
                                joueurs[idxJoueur].couleur = FILE_WAGON_YELLOW_0_0;
                                break;
                            }
                        }
                    }

                    etatGlobal = ETAT_CHOIX_SLOT_SAUVEGARDE;
                    break;
                }
            }
            if (selectionChoix == 6) {
                etatGlobal = ETAT_MENU;
                break;
            }

            if (humain[selectionChoix] == 0) {
                // activation, en bot
                humain[selectionChoix] = 1;
                afficher = true;
                reconstruire = true;

                // se ce bot est déjà utilisé
                dejaUtilise = true;
                while (dejaUtilise) {
                    humain[selectionChoix]++;
                    if (humain[selectionChoix] == 6) {
                        humain[selectionChoix] = 1;
                    }
                    dejaUtilise = false;
                    if (humain[selectionChoix] > 1) {
                        for (uint8 i=0; i<5; i++) {
                            if (i != selectionChoix) {
                                if (humain[i] == humain[selectionChoix]) {
                                    dejaUtilise = true;
                                }
                            }
                        }
                    }
                }
                // si cette couleur est déjà utilisée, on la change
                dejaUtilise = false;
                for (uint8 i=0; i<5; i++) {
                    if (i != selectionChoix) {
                        if ((humain[i] > 0) && (couleur[i] == couleur[selectionChoix])) {
                            dejaUtilise = true;
                        }
                    }
                }
                while (dejaUtilise) {
                    couleur[selectionChoix]++;
                    if (couleur[selectionChoix] == 5) {
                        couleur[selectionChoix] = 0;
                    }
                    // si cette couleur est déjà utilisée, on la change
                    dejaUtilise = false;
                    for (uint8 i=0; i<5; i++) {
                        if (i != selectionChoix) {
                            if ((humain[i] > 0) && (couleur[i] == couleur[selectionChoix])) {
                                dejaUtilise = true;
                            }
                        }
                    }
                }

            } else {
                switch (selectionCol) {
                case 0:
                    // humain ou bot
                    afficher = true;
                    reconstruire = true;
                    // se ce bot est déjà utilisé
                    dejaUtilise = true;
                    while (dejaUtilise) {
                        humain[selectionChoix]++;
                        if (humain[selectionChoix] == 6) {
                            humain[selectionChoix] = 1;
                        }
                        dejaUtilise = false;
                        if (humain[selectionChoix] > 1) {
                            for (uint8 i=0; i<5; i++) {
                                if (i != selectionChoix) {
                                    if (humain[i] == humain[selectionChoix]) {
                                        dejaUtilise = true;
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 1:
                    afficher = true;
                    reconstruire = true;
                    // couleur
                    dejaUtilise = true;
                    while (dejaUtilise) {
                        couleur[selectionChoix]++;
                        if (couleur[selectionChoix] == 5) {
                            couleur[selectionChoix] = 0;
                        }
                        // si cette couleur est déjà utilisée, on la change
                        dejaUtilise = false;
                        for (uint8 i=0; i<5; i++) {
                            if (i != selectionChoix) {
                                if ((humain[i] > 0) && (couleur[i] == couleur[selectionChoix])) {
                                    dejaUtilise = true;
                                }
                            }
                        }
                    }
                    break;
                case 2:
                    first = selectionChoix;
                    afficher = true;
                    reconstruire = true;
                    break;
                }
            }

            while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER) || isKeyPressed(KEY_NSPIRE_5));
        }
        // refuser
        if (isKeyPressed(KEY_NSPIRE_SHIFT)) {
            if (selectionChoix < 5) {
                humain[selectionChoix] = 0;
                selectionCol = 1;
                afficher = true;
                reconstruire = true;
                if (first == selectionChoix) {
                    // prendre le premier non disabled
                    for (uint8 i=0; i<5; i++) {
                        if ((i != selectionChoix) && (humain[i] > 0)) {
                            first = i;
                            break;
                        }
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_SHIFT));
        }

        if (isKeyPressed(KEY_NSPIRE_ESC)) {
            etatGlobal = ETAT_MENU;
            break;
        }
    }

    free(sprFond);
    return etatGlobal;
}

void afficherPastilleJoueur(bool humain, uint8 couleur, uint8 avatar, uint16 x, uint8 y) {
    if (humain) {
        afficherGrafx_file(FILE_LOADGAME_PASTILLE_HUMAIN + couleur, x, y+9, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(FILE_AVATAR_HUMAN_35PX + couleur, x, y, SCREEN_WORKING, 0xFFFF);
    } else {
        afficherGrafx_file(FILE_LOADGAME_PASTILLE_BOT + couleur, x, y+9, SCREEN_WORKING, 0xFFFF);
        switch (avatar) {
        case 1:
            afficherGrafx_file(FILE_AVATAR_35PX_BOT1 + couleur, x+3, y, SCREEN_WORKING, 0xFFFF);
            break;
        case 2:
            afficherGrafx_file(FILE_AVATAR_35PX_BOT2 + couleur, x+3, y, SCREEN_WORKING, 0xFFFF);
            break;
        case 3:
            afficherGrafx_file(FILE_AVATAR_35PX_BOT3 + couleur, x+3, y, SCREEN_WORKING, 0xFFFF);
            break;
        case 4:
            afficherGrafx_file(FILE_AVATAR_35PX_BOT4 + couleur, x+3, y, SCREEN_WORKING, 0xFFFF);
            break;
        }
    }
}

uint8 choisirSlot(bool modeChargement) {
    // faire apparaitre le plateau de chargement
    uint32 taille = chargerTaille_file(FILE_LOADGAME_FOND);
    unsigned char *sprFond = malloc(taille);
    chargerGrafx_file(sprFond, FILE_LOADGAME_FOND, taille);

    // afficher le fond du menu (loco + gerry)
    dumperScreen(FILE_MAINMENU_FOND, 320 * 240 * 2, 0);
    afficherGrafx_file(FILE_MAINMENU_LOCO, 0, 89, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_file(FILE_MAINMENU_PILAR, 0, 0, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_file(FILE_MAINMENU_GERRY_TICKET, 0, 29, SCREEN_WORKING, 0xFFFF);
    empilerBackScr();

    // faire apparaitre la planche de fond 268
    for (uint8 i=0; i < CPT_ANIMATION + 1; i++) {
        afficherGrafx_buffer(sprFond, round(294 * i / CPT_ANIMATION)-268,0, SCREEN_WORKING, 0xFFFF);
        afficherBackScreen();
        depilerBackScr();
    }
    afficherGrafx_buffer(sprFond, 26,0, SCREEN_WORKING, 0xFFFF);
    ecrireGrafxA("Turn", 26+20, 26+2, 0xFFFF);

    // afficher les sauvegardes
    ttrJoueur *dummy;
    uint8 nbDummy;
    uint8 aQuiLeTour;
    uint8 tourNo;
    uint8 idxJoueur;
    bool sauvegarde[5];

    for (uint8 i=0; i<5; i++) {
        // on essaye de charger la sauvegarde
        memset(partie, 0, 22);
        strcpy(partie, "grafx/sav_");
        empilerPartie(i+1);
        strcat(partie, ".tns");
        FILE *ttrfic = fopen(getCheminFichier(partie), "rb");

        if(!ttrfic) {
            // pas de sauvegarde
            sauvegarde[i] = false;
        } else {
            // charger une partie de cette sauvegarde
            sauvegarde[i] = true;

            // la version
            uint8 version;
            fread(&version, sizeof(uint8), 1, ttrfic);
            // les joueurs
            fread(&nbDummy, sizeof(uint8), 1, ttrfic);
            dummy = (ttrJoueur *)malloc((nbDummy + 1) * sizeof(ttrJoueur));
            for (uint8 i=1; i<=nbDummy; i++) {
                fread(&dummy[i], sizeof(ttrJoueur), 1, ttrfic);
            }
            // à qui le tour
            fread(&aQuiLeTour, sizeof(uint8), 1, ttrfic);
            // numéro du tour
            fread(&tourNo, sizeof(uint8), 1, ttrfic);
            // libérer le fichier
            fclose(ttrfic);

            afficherGrafx_file(FILE_LOADGAME_VIGNETTE, 245, 45 + 35 * i, SCREEN_WORKING, 0xFFFF);

            // afficher les joueurs en commençant par le joueur actif
            idxJoueur = 0;
            for (uint8 j=aQuiLeTour; j<=nbDummy; j++) {
                if  (j != 0) {
                    afficherPastilleJoueur(dummy[j].humain, dummy[j].couleurW, dummy[j].avatar, 82 + idxJoueur * 33, i * 36 + 37);
                    idxJoueur++;
                }
            }
            for (uint8 j=1; j<aQuiLeTour; j++) {
                afficherPastilleJoueur(dummy[j].humain, dummy[j].couleurW, dummy[j].avatar, 82 + idxJoueur * 33, i * 36 + 37);
                idxJoueur++;
            }
            // écrire le n° du tour ?  round:xx
            // si la partie est finie, afficher la coupe
            if (aQuiLeTour == 0) {
                afficherGrafx_ram(RAM_LAST_TURN, 44, i*36+38, SCREEN_WORKING, 0xFFFF);
                // sauvegarde[i] = false; temporairement, pour pouvoir recharger la partie
            } else {
                ecrireGrafx0(tourNo, 64 - taillerGrafx0(tourNo), i*36+37 + 12, 0xFFFF);
            }

            // afficher
            afficherBackScreen();

            // libérer la sauvegarde
            free(dummy);
        }
    }
    empilerBackScr();
    free(sprFond);

    uint8 selectionChoix = 0;
    uint8 savSelection = 0;
    bool afficher = true;
    etatGlobal = 0;
    while (etatGlobal == 0) {
        if (afficher) {
            afficher = false;
            depilerBackScr();
            // bouton back
            if (selectionChoix == 0) {
                afficherGrafx_file(FILE_BUTTON_BACK_OVER,0,0, SCREEN_WORKING, 0xFFFF);
                afficherGrafx_ram(RAM_CURSOR, 16-10, 16-1, SCREEN_WORKING, 0xFFFF);
            } else {
                afficherGrafx_file(FILE_BUTTON_BACK,0,0, SCREEN_WORKING, 0xFFFF);
                // texte
                afficherGrafx_file(FILE_MAINMENU_TEXT, 37, 240-23, SCREEN_WORKING, 0xFFFF);
                if (modeChargement) {
                    ecrireGrafxA("Load this game", 160-45, 240-15, 0xFFFF);
                } else {
                    if (sauvegarde[selectionChoix - 1]) {
                        ecrireGrafxA("Replace this savegame", 160-69, 240-15, 0xFFFF);
                    } else {
                        ecrireGrafxA("Use this location", 160-51, 240-15, 0xFFFF);
                    }
                }

                // sélection
                afficherGrafx_ram(RAM_CURSOR, 160-10, selectionChoix * 36 + 20, SCREEN_WORKING, 0xFFFF);
            }
            afficherBackScreen();
        }
        // choix suivant
        if (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_2)) {
            if (selectionChoix < 5) {
                afficher = true;
                savSelection = selectionChoix;
                selectionChoix++;
                if (modeChargement) {
                    // se placer sur une sauvegarde existante
                    while ((selectionChoix < 5) && (!sauvegarde[selectionChoix - 1])) {
                        selectionChoix++;
                    }
                    if (!sauvegarde[selectionChoix - 1]) {
                        selectionChoix = savSelection;
                        afficher = false;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN) || isKeyPressed(KEY_NSPIRE_2));
        }
        // choix précédent
        if (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_8)) {
            if (selectionChoix > 0) {
                afficher = true;
                selectionChoix--;
                if (modeChargement) {
                    // se placer sur une sauvegarde existante
                    while ((selectionChoix > 0) && (!sauvegarde[selectionChoix - 1])) {
                        selectionChoix--;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP) || isKeyPressed(KEY_NSPIRE_8));
        }
        // sélectionner le choix
        if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER) || isKeyPressed(KEY_NSPIRE_5)) {
            if (selectionChoix == 0) {
                etatGlobal = ETAT_MENU;
            } else {
                if (modeChargement) {
                    etatGlobal = ETAT_LOADING_SLOT_1 + selectionChoix - 1;
                } else {
                    etatGlobal = ETAT_CHOIX_SLOT_1 + selectionChoix - 1;
                }
            }
            while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER) || isKeyPressed(KEY_NSPIRE_5));
        }

        // afficher la vignette
        if (modeChargement) {
            if (isKeyPressed(KEY_NSPIRE_TAB) || isKeyPressed(KEY_NSPIRE_RIGHT) || isKeyPressed(KEY_NSPIRE_6)) {
                // la vignette de la sauvegarde
                chargerPartie(selectionChoix);
                afficherMiniCarte(false);

                afficher = true;
                while (isKeyPressed(KEY_NSPIRE_TAB) || isKeyPressed(KEY_NSPIRE_RIGHT) || isKeyPressed(KEY_NSPIRE_6));
            }
        }

        if (isKeyPressed(KEY_NSPIRE_ESC)) {
            etatGlobal = ETAT_MENU;
            while (isKeyPressed(KEY_NSPIRE_ESC));
        }
    }

    return etatGlobal;
}

void afficherFinDuJeu() {
    // Afficher les scores
    uint16 plusLong[6];
    uint16 best = 0;
    sint16 ouY;

    clearBackScreen();
    dumperScreen(FILE_FOND_SCORE, 320 * 208 * 2, 16);
    afficherBackScreen();

    uint32 taille = chargerTaille_file(FILE_MINI_LONG_ROAD);
    unsigned char *sprMiniLR = malloc(taille);
    chargerGrafx_file(sprMiniLR, FILE_MINI_LONG_ROAD, taille);

    unsigned char *tchoutchou[5];
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        taille = chargerTaille_file(FILE_SCORE_TRAIN_BLUE + joueurs[i].couleurW);
        tchoutchou[i] = malloc(taille);
        chargerGrafx_file(tchoutchou[i], FILE_SCORE_TRAIN_BLUE + joueurs[i].couleurW, taille);
    }

    // Route la plus longue
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        plusLong[i] = 0;
        if (joueurs[i].points > 0) {
            plusLong[i] = pathfinder_cheminLePlusLong(i);
            if (plusLong[i] > best) {
                best = plusLong[i];
            }
        }
    }
    uint8 maxPts = 0;
    uint8 zeWinnerIz = 0;

    sint16 total[5];
    uint16 mok[5];
    uint16 mko[5];

    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        // calculer les points
        mok[i] = 0;
        mko[i] = 0;
        for (uint8 j=0; j<joueurs[i].nbCartesMission; j++) {
            if (joueurs[i].missionsRealisee[j]) {
                mok[i] += missions[joueurs[i].lstCartesMission[j]].pts;
            } else {
                mko[i] += missions[joueurs[i].lstCartesMission[j]].pts;
            }
        }
        total[i] = joueurs[i].points + mok[i] - mko[i];
        if ((best == plusLong[i]) && (best > 0)) {
            total[i] += 10;
        }
        if (total[i] > maxPts) {
            maxPts = total[i];
        }

        if (total[i] == maxPts) {
            if (zeWinnerIz == 0) {
                zeWinnerIz = i;
            } else {
                // The player with the most points wins the game. If two or more players are tied for the most points, the player who has completed the most Destination
                // Tickets wins. In the unlikely event that they are still tied, the player with the Longest Continuous Path card wins.
                uint8 nbMissionsOk1 = 0;
                uint8 nbMissionsOk2 = 0;
                for (uint8 j=0; j<joueurs[i].nbCartesMission; j++) {
                    if (joueurs[i].missionsRealisee[j]) {
                        nbMissionsOk1++;
                    }
                }
                for (uint8 j=0; j<joueurs[zeWinnerIz].nbCartesMission; j++) {
                    if (joueurs[zeWinnerIz].missionsRealisee[j]) {
                        nbMissionsOk2++;
                    }
                }
                if (nbMissionsOk1 > nbMissionsOk2) {
                    zeWinnerIz = i;
                } else {
                    if (nbMissionsOk1 == nbMissionsOk2) {
                        if (pathfinder_cheminLePlusLong(i) > pathfinder_cheminLePlusLong(zeWinnerIz)) {
                            zeWinnerIz = i;
                        }
                    }
                }
            }
        }
    }

    // l'entete
    ouY = 0;
    afficherGrafx_ram(RAM_MINI_WAG_BLUE,   100+7+10,  ouY+0, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_ram(RAM_MINI_MISSION_OK, 100+44+20, ouY+2, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_ram(RAM_MINI_MISSION_KO, 100+44*2+20, ouY+2, SCREEN_WORKING, 0xFFFF);
    afficherGrafx_buffer(sprMiniLR, 100+44*3+20, ouY+2, SCREEN_WORKING, 0xFFFF);
    empilerBackScr();

    // animer les trains
    for (uint16 ani=0; ani<(2 * CPT_ANIMATION); ani++) {
        depilerBackScr();
        ouY = 24;
        for (uint8 i=1; i<=nbTotalJoueur; i++) {
            // petit train
            afficherGrafx_buffer(tchoutchou[i], trunc((total[i] * ani) / (2 * CPT_ANIMATION)) - 300, ouY, SCREEN_WORKING, 0xFFFF);
            ouY += 38;
        }
        afficherBackScreen();
    }
    // afficher les scores
    ouY = 24;
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        // Les points
        ecrireGrafx0(joueurs[i].points, 100 + 40 - taillerGrafx0(joueurs[i].points), ouY + 6, 0xFFFF);
        // missions ok
        if (mok[i] > 0) {
            ecrireGrafx0(mok[i], 100 + 40 - taillerGrafx0(mok[i]) + 44, ouY + 6, 0x07E0);
        }
        // missions ko
        if (mko[i] > 0) {
            ecrireGrafx0(- mko[i], 100 + 40 - taillerGrafx0(- mko[i]) + 44 * 2, ouY + 6, 0xF800);
        }
        // route la plus longue
        if ((best == plusLong[i]) && (best > 0)) {
            ecrireGrafx0(10, 100 + 40 - taillerGrafx0(10) + 44 * 3, ouY + 6, 0x07E0);
        }
        // Total
        if (total[i] < 0) {
            ecrireGrafx0(total[i], 100 + 40 - taillerGrafx0(total[i]) + 44 * 4, ouY + 6, 0xF800);
        } else {
            ecrireGrafx0(total[i], 100 + 40 - taillerGrafx0(total[i]) + 44 * 4, ouY + 6, 0xFFFF);
        }

        ouY += 38;
    }
    afficherBackScreen();
    empilerBackScr();

    // afficher le grand gagnant
    for (uint8 i=1; i<23; i++) {
        depilerBackScr();

        afficherGrafx_file(FILE_MAINMENU_TEXT, 37, 240-i, SCREEN_WORKING, 0xFFFF);
        switch (joueurs[zeWinnerIz].couleurW) {
        case 0:
            ecrireGrafxA("Blue wins !", 128, 262-15-i, 0xFFFF);
            break;
        case 1:
            ecrireGrafxA("Green wins !", 122, 262-15-i, 0xFFFF);
            break;
        case 2:
            ecrireGrafxA("Purple wins !", 129, 262-15-i, 0xFFFF);
            break;
        case 3:
            ecrireGrafxA("Red wins !", 121, 262-15-i, 0xFFFF);
            break;
        case 4:
            ecrireGrafxA("Yellow wins !", 119, 262-15-i, 0xFFFF);
            break;
        }
        afficherBackScreen();
    }

//ecrireGrafxA("ROUGE", 10, 30, 0xF800);
//ecrireGrafxA("VERT", 10, 10, 0x07E0);
//ecrireGrafxA("BLEU", 10, 50, 0x001F);
//ecrireGrafxA("BLANC", 10, 70, 0xFFFF);

    while (!isKeyPressed(KEY_NSPIRE_ESC) && !isKeyPressed(KEY_NSPIRE_MENU) && !isKeyPressed(KEY_NSPIRE_5) && !isKeyPressed(KEY_NSPIRE_DOWN) && !isKeyPressed(KEY_NSPIRE_UP) &&
            !isKeyPressed(KEY_NSPIRE_8) && !isKeyPressed(KEY_NSPIRE_2) && !isKeyPressed(KEY_NSPIRE_TAB) && !isKeyPressed(KEY_NSPIRE_CTRL) && !isKeyPressed(KEY_NSPIRE_DEL)) {
    }

    uint8 sav_carte = 0;
    uint8 sav_joueur = 0;
    bool sav_realise = false;

    // mode détaillé
    while (!isKeyPressed(KEY_NSPIRE_ESC)) {
        // calculer la taille totale
        uint16 maxiY = 24 + (44 + 4) * nbTotalJoueur;
        uint8 maxiCM = 0;
        for (uint8 i=1; i<=nbTotalJoueur; i++) {
            maxiY += trunc(joueurs[i].nbCartesMission / 3) * 54;
            if ((joueurs[i].nbCartesMission % 3) > 0) {
                maxiY += 54;
            }
            maxiCM += joueurs[i].nbCartesMission;
        }

        // préparer le fond
        clearBackScreen();
        dumperScreen(FILE_FOND_SCORE, 320 * 208 * 2, 16);
        empilerBackScr();

        // et let's go
        uint8 selection = 0;
        uint16 decalY = 0;
        bool afficher = true;
        while (!isKeyPressed(KEY_NSPIRE_ESC)) {
            if (afficher) {
                afficher = false;
                depilerBackScr();

                ouY = -decalY;
                // bandeau du haut
                if ((ouY > -24) && (ouY < 240)) {
                    afficherGrafx_ram(RAM_MINI_WAG_BLUE,   100+7+10,  ouY+0, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_ram(RAM_MINI_MISSION_OK, 100+44+20, ouY+2, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_ram(RAM_MINI_MISSION_KO, 100+44*2+20, ouY+2, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_buffer(sprMiniLR, 100+44*3+20, ouY+2, SCREEN_WORKING, 0xFFFF);
                }
                ouY += 24;

                uint8 cursor = 0;

                // les joueurs
                for (uint8 i=1; i<=nbTotalJoueur; i++) {
                    if ((ouY > -38) && (ouY < 240)) {
                        // le train + les points
                        afficherGrafx_buffer(tchoutchou[i], total[i] - 300, ouY, SCREEN_WORKING, 0xFFFF);
                    }
                    ouY += 6;
                    if ((ouY > -17) && (ouY < 240)) {
                        // Les points
                        ecrireGrafx0(joueurs[i].points, 100 + 40 - taillerGrafx0(joueurs[i].points), ouY, 0xFFFF);
                        // missions ok
                        if (mok[i] > 0) {
                            ecrireGrafx0(mok[i], 100 + 40 - taillerGrafx0(mok[i]) + 44, ouY, 0x07E0);
                        }
                        // missions ko
                        if (mko[i] > 0) {
                            ecrireGrafx0(- mko[i], 100 + 40 - taillerGrafx0(- mko[i]) + 44 * 2, ouY, 0xF800);
                        }
                        // route la plus longue
                        if ((best == plusLong[i]) && (best > 0)) {
                            ecrireGrafx0(10, 100 + 40 - taillerGrafx0(10) + 44 * 3, ouY, 0x07E0);
                        }
                        // Total
                        if (total[i] < 0) {
                            ecrireGrafx0(total[i], 100 + 40 - taillerGrafx0(total[i]) + 44 * 4, ouY, 0xF800);
                        } else {
                            ecrireGrafx0(total[i], 100 + 40 - taillerGrafx0(total[i]) + 44 * 4, ouY, 0xFFFF);
                        }
                    }
                    ouY += 34;

                    // les missions
                    uint8 cpt = 0;
                    uint16 ouX = 16;
                    for (uint8 j=0; j<joueurs[i].nbCartesMission; j++) {
                        afficherTicketDestination(i, joueurs[i].lstCartesMission[j], 80, ouX, ouY, true, false, joueurs[i].missionsRealisee[j]);
                        if (selection == cursor) {
                            afficherGrafx_ram(RAM_CURSOR, ouX+40-10, ouY+26-1, SCREEN_WORKING, 0xFFFF);
                            // stocker la carte ici
                            sav_carte = joueurs[i].lstCartesMission[j];
                            sav_joueur = i;
                            sav_realise = joueurs[i].missionsRealisee[j];
                        }

                        ouX += 96;
                        cpt++;
                        cursor++;
                        if (cpt == 3) {
                            cpt = 0;
                            ouX = 16;
                            ouY += 54;
                        }
                    }
                    if (cpt > 0) {
                        ouY += 54;
                    }

                    ouY += 4;
                }
                afficherBackScreen();
            }

            if (isKeyPressed(KEY_NSPIRE_5)) {
                // préparer l'affichage pour la carte sélectionnée
                if (sav_joueur != 0) {
                    effacerMapSelection();
                    if (sav_realise) {
                        selectionnerMission(sav_carte, RAM_CARTE_VILLE_OK);
                    } else {
                        selectionnerMission(sav_carte, RAM_CARTE_VILLE_KO);
                    }
                }

                afficherMiniCarte(false);
                while (isKeyPressed(KEY_NSPIRE_5));
                afficher = true;
            }
            if (isKeyPressed(KEY_NSPIRE_TAB)) {
                if (sav_joueur != 0) {
                    bool sav_humain = joueurs[sav_joueur].humain;
                    joueurs[sav_joueur].humain = true;
                    afficherZoomCarteMission(sav_joueur, sav_carte, sav_realise);
                    joueurs[sav_joueur].humain = sav_humain;
                    afficher = true;
                }
            }
            if (isKeyPressed(KEY_NSPIRE_2) || isKeyPressed(KEY_NSPIRE_DOWN)) {
                if (decalY < maxiY - 240) {
                    decalY += 8;
                    afficher = true;
                }
            }
            if (isKeyPressed(KEY_NSPIRE_8) || isKeyPressed(KEY_NSPIRE_UP)) {
                if (decalY >= 8) {
                    decalY -= 8;
                    afficher = true;
                }
            }
            if (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_RIGHT)) {
                if (selection < maxiCM-1) {
                    selection++;
                    afficher=true;
                }
            }
            if (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_LEFT)) {
                if (selection > 0) {
                    selection--;
                    afficher=true;
                }
            }
        }
    }

    while (isKeyPressed(KEY_NSPIRE_ESC));

    free(sprMiniLR);
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        free(tchoutchou[i]);
    }
}

void terminerPartie(uint8 slotCourant) {
    sauverPartie(0, slotCourant);
}

void afficherCredits() {
    dumperScreen(FILE_CREDITS_FOND, 320 * 240 * 2, 0);
    empilerBackScr();

    uint32 taille = chargerTaille_file(FILE_CREDITS_CURTAIN);
    unsigned char *sprCurtain = malloc(taille);
    chargerGrafx_file(sprCurtain, FILE_CREDITS_CURTAIN, taille);

    taille = chargerTaille_file(FILE_CREDITS_DOW);
    unsigned char *sprDow = malloc(taille);
    chargerGrafx_file(sprDow, FILE_CREDITS_DOW, taille);

    taille = chargerTaille_file(FILE_CREDITS_ASMODEE);
    unsigned char *sprAsmodee = malloc(taille);
    chargerGrafx_file(sprAsmodee, FILE_CREDITS_ASMODEE, taille);

    while (isKeyPressed(KEY_NSPIRE_ENTER));

    int y;
    uint8 cpt = 0;
    for (int ouY=240; ouY>-720;) {
        depilerBackScr();

        y = ouY;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Ticket To Ride", 115, y, 0xFFFF);
        }
        y += 30;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("nSpire version by Dubs", 86, y, 0xFFFF);
        }
        y += 50;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Adapted from the original board game", 44, y, 0xFFFF);
        }
        y += 20;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("designed by Alan R. Moon", 80, y, 0xFFFF);
        }
        y += 50;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Original Illustrations", 99, y, 0xFFFF);
        }
        y += 20;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Julien Delval", 122, y, 0xFFFF);
        }
        y += 60;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Special Thanks", 114, y, 0xFFFF);
        }
        y += 20;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("to all the Ti-planet.org users", 73, y, 0xFFFF);
        }
        y += 60;
        if ((y > -96) && (y < 240)) {
            afficherGrafx_buffer(sprDow, 40, y, SCREEN_WORKING, 0xFFFF);
        }
        y += 110;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Copyrights & Trademarks", 81, y, 0xFFFF);
        }
        y += 20;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Board game, artwork and rules", 68, y, 0xFFFF);
        }
        y += 20;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Copyright 2012-2016 Days of Wonder, Inc.", 29, y, 0xFFFF);
        }
        y += 20;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("All Rights Reserved.", 99, y, 0xFFFF);
        }
        y += 50;
        if ((y > -15) && (y < 240)) {
            ecrireGrafxA("Days of Wonder is an Asmodee company.", 32, y, 0xFFFF);
        }
        y += 20;
        if ((y > -180) && (y < 240)) {
            afficherGrafx_buffer(sprAsmodee, 70, y, SCREEN_WORKING, 0xFFFF);
        }

        afficherGrafx_buffer(sprCurtain, 0, 0, SCREEN_WORKING, 0xFFFF);
        afficherBackScreen();

        cpt++;
        if (cpt > 5) {
            ouY--;
        }

        if (any_key_pressed()) {
            return;
        }
    }

    free(sprCurtain);
    free(sprDow);
    free(sprAsmodee);

    while (isKeyPressed(KEY_NSPIRE_ESC) || isKeyPressed(KEY_NSPIRE_ENTER));
}


void testerPassAndPlay() {
    passAndPlayActif = false;

    uint8 nbHumain = 0;
    for (uint8 i=1; i<=nbTotalJoueur; i++) {
        // Les points
        if (joueurs[i].humain) {
            nbHumain++;
        }
    }
    passAndPlayActif = nbHumain > 1;

    if (passAndPlayActif) {
        // demander le code pin des joueurs humains
        for (uint8 i=1; i<=nbTotalJoueur; i++) {
            codePin[i] = 1000;
        }
    }
}

bool attendreTuto() {
    afficherBackScreen();
    while (true) {
        if (isKeyPressed(KEY_NSPIRE_ESC)) {
            while (isKeyPressed(KEY_NSPIRE_ESC));
            free(joueurs);
            return true;
        }
        if (isKeyPressed(KEY_NSPIRE_ENTER)) {
            while (isKeyPressed(KEY_NSPIRE_ENTER));
            return false;
        }
    }

}

bool tuto_animerPiocheCartesMissions() {
// piocher 3 cartes missions
    uint16 ax = 0;
    uint16 ay = 0;

    for (uint8 nb=0; nb<3; nb++) {
        // 1) de la droite vers le centre
        for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
            depilerBackScr();
            // de animationX, animationY vers (320-80)/2 , (240-52)/2
            ax = 275 - trunc(((275 - 120) * i) / CPT_ANIMATION);
            ay = -7 - trunc(((-7 - 94) * i) / CPT_ANIMATION);
            afficherGrafx_ram(RAM_CARD_SHADOW80, ax-2, ay-2, SCREEN_WORKING, 0xFFFF);
            afficherGrafx_ram(RAM_MIS_BA_80, ax, ay, SCREEN_WORKING, 0xFFFF);

            afficherBackScreen();
        }

        // 2) du centre vers le bas
        for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
            depilerBackScr();

            // de (320-80)/2 , (240-52)/2 vers (320-80)/2, 240
            ax = 35;
            ay = 40 - trunc(((40 - 240) * i) / CPT_ANIMATION);
            afficherTicketDestination(JOUEUR_TUTO, choixCarteMission[nb], 100, ax, ay, true, false, false);
            afficherBackScreen();
        }

        // stocker la carte en bas
        depilerBackScr();
        afficherTicketDestination(JOUEUR_TUTO, choixCarteMission[nb], 80, 18+86*nb, 240-17-30, false, false, false);
        empilerBackScr();
    }

    nbChoixCarteMission = 3;
    etatChoixCarteMission(JOUEUR_TUTO,0,true);


    return etatGlobal != ETAT_LIBERATION_MEMOIRE;
}

uint8 tuto_choix(bool forcerMission, bool forcerCarte, bool forcerWagon, bool afficherWagon, bool forcerCouleur, uint8 couleur, bool locoDisponible) {
    bool afficher = true;
    bool reconstruire = true;
    bool zoomEnCours = false;
    uint8 nbCartesPiochees = 0;
    if (!locoDisponible) {
        nbCartesPiochees = 1;
    }
    nbChoixCarteMission = 0;
    uint8 selectionChoix = joueurs[JOUEUR_TUTO].selectionChoix;

    // recaler la carte
    if (xCarte > MAX_CARTE_X) {
        xCarte = MAX_CARTE_X;
    }
    if (yCarte > MAX_CARTE_Y) {
        yCarte = MAX_CARTE_Y;
    }

    etatGlobal = ETAT_CHOIX_JOUEUR;
    while (etatGlobal == ETAT_CHOIX_JOUEUR) {
        if (reconstruire) {
            // le fond : la carte
            afficherCarte(xCarte,yCarte,284,222);
            // la carte foncée à droite
            afficherCarteSombre(284,0,319,222,xCarte,yCarte);
            // le bas ?
            afficherBas(JOUEUR_TUTO, 0);
            // conserver le fond
            empilerBackScr();

            afficher = true;
        }

        if (afficher) {
            afficher = false;
            // le fond
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // afficher les cartes à droite
            // Mission
            if (selectionChoix != 6) {
                // carte mission
                afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
            }

            // Pioche cartes wagons retournés
            for (uint8 i=0; i<5; i++) {
                if ((i != selectionChoix) && (choixCartesWagon[i] != 0xFF)) {
                    // si c'est une loco et qu'on a déjà pioché une carte
                    if ((nbCartesPiochees > 0) && (choixCartesWagon[i] == COULEUR_LOCO)) {
                        afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285+10, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                    } else {
                        afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                    }
                }
            }
            // Pioche carte wagon face retournée
            if (selectionChoix != 5) {
                afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
            }

            if (afficherWagon && (selectionChoix != 7)) {
                afficherGrafx_ram(RAM_WAGON_60 + joueurs[JOUEUR_TUTO].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
            }

            if (zoomEnCours) {
                afficher = true;
                zoomEnCours = false;
                switch (selectionChoix) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                    if (choixCartesWagon[selectionChoix] != 0xFF) {
                        afficherZoomCarte(FILE_WAG_LOCO_NO + choixCartesWagon[selectionChoix]);
                    }
                    break;
                case 5:
                    afficherZoomCarte(FILE_WAG_BACK_NO);
                    break;
                case 6:
                    afficherZoomCarte(FILE_MIS_BA_NO);
                    break;
                }
            } else {
                switch (selectionChoix) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                    if (choixCartesWagon[selectionChoix] != 0xFF) {
                        afficherGrafx_ram(RAM_CARD_SHADOW80, 285-10-2, 3+39+5+selectionChoix*18-10-2, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_ram(RAM_WAG_LOCO_80 + choixCartesWagon[selectionChoix], 285-10, 3+39+5+selectionChoix*18-10, SCREEN_WORKING, 0xFFFF);
                    }
                    afficherGrafx_ram(RAM_CURSOR, 285-10+14, 3+39+5+selectionChoix*18-10+36, SCREEN_WORKING, 0xFFFF);
                    break;
                case 5:
                    afficherGrafx_ram(RAM_CARD_SHADOW80, 285-10-2, 137-10-2, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_ram(RAM_WAG_BACK_80, 285-10, 137-10, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
                    afficherGrafx_ram(RAM_CURSOR, 285-10+14, 137-10+36, SCREEN_WORKING, 0xFFFF);
                    break;
                case 6:
                    afficherGrafx_ram(RAM_CARD_SHADOW80, 285-10-2, 3-10-2, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_ram(RAM_MIS_BA_80, 285-10, 3-10, SCREEN_WORKING, 0xFFFF);
                    afficherGrafx_ram(RAM_CURSOR, 285-10+14, 3-10+36, SCREEN_WORKING, 0xFFFF);
                    break;
                case 7:
                    if (afficherWagon) {
                        afficherGrafx_ram(RAM_WAGON_80 + joueurs[JOUEUR_TUTO].couleurW, 285-20, 137+39+5-10, SCREEN_WORKING, 0xFFFF);
                        afficherGrafx_ram(RAM_CURSOR, 285-10+14, 137+39+5-10+30, SCREEN_WORKING, 0xFFFF);
                    }
                }
            }

            afficherBackScreen();
        }

        // toujours pouvoir scroller la carte
        if (scrollerCarte(JOUEUR_TUTO)) {
            joueurs[JOUEUR_TUTO].xCarte = xCarte;
            joueurs[JOUEUR_TUTO].yCarte = yCarte;
            reconstruire = true;
        }
        // mini carte
        if (isKeyPressed(KEY_NSPIRE_5)) {
            afficherMiniCarte(true);
            afficher = true;
        }
        // Zoom sur la carte
        if (isKeyPressed(KEY_NSPIRE_TAB) && (selectionChoix != 7)) {
            zoomEnCours = true;
            afficher = true;
        }

        // choisir la mission
        if (isKeyPressed(KEY_NSPIRE_SCRATCHPAD)) {
            reconstruire = true;
            if (afficherMissionCourante(JOUEUR_TUTO)) {
                effacerMapSelection();
                if (joueurs[JOUEUR_TUTO].missionsRealisee[joueurs[JOUEUR_TUTO].missionCourante]) {
                    selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_OK);
                } else {
                    selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_KO);
                }
            }
        }


        // Choix suivant
        if (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN)) {
            afficher = true;
            if (nbCartesPiochees == 1) {
                // rester sur le choix des cartes 0..5
                switch (selectionChoix) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                    selectionChoix++;
                    while ((selectionChoix < 5) && ((choixCartesWagon[selectionChoix] == 0xFF) || (choixCartesWagon[selectionChoix] == COULEUR_LOCO))) {
                        selectionChoix++;
                    }
                    break;
                }

            } else {
                switch (selectionChoix) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                    selectionChoix++;
                    while ((selectionChoix < 5) && ((choixCartesWagon[selectionChoix] == 0xFF) || ((nbCartesPiochees > 0) && (choixCartesWagon[selectionChoix] == COULEUR_LOCO)))) {
                        selectionChoix++;
                    }

                    break;
                case 5:
                    if (afficherWagon) {
                        selectionChoix = 7;
                    }
                    break;
                case 6:
                    selectionChoix = 0;
                    bool ok = choixCartesWagon[selectionChoix] != 0xFF;
                    if (ok && (nbCartesPiochees > 0)) {
                        ok = choixCartesWagon[selectionChoix] != COULEUR_LOCO;
                    }
                    while (!ok) {
                        selectionChoix++;
                        if (selectionChoix == 5) {
                            ok = true;
                        } else {
                            ok = choixCartesWagon[selectionChoix] != 0xFF;
                            if (ok && (nbCartesPiochees > 0)) {
                                ok = choixCartesWagon[selectionChoix] != COULEUR_LOCO;
                            }
                        }
                    }
                    break;
                }
            }
            while (isKeyPressed(KEY_NSPIRE_DEL) || isKeyPressed(KEY_NSPIRE_DOWN));
        }
        // Choix précédent
        if (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP)) {
            afficher = true;

            bool remonter = false;
            if (nbCartesPiochees == 1) {
                // rester sur choix des cartes 0..5
                switch (selectionChoix) {
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                    selectionChoix--;
                    while ((selectionChoix != 0) && ((choixCartesWagon[selectionChoix] == 0xFF) || (choixCartesWagon[selectionChoix] == COULEUR_LOCO))) {
                        selectionChoix--;
                    }
                    break;
                }

            } else {
                switch (selectionChoix) {
                case 0:
                    selectionChoix = 6;
                    remonter = nbCartesMissionPioche == 0;
                    break;

                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                    selectionChoix--;
                    while ((selectionChoix != 6) && ((choixCartesWagon[selectionChoix] == 0xFF) || ((nbCartesPiochees > 0) && (choixCartesWagon[selectionChoix] == COULEUR_LOCO)))) {
                        if (selectionChoix == 0) {
                            selectionChoix = 6;
                        } else {
                            selectionChoix--;
                        }
                    }
                    if (selectionChoix == 6) {
                        remonter = nbCartesMissionPioche == 0;
                    }

                    break;
                case 7:
                    selectionChoix = 5;
                    break;
                }

                while (remonter) {
                    if (selectionChoix == 6) {
                        selectionChoix = 0;
                    } else {
                        selectionChoix++;
                    }
                    switch (selectionChoix) {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                        remonter = choixCartesWagon[selectionChoix] == 0xFF;
                        if (!remonter && (nbCartesPiochees > 0)) {
                            remonter = choixCartesWagon[selectionChoix] == COULEUR_LOCO;
                        }
                        break;

                    case 5:
                        remonter = nbCartesWagonPioche == 0;
                        break;
                    }
                }
            }
            while (isKeyPressed(KEY_NSPIRE_CTRL) || isKeyPressed(KEY_NSPIRE_UP));
        }

        // Valider choix
        if (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER)) {

            joueurs[JOUEUR_TUTO].selectionChoix = selectionChoix;
            switch (selectionChoix) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
                if (forcerCarte) {
                    if ((choixCartesWagon[selectionChoix] != 0xFF) && ((nbCartesPiochees == 0) || (choixCartesWagon[selectionChoix] != COULEUR_LOCO))) {
                        if (forcerCouleur) {
                            if (couleur == choixCartesWagon[selectionChoix]) {
                                etatGlobal = ETAT_FIN_DU_TOUR;
                            }
                        } else {
                            etatGlobal = ETAT_FIN_DU_TOUR;
                        }
                    }
                }
                break;
            case 5:
                if (forcerCarte) {
                    if (forcerCouleur) {
                        if (couleur == 100) {
                            etatGlobal = ETAT_FIN_DU_TOUR;
                        }
                    } else {
                        etatGlobal = ETAT_FIN_DU_TOUR;
                    }
                }
                break;
            case 6:
                if (forcerMission) {
                    etatGlobal = ETAT_FIN_DU_TOUR;
                }
                break;
            case 7:
                if (forcerWagon) {
                    etatGlobal = ETAT_FIN_DU_TOUR;
                }
                break;
            }
            while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER));
        }

        // sortir : à revoir. 1 sortie rapide et 1 sortie vers le menu
        if (isKeyPressed(KEY_NSPIRE_ESC)) {
            etatGlobal = ETAT_LIBERATION_MEMOIRE;
            return 100;
        }
    }

    return selectionChoix;
}

void tuto_animationPiocherCarteWagon(uint8 selectionChoix, bool locoDisponible, bool afficherWagon) {
    sint16 animationX = 0;
    sint16 animationY = 0;
    uint8 animationC = 0;
    uint8 animationC2 = 0;
    // afficher l'animation : droite vers centre, puis centre vers bas, puis remettre une carte de la pioche
    if (selectionChoix == 5) {
        animationX = 285-10;
        animationY = 137-10;
        animationC = RAM_WAG_BACK_80;
        animationC2 = FILE_WAG_LOCO_NO + piocheCartesWagon[nbCartesWagonPioche - 1];
    } else {
        animationX = 285-10;
        animationY = 3+39+5+selectionChoix*18-10;
        animationC = RAM_WAG_LOCO_80 + choixCartesWagon[selectionChoix];
        animationC2 = FILE_WAG_LOCO_NO + choixCartesWagon[selectionChoix];
    }

    uint16 ax = 0;
    uint16 ay = 0;
    // tout afficher sauf la carte sélectionner (sauf si 5)
    // le fond : la carte
    afficherCarte(xCarte,yCarte,284,222);
    // la carte foncée à droite
    afficherCarteSombre(284,0,319,222,xCarte,yCarte);
    // le bas ?
    afficherBas(JOUEUR_TUTO, 0);
    // carte mission
    afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
    // Pioche cartes wagons retournés
    for (uint8 i=0; i<5; i++) {
        if ((i != selectionChoix) && (choixCartesWagon[i] != 0xFF)) {
            // si c'est une loco et qu'on a déjà pioché une carte
            if (!locoDisponible && (choixCartesWagon[i] == COULEUR_LOCO)) {
                afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285+10, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
            } else {
                afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
            }
        }
    }
    if (afficherWagon) {
        afficherGrafx_ram(RAM_WAGON_60 + joueurs[JOUEUR_TUTO].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
    }
    // Pioche carte wagon face retournée
    afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
    empilerBackScr();
    // 1) de la droite vers le centre
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        if (i != 0) {
            depilerBackScr();
        }

        // de animationX, animationY vers (320-80)/2 , (240-52)/2
        ax = animationX - trunc(((animationX - 120) * i) / CPT_ANIMATION);
        ay = animationY - trunc(((animationY - 94) * i) / CPT_ANIMATION);
        afficherGrafx_ram(RAM_CARD_SHADOW80, ax-2, ay-2, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_ram(animationC, ax, ay, SCREEN_WORKING, 0xFFFF);

        afficherBackScreen();
    }

    // 2) du centre vers le bas
    for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
        depilerBackScr();

        // de (320-80)/2 , (240-52)/2 vers (320-80)/2, 240
        ax = 35;
        ay = 40 - trunc(((40 - 240) * i) / CPT_ANIMATION);
        afficherGrafx_ram(RAM_CARD_SHADOW, ax-4, ay-4, SCREEN_WORKING, 0xFFFF);
        afficherGrafx_file(animationC2, ax, ay, SCREEN_WORKING, 0xFFFF);

        afficherBackScreen();
    }

    if (selectionChoix == 5) {
        uint8 carteWagon = piocheCartesWagon[nbCartesWagonPioche - 1];
        joueurs[JOUEUR_TUTO].lstCartesWagon[joueurs[JOUEUR_TUTO].nbCartesWagon++] = carteWagon;
        joueurs[JOUEUR_TUTO].nbCartes[carteWagon]++;
        nbCartesWagonPioche--;
    } else {
        // piocher une nouvelle carte et la remettre à sa place
        uint8 carteWagon = choixCartesWagon[selectionChoix];
        joueurs[JOUEUR_TUTO].lstCartesWagon[joueurs[JOUEUR_TUTO].nbCartesWagon++] = carteWagon;
        joueurs[JOUEUR_TUTO].nbCartes[carteWagon]++;

        // remettre une carte wagon
        if (choixCartesWagon[selectionChoix] != 0xFF) {
            for (uint8 i = 0; i < CPT_ANIMATION + 1; i++) {
                depilerBackScr();

                // de 285 , 137 vers animationX, animationY
                ax = 290;
                ay = 137 - trunc(((137 - animationY) * i) / CPT_ANIMATION);
                afficherGrafx_ram(RAM_WAG_BACK_60, ax, ay, SCREEN_WORKING, 0xFFFF);

                afficherBackScreen();
            }
        }

        choixCartesWagon[selectionChoix] = rand() % COULEUR_BACK;
        // en mode tuto, éviter d'avoir 3 loco retournées
        if (choixCartesWagon[selectionChoix] == COULEUR_LOCO) {
            uint8 nbLoco = 0;
            for (uint8 i=0; i<5; i++) {
                if (choixCartesWagon[i] == COULEUR_LOCO) {
                    nbLoco++;
                }
            }
            while (nbLoco >= 3) {
                choixCartesWagon[selectionChoix] = rand() % COULEUR_BACK;
                for (uint8 i=0; i<5; i++) {
                    if (choixCartesWagon[i] == COULEUR_LOCO) {
                        nbLoco++;
                    }
                }
            }
        }
    }
}

bool tuto_piocherCarteWagon(bool forcerCouleur, uint8 couleur, bool locoDisponible, bool afficherWagon) {
    // piocher la carte
    uint8 selectionChoix = tuto_choix(false, true, false, false, forcerCouleur, couleur, locoDisponible);
    // animer la pioche
    if (etatGlobal == ETAT_FIN_DU_TOUR) {
        tuto_animationPiocherCarteWagon(selectionChoix, locoDisponible, afficherWagon);
    }

    return etatGlobal != ETAT_LIBERATION_MEMOIRE;
}

void afficherFondTuto(bool sombre, bool afficherMission, bool afficherCartes, uint8 modeBas, bool afficherWagon, bool locoDisponible) {
    // le fond : la carte
    afficherCarte(xCarte,yCarte,284,222);
    // la carte foncée à droite
    afficherCarteSombre(284,0,319,222,xCarte,yCarte);
    if (afficherMission) {
        // la pile de carte mission
        afficherGrafx_ram(RAM_MIS_BA_60, 285, 3, SCREEN_WORKING, 0xFFFF);
    }
    if (afficherCartes) {
        // Pioche cartes wagons retournés
        for (uint8 i=0; i<5; i++) {
            if (choixCartesWagon[i] != 0xFF) {
                if (!locoDisponible && (choixCartesWagon[i] == COULEUR_LOCO)) {
                    afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285+10, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                } else {
                    afficherGrafx_ram(RAM_WAG_LOCO_60 + choixCartesWagon[i], 285, 3+39+5+i*18, SCREEN_WORKING, 0xFFFF);
                }
            }
        }
        // face cachée
        afficherGrafx_ram(RAM_WAG_BACK_60, 285, 137, SCREEN_WORKING, 0xFFFF); // 3+39+5+5*18
    }
    if (afficherWagon) {
        afficherGrafx_ram(RAM_WAGON_60 + joueurs[JOUEUR_TUTO].couleurW, 285-10, 137+39+5, SCREEN_WORKING, 0xFFFF);
    }
    // le bas ?
    afficherBas(JOUEUR_TUTO, modeBas);
    // assombrir
    if (sombre) {
        assombrirBackScr();
        assombrirBackScr();
    }
    // conserver le fond
    empilerBackScr();
}

bool tuto_choisirWagon() {
    if (tuto_choix(false, false, true, true, false, 0, true) != 7) {
        return false;
    }

    return etatGlobal != ETAT_LIBERATION_MEMOIRE;
}

bool tuto_choisirMission() {
    if (tuto_choix(true, false, false, true, false, 0, true) != 6) {
        return false;
    }

    // piocher les cartes missions
    tuto_animerPiocheCartesMissions();

    return etatGlobal != ETAT_LIBERATION_MEMOIRE;

}

uint8 tuto_choisirRoute(bool forcerPath, uint8 numPathForce) {

    bool afficher = true;
    bool reconstruire = true;
    uint8 selectionChoix = 0;
    bool tester = true;
    uint8 numPath = 0xFF;
    uint8 savNumPath = numPath;

    etatGlobal = ETAT_CHOIX_ROUTE;
    while (etatGlobal == ETAT_CHOIX_ROUTE) {
        if (reconstruire) {
            // le fond : la carte
            afficherCarte(xCarte,yCarte,284,222);
            // la carte foncée à droite
            afficherCarteSombre(284,0,319,222,xCarte,yCarte);
            // le bas ?
            afficherBas(JOUEUR_TUTO, 0);
            // conserver le fond
            empilerBackScr();

            afficher = true;
        }

        if (afficher) {
            afficher = false;
            // le fond
            if (reconstruire) {
                reconstruire = false;
            } else {
                depilerBackScr();
            }

            // le curseur
            afficherGrafx_ram(RAM_CURSOR, cursorX-10, cursorY-1, SCREEN_WORKING, 0xFFFF);

            // les cartes à consommer
            uint16 ouX = 0;
            uint16 ouY = 0;
            if ((nbPaiementPossible > 0) && (numPath < 200)) {
                uint8 mod = 2;
                sint8 decalX = -18; // -26+8
                uint8 decalY = 24;

                if (paths[numPath].distance == 1) {
                    mod = 1;
                    decalX = -5; // -18+26/2
                }
                if (paths[numPath].distance > 4) {
                    mod = 3;
                    decalX = -31; // -26-26/2+8
                }
                // les ombres
                for (uint8 i=0; i<paths[numPath].distance; i++) {
                    ouX = cursorX+decalX + 26 * (i % mod);
                    ouY = cursorY+decalY + 18 * trunc(i / mod);
                    afficherGrafx_ram(RAM_MINI_CARD_SHADOW, ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
                // les mini cartes
                for (uint8 i=0; i<paths[numPath].distance; i++) {
                    ouX = cursorX+decalX + 26 * (i % mod);
                    ouY = cursorY+decalY + 18 * trunc(i / mod);
                    afficherGrafx_ram(RAM_MINI_WAG_LOCO + paiementPossible[selectionChoix][i], ouX, ouY, SCREEN_WORKING, 0xFFFF);
                }
            }
            afficherBackScreen();
        }

        // toujours pouvoir scroller la carte
        if (scrollerCarte(JOUEUR_TUTO)) {
            joueurs[JOUEUR_TUTO].xCarte = xCarte;
            joueurs[JOUEUR_TUTO].yCarte = yCarte;
            afficher = true;
            reconstruire = true;
            tester = true;
            nbPaiementPossible = 0;
        }
        if (autoScroll()) {
            joueurs[JOUEUR_TUTO].xCarte = xCarte;
            joueurs[JOUEUR_TUTO].yCarte = yCarte;
            afficher = true;
            reconstruire = true;
            tester = true;
            nbPaiementPossible = 0;
        } else {
            if (scrollerCurseur()) {
                afficher = true;
                tester = true;
                nbPaiementPossible = 0;
            }
        }
        // mini carte
        if (isKeyPressed(KEY_NSPIRE_5)) {
            afficherMiniCarte(true);
            afficher = true;
        }

        if (tester && !any_key_pressed()) {
            tester = false;
            numPath = routeSousCurseur((cursorX + xCarte) >> 1, (cursorY + yCarte) >> 1);
            if (forcerPath && (numPathForce != numPath)) {
                numPath = 200;
                nbPaiementPossible = 0;
            }
            if (numPath < 200) {
                // peut-on réclamer cette route ?
                remplirChoixPaiementWagon(JOUEUR_TUTO, numPath);
                selectionChoix = 0;
                afficher = true;
            }

            if (savNumPath != numPath) {
                savNumPath = numPath;
                effacerMapSelection();
                if (joueurs[JOUEUR_TUTO].missionsRealisee[joueurs[JOUEUR_TUTO].missionCourante]) {
                    selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_OK);
                } else {
                    selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_KO);
                }
                if ((numPath < 200) && (nbPaiementPossible > 0)) {
                    selectionnerPath(numPath, RAM_CARTE_VILLE_SELECT);
                }
                reconstruire = true;
            }
        }

        // choix suivant
        if (isKeyPressed(KEY_NSPIRE_DEL) && (numPath < 200)) {
            if (selectionChoix < (nbPaiementPossible - 1)) {
                selectionChoix++;
            } else {
                selectionChoix = 0;
            }
            afficher = true;
            while (isKeyPressed(KEY_NSPIRE_DEL));
        }
        // choix précédent
        if (isKeyPressed(KEY_NSPIRE_CTRL) && (numPath < 200)) {
            if (selectionChoix > 0) {
                selectionChoix--;
            } else {
                selectionChoix = nbPaiementPossible - 1;
            }
            afficher = true;
            while (isKeyPressed(KEY_NSPIRE_CTRL));
        }
        // valider la route
        if ((isKeyPressed(KEY_NSPIRE_VAR)  || isKeyPressed(KEY_NSPIRE_ENTER)) && (numPath < 200)) {
            while (isKeyPressed(KEY_NSPIRE_VAR) || isKeyPressed(KEY_NSPIRE_ENTER));

            // tester si c'est possible !!!
            if (nbPaiementPossible > 0) {
                etatGlobal = ETAT_FIN_DU_TOUR;
                return numPath;
            }
        }
        if (isKeyPressed(KEY_NSPIRE_ESC)) {
            while (isKeyPressed(KEY_NSPIRE_ESC));
            return 200;
        }

    }

    return 200;
}

void tuto_revendiquerRoute(uint8 numPath) {
    revendiquerRoute(numPath, JOUEUR_TUTO);
    payerRoute(numPath, 0, JOUEUR_TUTO);

    if (joueurs[JOUEUR_TUTO].missionsRealisee[joueurs[JOUEUR_TUTO].missionCourante]) {
        selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_OK);
    } else {
        selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_KO);
    }
}


void afficherTuto() {
    while (isKeyPressed(KEY_NSPIRE_ENTER));

    // libérer les routes
    for (uint8 i=1; i<MAX_PATH; i++) {
        paths[i].owner = 0;
    }
    for (uint16 i=1; i<MAX_PAVE; i++) {
        paves[i].owner = 0;
    }
    nbPaveAAfficher = 0;
    resetUsMap();
    preparerUsMap();
    passAndPlayActif = false;
    numeroTour = 0;
    tourRestant = 0;

    // créer un joueur fictif
    nbTotalJoueur = 1;
    joueurs = (ttrJoueur *)malloc(2 * sizeof(ttrJoueur));
    joueurs[JOUEUR_TUTO].humain = true;
    joueurs[JOUEUR_TUTO].points = 0;
    joueurs[JOUEUR_TUTO].nbCartesWagon = 0;
    joueurs[JOUEUR_TUTO].nbCartesMission = 0;
    joueurs[JOUEUR_TUTO].nbWagons = 250;
    joueurs[JOUEUR_TUTO].missionCourante = 0;
    joueurs[JOUEUR_TUTO].affichageBas = 0;
    joueurs[JOUEUR_TUTO].lastAction = 0;
    joueurs[JOUEUR_TUTO].xCarte = 120;
    joueurs[JOUEUR_TUTO].yCarte = 96;
    joueurs[JOUEUR_TUTO].couleurW = 0;
    joueurs[JOUEUR_TUTO].couleurFonte = 0xFFFF;
    joueurs[JOUEUR_TUTO].couleur = FILE_WAGON_BLUE_0_0;
    joueurs[JOUEUR_TUTO].avatar = 0;
    joueurs[JOUEUR_TUTO].selectionChoix = 6;

    memset(joueurs[JOUEUR_TUTO].lstCartesWagon,0,sizeof(joueurs[JOUEUR_TUTO].lstCartesWagon));
    memset(joueurs[JOUEUR_TUTO].lstCartesMission,0,sizeof(joueurs[JOUEUR_TUTO].lstCartesMission));
    memset(joueurs[JOUEUR_TUTO].nbCartes, 0, sizeof(joueurs[JOUEUR_TUTO].nbCartes));
    for (uint8 j=0; j<30; j++) {
        joueurs[JOUEUR_TUTO].missionsRealisee[j] = false;
    }
    for (uint8 j=0; j<36; j++) {
        joueurs[JOUEUR_TUTO].villesAccessibles[j] = false;
    }

    // préparer le fond
    xCarte = 120;
    yCarte = 96;

    afficherFondTuto(true, false, false, 1, false, true);
    ecrireGrafxPhrase("Welcome to this interactive tutorial!\n\nIn Ticket to Ride, your goal is to score the most points by:\n- Playing TRAIN CARDS from your hand to claim ROUTES on the map\n- Using these routes to connect cities listed on your TICKETS\n\nSimply follow the instructions written on this board...\n...Press Enter to go on, and Esc to return to the menu.",
                      5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }
    depilerBackScr();
    ecrireGrafxPhrase("So let's get started!\n\nChoose at least 2 Tickets:\n- Press Left and Right keys to move the cursor.\n- Press Down key to keep a ticket.\n- Press Up key to discard a ticket.\n- Press Enter to confirm your choice.\n- Press Tab to zoom the Ticket.\nYou can scroll the map with 2,4,6 and 8 keys.\nPress 5 to display the entire map.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

// <<< Piocher 3 tickets >>> n'afficher que les cartes mission en haut à droite
    afficherFondTuto(false, true, false, 1, false, true);
    choixCarteMission[0] = 2;
    choixCarteMission[1] = 10;
    choixCarteMission[2] = 16;
    choixCartesWagon[0] = 0xFF;
    choixCartesWagon[1] = 0xFF;
    choixCartesWagon[2] = 0xFF;
    choixCartesWagon[3] = 0xFF;
    choixCartesWagon[4] = 0xFF;
    nbCartesWagonPioche = 0;
    joueurs[JOUEUR_TUTO].nbWagons = 0;

    if (!tuto_animerPiocheCartesMissions()) {
        free(joueurs);
        return;
    }
    nbCartesWagonPioche = 40;
    joueurs[JOUEUR_TUTO].nbWagons = 250;
    // Les cartes retournées
    choixCartesWagon[0] = COULEUR_LOCO;
    choixCartesWagon[1] = COULEUR_ROSE;
    choixCartesWagon[2] = COULEUR_ROUGE;
    choixCartesWagon[3] = COULEUR_VERT;
    choixCartesWagon[4] = COULEUR_ROSE;

    bool cal_salt = false;

    // sélectionner la première carte mission
    for (uint8 i=0; i < joueurs[JOUEUR_TUTO].nbCartesMission; i++) {
        if (joueurs[JOUEUR_TUTO].lstCartesMission[i] == 2) {
            cal_salt = true;
            joueurs[JOUEUR_TUTO].missionCourante = i;
        } else if (joueurs[JOUEUR_TUTO].lstCartesMission[i] == 10) {
            joueurs[JOUEUR_TUTO].missionCourante = i;
        }
    }

    selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_KO);

    afficherFondTuto(true, true, false, 1, false, true);
    if (cal_salt) {
        ecrireGrafxPhrase("Now let's play your first Turn!\n\nFor now, ignore your opponent(s).\n\nWe are going to help you claim your first routes and complete the Ticket \"Calgary\" to \"Salt Lake City\".",5,2,17, 0xFFFF);
    } else {
        ecrireGrafxPhrase("Now let's play your first Turn!\n\nFor now, ignore your opponent(s).\n\nWe are going to help you claim your first routes and complete the Ticket \"Helena\" to \"Los Angeles\".",5,2,17, 0xFFFF);
    }
    if (attendreTuto()) {
        return;
    }
    depilerBackScr();
    ecrireGrafxPhrase("You will need a set of cards that matches the color and number of spaces of the route you want to claim.\n\nNow pick a purple card:\n- Press Up and Down keys to move the cursor.\n- Press Enter to confirm your choice.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

//<<<piocher carte wagon forcer rose>>>
    if (!tuto_piocherCarteWagon(true, COULEUR_ROSE, true, false)) {
        free(joueurs);
        return;
    }
    afficherFondTuto(true, true, true, 0, false, false);
    ecrireGrafxPhrase("When you draw a face up card, a replacement card will be immediately turns face-up from the deck.\n\nYou may only pick two cards during a single turn.\n\nYour hand cards are displayed at the bottom.\n\nPick the other purple card to end your turn.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

//<<<piocher carte wagon forcer rose>>>
    if (!tuto_piocherCarteWagon(true, COULEUR_ROSE, false, false)) {
        free(joueurs);
        return;
    }
    afficherFondTuto(true, true, true, 0, false, true);
    ecrireGrafxPhrase("Your turn is done.\n\nIn this tutorial you play alone, so it's your turn again.\n\nNow let's make a blind draw from the deck.\n\nDraw a card at random from the blind deck.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

//<<<piocher carte wagon forcer cachée>>>
    if (!tuto_piocherCarteWagon(true, 100, true, false)) {
        free(joueurs);
        return;
    }
    afficherFondTuto(true, true, true, 0, false, false);
    ecrireGrafxPhrase("and pick another one.\n\nNote that the Locomotive card is no longer available, we will see this in the next round.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

//<<<piocher carte wagon sauf loco>>>
    if (!tuto_piocherCarteWagon(false, 0, false, false)) {
        free(joueurs);
        return;
    }
    afficherFondTuto(true, true, true, 0, false, true);
    ecrireGrafxPhrase("Your turn is done!\n\nOn the next turn pick the Locomotive card.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

//<<<piocher carte wagon forcer locomotive >>>
    if (!tuto_piocherCarteWagon(true, COULEUR_LOCO, true, false)) {
        free(joueurs);
        return;
    }
    afficherFondTuto(true, true, true, 0, false, true);
    ecrireGrafxPhrase("You just picked a Locomotive card; it acts as a wild.\n\nYou can use it to replace any card of color.\n\nIf you pick a Locomotive card face-up during your draw, it will be the only card you pick this turn.\n\nWhen 3 locomotive cards are face-up: the game automatically wiped all cards out and drew 5 new ones to refresh the draw.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

    //<< Afficher le bas>>
    afficherFondTuto(true, true, true, 0, false, true);
    ecrireGrafxPhrase("You start the game with 4 cards drawn randomly.\n\nNow you will claim the \"Helena\" to \"Salt Lake City\" route.\n\nSelect the train car and then move the cursor between \"Helena\" and \"Salt Lake City\" with the Down, Left, Right and Up keys.\n\n(You can scroll the map with 2,4,6 and 8).\nThen press Enter.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

    //<<choisir wagon>>
    if (!tuto_choisirWagon()) {
        free(joueurs);
        return;
    }
    //<<choisir la route sans rien défausser>>
    if (tuto_choisirRoute(true, 21) != 21) {
        free(joueurs);
        return;
    }

    afficherFondTuto(true, true, true, 0, true, true);
    ecrireGrafxPhrase("When you claim a route on the board you discard a set of Train Car cards that match the color and length of the route.\n\nThe cursor indicates which cards will be used to claim the route.\n\nYou can change the combination of cards used with the Ctrl and Del keys.\n\nYou place one of your colored trains on each space of the route.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }
    tuto_revendiquerRoute(21);  // ça déconne ici !
    selectionnerMission(joueurs[JOUEUR_TUTO].lstCartesMission[joueurs[JOUEUR_TUTO].missionCourante], RAM_CARTE_VILLE_KO);

    afficherFondTuto(true, true, true, 0, true, true);
    ecrireGrafxPhrase("Some routes (those that are Gray colored) can be claimed using a set of cards of any one color.\n\nA player may claim any open route on the board.\n\nSome cities are connected by Double-Routes. One player cannot claim both routes to the same cities.\n\nImportant Note: In 2 or 3 player games, only one of the Double-Routes can be used.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }
    depilerBackScr();
    ecrireGrafxPhrase("Claim a road makes you earn points.\n\nThe longer the route, the more points you earn.\n\nDo the same again for the other routes on your Ticket!\n\nBeware: If you fail to connect a Ticket's cities by game end, you will lose its points instead of gaining them!",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

    uint8 selectionChoix = 0;
    bool tousLesTicketOK = false;
    bool afficherMsgTicketOk = true;
    bool locoDisponible = true;
    // pour le tuto : piocher une carte aléatoirement sans dépiler, nb de wagon illimité
    while (!tousLesTicketOK) {
        // piocher la carte
        selectionChoix = tuto_choix(false, true, locoDisponible, true, false, 0, locoDisponible);
        if (selectionChoix == 100) {
            free(joueurs);
            return;
        }
        switch (selectionChoix) {
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            if (locoDisponible) {
                if ((selectionChoix == 5) || (choixCartesWagon[selectionChoix] != COULEUR_LOCO)) {
                    locoDisponible = false;
                } else {
                    locoDisponible = true;
                }
            } else {
                locoDisponible = true;
            }
            tuto_animationPiocherCarteWagon(selectionChoix, locoDisponible, true);
            break;

        case 7:
            selectionChoix = tuto_choisirRoute(false, 0);
            if (selectionChoix != 200) {
                tuto_revendiquerRoute(selectionChoix);

                // si un des tickets du joueur est réalisé
                uint8 nbTicketOK = 0;
                tousLesTicketOK = true;
                for (uint8 i=0; i<joueurs[JOUEUR_TUTO].nbCartesMission; i++) {
                    if (joueurs[JOUEUR_TUTO].missionsRealisee[i]) {
                        nbTicketOK++;
                    } else {
                        tousLesTicketOK = false;
                    }
                }
                if (afficherMsgTicketOk && (nbTicketOK > 0)) {
                    afficherMsgTicketOk = false;

                    afficherFondTuto(true, true, true, 0, true, true);
                    ecrireGrafxPhrase("Congratulations, this Ticket is done. The points indicated on it will be added to your score at game's end!\n\nSuccessfully completing a Ticket during the game is a secret; keep it to yourself!\n\nTry to complete another Ticket now: Select another Ticket with the ScratchPad key (between Esc and Tab keys).",5,2,17, 0xFFFF);
                    if (attendreTuto()) {
                        return;
                    }
                }
            }
        }

    }

    afficherFondTuto(true, true, true, 0, true, true);
    ecrireGrafxPhrase("Congratulations, all your Tickets are done!\nNow you may want to push your luck and draw some new Tickets.\nAs you may have figured out by now, on each turn you can either draw two Train Cards or claim a Route.\n\nDrawing additional Tickets is the third possible, alternative, action you may choose on your turn.\n\nSelect the Tickets stack, and keep at least 1 Ticket.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }
    //<<selectionner mission>>>
    choixCarteMission[0] = 3;
    choixCarteMission[1] = 11;
    choixCarteMission[2] = 17;
    if (!tuto_choisirMission()) {
        free(joueurs);
        return;
    }

    afficherFondTuto(true, true, true, 0, true, true);
    ecrireGrafxPhrase("Once you or one of your opponents have 2 trains or less left in reserve, this will trigger the game's last turn; so try to claim some routes quickly.\n\nBlock your opponents where you can!\nAt the end of the game the final scores are calculated, adding points for the Tickets successfully completed and subtracting points for those that failed.\n\nPlayers with the longest path also get a 10-point bonus.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }
    depilerBackScr();
    ecrireGrafxPhrase("You know enough now. This tutorial is over.",5,2,17, 0xFFFF);
    if (attendreTuto()) {
        return;
    }

    /* afficher les touches ? */
}