Adventuregame Folge 5

Das Spielfeld
Wir wollen nun die graphische Darstellung eines Spielfeldes entwickeln, und dazu benötigen wir zwei neue Klassen, nämlich Feld und Dungeon.

Die Klasse Feld steht dabei für ein einzelnes Feld innerhalb des Dungeons, für eine Bodenplatte sozusagen, auf der ein Held oder ein Monster stehen oder ein Gegenstand liegen kann. Die Wände des Dungeons realisieren wir einfach durch besondere Bodenplatten, die nicht flach, sondern drei Meter dick bzw. hoch sind.

Die Klasse Dungeon besteht aus lauter solchen Bodenplatten, hier werden wir einen zweidimensionalen Array realisieren.

In dieser Folge 5 wollen wir beide Klassen so weit entwickeln, dass man in dem Applet einen Dungeon mit Wänden und normalen Bodenplatten sieht, außerdem wollen wir den Helden und mehrere Gegenstände sichtbar machen. Bewegen wollen wir den Helden in dieser Folge 5 noch nicht.

Die Klasse Feld

Wir gehen nach bewährtem Schema vor: Welche Attribute soll die Klasse Feld besitzen, und welche Methoden definieren das Verhalten von Feld-Objekten?

Ein Feld in unserem Spiel soll quadratisch sein mit einer festen Kantenlänge von 32 Pixeln, wir wollen es aus der Vogelperspektive darstellen. Ein Feld soll - wenn es leer ist - gelb oder weiß dargestellt werden. Handelt es sich um ein Wand-Feld, so soll es dunkelblau oder schwarz dargestellt werden. Bei einer Tür handelt es sich nicht einfach um eine Lücke in der Wand, sondern hier ist ein eigener Feldtyp erforderlich:

Feldtyp 0 = leeres Feld

Feldtyp 1 = Wand

Feldtyp 2 = Tür, geschlossen

Feldtyp 3 = Tür, offen

Wenn der Held auf dem Feld steht, soll ein kleines Bild des Helden gezeigt werden, und wenn ein Gegenstand auf dem Feld liegt, so soll zunächst gar nichts angezeigt werden. Erst wenn der Held zufällig auf ein Feld mit einem Gegenstand gestoßen ist, wird der versteckte Gegenstand durch ein kleines Bild angezeigt.

Später werden wir noch weitere Objekte modellieren, die auf Feldern stehen können, vor allem Monster und Schatztruhen.

Die Klasse Dungeon

Diese Klasse stellt das eigentliche Spiel dar und besitzt ("HAT") zunächst viele Felder, einen Helden und mehrere Gegenstände. Da Sie wahrscheinlich noch nie einen zweidimensionalen Array programmiert haben, erhalten Sie an dieser Stelle Einsicht in einen rudimentären Quelltext der Klasse Dungeon:

import java.awt.*;

public class Dungeon
{
	Feld[][] feld;
	int breite, hoehe;
	
 public Dungeon(int breite, int hoehe)
	{
  // alle Felder erzeugen
	    feld = new Feld[32][24];
	    
	 // Koordinaten, Typ für die Felder festlegen   
     for (int x = 0; x <= breite; x++)
       for (int y = 0; y <= hoehe; y++)
         feld[x][y] = new Feld(x,y,0);

	 // Eigenschaften des Dungeons festlegen
	    this.breite = breite;
     this.hoehe = hoehe;
	}
	

	public void anzeigen(Graphics g)
	{
	   for (int x = 0; x <= breite; x++)
	      for (int y = 0; y <= hoehe; y++)
	         feld[x][y].anzeigen(g);
	}
}

Dieser Quelltext ist wirklich sehr rudimentär. Ein Dungeon kann hier maximal aus 32 mal 24 Feldern bestehen. Die tatsächliche Feldanzahl wird in den Attributen breite und hoehe gespeichert.

Übung 5.1 (4 Punkte)

Erstellen Sie die Klassen Feld und Dungeon nach den obigen Spezifikationen und testen Sie dann, ob der Dungeon genau so dargestellt wird wie in der Abbildung 1. Der Dungeon besteht hier aus 16 mal 12 Feldern, die alle vom Typ 0 (leer) sind.

1 Das Spiel nach Übung 5.1

2 Das Spiel nach Übung 5.2

