类的使用
cn.wjybxx.btree.Task

使用Task的程序包

程序包	说明
cn.wjybxx.btree
cn.wjybxx.btree.branch
cn.wjybxx.btree.branch.join
cn.wjybxx.btree.decorator
cn.wjybxx.btree.fsm
cn.wjybxx.btree.leaf

cn.wjybxx.btree中Task的使用

cn.wjybxx.btree中Task的子类

修饰符和类型	类	说明
class	BranchTask<T>	分支任务（可能有多个子节点）
class	Decorator<T>	装饰任务（最多只有一个子节点）
class	LeafTask<T>	叶子任务（不能有子节点）
class	TaskEntry<T>	任务入口（可联想程序的Main）

声明为Task的cn.wjybxx.btree中的字段

修饰符和类型	字段	说明
protected Task<T>	Decorator.child

类型参数类型为Task的cn.wjybxx.btree中的字段

修饰符和类型	字段	说明
protected List<Task<T>>	BranchTask.children

返回Task的cn.wjybxx.btree中的方法

修饰符和类型	方法	说明
final Task<T>	BranchTask.getChild(int index)
Task<T>	Decorator.getChild()
final Task<T>	Decorator.getChild(int index)
final Task<T>	LeafTask.getChild(int index)
abstract Task<T>	Task.getChild(int index)	获取指定索引的child
final Task<T>	TaskEntry.getChild(int index)
final Task<T>	Task.getControl()
final Task<T>	BranchTask.getFirstChild()	获取第一个子节点 -- 主要为MainPolicy提供帮助
final Task<T>	Task.getGuard()
final Task<T>	TaskInlineHelper.getInlinedRunningChild()	获取被内联运行的子节点
final Task<T>	BranchTask.getLastChild()	获取最后一个子节点
Task<T>	TaskEntry.getRootTask()
default <T> Task<T>	TreeLoader.loadRootTask(String treeName)
final Task<T>	Task.removeChild(int index)	删除指定索引的child
protected final Task<T>	BranchTask.removeChildImpl(int index)
protected final Task<T>	Decorator.removeChildImpl(int index)
protected final Task<T>	LeafTask.removeChildImpl(int index)
protected abstract Task<T>	Task.removeChildImpl(int index)
protected final Task<T>	TaskEntry.removeChildImpl(int index)
final Task<T>	Task.setChild(int index, Task<T> newTask)	替换指定索引位置的child （该方法可避免Task的结构发生变化，也可以减少事件数）
protected final Task<T>	BranchTask.setChildImpl(int index, Task<T> task)
protected final Task<T>	Decorator.setChildImpl(int index, Task<T> task)
protected final Task<T>	LeafTask.setChildImpl(int index, Task<T> task)
protected abstract Task<T>	Task.setChildImpl(int index, Task<T> task)
protected final Task<T>	TaskEntry.setChildImpl(int index, Task<T> task)
final Task<T>	Task.setFlags(int flags)
final Task<T>	Task.setGuard(Task<T> guard)
default <T> Task<T>	TreeLoader.tryLoadRootTask(String treeName)	尝试加载行为树的根节点

返回变量类型为Task的类型的cn.wjybxx.btree中的方法

修饰符和类型	方法	说明
final Stream<Task<T>>	BranchTask.childStream()
final Stream<Task<T>>	Decorator.childStream()
final Stream<Task<T>>	LeafTask.childStream()
abstract Stream<Task<T>>	Task.childStream()	该接口主要用于测试，该接口有一定的开销
final Stream<Task<T>>	TaskEntry.childStream()
List<Task<T>>	BranchTask.getChildren()

参数类型为Task的cn.wjybxx.btree中的方法

