Lua, C++ behavior tree 최적화2

🐉 C++ 기반 Behavior Tree (Lua + C++)

이제 Behavior Tree가 Lua에서 트리 구조를 정의하고, C++에서 실행 및 제어할 수 있도록 구현합니다.
🔹 모든 Leaf 노드에 Monster*을 전달하고,
🔹 switch 대신 다형성을 활용한 구조로 변경하여 확장성 및 성능 개선을 적용했습니다.

---

📌 Lua에서 트리 정의 (Lua Script)

우선, Lua에서 트리 구조를 정의합니다.

function Selector(children)
    return { type = "Selector", children = children }
end

function Sequence(children)
    return { type = "Sequence", children = children }
end

function Leaf(name)
    return { type = "Leaf", name = name }
end

BehaviorTree = Selector({
    Sequence({
        Leaf("CheckEnemy"),
        Selector({
            Leaf("AttackEnemy"),
            Leaf("FallbackDefense")
        })
    }),
    Leaf("PatrolArea")
})

return BehaviorTree

---

📌 C++ 코드

이제 C++에서 Lua 데이터를 로드하고, Behavior Tree를 실행하는 전체 코드를 작성합니다.

---

1️⃣ Node 기본 클래스

#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <unordered_map>
#include <lua.hpp>

class Monster {
public:
    std::string name;
    int health;

    Monster(std::string name, int hp) : name(std::move(name)), health(hp) {}

    void attack() {
        std::cout << name << " attacks the enemy!\n";
    }

    std::string getName() const {
        return name;
    }
};

class Node {
public:
    virtual ~Node() = default;
    virtual bool execute() = 0;
};

---

2️⃣ Composite (Selector / Sequence)

enum class NodeType { Sequence, Selector };

class CompositeNode : public Node {
protected:
    std::vector<std::unique_ptr<Node>> children;
    NodeType type;

public:
    explicit CompositeNode(NodeType type) : type(type) {}

    void addChild(std::unique_ptr<Node> child) {
        children.push_back(std::move(child));
    }

    bool execute() override {
        if (type == NodeType::Sequence) {
            for (auto& child : children) {
                if (!child->execute()) return false;
            }
            return true;
        } else {  // Selector
            for (auto& child : children) {
                if (child->execute()) return true;
            }
            return false;
        }
    }
};

---

3️⃣ Leaf 기본 클래스

class Leaf : public Node {
protected:
    Monster* monster;

public:
    explicit Leaf(Monster* monster) : monster(monster) {}
    virtual ~Leaf() = default;
    virtual bool execute() override = 0;
};

---

4️⃣ Leaf 행동 클래스

class AttackEnemyLeaf : public Leaf {
public:
    using Leaf::Leaf;

    bool execute() override {
        if (monster) {
            monster->attack();
            return true;
        }
        return false;
    }
};

class CheckEnemyLeaf : public Leaf {
public:
    using Leaf::Leaf;

    bool execute() override {
        if (monster) {
            std::cout << monster->getName() << " is checking for enemies...\n";
        }
        return true;
    }
};

class FallbackDefenseLeaf : public Leaf {
public:
    using Leaf::Leaf;

    bool execute() override {
        if (monster) {
            std::cout << monster->getName() << " is falling back to defense mode!\n";
        }
        return true;
    }
};

---

5️⃣ LeafFactory

class LeafFactory {
public:
    static std::unique_ptr<Leaf> createLeaf(const std::string& name, Monster* monster) {
        if (name == "AttackEnemy") return std::make_unique<AttackEnemyLeaf>(monster);
        if (name == "CheckEnemy") return std::make_unique<CheckEnemyLeaf>(monster);
        if (name == "FallbackDefense") return std::make_unique<FallbackDefenseLeaf>(monster);
        return nullptr;
    }
};

---

6️⃣ Lua에서 트리 데이터 파싱

std::unique_ptr<Node> parseNode(lua_State* L, int index, Monster* monster) {
    lua_getfield(L, index, "type");
    std::string typeStr = lua_tostring(L, -1);
    lua_pop(L, 1);

    if (typeStr == "Leaf") {
        lua_getfield(L, index, "name");
        std::string name = lua_tostring(L, -1);
        lua_pop(L, 1);
        return LeafFactory::createLeaf(name, monster);
    } 
    else if (typeStr == "Sequence" || typeStr == "Selector") {
        lua_getfield(L, index, "children");
        auto compositeNode = std::make_unique<CompositeNode>(
            (typeStr == "Sequence") ? NodeType::Sequence : NodeType::Selector
        );

        if (lua_istable(L, -1)) {
            int len = luaL_len(L, -1);
            for (int i = 1; i <= len; ++i) {
                lua_rawgeti(L, -1, i);
                compositeNode->addChild(parseNode(L, lua_gettop(L), monster));
                lua_pop(L, 1);
            }
        }
        lua_pop(L, 1);
        return compositeNode;
    }

    return nullptr;
}

---

7️⃣ 트리 로드 및 실행

std::unique_ptr<Node> loadTreeFromLua(lua_State* L, const std::string& filename, Monster* monster) {
    if (luaL_dofile(L, filename.c_str()) != LUA_OK) {
        std::cerr << "Failed to load Lua file: " << lua_tostring(L, -1) << std::endl;
        return nullptr;
    }

    lua_getglobal(L, "behavior_tree");
    if (!lua_istable(L, -1)) {
        std::cerr << "Invalid behavior tree format\n";
        return nullptr;
    }

    auto rootNode = parseNode(L, lua_gettop(L), monster);
    lua_pop(L, 1);
    return rootNode;
}

---

8️⃣ 실행 코드 (main)

int main() {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    Monster monster("Goblin", 100);

    auto behaviorTree = loadTreeFromLua(L, "behavior_tree.lua", &monster);
    if (behaviorTree) {
        behaviorTree->execute();
    }

    lua_close(L);
    return 0;
}

---

🚀 주요 개선 사항

항목 기존 변경

Leaf 노드 Monster* 사용	일부 Leaf만 사용	모든 Leaf에서 Monster*을 사용
트리 실행 방식	switch 문	다형성(상속) 기반 구조
Lua 데이터 파싱	수동 필드 접근	parseNode() 함수로 자동화
Factory 패턴	switch로 생성	LeafFactory 사용

---

🎯 최종 요약

• 📌 Lua에서 트리 구조만 설계, C++에서 실행
• 📌 Leaf 노드의 다형성 기반 설계 (switch 제거)
• 📌 Monster*을 모든 Leaf에서 사용하여 유연성 증가
• 📌 Lua 데이터 자동 파싱하여 트리 구성
• 📌 확장성이 뛰어난 Behavior Tree 구조 완성

이제 Lua에서 행동을 쉽게 변경할 수 있고, C++에서 빠르고 최적화된 실행이 가능합니다. 🚀🔥