Main startet nicht bei vorgegebenen Code

Diskutiere Main startet nicht bei vorgegebenen Code im Java Basics - Anfänger-Themen Bereich.
J

JustNobody

Aber da sieht man doch direkt den Kommentar Placeholder mit dem return null;

Das sieht ja fast so aus, als ob man da etwas Code schreiben müsste ... Und eine NPE ist auch logisch, wenn bei der Factory nur null zurück kommt...
 
T

Tasmani

Vermutlich soll ich die Klasse TextAdventureException anwenden in der factory? Diese Exceptions machen es ja einem echt schwer :/ Wenn ich dieses exception problem lösen könnte wäre das schon genug.

Code:
package ias;

/**
* General Exception-type of the text adventure framework.
*/
public class TextAdventureException extends Exception {

    /**
     * Exception Prefix.
     */
    public static final String ERROR = "Error! ";

    /**
     * Creates a new TextAdventureException with the given message.
     * @param message The error-message
     */
    public TextAdventureException(String message) {
        super(ERROR + message);
    }
}
 
T

Tasmani

Die NullpointerException bedeutet doch das auf ein Objekt zugegriffen wird welches noch gar nicht instanziert wurden ist oder? In diesem Fall

Exception in thread "main" java.lang.NullPointerException
at ias.Adventures.getFiremanGame(Adventures.java:18)
at student.Main.main(Main.java:22)

wobei auf folgende Zeile verwiesen wird:

textAdventure.addSceneryType("BurningTree", "A blazing fire on an oak tree.");

In dieser Zeile wird die methode addSceneryType() auf das Objekt textAdventure angewendet. Dann vermute ich mal das textAdventure erst als Objekt vorliegen muss, also es wurde noch gar nicht erzeugt. Wenn das richtig ist, aus welche Klasse erzeuge ich dann textAdventure?

Ich denke mal nicht aus dem Interface TextAdventure.java, da dies ja lediglich nur ein Interface ist, welches noch implementiert werden muss in einer Klasse, um dann von dieser Klasse eine Instanz zu erzeugen.

Vielleicht muss ich auch selbst eine Klasse textAdventure schreiben in der ich das Interface TextAdventure.java implementiere. Das ist echt alles blöd ...

In der Aufgabenstellung steht:

Das Interface TextAdventure, dessen Methoden Sie implementieren mussen, ermoglicht
es ein Text-Adventure-Game anzulegen. Im Paket student finden Sie eine Klasse
Main, die das Interface TextAdventure nutzt, um verschiedene Spiele zu initialisieren.
Diese konnen Sie nach erfolgreicher Implementierung der Interfaces
durchspielen. Die Spielszenarien sollen Ihnen beim ausgiebigen Testen Ihres Codes
helfen. Fur die Interaktion mit dem Spiel stehen Ihnen alle Methoden des
Interface Player zur Verfugung. Schauen Sie sich hierzu auch die Klasse Game-
Starter an. In dieser ist die Interaktion mit dem Spieler implementiert. Unsere
automatisierten Tests benutzen ebenfalls das Interface TextAdventure um Test-
Spielszenarios zu erstellen.
Das Interface TextAdventure bietet verschiedene Methoden, um ein neues Spiel
zu erzeugen. Uberlegen Sie sich fur jede Methode, in welchen Fallen ihre Ausfuhrung
fehlschlagen kann.
Werfen Sie in diesen Fallen eine TextAdventureException.
Diese wird Ihnen ebenfalls im Paket ias zur Verfugung gestellt. Sobald der
gewunschte Ausgangszustand hergestellt ist, kann mit startGame ein Spiel gestartet
werden.

Das schwarzgedruckte ist klar, das kann man für jede methode mit einer try catch Befehl lösen. Aber dieses Nullpointerproblem bekomm ich einfach nicht hin.
 
L

LimDul

Vielleicht muss ich auch selbst eine Klasse textAdventure schreiben in der ich das Interface TextAdventure.java implementiere. Das ist echt alles blöd ...