修饰符和类型	方法	说明
final int	Task.addChild(Task<T> task)	1.尽量不要在运行时增删子节点（危险操作） 2.不建议将Task从一棵树转移到另一棵树，可能产生内存泄漏（引用未删除干净）
protected final int	BranchTask.addChildImpl(Task<T> task)
protected final int	Decorator.addChildImpl(Task<T> task)
protected final int	LeafTask.addChildImpl(Task<T> task)
protected abstract int	Task.addChildImpl(Task<T> task)
protected final int	TaskEntry.addChildImpl(Task<T> task)
final int	BranchTask.indexChild(Task<?> task)
final int	Decorator.indexChild(Task<?> task)
final int	LeafTask.indexChild(Task<?> task)
int	Task.indexChild(Task<?> task)
final int	TaskEntry.indexChild(Task<?> task)
final void	TaskInlineHelper.inlineChild(Task<T> runningChild)	尝试内联运行中的子节点
final boolean	BranchTask.isFirstChild(Task<?> child)	是否是第一个子节点
final boolean	BranchTask.isLastChild(Task<?> child)	是否是第最后一个子节点
protected final void	LeafTask.onChildCompleted(Task<T> child)
protected abstract void	Task.onChildCompleted(Task<T> child)	子节点进入完成状态 1.避免方法数太多，实现类测试task的status即可 2.getNormalizedStatus()有助于switch测试 3.task可能是取消状态，甚至可能没运行过直接失败（前置条件失败） 4.钩子任务和guard不会调用该方法 5.isExecuting()有助于检测冲突，减少调用栈深度 6.同一子节点连续通知的情况下，completed的逻辑应当覆盖onChildRunning(Task)的影响。
protected void	TaskEntry.onChildCompleted(Task<T> child)
protected void	Decorator.onChildRunning(Task<T> child)	子类如果支持内联，则重写该方法
protected final void	LeafTask.onChildRunning(Task<T> child)
protected abstract void	Task.onChildRunning(Task<T> child)	子节点还需要继续运行 1.child在运行期间只会通知一次 2.该方法不应该触发状态迁移，即不应该使自己进入完成状态
protected void	TaskEntry.onChildRunning(Task<T> child)
final boolean	Task.removeChild(Task<?> task)	删除指定child
static void	Task.resetForRestart(Task<?> task)	重置目标任务
void	Decorator.setChild(Task<T> child)
final Task<T>	Task.setChild(int index, Task<T> newTask)	替换指定索引位置的child （该方法可避免Task的结构发生变化，也可以减少事件数）
final void	Task.setChildCancelToken(Task<T> child, ICancelToken childCancelToken)	设置子节点的取消令牌
protected final Task<T>	BranchTask.setChildImpl(int index, Task<T> task)
protected final Task<T>	Decorator.setChildImpl(int index, Task<T> task)
protected final Task<T>	LeafTask.setChildImpl(int index, Task<T> task)
protected abstract Task<T>	Task.setChildImpl(int index, Task<T> task)
protected final Task<T>	TaskEntry.setChildImpl(int index, Task<T> task)
final void	Task.setControl(Task<T> control)	设置任务的控制节点
final Task<T>	Task.setGuard(Task<T> guard)
final void	Task.setGuardFailed(Task<T> control)	设置为前置条件测试失败 1.该方法仅适用于control测试child的guard失败，令child在未运行的情况下直接失败的情况。
void	TaskEntry.setRootTask(Task<T> rootTask)
static void	Task.stop(Task<?> task)	停止目标任务
final boolean	Task.template_checkGuard(Task<T> guard)	检查前置条件 1.如果未显式设置guard的上下文，会默认捕获当前Task的上下文 2.guard的上下文在运行结束后会被清理 3.guard只应该依赖共享上下文(黑板和props)，不应当对父节点做任何的假设。
final void	Task.template_runChild(Task<T> child)	运行子节点，会检查子节点的前置条件 注：如果想减少方法调用，对于运行中的子节点，可直接调用子节点的template_execute(boolean)方法。
final void	Task.template_runChildDirectly(Task<T> child)	运行子节点，不检查子节点的前置条件
final void	Task.template_runHook(Task<T> hook)	执行钩子任务，会检查前置条件 1.钩子任务不会触发onChildRunning(Task)和onChildCompleted(Task) 2.前置条件其实是特殊的钩子任务 3.条件分支不应该有钩子任务
final void	Task.template_runHookDirectly(Task<T> hook)	执行钩子任务，不检查前置条件
final void	Task.template_runInlinedChild(Task<T> inlinedChild, TaskInlineHelper<T> helper, Task<T> runningChild)	执行被内联的子任务
final void	Task.unsetChildCancelToken(Task<T> child)	删除子节点的取消令牌

