public LispParser.Node BuildParseTree()
{
LispParser.MethodNode node = new LispParser.MethodNode("TaskUtility");
node.Add(UtilityComputer.BuildParseTree());
node.Add(Task.BuildParseTree());
return(node);
}
LispParser.ICanCreateFromLispParseTree <TBb> LispParser.ICompiler <TBb> .Compile(TBb blackboard, LispParser.Node parseTree)
{
foreach (LispParser.ICanCreateFromLispParseTree <TBb> creator in Creators)
{
LispParser.ICanCreateFromLispParseTree <TBb> result = creator.CreateFromParseTree(blackboard, parseTree, this);
if (result != null)
{
return(result);
}
}
// For named couritines, we rewrite the parsetree to be able to use the regular flow.
LispParser.MethodNode method = parseTree as LispParser.MethodNode;
if (method != null)
{
Func <IEnumerator <TaskState> > function = blackboard.GetCoRoutineFunc(method.Identifier.Value);
if (function != null)
{
method.Add(method.Identifier);
method.Identifier = new LispParser.IdentifierNode("NamedCoroutine");
LispParser.ICanCreateFromLispParseTree <TBb> result = ((LispParser.ICanCreateFromLispParseTree <TBb>)_namedCoroutine).CreateFromParseTree(blackboard, method, this);
if (result != null)
{
return(result);
}
}
}
throw new InvalidOperationException(
string.Format("Unrecognized token: {0}.", parseTree));
}
public virtual LispParser.MethodNode BuildParseTree()
{
string className = GetClassName();
LispParser.MethodNode node = new LispParser.MethodNode(className);
node.Add("Name", Name, true);
return(node);
}
public LispParser.Node BuildParseTree()
{
LispParser.MethodNode node = new LispParser.MethodNode("BehaviourTree");
node.Add("Name", Name, true);
node.Add("RunningTaskHysterisis", RunningTaskHysterisis);
node.Add(RootTask.BuildParseTree());
return(node);
}
public override LispParser.MethodNode BuildParseTree()
{
LispParser.MethodNode node = base.BuildParseTree();
foreach (TaskUtility <TBb> taskUtility in Children)
{
node.Children.Add(taskUtility.BuildParseTree());
}
return(node);
}
public override LispParser.MethodNode BuildParseTree()
{
// Named Coroutine is hidden in the code, so this behaves slightly differently than would be expected
//LispParser.MethodNode node = base.BuildParseTree();
//node.Add(NamedCoroutineCreator.BuildParseTree());
//return node;
LispParser.MethodNode node = new LispParser.MethodNode(NamedCoroutineCreator.Name);
node.Add("Name", Name, true);
return(node);
}
public override LispParser.MethodNode BuildParseTree()
{
LispParser.MethodNode node = (LispParser.MethodNode)base.BuildParseTree();
if (Predicate != null)
{
node.Add("if", Predicate.BuildParseTree());
}
foreach (TreeTask <TBb> treeTask in Children)
{
node.Add(treeTask.BuildParseTree());
}
return(node);
}
public LispParser.ICanCreateFromLispParseTree <TBb> CreateFromParseTree(TBb blackboard, LispParser.Node node, LispParser.ICompiler <TBb> compiler)
{
LispParser.MethodNode method = node as LispParser.MethodNode;
if (method == null || method.MethodName != "TaskUtility")
{
return(null);
}
TaskUtility <TBb> taskUtility = new TaskUtility <TBb>(null, null);
taskUtility.UtilityComputer = ((BehaviourTreeCompiler <TBb>)compiler).LispCompiler.Compile(blackboard, method.Children[0]);
if (!(taskUtility.UtilityComputer is ICanEvaluateToFloat))
{
throw new InvalidOperationException("The utility computer must evaluate to a float!");
}
taskUtility.Task = (TreeTask <TBb>)compiler.Compile(blackboard, method.Children[1]);
return(taskUtility);
}
LispParser.ICanCreateFromLispParseTree <TBb> LispParser.ICanCreateFromLispParseTree <TBb> .CreateFromParseTree(TBb blackboard, LispParser.Node node, LispParser.ICompiler <TBb> compiler)
{
LispParser.MethodNode method = node as LispParser.MethodNode;
if (method == null)
{
return(null);
}
if (method.MethodName == GetClassName())
{
TreeTask <TBb> treeTask = CreateTreeTaskFromParseTree(blackboard, method, compiler);
foreach (LispParser.Node child in method.Children)
{
child.NamedParamX <LispParser.StringNode>("Name", v => treeTask.Name = v.Value);
}
return(treeTask);
}
else
{
return(null);
}
}
public LispParser.ICanCreateFromLispParseTree <TBb> CreateFromParseTree(TBb blackboard, LispParser.Node node, LispParser.ICompiler <TBb> compiler)
{
LispParser.MethodNode method = node as LispParser.MethodNode;
if (method == null)
{
throw new InvalidOperationException("Expected BehaviourTree but found: null");
}
if (method.MethodName != "BehaviourTree")
{
throw new InvalidOperationException("Expected BehaviourTree but found: " + method);
}
BehaviourTree <TBb> behaviourTree = new BehaviourTree <TBb>(null, null);
foreach (LispParser.Node child in method.Children)
{
child.NamedParamX <LispParser.NumberNode>("RunningTaskHysterisis", v => behaviourTree.RunningTaskHysterisis = (int)v.FloatValue);
child.NamedParamX <LispParser.StringNode>("Name", v => behaviourTree.Name = v.Value);
child.ParamX <LispParser.MethodNode>(null, v => behaviourTree.RootTask = (TreeTask <TBb>)compiler.Compile(blackboard, v));
}
return(behaviourTree);
}
protected abstract TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler);
public override LispParser.MethodNode BuildParseTree()
{
LispParser.MethodNode node = new LispParser.MethodNode("DebugLog");
node.Add(StringComputer.BuildParseTree());
return(node);
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
DebugLog <TBb> debugLog = new DebugLog <TBb>(null);
debugLog.StringComputer = ((BehaviourTreeCompiler <TBb>)compiler).LispCompiler.Compile(blackboard, method.Children[0]);
if (!(debugLog.StringComputer is ICanEvaluateToString))
{
throw new InvalidOperationException("The string computer must evaluate to a string!");
}
return(debugLog);
}
protected override UtilityControlFlowNode <TBb> CreateUtilityControlFlow(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
return(new UtilitySelector <TBb>());
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
FixedResultState <TBb> fixedResultState = new FixedResultState <TBb>(ResultState);
foreach (LispParser.Node child in method.Children)
{
child.NamedParamX <LispParser.StringNode>("ResultState", v => fixedResultState.ResultState = (TaskState)Enum.Parse(typeof(TaskState), v.Value));
}
return(fixedResultState);
}
protected abstract ControlFlowNode <TBb> CreateControlFlow(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler);
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
throw new InvalidOperationException("Not implemented!");
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
UtilityControlFlowNode <TBb> utilityControlFlowNode = CreateUtilityControlFlow(blackboard, method, compiler);
if (utilityControlFlowNode == null)
{
return(null);
}
foreach (LispParser.Node child in method.Children)
{
child.NamedParamX <LispParser.StringNode>("Name", v => utilityControlFlowNode.Name = v.Value);
child.ParamX <LispParser.MethodNode>(null, v => utilityControlFlowNode.Children.Add((TaskUtility <TBb>)compiler.Compile(blackboard, child)));
}
return(utilityControlFlowNode);
}
public override LispParser.MethodNode BuildParseTree()
{
LispParser.MethodNode method = base.BuildParseTree();
method.Children.Insert(0, new LispParser.NamedParameterNode("MaxRunTimes", MaxRunTimes));
return(method);
}
protected override Decorator <TBb> CreateDecoratorFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
RunNTimes <TBb> runNTimes = new RunNTimes <TBb>(null);
foreach (LispParser.Node child in method.Children)
{
child.NamedParamX <LispParser.IntegerNode>("MaxRunTimes", x => runNTimes.MaxRunTimes = x.Value);
}
return(runNTimes);
}
public override LispParser.MethodNode BuildParseTree()
{
LispParser.MethodNode node = base.BuildParseTree();
node.Add(DecoratedTask.BuildParseTree());
return(node);
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
throw new NotImplementedException();
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
return(new KeepRunning <TBb>());
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
Decorator <TBb> decorator = CreateDecoratorFromParseTree(blackboard, method, compiler);
if (decorator != null)
{
if (decorator.GetType() != GetType())
{
throw new InvalidOperationException(
string.Format(
"Expected {0} but compiled to {1}!",
TypeHelper.GetFriendlyTypeName(GetType()),
TypeHelper.GetFriendlyTypeName(decorator.GetType())));
}
decorator.DecoratedTask = (TreeTask <TBb>)compiler.Compile(blackboard, method.Children.OfType <LispParser.MethodNode>().Single());
}
return(decorator);
}
protected override ControlFlowNode <TBb> CreateControlFlow(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
return(new Sequence <TBb>());
}
protected abstract Decorator <TBb> CreateDecoratorFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler);
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
ControlFlowNode <TBb> controlFlowNode = CreateControlFlow(blackboard, method, compiler);
if (controlFlowNode == null)
{
return(null);
}
foreach (LispParser.Node child in method.Children)
{
bool handled =
child.NamedParamX <LispParser.StringNode>("Name", v => controlFlowNode.Name = v.Value) ||
child.ParamX <LispParser.MethodNode>(null, v => controlFlowNode.Children.Add((TreeTask <TBb>)compiler.Compile(blackboard, child)));
if (!handled)
{
LispParser.NamedParameterNode named = child as LispParser.NamedParameterNode;
if (named != null && named.Identifier.Value == "if")
{
controlFlowNode.Predicate = ((BehaviourTreeCompiler <TBb>)compiler).LispCompiler.Compile(blackboard, named.Value);
if (!(controlFlowNode.Predicate is ICanEvaluateToBool))
{
throw new InvalidOperationException(
string.Format(
"The if predicate must evaluate to a bool, {0} doesn't!",
named.Value));
}
continue;
}
throw new InvalidOperationException(
string.Format(
"Unhandled child {0} on {1}!",
child,
this));
}
}
return(controlFlowNode);
}
protected override Decorator <TBb> CreateDecoratorFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
return(new Counter <TBb>(null));
}
public override LispParser.MethodNode BuildParseTree()
{
LispParser.MethodNode node = base.BuildParseTree();
node.Add("ResultState", ResultState.ToString());
return(node);
}
protected override TreeTask <TBb> CreateTreeTaskFromParseTree(TBb blackboard, LispParser.MethodNode method, LispParser.ICompiler <TBb> compiler)
{
throw new NotImplementedException("Not implemented, use NamedCoroutine instead?");
}
