Initial commit of the source files.

README.TXT

@@ -0,0 +1,14 @@
+------------------------------------------------------------------------
+Dies ist die README-Datei des Projekts. Hier sollten Sie Ihr Projekt
+beschreiben.
+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

@@ -0,0 +1,110 @@
+import java.awt.Point;
+import java.util.ArrayList;
+
+/**
+ * Repraesentiert eine Schlange
+ * 
+ */
+public class Schlange {
+  private ArrayList<Point> schlange;
+
+  /**
+   * Konstruiert eine Schlangen mit Startposition
+   * 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.add(new Point(x, y));
+  }
+
+  /**
+   * Prueft, ob die Schlange am bezeichneten Standort ist
+   * 
+   * @param standort
+   * @return true, falls die Schlange am bezeichneten Standort ist
+   */
+  public boolean istAufPunkt(Point standort) {
+    return schlange.contains(standort);
+  }
+
+  /**
+   * Prueft, ob der Schlangenkopf am bezeichneten Standort ist
+   * 
+   * @param standort
+   * @return wahr, falls der Schlangenkopf am bezeichneten Standort ist
+   */
+  public boolean istKopfAufPunkt(Point standort) {
+    return kopf().equals(standort);
+  }
+
+  /**
+   * Bewege die Schlange in die angegebene Richtung.
+   * Gueltige Richtungen sind:
+   *
+   * 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':
+      schlange.add( new Point(kopf.x, kopf.y - 1) );
+      schlange.remove(0);
+      break;
+    case 's':
+      schlange.add( new Point(kopf.x, kopf.y + 1) );
+      schlange.remove(0);
+      break;
+    case 'a':
+      schlange.add( new Point(kopf.x - 1, kopf.y) );
+      schlange.remove(0);
+      break;
+    case 'd':
+      schlange.add( new Point(kopf.x + 1, kopf.y) );
+      schlange.remove(0);
+      break;
+    }
+  }
+
+  /**
+   * 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++) {
+      istKopfAufKoerper |= istKopfAufPunkt(schlange.get(i));
+    }
+    return istKopfAufKoerper;
+  }
+
+  /**
+   * Laesst die Schlange um eine Einheit laenger werden.
+   */
+  public void wachsen() {
+    Point schwanz = schlange.get(0);
+    schlange.add(0, new Point(schwanz.x, schwanz.y));
+  }
+
+  /**
+   * Liefert die Position des Kopfs der Schlange zurueck.
+   * 
+   * @return die aktuelle Position (Kopf) der Schlange
+   */
+  public Point gibPosition() {
+    return kopf();
+  }
+
+  private Point kopf() {
+    return schlange.get(schlange.size()-1);
+  }
+}

SnakeSpiel.java

