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

Test: Nested HSM flow, dispatch() and get_root()

This commit is contained in:
Serhii Snitsaruk 2024-05-01 13:59:57 +02:00
parent 0e843d3193
commit dedffc4f22
No known key found for this signature in database
GPG Key ID: A965EF8799FFEC2D
1 changed files with 80 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
tests/test_hsm.h
View File

@ -24,6 +24,12 @@
namespace TestHSM { namespace TestHSM {
inline void wire_callbacks(LimboState *p_state, Ref<CallbackCounter> p_entries_counter, Ref<CallbackCounter> p_updates_counter, Ref<CallbackCounter> p_exits_counter) {
p_state->call_on_enter(callable_mp(p_entries_counter.ptr(), &CallbackCounter::callback));
p_state->call_on_update(callable_mp(p_updates_counter.ptr(), &CallbackCounter::callback_delta));
p_state->call_on_exit(callable_mp(p_exits_counter.ptr(), &CallbackCounter::callback));
}
class TestGuard : public RefCounted { class TestGuard : public RefCounted {
GDCLASS(TestGuard, RefCounted); GDCLASS(TestGuard, RefCounted);
@ -42,22 +48,38 @@ TEST_CASE("[Modules][LimboAI] HSM") {
Ref<CallbackCounter> beta_entries = memnew(CallbackCounter); Ref<CallbackCounter> beta_entries = memnew(CallbackCounter);
Ref<CallbackCounter> beta_exits = memnew(CallbackCounter); Ref<CallbackCounter> beta_exits = memnew(CallbackCounter);
Ref<CallbackCounter> beta_updates = memnew(CallbackCounter); Ref<CallbackCounter> beta_updates = memnew(CallbackCounter);
Ref<CallbackCounter> nested_entries = memnew(CallbackCounter);
Ref<CallbackCounter> nested_exits = memnew(CallbackCounter);
Ref<CallbackCounter> nested_updates = memnew(CallbackCounter);
Ref<CallbackCounter> gamma_entries = memnew(CallbackCounter);
Ref<CallbackCounter> gamma_exits = memnew(CallbackCounter);
Ref<CallbackCounter> gamma_updates = memnew(CallbackCounter);
Ref<CallbackCounter> delta_entries = memnew(CallbackCounter);
Ref<CallbackCounter> delta_exits = memnew(CallbackCounter);
Ref<CallbackCounter> delta_updates = memnew(CallbackCounter);
LimboState *state_alpha = memnew(LimboState); LimboState *state_alpha = memnew(LimboState);
state_alpha->call_on_enter(callable_mp(alpha_entries.ptr(), &CallbackCounter::callback)); wire_callbacks(state_alpha, alpha_entries, alpha_updates, alpha_exits);
state_alpha->call_on_update(callable_mp(alpha_updates.ptr(), &CallbackCounter::callback_delta));
state_alpha->call_on_exit(callable_mp(alpha_exits.ptr(), &CallbackCounter::callback));
LimboState *state_beta = memnew(LimboState); LimboState *state_beta = memnew(LimboState);
state_beta->call_on_enter(callable_mp(beta_entries.ptr(), &CallbackCounter::callback)); wire_callbacks(state_beta, beta_entries, beta_updates, beta_exits);
state_beta->call_on_update(callable_mp(beta_updates.ptr(), &CallbackCounter::callback_delta)); LimboHSM *nested_hsm = memnew(LimboHSM);
state_beta->call_on_exit(callable_mp(beta_exits.ptr(), &CallbackCounter::callback)); wire_callbacks(nested_hsm, nested_entries, nested_updates, nested_exits);
LimboState *state_gamma = memnew(LimboState);
wire_callbacks(state_gamma, gamma_entries, gamma_updates, gamma_exits);
LimboState *state_delta = memnew(LimboState);
wire_callbacks(state_delta, delta_entries, delta_updates, delta_exits);
hsm->add_child(state_alpha); hsm->add_child(state_alpha);
hsm->add_child(state_beta); hsm->add_child(state_beta);
hsm->add_child(nested_hsm);
nested_hsm->add_child(state_gamma);
nested_hsm->add_child(state_delta);
hsm->add_transition(state_alpha, state_beta, "event_one"); hsm->add_transition(state_alpha, state_beta, "event_one");
hsm->add_transition(state_beta, state_alpha, "event_two"); hsm->add_transition(state_beta, state_alpha, "event_two");
hsm->add_transition(hsm->anystate(), nested_hsm, "goto_nested");
nested_hsm->add_transition(state_gamma, state_delta, "goto_delta");
nested_hsm->add_transition(state_delta, state_gamma, "goto_gamma");
hsm->set_initial_state(state_alpha); hsm->set_initial_state(state_alpha);
Ref<Blackboard> parent_scope = memnew(Blackboard); Ref<Blackboard> parent_scope = memnew(Blackboard);
@ -179,6 +201,57 @@ TEST_CASE("[Modules][LimboAI] HSM") {
CHECK(state_beta->get_blackboard()->get_parent() == parent_scope); CHECK(state_beta->get_blackboard()->get_parent() == parent_scope);
CHECK(state_alpha->get_blackboard()->get_var("parent_var", Variant()) == Variant(100)); CHECK(state_alpha->get_blackboard()->get_var("parent_var", Variant()) == Variant(100));
} }
SUBCASE("Test flow with a nested HSM, and test dispatch() from nested states") {
state_gamma->dispatch("goto_nested");
CHECK(hsm->get_leaf_state() == state_gamma);
CHECK(nested_entries->num_callbacks == 1);
CHECK(nested_updates->num_callbacks == 0);
CHECK(nested_exits->num_callbacks == 0);
CHECK(gamma_entries->num_callbacks == 1);
CHECK(gamma_updates->num_callbacks == 0);
CHECK(gamma_exits->num_callbacks == 0);
hsm->update(0.01666);
CHECK(nested_entries->num_callbacks == 1);
CHECK(nested_updates->num_callbacks == 1);
CHECK(nested_exits->num_callbacks == 0);
CHECK(gamma_entries->num_callbacks == 1);
CHECK(gamma_updates->num_callbacks == 1);
CHECK(gamma_exits->num_callbacks == 0);
state_gamma->dispatch("goto_delta");
CHECK(hsm->get_leaf_state() == state_delta);
CHECK(nested_entries->num_callbacks == 1);
CHECK(nested_updates->num_callbacks == 1);
CHECK(nested_exits->num_callbacks == 0);
CHECK(gamma_entries->num_callbacks == 1);
CHECK(gamma_updates->num_callbacks == 1);
CHECK(gamma_exits->num_callbacks == 1);
CHECK(delta_entries->num_callbacks == 1);
CHECK(delta_updates->num_callbacks == 0);
CHECK(delta_exits->num_callbacks == 0);
state_delta->dispatch(hsm->event_finished());
CHECK(nested_entries->num_callbacks == 1);
CHECK(nested_updates->num_callbacks == 1);
CHECK(nested_exits->num_callbacks == 1);
CHECK(gamma_entries->num_callbacks == 1);
CHECK(gamma_updates->num_callbacks == 1);
CHECK(gamma_exits->num_callbacks == 1);
CHECK(delta_entries->num_callbacks == 1);
CHECK(delta_updates->num_callbacks == 0);
CHECK(delta_exits->num_callbacks == 1);
CHECK(hsm->is_active() == false);
CHECK(hsm->get_leaf_state() == hsm);
}
SUBCASE("Test get_root()") {
CHECK(hsm->get_root() == hsm);
CHECK(state_alpha->get_root() == hsm);
CHECK(state_beta->get_root() == hsm);
CHECK(nested_hsm->get_root() == hsm);
CHECK(state_delta->get_root() == hsm);
CHECK(state_gamma->get_root() == hsm);
}
memdelete(agent); memdelete(agent);
memdelete(hsm); memdelete(hsm);