Package cz.cuni.amis.pogamut.shady

Shady - experimental POSH-like engine.

See:
Description

Interface Summary

IArgument<T>	Interface that unified various arguments used when shade is calling the primitive.
IQuery	Interface for getting integer value from some part of the plan, e.g.
ShadyParserConstants	Token literal values and constants.

Class Summary

ArgString	Store the string value as an argument.
NodeCall	During the execution of the tree, we have to go from one node to another and finally execute one primitive.
NodeElement	Every node has multiple elemnts, binary tree has two, our if-then tree structure has a variable ammount.
QueryCall	Query call is used to call some function in outside of engine with some parameters and return the value.
ShadeEngine<EXECUTOR extends IWorkExecutor>	This class is taking a shade plan (already parsed in form of ShadeTree and executing it using supplied IWorkExecutor.
ShadeNode	Representation of one node in the if-then tree.
ShadeTree	This class contains all nodes of one shade plan.
ShadyParser
ShadyParserTokenManager	Token Manager.
SimpleCharStream	An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
Token	Describes the input token stream.

Exception Summary

ParseException

This exception is thrown when parse errors are encountered.

Error Summary

TokenMgrError

Token Manager Error.

Package cz.cuni.amis.pogamut.shady Description

Shady - experimental POSH-like engine.

Shady is a new engine using if-then rules. posh is ugly piece of code that is maintaining compatibility with the version written in lisp and later in Python. That must stop, it is not pretty (in fact, it is distasteful), it has many features that are not used (goals in competences, nested APs) and very few people even have an idea they are there (default goals and such) or even why they are there.

Our students often complain about posh, so do I. I believe that much simples tree engine with simple node structure will be easier to learn and to use. This idea was proposed by Jakub Gemrot alongside with my tasks for master thesis, but I am beat tonight, so it is time for some fun instead of productuive work.

What is difference from posh?

• Name - sorry, but I can't stand it any longer. That is also why my editor is called Shed, not poSH EDitor.
• Simpler structure. In posh, we have AP, C, Ds, here, we have unified node. There are slight differences in behavior of Cs and DC, but not even I can remember what they are(another obscure feature). DPEs, CPEs...Headaches with connecting it all together...Be gone.
• Arguments - I made a big mistake with named variables in posh. My design was more Pyhton like (named variables), not lisp like.
• Priority - instead of fixed priority numbers in one node, the priority will determined on runtime. This will allow for things like node activating (prio- rity will be increased), when there is a predator close.
• Multiple plan execution. It will be possible to execute multiple plans at once. You are probably not sure why. It only introduces complexity for our plan; that is not correct at all. We can utilize it using resource approach. One plan will be responsible for moving player along the route, while other plan turns, shoots or whatnot. If you had only one plan, you would need to somehow handle the other plan in every action. This is by no means compulsory, but it could be useful, so it will be included.
• trigger will be more complex, if needed. And, not, or.
• simplified value handling. Then primitive returns value, in posh, it can be (nearly) anything, null, int, string, double, even object. Not here. I only allow to return the number. Zero is false, otherwise it is true. Numbers is about everything I need in plan. For more complex things, program new sense.
• I will of course incorporate all lessons learned while programming posh engine.

Grammar

fuzzy : '(' node ')'

# NAME is a string in quotes, e.g. "root" or "run on hills"
node : '(' 'node' NAME DESCR (connection)+ ')'

# priority is a call 
connection : '(' PRIORITY trigger call ')'

# Trigger is something that returns either 1 or 0 (instead of true/false)
trigger : '(' 'not' trigger ')'
           '(' 'and' (trigger)+ ')'
           '(' 'or' (trigger)+ ')'
           '(' '>' value value ')'
           '(' '>=' value value ')'
           '(' '=' value value ')'
           '(' '=<' value value ')'
           '(' '<' value value ')'
           call

# Something that returns numerical value, either parameter, constant or call
value : call
        | parameter

 
# call function and return numerical value
call : '(' NAME (PARAMETER)* ')'

parameter : argument | string | number

ARG: '*' (DIGIT)+ '*'
STRING: 
INT: 
NUMBER:

Example :   
(
    (node "root" "Root node for rabbit"
        ((fix 100)  ((hungry)) ("look for food") )
        ((fix 50)   ((succeed)) ("run around") )
        ((scared)   ((succeed)) ("run from closest enemy"))
    )
    
    (node "look for food" "Go around the forrest and look for edible stuff"
        ((fix 10) ) 
    )
)

How is target of call determined:

• names of nodes in the plan
• names of classes on classpath
• append name of call to the packages on classpath and try to use it as FQN name of class.
• Use target name as FQN of class