lua行为树设计与实现

项目需要，之前行为树用的是behaviorDesigner，要改成纯lua的

我先做了一版用递归实现，代码可读性高但是中断机制实现起来比较复杂，而且创建自定义action重写方法时需要调用父类的方法， 如果忘了调用就会出现问题， 所以改成了用栈模拟递归。

用栈模拟递归好处在于效率高，并且容易控制，用非递归实现后自定义一个行为树节点，那么该节点不用知道父亲的方法，只要做好自己的事情就OK了

完整测试工程已上传到了github：https://github.com/MCxYY/LuaBT

行为树整体结构

（和BehaviorDesigner很像，因为就是参考BehaviorDesigner设计的，要做的是c#移植成lua，移植成本尽可能低）

如上，base文件夹中是行为树核心逻辑，最好不要修改，其他几个文件夹是自定义节点，如果是Action节点那么继承Base中的Action.lua；如果是Composite节点则继承Composite.lua等

行为树类结构大致如下：（出于篇幅限制，有些方法没写出来）

其中BTManager存储着所有行为树BTree，unity每帧调用BTManager的Update，而BTManager调用所有运行中的BTree的Update，BTree管理着自身的节点Task，根据逻辑执行调用Task的OnAwake（）、OnStart等

Shared是节点共享数据，在后文中讲述

Task的OnAwake是整颗行为树激活时运行一次

OnStart是进入该Task时运行一次

OnUpdate是该Task执行中时每帧运行一次

OnPause（bPause）是整棵行为树暂停或者从暂停中苏醒时运行，bPause为true则暂停

OnEnd（）是该Task退出时运行一次

运行逻辑

