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 + 1
    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 = 1, #task.tChildTaskList do
            table.insert(self.tRelativeChildIndex,i) --该task在其父亲中处于第几个
            table.insert(self.tChildrenIndex[curIndex],#self.tTaskList + 1) --可以找到其所有儿子的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 == 0 then
        return BT.ETaskStatus.Inactive
    end
    --遍历执行所有栈
    for i = #self.tRunStack,1,-1 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 = -1
    local preRelChildIndex = -1
    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 0 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 = 1, #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 = 1, #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,1,-1  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 = 1, #self.tConditionalReevaluate do
        repeat
            local reevalute = self.tConditionalReevaluate[i]
            if reevalute == nil or reevalute.compositeIndex == 0 then
                break
            end
            local status = self.tTaskList[reevalute.index]:OnUpdate()
            if status == reevalute.status then
                break
            end
            --打断
            local bBreak = false
            for stackIndex = 1, #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,-1 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，谢谢