Vous êtes ici :  Gecif.net  >  Linux et programmation  >  Le jeu du MasterMind
  

Le MasterMind

La règle du jeu

Vous connaissez sûrement le jeu du Mastermind, ce jeu de logique et de déduction dans lequel il faut trouver une combinaison de 5 couleurs.

Les 5 couleurs à trouver sont prises dans un ensemble de 8 couleurs. La combinaison à trouver contient 5 couleurs différentes : aucune couleur n'est représentée plusieurs fois dans la combinaison à trouver.

 

Entraînez-vous sur cette applet Java

Grâce à l'applet Java ci-dessous vous pouvez vous entraîner pour trouver la solution optimale du Mastermind. L'ordinateur a en mémoire une combinaison de 5 couleurs qu'il vous faut retrouver.

Pour composer une ligne, déplacez le curseur à l'aide des boutons gauche et droite (représentés "<" et ">" dans l'applet), puis cliquez sur les boutons de couleur pour positionner une couleur à l'endroit du curseur.

Une fois votre ligne terminée, cliquez sur le bouton "Valider la ligne" pour la proposer à l'ordinateur. L'ordinateur vous répond alors à droite de la ligne, avec des pions rouges et des pions blancs dont la signification est la suivante :

Enfin, vous pouvez afficher ou cacher à tout moment la solution à déterminer, grâce au bouton "Montrer la solution".

Avec cette applet vous pouvez valider n'importe quelle sorte de ligne (des lignes vides, des lignes à moitié pleines, des lignes contenant 5 fois la même couleur, des lignes contenant plusieurs pions de la même couleur, etc.) mais la vraie règle du jeu voudrait que vous ne validiez que des lignes contenant toujours 5 couleurs différentes.

Maintenant c'est à vous de jouer. Bonne chance !

Remarques :

 

Le code source de l'applet

Voici le code source en Java de l'applet ci-dessus du Mastermind que j'ai mis au point et compilé avec JBuilder 9 sous Linux :

import java.awt.*;
import java.awt.event.*;
import java.applet.*;

