From 0f4e77d4b7096cddc1c32617eb25360c0551e218 Mon Sep 17 00:00:00 2001 From: Chris Cromer Date: Fri, 26 Aug 2022 19:27:57 -0400 Subject: [PATCH] cleanup c++ code --- src/CameraLimit.cpp | 21 ++--- src/CameraLimit.h | 6 +- src/Main.cpp | 79 ++++++++--------- src/Main.h | 56 +++++++----- src/godot.cpp | 35 ++++---- src/player/Player.cpp | 137 ++++++++++++++--------------- src/player/Player.h | 35 ++++---- src/player/states/PlayerFall.cpp | 23 +++-- src/player/states/PlayerFall.h | 12 +-- src/player/states/PlayerIdle.cpp | 23 +++-- src/player/states/PlayerIdle.h | 15 ++-- src/player/states/PlayerJump.cpp | 27 +++--- src/player/states/PlayerJump.h | 14 +-- src/player/states/PlayerMove.cpp | 23 +++-- src/player/states/PlayerMove.h | 10 +-- src/state_machine/State.cpp | 22 +++-- src/state_machine/State.h | 15 ++-- src/state_machine/StateMachine.cpp | 74 ++++++++-------- src/state_machine/StateMachine.h | 64 +++++++------- 19 files changed, 340 insertions(+), 351 deletions(-) diff --git a/src/CameraLimit.cpp b/src/CameraLimit.cpp index 95858b2..cdc4add 100644 --- a/src/CameraLimit.cpp +++ b/src/CameraLimit.cpp @@ -1,40 +1,37 @@ #include "CameraLimit.h" +#include #include #include -#include #include -#include -using namespace godot; - -void CameraLimit::_register_methods() +void alai::CameraLimit::_register_methods() { register_method("_ready", &CameraLimit::_ready); } -CameraLimit::CameraLimit() +alai::CameraLimit::CameraLimit() { } -CameraLimit::~CameraLimit() +alai::CameraLimit::~CameraLimit() { } -void CameraLimit::_init() +void alai::CameraLimit::_init() { } -void CameraLimit::_ready() +void alai::CameraLimit::_ready() { auto node = find_node("Middleground"); - auto middle_ground = cast_to(node); + auto middle_ground = cast_to(node); if (middle_ground != NULL) { auto used_rect = middle_ground->get_used_rect(); - auto bounds = Vector2(used_rect.position.x + used_rect.size.x, used_rect.position.y + used_rect.size.y); + auto bounds = godot::Vector2(used_rect.position.x + used_rect.size.x, used_rect.position.y + used_rect.size.y); node = get_tree()->get_root()->find_node("Camera2D", true, false); - auto camera = cast_to(node); + auto camera = cast_to(node); if (camera != NULL) { camera->set_limit(2, bounds.x * middle_ground->get_cell_size().x); diff --git a/src/CameraLimit.h b/src/CameraLimit.h index e277a4b..d9f86b5 100644 --- a/src/CameraLimit.h +++ b/src/CameraLimit.h @@ -4,16 +4,16 @@ #include #include -namespace godot +namespace alai { /** * @brief This class limits the camera's position. * * @details The camera will be limited based on the used width and height of the Middleground tilemap. */ - class CameraLimit: public Node2D + class CameraLimit: public godot::Node2D { - GODOT_CLASS(CameraLimit, Node2D) + GODOT_CLASS(CameraLimit, godot::Node2D) public: /** diff --git a/src/Main.cpp b/src/Main.cpp index 6bc13fb..00d622f 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -2,50 +2,47 @@ #include -using namespace godot; -using namespace main; - -void Main::_register_methods() +void alai::main::Main::_register_methods() { - register_method("_ready", &Main::_ready); - register_method("_physics_process", &Main::_physics_process); - register_method("_on_monitor_loaded", &Main::_on_monitor_loaded); - register_property("game_version", &Main::set_game_version, &Main::get_game_version, String(main::game_version.c_str())); - register_property>("level", &Main::set_level, &Main::get_level, NULL, GODOT_METHOD_RPC_MODE_DISABLED, GODOT_PROPERTY_USAGE_DEFAULT, GODOT_PROPERTY_HINT_RESOURCE_TYPE, String("PackedScene")); - register_property("full_screen", &Main::set_full_screen, &Main::get_full_screen, main::full_screen); - register_property("window_size", &Main::set_window_size, &Main::get_window_size, main::window_size); - register_property("launch_screen", &Main::set_launch_screen, &Main::get_launch_screen, main::launch_screen); - register_signal
("monitor_loaded"); + godot::register_method("_ready", &Main::_ready); + godot::register_method("_physics_process", &Main::_physics_process); + godot::register_method("_on_monitor_loaded", &Main::_on_monitor_loaded); + godot::register_property("game_version", &Main::set_game_version, &Main::get_game_version, godot::String(main::game_version.c_str())); + godot::register_property>("level", &Main::set_level, &Main::get_level, NULL, GODOT_METHOD_RPC_MODE_DISABLED, GODOT_PROPERTY_USAGE_DEFAULT, GODOT_PROPERTY_HINT_RESOURCE_TYPE, godot::String("PackedScene")); + godot::register_property("full_screen", &Main::set_full_screen, &Main::get_full_screen, main::full_screen); + godot::register_property("window_size", &Main::set_window_size, &Main::get_window_size, main::window_size); + godot::register_property("launch_screen", &Main::set_launch_screen, &Main::get_launch_screen, main::launch_screen); + godot::register_signal
("monitor_loaded"); } -Main::Main() +alai::main::Main::Main() { } -Main::~Main() +alai::main::Main::~Main() { } -void Main::_init() +void alai::main::Main::_init() { - _os = OS::get_singleton(); - _input = Input::get_singleton(); - _project_settings = ProjectSettings::get_singleton(); - _resource_loader = ResourceLoader::get_singleton(); + _os = godot::OS::get_singleton(); + _input = godot::Input::get_singleton(); + _project_settings = godot::ProjectSettings::get_singleton(); + _resource_loader = godot::ResourceLoader::get_singleton(); - game_version = String(main::game_version.c_str()); + game_version = godot::String(main::game_version.c_str()); full_screen = main::full_screen; window_size = main::window_size; launch_screen = main::launch_screen; } -void Main::_ready() +void alai::main::Main::_ready() { auto success = _project_settings->load_resource_pack("monitor.pck"); if (success) { // Load monitor from pck - Godot::print("Monitor pck found, loading..."); + godot::Godot::print("Monitor pck found, loading..."); load_monitor(); } else if (_resource_loader->exists("res://monitor/Monitor.tscn")) @@ -75,19 +72,19 @@ void Main::_ready() if (success) { // Load crt from pck - Godot::print("CRT pck found, loading..."); - Ref crt_scene = _resource_loader->load("res://shaders/crt/crt.tscn"); + godot::Godot::print("CRT pck found, loading..."); + godot::Ref crt_scene = _resource_loader->load("res://shaders/crt/crt.tscn"); add_child(crt_scene->instance()); } else if (_resource_loader->exists("res://shaders/crt/crt.tscn")) { // Load crt from alai's pck - Ref crt_scene = _resource_loader->load("res://shaders/crt/crt.tscn"); + godot::Ref crt_scene = _resource_loader->load("res://shaders/crt/crt.tscn"); add_child(crt_scene->instance()); } } -void Main::_on_monitor_loaded() +void alai::main::Main::_on_monitor_loaded() { if (level != nullptr) { @@ -97,16 +94,16 @@ void Main::_on_monitor_loaded() } } -void Main::load_monitor() +void alai::main::Main::load_monitor() { - Ref monitor_scene = _resource_loader->load("res://monitor/Monitor.tscn"); + godot::Ref monitor_scene = _resource_loader->load("res://monitor/Monitor.tscn"); add_child(monitor_scene->instance()); auto monitor = get_node("Monitor"); monitor->connect("monitor_loaded", this, "_on_monitor_loaded"); get_tree()->set_pause(true); } -Node *Main::load_level() +godot::Node *alai::main::Main::load_level() { if (level != nullptr) { @@ -119,7 +116,7 @@ Node *Main::load_level() return nullptr; } -void Main::_physics_process(float delta) +void alai::main::Main::_physics_process(float delta) { if (_input->is_action_just_pressed("ui_cancel")) { @@ -127,52 +124,52 @@ void Main::_physics_process(float delta) } } -void Main::set_level(Ref level) +void alai::main::Main::set_level(godot::Ref level) { this->level = level; } -Ref Main::get_level() +godot::Ref alai::main::Main::get_level() { return this->level; } -void Main::set_game_version(String game_version) +void alai::main::Main::set_game_version(godot::String game_version) { this->game_version = game_version; } -String Main::get_game_version() +godot::String alai::main::Main::get_game_version() { return this->game_version; } -void Main::set_full_screen(bool full_screen) +void alai::main::Main::set_full_screen(bool full_screen) { this->full_screen = full_screen; } -bool Main::get_full_screen() +bool alai::main::Main::get_full_screen() { return this->full_screen; } -void Main::set_window_size(Vector2 window_size) +void alai::main::Main::set_window_size(godot::Vector2 window_size) { this-> window_size = window_size; } -Vector2 Main::get_window_size() +godot::Vector2 alai::main::Main::get_window_size() { return this->window_size; } -void Main::set_launch_screen(int8_t launch_screen) +void alai::main::Main::set_launch_screen(int8_t launch_screen) { this->launch_screen = launch_screen; } -int8_t Main::get_launch_screen() +int8_t alai::main::Main::get_launch_screen() { if (this->launch_screen == -1) { diff --git a/src/Main.h b/src/Main.h index 4c04cc9..a575dfb 100644 --- a/src/Main.h +++ b/src/Main.h @@ -3,20 +3,20 @@ #include #include +#include #include #include -#include #include -#include #include +#include #include /** - * @brief This is the godot namespace for all the code included in the library. + * @brief This is the alai namespace for all the code included in the game. * * @details This namespace is used a prefix when the Godot engine looks for classes, methods, and properties. */ -namespace godot +namespace alai { /** * @brief This namespace houses some global variables and the main class. @@ -38,7 +38,7 @@ namespace godot * @brief The default resolution for the game window. * */ - const Vector2 window_size = Vector2(1280, 720); + const godot::Vector2 window_size = godot::Vector2(1280, 720); /** * @brief The default screen the the game should open on. * @@ -49,44 +49,44 @@ namespace godot /** * @brief This class controls the Main node. * - * @details The main node is responsible for controling the window and the game iteself is a child of it. + * @details The main node is responsible for controlling the window and the game itself is a child of it. */ - class Main : public Node + class Main : public godot::Node { - GODOT_CLASS(Main, Node) + GODOT_CLASS(Main, godot::Node) private: /** * @brief OS singleton. * */ - OS *_os; + godot::OS *_os; /** * @brief Input singleton. * */ - Input *_input; + godot::Input *_input; /** * @brief ProjectSettings singleton. * */ - ProjectSettings *_project_settings; + godot::ProjectSettings *_project_settings; /** * @brief ResourceLoader singleton. * */ - ResourceLoader *_resource_loader; + godot::ResourceLoader *_resource_loader; /** * @brief The first level to load * */ - Ref level; + godot::Ref level; /** * @brief The current version of the game. * */ - String game_version; + godot::String game_version; /** * @brief If the window is full screen or not. * @@ -96,7 +96,7 @@ namespace godot * @brief The size of the window. * */ - Vector2 window_size; + godot::Vector2 window_size; /** * @brief The screen to launch the game on. * @@ -151,28 +151,28 @@ namespace godot * * @param[in] level The new level to load when starting. */ - void set_level(Ref level); + void set_level(godot::Ref level); /** * @brief Get the level object. * * @return Ref The level scene to load. */ - Ref get_level(); + godot::Ref get_level(); /** * @brief Set the game version object. * * @param[in] game_version The new version fo the game. */ - void set_game_version(String game_version); + void set_game_version(godot::String game_version); /** * @brief Get the game version object. * * @return String The current version of the game. */ - String get_game_version(); + godot::String get_game_version(); /** * @brief Set the full screen object. @@ -194,14 +194,14 @@ namespace godot * * @param[in] window_size The new window size. */ - void set_window_size(Vector2 window_size); + void set_window_size(godot::Vector2 window_size); /** * @brief Get the window size object. * * @return Vector2 The window size. */ - Vector2 get_window_size(); + godot::Vector2 get_window_size(); /** * @brief Set the launch screen object. @@ -217,9 +217,23 @@ namespace godot */ int8_t get_launch_screen(); + /** + * @brief Called when the monitor finishes loading. + * + */ void _on_monitor_loaded(); + /** + * @brief Loads the monitor and adds it to the scene. + * + */ void load_monitor(); + + /** + * @brief Loads the selected level. + * + * @return Node* The level node which we will later add the monitor to. + */ Node *load_level(); }; } diff --git a/src/godot.cpp b/src/godot.cpp index 1c56d09..a8a9017 100644 --- a/src/godot.cpp +++ b/src/godot.cpp @@ -1,24 +1,22 @@ #include -#include "state_machine/StateMachine.h" -#include "state_machine/State.h" -#include "Main.h" #include "CameraLimit.h" +#include "Main.h" +#include "state_machine/State.h" +#include "state_machine/StateMachine.h" #include "player/Player.h" #include "player/states/PlayerIdle.h" #include "player/states/PlayerMove.h" #include "player/states/PlayerJump.h" #include "player/states/PlayerFall.h" -using namespace godot; - /** * @brief This function connects the gdnative init function. * */ extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) { - Godot::gdnative_init(o); + godot::Godot::gdnative_init(o); } /** @@ -29,8 +27,8 @@ extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_opt { // This next line is a workaround to fix bug: // https://github.com/godotengine/godot/issues/48295 - Godot::nativescript_terminate(_RegisterState::nativescript_handle); - Godot::gdnative_terminate(o); + godot::Godot::nativescript_terminate(godot::_RegisterState::nativescript_handle); + godot::Godot::gdnative_terminate(o); } /** @@ -39,14 +37,15 @@ extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_opt */ extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) { - Godot::nativescript_init(handle); - register_class(); - register_class(); - register_class(); - register_class(); - register_class(); - register_class(); - register_class(); - register_class(); - register_class(); + godot::Godot::nativescript_init(handle); + + godot::register_class(); + godot::register_class(); + godot::register_class(); + godot::register_class(); + godot::register_class(); + godot::register_class(); + godot::register_class(); + godot::register_class(); + godot::register_class(); } diff --git a/src/player/Player.cpp b/src/player/Player.cpp index 868156b..38348a2 100644 --- a/src/player/Player.cpp +++ b/src/player/Player.cpp @@ -1,48 +1,45 @@ #include "player/Player.h" #include -#include -#include +#include +#include #include #include +#include #include -#include -#include +#include -using namespace godot; -using namespace player; - -void Player::_register_methods() +void alai::player::Player::_register_methods() { - register_method("_ready", &Player::_ready); - register_method("_physics_process", &Player::_physics_process); - register_method("set_velocity", &Player::set_velocity); - register_method("get_velocity", &Player::get_velocity); - register_method("_on_player_touched", &Player::_on_player_touched); - register_method("_on_monitor_loaded", &Player::_on_monitor_loaded); - //register_property>("sprite_frames", &Player::set_sprite_frames, &Player::get_sprite_frames, Ref(), GODOT_METHOD_RPC_MODE_DISABLED, GODOT_PROPERTY_USAGE_DEFAULT, GODOT_PROPERTY_HINT_RESOURCE_TYPE, String("SpriteFrames")); - register_property("speed", &Player::set_speed, &Player::get_speed, player::speed); - register_property("jump_force", &Player::set_jump_force, &Player::get_jump_force, player::jump_force); - register_property("bounce_force", &Player::set_bounce_force, &Player::get_bounce_force, player::bounce_force); - register_property("gravity", &Player::set_gravity, &Player::get_gravity, player::gravity); - register_property("run_speed", &Player::set_run_speed, &Player::get_run_speed, player::run_speed); - register_property("double_jump", &Player::set_double_jump, &Player::get_double_jump, player::double_jump); - register_signal("object_created", "name", GODOT_VARIANT_TYPE_STRING, "state", GODOT_VARIANT_TYPE_STRING, "position", GODOT_VARIANT_TYPE_VECTOR2, "velocity", GODOT_VARIANT_TYPE_VECTOR2); - register_signal("object_updated", "name", GODOT_VARIANT_TYPE_STRING, "state", GODOT_VARIANT_TYPE_STRING, "position", GODOT_VARIANT_TYPE_VECTOR2, "velocity", GODOT_VARIANT_TYPE_VECTOR2); - register_signal("object_removed", "name", GODOT_VARIANT_TYPE_STRING); + godot::register_method("_ready", &Player::_ready); + godot::register_method("_physics_process", &Player::_physics_process); + godot::register_method("set_velocity", &Player::set_velocity); + godot::register_method("get_velocity", &Player::get_velocity); + godot::register_method("_on_player_touched", &Player::_on_player_touched); + godot::register_method("_on_monitor_loaded", &Player::_on_monitor_loaded); + //godot::register_property>("sprite_frames", &Player::set_sprite_frames, &Player::get_sprite_frames, godot::Ref(), GODOT_METHOD_RPC_MODE_DISABLED, GODOT_PROPERTY_USAGE_DEFAULT, GODOT_PROPERTY_HINT_RESOURCE_TYPE, godot::String("SpriteFrames")); + godot::register_property("speed", &Player::set_speed, &Player::get_speed, player::speed); + godot::register_property("jump_force", &Player::set_jump_force, &Player::get_jump_force, player::jump_force); + godot::register_property("bounce_force", &Player::set_bounce_force, &Player::get_bounce_force, player::bounce_force); + godot::register_property("gravity", &Player::set_gravity, &Player::get_gravity, player::gravity); + godot::register_property("run_speed", &Player::set_run_speed, &Player::get_run_speed, player::run_speed); + godot::register_property("double_jump", &Player::set_double_jump, &Player::get_double_jump, player::double_jump); + godot::register_signal("object_created", "name", GODOT_VARIANT_TYPE_STRING, "state", GODOT_VARIANT_TYPE_STRING, "position", GODOT_VARIANT_TYPE_VECTOR2, "velocity", GODOT_VARIANT_TYPE_VECTOR2); + godot::register_signal("object_updated", "name", GODOT_VARIANT_TYPE_STRING, "state", GODOT_VARIANT_TYPE_STRING, "position", GODOT_VARIANT_TYPE_VECTOR2, "velocity", GODOT_VARIANT_TYPE_VECTOR2); + godot::register_signal("object_removed", "name", GODOT_VARIANT_TYPE_STRING); } -Player::Player() +alai::player::Player::Player() { } -Player::~Player() +alai::player::Player::~Player() { } -void Player::_init() +void alai::player::Player::_init() { - _resource_loader = ResourceLoader::get_singleton(); + _resource_loader = godot::ResourceLoader::get_singleton(); //sprite_frames = _resource_loader->load(player::sprite_frames); set_speed(player::speed); @@ -54,23 +51,23 @@ void Player::_init() coins = 0; - velocity = Vector2(); + velocity = godot::Vector2(); } -void Player::_ready() +void alai::player::Player::_ready() { - animated_sprite = get_node("AnimatedSprite"); + animated_sprite = get_node("AnimatedSprite"); if (!animated_sprite) { ERR_PRINT("AnimateSprite not found!"); - animated_sprite = AnimatedSprite()._new(); + animated_sprite = godot::AnimatedSprite()._new(); } //animated_sprite->set_sprite_frames(sprite_frames); auto node = get_parent()->find_node("Middleground"); if (node != nullptr) { - auto tile_map = Object::cast_to(node); + auto tile_map = Object::cast_to(node); get_parent()->call_deferred("remove_child", this); tile_map->call_deferred("add_child", this); } @@ -80,7 +77,7 @@ void Player::_ready() } } -void Player::_on_monitor_loaded() { +void alai::player::Player::_on_monitor_loaded() { auto object_node = get_tree()->get_root()->find_node("Monitor", true, false); if (object_node != nullptr) { @@ -105,22 +102,22 @@ void Player::_on_monitor_loaded() { #endif } -void Player::_physics_process(float delta) +void alai::player::Player::_physics_process(float delta) { velocity.y += get_gravity(); - auto snap_vector = Vector2::ZERO; + auto snap_vector = godot::Vector2::ZERO; if (!is_on_floor()) { - snap_vector = Vector2::DOWN * 20.0; + snap_vector = godot::Vector2::DOWN * 20.0; } - auto platform_detector = get_node("PlatformDetector"); + auto platform_detector = get_node("PlatformDetector"); auto is_on_platform = platform_detector->is_colliding(); - velocity = move_and_slide_with_snap(velocity, snap_vector, Vector2::UP, !is_on_platform, 4, 0.9, false); + velocity = move_and_slide_with_snap(velocity, snap_vector, godot::Vector2::UP, !is_on_platform, 4, 0.9, false); //velocity = move_and_slide(velocity, Vector2::UP, !is_on_platform); - velocity.x = Math::lerp((float) velocity.x, (float) 0, (float) 0.2); + velocity.x = godot::Math::lerp((float) velocity.x, (float) 0, (float) 0.2); auto count = get_slide_count(); for (int64_t i = 0; i < count; i++) @@ -128,7 +125,7 @@ void Player::_physics_process(float delta) auto collision = get_slide_collision(i); auto collision_object = collision->get_collider(); auto collider = Object::cast_to(collision_object); - if (collider->is_in_group("squashable") && Vector2::UP.dot(collision->get_normal()) > 0.1) + if (collider->is_in_group("squashable") && godot::Vector2::UP.dot(collision->get_normal()) > 0.1) { collider->call_deferred("squash"); /*auto dup_node = collider->duplicate(); @@ -147,7 +144,7 @@ void Player::_physics_process(float delta) }*/ velocity.y = -get_bounce_force(); } - else if (collider->is_in_group("enemy") && (collider->is_in_group("rideable") && Vector2::DOWN.dot(collision->get_normal()) > 0)) + else if (collider->is_in_group("enemy") && (collider->is_in_group("rideable") && godot::Vector2::DOWN.dot(collision->get_normal()) > 0)) { _on_player_touched(); } @@ -158,23 +155,23 @@ void Player::_physics_process(float delta) } // Clamp the player's position inside the camera's limits - auto camera = get_node("Camera2D"); + auto camera = get_node("Camera2D"); auto position = get_global_position(); - auto sprite_node = get_node("AnimatedSprite"); + auto sprite_node = get_node("AnimatedSprite"); if (sprite_node != nullptr) { - position.x = Math::clamp((float) position.x, (float) camera->get_limit(0), (float) camera->get_limit(2) - sprite_node->get_sprite_frames()->get_frame("idle", 0)->get_size().x); - position.y = Math::clamp((float) position.y, (float) camera->get_limit(1), (float) camera->get_limit(3) + sprite_node->get_sprite_frames()->get_frame("idle", 0)->get_size().y); + position.x = godot::Math::clamp((float) position.x, (float) camera->get_limit(0), (float) camera->get_limit(2) - sprite_node->get_sprite_frames()->get_frame("idle", 0)->get_size().x); + position.y = godot::Math::clamp((float) position.y, (float) camera->get_limit(1), (float) camera->get_limit(3) + sprite_node->get_sprite_frames()->get_frame("idle", 0)->get_size().y); } else { WARN_PRINT("Could not clamp player based on sprite frame size!"); - position.x = Math::clamp((float) position.x, (float) camera->get_limit(0), (float) camera->get_limit(2)); - position.y = Math::clamp((float) position.y, (float) camera->get_limit(1), (float) camera->get_limit(3)); + position.x = godot::Math::clamp((float) position.x, (float) camera->get_limit(0), (float) camera->get_limit(2)); + position.y = godot::Math::clamp((float) position.y, (float) camera->get_limit(1), (float) camera->get_limit(3)); } set_global_position(position); // If the player is off screen reload the scene - auto notifier = get_node("Camera2D/VisibilityNotifier2D"); + auto notifier = get_node("Camera2D/VisibilityNotifier2D"); if (notifier != nullptr) { if (!notifier->is_on_screen()) @@ -182,9 +179,9 @@ void Player::_physics_process(float delta) if (get_parent()->get_class() == "TileMap") { auto error = get_tree()->change_scene("res://Main.tscn"); - if (error != Error::OK) + if (error != godot::Error::OK) { - ERR_PRINT(String().num((int) error) + " Could not load scene!"); + ERR_PRINT(godot::String().num((int) error) + " Could not load scene!"); } } } @@ -201,91 +198,91 @@ void Player::_physics_process(float delta) } } -void Player::set_sprite_frames(Ref sprite_frames) +void alai::player::Player::set_sprite_frames(godot::Ref sprite_frames) { this->sprite_frames = sprite_frames; } -Ref Player::get_sprite_frames() +godot::Ref alai::player::Player::get_sprite_frames() { return this->sprite_frames; } -void Player::set_speed(float speed) +void alai::player::Player::set_speed(float speed) { this->speed = speed; } -float Player::get_speed() +float alai::player::Player::get_speed() { return this->speed; } -void Player::set_jump_force(float jump_force) +void alai::player::Player::set_jump_force(float jump_force) { this->jump_force = jump_force; } -float Player::get_jump_force() +float alai::player::Player::get_jump_force() { return this->jump_force; } -void Player::set_bounce_force(float bounce_force) +void alai::player::Player::set_bounce_force(float bounce_force) { this->bounce_force = bounce_force; } -float Player::get_bounce_force() +float alai::player::Player::get_bounce_force() { return this->bounce_force; } -void Player::set_gravity(float gravity) +void alai::player::Player::set_gravity(float gravity) { this->gravity = gravity; } -float Player::get_gravity() +float alai::player::Player::get_gravity() { return this->gravity; } -void Player::set_run_speed(float run_speed) +void alai::player::Player::set_run_speed(float run_speed) { this->run_speed = run_speed; } -float Player::get_run_speed() +float alai::player::Player::get_run_speed() { return this->run_speed; } -void Player::set_double_jump(bool double_jump) +void alai::player::Player::set_double_jump(bool double_jump) { this->double_jump = double_jump; } -bool Player::get_double_jump() +bool alai::player::Player::get_double_jump() { return this->double_jump; } -void Player::set_velocity(Vector2 velocity) +void alai::player::Player::set_velocity(godot::Vector2 velocity) { this->velocity = velocity; } -Vector2 Player::get_velocity() +godot::Vector2 alai::player::Player::get_velocity() { return this->velocity; } -void Player::_on_player_touched() +void alai::player::Player::_on_player_touched() { auto error = get_tree()->change_scene("res://Main.tscn"); - if (error != Error::OK) + if (error != godot::Error::OK) { - ERR_PRINT(String().num((int) error) + " Could not load scene!"); + ERR_PRINT(godot::String().num((int) error) + " Could not load scene!"); } } diff --git a/src/player/Player.h b/src/player/Player.h index ee505a0..cedcfb5 100644 --- a/src/player/Player.h +++ b/src/player/Player.h @@ -1,14 +1,13 @@ -#ifndef ALAI_PLAYER_H -#define ALAI_PLAYER_H +#ifndef ALAI_PLAYER_PLAYER_H +#define ALAI_PLAYER_PLAYER_H +#include #include #include -#include -#include -#include #include +#include -namespace godot +namespace alai { /** * @brief This namespace contains the global variables related to the player and its states. @@ -57,27 +56,27 @@ namespace godot * * @details This class allows the player to move, run, and jump as well as controls the sprite displayed for those actions. */ - class Player : public KinematicBody2D + class Player : public godot::KinematicBody2D { - GODOT_CLASS(Player, KinematicBody2D) + GODOT_CLASS(Player, godot::KinematicBody2D) private: /** * @brief ResourceLoader singleton. * */ - ResourceLoader *_resource_loader; + godot::ResourceLoader *_resource_loader; /** * @brief The animated sprite connected to the KinematicBody2D. * */ - AnimatedSprite *animated_sprite; + godot::AnimatedSprite *animated_sprite; /** * @brief The sprite frames used in the animated sprite. * */ - Ref sprite_frames; + godot::Ref sprite_frames; /** * @brief The coins the player has collected. * @@ -87,7 +86,7 @@ namespace godot * @brief The velocity at which moves the player moves. * */ - Vector2 velocity; + godot::Vector2 velocity; /** * @brief The speed that the player moves in. * @@ -167,14 +166,14 @@ namespace godot * * @param[in] sprite_frames The new sprite frame. */ - void set_sprite_frames(Ref sprite_frames); + void set_sprite_frames(godot::Ref sprite_frames); /** * @brief Get the sprite frames object. * * @return Ref A reference to the sprite frames object. */ - Ref get_sprite_frames(); + godot::Ref get_sprite_frames(); /** * @brief Set the speed object. @@ -266,14 +265,14 @@ namespace godot * * @param[in] velocity The new velocity of the player. */ - void set_velocity(Vector2 velocity); + void set_velocity(godot::Vector2 velocity); /** * @brief Get the velocity object. * * @return Vector2 Returns the velocity of the player. */ - Vector2 get_velocity(); + godot::Vector2 get_velocity(); /** * @brief This function is called when an enemy touches the player. @@ -281,6 +280,10 @@ namespace godot */ void _on_player_touched(); + /** + * @brief Called when the monitor is loaded to connect the player to it for tracking. + * + */ void _on_monitor_loaded(); }; } diff --git a/src/player/states/PlayerFall.cpp b/src/player/states/PlayerFall.cpp index c3e6ff4..d218305 100644 --- a/src/player/states/PlayerFall.cpp +++ b/src/player/states/PlayerFall.cpp @@ -1,45 +1,42 @@ #include "player/states/PlayerFall.h" #include "player/Player.h" -using namespace godot; -using namespace player; - -void PlayerFall::_register_methods() +void alai::player::PlayerFall::_register_methods() { register_method("_state_enter", &PlayerFall::_state_enter); register_method("_state_exit", &PlayerFall::_state_exit); register_method("_physics_process", &PlayerFall::_physics_process); } -PlayerFall::PlayerFall() +alai::player::PlayerFall::PlayerFall() { } -PlayerFall::~PlayerFall() +alai::player::PlayerFall::~PlayerFall() { } -void PlayerFall::_init() +void alai::player::PlayerFall::_init() { - _input = Input::get_singleton(); + _input = godot::Input::get_singleton(); } -void PlayerFall::_state_enter() +void alai::player::PlayerFall::_state_enter() { - animated_sprite = get_parent()->get_node("AnimatedSprite"); + animated_sprite = get_parent()->get_node("AnimatedSprite"); animated_sprite->stop(); animated_sprite->set_animation("air"); } -void PlayerFall::_state_exit() +void alai::player::PlayerFall::_state_exit() { animated_sprite->set_animation("move"); animated_sprite->set_frame(1); } -void PlayerFall::_physics_process(float delta) +void alai::player::PlayerFall::_physics_process(float delta) { - auto parent = Object::cast_to(get_parent()); + auto parent = Object::cast_to(get_parent()); if (parent->is_on_floor()) { diff --git a/src/player/states/PlayerFall.h b/src/player/states/PlayerFall.h index b7d774a..5fbd54a 100644 --- a/src/player/states/PlayerFall.h +++ b/src/player/states/PlayerFall.h @@ -1,13 +1,13 @@ -#ifndef JUEGO_PLAYER_FALL_H -#define JUEGO_PLAYER_FALL_H +#ifndef ALAI_PLAYER_STATES_PLAYER_FALL_H +#define ALAI_PLAYER_STATES_PLAYER_FALL_H #include "state_machine/State.h" +#include #include #include -#include -namespace godot +namespace alai { namespace player { @@ -24,13 +24,13 @@ namespace godot * @brief Input singleton. * */ - Input *_input; + godot::Input *_input; /** * @brief The animated sprite connected to the Player. * */ - AnimatedSprite *animated_sprite; + godot::AnimatedSprite *animated_sprite; public: /** diff --git a/src/player/states/PlayerIdle.cpp b/src/player/states/PlayerIdle.cpp index 026b5cf..4a03de4 100644 --- a/src/player/states/PlayerIdle.cpp +++ b/src/player/states/PlayerIdle.cpp @@ -1,43 +1,40 @@ #include "player/states/PlayerIdle.h" #include "player/Player.h" -using namespace godot; -using namespace player; - -void PlayerIdle::_register_methods() +void alai::player::PlayerIdle::_register_methods() { register_method("_state_enter", &PlayerIdle::_state_enter); register_method("_state_exit", &PlayerIdle::_state_exit); register_method("_physics_process", &PlayerIdle::_physics_process); } -PlayerIdle::PlayerIdle() +alai::player::PlayerIdle::PlayerIdle() { } -PlayerIdle::~PlayerIdle() +alai::player::PlayerIdle::~PlayerIdle() { } -void PlayerIdle::_init() +void alai::player::PlayerIdle::_init() { - _input = Input::get_singleton(); + _input = godot::Input::get_singleton(); } -void PlayerIdle::_state_enter() +void alai::player::PlayerIdle::_state_enter() { - animated_sprite = get_parent()->get_node("AnimatedSprite"); + animated_sprite = get_parent()->get_node("AnimatedSprite"); animated_sprite->stop(); animated_sprite->set_animation("idle"); } -void PlayerIdle::_state_exit() +void alai::player::PlayerIdle::_state_exit() { } -void PlayerIdle::_physics_process(float delta) +void alai::player::PlayerIdle::_physics_process(float delta) { - auto parent = Object::cast_to(get_parent()); + auto parent = Object::cast_to(get_parent()); if (_input->is_action_pressed("right")) { diff --git a/src/player/states/PlayerIdle.h b/src/player/states/PlayerIdle.h index 8dc46d2..8a458b4 100644 --- a/src/player/states/PlayerIdle.h +++ b/src/player/states/PlayerIdle.h @@ -1,14 +1,13 @@ -#ifndef JUEGO_PLAYER_IDLE_H -#define JUEGO_PLAYER_IDLE_H +#ifndef ALAI_PLAYER_STATES_PLAYER_IDLE_H +#define ALAI_PLAYER_STATES_PLAYER_IDLE_H #include "state_machine/State.h" -#include -#include -#include #include +#include +#include -namespace godot +namespace alai { namespace player { @@ -25,12 +24,12 @@ namespace godot * @brief Input singleton. * */ - Input *_input; + godot::Input *_input; /** * @brief The animated sprite of the Player. * */ - AnimatedSprite *animated_sprite; + godot::AnimatedSprite *animated_sprite; public: /** diff --git a/src/player/states/PlayerJump.cpp b/src/player/states/PlayerJump.cpp index e9f9082..4a77147 100644 --- a/src/player/states/PlayerJump.cpp +++ b/src/player/states/PlayerJump.cpp @@ -3,35 +3,32 @@ #include -using namespace godot; -using namespace player; - -void PlayerJump::_register_methods() +void alai::player::PlayerJump::_register_methods() { register_method("_state_enter", &PlayerJump::_state_enter); register_method("_state_exit", &PlayerJump::_state_exit); register_method("_physics_process", &PlayerJump::_physics_process); } -PlayerJump::PlayerJump() +alai::player::PlayerJump::PlayerJump() { } -PlayerJump::~PlayerJump() +alai::player::PlayerJump::~PlayerJump() { } -void PlayerJump::_init() +void alai::player::PlayerJump::_init() { - _input = Input::get_singleton(); + _input = godot::Input::get_singleton(); } -void PlayerJump::_state_enter(const String state) +void alai::player::PlayerJump::_state_enter(const godot::String state) { - auto jump_sound = get_parent()->get_node("Sounds/Jump"); + auto jump_sound = get_parent()->get_node("Sounds/Jump"); jump_sound->play(); - animated_sprite = get_parent()->get_node("AnimatedSprite"); + animated_sprite = get_parent()->get_node("AnimatedSprite"); animated_sprite->stop(); animated_sprite->set_animation("air"); @@ -44,21 +41,21 @@ void PlayerJump::_state_enter(const String state) double_jumped = false; } - auto parent = Object::cast_to(get_parent()); + auto parent = Object::cast_to(get_parent()); auto velocity = parent->get_velocity(); velocity.y = -parent->get_jump_force(); parent->set_velocity(velocity); } -void PlayerJump::_state_exit() +void alai::player::PlayerJump::_state_exit() { animated_sprite->set_animation("move"); animated_sprite->set_frame(1); } -void PlayerJump::_physics_process(float delta) +void alai::player::PlayerJump::_physics_process(float delta) { - auto parent = Object::cast_to(get_parent()); + auto parent = Object::cast_to(get_parent()); if (parent->is_on_floor()) { get_state_machine()->change("Move"); diff --git a/src/player/states/PlayerJump.h b/src/player/states/PlayerJump.h index 4640085..b3c67ed 100644 --- a/src/player/states/PlayerJump.h +++ b/src/player/states/PlayerJump.h @@ -1,13 +1,13 @@ -#ifndef JUEGO_PLAYER_JUMP_H -#define JUEGO_PLAYER_JUMP_H +#ifndef ALAI_PLAYER_STATES_PLAYER_JUMP_H +#define ALAI_PLAYER_STATES_PLAYER_JUMP_H #include "state_machine/State.h" +#include #include #include -#include -namespace godot +namespace alai { namespace player { @@ -24,12 +24,12 @@ namespace godot * @brief Input singleton. * */ - Input *_input; + godot::Input *_input; /** * @brief The animated sprite connected to the Player. * */ - AnimatedSprite *animated_sprite; + godot::AnimatedSprite *animated_sprite; /** * @brief If the player has already performed a double jump or not. * @@ -70,7 +70,7 @@ namespace godot * * @param[in] state The previous state before this one was entered. */ - void _state_enter(const String state); + void _state_enter(const godot::String state); /** * @brief Called when the player exits the jump state. diff --git a/src/player/states/PlayerMove.cpp b/src/player/states/PlayerMove.cpp index 77df13e..7ad60ff 100644 --- a/src/player/states/PlayerMove.cpp +++ b/src/player/states/PlayerMove.cpp @@ -1,43 +1,40 @@ #include "player/states/PlayerMove.h" #include "player/Player.h" -using namespace godot; -using namespace player; - -void PlayerMove::_register_methods() +void alai::player::PlayerMove::_register_methods() { register_method("_state_enter", &PlayerMove::_state_enter); register_method("_state_exit", &PlayerMove::_state_exit); register_method("_physics_process", &PlayerMove::_physics_process); } -PlayerMove::PlayerMove() +alai::player::PlayerMove::PlayerMove() { } -PlayerMove::~PlayerMove() +alai::player::PlayerMove::~PlayerMove() { } -void PlayerMove::_init() +void alai::player::PlayerMove::_init() { - _input = Input::get_singleton(); + _input = godot::Input::get_singleton(); } -void PlayerMove::_state_enter() +void alai::player::PlayerMove::_state_enter() { - animated_sprite = get_parent()->get_node("AnimatedSprite"); + animated_sprite = get_parent()->get_node("AnimatedSprite"); animated_sprite->set_animation("move"); animated_sprite->play(); } -void PlayerMove::_state_exit() +void alai::player::PlayerMove::_state_exit() { } -void PlayerMove::_physics_process(float delta) +void alai::player::PlayerMove::_physics_process(float delta) { - auto parent = Object::cast_to(get_parent()); + auto parent = Object::cast_to(get_parent()); auto direction_pressed = false; diff --git a/src/player/states/PlayerMove.h b/src/player/states/PlayerMove.h index 610819d..a436a95 100644 --- a/src/player/states/PlayerMove.h +++ b/src/player/states/PlayerMove.h @@ -1,5 +1,5 @@ -#ifndef JUEGO_PLAYER_MOVE_H -#define JUEGO_PLAYER_MOVE_H +#ifndef ALAI_PLAYER_STATES_PLAYER_MOVE_H +#define ALAI_PLAYER_STATES_PLAYER_MOVE_H #include "state_machine/State.h" @@ -7,7 +7,7 @@ #include #include -namespace godot +namespace alai { namespace player { @@ -24,12 +24,12 @@ namespace godot * @brief Input singleton. * */ - Input *_input; + godot::Input *_input; /** * @brief The animated sprite of the Player. * */ - AnimatedSprite *animated_sprite; + godot::AnimatedSprite *animated_sprite; public: /** diff --git a/src/state_machine/State.cpp b/src/state_machine/State.cpp index 2763449..1c66968 100644 --- a/src/state_machine/State.cpp +++ b/src/state_machine/State.cpp @@ -1,8 +1,6 @@ #include "state_machine/State.h" -using namespace godot; - -void State::_register_methods() +void alai::State::_register_methods() { register_method("set_parent", &State::set_parent); register_method("get_parent", &State::get_parent); @@ -11,44 +9,44 @@ void State::_register_methods() register_method("_state_exit", &State::_state_exit); } -State::State() +alai::State::State() { } -State::~State() +alai::State::~State() { } -void State::_init() +void alai::State::_init() { } -void State::_state_enter(const String state, const Array args) +void alai::State::_state_enter(const godot::String state, const godot::Array args) { WARN_PRINT("State " + get_state_machine()->get_current_state() + " is missing its _state_enter method!"); } -void State::_state_exit(const String state, const Array args) +void alai::State::_state_exit(const godot::String state, const godot::Array args) { WARN_PRINT("State " + get_state_machine()->get_current_state() + " is missing its _state_exit method!"); } -void State::set_parent(Node *parent) +void alai::State::set_parent(Node *parent) { this->parent = parent; } -Node *State::get_parent() +godot::Node *alai::State::get_parent() { return parent; } -void State::set_state_machine(StateMachine *state_machine) +void alai::State::set_state_machine(alai::StateMachine *state_machine) { this->state_machine = state_machine; } -StateMachine *State::get_state_machine() +alai::StateMachine *alai::State::get_state_machine() { return this->state_machine; } diff --git a/src/state_machine/State.h b/src/state_machine/State.h index 2576f6a..f8f04b4 100644 --- a/src/state_machine/State.h +++ b/src/state_machine/State.h @@ -1,12 +1,11 @@ -#ifndef JUEGO_STATE_H -#define JUEGO_STATE_H +#ifndef ALAI_STATE_MACHINE_STATE_H +#define ALAI_STATE_MACHINE_STATE_H #include "state_machine/StateMachine.h" #include -#include -namespace godot +namespace alai { /** * @brief This class provides a virtual template state that real states should extend from and override. @@ -21,7 +20,7 @@ namespace godot * @brief The state's parent, this is the node 1 level above the state machine. * */ - Node *parent; + godot::Node *parent; /** * @brief The state machine itself, used to handle all state related work. * @@ -61,7 +60,7 @@ namespace godot * @param[in] state This will contain the previous state. * @param[in] args The arguments passed to the state. */ - virtual void _state_enter(const String state, const Array args = Array()); + virtual void _state_enter(const godot::String state, const godot::Array args = godot::Array()); /** * @brief This is called when a state is exited. @@ -69,14 +68,14 @@ namespace godot * @param[in] state The state we are going to. * @param[in] args The arguments passed to the state. */ - virtual void _state_exit(const String state, const Array args = Array()); + virtual void _state_exit(const godot::String state, const godot::Array args = godot::Array()); /** * @brief Set the parent object. * * @param[in] parent The parent of the state. */ - virtual void set_parent(Node *parent) final; + virtual void set_parent(godot::Node *parent) final; /** * @brief Get the parent object. diff --git a/src/state_machine/StateMachine.cpp b/src/state_machine/StateMachine.cpp index 73b1f9d..ef6cb34 100644 --- a/src/state_machine/StateMachine.cpp +++ b/src/state_machine/StateMachine.cpp @@ -1,35 +1,33 @@ #include "state_machine/StateMachine.h" #include "state_machine/State.h" -using namespace godot; - -void StateMachine::_register_methods() +void alai::StateMachine::_register_methods() { - register_method("_ready", &StateMachine::_ready); - register_method("_on_StateMachine_tree_entered", &StateMachine::_on_StateMachine_tree_entered); - register_method("_on_StateMachine_tree_exiting", &StateMachine::_on_StateMachine_tree_exiting); - register_property("default_state", &StateMachine::set_default_state, &StateMachine::get_default_state, String()); - register_property("debug", &StateMachine::set_debug, &StateMachine::get_debug, false); - register_signal("state_entered", "state", GODOT_VARIANT_TYPE_STRING); - register_signal("state_exited", "state", GODOT_VARIANT_TYPE_STRING); - register_signal("state_restarted", "state", GODOT_VARIANT_TYPE_STRING); + godot::register_method("_ready", &StateMachine::_ready); + godot::register_method("_on_StateMachine_tree_entered", &StateMachine::_on_StateMachine_tree_entered); + godot::register_method("_on_StateMachine_tree_exiting", &StateMachine::_on_StateMachine_tree_exiting); + godot::register_property("default_state", &StateMachine::set_default_state, &StateMachine::get_default_state, godot::String()); + godot::register_property("debug", &StateMachine::set_debug, &StateMachine::get_debug, false); + godot::register_signal("state_entered", "state", GODOT_VARIANT_TYPE_STRING); + godot::register_signal("state_exited", "state", GODOT_VARIANT_TYPE_STRING); + godot::register_signal("state_restarted", "state", GODOT_VARIANT_TYPE_STRING); } -StateMachine::StateMachine() +alai::StateMachine::StateMachine() { } -StateMachine::~StateMachine() +alai::StateMachine::~StateMachine() { } -void StateMachine::_init() +void alai::StateMachine::_init() { - set_default_state(String()); + set_default_state(godot::String()); set_debug(false); } -void StateMachine::_ready() +void alai::StateMachine::_ready() { connect("tree_entered", this, "_on_StateMachine_tree_entered"); connect("tree_exiting", this, "_on_StateMachine_tree_exiting"); @@ -46,7 +44,7 @@ void StateMachine::_ready() setup(); } -void StateMachine::setup() +void alai::StateMachine::setup() { auto children = get_children(); @@ -89,7 +87,7 @@ void StateMachine::setup() } } -void StateMachine::add_states() +void alai::StateMachine::add_states() { auto children = get_children(); for (uint8_t i = 0; i < children.size(); i++) @@ -99,12 +97,12 @@ void StateMachine::add_states() } } -void StateMachine::add_state(const String state, Node *child) +void alai::StateMachine::add_state(const godot::String state, Node *child) { states[state] = child; } -bool StateMachine::is_current(const String state) +bool alai::StateMachine::is_current(const godot::String state) { if (get_current_state() == "") { @@ -116,19 +114,19 @@ bool StateMachine::is_current(const String state) } } -bool StateMachine::has(const String state) +bool alai::StateMachine::has(const godot::String state) { return states.has(state); } -void StateMachine::restart(const String state, const Array& args) +void alai::StateMachine::restart(const godot::String state, const godot::Array& args) { this->call("_state_exit", state, args); this->call("_state_enter", state, args); this->emit_signal("state_restarted", get_current_state()); } -void StateMachine::change(const String state, const Array &args) +void alai::StateMachine::change(const godot::String state, const godot::Array &args) { if (is_current(state)) { @@ -143,7 +141,7 @@ void StateMachine::change(const String state, const Array &args) auto previous_state = get_current_state(); - Variant exiting; + godot::Variant exiting; Node *state_node = Object::cast_to(this->states[previous_state]); if (state_node) { @@ -171,7 +169,7 @@ void StateMachine::change(const String state, const Array &args) this->emit_signal("state_exited", get_current_state()); if (debug) { - Godot::print(get_current_state() + " exited!"); + godot::Godot::print(get_current_state() + " exited!"); } } @@ -199,11 +197,11 @@ void StateMachine::change(const String state, const Array &args) this->emit_signal("state_entered", get_current_state()); if (debug) { - Godot::print(get_current_state() + " entered!"); + godot::Godot::print(get_current_state() + " entered!"); } } -Variant StateMachine::call(const String method, const Array &args) +godot::Variant alai::StateMachine::call(const godot::String method, const godot::Array &args) { auto node = Object::cast_to(states[get_current_state()].operator Object*()); if (node) @@ -215,57 +213,57 @@ Variant StateMachine::call(const String method, const Array &args) else { WARN_PRINT("The state " + get_current_state() + " doesn't contain the method " + method + "!"); - return Variant(); + return godot::Variant(); } } else { ERR_PRINT("Could not get current state node for " + get_current_state() + "!"); - return Variant(); + return godot::Variant(); } } -Variant StateMachine::_call(const String method, const Array &args) +godot::Variant alai::StateMachine::_call(const godot::String method, const godot::Array &args) { return this->call(method, args); } -void StateMachine::set_default_state(const String default_state) +void alai::StateMachine::set_default_state(const godot::String default_state) { this->default_state = default_state; } -String StateMachine::get_default_state() +godot::String alai::StateMachine::get_default_state() { return this->default_state; } -void StateMachine::set_current_state(const String current_sate) +void alai::StateMachine::set_current_state(const godot::String current_sate) { this->current_state = current_sate; } -String StateMachine::get_current_state() +godot::String alai::StateMachine::get_current_state() { return this->current_state; } -void StateMachine::set_debug(bool debug) +void alai::StateMachine::set_debug(bool debug) { this->debug = debug; } -bool StateMachine::get_debug() +bool alai::StateMachine::get_debug() { return this->debug; } -void StateMachine::_on_StateMachine_tree_entered() +void alai::StateMachine::_on_StateMachine_tree_entered() { setup(); } -void StateMachine::_on_StateMachine_tree_exiting() +void alai::StateMachine::_on_StateMachine_tree_exiting() { auto keys = states.keys(); for (uint8_t i = 0; i < keys.size(); i++) diff --git a/src/state_machine/StateMachine.h b/src/state_machine/StateMachine.h index 8c42f55..36e3e4f 100644 --- a/src/state_machine/StateMachine.h +++ b/src/state_machine/StateMachine.h @@ -1,32 +1,32 @@ -#ifndef JUEGO_STATE_MACHINE_H -#define JUEGO_STATE_MACHINE_H +#ifndef ALAI_STATE_MACHINE_STATE_MACHINE_H +#define ALAI_STATE_MACHINE_STATE_MACHINE_H #include #include -namespace godot +namespace alai { /** * @brief This class provides a finite state machine that can be used with any scene and node. * */ - class StateMachine : public Node + class StateMachine : public godot::Node { - GODOT_CLASS(StateMachine, Node) + GODOT_CLASS(StateMachine, godot::Node) private: /** * @brief The parent node which is one level above the state machine. * */ - Node *parent; + godot::Node *parent; /** * @brief The default state for the state machine to run. * * @details If this is not set, the state machine will try to run the first state node. * If no state nodes are present, an error will be printed and the state machine will not work. */ - String default_state; + godot::String default_state; /** * @brief If set to true the state machine will print a message showing when it enters or exits a state. * @@ -36,12 +36,12 @@ namespace godot * @brief The current state the machine is in. * */ - String current_state; + godot::String current_state; /** * @brief A list of the states in the state machine. * */ - Dictionary states; + godot::Dictionary states; /** * @brief This adds all nodes of the states machine as states in the machine. @@ -55,14 +55,14 @@ namespace godot * @param[in] state The new state. * @param[in] child The godot node which represents the state. */ - void add_state(const String state, Node *child); + void add_state(const godot::String state, godot::Node *child); /** * @brief Set the current state object. * * @param[in] current_state The current state that is running. */ - void set_current_state(const String current_state); + void set_current_state(const godot::String current_state); public: /** @@ -109,7 +109,7 @@ namespace godot * @return true If the running state and given state are the same. * @return false If the running state and given state are not the same. */ - bool is_current(const String state); + bool is_current(const godot::String state); /** * @brief Check if the state machine has a given state. @@ -118,7 +118,7 @@ namespace godot * @return true If the state exists. * @return false If the state doesn't exist. */ - bool has(const String state); + bool has(const godot::String state); /** * @brief Restar the running state by calling its enter and exit methods. @@ -126,7 +126,7 @@ namespace godot * @param[in] state The state that is being restarted. * @param[in] args The arguments to pass to the state on exit and enter. */ - void restart(const String state, const Array& args = Array()); + void restart(const godot::String state, const godot::Array& args = godot::Array()); /** * @brief Change to a different state. @@ -136,7 +136,7 @@ namespace godot * @param[in] state The state to change to. * @param[in] args The arguments to pass to the exiting state and the entering state. */ - void change(const String state, const Array &args = Array()); + void change(const godot::String state, const godot::Array &args = godot::Array()); /** * @brief Call a registered godot method in the class. @@ -145,7 +145,7 @@ namespace godot * @param[in] args The arguments to pass to the method. * @return Variant Returns a Variant based off what the method returns. */ - Variant call(const String method, const Array &args = Array()); + godot::Variant call(const godot::String method, const godot::Array &args = godot::Array()); /** * @brief This method is to link up a signal call back. @@ -154,28 +154,28 @@ namespace godot * @param[in] args The arguments to pass to the method. * @return Variant Returns a Variant based off what the method returns. */ - Variant _call(const String method, const Array &args = Array()); + godot::Variant _call(const godot::String method, const godot::Array &args = godot::Array()); /** * @brief Set the default state object. * * @param[in] default_state The new default state. */ - void set_default_state(const String default_state); + void set_default_state(const godot::String default_state); /** * @brief Get the default state object. * * @return String The default state. */ - String get_default_state(); + godot::String get_default_state(); /** * @brief Get the current state object. * * @return String The current running state. */ - String get_current_state(); + godot::String get_current_state(); /** * @brief Set the debug object. @@ -210,51 +210,51 @@ namespace godot /** * @brief Restarts the running state. * - * @tparam Args Variable number of arguments to pass to restart. + * @param Args Variable number of arguments to pass to restart. * @param[in] state The state being restarted. * @param[in] args The arguments to pass when restarting. */ - template void restart(const String state, Args ...args) + template void restart(const godot::String state, Args ...args) { - return restart(state, Array::make(args...)); + return restart(state, godot::Array::make(args...)); } /** * @brief Changes to a new state. * - * @tparam Args Variable number of arguments to pass when chaning states. + * @param Args Variable number of arguments to pass when changing states. * @param[in] state The state to change to. * @param[in] args The arguments to pass to the new state. */ - template void change(const String state, Args ...args) + template void change(const godot::String state, Args ...args) { - return change(state, Array::make(args...)); + return change(state, godot::Array::make(args...)); } /** * @brief Call a registered godot method in the class. * - * @tparam Args The variable arguments to pass to the method. + * @param Args The variable arguments to pass to the method. * @param[in] method The method to call. * @param[in] args The arguments to pass to it. * @return Variant The Variant object returned by the method called. */ - template Variant call(const String method, Args ...args) + template godot::Variant call(const godot::String method, Args ...args) { - return call(method, Array::make(args...)); + return call(method, godot::Array::make(args...)); } /** * @brief This is used to connect a callback from a signal. * - * @tparam Args The arguments to pass to the callback method. + * @param Args The arguments to pass to the callback method. * @param[in] method The method to call. * @param[in] args The arguments to pass. * @return Variant The Variant object returned by the method called. */ - template Variant _call(const String method, Args ...args) + template godot::Variant _call(const godot::String method, Args ...args) { - return _call(method, Array::make(args...)); + return _call(method, godot::Array::make(args...)); } }; }