Übung 5.2 (4 Punkte)

Schreiben Sie nun für die Klasse Dungeon eine Methode aufbauen(), welche den Dungeon mit Wänden und offenen Türen ausstattet. Da Sie auf das Attribut typ der Klasse Feld nicht direkt zugreifen dürfen, müssen Sie sich eine Methode

public void setzeTyp(int typ)

oder alternativ mehrere Methoden

public void erzeugeWand()
public void erzeugeTuer()
public void oeffneTuer()

für die Klasse Feld schreiben, die Sie dann von Dungeon her einfach aufrufen können, zum Beispiel so:

feld[ 6][ 3].erzeugeTuer();

Wenn Sie mit Übung 5.2 fertig sind, sollte Ihr Dungeon so aussehen wie in der Abbildung 2. Sie dürfen natürlich gerne andere Farben wählen, den Dungeon größer machen, die Zahl der Wände und Türen verändern etc. Sagen wir mal so: Für die vier Punkte muss Ihr Dungeon mindestens so aussehen wie in der Abbildung.

Die Darstellung der Gegenstände im Dungeon

Wir wollen unseren Dungeon jetzt so erweitern, dass Gegenstände auf den Feldern herumliegen können, die der Held dann aufnehmen kann. Wie machen wir das?

Die einfachste Lösung ist folgende: Jedes einzelne Feld erhält ein zusätzliches Attribut vom Typ Gegenstand, so dass man von einer neuen HAT-Beziehung sprechen kann - jedes Feld hat einen Gegenstand. Dazu verändern wir die Definition der Klasse Feld etwas:

public class Feld
{
    private int typ;
    private int x,y;
    Gegenstand ding;
    
	   public Feld(int xpos, int ypos, int typ)
   	{
	      this.typ = typ;
	      x = xpos; 
	      y = ypos;
	      ding = null;
	   }

Hinterlegen von Gegenständen auf einem Feld

Die wichtigste Operation, die wir jetzt für die Klasse Feld schreiben müssen, heißt

   	public void hinterlegeGegenstand(Gegenstand g)
   	{
	      ding = g;   
   	}

Damit weisen wir einem Feld einen Gegenstand g zu. Vor dem Aufrufen von hinterlegeGegenstand() hat das Attribut ding eines Feldes den Wert null, nach dem Aufruf zeigt ding auf einen konkreten Gegenstand.

Beim Anzeigen eines Feldes können wir nun diesen Gegenstand einfach mitanzeigen. Dabei ist allerdings zu beachten, dass die Methode

public void anzeigen(Graphics g, int x, int y, int modus)

der Klasse Gegenstand die Koordinaten in Pixeln erwartet, während wir im Dungeon mit Zahlenwerten im Bereich zwischen 0 und 31 für die X-Achse bzw. 0 und 23 für die Y-Achse rechnen. Und damit wären wir auch schon bei der Übung 5.3.

Übung 5.3 (4 Punkte)

Ergänzen Sie Ihre Klasse Feld wie oben angegeben um das Attribut ding sowie die Methode hinterlegeGegenstand()

Schreiben Sie eine Methode

public Gegenstand entferneGegenstand()

welche einen Gegenstand wieder von dem Feld entfernt. Der entfernte Gegenstand wird dabei als Parameter zurückgegeben. Hierfür erhalten Sie zwei Punkte.

Ergänzen Sie außerdem die Methode

public void anzeigen(Graphics g)

der Klasse Feld so, dass das Attribut ding mitangezeigt wird, falls es nicht den Wert null hat. Das Bild des Gegenstandes soll möglichst zentriert in dem Feld dargestellt werden. Auch hierfür erhalten Sie zwei Punkte.

Ergänzen Sie schließlich die Klasse Dungeon um die Methode

public void hinterlegeGegenstand(int x, int y, Gegenstand neu)
{
   feld[x][y].hinterlegeGegenstand(neu);   
}

Öffnen Sie jetzt die Seite mit dem Test-Applet und kopieren Sie sich den Quelltext, so dass Sie Ihre Veränderungen testen können. Wenn alles klappt, müsste Ihr Spiel ungefähr so aussehen:

3 Das Spiel nach Übung 5.3

Diese HTML-Seite wurde erstellt von Ulrich Helmich am 8. Februar 2006





IMPRESSUM