In der Aufgabenstellung steht:

Diese konnen Sie nach erfolgreicher Implementierung der Interfaces
durchspielen.
Merkst du was? :)
 
T

Tasmani

okay, ich denke ich hab es jetzt verstanden. Es läuft glaube ich auf sowas hinaus

public class Spiel implements TextAdventure {

hier die methoden von TextAdventure implementieren; }

Am Ende ein Objekt hier von erzeugen
Spiel textAdventure = new Spiel();

Wieso der Name textAdventure? Weil in der vorgegebenen Klasse
adventures.java methoden auf das Objekt textAdventure angewendet werden.
Ziel ist es erst einmal das Objekt textAdventure somit zu erzeugen.

Die ähnlichen Namen textAdventure=Objekt das ich erzeugen muss aus einer von mir geschriebenen Klasse und TextAdventure=interface welches vorgegeben ist, die ich in der von mir geschriebenen Klasse implementiere (die methoden also innerhalb TextAdventure), sollen uns Studenten nur verwirren. Vermute ich mal.
 

Anhänge

J

JustNobody

Also wir haben nur einen begrenzen Einblick, aber der Hinweis bezüglich Factory Klasse ist ja schon gekommen.... auch der dezente Hinweis, dass da ja ein Student Ordner ist ....

Und dein Ausschnitt hat gezeigt, dass da etwas gefüllt werden soll ....

Was hindert dich daran, da los zu legen?
 
mrBrown

mrBrown

okay, ich denke ich hab es jetzt verstanden. Es läuft glaube ich auf sowas hinaus

public class Spiel implements TextAdventure {

hier die methoden von TextAdventure implementieren; }
Zumindest der Teil ist noch völlig korrekt.

Am Ende ein Objekt hier von erzeugen
Spiel textAdventure = new Spiel();

Wieso der Name textAdventure? Weil in der vorgegebenen Klasse
adventures.java methoden auf das Objekt textAdventure angewendet werden.
Ziel ist es erst einmal das Objekt textAdventure somit zu erzeugen.

Die ähnlichen Namen textAdventures=Objekt das ich erzeugen muss aus einer von mir geschriebenen Klasse und TextAdventure=interface welches vorgegeben ist sollen uns tudenten nur verwirren. Vermute ich mal.
Aber hier wird's dann völlig merkwürdig...

Der Code in dem Screenshot steht in einer Klasse, die du nicht anfassen sollst – der Name einer dort deklarieren lokalen Variable ist völlig irrelevant für alles außerhalb der jeweiligen Methode.

Außer der Implementierung von TextAdventure muss muss auch in Factory was angepasst werden – an der Stelle, wo extra Placeholder steht.
 
T

temi

Um mal ein Beispiel zu machen:
Java:
// ein gegebenes Interface
interface Foo {
    void doSomething();
}

// eine gegebene Hauptklasse - soll nicht geändert werden!
class Main {
   
    public static void main(String[] args) {
        Foo foo = Factory.getFoo();
        foo.doSomething();
        // mehr code..
    }
}

// Factory-Klasse, die ein Foo erzeugen soll
class Factory {
    public static Foo getFoo() {
        return new MyFoo();
    }
}

// Klasse, die Foo implementiert
class MyFoo implements Foo {
   
    public void doSomething() {
        // code..
    }
}
In der Factory-Klasse wird festgelegt, welches konkrete Foo in der Main später verwendet wird. Solltest du also später einmal eine neue Klasse class MyNewSuperFoo implements Foo erstellen, dann kannst du die einfach in der Factory austauschen, die Main-Klasse wird davon nichts bemerken.
 
Zuletzt bearbeitet:
T

Tasmani

Hey, ich bekomme das einfach nicht hin. Das Progamm will einfach nicht starten. Ich habe jetzt mehrere Stunden probiert und überlegt. Andauenrd dieselbe fehlermeldung. Ich möchte zunächst lediglich erreichen dass das Programm startet.
 
