475 lines
16 KiB
Java
475 lines
16 KiB
Java
//Tom Monin et Clément Martins
|
|
//Class pour des fonction static de jeu
|
|
//V2
|
|
|
|
import java.io.*;
|
|
import java.util.*;
|
|
import java.awt.event.*;
|
|
import java.io.ObjectOutputStream;
|
|
import java.awt.*;
|
|
import javax.swing.*;
|
|
|
|
public class plateau{
|
|
private paintMenuJeu logo;
|
|
private JFrame fenetre;
|
|
private observateurSAV observateur;
|
|
private int ligne, collonne, bombe;
|
|
private paintMenuJeu[] tabScore= new paintMenuJeu[3];
|
|
private Case[][] tableau;
|
|
public plateau(JFrame fenetre0){
|
|
this.fenetre=fenetre0;
|
|
this.ligne=-1;
|
|
this.collonne=-1;
|
|
this.bombe=0;
|
|
}
|
|
public void setLogo(paintMenuJeu logo0){
|
|
this.logo=logo0;
|
|
}
|
|
public void setObservateur(observateurSAV observateur0){
|
|
this.observateur=observateur0;
|
|
}
|
|
public int getLigne(){
|
|
return this.ligne;
|
|
}
|
|
public int getCollonne(){
|
|
return this.collonne;
|
|
}
|
|
public int getBombe(){
|
|
return this.bombe;
|
|
}
|
|
public JFrame getFenetre(){
|
|
return this.fenetre;
|
|
}
|
|
public void setCollonne(int n){
|
|
this.collonne=n;
|
|
}
|
|
public void setLigne(int n){
|
|
this.ligne=n;
|
|
}
|
|
public void setBombe(int n){
|
|
this.bombe=n;
|
|
}
|
|
//-------------------------Fonction plaçant les bombes aléatoirement------------------------
|
|
|
|
private void setAllBombe(){
|
|
Random rand = new Random();
|
|
//on répète le nombre de fois le nombre de bombe a placer
|
|
for(int i=0; i<this.bombe; i++){
|
|
//on genere 2 chiffre aléatoire(ligne et collonne)
|
|
int x=rand.nextInt(this.ligne);
|
|
int y=rand.nextInt(this.collonne);
|
|
//si il n'y a pas de bombe ici
|
|
if(this.tableau[x][y].getBombe()==false){
|
|
//on en place une
|
|
this.tableau[x][y].setBombe();
|
|
}else{
|
|
//autrement nous recomencerons 1 fois de plus le tirage pour ne pas modifier le nombre de bombe
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
//-------------------------Fonction mettant le nombre de bombe voisin a chaque Case------------------
|
|
|
|
public void setAllVoisin(){
|
|
//nous parcourons le tableau du jeu
|
|
for(int i=0; i<this.tableau.length; i++){
|
|
for(int t=0; t<this.tableau[i].length; t++){
|
|
int voisin=0;
|
|
//nous regardons dans les cases adjacentes(si elles existe) si elle sont des bombes
|
|
if(i>0){
|
|
if(this.tableau[i-1][t].getBombe()==true){
|
|
//si elle le sont alors nous augmentons le nombre de voisin
|
|
voisin++;
|
|
}
|
|
if(t>0){
|
|
if(this.tableau[i-1][t-1].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
}
|
|
if(t<this.tableau[i].length-1){
|
|
if(this.tableau[i-1][t+1].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
}
|
|
}
|
|
if(i<this.tableau.length-1){
|
|
if(this.tableau[i+1][t].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
if(t>0){
|
|
if(this.tableau[i+1][t-1].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
}
|
|
if(t<this.tableau[i].length-1){
|
|
if(this.tableau[i+1][t+1].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
}
|
|
}
|
|
if(t>0){
|
|
if(this.tableau[i][t-1].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
}
|
|
if(t<this.tableau[i].length-1){
|
|
if(this.tableau[i][t+1].getBombe()==true){
|
|
voisin++;
|
|
}
|
|
}
|
|
//finalement nous mettons pour cette case sont nombre de voisin
|
|
this.tableau[i][t].setVoisin(voisin);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------Fonction qui verifie l'etat de jeu(perdu, gagner)------------------------
|
|
|
|
public int etatDeVictoire(){
|
|
//variable pour une condition
|
|
int condition=0;
|
|
//nous parcourons le tableau du jeu
|
|
for(int i=0; i<this.tableau.length; i++){
|
|
for(int t=0; t<this.tableau[i].length; t++){
|
|
//si une case n'est pas visible mais que ce n'est pas une bombe
|
|
if(this.tableau[i][t].getVisibiliter()==false && this.tableau[i][t].getBombe()==false){
|
|
//nous augmentons la conditions pour montrer que la partie est toujour en cours
|
|
condition++;
|
|
}
|
|
//si une bombe est visible
|
|
if(this.tableau[i][t].getVisibiliter()==true && this.tableau[i][t].getBombe()==true){
|
|
// le joueur a perdu
|
|
this.removeListener();
|
|
this.perdu();
|
|
//on retourne une valeur représentant la défaite: -1
|
|
return -1;
|
|
}
|
|
//si une bombe n'est pas susposer comme tel
|
|
if(this.tableau[i][t].getSuspition()!=1 && this.tableau[i][t].getBombe()==true){
|
|
//nous augmentons la conditions pour montrer que la partie n'est pas fini
|
|
condition++;
|
|
}
|
|
}
|
|
}
|
|
//si la partie n'est pas fini
|
|
if(condition>0){
|
|
//on retourne 0 ici comme une valleur null
|
|
return 0;
|
|
}
|
|
// le joueur a gagner
|
|
this.removeListener();
|
|
this.gagner();
|
|
//sinon le joueur a donc gagner on renvoie 1
|
|
return 1;
|
|
}
|
|
//-----------------------------------Fonction après victoire/defaite pour enlever les observateur a chaque Case--------------------------------
|
|
|
|
private void removeListener(){
|
|
//on parcour le tableau du jeu
|
|
for(int i=0; i<this.tableau.length; i++){
|
|
for(int t=0; t<this.tableau[i].length; t++){
|
|
//on récupere le tableau d'observateur
|
|
MouseListener[] tabListener;
|
|
tabListener=this.tableau[i][t].getMouseListeners();
|
|
//que nous parcourons
|
|
for(int longeur=0; longeur<=tabListener.length-1; longeur++){
|
|
//on enleve a chaque case les observateur 1 par 1
|
|
this.tableau[i][t].removeMouseListener(tabListener[longeur]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//-------------------------------------Fonction des modification a faire si le joeur a perdu-------------------------------------
|
|
private void perdu(){
|
|
//on modifie l'affichage du menu du haut par le choix 5(tete rouge)
|
|
for(int i=0; i<tabScore.length; i++){
|
|
this.tabScore[i].setChoix(5);
|
|
}
|
|
//puis nous affichons toutes les case pour que le joueur puisse voir la grille
|
|
for(int i=0;i<this.tableau.length;i++){
|
|
for(int t=0;t<this.tableau[i].length;t++){
|
|
this.tableau[i][t].setVisibiliter(true);
|
|
this.tableau[i][t].repaint();
|
|
}
|
|
}
|
|
//enfin nous affichons le logo rejouer
|
|
this.paintLogo();
|
|
}
|
|
//-------------------------------------Fonction des modification a faire si le joeur a gagner-------------------------------------
|
|
private void gagner(){
|
|
//on modifie l'affichage du menu du haut par le choix 6(tete vert)
|
|
for(int i=0; i<tabScore.length; i++){
|
|
this.tabScore[i].setChoix(6);
|
|
}
|
|
//nous affichons le logo rejouer
|
|
this.paintLogo();
|
|
}
|
|
//-------------------------------------Fonction pour modifier le Score des bombes restantes--------------------------------------
|
|
public void setScore(int n){
|
|
//on parcoure le menu du haut avec le score et nous lui ajoutons l'entier entrée dans l'apel
|
|
for(int i=0; i<tabScore.length; i++){
|
|
tabScore[i].setScore(tabScore[i].getScore()+n);
|
|
}
|
|
}
|
|
//------------------------------------> Fonction pour afficher le logo rejouer <----------------------------
|
|
private void paintLogo(){
|
|
//on modifie l'aspect de l'ancien logo
|
|
this.logo.setChoix(7);
|
|
//et la fonction de son observateur
|
|
this.observateur.setFonction(true);
|
|
}
|
|
|
|
//------------------------------------> Fonction pour lancer une nouvelle partie <-----------------------
|
|
|
|
public void newGame(){
|
|
//initialisation du tableau de Case
|
|
this.tableau=new Case[ligne][collonne];
|
|
for(int i=0; i<ligne; i++){
|
|
for(int t=0; t<collonne; t++){
|
|
this.tableau[i][t]= new Case();
|
|
this.tableau[i][t].setPreferredSize(new Dimension(100,100));
|
|
//nous ajoutons aussi a chaque case son observateur de case
|
|
}
|
|
}
|
|
//nous disposons les bombe dans le jeu
|
|
this.setAllBombe();
|
|
//maitenant que les bombe sont mise nous pouvons modifier le nombre de voisin des cases
|
|
this.setAllVoisin();
|
|
//on lance la partie avec le tableau de Case initialiser et le nombre de bombe en score(aucune Case n'est encore suspecter)
|
|
this.launchGame(this.bombe);
|
|
}
|
|
|
|
//------------------------------------> Fonction pour sauvegarder la partie <-------------------------
|
|
|
|
public void save(){
|
|
//les fonctions vont lever des Exeption nous devons donc mettre un try Catch
|
|
try{
|
|
//nous initialison le outputStream en créant le fichier "sauvegarde.data"
|
|
FileOutputStream sav = new FileOutputStream(new File("sauvegarde.data"));
|
|
//nous allons sérialiser le tableau de Case
|
|
ObjectOutputStream oos = new ObjectOutputStream(sav);
|
|
//nous écrivons donc tout d'abord la taille de celui-ci
|
|
oos.writeInt(this.ligne);
|
|
oos.writeInt(this.collonne);
|
|
//puis nous parcourons le tableau en sérialisant toute les Case
|
|
for(int i=0; i<this.ligne; i++){
|
|
for(int t=0; t<this.collonne; t++){
|
|
oos.writeObject(this.tableau[i][t]);
|
|
}
|
|
}
|
|
//nous écrivons ensuite le score Maximum(nombre de bombe) pour éviter de regarder toutes les Case plus tard
|
|
oos.writeInt(this.tabScore[0].getScoreMax());
|
|
//puis le score a l'instant T
|
|
oos.writeInt(this.tabScore[0].getScore());
|
|
//nous fermons la sauvegardes
|
|
oos.close();
|
|
sav.close();
|
|
}catch(FileNotFoundException e1){
|
|
}catch(IOException e2){
|
|
}
|
|
//nous fermons la fenetre et donc arrêtons l'applications
|
|
this.fenetre.dispose();
|
|
|
|
}
|
|
public void reprendrePartie(FileInputStream file){
|
|
//initialisation de la variable score
|
|
int score=0;
|
|
//les fonctions vont lever des Exeption nous devons donc mettre un try Catch
|
|
try{
|
|
//création de l'objet pour lire le fichier donner
|
|
ObjectInputStream ois = new ObjectInputStream(file);
|
|
//initialisation des collonnes avec le fichier
|
|
this.ligne=ois.readInt();
|
|
this.collonne=ois.readInt();
|
|
//on crée le tableau de Case avec les bonnes dimention
|
|
this.tableau=new Case[this.ligne][this.collonne];
|
|
//on parcoure celui-ci et remettons les Case avec la sauvegarde
|
|
for(int i=0; i<ligne; i++){
|
|
for(int t=0; t<collonne; t++){
|
|
this.tableau[i][t]=(Case) ois.readObject();
|
|
}
|
|
}
|
|
//nous initialison maintenant le nombre de bombe
|
|
this.bombe=ois.readInt();
|
|
//puis le score
|
|
score=ois.readInt();
|
|
}catch(IOException e2){
|
|
}catch(ClassNotFoundException e3){
|
|
}
|
|
//nous pouvons maintenant lancer la partie sauvegarder
|
|
this.launchGame(score);
|
|
}
|
|
//----------------------------------------> Fonction pour Lancer une partie <--------------------------------------
|
|
|
|
private void launchGame(int score){
|
|
//on ferme l'ancienne fenetre
|
|
this.fenetre.dispose();
|
|
//on en crée une nouvelles
|
|
this.fenetre=new JFrame("démineur");
|
|
// l'application se fermera que si on ferme la fenetre
|
|
this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
//on l'affiche
|
|
this.fenetre.setVisible(true);
|
|
//on ajoute son observateur (pour savegarder la partie si on ferme la fenetre)
|
|
this.fenetre.addWindowListener(new observateurFenetre(this));
|
|
this.fenetre.setBackground(new Color(0,0,0));
|
|
JPanel panJeu = new JPanel();
|
|
JPanel panMenu = new JPanel();
|
|
panJeu.setBackground(new Color(0,0,0));
|
|
panMenu.setBackground(new Color(0,0,0));
|
|
//on met un gestionaires de mise en page grille avec le nombre de ligne+1 (pour le menu en haut) et le nombre de collonne
|
|
panJeu.setLayout(new GridLayout(this.ligne,this.collonne));
|
|
panMenu.setLayout(new GridLayout(1, 7));
|
|
//on met en place le menu du haut et donc toute la première ligne
|
|
for(int i=0; i<10; i++){
|
|
paintMenuJeu menu= new paintMenuJeu(0, score, bombe);
|
|
//nous mettons des dimensions convenable pour des Case
|
|
menu.setPreferredSize(new Dimension(50,50));
|
|
//les 3 premières case serons consacrés au score
|
|
if(i==0){
|
|
this.tabScore[0]=menu;
|
|
menu.setChoix(1);
|
|
}
|
|
if(i==1){
|
|
this.tabScore[1]=menu;
|
|
menu.setChoix(2);
|
|
}
|
|
if(i==2){
|
|
this.tabScore[2]=menu;
|
|
menu.setChoix(3);
|
|
}
|
|
//et la derniere au logo
|
|
if(i==9){
|
|
menu.setChoix(4);
|
|
this.setLogo(menu);
|
|
observateurSAV observateur=new observateurSAV(menu, this);
|
|
menu.addMouseListener(observateur);
|
|
this.setObservateur(observateur);
|
|
}
|
|
//sinon le composant sera juste sobre
|
|
panMenu.add(menu);
|
|
}
|
|
//on ajoute ensuite toutes les Case a la fenetre
|
|
for(int i=0; i<ligne; i++){
|
|
for(int t=0;t<collonne; t++){
|
|
panJeu.add(this.tableau[i][t]);
|
|
this.tableau[i][t].addMouseListener(new observateurCase(i, t, this.tableau, this));
|
|
}
|
|
}
|
|
this.fenetre.add(panMenu, BorderLayout.NORTH);
|
|
this.fenetre.add(panJeu, BorderLayout.CENTER);
|
|
//on ajuste la taille de la fenetre a son contenu
|
|
this.fenetre.pack();
|
|
}
|
|
//---------------------> Fonction d'affichage du menu pour le Choix des Ligne, Collonne et Bombe <-----------------------------
|
|
public void menuChoixLCB(){
|
|
//nous fermons l'ancienne fenetre
|
|
this.fenetre.dispose();
|
|
//créons une nouvelle
|
|
this.fenetre= new JFrame("démineur");
|
|
this.fenetre.setLocation(0,0);
|
|
this.fenetre.setSize(1600, 1000);
|
|
this.fenetre.setVisible(true);
|
|
this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
//nous utiliserons un gestionnaires avec 27 ligne(de 4 a 30 ligne/collonne) et 3 collonne
|
|
fenetre.setLayout(new GridLayout(27,3));
|
|
//initialisation des objet utiliser par des observateur plus tard
|
|
paintChoix retenue= new paintChoix(-1, -1);
|
|
paintChoix premier= new paintChoix(-1, -1);
|
|
paintChoix retenue2= new paintChoix(-1, -1);
|
|
paintChoix premier2= new paintChoix(-1, -1);
|
|
JLabel texte1 = new JLabel("ligne: ???");
|
|
JLabel texte2 = new JLabel("collonne: ???");
|
|
//aligment Central plus estetique
|
|
texte1.setHorizontalAlignment(JLabel.CENTER);
|
|
texte2.setHorizontalAlignment(JLabel.CENTER);
|
|
JTextField nbombe = new JTextField("????");
|
|
//nous ajoutons les Case
|
|
for(int i=0; i<27; i++){
|
|
//creons les composant
|
|
paintChoix pinceau = new paintChoix(i, 1);
|
|
paintChoix pinceau2 = new paintChoix(i, 2);
|
|
if(i==0){
|
|
//si c'est la première Case alors ça sera la première pour sa ligne
|
|
premier=pinceau;
|
|
premier2=pinceau2;
|
|
}
|
|
//nous leurs ajoutons un observateur
|
|
pinceau.addMouseListener(new observateurChoix(pinceau, premier, texte1, this));
|
|
pinceau2.addMouseListener(new observateurChoix(pinceau2, premier2, texte2, this));
|
|
//positionons la retenue sur le nouveau pinceau
|
|
retenue.setPaintChoix(pinceau);
|
|
retenue=pinceau;
|
|
retenue2.setPaintChoix(pinceau2);
|
|
retenue2=pinceau2;
|
|
//nous ajoutons la première case sur la collonne 1
|
|
this.fenetre.add(pinceau);
|
|
//la dexième collonne dependra de sa hauteur dans la ligne
|
|
if(i==10){
|
|
//texte sur les lignes
|
|
this.fenetre.add(texte1);
|
|
}
|
|
if(i==12){
|
|
//texte sur les collonnes
|
|
this.fenetre.add(texte2);
|
|
}if(i==26){
|
|
//si c'est la dernière ligne, boutons valider
|
|
JButton valider = new JButton("valider");
|
|
valider.addActionListener(new observateurButtonEtText(this, 2, nbombe));
|
|
this.fenetre.add(valider);
|
|
}if(i==17){
|
|
//boutons plus
|
|
JButton plus = new JButton("+");
|
|
plus.addActionListener(new plusoumoins(nbombe, 1, this));
|
|
this.fenetre.add(plus);
|
|
}if(i==18){
|
|
//texteArea qui représente le nombre de bombe
|
|
nbombe.setHorizontalAlignment(JLabel.CENTER);
|
|
nbombe.addActionListener(new observateurButtonEtText(this, 1, nbombe));
|
|
this.fenetre.add(nbombe);
|
|
}if(i==19){
|
|
//boutons moins
|
|
JButton moins = new JButton("-");
|
|
moins.addActionListener(new plusoumoins(nbombe, -1, this));
|
|
this.fenetre.add(moins);
|
|
}if(i==16){
|
|
//juste le texte
|
|
JLabel texte3 = new JLabel("Nombre de Bombe");
|
|
texte3.setHorizontalAlignment(JLabel.CENTER);
|
|
this.fenetre.add(texte3);
|
|
}if(i!=10 && i!=12 && i!=26 && i!=17 && i!=18 && i!=19 && i!=16){
|
|
//autrement nous ajoutons un composant inutile
|
|
this.fenetre.add(new JLabel());
|
|
}
|
|
//enfin nous ajoutons sur la 3ième collonne le 2ième paintChoix
|
|
this.fenetre.add(pinceau2);
|
|
}
|
|
}
|
|
//-----------------------------------------> Fonction pour l'affichage du premier menu (nouvelle partie/reprendrePartie/quitter) <---------------------
|
|
public void menuChoixTypePartie(){
|
|
//nous créons une nouvelles fenetre
|
|
this.fenetre.dispose();
|
|
this.fenetre= new JFrame("démineur");
|
|
this.fenetre.setLocation(0,0);
|
|
this.fenetre.setSize(1600, 1000);
|
|
this.fenetre.setVisible(true);
|
|
this.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
|
this.fenetre.setLayout(new FlowLayout());
|
|
JPanel pan1 = new JPanel();
|
|
JPanel pan2 = new JPanel();
|
|
JPanel pan3 = new JPanel();
|
|
JButton nouveau = new JButton("nouvelle partie");
|
|
JButton reprende = new JButton("reprendrePartie");
|
|
JButton quitter = new JButton("quitter");
|
|
nouveau.addActionListener(new observateurButtonEtText(this, 3, null));
|
|
reprende.addActionListener(new observateurButtonEtText(this, 4, null));
|
|
quitter.addActionListener(new observateurButtonEtText(this, 5, null));
|
|
pan1.add(nouveau);
|
|
pan2.add(reprende);
|
|
pan3.add(quitter);
|
|
this.fenetre.add(pan1);
|
|
this.fenetre.add(pan2);
|
|
this.fenetre.add(pan3);
|
|
//nous ajustons la fenetre a la taille de son contenue volontairement grand qui poussera sûrment un plein ecran (2000x2000)
|
|
}
|
|
} |