行为树（BTree）启动的时候调用BTree.Init()方法先序遍历该树，获得一系列节点数据，比如赋值儿子index，每个节点的儿子index是什么，每个节点的父亲index等，代码如下：

 --先序遍历，root的index为1、父亲index为0
 function BT.BTree:Init(task, parentIndex, compositeIndex)
     task:Init(self)
     task:OnAwake()
     local curIndex = #self.tTaskList +
     table.insert(self.tTaskList,task) --赋值task的index
     table.insert(self.tParentIndex,parentIndex) --可以找到其父亲的index
     table.insert(self.tParentCompositeIndex,compositeIndex) --可以找到是Composite类型且离自己最近的祖先的index，用于中断评估

     if task:CheckType(BT.ParentTask) then
         if task:CheckChildCount() == false then
             LogMgr.Error(BT.ErrorRet.ChildCountMin.." index = "..curIndex.." count = "..#task.tChildTaskList)
             return
         end
         self.tChildrenIndex[curIndex] = {}
         self.tChildConditionalIndex[curIndex] = {}
         for i = , #task.tChildTaskList do
             table.insert(self.tRelativeChildIndex,i) --该task在其父亲中处于第几个
             table.insert(self.tChildrenIndex[curIndex],#self.tTaskList + ) --可以找到其所有儿子的index
             if task:CheckType(BT.Composite) then
                 self:Init(task.tChildTaskList[i], curIndex, curIndex)
             else
                 self:Init(task.tChildTaskList[i], curIndex, compositeIndex)
             end
         end
     else
         if task:CheckType(BT.Conditional) then
             --可以找到是Conditional类型且离自己最近的子孙的index，用于中断评估
             table.insert(self.tChildConditionalIndex[self.tParentCompositeIndex[curIndex]],curIndex)
         end
     end
 end

行为树（BTree）中存储着一个list<stack<taskindex>>，这个是运行栈，行为树启动时创建一个运行栈，塞进去树根；每当有并行分支，则创建一个运行栈，塞进去分支第一个运行的节点。

节点（Task）的状态有四种：

1、ETaskStatus.Inactive //未激活

2、ETaskStatus.Failure //失败

3、ETaskStatus.Success //成功

4、ETaskStatus.Running //运行中

运行栈中放的节点都是处于Running状态，update时遍历运行栈，取出栈顶节点执行，如果节点执行完毕后状态不等于running，说明该节点不需要再次运行，那么就出栈，代码如下：

 function BT.BTree:Update()
     --进入评估阶段，中断修改运行栈
     self:ConditionalReevaluate()
     local status
     if #self.tRunStack ==  then
         return BT.ETaskStatus.Inactive
     end
     --遍历执行所有栈
     for i = #self.tRunStack,,- do
         repeat
             if self.tRunStack[i] == Const.Empty then
                 table.remove(self.tRunStack,i)
                 break
             end
             status = BT.ETaskStatus.Inactive
             while status ~= BT.ETaskStatus.Running do
                 if self.tRunStack[i] ~= Const.Empty then
                     status = self:RunTask(self.tRunStack[i]:Peek(),i)
                 else
                     break
                 end
             end
         until(true)
     end
     return BT.ETaskStatus.Running
 end

节点运行的时候

如果该节点是ParentTask类型则需要运行儿子，其状态由儿子执行完毕后的状态来决定

如果该节点是Task类型没有儿子，那么其状态就是其Update的状态

递归实现那么代码大致如下：

status task.runParent(){

　　for task.childList {

　　　　if typeOf(task.childItem) == ParentTask {

　　　　　　status = task.childItem.runParent()

　　　　}

　　　　else{

　　　　　　status = task.childItem.OnUpdate()

　　　　}

　　　　if task.CanExcute(status) == false{

　　　　　　return task.status

　　　　}

　　}

　　return task.status

}

栈实现虽然麻烦点，但思路还是一样的，多了出栈入栈和其他一些操作

RunTask()

 function BT.BTree:RunTask(taskIndex, stackIndex)
     local task = self.tTaskList[taskIndex]
     self:PushTask(taskIndex,stackIndex)

     local status = BT.ETaskStatus.Inactive

     if task:CheckType(BT.ParentTask) then
         status = self:RunParentTask(taskIndex,stackIndex)
     else
         status = task:OnUpdate()
     end

     if status ~= BT.ETaskStatus.Running then
         self:PopTask(stackIndex, status)
     end
     return status
 end

RunParent()

 function BT.BTree:RunParentTask(taskIndex, stackIndex)
     local task = self.tTaskList[taskIndex]
     local curRelChildIndex = -
     local preRelChildIndex = -
     while task:CanExcute() do
         curRelChildIndex = task:GetCurChildIndex()
         if curRelChildIndex == preRelChildIndex then
             return BT.ETaskStatus.Running
         end
         local childIndex = self.tChildrenIndex[taskIndex][curRelChildIndex]
         if childIndex == nil then
             break
         end
         --这个主要是为并行节点服务的
         --其他类型的节点都是儿子执行完毕主动通知父亲然后curChildIndex指向下个儿子
         --但是并行节点是所有儿子一开始都同时执行
         task:OnChildStart(curRelChildIndex)
         if task:CanExcuteParallel() then
             --并行节点创建新的分支
             local newStack = Stack:New()
             table.insert(self.tRunStack, newStack)
             newStack:Push(childIndex)
             self:RunTask(childIndex, #self.tRunStack)
         else
             self:RunTask(childIndex, stackIndex)
         end
         preRelChildIndex = curRelChildIndex
     end
     return task:GetStatus()
 end

节点共享数据

节点共享数据分为三种：一，树之间任意节点全局共享的数据  二，树内任意节点共享的数据 三，节点内不共享数据

节点内数据那就不用说了，在节点内声明的数据都是节点内数据

BehaviorDesigner的共享数据是通过编辑器保存读取的

由于时间不允许，没有做编辑器，所以我就做了个存储的类简单的实现了下

Shared.lua就是存储的类，其实里面就是一个table，对外只提供一个GetData(name)的方法，如果没有name的变量就创建个值为空的table保存起来，返回这个table

结构大致是data = {

name1 = {name = name1, val = val1},

...

name2 = {name = name2, val = val2},

}

之所以用table存，是因为table在lua中属于引用类型

shared.lua代码如下：

 BT.Shared = {}
 BT.Shared.__index = BT.Shared

 function BT.Shared:New()
     local o = {}
     setmetatable(o,BT.Shared)
     o.data = {} -- val is [name] = {name = name,val = val}
     return o
 end

 function BT.Shared:GetData(name)
     if self.data[name] == nil then
         self.data[name] = {name = name,val = nil}
     end
     return self.data[name]
 end

那么全局共享数据放在BTManager中，使得树都可以访问

树内共享数据放在树中

在树执行Init时将树传给task

代码如下：

 BT.Mgr = {
     ...
     globalSharedData = BT.Shared:New()
 }

 function BT.BTree:New(gameObject, name)
     local o = {}
     setmetatable(o,this)
     ...
     o.sharedData = BT.Shared:New()
     o.globalSharedData = BT.Mgr.globalSharedData
     ...
 }

 function BT.BTree:Init(task, parentIndex, compositeIndex)
     task:Init(self)
     ...
 }

中断的实现

中断的实现应该是行为树中比较复杂的功能了，涉及到树上的一些算法及运行栈的操作，牵涉到的判断也多，这里会重点讲述

中断必要的原因是可能存在以下情况（不限于此情况）：
比如怪物正在向目标点移动的时候遇到玩家需要攻击，此时移动的节点状态是running，没有中断的时候只能走到目标点的时候返回success停止移动才开始进入其他节点，这时候就错过了攻击玩家，中断的作用就体现出来了，就算是在running状态也能打断运行栈进入攻击节点

BehaviorDesigner打断的方法是将打断类型分为这么几类：

EAbortType = {

　　None = 0, //不打断

　　Self = 1, //打断自身

　　LowerPriority = 2, //打断低优先级

　　Both = 3, //同时包括Self和LowerPriority两种效果

}

其中只有Composite类型的节点可以拥有打断操作

Self打断类型：指的是Composite节点下面的直系子孙（这个名词是我临时取得。。意思是Composite与Conditional中间可以插入Decorate，可以插入Composite但插入得Composite类型必须是Self或Both）Conditional类型的节点的状态发生变化时，那么打断正在运行且是Composite子孙的分支，重新进入变化的Conditional节点所处的分支中。打断的结构大概如下图所示：

（绿色的指正在运行中的节点）

那么Conditional变化时可以打断Task2，当然如果Task1处于运行时也可以打断，因为Composite2的打断类型为Self且Composite3的打断类型也是Self，即AbortType是可以递归的

运行栈回退到Composite和运行节点的最近公共祖先节点，在此图中回退到Composite3节点处。

假设Composite2的打断类型是None或者LowerPriority且正在运行的是Task1，那么就不会打断

LowerPriority打断类型：指的是当Composite直系子孙（意思同上，只是插入的Composite必须是LowerPriority或Both）Conditional类型的节点的状态变化时，那么打断运行节点所处分支是Composite兄弟节点分支，打断结构如下图所示：

假设正在运行的是Task1，那么不可以打断

通过以上的例子，我们可以知道，从Composite到Conditional是一条链也就是打断链，将打断链存储下来，每次树update的时候先判断运行分支是否和打断链上的节点处于同一分支，那么就可以打断

Self打断链和LowerPriority的打断链如图所示：（当运行分支处于红色节点分支中，则可以打断）

当然还有一种情况例外，比如并行节点Parallel，也属于Composite，但是两个子分支之间是不能打断的，如下图所示，不能打断Task，因为Conditional和Task是两个运行栈

通过上面所说，我们只需要算出打断链算出来并存储下来进行计算即可。

只有Conditional进行过一次才可以进行中断评估

那么在节点出栈的时候进行计算，将打断链接上自己的父亲，或者删除打断链，代码如下所示：

 function BT.BTree:PopTask(stackIndex, status)
     ...
     ...
     --reevaluate
     local parentCompositeIndex = self.tParentCompositeIndex[taskIndex]
     local parentComposite = self.tTaskList[parentCompositeIndex]

     --如果节点是Conditional类型且父亲Composite有中断类型，那么创建中断链保存起来
     if task:CheckType(BT.Conditional) then
         if  parentComposite ~= nil and parentComposite.abortType ~= BT.EAbortType.None then
             if self.tConditionalReevaluateDic[taskIndex]  == nil then
                 local reevaluate = BT.Reevaluate:New(taskIndex, status, stackIndex, parentComposite.abortType == BT.EAbortType.LowerPriority and  or parentCompositeIndex, parentComposite.abortType)
                 table.insert(self.tConditionalReevaluate,reevaluate)
                 self.tConditionalReevaluateDic[taskIndex] = reevaluate
             end
         end
     elseif task:CheckType(BT.Composite) then

         repeat
             --LowerPriority延迟指向
             if task.abortType == BT.EAbortType.LowerPriority then
                 for i = , #self.tChildConditionalIndex[taskIndex] do
                     local reevalute = self.tConditionalReevaluateDic[self.tChildConditionalIndex[taskIndex][i]]
                     if reevalute ~= nil then
                         reevalute.compositeIndex = taskIndex
                     end
                 end
             end

             --指向自己的reevalute重新指向自己的父亲
             local lam_BothOrOther = function(tab,abortType)
                 if tab.abortType == abortType or tab.abortType == BT.EAbortType.Both then
                     return true
                 end
                 return false
             end

             for i = , #self.tConditionalReevaluate do
                 local reevalute = self.tConditionalReevaluate[i]
                 if reevalute.compositeIndex == taskIndex then
                     if lam_BothOrOther(task,BT.EAbortType.Self) and lam_BothOrOther(parentComposite,BT.EAbortType.Self) and lam_BothOrOther(reevalute,BT.EAbortType.Self) or
                             lam_BothOrOther(task,BT.EAbortType.LowerPriority) and lam_BothOrOther(reevalute,BT.EAbortType.LowerPriority)
                     then
                         reevalute.compositeIndex = parentCompositeIndex
                         if reevalute.abortType == BT.EAbortType.Both then
                             if task.abortType == BT.EAbortType.Self or parentComposite.abortType == BT.EAbortType.Self then
                                 reevalute.abortType = BT.EAbortType.Self
                             elseif task.abortType == BT.EAbortType.LowerPriority or parentComposite.abortType == BT.EAbortType.LowerPriority then
                                 reevalute.abortType = BT.EAbortType.LowerPriority
                             end
                         end
                     end
                 end
             end

             --自己已经出栈，删除目前还指向自己的中断链
             for i = #self.tConditionalReevaluate,,-  do
                 local reevalute = self.tConditionalReevaluate[i]
                 if reevalute.compositeIndex == taskIndex then
                     self.tConditionalReevaluateDic[reevalute.index] = nil
                     table.remove(self.tConditionalReevaluate,i)
                 end
             end
         until(true)

     end
     if stack:Empty() then
         self.tRunStack[stackIndex] = Const.Empty
     end
     task:OnEnd()
 end

经过上一步就计算并保存了中断链，接下来就是打断操作，代码如下所示：

 --遍历所有的中断链
 function BT.BTree:ConditionalReevaluate()
     for i = , #self.tConditionalReevaluate do
         repeat
             local reevalute = self.tConditionalReevaluate[i]
             if reevalute == nil or reevalute.compositeIndex ==  then
                 break
             end
             local status = self.tTaskList[reevalute.index]:OnUpdate()
             if status == reevalute.status then
                 break
             end
             --打断
             local bBreak = false
             for stackIndex = , #self.tRunStack do
                 repeat
                     if self.tRunStack[stackIndex] == Const.Empty then
                         break
                     end
                     local runIndex = self.tRunStack[stackIndex]:Peek()
                     local lcaIndex = self:LCA(reevalute.compositeIndex,runIndex)
                     --只有在reevaluate打断链上的运行节点才能被打断
                     if not self:IsParent(reevalute.compositeIndex,lcaIndex) then
                         break
                     end
                     --如果运行节点和reevaluate的conditional处于同一个并行节点的不同分支上，不能被打断
                     if stackIndex ~= reevalute.stackIndex and self.tTaskList[self:LCA(reevalute.index,runIndex)]:CanExcuteParallel() then
                         break
                     end

                     if reevalute.abortType == BT.EAbortType.LowerPriority and self.tParentCompositeIndex[reevalute.index] == self.tParentCompositeIndex[runIndex] then
                         break
                     end

                     --更改运行栈
                     while true do
                         if self.tRunStack[stackIndex] == Const.Empty or self.tRunStack[stackIndex]:Empty() then
                             break
                         end
                         runIndex = self.tRunStack[stackIndex]:Peek()
                         if runIndex == lcaIndex then
                             self.tTaskList[lcaIndex]:OnConditionalAbort()
                             break
                         end
                         self:PopTask(stackIndex,BT.ETaskStatus.Inactive)
                     end
                     bBreak = true
                 until(true)
             end

             if not bBreak then
                 break
             end
             --删除同一个中断链且优先级较低的reevalute
             for j = #self.tConditionalReevaluate, i,- do
                 local nextReevalute = self.tConditionalReevaluate[j]
                 if self:IsParent(reevalute.compositeIndex,nextReevalute.index) then
                     self.tConditionalReevaluateDic[nextReevalute.index] = nil
                     table.remove(self.tConditionalReevaluate,j)
                 end
             end
         until(true)
     end
 end

至此，行为树讲述完毕

欢迎转载，转载请注明出处：https://www.cnblogs.com/McYY/p/11689623.html，谢谢