T

Tasmani

Den Studet Ordner darf ich ändern

Code:
package student;

/**
 * Factory class with functions to generate a game and terminal.
 */
public final class Factory   {
    
    private Factory() { }
        
    /**
     * Creates a new game-instance with an empty board of the given size.
     * @param name The name of the game
     * @param boardWidth the width of the board
     * @param boardHeight the height of the board
     * @return a fresh game instance
     * @throws ias.TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    public static ias.TextAdventure getGame(String name, int boardWidth, int boardHeight)
            throws ias.TextAdventureException {
        //placeholder
        return null;
    }

    /**
     * Creates a new terminal-instance to read user input and prompt messages.
     * @return a terminal instance
     */
    public static ias.Terminal getTerminal() {
        //placeholder
        return null;
    }
}
Code:
package student;

import ias.Adventures;
import ias.TextAdventureException;
import ias.GameStarter;
import ias.TextAdventure;

/**
 * Main class, serves as an entry point to the program.
 */
public class Main  {

    /**
     * Main method which serves as an entry to the program.
     * @param args terminal parameters
     */
    public static void main(String[] args) {
        try {
            
            // Add additional games to the Array
            TextAdventure[] games = {
                    Adventures.getFiremanGame(), Adventures.getLumberjackGame(), Adventures.getPokemonGame()
            };
            GameStarter starter = new GameStarter(games);
            starter.startGame();
        } catch (TextAdventureException e) {
            e.printStackTrace();
        }

    }
}
 
T

Tasmani

Den IAS Ordner darf ich nicht ändern.

Code:
package ias;

import student.Factory;

/**
 * Class with text adventure scenarios to play.
 */
public class Adventures {

    /**
     * Initialize the fireman-game.
     *
     * @return the fireman-game
     * @throws TextAdventureException
     */
    public static ias.TextAdventure getFiremanGame() throws TextAdventureException {
        ias.TextAdventure textAdventure = Factory.getGame("Sample1", 2, 2);
        textAdventure.addSceneryType("BurningTree", "A blazing fire on an oak tree.");
        textAdventure.addSceneryType("HalfBurningTree", "A little fire on an oak tree.");
        textAdventure.addItemType("Bucket", "An empty bucket.");
        textAdventure.addItemType("Water", "A bucket full of water.");
        textAdventure.addItemType("Head", "Kopf");
        textAdventure.addItemType("Headweh", "Jetzt brummt de kopf");
        textAdventure.addSceneryType("Lake", "A beautiful lake.");
        textAdventure.addSceneryType("CharredOak", "A poor, charred oak tree.");
        textAdventure.addTransformation("Bucket", "Lake", "Water", "Lake",
                "Now you got a bucket full of water.");
        textAdventure.addTransformation("Water", "BurningTree", "HalfBurningTree", "Bucket",
                "The water quenches the fire. But not completely.");
        textAdventure.addTransformation("Water", "HalfBurningTree", "CharredOak", "Bucket",
                "The water quenches the fire.");
        textAdventure.addComposition("Bucket", "Head", "Headweh", "Kopfwehh");
        textAdventure.placeItem("Lake", 0, 0);
        textAdventure.placeItem("Bucket", 1, 1);
        textAdventure.placeItem("Head", 1, 1);
        textAdventure.placeItem("BurningTree", 0, 0);
        return textAdventure;
    }

    /**
     * Initialize the lumberjack-game.
     *
     * @return The lumberjack-game
     * @throws TextAdventureException
     */
    public static ias.TextAdventure getLumberjackGame() throws TextAdventureException {
        ias.TextAdventure textAdventure = Factory.getGame("Sample2", 1, 1);
        textAdventure.addSceneryType("Tree", "A lush green tree.");
        textAdventure.addItemType("Wood", "Some pieces of wood");
        textAdventure.addSceneryType("Roots", "The sad roots of a former tree.");
        textAdventure.addDecomposition("Tree", "Wood", "Roots", "You fell the tree and get some wood.");
        textAdventure.placeItem("Tree", 0, 0);
        return textAdventure;
    }


