API tools faq
paste
Advertisement
Wistaro

ISN_2015_Cahors_MasterMind

Wistaro
May 31st, 2015
551
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 33.72 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Le code est disponible sous la licence "Creative Commons 3.0": http://creativecommons.org/licenses/by-sa/3.0/deed.fr
  3. Dernière compilation: 31/05/2015 @ 18:06
  4.  
  5. */
  6.  
  7. /*
  8.                 -----------------------
  9.                 |******MASTERMIND*****|
  10.                 -----------------------
  11.                
  12.     ************************************************************       
  13.     * GOMES Kévin - ROMIGUIERES Victoria - ROMIGUIERES William *
  14.     ************************************************************
  15.  
  16. */
  17. /*
  18.  * Précisions :
  19.  * -> pion noir correcteur = bonne couleur, mal placée
  20.  * -> pion rouge correcteur = bonne couleur, bien placée
  21.  * -> mode débutant = pion correcteur placé à l'emplacement de la couleur du joueur qui devine
  22.  *  mais côté correcteur
  23.  */
  24.  
  25. /*Ces variables sont définies partout dans les sous-programmes et dans le main. Il est donc inutile des les définir ailleur.*/
  26.  
  27. int temps = 0;
  28. int temps_2 = 0; //permet de diviser le temps qui s'écoule trop vite.
  29.  
  30. String couleurs_j1_initial[]=new String[4]; //couleur que va choisir l'ordinateur ou le joueur au début
  31. String couleurs_j1[]=new String[4]; //les 4 couleurs que va jouer l'utilisateur cherchant
  32. String couleurs_j2[]=new String[4]; //les 4 couleurs que va jouer l'utilisateur correcteur
  33. String couleur_j1_manuel=""; //variable définie partout
  34. String chemin = "H:/TRAVAIL/TERMINALE S - 2014-2015/ISN/"; //les fichiers du jeu doivent être mis dans un dossier nommé "MasterMind". Iic, indiquez le chemin de ce dossier
  35. String couleur_j2_manuel=""; // variable définie partout : choix couleur correction
  36. int choix_menu = 0;
  37.  
  38. //initialisation du fichier de configuration
  39.  
  40.      int []config = new int[6];
  41.  
  42.      /* FICHIER DE CONFIGURATION
  43.       * [0] --> Mode de jeu: 1 = JCJ, 2 = JCIA
  44.       * [1] --> Sous-mode: 1 = Débutant, 2 = Normal
  45.       * [2] --> Difficultée: 1 = Facile, 2 = Normal, 3 = Difficile, 4 = Expert, 5 = Aléatoire
  46.       * [3] --> Vérification: 1 = Auto, 2 = Manuel
  47.       * [4] --> Temps maximum (en secondes)
  48.       * [5] --> Nombre de coups maximums
  49.       */
  50.  
  51.  
  52. int changer_dif(){
  53.  
  54.     //permet de changer la difficultée
  55.  
  56.     println("Choisissez la difficulté selon les nombres : ");
  57.     println();
  58.     println("Facile : 1");
  59.     println("Normal : 2");
  60.     println("Difficile : 3");
  61.     println("Expert : 4");
  62.     println("Aléatoire : 5");
  63.     int dif = readInt("Entrez un nombre entre 1 et 5 selon la difficulté voulue");
  64.  
  65.     if(dif == 5){
  66.  
  67.         dif = random(1,4);
  68.  
  69.         //on tire une difficulté au hasard
  70.        
  71.     }
  72.     return dif;
  73.    
  74. }
  75. int changer_verif (){
  76.  
  77.         println("1 : vérif auto");
  78.         println("2 : vérif manuelle");
  79.         int num_verif = readInt("Entrez un numéro selon la vérification voulue :");
  80.         return num_verif;
  81.  
  82.    
  83. }
  84. void ecran_fin(int win){
  85.  
  86.         if(win ==1){
  87.  
  88.             //victoire
  89.             load(chemin+"Mastermind/images/fin_win.png");
  90.             sleep(50000);
  91.            
  92.         }else{
  93.  
  94.             //défaite
  95.             load(chemin+"Mastermind/images/fin_go.png");
  96.             sleep(50000);
  97.  
  98.            
  99.  
  100.            
  101.         }
  102. }
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109. void choix_couleur_initial(int type){
  110.  
  111.     //type: 1=JCJ, 2=JCO
  112.    
  113.     int choix_couleur_user = 0;
  114.  
  115.     if(type == 1){
  116.  
  117.     //on charge l'image de sélection des couleurs par le joueur 1 
  118.     load(chemin+"Mastermind/images/choix_couleur_user.png");
  119.    
  120.         for(int a = 1; a<=4; a++){
  121.        
  122.                 choix_couleur_user = readInt("Choisissez la couleur n°"+a);
  123.                
  124.  
  125.        
  126.                 if(choix_couleur_user == 1){
  127.  
  128.                             couleurs_j1_initial[a-1] = "noir";
  129.                        
  130.                 }
  131.                
  132.                 if(choix_couleur_user == 2){
  133.  
  134.                             couleurs_j1_initial[a-1] = "rouge";
  135.                        
  136.                 }
  137.                
  138.                 if(choix_couleur_user == 3){
  139.  
  140.                             couleurs_j1_initial[a-1] = "vert";
  141.                        
  142.                 }
  143.  
  144.                
  145.                 if(choix_couleur_user == 4){
  146.  
  147.                             couleurs_j1_initial[a-1] = "jaune";
  148.                        
  149.                 }
  150.                
  151.                 if(choix_couleur_user == 5){
  152.  
  153.                             couleurs_j1_initial[a-1] = "bleu";
  154.                        
  155.                 }
  156.                
  157.                 if(choix_couleur_user == 6){
  158.  
  159.                             couleurs_j1_initial[a-1] = "violet";
  160.                        
  161.                 }
  162.                
  163.                 if(choix_couleur_user == 7){
  164.  
  165.                             couleurs_j1_initial[a-1] = "orange";
  166.                        
  167.                 }
  168.  
  169.                
  170.                 if(choix_couleur_user == 8){
  171.  
  172.                             couleurs_j1_initial[a-1] = "blanc";
  173.                        
  174.                 }
  175.  
  176.                 if(choix_couleur_user < 0 || choix_couleur_user >8){
  177.  
  178.                             couleurs_j1_initial[a-1] = "noir";
  179.                        
  180.                 }
  181.  
  182.                
  183.  
  184.                
  185.            
  186.         }
  187.  
  188.  
  189.    
  190.    
  191.    
  192.    
  193.    
  194.     }else{
  195.  
  196.     //joueur contre ordinateur: choix couleur aléatoire
  197.    
  198.     int couleur_choisi_ordi[]=  new int[4];
  199.        
  200.     couleur_choisi_ordi[0] = random (1,8);
  201.     couleur_choisi_ordi[1] = random (1,8);
  202.     couleur_choisi_ordi[2] = random (1,8);
  203.     couleur_choisi_ordi[3] = random (1,8);
  204.  
  205.     //couleur_j1_initial étant un tableau d'entiers, on convertit les entiers trouvés aléatoirement en string
  206.    
  207.     for(int a = 0; a<=3; a++){
  208.        
  209.                
  210.  
  211.        
  212.                 if(couleur_choisi_ordi[a] == 1){
  213.  
  214.                             couleurs_j1_initial[a] = "noir";
  215.                        
  216.                 }
  217.                
  218.                 if(couleur_choisi_ordi[a]  == 2){
  219.  
  220.                             couleurs_j1_initial[a] = "rouge";
  221.                        
  222.                 }
  223.                
  224.                 if(couleur_choisi_ordi[a]  == 3){
  225.  
  226.                             couleurs_j1_initial[a] = "vert";
  227.                        
  228.                 }
  229.  
  230.                
  231.                 if(couleur_choisi_ordi[a]  == 4){
  232.  
  233.                             couleurs_j1_initial[a] = "jaune";
  234.                        
  235.                 }
  236.                
  237.                 if(couleur_choisi_ordi[a]  == 5){
  238.  
  239.                             couleurs_j1_initial[a] = "bleu";
  240.                        
  241.                 }
  242.                
  243.                 if(couleur_choisi_ordi[a] == 6){
  244.  
  245.                             couleurs_j1_initial[a] = "violet";
  246.                        
  247.                 }
  248.                
  249.                 if(couleur_choisi_ordi[a] == 7){
  250.  
  251.                             couleurs_j1_initial[a] = "orange";
  252.                        
  253.                 }
  254.  
  255.                
  256.                 if(couleur_choisi_ordi[a] == 8){
  257.  
  258.                             couleurs_j1_initial[a] = "blanc";
  259.                        
  260.                 }
  261.  
  262.                
  263.                
  264.  
  265.                
  266.            
  267.         }
  268.    
  269.  
  270.    
  271.  
  272.            
  273.                
  274.        
  275.     }
  276.  
  277.    
  278. }
  279.  
  280.  
  281. int demander_menu() {
  282.  
  283. //routine qui va demander à l'utilisateur de selectionner la zone du menu et qui renvois le choix fait
  284.  
  285.          setRunnable(new Runnable() {
  286.             public void run() {
  287.  
  288.                
  289.                
  290.                int x = getX();
  291.                int y = getY();
  292.  
  293.                
  294.             clear();
  295.              
  296.                    
  297.             //suivant les coordonnées du clic, on retourne le choix
  298.             if(y>=14 && y <= 58 && x<= 114 && x>=-95){
  299.  
  300.                 choix_menu = 1;
  301.                
  302.             }
  303.             if(y>=-80 && y <= -36 && x<= 114 && x>=-95){
  304.  
  305.                 choix_menu = 2;
  306.                
  307.             }
  308.             if(y>=-80 && y <= -36 && x<= 114 && x>=-95){
  309.  
  310.                 choix_menu = 2;
  311.                
  312.             }
  313.             if(y>=-177 && y <= -113 && x<= 114 && x>=-95){
  314.  
  315.                 choix_menu = 3;
  316.                
  317.             }
  318.  
  319.              
  320.             }
  321.          }
  322.         );
  323.      
  324.      
  325.      
  326.       return choix_menu;
  327.      
  328.    
  329. }
  330.  
  331. void coup_joueur_cherche(int coup){
  332.  
  333.     String choix_couleur = "";
  334.  
  335.     //le coup du joueur qui cherche: s'occupe de tout charger
  336.    
  337.    
  338.     clear();   
  339.  
  340.     for(int nb_couleur_choix = 0; nb_couleur_choix<4; nb_couleur_choix++){
  341.  
  342.  
  343.    
  344.         while(choix_couleur == ""){
  345.  
  346.             //pendant le choix de l'utilisateur qui cherche, on incrémente le temps
  347.             temps++;
  348.            
  349.             temps_2 = temps/5;
  350.            
  351.             lcd_temps(temps_2);
  352.             sleep(200);
  353.             effacer_digits_temps();
  354.  
  355.             if(temps_2 >= config[4] || coup == config[5]){
  356.  
  357.                 ecran_fin(0);
  358.        
  359.     }
  360.            
  361.                
  362.           choix_couleur = demander_couleurs_j1_manuel();
  363.        
  364.        
  365.         }
  366.    
  367.  
  368.  
  369.     couleurs_j1[nb_couleur_choix] = choix_couleur;
  370.  
  371.    
  372.     choix_couleur = "";
  373.     couleur_j1_manuel="";
  374.    
  375.  
  376.    
  377.    
  378.     }
  379.    
  380.    
  381.      afficher_couleurs_coup(coup);
  382.    
  383. //fin demander couleur 
  384.    
  385. }
  386.  
  387. void coup_joueur_correcteur(int coup){
  388.  
  389.     String choix_couleur = "";
  390.    
  391.    
  392.     clear();   
  393.  
  394.     for(int nb_couleur_choix = 0; nb_couleur_choix<4; nb_couleur_choix++){
  395.  
  396.  
  397.    
  398.         while(choix_couleur == ""){
  399.  
  400.         //tant que l'utilisateur correcteur n'a pas choisi de couleur, on reste dans la boucle.
  401.           choix_couleur = demander_couleurs_j2_correction();
  402.          
  403.        
  404.        
  405.         }
  406.    
  407.  
  408.     //On stocke les couleurs du correcteur
  409.     couleurs_j2[nb_couleur_choix] = choix_couleur;
  410.  
  411.     //on réinitialise les 2 variables pour éviter que le while ne s'execute pas de suite
  412.     choix_couleur = "";
  413.     couleur_j2_manuel="";
  414.    
  415.  
  416.    
  417.    
  418.     }
  419.    
  420.    
  421.      afficher_couleurs_correcteur(coup);
  422.     //on lance la routine qui va afficher les couleurs du correcteur suivant le coup
  423.    
  424. //fin demander couleur 
  425.    
  426. }
  427. String demander_couleurs_j1_manuel() {
  428.  
  429.  
  430.         /* int []rouge = {250,38,21}; //rouge
  431.         int []vert = {2,221,9}; //vert
  432.         int []jaune = {255,255,51}; //jaune
  433.         int []bleu = {0,255,255}; //bleu
  434.         int []violet = {179,14,211}; //violet
  435.         int []orange = {255,126,39}; //orange
  436.         int []blanc = {255,255,255}; //blanc
  437.         int []noir = {0,0,0}; //noir */
  438.    
  439.      
  440.  
  441.  
  442.          setRunnable(new Runnable() {
  443.             public void run() {
  444.  
  445.                 couleur_j1_manuel = "";
  446.  
  447.            
  448.                 int rgb2[] = getPixelColor(getX(), getY());  
  449.              
  450.            
  451.            
  452.            
  453.  
  454.  
  455.              if(rgb2[0] == 250 && rgb2[1] == 38 && rgb2[2] == 21){
  456.  
  457.                 couleur_j1_manuel = "rouge";
  458.              }
  459.              
  460.            
  461.                
  462.                 if (rgb2[0] == 2 && rgb2[1] == 221 && rgb2[2] == 9){
  463.  
  464.                    
  465.                     couleur_j1_manuel = "vert";
  466.                
  467.                }
  468.                 if (rgb2[0] == 255 && rgb2[1] == 255 && rgb2[2] == 51){
  469.  
  470.                     couleur_j1_manuel = "jaune";
  471.                }
  472.                 if (rgb2[0] == 0 && rgb2[1] == 255 && rgb2[2] == 255){
  473.  
  474.                     couleur_j1_manuel = "bleu";
  475.                }
  476.                 if (rgb2[0] == 179 && rgb2[1] == 14 && rgb2[2] == 211){
  477.  
  478.                     couleur_j1_manuel = "violet";
  479.                
  480.                }
  481.                 if (rgb2[0] == 255 && rgb2[1] == 126 && rgb2[2] == 39){
  482.  
  483.                     couleur_j1_manuel = "orange";
  484.                
  485.                }
  486.                 if (rgb2[0] == 255 && rgb2[1] == 255 && rgb2[2] == 255){
  487.  
  488.                     couleur_j1_manuel = "blanc";
  489.                
  490.                }
  491.                 if (rgb2[0] == 0 && rgb2[1] == 0 && rgb2[2] == 0){
  492.  
  493.                     couleur_j1_manuel = "noir";
  494.                
  495.                }
  496.              
  497.  
  498.                
  499.  
  500.                
  501.  
  502.             clear();
  503.              
  504.            
  505.  
  506.              
  507.             }
  508.          }
  509.         );
  510.      
  511.      
  512.      
  513.       return couleur_j1_manuel;
  514.      
  515.    
  516. }
  517.  String demander_couleurs_j2_correction(){
  518.  
  519.    
  520.      /*on demande au joueur 2 de saisir les couleurs de la correction.
  521.      On retourne la valeur de la couleur choisie (rouge, noir ou rien
  522.      si l'utilisateur a cliqué dans le vide)*/
  523.  
  524.  
  525.          setRunnable(new Runnable() {
  526.             public void run() {
  527.  
  528.                 couleur_j2_manuel = "";
  529.  
  530.            
  531.                 int rgb2[] = getPixelColor(getX(), getY());  
  532.               //on stocke les valeurs rgb du pixel sélectionné par l'utilisateur.
  533.  
  534.               //On retourne en fonction du clic la valeur de la couleur.
  535.  
  536.  
  537.              if(rgb2[0] == 250 && rgb2[1] == 38 && rgb2[2] == 22){
  538.  
  539.                 couleur_j2_manuel = "rouge";
  540.  
  541.                      }
  542.              
  543.            
  544.                
  545.                
  546.                 if (rgb2[0] == 0 && rgb2[1] == 0 && rgb2[2] == 1){
  547.  
  548.                     couleur_j2_manuel = "noir";
  549.                
  550.                }
  551.  
  552.                
  553.               if(couleur_j2_manuel == "" && getX() != 0 &&  getY() != 0){
  554.  
  555.                     couleur_j2_manuel = "rien";
  556.                     //s'il clique autre part que dans la case rouge/noire, on retourne "rien".
  557.                            
  558.               }
  559.            
  560.                
  561.  
  562.                
  563.  
  564.             clear();
  565.              
  566.            
  567.  
  568.              
  569.             }
  570.          }
  571.         );
  572.      
  573.      
  574.      
  575.       return couleur_j2_manuel;
  576.    
  577. }
  578.  
  579. int[] changer_variables_difficultee(){
  580.  
  581.         //change les variables suivant la difficultée
  582.        
  583.         int[]temps_et_coup_max = new int[2];
  584.  
  585.         if(config[2] == 1){
  586.            
  587.                 temps_et_coup_max[0] = 99;//le temps est en secondes !
  588.                 temps_et_coup_max[1] = 12;
  589.            
  590.         }
  591.  
  592.         if(config[2] == 2){
  593.            
  594.                 temps_et_coup_max[0] = 60;
  595.                 temps_et_coup_max[1] = 12;
  596.            
  597.         }
  598.  
  599.         if(config[2] == 3){
  600.            
  601.                 temps_et_coup_max[0] = 60;
  602.                 temps_et_coup_max[1] = 10;
  603.            
  604.         }
  605.  
  606.         if(config[2] == 4){
  607.            
  608.                 temps_et_coup_max[0] = 30;
  609.                 temps_et_coup_max[1] = 8;
  610.            
  611.         }
  612.  
  613.         return temps_et_coup_max;
  614.        
  615.    
  616. }  
  617. /*
  618. *************************************************************************************
  619. ICI EST LE MAIN() !
  620. *************************************************************************************
  621.  
  622. */
  623. void main(){
  624.  
  625.     //*******************début partie menu*********************************
  626.  
  627.     //on initialise les variables de choix (JcJ/JcIA/Option et Débutant/Normal)
  628.     int choix1 = 0;
  629.     int choix2 = 0;
  630.  
  631.    
  632.     //on charge l'image contenant les choix JcJ/JcIA/Options
  633.     load(chemin+"Mastermind/images/intro1.png");
  634.  
  635.     //on attend que l'utilisateur ait choisi. Sinon on reste dans la boucle.
  636.     while(choix1 == 0){
  637.        
  638.         choix1 = demander_menu();
  639.         //on demande le clic de l'utilisateur
  640.  
  641.        
  642.     }
  643.    
  644.     config[0] = choix1;
  645.     config[3] = 2; //par défaut, vérification manuel
  646.     config[2] = 2; //par défaut difficulté normale
  647.  
  648.     if(choix1 == 3){ //si l'utilisateur a choisi la 3e option du menu 1: on affiche le menu d'options du jeu
  649.        
  650.  
  651.         config[2] = changer_dif();
  652.  
  653.    
  654.  
  655.     int[]temps_coup_max = changer_variables_difficultee();
  656.    
  657.     config[4] = temps_coup_max[0];
  658.     config[5] = temps_coup_max[1];
  659.  
  660.     println();
  661.     println("Le temps max est de : "+config[4]+" secondes !");
  662.     println();
  663.     println("Le coup max est de : "+config[5]);
  664.     println();
  665.  
  666.     config[3] = changer_verif();
  667.  
  668.                    
  669.     }else{
  670.  
  671.         //valeurs par défault
  672.         config[2] = 2; //difficultée normal
  673.         config[3] = 2; //vérification manuelle par défaut
  674.         config[4] = 60; //60s comme le mode normal
  675.         config[5] = 12; //nombre de coup par défaut=12
  676.        
  677.     }
  678.  
  679.     //on charge l'image contenant les choix JcJ/JcIA/Options
  680.     load(chemin+"Mastermind/images/intro2.png");
  681.     choix_menu = 0;
  682.    
  683.     while(choix2 == 0){
  684.        
  685.         choix2 = demander_menu();
  686.     }
  687.  
  688.     config[1] = choix2;
  689.  
  690.     if(config[1] == 1){
  691.  
  692.         //si l'utilisateur choisit le mode débutant, on charge la difficulté facile.
  693.  
  694.         config[2] = 1; //difficultée facile
  695.         config[4] = 99; //99s comme le mode facile
  696.         config[5] = 12; //nombre de coup par défaut=12
  697.        
  698.     }
  699.    
  700.    
  701.    
  702.  
  703.     //*******************fin partie menu*********************************
  704.    
  705.     //début partie choix couleur
  706.  
  707.     choix_couleur_initial(config[0]);
  708.  
  709.    
  710.     //démarrage du jeu
  711.  
  712.     //on charge l'image principale du jeu
  713.     load(chemin+"Mastermind/images/fond2.png");
  714.  
  715.    
  716.     //on charge tout les graphismes
  717.     affichage_palette_couleur();
  718.     affichage_grille_gauche();
  719.     affichage_grille_droite();
  720.     affichage_palette_couleur_correcteur();
  721.  
  722.    
  723.  
  724.    
  725.  
  726.     //score
  727.  
  728.     int score = 0;
  729.    
  730.  
  731. for(int coup=1;coup<=config[5]+2;coup++){
  732.    
  733.     score =  (score + 3*config[2] + config[1]*2) - coup;
  734.     //le score est calculé en fonction du niveau de difficulté, du mode débutant/normal et du nombre de coups
  735.  
  736.    
  737.    
  738.     if(score < 0){
  739.         score = 0;
  740.     }
  741.  
  742.     lcd_score(score);
  743.     lcd_coup(coup);
  744.    
  745.    
  746.    
  747.     coup_joueur_cherche(coup);
  748.    
  749.  
  750.     if(config[0] == 2){
  751.  
  752.  
  753.        
  754.         corriger_auto(couleurs_j1_initial,couleurs_j1, config[1], coup);
  755.        
  756.    
  757.     }else{
  758.  
  759.         if(config[3] == 1){
  760.                
  761.                 corriger_auto(couleurs_j1_initial,couleurs_j1, config[1], coup);
  762.            
  763.         }else{
  764.  
  765.            
  766.             coup_joueur_correcteur(coup);
  767.            
  768.         }
  769.  
  770.        
  771.     }
  772.    
  773.    
  774.     effacer_digits_coup();
  775.     effacer_digits_score();
  776.    
  777.  
  778.  
  779. }
  780.  
  781.  
  782.    
  783. }
  784. void lcd_score(int r){
  785.     //r = nombre à afficher pour le nb de coups: [0;99]
  786.  
  787.         int prem = r/10; //a afficher sur le digit de gauche
  788.         int second = r - 10*prem; //a afficher sur le digit de droite
  789.         lcd_aff_seg_digit(prem, 180,95,20); //on affiche le premier segment
  790.         lcd_aff_seg_digit(second, 220,95,20); //le second
  791.        
  792. }
  793.  
  794. void lcd_coup(int r){
  795.     //r = nombre à afficher pour le nb de coups: [0;99]
  796.  
  797.         int prem = r/10; //a afficher sur le digit de gauche
  798.         int second = r - 10*prem; //a afficher sur le digit de droite
  799.         lcd_aff_seg_digit(prem, 180,-20,20); //on affiche le premier segment
  800.         lcd_aff_seg_digit(second, 220,-20,20); //le second
  801.        
  802. }
  803. void lcd_temps(int r){
  804.     //r = nombre à afficher pour le nb de coups: [0;99]
  805.  
  806.         int prem = r/10; //a afficher sur le digit de gauche
  807.         int second = r - 10*prem; //a afficher sur le digit de droite
  808.         lcd_aff_seg_digit(prem, 180,-155,20); //on affiche le premier segment
  809.         lcd_aff_seg_digit(second, 220,-155,20); //le second
  810.        
  811. }
  812.  
  813.  
  814. void lcd_aff_seg_digit(int r, int x, int y, int tailleseg){
  815. /*
  816. ********************************************************************************************************
  817. Paramètres: (chiffre [0;9], extremité gauche du segment, extremité haut du segment, taille des segments)
  818. ********************************************************************************************************   
  819. /*cette fonction permet d'afficher un seul digit
  820. //pourra être réutilisé pour d'autres afficheurs */
  821.  
  822.  
  823.     clear();
  824.  
  825.  
  826.     int info_lcd[] = new int [3];
  827.  
  828.     info_lcd[0] = x; //centre sur la largeur:210
  829.     info_lcd[1] = y; //centre sur la hauteur: -30
  830.     info_lcd[2] = tailleseg; //tailles des segments:10
  831.     //centre = pixel en haut à gauche du digit
  832.  
  833.  
  834.  
  835.    
  836.     //Séquence affichage des différents digits
  837.  
  838.    
  839.     //les numéros correspondent au numéro de segment et non le numéro affiché
  840.  
  841.         int lcdseg[][] = new int[11][8];
  842.         //premier niveau = le chiffre affiché -1 (0 = chiffre1)
  843.         //second niveau = la séquence à suivre pour afficher ce numéro
  844.  
  845.     //8 = segment non affiché
  846.             int[]seg1 = {1,2,4,5,6,7,8}; //code afficher 0
  847.             int[]seg2 = {7,6,8,8,8,8,8}; //code afficher 1...
  848.             int[]seg3 = {1,2,6,5,3,8,8};
  849.             int[]seg4 = {1,2,6,7,3,8,8};
  850.             int[]seg5 = {4,6,3,7,8,8,8};
  851.             int[]seg6 = {1,2,3,4,7,8,8};
  852.             int[]seg7 = {1,2,3,4,5,7,8};
  853.             int[]seg8 = {1,6,7,8,8,8,8};
  854.             int[]seg9 = {1,2,3,4,5,6,7};
  855.             int[]seg10 = {1,2,3,4,8,6,7};
  856.             int[]segeff = {8,8,8,8,8,8,8};
  857.            
  858.  
  859.             lcdseg[0] = seg1;
  860.             lcdseg[1] = seg2;
  861.             lcdseg[2] = seg3;
  862.             lcdseg[3] = seg4;
  863.             lcdseg[4] = seg5;
  864.             lcdseg[5] = seg6;
  865.             lcdseg[6] = seg7;
  866.             lcdseg[7] = seg8;
  867.             lcdseg[8] = seg9;
  868.             lcdseg[9] = seg10;
  869.             lcdseg[10] = segeff;
  870.            
  871.            
  872.        
  873.  
  874.  
  875.     //effacer_digits_coup();
  876.    
  877.             for(int w = 0; w<7; w++){
  878.  
  879.                     if(lcdseg[r][w] == 1){
  880.                         seghm(info_lcd);
  881.                     }
  882.                     if(lcdseg[r][w] == 2){
  883.                         segbm(info_lcd);
  884.                     }
  885.                     if(lcdseg[r][w] == 3){
  886.                         segmm(info_lcd);
  887.                     }
  888.                     if(lcdseg[r][w] == 4){
  889.                         seghg(info_lcd);
  890.                     }
  891.                     if(lcdseg[r][w] == 5){
  892.                         segbg(info_lcd);
  893.                     }
  894.                     if(lcdseg[r][w] == 6){
  895.                         seghd(info_lcd);
  896.                     }
  897.                     if(lcdseg[r][w] == 7){
  898.                         segbd(info_lcd);
  899.                     }
  900.                    
  901.                        
  902.                    
  903.  
  904.             }//fin
  905.  
  906.            
  907.        
  908.  
  909.        
  910.        
  911.     //partie correspondence:
  912.        
  913.  
  914. //fin affichage digit  
  915. }
  916.  
  917. //début affichage segments
  918.  
  919. void seghm(int[]inf){
  920.  
  921.         for(int i = inf[0]; i<= inf[0]+inf[2]; i++){
  922.                 setPixel(i, inf[1], "cyan");
  923.         }
  924. }
  925.  
  926. void segbm(int[]inf){
  927.  
  928.         for(int i = inf[0]; i<= inf[0]+inf[2]; i++){
  929.                 setPixel(i, inf[1]-60, "cyan");
  930.         }
  931. }
  932. void segmm(int[]inf){
  933.  
  934.         for(int i = inf[0]; i<= inf[0]+inf[2]; i++){
  935.                 setPixel(i, inf[1]-30, "cyan");
  936.         }
  937. }
  938.  
  939. void seghg(int[]inf){
  940.  
  941.         for(int i = inf[1]-30; i<= inf[1]; i++){
  942.                 setPixel(inf[0]-3, i, "cyan");
  943.         }
  944. }
  945.  
  946. void segbg(int[]inf){
  947.  
  948.         for(int i = inf[1]-60; i<= inf[1]-30; i++){
  949.                 setPixel(inf[0]-3, i, "cyan");
  950.         }
  951. }
  952. void seghd(int[]inf){
  953.  
  954.         for(int i = inf[1]-30; i<= inf[1]; i++){
  955.                 setPixel(inf[0]+inf[2]+3, i, "cyan");
  956.         }
  957. }
  958. void segbd(int[]inf){
  959.  
  960.         for(int i = inf[1]-60; i<= inf[1]-30; i++){
  961.                 setPixel(inf[0]+inf[2]+3, i, "cyan");
  962.         }
  963. }
  964.  
  965. void effacer_digits_coup(){
  966.  
  967.     for(int i = 170; i<=250;i++){
  968.  
  969.         for(int k = -93; k<= -3; k++){
  970.  
  971.                 setPixel(i, k, 102, 102, 102);
  972.            
  973.         }
  974.        
  975.     }
  976.    
  977.    
  978. }
  979. void effacer_digits_score(){
  980.  
  981.     for(int i = 170; i<=250;i++){
  982.  
  983.         for(int k = 27; k<=116; k++){
  984.  
  985.                 setPixel(i, k, 102, 102, 102);
  986.            
  987.         }
  988.        
  989.     }
  990.    
  991.    
  992. }
  993. void effacer_digits_temps(){
  994.  
  995.     for(int i = 170; i<=250;i++){
  996.  
  997.         for(int k = -228; k<=-120; k++){
  998.  
  999.                 setPixel(i, k, 102, 102, 102);
  1000.            
  1001.         }
  1002.        
  1003.     }
  1004.    
  1005.    
  1006. }
  1007.  
  1008.  //fin affichage segments
  1009.  
  1010. void affichage_palette_couleur(){
  1011.  
  1012.  
  1013.     clear();
  1014.  
  1015.         int largeur = getWidth();
  1016.         int hauteur = getHeight();
  1017.  
  1018.         int taille_cases = 10;
  1019.  
  1020.         int tab_centre_pt[][][] = new int[8][8][3];
  1021.        
  1022.         int hauteur_palette = -hauteur+20; //hauteur centre palette
  1023.  
  1024.         //couleurs palette:
  1025.  
  1026.  
  1027.         int []rouge = {250,38,21}; //rouge
  1028.         int []vert = {2,221,9}; //vert
  1029.         int []jaune = {255,255,51}; //jaune
  1030.         int []bleu = {0,255,255}; //bleu
  1031.         int []violet = {179,14,211}; //violet
  1032.         int []orange = {255,126,39}; //orange
  1033.         int []blanc = {255,255,255}; //blanc
  1034.         int []noir = {0,0,0}; //noir
  1035.  
  1036.  
  1037.         tab_centre_pt[2][1] = rouge;
  1038.         tab_centre_pt[2][2] = vert;
  1039.         tab_centre_pt[2][3] = jaune;
  1040.         tab_centre_pt[2][4] = bleu;
  1041.         tab_centre_pt[2][5] = violet;
  1042.         tab_centre_pt[2][6] = orange;
  1043.         tab_centre_pt[2][7] = blanc;
  1044.         tab_centre_pt[2][0] = noir;
  1045.        
  1046.  
  1047.  
  1048.  
  1049.         int cpt = 0;
  1050.  
  1051.         for(int i = 15; i<=280; i = i+35){
  1052.  
  1053.            
  1054.             tab_centre_pt[1][cpt][0] = -largeur+i;
  1055.            
  1056.             cpt++;
  1057.            
  1058.    
  1059.         }
  1060.  
  1061.        
  1062.     for(int j = hauteur_palette -taille_cases; j <= hauteur_palette +taille_cases; j++){
  1063.  
  1064.        
  1065.  
  1066.         for(int cpt2 = 0; cpt2 <= 7; cpt2++){
  1067.  
  1068.             for(int k = tab_centre_pt[1][cpt2][0] -taille_cases; k <= tab_centre_pt[1][cpt2][0] +taille_cases; k++){
  1069.  
  1070.            
  1071.                 setPixel(k, j, tab_centre_pt[2][cpt2][0], tab_centre_pt[2][cpt2][1], tab_centre_pt[2][cpt2][2]);
  1072.  
  1073.  
  1074.  
  1075.                 }
  1076.  
  1077.                         }
  1078.  
  1079.            
  1080.                                 }
  1081.  
  1082.  
  1083.  
  1084.  
  1085.  
  1086.  
  1087.  
  1088.  
  1089.  
  1090.  
  1091. //fin affichage  palette couleur   
  1092. }
  1093.  
  1094.  
  1095. void affichage_grille_gauche(){
  1096.  
  1097.                 /*240 - (-197) = 437 (amplitude hauteur)
  1098.                  *  437/12 = 37
  1099.                  *
  1100.     */
  1101.  
  1102.             //affiche les lignes horizontales
  1103.             for(int a = -197; a<= 240; a = a+37){
  1104.  
  1105.                     for(int b = -250; b<=30; b++){
  1106.  
  1107.                             setPixel(b, a, "black");
  1108.  
  1109.                        
  1110.                     }
  1111.                      
  1112.             }
  1113.  
  1114.  
  1115.  
  1116.             //affichage case
  1117.  
  1118.  
  1119.         //30- -250 = 280: amplitude sur les x
  1120.         //280/4 = 70
  1121.        
  1122.         int centre_case_x=0;
  1123.         int centre_case_y=0;
  1124.         int epaisseur = 4; //epaisseur des cases
  1125.         int taille_case = 10; // taille des cases
  1126.  
  1127. for(int y = -160; y<= 277; y = y+37){
  1128.     //centre la case sur les y
  1129.  
  1130.      centre_case_y=y-37/2;
  1131.  
  1132.  
  1133.         for(int x = -180; x<100; x = x+70 ){
  1134.             //centre la case sur les x
  1135.  
  1136.            
  1137.  
  1138.             centre_case_x=x-70/2;
  1139.  
  1140.  
  1141.  
  1142.                 //affiche les cases pleines avec les bordures
  1143.  
  1144.  
  1145.                 for(int gauche = centre_case_x-taille_case-epaisseur; gauche<= centre_case_x+taille_case+epaisseur; gauche++){
  1146.  
  1147.                     for(int haut = centre_case_y-taille_case-epaisseur; haut<= centre_case_y+taille_case+epaisseur; haut++){
  1148.  
  1149.                     setPixel(gauche,  haut, "black");
  1150.  
  1151.                    
  1152.                     }
  1153.                 }
  1154.                 //on efface l'intérieur des cases
  1155.                 for(int gauche = centre_case_x-taille_case-epaisseur/2; gauche<= centre_case_x+epaisseur/2+taille_case; gauche++){
  1156.  
  1157.                     for(int haut = centre_case_y-taille_case-epaisseur/2; haut<= centre_case_y+epaisseur/2+taille_case; haut++){
  1158.  
  1159.                     setPixel(gauche,  haut, 195,195,180);
  1160.  
  1161.                    
  1162.                     }
  1163.                 }
  1164.  
  1165.  
  1166.         }  
  1167.  
  1168. }
  1169.     //fin procedure affichage grille gauche
  1170. }
  1171. void affichage_grille_droite(){
  1172.  
  1173.                 /*240 - (-197) = 437 (amplitude hauteur)
  1174.                  *  437/12 = 37
  1175.                  *  
  1176.                  *  159 -36 = 123 (amplitude largeur)
  1177.                  *
  1178.     */
  1179.  
  1180.             //affiche les lignes horizontales
  1181.             for(int a = -197; a<= 240; a = a+37){
  1182.  
  1183.                     for(int b = 36; b<=159; b++){
  1184.  
  1185.                             setPixel(b, a, "black");
  1186.  
  1187.                        
  1188.                     }
  1189.                      
  1190.             }
  1191.  
  1192.  
  1193.  
  1194.             //affichage case
  1195.  
  1196.  
  1197.          /*     159 -36 = 123 (amplitude largeur)
  1198.                  * 123/4 = 31 */
  1199.        
  1200.         int centre_case_x=0;
  1201.         int centre_case_y=0;
  1202.         int epaisseur =2; //epaisseur des cases
  1203.         int taille_case = 3; // taille des cases
  1204.  
  1205. for(int y = -160; y<= 277; y = y+37){
  1206.     //centre la case sur les y
  1207.  
  1208.      centre_case_y=y-37/2;
  1209.  
  1210.        
  1211.         for(int x = 67; x<=190; x = x+31 ){
  1212.             //centre la case sur les x
  1213.  
  1214.            
  1215.  
  1216.             centre_case_x=x-31/2;
  1217.  
  1218.  
  1219.  
  1220.                 //affiche les cases pleines avec les bordures
  1221.  
  1222.  
  1223.                 for(int gauche = centre_case_x-taille_case-epaisseur; gauche<= centre_case_x+taille_case+epaisseur; gauche++){
  1224.  
  1225.                     for(int haut = centre_case_y-taille_case-epaisseur; haut<= centre_case_y+taille_case+epaisseur; haut++){
  1226.  
  1227.                     setPixel(gauche,  haut, "black");
  1228.  
  1229.                    
  1230.                     }
  1231.                 }
  1232.                 //on efface l'intérieur des cases
  1233.                 for(int gauche = centre_case_x-taille_case-epaisseur/2; gauche<= centre_case_x+epaisseur/2+taille_case; gauche++){
  1234.  
  1235.                     for(int haut = centre_case_y-taille_case-epaisseur/2; haut<= centre_case_y+epaisseur/2+taille_case; haut++){
  1236.  
  1237.                     setPixel(gauche,  haut, 195,195,180);
  1238.  
  1239.                    
  1240.                     }
  1241.                 }
  1242.  
  1243.  
  1244.         }  
  1245.  
  1246. }
  1247.     //fin procedure affichage grille droite
  1248. }
  1249.  
  1250. void affichage_palette_couleur_correcteur(){
  1251.  
  1252.  
  1253.         int largeur = getWidth();
  1254.         int hauteur = getHeight();
  1255.  
  1256.  
  1257.     //création première case
  1258.        
  1259.         int hauteur_pixel = -212; //coordonnées hauteur centre sur y
  1260.         int largeur_pixel = 70; // coordonnées largeur centre sur x
  1261.         int taille_case = 8; // taille case à partir du centre
  1262.        
  1263.  
  1264.  
  1265.         for(int x = largeur_pixel - taille_case; x<= largeur_pixel+taille_case; x++ ){
  1266.  
  1267.                     for(int y = hauteur_pixel - taille_case; y<= hauteur_pixel+taille_case; y++ ){
  1268.                    
  1269.                             setPixel(x, y, 250,38,22);
  1270.                        
  1271.                     }
  1272.    
  1273.         }
  1274.  
  1275.  
  1276.          //création seconde case
  1277.        
  1278.          hauteur_pixel = -212; //coordonnées hauteur centre sur y
  1279.          largeur_pixel = 120; // coordonnées largeur centre sur x
  1280.                
  1281.  
  1282.         for(int x = largeur_pixel - taille_case; x<= largeur_pixel+taille_case; x++ ){
  1283.  
  1284.                     for(int y = hauteur_pixel - taille_case; y<= hauteur_pixel+taille_case; y++ ){
  1285.                    
  1286.                             setPixel(x, y, 0,0,1);
  1287.                        
  1288.                     }
  1289.        
  1290.        
  1291.                 }
  1292. //Fin affichage palette couleurs correction
  1293. }
  1294.  
  1295.  
  1296. void afficher_couleurs_coup(int coup){
  1297.  
  1298.  
  1299.         int []rouge = {250,38,21}; //rouge
  1300.         int []vert = {2,221,9}; //vert
  1301.         int []jaune = {255,255,51}; //jaune
  1302.         int []bleu = {0,255,255}; //bleu
  1303.         int []violet = {179,14,211}; //violet
  1304.         int []orange = {255,126,39}; //orange
  1305.         int []blanc = {255,255,255}; //blanc
  1306.         int []noir = {0,0,0}; //noir
  1307.  
  1308.         int[] color = new int[3];
  1309.  
  1310.     for(int aff_couleur = 1; aff_couleur<=4; aff_couleur++){
  1311.  
  1312.            
  1313.         if(couleurs_j1[aff_couleur-1] == "rouge"){
  1314.  
  1315.                 color = rouge;
  1316.            
  1317.         }
  1318.         if(couleurs_j1[aff_couleur-1] == "vert"){
  1319.  
  1320.                 color = vert;
  1321.            
  1322.         }
  1323.         if(couleurs_j1[aff_couleur-1] == "jaune"){
  1324.  
  1325.                 color = jaune;
  1326.            
  1327.         }
  1328.         if(couleurs_j1[aff_couleur-1] == "bleu"){
  1329.  
  1330.                 color = bleu;
  1331.            
  1332.         }
  1333.         if(couleurs_j1[aff_couleur-1] == "violet"){
  1334.  
  1335.                 color = violet;
  1336.            
  1337.         }
  1338.         if(couleurs_j1[aff_couleur-1] == "orange"){
  1339.  
  1340.                 color = orange;
  1341.            
  1342.         }
  1343.         if(couleurs_j1[aff_couleur-1] == "blanc"){
  1344.  
  1345.                 color = blanc;
  1346.            
  1347.         }
  1348.         if(couleurs_j1[aff_couleur-1] == "noir"){
  1349.  
  1350.                 color =noir;
  1351.            
  1352.         }
  1353.        
  1354.         afficher_couleur_grille(aff_couleur,coup,color);
  1355.  
  1356.     }
  1357.  
  1358.  
  1359.    
  1360. }
  1361. void afficher_couleurs_correcteur(int coup){
  1362.  
  1363.  
  1364.         int[]rouge ={250,38,22};//rouge
  1365.         int[]noir = {0,0,1}; //noir
  1366.         int[]rien = {195, 195, 180}; //rien dans la case
  1367.  
  1368.         int[] color = new int[3];
  1369.  
  1370.     for(int aff_couleur = 1; aff_couleur<=4; aff_couleur++){
  1371.  
  1372.            
  1373.         if(couleurs_j2[aff_couleur-1] == "rouge"){
  1374.  
  1375.                 color = rouge;
  1376.            
  1377.         }
  1378.        
  1379.         if(couleurs_j2[aff_couleur-1] == "noir"){
  1380.  
  1381.                 color =noir;
  1382.            
  1383.         }
  1384.  
  1385.  
  1386.         if(couleurs_j2[aff_couleur-1] == "rien"){
  1387.  
  1388.                 color = rien;      
  1389.  
  1390.         }
  1391.        
  1392.         afficher_couleur_correcteur(aff_couleur,coup,color); //affiche une couleur
  1393.  
  1394.     }
  1395.  
  1396.  
  1397.    
  1398. }
  1399.  
  1400. void afficher_couleur_grille(int num_case_x, int num_case_y, int[]couleur){
  1401.  
  1402.     int grille_gauche[][][] = new int[4][12][2]; //tableau qui stocke les coordonnées des cases
  1403.        
  1404.     int centre_case_x=0;
  1405.     int centre_case_y=0;
  1406.     int cpt_x = 0;
  1407.     int cpt_y = 0;
  1408.  
  1409.     for(int y = -160; y<= 277; y = y+37){
  1410.         //stocker les coordonnées réelles de la case sur y
  1411.    
  1412.  
  1413.      centre_case_y=y-37/2;
  1414.      
  1415.  
  1416.  
  1417.         for(int x = -180; x<100; x = x+70 ){
  1418.         //stocker les coordonnées réelles de la case sur x
  1419.  
  1420.             centre_case_x=x-70/2;
  1421.  
  1422.                
  1423.            
  1424.                 grille_gauche[cpt_x][cpt_y][0] = centre_case_x;
  1425.  
  1426.              
  1427.                 grille_gauche[cpt_x][cpt_y][1] = centre_case_y;
  1428.              
  1429.             cpt_x++;
  1430.            
  1431.            
  1432.            
  1433.  
  1434.            
  1435.  
  1436.            
  1437.             }
  1438.  
  1439.     cpt_y++;
  1440.     cpt_x = 0;
  1441.  
  1442.    
  1443.  
  1444.    
  1445.     }
  1446.  
  1447.  
  1448.     int epaisseur = 4; //epaisseur des cases
  1449.     int taille_case = 10; // taille des cases
  1450.    
  1451.  
  1452.  
  1453.     int xcase = grille_gauche[num_case_x-1][num_case_y-1][0];
  1454.     int ycase = grille_gauche[num_case_x-1][num_case_y-1][1];
  1455.    
  1456.     //cases sur x allant de 1 à 4 et sur y allant de 1 à 12. Il faudra donc enlever 1 pour retrouver le bon index du tableau.
  1457.     //setPixel(grille_gauche[num_case_x-1][num_case_y-1][0], grille_gauche[num_case_x-1][num_case_y-1][1], "red");
  1458.  
  1459.        
  1460.                 //on efface l'intérieur des cases
  1461.                 for(int gauche = xcase-taille_case-epaisseur/2; gauche<= xcase+epaisseur/2+taille_case; gauche++){
  1462.  
  1463.                     for(int haut = ycase-taille_case-epaisseur/2; haut<= ycase+epaisseur/2+taille_case; haut++){
  1464.  
  1465.                     setPixel(gauche,  haut, couleur[0], couleur[1], couleur[2]);
  1466.  
  1467.                    
  1468.                     }
  1469.                 }
  1470.  
  1471.    
  1472.    
  1473. }
  1474.  
  1475. void afficher_couleur_correcteur(int num_case_x, int num_case_y, int[]couleur){
  1476.  
  1477.     int grille_droite[][][] = new int[4][12][2]; //tableau qui stocke les coordonnées des cases
  1478.        
  1479.     int centre_case_x=0;
  1480.     int centre_case_y=0;
  1481.     int cpt_x = 0;
  1482.     int cpt_y = 0;
  1483.  
  1484.     for(int y = -160; y<= 277; y = y+37){
  1485.         //stocker les coordonnées réelles de la case sur y
  1486.    
  1487.  
  1488.      centre_case_y=y-37/2;
  1489.      
  1490.  
  1491.  
  1492.         for(int x = 67; x<190; x = x+31 ){
  1493.         //stocker les coordonnées réelles de la case sur x
  1494.  
  1495.             centre_case_x=x-31/2;
  1496.  
  1497.                
  1498.            
  1499.                 grille_droite[cpt_x][cpt_y][0] = centre_case_x;
  1500.  
  1501.              
  1502.                 grille_droite[cpt_x][cpt_y][1] = centre_case_y;
  1503.              
  1504.             cpt_x++;
  1505.            
  1506.            
  1507.            
  1508.  
  1509.            
  1510.  
  1511.            
  1512.             }
  1513.  
  1514.     cpt_y++;
  1515.     cpt_x = 0;
  1516.  
  1517.    
  1518.  
  1519.    
  1520.     }
  1521.  
  1522.  
  1523.     int epaisseur = 4; //épaisseur des cases
  1524.     int taille_case = 2; // taille des cases
  1525.    
  1526.  
  1527.  
  1528.     int xcase = grille_droite[num_case_x-1][num_case_y-1][0];
  1529.     int ycase = grille_droite[num_case_x-1][num_case_y-1][1];
  1530.    
  1531.    
  1532.                 //on efface l'intérieur des cases
  1533.                 for(int gauche = xcase-taille_case-epaisseur/2; gauche<= xcase+epaisseur/2+taille_case; gauche++){
  1534.  
  1535.                     for(int haut = ycase-taille_case-epaisseur/2; haut<= ycase+epaisseur/2+taille_case; haut++){
  1536.  
  1537.                     setPixel(gauche,  haut, couleur[0], couleur[1], couleur[2]);
  1538.  
  1539.                    
  1540.                     }
  1541.                 }
  1542.  
  1543.    
  1544.    
  1545. }
  1546.  
  1547.  
  1548. void corriger_auto(String couleur_a_deviner_str[], String couleurJ_str[], int mode,int coup){
  1549.  
  1550. clear();
  1551. int couleur_a_deviner[] = new int[4];
  1552. int couleurJ[] = new int[4];
  1553. //partie conversion tableau de string en tableau d'entiers
  1554. for(int r = 0; r<=3;r++){
  1555.  
  1556.     couleur_a_deviner[r] = conv_couleurstring_couleurint(couleur_a_deviner_str[r]);
  1557.     couleurJ[r] = conv_couleurstring_couleurint(couleurJ_str[r]);
  1558. }
  1559.  
  1560. //fin partie conversion
  1561.  
  1562.     String[]cases_pions = new String[4];
  1563.    
  1564.    
  1565.  
  1566.     //DEBUT PARTIE KEVIN GESTION DES COUPS
  1567.  
  1568.    
  1569.     int compteur = 0;
  1570.  
  1571.    
  1572.    
  1573.    
  1574.  
  1575.    
  1576.    
  1577.     if(couleur_a_deviner[0] == couleurJ[0]){
  1578.  
  1579.         if(mode == 1){
  1580.  
  1581.                 cases_pions[compteur] = "rouge";
  1582.                 compteur++;
  1583.                 //println();
  1584.                
  1585.         }else{
  1586.  
  1587.                 cases_pions[0] = "rouge";              
  1588.            
  1589.         }
  1590.  
  1591.        
  1592.     }else{
  1593.             if(couleurJ[0] == couleur_a_deviner[1] || couleurJ[0] == couleur_a_deviner[2] || couleurJ[0] == couleur_a_deviner[3]){
  1594.  
  1595.                 //println("pion noir");
  1596.                 if(mode == 1){
  1597.  
  1598.                 cases_pions[compteur] = "noir";
  1599.                 compteur++;
  1600.                
  1601.             }else{
  1602.  
  1603.                 cases_pions[0] = "noir";               
  1604.            
  1605.             }
  1606.  
  1607.                 }  
  1608.         }
  1609.    
  1610.  
  1611.     if(couleur_a_deviner[1] == couleurJ[1]){
  1612.  
  1613.         //println("pion rouge");
  1614.         if(mode == 1){
  1615.  
  1616.                 cases_pions[compteur] = "rouge";
  1617.                 compteur++;
  1618.                
  1619.         }else{
  1620.  
  1621.                 cases_pions[1] = "rouge";              
  1622.            
  1623.         }
  1624.        
  1625.     }else{
  1626.  
  1627.         if(couleurJ[1] == couleur_a_deviner[0] || couleurJ[1] == couleur_a_deviner[2] || couleurJ[1] == couleur_a_deviner[3]){
  1628.  
  1629.             //println("pion noir");
  1630.             if(mode == 1){
  1631.  
  1632.                 cases_pions[compteur] = "noir";
  1633.                 compteur++;
  1634.                
  1635.         }else{
  1636.  
  1637.                 cases_pions[1] = "noir";               
  1638.            
  1639.         }
  1640.        
  1641.         }
  1642.     }
  1643.  
  1644.     if(couleur_a_deviner[2] == couleurJ[2]){
  1645.  
  1646.         //println("pion rouge");
  1647.         if(mode == 1){
  1648.  
  1649.                 cases_pions[compteur] = "rouge";
  1650.                 compteur++;
  1651.                
  1652.         }else{
  1653.  
  1654.                 cases_pions[2] = "rouge";              
  1655.            
  1656.         }
  1657.        
  1658.     }else{
  1659.  
  1660.         if(couleurJ[2] == couleur_a_deviner[0] || couleurJ[2] == couleur_a_deviner[1] || couleurJ[2] == couleur_a_deviner[3]){
  1661.  
  1662.             //println("pion noir");
  1663.             if(mode == 1){
  1664.  
  1665.                 cases_pions[compteur] = "noir";
  1666.                 compteur++;
  1667.                
  1668.         }else{
  1669.  
  1670.                 cases_pions[2] = "noir";               
  1671.            
  1672.         }
  1673.        
  1674.         }
  1675.     }
  1676.  
  1677.     if(couleur_a_deviner[3] == couleurJ[3]){
  1678.  
  1679.         //println("pion rouge");
  1680.         if(mode == 1){
  1681.  
  1682.                 cases_pions[compteur] = "rouge";
  1683.                 compteur++;
  1684.                
  1685.         }else{
  1686.  
  1687.                 cases_pions[3] = "rouge";              
  1688.            
  1689.         }
  1690.        
  1691.     }else{
  1692.  
  1693.         if(couleurJ[3] == couleur_a_deviner[0] || couleurJ[3] == couleur_a_deviner[1] || couleurJ[3] == couleur_a_deviner[2]){
  1694.  
  1695.             //println("pion noir");
  1696.             if(mode == 1){
  1697.  
  1698.                 cases_pions[compteur] = "noir";
  1699.                 compteur++;
  1700.                
  1701.         }else{
  1702.  
  1703.                 cases_pions[3] = "noir";               
  1704.            
  1705.         }
  1706.        
  1707.         }
  1708.     }
  1709.  
  1710.  
  1711.     //DEBUT PARTIE KEVIN GESTION DES COUPS
  1712.  
  1713.         if(couleurJ[0] == couleur_a_deviner[0] && couleurJ[1] == couleur_a_deviner[1] && couleurJ[2] == couleur_a_deviner[2] && couleurJ[3] == couleur_a_deviner[3]){
  1714.  
  1715.            
  1716.             ecran_fin(1);
  1717.        
  1718.         }
  1719.  
  1720.         //affichage des pions au bon endroit
  1721.  
  1722.         //afficher_couleur_correcteur(int num_case_x, int num_case_y, int[]couleur)
  1723.  
  1724.        
  1725.         int[]rouge = {250,38,21}; //rouge
  1726.         int []noir = {0,0,0}; //noir
  1727.         int[]rien = {195, 195, 180}; //rien dans la case
  1728.        
  1729.         for(int c = 0;c<=3;c++){
  1730.  
  1731.                 if(cases_pions[c] == "noir"){
  1732.  
  1733.                    
  1734.                     afficher_couleur_correcteur(c+1, coup, noir);
  1735.                    
  1736.                 }
  1737.                 if(cases_pions[c] == "rouge"){
  1738.  
  1739.                    
  1740.                     afficher_couleur_correcteur(c+1, coup, rouge);
  1741.                    
  1742.                 }
  1743.                 if(cases_pions[c] == "null"){
  1744.  
  1745.                    
  1746.                     afficher_couleur_correcteur(c+1, coup, rouge);
  1747.                    
  1748.                 }
  1749.                
  1750.  
  1751.                
  1752.            
  1753.         }
  1754.    
  1755.    
  1756.  
  1757. }
  1758. int conv_couleurstring_couleurint(String couleur){
  1759.  
  1760.     //on va convertir la couleur qui est en String en un entier.
  1761.     //C'est nécessaire pour certaines fonctions.
  1762.  
  1763.  
  1764.         int couleur_int = 0;
  1765.  
  1766.  
  1767.         if(couleur == "rouge"){
  1768.  
  1769.             couleur_int = 1;
  1770.  
  1771.            
  1772.         }
  1773.         if(couleur == "noir"){
  1774.  
  1775.             couleur_int = 8;
  1776.  
  1777.            
  1778.         }
  1779.         if(couleur == "vert"){
  1780.  
  1781.             couleur_int = 2;
  1782.  
  1783.            
  1784.         }
  1785.         if(couleur == "rouge"){
  1786.  
  1787.             couleur_int = 1;
  1788.  
  1789.            
  1790.         }
  1791.         if(couleur == "jaune"){
  1792.  
  1793.             couleur_int = 3;
  1794.  
  1795.            
  1796.         }
  1797.         if(couleur == "bleu"){
  1798.  
  1799.             couleur_int = 4;
  1800.  
  1801.            
  1802.         }
  1803.         if(couleur == "violet"){
  1804.  
  1805.             couleur_int = 5;
  1806.  
  1807.            
  1808.         }
  1809.         if(couleur == "orange"){
  1810.  
  1811.             couleur_int = 6;
  1812.  
  1813.            
  1814.         }
  1815.         if(couleur == "blanc"){
  1816.  
  1817.             couleur_int = 7;
  1818.  
  1819.            
  1820.         }
  1821.        
  1822.        
  1823.         return couleur_int;
  1824. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!