Hallo liebes Forum,
im Verlauf meines Studiums haben wir nun die Aufgabe bekommen das Textbasierte Spiel "Die Welt von Zuul zu erweitern". Vielleicht kennen ein paar von euch dieses Spiel.
Auf jeden Fall haben wir eine Projektdatei bekommen und Aufgabenstellungen. Naja, bevor ich diese Aufgabenstellung überhaupt bearbeiten kann, musste ich einige Fehler dieses Spiels beheben (doppelter Code etc. pp., hat mich 1 1/2 Stunden gekostet, bin auch nicht wirklich gut in Programmierung
) und hoffe diese jetzt ausgemerzt zu haben.
Ich habe folgende Klassen, die ich zur Übersicht auch posten werde: Befehl, Befehlswoerter, Befehlswort, Parser, Raum und Spieler.
Nun zur Aufgabenstellung:
Ich soll eine Klasse Spieler hinzufügen. Ein Spieler-Objekt soll den aktuellen Raum halten, aber auch den Namen des Spielers. Des Weiteren sollen wir eine Erweiterung implementieren, bei der der Spieler beliebig viele Gegenstände aufnehmen kann (Mit den weiteren Befehlen take und drop).
Für die Aufnahme der Gegenstände soll es die Beschränkung geben, dass ein Spieler nur Gegenstände bis zu einem maximalen Gewicht an sich nehmen kann. Demnach soll die Tragkraft des Spielers eines seiner Attribute sein. Mit einem weiteren Befehl "status" sollen alle aufgenommenen Gegenstände mit Gesamtgewicht aufgelistet werden.
Zu guter letzt sollen wir in einem Raum einen magischen Muffin ablegen und durch den Befehl eat muffin, soll der Spieler den Muffin essen und so seine maximale Tragkraft erhöhen.
Ich hab nur keine Ahnung wie ich das Ganze angehen soll, da ich (s.o.) wirklich nicht der Hellste in der Programmierung bin, und hoffe ihr könnt mir hier ordentlich unter die Arme greifen.
Spiel:
Raum:
Parser:
Befehlswort:
Befehlswoerter:
im Verlauf meines Studiums haben wir nun die Aufgabe bekommen das Textbasierte Spiel "Die Welt von Zuul zu erweitern". Vielleicht kennen ein paar von euch dieses Spiel.
Auf jeden Fall haben wir eine Projektdatei bekommen und Aufgabenstellungen. Naja, bevor ich diese Aufgabenstellung überhaupt bearbeiten kann, musste ich einige Fehler dieses Spiels beheben (doppelter Code etc. pp., hat mich 1 1/2 Stunden gekostet, bin auch nicht wirklich gut in Programmierung
) und hoffe diese jetzt ausgemerzt zu haben.Ich habe folgende Klassen, die ich zur Übersicht auch posten werde: Befehl, Befehlswoerter, Befehlswort, Parser, Raum und Spieler.
Nun zur Aufgabenstellung:
Ich soll eine Klasse Spieler hinzufügen. Ein Spieler-Objekt soll den aktuellen Raum halten, aber auch den Namen des Spielers. Des Weiteren sollen wir eine Erweiterung implementieren, bei der der Spieler beliebig viele Gegenstände aufnehmen kann (Mit den weiteren Befehlen take und drop).
Für die Aufnahme der Gegenstände soll es die Beschränkung geben, dass ein Spieler nur Gegenstände bis zu einem maximalen Gewicht an sich nehmen kann. Demnach soll die Tragkraft des Spielers eines seiner Attribute sein. Mit einem weiteren Befehl "status" sollen alle aufgenommenen Gegenstände mit Gesamtgewicht aufgelistet werden.
Zu guter letzt sollen wir in einem Raum einen magischen Muffin ablegen und durch den Befehl eat muffin, soll der Spieler den Muffin essen und so seine maximale Tragkraft erhöhen.
Ich hab nur keine Ahnung wie ich das Ganze angehen soll, da ich (s.o.) wirklich nicht der Hellste in der Programmierung bin, und hoffe ihr könnt mir hier ordentlich unter die Arme greifen.
Spiel:
Java:
class Spiel {
private Parser parser;
private Raum aktuellerRaum;
/**
* Erzeuge ein Spiel und initialisiere die interne Raumkarte.
*/
public Spiel() {
raeumeAnlegen();
parser = new Parser();
}
/**
* Erzeuge alle Räume und verbinde ihre Ausgänge miteinander.
*/
private void raeumeAnlegen() {
Raum draussen, hoersaal, cafeteria, labor, buero, keller;
// die Räume erzeugen
draussen = new Raum("vor dem Haupteingang der FH");
hoersaal = new Raum("in einem Hörsaal");
cafeteria = new Raum("in der Cafeteria");
labor = new Raum("im Rechnerraum");
buero = new Raum("im Dekanant");
keller = new Raum("im Keller");
// die Ausgänge initialisieren
draussen.setzeAusgang("east", hoersaal);
draussen.setzeAusgang("south", labor);
draussen.setzeAusgang("west", cafeteria);
hoersaal.setzeAusgang("west", draussen);
cafeteria.setzeAusgang("east", draussen);
cafeteria.setzeAusgang("down", keller);
keller.setzeAusgang("up", cafeteria);
labor.setzeAusgang("east", buero);
labor.setzeAusgang("north",draussen);
buero.setzeAusgang("west", labor);
aktuellerRaum = draussen; // das Spiel startet draussen
}
/**
* Die Hauptmethode zum Spielen. Läuft bis zum Ende des Spiels in einer
* Schleife.
*/
public void spielen() {
willkommenstextAusgeben();
// Die Hauptschleife. Hier lesen wir wiederholt Befehle ein
// und führen sie aus, bis das Spiel beendet wird.
boolean beendet = false;
while (!beendet) {
Befehl befehl = parser.liefereBefehl();
beendet = verarbeiteBefehl(befehl);
}
System.out.println("Danke für dieses Spiel. Auf Wiedersehen.");
}
/**
* Einen Begrüßungstext für den Spieler ausgeben.
*/
private void willkommenstextAusgeben()
{
System.out.println();
System.out.println("Willkommen zu Zuul!");
System.out.println("Zuul ist ein neues, unglaublich langweiliges Spiel.");
System.out.println("Tippen sie 'help', wenn Sie Hilfe brauchen.");
System.out.println();
aktuellerRaum.gibRauminfo();
}
/**
* Verarbeite einen gegebenen Befehl (führe ihn aus).
*
* @param befehl
* Der zu verarbeitende Befehl.
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean verarbeiteBefehl(Befehl befehl) {
boolean moechteBeenden = false;
Befehlswort befehlswort = befehl.gibBefehlswort();
if (befehlswort == Befehlswort.UNKNOWN) {
System.out.println("Ich weiß nicht, was Sie meinen...");
return false;
}
if (befehlswort == Befehlswort.HELP) {
hilfstextAusgeben();
} else if (befehlswort == Befehlswort.GO) {
wechsleRaum(befehl);
} else if (befehlswort == Befehlswort.QUIT) {
moechteBeenden = beenden(befehl);
}
// ansonsten: Befehl nicht erkannt.
return moechteBeenden;
}
// Implementierung der Benutzerbefehle:
/**
* Gib Hilfsinformationen aus. Hier geben wir eine etwas alberne und unklare
* Beschreibung aus, sowie eine Liste der Befehlswörter.
*/
private void hilfstextAusgeben() {
System.out.println("Sie haben sich verlaufen. Sie sind allein.");
System.out.println("Sie irren auf dem Unigelände herum.");
System.out.println();
System.out.println("Ihnen stehen folgende Befehle zur Verfügung:");
parser.zeigeBefehle();
}
/**
* Versuche, den Raum zu wechseln. Wenn es einen Ausgang gibt, wechsele in
* den neuen Raum, ansonsten gib eine Fehlermeldung aus.
*/
private void wechsleRaum(Befehl befehl)
{
if(!befehl.hatZweitesWort()) {
// Gibt es kein zweites Wort, wissen wir nicht, wohin...
System.out.println("Wohin möchten Sie gehen?");
return;
}
String richtung = befehl.gibZweitesWort();
Raum naechsterRaum = aktuellerRaum.gibNaechstenRaum(richtung);
if (naechsterRaum == null)
System.out.println("Dort ist keine Tür!");
else {
aktuellerRaum = naechsterRaum;
String text = aktuellerRaum.gibRauminfo();
System.out.println(text);
}
}
/**
* "quit" wurde eingegeben. Überprüfe den Rest des Befehls, ob das Spiel
* wirklich beendet werden soll.
*
* @return 'true', wenn der Befehl das Spiel beendet, 'false' sonst.
*/
private boolean beenden(Befehl befehl) {
if (befehl.hatZweitesWort()) {
System.out.println("Was soll beendet werden?");
return false;
} else {
return true; // Das Spiel soll beendet werden.
}
}
public static void main(String[] args) {
Spiel sp = new Spiel();
sp.spielen();
}
}Raum:
Java:
class Raum
{
public String beschreibung;
private HashMap<String, Raum> ausgaenge; // die Ausgänge dieses Raums
public Raum nordausgang;
public Raum suedausgang;
public Raum ostausgang;
public Raum westausgang;
/**
* Erzeuge einen Raum mit einer Beschreibung. Ein Raum
* hat anfangs keine Ausgänge.
* @param beschreibung enthält eine Beschreibung in der Form
* "in einer Küche" oder "auf einem Sportplatz".
*/
public Raum(String beschreibung)
{
this.beschreibung = beschreibung;
ausgaenge = new HashMap<String, Raum>();
}
/**
* Definiere einen Ausgang für diesen Raum.
* @param richtung die Richtung, in der der Ausgang liegen soll
* @param nachbar der Raum, der über diesen Ausgang erreicht wird
*/
public void setzeAusgang(String richtung, Raum nachbar)
{
ausgaenge.put(richtung, nachbar);
}
/**
* @return die kurze Beschreibung dieses Raums (die dem Konstruktor
* übergeben wurde).
*/
public String gibKurzbeschreibung()
{
return beschreibung;
}
/**
* Liefere eine lange Beschreibung dieses Raums, in der Form:
* Sie sind in der Küche.
* Ausgänge: nord west
* @return eine lange Beschreibung dieses Raumes.
*/
public String gibLangeBeschreibung()
{
return "Sie sind " + beschreibung + ".\n" + gibAusgaengeAlsString();
}
/**
* Liefere eine Zeichenkette, die die Ausgänge dieses Raums
* beschreibt, beispielsweise
* "Ausgänge: north west".
* @return Eine Beschreibung der Ausgänge dieses Raumes.
*/
private String gibAusgaengeAlsString()
{
String ergebnis = "Ausgänge:";
Set<String> keys = ausgaenge.keySet();
for(String ausgang : keys)
ergebnis += " " + ausgang;
return ergebnis;
}
/**
* Liefere den Raum, den wir erreichen, wenn wir aus diesem Raum
* in die angegebene Richtung gehen. Liefere 'null', wenn in
* dieser Richtung kein Ausgang ist.
* @param richtung die Richtung, in die gegangen werden soll.
* @return den Raum in der angegebenen Richtung.
*/
public Raum gibAusgang(String richtung)
{
return ausgaenge.get(richtung);
}
/**
* rauminfoAusgeben, um doppelten Code in
* willkommenstextAusgeben und welchsleRaum zu verhindern.
public void rauminfoAusgeben()
{
System.out.println("Sie sind " + aktuellerRaum.gibBeschreibung());
System.out.print("Ausgänge: ");
if(aktuellerRaum.nordausgang != null)
System.out.print("north ");
if(aktuellerRaum.ostausgang != null)
System.out.print("east ");
if(aktuellerRaum.suedausgang != null)
System.out.print("south ");
if(aktuellerRaum.westausgang != null)
System.out.print("west ");
System.out.println();
}
*/
public String gibRauminfo()
{
Set<String> schluessel = ausgaenge.keySet();
String info="Sie sind " + beschreibung + "\n";
info += "Ausgänge: ";
for (String ausgang : schluessel) {
info = info + ausgang + ", ";
}
return info;
}
public Raum gibNaechstenRaum(String richtung)
{
// Wir versuchen den Raum zu verlassen.
Raum naechsterRaum = ausgaenge.get(richtung);
return naechsterRaum;
}
}Parser:
Java:
class Parser
{
private Befehlswoerter befehle; // hält die gültigen Befehlswörter
private Scanner leser; // Lieferant für eingegebene Befehle
/**
* Erzeuge einen Parser, der Befehle von der Konsole einliest.
*/
public Parser()
{
befehle = new Befehlswoerter();
leser = new Scanner(System.in);
}
/**
* @return Den nächsten Befehl des Benutzers.
*/
public Befehl liefereBefehl()
{
String eingabezeile; // für die gesamte Eingabezeile
String wort1 = null;
String wort2 = null;
System.out.print("> "); // Eingabeaufforderung
eingabezeile = leser.nextLine();
// Finde bis zu zwei Wörter in der Zeile
Scanner zerleger = new Scanner(eingabezeile);
if(zerleger.hasNext()) {
wort1 = zerleger.next(); // erstes Wort lesen
if (zerleger.hasNext()) {
wort2 = zerleger.next(); // zweites Wort lesen
// Hinweis: Wir ignorieren den Rest der Eingabezeile.
}
}
return new Befehl(befehle.gibBefehlswort(wort1), wort2);
}
/**
* Gib eine Liste der bekannten Befehlswörter aus.
*/
public void zeigeBefehle()
{
befehle.alleAusgeben();
}
}Befehlswort:
Java:
public enum Befehlswort
{
// Ein Wert für jedes Befehlswort, plus eines für nicht
// erkannte Befehle
GO("go"), QUIT("quit"), HELP("help"), UNKNOWN("?");
// Das Befehlswort als Zeichenkette.
private String befehlswort;
/**
* Initialisieren mit dem entsprechenden Befehlswort.
* @param befehlswort Das Befehlswort als Zeichenkette.
*/
Befehlswort(String befehlswort)
{
this.befehlswort = befehlswort;
}
/**
* @return Das Befehlswort als Zeichenkette.
*/
public String toString()
{
return befehlswort;
}
}Befehlswoerter:
Java:
class Befehlswoerter
{
// eine Abbildung von Befehlswörtern auf Elemente des
// Aufzählungstyps Befehlswort
private HashMap<String, Befehlswort> gueltigeBefehle;
/**
* Konstruktor - initialisiere die Befehlswörter.
*/
public Befehlswoerter()
{
gueltigeBefehle = new HashMap<String, Befehlswort>();
for(Befehlswort befehl : Befehlswort.values()) {
if(befehl != Befehlswort.UNKNOWN) {
gueltigeBefehle.put(befehl.toString(), befehl);
}
}
}
/**
* Finde das Befehlswort, das mit einem Befehls-String verknüpft ist.
* @param befehlswort das nachzuschlagende Wort.
* @return Das zugehörige Befehlswort zum dem Wort oder UNKNOWN,
* wenn das Wort kein gültiges Befehlswort ist.
*/
public Befehlswort gibBefehlswort(String wort)
{
Befehlswort befehlswort = gueltigeBefehle.get(wort);
if(befehlswort != null) {
return befehlswort;
}
else {
return Befehlswort.UNKNOWN;
}
}
/**
* Prüfe, ob eine gegebene Zeichenkette ein gültiger
* Befehl ist.
* @return 'true', wenn die gegebene Zeichenkette ein gültiger
* Befehl ist, 'false' sonst.
*/
public boolean istBefehl(String eingabe)
{
return gueltigeBefehle.containsKey(eingabe);
}
/**
* Gib alle gültigen Befehlswörter auf die Konsole aus.
*/
public void alleAusgeben()
{
for(String befehl : gueltigeBefehle.keySet()) {
System.out.print(befehl + " ");
}
System.out.println();
}
}
Java:
class Befehl
{
private Befehlswort befehlswort;
private String zweitesWort;
/**
* Erzeuge ein Befehlsobjekt. beide Parameter müssen angegeben werden,
* aber der zweite darf 'null' sein.
* @param befehlswort Das Befehlswort. UNKNOWN, wenn dieser Befehl nicht
* vom Spiel erkannt wurde.
* @param zweitesWort Das zweite Wort des Befehls. Darf null sein.
*/
public Befehl(Befehlswort befehlswort, String zweitesWort)
{
this.befehlswort = befehlswort;
this.zweitesWort = zweitesWort;
}
/**
* Liefere das Befehlswort (das erste Wort) dieses Befehls.
* Wenn der Befehl nicht verstanden wurde, ist das Ergebnis
* UNKNOWN.
* @return Das Befehlswort.
*/
public Befehlswort gibBefehlswort()
{
return befehlswort;
}
/**
* @return Das zweite Wort dieses Befehls. Liefere 'null', wenn
* es kein zweites Wort gab.
*/
public String gibZweitesWort()
{
return zweitesWort;
}
/**
* @return 'true', wenn dieser Befehl nicht verstanden wurde.
*/
public boolean istUnbekannt()
{
return (befehlswort == Befehlswort.UNKNOWN);
}
/**
* @return 'true', wenn dieser Befehl ein zweites Wort hat.
*/
public boolean hatZweitesWort()
{
return (zweitesWort != null);
}
}
