Using Lua to define NPC behaviour in a C++ game engine

I'm working on a game engine in C++ using Lua for NPC behaviour. I ran into some problems during the design.

For everything that needs more than one frame for execution I wanted to use a linked list of processes (which are C++ classes). So this:

goto(point_a)
say("Oh dear, this lawn looks really scruffy!")
mowLawn()

would create a GotoProcess object, which would have a pointer to a SayProcess object, which would have a pointer to a MowLawnProcess object. These objects would be created instantly when the NPC is spawned, no further scripting needed. The first of these objects will be updated each frame. When it's finished, it will be deleted and the next one will be used for updating. I extended this model by a ParallelProcess which would contain multiple processes that are updated simultaneously.

I found some serious problems. Look at this example: I want a character to walk to point_a and then go berserk and just attack anybody who comes near. The script would look like that:

goto(point_a)
while true do
    character = getNearestCharacterId()
    attack(character)
end

That wouldn't work at all with my design. First of all, the character variable would be set at the beginning, when the character hasn't even started walking to point_a. Then, then script would continue adding AttackProcesses forever due to the while loop.

I could implement a WhileProcess for the loop and evaluate the script line by line. I doubt this would increase readability of the code though.

Is there another common approach I didn't think of to tackle this 开发者_JAVA百科problem?

I think the approach you give loses a lot of the advantages of using a scripting language. It will break with conditionals as well as loops.

With coroutines all you really need to do is:

npc_behaviour = coroutine.create(
    function()
        goto(point_a)
        coroutine.yield()
        say("Oh dear, this lawn looks really scruffy!")
        coroutine.yield()
        mowLawn()
        coroutine.yield()
    end
)

goto, say and mowLawn return immediately but initiate the action in C++. Once C++ completes those actions it calls coroutine.resume(npc_behaviour)

To avoid all the yields you can hide them inside the goto etc. functions, or do what I do which is have a waitFor function like:

function waitFor(id)
    while activeEvents[id] ~= nil do
        coroutine.yield()
    end
end

activeEvents is just a Lua table which keeps track of all the things which are currently in progress - so a goto will add an ID to the table when it starts, and remove it when it finishes, and then every time an action finishes, all coroutines are activated to check if the action they're waiting for is finished.

Have you looked at Finite State Machines ? If I were you I wouldn't use a linked list but a stack. I think the end result is the same.

stack:push(action:new(goto, character, point_a))
stack:push(action:new(say, character, "Oh dear, this lawn was stomped by a mammoth!"))
stack:push(action:new(mowLawn, character))

Executing the actions sequentially would give something like :

while stack.count > 0 do -- do all actions in the stack
    action = stack:peek() -- gets the action on top of the stack
    while action.over ~= true do -- continue action until it is done
        action:execute() -- execute is what the action actually does
    end
    stack:pop() -- action over, remove it and proceed to next one
end

The goto and other functions would look like this :

function goto(action, character, point)
    -- INSTANT MOVE YEAH
    character.x = point.x
    character.y = point.y
    action.over = true -- set the overlying action to be over
end

function attack(action, character, target)
    -- INSTANT DEATH WOOHOO
    target.hp = 0
    action.over = true -- attack is a punctual action
end

function berserk(action, character)
    attack(action, character, getNearestCharacterId()) -- Call the underlying attack
    action.over = false -- but don't set action as done !
end

So whenever you stack:push(action:new(berserk, character)) it will loop on attacking a different target every time.

I also made you a stack and action implementation in object lua here. Haven't tried it. May be bugged like hell. Good luck with your game !

I don't know the reasons behind you design, and there might be simpler / more idiomatic ways to it.

However, would writing a custom "loop" process that would somehow take a function as it's argument do the trick ?

 goto(point_a)
 your_loop(function () 
   character = getNearestCharacterId()
   attack(character)
 end)

Since Lua has closures (see here in the manual), the function could be attached to your 'LoopProcess', and you call this same function at each frame. You would probably have to implement your LoopProcess so that that it's never removed from the process list ...

If you want your loop to be able to stop, it's a bit more complicated ; you would have to pass another function containing the test logic (and again, you LoopProcess would have to call this every frame, or something).

Hoping I understood your problem ...