449 lines
11 KiB
Java
449 lines
11 KiB
Java
import javax.swing.*;
|
|
import java.awt.*;
|
|
import java.util.Random;
|
|
import java.util.Arrays;
|
|
/**
|
|
* La classe <code>Grille</code> correspond à une grille de jeu
|
|
* elle genère un tableau de case et une Bannière
|
|
* @version 1.1
|
|
* @author Kayyissa Haïssous
|
|
*/
|
|
public class Grille extends JPanel{
|
|
/**
|
|
* Banniere
|
|
*/
|
|
private Banniere banniere;
|
|
/**
|
|
* Dimension de la grille
|
|
*/
|
|
private Dimension grilleSize=new Dimension(0,0);
|
|
/**
|
|
* tableau des cases de la partie
|
|
*/
|
|
private Case[] plateau;
|
|
/**
|
|
* nombre de colonnes
|
|
*/
|
|
private int colonnes;
|
|
/**
|
|
* nombre de lignes
|
|
*/
|
|
private int lignes;
|
|
/**
|
|
* nombre de cases
|
|
*/
|
|
private int taille;
|
|
/**
|
|
* nombre de mines
|
|
*/
|
|
private int mines;
|
|
/**
|
|
* nombre de mines restantes à trouver
|
|
*/
|
|
private int minesLeft;
|
|
/**
|
|
* statut si la partie est en cours ou non
|
|
*/
|
|
private boolean enJeu;
|
|
/**
|
|
* fenetre de Jeu
|
|
*/
|
|
private FrameJeu fenetre;
|
|
|
|
/**
|
|
* Définition du constructeur qui correspond à une nouvelle grille de jeu
|
|
* @param lignes nombre de lignes
|
|
* @param colonnes nombre de colonnes
|
|
* @param mines nombre de mines
|
|
* @param fenetre fenetre de Jeu
|
|
* @param menu fenetre du menu rattaché
|
|
*/
|
|
public Grille(int lignes, int colonnes, int mines, FrameJeu fenetre, FrameMenu menu){
|
|
super();
|
|
this.colonnes=colonnes;
|
|
this.lignes=lignes;
|
|
this.taille=lignes*colonnes;
|
|
this.mines=mines;
|
|
this.minesLeft=mines;
|
|
this.enJeu=true;
|
|
this.fenetre=fenetre;
|
|
|
|
// Découpage de l'espace en fonction des paramètres pour la mise en place de la grille
|
|
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
|
|
this.grilleSize = new Dimension(((screenSize.height*3/4)/lignes)*colonnes, screenSize.height*3/4 );
|
|
Dimension caseSize = new Dimension(this.grilleSize.height/lignes,this.grilleSize.height/lignes);
|
|
GridLayout damier = new GridLayout(lignes,colonnes);
|
|
Banniere banniere = new Banniere(mines,this.fenetre, menu, this);
|
|
this.banniere=banniere;
|
|
this.setLayout(damier);
|
|
this.setSize(grilleSize);
|
|
|
|
// On génère le plateau contenant les cases
|
|
GenererPlateau(caseSize);
|
|
|
|
|
|
// Instalation des mines
|
|
// Création d'un tableau de nombres aléatoires pour savoir où les placer
|
|
int[] caseMine = new int[mines];
|
|
Random rand = new Random();
|
|
// On initialise les emplacements des mines
|
|
caseMine[0] = rand.nextInt(taille);
|
|
for (int i=1;i<mines;i++){
|
|
caseMine[i] = rand.nextInt(taille);
|
|
// On vérifie que la case n'a pas déjà été minée, auquel cas on change de case
|
|
for (int j=0;j<=(i-1);j++){
|
|
if (caseMine[i]==caseMine[j]){
|
|
caseMine[i] = rand.nextInt(taille);
|
|
j=-1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// On place maintenant les mines sur la plateau en fixant la variable minee des cases à true
|
|
for (int i=0; i<taille;i++){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i){
|
|
plateau[i].setMine();
|
|
}
|
|
}
|
|
}
|
|
|
|
// On défini l'entourage de chaque case
|
|
SetEntourage(caseMine);
|
|
|
|
// On place les cases à leur état actuel dans la grille
|
|
AfficherPlateau();
|
|
|
|
// On initialise le compteur de mines restantes
|
|
this.banniere.setMinesLeft(this.minesLeft);
|
|
}
|
|
|
|
|
|
/**
|
|
* Définition du constructeur qui correspond au chargement d'une grille sauvegardé
|
|
* @param lignes nombre de lignes
|
|
* @param colonnes nombre de colonnes
|
|
* @param donnees sauvegarde
|
|
* @param mines nombre de mines
|
|
* @param fenetre fenetre de Jeu
|
|
* @param menu fenetre du menu rattaché
|
|
*/
|
|
public Grille (int lignes,int colonnes,SaveManager.SaveData donnees,int mines,FrameJeu fenetre, FrameMenu menu){
|
|
super();
|
|
this.colonnes=colonnes;
|
|
this.lignes=lignes;
|
|
this.taille=lignes*colonnes;
|
|
this.mines=mines;
|
|
this.minesLeft=mines;
|
|
this.enJeu=true;
|
|
this.fenetre=fenetre;
|
|
|
|
// Découpage de l'espace en fonction des paramètres pour la mise en place de la grille
|
|
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
|
|
this.grilleSize = new Dimension(((screenSize.height*3/4)/lignes)*colonnes, screenSize.height*3/4 );
|
|
Dimension caseSize = new Dimension(this.grilleSize.height/lignes,this.grilleSize.height/lignes);
|
|
GridLayout damier = new GridLayout(lignes,colonnes);
|
|
Banniere banniere = new Banniere(mines,this.fenetre, menu, this);
|
|
this.banniere=banniere;
|
|
this.setLayout(damier);
|
|
this.setSize(grilleSize);
|
|
|
|
// On initialise un plateau de cases
|
|
GenererPlateau(caseSize);
|
|
|
|
// On créer un tableau pour y placer les cases minées
|
|
int[] caseMine = new int[mines];
|
|
int j=0;
|
|
// On lit maintenant les données pour fixer certains attributs et savoir où sont les mines
|
|
for (int i=0;i<=taille-1;i++){
|
|
if (Integer.parseInt(donnees.cases.substring(i,i+1))==1){
|
|
plateau[i].setMine();
|
|
caseMine[j]=i;
|
|
j++;
|
|
} else if (Integer.parseInt(donnees.cases.substring(i,i+1))==2){
|
|
plateau[i].setReperee(true,1);
|
|
} else if (Integer.parseInt(donnees.cases.substring(i,i+1))==3){
|
|
plateau[i].setMine();
|
|
caseMine[j]=i;
|
|
j++;
|
|
plateau[i].setReperee(true,1);
|
|
}
|
|
}
|
|
|
|
// On détermine l'entourage de chaque case
|
|
SetEntourage(caseMine);
|
|
|
|
|
|
// On affiche les cases qui doivent être visibles
|
|
for (int n=0;n<=taille-1;n++){
|
|
if (Integer.parseInt(donnees.cases.substring(n,n+1))==4){
|
|
plateau[n].setVisible();
|
|
}
|
|
}
|
|
|
|
// On affiche la grille
|
|
AfficherPlateau();
|
|
|
|
// On initialise le compteur de mines restantes
|
|
this.banniere.setMinesLeft(this.minesLeft);
|
|
}
|
|
|
|
/**
|
|
*Méthode pour Génerer le plateau
|
|
* @param caseSize taille d'une case
|
|
*/
|
|
protected void GenererPlateau(Dimension caseSize){
|
|
this.plateau= new Case[this.taille];
|
|
for (int i=0;i<this.taille;i++){
|
|
this.plateau[i]= new Case(this,caseSize);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*Méthode pour Afficher le plateau
|
|
*/
|
|
protected void AfficherPlateau(){
|
|
for (int i=0;i<this.taille;i++){
|
|
this.add(this.plateau[i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
*Méthode pour établir le nombre de mines autour de chaque case
|
|
* @param caseMine tableau des cases minées
|
|
*/
|
|
protected void SetEntourage(int[] caseMine){
|
|
// On cherche à connaître le nombre de mines autour de chaque case
|
|
for (int i=0;i<taille;i++){
|
|
int entourage = 0;
|
|
// On vérifie pour chaque case qu'elle n'est pas déjà à l'extrémité du plateau où on cherche une case
|
|
// Mine au dessus à droite
|
|
if ((i>=colonnes)&&(i%colonnes!=colonnes-1)){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i-colonnes+1){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine au dessus à gauche
|
|
if ((i>=colonnes)&&(i%colonnes!=0)){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i-colonnes-1){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine en dessous à droite
|
|
if ((i<taille-colonnes)&&(i%colonnes!=colonnes-1)){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i+colonnes+1){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine en bas à gauche
|
|
if ((i<taille-colonnes)&&(i%colonnes!=0)){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i+colonnes-1){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine au dessus
|
|
if (i>=colonnes){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i-colonnes){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine en dessous
|
|
if (i<taille-colonnes){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i+colonnes){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine à droite
|
|
if (i%colonnes!=colonnes-1){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i+1){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
// Mine à gauche
|
|
if (i%colonnes!=0){
|
|
for (int j=0;j<mines;j++){
|
|
if (caseMine[j]==i-1){
|
|
entourage+=1;
|
|
}
|
|
}
|
|
}
|
|
plateau[i].setEntourage(entourage);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Méthode pour obtenir la taille de la grille de jeu
|
|
* @return grilleSize
|
|
*/
|
|
public Dimension getGrilleSize(){
|
|
return grilleSize;
|
|
}
|
|
|
|
|
|
/**
|
|
*Méthode déterminant le nombre de mines restantes
|
|
*/
|
|
public void MinesLeft(){
|
|
this.minesLeft=this.mines;
|
|
for (int i=0;i<this.taille;i++){
|
|
if(plateau[i].getReperee()==true){
|
|
this.minesLeft-=1;
|
|
}
|
|
}
|
|
this.banniere.setMinesLeft(this.minesLeft);
|
|
}
|
|
|
|
/**
|
|
*Méthode déterminant les conditions de victoire
|
|
*/
|
|
public void verifVictoire(){
|
|
// Compte le nombre de cases visibles
|
|
int casesVisibles=0;
|
|
for (int i=0;i<this.taille;i++){
|
|
if(plateau[i].getVisible()==true){
|
|
casesVisibles+=1;
|
|
}
|
|
}
|
|
// Lance la victoire si toutes les cases non minées sont révélées
|
|
if (taille-mines==casesVisibles){
|
|
for (int i=0;i<taille;i++){
|
|
this.plateau[i].setVictoire();
|
|
}
|
|
this.banniere.setVictoire();
|
|
}
|
|
}
|
|
|
|
/**
|
|
*Méthode pour montrer la défaite
|
|
*/
|
|
public void Defaite(){
|
|
// Montre toutes les cases du plateau
|
|
for (int i=0;i<this.taille;i++){
|
|
this.plateau[i].setVisible();
|
|
}
|
|
this.banniere.setDefaite();
|
|
}
|
|
|
|
/**
|
|
* Methode pour récupérer le plateau de jeu
|
|
* @return copie du tableau de cases
|
|
*/
|
|
public Case[] getPlateau(){
|
|
return Arrays.copyOf(this.plateau,this.taille);
|
|
}
|
|
|
|
/**
|
|
*Méthode pour récupérer la taille de la grille
|
|
* @return la taille de la grille
|
|
*/
|
|
public Dimension getDimensionGrille(){
|
|
Dimension grilleSize= new Dimension(this.colonnes, this.lignes);
|
|
return grilleSize;
|
|
}
|
|
|
|
/**
|
|
*Méthode pour savoir combien de mines sont dans la grille
|
|
* @return this.mines le nombre de mines
|
|
*/
|
|
public int getMines(){
|
|
return this.mines;
|
|
}
|
|
|
|
/**
|
|
*Méthode pour rendre visibles les cases autour d'un 0
|
|
* @param panel case autour de laquelle il faut révéler les cases
|
|
*/
|
|
public void setEntourageVisible(Case panel){
|
|
for(int i=0; i<this.taille;i++){
|
|
if (plateau[i]==panel){
|
|
// Mine au dessus à droite
|
|
if ((i>=colonnes)&&(i%colonnes!=colonnes-1)){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i-colonnes+1].setVisible();
|
|
}
|
|
}
|
|
// Mine au dessus à gauche
|
|
if ((i>=colonnes)&&(i%colonnes!=0)){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i-colonnes-1].setVisible();
|
|
}
|
|
}
|
|
// Mine en dessous à droite
|
|
if ((i<taille-colonnes)&&(i%colonnes!=colonnes-1)){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i+colonnes+1].setVisible();
|
|
}
|
|
}
|
|
// Mine en bas à gauche
|
|
if ((i<taille-colonnes)&&(i%colonnes!=0)){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i+colonnes-1].setVisible();
|
|
}
|
|
}
|
|
// Mine au dessus
|
|
if (i>=colonnes){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i-colonnes].setVisible();
|
|
}
|
|
}
|
|
// Mine en dessous
|
|
if (i<taille-colonnes){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i+colonnes].setVisible();
|
|
}
|
|
}
|
|
// Mine à droite
|
|
if (i%colonnes!=colonnes-1){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i+1].setVisible();
|
|
}
|
|
}
|
|
// Mine à gauche
|
|
if (i%colonnes!=0){
|
|
for (int j=0;j<mines;j++){
|
|
plateau[i-1].setVisible();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*Méthode qui renvoie la banniere d'état de la partie
|
|
* @return this.banniere
|
|
*/
|
|
public Banniere getBanniere(){
|
|
return this.banniere;
|
|
}
|
|
|
|
/**
|
|
*Méthode qui défini si la partie est en cours ou non
|
|
* @param enJeu statut de la partie
|
|
*/
|
|
public void setEnJeu(boolean enJeu){
|
|
this.enJeu=enJeu;
|
|
}
|
|
|
|
/**
|
|
*Méthode qui renvoie si la partie est en cours ou non
|
|
* @return statut enjeu
|
|
*/
|
|
public boolean getEnJeu(){
|
|
return this.enJeu;
|
|
}
|
|
}
|