    /**
     * Initialize the pokemon-game.
     *
     * @return the pokemon-game
     * @throws TextAdventureException
     */
    public static ias.TextAdventure getPokemonGame() throws TextAdventureException {
        TextAdventure textAdventure = Factory.getGame("Pokemon", 50, 50);

        textAdventure.addItemType("Coin", "One coin");
        textAdventure.addItemType("Money", "Many coins");
        textAdventure.addItemType("Bisasam", "Look, a wild Bisasam.");
        textAdventure.addItemType("Glumanda", "Look, a wild Glumanda.");
        textAdventure.addItemType("Schiggy", "Look, a wild Schiggy.");
        textAdventure.addItemType("Bisaknosp", "Bisaknosp eats plants.");
        textAdventure.addItemType("Glutexo", "Glutexo burns.");
        textAdventure.addItemType("Schillok", "Schillok swimming around.");
        textAdventure.addItemType("Bisaflor", "Bisaflor eats plants.");
        textAdventure.addItemType("Glurak", "Glurak burns.");
        textAdventure.addItemType("Turtok", "Turtok swimming around.");
        textAdventure.addItemType("Taubsi", "Taubsi flying around.");
        textAdventure.addItemType("Tauboga", "Tauboga flying around.");
        textAdventure.addItemType("Tauboss", "Tauboss flying around.");
        textAdventure.addItemType("Mewtu", "Mewtu sees dead people.");
        textAdventure.addItemType("Developmentstone",
                "The Developmentstone brings your Pokemon to the next Level.");
        textAdventure.addItemType("Attackstone",
                "The Attackstone is in combination with your Pokemon to attack other Pokemons.");
        textAdventure.addItemType("Pokeball",
                "Pokeball is there to catch other Pokemons.");
        textAdventure.addSceneryType("Wildtaubsi", "Look, a wild Taubsi.");
        textAdventure.addSceneryType("Deadtaubsi", "Look, a dead Taubsi.");
        textAdventure.addSceneryType("Silvertreasure", "Look, a Treasure.");
        textAdventure.addSceneryType("Goldtreasure", "Look, a Treasure.");
        textAdventure.placeItem("Coin", 0, 0);
        textAdventure.placeItem("Bisasam", 0, 0);
        textAdventure.placeItem("Glumanda", 0, 0);
        textAdventure.placeItem("Schiggy", 0, 0);
        textAdventure.placeItem("Developmentstone", 2, 4);
        textAdventure.placeItem("Developmentstone", 25, 31);
        textAdventure.placeItem("Developmentstone", 49, 11);
        textAdventure.placeItem("Developmentstone", 22, 22);
        textAdventure.placeItem("Developmentstone", 11, 44);
        textAdventure.placeItem("Developmentstone", 23, 43);
        textAdventure.placeItem("Developmentstone", 39, 1);
        textAdventure.placeItem("Developmentstone", 22, 21);
        textAdventure.placeItem("Developmentstone", 45, 30);
        textAdventure.placeItem("Developmentstone", 10, 12);
        textAdventure.placeItem("Developmentstone", 23, 1);
        textAdventure.placeItem("Developmentstone", 49, 49);
        textAdventure.placeItem("Developmentstone", 17, 15);
        textAdventure.placeItem("Attackstone", 1, 1);
        textAdventure.placeItem("Attackstone", 10, 10);
        textAdventure.placeItem("Attackstone", 20, 20);
        textAdventure.placeItem("Attackstone", 30, 30);
        textAdventure.placeItem("Attackstone", 4, 5);
        textAdventure.placeItem("Attackstone", 10, 2);
        textAdventure.placeItem("Attackstone", 23, 44);
        textAdventure.placeItem("Attackstone", 30, 35);
        textAdventure.placeItem("Pokeball", 1, 1);
        textAdventure.placeItem("Pokeball", 3, 22);
        textAdventure.placeItem("Pokeball", 17, 21);
        textAdventure.placeItem("Pokeball", 33, 13);
        textAdventure.placeItem("Pokeball", 45, 22);
        textAdventure.placeItem("Pokeball", 21, 13);
        textAdventure.placeItem("Pokeball", 19, 41);
        textAdventure.placeItem("Pokeball", 12, 32);
        textAdventure.placeItem("Wildtaubsi", 2, 2);
        textAdventure.placeItem("Wildtaubsi", 23, 24);
        textAdventure.placeItem("Wildtaubsi", 11, 7);
        textAdventure.placeItem("Wildtaubsi", 3, 9);
        textAdventure.placeItem("Wildtaubsi", 32, 45);
        textAdventure.placeItem("Wildtaubsi", 31, 29);
        textAdventure.placeItem("Wildtaubsi", 17, 31);
        textAdventure.placeItem("Wildtaubsi", 45, 45);
        textAdventure.placeItem("Wildtaubsi", 18, 32);
        textAdventure.placeItem("Wildtaubsi", 26, 42);
        textAdventure.placeItem("Wildtaubsi", 42, 26);
        textAdventure.placeItem("Wildtaubsi", 17, 49);
        textAdventure.placeItem("Wildtaubsi", 11, 22);
        textAdventure.placeItem("Wildtaubsi", 36, 39);
        textAdventure.placeItem("Wildtaubsi", 31, 24);
        textAdventure.placeItem("Silvertreasure", 2, 3);
        textAdventure.placeItem("Silvertreasure", 32, 33);
        textAdventure.placeItem("Silvertreasure", 14, 13);
        textAdventure.placeItem("Silvertreasure", 47, 11);
        textAdventure.placeItem("Silvertreasure", 12, 34);
        textAdventure.placeItem("Silvertreasure", 21, 33);
        textAdventure.placeItem("Silvertreasure", 43, 21);
        textAdventure.placeItem("Silvertreasure", 49, 3);
        textAdventure.placeItem("Silvertreasure", 12, 49);
        textAdventure.placeItem("Silvertreasure", 41, 34);
        textAdventure.placeItem("Silvertreasure", 12, 33);
        textAdventure.placeItem("Silvertreasure", 22, 34);
        textAdventure.placeItem("Silvertreasure", 1, 40);
        textAdventure.placeItem("Silvertreasure", 19, 28);
        textAdventure.placeItem("Silvertreasure", 45, 32);
        textAdventure.placeItem("Silvertreasure", 21, 23);
        textAdventure.placeItem("Goldtreasure", 33, 34);
        textAdventure.addComposition("Coin", "Coin", "Money", "You made money");
        textAdventure.addComposition("Bisasam", "Developmentstone", "Bisaknosp",
                "Look your Bisasam has developed to Bisaknosp.");
        textAdventure.addComposition("Glumanda", "Developmentstone", "Glutexo",
                "Look your Glumanda has developed to Glutexo.");
        textAdventure.addComposition("Schiggy", "Developmentstone", "Schillok",
                "Look your Schiggy has developed to Schillok.");
        textAdventure.addComposition("Taubsi", "Developmentstone", "Tauboga",
                "Look your Taubsi has developed to Tauboga");
        textAdventure.addComposition("Bisaknosp", "Developmentstone", "Bisaflor",
                "Look your Bisaknosp has developed to Bisaflor");
        textAdventure.addComposition("Glutexo", "Developmentstone", "Glurak",
                "Look your Glutexo has developed to Glurak");
        textAdventure.addComposition("Schillok", "Developmentstone", "Turtok",
                "Look your Schillok has developed to Turtok");
        textAdventure.addComposition("Tauboga", "Developmentstone", "Tauboss",
                "Look your Tauboga has developed to Tauboss");
        textAdventure.addComposition("Wildtaubsi", "Attackstone", "Deadtaubsi",
                "Your Pokemon attacks the wild Taubsi. Taubsi is dead.");
        textAdventure.addComposition("Wildtaubsi", "Pokeball", "Taubsi",
                "You have catch Taubsi. Congratulations, Taubsi is your new Pokemon.");
        textAdventure.addDecomposition("Silvertreasure", "Developmentstone",
                "Attackstone",
                "You open the treasure and you find an Attack- and Developmentstone.");
        textAdventure.addDecomposition("Goldtreasure", "Pokeball", "Mewtu",
                "See, you find the unique Mewtu.");
        textAdventure.addTransformation("Taubsi", "Attackstone", "Taubsi",
                "Developmentstone",
                "Look, your Taubsi transform the Attackstone to a Developmentstone.");
        textAdventure.addTransformation("Tauboga", "Attackstone", "Tauboga",
                "Developmentstone",
                "Look, your Tauboga transform the Attackstone to a Developmentstone.");
        textAdventure.addTransformation("Tauboss", "Attackstone", "Tauboss",
                "Developmentstone",
                "Look, your Tauboss transform the Attackstone to a Developmentstone.");
        textAdventure.addTransformation("Mewtu", "Developmentstone", "Mewtu",
                "Attackstone",
                "Look, your Mewtu transform the Developmentstone to a Attackstone.");
        textAdventure.addTransformation("Bisasam", "Attackstone", "Bisasam",
                "Pokeball",
                "Look, your Bisasam transform the Attackstone to a Pokeball.");
        textAdventure.addTransformation("Bisaknosp", "Attackstone", "Bisaknosp",
                "Pokeball",
                "Look, your Bisaknosp transform the Attackstone to a Pokeball.");
        textAdventure.addTransformation("Bisaflor", "Attackstone", "Bisaflor",
                "Pokeball",
                "Look, your Bisaflor transform the Attackstone to a Pokeball.");
        textAdventure.addTransformation("Glumanda", "Pokeball", "Glumanda",
                "Developmentstone",
                "Look, your Glumanda transform the Pokeball to a Developmentstone.");
        textAdventure.addTransformation("Glutexo", "Pokeball", "Glutexo",
                "Developmentstone",
                "Look, your Glutexo transform the Pokeball to a Developmentstone.");
        textAdventure.addTransformation("Glurak", "Pokeball", "Glurak",
                "Developmentstone",
                "Look, your Glurak transform the Pokeball to a Developmentstone.");
        textAdventure.addTransformation("Schiggy", "Pokeball", "Schiggy",
                "Attackstone",
                "Look, your Schiggy transform the Pokeball to a Attackstone.");
        textAdventure.addTransformation("Schillok", "Pokeball", "Schillok",
                "Attackstone",
                "Look, your Schillok transform the Pokeball to a Attackstone.");
        textAdventure.addTransformation("Turtok", "Pokeball", "Turtok",
                "Attackstone",
                "Look, your Turtok transform the Pokeball to a Attackstone.");

        return textAdventure;
    }
}
Code:
package ias;

