From dedffc4f22154b58f534e71b7ac8a4591bc9dcbb Mon Sep 17 00:00:00 2001 From: Serhii Snitsaruk Date: Wed, 1 May 2024 13:59:57 +0200 Subject: [PATCH] Test: Nested HSM flow, dispatch() and get_root() --- tests/test_hsm.h | 87 ++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 80 insertions(+), 7 deletions(-) diff --git a/tests/test_hsm.h b/tests/test_hsm.h index 184f086..533f279 100644 --- a/tests/test_hsm.h +++ b/tests/test_hsm.h @@ -24,6 +24,12 @@ namespace TestHSM { +inline void wire_callbacks(LimboState *p_state, Ref p_entries_counter, Ref p_updates_counter, Ref 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 { GDCLASS(TestGuard, RefCounted); @@ -42,22 +48,38 @@ TEST_CASE("[Modules][LimboAI] HSM") { Ref beta_entries = memnew(CallbackCounter); Ref beta_exits = memnew(CallbackCounter); Ref beta_updates = memnew(CallbackCounter); + Ref nested_entries = memnew(CallbackCounter); + Ref nested_exits = memnew(CallbackCounter); + Ref nested_updates = memnew(CallbackCounter); + Ref gamma_entries = memnew(CallbackCounter); + Ref gamma_exits = memnew(CallbackCounter); + Ref gamma_updates = memnew(CallbackCounter); + Ref delta_entries = memnew(CallbackCounter); + Ref delta_exits = memnew(CallbackCounter); + Ref delta_updates = memnew(CallbackCounter); LimboState *state_alpha = memnew(LimboState); - state_alpha->call_on_enter(callable_mp(alpha_entries.ptr(), &CallbackCounter::callback)); - 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)); - + wire_callbacks(state_alpha, alpha_entries, alpha_updates, alpha_exits); LimboState *state_beta = memnew(LimboState); - state_beta->call_on_enter(callable_mp(beta_entries.ptr(), &CallbackCounter::callback)); - state_beta->call_on_update(callable_mp(beta_updates.ptr(), &CallbackCounter::callback_delta)); - state_beta->call_on_exit(callable_mp(beta_exits.ptr(), &CallbackCounter::callback)); + wire_callbacks(state_beta, beta_entries, beta_updates, beta_exits); + LimboHSM *nested_hsm = memnew(LimboHSM); + 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_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_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); Ref parent_scope = memnew(Blackboard); @@ -179,6 +201,57 @@ TEST_CASE("[Modules][LimboAI] HSM") { CHECK(state_beta->get_blackboard()->get_parent() == parent_scope); 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(hsm);