Forum Graph100

// Affichage.c de Master Mind //
// Fichier gerant les fonction d'affichages //

// efface un rectangle selon la position de l'essai,
void clear_rect( char essai ){
  Coord A,B;   // coordonnées des points pour le rectangle
  switch(essai){
    case 1:
    A.x=24; A.y=47; B.x=63; B.y=62;
    break;

    case 2:
    A.x=24; A.y=30; B.x=63; B.y=45;
    break;

    case 3:
    A.x=24; A.y=13; B.x=63; B.y=28;
    break;

    case 4:
    A.x=88; A.y=47; B.x=126; B.y=62;
    break;

    case 5:
    A.x=88; A.y=30; B.x=126; B.y=45;
    break;

    case 6:
    A.x=88; A.y=13; B.x=126; B.y=28;
    break;
  }
  gxFillrect(A.x,A.y,B.x,B.y,GX_LIGHTGRAY);
}

// ecrit le nombre du joueur à la bonne position en fonction de son essai (1~6)
void write_try( char essai , int nombre ){
char x,y;

    switch(essai)
    {
     case 1:
     x=32; y=52;
     break;

     case 2:
     x=32; y=35;
     break;

     case 3:
     x=32; y=18;
     break;

     case 4:
     x=96; y=52;
     break;

     case 5:
     x=96; y=35;
     break;

     case 6:
     x=96; y=18;
     break;
     }
writevalue(x,y,nombre);
}

// dessine le plateau de jeu dans le buffer
void draw_plateau(void){
  int h;

  // Le fond gris moyen
  gxFill(GX_LIGHTGRAY);

  //les lignes verticales de gauche … droite
  gxVLine(0,0,63,GX_BLACK);
  gxVLine(23,12,63,GX_BLACK);
  gxVLine(64,12,63,GX_BLACK);
  gxVLine(87,12,63,GX_BLACK);
  gxVLine(127,0,63,GX_BLACK);

  //les lignes horizontales de haut en bas
  gxHLine(0,127,0,GX_BLACK);
  gxHLine(0,127,12,GX_BLACK);
  gxHLine(0,23,29,GX_BLACK);
  gxHLine(64,87,29,GX_BLACK);
  gxHLine(0,23,46,GX_BLACK);
  gxHLine(64,87,46,GX_BLACK);
  gxHLine(0,127,63,GX_BLACK);
}

// affiche les pions noirs, en fonction de l'essai
void draw_pions(char essai, char noir, char blanc){
  char x,y,i,j;
  switch (essai){
     case 1:
     x=6; y=56;
     break;

     case 2:
     x=6; y=39;
     break;

     case 3:
     x=6; y=22;
     break;

     case 4:
     x=70; y=56;
     break;

     case 5:
     x=70; y=39;
     break;

     case 6:
     x=70; y=22;
     break;
  }
  for (i=1 ; i<=noir ; i++){            // affiche les pions noirs
    gxSpr_noM_noC(x,y,pion_noir);
    x+=7;
    if(x>13 && essai<=3){
       x=6; y-=7;
    }
    if(x>77 && essai>=4){
       x=70; y-=7;
    }
  }
  for (j=1 ; j<=blanc ; j++){            // affiche les pions blancs
    gxSpr_M_noC(x,y,pion_blanc);
    x+=7;
    if(x>13 && essai<=3){
       x=6; y-=7;
    }
    if(x>77 && essai>=4){
       x=70; y-=7;
    }
  }
}

//   defs de Master Mind   //

// Structures //
struct Coord
{
  char x;
  char y;
};
typedef struct Coord Coord;

// Sprites //