类型变量类型为Task的cn.wjybxx.btree中的方法参数

修饰符和类型	方法	说明
void	BranchTask.setChildren(List<Task<T>> children)

参数类型为Task的cn.wjybxx.btree中的构造器

限定符	构造器	说明
	BranchTask(Task<T> first, Task<T> second)
	Decorator(Task<T> child)
	TaskEntry(String name, Task<T> rootTask, T blackboard, Object entity, TreeLoader treeLoader)

类型变量类型为Task的cn.wjybxx.btree中的构造器参数

限定符	构造器	说明
	BranchTask(List<Task<T>> children)

cn.wjybxx.btree.branch中Task的使用

cn.wjybxx.btree.branch中Task的子类

修饰符和类型	类	说明
class	ActiveSelector<T>	主动选择节点 每次运行时都会重新测试节点的运行条件，选择一个新的可运行节点。
class	FixedSwitch<T>	展开的switch 在编辑器中，children根据坐标排序，容易变动；这里将其展开为字段，从而方便配置。
class	Foreach<T>	迭代所有的子节点最后返回成功
class	Join<T>	Join 1.在得出结果之前不会重复执行已完成的任务。
class	Parallel<T>	并行节点基类 定义该类主要说明一些注意事项，包括： 1.不建议在子节点完成事件中再次驱动子节点，避免运行execute()方法，否则可能导致其它task单帧内运行多次。
class	Selector<T>
class	SelectorN<T>	多选Selector。
class	Sequence<T>
class	ServiceParallel<T>	服务并发节点 1.其中第一个任务为主要任务，其余任务为后台服务。
class	SimpleParallel<T>	简单并发节点。
class	SingleRunningChildBranch<T>	非并行分支节点抽象(最多只有一个运行中的子节点)
class	Switch<T>	Switch-选择一个分支运行，直到其结束

声明为Task的cn.wjybxx.btree.branch中的字段

修饰符和类型	字段	说明
protected Task<T>	SingleRunningChildBranch.runningChild	运行中的子节点

返回Task的cn.wjybxx.btree.branch中的方法

修饰符和类型	方法	说明
Task<T>	FixedSwitch.getBranch1()
Task<T>	FixedSwitch.getBranch2()
Task<T>	FixedSwitch.getBranch3()
Task<T>	FixedSwitch.getBranch4()
Task<T>	FixedSwitch.getBranch5()
final Task<T>	SingleRunningChildBranch.getRunningChild()	获取运行中的子节点
protected Task<T>	SingleRunningChildBranch.nextChild()

参数类型为Task的cn.wjybxx.btree.branch中的方法