/************************************************************/
// debut de la classe
/************************************************************/
public class mastermind
    extends Applet
    implements ActionListener {

  /************************************************************/
  // Declaration des variables
  /************************************************************/
// Les boutons :
  Button bouton_gauche = new Button(" < ");
  Button bouton_droite = new Button(" > ");
  Button bouton_valider = new Button("Valider la ligne");
  Button bouton_montrer = new Button("Montrer la solution");
  Button bouton_rouge = new Button(" ");
  Button bouton_vert = new Button(" ");
  Button bouton_bleu = new Button(" ");
  Button bouton_jaune = new Button(" ");
  Button bouton_magenta = new Button(" ");
  Button bouton_cyan = new Button(" ");
  Button bouton_noir = new Button(" ");
  Button bouton_blanc = new Button(" ");
// Autres variables :
  int ligne_courante = 1;
  int colonne_courante = 1;
  String[][] tab = new String[6][21];
  int[][] reponse = new int[6][21];
  String[] solution = new String[6];
  public boolean montrer_solution = false;

  /************************************************************/
  // Fonction tester_proposition pour tester la ligne validée
  /************************************************************/
  public void tester_proposition() {
    int i, n = 1;
    String s;
    for (i = 1; i <= 5; i++) {
      if (tab[i][ligne_courante] == solution[i]) {
        reponse[n][ligne_courante] = 2; // ajoute 1 pion rouge dans la réponse
        n = n + 1;
      }
    }
    s = tab[1][ligne_courante];
    if ( (s == solution[2]) || (s == solution[3]) || (s == solution[4]) ||
        (s == solution[5])) {
      reponse[n][ligne_courante] = 1; // ajoute 1 pion blanc dans la réponse
      n = n + 1;
    }
    s = tab[2][ligne_courante];
    if ( (s == solution[1]) || (s == solution[3]) || (s == solution[4]) ||
        (s == solution[5])) {
      reponse[n][ligne_courante] = 1; // ajoute 1 pion blanc dans la réponse
      n = n + 1;
    }
    s = tab[3][ligne_courante];
    if ( (s == solution[1]) || (s == solution[2]) || (s == solution[4]) ||
        (s == solution[5])) {
      reponse[n][ligne_courante] = 1; // ajoute 1 pion blanc dans la réponse
      n = n + 1;
    }
    s = tab[4][ligne_courante];
    if ( (s == solution[1]) || (s == solution[2]) || (s == solution[3]) ||
        (s == solution[5])) {
      reponse[n][ligne_courante] = 1; // ajoute 1 pion blanc dans la réponse
      n = n + 1;
    }
    s = tab[5][ligne_courante];
    if ( (s == solution[1]) || (s == solution[2]) || (s == solution[3]) ||
        (s == solution[4])) {
      reponse[n][ligne_courante] = 1; // ajoute 1 pion blanc dans la réponse
      n = n + 1;
    }
    ligne_courante = ligne_courante + 1;
    if (ligne_courante > 20) {
      ligne_courante = 20;
    }
  }

  /************************************************************/
  // Fonction init_solution pour tirer au hasard la solution
  /************************************************************/
  public void init_solution() {
    int i, j;
    int[] solu = new int[6];
    for (i = 1; i <= 5; i++) {
      solu[i] = 0;
    }
    for (j = 1; j <= 5; j++) {
      do {
        i = (int) (Math.random() * 10);
      }
      while ( (i == 0) || (i == 9) || (i == solu[1]) || (i == solu[2]) ||
             (i == solu[3]) || (i == solu[4]) || (i == solu[5]));
      solu[j] = i;
      if (solu[j] == 1) {
        solution[j] = "rouge";
      }
      if (solu[j] == 2) {
        solution[j] = "vert";
      }
      if (solu[j] == 3) {
        solution[j] = "bleu";
      }
      if (solu[j] == 4) {
        solution[j] = "jaune";
      }
      if (solu[j] == 5) {
        solution[j] = "magenta";
      }
      if (solu[j] == 6) {
        solution[j] = "cyan";
      }
      if (solu[j] == 7) {
        solution[j] = "noir";
      }
      if (solu[j] == 8) {
        solution[j] = "blanc";
      }
    }
  }

  /************************************************************/
  // Fonction init() pour initialiser l'applet
  /************************************************************/
  public void init() {
    int x, y;
    init_solution();
// Configure la couleur de fond des boutons :
    bouton_rouge.setBackground(Color.red);
    bouton_vert.setBackground(Color.green);
    bouton_bleu.setBackground(Color.blue);
    bouton_jaune.setBackground(Color.yellow);
    bouton_magenta.setBackground(Color.magenta);
    bouton_cyan.setBackground(Color.cyan);
    bouton_noir.setBackground(Color.black);
    bouton_blanc.setBackground(Color.white);
// insère les boutons :
    add(bouton_gauche);
    add(bouton_droite);
    add(bouton_valider);
    add(bouton_montrer);
    add(bouton_rouge);
    add(bouton_vert);
    add(bouton_bleu);
    add(bouton_jaune);
    add(bouton_magenta);
    add(bouton_cyan);
    add(bouton_noir);
    add(bouton_blanc);
// connecte chaque bouton au gestionnaire d'évènement (Fonction ActionPerformed) :
    bouton_gauche.addActionListener(this);
    bouton_droite.addActionListener(this);
    bouton_valider.addActionListener(this);
    bouton_montrer.addActionListener(this);
    bouton_rouge.addActionListener(this);
    bouton_vert.addActionListener(this);
    bouton_bleu.addActionListener(this);
    bouton_jaune.addActionListener(this);
    bouton_magenta.addActionListener(this);
    bouton_cyan.addActionListener(this);
    bouton_noir.addActionListener(this);
    bouton_blanc.addActionListener(this);
    for (x = 1; x <= 5; x++) {
      for (y = 1; y <= 20; y++) {
        tab[x][y] = "";
        reponse[x][y] = 0;
      }
    }
  } // fin de la fonction init()

  /************************************************************/
  // Fonction paint()
  /************************************************************/
  public void paint(Graphics ecran) {
    int x, y, rayon, ecart;
    rayon = 15;
    ecart = 10;
    ecran.setColor(Color.black);
    for (x = 0; x < 5; x++) {
      for (y = 0; y < 20; y++) {
        ecran.drawOval(x * (rayon + ecart) + 70, y * (rayon + ecart) + 80,
                       rayon, rayon);
      }
    }
    rayon = 10;
    ecart = 15;
    for (x = 0; x < 5; x++) {
      for (y = 0; y < 20; y++) {
        ecran.drawOval(x * (rayon + 10) + 240, y * (rayon + ecart) + 80, rayon,
                       rayon);
      }
    }
    ecran.setColor(Color.red);
    ecran.fillArc(30, 548 - ligne_courante * 25, 60, 80, 200, -40);
    ecran.setColor(Color.red);
    ecran.fillArc(23 + colonne_courante * 25, 550, 60, 60, -70, -40);
    for (x = 1; x <= 5; x++) {
      for (y = 1; y <= 20; y++) {
        if (tab[x][y] != "") {
          if (tab[x][y] == "rouge") {
            ecran.setColor(Color.red);
          }
          else
          if (tab[x][y] == "vert") {
            ecran.setColor(Color.green);
          }
          else
          if (tab[x][y] == "bleu") {
            ecran.setColor(Color.blue);
          }
          else
          if (tab[x][y] == "jaune") {
            ecran.setColor(Color.yellow);
          }
          else
          if (tab[x][y] == "magenta") {
            ecran.setColor(Color.magenta);
          }
          else
          if (tab[x][y] == "cyan") {
            ecran.setColor(Color.cyan);
          }
          else
          if (tab[x][y] == "noir") {
            ecran.setColor(Color.black);
          }
          else
          if (tab[x][y] == "blanc") {
            ecran.setColor(Color.white);
          }
          ecran.fillOval( (x - 1) * 25 + 69,
                         (20 - y) * 25 + 79, 17, 17);
        }
      }
    }
    for (x = 1; x <= 5; x++) {
      for (y = 1; y <= 20; y++) {
        if (reponse[x][y] != 0) {
          if (reponse[x][y] == 2) {
            ecran.setColor(Color.red);
          }
          else
          if (reponse[x][y] == 1) {
            ecran.setColor(Color.white);
          }
          ecran.fillOval( (x - 1) * 20 + 239,
                         (20 - y) * 25 + 79, 12, 12);
        }
      }
    }
    if (montrer_solution) {
      for (x = 1; x <= 5; x++) {
        if (solution[x] == "rouge") {
          ecran.setColor(Color.red);
        }
        else
        if (solution[x] == "vert") {
          ecran.setColor(Color.green);
        }
        else
        if (solution[x] == "bleu") {
          ecran.setColor(Color.blue);
        }
        else
        if (solution[x] == "jaune") {
          ecran.setColor(Color.yellow);
        }
        else
        if (solution[x] == "magenta") {
          ecran.setColor(Color.magenta);
        }
        else
        if (solution[x] == "cyan") {
          ecran.setColor(Color.cyan);
        }
        else
        if (solution[x] == "noir") {
          ecran.setColor(Color.black);
        }
        else
        if (solution[x] == "blanc") {
          ecran.setColor(Color.white);
        }
        ecran.fillOval(x * 30 + 150, 610, 20, 20);
        ecran.setColor(Color.black);
        ecran.drawString("La solution est :", 205, 600);
      }
    }
    ecran.setColor(Color.red);
    ecran.drawString(
        "Cette applet JAVA a été réalisée par Jean-Christophe MICHEL", 20, 660);
    ecran.drawString("http://java.gecif.net", 130, 680);
  } // fin de la fonction paint()

  /************************************************************/
  /* Fonction ActionPerformed (ActionEvent) */
  /* Cette fonction ActionPerformed est le gestionnaire d'évènements */
  /************************************************************/
  public void actionPerformed(ActionEvent e) {
    Object source = e.getSource();
    if (source == bouton_gauche) { // Teste si le bouton 1 a été enfoncé
      colonne_courante = colonne_courante - 1;
      if (colonne_courante == 0) {
        colonne_courante = 5;
      }
    }
    else
    if (source == bouton_droite) { // Teste si le bouton 1 a été enfoncé
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_valider) { // Teste si le bouton 1 a été enfoncé
      tester_proposition();
    }
    else
    if (source == bouton_rouge) {
      tab[colonne_courante][ligne_courante] = "rouge";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_vert) {
      tab[colonne_courante][ligne_courante] = "vert";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_bleu) {
      tab[colonne_courante][ligne_courante] = "bleu";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_jaune) {
      tab[colonne_courante][ligne_courante] = "jaune";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_magenta) {
      tab[colonne_courante][ligne_courante] = "magenta";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_cyan) {
      tab[colonne_courante][ligne_courante] = "cyan";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_noir) {
      tab[colonne_courante][ligne_courante] = "noir";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_blanc) {
      this.tab[colonne_courante][ligne_courante] = "blanc";
      colonne_courante = colonne_courante + 1;
      if (colonne_courante == 6) {
        colonne_courante = 1;
      }
    }
    else
    if (source == bouton_montrer) {
      montrer_solution = !montrer_solution;
      if (montrer_solution) {
        bouton_montrer.setLabel("Cacher la solution");
      }
      else {
        bouton_montrer.setLabel("Montrer la solution");
      }
    }
    repaint();
  } // fin de la fonction ActionPerformed
} // fin de la classe

 


Site Internet : www.gecif.net

Auteur : Jean-Christophe MICHEL

Professeur de Sciences Industrielles de l'Ingénieur
option Informatique et Numérique

Courriel : jc.michel@gecif.net