//BMP Menu
unsigned char Menu[] = {
170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,170,2,0,0,0,0,0,0,0,128,
1,0,0,0,0,64,85,5,0,0,0,0,0,0,0,0,
0,0,0,0,0,160,170,10,0,0,0,0,0,0,0,128,
1,0,0,0,0,80,85,5,0,0,0,0,0,0,0,0,
0,0,0,0,0,168,170,10,0,0,0,0,0,0,0,128,
1,0,0,0,0,84,85,21,0,0,0,0,0,0,0,0,
0,0,0,0,0,170,170,10,168,0,0,0,0,0,0,128,
1,0,0,0,0,85,85,85,85,5,0,0,0,0,0,0,
0,0,0,0,0,170,170,170,170,10,0,0,0,0,0,128,
1,0,0,0,0,85,85,85,69,21,0,0,0,0,0,0,
0,0,0,0,128,170,170,170,170,10,0,0,0,0,0,128,
1,0,0,0,80,85,85,85,85,21,0,0,0,0,0,0,
0,0,0,0,160,170,170,170,170,170,0,0,0,0,0,128,
1,0,0,0,84,85,85,85,85,85,1,0,0,0,0,0,
0,0,0,0,168,160,170,170,170,170,42,0,0,0,0,128,
1,0,0,0,84,81,85,69,85,85,85,0,0,0,0,0,
0,0,0,0,160,170,170,170,170,138,168,0,0,0,0,128,
1,0,0,0,84,81,84,85,85,85,85,1,0,0,0,0,
0,0,0,0,168,168,170,162,170,138,170,2,0,0,0,128,
1,0,0,0,84,85,21,84,85,85,85,1,0,0,0,0,
0,0,0,0,168,170,170,170,136,170,170,2,0,0,0,128,
1,0,0,0,80,85,85,69,20,69,85,1,0,0,0,0,
0,0,0,0,168,170,170,34,168,170,170,2,0,0,0,128,
1,0,0,0,80,85,85,65,64,81,84,1,0,0,0,0,
0,0,0,0,160,170,170,42,162,170,168,2,0,0,0,128,
1,0,0,0,64,85,85,84,68,85,85,1,0,0,0,0,
0,0,0,160,162,42,42,170,162,170,170,34,0,0,0,128,
1,0,0,64,84,85,69,85,85,85,85,69,0,0,0,0,
0,0,0,32,130,170,162,138,170,170,170,42,0,0,0,128,
1,0,0,64,84,85,84,85,85,81,85,68,0,0,0,0,
0,0,0,32,34,170,170,170,42,170,170,34,0,0,0,128,
1,0,0,64,68,85,85,85,85,85,85,84,0,0,0,0,
0,0,0,0,0,168,170,162,170,170,10,34,0,0,0,128,
1,0,0,0,0,84,85,85,85,85,5,68,0,0,0,0,
0,0,0,0,0,168,170,170,170,170,2,0,0,0,0,128,
1,0,0,0,0,80,85,85,85,85,0,0,0,0,0,0,
0,0,0,0,0,160,170,170,170,42,0,0,0,0,0,128,
1,0,0,0,0,0,84,85,85,21,0,0,0,0,0,0,
0,0,0,0,0,0,168,170,170,2,0,0,0,0,0,128,
1,0,0,0,0,0,80,85,21,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,
170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,160,130,32,34,34,8,138,130,34,138,40,2,0,128,
1,0,80,69,16,17,69,16,21,69,69,21,17,1,0,0,
0,0,32,138,32,34,34,136,40,34,136,136,40,2,0,128,
1,0,16,68,16,17,69,16,16,68,65,20,17,1,0,0,
0,0,32,136,32,162,42,136,42,130,130,138,40,2,0,128,
1,0,16,68,16,17,69,16,21,4,69,1,69,1,0,0,
0,0,32,138,40,162,40,136,32,34,136,136,40,2,0,128,
1,0,80,69,21,81,80,21,21,69,69,21,69,1,0,0,
0,0,160,130,34,162,40,10,138,138,130,138,130,2,0,128,
1,0,16,0,0,80,80,0,0,4,0,0,69,1,0,0,
0,0,32,0,0,162,40,0,0,2,0,128,130,2,0,128,
1,0,16,0,0,81,80,0,0,0,0,0,1,1,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,4,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,128,162,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,64,0,5,0,0,0,0,0,0,0,128,
1,0,0,0,0,160,0,2,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,4,0,0,0,0,0,0,0,128,
1,0,0,0,0,32,0,10,0,0,0,0,0,0,0,128,
1,0,0,0,0,16,0,1,16,0,0,0,0,0,0,128,
1,0,0,0,0,2,128,138,0,0,0,0,0,0,0,128,
1,0,0,0,0,4,0,85,1,0,0,0,0,0,0,128,
1,0,0,0,128,2,10,0,128,0,0,0,0,0,0,128,
1,0,0,0,64,85,1,0,0,0,0,0,0,0,0,128,
1,0,0,0,32,170,0,32,0,8,0,0,0,0,0,128,
1,0,0,0,0,192,28,115,219,120,0,0,0,0,0,128,
1,0,0,0,0,192,38,102,155,249,0,0,0,0,0,128,
1,0,0,0,0,193,96,102,155,205,5,0,0,0,0,128,
1,0,0,0,0,192,126,102,155,143,33,0,0,0,0,128,
1,0,0,0,16,192,102,119,155,141,1,1,0,0,0,128,
1,0,0,0,0,240,56,255,155,141,1,0,0,0,0,128,
1,0,0,0,0,64,16,102,0,136,0,0,0,0,0,128,
1,0,0,0,0,32,0,34,3,112,0,2,0,0,0,128,
1,0,0,0,16,0,0,0,0,64,69,0,0,0,0,128,
1,0,0,0,8,0,0,2,0,128,0,2,0,0,0,128,
1,0,0,0,16,4,0,0,0,1,64,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,128,0,0,0,0,128,
1,0,0,0,80,48,4,0,0,0,64,1,0,0,0,128,
1,0,0,0,160,24,0,32,0,32,8,0,0,0,0,128,
1,0,0,96,227,25,54,143,199,217,112,103,0,0,0,128,
1,0,0,96,38,27,102,219,204,153,201,102,0,0,0,128,
1,0,0,96,6,27,102,27,204,217,205,102,0,0,0,128,
1,0,0,96,246,59,102,207,111,155,237,102,0,0,0,128,
1,0,0,96,54,31,118,211,100,159,93,102,0,0,0,128,
1,0,0,96,198,26,102,142,35,154,57,102,0,0,0,128,
1,0,0,0,0,4,64,0,0,65,17,102,0,0,0,128,
1,0,0,0,0,24,0,128,0,138,2,102,0,0,0,128,
1,0,0,0,0,16,20,0,4,1,1,0,0,0,0,128,
1,0,0,0,0,0,128,136,0,170,0,0,0,0,0,128,
1,0,0,0,0,0,17,69,81,17,0,0,0,0,0,128,
1,0,0,0,0,0,170,170,138,11,0,0,0,0,0,128,
1,0,0,0,0,0,64,17,80,1,0,0,0,0,0,128,
1,0,0,0,0,0,128,170,10,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,176,195,48,51,98,24,14,131,67,134,17,3,0,128,
1,0,240,199,48,51,98,24,159,199,207,143,57,3,0,128,
1,0,48,196,48,51,103,152,17,102,204,152,57,3,0,128,
1,0,48,204,48,51,103,24,48,230,192,152,57,3,0,128,
1,0,48,204,48,51,101,152,63,198,199,143,41,3,0,128,
1,0,48,204,48,179,109,152,63,6,206,128,109,3,0,128,
1,0,48,196,48,179,109,24,17,102,204,152,69,3,0,128,
1,0,240,135,63,179,104,30,159,207,143,143,69,3,0,128,
1,0,176,3,55,243,120,27,142,143,3,135,69,3,0,128,
1,0,48,0,0,240,120,0,0,6,0,128,131,3,0,128,
1,0,48,0,0,115,112,0,0,6,0,128,131,3,0,128,
1,0,48,0,0,115,112,0,0,2,0,128,131,3,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,208,1,0,0,0,0,0,0,0,0,
0,0,0,0,0,64,88,3,0,0,0,0,0,0,0,128,
1,0,0,0,0,176,213,2,0,0,0,0,0,0,0,0,
0,0,0,0,0,24,170,12,0,0,0,0,0,0,0,128,
1,0,0,0,0,92,85,9,0,0,0,0,0,0,0,0,
0,0,0,0,0,138,170,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,100,85,20,196,0,0,0,0,0,0,0,
0,0,0,0,0,188,106,117,170,2,0,0,0,0,0,128,
1,0,0,0,0,91,85,170,84,21,0,0,0,0,0,0,
0,0,0,0,0,169,181,170,42,10,0,0,0,0,0,128,
1,0,0,0,128,170,84,93,85,21,0,0,0,0,0,0,
0,0,0,0,224,85,170,202,170,22,0,0,0,0,0,128,
1,0,0,0,80,85,117,21,117,85,0,0,0,0,0,0,
0,0,0,0,168,170,234,170,138,142,2,0,0,0,0,128,
1,0,0,0,84,68,85,84,81,53,19,0,0,0,0,0,
0,0,0,0,176,170,170,170,170,168,138,0,0,0,0,128,
1,0,0,0,68,81,21,76,85,87,209,0,0,0,0,0,
0,0,0,0,40,168,142,170,234,170,170,0,0,0,0,128,
1,0,0,0,84,5,69,68,85,87,85,3,0,0,0,0,
0,0,0,0,168,11,42,170,142,170,234,0,0,0,0,128,
1,0,0,0,104,85,85,85,69,5,18,3,0,0,0,0,
0,0,0,0,176,170,170,40,136,11,168,1,0,0,0,128,
1,0,0,0,72,81,117,85,16,192,20,1,0,0,0,0,
0,0,0,0,240,168,32,34,34,162,106,3,0,0,0,128,
1,0,0,0,160,21,81,117,65,85,181,0,0,0,0,0,
0,0,0,0,96,170,170,10,162,138,162,0,0,0,0,128,
1,0,0,64,65,85,93,81,65,113,157,68,0,0,0,0,
0,0,0,32,242,170,170,138,162,170,174,35,0,0,0,128,
1,0,0,64,132,85,85,81,117,23,117,76,0,0,0,0,
0,0,0,32,162,142,170,130,170,170,154,42,0,0,0,128,
1,0,0,64,4,81,197,85,93,81,97,84,0,0,0,0,
0,0,0,32,162,172,170,43,238,175,42,50,0,0,0,128,
1,0,0,0,0,208,21,85,213,20,14,68,0,0,0,0,
0,0,0,0,0,172,238,42,186,117,12,34,0,0,0,128,
1,0,0,0,0,232,193,213,217,222,2,0,0,0,0,0,
0,0,0,0,0,160,58,34,234,85,0,0,0,0,0,128,
1,0,0,0,0,192,100,144,44,46,0,0,0,0,0,0,
0,0,0,0,0,0,68,85,117,6,0,0,0,0,0,128,
1,0,0,0,0,0,148,126,173,0,0,0,0,0,0,0,
0,0,0,0,0,0,104,81,5,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,80,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,
85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,85,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,
1,0,16,65,16,17,69,16,133,65,69,13,17,1,0,0,
0,0,160,130,32,34,39,8,10,162,130,154,0,2,0,128,
1,0,80,76,16,17,69,16,49,68,68,17,17,1,0,0,
0,0,32,136,32,34,34,8,32,34,128,136,40,2,0,128,
1,0,16,68,16,17,69,16,21,68,69,5,85,1,0,0,
0,0,32,136,32,162,40,136,42,2,138,131,40,2,0,128,
1,0,80,76,25,17,64,148,49,68,68,16,109,1,0,0,
0,0,160,194,42,162,40,11,138,170,194,138,130,2,0,128,
1,0,16,1,17,17,64,17,4,69,133,5,199,1,0,0,
0,0,32,0,0,32,32,0,0,2,0,128,198,2,0,128,
1,0,16,0,0,81,80,0,0,4,0,0,69,1,0,0,
0,0,32,0,0,34,32,0,0,0,0,128,130,2,0,128,
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170 };