修饰符和类型	方法	说明
static <T> ParallelChildHelper<T>	Parallel.getChildHelper(Task<T> child)	获取child的helper
protected void	ActiveSelector.onChildCompleted(Task<T> child)
protected void	Foreach.onChildCompleted(Task<T> child)
protected void	Join.onChildCompleted(Task<T> child)
void	JoinPolicy.onChildCompleted(Join<T> join, Task<T> child)	Join在调用该方法前更新了完成计数和成功计数
protected void	Selector.onChildCompleted(Task<T> child)
protected void	SelectorN.onChildCompleted(Task<T> child)
protected void	Sequence.onChildCompleted(Task<T> child)
protected void	ServiceParallel.onChildCompleted(Task<T> child)
protected void	SimpleParallel.onChildCompleted(Task<T> child)
protected void	SingleRunningChildBranch.onChildCompleted(Task<T> child)	子类的实现模板：
protected void	Switch.onChildCompleted(Task<T> child)
protected void	ActiveSelector.onChildRunning(Task<T> child)
protected void	Foreach.onChildRunning(Task<T> child)
protected void	Join.onChildRunning(Task<T> child)
protected void	Parallel.onChildRunning(Task<T> child)	1.并发节点通常不需要在该事件中将自己更新为运行状态，而是应该在execute()方法的末尾更新 2.实现类可以在该方法中内联子节点
protected void	Selector.onChildRunning(Task<T> child)
protected void	SelectorN.onChildRunning(Task<T> child)
protected void	Sequence.onChildRunning(Task<T> child)
protected void	ServiceParallel.onChildRunning(Task<T> child)
protected void	SimpleParallel.onChildRunning(Task<T> child)
protected void	SingleRunningChildBranch.onChildRunning(Task<T> child)	子类如果支持内联，则重写该方法
protected void	Switch.onChildRunning(Task<T> child)
void	FixedSwitch.setBranch1(Task<T> branch1)
void	FixedSwitch.setBranch2(Task<T> branch2)
void	FixedSwitch.setBranch3(Task<T> branch3)
void	FixedSwitch.setBranch4(Task<T> branch4)
void	FixedSwitch.setBranch5(Task<T> branch5)

参数类型为Task的cn.wjybxx.btree.branch中的构造器

限定符	构造器	说明
	Selector(Task<T> first, Task<T> second)
	SelectorN(Task<T> first, Task<T> second)
	Sequence(Task<T> first, Task<T> second)
	SingleRunningChildBranch(Task<T> first, Task<T> second)

类型变量类型为Task的cn.wjybxx.btree.branch中的构造器参数

限定符	构造器	说明
	ActiveSelector(List<Task<T>> children)
	Foreach(List<Task<T>> children)
	Parallel(List<Task<T>> children)
	Selector(List<Task<T>> children)
	SelectorN(List<Task<T>> children)
	Sequence(List<Task<T>> children)
	ServiceParallel(List<Task<T>> children)
	SimpleParallel(List<Task<T>> children)
	SingleRunningChildBranch(List<Task<T>> children)

cn.wjybxx.btree.branch.join中Task的使用

参数类型为Task的cn.wjybxx.btree.branch.join中的方法

修饰符和类型	方法	说明
void	JoinAnyOf.onChildCompleted(Join<T> join, Task<T> child)
void	JoinMain.onChildCompleted(Join<T> join, Task<T> child)
void	JoinSelector.onChildCompleted(Join<T> join, Task<T> child)
void	JoinSelectorN.onChildCompleted(Join<T> join, Task<T> child)
void	JoinSequence.onChildCompleted(Join<T> join, Task<T> child)
void	JoinWaitAll.onChildCompleted(Join<T> join, Task<T> child)

cn.wjybxx.btree.decorator中Task的使用

cn.wjybxx.btree.decorator中Task的子类

修饰符和类型	类	说明
class	AlwaysCheckGuard<T>	每一帧都检查子节点的前置条件，如果前置条件失败，则取消child执行并返回失败。
class	AlwaysFail<T>	在子节点完成之后固定返回失败
class	AlwaysRunning<T>	在子节点完成之后仍返回运行。
class	AlwaysSuccess<T>	在子节点完成之后固定返回成功
class	Inverter<T>	反转装饰器，它用于反转子节点的执行结果。
class	LoopDecorator<T>	循环节点抽象
class	OnlyOnce<T>	只执行一次。
class	Repeat<T>	重复N次
class	SubtreeRef<T>	子树引用
class	UntilCond<T>	循环子节点直到给定的条件达成
class	UntilFail<T>	重复运行子节点，直到该任务失败
class	UntilSuccess<T>	重复运行子节点，直到该任务成功

