/**
* Constructs an ExecutionLeaf to run a specific ModelLeaf.
*
* @param modelTask
* the ModelLeaf to run.
* @param executor
* the BTExecutor that will manage this ExecutionLeaf.
* @param parent
* the parent ExecutionTask of this task.
*/
protected ExecutionLeaf(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelLeaf))
{
throw new ArgumentException("The ModelTask must subclass ModelLeaf but it inherits from " + modelTask.GetType().Name);
}
}
/**
* Constructs an ExecutionRandomSelector to run a specific ModelRandomSelector.
*
* @param modelTask
* the ModelRandomSelector to run.
* @param executor
* the BTExecutor that will manage this ExecutionRandomSelector.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionRandomSelector(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelRandomSelector))
{
throw new ArgumentException("The ModelTask must subclass ModelRandomSelector but it inherits from " + modelTask.GetType().Name);
}
}
protected ModelComposite(ModelTask guard, string name, params ModelTask[] children)
: base(guard, name, children)
{
if (children.Length == 0)
{
throw new ArgumentException("The list of children cannot be empty");
}
}
/**
* Creates an ExecutionStaticPriorityList that is able to run a
* ModelStaticPriorityList task and that is managed by a BTExecutor.
*
* @param modelTask
* the ModelStaticPriorityList that this
* ExecutionStaticPriorityList is going to run.
* @param executor
* the BTExecutor in charge of running this
* ExecutionStaticPriorityList.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionStaticPriorityList(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelStaticPriorityList))
{
throw new ArgumentException("The ModelTask must subclass ModelStaticPriorityList but it inherits from " +
modelTask.GetType().Name);
}
}
/**
* Constructs an ExecutionSafeContextManager that knows how to run a
* ModelSafeContextManager.
*
* @param modelTask
* the ModelSafeContextManager to run.
* @param executor
* the BTExecutor that will manage this
* ExecutionSafeContextManager.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionSafeContextManager(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelSafeContextManager))
{
throw new ArgumentException("The ModelTask must subclass ModelSafeContextManager but it inherits from " +
modelTask.GetType().Name);
}
}
/**
* Constructs an ExecutionSubtreeLookup that knows how to run a
* ModelSubtreeLookup.
*
* @param modelTask
* the ModelSubtreeLookup to run.
* @param executor
* the BTExecutor that will manage this ExecutionSubtreeLookup.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionSubtreeLookup(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelSubtreeLookup))
{
throw new ArgumentException("The ModelTask must subclass ModelSubtreeLookup but it inherits from " +
modelTask.GetType().Name);
}
}
/**
* Creates an ExecutionComposite that is able to run a particular
* ModelComposite task.
*
* @param modelTask
* the ModelComposite task to run.
* @param executor
* the BTExecutor that will manage this ExecutionComposite.
* @param parent
* the parent ExecutionTask of this task.
*/
protected ExecutionComposite(ModelTask modelTask, IBTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelComposite))
{
throw new ArgumentException("The ModelTask must subclass " + typeof (ModelComposite).Name + " but it inherits from " +
modelTask.GetType().Name);
}
}
/**
* Constructs and ExecutionUntilFail that knows how to run a ModelUntilFail.
*
* @param modelTask
* the ModelUntilFail that this ExecutionUntilFail will run.
* @param executor
* the BTExecutor that will manage this ExecutionUntilFail.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionUntilFail(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelUntilFail))
{
throw new ArgumentException("The ModelTask must subclass ModelUntilFail but it inherits from " +
modelTask.GetType().Name);
}
}
/**
* Creates an ExecutionPerformInterruption that is able to run a
* ModelPerformInterruption task and that is managed by a BTExecutor.
*
* @param modelTask
* the ModelPerformInterruption that this
* ExecutionPerformInterruption is going to run.
* @param executor
* the BTExecutor in charge of running this
* ExecutionPerformInterruption.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionPerformInterruption(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelPerformInterruption))
{
throw new ArgumentException("The ModelTask must subclass ModelPerformInterruption but it inherits from " +
modelTask.GetType().Name);
}
}
/**
* Creates an ExecutionWait that is able to run a ModelWait task and that is
* managed by a BTExecutor.
*
* @param modelTask
* the ModelWait that this ExecutionWait is going to run.
* @param executor
* the BTExecutor in charge of running this ExecutionWait.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionWait(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelWait))
{
throw new ArgumentException("The ModelTask must subclass ModelWait but it inherits from " + modelTask.GetType().Name);
}
Initialize(modelTask);
}
/**
* Creates an ExecutionLimit that knows how to run a ModelLimit.
*
* @param modelTask
* the ModelLimit to run.
* @param executor
* the BTExecutor that will manage this ExecutionLimit.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionLimit(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelLimit))
{
throw new ArgumentException("The ModelTask must subclass ModelLimitbut it inherits from " + modelTask.GetType().Name);
}
_maxNumTimes = ((ModelLimit) ModelTask).getMaxNumTimes();
_numRunsSoFar = 0;
}
/**
* Constructs an ExecutionVariableRenamer that knows how to run a
* ModelVariableRenamer.
*
* @param modelTask
* the ModelVariableRenamer to run.
* @param executor
* the BTExecutor in charge of running this
* ExecutionVariableRenamer.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionVariableRenamer(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelVariableRenamer))
{
throw new ArgumentException("The ModelTask must subclass ModelVariableRenamer but it inherits from " +
modelTask.GetType().Name);
}
_variableName = ((ModelVariableRenamer) modelTask).VariableName;
_newVariableName = ((ModelVariableRenamer) modelTask).NewVariableName;
}
protected ModelTask(ModelTask guard, string name, params ModelTask[] children)
{
_guard = guard;
_name = name;
_children = new List <ModelTask>();
foreach (var modelTask in children)
{
_children.Add(modelTask);
}
_position = new Position();
}
protected ModelTask(ModelTask guard, string name, params ModelTask[] children)
{
_guard = guard;
_name = name;
_children = new List<ModelTask>();
foreach (var modelTask in children)
{
_children.Add(modelTask);
}
_position = new Position();
}
/**
* Adds the behaviour tree <code>tree</code> to the set of behaviour trees
* stored in this library. If there is already a tree with the name
* <code>name</code>, then it is overwritten by <code>tree</code>.
*
* @param name
* the name that will identify the tree <code>tree</code> in the
* library.
* @param tree
* the tree to insert.
* @return true if there was already a tree with name <code>name</code>, and
* false otherwise.
*/
public bool AddBT(string name, ModelTask tree)
{
bool overwritten = false;
if (_trees.ContainsKey(name))
{
overwritten = true;
_trees.Remove(name);
}
_trees.Add(name, tree);
return overwritten;
}
/**
* Creates an ExecutionParallel that is able to run a ModelParallel task and
* that is managed by a BTExecutor.
*
* @param modelTask
* the ModelParallel that this ExecutionParallel is going to run.
* @param executor
* the BTExecutor in charge of running this ExecutionParallel.
* @param parent
* the parent ExecutionTask of this task.
*/
public ExecutionParallel(ModelTask modelTask, BTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
if (!(modelTask is ModelParallel))
{
throw new ArgumentException("The ModelTask must subclass " + typeof (ModelParallel).Name + " but it inherits from " +
modelTask.GetType().Name);
}
_policy = ((ModelParallel)modelTask).Policy;
_modelChildren = modelTask.Children;
Initialize();
}
/**
* This method sets the positions of all tasks below <code>t</code> in the
* tree.
*
* @param t
* the task whose descendants will be computed their positions.
*/
private void RecursiveComputePositions(ModelTask t)
{
/*
* Set the position of all of the children of this task and recursively
* compute the position of the rest of the tasks.
*/
for (var i = 0; i < t._children.Count; i++)
{
var currentChild = t._children[i];
var currentChildPos = new Position(t.Position);
currentChildPos.AddMove(i);
currentChild._position = currentChildPos;
RecursiveComputePositions(currentChild);
}
}
/**
* This method computes the positions of all the tasks of the behaviour tree
* whose root is this node. After calling this method, the positions of all
* the tasks below this one will be available and accessible through
* {@link #getPosition()}.
* <p>
* It is important to note that, when calling this method, this task is
* considered to be the root of the behaviour tree, so its position will be
* set to an empty sequence of moves, with no offset, and the positions of
* the tasks below it will be computed from it.
*/
public void ComputePositions()
{
/* Assume this node is the root of the tree. */
_position = new Position(new List <int>());
/*
* Set the position of all of the children of this task and recursively
* compute the position of the rest of the tasks.
*/
for (var i = 0; i < _children.Count; i++)
{
ModelTask currentChild = _children[i];
var currentChildPos = new Position(_position);
currentChildPos.AddMove(i);
currentChild._position = currentChildPos;
RecursiveComputePositions(currentChild);
}
}
/**
* Constructor.
*
* @param guard
* the guard of the ModelHierarchicalContextManager, which may be null.
* @param child
* the child of the ModelHierarchicalContextManager.
*/
public ModelHierarchicalContextManager(ModelTask guard, ModelTask child)
: base(guard, child)
{
}
private void Initialize(ModelTask modelTask)
{
duration = ((ModelWait) modelTask).Duration;
}
/**
* Creates a ModelDynamicPriorityList task with a guard, and a list of
* children to run. A ModelDynamicPriorityList must have at least one child.
*
* @param guard
* the guard, which may be null.
* @param children
* the list of children. Must have at least one element.
*/
public ModelDynamicPriorityList(ModelTask guard, params ModelTask[] children)
: base(guard, children)
{
}
/**
* Creates a BTExecutor that handles the execution of a behaviour tree. The behaviour tree is
* represented by a ModelTask (the root of the tree).
* <p>
* A new empty context for the tree is created. This context is passed to the root of the tree,
* and, in general, it will be shared by all the nodes in the tree (it will be passed down the
* hierarchy of the tree). Note however that, depending on the semantics of the tree itself,
* some nodes may not use the context context.
*
* @param modelBT
* the root of the behaviour tree to run.
*/
public BTExecutor(ModelTask modelBT)
{
if (modelBT == null)
{
throw new ArgumentException("The input ModelTask cannot be null");
}
_modelBT = modelBT;
_modelBT.ComputePositions();
_context = new BasicContext();
_tickableTasks = new List<ExecutionTask>();
_openTasks = new List<ExecutionTask>();
_currentOpenInsertions = new List<ExecutionTask>();
_currentOpenRemovals = new List<ExecutionTask>();
_currentTickableInsertions = new List<ExecutionTask>();
_currentTickableRemovals = new List<ExecutionTask>();
_interrupters = new Dictionary<ModelInterrupter, ExecutionInterrupter>();
_tasksStates = new Dictionary<Position, ITaskState>();
}
public StubExecutionTask(ModelTask modelTask, IBTExecutor executor, ExecutionTask parent)
: base(modelTask, executor, parent)
{
}
/**
* Constructs an ExecutionTask with an associated ModelTask and a
* BTExecutor. The ModelTask represents the conceptual task that the
* ExecutionTask is running, and the BTExecutor is that in charge of the
* ExecutionTask. Also, the parent of the ExecutionTask must be provided.
*
* @param modelTask
* the ModelTask this ExecutionTask will run.
* @param executor
* the BTExecutor managing this task.
* @param parent
* the parent ExecutionTask, or null in case this is the root of
* the tree.
*/
protected ExecutionTask(ModelTask modelTask, IBTExecutor executor, ExecutionTask parent)
{
_modelTask = modelTask;
_executor = executor as BTExecutor;
_listeners = new List<ITaskListener>();
_spawnable = true;
_tickable = false;
_terminated = false;
_status = Status.Uninitialized;
_parent = parent;
if(_modelTask != null)
AlwaysFail = modelTask.AlwaysFail;
/* Compute the position of this node. */
if (parent == null)
{
_position = new Position();
}
else
{
_position = new Position(parent._position);
var nextMove = GetMove();
_position.AddMove(nextMove);
}
}
/**
* Creates a ModelRandomSelector with a guard and several children. The list
* of children cannot be empty.
*
* @param guard
* the guard of the ModelRandomSelector, which may be null.
* @param children
* the list of children, which cannot be empty.
*/
public ModelRandomSelector(ModelTask guard, params ModelTask[] children)
: base(guard, children)
{
}
/**
* Constructor.
*
* @param guard
* the guard of the ModelSafeOutputContextManager, which may be
* null.
* @param child
* the child of the ModelSafeOutputContextManager.
* @param outputVariables
* the list of output variables of the SafeOutputContext that is
* created.
*/
public ModelSafeOutputContextManager(ModelTask guard, List<string> outputVariables, ModelTask child)
: base(guard, child)
{
this.outputVariables = outputVariables;
}
/**
* This method sets the positions of all tasks below <code>t</code> in the
* tree.
*
* @param t
* the task whose descendants will be computed their positions.
*/
private void RecursiveComputePositions(ModelTask t)
{
/*
* Set the position of all of the children of this task and recursively
* compute the position of the rest of the tasks.
*/
for (var i = 0; i < t._children.Count; i++)
{
var currentChild = t._children[i];
var currentChildPos = new Position(t.Position);
currentChildPos.AddMove(i);
currentChild._position = currentChildPos;
RecursiveComputePositions(currentChild);
}
}
/**
* Constructor.
* <p>
* Constructs a ModelDecorator with one child.
*
* @param guard
* the guard of the ModelDecorator. which may be null.
* @param child
* the child of the ModelDecorator.
*/
protected ModelDecorator(ModelTask guard, ModelTask child)
: base(guard, child)
{
}
/**
* Creates a new ModelTask with a guard and several children. The guard may
* be null, in which case it is always evaluated to true. The task may also
* have no children.
*
* @param guard
* the guard, which may be null.
* @param children
* the list of children.
*/
protected ModelTask(ModelTask guard, params ModelTask[] children)
: this(guard, null, children)
{
}
/**
* Constructor.
* <p>
* Constructs a ModelComposite with some children. A ModelComposite must
* have at least one child.
*
* @param guard
* the guard of the ModelComposite.
* @param children
* the list of children. Must have at least one element.
*/
protected ModelComposite(ModelTask guard, params ModelTask[] children)
: this(guard, null, children)
{
}
/**
* Creates a ModelRandomSequence with a guard and several children. The list
* of children cannot be empty.
*
* @param guard
* the guard of the ModelRandomSequence, which may be null.
* @param children
* the list of children, which cannot be empty.
*/
public ModelRandomSequence(ModelTask guard, params ModelTask[] children)
: base(guard, children)
{
}
public TestTask(ModelTask guard, params ModelTask[] children)
: base(guard, children)
{
}
/**
* Constructor.
*
* @param guard
* the guard of the task, which may be null.
* @param variableName
* the name of the variable to rename.
* @param newVariableName
* the new name for the variable.
*/
public ModelVariableRenamer(ModelTask guard, string variableName, string newVariableName)
: base(guard)
{
_variableName = variableName;
_newVariableName = newVariableName;
}
/**
* Constructor.
*
* @param guard
* the guard of the ModelRepeat, which may be null.
* @param child
* the child that will be run forever.
*/
public ModelRepeat(ModelTask guard, ModelTask child)
: base(guard, child)
{
}