//Sprite Plot pour Menu
unsigned char plot[] = {
0,0,5,5,32,32,0,112,112,0,248,248,0,112,112,0,
32,32,0,0 };

// Pions pour l'affichage
unsigned char pion_noir[] = {
0,0,5,5,248,248,0,248,248,0,248,248,0,248,248,0,
248,248,0,0 };
unsigned char pion_blanc[] = {
0,0,5,5,248,248,0,136,136,112,136,136,112,136,136,112,
248,248,0,0 };

// Game.c de Master Mind //
// Fonctions gérant les données du jeu //

// Fonction qui affiche le menu, laisse le choix à l'user et retourne 0 si nouvelle partie, 1 si quitter
char menu(void){
  char yplot=28,is_pressed=false; // coord y du plot, et si une touche est préssée
  while(getkey(1)!=K_EXE){        // boucle du menu, tant que EXE n'est pas appuyé
    gxClearBuff();                 // efface le contenu des buffers
    gxDrawBmp( Menu );            // met le Menu dans le buffer
    write(2,57,"Par Medivh");
    wait(25);              // ralenti un peu la boucle

    if(getkey(1)==K_HAUT&&is_pressed==false){ // si le joueur appuye sur haut
      is_pressed=true;                        // on signale qu'une touche est appuyée
      if(yplot==28){                          // et si le plot est déjà en haut
        yplot=42;}                            // on place le plot en bas
      else{                                  // si le plot est en bas
        yplot=28;}                          // on le place en haut
    }
    if(getkey(1)==K_BAS&&is_pressed==false){  // si le joueur appuye sur bas
      is_pressed=true;                        // on signale qu'une touche est appuyée
      if(yplot==42){                          // et si le plot est déjà en bas
        yplot=28;}                            // on place le plot en haut
      else{                              // si le plot est en haut
        yplot=42;}                               // on le place en bas
    }
    if(getkey(1)==0)is_pressed=false; // on signale qu'aucune touche est appuyée
    gxSpr_noM_noC(27,yplot,plot);     // affiche le plot a gauche
    gxSpr_noM_noC(100,yplot,plot);    // affiche le plot a droit
    gxRefresh();                      // rafraichis le buffer
  }                                   // fin de la boucle du menu
  switch(yplot){
    case 28:
    return(0);
    case 42:
    return(1);
  }
return(1);
}

