botaccount
/
limboai
mirror of https://github.com/limbonaut/limboai.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename BlackboardSource => BlackboardPlan 

Because it's a better name ;)
This commit is contained in:
Serhii Snitsaruk 2024-01-23 20:02:23 +01:00
parent b04f7530e4
commit 20a995d1d2
13 changed files with 109 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
blackboard/blackboard_source.cpp → blackboard/blackboard_plan.cpp
View File

@ -1,5 +1,5 @@
/** /**
* blackboard_source.cpp * blackboard_plan.cpp
* ============================================================================= * =============================================================================
* Copyright 2021-2024 Serhii Snitsaruk * Copyright 2021-2024 Serhii Snitsaruk
* *
@ -9,9 +9,9 @@
* ============================================================================= * =============================================================================
*/ */
#include "blackboard_source.h" #include "blackboard_plan.h"
bool BlackboardSource::_set(const StringName &p_name, const Variant &p_value) { bool BlackboardPlan::_set(const StringName &p_name, const Variant &p_value) {
String prop_name = p_name; String prop_name = p_name;
// * Editor // * Editor
@ -46,7 +46,7 @@ bool BlackboardSource::_set(const StringName &p_name, const Variant &p_value) {
return false; return false;
} }
bool BlackboardSource::_get(const StringName &p_name, Variant &r_ret) const { bool BlackboardPlan::_get(const StringName &p_name, Variant &r_ret) const {
String prop_name = p_name; String prop_name = p_name;
// * Editor // * Editor
@ -75,7 +75,7 @@ bool BlackboardSource::_get(const StringName &p_name, Variant &r_ret) const {
return true; return true;
} }
void BlackboardSource::_get_property_list(List<PropertyInfo> *p_list) const { void BlackboardPlan::_get_property_list(List<PropertyInfo> *p_list) const {
for (const KeyValue<String, BBVariable> &kv : data) { for (const KeyValue<String, BBVariable> &kv : data) {
String var_name = kv.key; String var_name = kv.key;
BBVariable var = kv.value; BBVariable var = kv.value;
@ -92,11 +92,11 @@ void BlackboardSource::_get_property_list(List<PropertyInfo> *p_list) const {
} }
} }
bool BlackboardSource::_property_can_revert(const StringName &p_name) const { bool BlackboardPlan::_property_can_revert(const StringName &p_name) const {
return base.is_valid() && base->data.has(p_name); return base.is_valid() && base->data.has(p_name);
} }
bool BlackboardSource::_property_get_revert(const StringName &p_name, Variant &r_property) const { bool BlackboardPlan::_property_get_revert(const StringName &p_name, Variant &r_property) const {
if (base->data.has(p_name)) { if (base->data.has(p_name)) {
r_property = base->data[p_name].get_value(); r_property = base->data[p_name].get_value();
return true; return true;
@ -104,40 +104,40 @@ bool BlackboardSource::_property_get_revert(const StringName &p_name, Variant &r
return false; return false;
} }
void BlackboardSource::set_base_source(const Ref<BlackboardSource> &p_base) { void BlackboardPlan::set_base_plan(const Ref<BlackboardPlan> &p_base) {
base = p_base; base = p_base;
sync_with_base_source(); sync_with_base_plan();
emit_changed(); emit_changed();
} }
void BlackboardSource::set_value(const String &p_name, const Variant &p_value) { void BlackboardPlan::set_value(const String &p_name, const Variant &p_value) {
ERR_FAIL_COND(!data.has(p_name)); ERR_FAIL_COND(!data.has(p_name));
data.get(p_name).set_value(p_value); data.get(p_name).set_value(p_value);
} }
Variant BlackboardSource::get_value(const String &p_name) const { Variant BlackboardPlan::get_value(const String &p_name) const {
ERR_FAIL_COND_V(!data.has(p_name), Variant()); ERR_FAIL_COND_V(!data.has(p_name), Variant());
return data.get(p_name).get_value(); return data.get(p_name).get_value();
} }
void BlackboardSource::add_var(const String &p_name, const BBVariable &p_var) { void BlackboardPlan::add_var(const String &p_name, const BBVariable &p_var) {
ERR_FAIL_COND(data.has(p_name)); ERR_FAIL_COND(data.has(p_name));
ERR_FAIL_COND(base.is_valid()); ERR_FAIL_COND(base.is_valid());
data.insert(p_name, p_var); data.insert(p_name, p_var);
} }
void BlackboardSource::remove_var(const String &p_name) { void BlackboardPlan::remove_var(const String &p_name) {
ERR_FAIL_COND(!data.has(p_name)); ERR_FAIL_COND(!data.has(p_name));
ERR_FAIL_COND(base.is_valid()); ERR_FAIL_COND(base.is_valid());
data.erase(p_name); data.erase(p_name);
} }
BBVariable BlackboardSource::get_var(const String &p_name) { BBVariable BlackboardPlan::get_var(const String &p_name) {
ERR_FAIL_COND_V(!data.has(p_name), BBVariable()); ERR_FAIL_COND_V(!data.has(p_name), BBVariable());
return data.get(p_name); return data.get(p_name);
} }
PackedStringArray BlackboardSource::list_vars() const { PackedStringArray BlackboardPlan::list_vars() const {
PackedStringArray ret; PackedStringArray ret;
for (const KeyValue<String, BBVariable> &kv : data) { for (const KeyValue<String, BBVariable> &kv : data) {
ret.append(kv.key); ret.append(kv.key);
@ -145,10 +145,12 @@ PackedStringArray BlackboardSource::list_vars() const {
return ret; return ret;
} }
void BlackboardSource::sync_with_base_source() { void BlackboardPlan::sync_with_base_plan() {
if (base.is_null()) { if (base.is_null()) {
return; return;
} }
// Sync variables with the base plan.
for (const KeyValue<String, BBVariable> &kv : base->data) { for (const KeyValue<String, BBVariable> &kv : base->data) {
if (!data.has(kv.key)) { if (!data.has(kv.key)) {
data.insert(kv.key, kv.value.duplicate()); data.insert(kv.key, kv.value.duplicate());
@ -163,9 +165,16 @@ void BlackboardSource::sync_with_base_source() {
var.set_value(kv.value.get_value()); var.set_value(kv.value.get_value());
} }
} }
// Erase variables that do not exist in the base plan.
for (const KeyValue<String, BBVariable> &kv : data) {
if (!base->data.has(kv.key)) {
data.erase(kv.key);
}
}
} }
Ref<Blackboard> BlackboardSource::create_blackboard() { Ref<Blackboard> BlackboardPlan::create_blackboard() {
Ref<Blackboard> bb = memnew(Blackboard); Ref<Blackboard> bb = memnew(Blackboard);
for (const KeyValue<String, BBVariable> &kv : data) { for (const KeyValue<String, BBVariable> &kv : data) {
bb->add_var(kv.key, kv.value.duplicate()); bb->add_var(kv.key, kv.value.duplicate());
@ -173,7 +182,7 @@ Ref<Blackboard> BlackboardSource::create_blackboard() {
return bb; return bb;
} }
void BlackboardSource::populate_blackboard(const Ref<Blackboard> &p_blackboard, bool overwrite) { void BlackboardPlan::populate_blackboard(const Ref<Blackboard> &p_blackboard, bool overwrite) {
for (const KeyValue<String, BBVariable> &kv : data) { for (const KeyValue<String, BBVariable> &kv : data) {
if (p_blackboard->has_var(kv.key)) { if (p_blackboard->has_var(kv.key)) {
if (overwrite) { if (overwrite) {
@ -186,9 +195,12 @@ void BlackboardSource::populate_blackboard(const Ref<Blackboard> &p_blackboard,
} }
} }
BlackboardSource::BlackboardSource() { BlackboardPlan::BlackboardPlan() {
// TODO: REMOVE ALL BELOW // TODO: REMOVE THE TEST DATA BELOW.
data.insert("speed", BBVariable(Variant::Type::FLOAT, PropertyHint::PROPERTY_HINT_NONE, "")); data.insert("speed", BBVariable(Variant::Type::FLOAT));
data.insert("limit_speed", BBVariable(Variant::Type::BOOL, PropertyHint::PROPERTY_HINT_NONE, "")); data["speed"].set_value(200.0);
data.insert("limit_speed", BBVariable(Variant::Type::BOOL));
data["limit_speed"].set_value(500.0);
data.insert("about", BBVariable(Variant::Type::STRING, PropertyHint::PROPERTY_HINT_MULTILINE_TEXT, "")); data.insert("about", BBVariable(Variant::Type::STRING, PropertyHint::PROPERTY_HINT_MULTILINE_TEXT, ""));
data["about"].set_value("Hello, World!");
} }

26
blackboard/blackboard_source.h → blackboard/blackboard_plan.h
View File

@ -1,5 +1,5 @@
/** /**
* blackboard_source.h * blackboard_plan.h
* ============================================================================= * =============================================================================
* Copyright 2021-2024 Serhii Snitsaruk * Copyright 2021-2024 Serhii Snitsaruk
* *
@ -9,23 +9,23 @@
* ============================================================================= * =============================================================================
*/ */
#ifndef BLACKBOARD_SOURCE_H #ifndef BLACKBOARD_PLAN_H
#define BLACKBOARD_SOURCE_H #define BLACKBOARD_PLAN_H
#include "core/io/resource.h" #include "core/io/resource.h"
#include "bb_variable.h" #include "bb_variable.h"
#include "blackboard.h" #include "blackboard.h"
class BlackboardSource : public Resource { class BlackboardPlan : public Resource {
GDCLASS(BlackboardSource, Resource); GDCLASS(BlackboardPlan, Resource);
private: private:
HashMap<String, BBVariable> data; HashMap<String, BBVariable> data;
// When base is not null, the source is considered to be derived from the base source. // When base is not null, the plan is considered to be derived from the base plan.
// A derived source can only have variables that exist in the base source. // A derived plan can only have variables that exist in the base plan.
Ref<BlackboardSource> base; Ref<BlackboardPlan> base;
protected: protected:
bool _set(const StringName &p_name, const Variant &p_value); bool _set(const StringName &p_name, const Variant &p_value);
@ -35,8 +35,8 @@ protected:
bool _property_get_revert(const StringName &p_name, Variant &r_property) const; bool _property_get_revert(const StringName &p_name, Variant &r_property) const;
public: public:
void set_base_source(const Ref<BlackboardSource> &p_base); void set_base_plan(const Ref<BlackboardPlan> &p_base);
Ref<BlackboardSource> get_base_source() const { return base; } Ref<BlackboardPlan> get_base_plan() const { return base; }
void set_value(const String &p_name, const Variant &p_value); void set_value(const String &p_name, const Variant &p_value);
Variant get_value(const String &p_name) const; Variant get_value(const String &p_name) const;
@ -46,13 +46,13 @@ public:
PackedStringArray list_vars() const; PackedStringArray list_vars() const;
bool is_empty() const { return data.is_empty(); } bool is_empty() const { return data.is_empty(); }
void sync_with_base_source(); void sync_with_base_plan();
bool is_derived() { return base.is_valid(); } bool is_derived() { return base.is_valid(); }
Ref<Blackboard> create_blackboard(); Ref<Blackboard> create_blackboard();
void populate_blackboard(const Ref<Blackboard> &p_blackboard, bool overwrite); void populate_blackboard(const Ref<Blackboard> &p_blackboard, bool overwrite);
BlackboardSource(); BlackboardPlan();
}; };
#endif // BLACKBOARD_SOURCE_H #endif // BLACKBOARD_PLAN_H

14
bt/behavior_tree.cpp
View File

@ -22,10 +22,10 @@
#include "godot_cpp/core/error_macros.hpp" #include "godot_cpp/core/error_macros.hpp"
#endif // ! LIMBOAI_GDEXTENSION #endif // ! LIMBOAI_GDEXTENSION
void BehaviorTree::set_blackboard_source(const Ref<BlackboardSource> &p_source) { void BehaviorTree::set_blackboard_plan(const Ref<BlackboardPlan> &p_plan) {
blackboard_source = p_source; blackboard_plan = p_plan;
if (blackboard_source.is_null()) { if (blackboard_plan.is_null()) {
blackboard_source = Ref<BlackboardSource>(memnew(BlackboardSource)); blackboard_plan = Ref<BlackboardPlan>(memnew(BlackboardPlan));
} }
emit_changed(); emit_changed();
} }
@ -55,8 +55,8 @@ Ref<BTTask> BehaviorTree::instantiate(Node *p_agent, const Ref<Blackboard> &p_bl
void BehaviorTree::_bind_methods() { void BehaviorTree::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_description", "p_value"), &BehaviorTree::set_description); ClassDB::bind_method(D_METHOD("set_description", "p_value"), &BehaviorTree::set_description);
ClassDB::bind_method(D_METHOD("get_description"), &BehaviorTree::get_description); ClassDB::bind_method(D_METHOD("get_description"), &BehaviorTree::get_description);
ClassDB::bind_method(D_METHOD("set_blackboard_source", "p_source"), &BehaviorTree::set_blackboard_source); ClassDB::bind_method(D_METHOD("set_blackboard_plan", "p_plan"), &BehaviorTree::set_blackboard_plan);
ClassDB::bind_method(D_METHOD("get_blackboard_source"), &BehaviorTree::get_blackboard_source); ClassDB::bind_method(D_METHOD("get_blackboard_plan"), &BehaviorTree::get_blackboard_plan);
ClassDB::bind_method(D_METHOD("set_root_task", "p_value"), &BehaviorTree::set_root_task); ClassDB::bind_method(D_METHOD("set_root_task", "p_value"), &BehaviorTree::set_root_task);
ClassDB::bind_method(D_METHOD("get_root_task"), &BehaviorTree::get_root_task); ClassDB::bind_method(D_METHOD("get_root_task"), &BehaviorTree::get_root_task);
ClassDB::bind_method(D_METHOD("clone"), &BehaviorTree::clone); ClassDB::bind_method(D_METHOD("clone"), &BehaviorTree::clone);
@ -65,7 +65,7 @@ void BehaviorTree::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::STRING, "description", PROPERTY_HINT_MULTILINE_TEXT), "set_description", "get_description"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "description", PROPERTY_HINT_MULTILINE_TEXT), "set_description", "get_description");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "root_task", PROPERTY_HINT_RESOURCE_TYPE, "BTTask", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "set_root_task", "get_root_task"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "root_task", PROPERTY_HINT_RESOURCE_TYPE, "BTTask", PROPERTY_USAGE_NO_EDITOR | PROPERTY_USAGE_INTERNAL), "set_root_task", "get_root_task");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_source", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardSource", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_blackboard_source", "get_blackboard_source"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_plan", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardPlan", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_blackboard_plan", "get_blackboard_plan");
} }
BehaviorTree::BehaviorTree() { BehaviorTree::BehaviorTree() {

8
bt/behavior_tree.h
View File

@ -12,7 +12,7 @@
#ifndef BEHAVIOR_TREE_H #ifndef BEHAVIOR_TREE_H
#define BEHAVIOR_TREE_H #define BEHAVIOR_TREE_H
#include "../blackboard/blackboard_source.h" #include "../blackboard/blackboard_plan.h"
#include "tasks/bt_task.h" #include "tasks/bt_task.h"
#ifdef LIMBOAI_MODULE #ifdef LIMBOAI_MODULE
@ -29,7 +29,7 @@ class BehaviorTree : public Resource {
private: private:
String description; String description;
Ref<BlackboardSource> blackboard_source; Ref<BlackboardPlan> blackboard_plan;
Ref<BTTask> root_task; Ref<BTTask> root_task;
protected: protected:
@ -40,8 +40,8 @@ public:
virtual bool editor_can_reload_from_file() override { return false; } virtual bool editor_can_reload_from_file() override { return false; }
#endif #endif
void set_blackboard_source(const Ref<BlackboardSource> &p_source); void set_blackboard_plan(const Ref<BlackboardPlan> &p_plan);
Ref<BlackboardSource> get_blackboard_source() const { return blackboard_source; } Ref<BlackboardPlan> get_blackboard_plan() const { return blackboard_plan; }
void set_description(String p_value) { void set_description(String p_value) {
description = p_value; description = p_value;

35
bt/bt_player.cpp
View File

@ -63,15 +63,16 @@ void BTPlayer::_load_tree() {
#endif #endif
} }
void BTPlayer::_update_blackboard_source() { void BTPlayer::_update_blackboard_plan() {
if (behavior_tree.is_valid() && behavior_tree->get_blackboard_source().is_valid()) { if (blackboard_plan.is_null()) {
if (blackboard_source.is_null()) { blackboard_plan = Ref<BlackboardPlan>(memnew(BlackboardPlan));
blackboard_source = Ref<BlackboardSource>(memnew(BlackboardSource)); }
}
if (blackboard_source == behavior_tree->get_blackboard_source()) { if (behavior_tree.is_valid()) {
blackboard_source->sync_with_base_source(); if (blackboard_plan == behavior_tree->get_blackboard_plan()) {
blackboard_plan->sync_with_base_plan();
} else { } else {
blackboard_source->set_base_source(behavior_tree->get_blackboard_source()); blackboard_plan->set_base_plan(behavior_tree->get_blackboard_plan());
} }
} }
} }
@ -81,12 +82,12 @@ void BTPlayer::set_behavior_tree(const Ref<BehaviorTree> &p_tree) {
if (Engine::get_singleton()->is_editor_hint() == false && get_owner()) { if (Engine::get_singleton()->is_editor_hint() == false && get_owner()) {
_load_tree(); _load_tree();
} }
_update_blackboard_source(); _update_blackboard_plan();
} }
void BTPlayer::set_blackboard_source(const Ref<BlackboardSource> &p_source) { void BTPlayer::set_blackboard_plan(const Ref<BlackboardPlan> &p_plan) {
blackboard_source = p_source; blackboard_plan = p_plan;
_update_blackboard_source(); _update_blackboard_plan();
} }
void BTPlayer::set_update_mode(UpdateMode p_mode) { void BTPlayer::set_update_mode(UpdateMode p_mode) {
@ -182,8 +183,8 @@ void BTPlayer::_notification(int p_notification) {
if (blackboard.is_null()) { if (blackboard.is_null()) {
blackboard = Ref<Blackboard>(memnew(Blackboard)); blackboard = Ref<Blackboard>(memnew(Blackboard));
} }
if (blackboard_source.is_valid()) { if (blackboard_plan.is_valid()) {
blackboard_source->populate_blackboard(blackboard, false); blackboard_plan->populate_blackboard(blackboard, false);
} }
if (behavior_tree.is_valid()) { if (behavior_tree.is_valid()) {
_load_tree(); _load_tree();
@ -221,8 +222,8 @@ void BTPlayer::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_prefetch_nodepath_vars", "p_value"), &BTPlayer::set_prefetch_nodepath_vars); ClassDB::bind_method(D_METHOD("set_prefetch_nodepath_vars", "p_value"), &BTPlayer::set_prefetch_nodepath_vars);
ClassDB::bind_method(D_METHOD("get_prefetch_nodepath_vars"), &BTPlayer::get_prefetch_nodepath_vars); ClassDB::bind_method(D_METHOD("get_prefetch_nodepath_vars"), &BTPlayer::get_prefetch_nodepath_vars);
ClassDB::bind_method(D_METHOD("set_blackboard_source", "p_blackboard"), &BTPlayer::set_blackboard_source); ClassDB::bind_method(D_METHOD("set_blackboard_plan", "p_plan"), &BTPlayer::set_blackboard_plan);
ClassDB::bind_method(D_METHOD("get_blackboard_source"), &BTPlayer::get_blackboard_source); ClassDB::bind_method(D_METHOD("get_blackboard_plan"), &BTPlayer::get_blackboard_plan);
ClassDB::bind_method(D_METHOD("update", "p_delta"), &BTPlayer::update); ClassDB::bind_method(D_METHOD("update", "p_delta"), &BTPlayer::update);
ClassDB::bind_method(D_METHOD("restart"), &BTPlayer::restart); ClassDB::bind_method(D_METHOD("restart"), &BTPlayer::restart);
@ -232,7 +233,7 @@ void BTPlayer::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::INT, "update_mode", PROPERTY_HINT_ENUM, "Idle,Physics,Manual"), "set_update_mode", "get_update_mode"); ADD_PROPERTY(PropertyInfo(Variant::INT, "update_mode", PROPERTY_HINT_ENUM, "Idle,Physics,Manual"), "set_update_mode", "get_update_mode");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "active"), "set_active", "get_active"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "active"), "set_active", "get_active");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard", PROPERTY_HINT_NONE, "Blackboard", 0), "set_blackboard", "get_blackboard"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard", PROPERTY_HINT_NONE, "Blackboard", 0), "set_blackboard", "get_blackboard");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_source", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardSource", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_blackboard_source", "get_blackboard_source"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_plan", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardPlan", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_blackboard_plan", "get_blackboard_plan");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "prefetch_nodepath_vars"), "set_prefetch_nodepath_vars", "get_prefetch_nodepath_vars"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "prefetch_nodepath_vars"), "set_prefetch_nodepath_vars", "get_prefetch_nodepath_vars");
BIND_ENUM_CONSTANT(IDLE); BIND_ENUM_CONSTANT(IDLE);

10
bt/bt_player.h
View File

@ -13,7 +13,7 @@
#define BT_PLAYER_H #define BT_PLAYER_H
#include "../blackboard/blackboard.h" #include "../blackboard/blackboard.h"
#include "../blackboard/blackboard_source.h" #include "../blackboard/blackboard_plan.h"
#include "behavior_tree.h" #include "behavior_tree.h"
#include "tasks/bt_task.h" #include "tasks/bt_task.h"
@ -37,7 +37,7 @@ public:
private: private:
Ref<BehaviorTree> behavior_tree; Ref<BehaviorTree> behavior_tree;
Ref<BlackboardSource> blackboard_source; Ref<BlackboardPlan> blackboard_plan;
UpdateMode update_mode = UpdateMode::PHYSICS; UpdateMode update_mode = UpdateMode::PHYSICS;
bool active = true; bool active = true;
Ref<Blackboard> blackboard; Ref<Blackboard> blackboard;
@ -47,7 +47,7 @@ private:
Ref<BTTask> tree_instance; Ref<BTTask> tree_instance;
void _load_tree(); void _load_tree();
void _update_blackboard_source(); void _update_blackboard_plan();
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -58,8 +58,8 @@ public:
void set_behavior_tree(const Ref<BehaviorTree> &p_tree); void set_behavior_tree(const Ref<BehaviorTree> &p_tree);
Ref<BehaviorTree> get_behavior_tree() const { return behavior_tree; }; Ref<BehaviorTree> get_behavior_tree() const { return behavior_tree; };
void set_blackboard_source(const Ref<BlackboardSource> &p_source); void set_blackboard_plan(const Ref<BlackboardPlan> &p_plan);
Ref<BlackboardSource> get_blackboard_source() const { return blackboard_source; } Ref<BlackboardPlan> get_blackboard_plan() const { return blackboard_plan; }
void set_update_mode(UpdateMode p_mode); void set_update_mode(UpdateMode p_mode);
UpdateMode get_update_mode() const { return update_mode; } UpdateMode get_update_mode() const { return update_mode; }

14
bt/bt_state.cpp
View File

@ -26,15 +26,15 @@
#include <godot_cpp/classes/engine_debugger.hpp> #include <godot_cpp/classes/engine_debugger.hpp>
#endif // LIMBOAI_GDEXTENSION #endif // LIMBOAI_GDEXTENSION
void BTState::_update_blackboard_source() { void BTState::_update_blackboard_plan() {
if (behavior_tree.is_valid() && behavior_tree->get_blackboard_source().is_valid()) { if (behavior_tree.is_valid() && behavior_tree->get_blackboard_plan().is_valid()) {
if (get_blackboard_source().is_null()) { if (get_blackboard_plan().is_null()) {
set_blackboard_source(Ref<BlackboardSource>(memnew(BlackboardSource))); set_blackboard_plan(Ref<BlackboardPlan>(memnew(BlackboardPlan)));
} }
if (get_blackboard_source() == behavior_tree->get_blackboard_source()) { if (get_blackboard_plan() == behavior_tree->get_blackboard_plan()) {
get_blackboard_source()->sync_with_base_source(); get_blackboard_plan()->sync_with_base_plan();
} else { } else {
get_blackboard_source()->set_base_source(behavior_tree->get_blackboard_source()); get_blackboard_plan()->set_base_plan(behavior_tree->get_blackboard_plan());
} }
} }
} }

2
bt/bt_state.h
View File

@ -26,7 +26,7 @@ private:
String success_event; String success_event;
String failure_event; String failure_event;
void _update_blackboard_source(); void _update_blackboard_plan();
protected: protected:
static void _bind_methods(); static void _bind_methods();

10
bt/tasks/decorators/bt_new_scope.cpp
View File

@ -16,8 +16,8 @@ void BTNewScope::initialize(Node *p_agent, const Ref<Blackboard> &p_blackboard)
ERR_FAIL_COND(p_blackboard == nullptr); ERR_FAIL_COND(p_blackboard == nullptr);
Ref<Blackboard> bb; Ref<Blackboard> bb;
if (blackboard_source.is_valid()) { if (blackboard_plan.is_valid()) {
bb = blackboard_source->create_blackboard(); bb = blackboard_plan->create_blackboard();
} else { } else {
bb = Ref<Blackboard>(memnew(Blackboard)); bb = Ref<Blackboard>(memnew(Blackboard));
} }
@ -33,8 +33,8 @@ BT::Status BTNewScope::_tick(double p_delta) {
} }
void BTNewScope::_bind_methods() { void BTNewScope::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_blackboard_source", "p_source"), &BTNewScope::set_blackboard_source); ClassDB::bind_method(D_METHOD("set_blackboard_plan", "p_plan"), &BTNewScope::set_blackboard_plan);
ClassDB::bind_method(D_METHOD("get_blackboard_source"), &BTNewScope::get_blackboard_source); ClassDB::bind_method(D_METHOD("get_blackboard_plan"), &BTNewScope::get_blackboard_plan);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_source", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardSource", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_blackboard_source", "get_blackboard_source"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_plan", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardPlan", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT), "set_blackboard_plan", "get_blackboard_plan");
} }

8
bt/tasks/decorators/bt_new_scope.h
View File

@ -14,20 +14,20 @@
#include "../bt_decorator.h" #include "../bt_decorator.h"
#include "../../../blackboard/blackboard_source.h" #include "../../../blackboard/blackboard_plan.h"
class BTNewScope : public BTDecorator { class BTNewScope : public BTDecorator {
GDCLASS(BTNewScope, BTDecorator); GDCLASS(BTNewScope, BTDecorator);
TASK_CATEGORY(Decorators); TASK_CATEGORY(Decorators);
private: private:
Ref<BlackboardSource> blackboard_source; Ref<BlackboardPlan> blackboard_plan;
protected: protected:
static void _bind_methods(); static void _bind_methods();
void set_blackboard_source(const Ref<BlackboardSource> &p_source) { blackboard_source = p_source; } void set_blackboard_plan(const Ref<BlackboardPlan> &p_plan) { blackboard_plan = p_plan; }
Ref<BlackboardSource> get_blackboard_source() const { return blackboard_source; } Ref<BlackboardPlan> get_blackboard_plan() const { return blackboard_plan; }
virtual Status _tick(double p_delta) override; virtual Status _tick(double p_delta) override;

10
hsm/limbo_state.cpp
View File

@ -69,8 +69,8 @@ void LimboState::_initialize(Node *p_agent, const Ref<Blackboard> &p_blackboard)
agent = p_agent; agent = p_agent;
if (!p_blackboard.is_null()) { if (!p_blackboard.is_null()) {
if (blackboard_source.is_valid() && !blackboard_source->is_empty()) { if (blackboard_plan.is_valid() && !blackboard_plan->is_empty()) {
blackboard = blackboard_source->create_blackboard(); blackboard = blackboard_plan->create_blackboard();
blackboard->set_parent_scope(p_blackboard); blackboard->set_parent_scope(p_blackboard);
} else { } else {
blackboard = p_blackboard; blackboard = p_blackboard;
@ -180,8 +180,8 @@ void LimboState::_bind_methods() {
ClassDB::bind_method(D_METHOD("clear_guard"), &LimboState::clear_guard); ClassDB::bind_method(D_METHOD("clear_guard"), &LimboState::clear_guard);
ClassDB::bind_method(D_METHOD("get_blackboard"), &LimboState::get_blackboard); ClassDB::bind_method(D_METHOD("get_blackboard"), &LimboState::get_blackboard);
ClassDB::bind_method(D_METHOD("set_blackboard_source", "p_source"), &LimboState::set_blackboard_source); ClassDB::bind_method(D_METHOD("set_blackboard_plan", "p_plan"), &LimboState::set_blackboard_plan);
ClassDB::bind_method(D_METHOD("get_blackboard_source"), &LimboState::get_blackboard_source); ClassDB::bind_method(D_METHOD("get_blackboard_plan"), &LimboState::get_blackboard_plan);
#ifdef LIMBOAI_MODULE #ifdef LIMBOAI_MODULE
GDVIRTUAL_BIND(_setup); GDVIRTUAL_BIND(_setup);
@ -195,7 +195,7 @@ void LimboState::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::STRING, "EVENT_FINISHED", PROPERTY_HINT_NONE, "", 0), "", "event_finished"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "EVENT_FINISHED", PROPERTY_HINT_NONE, "", 0), "", "event_finished");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "agent", PROPERTY_HINT_RESOURCE_TYPE, "Node", 0), "set_agent", "get_agent"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "agent", PROPERTY_HINT_RESOURCE_TYPE, "Node", 0), "set_agent", "get_agent");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard", PROPERTY_HINT_RESOURCE_TYPE, "Blackboard", 0), "", "get_blackboard"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard", PROPERTY_HINT_RESOURCE_TYPE, "Blackboard", 0), "", "get_blackboard");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_source", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardSource", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_blackboard_source", "get_blackboard_source"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "blackboard_plan", PROPERTY_HINT_RESOURCE_TYPE, "BlackboardPlan", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_INTERNAL), "set_blackboard_plan", "get_blackboard_plan");
ADD_SIGNAL(MethodInfo("setup")); ADD_SIGNAL(MethodInfo("setup"));
ADD_SIGNAL(MethodInfo("entered")); ADD_SIGNAL(MethodInfo("entered"));

8
hsm/limbo_state.h
View File

@ -13,7 +13,7 @@
#define LIMBO_STATE_H #define LIMBO_STATE_H
#include "../blackboard/blackboard.h" #include "../blackboard/blackboard.h"
#include "../blackboard/blackboard_source.h" #include "../blackboard/blackboard_plan.h"
#include "../util/limbo_string_names.h" #include "../util/limbo_string_names.h"
@ -38,7 +38,7 @@ class LimboState : public Node {
GDCLASS(LimboState, Node); GDCLASS(LimboState, Node);
private: private:
Ref<BlackboardSource> blackboard_source; Ref<BlackboardPlan> blackboard_plan;
Node *agent; Node *agent;
Ref<Blackboard> blackboard; Ref<Blackboard> blackboard;
HashMap<String, Callable> handlers; HashMap<String, Callable> handlers;
@ -70,8 +70,8 @@ protected:
void add_event_handler(const String &p_event, const Callable &p_handler); void add_event_handler(const String &p_event, const Callable &p_handler);
public: public:
void set_blackboard_source(const Ref<BlackboardSource> p_source) { blackboard_source = p_source; } void set_blackboard_plan(const Ref<BlackboardPlan> p_plan) { blackboard_plan = p_plan; }
Ref<BlackboardSource> get_blackboard_source() const { return blackboard_source; } Ref<BlackboardPlan> get_blackboard_plan() const { return blackboard_plan; }
Ref<Blackboard> get_blackboard() const { return blackboard; } Ref<Blackboard> get_blackboard() const { return blackboard; }

4
register_types.cpp
View File

@ -47,7 +47,7 @@
#include "blackboard/bb_param/bb_vector4.h" #include "blackboard/bb_param/bb_vector4.h"
#include "blackboard/bb_param/bb_vector4i.h" #include "blackboard/bb_param/bb_vector4i.h"
#include "blackboard/blackboard.h" #include "blackboard/blackboard.h"
#include "blackboard/blackboard_source.h" #include "blackboard/blackboard_plan.h"
#include "bt/behavior_tree.h" #include "bt/behavior_tree.h"
#include "bt/bt_player.h" #include "bt/bt_player.h"
#include "bt/bt_state.h" #include "bt/bt_state.h"
@ -134,7 +134,7 @@ void initialize_limboai_module(ModuleInitializationLevel p_level) {
GDREGISTER_CLASS(LimboUtility); GDREGISTER_CLASS(LimboUtility);
GDREGISTER_CLASS(Blackboard); GDREGISTER_CLASS(Blackboard);
GDREGISTER_CLASS(BlackboardSource); GDREGISTER_CLASS(BlackboardPlan);
GDREGISTER_CLASS(LimboState); GDREGISTER_CLASS(LimboState);
GDREGISTER_CLASS(LimboHSM); GDREGISTER_CLASS(LimboHSM);