@@ -0,0 +1,103 @@
+import java.awt.Point;
+import java.util.Scanner;
+
+/**
+ * Spielklasse des Spiels Snake.
+ *
+ * Ziel dieses Spiels ist es alle Goldstuecke einzusammeln und 
+ * die Tuer zu erreichen, ohne sich selber zu beissen oder in 
+ * die Spielfeldbegrenzung reinzukriechen. 
+ */
+public class SnakeSpiel {
+  private Schlange schlange;
+  private Tuer tuer;
+  private Spielfeld spielfeld;
+  private Point goldStueck;
+  private boolean spielLaeuft = true;
+
+  /**
+   * Startet das Spiel.
+   */
+  public void spielen() {
+    spielInitialisieren();
+    while (spielLaeuft) {
+      zeichneSpielfeld();
+      ueberpruefeSpielstatus();
+      fuehreSpielzugAus();
+    }   
+  }
+  
+  public static void main(String[] args) {
+    new SnakeSpiel().spielen();
+  }
+
+  private void spielInitialisieren() {
+    tuer = new Tuer(0, 5);
+    spielfeld = new Spielfeld(40, 10);
+    goldStueck = new Point(20, 2);
+    schlange = new Schlange(30, 2);
+  }
+
+  private void zeichneSpielfeld() {
+    char ausgabeZeichen;
+    for (int y = 0; y < spielfeld.gibHoehe(); y++) {
+      for (int x = 0; x < spielfeld.gibBreite(); x++) {
+        Point punkt = new Point(x, y);
+        ausgabeZeichen = '.';
+        if (schlange.istAufPunkt(punkt)) {
+          ausgabeZeichen = '@';
+        } else if (istEinGoldstueckAufPunkt(punkt)) {
+          ausgabeZeichen = '$';
+        } else if (tuer.istAufPunkt(punkt)) {
+          ausgabeZeichen = '#';
+        } 
+        if(schlange.istKopfAufPunkt(punkt)) {
+          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()){
+      System.out.println("Verloren!");
+      spielLaeuft = false;
+    }
+    if (istGewonnen()){
+      System.out.println("Gewonnen!");
+      spielLaeuft = false;
+    }
+  }
+  
+  private boolean istGewonnen() {
+    return goldStueck == null && 
+      tuer.istAufPunkt(schlange.gibPosition());
+  }
+
+  private boolean istVerloren() {
+    return schlange.istKopfAufKoerper() || 
+         !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

@@ -0,0 +1,61 @@
+import java.awt.Point;
+
+/**
+ * Enthaelt Angaben zum Spielfeld
+ */
+public class Spielfeld {
+  private int hoehe;
+  private int breite;
+  
+  /**
+   * Konstruiert ein Spielfeld mit der gegebenen Breite
+   * und Hoehe.
+   *  
+   * @param breite Breite des Spielfelds
+   * @param hoehe Hoehe des Spielfelds
+   */
+  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; 
+  }
+  
+  /**
+   * Erzeugt ein Point-Objekt, welches einen zufaelligen 
+   * Standort innerhalb des Spielfelds repraesentiert. 
+   * 
+   * @return zufaelliger Standort innerhalb des Spielfelds
+   */
+  public Point erzeugeZufallspunktInnerhalb(){    
+    int xKoordinate = (int)(Math.random() * this.breite);
+    int yKoordinate = (int)(Math.random() * this.hoehe);
+    return new Point(xKoordinate, yKoordinate);
+  }
+}

Tuer.java

@@ -0,0 +1,29 @@
+import java.awt.Point;
+
+/**
+ * Repraesentiert eine Tuer.
+ */
+public class Tuer {
+  private Point aktuellerOrt;
+
+  /**
+   * Konstruiert eine Tuer mit Standort
+   * bei den angegebenen Koordinaten. 
+   * 
+   * @param x x-Koordinate der Tuer
+   * @param y y-Koordinate der Tuer
+   */
+  public Tuer(int x, int y) {
+    aktuellerOrt = new Point(x, y);
+  }
+
+  /**
+   * Prueft, ob die Tuer am bezeichneten Standort ist
+   * 
+   * @param standort
+   * @return wahr, falls die Tuer am bezeichneten Standort ist
+   */
+  public boolean istAufPunkt(Point standort) {
+    return aktuellerOrt.equals(standort);
+  }
+}

package.bluej

@@ -0,0 +1,67 @@
+#BlueJ package file
+dependency1.from=SnakeSpiel
+dependency1.to=Schlange
+dependency1.type=UsesDependency
+dependency2.from=SnakeSpiel
+dependency2.to=Tuer
+dependency2.type=UsesDependency
+dependency3.from=SnakeSpiel
+dependency3.to=Spielfeld
+dependency3.type=UsesDependency
+package.editor.height=400
+package.editor.width=560
+package.editor.x=449
+package.editor.y=246
+package.numDependencies=3
+package.numTargets=4
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+target1.editor.height=700
+target1.editor.width=900
+target1.editor.x=314
+target1.editor.y=252
+target1.height=50
+target1.name=Spielfeld
+target1.naviview.expanded=false
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=80
+target1.x=280
+target1.y=30
+target2.editor.height=700
+target2.editor.width=900
+target2.editor.x=314
+target2.editor.y=252
+target2.height=50
+target2.name=Schlange
+target2.naviview.expanded=false
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=80
+target2.x=330
+target2.y=120
+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
+target3.showInterface=false
+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.naviview.expanded=false
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=90
+target4.x=100
+target4.y=150