SHARE
TWEET

Untitled

a guest May 19th, 2017 45 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /******************************************************************************
  2.    Compilation:  javac Minesweeper.java
  3.    Execution:    java Minesweeper
  4.  
  5.     Bemerkungen:
  6.     -Der Code ist größtenteils kommentiert, aber aus Zeitgründen nicht vollständig
  7.  
  8.     Dann noch viel Spass mit dem Spiel!
  9.  
  10.  ******************************************************************************/
  11. import java.util.*;
  12. public class Minesweeper {
  13.  
  14.     public static void main (String [] args){
  15.  
  16.         /*
  17.         Kurze Erklärung zum Vorgehen hier:
  18.         Es wird eine boolean Ausgabe von der Methode zur Spielausführung erwartet.
  19.         Diese dient dazu festzustellen, ob das Spiel einmal zu Ende gespielt wurde.
  20.         Eigentlich kann man diese Variable auslassen und einfach eine Endlosschleife machen,
  21.         dies ist nur probehalbar implementiert.
  22.         */
  23.             boolean spass = false; 
  24.             //kot: =false ist unnötig weil jede boolean default false ist //boolean-Variable spass wird erzeugt und                                                                                                                //auf false gesetzt
  25.             String s = "";              //kot: s auf "" setzen ist unnötig man kann auch s einfach erst unten deklareiere                                             
  26.  
  27.                                                                                             //String-Variable s wird erzeugt und                                                                                                                //auf einen leeren String gesetzt
  28.             System.out.println("Möchten Sie beginnen: Ja? Nein?");                                         //Ausgabe an den Nutzer
  29.             s = StdIn.readString();
  30.                             //s wird auf die Eingabe des Nutzers gesetzt
  31.             if(s.equals("Ja") || s.equals("J") ||s.equals("j") || s.equals("y") || s.equals("ja")){         //Für bestimmte Eingaben wird das Spiel                        //kot: "Ja" fall ist unnötig, man kann auch einfach oen an .readString() .toLowerCase() dranhängen
  32.                                                                                                 //gestartet
  33.                 spass = ausführung();                                                                      //Methode für Spielvers. 2 wird aufgerufen
  34.                 StdDraw.show(500);                                                                          //Animation wird gestoppt
  35.             }                                                                                               //
  36.             else{                                                                                           //
  37.                 System.out.println("Warum klickst du auf das Spiel, wenn du es nicht spielen willst?");     //Spassausgabe
  38.             }                          
  39.             while(spass == true){                                                                           //
  40.                 System.out.println("Erneut spielen: Ja? Nein?");                                            //Ausgabe an den Nutzer
  41.                 StdDraw.clear();                                                                            //
  42.                 System.out.println("Natürlich willst du nochmal spielen, ich sehe doch wie viel Spass dir das Spiel gemacht hat"); //Spassausgabe     
  43.                 //kot: unnötige "scherze" aus der konsole entfernen
  44.                 StdDraw.show();                                                                             //
  45.                 spass = ausführung();                                                                      //Methode für Spielvers. 2 wird aufgerufen
  46.             }
  47.  
  48.     }
  49.  
  50. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  51.     //kot: ALLE methoden außer main "müssen" private
  52.     public static boolean ausführung(){
  53.  
  54.         double x=0;                                                                 //später x-Wert durch Mauseingabe
  55.         double y=0;                                                                 //später y-Wert durch Mauseingabe
  56.         int k=0;                                                                    //Zählvariable
  57.         int ko = 0;                                                                 //Zählvariable
  58.         int random = 10;//kot: variabel anders nennen da nicht random                                                           //Breite/Höhe des Feldes
  59.         int minen = 10;
  60.         int spalte=-1;                                                              //angeklickte Spalte
  61.         int zeile=-1;                                                               //angeklickte Zeile
  62.         double nnew = (double) random;                                              //Variable zum Rechnen
  63.         double linien = 1.0/(double) random;                                                    //Variable mit Abständen zwischen Linien als Wert
  64.         double halb = linien/2;     //kot: die ganzen berechnungen hier sind unnötig, die werte sind immer die gleichen warum sollte man sie ausrechnen                                                //Variable mit Mitte von Abstand von 2 Linien als Wert
  65.         for(int p1=0;p1<random+1;p1++){                                             //for-schleife die das
  66.             for(int p2=0;p2<random+1;p2++){                                         //Raster für das Feld zeichnet
  67.                 StdDraw.line(linien*p2,linien*p2,linien*p2,linien*p1);              //Erklärung entfällt, da zu zeitaufwändig
  68.                 StdDraw.line(linien*p1,linien*p2,linien*p2,linien*p2);              //Erklärung entfällt, da zu zeitaufwändig
  69.             }
  70.         }
  71.         boolean [][] bool = new boolean [random+1][random+1];                       //2-dim boolean Array mit zusätzlicher Spalte und Zeile zur                                                                                    //Überprüfung für Spielende
  72.         boolean [][] bool2 = new boolean [random+1][random+1];                                         
  73.         int [][] boar = new int [random][random];                                   //Minesweeper-Feld mit Größe random*random
  74.         int [][] boar2 = new int [random][random];                                  //Minesweeper-Feld mit Größe random*random
  75.         boar = makeRandomBoard(random,random,minen);                                //zufälliges Feld mit Minen wird erstellt mit Größe random² und                                                                                     //random-vielen Minen
  76.  
  77.  
  78.         /*
  79.         Kurze Erläuterung zum weiterführenden Code:
  80.         Da das Minesweeper-Board von oben nach unten gelesen wird,
  81.         aber die Koordinaten für die Mauseingabe ihren Ursprung unten links haben,
  82.         war es notwendig das Array in ihrer Zeile und Spalte zu invertieren.
  83.         Hätte man auch anders lösen können, aber so war es weniger aufwändig den bereitsgeschriebenen Code zu ändern. 
  84.         */
  85.  
  86.         for(int t=0; t<random;t++){                                                 //Zeilen werden durchgegangen
  87.             for(int s=0;s<random;s++){                                              //Spalten werden durchgegangen
  88.                 boar2[(random-1)-t][(random-1)-s]=boar[t][s];                       //boar-Array wird umgedreht und als boar2 gespeichert
  89.             }
  90.         }
  91.        
  92.         k=0;                                                                        //Zählvariable
  93.         while(bool2[random][random]==false && (random*random)-(minen+ko)>0){        //Solange keine Mine geöffnet wurde oder eine nicht Mine noch nicht                                                                                    //geöffnet wurde
  94.             while(zeile==-1 && spalte==-1){                                         //Zeile und Spalte soll zur Eingabe des Nutzers werden
  95.                 System.out.print("Zeile: ");                                        //Ausgabe an den Nutzer
  96.                 zeile=StdIn.readInt();                                              //zeile wird zur Eingabe des Nutzers
  97.                 while(zeile>=random){                                               //zeile soll aber immernoch im Array liegen
  98.                     k++;                                                            //k wird um eins erhöht
  99.                     if(k>3){                                                        //wenn der Nutzer 3 falsche Eingaben macht
  100.                         System.out.println("Sag mal kannst du nicht lesen?");       //Spassausgabe
  101.                     }
  102.                     System.out.print("Zahl zu groß, bitte neue Zahl eingeben: ");  //Neue Eingabe wird erwartet
  103.                     zeile=StdIn.readInt();                                          //zeile wird zur Eingabe des Nutzers
  104.                 }  
  105.                 System.out.print("Spalte: ");                                       //Ausgabe an den Nutzer
  106.                 spalte=StdIn.readInt();                                             //zeile wird zur Eingabe des Nutzers
  107.                 k=0;                                                                //k wird wieder als Zählvariable genutzt
  108.                 while(spalte>=random){                                              //zeile soll aber immernoch im Array liegen
  109.                     k++;                                                            //k wird um eins erhöht
  110.                     if(k>3){                                                        //wenn der Nutzer 3 falsche Eingaben macht
  111.                         System.out.println("Sag mal kannst du nicht lesen?");       //Spassausgabe
  112.                     }
  113.                     System.out.print("Zahl zu groß, bitte neue Zahl eingeben: ");  //Neue Eingabe wird erwartet
  114.                     spalte=StdIn.readInt();                                         //spalte wird zur Eingabe des Nutzers
  115.                 }  
  116.             }      
  117.             k=0;
  118.             bool = uncover(bool,boar,zeile,spalte);
  119.             for(int t=0; t<random;t++){
  120.                 for(int s=0;s<random;s++){
  121.                     bool2[(random-1)-t][(random-1)-s]=bool[t][s];
  122.                 }
  123.             }      
  124.             for(int t=0; t<random;t++){
  125.                 for(int s=0;s<random;s++){
  126.                     String sp = Integer.toString(countMines(boar2,t,s));                    //hier gucken ob boar oder boar2 eingesetzt werden müssen
  127.                     if(bool2[t][s]==true){                                              //wird geprüft welche Felder schon geöffnet wurden
  128.                         if(Integer.parseInt(sp)==-1){
  129.                             StdDraw.text(1-(halb+(linien*s)),halb+(linien*t),"TOD");
  130.                             bool2[random][random]=true;
  131.                         }
  132.                         else{
  133.                             StdDraw.text(1-(halb+(linien*s)),(halb+(linien*t)),sp);
  134.                         }
  135.                         ko++;
  136.                     }
  137.                 }
  138.             }      
  139.             if((random*random)-(minen+ko)==0){
  140.                 k=10;
  141.             }
  142.             if(bool2[random][random]==true){
  143.                 k=100;
  144.             }
  145.             zeile=-1;
  146.             spalte=-1;
  147.         }      
  148.         StdDraw.show(200);
  149.         StdDraw.clear();
  150.         for(int p1=0;p1<random+1;p1++){                                     //for-schleife die das
  151.             for(int p2=0;p2<random+1;p2++){                                 //Raster für das Feld zeichnet
  152.                 StdDraw.line(linien*p2,linien*p2,linien*p2,linien*p1);      //Erklärung entfällt, da zu zeitaufwändig
  153.                 StdDraw.line(linien*p1,linien*p2,linien*p2,linien*p2);      //Erklärung entfällt, da zu zeitaufwändig
  154.             }
  155.         }
  156.         for(int t=0; t<random;t++){
  157.             for(int s=0;s<random;s++){
  158.                 String sp = Integer.toString(countMines(boar,t,s));         //hier gucken ob boar oder boar2 eingesetzt werden müssen
  159.                 StdDraw.text(1-(halb+(linien*s)),halb+(linien*t),sp);
  160.             }
  161.         }
  162.         //System.out.println((random*random)-(minen+ko));                       //Testausgabe
  163.         if(k==10){                                                          //aus vorherigen Zeilen ergibt sich: Wird aufgerufen, wenn alle nicht-Minen                                                                             //geöffnet wurden
  164.             System.out.println("Victory!");                                 //Ausgabe
  165.             StdDraw.show();
  166.             StdDraw.clear();
  167.         }
  168.         else{                                                               //Wenn auf eine Mine gedrückt wurde
  169.             System.out.println("Verkackt!");//kot: in "kot verkackt!" ändern                               //Ausgabe
  170.             StdDraw.show();
  171.             StdDraw.clear();
  172.         }
  173.         return true;
  174.     }
  175. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  176.  
  177.  
  178.  
  179.     public static boolean[][] uncover(boolean [][] uncovered, int [][] board, int zeile, int spalte) {
  180.         int z = board.length;
  181.         int s = board[0].length;
  182.         //boolean [][] out = new boolean [z+1][z+1];//kot: kein bock auf diesen haufen
  183.         if(isMine(board,zeile,spalte)==true){
  184.             uncovered[zeile][spalte]=true;
  185.             uncovered[z][s]=true;
  186.         }
  187.         else{
  188.             if(countMines(board,zeile,spalte)>0){
  189.                 uncovered[zeile][spalte]=true;
  190.             }          
  191.             if(countMines(board,zeile,spalte)==0){
  192.                 uncovered[zeile][spalte]=true;
  193.                 if(zeile>0 && uncovered[zeile-1][spalte] != true){
  194.                     uncover(uncovered,board,zeile-1,spalte);
  195.            
  196.                     if(spalte<s-1 && uncovered[zeile-1][spalte+1] != true){
  197.                         uncover(uncovered,board,zeile-1,spalte+1);
  198.                     }              
  199.                     if(spalte>0 && uncovered[zeile-1][spalte-1] != true){
  200.                         uncover(uncovered,board,zeile-1,spalte-1);
  201.                     }
  202.                 }          
  203.                 if(zeile<z-1 && uncovered[zeile+1][spalte] != true){
  204.                     uncover(uncovered,board,zeile+1,spalte);
  205.  
  206.                     if(spalte<s-1 && uncovered[zeile+1][spalte+1] != true){
  207.                         uncover(uncovered,board,zeile+1,spalte+1);
  208.                     }
  209.                     if(spalte>0 && uncovered[zeile+1][spalte-1] != true){
  210.                         uncover(uncovered,board,zeile+1,spalte-1);
  211.                     }      
  212.                 }      
  213.                 if(spalte<s-1 && uncovered[zeile][spalte+1] != true){
  214.                     uncover(uncovered,board,zeile,spalte+1);
  215.                 }
  216.                 if(spalte>0 && uncovered[zeile][spalte-1] != true){
  217.                     uncover(uncovered,board,zeile,spalte-1);
  218.                 }
  219.             }
  220.         }
  221.         //out = uncovered;
  222.         return uncovered;
  223.     }
  224.  
  225. ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  226. ////////////////////////////////////////////////////////////////////////////////////////////////////////////
  227.  
  228.     public static boolean isMine(int[][] board, int i, int j) {
  229.             return board[i][j] == 1;
  230.     }
  231.          
  232.     public static int countMines(int[][] board, int z, int s) {
  233.         if (board[z][s] == 1) { return -1; }
  234.         int height = board.length;
  235.         int width = board[0].length;
  236.         int count = 0;
  237.         for (int i=z-1;i<=z+1;i++) {
  238.           for (int j=s-1;j<=s+1;j++) {
  239.             if (
  240.                   i < height && i >= 0 &&  // zeile ist gueltig
  241.                   j < width && j >= 0 &&   // spalte ist gueltig
  242.                   board[i][j] == 1         // es ist eine Mine
  243.                ) { count++; }
  244.           }
  245.         }
  246.         return count;
  247.     }
  248.     public static int[][] makeRandomBoard(int height, int width, int mines) {
  249.         int[][] board = new int[height][width];
  250.         for (int i =0; i<mines; i++) {
  251.             int[] pos = selectRandomPosition(height,width);
  252.             board[pos[0]][pos[1]] = 1;
  253.         }
  254.         return board;
  255.     }
  256.      public static int[] selectRandomPosition(int height, int width) {
  257.     int spalte = StdRandom.uniform(0,width);
  258.     int zeile = StdRandom.uniform(0,height);
  259.     return new int[]{zeile,spalte};
  260.   }
  261.  
  262. /*////////////////////////////////////////////////////////////////////////////////////////////
  263. Test- und Debugging Methoden
  264. ////////////////////////////////////////////////////////////////////////////////////////////*/
  265.  
  266.     public static void output(boolean [][] b){ 
  267.         int n = b.length;      
  268.         for (int i=0;i<n;i++) {
  269.             for (int ko=0;ko<n;ko++) {
  270.                 System.out.print(b[i][ko]+" ");
  271.             }
  272.             System.out.println();      
  273.         }
  274.     }
  275.     public static void intoutput(int [][] b){  
  276.         int n = b.length;      
  277.         for (int i=0;i<n;i++) {
  278.             for (int ko=0;ko<n;ko++) {
  279.                 System.out.print(b[i][ko]+" ");
  280.             }
  281.             System.out.println();      
  282.         }
  283.     }
  284.  
  285. }
RAW Paste Data
Top