Lua 行为树实现

BehaviorTreeNode = {}

BehaviorTreeNode.Type = {
    ACTION = "ACTION",
    CONDITION = "CONDITION",
    SELECTOR = "SELECTOR",
    SEQUENCE = "SEQUENCE"
}

function BehaviorTreeNode.new(name,type)
    local node = {}

    node.action_ = nil
    node.children_ = {}
    node.evaluator_ = nil
    node.name_ = name or ""
    node.parent_ = nil
    node.type_ = type or BehaviorTreeNode.Type.ACTION

    node.AddChild = BehaviorTreeNode.AddChild
    node.ChildIndex = BehaviorTreeNode.ChildIndex
    node.GetChild = BehaviorTreeNode.GetChild
    node.GetNumberOfChildren = BehaviorTreeNode.GetNumberOfChildren

    node.GetParent = BehaviorTreeNode.GetParent
    node.SetAction = BehaviorTreeNode.SetAction
    node.SetEvaluator = BehaviorTreeNode.SetEvaluator
    node.SetType = BehaviorTreeNode.SetType

    return node
end

function BehaviorTreeNode.AddChild(self,child,index)
    index = index or (#self.children_ + 1)
    table.insert(self.children_,index,child)
    child.parent_ = self
end

function BehaviorTreeNode.ChildIndex(self,child)
    for index = 1, #self.children_ do
        if self.children_[index] == child then
            return index
        end
    end

    return -1
end

function BehaviorTreeNode.GetChild(self,childIndex)
    return self.children_[childIndex]
end

function BehaviorTreeNode.GetNumberOfChildren(self)
    return #self.children_
end

function BehaviorTreeNode.GetParent(self)
    return self.parent_
end

function BehaviorTreeNode.SetAction(self,action)
    self.action_ = action
end

function BehaviorTreeNode.SetEvaluator(self,evaluator)
    self.evaluator_ = evaluator
end

function BehaviorTreeNode.SetType(self,type)
    self.type_ = type
end

require "BehaviorTreeNode"
require "Action"

BehaviorTree = {}

local _EvaluateSelector
local _EvaluateSequence

function BehaviorTree.SetNode(self,node)
    self.node_ = node
end

function BehaviorTree.new(userData)
    local tree = {}

    tree.currentNode_ = nil
    tree.node_ = nil
    tree.userData_ = userData

    tree.SetNode = BehaviorTree.SetNode
    tree.Update = BehaviorTree.Update

    return tree
end

_EvaluateSelector = function(self,node,deltaTimeInMillis)
    for index = 1,#node.children_ do
        local child = node:GetChild(index)

        if child.type_ == BehaviorTreeNode.Type.ACTION then
            return {node = child,result = true}
        elseif child.type_ == BehaviorTreeNode.Type.CONDITION then
            assert(false)
            return {result = false}
        elseif child.type_ == BehaviorTreeNode.Type.SELECTOR then
            local result = _EvaluateSelector(self,child,deltaTimeInMillis)

            if result.result then
                return result
            end
        elseif child.type_ == BehaviorTreeNode.Type.SEQUENCE then
            local result = _EvaluateSequence(self,child,deltaTimeInMillis)

            if result.result then
                return result
            end
        end

    end

    return {result = false}
end

_EvaluateSequence = function(self,node,deltaTimeInMillis,index)

    index = index or 1

    for count = index,#node.children_ do
        local child = node:GetChild(count)

        if child.type_ == BehaviorTreeNode.Type.ACTION then
            return  { node = child,result = true }
        elseif child.type_ == BehaviorTreeNode.Type.CONDITION then
            local result = child.evaluator_(self.userData_)

            if not result then
                return {result = false}
            end

        elseif child.type_ == BehaviorTreeNode.Type.SELECTOR then
            local result = _EvaluateSelector(self,child,deltaTimeInMillis)

            if not result.result then
                return {result = false}
            elseif result.result and result.node ~= nil then
                return result
            end
        elseif child.type_ == BehaviorTreeNode.Type.SEQUENCE then
            local result = _EvaluateSequence(self,child,deltaTimeInMillis)

            if not result.result then
                return {result = false}
            elseif result.result and result.node ~= nil then
                return result
            end

        end

        count = count + 1

    end

    return {result = true}
end

local function _EvaluateNode(self,node,deltaTimeInMillis)
    if node.type_ == BehaviorTreeNode.Type.ACTION then
        return node
    elseif node.type_ == BehaviorTreeNode.Type.CONDITION then
        assert(false)
    elseif node.type_ == BehaviorTreeNode.Type.SELECTOR then
        local result = _EvaluateSelector(self,node,deltaTimeInMillis)

        if result.result then
            return result.node
        end
    elseif node.type_ == BehaviorTreeNode.Type.SEQUENCE then
        local result = _EvaluateSequence(self,node,deltaTimeInMillis)

        if result.result then
            return result.node
        end
    end
end

local function _ContinueEvaluation(self,node,deltaTimeInMillis)
    local parentNode = node:GetParent()
    local childNode = node
    while parentNode ~= nil do
        if parentNode.type_ == BehaviorTreeNode.Type.SEQUENCE then
            local childIndex = parentNode:ChildIndex(childNode)

            if childIndex < parentNode:GetNumberOfChildren() then
                local result = _EvaluateSequence(self,parentNode,deltaTimeInMillis,childIndex + 1)

                if result.result then
                    return result.node
                end
            end
        end

        childNode = parentNode
        parentNode = childNode:GetParent()
    end
end

function BehaviorTree.Update(self,deltaTimeInMillis)
    if self.currentNode_ == nil then
        self.currentNode_ = _EvaluateNode(self,self.node_,deltaTimeInMillis)
    end

    if self.currentNode_ ~= nil then
        local status = self.currentNode_.action_.status_
        if status == Action.Status.UNINIIALIZED then
            self.currentNode_.action_:Initialize()
        elseif status == Action.Status.TERMINATED then
            self.currentNode_.action_:CleanUp()

            self.currentNode_ = _ContinueEvaluation(self,self.currentNode_,deltaTimeInMillis)

        elseif status == Action.Status.RUNNING then
            self.currentNode_.action_:Update(deltaTimeInMillis)
        end
    end
end

Action = {}

Action.Status = {
    RUNNING = "RUNNING",
    TERMINATED = "TERMINATED",
    UNINIIALIZED = "UNINIIALIZED"
}

Action.Type = "Action"


function Action.new(name,initializeFunction,updateFunction,cleanUpFunction,userData)

    local action = {}

    action.cleanUpFunction_ = cleanUpFunction
    action.initializeFunction_ = initializeFunction
    action.updateFunction_  = updateFunction
    action.name_ = name or ""
    action.status_ = Action.Status.UNINIIALIZED
    action.type_ = Action.Type
    action.userData_ = userData

    action.CleanUp = Action.CleanUp
    action.Initialize = Action.Initialize
    action.Update = Action.Update

    return action
end

function Action.Initialize(self)
    if self.status_ == Action.Status.UNINIIALIZED then
        if self.initializeFunction_ then
            self.initializeFunction_(self.userData_)
        end
    end

    self.status_ = Action.Status.RUNNING
end


function Action.Update(self,deltaTimeInMillis)
    if self.status_ == Action.Status.TERMINATED then
        return Action.Status.TERMINATED
    elseif self.status_ == Action.Status.RUNNING then
        if self.updateFunction_ then
            self.status_ = self.updateFunction_(deltaTimeInMillis,self.userData_)

            assert(self.status_)
        else
            self.status_ = Action.Status.TERMINATED
        end
    end

    return self.status_

end
function Action.CleanUp(self)
    if self.status_ == Action.Status.TERMINATED then
        if self.cleanUpFunction_ then
            self.cleanUpFunction_(self.userData_)
        end
    end

    self.status_ = Action.Status.UNINIIALIZED
end