//Fonction qui fait rentrer au joueur son essai, renvoie l'essai, ou -1 si le joueur veut retourner au menu
int enter_your_try(char i){
  int essai=0;                // L'essai du joueur
  while(1){
     while(getkey(1)!=K_EXE){       // boucle de getkey, tant que EXE n'est pas appuyé
        wait(25);               // ralenti un peu la boucle
        clear_rect(i);             // on rend la place à laquelle le joueur doit entrer les chiffres vierge
        write_try(i,essai);        // ecrit l'essai du joueur au bon endroit (fonction de i)
        gxRefresh();               // rafraichis le buffer
        switch(getkey(2)){         // on verifie si une touche est préssée
          case K_1 :               // et on execute l'action requise
          if(essai<=666)essai = (essai*10)+1;
          break;

          case K_2 :
          if(essai<=666)essai = (essai*10)+2;
          break;

          case K_3 :
          if(essai<=666)essai = (essai*10)+3;
          break;

          case K_4 :
          if(essai<=666)essai = (essai*10)+4;
          break;

          case K_5 :
          if(essai<=666)essai = (essai*10)+5;
          break;

          case K_6 :
          if(essai<=666)essai = essai*10+6;
          break;

          case K_DEL :
          essai/=10;
          clear_rect(i);
          break;
          
          case K_ESC :
          return -1;
        }
     }
     if (essai>=1111)return(essai);
  }
}

//Fonction qui créé un nombre mystere composé de 4 chifres alea entre 1~6
void create_mystere(char* mystere){
  char i;
  srand (time (0));                // on initialise le générateur de nombre aleatoire utilisé après
  for(i=0;i<=3;i++){
    *(mystere+i) = 1+(rand()%6);
  }
}

