Minesweeper.java

package Fenster;

import Spiel.Feld;
import Spiel.Feld.FeldStatus;

import java.util.List;
import java.util.ArrayList;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

/**
 *
 * @author DoHate -> Florian Schneider
 */
class Minesweeper extends JFrame {

    // <editor-fold defaultstate="collapsed" desc="Definiere Globale Variablen">
    //Spiel Parameter & Objekte
    private boolean spielende = false;
    private int schwierigkeitsgrad = 10, minenAnzeige = 10, minenAnzahl = 10;
    private Feld[][] spielFeld = new Feld[10][10]; //Groeße statisch oder dynamisch angeben?
    private List<Point> pruefListe = new ArrayList<Point>(); //Fuer Aufdeck-Algorithmus
    private List<Point> entschaerft = new ArrayList<Point>(); //Liste fuer entschaerfte Felder
    private Feld currentFeld; //Tmp halter fuer gerade geklicktes Feld
    //Importiere Icons
    private ImageIcon bildMinen = new ImageIcon(Minesweeper.class.getResource("/IconBilder/bildMinen.png"));
    private ImageIcon bildZeit = new ImageIcon(Minesweeper.class.getResource("/IconBilder/bildZeit.png"));
    //Timer Objekte
    private Timer timer = new Timer();
    private TimerTask task = new TimerTask() {
        public void run() {
            if (!spielende) {
                if (sec == 60) {
                    sec = 0;
                    min++;
                }
                if (min > 9 && sec > 9) {
                    labelZeit.setText(min + ":" + sec);
                } else {
                    if (min > 9) {
                        labelZeit.setText(min + ":0" + sec);
                    } else if (sec > 9) {
                        labelZeit.setText("0" + min + ":" + sec);
                    } else {
                        labelZeit.setText("0" + min + ":0" + sec);
                    }
                }
                sec++;
            } else {
                labelZeit.setText("0" + min + ":0" + sec);
            }
        }
    };
    private int min = 0, sec = 0;
    //Fenster Objekte
    private JPanel panelCenter = new JPanel();
    private JPanel panelSouth = new JPanel();
    private JLabel labZeit = new JLabel(bildZeit, JLabel.CENTER);
    private JLabel labMinen = new JLabel(bildMinen, JLabel.CENTER);
    private JLabel labelZeit = new JLabel();
    private JLabel labelMinen = new JLabel();
    //Menuleiste
    private JMenuBar menuBar = new JMenuBar();
    //Datei
    private JMenu menu = new JMenu("Datei");
    private JMenuItem neu = new JMenuItem("Neues Spiel");
    //Siehe weiter unten
    //private JMenuItem einfach = new JMenuItem("Einfach");
    //private JMenuItem mittel = new JMenuItem("Mittel");
    //private JMenuItem schwer = new JMenuItem("Schwer");
    private JMenuItem beenden = new JMenuItem("Beenden");
    //?
    private JMenu impressum = new JMenu("?");
    private JMenuItem hilfe = new JMenuItem("Hilfe");
    private JMenuItem info = new JMenuItem("Info");
    //EventListener
    private pruefListener feldAktion = new pruefListener();

    //Siehe unten!
    //AchtonListenerSchwierigkeitsgrad allGrade=new AchtonListenerSchwierigkeitsgrad();
    //</editor-fold>

    //Konstruktor
    public Minesweeper() {
        super("Minesweeper");
        this.setIconImage(bildMinen.getImage());

        initFelder();
        initFenster();

        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
        this.setLocation(dim.width / 2 - this.getWidth() / 2, dim.height / 2 - this.getHeight() / 2);
        this.setVisible(true); //Das koennte auch in die main, wenn es nicht direkt sichtbar sein soll
    }

    //Allgemeiner Einstiegspunkt!
    public static void main(String[] args) {
        Minesweeper ms = new Minesweeper();
    }

