Commands to Objects

Hey All,

I'm trying to write an object which takes a keyboard-entered string, tokenizes it, creates 'Action-related' objects out of the tokens, and then constructs an Action object with the objects as parameters.

I am going to delete most of this post because my second post is now more relevant.
[ December 09, 2008: Message edited by: Alex Birmingham ]

Update:

The beginnings are still humble, but the class has been fleshed out a bit. Upon instantiation of CommandFilter, a list of Action sub-classes is created, and that list is used to map a HashMap of strings and their corresponding cued classes. Next step, in theory, is to work on parsing Action-related objects from the rest of the user-entered command, and then to use reflection-built-constructor to instantiate the Action sub-class with those objects.

*Wipes sweat from brow*

What do you guys think, is this the right solution here?

Here's the CommandFilter code:

public class CommandFilter {

private static ArrayList<Class<? extends Action>> actionClasses;
private static HashMap<String, Class<? extends Action>> actionCommands;
 
// Constructor
public CommandFilter() {
actionCommands = new HashMap<String, Class<? extends Action>>();
actionClasses = new ArrayList<Class<? extends Action>>();
actionClasses.add(Attack.class);
actionClasses.add(Cast.class);
actionClasses.add(Move.class);
actionClasses.add(Stand.class);
generateActionCommands();
}

// User enters command
public DisplayEvent command(String cmd) {
cmd = cmd.toLowerCase();
String[] tokens = cmd.split(" ");
System.out.println(tokens.length);
System.out.println(actionCommands.keySet());
Class<? extends Action> actionClass = null;
if(tokens.length > 0)
actionClass = getActionClass(tokens[0]);
if(actionClass == null)
return new DisplayEvent(0, "You want to do what?");

// Deal with the rest of the tokens
// Instantiate Action object
return new DisplayEvent();
}
 
// Scour HashMap for appropriate class
private Class<? extends Action> getActionClass(String cmd) {
System.out.println(actionCommands.values());
Class<? extends Action> foundClass = null;
if(actionCommands.containsKey(cmd))
foundClass = actionCommands.get(cmd);
return foundClass;
}

// Unpack actionClasses into actionCommands
private void generateActionCommands() {
for(Class<? extends Action> actionClass: actionClasses) {
try {
Field commandsField = actionClass.getDeclaredField("commands");
String[] commands = (String[]) commandsField.get(null);
for(String s: commands) {
actionCommands.put(s, actionClass);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}

[ December 09, 2008: Message edited by: Alex Birmingham ]
[ December 09, 2008: Message edited by: Alex Birmingham ]

...if anyone's interested, here's how it turned out.
I feel bad about how clunky it is, and would still appreciate general feedback.

/* Designed to take String commands and turn them into Action Objects. Constructor adds
 * all Action sub-classes to actionClasses, and generateActionCommands() uses that ArrayList
 * to map a HashMap<String, Class<? extends Action>>, actionCommands. 
 * FindSimilar() takes an array of Parsable Objects (Spells and Targetables) and String[] tokens,
 * cross-compares them, and returns the most accurately described Parsable object.
 * Lives server-side. */
package navea.system;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
 
import navea.actions.*;
import navea.mobs.Mob;
import navea.mobs.Player;
import navea.spells.Spell;
import navea.frontend.DisplayEvent;
 
public class CommandFilter {

private static String[] conjunctions = { "to", "from", "at", "for" };

private Player player;
private static ArrayList<Class<? extends Action>> actionClasses;
private static HashMap<String, Class<? extends Action>> actionCommands;

// Test (DELETE) //
public static void main(String[] args) {
CommandFilter filter = new CommandFilter();
System.out.println(filter.test().string());
}

public DisplayEvent test() {
return command("cast jello");
}
// //

// Construction
public CommandFilter() {
actionCommands = new HashMap<String, Class<? extends Action>>();
actionClasses = new ArrayList<Class<? extends Action>>();
actionClasses.add(Attack.class);
actionClasses.add(Cast.class);
actionClasses.add(Move.class);
actionClasses.add(Stand.class);
generateActionCommands();
}

private void generateActionCommands() {
for(Class<? extends Action> actionClass: actionClasses) {
try {
Field commandsField = actionClass.getDeclaredField("commands");
String[] commands = (String[]) commandsField.get(null);
for(String s: commands)
actionCommands.put(s, actionClass);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
 
// Command and Company
public DisplayEvent command(String cmd) {
cmd = cmd.toLowerCase();
String[] tokens = cmd.split(" ");
tokens = removeConjunctions(tokens);

// Attempt: Get Action Class
Class<? extends Action> actionClass = null;
if(tokens.length > 0)
actionClass = getActionClass(tokens[0]);
if(actionClass == null)
return new DisplayEvent(0, "You want to do what?");
// Instantiate or continue
if(tokens.length == 1) {
instantiateAction(actionClass, null, null);
return new DisplayEvent();
}
String[] tokens2 = new String[tokens.length - 1];
for(int i = 1; i < tokens.length; i++)
tokens2[i - 1] = tokens[i];

// Attempt: Check if casting
Spell spell = null;
if(actionClass.getCanonicalName().equals("navea.actions.Cast")) {
spell = findSpell(tokens2);
if(spell == null)
return new DisplayEvent(0, "Cast what?");
}
// Instantiate or continue
if(tokens.length == 1) {
instantiateAction(actionClass, null, spell);
return new DisplayEvent();
}
String[] tokens3 = new String[tokens2.length - 1];
for(int i = 1; i < tokens2.length; i++)
tokens3[i - 1] = tokens2[i];

// Attempt: Find target
Targetable target = null;
if(tokens3.length > 0)
target = (Targetable) findSimilar(player.targetables(), tokens);

instantiateAction(actionClass, target, spell);
return new DisplayEvent();
}

// Remove Conjunctions
private String[] removeConjunctions(String[] tokens) {
ArrayList<String> conjunctionLess = new ArrayList<String>();
for(String t: tokens) {
boolean conjunction = false;
for(String c: conjunctions) {
if(t.equals(c))
conjunction = true;
}
if(!conjunction)
conjunctionLess.add(t);
}

String[] s = new String[conjunctionLess.size()];
return conjunctionLess.toArray(s);

}

// Find actionClass
private Class<? extends Action> getActionClass(String cmd) {
Class<? extends Action> foundClass = null;
if(actionCommands.containsKey(cmd))
foundClass = actionCommands.get(cmd);
return foundClass;
}

// Find Spell
private Spell findSpell(String[] tokens) {
ArrayList<Parsable> spells = new ArrayList<Parsable>(player.knownSpells());
return (Spell) findSimilar(spells, tokens);
}

// Find Similar Targets
private Object findSimilar(ArrayList<Parsable> objects, String[] tokens) {
ArrayList<Parsable> similarObjects = new ArrayList<Parsable>();
int mostSimilarIndex = 0;
for(Parsable o: objects) {
for(String token: tokens) {
for(int i = 3; i <= o.noun().length(); i++) {
boolean matchesToI = o.noun().regionMatches(0, token, 0, i);
if(matchesToI) {
if(i > mostSimilarIndex) {
mostSimilarIndex = i;
similarObjects.clear();
similarObjects.add(o);
} else if(i == mostSimilarIndex)
similarObjects.add(o);
}
}
}
}

// Distinguish finer by adjectives
mostSimilarIndex = 0;
ArrayList<Parsable> mostSimilarObjects = new ArrayList<Parsable>();
for(Parsable o: similarObjects) {
ArrayList<String> adjectives = new ArrayList<String>(o.adjectives());
for(String adj: adjectives) {
for(String token: tokens) {
for (int i = 3; i <= token.length(); i++) {
boolean matchesToI = adj.regionMatches(0, token, 0, 3);
if(matchesToI) {
if(i > mostSimilarIndex) {
mostSimilarIndex = i;
mostSimilarObjects.clear();
mostSimilarObjects.add(o);
} else if(i == mostSimilarIndex)
similarObjects.add(o);
}
}
}
}
}
if(mostSimilarObjects.size() > 0)
similarObjects = mostSimilarObjects;

// Offsets
int offset = 0;
for(String s: tokens) {
if(s.equals("other"))offset = 1;
if(s.equals("second"))offset = 1;
if(s.equals("third"))offset = 2;
if(s.equals("fourth"))offset = 3;
if(s.equals("fifth"))offset = 4;
if(s.equals("sixth"))offset = 5;
}
if(similarObjects.size() >= offset)
return similarObjects.get(offset);
else return null;
}

// Instantiate
private void instantiateAction(Class actionClass, Targetable target, Spell spell) {
if(target == null)
target = player;
try {
if(spell != null) {
Class[] parTypes = new Class[3];
parTypes[0] = Mob.class;
parTypes[1] = Targetable.class;
parTypes[2] = Spell.class;
Object[] argList = { (Mob) player, target, spell };
Constructor ct = actionClass.getConstructor(parTypes);
Object newAction = ct.newInstance(argList);
return;
} else {
Class[] parTypes = new Class[2];
parTypes[0] = Mob.class;
parTypes[1] = Targetable.class;
Object[] argList = { (Mob) player, target };
Constructor ct = actionClass.getConstructor(parTypes);
Object newAction = ct.newInstance(argList);
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
 
}

Er, alright.

So it turns out that what I really needed to know was simply the phrase "Regular Expression."

Hi Alex,

Can you post your final solution, I'm curious

Well, I haven't coded it yet, but it's looking like the most logical way to do this is to encode a regex or 'regular expression' anything all the Action objects, all the Targetable objects, and anything else that could possibly be invoked via player command.

These regexes will function as 'hooks,' and because of the versatile nature of the Pattern object (or so I'm told, I haven't ever used it myself) it will clean up both the hook code and the parsing code.

so an 'attack' Action object would include something like this:

Pattern hooks = new Pattern("at[tack]|k[ill}|swin[g]");
// Exact syntax unknown

My only issue now is that the targetable hooks have to include adjectives, so that 'a grey door' can be distinguished from 'a blue door.' I believe this is possible with regex, but I'm still looking to figure out how.

Hmm, interesting

. I'm curious because I work on Role Playing software myself (saw some of your variable names). We still tend to use explicit strings for our rule set, but they are not 'actions' like you have.