//Fonction qui analyse l'essai et renvoie le nombre de noir et blanc correspondant
void traite_essai(int essai, char* mystere ,char* noir, char*blanc)
{
  char nbre[4] , use[4];                       // on traiteras individuellment chaque chiffre, et on indique si tel ou tel chiffre est déja pointé
  char k;
  nbre[3] = essai%10;                          // on souhaite traiter chaque chiffre individuelement
  nbre[2] = ((essai%100)-essai%10)/10;         // pour cela, on decompose essai
  nbre[1] = ((essai%1000)-essai%100)/100;      // à l'aide du modulo
  nbre[0] = ((essai%10000)-essai%1000)/1000;
  for(k=0;k<=3;k++){
    use[k]=false;
  }  

  for (k=0; k<=3; k++){                        // on donne le nombre de noirs
    if (*(mystere+k)==nbre[k]){
      *noir=*noir+1;
      use[k]=true;
      nbre[k]=0;                                // il faut faire en sorte que nbre[k] ne soit jamais plus utilisé
    }
  }
  if (nbre[0]==*(mystere+1) && use[1]==false){
    *blanc=*blanc+1;
    use[1]=true;
    goto un;
  }
  if (nbre[0]==*(mystere+2) && use[2]==false){
    *blanc=*blanc+1;
    use[2]=true;
    goto un;
  }
  if (nbre[0]==*(mystere+3) && use[3]==false){
    *blanc=*blanc+1;
    use[3]=true;
  }
  un:
  if (nbre[1]==*(mystere+0) && use[0]==false){
    *blanc=*blanc+1;
    use[0]=true;
    goto deux;
  }
  if (nbre[1]==*(mystere+2) && use[2]==false){
    *blanc=*blanc+1;
    use[2]=true;
    goto deux;
  }
  if (nbre[1]==*(mystere+3) && use[3]==false){
    *blanc=*blanc+1;
    use[3]=true;
  }
  deux:
  if (nbre[2]==*(mystere+0) && use[0]==false){
    *blanc=*blanc+1;
    use[0]=true;
    goto trois;
  }
  if (nbre[2]==*(mystere+1) && use[1]==false){
    *blanc=*blanc+1;
    use[1]=true;
    goto trois;
  }
  if (nbre[2]==*(mystere+3) && use[3]==false){
    *blanc=*blanc+1;
    use[3]=true;
  }
  trois:
  if (nbre[3]==*(mystere+0) && use[0]==false){
    *blanc=*blanc+1;
    use[0]=true;
    goto fin;
  }
  if (nbre[3]==*(mystere+1) && use[1]==false){
    *blanc=*blanc+1;
    use[1]=true;
    goto fin;
  }
  if (nbre[3]==*(mystere+2) && use[2]==false){
    *blanc=*blanc+1;
    use[2]=true;
  }
  fin:
}

// Indique au joueur qu'il a perdu et lui donne la solution
void game_over(char* mystere){
  gxFillrect(1,1,126,11,GX_LIGHTGRAY);       // efface une partie de l'écran
  write(4,4,"La solution etait :");        // donne la solution au joueur
  writevalue(102,4,mystere[0]);            // mais on est obligé d'afficher chaque
  writevalue(107,4,mystere[1]);            // chiffre individuelement
  writevalue(112,4,mystere[2]);            // car ce n'est ni un int, ni un string
  writevalue(117,4,mystere[3]);
  gxRefresh();
  getkey(0);                               // attend la pression d'une touche
}

// Indique au joueur qu'il a gagné
void game_sucess(void){
  gxFillrect(1,1,126,11,GX_LIGHTGRAY);     // efface une partie de l'écran
  write(35,4,"Felicitations");             // signale au joueur qu'il a gagné
  gxRefresh();                             // rafraichis l'écran
  getkey(0);                               // attend la pression d'une touche                            // attend un peu, sinon le menu prend le getkey() pour lui
}

//Master.c

#include <sprWrite.h> // ecrit a l'aide de sprites
#include <time.h>     // pour rand() et srand()
#include <gxlib10.h>  // La librairie d'affichage 5GS
#include "utils.h"    // Des fonx utiles
#include "defs.h"     // les defs des sprites
#include "affich.c"
#include "game.c"     // Je sait que c'est aps propre mais dla *****


int main(void)                 // début du programme
{
char mystere[4];           // le nombre a trouver
char noir , blanc;         // nombre de noir et de blanc
char i;                   // variables de boucles
int essai;                 // essai du joueur

initialize();              // initialise le programme (desactAPO(), desalimente le buffer, ..etc)

while(1){
  create_mystere(mystere); // on créé un nombre mystere
  switch(menu()){          // affiche le menu, renvoie 0 si nouveau jeu, 1 si quitter

    case 0:
    /////////////////////
    // Nouvelle partie //
    /////////////////////
    gxClearBuff();                     // efface le buffer
    draw_plateau();                    // met le plateau de jeu dans le buffer
    for ( i=1; i<=6; i++ ){           // le joueur a 6 essais
      blanc=0;noir=0;                  // il faut remetre le nbre de blanc et noir a 0
      gxFillrect(1,1,126,11,GX_LIGHTGRAY);      // l'endroit ou est marqué 'Essai numero i' est vierge
      write(30,4,"Essai numero");               // signale au joueur
      writevalue(93,4,i);                       // qu'il en est a son Ième essai
      wait(50);                                 // ralentit un peu la boucle
      essai=enter_your_try(i);                  // le joueur entre son essai
      if(essai==-1)break;                        // Si ce que enter_your_try() a renvoyé vaut -1, on retourne au menu mais on affiche le mystere d'abord
      traite_essai(essai,mystere, &noir, &blanc);// on traite l'essai, cette fonction renvoie dans noir et blanc le nombres de...noir et blanc
      draw_pions(i,noir,blanc);                  // on dessine le bon nombre de pions (noirs et blancs) en fonction de l'essai
      if (noir==4){                              // si le joueur a trouvé le mystere
        game_sucess();                           // on lui indique qu'il a gagné
        break;
      }
    }
    game_over(mystere);
    break;

    case 1:
    /////////////////////
    //    Fin du jeu   //
    /////////////////////
    quit();       // rend la caltos prete pour son utilisation normale (actAPO, alimente le buffer touche...etc)
    return(0);    // quitte/retour au menu principal

  }
}
}

 /////////////////////////////////////////////////////////////////////////////////////