返回Task的cn.wjybxx.btree.decorator中的方法

修饰符和类型	方法	说明
Task<T>	UntilCond.getCond()

参数类型为Task的cn.wjybxx.btree.decorator中的方法

修饰符和类型	方法	说明
protected void	AlwaysCheckGuard.onChildCompleted(Task<T> child)
protected void	AlwaysFail.onChildCompleted(Task<T> child)
protected void	AlwaysRunning.onChildCompleted(Task<T> child)
protected void	AlwaysSuccess.onChildCompleted(Task<T> child)
protected void	Inverter.onChildCompleted(Task<T> child)
protected void	OnlyOnce.onChildCompleted(Task<T> child)
protected void	Repeat.onChildCompleted(Task<T> child)
protected void	SubtreeRef.onChildCompleted(Task<T> child)
protected void	UntilCond.onChildCompleted(Task<T> child)
protected void	UntilFail.onChildCompleted(Task<T> child)
protected void	UntilSuccess.onChildCompleted(Task<T> child)
protected void	AlwaysCheckGuard.onChildRunning(Task<T> child)
protected void	AlwaysFail.onChildRunning(Task<T> child)
protected void	AlwaysRunning.onChildRunning(Task<T> child)
protected void	AlwaysSuccess.onChildRunning(Task<T> child)
protected void	Inverter.onChildRunning(Task<T> child)
protected void	OnlyOnce.onChildRunning(Task<T> child)
protected void	Repeat.onChildRunning(Task<T> child)
protected void	SubtreeRef.onChildRunning(Task<T> child)
protected void	UntilCond.onChildRunning(Task<T> child)
protected void	UntilFail.onChildRunning(Task<T> child)
protected void	UntilSuccess.onChildRunning(Task<T> child)
void	UntilCond.setCond(Task<T> cond)

参数类型为Task的cn.wjybxx.btree.decorator中的构造器

限定符	构造器	说明
	AlwaysCheckGuard(Task<T> child)
	AlwaysFail(Task<T> child)
	AlwaysSuccess(Task<T> child)
	Inverter(Task<T> child)
	LoopDecorator(Task<T> child)
	OnlyOnce(Task<T> child)
	UntilFail(Task<T> child)
	UntilSuccess(Task<T> child)

cn.wjybxx.btree.fsm中Task的使用

cn.wjybxx.btree.fsm中Task的子类

修饰符和类型	类	说明
class	ChangeStateTask<T>
class	StackStateMachineTask<T>	栈式状态机，在普通状态机的基础上支持了redo和undo
class	StateMachineTask<T>	状态机节点 ps:以我的经验来看，状态机是最重要的节点，Join则是仅次于状态机的节点 -- 不能以使用数量而定。

声明为Task的cn.wjybxx.btree.fsm中的字段

修饰符和类型	字段	说明
protected Task<T>	StateMachineTask.initState	初始状态
protected Task<T>	StateMachineTask.tempNextState	待切换的状态，主要用于支持当前状态退出后再切换 -- 即支持当前状态设置结果

返回Task的cn.wjybxx.btree.fsm中的方法

修饰符和类型	方法	说明
final Task<T>	StateMachineTask.discardTempNextState()	丢弃未切换的临时状态
final Task<T>	StateMachineTask.getCurState()	获取当前状态
Task<T>	StateMachineTask.getInitState()
Task<T>	ChangeStateTask.getNextState()
final Task<T>	StateMachineTask.getTempNextState()	获取临时的下一个状态
final Task<T>	StackStateMachineTask.peekRedoState()	查看redo对应的state
final Task<T>	StackStateMachineTask.peekUndoState()	查看undo对应的state

参数类型为Task的cn.wjybxx.btree.fsm中的方法

