Lua FSM有限状态机的实现

最近做项目，因为要将游戏的代码基本全部改成lua的，对c#层面的东西基本只要unity的生命周期就可以了。刚开始接触lua，心痒痒，决定上网买了《Lua游戏AI开发指南》看看，决定实现一个fsm以便于在项目中使用。在这里贴出代码，其实代码都是直接抄这本书的。建议直接买书看，对于不想买书又想实现lua的状态机的可以直接拿下面的代码使用就可以了。

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

require "Action"
--require "FiniteState"
require "FiniteStateTransition"

FiniteState = {}

function FiniteState.new(name,action)
    local state = {}
    -- 状态的数据
    state.name_ = name
    state.action_ = action

    return state
end

FiniteStateTransition = {}

function FiniteStateTransition.new(toStateName,evaluator)
    local transition = {}

    -- 状态转换条件的数据
    transition.evaluator_ = evaluator
    transition.toStateName_ = toStateName

    return transition
end

require "Action"
require "FiniteState"
require "FiniteStateTransition"

FiniteStateMachine = {}

function FiniteStateMachine.new(userData)
    local fsm = {}

    -- 状态机的数据
    fsm.currentState_ = nil
    fsm.states_ = {}
    fsm.transition_ = {}
    fsm.userData_ = userData

    fsm.AddState = FiniteStateMachine.AddState
    fsm.AddTransition = FiniteStateMachine.AddTransition
    fsm.ContainState = FiniteStateMachine.ContainState
    fsm.ContainTransition = FiniteStateMachine.ContainTransition
    fsm.GetCurrentStateName = FiniteStateMachine.GetCurrentStateName
    fsm.GetCurrentStateStatus = FiniteStateMachine.GetCurrentStateStatus
    fsm.SetState = FiniteStateMachine.SetState
    fsm.Update = FiniteStateMachine.Update

    return fsm
end


function FiniteStateMachine.ContainState(self,stateName)
    return self.states_[stateName] ~= nil
end

function FiniteStateMachine.ContainTransition(self,fromStateName,toStateName)
    return self.transition_[fromStateName] ~= nil and
        self.transition_[fromStateName][toStateName] ~= nil
end

function FiniteStateMachine.GetCurrentStateName(self)
    if self.currentState_ then
        return self.currentState_.name_
    end
end

function FiniteStateMachine.GetCurrentStateStatus(self)
    if self.currentState_ then
        return self.currentState_.action_.status_
    end
end


function FiniteStateMachine.SetState(self,stateName)
    if self:ContainState(stateName) then
        if self.currentState_ then
            self.currentState_.action_:CleanUp()
        end

        self.currentState_ = self.states_[stateName]
        self.currentState_.action_:Initialize()
    end
end
function FiniteStateMachine.AddState(self,name,action)
    self.states_[name] = FiniteState.new(name,action)
end

function FiniteStateMachine.AddTransition(self,fromStateName,toStateName,evaluator)
    if self:ContainState(fromStateName) and
        self:ContainState(toStateName) then

        if self.transition_[fromStateName] == nil then
            self.transition_[fromStateName] = {}
        end

        table.insert(
            self.transition_[fromStateName],
            FiniteStateTransition.new(toStateName,evaluator)
        )

    end
end
local function EvaluateTransitions(self,transitions)
    for index = 1 , #transitions do
        if transitions[index].evaluator_(self.userData_) then
            return transitions[index].toStateName_;
        end
    end
end
function FiniteStateMachine.Update(self,deltaTimeInMillis)
    if self.currentState_ then
        local status = self:GetCurrentStateStatus()

        if status == Action.Status.RUNNING then
            self.currentState_.action_:Update(deltaTimeInMillis)
        elseif status == Action.Status.TERMINATED then
            local toStateName = EvaluateTransitions(self,self.transition_[self.currentState_.name_])

            if self.states_[toStateName] ~= nil then
                self.currentState_.action_:CleanUp()
                self.currentState_ = self.states_[toStateName]
                self.currentState_.action_:Initialize()
            end
        end
    end
end

下面是测试代码

timer = 0

function SoldierActions_IdleCleanUp(userData)
    print("SoldierActions_IdleCleanUp data is "..userData)
    timer = 0
end

function SoldierActions_IdleInitialize(userData)
    print("SoldierActions_IdleInitialize data is "..userData)
    timer = 0
end

function SoldierActions_IdleUpdate(deltaTimeInMillis,userData)
    print("SoldierActions_IdleUpdate data is "..userData)
    timer = (timer + 1)
    if timer > 3 then
        return Action.Status.TERMINATED
    end

    return Action.Status.RUNNING
end


function SoldierActions_DieCleanUp(userData)
    print("SoldierActions_DieCleanUp data is "..userData)
    timer = 0
end

function SoldierActions_DieInitialize(userData)
    print("SoldierActions_DieInitialize data is "..userData)
    timer = 0
end

function SoldierActions_DieUpdate(deltaTimeInMillis,userData)
    print("SoldierActions_DieUpdate data is "..userData)
    timer = (timer + 1)
    if timer > 3 then
        return Action.Status.TERMINATED
    end

    return Action.Status.RUNNING
end

function SoldierEvaluators_True(userData)
    print("SoldierEvaluators_True data is "..userData)
    return true
end

function SoldierEvaluators_False(userData)
    print("SoldierEvaluators_True data is "..userData)
    return false
end

require "SoldierActions"
require "FiniteStateMachine"
require "SoldierEvaluators"

local function IdleAction(userData)
    return Action.new(
        "idle",
        SoldierActions_IdleInitialize,
        SoldierActions_IdleUpdate,
        SoldierActions_IdleCleanUp,
        userData
    )
end


local function DieAction(userData)
    return Action.new(
        "die",
        SoldierActions_DieInitialize,
        SoldierActions_DieUpdate,
        SoldierActions_DieCleanUp,
        userData
    )
end

function SoldierLogic_FiniteStateMachine(userData)
    local fsm = FiniteStateMachine.new(userData)
    fsm:AddState("idle",IdleAction(userData))
    fsm:AddState("die",    DieAction(userData))

    fsm:AddTransition("idle","die",SoldierEvaluators_True)
    fsm:AddTransition("die","idle",SoldierEvaluators_True)

    fsm:SetState('idle')

    return fsm
end

基本就是这样，挺喜欢这个状态机的。

这本书还有讲决策树和行为树的代码，以后有需求再实现一遍。