//*                          <sprWrite pour CASIO Graph100>                         *//
//                                                                                   //
//                         Fichier à inclure dans votre projet                       //
//                    Permet d'écrire à l'aide de sprite en mode 5 couleurs          //
//                                                                                   //
//*(c) Medivh - 2006                             Basé sur gxLib 1.0 de Julien PATTE *//
 /////////////////////////////////////////////////////////////////////////////////////

#include <gxLib10.h>
#include <string.h>                  // pour strlen()
#include <ctype.h>                   // pour islower(), toupper();
#include "sprWrite.h"

// sprites de tout l'alphabet moins ceux qui sont non-utilisés
// Si besoin, remplacez par les votre : 5px*4px, encodé avec SpriteMaker en mode 5 couleurs

unsigned char zero[] = {
0,0,5,4,96,96,0,144,144,0,144,144,0,144,144,0,
96,96,0,0 };

unsigned char un[] = {
0,0,5,4,32,32,0,96,96,0,32,32,0,32,32,0,
32,32,0,0 };

unsigned char deux[] = {
0,0,5,4,96,96,0,144,144,0,32,32,0,64,64,0,
240,240,0,0 };

unsigned char trois[] = {
0,0,5,4,96,96,0,144,144,0,32,32,0,144,144,0,
96,96,0,0 };

unsigned char quatre[] = {
0,0,5,4,32,32,0,96,96,0,160,160,0,240,240,0,
32,32,0,0 };

unsigned char cinq[] = {
0,0,5,4,240,240,0,128,128,0,224,224,0,16,16,0,
224,224,0,0 };

unsigned char six[] = {
0,0,5,4,96,96,0,128,128,0,224,224,0,144,144,0,
96,96,0,0 };

unsigned char sept[] = {
0,0,5,4,240,240,0,16,16,0,32,32,0,64,64,0,
64,64,0,0 };

unsigned char huit[] = {
0,0,5,4,96,96,0,144,144,0,96,96,0,144,144,0,
96,96,0,0 };

unsigned char neuf[] = {
0,0,5,4,96,96,0,144,144,0,112,112,0,16,16,0,
96,96,0,0 };

unsigned char deuxpt[] = {
0,0,5,4,96,96,0,96,96,0,0,0,0,96,96,0,
96,96,0,0 };

unsigned char ptvirgule[] = {
0,0,5,4,96,96,0,0,0,0,96,96,0,32,32,0,
64,64,0,0 };

unsigned char inf[] = {
0,0,5,4,16,16,0,32,32,0,64,64,0,32,32,0,
16,16,0,0 };

unsigned char egal[] = {
0,0,5,4,0,0,0,240,240,0,0,0,0,240,240,0,
0,0,0,0 };

unsigned char sup[] = {
0,0,5,4,128,128,0,64,64,0,32,32,0,64,64,0,
128,128,0,0 };

unsigned char ptint[] = {
0,0,5,4,96,96,0,144,144,0,32,32,0,0,0,0,
32,32,0,0 };

unsigned char arobase[] = {
0,0,5,4,112,112,0,16,16,0,240,240,0,144,144,0,
240,240,0,0 };

unsigned char A[] = {
0,0,5,4,96,96,0,144,144,0,240,240,0,144,144,0,
144,144,0,0 };

unsigned char B[] = {
0,0,5,4,224,224,0,144,144,0,224,224,0,144,144,0,
224,224,0,0 };

unsigned char C[] = {
0,0,5,4,96,96,0,144,144,0,128,128,0,144,144,0,
96,96,0,0 };

unsigned char D[] = {
0,0,5,4,224,224,0,144,144,0,144,144,0,144,144,0,
224,224,0,0 };

unsigned char E[] = {
0,0,5,4,240,240,0,128,128,0,224,224,0,128,128,0,
240,240,0,0 };

unsigned char F[] = {
0,0,5,4,240,240,0,128,128,0,224,224,0,128,128,0,
128,128,0,0 };

unsigned char G[] = {
0,0,5,4,112,112,0,128,128,0,176,176,0,144,144,0,
112,112,0,0 };

unsigned char H[] = {
0,0,5,4,144,144,0,144,144,0,240,240,0,144,144,0,
144,144,0,0 };

unsigned char I[] = {
0,0,5,4,112,112,0,32,32,0,32,32,0,32,32,0,
112,112,0,0 };

unsigned char J[] = {
0,0,5,4,16,16,0,16,16,0,16,16,0,144,144,0,
96,96,0,0 };

unsigned char K[] = {
0,0,5,4,144,144,0,160,160,0,192,192,0,160,160,0,
144,144,0,0 };

unsigned char L[] = {
0,0,5,4,128,128,0,128,128,0,128,128,0,128,128,0,
240,240,0,0 };

unsigned char M[] = {
0,0,5,4,144,144,0,240,240,0,144,144,0,144,144,0,
144,144,0,0 };

