CODEWITHSUNDEEP
javaparsing
AwaX
AwaX

Reputation: 588

Best way to parse commands in a java text-based game

I'm developing a text based game in java and I'm looking for the best way to deal with player's commands. Commands allow the player to interact with the environment, like :

My objective is now to develop a complete set of those simple commands but I'm having trouble to find an easy way to parse it. I would like to develop a flexible and extensible parser which could call the main command like "look", "use", "attack", etc... and each of them would have a specific syntax and actions in the game.

I found a lot of tools to parse command line arguments like -i -v --verbose but none of them seems to have the sufficient flexibility to fit my needs. They can parse one by one argument but without taking into account a specific syntax for each of them. I tried JCommander which seems to be perfect but I'm lost between what is an argument, a parameter, who call who, etc...

So if someone could help me to pick the correct java library to do that, that would be great :)

Upvotes: 2

Views: 2981

Answers (3)

aioobe
aioobe

Reputation: 421040

Unless you're dealing with complex command strings that involve for instance arithmetic expressions or well balanced parenthesis I would suggest you go with a plain Scanner.

Here's an example that I would find readable and easy to maintain:

interface Action {
    void run(Scanner args);
}

class Drink implements Action {
    @Override
    public void run(Scanner args) {
        if (!args.hasNext())
            throw new IllegalArgumentException("What should I drink?");
        System.out.println("Drinking " + args.next());
    }
}

class Look implements Action {
    @Override
    public void run(Scanner args) {
        if (!args.hasNext())
            throw new IllegalArgumentException("Where should I look?");
        System.out.println("Looking " + args.next());
    }
}

And use it as

Map<String, Action> actions = new HashMap<>();
actions.put("look", new Look());
actions.put("drink", new Drink());

String command = "drink coke";

// Parse
Scanner cmdScanner = new Scanner(command);
actions.get(cmdScanner.next()).run(cmdScanner);

You could even make it fancier and use annotations instead as follows:

@Retention(RetentionPolicy.RUNTIME)
@interface Command {
    String value();
}

@Command("drink")
class Drink implements Action {
    ...
}

@Command("look")
class Look implements Action {
    ...
}

And use it as follows:

List<Action> actions = Arrays.asList(new Drink(), new Look());

String command = "drink coke";

// Parse
Scanner cmdScanner = new Scanner(command);
String cmd = cmdScanner.next();
for (Action a : actions) {
    if (a.getClass().getAnnotation(Command.class).value().equals(cmd))
        a.run(cmdScanner);
}

Upvotes: 2

Jason Hu
Jason Hu

Reputation: 6333

the fun part of it is to have some command is human readable, which at the same time, it's machine parsable.

first of all, you needs to define the syntax of your language, for example:

look (north|south|east|west)

but it's in regular expression, it's generally speaking not a best way to explain a syntactical rule, so i would say this is better:

Sequence("look", Xor("north", "south", "east", "west"));

so by doing this, i think you've got the idea. you need to define something like:

public abstract class Syntax { public abstract boolean match(String cmd); }

then

public class Atom extends Syntax { private String keyword; }

public class Sequence extends Syntax { private List<Syntax> atoms; }

public class Xor extends Syntax { private List<Syntax> atoms; }

use a bunch of factory functions to wrap the constructors, returning Syntax. then you will have something like this eventually:

class GlobeSyntax
{
    Syntax syntax = Xor( // exclusive or
         Sequence(Atom("look"), 
                  Xor(Atom("north"), Atom("south"), Atom("east"), Atom("west"))),
         Sequence(Atom("drink"),
                  Or(Atom("Wine"), Atom("Drug"), Atom("Portion"))), // may drink multiple at the same time
         /* ... */
    );
}

or so.

now what you need is just a recursive parser according to these rules.

you can see, it's recursive structure, very easy to code up, and very easy to maintain. by doing this, your command is not only human readable, but machine parsable.

sure it's not finished yet, you needs to define action. but it's easy right? it's typical OO trick. all to need to do is to perform something when Atom is matched.

Upvotes: 1

dkatzel
dkatzel

Reputation: 31648

I don't think you want to parse command line arguments. That would mean each "move" in your game would require running a new JVM instance to run a different program and extra complexity of saving state between JVM sessions etc.

This looks like a text based game where you prompt users for what to do next. You probably just want to have users enter input on STDIN.

Example, let's say your screen says:

You are now in a dark room. There is a light switch what do you want to do?

1. turn on light
2. Leave room back the way you came.

Please choose option:

then the user types 1 or 2 or if you want to be fancy turn on light etc. then you readLine() from the STDIN and parse the String to see what the user chose. I recommend you look at java.util.Scannerto see how to easily parse text 

Scanner scanner = new Scanner(System.in);
String userInput = scanner.readLine();
//parse userInput string here

Upvotes: 1

Related Questions