A.I Blackboard concept in entt.

[rudiHammad]

hello,
I've been reading about a.i and behavior trees and I came across the blackboard concept which is essentially a
key, value storage. It would be similar to the pseudo code bellow

// Blackboard for storing shared AI data
struct BlackboardComponent {
    std::unordered_map<std::string, std::any> data;

    template<typename T>
    void set(const std::string& key, T value) {
        data[key] = value;
    }

    template<typename T>
    T get(const std::string& key) const {
        return std::any_cast<T>(data.at(key));
    }

    bool hasKey(const std::string& key) const {
        return data.find(key) != data.end();
    }
};

// Stores AI state and reference to blackboard
struct AIComponent {
    entt::entity blackboard; // Reference to shared blackboard
};

So then it would be used like this the a.i components

void update(entt::registry& registry) 
{
    auto blackboardView = registry.view<BlackboardComponent>();
    auto aiView = registry.view<AIComponent, Position>();

    for (auto blackboard : blackboardView) {
        auto& bb = registry.get<BlackboardComponent>(blackboard);

        if (bb.hasKey("PlayerPosition")) {
            // Do stuff
        }
}        

Having to look into the key by string in a map seems pretty slow to me. The alternative would be to create the black board as a simple entity and add components to it that were represented before as key:value in the map.

entt::registry registry;
    
// Create a special "blackboard" entity
entt::entity blackboard = registry.create();

// Store shared data as components
registry.emplace<PlayerPosition>(blackboard, 10.0f, 20.0f);

And then instead, of bb.hasKey("PlayerPosition")), we would check as usual for that component.

As far as I understood, the point of the blackboard is to have the key, value map to avoid having to create it as an entity that recieves components. The map is updated each frame with the blackboard set method.
So the idea is to have a centralized storage map from which all a.i entities get information and prevent recalculations.
Also, a a.i entity can even write to the blackboard to update it.

I was wondering if any one has thoughts about how to implement in entt this blackboard concept.
Using a map seems slow compared to creating a black board entity with component, but doing that defeats the purpose of a blackboard. Or at least that's what I've understood from what I read.

Thx

[skypjack]

Having to look into the key by string in a map seems pretty slow to me

Have you considered the hashed_string class for your use case then?
As far as I remember, the blackboard is a centralized element, it doens't make much sense to me to bind it to an entity. 🤔
That said, take this with a grain of salt. I should refresh my mind before giving meaningful details in this regard. 🙂

[rudiHammad]

I didn't know about hashed_string I think that should work.
I think you are right, it is probably an attribute that the behavior tree has. Or maybe the nodes of the tree.. I am not sure. Anyways, it is a centralized elemente yes. So maybe it would be something like this:

using BlackboardValue = std::variant<int, float, bool, entt::entity>;

struct Blackboard {
    std::unordered_map<entt::hashed_string::hash_type, BlackboardValue> data;

    
    template <typename T>
    void set(entt::hashed_string key, T value) {
        // set value
    }

    template <typename T>
    T get(entt::hashed_string key, T default_value = T{}) const {
       // find the key and get the value
    }
};

Now all the a.i component should be able to access the blackboard. For instance, the blackboard can store the number of enemies alive. If we have 5 enemies with a.i component, they read from it. Maybe the player component has access to the blackboard,
and as enemies are killed, it set the number of enemies alive. and if 4 enemies are killed, the last enemy, reading from the blackboard that he is the only one alive, can trigger a run away action node.
Sorry for the rambling, I was just thinking out loud. And entt::hashed_string::hash_type being fast evaluate should work.

[rudiHammad]

okey, one last question. I have my blackboard struct working now and I am using entt::hashed_string.

BlackBoard blackBoard;
entt::hashed_string player_health("player_health");
blackBoard.setValue(player_health, 100);
AXLOG(">>> %i", blackBoard.getValue(player_health));

all working fine. My only doubt is on how to cast into the proper type the value. I am using std::get<> like so

auto healthValue = std::get<int>(blackBoard.getValue(entt::hashed_string("player_health")));
healthValue -= 10;
blackBoard.setValue(entt::hashed_string("player_health"), healthValue);

And it works fine. I am just a bit obsessed into writing fast code since the the black board can be accesses each frame.
So I want to make sure I am using entt right.

Thx

[skypjack]

I am just a bit obsessed into writing fast code

Don't be obsessed. Measure. Profile. That's the only way you have to find real bottlenecks. 👍
As for your how to cast question, I don't even know what's the subject 😅 can you elaborate it a little?

[rudiHammad]

yeah, you're right. Not an expert on profiling to be honest. I do use a timer to check how long it takes a whole loop to compute, but when it comes to profile the difference between one line of code written one way or the other the timer doesn't do much. I have to improve my profile skills. Anyway, back to my point. My question was if this line that uses std::get auto healthValue = std::get<int>(blackBoard.getValue(entt::hashed_string("player_health"))); was okey or if there is a better way. I know it's very vague so maybe it doesn't make much sence to ask. The reason I do it is because, I can't do this:

auto healthValue = blackBoard.getValue(entt::hashed_string("player_health"));
healthValue -= 10;  // this errors

The error is no operator -= matches this operands because blackBoard.getValue(...) returns BlackBoard.blackBoardValue.
For more context, this is how my BlackBoard struct looks like:

struct BlackBoard
{
public:
    using blackBoardValue = std::variant<int, float, bool, entt::entity>;

    std::unordered_map<size_t, blackBoardValue> storage;

    BlackBoard() = default;

    void setValue(entt::hashed_string key, blackBoardValue value)
    {
        storage[key.value()] = value;
    };


    blackBoardValue getValue(entt::hashed_string key)
    {
        return storage.at(key);     // faster solution I think, at the risk of assuming the key exists, witch 
                                                // is true in blackboard. Otherwise, if not found it would crash
    }

};

So to summarize my question is that, since I found my self having to do cast (std::get()) I wonder if I am using entt::hashed_string in an optimal way to write and read from it.

[skypjack]

hashed_string returns entt::id_type, if you want to avoid the case. It's probably better suited for the key type. And ofc it's still an integral type, so you're good to go with it.