unsigned char N[] = {
0,0,5,4,144,144,0,208,208,0,176,176,0,144,144,0,
144,144,0,0 };

unsigned char O[] = {
0,0,5,4,96,96,0,144,144,0,144,144,0,144,144,0,
96,96,0,0 };

unsigned char P[] = {
0,0,5,4,224,224,0,144,144,0,224,224,0,128,128,0,
128,128,0,0 };

unsigned char Q[] = {
0,0,5,4,96,96,0,144,144,0,144,144,0,160,160,0,
80,80,0,0 };

unsigned char R[] = {
0,0,5,4,224,224,0,144,144,0,224,224,0,144,144,0,
144,144,0,0 };

unsigned char S[] = {
0,0,5,4,112,112,0,128,128,0,96,96,0,16,16,0,
224,224,0,0 };

unsigned char T[] = {
0,0,5,4,240,240,0,64,64,0,64,64,0,64,64,0,
64,64,0,0 };

unsigned char U[] = {
0,0,5,4,144,144,0,144,144,0,144,144,0,144,144,0,
240,240,0,0 };

unsigned char V[] = {
0,0,5,4,144,144,0,144,144,0,144,144,0,160,160,0,
64,64,0,0 };

unsigned char W[] = {
0,0,5,4,144,144,0,144,144,0,144,144,0,240,240,0,
144,144,0,0 };

unsigned char X[] = {
0,0,5,4,144,144,0,144,144,0,96,96,0,144,144,0,
144,144,0,0 };

unsigned char Y[] = {
0,0,5,4,144,144,0,144,144,0,96,96,0,64,64,0,
128,128,0,0 };

unsigned char Z[] = {
0,0,5,4,240,240,0,16,16,0,32,32,0,64,64,0,
240,240,0,0 };


unsigned char* Alphabet[] = {
    zero,
    un,
    deux,
    trois,
    quatre,
    cinq,
    six,
    sept,
    huit,
    neuf,
    deuxpt,
    ptvirgule,
    inf,
    egal,
    sup,
    ptint,
    arobase,
    A,
    B,
    C,
    D,
    E,
    F,
    G,
    H,
    I,
    J,
    K,
    L,
    M,
    N,
    O,
    P,
    Q,
    R,
    S,
    T,
    U,
    V,
    W,
    X,
    Y,
    Z
};



// fonction qui écrit une chaîne de charactère à l'aide des sprites de Alphabet[]

void write(int x, int y, char string[]){
int size , j;
char spr;
size = strlen(string);            // on récupère la longueur de string dans size

   for(j=0 ; j<size ; j++){                // pour chaque caractère de la chaine
    if(islower(string[j]))            // on verifie s'il est en minuscule
    string[j]= toupper(string[j]);      // si necesaire on le met en majuscule
    spr = string[j]-48;            // mon tableau est décalé de 48 par rapport à l'ASCII
    gxSpr_noM_noC(x,y,Alphabet[spr]);    // et on affiche le caractère
    x=x+5;                     // sans oublier les espacements
   }
}


// fonction qui affiche une valeur numerique decimale
void writevalue(int x,int y,int value)
{
   int i,j,s=0,r;
   char st[10];

   if (value<0) {st[0]='-'; s=1;value=-value; }   // si le nombre est négatif, on ajoute '-' et on décale la string d'iun rang

   r=value;
   for(j=1;r>9;j++) r/=10;    // on calcule le nombre de chara dans l'int

   for (i=0;i<j;i++)          // pour chaque chara
   {
      st[j+s-i-1]='0'+value%10;      // on remplie la string en commencant au fond, et en remontant
      value/=10;                     // on décale le chiffre a afficher d'un cran
   }
   st[s+j]='\0';                     // sans oublier le chara '\0' a la fin de la string

    write(x,y,st);                   // et on affiche la string avec write (ci dessus)
}


void gxFillrect(int Ax, int Ay, int Bx, int By, char color)
{
   int i;
       for( i=Ay ; i<By ; i++){
         gxHLine(Ax, Bx , i , color);
       }
}

 /////////////////////////////////////////////////////////////////////////////////////
//*                          <sprWrite pour CASIO Graph100>                         *//
//                                                                                   //
//       Librairie permettant d'écrire à l'aide de sprite en mode 5 couleurs         //
//                                                                                   //
//*(c) Medivh - 2006                                 Basé sur gxLib de Julien PATTE *//
 /////////////////////////////////////////////////////////////////////////////////////

void write(int x, int y, char string[]);
void writevalue(int x, int y, int value);
void gxFillrect(int Ax, int Ay, int Bx, int By, char color);

//Utils . c
#include <gxLib10.h>
#include "utils.h"
#define NUMBER_SAVE   6
unsigned int OldInt[NUMBER_SAVE][2];     // desactint() / actint()

unsigned char lastkey=0;                 // getkey()

// Wait, ralenti le programme
void wait(long t){long i;
    for (i=0; i<=t*100;i++);}

// Clearkeybuf : vide le bufffer touche
void clearkeybuf(void)
{
  asm{
       mov ax,0x40
       mov es,ax
       mov al,es:0x1B
       mov es:0x1D,al
     }
}