    //Initialisiere HauptFenster
    private void initFenster() {
        this.setSize(440, 460);
        this.setResizable(false);
        this.setLayout(new BorderLayout());

        menuBar.add(menu);
        menu.add(neu);
        menu.addSeparator();
        //Schwierigkeitsgrad vielleicht anders festlegen?
        //menu.add(einfach);
        //menu.add(mittel);
        //menu.add(schwer);
        menu.addSeparator();
        menu.add(beenden);
        menuBar.add(impressum);
        impressum.add(hilfe);
        impressum.add(info);

        panelSouth.setLayout(new FlowLayout());
        panelSouth.add(labZeit);
        panelSouth.add(labelZeit);
        panelSouth.add(labMinen);
        panelSouth.add(labelMinen);

        neu.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                neuesSpiel();
            }
        });
        //Siehe unten
        //einfach.addActionListener(allGrade);
        //mittel.addActionListener(allGrade);
        //schwer.addActionListener(allGrade);
        beenden.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e){
                System.exit(0);
            }
        });

        this.add(menuBar, BorderLayout.NORTH);
        this.add(panelCenter, BorderLayout.CENTER);
        this.add(panelSouth, BorderLayout.SOUTH);

        //Diese Aktion ist schon in spielFeldErzeugen
        //panelCenter.setLayout(new GridLayout(schwierigkeitsgrad, schwierigkeitsgrad));

        timer.scheduleAtFixedRate(task, 0, 1000);
        this.spielFeldErzeugen();
    }

    /*spaeter
    public void guiInfo() {

    }

    public void guiHilfe() {

    }
     *
     */

    //Initialisiere Felder
    private void initFelder(){
        for(int i = 0; i < spielFeld.length; i++){
            for(int j = 0; j < spielFeld[0].length; j++){
                spielFeld[i][j] = new Feld(i, j);
                spielFeld[i][j].addMouseListener(feldAktion);
            }
        }
    }

    private void spielFeldErzeugen() {
        minenLegen();
        panelCenter.removeAll();
        panelCenter.setLayout(new GridLayout(schwierigkeitsgrad, schwierigkeitsgrad));
        for (int i = 0; i < schwierigkeitsgrad; i++) {
            for (int j = 0; j < schwierigkeitsgrad; j++) {
                spielFeld[i][j].setMinenAußenrum(this.wievielMinenUmDasFeld(i, j));
                panelCenter.add(spielFeld[i][j]);
            }
        }
        this.repaint();
    }

    //Lege Minen auf das Spielfeld
    private void minenLegen() {
        List<Point> tmpList = new ArrayList<Point>();
        for (int i = 0; i < schwierigkeitsgrad * (schwierigkeitsgrad / 10); i++) {
            int randomX, randomY;
            do {
                randomX = (int) (Math.random() * schwierigkeitsgrad);
                randomY = (int) (Math.random() * schwierigkeitsgrad);
            } while (tmpList.contains(new Point(randomX, randomY)));
            tmpList.add(new Point(randomX, randomY));
        }
        labelMinen.setText("" + schwierigkeitsgrad * (schwierigkeitsgrad / 10) + "");
        minenAnzeige = schwierigkeitsgrad * (schwierigkeitsgrad / 10);
        minenAnzahl = minenAnzeige;

        for(Point p : tmpList){
            spielFeld[p.x][p.y].setMine();
        }
    }

    private void neuesSpiel() {
        spielende = false;
        min = 0;
        sec = 0;
        for (int i = 0; i < spielFeld.length; i++) {
            for (int j = 0; j < spielFeld[0].length; j++) {
                spielFeld[i][j].reset();
            }
        }
        this.spielFeldErzeugen();
    }

    //Diese Methode ist verdammt Elegant. Richtig Respekt hierfuer!!!!!!
    private int wievielMinenUmDasFeld(int x, int y) {
        int anzahlMinen=0;
        for (int i = -1; i < 2; i++) {
            for (int j = -1; j < 2; j++) {
                if (!outOfBound(x+i, y+j)) {
                    if (spielFeld[x + i][y + j].isMine()) {
                        anzahlMinen++;
                    }
                }
            }
        }
        return anzahlMinen;
    }

    //Feld entschaerfen
    public void entschaerfung() {
        if(currentFeld.getStatus() == FeldStatus.ZU){
            if(!entschaerft.contains(currentFeld.getPointer())){
                boolean result = currentFeld.feldEntschaerfen();
                if(result){
                    if(currentFeld.isMine()){
                        minenAnzahl--;
                    }
                    minenAnzeige--;
                    entschaerft.add(currentFeld.getPointer());
                    labelMinen.setText(""+minenAnzeige+"");
                }
                if(minenAnzahl == 0){
                    //Spiel Beendet!
                }
            }else{
                boolean result = currentFeld.feldEntschaerfen();
                if(!result){
                    if(currentFeld.isMine()){
                        minenAnzahl++;
                    }
                    minenAnzeige++;
                    entschaerft.remove(currentFeld.getPointer());
                    labelMinen.setText(""+minenAnzeige+"");
                }
            }
        }
    }

    //Feld Aufdecken
    public void aufdecken(){
        FeldStatus status = currentFeld.aufdecken();
        switch(status){
            case OFFEN://Hier eigentlich minenAnzeige hochzählen, da eventuell schon entschaerft gewesen
                break;//Mache nichts
            case LEER:
                leerAufdecken(currentFeld.getPointer());
                break;
            case ZU:
                //Mine erwischt
        }
    }

    //Leere Felder außenrum aufdecken // Defekt
    //Bei 10x10 feld gehts! Sobald 2-stelliger index, gehts nichtmehr
    //Rechte und untere seite wird falsch aufgedeckt!
    private void leerAufdecken(Point point){
        Point tmp = null;
        //<editor-fold defaultstate="collapsed" desc="Von dir Geklaut :P">
        for (int i = -1; i < 2; i++) {
            for (int j = -1; j < 2; j++) {
                tmp = new Point(point.x+i, point.y+j);
                if (!outOfBound(tmp) && !pruefListe.contains(tmp)) {
                    pruefListe.add(tmp);
                }
            }
        }
        //</editor-fold>
        for(Point p : pruefListe){
            if(spielFeld[p.x][p.y].aufdecken() == FeldStatus.LEER){//Hier eigentlich minenAnzeige hochzählen, da eventuell schon entschaerft gewesen
                leerAufdecken(p);
                break;
            }
        }
        pruefListe.clear();
    }
    /*
    //Leere Felder aufdecken 2 Version
    private void leerAufdecken(Point point){
        Point[] pruefFelder = new Point[9];
        Point tmp = null;
        int count = 0;

        for (int i = -1; i < 2; i++) {
            for (int j = -1; j < 2; j++) {
                tmp = new Point(point.x+i, point.y+j);
                if (!outOfBound(tmp)) {
                    pruefFelder[count++] = tmp;
                }
            }
        }

        for(int i = 0; i < pruefFelder.length; i++){
            if(pruefFelder[i] != null && spielFeld[pruefFelder[i].x][pruefFelder[i].y].aufdecken() == FeldStatus.LEER){//Hier eigentlich minenAnzeige hochzählen, da eventuell schon entschaerft gewesen
                leerAufdecken(pruefFelder[i]);
                //break;
            }
        }
    }
     *
     */

    //Pruefe ob point OutOfBound
    private boolean outOfBound(int x, int y){
        if(x >= 0 && y >= 0 && x < spielFeld.length && y < spielFeld[0].length){
            return false;
        }else{
            return true;
        }
    }
    private boolean outOfBound(Point p){
        return outOfBound(p.x, p.y);
    }


    //Listener Klasse fuer Felder
    class pruefListener implements MouseListener {
        public void mouseClicked(MouseEvent e) {
            Feld feld = (Feld)e.getSource();
            currentFeld = feld;
            if(e.getButton() == 3){ //Wenn Rechtsklick
                entschaerfung();
            }else if(e.getButton() == 1){ //Wenn Linksklick
                aufdecken();
            }
        }

        public void mousePressed(MouseEvent e) {}
        public void mouseReleased(MouseEvent e) {}
        public void mouseEntered(MouseEvent e) {}
        public void mouseExited(MouseEvent e) {}
    }
}