修饰符和类型	方法	说明
final boolean	StackStateMachineTask.addRedoState(Task<T> curState)	向redo队列中添加一个状态
final boolean	StackStateMachineTask.addUndoState(Task<T> curState)	向undo队列中添加一个状态
protected void	StackStateMachineTask.beforeChangeState(Task<T> curState, Task<T> nextState)
void	StateMachineHandler.beforeChangeState(StateMachineTask<T> stateMachineTask, Task<T> curState, Task<T> nextState)	该方法在进入新状态前调用 1.两个参数最多一个为null 2.可以设置新状态的黑板和其它数据 3.用户此时可为新状态分配上下文(黑板、取消令牌、共享属性)；同时清理前一个状态的上下文 4.用户此时可拿到新状态ChangeStateArgs，后续则不可 5.如果task需要感知redo和undo，则由用户将信息写入黑板
final void	StateMachineHandlers.RedoHandler.beforeChangeState(StateMachineTask<T> stateMachineTask, Task<T> curState, Task<T> nextState)
protected void	StateMachineTask.beforeChangeState(Task<T> curState, Task<T> nextState)
final void	StateMachineTask.changeState(Task<T> nextState)	切换状态 -- 如果状态机处于运行中，则立即切换
final void	StateMachineTask.changeState(Task<T> nextState, ChangeStateArgs changeStateArgs)	切换状态 1.如果当前有一个待切换的状态，则会被悄悄丢弃(todo 可以增加一个通知) 2.无论何种模式，在当前状态进入完成状态时一定会触发 3.如果状态机未运行，则仅仅保存在那里，等待下次运行的时候执行 4.当前状态可先正常完成，然后再切换状态，就可以避免进入被取消状态；可参考ChangeStateTask
static <T> StateMachineTask<T>	StateMachineTask.findStateMachine(Task<T> task)	查找task最近的状态机节点 1.仅递归查询父节点和长兄节点 2.优先查找附近的，然后测试长兄节点 - 状态机作为第一个节点的情况比较常见
static <T> StateMachineTask<T>	StateMachineTask.findStateMachine(Task<T> task, String name)	查找task最近的状态机节点 1.名字不为空的情况下，支持从兄弟节点中查询 2.优先测试父节点，然后测试兄弟节点
protected boolean	StateMachineTask.isReady(Task<T> curState, Task<?> nextState)
default int	StateMachineHandler.onChildCompleted(StateMachineTask<T> stateMachineTask, Task<T> curState)	该方法在当前状态正常结束(非stop结束)时调用
final int	StateMachineHandlers.RedoHandler.onChildCompleted(StateMachineTask<T> stateMachineTask, Task<T> curState)
protected void	StateMachineTask.onChildCompleted(Task<T> child)
protected void	StateMachineTask.onChildRunning(Task<T> child)
default boolean	StateMachineHandler.onNextStateAbsent(StateMachineTask<T> stateMachineTask, Task<T> preState)	当状态机没有下一个状态时调用该方法，以避免无可用状态 注意： 1.状态机启动时不会调用该方法 2.如果该方法返回后仍无可用状态，将触发无状态逻辑
boolean	StateMachineHandlers.RedoHandler.onNextStateAbsent(StateMachineTask<T> stateMachineTask, Task<T> preState)
void	StateMachineTask.setInitState(Task<T> initState)
void	ChangeStateTask.setNextState(Task<T> nextState)

参数类型为Task的cn.wjybxx.btree.fsm中的构造器

限定符	构造器	说明
	ChangeStateTask(Task<T> nextState)

cn.wjybxx.btree.leaf中Task的使用

cn.wjybxx.btree.leaf中Task的子类

修饰符和类型	类	说明
class	ActionTask<T>	行为节点抽象 (并非所有行为节点都需要继承该类)
class	ConditionTask<T>	条件节点 注意：并非条件节点必须继承该类。
class	Failure<T>
class	Running<T>
class	SimpleRandom<T>	简单随机任务 在正式的项目中，Random应当从实体上获取。
class	Success<T>
class	WaitFrame<T>	等待N帧