// Desactive une l'interruption designee par intrp.
// Pos represente l'endroit de la sauvegarde.
// Fonction de DB-lib.h par Swifter - SWF Prod 2004
void desactint(unsigned char intrp,unsigned char pos)
{
  void* adrs=&OldInt[pos<<1];
  asm{
       xor ax,ax
       mov es,ax
       mov al,intrp
       mov di,ax
       mov si,adrs
       shl di,0x2
       mov ax,es:[di+2]
       mov ds:[si+2],ax
       mov ax,es:[di]
       mov ds:[si],ax
       mov ax,es:0x03FE
       mov es:[di+2],ax
       mov ax,es:0x03FC
       mov es:[di],ax
     }
}


// Reactive une interruption desactivee auparavant.
// Fonction de DB-lib.h par Swifter - SWF Prod 2004
void actint(unsigned char intrp,unsigned char pos)
{
  void* adrs=&OldInt[pos<<1];
  asm{
       xor ax,ax
       mov es,ax
       mov al,intrp
       mov di,ax
       mov si,adrs
       shl di,0x2
       mov ax,ds:[si+2]
       mov es:[di+2],ax
       mov ax,ds:[si]
       mov es:[di],ax
     }
}

// Getkey, retrouve si une touche est préssée
unsigned char getkey(unsigned char mode)
{
  top:
  asm{
       xor ah,ah
       mov al,lastkey
       mov dx,0xA80
       div dh
       mov cx,ax
       mov ax,0x1
       shl ax,cl
       mov cl,ch
       shr dl,cl
       mov dh,0x2
       mov ch,0x6
     }
  loop0:
  asm{
       out 0x13,ax
       in al,0x13
       and al,dl
       cmp al,0x0
       jne test
       mov ax,0x1
       mov dl,al
       dec dh
       jne loop0
       mov ax,0x2
       mov dx,0xA02
       jmp loop1
     }
  test:
  asm{
       mov ch,0x2C
       cmp dh,0x2
       jne endtest
       dec dh
       cmp dh,mode
       jne null
     }
  return lastkey;
  loop1:
  asm{
       out 0x13,ax
       mov bx,ax
       in al,0x13
       cmp al,0x0
       jne loop2
       add dh,0xA
       shl bx,0x1
       mov ax,bx
       cmp ax,0x800
       jne loop1
       xor dl,dl
       mov lastkey,dl
     }
  null:
  asm{
       xor dh,dh
       cmp dh,mode
       je top
     }
  return 0;
  loop2:
  asm{
       mov cl,al
       and cl,dl
       cmp cl,0x0
       jne endtest
       shl dl,0x1
       dec ch
       jne loop2
     }
  endtest:
  asm{
       add dh,ch
       mov dl,0x1
       cmp dl,mode
       je end
       cmp dh,lastkey
       jne end
       jmp null
     }
  end:
  asm mov lastkey,dh
  return lastkey;
}

// initialise le programme
void initialize(void){
  desact_APO();            // desactive l'alimentation automatique
  clearkeybuf();           // vide le buffer touche
  desactint9();            // desactive l'alimentation du buffer touche
  gxSetMode(true);       // passe en mode 5 couleurs
}

// rend la calculatrice prete pour son fonctionnement normal
void quit(void){
  gxClearBuff();             // on éfface le buffer
  gxRefresh();               // et on rafraichis l'écran
  gxSetMode(false);          // repasse en mode C3
  actint9();                 // reactive l'alimentation du buffer touche
  act_APO();                 // reactive l'extinction automatique
}

//utils.h
/* DEFINITIONS */


void desactint(unsigned char intrp,unsigned char pos);
void actint(unsigned char intrp,unsigned char pos);
void wait(long t);
void clearkeybuf(void);
unsigned char getkey(unsigned char mode);
void initialize(void);
void quit(void);


#define desactint9() desactint(0x9,0)
#define actint9() actint(0x9,0)
#define desact_APO() desactint(0x4A,1)
#define act_APO() actint(0x4A,1)
#define K_F1        101
#define K_F2        102
#define K_F3        103
#define K_F4        104
#define K_F5        105
#define K_F6        106
#define K_SHIFT        81
#define K_CTRL        82
#define K_OPTN        83
#define K_MENU        84
#define K_GAUCHE    91
#define K_DROITE    94
#define K_HAUT        92
#define K_BAS        93
#define K_ALPHA        71
#define K_VARS        72
#define K_PUISS        73
#define K_ESC        74
#define K_X        61
#define K_LOG        62
#define K_LN        63
#define K_SIN        64
#define K_COS        65
#define K_TAN        66
#define K_DC        51
#define K_X2        52
#define K_CRH_G        53
#define K_CRH_D        54
#define K_VIRG        55
#define K_FLECHE    56
#define    K_7        41
#define    K_8        42
#define    K_9        43
#define K_DEL        44
#define K_ACon        45
#define    K_4        31
#define    K_5        32
#define    K_6        33
#define K_FOIS        34
#define K_DIVIS        35
#define    K_1        21
#define    K_2        22
#define    K_3        23
#define K_PLUS        24
#define K_MOINS        25
#define    K_0        11
#define K_POINT        12
#define K_EXP        13
#define K_TIRET        14
#define K_EXE        15