Démineur

// Votre package
package module_631;

import java.util.Scanner;

/**
 * @author Reksy ||Tiago Almeida
 */
public class module_631 {

    /**
     * @param args the command line arguments
     */


 public static final char bombe = 9;


    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //déclarationde variables

        int randLigne, randCollone, cpt;    //variables de génération du tableau
        int maxLigne = 10;                  //Nombre  de lignes pour notre carte
        int maxCollone = 10;                //Nombre de Collones pour notre Carte
        int nbrBombes = 10;                 //Nombre de bombes dans la carte


        // Initialisation de la matrice qui nous servira de Carte
        int tableau[][] = new int[maxLigne][maxCollone];



  System.out.println("BIENVENU AU SUPER MINI-DEMINEUR !!!");
  System.out.println();


        //PLACEMENT DES BOMBES
        cpt = 0;
        while (cpt < nbrBombes) {

            //Création aléatoire de l'endroit où nous plaçons nos bombes
            randLigne = (int) (Math.random() * (maxLigne));
            randCollone = (int) (Math.random() * (maxCollone));


            // Si la case ne contien pas de bombe on en met une puis on incrémente notre compteur de bombes
            if (tableau[randLigne][randCollone] != bombe) {
                tableau[randLigne][randCollone] = bombe;
                cpt++;

            }
        }

        //REMPLISSAGE DES INDICATEURS DE BOMBES

        //Boucle sur les lignes
        for (int li = 0; li < maxLigne; li++) {

             //Boucle sur les collones
            for (int col = 0; col < maxCollone; col++) {

                //ON controle que la case ne contienne déja une bombe
                if (tableau[li][col] != bombe) {
                    tableau[li][col] = remplirChamp(li, maxLigne, col, maxCollone, tableau);
                }
            };
        };



        //AFFICHAGE DU RESULTAT

        //Boucle sur les lignes
        for (int li = 0; li < maxLigne; li++) {

            //Boucles sur les collones
            for (int col = 0; col < maxCollone; col++) {

                //Nous affichons un * s'il s'agit d'une bombe
                if(tableau[li][col]==bombe){
                    System.out.print('*');
                }else{
                    System.out.print(tableau[li][col]);
                }
            };

            //Retour a la ligne lorsqu'on change de ligne
            System.out.println();
        };

        //Notre mini-démineur est poli
        System.out.println("En vous souhaitant une bonne journée !!!");
    }



    /*
    *  Fonction qui défini le minimum entre une variable A et une variable B
    * @ prend en parametre des valeurs entieres
    * @ retourn la valeur plus petite
    */
    public static int minimum(int a, int b) {

        int min = 0;

        if (a < b) {
            min = a;
        } else {
            min = b;
        }

        // retourne la valeur la plus petite des deux valeurs entre a et b
        return min;

    };


    /*
    *  Fonction qui situe puis controle si la case existe si c'est le cas on incremente une variable resultat qui retourne le nombre de bombes qui adjacente une case.
    * @ prend en parametre des int et une matrice tableau
    * @ retourn le nombre de bombes qui entourent la case
    */
    public static int remplirChamp(int ligne, int maxLigne, int collone, int maxCollone, int[][] tableau) {


        // variables locales
        int resultat = 0;
        int droite, gauche, bas, haut, hautGauche, hautDroite, basGauche,basDroite;


        // Nous situons notre case par rapport à toutes les directions, c'est à dire combien de cases il y a à gauche , droite , haut , bas etc par rapport à la matrice.
        droite= calculCellules(collone + 1, maxCollone, true);
        gauche = calculCellules(collone + 1, maxCollone, false);
        bas = calculCellules(ligne + 1, maxLigne, true);
        haut = calculCellules(ligne + 1, maxLigne, false);

        // Nous définissons le minimum entre directions pour avoir la limite de jusqu'ou on peut aller dans la direction donnée
        hautGauche=minimum(haut,gauche);
        hautDroite=minimum(haut,droite);
        basGauche=minimum(bas,gauche);
        basDroite=minimum(bas,droite);


        //Nous controllons qu'il y aie des cases qui existent à gauche
        if (gauche > 0  ) {
            // Nous controlons s'il y a une bombe à gauche à l'aide de la méthode  "estAdjacentBombe"
            if (estAdjacentBombe(ligne, 0, collone, -1, tableau)) {
                //Si la bombe existe nous incrémentons la valeur résultat
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (droite > 0  ) {
            if (estAdjacentBombe(ligne, 0, collone, 1, tableau)) {
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (bas > 0  ) {
            if (estAdjacentBombe(ligne, 1, collone, 0, tableau)) {
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (haut > 0  ) {
            if (estAdjacentBombe(ligne, -1, collone, 0, tableau)) {
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (hautGauche > 0  ) {
            if (estAdjacentBombe(ligne, -1, collone, -1, tableau)) {
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (hautDroite > 0  ) {
            if (estAdjacentBombe(ligne, -1, collone, 1, tableau)) {
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (basDroite > 0  ) {
            if (estAdjacentBombe(ligne, 1, collone, 1, tableau)) {
                resultat++;
            }

        }

        //Même principe que la portion de code "Gauche"
        if (basGauche > 0  ) {
            if (estAdjacentBombe(ligne, 1, collone, -1, tableau)) {
                resultat++;
            }

        }
        return resultat;

    }
    /*
    *  Fonction qui controle si la case située a
    * @ prend en parametre les coordonnées de base de la cellule, puis les coordonnées de la cellule qu'on doit controler et finalement le tableau à deux dimentions
    * @ retourn un boolean qui indique si la case visée contient ou pas une bombe
    */
    public static boolean estAdjacentBombe(int xBase, int positionX, int yBase, int positionY, int[][] tableau) {
        boolean boolAdjacent = false;

        // Nous changeons la valeur de booladjacent à true si la case visée contient une bombe
            if(tableau[((int) (xBase + positionX))][(int) (yBase + positionY)]==bombe){
                boolAdjacent=true;
            }

            //Nous retournons le résultat du controle
        return boolAdjacent;

    }

    /*
    *  Fonction qui retourne le nombre de collones ou lignes par rapport aux bords
    *
    */
    public static int calculCellules(int currentCol, int nbrCol, boolean positif) {


        //Initialisation de la variable local
        int nbrCollones = 0;


        // J'entends par positif la droite pour les collones  ou le bas pour les lignes
        if (positif) {
            nbrCollones = nbrCol - currentCol;
        } else {

            nbrCollones = nbrCol - (nbrCol - currentCol);

            if (nbrCollones >= 0) {
                nbrCollones--;
            }
        }

        //Nous retournons notre valeur final
        return nbrCollones;

    }

};