Aktualisierung für HS 2019

README.TXT

@@ -1,14 +1,3 @@
-------------------------------------------------------------------------
+PROJEKTBEZEICHNUNG: 04_Praktikum-1_Snake
-Dies ist die README-Datei des Projekts. Hier sollten Sie Ihr Projekt
+PROJEKTZWECK:       Übung im Rahmen von PROG1
-beschreiben.
+VERSION:            Aufgabenstellung
-Erzählen Sie dem Leser (jemand, der nichts über dieses Projekt weiss),
-alles, was er/sie wissen muss. Üblicherweise sollte der Kommentar 
-zumindest die folgenden Angaben umfassen:
-------------------------------------------------------------------------
-
-PROJEKTBEZEICHNUNG:
-PROJEKTZWECK:
-VERSION oder DATUM:
-WIE IST DAS PROJEKT ZU STARTEN:
-AUTOR(EN):
-BENUTZERHINWEISE:

Schlange.java

@@ -1,28 +1,28 @@
 import java.awt.Point;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Repraesentiert eine Schlange
- * 
  */
 public class Schlange {
-  private ArrayList<Point> schlange;
+  private List<Point> schlange;
 
   /**
    * Konstruiert eine Schlangen mit Startposition
-   * bei den angegebenen Koordinaten. 
+   * bei den angegebenen Koordinaten.
-   * 
+   *
    * @param x x-Koordinate der Schlangenposition
    * @param y y-Koordinate der Schlangenposition
    */
   public Schlange(int x, int y) {
-    schlange = new ArrayList<Point>();
+    schlange = new ArrayList<>();
     schlange.add(new Point(x, y));
   }
 
   /**
    * Prueft, ob die Schlange am bezeichneten Standort ist
-   * 
+   *
    * @param standort
    * @return true, falls die Schlange am bezeichneten Standort ist
    */
@@ -32,7 +32,7 @@ public class Schlange {
 
   /**
    * Prueft, ob der Schlangenkopf am bezeichneten Standort ist
-   * 
+   *
    * @param standort
    * @return wahr, falls der Schlangenkopf am bezeichneten Standort ist
    */
@@ -43,45 +43,47 @@ public class Schlange {
   /**
    * Bewege die Schlange in die angegebene Richtung.
    * Gueltige Richtungen sind:
-   *
+   * <p>
    * w  (oben)
    * s  (unten)
    * a  (links)
    * d  (rechts)
-   * 
+   *
    * @param richtung Richtung, in die sich die Schlange bewegen soll
    */
   public void bewege(char richtung) {
     Point kopf = kopf();
     switch (richtung) {
-    case 'w':
+      case 'w':
-      schlange.add( new Point(kopf.x, kopf.y - 1) );
+        schlange.add(new Point(kopf.x, kopf.y - 1));
-      schlange.remove(0);
+        schlange.remove(0);
-      break;
+        break;
-    case 's':
+      case 's':
-      schlange.add( new Point(kopf.x, kopf.y + 1) );
+        schlange.add(new Point(kopf.x, kopf.y + 1));
-      schlange.remove(0);
+        schlange.remove(0);
-      break;
+        break;
-    case 'a':
+      case 'a':
-      schlange.add( new Point(kopf.x - 1, kopf.y) );
+        schlange.add(new Point(kopf.x - 1, kopf.y));
-      schlange.remove(0);
+        schlange.remove(0);
-      break;
+        break;
-    case 'd':
+      case 'd':
-      schlange.add( new Point(kopf.x + 1, kopf.y) );
+        schlange.add(new Point(kopf.x + 1, kopf.y));
-      schlange.remove(0);
+        schlange.remove(0);
-      break;
+        break;
+      default:
+        System.out.println("Ungültige Taste");
     }
   }
 
   /**
    * Testet, ob der Kopf der Schlange auf dem Koerper liegt.
-   * 
+   *
    * @return true, falls der Kopf auf dem Koerper liegt
    */
   public boolean istKopfAufKoerper() {
     boolean istKopfAufKoerper = false;
 
-    for(int i=0; i<schlange.size()-2; i++) {
+    for (int i = 0; i < schlange.size() - 2; i++) {
       istKopfAufKoerper |= istKopfAufPunkt(schlange.get(i));
     }
     return istKopfAufKoerper;
@@ -97,7 +99,7 @@ public class Schlange {
 
   /**
    * Liefert die Position des Kopfs der Schlange zurueck.
-   * 
+   *
    * @return die aktuelle Position (Kopf) der Schlange
    */
   public Point gibPosition() {
@@ -105,6 +107,6 @@ public class Schlange {
   }
 
   private Point kopf() {
-    return schlange.get(schlange.size()-1);
+    return schlange.get(schlange.size() - 1);
   }
 }

SnakeSpiel.java

@@ -3,10 +3,10 @@ import java.util.Scanner;
 
 /**
  * Spielklasse des Spiels Snake.
- *
+ * <p>
- * Ziel dieses Spiels ist es alle Goldstuecke einzusammeln und 
+ * Ziel dieses Spiels ist es alle Goldstuecke einzusammeln und
- * die Tuer zu erreichen, ohne sich selber zu beissen oder in 
+ * die Tuer zu erreichen, ohne sich selber zu beissen oder in
- * die Spielfeldbegrenzung reinzukriechen. 
+ * die Spielfeldbegrenzung reinzukriechen.
  */
 public class SnakeSpiel {
   private Schlange schlange;
@@ -14,21 +14,24 @@ public class SnakeSpiel {
   private Spielfeld spielfeld;
   private Point goldStueck;
   private boolean spielLaeuft = true;
+  private Scanner scanner;
+
+  public static void main(String[] args) {
+    new SnakeSpiel().spielen();
+  }
 
   /**
    * Startet das Spiel.
    */
   public void spielen() {
+    scanner = new Scanner(System.in);
     spielInitialisieren();
     while (spielLaeuft) {
       zeichneSpielfeld();
       ueberpruefeSpielstatus();
       fuehreSpielzugAus();
-    }   
+    }
-  }
+    scanner.close();
-  
-  public static void main(String[] args) {
-    new SnakeSpiel().spielen();
   }
 
   private void spielInitialisieren() {
@@ -50,53 +53,52 @@ public class SnakeSpiel {
           ausgabeZeichen = '$';
         } else if (tuer.istAufPunkt(punkt)) {
           ausgabeZeichen = '#';
-        } 
+        }
-        if(schlange.istKopfAufPunkt(punkt)) {
+        if (schlange.istKopfAufPunkt(punkt)) {
-          ausgabeZeichen = 'S';         
+          ausgabeZeichen = 'S';
         }
         System.out.print(ausgabeZeichen);
       }
       System.out.println();
     }
   }
-  
+
   private boolean istEinGoldstueckAufPunkt(Point punkt) {
     return goldStueck != null && goldStueck.equals(punkt);
   }
-  
+
   private void ueberpruefeSpielstatus() {
     if (istEinGoldstueckAufPunkt(schlange.gibPosition())) {
       goldStueck = null;
       schlange.wachsen();
       System.out.println("Goldstueck eingesammelt.");
     }
-    if (istVerloren()){
+    if (istVerloren()) {
       System.out.println("Verloren!");
       spielLaeuft = false;
     }
-    if (istGewonnen()){
+    if (istGewonnen()) {
       System.out.println("Gewonnen!");
       spielLaeuft = false;
     }
   }
-  
+
   private boolean istGewonnen() {
-    return goldStueck == null && 
+    return goldStueck == null &&
       tuer.istAufPunkt(schlange.gibPosition());
   }
 
   private boolean istVerloren() {
-    return schlange.istKopfAufKoerper() || 
+    return schlange.istKopfAufKoerper() ||
-         !spielfeld.istPunktInSpielfeld(schlange.gibPosition());
+      !spielfeld.istPunktInSpielfeld(schlange.gibPosition());
   }
-  
+
   private void fuehreSpielzugAus() {
     char eingabe = liesZeichenVonTastatur();
     schlange.bewege(eingabe);
   }
 
   private char liesZeichenVonTastatur() {
-    Scanner scanner = new Scanner(System.in);
     char konsolenEingabe = scanner.next().charAt(0);
     return konsolenEingabe;
   }

Spielfeld.java

@@ -1,4 +1,5 @@
 import java.awt.Point;
+import java.util.Random;
 
 /**
  * Enthaelt Angaben zum Spielfeld
@@ -6,56 +7,57 @@ import java.awt.Point;
 public class Spielfeld {
   private int hoehe;
   private int breite;
-  
+  private Random random = new Random();
+
   /**
    * Konstruiert ein Spielfeld mit der gegebenen Breite
    * und Hoehe.
-   *  
+   *
    * @param breite Breite des Spielfelds
-   * @param hoehe Hoehe des Spielfelds
+   * @param hoehe  Hoehe des Spielfelds
    */
-  public Spielfeld(int breite, int hoehe){
+  public Spielfeld(int breite, int hoehe) {
     this.hoehe = hoehe;
     this.breite = breite;
   }
-  
+
   /**
    * Gibt die Spielfeldhoehe zurueck
-   * 
+   *
    * @return die Hoehe des Spielfelds
    */
   public int gibHoehe() {
     return hoehe;
   }
-  
+
   /**
    * Gibt die Spielfeldbreite zurueck
-   * 
+   *
    * @return die Breite des Spielfelds
    */
   public int gibBreite() {
     return breite;
   }
-  
+
   /**
    * Testet, ob ein gegebener Standort innerhalb des Spielfelds ist.
-   * 
+   *
    * @param p zu pruefender Standort
    * @return true, falls der Standort innerhalb des Spielfelds ist
    */
   public boolean istPunktInSpielfeld(Point p) {
-    return p.x >=0 && p.x < breite && p.y >= 0 && p.y < hoehe; 
+    return p.x >= 0 && p.x < breite && p.y >= 0 && p.y < hoehe;
   }
-  
+
   /**
-   * Erzeugt ein Point-Objekt, welches einen zufaelligen 
+   * Erzeugt ein Point-Objekt, welches einen zufaelligen
-   * Standort innerhalb des Spielfelds repraesentiert. 
+   * Standort innerhalb des Spielfelds repraesentiert.
-   * 
+   *
    * @return zufaelliger Standort innerhalb des Spielfelds
    */
-  public Point erzeugeZufallspunktInnerhalb(){    
+  public Point erzeugeZufallspunktInnerhalb() {
-    int xKoordinate = (int)(Math.random() * this.breite);
+    int xKoordinate = random.nextInt(this.breite);
-    int yKoordinate = (int)(Math.random() * this.hoehe);
+    int yKoordinate = random.nextInt(this.hoehe);
     return new Point(xKoordinate, yKoordinate);
   }
 }

Tuer.java

@@ -8,8 +8,8 @@ public class Tuer {
 
   /**
    * Konstruiert eine Tuer mit Standort
-   * bei den angegebenen Koordinaten. 
+   * bei den angegebenen Koordinaten.
-   * 
+   *
    * @param x x-Koordinate der Tuer
    * @param y y-Koordinate der Tuer
    */
@@ -19,7 +19,7 @@ public class Tuer {
 
   /**
    * Prueft, ob die Tuer am bezeichneten Standort ist
-   * 
+   *
    * @param standort
    * @return wahr, falls die Tuer am bezeichneten Standort ist
    */

package.bluej

@@ -8,43 +8,46 @@ dependency2.type=UsesDependency
 dependency3.from=SnakeSpiel
 dependency3.to=Spielfeld
 dependency3.type=UsesDependency
-package.editor.height=400
+editor.fx.0.height=0
-package.editor.width=560
+editor.fx.0.width=0
-package.editor.x=449
+editor.fx.0.x=0
-package.editor.y=246
+editor.fx.0.y=0
+objectbench.height=163
+objectbench.width=451
+package.divider.horizontal=0.599476439790576
+package.divider.vertical=0.66
+package.editor.height=323
+package.editor.width=670
+package.editor.x=451
+package.editor.y=234
+package.frame.height=600
+package.frame.width=800
 package.numDependencies=3
 package.numTargets=4
 package.showExtends=true
 package.showUses=true
 project.charset=UTF-8
-target1.editor.height=700
+readme.height=58
-target1.editor.width=900
+readme.name=@README
-target1.editor.x=314
+readme.width=47
-target1.editor.y=252
+readme.x=10
+readme.y=10
 target1.height=50
-target1.name=Spielfeld
+target1.name=SnakeSpiel
 target1.naviview.expanded=false
 target1.showInterface=false
 target1.type=ClassTarget
-target1.width=80
+target1.width=90
-target1.x=280
+target1.x=100
-target1.y=30
+target1.y=150
-target2.editor.height=700
-target2.editor.width=900
-target2.editor.x=314
-target2.editor.y=252
 target2.height=50
-target2.name=Schlange
+target2.name=Spielfeld
 target2.naviview.expanded=false
 target2.showInterface=false
 target2.type=ClassTarget
 target2.width=80
-target2.x=330
+target2.x=280
-target2.y=120
+target2.y=30
-target3.editor.height=700
-target3.editor.width=900
-target3.editor.x=314
-target3.editor.y=252
 target3.height=50
 target3.name=Tuer
 target3.naviview.expanded=false
@@ -53,15 +56,11 @@ target3.type=ClassTarget
 target3.width=80
 target3.x=310
 target3.y=240
-target4.editor.height=700
-target4.editor.width=900
-target4.editor.x=314
-target4.editor.y=252
 target4.height=50
-target4.name=SnakeSpiel
+target4.name=Schlange
 target4.naviview.expanded=false
 target4.showInterface=false
 target4.type=ClassTarget
-target4.width=90
+target4.width=80
-target4.x=100
+target4.x=330
-target4.y=150
+target4.y=120