import student.Factory;

/**
 * Class integrates the implementation of the student package and allows to play the text adventure scenarios.
 */
public class GameStarter {

    private static final String PROMPT = "play>";
    private static Player player;
    private Terminal terminal;
    private TextAdventure[] games;

    /**
     * Constructor to create a GameStarter instance.
     * @param games array with text adventures games to play
     */
    public GameStarter(TextAdventure[] games) {
        terminal = Factory.getTerminal();
        this.games = games;
    }

    /**
     * Starts one of the given games.
     */
    public void startGame() {
        String[] input;
        String prompt = "Play (";
        for (TextAdventure game : this.games) {
            prompt += game.getName();
            prompt += "|";
        }
        prompt = prompt.substring(0, prompt.length() - 1) + ")";
        do {
            terminal.promptInput(prompt);
            input = terminal.readInput();
        } while (input[0].equals("") || input[0].equals(" "));


        String gameName = input[0];
        for (TextAdventure game : this.games) {
            if (game.getName().equals(gameName)) {
                startGame(game, 0, 0);
                return;
            }
        }
        System.out.println("Unknown game scenario");
        System.exit(1);


    }

    /**
     * Starts a given game and runs a simple input-loop that accepts game-commands.
     * @param textAdventure to play
     * @param x coordinate of the player
     * @param y coordinate of the player
     */
    public void startGame(TextAdventure textAdventure, int x, int y) {
        try {
            player = textAdventure.startGame(x, y);
        } catch (TextAdventureException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
        boolean run = true;
        while (run) {
            try {
                terminal.promptInput(PROMPT);
                String[] input = terminal.readInput();
                run = processInput(input);
            } catch (TextAdventureException e) {
                System.out.println(e.getMessage());
            }
        }
    }


    /**
     * Process the given command-line, translate it into player-actions if possible.
     * @param input the splitted user input
     * @return false if the user wants to quit, true otherwise
     * @throws TextAdventureException If an invalid command is entered
     */
    private static boolean processInput(String[] input) throws TextAdventureException {
        switch (input[0]) {
            case "go": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify a direction.");
                } else {
                    System.out.println(player.go(input[1]));
                }
                return true;
            }
            case "look": {
                String[] list = player.look();
                for (String line : list) {
                    System.out.println(line);
                }
                return true;
            }
            case "inventory": {
                String[] list = player.inventory();
                for (String line : list) {
                    System.out.println(line);
                }
                return true;
            }
            case "take": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify an object.");
                } else {
                    System.out.println(player.take(input[1]));
                }
                return true;
            }
            case "drop": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify an object.");
                } else {
                    System.out.println(player.drop(input[1]));
                }
                return true;
            }
            case "convert": {
                if (input.length < 3) {
                    System.out.println("Sorry, please specify the objects to compose.");
                } else {
                    System.out.println(player.convert(input[1], input[2]));
                }
                return true;
            }
            case "decompose": {
                if (input.length < 2) {
                    System.out.println("Sorry, please specify an object.");
                } else {
                    System.out.println(player.decompose(input[1]));
                }
                return true;
            }
            case "help": {
                System.out.println("Valid Commands are: go, look, inventory, take, drop, compose, decompose");
                return true;
            }
            case "exit": {
                System.out.println("Bye!");
                return false;
            }
            default: {
                throw new TextAdventureException("Unknown Command: " + input[0]);
            }
        }
    }
}
Code:
package ias;

/**
 * Models the interface of a text adventure player.
 */
public interface Player {

    /**
     * Move the player's token into direction.
     * @param direction One of eight valid directions "N", "NE", "E", "SE", "S", "SW", "W", "NW"
     * @return A ui-message for the user
     */
    String go(String direction);

    /**
     * Returns an array of objects on the current field.
     * @return An array of object-type and descriptions for the ui
     */
    String[] look();
    
    /**
     * Returns an array of objects in the inventory.
     * @return An array of object-type and descriptions for the ui
     */
    String[] inventory();

    /**
     * Removes an object of the given type from the current field and adds it to the inventory.
     * @param item An object-type
     * @return A ui-message for the user
     */
    String take(String item);
    
    /**
     * Removes an object of the given type from the inventory and adds it to the current field.
     * @param item An object-type
     * @return A ui-message for the user
     */
    String drop(String item);

    /**
     * Applies a transformation- or composition-rule to item1 and item2.
     * If possible, removes item1 and item2 from the current field or inventory
     * and adds the mutation-result to the current field or inventory,
     * depending on the object's base-type (scenery or item).
     * @param item1 An Object-Type
     * @param item2 An Object-Type
     * @return A ui-message for the user
     */
    String convert(String item1, String item2);
    
    /**
     * Applies a decomposition-rule to item.
     * If possible, removes item from the current field or inventory
     * and adds the mutation-result to the current field or inventory,
     * depending on the object's base-type (scenery or item).
     * @param item An Object-Type
     * @return A ui-message for the user
     */
    String decompose(String item);
}
Code:
package ias;

/**
 * Models the interface of terminal to interact with a player.
 */
public interface Terminal {

    /**
     * Prompts the user to enter a string as input. The string is printed to the standard output (terminal).
     *
     * @param input the message to display the player
     */
    public void promptInput(String input);

    /**
     * Reads the user input and returns splitted at spaces as string array.
     * @return splitted user input string
     */
    public String[] readInput();

}
Code:
package ias;

/**
 * Models the interface of a text adventure game-instance.
 */
public interface TextAdventure {

    /**
     * Declares a new portable object-type with given id and description.
     * @param id The id object-type, used in the ui to search for objects
     * @param description The description of the object-type
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addItemType(String id, String description) throws TextAdventureException;
    
    /**
     * Declares a new non-portable object-type with given id and description.
     * @param id The id object-type, used in the ui to search for objects
     * @param description The description of the object-type
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addSceneryType(String id, String description) throws TextAdventureException;

    /**
     * Adds a new object of the given type to the field at the specified position.
     * @param type The id of an object-type
     * @param x A field coordinate on the board
     * @param y A field coordinate on the board
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void placeItem(String type, int x, int y) throws TextAdventureException;

    /**
     * Adds a new composition-rule to the set of mutation-rules.
     * @param in1 Object-type id of the input-object
     * @param in2 Object-type id of the input-object
     * @param out Object-type id of the output-object
     * @param description Mutation-description for the ui
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addComposition(String in1, String in2, String out, String description) throws TextAdventureException;
    
    /**
     * Adds a new decomposition-rule to the set of mutation-rules.
     * @param in Object-type id of the input-object
     * @param out1 Object-type id of the output-object
     * @param out2 Object-type id of the output-object
     * @param description Mutation-description for the ui
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addDecomposition(String in, String out1, String out2, String description) throws TextAdventureException;
    
    /**
     * Adds a new transformation-rule to the set of mutation-rules.
     * @param in1 in1 Object-type id of the input-object
     * @param in2 in1 Object-type id of the input-object
     * @param out1 Object-type id of the output-object
     * @param out2 Object-type id of the output-object
     * @param description Mutation-description for the ui
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    void addTransformation(String in1, String in2, String out1, String out2, String description)
            throws TextAdventureException;

    /**
     * Initializes a new game instance and returns a player-instance for game-control.
     * The player's initial position is at the given coordinates
     * @param x A field coordinate on the board
     * @param y A field coordinate on the board
     * @return A player-instance for game-control
     * @throws TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
    Player startGame(int x, int y) throws TextAdventureException;

    /**
     * Returns the name of the game instance.
     * @return the name of the game instance
     */
    String getName();
}
Code:
package ias;

/**
 * General Exception-type of the text adventure framework.
 */
public class TextAdventureException extends Exception {

    /**
     * Exception Prefix.
     */
    public static final String ERROR = "Error! ";

    /**
     * Creates a new TextAdventureException with the given message.
     * @param message The error-message
     */
    public TextAdventureException(String message) {
        super(ERROR + message);
    }
}
 
T

Tasmani

Seit 10 Stunden am probieren und überlegen. Ich würde lediglich es schaffen, dass dass Programm sartet ohne die Implementationen der ganzen Methode.
 
T

temi

Und was sollte die Methode zurückgeben?
Hint: Steht sogar im Javadoc ;)
Java:
    /**
     * Creates a new game-instance with an empty board of the given size.
     * @param name The name of the game
     * @param boardWidth the width of the board
     * @param boardHeight the height of the board
     * @return a fresh game instance
     * @throws ias.TextAdventureException Think about the cases in which an exception is useful and implement it.
     */
 
T

Tasmani

Ich glaube die Gamestarter.java Klasse und Adventures.java Klasse aus dem package ias sollen in der Klasse Factory.java aus dem package student integriert werden oder?
 
Thema: 

Main startet nicht bei vorgegebenen Code

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben